316 files changed, 26081 insertions, 15887 deletions

diff --git a/sys/amd64/amd64/exception.S b/sys/amd64/amd64/exception.S
index 3d6401e3cd04..bbc304a48d61 100644
--- a/sys/amd64/amd64/exception.S
+++ b/sys/amd64/amd64/exception.S
@@ -668,7 +668,8 @@ ld_fs:	movw	%ax,%fs
 	movl	$MSR_FSBASE,%ecx
 	movl	PCB_FSBASE(%r8),%eax
 	movl	PCB_FSBASE+4(%r8),%edx
-	wrmsr
+	.globl	ld_fsbase
+ld_fsbase: wrmsr
 1:
 	/* Restore %gs and gsbase */
 	movw	TF_GS(%rsp),%si
@@ -685,7 +686,8 @@ ld_gs:	movw	%si,%gs
 	movl	$MSR_KGSBASE,%ecx
 	movl	PCB_GSBASE(%r8),%eax
 	movl	PCB_GSBASE+4(%r8),%edx
-	wrmsr
+	.globl	ld_gsbase
+ld_gsbase: wrmsr
 1:	.globl	ld_es
 ld_es:	movw	TF_ES(%rsp),%es
 	.globl	ld_ds
@@ -798,6 +800,30 @@ gs_load_fault:
 	call	trap
 	movw	$KUG32SEL,TF_GS(%rsp)
 	jmp	doreti
+
+	ALIGN_TEXT
+	.globl	fsbase_load_fault
+fsbase_load_fault:
+	movl	$T_PROTFLT,TF_TRAPNO(%rsp)
+	movq	%rsp, %rdi
+	call	trap
+	movq	PCPU(CURTHREAD),%r8
+	movq	TD_PCB(%r8),%r8
+	movq	$0,PCB_FSBASE(%r8)
+	jmp	doreti
+
+	ALIGN_TEXT
+	.globl	gsbase_load_fault
+gsbase_load_fault:
+	popfq
+	movl	$T_PROTFLT,TF_TRAPNO(%rsp)
+	movq	%rsp, %rdi
+	call	trap
+	movq	PCPU(CURTHREAD),%r8
+	movq	TD_PCB(%r8),%r8
+	movq	$0,PCB_GSBASE(%r8)
+	jmp	doreti
+
 #ifdef HWPMC_HOOKS
 	ENTRY(end_exceptions)
 #endif
diff --git a/sys/amd64/amd64/machdep.c b/sys/amd64/amd64/machdep.c
index 1155eaa83701..b65b67907656 100644
--- a/sys/amd64/amd64/machdep.c
+++ b/sys/amd64/amd64/machdep.c
@@ -424,13 +424,14 @@ sigreturn(td, uap)
 
 	error = copyin(uap->sigcntxp, &uc, sizeof(uc));
 	if (error != 0) {
-		printf("sigreturn (pid %d): copyin failed\n", p->p_pid);
+		uprintf("pid %d (%s): sigreturn copyin failed\n",
+		    p->p_pid, td->td_name);
 		return (error);
 	}
 	ucp = &uc;
 	if ((ucp->uc_mcontext.mc_flags & ~_MC_FLAG_MASK) != 0) {
-		printf("sigreturn (pid %d): mc_flags %x\n", p->p_pid,
-		    ucp->uc_mcontext.mc_flags);
+		uprintf("pid %d (%s): sigreturn mc_flags %x\n", p->p_pid,
+		    td->td_name, ucp->uc_mcontext.mc_flags);
 		return (EINVAL);
 	}
 	regs = td->td_frame;
@@ -449,8 +450,8 @@ sigreturn(td, uap)
 	 * one less debugger trap, so allowing it is fairly harmless.
 	 */
 	if (!EFL_SECURE(rflags & ~PSL_RF, regs->tf_rflags & ~PSL_RF)) {
-		printf("sigreturn (pid %d): rflags = 0x%lx\n", p->p_pid,
-		    rflags);
+		uprintf("pid %d (%s): sigreturn rflags = 0x%lx\n", p->p_pid,
+		    td->td_name, rflags);
 		return (EINVAL);
 	}
 
@@ -461,7 +462,8 @@ sigreturn(td, uap)
 	 */
 	cs = ucp->uc_mcontext.mc_cs;
 	if (!CS_SECURE(cs)) {
-		printf("sigreturn (pid %d): cs = 0x%x\n", p->p_pid, cs);
+		uprintf("pid %d (%s): sigreturn cs = 0x%x\n", p->p_pid,
+		    td->td_name, cs);
 		ksiginfo_init_trap(&ksi);
 		ksi.ksi_signo = SIGBUS;
 		ksi.ksi_code = BUS_OBJERR;
@@ -473,7 +475,8 @@ sigreturn(td, uap)
 
 	ret = set_fpcontext(td, &ucp->uc_mcontext);
 	if (ret != 0) {
-		printf("sigreturn (pid %d): set_fpcontext\n", p->p_pid);
+		uprintf("pid %d (%s): sigreturn set_fpcontext err %d\n",
+		    p->p_pid, td->td_name, ret);
 		return (ret);
 	}
 	bcopy(&ucp->uc_mcontext.mc_rdi, regs, sizeof(*regs));
diff --git a/sys/amd64/amd64/trap.c b/sys/amd64/amd64/trap.c
index bd7ee6358969..8acde03560cb 100644
--- a/sys/amd64/amd64/trap.c
+++ b/sys/amd64/amd64/trap.c
@@ -303,7 +303,7 @@ trap(struct trapframe *frame)
 		 * enabled later.
 		 */
 		if (ISPL(frame->tf_cs) == SEL_UPL)
-			printf(
+			uprintf(
 			    "pid %ld (%s): trap %d with interrupts disabled\n",
 			    (long)curproc->p_pid, curthread->td_name, type);
 		else if (type != T_NMI && type != T_BPTFLT &&
@@ -566,6 +566,14 @@ trap(struct trapframe *frame)
 				frame->tf_gs = _ugssel;
 				goto out;
 			}
+			if (frame->tf_rip == (long)ld_gsbase) {
+				frame->tf_rip = (long)gsbase_load_fault;
+				goto out;
+			}
+			if (frame->tf_rip == (long)ld_fsbase) {
+				frame->tf_rip = (long)fsbase_load_fault;
+				goto out;
+			}
 			if (PCPU_GET(curpcb)->pcb_onfault != NULL) {
 				frame->tf_rip =
 				    (long)PCPU_GET(curpcb)->pcb_onfault;
diff --git a/sys/amd64/ia32/ia32_signal.c b/sys/amd64/ia32/ia32_signal.c
index a4293c89a3b1..8033443ffad2 100644
--- a/sys/amd64/ia32/ia32_signal.c
+++ b/sys/amd64/ia32/ia32_signal.c
@@ -565,7 +565,8 @@ freebsd4_freebsd32_sigreturn(td, uap)
 	 * one less debugger trap, so allowing it is fairly harmless.
 	 */
 	if (!EFL_SECURE(eflags & ~PSL_RF, regs->tf_rflags & ~PSL_RF)) {
-		printf("freebsd4_freebsd32_sigreturn: eflags = 0x%x\n", eflags);
+		uprintf("pid %d (%s): freebsd4_freebsd32_sigreturn eflags = 0x%x\n",
+		    td->td_proc->p_pid, td->td_name, eflags);
 		return (EINVAL);
 	}
 
@@ -576,7 +577,8 @@ freebsd4_freebsd32_sigreturn(td, uap)
 	 */
 	cs = ucp->uc_mcontext.mc_cs;
 	if (!CS_SECURE(cs)) {
-		printf("freebsd4_sigreturn: cs = 0x%x\n", cs);
+		uprintf("pid %d (%s): freebsd4_sigreturn cs = 0x%x\n",
+		    td->td_proc->p_pid, td->td_name, cs);
 		ksiginfo_init_trap(&ksi);
 		ksi.ksi_signo = SIGBUS;
 		ksi.ksi_code = BUS_OBJERR;
@@ -647,7 +649,8 @@ freebsd32_sigreturn(td, uap)
 	 * one less debugger trap, so allowing it is fairly harmless.
 	 */
 	if (!EFL_SECURE(eflags & ~PSL_RF, regs->tf_rflags & ~PSL_RF)) {
-		printf("freebsd32_sigreturn: eflags = 0x%x\n", eflags);
+		uprintf("pid %d (%s): freebsd32_sigreturn eflags = 0x%x\n",
+		    td->td_proc->p_pid, td->td_name, eflags);
 		return (EINVAL);
 	}
 
@@ -658,7 +661,8 @@ freebsd32_sigreturn(td, uap)
 	 */
 	cs = ucp->uc_mcontext.mc_cs;
 	if (!CS_SECURE(cs)) {
-		printf("sigreturn: cs = 0x%x\n", cs);
+		uprintf("pid %d (%s): sigreturn cs = 0x%x\n",
+		    td->td_proc->p_pid, td->td_name, cs);
 		ksiginfo_init_trap(&ksi);
 		ksi.ksi_signo = SIGBUS;
 		ksi.ksi_code = BUS_OBJERR;
diff --git a/sys/amd64/include/md_var.h b/sys/amd64/include/md_var.h
index 2b43b37cc184..88f3e1dbaed8 100644
--- a/sys/amd64/include/md_var.h
+++ b/sys/amd64/include/md_var.h
@@ -83,10 +83,14 @@ void	ld_ds(void) __asm(__STRING(ld_ds));
 void	ld_es(void) __asm(__STRING(ld_es));
 void	ld_fs(void) __asm(__STRING(ld_fs));
 void	ld_gs(void) __asm(__STRING(ld_gs));
+void	ld_fsbase(void) __asm(__STRING(ld_fsbase));
+void	ld_gsbase(void) __asm(__STRING(ld_gsbase));
 void	ds_load_fault(void) __asm(__STRING(ds_load_fault));
 void	es_load_fault(void) __asm(__STRING(es_load_fault));
 void	fs_load_fault(void) __asm(__STRING(fs_load_fault));
 void	gs_load_fault(void) __asm(__STRING(gs_load_fault));
+void	fsbase_load_fault(void) __asm(__STRING(fsbase_load_fault));
+void	gsbase_load_fault(void) __asm(__STRING(gsbase_load_fault));
 void	dump_add_page(vm_paddr_t);
 void	dump_drop_page(vm_paddr_t);
 void	initializecpu(void);
diff --git a/sys/amd64/include/pmc_mdep.h b/sys/amd64/include/pmc_mdep.h
index f233a510d3cc..4f164852d3c0 100644
--- a/sys/amd64/include/pmc_mdep.h
+++ b/sys/amd64/include/pmc_mdep.h
@@ -43,17 +43,20 @@ struct pmc_mdep;
 #include <dev/hwpmc/hwpmc_core.h>
 #include <dev/hwpmc/hwpmc_piv.h>
 #include <dev/hwpmc/hwpmc_tsc.h>
+#include <dev/hwpmc/hwpmc_uncore.h>
 
 /*
  * Intel processors implementing V2 and later of the Intel performance
  * measurement architecture have PMCs of the following classes: TSC,
- * IAF and IAP.
+ * IAF, IAP, UCF and UCP.
  */
 #define	PMC_MDEP_CLASS_INDEX_TSC	0
 #define	PMC_MDEP_CLASS_INDEX_K8		1
 #define	PMC_MDEP_CLASS_INDEX_P4		1
 #define	PMC_MDEP_CLASS_INDEX_IAP	1
 #define	PMC_MDEP_CLASS_INDEX_IAF	2
+#define	PMC_MDEP_CLASS_INDEX_UCP	3
+#define	PMC_MDEP_CLASS_INDEX_UCF	4
 
 /*
  * On the amd64 platform we support the following PMCs.
@@ -63,12 +66,16 @@ struct pmc_mdep;
  * PIV		Intel P4/HTT and P4/EMT64
  * IAP		Intel Core/Core2/Atom CPUs in 64 bits mode.
  * IAF		Intel fixed-function PMCs in Core2 and later CPUs.
+ * UCP		Intel Uncore programmable PMCs.
+ * UCF		Intel Uncore fixed-function PMCs.
  */
 
 union pmc_md_op_pmcallocate  {
 	struct pmc_md_amd_op_pmcallocate	pm_amd;
 	struct pmc_md_iaf_op_pmcallocate	pm_iaf;
 	struct pmc_md_iap_op_pmcallocate	pm_iap;
+	struct pmc_md_ucf_op_pmcallocate	pm_ucf;
+	struct pmc_md_ucp_op_pmcallocate	pm_ucp;
 	struct pmc_md_p4_op_pmcallocate		pm_p4;
 	uint64_t				__pad[4];
 };
@@ -83,6 +90,8 @@ union pmc_md_pmc {
 	struct pmc_md_amd_pmc	pm_amd;
 	struct pmc_md_iaf_pmc	pm_iaf;
 	struct pmc_md_iap_pmc	pm_iap;
+	struct pmc_md_ucf_pmc	pm_ucf;
+	struct pmc_md_ucp_pmc	pm_ucp;
 	struct pmc_md_p4_pmc	pm_p4;
 };
 
diff --git a/sys/arm/include/bus.h b/sys/arm/include/bus.h
index 4080c3371355..cabf1f7c588c 100644
--- a/sys/arm/include/bus.h
+++ b/sys/arm/include/bus.h
@@ -721,6 +721,8 @@ bs_c_8_proto(f);
 #define BUS_SPACE_MAXSIZE_32BIT	0xFFFFFFFF
 #define BUS_SPACE_MAXSIZE 	0xFFFFFFFF
 
+#define BUS_SPACE_UNRESTRICTED	(~0)
+
 #include <machine/bus_dma.h>
 
 #endif /* _MACHINE_BUS_H_ */
diff --git a/sys/boot/i386/efi/Makefile b/sys/boot/i386/efi/Makefile
new file mode 100644
index 000000000000..2d1104611f58
--- /dev/null
+++ b/sys/boot/i386/efi/Makefile
@@ -0,0 +1,69 @@
+# $FreeBSD$
+
+NO_MAN=
+WITHOUT_SSP=
+BUILDING_EFI=
+
+.include <bsd.own.mk>
+
+PROG=		loader.sym
+INTERNALPROG=
+
+# architecture-specific loader code
+SRCS=	main.c exec.c conf.c vers.c reloc.c start.S elf32_freebsd.c
+SRCS+=	i386_copy.c bootinfo.c autoload.c devicename.c efimd.c
+
+CFLAGS+=	-I${.CURDIR}/../../efi/include
+CFLAGS+=	-I${.CURDIR}/../../efi/include/i386
+
+.if ${MK_FORTH} != "no"
+BOOT_FORTH=	yes
+CFLAGS+=	-DBOOT_FORTH
+CFLAGS+=	-I${.CURDIR}/../../ficl
+CFLAGS+=	-I${.CURDIR}/../../ficl/i386
+LIBFICL=	${.OBJDIR}/../../ficl/libficl.a
+.endif
+
+# Include bcache code.
+HAVE_BCACHE=    yes
+
+# Always add MI sources 
+.PATH:		${.CURDIR}/../../common
+.include	"${.CURDIR}/../../common/Makefile.inc"
+CFLAGS+=	-I${.CURDIR}/../../common
+
+FILES=	loader.efi
+FILESMODE_loader.efi=	${BINMODE}
+
+LDSCRIPT=	${.CURDIR}/ldscript.${MACHINE_ARCH}
+LDFLAGS=	-Wl,-T${LDSCRIPT} -shared -symbolic
+
+${PROG}:	${LDSCRIPT}
+
+CLEANFILES=	vers.c loader.efi
+
+NEWVERSWHAT=	"EFI loader" ${MACHINE_ARCH}
+
+vers.c:	${.CURDIR}/../../common/newvers.sh ${.CURDIR}/version
+	sh ${.CURDIR}/../../common/newvers.sh ${.CURDIR}/version ${NEWVERSWHAT}
+
+OBJCOPY?=	objcopy
+OBJDUMP?=	objdump
+
+loader.efi: loader.sym
+	if [ `${OBJDUMP} -t ${.ALLSRC} | fgrep '*UND*' | wc -l` != 0 ]; then \
+		${OBJDUMP} -t ${.ALLSRC} | fgrep '*UND*'; \
+		exit 1; \
+	fi
+	${OBJCOPY} -j .data -j .dynamic -j .dynstr -j .dynsym -j .hash \
+	    -j .rel.dyn -j .reloc -j .sdata -j .text -j set_Xcommand_set \
+	    --target=efi-app-ia32 ${.ALLSRC} ${.TARGET}
+
+LIBEFI=		${.OBJDIR}/../../efi/libefi/libefi.a
+CFLAGS+=	-I${.CURDIR}/../libi386
+CFLAGS+=	-I${.CURDIR}/../btx/lib
+
+DPADD=		${LIBFICL} ${LIBEFI} ${LIBSTAND}
+LDADD=		${LIBFICL} ${LIBEFI} -lstand
+
+.include <bsd.prog.mk>
diff --git a/sys/boot/i386/efi/autoload.c b/sys/boot/i386/efi/autoload.c
new file mode 100644
index 000000000000..26370d67994d
--- /dev/null
+++ b/sys/boot/i386/efi/autoload.c
@@ -0,0 +1,35 @@
+/*-
+ * Copyright (c) 2010 Rui Paulo <rpaulo@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.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+int
+i386_autoload(void)
+{
+
+	return (0);
+}
diff --git a/sys/boot/i386/efi/bootinfo.c b/sys/boot/i386/efi/bootinfo.c
new file mode 100644
index 000000000000..b3a3fa9f647d
--- /dev/null
+++ b/sys/boot/i386/efi/bootinfo.c
@@ -0,0 +1,297 @@
+/*-
+ * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
+ * Copyright (c) 2006 Marcel Moolenaar
+ * 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 <stand.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/reboot.h>
+#include <sys/linker.h>
+
+#include <efi.h>
+#include <efilib.h>
+
+#include "bootstrap.h"
+#include "libi386.h"
+#include <machine/bootinfo.h>
+
+/*
+ * Return a 'boothowto' value corresponding to the kernel arguments in
+ * (kargs) and any relevant environment variables.
+ */
+static struct 
+{
+	const char	*ev;
+	int		mask;
+} howto_names[] = {
+	{ "boot_askname",	RB_ASKNAME},
+	{ "boot_cdrom",		RB_CDROM},
+	{ "boot_ddb",		RB_KDB},
+	{ "boot_dfltroot",	RB_DFLTROOT},
+	{ "boot_gdb",		RB_GDB},
+	{ "boot_multicons",	RB_MULTIPLE},
+	{ "boot_mute",		RB_MUTE},
+	{ "boot_pause",		RB_PAUSE},
+	{ "boot_serial",	RB_SERIAL},
+	{ "boot_single",	RB_SINGLE},
+	{ "boot_verbose",	RB_VERBOSE},
+	{ NULL,	0}
+};
+
+static const char howto_switches[] = "aCdrgDmphsv";
+static int howto_masks[] = {
+	RB_ASKNAME, RB_CDROM, RB_KDB, RB_DFLTROOT, RB_GDB, RB_MULTIPLE,
+	RB_MUTE, RB_PAUSE, RB_SERIAL, RB_SINGLE, RB_VERBOSE
+};
+
+int
+bi_getboothowto(char *kargs)
+{
+	const char *sw;
+	char *opts;
+	int howto, i;
+
+	howto = 0;
+
+	/* Get the boot options from the environment first. */
+	for (i = 0; howto_names[i].ev != NULL; i++) {
+		if (getenv(howto_names[i].ev) != NULL)
+			howto |= howto_names[i].mask;
+	}
+
+	/* Parse kargs */
+	if (kargs == NULL)
+		return (howto);
+
+	opts = strchr(kargs, '-');
+	while (opts != NULL) {
+		while (*(++opts) != '\0') {
+			sw = strchr(howto_switches, *opts);
+			if (sw == NULL)
+				break;
+			howto |= howto_masks[sw - howto_switches];
+		}
+		opts = strchr(opts, '-');
+	}
+
+	return (howto);
+}
+
+/*
+ * Copy the environment into the load area starting at (addr).
+ * Each variable is formatted as <name>=<value>, with a single nul
+ * separating each variable, and a double nul terminating the environment.
+ */
+vm_offset_t
+bi_copyenv(vm_offset_t start)
+{
+	struct env_var *ep;
+	vm_offset_t addr, last;
+	size_t len;
+
+	addr = last = start;
+
+	/* Traverse the environment. */
+	for (ep = environ; ep != NULL; ep = ep->ev_next) {
+		len = strlen(ep->ev_name);
+		if (i386_copyin(ep->ev_name, addr, len) != len)
+			break;
+		addr += len;
+		if (i386_copyin("=", addr, 1) != 1)
+			break;
+		addr++;
+		if (ep->ev_value != NULL) {
+			len = strlen(ep->ev_value);
+			if (i386_copyin(ep->ev_value, addr, len) != len)
+				break;
+			addr += len;
+		}
+		if (i386_copyin("", addr, 1) != 1)
+			break;
+		last = ++addr;
+	}
+
+	if (i386_copyin("", last++, 1) != 1)
+		last = start;
+	return(last);
+}
+
+/*
+ * Copy module-related data into the load area, where it can be
+ * used as a directory for loaded modules.
+ *
+ * Module data is presented in a self-describing format.  Each datum
+ * is preceded by a 32-bit identifier and a 32-bit size field.
+ *
+ * Currently, the following data are saved:
+ *
+ * MOD_NAME	(variable)		module name (string)
+ * MOD_TYPE	(variable)		module type (string)
+ * MOD_ARGS	(variable)		module parameters (string)
+ * MOD_ADDR	sizeof(vm_offset_t)	module load address
+ * MOD_SIZE	sizeof(size_t)		module size
+ * MOD_METADATA	(variable)		type-specific metadata
+ */
+#define COPY32(v, a) {				\
+    u_int32_t	x = (v);			\
+    i386_copyin(&x, a, sizeof(x));		\
+    a += sizeof(x);				\
+}
+
+#define MOD_STR(t, a, s) {			\
+    COPY32(t, a);				\
+    COPY32(strlen(s) + 1, a);			\
+    i386_copyin(s, a, strlen(s) + 1);		\
+    a += roundup(strlen(s) + 1, sizeof(u_int64_t));\
+}
+
+#define MOD_NAME(a, s)	MOD_STR(MODINFO_NAME, a, s)
+#define MOD_TYPE(a, s)	MOD_STR(MODINFO_TYPE, a, s)
+#define MOD_ARGS(a, s)	MOD_STR(MODINFO_ARGS, a, s)
+
+#define MOD_VAR(t, a, s) {			\
+    COPY32(t, a);				\
+    COPY32(sizeof(s), a);			\
+    i386_copyin(&s, a, sizeof(s));		\
+    a += roundup(sizeof(s), sizeof(u_int64_t));	\
+}
+
+#define MOD_ADDR(a, s)	MOD_VAR(MODINFO_ADDR, a, s)
+#define MOD_SIZE(a, s)	MOD_VAR(MODINFO_SIZE, a, s)
+
+#define MOD_METADATA(a, mm) {			\
+    COPY32(MODINFO_METADATA | mm->md_type, a);	\
+    COPY32(mm->md_size, a);			\
+    i386_copyin(mm->md_data, a, mm->md_size);	\
+    a += roundup(mm->md_size, sizeof(u_int64_t));\
+}
+
+#define MOD_END(a) {				\
+    COPY32(MODINFO_END, a);			\
+    COPY32(0, a);				\
+}
+
+vm_offset_t
+bi_copymodules(vm_offset_t addr)
+{
+	struct preloaded_file *fp;
+	struct file_metadata *md;
+
+	/* Start with the first module on the list, should be the kernel. */
+	for (fp = file_findfile(NULL, NULL); fp != NULL; fp = fp->f_next) {
+		/* The name field must come first. */
+		MOD_NAME(addr, fp->f_name);
+		MOD_TYPE(addr, fp->f_type);
+		if (fp->f_args)
+			MOD_ARGS(addr, fp->f_args);
+		MOD_ADDR(addr, fp->f_addr);
+		MOD_SIZE(addr, fp->f_size);
+		for (md = fp->f_metadata; md != NULL; md = md->md_next) {
+			if (!(md->md_type & MODINFOMD_NOCOPY))
+				MOD_METADATA(addr, md);
+		}
+	}
+	MOD_END(addr);
+	return(addr);
+}
+
+/*
+ * Load the information expected by the kernel.
+ *
+ * - The kernel environment is copied into kernel space.
+ * - Module metadata are formatted and placed in kernel space.
+ */
+int
+bi_load(struct preloaded_file *fp, uint64_t *bi_addr)
+{
+	struct bootinfo bi;
+	struct preloaded_file *xp;
+	struct file_metadata *md;
+	struct devdesc *rootdev;
+	char *rootdevname;
+	vm_offset_t addr, ssym, esym;
+
+	bzero(&bi, sizeof(struct bootinfo));
+	bi.bi_version = 1;
+//	bi.bi_boothowto = bi_getboothowto(fp->f_args);
+
+	/* 
+	 * Allow the environment variable 'rootdev' to override the supplied
+	 * device. This should perhaps go to MI code and/or have $rootdev
+	 * tested/set by MI code before launching the kernel.
+	 */
+	rootdevname = getenv("rootdev");
+	i386_getdev((void**)&rootdev, rootdevname, NULL);
+	if (rootdev != NULL) {
+		/* Try reading /etc/fstab to select the root device. */
+		getrootmount(i386_fmtdev(rootdev));
+		free(rootdev);
+	}
+
+	md = file_findmetadata(fp, MODINFOMD_SSYM);
+	ssym = (md != NULL) ? *((vm_offset_t *)&(md->md_data)) : 0;
+	md = file_findmetadata(fp, MODINFOMD_ESYM);
+	esym = (md != NULL) ? *((vm_offset_t *)&(md->md_data)) : 0;
+	if (ssym != 0 && esym != 0) {
+		bi.bi_symtab = ssym;
+		bi.bi_esymtab = esym;
+	}
+
+	/* Find the last module in the chain. */
+	addr = 0;
+	for (xp = file_findfile(NULL, NULL); xp != NULL; xp = xp->f_next) {
+		if (addr < (xp->f_addr + xp->f_size))
+			addr = xp->f_addr + xp->f_size;
+	}
+
+	addr = (addr + 15) & ~15;
+
+	/* Copy module list and metadata. */
+	bi.bi_modulep = addr;
+	addr = bi_copymodules(addr);
+	if (addr <= bi.bi_modulep) {
+		addr = bi.bi_modulep;
+		bi.bi_modulep = 0;
+	}
+
+	addr = (addr + 15) & ~15;
+
+	/* Copy our environment. */
+	bi.bi_envp = addr;
+	addr = bi_copyenv(addr);
+	if (addr <= bi.bi_envp) {
+		addr = bi.bi_envp;
+		bi.bi_envp = 0;
+	}
+
+	addr = (addr + PAGE_MASK) & ~PAGE_MASK;
+	bi.bi_kernend = addr;
+
+	return (ldr_bootinfo(&bi, bi_addr));
+}
diff --git a/sys/boot/i386/efi/conf.c b/sys/boot/i386/efi/conf.c
new file mode 100644
index 000000000000..13c2145059d0
--- /dev/null
+++ b/sys/boot/i386/efi/conf.c
@@ -0,0 +1,77 @@
+/*-
+ * Copyright (c) 2006 Marcel Moolenaar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <stand.h>
+#include <bootstrap.h>
+#include <efi.h>
+#include <efilib.h>
+
+struct devsw *devsw[] = {
+	&efipart_dev,
+	&efinet_dev,
+	NULL
+};
+
+struct fs_ops *file_system[] = {
+	&dosfs_fsops,
+	&ufs_fsops,
+	&cd9660_fsops,
+	&nfs_fsops,
+	&gzipfs_fsops,
+	NULL
+};
+
+struct netif_driver *netif_drivers[] = {
+	&efinetif,
+	NULL
+};
+
+#ifdef notyet
+extern struct file_format amd64_elf;
+extern struct file_format amd64_elf_obj;
+#endif
+extern struct file_format i386_elf;
+extern struct file_format i386_elf_obj;
+
+struct file_format *file_formats[] = {
+#ifdef notyet
+	&amd64_elf,
+	&amd64_elf_obj,
+#endif
+	&i386_elf,
+	&i386_elf_obj,
+	NULL
+};
+
+extern struct console efi_console;
+
+struct console *consoles[] = {
+	&efi_console,
+	NULL
+};
diff --git a/sys/boot/i386/efi/devicename.c b/sys/boot/i386/efi/devicename.c
new file mode 100644
index 000000000000..c3d90626b532
--- /dev/null
+++ b/sys/boot/i386/efi/devicename.c
@@ -0,0 +1,169 @@
+/*-
+ * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
+ * Copyright (c) 2006 Marcel Moolenaar
+ * 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 <stand.h>
+#include <string.h>
+#include <sys/disklabel.h>
+#include "bootstrap.h"
+
+#include <efi.h>
+#include <efilib.h>
+
+static int i386_parsedev(struct devdesc **, const char *, const char **);
+
+/* 
+ * Point (dev) at an allocated device specifier for the device matching the
+ * path in (devspec). If it contains an explicit device specification,
+ * use that.  If not, use the default device.
+ */
+int
+i386_getdev(void **vdev, const char *devspec, const char **path)
+{
+	struct devdesc **dev = (struct devdesc **)vdev;
+	int rv;
+
+	/*
+	 * If it looks like this is just a path and no device, then
+	 * use the current device instead.
+	 */
+	if (devspec == NULL || *devspec == '/' || !strchr(devspec, ':')) {
+		rv = i386_parsedev(dev, getenv("currdev"), NULL);
+		if (rv == 0 && path != NULL)
+			*path = devspec;
+		return (rv);
+	}
+
+	/* Parse the device name off the beginning of the devspec. */
+	return (i386_parsedev(dev, devspec, path));
+}
+
+/*
+ * Point (dev) at an allocated device specifier matching the string version
+ * at the beginning of (devspec).  Return a pointer to the remaining
+ * text in (path).
+ *
+ * In all cases, the beginning of (devspec) is compared to the names
+ * of known devices in the device switch, and then any following text
+ * is parsed according to the rules applied to the device type.
+ *
+ * For disk-type devices, the syntax is:
+ *
+ * fs<unit>:
+ */
+static int
+i386_parsedev(struct devdesc **dev, const char *devspec, const char **path)
+{
+	struct devdesc *idev;
+	struct devsw *dv;
+	char *cp;
+	const char *np;
+	int i, err;
+
+	/* minimum length check */
+	if (strlen(devspec) < 2)
+		return (EINVAL);
+
+	/* look for a device that matches */
+	for (i = 0; devsw[i] != NULL; i++) {
+		dv = devsw[i];
+		if (!strncmp(devspec, dv->dv_name, strlen(dv->dv_name)))
+			break;
+	}
+	if (devsw[i] == NULL)
+		return (ENOENT);
+
+	idev = malloc(sizeof(struct devdesc));
+	if (idev == NULL)
+		return (ENOMEM);
+
+	idev->d_dev = dv;
+	idev->d_type = dv->dv_type;
+	idev->d_unit = -1;
+
+	err = 0;
+	np = devspec + strlen(dv->dv_name);
+	if (*np != '\0' && *np != ':') {
+		idev->d_unit = strtol(np, &cp, 0);
+		if (cp == np) {
+			idev->d_unit = -1;
+			free(idev);
+			return (EUNIT);
+		}
+	}
+	if (*cp != '\0' && *cp != ':') {
+		free(idev);
+		return (EINVAL);
+	}
+
+	if (path != NULL)
+		*path = (*cp == 0) ? cp : cp + 1;
+	if (dev != NULL)
+		*dev = idev;
+	else
+		free(idev);
+	return (0);
+}
+
+char *
+i386_fmtdev(void *vdev)
+{
+	struct devdesc *dev = (struct devdesc *)vdev;
+	static char buf[32];	/* XXX device length constant? */
+
+	switch(dev->d_type) {
+	case DEVT_NONE:
+		strcpy(buf, "(no device)");
+		break;
+
+	default:
+		sprintf(buf, "%s%d:", dev->d_dev->dv_name, dev->d_unit);
+		break;
+	}
+
+	return(buf);
+}
+
+/*
+ * Set currdev to suit the value being supplied in (value)
+ */
+int
+i386_setcurrdev(struct env_var *ev, int flags, const void *value)
+{
+	struct devdesc *ncurr;
+	int rv;
+
+	rv = i386_parsedev(&ncurr, value, NULL);
+	if (rv != 0)
+		return(rv);
+
+	free(ncurr);
+	env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);
+	return (0);
+}
diff --git a/sys/boot/i386/efi/efimd.c b/sys/boot/i386/efi/efimd.c
new file mode 100644
index 000000000000..01905e664fdd
--- /dev/null
+++ b/sys/boot/i386/efi/efimd.c
@@ -0,0 +1,139 @@
+/*-
+ * Copyright (c) 2004, 2006 Marcel Moolenaar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <stand.h>
+
+#include <efi.h>
+#include <efilib.h>
+
+#include <libi386.h>
+#include <machine/bootinfo.h>
+
+#define EFI_INTEL_FPSWA		\
+    {0xc41b6531,0x97b9,0x11d3,{0x9a,0x29,0x00,0x90,0x27,0x3f,0xc1,0x4d}}
+
+static EFI_GUID fpswa_guid = EFI_INTEL_FPSWA;
+
+/* DIG64 Headless Console & Debug Port Table. */
+#define	HCDP_TABLE_GUID		\
+    {0xf951938d,0x620b,0x42ef,{0x82,0x79,0xa8,0x4b,0x79,0x61,0x78,0x98}}
+
+static EFI_GUID hcdp_guid = HCDP_TABLE_GUID;
+
+static UINTN mapkey;
+
+uint64_t
+ldr_alloc(vm_offset_t va)
+{
+
+	return (0);
+}
+
+int
+ldr_bootinfo(struct bootinfo *bi, uint64_t *bi_addr)
+{
+	VOID *fpswa;
+	EFI_MEMORY_DESCRIPTOR *mm;
+	EFI_PHYSICAL_ADDRESS addr;
+	EFI_HANDLE handle;
+	EFI_STATUS status;
+	size_t bisz;
+	UINTN mmsz, pages, sz;
+	UINT32 mmver;
+
+	bi->bi_systab = (uint64_t)ST;
+	bi->bi_hcdp = (uint64_t)efi_get_table(&hcdp_guid);
+
+	sz = sizeof(EFI_HANDLE);
+	status = BS->LocateHandle(ByProtocol, &fpswa_guid, 0, &sz, &handle);
+	if (status == 0)
+		status = BS->HandleProtocol(handle, &fpswa_guid, &fpswa);
+	bi->bi_fpswa = (status == 0) ? (uint64_t)fpswa : 0;
+
+	bisz = (sizeof(struct bootinfo) + 0x0f) & ~0x0f;
+
+	/*
+	 * Allocate enough pages to hold the bootinfo block and the memory
+	 * map EFI will return to us. The memory map has an unknown size,
+	 * so we have to determine that first. Note that the AllocatePages
+	 * call can itself modify the memory map, so we have to take that
+	 * into account as well. The changes to the memory map are caused
+	 * by splitting a range of free memory into two (AFAICT), so that
+	 * one is marked as being loader data.
+	 */
+	sz = 0;
+	BS->GetMemoryMap(&sz, NULL, &mapkey, &mmsz, &mmver);
+	sz += mmsz;
+	sz = (sz + 15) & ~15;
+	pages = EFI_SIZE_TO_PAGES(sz + bisz);
+	status = BS->AllocatePages(AllocateAnyPages, EfiLoaderData, pages,
+	    &addr);
+	if (EFI_ERROR(status)) {
+		printf("%s: AllocatePages() returned 0x%lx\n", __func__,
+		    (long)status);
+		return (ENOMEM);
+	}
+
+	/*
+	 * Read the memory map and stash it after bootinfo. Align the
+	 * memory map on a 16-byte boundary (the bootinfo block is page
+	 * aligned).
+	 */
+	*bi_addr = addr;
+	mm = (void *)(addr + bisz);
+	sz = (EFI_PAGE_SIZE * pages) - bisz;
+	status = BS->GetMemoryMap(&sz, mm, &mapkey, &mmsz, &mmver);
+	if (EFI_ERROR(status)) {
+		printf("%s: GetMemoryMap() returned 0x%lx\n", __func__,
+		    (long)status);
+		return (EINVAL);
+	}
+	bi->bi_memmap = (uint64_t)mm;
+	bi->bi_memmap_size = sz;
+	bi->bi_memdesc_size = mmsz;
+	bi->bi_memdesc_version = mmver;
+
+	bcopy(bi, (void *)(*bi_addr), sizeof(*bi));
+	return (0);
+}
+
+int
+ldr_enter(const char *kernel)
+{
+	EFI_STATUS status;
+
+	status = BS->ExitBootServices(IH, mapkey);
+	if (EFI_ERROR(status)) {
+		printf("%s: ExitBootServices() returned 0x%lx\n", __func__,
+		    (long)status);
+		return (EINVAL);
+	}
+
+	return (0);
+}
diff --git a/sys/boot/i386/efi/elf32_freebsd.c b/sys/boot/i386/efi/elf32_freebsd.c
new file mode 100644
index 000000000000..f193735a4f34
--- /dev/null
+++ b/sys/boot/i386/efi/elf32_freebsd.c
@@ -0,0 +1,87 @@
+/*-
+ * Copyright (c) 1998 Michael Smith <msmith@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>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/exec.h>
+#include <sys/linker.h>
+#include <string.h>
+#include <machine/bootinfo.h>
+#include <machine/elf.h>
+#include <stand.h>
+
+#include "bootstrap.h"
+#include "../libi386/libi386.h"
+#include "../btx/lib/btxv86.h"
+
+extern void __exec(caddr_t addr, ...);
+
+
+static int	elf32_exec(struct preloaded_file *amp);
+static int	elf32_obj_exec(struct preloaded_file *amp);
+
+struct file_format i386_elf = { elf32_loadfile, elf32_exec };
+struct file_format i386_elf_obj = { elf32_obj_loadfile, elf32_obj_exec };
+
+/*
+ * There is an ELF kernel and one or more ELF modules loaded.  
+ * We wish to start executing the kernel image, so make such 
+ * preparations as are required, and do so.
+ */
+static int
+elf32_exec(struct preloaded_file *fp)
+{
+    struct file_metadata	*md;
+    Elf_Ehdr 			*ehdr;
+    vm_offset_t			entry, bootinfop, modulep, kernend;
+    int				boothowto, err, bootdev;
+
+    if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL)
+	return(EFTYPE);
+    ehdr = (Elf_Ehdr *)&(md->md_data);
+
+    err = bi_load(fp->f_args, &boothowto, &bootdev, &bootinfop, &modulep, &kernend);
+    if (err != 0)
+	return(err);
+    entry = ehdr->e_entry & 0xffffff;
+
+    printf("Start @ 0x%lx ...\n", entry);
+
+    ldr_enter(fp->f_name);
+
+    dev_cleanup();
+    __exec((void *)entry, boothowto, bootdev, 0, 0, 0, bootinfop, modulep, kernend);
+
+    panic("exec returned");
+}
+
+static int
+elf32_obj_exec(struct preloaded_file *fp)
+{
+	return (EFTYPE);
+}
diff --git a/sys/boot/i386/efi/exec.c b/sys/boot/i386/efi/exec.c
new file mode 100644
index 000000000000..fefbf0bb7925
--- /dev/null
+++ b/sys/boot/i386/efi/exec.c
@@ -0,0 +1,59 @@
+/*-
+ * Copyright (c) 2010 Rui Paulo <rpaulo@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.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <stand.h>
+#include <machine/elf.h>
+#include "../btx/lib/btxv86.h"
+
+#include "../../common/bootstrap.h"
+
+uint32_t __base;
+struct __v86 __v86;
+
+void
+__v86int()
+{
+	printf("%s\n", __func__);
+	exit(1);
+}
+
+void
+__exec(caddr_t addr, ...)
+{
+	/* XXX this is wrong */
+	__asm __volatile("movl %cr0, %eax");
+	__asm __volatile("andl $0x7fffffff, %eax");
+	__asm __volatile("mov %eax, %cr0");
+	__asm __volatile("xorl %eax, %eax");
+	__asm __volatile("mov %eax, %cr3");
+	__asm __volatile("movl %cr0, %eax");
+	__asm __volatile("andl $0xfffffffe, %eax");
+	__asm __volatile("movl %eax, %cr0");
+	__asm __volatile("jmp %0" :: "r" (addr));
+}
diff --git a/sys/boot/i386/efi/i386_copy.c b/sys/boot/i386/efi/i386_copy.c
new file mode 100644
index 000000000000..43c26ce064cd
--- /dev/null
+++ b/sys/boot/i386/efi/i386_copy.c
@@ -0,0 +1,59 @@
+/*-
+ * Copyright (c) 1998 Michael Smith <msmith@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>
+__FBSDID("$FreeBSD$");
+
+/*
+ * MD primitives supporting placement of module data 
+ *
+ * XXX should check load address/size against memory top.
+ */
+#include <stand.h>
+
+#include "libi386.h"
+#include "btxv86.h"
+
+ssize_t
+i386_copyin(const void *src, vm_offset_t dest, const size_t len)
+{
+    bcopy(src, PTOV(dest), len);
+    return(len);
+}
+
+ssize_t
+i386_copyout(const vm_offset_t src, void *dest, const size_t len)
+{
+    bcopy(PTOV(src), dest, len);
+    return(len);
+}
+
+
+ssize_t
+i386_readin(const int fd, vm_offset_t dest, const size_t len)
+{
+    return (read(fd, PTOV(dest), len));
+}
diff --git a/sys/boot/i386/efi/ldscript.amd64 b/sys/boot/i386/efi/ldscript.amd64
new file mode 100644
index 000000000000..9c5a29b56dc3
--- /dev/null
+++ b/sys/boot/i386/efi/ldscript.amd64
@@ -0,0 +1,75 @@
+/* $FreeBSD$ */
+OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
+OUTPUT_ARCH(i386:x86-64)
+ENTRY(_start)
+SECTIONS
+{
+  /* Read-only sections, merged into text segment: */
+  . = 0;
+  ImageBase = .;
+  . = SIZEOF_HEADERS;
+  . = ALIGN(4096);
+  .eh_frame	: {
+    *(.eh_frame)
+   }
+  .text		: {
+    *(.text .stub .text.* .gnu.linkonce.t.*)
+    /* .gnu.warning sections are handled specially by elf32.em. */
+    *(.gnu.warning)
+    *(.plt)
+  } =0x00300000010070000002000001000400
+  . = ALIGN(4096);
+  .data		: {
+    *(.rodata .rodata.* .gnu.linkonce.r.*)
+    *(.rodata1)
+    *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
+    *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)
+    *(.opd)
+    *(.data .data.* .gnu.linkonce.d.*)
+    *(.data1)
+    *(.plabel)
+    *(.dynbss)
+    *(.bss .bss.* .gnu.linkonce.b.*)
+    *(COMMON)
+  }
+  . = ALIGN(4096);
+  set_Xcommand_set	: {
+    __start_set_Xcommand_set = .;
+    *(set_Xcommand_set)
+    __stop_set_Xcommand_set = .;
+  }
+  . = ALIGN(4096);
+  __gp = .;
+  .sdata	: {
+    *(.got.plt .got)
+    *(.sdata .sdata.* .gnu.linkonce.s.*)
+    *(dynsbss)
+    *(.sbss .sbss.* .gnu.linkonce.sb.*)
+    *(.scommon)
+  }
+  . = ALIGN(4096);
+  .dynamic	: { *(.dynamic) }
+  . = ALIGN(4096);
+  .rel.dyn	: {
+    *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*)
+    *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*)
+    *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*)
+    *(.rel.got)
+    *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*)
+    *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*)
+    *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*)
+    *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*)
+    *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*)
+    *(.rel.plt)
+    *(.relset_*)
+    *(.rel.dyn .rel.dyn.*)
+  }
+  . = ALIGN(4096);
+  .reloc	: { *(.reloc) }
+  . = ALIGN(4096);
+  .hash		: { *(.hash) }
+  . = ALIGN(4096);
+  .dynsym	: { *(.dynsym) }
+  . = ALIGN(4096);
+  .dynstr	: { *(.dynstr) }
+}
diff --git a/sys/boot/i386/efi/ldscript.i386 b/sys/boot/i386/efi/ldscript.i386
new file mode 100644
index 000000000000..fdfda0a05ce4
--- /dev/null
+++ b/sys/boot/i386/efi/ldscript.i386
@@ -0,0 +1,72 @@
+/* $FreeBSD$ */
+OUTPUT_FORMAT("elf32-i386-freebsd", "elf32-i386-freebsd", "elf32-i386-freebsd")
+OUTPUT_ARCH(i386)
+ENTRY(_start)
+SECTIONS
+{
+  /* Read-only sections, merged into text segment: */
+  . = 0;
+  ImageBase = .;
+  . = SIZEOF_HEADERS;
+  . = ALIGN(4096);
+  .text		: {
+    *(.text .stub .text.* .gnu.linkonce.t.*)
+    /* .gnu.warning sections are handled specially by elf32.em. */
+    *(.gnu.warning)
+    *(.plt)
+  } =0x00300000010070000002000001000400
+  . = ALIGN(4096);
+  .data		: {
+    *(.rodata .rodata.* .gnu.linkonce.r.*)
+    *(.rodata1)
+    *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
+    *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)
+    *(.opd)
+    *(.data .data.* .gnu.linkonce.d.*)
+    *(.data1)
+    *(.plabel)
+    *(.dynbss)
+    *(.bss .bss.* .gnu.linkonce.b.*)
+    *(COMMON)
+  }
+  . = ALIGN(4096);
+  set_Xcommand_set	: {
+    __start_set_Xcommand_set = .;
+    *(set_Xcommand_set)
+    __stop_set_Xcommand_set = .;
+  }
+  . = ALIGN(4096);
+  __gp = .;
+  .sdata	: {
+    *(.got.plt .got)
+    *(.sdata .sdata.* .gnu.linkonce.s.*)
+    *(dynsbss)
+    *(.sbss .sbss.* .gnu.linkonce.sb.*)
+    *(.scommon)
+  }
+  . = ALIGN(4096);
+  .dynamic	: { *(.dynamic) }
+  . = ALIGN(4096);
+  .rel.dyn	: {
+    *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*)
+    *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*)
+    *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*)
+    *(.rel.got)
+    *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*)
+    *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*)
+    *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*)
+    *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*)
+    *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*)
+    *(.rel.plt)
+    *(.relset_*)
+    *(.rel.dyn .rel.dyn.*)
+  }
+  . = ALIGN(4096);
+  .reloc	: { *(.reloc) }
+  . = ALIGN(4096);
+  .hash		: { *(.hash) }
+  . = ALIGN(4096);
+  .dynsym	: { *(.dynsym) }
+  . = ALIGN(4096);
+  .dynstr	: { *(.dynstr) }
+}
diff --git a/sys/boot/i386/efi/main.c b/sys/boot/i386/efi/main.c
new file mode 100644
index 000000000000..1ea5c24e76e5
--- /dev/null
+++ b/sys/boot/i386/efi/main.c
@@ -0,0 +1,371 @@
+/*-
+ * Copyright (c) 2008-2010 Rui Paulo
+ * Copyright (c) 2006 Marcel Moolenaar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <stand.h>
+#include <string.h>
+#include <setjmp.h>
+
+#include <efi.h>
+#include <efilib.h>
+
+#include <bootstrap.h>
+#include "../libi386/libi386.h"
+
+extern char bootprog_name[];
+extern char bootprog_rev[];
+extern char bootprog_date[];
+extern char bootprog_maker[];
+
+struct devdesc currdev;		/* our current device */
+struct arch_switch archsw;	/* MI/MD interface boundary */
+
+EFI_GUID acpi = ACPI_TABLE_GUID;
+EFI_GUID acpi20 = ACPI_20_TABLE_GUID;
+EFI_GUID devid = DEVICE_PATH_PROTOCOL;
+EFI_GUID imgid = LOADED_IMAGE_PROTOCOL;
+EFI_GUID mps = MPS_TABLE_GUID;
+EFI_GUID netid = EFI_SIMPLE_NETWORK_PROTOCOL;
+EFI_GUID smbios = SMBIOS_TABLE_GUID;
+
+EFI_STATUS
+main(int argc, CHAR16 *argv[])
+{
+	char vendor[128];
+	EFI_LOADED_IMAGE *img;
+	int i;
+
+	/* 
+	 * XXX Chicken-and-egg problem; we want to have console output
+	 * early, but some console attributes may depend on reading from
+	 * eg. the boot device, which we can't do yet.  We can use
+	 * printf() etc. once this is done.
+	 */
+	cons_probe();
+
+	/*
+	 * March through the device switch probing for things.
+	 */
+	for (i = 0; devsw[i] != NULL; i++)
+		if (devsw[i]->dv_init != NULL)
+			(devsw[i]->dv_init)();
+
+	/* Get our loaded image protocol interface structure. */
+	BS->HandleProtocol(IH, &imgid, (VOID**)&img);
+
+	printf("Image base: 0x%lx\n", (u_long)img->ImageBase);
+	printf("EFI version: %d.%02d\n", ST->Hdr.Revision >> 16,
+	    ST->Hdr.Revision & 0xffff);
+	printf("EFI Firmware: ");
+	/* printf doesn't understand EFI Unicode */
+	ST->ConOut->OutputString(ST->ConOut, ST->FirmwareVendor);
+	printf(" (rev %d.%02d)\n", ST->FirmwareRevision >> 16,
+	    ST->FirmwareRevision & 0xffff);
+
+	printf("\n");
+	printf("%s, Revision %s\n", bootprog_name, bootprog_rev);
+	printf("(%s, %s)\n", bootprog_maker, bootprog_date);
+
+	efi_handle_lookup(img->DeviceHandle, &currdev.d_dev, &currdev.d_unit);
+	currdev.d_type = currdev.d_dev->dv_type;
+
+	/*
+	 * Disable the watchdog timer. By default the boot manager sets
+	 * the timer to 5 minutes before invoking a boot option. If we
+	 * want to return to the boot manager, we have to disable the
+	 * watchdog timer and since we're an interactive program, we don't
+	 * want to wait until the user types "quit". The timer may have
+	 * fired by then. We don't care if this fails. It does not prevent
+	 * normal functioning in any way...
+	 */
+	BS->SetWatchdogTimer(0, 0, 0, NULL);
+
+	env_setenv("currdev", EV_VOLATILE, i386_fmtdev(&currdev),
+	    i386_setcurrdev, env_nounset);
+	env_setenv("loaddev", EV_VOLATILE, i386_fmtdev(&currdev), env_noset,
+	    env_nounset);
+
+	setenv("LINES", "24", 1);	/* optional */
+    
+	archsw.arch_autoload = i386_autoload;
+	archsw.arch_getdev = i386_getdev;
+	archsw.arch_copyin = i386_copyin;
+	archsw.arch_copyout = i386_copyout;
+	archsw.arch_readin = i386_readin;
+
+	interact();			/* doesn't return */
+
+	return (EFI_SUCCESS);		/* keep compiler happy */
+}
+
+COMMAND_SET(reboot, "reboot", "reboot the system", command_reboot);
+
+static int
+command_reboot(int argc, char *argv[])
+{
+	int i;
+
+	for (i = 0; devsw[i] != NULL; ++i)
+		if (devsw[i]->dv_cleanup != NULL)
+			(devsw[i]->dv_cleanup)();
+
+	RS->ResetSystem(EfiResetCold, EFI_SUCCESS, 23,
+	    (CHAR16 *)"Reboot from the loader");
+
+	/* NOTREACHED */
+	return (CMD_ERROR);
+}
+
+COMMAND_SET(quit, "quit", "exit the loader", command_quit);
+
+static int
+command_quit(int argc, char *argv[])
+{
+	exit(0);
+	return (CMD_OK);
+}
+
+COMMAND_SET(memmap, "memmap", "print memory map", command_memmap);
+
+static int
+command_memmap(int argc, char *argv[])
+{
+	UINTN sz;
+	EFI_MEMORY_DESCRIPTOR *map, *p;
+	UINTN key, dsz;
+	UINT32 dver;
+	EFI_STATUS status;
+	int i, ndesc;
+	static char *types[] = {
+	    "Reserved",
+	    "LoaderCode",
+	    "LoaderData",
+	    "BootServicesCode",
+	    "BootServicesData",
+	    "RuntimeServicesCode",
+	    "RuntimeServicesData",
+	    "ConventionalMemory",
+	    "UnusableMemory",
+	    "ACPIReclaimMemory",
+	    "ACPIMemoryNVS",
+	    "MemoryMappedIO",
+	    "MemoryMappedIOPortSpace",
+	    "PalCode"
+	};
+
+	sz = 0;
+	status = BS->GetMemoryMap(&sz, 0, &key, &dsz, &dver);
+	if (status != EFI_BUFFER_TOO_SMALL) {
+		printf("Can't determine memory map size\n");
+		return CMD_ERROR;
+	}
+	map = malloc(sz);
+	status = BS->GetMemoryMap(&sz, map, &key, &dsz, &dver);
+	if (EFI_ERROR(status)) {
+		printf("Can't read memory map\n");
+		return CMD_ERROR;
+	}
+
+	ndesc = sz / dsz;
+	printf("%23s %12s %12s %8s %4s\n",
+	       "Type", "Physical", "Virtual", "#Pages", "Attr");
+	       
+	for (i = 0, p = map; i < ndesc;
+	     i++, p = NextMemoryDescriptor(p, dsz)) {
+	    printf("%23s %012lx %012lx %08lx ",
+		   types[p->Type],
+		   p->PhysicalStart,
+		   p->VirtualStart,
+		   p->NumberOfPages);
+	    if (p->Attribute & EFI_MEMORY_UC)
+		printf("UC ");
+	    if (p->Attribute & EFI_MEMORY_WC)
+		printf("WC ");
+	    if (p->Attribute & EFI_MEMORY_WT)
+		printf("WT ");
+	    if (p->Attribute & EFI_MEMORY_WB)
+		printf("WB ");
+	    if (p->Attribute & EFI_MEMORY_UCE)
+		printf("UCE ");
+	    if (p->Attribute & EFI_MEMORY_WP)
+		printf("WP ");
+	    if (p->Attribute & EFI_MEMORY_RP)
+		printf("RP ");
+	    if (p->Attribute & EFI_MEMORY_XP)
+		printf("XP ");
+	    printf("\n");
+	}
+
+	return CMD_OK;
+}
+
+COMMAND_SET(configuration, "configuration",
+	    "print configuration tables", command_configuration);
+
+static const char *
+guid_to_string(EFI_GUID *guid)
+{
+	static char buf[40];
+
+	sprintf(buf, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+	    guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
+	    guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
+	    guid->Data4[5], guid->Data4[6], guid->Data4[7]);
+	return (buf);
+}
+
+static int
+command_configuration(int argc, char *argv[])
+{
+	int i;
+
+	printf("NumberOfTableEntries=%ld\n", ST->NumberOfTableEntries);
+	for (i = 0; i < ST->NumberOfTableEntries; i++) {
+		EFI_GUID *guid;
+
+		printf("  ");
+		guid = &ST->ConfigurationTable[i].VendorGuid;
+		if (!memcmp(guid, &mps, sizeof(EFI_GUID)))
+			printf("MPS Table");
+		else if (!memcmp(guid, &acpi, sizeof(EFI_GUID)))
+			printf("ACPI Table");
+		else if (!memcmp(guid, &acpi20, sizeof(EFI_GUID)))
+			printf("ACPI 2.0 Table");
+		else if (!memcmp(guid, &smbios, sizeof(EFI_GUID)))
+			printf("SMBIOS Table");
+		else
+			printf("Unknown Table (%s)", guid_to_string(guid));
+		printf(" at %p\n", ST->ConfigurationTable[i].VendorTable);
+	}
+
+	return CMD_OK;
+}    
+
+
+COMMAND_SET(mode, "mode", "change or display text modes", command_mode);
+
+static int
+command_mode(int argc, char *argv[])
+{
+	unsigned int cols, rows, mode;
+	int i;
+	char *cp;
+	char rowenv[8];
+	EFI_STATUS status;
+	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
+
+	conout = ST->ConOut;
+
+	if (argc > 1) {
+		mode = strtol(argv[1], &cp, 0);
+		if (cp[0] != '\0') {
+			printf("Invalid mode\n");
+			return (CMD_ERROR);
+		}
+		status = conout->QueryMode(conout, mode, &cols, &rows);
+		if (EFI_ERROR(status)) {
+			printf("invalid mode %d\n", mode);
+			return (CMD_ERROR);
+		}
+		status = conout->SetMode(conout, mode);
+		if (EFI_ERROR(status)) {
+			printf("couldn't set mode %d\n", mode);
+			return (CMD_ERROR);
+		}
+		sprintf(rowenv, "%d", rows);
+		setenv("LINES", rowenv, 1);
+
+		return (CMD_OK);
+	}
+
+	for (i = 0; ; i++) {
+		status = conout->QueryMode(conout, i, &cols, &rows);
+		if (EFI_ERROR(status))
+			break;
+		printf("Mode %d: %d columns, %d rows\n", i, cols, rows);
+	}
+
+	if (i != 0)
+		printf("Choose the mode with \"col <mode number>\"\n");	
+
+	return (CMD_OK);
+}
+
+
+COMMAND_SET(nvram, "nvram", "get or set NVRAM variables", command_nvram);
+
+static int
+command_nvram(int argc, char *argv[])
+{
+	CHAR16 var[128];
+	CHAR16 *data;
+	EFI_STATUS status;
+	EFI_GUID varguid = { 0,0,0,{0,0,0,0,0,0,0,0} };
+	unsigned int varsz;
+	unsigned int datasz;
+	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
+	int i;
+
+	conout = ST->ConOut;
+
+	/* Initiate the search */
+	status = RS->GetNextVariableName(&varsz, NULL, NULL);
+
+	for (; status != EFI_NOT_FOUND; ) {
+		status = RS->GetNextVariableName(&varsz, var,
+		    &varguid);
+		//if (EFI_ERROR(status))
+			//break;
+
+		conout->OutputString(conout, var);
+		printf("=");
+		datasz = 0;
+		status = RS->GetVariable(var, &varguid, NULL, &datasz,
+		    NULL);
+		/* XXX: check status */
+		data = malloc(datasz);
+		status = RS->GetVariable(var, &varguid, NULL, &datasz,
+		    data);
+		if (EFI_ERROR(status))
+			printf("<error retrieving variable>");
+		else {
+			for (i = 0; i < datasz; i++) {
+				if (isalnum(data[i]) || isspace(data[i]))
+					printf("%c", data[i]);
+				else
+					printf("\\x%02x", data[i]);
+			}
+		}
+		/* XXX */
+		pager_output("\n");
+		free(data);
+	}
+
+	return (CMD_OK);
+}
diff --git a/sys/boot/i386/efi/reloc.c b/sys/boot/i386/efi/reloc.c
new file mode 100644
index 000000000000..24eed0aaab4b
--- /dev/null
+++ b/sys/boot/i386/efi/reloc.c
@@ -0,0 +1,103 @@
+/*-
+ * Copyright (c) 2008-2010 Rui Paulo <rpaulo@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>
+__FBSDID("$FreeBSD$");
+
+#include <sys/types.h>
+#include <sys/elf32.h>
+#include <efi.h>
+
+/*
+ * XXX: we can't include sys/systm.h.
+ */
+#ifndef CTASSERT                /* Allow lint to override */
+#define CTASSERT(x)             _CTASSERT(x, __LINE__)
+#define _CTASSERT(x, y)         __CTASSERT(x, y)
+#define __CTASSERT(x, y)        typedef char __assert ## y[(x) ? 1 : -1]
+#endif
+
+
+/*
+ * A simple relocator for IA32 EFI binaries.
+ */
+EFI_STATUS
+_reloc(unsigned long ImageBase, Elf32_Dyn *dynamic, EFI_HANDLE image_handle,
+    EFI_SYSTEM_TABLE *system_table)
+{
+	unsigned long relsz, relent;
+	unsigned long *newaddr;
+	Elf32_Rel *rel;
+	Elf32_Dyn *dynp;
+
+	/*
+	 * Find the relocation address, its size and the relocation entry.
+	 */
+	relsz = 0;
+	relent = 0;
+	for (dynp = dynamic; dynp->d_tag != DT_NULL; dynp++) {
+		switch (dynp->d_tag) {
+		case DT_REL:
+			rel = (Elf32_Rel *) ((unsigned long) dynp->d_un.d_ptr +
+			    ImageBase);
+			break;
+		case DT_RELSZ:
+			relsz = dynp->d_un.d_val;
+			break;
+		case DT_RELENT:
+			relent = dynp->d_un.d_val;
+			break;
+		default:
+			break;
+		}
+	}
+
+	/*
+	 * Perform the actual relocation.
+	 * XXX: We are reusing code for the amd64 version of this, but
+	 * we must make sure the relocation types are the same.
+	 */
+	CTASSERT(R_386_NONE == R_X86_64_NONE);
+	CTASSERT(R_386_RELATIVE == R_X86_64_RELATIVE);
+	for (; relsz > 0; relsz -= relent) {
+		switch (ELF32_R_TYPE(rel->r_info)) {
+		case R_386_NONE:
+			/* No relocation needs be performed. */
+			break;
+		case R_386_RELATIVE:
+			/* Address relative to the base address. */
+			newaddr = (unsigned long *)(ImageBase + rel->r_offset);
+			*newaddr += ImageBase;
+			break;
+		default:
+			/* XXX: do we need other relocations ? */
+			return (EFI_LOAD_ERROR);
+		}
+		rel = (Elf32_Rel *) ((caddr_t) rel + relent);
+	}
+
+	return (EFI_SUCCESS);
+}
diff --git a/sys/boot/i386/efi/start.S b/sys/boot/i386/efi/start.S
new file mode 100644
index 000000000000..ea4597feaae2
--- /dev/null
+++ b/sys/boot/i386/efi/start.S
@@ -0,0 +1,70 @@
+/*-
+ * Copyright (c) 2008-2010 Rui Paulo <rpaulo@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$
+ */
+
+	.text
+
+#include <machine/asm.h>
+
+#define EFI_SUCCESS		0
+
+/*
+ * EFI entry point. 
+ * _start(EFI_IMAGE image_handle, EFI_SYSTEM_TABLE *system_table);
+ *
+ * We calculate the base address along with _DYNAMIC, relocate us and finally
+ * pass control to efi_main.
+ */
+
+ENTRY(_start)
+	pushl	%ebp
+	movl	%esp, %ebp
+
+	pushl	12(%ebp)	/* image_handle */
+	pushl	8(%ebp)		/* system_table */
+	call	0f
+0:	popl	%eax
+	movl	%eax, %ebx
+	addl	$ImageBase-0b, %eax
+	addl	$_DYNAMIC-0b, %ebx
+	pushl	%ebx		/* dynamic */
+	pushl	%eax		/* ImageBase */
+	call	_reloc
+	cmpl	$EFI_SUCCESS, %eax
+	jne	1f
+	popl	%ebx		/* remove ImageBase from the stack */
+	popl	%ebx		/* remove dynamic from the stack */
+	call	efi_main
+1:	leave
+	ret
+END(_start)
+
+	.data
+	.section .reloc, "a"
+	.long	0
+	.long	10
+	.word	0
diff --git a/sys/boot/i386/efi/version b/sys/boot/i386/efi/version
new file mode 100644
index 000000000000..3a4c47c5efb1
--- /dev/null
+++ b/sys/boot/i386/efi/version
@@ -0,0 +1,7 @@
+$FreeBSD$
+
+NOTE ANY CHANGES YOU MAKE TO THE BOOTBLOCKS HERE.  The format of this
+file is important.  Make sure the current version number is on line 6.
+
+1.1:	Keep in sync with i386 version.
+0.1:	Initial i386 version. Derived from ia64.
diff --git a/sys/cam/scsi/scsi_da.c b/sys/cam/scsi/scsi_da.c
index 77652b2dc949..377275a86e52 100644
--- a/sys/cam/scsi/scsi_da.c
+++ b/sys/cam/scsi/scsi_da.c
@@ -997,6 +997,11 @@ dacleanup(struct cam_periph *periph)
 		xpt_print(periph->path, "can't remove sysctl context\n");
 	}
 
+	/*
+	 * Nullify our periph pointer here to try and catch
+	 * race conditions in callbacks/downcalls.
+	 */
+	softc->disk->d_drv1 = NULL;
 	disk_destroy(softc->disk);
 	callout_drain(&softc->sendordered_c);
 	free(softc, M_DEVBUF);
diff --git a/sys/compat/ia32/ia32_signal.h b/sys/compat/ia32/ia32_signal.h
index 9daa8d52293f..717ae74a94bc 100644
--- a/sys/compat/ia32/ia32_signal.h
+++ b/sys/compat/ia32/ia32_signal.h
@@ -180,6 +180,7 @@ struct ia32_sigframe3 {
 #endif
 
 struct ksiginfo;
+struct image_params;
 extern char ia32_sigcode[];
 extern char freebsd4_ia32_sigcode[];
 extern int sz_ia32_sigcode;
diff --git a/sys/compat/linprocfs/linprocfs.c b/sys/compat/linprocfs/linprocfs.c
index c095012e0d96..e6a4f16564ac 100644
--- a/sys/compat/linprocfs/linprocfs.c
+++ b/sys/compat/linprocfs/linprocfs.c
@@ -110,12 +110,14 @@ __FBSDID("$FreeBSD$");
 /*
  * Various conversion macros
  */
-#define T2J(x) (((x) * 100UL) / (stathz ? stathz : hz))	/* ticks to jiffies */
+#define T2J(x) ((long)(((x) * 100ULL) / (stathz ? stathz : hz)))	/* ticks to jiffies */
+#define T2CS(x) ((unsigned long)(((x) * 100ULL) / (stathz ? stathz : hz)))	/* ticks to centiseconds */
 #define T2S(x) ((x) / (stathz ? stathz : hz))		/* ticks to seconds */
 #define B2K(x) ((x) >> 10)				/* bytes to kbytes */
 #define B2P(x) ((x) >> PAGE_SHIFT)			/* bytes to pages */
 #define P2B(x) ((x) << PAGE_SHIFT)			/* pages to bytes */
 #define P2K(x) ((x) << (PAGE_SHIFT - 10))		/* pages to kbytes */
+#define TV2J(x)	((x)->tv_sec * 100UL + (x)->tv_usec / 10000)
 
 /**
  * @brief Mapping of ki_stat in struct kinfo_proc to the linux state
@@ -505,9 +507,10 @@ linprocfs_douptime(PFS_FILL_ARGS)
 
 	getmicrouptime(&tv);
 	read_cpu_time(cp_time);
-	sbuf_printf(sb, "%lld.%02ld %ld.%02ld\n",
+	sbuf_printf(sb, "%lld.%02ld %ld.%02lu\n",
 	    (long long)tv.tv_sec, tv.tv_usec / 10000,
-	    T2S(cp_time[CP_IDLE]), T2J(cp_time[CP_IDLE]) % 100);
+	    T2S(cp_time[CP_IDLE] / mp_ncpus),
+	    T2CS(cp_time[CP_IDLE] / mp_ncpus) % 100);
 	return (0);
 }
 
@@ -613,9 +616,17 @@ linprocfs_doprocstat(PFS_FILL_ARGS)
 	struct kinfo_proc kp;
 	char state;
 	static int ratelimit = 0;
+	vm_offset_t startcode, startdata;
 
 	PROC_LOCK(p);
 	fill_kinfo_proc(p, &kp);
+	if (p->p_vmspace) {
+	   startcode = (vm_offset_t)p->p_vmspace->vm_taddr;
+	   startdata = (vm_offset_t)p->p_vmspace->vm_daddr;
+	} else {
+	   startcode = 0;
+	   startdata = 0;
+	};
 	sbuf_printf(sb, "%d", p->p_pid);
 #define PS_ADD(name, fmt, arg) sbuf_printf(sb, " " fmt, arg)
 	PS_ADD("comm",		"(%s)",	p->p_comm);
@@ -634,30 +645,27 @@ linprocfs_doprocstat(PFS_FILL_ARGS)
 	PS_ADD("pgrp",		"%d",	p->p_pgid);
 	PS_ADD("session",	"%d",	p->p_session->s_sid);
 	PROC_UNLOCK(p);
-	PS_ADD("tty",		"%d",	0); /* XXX */
+	PS_ADD("tty",		"%d",	kp.ki_tdev);
 	PS_ADD("tpgid",		"%d",	kp.ki_tpgid);
 	PS_ADD("flags",		"%u",	0); /* XXX */
 	PS_ADD("minflt",	"%lu",	kp.ki_rusage.ru_minflt);
 	PS_ADD("cminflt",	"%lu",	kp.ki_rusage_ch.ru_minflt);
 	PS_ADD("majflt",	"%lu",	kp.ki_rusage.ru_majflt);
 	PS_ADD("cmajflt",	"%lu",	kp.ki_rusage_ch.ru_majflt);
-	PS_ADD("utime",		"%ld",	T2J(tvtohz(&kp.ki_rusage.ru_utime)));
-	PS_ADD("stime",		"%ld",	T2J(tvtohz(&kp.ki_rusage.ru_stime)));
-	PS_ADD("cutime",	"%ld",	T2J(tvtohz(&kp.ki_rusage_ch.ru_utime)));
-	PS_ADD("cstime",	"%ld",	T2J(tvtohz(&kp.ki_rusage_ch.ru_stime)));
+	PS_ADD("utime",		"%ld",	TV2J(&kp.ki_rusage.ru_utime));
+	PS_ADD("stime",		"%ld",	TV2J(&kp.ki_rusage.ru_stime));
+	PS_ADD("cutime",	"%ld",	TV2J(&kp.ki_rusage_ch.ru_utime));
+	PS_ADD("cstime",	"%ld",	TV2J(&kp.ki_rusage_ch.ru_stime));
 	PS_ADD("priority",	"%d",	kp.ki_pri.pri_user);
 	PS_ADD("nice",		"%d",	kp.ki_nice); /* 19 (nicest) to -19 */
 	PS_ADD("0",		"%d",	0); /* removed field */
 	PS_ADD("itrealvalue",	"%d",	0); /* XXX */
-	/* XXX: starttime is not right, it is the _same_ for _every_ process.
-	   It should be the number of jiffies between system boot and process
-	   start. */
-	PS_ADD("starttime",	"%lu",	T2J(tvtohz(&kp.ki_start)));
+	PS_ADD("starttime",	"%lu",	TV2J(&kp.ki_start) - TV2J(&boottime));
 	PS_ADD("vsize",		"%ju",	P2K((uintmax_t)kp.ki_size));
 	PS_ADD("rss",		"%ju",	(uintmax_t)kp.ki_rssize);
 	PS_ADD("rlim",		"%lu",	kp.ki_rusage.ru_maxrss);
-	PS_ADD("startcode",	"%u",	(unsigned)0);
-	PS_ADD("endcode",	"%u",	0); /* XXX */
+	PS_ADD("startcode",	"%ju",	(uintmax_t)startcode);
+	PS_ADD("endcode",	"%ju",	(uintmax_t)startdata);
 	PS_ADD("startstack",	"%u",	0); /* XXX */
 	PS_ADD("kstkesp",	"%u",	0); /* XXX */
 	PS_ADD("kstkeip",	"%u",	0); /* XXX */
@@ -800,7 +808,7 @@ linprocfs_doprocstatus(PFS_FILL_ARGS)
 	 */
 	sbuf_printf(sb, "VmSize:\t%8ju kB\n",	B2K((uintmax_t)kp.ki_size));
 	sbuf_printf(sb, "VmLck:\t%8u kB\n",	P2K(0)); /* XXX */
-	sbuf_printf(sb, "VmRss:\t%8ju kB\n",	P2K((uintmax_t)kp.ki_rssize));
+	sbuf_printf(sb, "VmRSS:\t%8ju kB\n",	P2K((uintmax_t)kp.ki_rssize));
 	sbuf_printf(sb, "VmData:\t%8ju kB\n",	P2K((uintmax_t)kp.ki_dsize));
 	sbuf_printf(sb, "VmStk:\t%8ju kB\n",	P2K((uintmax_t)kp.ki_ssize));
 	sbuf_printf(sb, "VmExe:\t%8ju kB\n",	P2K((uintmax_t)kp.ki_tsize));
diff --git a/sys/conf/files b/sys/conf/files
index 845c83fade63..7dd1b0ed3cdc 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -1190,7 +1190,7 @@ iwn6000fw.fwo			optional iwn6000fw | iwnfw		\
 	clean		"iwn6000fw.fwo"
 iwn6000.fw			optional iwn6000fw | iwnfw		\
 	dependency	".PHONY"					\
-	compile-with	"uudecode -o ${.TARGET} $S/contrib/dev/iwn/iwlwifi-6000-9.176.4.1.fw.uu" \
+	compile-with	"uudecode -o ${.TARGET} $S/contrib/dev/iwn/iwlwifi-6000-9.193.4.1.fw.uu" \
 	no-obj no-implicit-rule						\
 	clean		"iwn6000.fw"
 dev/ixgb/if_ixgb.c		optional ixgb
@@ -2358,7 +2358,7 @@ net80211/ieee80211_action.c	optional wlan
 net80211/ieee80211_ageq.c	optional wlan
 net80211/ieee80211_adhoc.c	optional wlan
 net80211/ieee80211_ageq.c	optional wlan
-net80211/ieee80211_amrr.c	optional wlan wlan_amrr
+net80211/ieee80211_amrr.c	optional wlan | wlan_amrr
 net80211/ieee80211_crypto.c	optional wlan
 net80211/ieee80211_crypto_ccmp.c optional wlan wlan_ccmp
 net80211/ieee80211_crypto_none.c optional wlan
@@ -2380,6 +2380,7 @@ net80211/ieee80211_phy.c	optional wlan
 net80211/ieee80211_power.c	optional wlan
 net80211/ieee80211_proto.c	optional wlan
 net80211/ieee80211_radiotap.c	optional wlan
+net80211/ieee80211_ratectl.c	optional wlan
 net80211/ieee80211_regdomain.c	optional wlan
 net80211/ieee80211_rssadapt.c	optional wlan wlan_rssadapt
 net80211/ieee80211_scan.c	optional wlan
diff --git a/sys/conf/files.amd64 b/sys/conf/files.amd64
index 905d24637db6..ae5170a9bc91 100644
--- a/sys/conf/files.amd64
+++ b/sys/conf/files.amd64
@@ -198,6 +198,7 @@ dev/hptrr/hptrr_config.c	optional	hptrr
 dev/hwpmc/hwpmc_amd.c		optional	hwpmc
 dev/hwpmc/hwpmc_intel.c		optional	hwpmc
 dev/hwpmc/hwpmc_core.c		optional	hwpmc
+dev/hwpmc/hwpmc_uncore.c	optional	hwpmc
 dev/hwpmc/hwpmc_piv.c		optional	hwpmc
 dev/hwpmc/hwpmc_tsc.c		optional	hwpmc
 dev/hwpmc/hwpmc_x86.c		optional	hwpmc
diff --git a/sys/conf/files.i386 b/sys/conf/files.i386
index a61dca22312a..b0c68b584b38 100644
--- a/sys/conf/files.i386
+++ b/sys/conf/files.i386
@@ -179,6 +179,7 @@ dev/hptrr/hptrr_config.c	optional hptrr
 dev/hwpmc/hwpmc_amd.c		optional hwpmc
 dev/hwpmc/hwpmc_intel.c		optional hwpmc
 dev/hwpmc/hwpmc_core.c		optional hwpmc
+dev/hwpmc/hwpmc_uncore.c	optional hwpmc
 dev/hwpmc/hwpmc_pentium.c	optional hwpmc
 dev/hwpmc/hwpmc_piv.c		optional hwpmc
 dev/hwpmc/hwpmc_ppro.c		optional hwpmc
diff --git a/sys/conf/files.pc98 b/sys/conf/files.pc98
index 314b16ec4a20..b24faaeb4b39 100644
--- a/sys/conf/files.pc98
+++ b/sys/conf/files.pc98
@@ -99,6 +99,7 @@ dev/fe/if_fe_cbus.c		optional fe isa
 dev/hwpmc/hwpmc_amd.c		optional hwpmc
 dev/hwpmc/hwpmc_intel.c		optional hwpmc
 dev/hwpmc/hwpmc_core.c		optional hwpmc
+dev/hwpmc/hwpmc_uncore.c	optional hwpmc
 dev/hwpmc/hwpmc_pentium.c	optional hwpmc
 dev/hwpmc/hwpmc_piv.c		optional hwpmc
 dev/hwpmc/hwpmc_ppro.c		optional hwpmc
diff --git a/sys/conf/files.sparc64 b/sys/conf/files.sparc64
index 1f8c4a3e07eb..a822a0ed817a 100644
--- a/sys/conf/files.sparc64
+++ b/sys/conf/files.sparc64
@@ -79,6 +79,7 @@ sparc64/pci/ofw_pcib.c		optional	pci
 sparc64/pci/ofw_pcib_subr.c	optional	pci
 sparc64/pci/ofw_pcibus.c	optional	pci
 sparc64/pci/psycho.c		optional	pci
+sparc64/pci/sbbc.c		optional	uart sbbc
 sparc64/pci/schizo.c		optional	pci
 sparc64/sbus/dma_sbus.c		optional	sbus
 sparc64/sbus/sbus.c		optional	sbus
diff --git a/sys/conf/kern.mk b/sys/conf/kern.mk
index 0f5cd6605c65..7e23a80453f8 100644
--- a/sys/conf/kern.mk
+++ b/sys/conf/kern.mk
@@ -108,3 +108,11 @@ CFLAGS+=	-restrict
 	${MACHINE_ARCH} != "arm" && ${MACHINE_ARCH} != "mips"
 CFLAGS+=	-fstack-protector
 .endif
+
+#
+# Enable CTF conversation on request.
+#
+.if defined(WITH_CTF)
+.undef NO_CTF
+.endif
+
diff --git a/sys/conf/kern.post.mk b/sys/conf/kern.post.mk
index f808c953b0f8..c5c9c3412067 100644
--- a/sys/conf/kern.post.mk
+++ b/sys/conf/kern.post.mk
@@ -19,6 +19,10 @@ MKMODULESENV+=	KERNBUILDDIR="${.CURDIR}" SYSDIR="${SYSDIR}"
 MKMODULESENV+=	CONF_CFLAGS="${CONF_CFLAGS}"
 .endif
 
+.if defined(WITH_CTF)
+MKMODULESENV+=	WITH_CTF="${WITH_CTF}"
+.endif
+
 .MAIN: all
 
 .for target in all clean cleandepend cleandir clobber depend install \
@@ -90,9 +94,7 @@ ${FULLKERNEL}: ${SYSTEM_DEP} vers.o
 	@rm -f ${.TARGET}
 	@echo linking ${.TARGET}
 	${SYSTEM_LD}
-.if defined(CTFMERGE)
-	${SYSTEM_CTFMERGE}
-.endif
+	@${SYSTEM_CTFMERGE}
 .if !defined(DEBUG)
 	${OBJCOPY} --strip-debug ${.TARGET}
 .endif
@@ -240,9 +242,7 @@ kernel-reinstall:
 
 config.o env.o hints.o vers.o vnode_if.o:
 	${NORMAL_C}
-.if defined(CTFCONVERT)
-	${CTFCONVERT} ${CTFFLAGS} ${.TARGET}
-.endif
+	@[ -z "${CTFCONVERT}" -o -n "${NO_CTF}" ] || ${CTFCONVERT} ${CTFFLAGS} ${.TARGET}
 
 config.ln env.ln hints.ln vers.ln vnode_if.ln:
 	${NORMAL_LINT}
diff --git a/sys/conf/kern.pre.mk b/sys/conf/kern.pre.mk
index 57ed33fcf592..1852cb7885c2 100644
--- a/sys/conf/kern.pre.mk
+++ b/sys/conf/kern.pre.mk
@@ -128,11 +128,7 @@ NORMAL_C_NOWERROR= ${CC} -c ${CFLAGS} ${PROF} ${.IMPSRC}
 NORMAL_M= ${AWK} -f $S/tools/makeobjops.awk ${.IMPSRC} -c ; \
 	  ${CC} -c ${CFLAGS} ${WERROR} ${PROF} ${.PREFIX}.c
 
-.if defined(CTFCONVERT)
-NORMAL_CTFCONVERT= ${CTFCONVERT} ${CTFFLAGS} ${.TARGET}
-.else
-NORMAL_CTFCONVERT=
-.endif
+NORMAL_CTFCONVERT= @[ -z "${CTFCONVERT}" -o -n "${NO_CTF}" ] || ${CTFCONVERT} ${CTFFLAGS} ${.TARGET}
 
 NORMAL_LINT=	${LINT} ${LINTFLAGS} ${CFLAGS:M-[DIU]*} ${.IMPSRC}
 
@@ -141,10 +137,7 @@ SYSTEM_CFILES= config.c env.c hints.c vnode_if.c
 SYSTEM_DEP= Makefile ${SYSTEM_OBJS}
 SYSTEM_OBJS= locore.o ${MDOBJS} ${OBJS}
 SYSTEM_OBJS+= ${SYSTEM_CFILES:.c=.o}
-.if defined(CTFMERGE)
-SYSTEM_CTFMERGE= ${CTFMERGE} ${CTFFLAGS} -o ${.TARGET} ${SYSTEM_OBJS} vers.o
-LD+= -g
-.endif
+SYSTEM_CTFMERGE= [ -z "${CTFMERGE}" -o -n "${NO_CTF}" ] || ${CTFMERGE} ${CTFFLAGS} -o ${.TARGET} ${SYSTEM_OBJS} vers.o
 .if ${MACHINE_ARCH} == XXX_ALTIX_TODO
 SYSTEM_LDFLAGS= -r
 .else
diff --git a/sys/conf/kmod.mk b/sys/conf/kmod.mk
index fd93443a58a4..ec11e9ed0664 100644
--- a/sys/conf/kmod.mk
+++ b/sys/conf/kmod.mk
@@ -69,6 +69,11 @@ OBJCOPY?=	objcopy
 .error "Do not use KMODDEPS on 5.0+; use MODULE_VERSION/MODULE_DEPEND"
 .endif
 
+# Enable CTF conversion on request.
+.if defined(WITH_CTF)
+.undef NO_CTF
+.endif
+
 .include <bsd.init.mk>
 
 .SUFFIXES: .out .o .c .cc .cxx .C .y .l .s .S
diff --git a/sys/contrib/dev/acpica/changes.txt b/sys/contrib/dev/acpica/changes.txt
index 5bd82ab6949a..d2c8c0e41edf 100644
--- a/sys/contrib/dev/acpica/changes.txt
+++ b/sys/contrib/dev/acpica/changes.txt
@@ -1,4 +1,79 @@
 ----------------------------------------
+31 March 2010. Summary of changes for version 20100331:
+
+1) ACPI CA Core Subsystem:
+
+Completed a major update for the GPE support in order to improve support for 
+shared GPEs and to simplify both host OS and ACPICA code. Added a reference 
+count mechanism to support shared GPEs that require multiple device drivers. 
+Several external interfaces have changed. One external interface has been 
+removed. One new external interface was added. Most of the GPE external 
+interfaces now use the GPE spinlock instead of the events mutex (and the 
+Flags parameter for many GPE interfaces has been removed.) See the updated 
+ACPICA Programmer Reference for details. Matthew Garrett, Bob Moore, Rafael 
+Wysocki. ACPICA BZ 831.
+
+Changed:
+    AcpiEnableGpe, AcpiDisableGpe, AcpiClearGpe, AcpiGetGpeStatus
+Removed:
+    AcpiSetGpeType
+New:
+    AcpiSetGpe
+
+Implemented write support for DataTable operation regions. These regions are 
+defined via the DataTableRegion() operator. Previously, only read support was 
+implemented. The ACPI specification allows DataTableRegions to be read/write, 
+however.
+
+Implemented a new subsystem option to force a copy of the DSDT to local 
+memory. Optionally copy the entire DSDT to local memory (instead of simply 
+mapping it.) There are some (albeit very rare) BIOSs that corrupt or replace 
+the original DSDT, creating the need for this option. Default is FALSE, do 
+not copy the DSDT.
+
+Implemented detection of a corrupted or replaced DSDT. This change adds 
+support to detect a DSDT that has been corrupted and/or replaced from outside 
+the OS (by firmware). This is typically catastrophic for the system, but has 
+been seen on some machines. Once this problem has been detected, the DSDT 
+copy option can be enabled via system configuration. Lin Ming, Bob Moore.
+
+Fixed two problems with AcpiReallocateRootTable during the root table copy. 
+When copying the root table to the new allocation, the length used was 
+incorrect. The new size was used instead of the current table size, meaning 
+too much data was copied. Also, the count of available slots for ACPI tables 
+was not set correctly. Alexey Starikovskiy, Bob Moore.
+
+Example Code and Data Size: These are the sizes for the OS-independent 
+acpica.lib produced by the Microsoft Visual C++ 6.0 32-bit compiler. The 
+debug version of the code includes the debug output trace mechanism and has a 
+much larger code and data size.
+
+  Previous Release:
+    Non-Debug Version:  87.5K Code, 18.4K Data, 105.9K Total
+    Debug Version:     163.4K Code, 51.1K Data, 214.5K Total
+  Current Release:
+    Non-Debug Version:  87.9K Code, 18.6K Data, 106.5K Total
+    Debug Version:     163.5K Code, 51.3K Data, 214.8K Total
+
+2) iASL Compiler/Disassembler and Tools:
+
+iASL: Implement limited typechecking for values returned from predefined 
+control methods. The type of any returned static (unnamed) object is now 
+validated. For example, Return(1). ACPICA BZ 786.
+
+iASL: Fixed a predefined name object verification regression. Fixes a problem 
+introduced in version 20100304. An error is incorrectly generated if a 
+predefined name is declared as a static named object with a value defined 
+using the keywords "Zero", "One", or "Ones". Lin Ming.
+
+iASL: Added Windows 7 support for the -g option (get local ACPI tables) by 
+reducing the requested registry access rights. ACPICA BZ 842.
+
+Disassembler: fixed a possible fault when generating External() statements. 
+Introduced in commit ae7d6fd: Properly handle externals with parent-prefix 
+(carat). Fixes a string length allocation calculation. Lin Ming.
+
+----------------------------------------
 04 March 2010. Summary of changes for version 20100304:
 
 1) ACPI CA Core Subsystem:
diff --git a/sys/contrib/dev/acpica/common/dmextern.c b/sys/contrib/dev/acpica/common/dmextern.c
index 59667290cc38..8d95571b04e0 100644
--- a/sys/contrib/dev/acpica/common/dmextern.c
+++ b/sys/contrib/dev/acpica/common/dmextern.c
@@ -270,6 +270,15 @@ AcpiDmNormalizeParentPrefix (
     }
 
     Length = (ACPI_STRLEN (ParentPath) + ACPI_STRLEN (Path) + 1);
+    if (ParentPath[1])
+    {
+        /*
+         * If ParentPath is not just a simple '\', increment the length
+         * for the required dot separator (ParentPath.Path)
+         */
+        Length++;
+    }
+
     Fullpath = ACPI_ALLOCATE_ZEROED (Length);
     if (!Fullpath)
     {
diff --git a/sys/contrib/dev/acpica/compiler/aslanalyze.c b/sys/contrib/dev/acpica/compiler/aslanalyze.c
index c3070f05bb70..608f6e512153 100644
--- a/sys/contrib/dev/acpica/compiler/aslanalyze.c
+++ b/sys/contrib/dev/acpica/compiler/aslanalyze.c
@@ -1157,6 +1157,12 @@ AnMethodAnalysisWalkEnd (
     case PARSEOP_RETURN:
 
         /*
+         * If the parent is a predefined method name, attempt to typecheck
+         * the return value. Only static types can be validated.
+         */
+        ApCheckPredefinedReturnValue (Op, MethodInfo);
+
+        /*
          * The parent block does not "exit" and continue execution -- the
          * method is terminated here with the Return() statement.
          */
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.h b/sys/contrib/dev/acpica/compiler/aslcompiler.h
index 554b0a38821d..dbc2709725b5 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.h
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.h
@@ -461,6 +461,11 @@ ApCheckForPredefinedMethod (
     ACPI_PARSE_OBJECT       *Op,
     ASL_METHOD_INFO         *MethodInfo);
 
+void
+ApCheckPredefinedReturnValue (
+    ACPI_PARSE_OBJECT       *Op,
+    ASL_METHOD_INFO         *MethodInfo);
+
 UINT32
 ApCheckForPredefinedName (
     ACPI_PARSE_OBJECT       *Op,
diff --git a/sys/contrib/dev/acpica/compiler/aslpredef.c b/sys/contrib/dev/acpica/compiler/aslpredef.c
index 97ed3caddbed..b9632f9c6e19 100644
--- a/sys/contrib/dev/acpica/compiler/aslpredef.c
+++ b/sys/contrib/dev/acpica/compiler/aslpredef.c
@@ -296,7 +296,11 @@ ApCheckForPredefinedMethod (
         if (MethodInfo->NumReturnNoValue &&
             PredefinedNames[Index].Info.ExpectedBtypes)
         {
-            sprintf (MsgBuffer, "%4.4s", PredefinedNames[Index].Info.Name);
+            ApGetExpectedTypes (StringBuffer,
+                PredefinedNames[Index].Info.ExpectedBtypes);
+
+            sprintf (MsgBuffer, "%s required for %4.4s",
+                StringBuffer, PredefinedNames[Index].Info.Name);
 
             AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Op,
                 MsgBuffer);
@@ -308,6 +312,90 @@ ApCheckForPredefinedMethod (
 
 /*******************************************************************************
  *
+ * FUNCTION:    ApCheckPredefinedReturnValue
+ *
+ * PARAMETERS:  Op              - A parse node of type "RETURN".
+ *              MethodInfo      - Saved info about this method
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: If method is a predefined name, attempt to validate the return
+ *              value. Only "static" types can be validated - a simple return
+ *              of an integer/string/buffer/package or a named reference to
+ *              a static object. Values such as a Localx or Argx or a control
+ *              method invocation are not checked.
+ *
+ ******************************************************************************/
+
+void
+ApCheckPredefinedReturnValue (
+    ACPI_PARSE_OBJECT       *Op,
+    ASL_METHOD_INFO         *MethodInfo)
+{
+    UINT32                  Index;
+    ACPI_PARSE_OBJECT       *ReturnValueOp;
+
+
+    /* Check parent method for a match against the predefined name list */
+
+    Index = ApCheckForPredefinedName (MethodInfo->Op,
+                MethodInfo->Op->Asl.NameSeg);
+
+    switch (Index)
+    {
+    case ACPI_NOT_RESERVED_NAME:        /* No underscore or _Txx or _xxx name not matched */
+    case ACPI_PREDEFINED_NAME:          /* Resource Name or reserved scope name */
+    case ACPI_COMPILER_RESERVED_NAME:   /* A _Txx that was not emitted by compiler */
+    case ACPI_EVENT_RESERVED_NAME:      /* _Lxx, _Exx, and _Qxx methods */
+
+        /* Just return, nothing to do */
+        return;
+
+    default: /* a real predefined ACPI name */
+
+        /* Exit if no return value expected */
+
+        if (!PredefinedNames[Index].Info.ExpectedBtypes)
+        {
+            return;
+        }
+
+        /* Get the object returned, it is the next argument */
+
+        ReturnValueOp = Op->Asl.Child;
+        switch (ReturnValueOp->Asl.ParseOpcode)
+        {
+        case PARSEOP_ZERO:
+        case PARSEOP_ONE:
+        case PARSEOP_ONES:
+        case PARSEOP_INTEGER:
+        case PARSEOP_STRING_LITERAL:
+        case PARSEOP_BUFFER:
+        case PARSEOP_PACKAGE:
+
+            /* Static data return object - check against expected type */
+
+            ApCheckObjectType (ReturnValueOp,
+                PredefinedNames[Index].Info.ExpectedBtypes);
+            break;
+
+        default:
+
+            /*
+             * All other ops are very difficult or impossible to typecheck at
+             * compile time. These include all Localx, Argx, and method
+             * invocations. Also, NAMESEG and NAMESTRING because the type of
+             * any named object can be changed at runtime (for example,
+             * CopyObject will change the type of the target object.)
+             */
+            break;
+        }
+    }
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    ApCheckForPredefinedObject
  *
  * PARAMETERS:  Op              - A parse node
@@ -441,7 +529,7 @@ ApCheckForPredefinedName (
  *
  * RETURN:      None
  *
- * DESCRIPTION: Check for the "special" predefined names - 
+ * DESCRIPTION: Check for the "special" predefined names -
  *              _Lxx, _Exx, _Qxx, and _T_x
  *
  ******************************************************************************/
@@ -512,7 +600,7 @@ ApCheckForSpecialName (
  *
  * FUNCTION:    ApCheckObjectType
  *
- * PARAMETERS:  Op              - A parse node
+ * PARAMETERS:  Op              - Current parse node
  *              ExpectedBtypes  - Bitmap of expected return type(s)
  *
  * RETURN:      None
@@ -529,11 +617,13 @@ ApCheckObjectType (
     UINT32                  ExpectedBtypes)
 {
     UINT32                  ReturnBtype;
-    char                    TypeBuffer[48]; /* Room for 5 types */
 
 
     switch (Op->Asl.ParseOpcode)
     {
+    case PARSEOP_ZERO:
+    case PARSEOP_ONE:
+    case PARSEOP_ONES:
     case PARSEOP_INTEGER:
         ReturnBtype = ACPI_RTYPE_INTEGER;
         break;
@@ -552,11 +642,11 @@ ApCheckObjectType (
 
     default:
         /* Not one of the supported object types */
-        
+
         goto TypeErrorExit;
     }
 
-    /* Is the object one of the expected types? */
+    /* Exit if the object is one of the expected types */
 
     if (ReturnBtype & ExpectedBtypes)
     {
@@ -568,10 +658,13 @@ TypeErrorExit:
 
     /* Format the expected types and emit an error message */
 
-    ApGetExpectedTypes (TypeBuffer, ExpectedBtypes);
+    ApGetExpectedTypes (StringBuffer, ExpectedBtypes);
+
+    sprintf (MsgBuffer, "found %s, requires %s",
+        UtGetOpName (Op->Asl.ParseOpcode), StringBuffer);
 
     AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Op,
-        TypeBuffer);
+        MsgBuffer);
 }
 
 
diff --git a/sys/contrib/dev/acpica/compiler/aslstubs.c b/sys/contrib/dev/acpica/compiler/aslstubs.c
index dc1598fa28ae..b2fb69a96fbe 100644
--- a/sys/contrib/dev/acpica/compiler/aslstubs.c
+++ b/sys/contrib/dev/acpica/compiler/aslstubs.c
@@ -243,13 +243,6 @@ AcpiEvInitializeRegion (
     return (AE_OK);
 }
 
-ACPI_STATUS
-AcpiEvCheckForWakeOnlyGpe (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
-{
-    return (AE_OK);
-}
-
 void
 AcpiExDoDebugObject (
     ACPI_OPERAND_OBJECT     *SourceDesc,
diff --git a/sys/contrib/dev/acpica/compiler/asltypes.h b/sys/contrib/dev/acpica/compiler/asltypes.h
index 6edf9870680a..30b8fdfe7d04 100644
--- a/sys/contrib/dev/acpica/compiler/asltypes.h
+++ b/sys/contrib/dev/acpica/compiler/asltypes.h
@@ -507,7 +507,7 @@ char                        *AslMessages [] = {
 /*    ASL_MSG_RESERVED_ARG_COUNT_HI */      "Reserved method has too many arguments",
 /*    ASL_MSG_RESERVED_ARG_COUNT_LO */      "Reserved method has too few arguments",
 /*    ASL_MSG_RESERVED_METHOD */            "Reserved name must be a control method",
-/*    ASL_MSG_RESERVED_OPERAND_TYPE */      "Invalid object type for reserved name, must be",
+/*    ASL_MSG_RESERVED_OPERAND_TYPE */      "Invalid object type for reserved name",
 /*    ASL_MSG_RESERVED_RETURN_VALUE */      "Reserved method must return a value",
 /*    ASL_MSG_RESERVED_USE */               "Invalid use of reserved name",
 /*    ASL_MSG_RESERVED_WORD */              "Use of reserved name",
diff --git a/sys/contrib/dev/acpica/debugger/dbdisply.c b/sys/contrib/dev/acpica/debugger/dbdisply.c
index 179f6f66de95..41094891ad7d 100644
--- a/sys/contrib/dev/acpica/debugger/dbdisply.c
+++ b/sys/contrib/dev/acpica/debugger/dbdisply.c
@@ -848,13 +848,12 @@ AcpiDbDisplayGpes (
                 Block, GpeBlock, GpeBlock->Node, Buffer);
 
             AcpiOsPrintf ("    Registers:    %u (%u GPEs)\n",
-                GpeBlock->RegisterCount,
-                ACPI_MUL_8 (GpeBlock->RegisterCount));
+                GpeBlock->RegisterCount, GpeBlock->GpeCount);
 
-            AcpiOsPrintf ("    GPE range:    0x%X to 0x%X\n",
+            AcpiOsPrintf ("    GPE range:    0x%X to 0x%X on interrupt %u\n",
                 GpeBlock->BlockBaseNumber,
-                GpeBlock->BlockBaseNumber +
-                    (GpeBlock->RegisterCount * 8) -1);
+                GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1),
+                GpeXruptInfo->InterruptNumber);
 
             AcpiOsPrintf (
                 "    RegisterInfo: %p  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
@@ -871,9 +870,12 @@ AcpiDbDisplayGpes (
                 GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
 
                 AcpiOsPrintf (
-                    "    Reg %u:  WakeEnable %2.2X, RunEnable %2.2X  Status %8.8X%8.8X Enable %8.8X%8.8X\n",
-                    i, GpeRegisterInfo->EnableForWake,
+                    "    Reg %u: (GPE %.2X-%.2X)  RunEnable %2.2X WakeEnable %2.2X"
+                    " Status %8.8X%8.8X Enable %8.8X%8.8X\n",
+                    i, GpeRegisterInfo->BaseGpeNumber,
+                    GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
                     GpeRegisterInfo->EnableForRun,
+                    GpeRegisterInfo->EnableForWake,
                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->StatusAddress.Address),
                     ACPI_FORMAT_UINT64 (GpeRegisterInfo->EnableAddress.Address));
 
@@ -886,17 +888,19 @@ AcpiDbDisplayGpes (
 
                     if (!(GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK))
                     {
-                        /* This GPE is not used (no method or handler) */
+                        /* This GPE is not used (no method or handler), ignore it */
 
                         continue;
                     }
 
                     AcpiOsPrintf (
-                        "        GPE %.3X: %p Flags %2.2X: ",
-                        GpeBlock->BlockBaseNumber + GpeIndex,
-                        GpeEventInfo,
+                        "        GPE %.2X: %p  RunRefs %2.2X   WakeRefs %2.2X Flags %2.2X (",
+                        GpeBlock->BlockBaseNumber + GpeIndex, GpeEventInfo,
+                        GpeEventInfo->RuntimeCount, GpeEventInfo->WakeupCount,
                         GpeEventInfo->Flags);
 
+                    /* Decode the flags byte */
+
                     if (GpeEventInfo->Flags & ACPI_GPE_LEVEL_TRIGGERED)
                     {
                         AcpiOsPrintf ("Level, ");
@@ -906,38 +910,13 @@ AcpiDbDisplayGpes (
                         AcpiOsPrintf ("Edge,  ");
                     }
 
-                    switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
-                    {
-                    case ACPI_GPE_TYPE_WAKE:
-                        AcpiOsPrintf ("WakeOnly: ");
-                        break;
-                    case ACPI_GPE_TYPE_RUNTIME:
-                        AcpiOsPrintf (" RunOnly: ");
-                        break;
-                    case ACPI_GPE_TYPE_WAKE_RUN:
-                        AcpiOsPrintf (" WakeRun: ");
-                        break;
-                    default:
-                        AcpiOsPrintf (" NotUsed: ");
-                        break;
-                    }
-
-                    if (GpeEventInfo->Flags & ACPI_GPE_WAKE_ENABLED)
-                    {
-                        AcpiOsPrintf ("[Wake 1 ");
-                    }
-                    else
-                    {
-                        AcpiOsPrintf ("[Wake 0 ");
-                    }
-
-                    if (GpeEventInfo->Flags & ACPI_GPE_RUN_ENABLED)
+                    if (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE)
                     {
-                        AcpiOsPrintf ("Run 1], ");
+                        AcpiOsPrintf ("CanWake, ");
                     }
                     else
                     {
-                        AcpiOsPrintf ("Run 0], ");
+                        AcpiOsPrintf ("RunOnly, ");
                     }
 
                     switch (GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)
@@ -957,7 +936,7 @@ AcpiDbDisplayGpes (
                         break;
                     }
 
-                    AcpiOsPrintf ("\n");
+                    AcpiOsPrintf (")\n");
                 }
             }
             Block++;
diff --git a/sys/contrib/dev/acpica/events/evgpe.c b/sys/contrib/dev/acpica/events/evgpe.c
index 77d7cf0b428f..0ece12ca78c4 100644
--- a/sys/contrib/dev/acpica/events/evgpe.c
+++ b/sys/contrib/dev/acpica/events/evgpe.c
@@ -134,71 +134,20 @@ AcpiEvAsynchEnableGpe (
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiEvSetGpeType
- *
- * PARAMETERS:  GpeEventInfo            - GPE to set
- *              Type                    - New type
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Sets the new type for the GPE (wake, run, or wake/run)
- *
- ******************************************************************************/
-
-ACPI_STATUS
-AcpiEvSetGpeType (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo,
-    UINT8                   Type)
-{
-    ACPI_STATUS             Status;
-
-
-    ACPI_FUNCTION_TRACE (EvSetGpeType);
-
-
-    /* Validate type and update register enable masks */
-
-    switch (Type)
-    {
-    case ACPI_GPE_TYPE_WAKE:
-    case ACPI_GPE_TYPE_RUNTIME:
-    case ACPI_GPE_TYPE_WAKE_RUN:
-        break;
-
-    default:
-        return_ACPI_STATUS (AE_BAD_PARAMETER);
-    }
-
-    /* Disable the GPE if currently enabled */
-
-    Status = AcpiEvDisableGpe (GpeEventInfo);
-
-    /* Clear the type bits and insert the new Type */
-
-    GpeEventInfo->Flags &= ~ACPI_GPE_TYPE_MASK;
-    GpeEventInfo->Flags |= Type;
-    return_ACPI_STATUS (Status);
-}
-
-
-/*******************************************************************************
- *
  * FUNCTION:    AcpiEvUpdateGpeEnableMasks
  *
  * PARAMETERS:  GpeEventInfo            - GPE to update
- *              Type                    - What to do: ACPI_GPE_DISABLE or
- *                                        ACPI_GPE_ENABLE
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Updates GPE register enable masks based on the GPE type
+ * DESCRIPTION: Updates GPE register enable masks based upon whether there are
+ *              references (either wake or run) to this GPE
  *
  ******************************************************************************/
 
 ACPI_STATUS
 AcpiEvUpdateGpeEnableMasks (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo,
-    UINT8                   Type)
+    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
 {
     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
     UINT8                   RegisterBit;
@@ -216,36 +165,21 @@ AcpiEvUpdateGpeEnableMasks (
     RegisterBit = (UINT8)
         (1 << (GpeEventInfo->GpeNumber - GpeRegisterInfo->BaseGpeNumber));
 
-    /* 1) Disable case. Simply clear all enable bits */
+    /* Clear the wake/run bits up front */
 
-    if (Type == ACPI_GPE_DISABLE)
-    {
-        ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
-        ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
-        return_ACPI_STATUS (AE_OK);
-    }
+    ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
+    ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
 
-    /* 2) Enable case. Set/Clear the appropriate enable bits */
+    /* Set the mask bits only if there are references to this GPE */
 
-    switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
+    if (GpeEventInfo->RuntimeCount)
     {
-    case ACPI_GPE_TYPE_WAKE:
-        ACPI_SET_BIT   (GpeRegisterInfo->EnableForWake, RegisterBit);
-        ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
-        break;
-
-    case ACPI_GPE_TYPE_RUNTIME:
-        ACPI_CLEAR_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
-        ACPI_SET_BIT   (GpeRegisterInfo->EnableForRun, RegisterBit);
-        break;
-
-    case ACPI_GPE_TYPE_WAKE_RUN:
-        ACPI_SET_BIT   (GpeRegisterInfo->EnableForWake, RegisterBit);
-        ACPI_SET_BIT   (GpeRegisterInfo->EnableForRun, RegisterBit);
-        break;
+        ACPI_SET_BIT (GpeRegisterInfo->EnableForRun, RegisterBit);
+    }
 
-    default:
-        return_ACPI_STATUS (AE_BAD_PARAMETER);
+    if (GpeEventInfo->WakeupCount)
+    {
+        ACPI_SET_BIT (GpeRegisterInfo->EnableForWake, RegisterBit);
     }
 
     return_ACPI_STATUS (AE_OK);
@@ -257,19 +191,19 @@ AcpiEvUpdateGpeEnableMasks (
  * FUNCTION:    AcpiEvEnableGpe
  *
  * PARAMETERS:  GpeEventInfo            - GPE to enable
- *              WriteToHardware         - Enable now, or just mark data structs
- *                                        (WAKE GPEs should be deferred)
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Enable a GPE based on the GPE type
+ * DESCRIPTION: Hardware-enable a GPE. Always enables the GPE, regardless
+ *              of type or number of references.
+ *
+ * Note: The GPE lock should be already acquired when this function is called.
  *
  ******************************************************************************/
 
 ACPI_STATUS
 AcpiEvEnableGpe (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo,
-    BOOLEAN                 WriteToHardware)
+    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
 {
     ACPI_STATUS             Status;
 
@@ -277,54 +211,37 @@ AcpiEvEnableGpe (
     ACPI_FUNCTION_TRACE (EvEnableGpe);
 
 
-    /* Make sure HW enable masks are updated */
+    /*
+     * We will only allow a GPE to be enabled if it has either an
+     * associated method (_Lxx/_Exx) or a handler. Otherwise, the
+     * GPE will be immediately disabled by AcpiEvGpeDispatch the
+     * first time it fires.
+     */
+    if (!(GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK))
+    {
+        return_ACPI_STATUS (AE_NO_HANDLER);
+    }
+
+    /* Ensure the HW enable masks are current */
 
-    Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo, ACPI_GPE_ENABLE);
+    Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
     if (ACPI_FAILURE (Status))
     {
         return_ACPI_STATUS (Status);
     }
 
-    /* Mark wake-enabled or HW enable, or both */
+    /* Clear the GPE (of stale events) */
 
-    switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
+    Status = AcpiHwClearGpe (GpeEventInfo);
+    if (ACPI_FAILURE (Status))
     {
-    case ACPI_GPE_TYPE_WAKE:
-
-        ACPI_SET_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
-        break;
-
-    case ACPI_GPE_TYPE_WAKE_RUN:
-
-        ACPI_SET_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
-
-        /*lint -fallthrough */
-
-    case ACPI_GPE_TYPE_RUNTIME:
-
-        ACPI_SET_BIT (GpeEventInfo->Flags, ACPI_GPE_RUN_ENABLED);
-
-        if (WriteToHardware)
-        {
-            /* Clear the GPE (of stale events), then enable it */
-
-            Status = AcpiHwClearGpe (GpeEventInfo);
-            if (ACPI_FAILURE (Status))
-            {
-                return_ACPI_STATUS (Status);
-            }
-
-            /* Enable the requested runtime GPE */
-
-            Status = AcpiHwWriteGpeEnableReg (GpeEventInfo);
-        }
-        break;
-
-    default:
-        return_ACPI_STATUS (AE_BAD_PARAMETER);
+        return_ACPI_STATUS (Status);
     }
 
-    return_ACPI_STATUS (AE_OK);
+    /* Enable the requested GPE */
+
+    Status = AcpiHwWriteGpeEnableReg (GpeEventInfo);
+    return_ACPI_STATUS (Status);
 }
 
 
@@ -336,7 +253,10 @@ AcpiEvEnableGpe (
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Disable a GPE based on the GPE type
+ * DESCRIPTION: Hardware-disable a GPE. Always disables the requested GPE,
+ *              regardless of the type or number of references.
+ *
+ * Note: The GPE lock should be already acquired when this function is called.
  *
  ******************************************************************************/
 
@@ -356,40 +276,14 @@ AcpiEvDisableGpe (
      * the GPE behind our back.
      */
 
-    /* Make sure HW enable masks are updated */
+    /* Ensure the HW enable masks are current */
 
-    Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo, ACPI_GPE_DISABLE);
+    Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
     if (ACPI_FAILURE (Status))
     {
         return_ACPI_STATUS (Status);
     }
 
-    /* Clear the appropriate enabled flags for this GPE */
-
-    switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
-    {
-    case ACPI_GPE_TYPE_WAKE:
-
-        ACPI_CLEAR_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
-        break;
-
-    case ACPI_GPE_TYPE_WAKE_RUN:
-
-        ACPI_CLEAR_BIT (GpeEventInfo->Flags, ACPI_GPE_WAKE_ENABLED);
-
-        /*lint -fallthrough */
-
-    case ACPI_GPE_TYPE_RUNTIME:
-
-        /* Disable the requested runtime GPE */
-
-        ACPI_CLEAR_BIT (GpeEventInfo->Flags, ACPI_GPE_RUN_ENABLED);
-        break;
-
-    default:
-        break;
-    }
-
     /*
      * Always H/W disable this GPE, even if we don't know the GPE type.
      * Simply clear the enable bit for this particular GPE, but do not
@@ -405,6 +299,49 @@ AcpiEvDisableGpe (
 
 /*******************************************************************************
  *
+ * FUNCTION:    AcpiEvLowGetGpeInfo
+ *
+ * PARAMETERS:  GpeNumber           - Raw GPE number
+ *              GpeBlock            - A GPE info block
+ *
+ * RETURN:      A GPE EventInfo struct. NULL if not a valid GPE (The GpeNumber
+ *              is not within the specified GPE block)
+ *
+ * DESCRIPTION: Returns the EventInfo struct associated with this GPE. This is
+ *              the low-level implementation of EvGetGpeEventInfo.
+ *
+ ******************************************************************************/
+
+ACPI_GPE_EVENT_INFO *
+AcpiEvLowGetGpeInfo (
+    UINT32                  GpeNumber,
+    ACPI_GPE_BLOCK_INFO     *GpeBlock)
+{
+    UINT32                  GpeIndex;
+
+
+    /*
+     * Validate that the GpeNumber is within the specified GpeBlock.
+     * (Two steps)
+     */
+    if (!GpeBlock ||
+        (GpeNumber < GpeBlock->BlockBaseNumber))
+    {
+        return (NULL);
+    }
+
+    GpeIndex = GpeNumber - GpeBlock->BlockBaseNumber;
+    if (GpeIndex >= GpeBlock->GpeCount)
+    {
+        return (NULL);
+    }
+
+    return (&GpeBlock->EventInfo[GpeIndex]);
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    AcpiEvGetGpeEventInfo
  *
  * PARAMETERS:  GpeDevice           - Device node. NULL for GPE0/GPE1
@@ -426,7 +363,7 @@ AcpiEvGetGpeEventInfo (
     UINT32                  GpeNumber)
 {
     ACPI_OPERAND_OBJECT     *ObjDesc;
-    ACPI_GPE_BLOCK_INFO     *GpeBlock;
+    ACPI_GPE_EVENT_INFO     *GpeInfo;
     UINT32                  i;
 
 
@@ -441,16 +378,11 @@ AcpiEvGetGpeEventInfo (
 
         for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++)
         {
-            GpeBlock = AcpiGbl_GpeFadtBlocks[i];
-            if (GpeBlock)
+            GpeInfo = AcpiEvLowGetGpeInfo (GpeNumber,
+                        AcpiGbl_GpeFadtBlocks[i]);
+            if (GpeInfo)
             {
-                if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
-                    (GpeNumber < GpeBlock->BlockBaseNumber +
-                        (GpeBlock->RegisterCount * 8)))
-                {
-                    return (&GpeBlock->EventInfo[GpeNumber -
-                        GpeBlock->BlockBaseNumber]);
-                }
+                return (GpeInfo);
             }
         }
 
@@ -468,15 +400,7 @@ AcpiEvGetGpeEventInfo (
         return (NULL);
     }
 
-    GpeBlock = ObjDesc->Device.GpeBlock;
-
-    if ((GpeNumber >= GpeBlock->BlockBaseNumber) &&
-        (GpeNumber < GpeBlock->BlockBaseNumber + (GpeBlock->RegisterCount * 8)))
-    {
-        return (&GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber]);
-    }
-
-    return (NULL);
+    return (AcpiEvLowGetGpeInfo (GpeNumber, ObjDesc->Device.GpeBlock));
 }
 
 
@@ -654,9 +578,9 @@ AcpiEvAsynchExecuteGpeMethod (
         return_VOID;
     }
 
-    /* Set the GPE flags for return to enabled state */
+    /* Update the GPE register masks for return to enabled state */
 
-    (void) AcpiEvEnableGpe (GpeEventInfo, FALSE);
+    (void) AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
 
     /*
      * Take a snapshot of the GPE info for this level - we copy the info to
@@ -872,15 +796,18 @@ AcpiEvGpeDispatch (
 
     default:
 
-        /* No handler or method to run! */
-
+        /*
+         * No handler or method to run!
+         * 03/2010: This case should no longer be possible. We will not allow
+         * a GPE to be enabled if it has no handler or method.
+         */
         ACPI_ERROR ((AE_INFO,
             "No handler or method for GPE[0x%2X], disabling event",
             GpeNumber));
 
         /*
-         * Disable the GPE. The GPE will remain disabled until the ACPICA
-         * Core Subsystem is restarted, or a handler is installed.
+         * Disable the GPE. The GPE will remain disabled a handler
+         * is installed or ACPICA is restarted.
          */
         Status = AcpiEvDisableGpe (GpeEventInfo);
         if (ACPI_FAILURE (Status))
diff --git a/sys/contrib/dev/acpica/events/evgpeblk.c b/sys/contrib/dev/acpica/events/evgpeblk.c
index 55bc97c6b93f..29b0e711e5f5 100644
--- a/sys/contrib/dev/acpica/events/evgpeblk.c
+++ b/sys/contrib/dev/acpica/events/evgpeblk.c
@@ -124,7 +124,7 @@
 /* Local prototypes */
 
 static ACPI_STATUS
-AcpiEvSaveMethodInfo (
+AcpiEvMatchGpeMethod (
     ACPI_HANDLE             ObjHandle,
     UINT32                  Level,
     void                    *ObjDesc,
@@ -194,8 +194,7 @@ AcpiEvValidGpeEvent (
         while (GpeBlock)
         {
             if ((&GpeBlock->EventInfo[0] <= GpeEventInfo) &&
-                (&GpeBlock->EventInfo[((ACPI_SIZE)
-                    GpeBlock->RegisterCount) * 8] > GpeEventInfo))
+                (&GpeBlock->EventInfo[GpeBlock->GpeCount] > GpeEventInfo))
             {
                 return (TRUE);
             }
@@ -328,7 +327,7 @@ AcpiEvDeleteGpeHandlers (
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiEvSaveMethodInfo
+ * FUNCTION:    AcpiEvMatchGpeMethod
  *
  * PARAMETERS:  Callback from WalkNamespace
  *
@@ -340,8 +339,7 @@ AcpiEvDeleteGpeHandlers (
  *              information for quick lookup during GPE dispatch
  *
  *              The name of each GPE control method is of the form:
- *              "_Lxx" or "_Exx"
- *              Where:
+ *              "_Lxx" or "_Exx", where:
  *                  L      - means that the GPE is level triggered
  *                  E      - means that the GPE is edge triggered
  *                  xx     - is the GPE number [in HEX]
@@ -349,38 +347,44 @@ AcpiEvDeleteGpeHandlers (
  ******************************************************************************/
 
 static ACPI_STATUS
-AcpiEvSaveMethodInfo (
+AcpiEvMatchGpeMethod (
     ACPI_HANDLE             ObjHandle,
     UINT32                  Level,
     void                    *ObjDesc,
     void                    **ReturnValue)
 {
+    ACPI_NAMESPACE_NODE     *MethodNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjHandle);
     ACPI_GPE_BLOCK_INFO     *GpeBlock = (void *) ObjDesc;
     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
     UINT32                  GpeNumber;
     char                    Name[ACPI_NAME_SIZE + 1];
     UINT8                   Type;
-    ACPI_STATUS             Status;
 
 
-    ACPI_FUNCTION_TRACE (EvSaveMethodInfo);
+    ACPI_FUNCTION_TRACE (EvMatchGpeMethod);
 
 
     /*
-     * _Lxx and _Exx GPE method support
+     * Match and decode the _Lxx and _Exx GPE method names
      *
-     * 1) Extract the name from the object and convert to a string
+     * 1) Extract the method name and null terminate it
      */
-    ACPI_MOVE_32_TO_32 (
-        Name, &((ACPI_NAMESPACE_NODE *) ObjHandle)->Name.Integer);
+    ACPI_MOVE_32_TO_32 (Name, &MethodNode->Name.Integer);
     Name[ACPI_NAME_SIZE] = 0;
 
+    /* 2) Name must begin with an underscore */
+
+    if (Name[0] != '_')
+    {
+        return_ACPI_STATUS (AE_OK); /* Ignore this method */
+    }
+
     /*
-     * 2) Edge/Level determination is based on the 2nd character
+     * 3) Edge/Level determination is based on the 2nd character
      *    of the method name
      *
-     * NOTE: Default GPE type is RUNTIME. May be changed later to WAKE
-     * if a _PRW object is found that points to this GPE.
+     * NOTE: Default GPE type is RUNTIME only. Later, if a _PRW object is
+     * found that points to this GPE, the ACPI_GPE_CAN_WAKE flag is set.
      */
     switch (Name[1])
     {
@@ -393,16 +397,15 @@ AcpiEvSaveMethodInfo (
         break;
 
     default:
-        /* Unknown method type, just ignore it! */
+        /* Unknown method type, just ignore it */
 
         ACPI_DEBUG_PRINT ((ACPI_DB_LOAD,
             "Ignoring unknown GPE method type: %s "
-            "(name not of form _Lxx or _Exx)",
-            Name));
+            "(name not of form _Lxx or _Exx)", Name));
         return_ACPI_STATUS (AE_OK);
     }
 
-    /* Convert the last two characters of the name to the GPE Number */
+    /* 4) The last two characters of the name are the hex GPE Number */
 
     GpeNumber = ACPI_STRTOUL (&Name[2], NULL, 16);
     if (GpeNumber == ACPI_UINT32_MAX)
@@ -411,45 +414,34 @@ AcpiEvSaveMethodInfo (
 
         ACPI_DEBUG_PRINT ((ACPI_DB_LOAD,
             "Could not extract GPE number from name: %s "
-            "(name is not of form _Lxx or _Exx)",
-            Name));
+            "(name is not of form _Lxx or _Exx)", Name));
         return_ACPI_STATUS (AE_OK);
     }
 
     /* Ensure that we have a valid GPE number for this GPE block */
 
-    if ((GpeNumber < GpeBlock->BlockBaseNumber) ||
-        (GpeNumber >= (GpeBlock->BlockBaseNumber +
-            (GpeBlock->RegisterCount * 8))))
+    GpeEventInfo = AcpiEvLowGetGpeInfo (GpeNumber, GpeBlock);
+    if (!GpeEventInfo)
     {
         /*
-         * Not valid for this GPE block, just ignore it. However, it may be
-         * valid for a different GPE block, since GPE0 and GPE1 methods both
-         * appear under \_GPE.
+         * This GpeNumber is not valid for this GPE block, just ignore it.
+         * However, it may be valid for a different GPE block, since GPE0
+         * and GPE1 methods both appear under \_GPE.
          */
         return_ACPI_STATUS (AE_OK);
     }
 
     /*
-     * Now we can add this information to the GpeEventInfo block for use
-     * during dispatch of this GPE. Default type is RUNTIME, although this may
-     * change when the _PRW methods are executed later.
+     * Add the GPE information from above to the GpeEventInfo block for
+     * use during dispatch of this GPE.
      */
-    GpeEventInfo = &GpeBlock->EventInfo[GpeNumber - GpeBlock->BlockBaseNumber];
-
-    GpeEventInfo->Flags = (UINT8)
-        (Type | ACPI_GPE_DISPATCH_METHOD | ACPI_GPE_TYPE_RUNTIME);
-
-    GpeEventInfo->Dispatch.MethodNode = (ACPI_NAMESPACE_NODE *) ObjHandle;
-
-    /* Update enable mask, but don't enable the HW GPE as of yet */
-
-    Status = AcpiEvEnableGpe (GpeEventInfo, FALSE);
+    GpeEventInfo->Flags = (UINT8) (Type | ACPI_GPE_DISPATCH_METHOD);
+    GpeEventInfo->Dispatch.MethodNode = MethodNode;
 
     ACPI_DEBUG_PRINT ((ACPI_DB_LOAD,
         "Registered GPE method %s as GPE number 0x%.2X\n",
         Name, GpeNumber));
-    return_ACPI_STATUS (Status);
+    return_ACPI_STATUS (AE_OK);
 }
 
 
@@ -464,7 +456,7 @@ AcpiEvSaveMethodInfo (
  *
  * DESCRIPTION: Called from AcpiWalkNamespace. Expects each object to be a
  *              Device. Run the _PRW method. If present, extract the GPE
- *              number and mark the GPE as a WAKE GPE.
+ *              number and mark the GPE as a CAN_WAKE GPE.
  *
  ******************************************************************************/
 
@@ -495,7 +487,7 @@ AcpiEvMatchPrwAndGpe (
                 ACPI_BTYPE_PACKAGE, &PkgDesc);
     if (ACPI_FAILURE (Status))
     {
-        /* Ignore all errors from _PRW, we don't want to abort the subsystem */
+        /* Ignore all errors from _PRW, we don't want to abort the walk */
 
         return_ACPI_STATUS (AE_OK);
     }
@@ -561,25 +553,17 @@ AcpiEvMatchPrwAndGpe (
      *     2) The GPE index(number) is within the range of the Gpe Block
      *          associated with the GPE device.
      */
-    if ((GpeDevice == TargetGpeDevice) &&
-        (GpeNumber >= GpeBlock->BlockBaseNumber) &&
-        (GpeNumber < GpeBlock->BlockBaseNumber +
-            (GpeBlock->RegisterCount * 8)))
+    if (GpeDevice != TargetGpeDevice)
     {
-        GpeEventInfo = &GpeBlock->EventInfo[GpeNumber -
-            GpeBlock->BlockBaseNumber];
-
-        /* Mark GPE for WAKE-ONLY but WAKE_DISABLED */
-
-        GpeEventInfo->Flags &= ~(ACPI_GPE_WAKE_ENABLED | ACPI_GPE_RUN_ENABLED);
+        goto Cleanup;
+    }
 
-        Status = AcpiEvSetGpeType (GpeEventInfo, ACPI_GPE_TYPE_WAKE);
-        if (ACPI_FAILURE (Status))
-        {
-            goto Cleanup;
-        }
+    GpeEventInfo = AcpiEvLowGetGpeInfo (GpeNumber, GpeBlock);
+    if (GpeEventInfo)
+    {
+        /* This GPE can wake the system */
 
-        Status = AcpiEvUpdateGpeEnableMasks (GpeEventInfo, ACPI_GPE_DISABLE);
+        GpeEventInfo->Flags |= ACPI_GPE_CAN_WAKE;
     }
 
 Cleanup:
@@ -880,7 +864,7 @@ AcpiEvDeleteGpeBlock (
         AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
     }
 
-    AcpiCurrentGpeCount -= GpeBlock->RegisterCount * ACPI_GPE_REGISTER_WIDTH;
+    AcpiCurrentGpeCount -= GpeBlock->GpeCount;
 
     /* Free the GpeBlock */
 
@@ -925,8 +909,8 @@ AcpiEvCreateGpeInfoBlocks (
     /* Allocate the GPE register information block */
 
     GpeRegisterInfo = ACPI_ALLOCATE_ZEROED (
-                            (ACPI_SIZE) GpeBlock->RegisterCount *
-                            sizeof (ACPI_GPE_REGISTER_INFO));
+                        (ACPI_SIZE) GpeBlock->RegisterCount *
+                        sizeof (ACPI_GPE_REGISTER_INFO));
     if (!GpeRegisterInfo)
     {
         ACPI_ERROR ((AE_INFO,
@@ -938,10 +922,8 @@ AcpiEvCreateGpeInfoBlocks (
      * Allocate the GPE EventInfo block. There are eight distinct GPEs
      * per register. Initialization to zeros is sufficient.
      */
-    GpeEventInfo = ACPI_ALLOCATE_ZEROED (
-                        ((ACPI_SIZE) GpeBlock->RegisterCount *
-                        ACPI_GPE_REGISTER_WIDTH) *
-                        sizeof (ACPI_GPE_EVENT_INFO));
+    GpeEventInfo = ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) GpeBlock->GpeCount *
+                    sizeof (ACPI_GPE_EVENT_INFO));
     if (!GpeEventInfo)
     {
         ACPI_ERROR ((AE_INFO,
@@ -1080,6 +1062,7 @@ AcpiEvCreateGpeBlock (
     /* Initialize the new GPE block */
 
     GpeBlock->Node = GpeDevice;
+    GpeBlock->GpeCount = (UINT16) (RegisterCount * ACPI_GPE_REGISTER_WIDTH);
     GpeBlock->RegisterCount = RegisterCount;
     GpeBlock->BlockBaseNumber = GpeBlockBaseNumber;
 
@@ -1110,7 +1093,7 @@ AcpiEvCreateGpeBlock (
 
     Status = AcpiNsWalkNamespace (ACPI_TYPE_METHOD, GpeDevice,
                 ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
-                AcpiEvSaveMethodInfo, NULL, GpeBlock, NULL);
+                AcpiEvMatchGpeMethod, NULL, GpeBlock, NULL);
 
     /* Return the new block */
 
@@ -1122,15 +1105,13 @@ AcpiEvCreateGpeBlock (
     ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
         "GPE %02X to %02X [%4.4s] %u regs on int 0x%X\n",
         (UINT32) GpeBlock->BlockBaseNumber,
-        (UINT32) (GpeBlock->BlockBaseNumber +
-                ((GpeBlock->RegisterCount * ACPI_GPE_REGISTER_WIDTH) -1)),
-        GpeDevice->Name.Ascii,
-        GpeBlock->RegisterCount,
+        (UINT32) (GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1)),
+        GpeDevice->Name.Ascii, GpeBlock->RegisterCount,
         InterruptNumber));
 
     /* Update global count of currently available GPEs */
 
-    AcpiCurrentGpeCount += RegisterCount * ACPI_GPE_REGISTER_WIDTH;
+    AcpiCurrentGpeCount += GpeBlock->GpeCount;
     return_ACPI_STATUS (AE_OK);
 }
 
@@ -1161,6 +1142,8 @@ AcpiEvInitializeGpeBlock (
     ACPI_GPE_WALK_INFO      GpeInfo;
     UINT32                  WakeGpeCount;
     UINT32                  GpeEnabledCount;
+    UINT32                  GpeIndex;
+    UINT32                  GpeNumber;
     UINT32                  i;
     UINT32                  j;
 
@@ -1193,39 +1176,65 @@ AcpiEvInitializeGpeBlock (
         Status = AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                     ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
                     AcpiEvMatchPrwAndGpe, NULL, &GpeInfo, NULL);
+        if (ACPI_FAILURE (Status))
+        {
+            ACPI_EXCEPTION ((AE_INFO, Status, "While executing _PRW methods"));
+        }
     }
 
     /*
-     * Enable all GPEs in this block that have these attributes:
-     * 1) are "runtime" or "run/wake" GPEs, and
-     * 2) have a corresponding _Lxx or _Exx method
-     *
-     * Any other GPEs within this block must be enabled via the
-     * AcpiEnableGpe() external interface.
+     * Enable all GPEs that have a corresponding method and are not
+     * capable of generating wakeups. Any other GPEs within this block
+     * must be enabled via the AcpiEnableGpe interface.
      */
     WakeGpeCount = 0;
     GpeEnabledCount = 0;
 
+    if (GpeDevice == AcpiGbl_FadtGpeDevice)
+    {
+        GpeDevice = NULL;
+    }
+
     for (i = 0; i < GpeBlock->RegisterCount; i++)
     {
-        for (j = 0; j < 8; j++)
+        for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
         {
             /* Get the info block for this particular GPE */
 
-            GpeEventInfo = &GpeBlock->EventInfo[((ACPI_SIZE) i *
-                ACPI_GPE_REGISTER_WIDTH) + j];
+            GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
+            GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
+
+            /* Ignore GPEs that can wake the system */
 
-            if (((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==
-                    ACPI_GPE_DISPATCH_METHOD) &&
-                 (GpeEventInfo->Flags & ACPI_GPE_TYPE_RUNTIME))
+            if (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE)
             {
-                GpeEnabledCount++;
+                WakeGpeCount++;
+                if (AcpiGbl_LeaveWakeGpesDisabled)
+                {
+                    continue;
+                }
             }
 
-            if (GpeEventInfo->Flags & ACPI_GPE_TYPE_WAKE)
+            /* Ignore GPEs that have no corresponding _Lxx/_Exx method */
+
+            if (!(GpeEventInfo->Flags & ACPI_GPE_DISPATCH_METHOD))
             {
-                WakeGpeCount++;
+                continue;
+            }
+
+            /* Enable this GPE */
+
+            GpeNumber = GpeIndex + GpeBlock->BlockBaseNumber;
+            Status = AcpiEnableGpe (GpeDevice, GpeNumber,
+                        ACPI_GPE_TYPE_RUNTIME);
+            if (ACPI_FAILURE (Status))
+            {
+                ACPI_EXCEPTION ((AE_INFO, Status,
+                    "Could not enable GPE 0x%02X", GpeNumber));
+                continue;
             }
+
+            GpeEnabledCount++;
         }
     }
 
@@ -1233,16 +1242,7 @@ AcpiEvInitializeGpeBlock (
         "Found %u Wake, Enabled %u Runtime GPEs in this block\n",
         WakeGpeCount, GpeEnabledCount));
 
-    /* Enable all valid runtime GPEs found above */
-
-    Status = AcpiHwEnableRuntimeGpeBlock (NULL, GpeBlock, NULL);
-    if (ACPI_FAILURE (Status))
-    {
-        ACPI_ERROR ((AE_INFO, "Could not enable GPEs in GpeBlock %p",
-            GpeBlock));
-    }
-
-    return_ACPI_STATUS (Status);
+    return_ACPI_STATUS (AE_OK);
 }
 
 
diff --git a/sys/contrib/dev/acpica/events/evxface.c b/sys/contrib/dev/acpica/events/evxface.c
index 284879c4ded1..3067fa8748d2 100644
--- a/sys/contrib/dev/acpica/events/evxface.c
+++ b/sys/contrib/dev/acpica/events/evxface.c
@@ -705,7 +705,7 @@ AcpiInstallGpeHandler (
 
     /* Parameter validation */
 
-    if ((!Address) || (Type > ACPI_GPE_XRUPT_TYPE_MASK))
+    if ((!Address) || (Type & ~ACPI_GPE_XRUPT_TYPE_MASK))
     {
         return_ACPI_STATUS (AE_BAD_PARAMETER);
     }
diff --git a/sys/contrib/dev/acpica/events/evxfevnt.c b/sys/contrib/dev/acpica/events/evxfevnt.c
index 92b6d4d69db7..333e0e586914 100644
--- a/sys/contrib/dev/acpica/events/evxfevnt.c
+++ b/sys/contrib/dev/acpica/events/evxfevnt.c
@@ -307,30 +307,43 @@ ACPI_EXPORT_SYMBOL (AcpiEnableEvent)
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiSetGpeType
+ * FUNCTION:    AcpiEnableGpe
  *
- * PARAMETERS:  GpeDevice       - Parent GPE Device
+ * PARAMETERS:  GpeDevice       - Parent GPE Device. NULL for GPE0/GPE1
  *              GpeNumber       - GPE level within the GPE block
- *              Type            - New GPE type
+ *              GpeType         - ACPI_GPE_TYPE_RUNTIME or ACPI_GPE_TYPE_WAKE
+ *                                or both
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Set the type of an individual GPE
+ * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
+ *              hardware-enabled (for runtime GPEs), or the GPE register mask
+ *              is updated (for wake GPEs).
  *
  ******************************************************************************/
 
 ACPI_STATUS
-AcpiSetGpeType (
+AcpiEnableGpe (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT8                   Type)
+    UINT8                   GpeType)
 {
     ACPI_STATUS             Status = AE_OK;
     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
+    ACPI_CPU_FLAGS          Flags;
+
+
+    ACPI_FUNCTION_TRACE (AcpiEnableGpe);
+
 
+    /* Parameter validation */
 
-    ACPI_FUNCTION_TRACE (AcpiSetGpeType);
+    if (!GpeType || (GpeType & ~ACPI_GPE_TYPE_WAKE_RUN))
+    {
+        return_ACPI_STATUS (AE_BAD_PARAMETER);
+    }
 
+    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
     /* Ensure that we have a valid GPE number */
 
@@ -341,61 +354,101 @@ AcpiSetGpeType (
         goto UnlockAndExit;
     }
 
-    if ((GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK) == Type)
+    if (GpeType & ACPI_GPE_TYPE_RUNTIME)
     {
-        return_ACPI_STATUS (AE_OK);
+        if (GpeEventInfo->RuntimeCount == ACPI_UINT8_MAX)
+        {
+            Status = AE_LIMIT; /* Too many references */
+            goto UnlockAndExit;
+        }
+
+        GpeEventInfo->RuntimeCount++;
+        if (GpeEventInfo->RuntimeCount == 1)
+        {
+            Status = AcpiEvEnableGpe (GpeEventInfo);
+            if (ACPI_FAILURE (Status))
+            {
+                GpeEventInfo->RuntimeCount--;
+                goto UnlockAndExit;
+            }
+        }
     }
 
-    /* Set the new type (will disable GPE if currently enabled) */
+    if (GpeType & ACPI_GPE_TYPE_WAKE)
+    {
+        /* The GPE must have the ability to wake the system */
 
-    Status = AcpiEvSetGpeType (GpeEventInfo, Type);
+        if (!(GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE))
+        {
+            Status = AE_TYPE;
+            goto UnlockAndExit;
+        }
+
+        if (GpeEventInfo->WakeupCount == ACPI_UINT8_MAX)
+        {
+            Status = AE_LIMIT; /* Too many references */
+            goto UnlockAndExit;
+        }
+
+        /*
+         * Update the enable mask on the first wakeup reference. Wake GPEs
+         * are only hardware-enabled just before sleeping.
+         */
+        GpeEventInfo->WakeupCount++;
+        if (GpeEventInfo->WakeupCount == 1)
+        {
+            (void) AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
+        }
+    }
 
 UnlockAndExit:
+    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
     return_ACPI_STATUS (Status);
 }
 
-ACPI_EXPORT_SYMBOL (AcpiSetGpeType)
+ACPI_EXPORT_SYMBOL (AcpiEnableGpe)
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiEnableGpe
+ * FUNCTION:    AcpiDisableGpe
  *
- * PARAMETERS:  GpeDevice       - Parent GPE Device
+ * PARAMETERS:  GpeDevice       - Parent GPE Device. NULL for GPE0/GPE1
  *              GpeNumber       - GPE level within the GPE block
- *              Flags           - Just enable, or also wake enable?
- *                                Called from ISR or not
+ *              GpeType         - ACPI_GPE_TYPE_RUNTIME or ACPI_GPE_TYPE_WAKE
+ *                                or both
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Enable an ACPI event (general purpose)
+ * DESCRIPTION: Remove a reference to a GPE. When the last reference is
+ *              removed, only then is the GPE disabled (for runtime GPEs), or
+ *              the GPE mask bit disabled (for wake GPEs)
  *
  ******************************************************************************/
 
 ACPI_STATUS
-AcpiEnableGpe (
+AcpiDisableGpe (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT32                  Flags)
+    UINT8                   GpeType)
 {
     ACPI_STATUS             Status = AE_OK;
     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
+    ACPI_CPU_FLAGS          Flags;
 
 
-    ACPI_FUNCTION_TRACE (AcpiEnableGpe);
+    ACPI_FUNCTION_TRACE (AcpiDisableGpe);
 
 
-    /* Use semaphore lock if not executing at interrupt level */
+    /* Parameter validation */
 
-    if (Flags & ACPI_NOT_ISR)
+    if (!GpeType || (GpeType & ~ACPI_GPE_TYPE_WAKE_RUN))
     {
-        Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
-        if (ACPI_FAILURE (Status))
-        {
-            return_ACPI_STATUS (Status);
-        }
+        return_ACPI_STATUS (AE_BAD_PARAMETER);
     }
 
+    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
+
     /* Ensure that we have a valid GPE number */
 
     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
@@ -405,59 +458,92 @@ AcpiEnableGpe (
         goto UnlockAndExit;
     }
 
-    /* Perform the enable */
+    /* Hardware-disable a runtime GPE on removal of the last reference */
+
+    if (GpeType & ACPI_GPE_TYPE_RUNTIME)
+    {
+        if (!GpeEventInfo->RuntimeCount)
+        {
+            Status = AE_LIMIT; /* There are no references to remove */
+            goto UnlockAndExit;
+        }
 
-    Status = AcpiEvEnableGpe (GpeEventInfo, TRUE);
+        GpeEventInfo->RuntimeCount--;
+        if (!GpeEventInfo->RuntimeCount)
+        {
+            Status = AcpiEvDisableGpe (GpeEventInfo);
+            if (ACPI_FAILURE (Status))
+            {
+                GpeEventInfo->RuntimeCount++;
+                goto UnlockAndExit;
+            }
+        }
+    }
 
-UnlockAndExit:
-    if (Flags & ACPI_NOT_ISR)
+    /*
+     * Update masks for wake GPE on removal of the last reference.
+     * No need to hardware-disable wake GPEs here, they are not currently
+     * enabled.
+     */
+    if (GpeType & ACPI_GPE_TYPE_WAKE)
     {
-        (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
+        if (!GpeEventInfo->WakeupCount)
+        {
+            Status = AE_LIMIT; /* There are no references to remove */
+            goto UnlockAndExit;
+        }
+
+        GpeEventInfo->WakeupCount--;
+        if (!GpeEventInfo->WakeupCount)
+        {
+            (void) AcpiEvUpdateGpeEnableMasks (GpeEventInfo);
+        }
     }
+
+
+UnlockAndExit:
+    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
     return_ACPI_STATUS (Status);
 }
 
-ACPI_EXPORT_SYMBOL (AcpiEnableGpe)
+ACPI_EXPORT_SYMBOL (AcpiDisableGpe)
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDisableGpe
+ * FUNCTION:    AcpiSetGpe
  *
- * PARAMETERS:  GpeDevice       - Parent GPE Device
+ * PARAMETERS:  GpeDevice       - Parent GPE Device. NULL for GPE0/GPE1
  *              GpeNumber       - GPE level within the GPE block
- *              Flags           - Just disable, or also wake disable?
- *                                Called from ISR or not
+ *              Action          - ACPI_GPE_ENABLE or ACPI_GPE_DISABLE
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Disable an ACPI event (general purpose)
+ * DESCRIPTION: Enable or disable an individual GPE. This function bypasses
+ *              the reference count mechanism used in the AcpiEnableGpe and
+ *              AcpiDisableGpe interfaces -- and should be used with care.
+ *
+ * Note: Typically used to disable a runtime GPE for short period of time,
+ * then re-enable it, without disturbing the existing reference counts. This
+ * is useful, for example, in the Embedded Controller (EC) driver.
  *
  ******************************************************************************/
 
 ACPI_STATUS
-AcpiDisableGpe (
+AcpiSetGpe (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT32                  Flags)
+    UINT8                   Action)
 {
-    ACPI_STATUS             Status = AE_OK;
     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
+    ACPI_STATUS             Status;
+    ACPI_CPU_FLAGS          Flags;
 
 
-    ACPI_FUNCTION_TRACE (AcpiDisableGpe);
-
+    ACPI_FUNCTION_TRACE (AcpiSetGpe);
 
-    /* Use semaphore lock if not executing at interrupt level */
 
-    if (Flags & ACPI_NOT_ISR)
-    {
-        Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
-        if (ACPI_FAILURE (Status))
-        {
-            return_ACPI_STATUS (Status);
-        }
-    }
+    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
     /* Ensure that we have a valid GPE number */
 
@@ -468,17 +554,29 @@ AcpiDisableGpe (
         goto UnlockAndExit;
     }
 
-    Status = AcpiEvDisableGpe (GpeEventInfo);
+    /* Perform the action */
 
-UnlockAndExit:
-    if (Flags & ACPI_NOT_ISR)
+    switch (Action)
     {
-        (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
+    case ACPI_GPE_ENABLE:
+        Status = AcpiEvEnableGpe (GpeEventInfo);
+        break;
+
+    case ACPI_GPE_DISABLE:
+        Status = AcpiEvDisableGpe (GpeEventInfo);
+        break;
+
+    default:
+        Status = AE_BAD_PARAMETER;
+        break;
     }
+
+UnlockAndExit:
+    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
     return_ACPI_STATUS (Status);
 }
 
-ACPI_EXPORT_SYMBOL (AcpiDisableGpe)
+ACPI_EXPORT_SYMBOL (AcpiSetGpe)
 
 
 /*******************************************************************************
@@ -592,9 +690,8 @@ ACPI_EXPORT_SYMBOL (AcpiClearEvent)
  *
  * FUNCTION:    AcpiClearGpe
  *
- * PARAMETERS:  GpeDevice       - Parent GPE Device
+ * PARAMETERS:  GpeDevice       - Parent GPE Device. NULL for GPE0/GPE1
  *              GpeNumber       - GPE level within the GPE block
- *              Flags           - Called from an ISR or not
  *
  * RETURN:      Status
  *
@@ -605,26 +702,17 @@ ACPI_EXPORT_SYMBOL (AcpiClearEvent)
 ACPI_STATUS
 AcpiClearGpe (
     ACPI_HANDLE             GpeDevice,
-    UINT32                  GpeNumber,
-    UINT32                  Flags)
+    UINT32                  GpeNumber)
 {
     ACPI_STATUS             Status = AE_OK;
     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
+    ACPI_CPU_FLAGS          Flags;
 
 
     ACPI_FUNCTION_TRACE (AcpiClearGpe);
 
 
-    /* Use semaphore lock if not executing at interrupt level */
-
-    if (Flags & ACPI_NOT_ISR)
-    {
-        Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
-        if (ACPI_FAILURE (Status))
-        {
-            return_ACPI_STATUS (Status);
-        }
-    }
+    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
     /* Ensure that we have a valid GPE number */
 
@@ -638,10 +726,7 @@ AcpiClearGpe (
     Status = AcpiHwClearGpe (GpeEventInfo);
 
 UnlockAndExit:
-    if (Flags & ACPI_NOT_ISR)
-    {
-        (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
-    }
+    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
     return_ACPI_STATUS (Status);
 }
 
@@ -700,9 +785,8 @@ ACPI_EXPORT_SYMBOL (AcpiGetEventStatus)
  *
  * FUNCTION:    AcpiGetGpeStatus
  *
- * PARAMETERS:  GpeDevice       - Parent GPE Device
+ * PARAMETERS:  GpeDevice       - Parent GPE Device. NULL for GPE0/GPE1
  *              GpeNumber       - GPE level within the GPE block
- *              Flags           - Called from an ISR or not
  *              EventStatus     - Where the current status of the event will
  *                                be returned
  *
@@ -716,26 +800,17 @@ ACPI_STATUS
 AcpiGetGpeStatus (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT32                  Flags,
     ACPI_EVENT_STATUS       *EventStatus)
 {
     ACPI_STATUS             Status = AE_OK;
     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
+    ACPI_CPU_FLAGS          Flags;
 
 
     ACPI_FUNCTION_TRACE (AcpiGetGpeStatus);
 
 
-    /* Use semaphore lock if not executing at interrupt level */
-
-    if (Flags & ACPI_NOT_ISR)
-    {
-        Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
-        if (ACPI_FAILURE (Status))
-        {
-            return_ACPI_STATUS (Status);
-        }
-    }
+    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);
 
     /* Ensure that we have a valid GPE number */
 
@@ -751,10 +826,7 @@ AcpiGetGpeStatus (
     Status = AcpiHwGetGpeStatus (GpeEventInfo, EventStatus);
 
 UnlockAndExit:
-    if (Flags & ACPI_NOT_ISR)
-    {
-        (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
-    }
+    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);
     return_ACPI_STATUS (Status);
 }
 
@@ -823,21 +895,15 @@ AcpiInstallGpeBlock (
         goto UnlockAndExit;
     }
 
-    /* Run the _PRW methods and enable the GPEs */
-
-    Status = AcpiEvInitializeGpeBlock (Node, GpeBlock);
-    if (ACPI_FAILURE (Status))
-    {
-        goto UnlockAndExit;
-    }
-
-    /* Get the DeviceObject attached to the node */
+    /* Install block in the DeviceObject attached to the node */
 
     ObjDesc = AcpiNsGetAttachedObject (Node);
     if (!ObjDesc)
     {
-        /* No object, create a new one */
-
+        /*
+         * No object, create a new one (Device nodes do not always have
+         * an attached object)
+         */
         ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_DEVICE);
         if (!ObjDesc)
         {
@@ -850,17 +916,20 @@ AcpiInstallGpeBlock (
         /* Remove local reference to the object */
 
         AcpiUtRemoveReference (ObjDesc);
-
         if (ACPI_FAILURE (Status))
         {
             goto UnlockAndExit;
         }
     }
 
-    /* Install the GPE block in the DeviceObject */
+    /* Now install the GPE block in the DeviceObject */
 
     ObjDesc->Device.GpeBlock = GpeBlock;
 
+    /* Run the _PRW methods and enable the runtime GPEs in the new block */
+
+    Status = AcpiEvInitializeGpeBlock (Node, GpeBlock);
+
 
 UnlockAndExit:
     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
@@ -1018,8 +1087,7 @@ AcpiEvGetGpeDevice (
 
     /* Increment Index by the number of GPEs in this block */
 
-    Info->NextBlockBaseIndex +=
-        (GpeBlock->RegisterCount * ACPI_GPE_REGISTER_WIDTH);
+    Info->NextBlockBaseIndex += GpeBlock->GpeCount;
 
     if (Info->Index < Info->NextBlockBaseIndex)
     {
diff --git a/sys/contrib/dev/acpica/executer/exdebug.c b/sys/contrib/dev/acpica/executer/exdebug.c
index 0331d38190aa..084c6cb2cc52 100644
--- a/sys/contrib/dev/acpica/executer/exdebug.c
+++ b/sys/contrib/dev/acpica/executer/exdebug.c
@@ -235,7 +235,7 @@ AcpiExDoDebugObject (
 
         AcpiOsPrintf ("[0x%.2X]\n", (UINT32) SourceDesc->Buffer.Length);
         AcpiUtDumpBuffer2 (SourceDesc->Buffer.Pointer,
-            (SourceDesc->Buffer.Length < 256) ? 
+            (SourceDesc->Buffer.Length < 256) ?
                 SourceDesc->Buffer.Length : 256, DB_BYTE_DISPLAY);
         break;
 
diff --git a/sys/contrib/dev/acpica/executer/exmutex.c b/sys/contrib/dev/acpica/executer/exmutex.c
index 5787b34127f3..315ad100e831 100644
--- a/sys/contrib/dev/acpica/executer/exmutex.c
+++ b/sys/contrib/dev/acpica/executer/exmutex.c
@@ -168,10 +168,10 @@ AcpiExUnlinkMutex (
         (ObjDesc->Mutex.Prev)->Mutex.Next = ObjDesc->Mutex.Next;
 
         /*
-         * Migrate the previous sync level associated with this mutex to the
-         * previous mutex on the list so that it may be preserved. This handles
-         * the case where several mutexes have been acquired at the same level,
-         * but are not released in opposite order.
+         * Migrate the previous sync level associated with this mutex to
+         * the previous mutex on the list so that it may be preserved.
+         * This handles the case where several mutexes have been acquired
+         * at the same level, but are not released in opposite order.
          */
         (ObjDesc->Mutex.Prev)->Mutex.OriginalSyncLevel =
             ObjDesc->Mutex.OriginalSyncLevel;
@@ -187,8 +187,8 @@ AcpiExUnlinkMutex (
  *
  * FUNCTION:    AcpiExLinkMutex
  *
- * PARAMETERS:  ObjDesc         - The mutex to be linked
- *              Thread          - Current executing thread object
+ * PARAMETERS:  ObjDesc             - The mutex to be linked
+ *              Thread              - Current executing thread object
  *
  * RETURN:      None
  *
@@ -228,9 +228,9 @@ AcpiExLinkMutex (
  *
  * FUNCTION:    AcpiExAcquireMutexObject
  *
- * PARAMETERS:  TimeDesc            - Timeout in milliseconds
+ * PARAMETERS:  Timeout             - Timeout in milliseconds
  *              ObjDesc             - Mutex object
- *              Thread              - Current thread state
+ *              ThreadId            - Current thread state
  *
  * RETURN:      Status
  *
@@ -337,11 +337,12 @@ AcpiExAcquireMutex (
         return_ACPI_STATUS (AE_BAD_PARAMETER);
     }
 
-    /* Must have a valid thread ID */
+    /* Must have a valid thread state struct */
 
     if (!WalkState->Thread)
     {
-        ACPI_ERROR ((AE_INFO, "Cannot acquire Mutex [%4.4s], null thread info",
+        ACPI_ERROR ((AE_INFO,
+            "Cannot acquire Mutex [%4.4s], null thread info",
             AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
         return_ACPI_STATUS (AE_AML_INTERNAL);
     }
@@ -488,7 +489,8 @@ AcpiExReleaseMutex (
 
     if (!OwnerThread)
     {
-        ACPI_ERROR ((AE_INFO, "Cannot release Mutex [%4.4s], not acquired",
+        ACPI_ERROR ((AE_INFO,
+            "Cannot release Mutex [%4.4s], not acquired",
             AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
         return_ACPI_STATUS (AE_AML_MUTEX_NOT_ACQUIRED);
     }
@@ -497,7 +499,8 @@ AcpiExReleaseMutex (
 
     if (!WalkState->Thread)
     {
-        ACPI_ERROR ((AE_INFO, "Cannot release Mutex [%4.4s], null thread info",
+        ACPI_ERROR ((AE_INFO,
+            "Cannot release Mutex [%4.4s], null thread info",
             AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
         return_ACPI_STATUS (AE_AML_INTERNAL);
     }
@@ -553,6 +556,7 @@ AcpiExReleaseMutex (
 
         OwnerThread->CurrentSyncLevel = PreviousSyncLevel;
     }
+
     return_ACPI_STATUS (Status);
 }
 
@@ -561,7 +565,7 @@ AcpiExReleaseMutex (
  *
  * FUNCTION:    AcpiExReleaseAllMutexes
  *
- * PARAMETERS:  Thread          - Current executing thread object
+ * PARAMETERS:  Thread              - Current executing thread object
  *
  * RETURN:      Status
  *
@@ -620,5 +624,3 @@ AcpiExReleaseAllMutexes (
         Thread->CurrentSyncLevel = ObjDesc->Mutex.OriginalSyncLevel;
     }
 }
-
-
diff --git a/sys/contrib/dev/acpica/executer/exoparg2.c b/sys/contrib/dev/acpica/executer/exoparg2.c
index b0aca013f4a2..2bedf5a1c9d7 100644
--- a/sys/contrib/dev/acpica/executer/exoparg2.c
+++ b/sys/contrib/dev/acpica/executer/exoparg2.c
@@ -206,33 +206,6 @@ AcpiExOpcode_2A_0T_0R (
             break;
         }
 
-#ifdef ACPI_GPE_NOTIFY_CHECK
-        /*
-         * GPE method wake/notify check.  Here, we want to ensure that we
-         * don't receive any "DeviceWake" Notifies from a GPE _Lxx or _Exx
-         * GPE method during system runtime.  If we do, the GPE is marked
-         * as "wake-only" and disabled.
-         *
-         * 1) Is the Notify() value == DeviceWake?
-         * 2) Is this a GPE deferred method?  (An _Lxx or _Exx method)
-         * 3) Did the original GPE happen at system runtime?
-         *    (versus during wake)
-         *
-         * If all three cases are true, this is a wake-only GPE that should
-         * be disabled at runtime.
-         */
-        if (Value == 2)     /* DeviceWake */
-        {
-            Status = AcpiEvCheckForWakeOnlyGpe (WalkState->GpeEventInfo);
-            if (ACPI_FAILURE (Status))
-            {
-                /* AE_WAKE_ONLY_GPE only error, means ignore this notify */
-
-                return_ACPI_STATUS (AE_OK)
-            }
-        }
-#endif
-
         /*
          * Dispatch the notify to the appropriate handler
          * NOTE: the request is queued for execution after this method
diff --git a/sys/contrib/dev/acpica/executer/exregion.c b/sys/contrib/dev/acpica/executer/exregion.c
index d25dff513e0e..77a500c722eb 100644
--- a/sys/contrib/dev/acpica/executer/exregion.c
+++ b/sys/contrib/dev/acpica/executer/exregion.c
@@ -608,8 +608,10 @@ AcpiExDataTableSpaceHandler (
     ACPI_FUNCTION_TRACE (ExDataTableSpaceHandler);
 
 
-    /* Perform the memory read or write */
-
+    /*
+     * Perform the memory read or write. The BitWidth was already
+     * validated.
+     */
     switch (Function)
     {
     case ACPI_READ:
@@ -619,9 +621,14 @@ AcpiExDataTableSpaceHandler (
         break;
 
     case ACPI_WRITE:
+
+        ACPI_MEMCPY (ACPI_PHYSADDR_TO_PTR (Address), ACPI_CAST_PTR (char, Value),
+            ACPI_DIV_8 (BitWidth));
+        break;
+
     default:
 
-        return_ACPI_STATUS (AE_SUPPORT);
+        return_ACPI_STATUS (AE_BAD_PARAMETER);
     }
 
     return_ACPI_STATUS (AE_OK);
diff --git a/sys/contrib/dev/acpica/include/acevents.h b/sys/contrib/dev/acpica/include/acevents.h
index 567ac1ec0e13..4d945eff8aad 100644
--- a/sys/contrib/dev/acpica/include/acevents.h
+++ b/sys/contrib/dev/acpica/include/acevents.h
@@ -171,13 +171,11 @@ AcpiEvQueueNotifyRequest (
  */
 ACPI_STATUS
 AcpiEvUpdateGpeEnableMasks (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo,
-    UINT8                   Type);
+    ACPI_GPE_EVENT_INFO     *GpeEventInfo);
 
 ACPI_STATUS
 AcpiEvEnableGpe (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo,
-    BOOLEAN                 WriteToHardware);
+    ACPI_GPE_EVENT_INFO     *GpeEventInfo);
 
 ACPI_STATUS
 AcpiEvDisableGpe (
@@ -188,6 +186,11 @@ AcpiEvGetGpeEventInfo (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber);
 
+ACPI_GPE_EVENT_INFO *
+AcpiEvLowGetGpeInfo (
+    UINT32                  GpeNumber,
+    ACPI_GPE_BLOCK_INFO     *GpeBlock);
+
 
 /*
  * evgpeblk
@@ -235,15 +238,6 @@ AcpiEvGpeDetect (
     ACPI_GPE_XRUPT_INFO     *GpeXruptList);
 
 ACPI_STATUS
-AcpiEvSetGpeType (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo,
-    UINT8                   Type);
-
-ACPI_STATUS
-AcpiEvCheckForWakeOnlyGpe (
-    ACPI_GPE_EVENT_INFO     *GpeEventInfo);
-
-ACPI_STATUS
 AcpiEvGpeInitialize (
     void);
 
diff --git a/sys/contrib/dev/acpica/include/acexcep.h b/sys/contrib/dev/acpica/include/acexcep.h
index 89fe5c66898f..a46de7d82f5e 100644
--- a/sys/contrib/dev/acpica/include/acexcep.h
+++ b/sys/contrib/dev/acpica/include/acexcep.h
@@ -162,7 +162,7 @@
 #define AE_NO_GLOBAL_LOCK               (ACPI_STATUS) (0x0017 | AE_CODE_ENVIRONMENTAL)
 #define AE_ABORT_METHOD                 (ACPI_STATUS) (0x0018 | AE_CODE_ENVIRONMENTAL)
 #define AE_SAME_HANDLER                 (ACPI_STATUS) (0x0019 | AE_CODE_ENVIRONMENTAL)
-#define AE_WAKE_ONLY_GPE                (ACPI_STATUS) (0x001A | AE_CODE_ENVIRONMENTAL)
+#define AE_NO_HANDLER                   (ACPI_STATUS) (0x001A | AE_CODE_ENVIRONMENTAL)
 #define AE_OWNER_ID_LIMIT               (ACPI_STATUS) (0x001B | AE_CODE_ENVIRONMENTAL)
 
 #define AE_CODE_ENV_MAX                 0x001B
diff --git a/sys/contrib/dev/acpica/include/acglobal.h b/sys/contrib/dev/acpica/include/acglobal.h
index 0df0c2719ecf..4f0769e6f676 100644
--- a/sys/contrib/dev/acpica/include/acglobal.h
+++ b/sys/contrib/dev/acpica/include/acglobal.h
@@ -191,6 +191,14 @@ UINT8       ACPI_INIT_GLOBAL (AcpiGbl_UseDefaultRegisterWidths, TRUE);
  */
 UINT8       ACPI_INIT_GLOBAL (AcpiGbl_EnableAmlDebugObject, FALSE);
 
+/*
+ * Optionally copy the entire DSDT to local memory (instead of simply
+ * mapping it.) There are some BIOSs that corrupt or replace the original
+ * DSDT, creating the need for this option. Default is FALSE, do not copy
+ * the DSDT.
+ */
+UINT8       ACPI_INIT_GLOBAL (AcpiGbl_CopyDsdtLocally, FALSE);
+
 
 /* AcpiGbl_FADT is a local copy of the FADT, converted to a common format. */
 
@@ -223,6 +231,11 @@ ACPI_EXTERN ACPI_GENERIC_ADDRESS        AcpiGbl_XPm1aEnable;
 ACPI_EXTERN ACPI_GENERIC_ADDRESS        AcpiGbl_XPm1bStatus;
 ACPI_EXTERN ACPI_GENERIC_ADDRESS        AcpiGbl_XPm1bEnable;
 
+/* DSDT information. Used to check for DSDT corruption */
+
+ACPI_EXTERN ACPI_TABLE_HEADER          *AcpiGbl_DSDT;
+ACPI_EXTERN ACPI_TABLE_HEADER           AcpiGbl_OriginalDsdtHeader;
+
 /*
  * Handle both ACPI 1.0 and ACPI 2.0 Integer widths. The integer width is
  * determined by the revision of the DSDT: If the DSDT revision is less than
diff --git a/sys/contrib/dev/acpica/include/aclocal.h b/sys/contrib/dev/acpica/include/aclocal.h
index 0aeacff6c525..8818a6ea9b53 100644
--- a/sys/contrib/dev/acpica/include/aclocal.h
+++ b/sys/contrib/dev/acpica/include/aclocal.h
@@ -561,6 +561,8 @@ typedef struct acpi_gpe_event_info
     struct acpi_gpe_register_info   *RegisterInfo;  /* Backpointer to register info */
     UINT8                           Flags;          /* Misc info about this GPE */
     UINT8                           GpeNumber;      /* This GPE */
+    UINT8                           RuntimeCount;   /* References to a run GPE */
+    UINT8                           WakeupCount;    /* References to a wake GPE */
 
 } ACPI_GPE_EVENT_INFO;
 
@@ -590,6 +592,7 @@ typedef struct acpi_gpe_block_info
     ACPI_GPE_EVENT_INFO             *EventInfo;     /* One for each GPE */
     ACPI_GENERIC_ADDRESS            BlockAddress;   /* Base address of the block */
     UINT32                          RegisterCount;  /* Number of register pairs in block */
+    UINT16                          GpeCount;       /* Number of individual GPEs in block */
     UINT8                           BlockBaseNumber;/* Base GPE number for this block */
 
 } ACPI_GPE_BLOCK_INFO;
diff --git a/sys/contrib/dev/acpica/include/acpixf.h b/sys/contrib/dev/acpica/include/acpixf.h
index da00928be8b1..5562fa0215d5 100644
--- a/sys/contrib/dev/acpica/include/acpixf.h
+++ b/sys/contrib/dev/acpica/include/acpixf.h
@@ -120,7 +120,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20100304
+#define ACPI_CA_VERSION                 0x20100331
 
 #include <contrib/dev/acpica/include/actypes.h>
 #include <contrib/dev/acpica/include/actbl.h>
@@ -146,6 +146,7 @@ extern UINT8                AcpiGbl_UseDefaultRegisterWidths;
 extern ACPI_NAME            AcpiGbl_TraceMethodName;
 extern UINT32               AcpiGbl_TraceFlags;
 extern UINT8                AcpiGbl_EnableAmlDebugObject;
+extern UINT8                AcpiGbl_CopyDsdtLocally;
 
 
 /*
@@ -463,34 +464,32 @@ AcpiGetEventStatus (
  * GPE Interfaces
  */
 ACPI_STATUS
-AcpiSetGpeType (
+AcpiSetGpe (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT8                   Type);
+    UINT8                   Action);
 
 ACPI_STATUS
 AcpiEnableGpe (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT32                  Flags);
+    UINT8                   GpeType);
 
 ACPI_STATUS
 AcpiDisableGpe (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT32                  Flags);
+    UINT8                   GpeType);
 
 ACPI_STATUS
 AcpiClearGpe (
     ACPI_HANDLE             GpeDevice,
-    UINT32                  GpeNumber,
-    UINT32                  Flags);
+    UINT32                  GpeNumber);
 
 ACPI_STATUS
 AcpiGetGpeStatus (
     ACPI_HANDLE             GpeDevice,
     UINT32                  GpeNumber,
-    UINT32                  Flags,
     ACPI_EVENT_STATUS       *EventStatus);
 
 ACPI_STATUS
diff --git a/sys/contrib/dev/acpica/include/actables.h b/sys/contrib/dev/acpica/include/actables.h
index 54fdaae9b1a7..9f1c4f00e5a8 100644
--- a/sys/contrib/dev/acpica/include/actables.h
+++ b/sys/contrib/dev/acpica/include/actables.h
@@ -231,6 +231,14 @@ AcpiTbVerifyChecksum (
     UINT32                  Length);
 
 void
+AcpiTbCheckDsdtHeader (
+    void);
+
+ACPI_TABLE_HEADER *
+AcpiTbCopyDsdt (
+    UINT32                  TableIndex);
+
+void
 AcpiTbInstallTable (
     ACPI_PHYSICAL_ADDRESS   Address,
     char                    *Signature,
diff --git a/sys/contrib/dev/acpica/include/actypes.h b/sys/contrib/dev/acpica/include/actypes.h
index 8d0d06ad62ce..3c0626ab1e35 100644
--- a/sys/contrib/dev/acpica/include/actypes.h
+++ b/sys/contrib/dev/acpica/include/actypes.h
@@ -742,53 +742,42 @@ typedef UINT32                          ACPI_EVENT_STATUS;
 #define ACPI_GPE_MAX                    0xFF
 #define ACPI_NUM_GPE                    256
 
+/* Actions for AcpiSetGpe */
+
 #define ACPI_GPE_ENABLE                 0
 #define ACPI_GPE_DISABLE                1
 
+/* GpeTypes for AcpiEnableGpe and AcpiDisableGpe */
+
+#define ACPI_GPE_TYPE_WAKE              (UINT8) 0x01
+#define ACPI_GPE_TYPE_RUNTIME           (UINT8) 0x02
+#define ACPI_GPE_TYPE_WAKE_RUN          (UINT8) 0x03
 
 /*
  * GPE info flags - Per GPE
- * +-+-+-+---+---+-+
- * |7|6|5|4:3|2:1|0|
- * +-+-+-+---+---+-+
- *  | | |  |   |  |
- *  | | |  |   |  +--- Interrupt type: Edge or Level Triggered
- *  | | |  |   +--- Type: Wake-only, Runtime-only, or wake/runtime
- *  | | |  +--- Type of dispatch -- to method, handler, or none
- *  | | +--- Enabled for runtime?
- *  | +--- Enabled for wake?
- *  +--- Unused
+ * +-------+---+-+-+
+ * |  7:4  |3:2|1|0|
+ * +-------+---+-+-+
+ *     |     |  | |
+ *     |     |  | +--- Interrupt type: edge or level triggered
+ *     |     |  +----- GPE can wake the system
+ *     |     +-------- Type of dispatch:to method, handler, or none
+ *     +-------------- <Reserved>
  */
 #define ACPI_GPE_XRUPT_TYPE_MASK        (UINT8) 0x01
 #define ACPI_GPE_LEVEL_TRIGGERED        (UINT8) 0x01
 #define ACPI_GPE_EDGE_TRIGGERED         (UINT8) 0x00
 
-#define ACPI_GPE_TYPE_MASK              (UINT8) 0x06
-#define ACPI_GPE_TYPE_WAKE_RUN          (UINT8) 0x06
-#define ACPI_GPE_TYPE_WAKE              (UINT8) 0x02
-#define ACPI_GPE_TYPE_RUNTIME           (UINT8) 0x04    /* Default */
-
-#define ACPI_GPE_DISPATCH_MASK          (UINT8) 0x18
-#define ACPI_GPE_DISPATCH_HANDLER       (UINT8) 0x08
-#define ACPI_GPE_DISPATCH_METHOD        (UINT8) 0x10
-#define ACPI_GPE_DISPATCH_NOT_USED      (UINT8) 0x00    /* Default */
+#define ACPI_GPE_CAN_WAKE               (UINT8) 0x02
 
-#define ACPI_GPE_RUN_ENABLE_MASK        (UINT8) 0x20
-#define ACPI_GPE_RUN_ENABLED            (UINT8) 0x20
-#define ACPI_GPE_RUN_DISABLED           (UINT8) 0x00    /* Default */
-
-#define ACPI_GPE_WAKE_ENABLE_MASK       (UINT8) 0x40
-#define ACPI_GPE_WAKE_ENABLED           (UINT8) 0x40
-#define ACPI_GPE_WAKE_DISABLED          (UINT8) 0x00    /* Default */
-
-#define ACPI_GPE_ENABLE_MASK            (UINT8) 0x60    /* Both run/wake */
+#define ACPI_GPE_DISPATCH_MASK          (UINT8) 0x0C
+#define ACPI_GPE_DISPATCH_HANDLER       (UINT8) 0x04
+#define ACPI_GPE_DISPATCH_METHOD        (UINT8) 0x08
+#define ACPI_GPE_DISPATCH_NOT_USED      (UINT8) 0x00
 
 /*
  * Flags for GPE and Lock interfaces
  */
-#define ACPI_EVENT_WAKE_ENABLE          0x2             /* AcpiGpeEnable */
-#define ACPI_EVENT_WAKE_DISABLE         0x2             /* AcpiGpeDisable */
-
 #define ACPI_NOT_ISR                    0x1
 #define ACPI_ISR                        0x0
 
diff --git a/sys/contrib/dev/acpica/include/platform/acfreebsd.h b/sys/contrib/dev/acpica/include/platform/acfreebsd.h
index 20ec3a20bf95..c835aaf665d8 100644
--- a/sys/contrib/dev/acpica/include/platform/acfreebsd.h
+++ b/sys/contrib/dev/acpica/include/platform/acfreebsd.h
@@ -114,7 +114,7 @@
  *****************************************************************************/
 
 #ifndef __ACFREEBSD_H__
-#define	__ACFREEBSD_H__
+#define __ACFREEBSD_H__
 
 
 /* FreeBSD uses GCC */
@@ -123,11 +123,11 @@
 #include <sys/types.h>
 #include <machine/acpica_machdep.h>
 
-#define	ACPI_UINTPTR_T		uintptr_t
+#define ACPI_UINTPTR_T      uintptr_t
 
-#define	ACPI_USE_DO_WHILE_0
-#define	ACPI_USE_LOCAL_CACHE
-#define	ACPI_USE_SYSTEM_CLIBRARY
+#define ACPI_USE_DO_WHILE_0
+#define ACPI_USE_LOCAL_CACHE
+#define ACPI_USE_SYSTEM_CLIBRARY
 
 #ifdef _KERNEL
 
@@ -139,18 +139,18 @@
 
 #include "opt_acpi.h"
 
-#define	ACPI_THREAD_ID		lwpid_t
-#define	ACPI_MUTEX_TYPE		ACPI_OSL_MUTEX
+#define ACPI_THREAD_ID      lwpid_t
+#define ACPI_MUTEX_TYPE     ACPI_OSL_MUTEX
 
 #ifdef ACPI_DEBUG
-#define	ACPI_DEBUG_OUTPUT	/* for backward compatibility */
-#define	ACPI_DISASSEMBLER
+#define ACPI_DEBUG_OUTPUT   /* for backward compatibility */
+#define ACPI_DISASSEMBLER
 #endif
 
 #ifdef ACPI_DEBUG_OUTPUT
 #include "opt_ddb.h"
 #ifdef DDB
-#define	ACPI_DEBUGGER
+#define ACPI_DEBUGGER
 #endif /* DDB */
 #endif /* ACPI_DEBUG_OUTPUT */
 
@@ -158,7 +158,7 @@
 #undef DEBUGGER_THREADING
 #endif /* DEBUGGER_THREADING */
 
-#define	DEBUGGER_THREADING	0	/* integrated with DDB */
+#define DEBUGGER_THREADING  0   /* integrated with DDB */
 
 #else /* _KERNEL */
 
@@ -166,12 +166,12 @@
 #include <ctype.h>
 #endif
 
-#define	ACPI_THREAD_ID		pthread_t
+#define ACPI_THREAD_ID      pthread_t
 
-#define	ACPI_USE_STANDARD_HEADERS
+#define ACPI_USE_STANDARD_HEADERS
 
-#define	ACPI_FLUSH_CPU_CACHE()
-#define	__cdecl
+#define ACPI_FLUSH_CPU_CACHE()
+#define __cdecl
 
 #endif /* _KERNEL */
 
diff --git a/sys/contrib/dev/acpica/parser/psxface.c b/sys/contrib/dev/acpica/parser/psxface.c
index e9fc45de6898..52a53c94d9aa 100644
--- a/sys/contrib/dev/acpica/parser/psxface.c
+++ b/sys/contrib/dev/acpica/parser/psxface.c
@@ -120,6 +120,7 @@
 #include <contrib/dev/acpica/include/acparser.h>
 #include <contrib/dev/acpica/include/acdispat.h>
 #include <contrib/dev/acpica/include/acinterp.h>
+#include <contrib/dev/acpica/include/actables.h>
 #include <contrib/dev/acpica/include/amlcode.h>
 
 
@@ -334,6 +335,10 @@ AcpiPsExecuteMethod (
     ACPI_FUNCTION_TRACE (PsExecuteMethod);
 
 
+    /* Quick validation of DSDT header */
+
+    AcpiTbCheckDsdtHeader ();
+
     /* Validate the Info and method Node */
 
     if (!Info || !Info->ResolvedNode)
diff --git a/sys/contrib/dev/acpica/tables/tbutils.c b/sys/contrib/dev/acpica/tables/tbutils.c
index 925cf15ccfb4..916c04e02415 100644
--- a/sys/contrib/dev/acpica/tables/tbutils.c
+++ b/sys/contrib/dev/acpica/tables/tbutils.c
@@ -395,6 +395,88 @@ AcpiTbChecksum (
 
 /*******************************************************************************
  *
+ * FUNCTION:    AcpiTbCheckDsdtHeader
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Quick compare to check validity of the DSDT. This will detect
+ *              if the DSDT has been replaced from outside the OS and/or if
+ *              the DSDT header has been corrupted.
+ *
+ ******************************************************************************/
+
+void
+AcpiTbCheckDsdtHeader (
+    void)
+{
+
+    /* Compare original length and checksum to current values */
+
+    if (AcpiGbl_OriginalDsdtHeader.Length != AcpiGbl_DSDT->Length ||
+        AcpiGbl_OriginalDsdtHeader.Checksum != AcpiGbl_DSDT->Checksum)
+    {
+        ACPI_ERROR ((AE_INFO,
+            "The DSDT has been corrupted or replaced - old, new headers below"));
+        AcpiTbPrintTableHeader (0, &AcpiGbl_OriginalDsdtHeader);
+        AcpiTbPrintTableHeader (0, AcpiGbl_DSDT);
+
+        /* Disable further error messages */
+
+        AcpiGbl_OriginalDsdtHeader.Length = AcpiGbl_DSDT->Length;
+        AcpiGbl_OriginalDsdtHeader.Checksum = AcpiGbl_DSDT->Checksum;
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiTbCopyDsdt
+ *
+ * PARAMETERS:  TableDesc           - Installed table to copy
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Implements a subsystem option to copy the DSDT to local memory.
+ *              Some very bad BIOSs are known to either corrupt the DSDT or
+ *              install a new, bad DSDT. This copy works around the problem.
+ *
+ ******************************************************************************/
+
+ACPI_TABLE_HEADER *
+AcpiTbCopyDsdt (
+    UINT32                  TableIndex)
+{
+    ACPI_TABLE_HEADER       *NewTable;
+    ACPI_TABLE_DESC         *TableDesc;
+
+
+    TableDesc = &AcpiGbl_RootTableList.Tables[TableIndex];
+
+    NewTable = ACPI_ALLOCATE (TableDesc->Length);
+    if (!NewTable)
+    {
+        ACPI_ERROR ((AE_INFO, "Could not copy DSDT of length 0x%X",
+            TableDesc->Length));
+        return (NULL);
+    }
+
+    ACPI_MEMCPY (NewTable, TableDesc->Pointer, TableDesc->Length);
+    AcpiTbDeleteTable (TableDesc);
+    TableDesc->Pointer = NewTable;
+    TableDesc->Flags = ACPI_TABLE_ORIGIN_ALLOCATED;
+
+    ACPI_INFO ((AE_INFO,
+        "Forced DSDT copy: length 0x%05X copied locally, original unmapped",
+        NewTable->Length));
+
+    return (NewTable);
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    AcpiTbInstallTable
  *
  * PARAMETERS:  Address                 - Physical address of DSDT or FACS
diff --git a/sys/contrib/dev/acpica/tables/tbxface.c b/sys/contrib/dev/acpica/tables/tbxface.c
index 26f9472c5aa0..e2eeb2e5aed3 100644
--- a/sys/contrib/dev/acpica/tables/tbxface.c
+++ b/sys/contrib/dev/acpica/tables/tbxface.c
@@ -265,6 +265,7 @@ AcpiReallocateRootTable (
 {
     ACPI_TABLE_DESC         *Tables;
     ACPI_SIZE               NewSize;
+    ACPI_SIZE               CurrentSize;
 
 
     ACPI_FUNCTION_TRACE (AcpiReallocateRootTable);
@@ -279,9 +280,15 @@ AcpiReallocateRootTable (
         return_ACPI_STATUS (AE_SUPPORT);
     }
 
-    NewSize = ((ACPI_SIZE) AcpiGbl_RootTableList.Count +
-                    ACPI_ROOT_TABLE_SIZE_INCREMENT) *
-                sizeof (ACPI_TABLE_DESC);
+    /*
+     * Get the current size of the root table and add the default
+     * increment to create the new table size.
+     */
+    CurrentSize = (ACPI_SIZE)
+        AcpiGbl_RootTableList.Count * sizeof (ACPI_TABLE_DESC);
+
+    NewSize = CurrentSize +
+        (ACPI_ROOT_TABLE_SIZE_INCREMENT * sizeof (ACPI_TABLE_DESC));
 
     /* Create new array and copy the old array */
 
@@ -291,10 +298,16 @@ AcpiReallocateRootTable (
         return_ACPI_STATUS (AE_NO_MEMORY);
     }
 
-    ACPI_MEMCPY (Tables, AcpiGbl_RootTableList.Tables, NewSize);
+    ACPI_MEMCPY (Tables, AcpiGbl_RootTableList.Tables, CurrentSize);
 
-    AcpiGbl_RootTableList.Size = AcpiGbl_RootTableList.Count;
+    /*
+     * Update the root table descriptor. The new size will be the current
+     * number of tables plus the increment, independent of the reserved
+     * size of the original table list.
+     */
     AcpiGbl_RootTableList.Tables = Tables;
+    AcpiGbl_RootTableList.Size =
+        AcpiGbl_RootTableList.Count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
     AcpiGbl_RootTableList.Flags =
         ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
 
@@ -534,6 +547,7 @@ AcpiTbLoadNamespace (
 {
     ACPI_STATUS             Status;
     UINT32                  i;
+    ACPI_TABLE_HEADER       *NewDsdt;
 
 
     ACPI_FUNCTION_TRACE (TbLoadNamespace);
@@ -542,30 +556,50 @@ AcpiTbLoadNamespace (
     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 
     /*
-     * Load the namespace. The DSDT is required, but any SSDT and PSDT tables
-     * are optional.
+     * Load the namespace. The DSDT is required, but any SSDT and
+     * PSDT tables are optional. Verify the DSDT.
      */
     if (!AcpiGbl_RootTableList.Count ||
         !ACPI_COMPARE_NAME (
             &(AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT].Signature),
             ACPI_SIG_DSDT) ||
-        ACPI_FAILURE (AcpiTbVerifyTable (
+         ACPI_FAILURE (AcpiTbVerifyTable (
             &AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT])))
     {
         Status = AE_NO_ACPI_TABLES;
         goto UnlockAndExit;
     }
 
-    /* A valid DSDT is required */
+    /*
+     * Save the DSDT pointer for simple access. This is the mapped memory
+     * address. We must take care here because the address of the .Tables
+     * array can change dynamically as tables are loaded at run-time. Note:
+     * .Pointer field is not validated until after call to AcpiTbVerifyTable.
+     */
+    AcpiGbl_DSDT = AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT].Pointer;
 
-    Status = AcpiTbVerifyTable (
-        &AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT]);
-    if (ACPI_FAILURE (Status))
+    /*
+     * Optionally copy the entire DSDT to local memory (instead of simply
+     * mapping it.) There are some BIOSs that corrupt or replace the original
+     * DSDT, creating the need for this option. Default is FALSE, do not copy
+     * the DSDT.
+     */
+    if (AcpiGbl_CopyDsdtLocally)
     {
-        Status = AE_NO_ACPI_TABLES;
-        goto UnlockAndExit;
+        NewDsdt = AcpiTbCopyDsdt (ACPI_TABLE_INDEX_DSDT);
+        if (NewDsdt)
+        {
+            AcpiGbl_DSDT = NewDsdt;
+        }
     }
 
+    /*
+     * Save the original DSDT header for detection of table corruption
+     * and/or replacement of the DSDT from outside the OS.
+     */
+    ACPI_MEMCPY (&AcpiGbl_OriginalDsdtHeader, AcpiGbl_DSDT,
+        sizeof (ACPI_TABLE_HEADER));
+
     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 
     /* Load and parse tables */
diff --git a/sys/contrib/dev/acpica/utilities/utglobal.c b/sys/contrib/dev/acpica/utilities/utglobal.c
index df32fc069f86..85a93fe77a6e 100644
--- a/sys/contrib/dev/acpica/utilities/utglobal.c
+++ b/sys/contrib/dev/acpica/utilities/utglobal.c
@@ -916,6 +916,7 @@ AcpiUtInitGlobals (
 
     /* Miscellaneous variables */
 
+    AcpiGbl_DSDT                        = NULL;
     AcpiGbl_CmSingleStep                = FALSE;
     AcpiGbl_DbTerminateThreads          = FALSE;
     AcpiGbl_Shutdown                    = FALSE;
diff --git a/sys/contrib/dev/iwn/LICENSE b/sys/contrib/dev/iwn/LICENSE
index 74a3f7e53089..82165b8f5f81 100644
--- a/sys/contrib/dev/iwn/LICENSE
+++ b/sys/contrib/dev/iwn/LICENSE
@@ -1,39 +1,39 @@
-Copyright (c) 2006-2009, Intel Corporation.
+Copyright (c) 2006-2010, Intel Corporation.
 All rights reserved.
 
-Redistribution.  Redistribution and use in binary form, without 
-modification, are permitted provided that the following conditions are 
+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 
+* 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 
+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 
+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.
diff --git a/sys/contrib/dev/iwn/iwlwifi-6000-9.176.4.1.fw.uu b/sys/contrib/dev/iwn/iwlwifi-6000-9.176.4.1.fw.uu
deleted file mode 100644
index 636a7ba4b266..000000000000
--- a/sys/contrib/dev/iwn/iwlwifi-6000-9.176.4.1.fw.uu
+++ /dev/null
@@ -1,8112 +0,0 @@
-Copyright (c) 2006-2009, 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-6000-9.176.4.1.fw.uu
-AQSwCds9AAAUQwIAAEABAKhBAgAAQAEAAAAAACAggA8AAEAAaSAAAGkgQABpIAAAaSBAACAggA8A
-AOgAaSAAAGkgQABpIAAAaSBAACAggA8AAHgGaSAAAGkgQABpIAAASiAAAEohAABKIgAASiMAAEok
-AABKJQAASiYAAEonAABKIAAQSiEAEEoiABBKIwAQSiQAEEolABBKJgAQSicAEEogACBKIQAgSiIA
-IEojACBKJAAgSiUAIEomACBKJwAgSiAAMEohADAKJIA/gQAAQEEsnDBALJwwQiQcNAoigD+AADBr
-CiMAN/4PAABKJgBwaSBAAEomAHBKJgBwSiYAcEomAHAAFgBwgABkBEB4ICBAhwAAAAAAAAAAAADh
-wOHB4cLPcKAAyB8WEAGGz3KAAJh/IKISEAGGIaITEAGGIqIUEAGGI6IVEAGGJKIkEAGGJqLPcZ8A
-uP9WoYoh/w8SGFiAExhYgBQYWIAVGFiAJBhYgMHCwcHBwCAgQIcMyM9yoADIHw4aGIANyA8aGIAO
-yBAaGIAPEgE2AcgkeBEaGIAQyC0aGIDgfuHE/BzIvvwcSL7hwOHB4cLhw/wcCLH8HEix/ByIsfwc
-yLH8HAiy/BxIsvwciLL8HMiy/BwIv2okgBDhxGokwBDhxPHAz3CgANAbFIDPcYAAYAQEIICPz1EE
-4QChCvIvKQEAz3CAAOQN8CBAAEB42v/RwMHEayTAEMHEaySAEMHEn3QEFAs0BBQKNAQUCTQEFAg0
-BBQHNAQUBjQEFAU0BBQENMHDwcLBwcHAwcRFLH4QCiZAfsHEaySAFMHEICBAhwzIh7gMGhgwDcib
-uA0aGDAOyA4aGDAPyIe4DxoYMBDIEBoYMOB+4HjxwAzIlbgMGhgwDcibuA0aGDAPyIq4jbiQuA8a
-GDDPcIAAHA8YiIHgC/QPyM9xAAC0DKy4DxoYMFYOIAAP2GfYNgsgAYohBgrRwOB+8cDPcIAAsK8A
-gIYg/oEJ9A/IBSCADwAAANQPGhgwof+KIFUFBgsgAYohRg7o8eB4z3EDAEANz3CgAKggLaDPcYAA
-jARAgQFqAKHPcKAAOC4FgAQggA/AAAAA13DAAAAACvJI2M9xnwC4/xqhW6Fp2Bi4GaHPcIAAeAgl
-gCOBIIHHcQAAiBMNA8AJ4HjPcIAAeAidAsAJ4HjxwB4MAAGA4M93gABgBIh1BfKB4AX0AdgC8ADY
-C6+A4QXygeEF9AHYAvAA2AqvgOIF8oHiBfQB2ALwANgMrwDYz3agAMgfGB4YkAuPgOCKIRAAD/II
-j4DgC/LPcAMAQA1FHhgQMKYC2BgeGJAC8DGmCo+A4BnyCY+A4Bfyz3ACABRDIB4YkM9wgAAoACEe
-GJDPcIAAXAQiHhiQGBYAlkUgAAMYHhiQDI+A4AjyGBYAloUgAQQYHhiQgeMH9BgWAJaIuBgeGJDP
-cIAAMHQAkI7gzCCiggb0GBYAloC4GB4YkIDlGfIA2JS4z3WAAIAEAKVx2Aa4Zg0gAfzZIIXPcAAA
-TBxaDSABn7kYFgCWhbgYHhiQdQMAAeB4z3Gqqru7z3CfALj/NqA2oDagNqDPcaAAyDsOgYi4DqFp
-IEAA/vHgePHApcFBwELBDBwAMRAcQDHPcYAAfGw0GcAPMBkADywZwA4oGYAOJBlADs9wgAB8bCAY
-QAvPcIAAfGwcGAALz3CAAHxsGBjACs9wgAB8bBQYgArPcIAAfGwQGMAIz3CAAHxsDBiACM9wgAB8
-bAgYQAjPcYAAAGyAGQAIfBnAB3gZgAd0GUAHcBkAB2wZAAdoGYAGZBlABmAZAAZcGcAFWBmABVQZ
-QAVQGQAFTBnABEgZgAREGUAEQBkABO+hzqGtoYyhLBnAAigZgAIkGUACIBkAAhwZwAEYGYABFBlA
-ARAZAAFjoWogAAPYGQAAaiDAAtQZAABqIIAC0BkAAGogQAHIGQAAaiAAAcQZAABqIMAAwBkAAGog
-gAC8GQAAaiBAALgZAABqIAAAtBkAAGoggAHMGQAA0NifuM9xnwC4/x2hz3CAAAAAxIBTJcQ1UybF
-Nde6AebTvsSgUyPABAUmjh/Q/gAA1qEFIIAPsP4AABahGIFTJ841AN2UuBihQMMBwALByXMMFAYw
-GgggARAUBzDPcKAAtA+8oM9xoADIOy6Bsg/gAH3YMg9AAboLIAGpcAjYANlmCyABmbnPcIAAMHQA
-kI7gzCCigsoggQ/gAMQxyiEhAJAIYQHPIaEF/QXP//HA1gggAXvYag/gAOHZz3GAAHxsNBnADzAZ
-AA8sGcAOKBmADiQZQA7PcIAAfGwgGEALz3CAAHxsHBgAC89wgAB8bBgYwArPcIAAfGwUGIAKz3CA
-AHxsEBjACM9wgAB8bAwYgAjPcIAAfGwIGEAIz3GAAABsgBkACHwZwAd4GYAHdBlAB3AZAAdsGQAH
-aBmABmQZQAZgGQAGXBnABVgZgAVUGUAFUBkABUwZwARIGYAERBlABEAZAATvoc6hraGMoSwZwAIo
-GYACJBlAAiAZAAIcGcABGBmAARQZQAEQGQABY6FqIAAD2BkAAGogwALUGQAAaiCAAtAZAABqIEAB
-yBkAAGogAAHEGQAAaiDAAMAZAABqIIAAvBkAAGogQAC4GQAAaiAAALQZAABqIIABzBkAAOt2z3Wg
-AMgfGRURls9wAABEHCoIYAEKIMAvWnDPcIAAHCkjgM9znwC4/893gAAAAASHgOEB4NO4JPIZFQKW
-USLAgB7yXYNA3p++3aMEpwUggA/Q/gAAFqNYG4AHIRUAliIVAJYEIYEP/wD8/wCBFqMI2BkdGJBW
-o12jaQfAANDZn7k9owSnBSCAD9D+AAAWo89wgACABACACyCAhAjyWBuABPYKQAIM2C7wjCEEoCfy
-jCEBoCPyQiFBII/hRgANADMmQXCAAABUQCeAcjR4AHhKIUAgDdgW8EohgCAE2BLwE9hKIQAhDvBK
-IQAiFNgK8EohACQV2AbwFtgE8BfYAvAP2M9zgACQDHCDCnHJcgokQATdA+//CiWABC0Cz//xwF4N
-wAB12BoN4ACKIQoDwgwAAP4PgAJb/qIIAAAKIcAP63IG2IojSgdKJAAApQPv/wolAAHgeIDh8cAD
-8qDgi/YKIcAP63IF2OPbSiRAAIED7/+4c89ygADkDRV6IKLRwOB+ANmeuRl5z3KAANwNAYIleOB/
-AaIA2Z65GXnPcoAA3A0BgiZ44H8BogDZnrkZec9wgADcDQGAJHhCIACA4H/KIGIA4HjPcIAA3A0B
-gOB/LygBAOB48cDiD4//4HjgeOB44HhpIIABbyE/AGkgAAD38fHAathKDOAAiiHEBQDYjbgKCuAD
-ChoYMBTMhiD/ignyz3CAACkFAIiA4AwPwgOw8fHAMg/AA89xgACQCPAhAABAeM9woADQG4DaUKDP
-cIAAAAAAgFEgAIIA2Qbyz3CfALj/PaCU8eB48cByDcAAz3GAAAAAAIFRIMCAG/IBgVEgwIBA2M8g
-4gfKIIEPAADQAM8g4QfPcp8AuP8dogSBAeDTuAShBSCAD9D+AAAWos9wgABgBKCAz3CAABwPCIAE
-JY0fDwAA4Ou4Ad4G9FIIAAyA4A70z3GgALRHANhLGRiAdxmYgwDYnrhUGRiAz3KAAJgEIILhggQl
-hB8BAAAAQCyAAKR4BCWDHwAAAEAHeQO7IKKkewR5Z38GJUAQ4aIEJYEfAAAAgC8iAgFFeQK55HsE
-JY0fAgAAAGZ4pHkmeC8oAQBOIEEEz3CAAHRr8CBCAM9wgABEtYQqCwwwIEAOUyBAgBsaWDAt9M9w
-nwC4/zighuEZ9M9ygACIfgmSgOAM8hsamDPJcc9ygACQDBuCAeAbohfwDJKA4BPyBNkbGlgw8/GE
-4cwhYoAL9M9wgACIfg6QgOAF8gbZGxpYMOXxz3KgABQEKqLPcIAA9AcAiIHgBfQJgrjgANiC9wHY
-gOAI9M9woACIIDV4wKA58M9xgAAwBQDYAKEA2ZG5z3CgAMgfExhYgM9wgADQAhB4z3WgALRHSR0Y
-kM9xgADEjc9wgAA0BSCgbydDEFQd2JPuD6ADChqYM+oOwAuA4BH0ANiRuM9xoADIHxMZGIDPcIAA
-AAQQeEkdGJBUHdiT6QPAAOB48cB6C8AAz3GAAGANgBEAAM91oADIHy8uARDPcAMAQA2f5kUdGBAA
-3x/yz3KAAAAAAILyuBnyAYLyuEDbzyPiB8ojgQ8AANAAzyPhB89wnwC4/32gZIIB49O7ZKIFI4MP
-0P4AAHag8CGAA0B4n+YM8s9wgAAAAACA8rgG8s9wnwC4//2ggNgVHRiQWQPAAOB48cDPcYAAYAR8
-2FYJ4AAggQohwA/rcgXY/dtKJAAA8Qev/wolAAHgePHA4cXPcIAAYASggGvYBCWNHw8AAOAiCeAA
-iiEICy8oQQOaC6APTiBABAolAIDKIcIPyiLCB8ogYgHKI4IPAAAyAqQHov/KJGIAf9gKuM9xoADQ
-GxOhf9gQoeECwADgePHA4cXPdYAAAAAAhe+4GvIBhe+4QNjPIOIHyiCBDwAA0ADPIOEHz3GfALj/
-HaEEhQHg07gEpQUggA/Q/gAAFqFr2JYI4ACKIcgPEgugDwTYCiUAgMohwg/KIsIHyiBiAcojgg8A
-AEECHAei/8okYgAAhe+4BvIA2c9wnwC4/z2gWQLAAEokwHUA2aggwAPPcIAAZA42eGGAQIDPcIAA
-YA0B4VV4YKDgfuB+4HhRIUDHBfINyL24DRoYMADZnbnPcKAA0BsxoOB+4H7gePHAgeDMIKKABfTP
-coAAHA8E8M9ygABYss9xgAC0f4HgzCDigCn0aIJgoWmCYaF8imipfYppqSoSgwBqqSsSgwBrqSwS
-gwBsqXSSdqltkmexd5JosWiCwLt0qWiCBCODDwAGAACA4wHbwHtyqYQSAgBUGZgAHPBggWiiYYFp
-omiJfKppiX2qaokqGsIAa4krGsIAbIksGsIAdol0smeRbbJokXeyVBEDBoQawACC4Ab0mgwgAUAh
-AAbRwOB+z3CAAFiyIIDPcqAAgCUmoiKQJ6IigCqiJpAros9xgACwryCBUSFAgCCAFfQooiKQKaIi
-gDGiJpAyoiKAN6ImkDiiIoA7oiaQPKIggDmiIpA6oiCANaIikDairQfAD+B48cB6CMAAz3CAAHiW
-AN7UqM9wgACwrwCAUSBAgBPyCN/JdYDlzCWikMwlIpHMJWKR3AhiBMogQgNhv4DnAeUz9xzwiiQB
-cc9xgACIfqggQAEEGZAD4HgA2UokAHLPcoAA4ICoIAADFiJAAHaQz3CAAAB/NHgB4WCwz3WAAFiy
-z3eAAFCSQCUAEiRvfg3gAAbaqXBAJ4EScg3gAAbaQCUAEkAnARRiDeAABtoYjYTgD/SKIA8KOg6g
-AIohmggoFYAQGg/gECiFig2ADwmFUSBAgQnyiiCHDhoOoACKIRoORgzACc9wgACwrwCAUSBAgEQI
-gQTPcQAA///PcIAABI8soCugBRqYM6f/2QeAAPHAbg+gAADahCgLDAAhg3+AAFiytRuYAM92gAAQ
-VLRoumZSggKGACGBf4AAVLTPd4AABIG6G5gAYYbcGcAAZYbgGQAABobkGcAA6BkAABYngBAWJoEQ
-COAE4UIM4AUI2t1lFIUWfhZ/QCcAEiRuLgzgBQjaYQeAAPHAANjh/8YN4AUA2M9wgACULVIOQAnP
-cIAA1C1GDkAJUggABq4NAAUB2ADZUgogD4DaPgxADE4LgA8SC8AJRg3ACmoKQAoA2K4P4A8Icc9w
-gABESwCIUSCAgAjyz3GgAMAdAIGguAChzgzADN4LAAqpBc//8cDhxQDdz3CAAFwFoKDPcIAAXJas
-sD4O4AmpcOIJj/+eDmAMqXC2CkAG/gtABAYMQAsiD6AMqXDuDoAMvQaAAPHARg6AAILgo8EG9M91
-gAAcDwjwhCgLDAAhjX+AAFiyguAG9M92gACsnAnwz3GAACC1hCgLDAAhTg4tlTx6KHCGIfEPR7nC
-uoYg/gMkekS4UHHKIcIPyiLCB8ogYgHKI4IPAAA8BMokIgD8AqL/yiUCAUiFO7pTIgKAQK5NlcC6
-Qa4M8neVhiP/CUO7Z653lYYj/gdFu2iugOIS8s9ygADcNhUiAwAAizV6Aq4BiwOuAosErgOLBa4D
-igvwAdkprgLYAq4jrgDYBK4D2AWuBq6LcMlxmgrgBQzaAMABwfYP4AwCwotwyXGGCuAFDNoAwAHB
-YgggDQLCz3GAANAGAKENlUS44LgA2S+lBfKKIQgAL6XhuAPyi7kvpVEggIAE8o25L6WNBaAAo8Dg
-ePHAFg2gAJhwhCgLDAAhgH+AAFiyVSBGCiiAVSDFC89ygAAYBVEhwICKIQgAyiEhACCiSiQAcgDZ
-qCCAD891gABYWPyILmXkfi8qgQNOIoMHz3KAAHxYb2IAJkMA4KtUEI8A5H4vLoETTiaPF+5iyKvI
-gFEmwJAP8l2IhuHTIqYALyqBAE4ijQfPcoAAhFiqYhDwz3aAAGxYLmbOZbyIxH1sEI4AxH0vLUET
-TiWOF8piUKsB4UokAHIA2qgggQDciM9zgABkWE9jz3WAAHxY5H4vKYEDTiGPB+9lACaBAPypVBCP
-AOR+Ly6BE04mjxfuZSQZggPIgFEmwJAP8n2IgOLTI6EALyvBAE4jjQfPc4AAhFirYxHwgOID8slq
-AvBIds5jfIjEe2wQjgDEey8rwQBOI44Hy2UsGcIAAeJKJABxANqoIEAFz3GAAGBYfYhJYQAljAAB
-4mR5LylBAE4hgwfPcYAAhFhpYSCsWg2gCIhwDQSAAPHAoguAAILgBfTPcYAAHA8H8IQoCwwAIYF/
-gABYsumBWIlBL8MQwLsXu8dzAACAHOS/zyMiBuC/Tt3PI6IAyiWCHwAATgGG4s8lYRLlvyz0z3KA
-ALR/FhKFAM9ygABktUaSsHLPdoAAWLLFFgQWDPTEFgIWUyIFAM9ygAC0f1SKsHIL8kEsQgFRIgCA
-BfJJhlEiQIEJ9FEkQIEG9EmGUSJAgQPygbvPcoAATLVUiofizyPhAFEnAJLPI6IFguCIGcAAjBlA
-Awb0z3GAABwPCPCEKAsMACGBf4AAWLJpEYMAThEOAQ4jgg8AADoBCbpifkV+WpFiehK6RX5bkWJ6
-QCrNBcV9BCW+nwDwAADKIcIPyiLCB8ogYgHKI4IPAADFAM8j4gLKJMIAnAdi/8olQgOC4JAZQAMG
-9M91gAAcDwjwhCgLDAAhjX+AAFiyz3CAADB0AJCO4MwgooIq8gfYtgrgAAq4BCCADwcAAAAwuIfg
-ZAANADMmAHCAAHRUQCcBchR5AHmKIAQAlB0AEB7wiiAQAJQdABAa8ADYi7iUHQAQFPAA2Iy4lB0A
-EBDwANiNuJQdABAK8APYDLiUHQAQBvAA2I64lB0AEIIgAQE9AqAAlB0AEAohwA/rcgXY+tuLu0ok
-AADhBm//CiUAAfHAtgmAAILgCHUG9M92gAAcDwjwhC0LHAAhjn+AAFiyAdloHkIQAN+AHsATTNhO
-HgQQBdgQpgrYG7YQ2Bq2FNhMHgQQLdhQHgQQJthSHgQQSiQAculwqCCADc9ygAC4WPQiAwDPcoAA
-HJAUemCyz3KAAMhY9CIDAM9ygAAskBR6YLLPcoAA2Fj0IgMAz3KAADyQFHpgss9ygADoWPQiAwDP
-coAATJAUemCyz3KAAPhY9CIDAM9ygABckBR6AeBgsgiG5bgF8gTaYh6CEAPwYh7CE+S4CvIJ2Woe
-RBAu2l22AtppHoIQCvAU2moehBAy2l22aR5CEBTZWY5RIACAWWEweWoeRBAa4Ty2CvIK2GQeBBAG
-2GYeBBAH2AjwENhkHgQQZh7EEwXYEKapcJL+PI4ocFQeQhCGIAMA5rlsHgIQyiJBAAvyUCHDAW96
-VB7CEFAgwwFveGwewhDluQfySHOGIwMAb3pUHsIQ5LkE8qW4bB4CEFEhwIAE8qS6VB6CEILlGPKp
-cMf+z3CAACy1hC0LHDAgQA5RIECA8djAKCIByiCBDwAAkwDAKCEBoB4AEBjYjbgXpgiGUSDAgM9w
-gABYsgbyvhCAAIm4BPClEIAAFqbPcKAArC8ZgDC4wLiKCiAQVR4CEAiGBCC+jwAGAAAL8ja4wLgb
-eAHgbh4EEALYgB4AEAPwbh7EEwDYHKYdpqlwAf8ohgHaSHNBKQAFNblSIAAAUiEBAMC4wLluC2//
-mHLtB0AA4HjPcIAAHA8IgM9xpAAcQMC4E3jBuBKh4H7xwOHFz3WAABwPV5XPcYAA1AbgulfYAKED
-8l/YAKHiugPyhbgAoVEiQIAE8oe4AKHPcYAArJxAiQDZgOLKIEEAz3GlAOgPBqHPcaAApDABgYDi
-zyDiANAg4QABoXoJQA0whc9woADIHCigKgqgDQ+FbQdAAOHFz3CAABwPKYBEIYOAANok9JDiigAG
-AAAijQ+AAIArAI2guACtgBWAEKC4gB0CEEAVgBCguEAdAhAQjaC4EK2QFYAQoLiQHQIQUBWAEKC4
-UB0CEAHi3/GQ4kYABgAAIo0PgACAKwCNgLgArYAVgBCAuIAdAhBAFYAQgLhAHQIQEI2AuBCtkBWA
-EIC4kB0CEFAVgBCAuFAdAhAB4t7x5rkQ8s9ygACAKwiKgLgIqogSgACAuIgaAgBIEoAAgLgS8IDj
-EvTPcoAAgCsIiqC4CKqIEoAAoLiIGgIASBKAAKC4SBoCAFEhAIAA2B7ySiQAdOB4qCBABuK4FPIA
-IIMPgACAKyATgQCAuSAbQgCgE4EAgLmgG0IAYBOBAIC5YBtCAAHgHfBKJAB04HioIEAG4rgU8gAg
-gw+AAIArIBOCAKC6IBuCAKATggCguqAbggBgE4IAoLpgG4IAAeDgf8HF4HjxwJINYAAH2s92oADI
-H0gemJDPdYAAHA+AFQAQz3GrAKD/TB4YkADYGaFaoRihiiAEAA+mahUAEc93gAAwdLAeABC0HgAQ
-H9gIuA6mCIVRIACAANiLuBXyEKaqD4APz3GgAKQwAYGEuAGhBJeF4Br0ANmUuc9woAAERCWgEvAR
-ptIPgA/PcaAApDABgaS4AaEEl4XgBvTPcaAABEQA2AWhz3CAAMwEAIDguAryhiD/DiK4FLjPcaAA
-BEQFoVb/ng7ADFv/d//PcAAAVVVaHhiQAdhZHhiQCIXPcaYAKADzuAbyANgPoe4PwA8E8AHYD6Fu
-FQERz3CmAOgHJqBuCIADIgygDA2VB4+A4AvyiiDYCfYKYAAB2WIJIAMC2ATwAg9gAwHYiBUAEM9x
-oADEJw8ZGICMFQIQz3CgADAQRKDPcIAAFIkQeI8ZGIDPcoAAxIlQeJYiAgAQukV4kBkYgIogBACS
-GRiAkBUAEECXQBkAgM9wgACAK1MZGIAPEQCGjuKfuA8ZGIDMIqKCCPQIEQCAhSCEAAgZAICK4gf0
-CBEAgIq4CBkAgA/YEBkAgJQVABAcGRiACIX9uA3yCgugDwDYDgugDwHYz3GmAPTPAdgSoQPw9gqA
-DyUEQADgePHAsgtAAAolAJDPcIAAWLIacQX0xRABBgLwKYAluVEhAIAo8s9ygAC0f89xgABktSaR
-doowcwj0xBABBlSKwLlQcQvyxRABBlEhQIEF8imAUSFAgQ70CiHAD+tyBdjPcwAAEQlKJAAAcQBv
-/wolAAGELQscL3fPdoAAHA/4YMlxdgigACnaz3GAAKycACeAH4AAILWuCKAADNrPcKAAtA8A3/yg
-SIZTIgAAhg0gDDSW5g/AAlz/gOWoDqEMyiBhAATIUSCAgAXyugkABAvwANmeuc9woAD8RCGgz3Cg
-ALQP/KBMIACguAyiD8ogYgDPdYAAoAQMjYDgBfQKCoANAdgMrRUDQADgePHAogpAAAolAJAB2BHy
-BMhRIICADPQKIcAP63IF2IojRw5KJAAArQcv/7hzANiELQscz3aAAFiyACZPHoQoCwxAJgEZMCFA
-DkmHJbglulMgEQBTIhIA6XDqDmAADdk2C6AQqXAJh4DlJbhTIBAABvQD2Cr8cPwE8K4KgA9MIACg
-HvJMIgCgyiHCD8oiwgfKI4IPAAAbAsogYgHF9SYNQAgqCOAAAdhMIQCgz3eAALCvBfTWDIAK2gyA
-ChfwDgjgAADYgOXPd4AAsK8E9Lv8CfBSCoAPAIdRIECAWAqCD0whAKBMC4H/qXAE/pYLoAGpcEwh
-AKAE2AQaGDAx9M9xgAC0f89wgABktQaQVokQcgj0xBYAFjSJwLgwcA/yxRYAFlEgQIEJ8gmGUSBA
-gQXyAIdRIECAE/SpcApxcP9/2RG5z3CgALAfNKCqDwAID8gFIIAPAQAA/A8aGDAAh1EgQIAg8s9x
-gAC0f89wgABktQaQVokQcgf0xBYAFjSJwLgwcAnyxRYAFlEgQIEJhtEgYoEI9BiOz3GAABwPGKkJ
-hgmhAd5KCSAMyXDPcIAAsQZiD+ALwKiB5Qz0z3CAAEy1FIiH4Ab0TCAAoMgJgg+eCYAPegxACCoN
-QABeC6ACANghAUAA4HjxwADYhv/GCw//z3GAALR/FomiC2AQNInVB0//8cCqCEAAgeDPdoAAWLII
-dQP06YYD8MUWDxYlv4QtCxwAJlAeJBAAIMC/USBAgcohwQ/KIsEHyiBhAcojgQ8AAK0CyiQhAIwF
-If/KJQEBz3CAAHAPgOUBiMxxNPRAgc9xgAC0f0ChABYDQIDgYaEAFoNAaKkAFoNAaakAFgBBA/IP
-tgAWgEAEIoIPAAYAAAqpABaAQIDiC6kAFoBAAdoMqQAWgEAAFgBBwHoHsQAWAEEIsQAWAEBSqWIO
-b/8E2DnwIIHPcoAAULbEHlgQABYBQIDgxR5YEAAWgUAUGkKAABaBQBUaQoDMcAfyIJDPcIAAZLUh
-sALwAJAAFoBAz3GAAFS2IhoCgAAWgEAjGgKAABaAQCQaAoAAFoBAABYAQQ4ZBIAAFgBBIhkEgAAW
-AECveHL9TgmgAalwz3GAALR/VomA589wgABktQaQIPQQcgj0xBYAFjSJwLgwcBLyxRYAFlEgQIEM
-8gmGUSBAgQjyz3CAALCvAIBRIECACPQkEAEgqXAlucC53f7iD0APcgtAAH0HAADxwADYmv/PcYAA
-tH8WifYJYBA0iSkGT//xwADZz3CgALQPPKBmCQANNg0ADeoKAAwWCmANANj/2c9wqwCg/zmgAtgq
-C2AABBoYMPUFT//geIQoCwwAIYB/gABUtOAQAgDPcYAAsIHcEAMAYBmAgOQQAgDoEAAAXBnAgGwZ
-gIDgf3AZAIDxwI4OIAAS2anBCHYCDWAAi3BKJABxANqoIIACFiSAMCiIgeHD9mG5KKgB4gHCAsGE
-LgscACGAf4AAVLTcGIAABcLgGEAABsG0buQYgADHdYAAEFRIFREQ6BhAAM9wgAAEgQogQC4WIEAE
-COCDwVYLYAUI2vSFz3CAAASBh8H2eAjgQgtgBQjaAMAAII0vgABYslEgAIC1HRgQCPK6HdgTuxUA
-FoC4B/C6HVgUuxUAFqC4ux0YEM9wgAA0slSINohEKj4LACGAf4AAkLA1eAaIEHb8DuH/yiCBA7UV
-ABZRIECA8djAKCIByiCBDwAAkwDAKCEB8glgAKAdABDxBSAAqcDgeADYfvHxwKXBi3AeCmAABdkA
-wuC6E/LPcIAAHA8YiIHgDfQA2Jq4z3GgAMgfD6EBwKQZAADD2Bq4DqFRIoCAFvIGEgI2ANlKJABy
-4HioIIADuHGDcSiJESJAgAAiQDFkGEIACfJAJUEAeglAAKXA0cDgfgohwA/rcgXYiiOPAzkCL/9K
-JEAA4HjxwM9wgAAcDwmAUSBAgcohwg/KIsIHyiBiAcojgg8AABcHyiRiAAgCIv/KJcIAHgtADKoM
-YAkB2M9wgABMtRSIh+Aj9M9wgABAtQuAUSBAgRvyz3CAANywCpDPcYAAqJYlgQq4MHDKIcIPyiLC
-B8ogYgHKI4IPAAAhB8okIgCwASL/yiXCAAIID/++DOALANiWCsALxghAAJUDT//xwALYrfy2/YkD
-T//xwGIMAAAA3s91oAC0D9ylyg7gC2h3+P/2D2AM6XAEyFEggIAE8goLwAMJ8ADZnrnPcKAA/EQh
-oNylkQQAAOB4hCgLDM9xgABAtTAhQg7PcIAA4IBWeHaQz3GAALR/xBncABeQz3OAALCBxRkcAM9w
-gAAEgVZ4DIiQGwKAANjgf8cZHADxwOoMT/9ODEAPVg1P//UCT//gePHAzgsgAETaz3WAABBUxG3P
-cYAACIFCCWAAqXBKJIBwANmoIIAIFGnYYHGAhCkLDAAhgn+AAFiyACGAf4AAVLS6GtgAANu1GtgA
-YYVChQHh3BjAAGWF4BiAAEaF5BjAAOgYgADVAwAAz3CAALR/pQQgAIohBQXgePHATgsgAADaocFA
-wgAWjkAAFo1AABaDQAAWkECA5R3yqXfPcYAA1JwjiYYn/BdFv8O95nngucoiQgNgwuG5yiJCA8oi
-IQABHIIwUSGAgMolIRACHEIzgOAk9M9wgAC0f7aI9Iixc8wmwZMR8gohwA/rckArBAQQvgXYiiNd
-CwUkRAP1B+/+BSbFEwDFQCAOBs93gABYslQYWAOEH0ATIfDPcIAAZLUGkBBzCvTPd4AAWLLEFwAW
-wLgQdg3yCiHAD+tyBdiKI50NmHOtB+/+SiUAAADFz3aAAPyw3R9YE0AgQSBJIQEGNHn+DiAAyXBC
-IMAlSCAAAIDgANvL9wDaABYBQAHig+K99wHjEHO491YmABnWDiAABtnPcIAAsK8AgFEgQIAa8s9x
-gAC0f89wgABktQaQVokQcgf0xBcAFjSJwLgQcQryxRcAFlEgQIEG8gmHUSBAgQ70rg1gAMlwz3CA
-AJgPoqCKIBINXgggAKlxMg4AAD0CIAChwOB4ANhC8fHAocGLcGIOIAAB2QAUBTBMJQCAyiHBD8oi
-wQfKIGEByiOBDwAArgfMBuH+yiRhAM9wgADUnO4NIAADGEIBocDRwOB+8cCOCQAAz3OAAFQQQ4MA
-3891oAAsILCF0mrUfn5mpaYEpgHijCIIgCamQ6OF9wKD46MB4AKjwQEAAOB4ANjPcaAAyB8YoRmh
-AdgOoeB+4HjxwD4JIABZcTlyyHHocgHdz3agAMgfs6YF3891gADAD+ClAaUEwEilCaUVhielCqUY
-hhgdQBELpRmGFB0AEQyloBYAEGSlDaWkFgAQDB1AEg6lqBYAEAgdgBIPpc9wAQCwCRClSglgACjY
-EaVCCWAAANgSpVMnwHUTpQLIVB0AFxalEhYAllAdABcXpRMWAJbPcoAAwA8YpRQWAJZKJEB5GaUV
-FgCWANkapSQWAJYbpRYWAJYcpc9wgACQDBCAHaXPcIAAwA94GIAKz3CAAMAPfBjACs9wgAA8EAQY
-AAuEGkALz3CgAMgcCICIGgAAz3CAAIAFAICMGgAAqCCAAvAiQwDPcJ8AuP8B4XagmQAAAPwciLb8
-HEi2/BwItvwcyLX8HIi1/BxItfwcCLX8HMi0/ByItPwcSLT8HAi0/BzIs/wciLP8HEiz4H7geATc
-ON018OB4BNw03TPw4HgE3DDdMfDgeATcLN0v8OB4BNwo3S3w4HgE3CTdK/DgeATcIN0p8OB4BNwc
-3Sfw4HgE3BjdJfDgeATcFN0j8OB4BNwQ3SHw4HgE3AzdH/DgeATcCN0c8OB4BNwE3RnwNBQaMDAU
-GTAsFBgwKBQXMCQUFjAgFBUwHBQUMBgUEzAUFBIwEBQRMAwUEDACxwHGsCRNM7AkHzPgfvHAz3GA
-AJAMEKHgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjRwOB+
-4HjhxeHGQCkNAiV9QC0DFIjipXsIdZD3UyV+kAbyAR1SEGG6+/FBKo4AwbpCJk6QBB3QEP31gOIK
-8i8kiXDgeKgggAEBHVIQ4HjBxuB/wcXgeChyANnW8eB48cCuDs//ocEId892oACsLxmGBCCAD3AA
-AADXcCAAAAAB2MB4LyYH8Ch1GnIT9IogSQb2DO//iiFNBDmG6gzv/4ogCQaKIAkG3gzv/6lxANgk
-8BHMABxEM08gwQMB4BB4BCCADwAA/7+PuAIcRDARGhwwRgmgD0AnABIH5wQnjx8AAPz/BScAFJ24
-n7jscQChAMHscCCgAdh5Bu//ocDgeCK5BvDscmCiBOBhuYHhYIA69wDZz3CgANQLbaDPcKAARB01
-oOB+4HjxwO4Nz/8Idih1KHBIcWhyyv+B4MoggQPAD+H/yiFBAzkGz//hxc9ygACwBKSKgOXPcp8A
-uP8G8s9z0Lr+yn6iGqI7ooDlDvLPcKAAOC4FgAQggA/AAAAA13DAAAAA9vNp2Bi4GaLgf8HF4Hjx
-wH4Nz/8Id89xgACwBAWJAN6A4KnBQMZD9AHdpanPcYAAgHbPcKAAzCstoADYj7gRGhwwIRqCM34I
-IA2LcCoJAAjPcAEAsAlBwIogUABCwM9wgAD8YgCIZMUC3REcAjAAwBIcQjMTHAIwz3CAAFQQRcDP
-cIAAwA9GwM9wgACABQCAQ8Yg2QHaR8BIx4HAPdsXu8H/CNgB2cj/BBpYM0kF7/+pwAPaz3GgABQE
-RaHPcaAA1AsNoeB+8cDhxc9yoADUCwPdsaIA23CiBRICN9dyAAAAQAHawiKKABe6x3IADgAARSIC
-Bp26n7rsdUClAtogGoIwCBINNuxyoKIREgI3AeIRGpww7HIAogISAjbscECg7HAgoAHYz3WgAMgf
-E6U4hexwIKAZhd//dB3YkM9xoADIOw6BiLgOob0Ez//gePHAANgIEoEw3P8IEoUwCiHAD+tyB9iK
-I9EESQHv/kokAADgeADaA/AB4kEogQAwcrz34H7PcYAAkAxAGcAHz3GgAMgfXIGduJ64TRkYgOB4
-4HjgeOB44HjgeOB44HgcgeB+4HgD2s9xoAAUBEWhz3GgAPwLDKngfgPaz3GgABQERaHPcaAACAwA
-seB+BcwA2tdwAAAAQAHYwiAKABe4x3AADgAATyCBAJ25n7nscCCgz3CgABQEA9kloAISATbPcKAA
-1AstoM9woABEHVWg4H6A4VTyQCHCA8O5j+GcAC0AJLozJkFwgACAVEAng3I0ewB7ABYBQAQYUAAA
-FgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAW
-AUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYB
-QEIiQoAEGFAAv/XgfuB4gOLhxSLyY2rBuoPiPAAtACK7MyaCcIAAkFRAJ41yVH0AfQQQAgQEGZAA
-BBACBAQZkAAEEAIEBBmQAEIjQ4AEEAIEBBmQAO/19wTP/4Di4cVT8kAiwwPDuo/ingAtACS7MyaC
-cIAAlFRAJw1yVH0AfQEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIE
-ARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQB
-GZIAARCCBAEZkgABEIIEARmSAEIjQ4ABEIIEARmSAL71SwTP/+B48cDKCc//KHZGIc0AHWUiuZL/
-wb6B5g7yguYI8oPmDfQAFoBAAR0SEAAWgEABHRIQABaAQACtAQLP/+B4gOHKJE1w4HjoIK0BABYB
-QQIYVADgfuB4gOHKJE1w4HjoIK0BABaBQAEYUgDgfuB48cBeCe//UyFCAE4iDQHPcqAAFATJggDb
-DiaCHwAAAAZQccohxg/KIsYHyiBmAcojhg8AAPwByiRmAEQGpv7KJcYAgOHKJE1wyiLNAOggLQJO
-YM9xoAA4BAHiyKmB5Q7yguUI8oPlDvTPcKAAOARoqM9woAA4BGioz3CgADgEaKhJAc//4cUA2g/w
-oIANc6CjoYANc6CjooANc6Cjo4ANc6CjEOAB4kEpAwFwcq/3ANsG8AQQDQQNcqCiAeNTIcIAIrpQ
-c7f3ANsG8AEQjQQNcqCqAeNTIUIAUHO59/sCz/8A289ynwC4/xqie6I+os9wAGwEABmi4H7xwF4I
-7/8A2qHBGnDPcNS6/spAwM9xnwC4/2gZAAQE2Buhi3AeoZ26z3CgANAbUaDPcABtABAZoQXw4gjv
-/4ogSQFRIUDH+/MAFAUwDCWAj9S6/so69CDdz3OgAMgfsKMB2EMbGAAA2I24/P6xo89xnwC4/2gZ
-AAQE2Buhi3AeoQDYnbgTGxiAz3AAbQAQGaEF8IoI7/+KIAkGUSFAx/vzABQFMAwlgI/Uuv7KyiHB
-D8oiwQfKIGEByiOBDwAAXALEBKH+yiQBBIEB7/+ocOB4z3GAALAEZImA489ynwC4/wXyz3HQuv7K
-PqIaooDjDvLPcKAAOC4FgAQggA/AAAAA13DAAAAA9vNq2Bi4GaIcguB+4HjxwFIPr/+YcCh2SHXs
-/wYggQOIcKV5Xf6lB4//z3GgADQfBKEB2AehCIGA4P71BYHgfuB48cAaD6//SiQAAgDdz3cAAAQd
-qXYVIoAzHBABBgDYz3KgABQEyqKooieiBKI9ZYjhaLnKIQ4A6XBH/kIkRABMJACAIOcB5ij3OQeP
-/0EpgYAK8i8kSXDgeKgggAEEEAIE7HFAoeB+4HjxwLYOj/8IdSh2rglgD0AhAAIFzNdwAAAAQAHY
-wiAKABe4ACCBDwAOAAAHbgQggA8AAPz/JXiduJ+47HEAoQISATbscCCgIr4F8OxxAKEE5WG+geYA
-hTv3YP7JBo//4HgH2c9yoADUBxoaWICA4A7yGRIBhgkgQwAPEgGGAiDAgHlhDxpYgPb14H7geKHB
-8cAFEgI313IAAABAAdrCIooAF7rHcgAOAACDuuxzQKPscgCiKHBJ/tHA4H+hwPHA4cXPcIAAMHQm
-iIDhMPIniIDhLPKgkE9th+IJ9zMmgnCAAKRUQCeBclR5AHkA2RHwJJAH3YDhAdnAeQvwJJAI3YXh
-AdnAeQXwJJCE4QHZwHmB4QzyCBAFAQohwA/rchDYiiPPBbUCr/6YdQEGj/+hwfHAgg2P/89ygAAN
-CECKgOJEwI7ygOEM9AohwA/rcgXYiiNPCUokQACBAq/+uHNggYDjBPJBgYDiCfTPcoAArIBwgmCh
-UYJBoSTGgObKIcEPyiLBB8ojgQ8AAO8DyiBhAePzgOLKIcEPyiLBB8ojgQ8AAPADyiBhAdfz6bgX
-8gQggA8BAADALrjPcoAAUFgIYkkggABhuAK4FHjHcIAAZJFqoCGBK6BE8Oi4G/Kg5solghPKJSEQ
-BCCCDwEAAMDPd4AAAFjOZwQggA8GAAAAMbguuh5mz3CAAFBYSGDCeBLwUyDCAF16z3WAADBbTWUE
-IIAPAQAAwC64z3KAAFBYCGJhuBZ9Em0UeMdwgABskGCgmOUhgSGgjPcKIcAP63IF2IojkAOKJIMP
-gQGv/rh1CNy/BI//4HjhxeHGz3GAAA0IIImA4SbyANtKJAB2z3KAAGyQqCCAAzJrNHklYD5ioKY9
-YKGFGWGhpiKBAeMipkgQAQZIGlgASRABBkkaWABLEAEGSxpYAEwQAAZMGhgANQWP//HA9guv/7hx
-z3KAAChtBLkwIkQAUSRAg6LBBvLPc4AA7LUF8M9zgAD8skAjAgZAIwEHUSRAgsohwg/KIsIHyiOC
-DwAANQTQAKL+yiBiAc92gAAwcEAtjQGmZui+QMYgxQTywr2qYQ/wUSZAkgfyRCUBHES5KmKJugXw
-UyXBEDx5KmPPcYAAMG8WIUEBIokOuUV5IKDNA6//osDgeHEHoAcI2OB48cBSC6//AdnPcIAAZCgg
-oADdz3aAALgEFiZAEwOAgODiIAIAQCVNkPjz8gyv/gbYjQOP//HAHguP/wh1z3CAAGQooKDPdoAA
-+CyKIFcLdgmv/yCGiiBXC2oJr/8lhqoMr/4G2ILlD/IA3c92gAC4BBYmQBMEgIDg4iACAEAlTZD4
-8z0Dj//gePHAygqP/wh2iiDXDC4Jr//Jcc91gABkKOoOYALCpQKFgeAs8oLgF/KE4Df00g5AAs9w
-AABsOc9xgAC4BAChz3AAADg7AaEA2Nn/mg6gBwXYI/DPcAAAWDnPcYAAuAQAoc9wAADYOwGhxP+S
-DkACfg5AAgDYDa0R8HIOQALPcAAAWDnPcYAAuAQAoc9wAADYOwGhANjG/6ECj//gePHAiiBXB5oI
-r/932QDZz3CAAPgsIKAB2NP/0cDgfuB48cDPcIAAZCgCgFEggIAK8oogVwdqCK//jdkODqAHCtjt
-8eB48cDhxQh1iiAXClIIr/+pcc9xgABkKAKBUSCAgB/ygOXPcIAALCkAgA30IrjAuA2pAtjPcYAA
-+CwCoQPYA6EA2AzwI7jAuA2pBNjPcYAA+CwCoQXYA6EG2AShBQKP/+B48cCKCY//z3WAAGQoAoVR
-IICADvQQEgQ2CiHAD+tyBdiKI0UHhQZv/kolAABeDUACXg1gAgh2geYB2AytFfTPcIAACAVaDUAC
-hgvABwh1iiDXCqoPb/+pcYnlzCWikEQNogfKIEIDkQGP/+B48cBKDUACz3CAAEyBIIjPcIAAAAXP
-coAAZCghqCyKwLkiqADZI6gSDWACIaIiDUACANmbuc9woADQGzGgZ/HgePHA4cUA3c9ygAB0KKCi
-ENtKJIBzqXGoIAACFiJAAGGgoqAB4c9wgADoKPoJr/8Q2c9wgAD4KO4Jr/8k2c9xgAD4LKChoaEI
-2AWhCQGv/6ah8cDhxc9wgABkKAKAUSCAgBjyiiBXB+oOb/+KIUYJAN2pcKH/qXBT/9L/4v+KIJcH
-zg5v/4ohRg3PcIAA+CygoMEAj//xwM9xgABkKCKBUSGAgMwgYoBQDKIHyiCiAQ/x8cDPcYAAZCgi
-gVEhgIDMIGKANAyiB8og4gEDBs//4HjxwAokAIDKIcIPyiLCB8ogYgHKI4IPAAC8AxQFYv7KJcIA
-z3CAALgEFiAAASOgzwXv/0Sg8cDWD0//CHaKIJgAPg5v/8lxz3WAAGQoiiAXDi4Ob/8hhSGFAN+Q
-4QT0Ad/BpclxgecT8s9wgABMgRUgggM1eCCIYIowcwn2AYghihBxBfYAhYDgDfSKIFcH8g1v/4oh
-CQ/BpY4LoAcD2AHYAvAA2M0HT//xwOHFCHEQ2ADbSiSAc891gABMgZhzqCAABxEhAIEU8s9ygAB0
-KBYiAgEEEgUATCUAhFD3FSVCEUCKUHPKIEsByiOLAEAkRAAvJAcBjQdP/wohwA/rcgXYLQRv/ooj
-Bw/xwAIPb/8Icc92gABkKAQWBRBMJQCEjPcKIcAP63IF2IojygYBBG/+iiSDD0oNb/+KIFgAiiAX
-Dj4Nb/8hhgGGz3WAAOgoCWUuDW//iiAXByGGKGWA4IoACQDPcIAATIE1eOGIENgBps91gAB0KIog
-Vw4GDW//IIWKIBcH+gxv/+lxAIWA4MogIQEp8sX/CHEBppDgyiHBD8oiwQfKIGEByiOBDwAAvALK
-JMEAeANh/solIQDCDG//iiAXDiGGz3CAAEyBNXgBiBB3y/aKIFcHpgxv/4ohywAD2EYKgAeNBk//
-4HjPcIAAZCgCgIHgAdjgf8IgAQDgePHA+g1P/3pwGnFacgDfQCgBBIogGABqDG//RXlMI4CjyiHK
-D8oiygfKIGoByiOKDwAA/ALKJMoE9AJq/solygBMIgCkyiHKD8oiygfKIGoByiOKDwAA/QLKJIoE
-0AJq/solygDPdoAAdCgWJs0UBBWREIog1w4KDG//KnEMIkCkBvTPcIAAZCgAgFbwTCEApAryACGB
-L4AA6CgAiWG4AKnpcArwiiBXB9YLb/+KIUwEAdg6dwAigi+AAOgoIIpMIQCkAeEgqsohyg/KIsoH
-yiBqAcojig8AABgDyiRKBFACav7KJcoEgeAQ8s9wgABMgRUgQgQVIIAEIIhgijBzhvYBiCGKEHFM
-9oogVwdyC2//iiHMBwQdgBQIHQAUAIYPIMAEAKZKcET/z3GAAGQoIIEDuCV4HQVP//HA0gxP/wh1
-KHdIdkAoAQSKINgAMgtv/0V5z3GAAPgoIBEEAEwkAIHKIcYPyiLGB8ogZgHKI4YPAAA8A7gBZv7K
-JSYAFiEAAaSo4KDFqEAkQAAIoeUEb/8C2OB48cDhxc9ygAD4KAiCgOAT8s91gAC4BGG4CKIWemCF
-BIoggmB7RYrPcoAA+CgIgoDg8/W9BE//4HjxwDYMT/86cI7gyiHKD8oiygfKIGoByiOKDwAAlgPK
-JEoEQAFq/solygDPdYAAdCgWJU4UBBaQEIog1w92Cm//KnGKINcObgpv/wpxANgCphDYAaYA2Q8h
-QQQAhUwgAKQmeAClHPJMIACkyiHKD8oiygfKIGoByiOKDwAApwPKJAoE4ABq/solSgQAIIEvgADo
-KACJYbgAqQpwKf/5A0//4H7geOHF4cYQ2QDez3WAAEyBn3HJc6ggAAQRIICDCvIVJYITQIpQc8oh
-iwPKI4sAAebPfihwwcbgf8HF8cBeC2//iiCXD0ogACDPd4AAdCjCCW//IIcO3gp1AIcRIECDC/IW
-J0ATAoCA4AfyQHgFIAAELyAHIGG+gOYB5a99L/cA2ACnTCAAoAHYdQNv/8IgDADgePHA/gpP/6/B
-CHcA3s9woABkLvAg0gMbEhA2GxrYM/XYBbgmDW//6XEbyM91oADUBxodGJAPFRGWGRUAloDgLPLA
-5kX3GRUOlvzxABYAQAAWBUAAHEAxIMCc4D/0gcBCD2//DtkjwGG4Y8AMwIDgDvLPcZ8AuP8aoS3A
-G6EDwB6hz3AAbAQAGaEPHViU7ghABw8VEZbPcKAAwC9REACGCyCAhMz1z3AAAGQe0gqP/xEgwIPE
-8xkVAJaA4MD1GxoYNPXYBbiCDG//CnEbyBodGJCJAm//r8AKIcAP63IF2IojWQtNBy/+iiQIAOB4
-8cBuDk//FQcP/uB4ABYBQSCwABaCQFMiQQAhoEEqwQBSIQEAwLkoqEEqgQDAuSmoQSoBAcC5MKgA
-FoFAz3GgAMgcKIHgfyOg8cABgIDgEfKB4BjyguAY8gohwA/rcgXY/9tKJAAA3QYv/golAAEB2c9w
-oADIHCmgjg1v/xTYCfAC2fjxAdnPcKAAyBwpoNHA4H7geIDg8cAR8oHgEvKC4BPyCiHAD+tyBdiK
-IwUHSiQAAJEGL/4KJQABKdgSuAjwFdgTuATwT3or2BK4NXhAoN/x4HjxwOHFCHUuDW//FNgjhc9w
-oADIHCigrQFP/+B48cAuCU//pcGLd+lwxP/pcNL/IsCA4BjyABYOQSTAgOAD8gAWAEEA3QnwAcAA
-FgJAyXHd/wHm0H4B5QAUATEwdbX3FPAA3Q3wABYBQYDiBPIAFgBBAcAAFgJAAeXS/wAUATEwdSTC
-svckwIDgBvRRIQCABPIAFgBBBczXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKECEgE27HAg
-oOlw0f+yC2//AdgA2c9woABEHTWg4QBv/6XA4HjxwAGAgOAU8oHgEPKC4BDyCiHAD+tyBdiKIwQJ
-SiQAAHUFL/4KJQABAtgD8AHYz3GgAMgcCaEmDG//FNhT8eB4gODxwBHygeAV8oLgFvIKIcAP63IF
-2IojhgNKJAAAOQUv/golAAEp2BK48CBAAACiOfEV2BO4+/Er2BK49/HgePHA8g8P/6XBi3fpcHX/
-6XDc/wAUATEFzAK513AAAABAAdjCIAoAF7jHcAAOAAAL4QQhgQ8AAPz/JXiduJ+47HEAoQISATbs
-cCCgABQBMexwILAJFIAwgOAH8s9wpgCcPxmAgeD79SLAgOAX8gAWDUEkwIDgA/IAFgBBAN4I8Oxy
-AcCpcc//AeWwfQHmABQBMTB2t/cS8ADdC/AAFgFBgOID8gAWAEHscgHAxv8B5QAUATEwdSTCs/ck
-wIDgBvRRIQCABPIAFgBB6XB4/2ILb/8B2ADZz3CgAEQdNaBO8eB48cASDy//AdgAFoJAABaKQAAW
-iUAAFoZARCa+g0QigxPAeAohQILKIWIAAeGA48ojgQDKIyIAgODKIEICyiAhAEDcBCILkxtjb3sk
-9AXMAd3XcAAAAEASa8IlShMM4Be9BCCADwAA/P/HdQAOAACleJ24n7jsdQClAhINNuxwoKDsdQAd
-ghLscGCoANvscGCwgOHyAC4AANj4cBlxgeDKI4EByiJBAsojggJEI4EDguFKJUAAwiVCAVIjDgDA
-vkQjAAyQ4AHbwHug4AHYwHgFIMQAABYNQIDhYbpPehj0gOIA39D3IIWA5gTlBPQAFg1ATCMAkAP0
-7HAgoAHnUHe09yCFTCMAkAT07HAgoAYlPoES8oDiANjN9wAWAUCA5iClBOUE9AAWDUAB4FBwtvcA
-FgBAAKULJECBHvKA4gDY0/cAFgFA4IWA4wPy53kC8OV5IKWA5gTlBPQAFg1AAeBQcLD3ABYAQCCF
-gOME8id4A/AleAClQiBBEIDhIAft/0AnQABMIwCQBvSyCW//AdgH8APZz3CgABQEJaAA2c9woABE
-HTWg1QUP/7kBT//xwGYNL/8A2c9woADQDzWgABYDQQAWAkHpuwXMFvLXcAAAAEAB2MIgCgAXuAAg
-jQ8ADgAAQCIBA89wAAD8/yR4pXiduJ+4E/DXcAAAAEAB3cIlShMXvcd1AA4AAEAiAQPPcAAA/P8k
-eKV47HEAoQLI7HEAoexwQLDscQDYALHou0DyI2rjuwQhgQ8AAPz/CfLPdaAAOAQIrQHYYbkweeS7
-DPKhaAi9BX3PdqAAEAS4tgLgD3hiuTB5AN0U8MNoGL7iaO9/EL/lfuFo738Iv+V+BX7Pd6AAFATL
-pwTgD3gB5dpp0XWs9wDeCPDPdaAAOAQIrQHgD3gB5lMhTQCxdrf35bsI8gHZz3CgANAPERhYgOa7
-CfID2M9xoAAUBBChAdgEoeO7BvIAFoFA7HAgqGG65LsJ8oHix/cAFgFB7HAgsGK6RCOBgUEqgAAV
-9ADeC/DPdaAAAATsjQAWjUDsdeCtAeayaLF2R/fnu/T1ABaPQPbxguEU9ADZCvDPdaAA1APclQAW
-DUHsdcC1AeEbfbFxRvfnu/P1ABYOQffx4rsV8oDgyiQNcOB46CDtA+e7CfLPcKAAmAM9gAAWAEAD
-8AAWAUDscCCgANkG8AAWg0DscGCoAeFTIkAAEHG597IPL/8B2ADYz3GgANAPERkYgM9xoAAUBASh
-BMjPcaAA0A8iuMC4FaHJAw//8cBiCy//ANlKJABy4HioIIACABYCQBUiQDAcGJgAAeEAFg1AABYO
-QB4MT//PcKAAFASsoM9woADUC9ygcg8P/40DD//hxeHGJIjPcoAArFSmiMK5LmIA2Q8hgQOA5c9z
-gACMgXYTAgYF9CZ6dhuYABzwRXl2G1gAJYgVI40DeR1YECaIRYhZYXwdWBAggIwhEIBF94ohEAAg
-oCO5dxtYAACAKrh4GxgAANnPcKAA8DYsoHkTAQYloHwTAQYmoHoTAQYnoH0TAQYooHsTAQYpoH4T
-AQYqoHcTAQYroHgTAQYtoHYTAQYkoMHG4H/BxeB48cDhxaLBi3WpcPoOL/8C2alw0f+qDg//zQIv
-/6LA4HiA4PHAB/TPcIAAZIOKCy//JNmvAM//4HjxwDYKL/+YcJDgyiHGD8oixgfKIGYByiOGDwAA
-WwM8B+b9yiUmBADaSiQAdM92gADMBKgggA9ALIMBVXvHc4AAMHAgg891gAAobUAsAAHduQBlIKPx
-uNEhIoIJ8qCLz3eAAABYrWeB5Qr2z3WAADBvFiUNEaCNUSUAkATynrkW8C24wLgVJg8Q44dSIU0C
-CydAkw3yz3WAAHiyhCgLDDAlQB7+uOzzn7kgowHi8QEP//HAdgkP/wAWEkEAFgBBz3GAAChtQCoA
-IQFhosFBKUADUyATAEwiAKTKIcYPyiLGB8ojhg8AAP0EmgEmAMogZgFRIUCCyiHCD8oiwgfKI4IP
-AAD+BAXYv/TPcIAAMG8WIIAEOnC2DS//AtnPcIAAsG8WIIAEpg0v/wLZQCqQIc91gAAwcAAlABSS
-DS//ENmLcIoNL/8B2QAlABRKCqALENkBEYAgkODKIcoPyiLKB8ogagHKI4oPAAAhBcokagDsBer9
-yiWKBEokAHQA2KggQQkVIAEgMCVFEAQlj48AAAABBBxAMUXyIcbPcYAAAFgEJYQPBgAAAMthQSxB
-BKDmemHRJeGCMPKA5wPygeMK9gQlhA8AAAAkDCSAjwAAACQk8oLhRAANAILhBfSA5xzyguMa9IDn
-A/LM5hb2z3GAADB0JpEwcxD2USXAghDyz3OAAHiyhCsLLDAjQQ4EIb6PAAYAAAT0ANsD8AHbb3sD
-8AHaSHMEJYEPAQAAwC65z3aAADhbKWYwcgHZwiFNAIDjzCEigBLyAeACEYAgz3GAAFBYCGGB4B3y
-CiHAD+tyBdiKIxQOEfDPc4AAeLKEKwssMCNEDgohwA/rcgXY4QTv/YojVA1KJEAA1QTv/UolAAAD
-EYAgCGGC4Mohwg/KIsIHyiOCDwAAOgUF2O31SnBV/89wgACwbxYggARAkM9xAAAYFQkiQQDCCy//
-ILC1B+/+osDxwGYP7/4C2c9wgADMBNIND//PcIAAzARAgM92oADsJ893oAAERM91gAAwdOC6PvIr
-hkQigACGIv8OIrqhuRS6tLkFegUhgwAEIYEPEAACAAQigg8QAAIAa6YlekWnKJWH4cwhooEQ9IDg
-z3GgAMgcBvIB2B6hzgrACwbwANgeoTILwAsElYXgL/TPcIAAzAQAgFEgwIAp8gTZz3CgAEQdJaAj
-oCSgIfDPcKAAyBwB2T6gC4aBuAumigrACwSVheAO9M9wgAAcDwiAUSAAgAjyANiUuAWnC4aUuAbw
-ANgFpwuGtLgLptIKD//lBs/+4HjhxTRoz3KAAChtIWItucC5hCkLDAAhgX+AAFiySIFRIgCAz3KA
-ANScQYIJ8jyJgOHFIoEPAAAKAgPyRSJCA0okAHQA26gggAI2aHV5ACGND4AAMHBApQHjAN3Pc4AA
-MG8WIwIAoKqhqgHZIqoD2SOqSiQAcalxqCDAAXphFnqkqgHh4H/BxeB40QOP/80Dj//xwAAWAECB
-4M9xgAAcKQChDfQAFgBADLgEIIAPAQAA8AGhABYAQAKhEfCC4AAWAEAL9EYgwgBDoQAWAEDPcKAA
-0BteoAPwABYAQAXM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChAhIBNuxwIKCeCC//AdgA
-2c9woABEHTWg1wOP/+B48cAAFgJAocFAwgEUgDBRIACABvLPcYAAsI8F8M9xgADIj0ChYIkB2gfw
-ABYAQBUhjAAApAHifXgQcvn3USMAgAnyABYAQQPwANgVIYwAAKQB4oXi+vcFzNdwAAAAQAHYwiAK
-ABe4x3AADgAAg7iduJ+47HIAogISAjbscECgCgkv/wKJANnPcKAARB01oKHA0cDgfvHA4cUAFgNA
-z3GAAAAAYKEAFgJAAN1BoQAWAED/uwKhABYAQAOhpKEQ8v+6QNjPIOIHyiCBDwAA0ADPIOEHz3Gf
-ALj/HaEG8M9wnwC4/72gBczXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKECEgE27HAgoHoP
-7/4B2M9woABEHbWgvQTP/uB48cDhxc91gADMBARtbgov/wjZAYXPcaAAuB4CoQKFA6FuCA//kQTP
-/vHA4cWhwQDdQMUAFgFAABYAQIHhGvIFzNdwAAAAQAHYwiAKABe4x3AADgAARSAAA524n7jscQCh
-AhIBNuxwIKDscKCgqXAg8AYP4AuLcAXMAdnXcAAAAEAB2MIgCgAXuMdwAA4AAIS4nbifuOxyAKIC
-EgI27HBAoOxwIKAAwexwIKAB2LoOz/7PcKAARB21oP0D7/6hwOB48cB2C8/+CiYAkDpxUPIvKIED
-TiCNB9rY2gnv/qlxGxpYM0AlABRKIAAgDyAQIPXYBbiKDe/+qXEbyM93oAAUBAqnz3GgAGQu8CEB
-AAmHgOAR9M9woADAL1EQAIYLIECACfTPcAAAsB6GCw//CyAAhBX02th+Ce/+iiGaCymHdgnv/trY
-z3GgAMAvUREBhmYJ7/7a2A4K4AYqcHoLYAKpcADYDyBAAwYmDpCz9c9xgABgBQCBB9qH4BsamDAd
-8s9woAA4LgWABCCAD8AAAADXcMAAAAAN8vXYBbjPc58AuP8ao1ujadgYuBmjAdgC8ADYgeAD9ECh
-z3CgABQESqDZAs/+4HjxwOHFAhINNgAWAEEAFgFBxbiCubr/tg7v/gIaWDPVAs/+4HjxwEoK7/6A
-2M93oADAL6UXEpYUFxGWAN6lH5iTz3KgAGQuFB+Yky8rAQBOI4EH8CJDAGV+ANsPI0MABiDAgPX1
-TybAFqQfGJCkFwCW/7j+86MXAJYEIIAPAAAAD4wgEID48/PYBbiA2SoM7/6fuRsSEDb12AW4B90a
-DO/+qXHPcKAAFASqoBsaWDMH8APZz3CgABQEJaDPcKAAFASpgIDlHvKA5fTzQS2AkAryLyQJcOB4
-qCCAAQAWAEDgeFMlTZAJ8i8kSXPgeKggQAEAFoBA4HjPcKAAFASpgOXx89jqCS//Bbj/uN/19dgF
-uKYL7/4Kcc9xoAAUBCgZAASA5hsaGDQk8i8ogQNOIIEHlOHKIkUAhfcocoAiwgHPcKAAGCzwIIMA
-lOHKIkUAhfcocoAiwgTPcKAAaCxVeGCgANgPIEAABiYOkOD1gNnPcKAA0BswoKUfmJQUH1iUTQHP
-/uB48cDqCO/+F9m3wYt3fg3v/ulwI8BKIUAgUyDSAIYg/gNMIgCkQigQAQwcgjSN9gohwA/rcgXY
-iiPODQokQATdBa/9CiWABBLGLb4gwMC+QCoNIcd1gAAobVEgAIAAhYYg9w839IDgyiHBD8oiwQfK
-I4EPAAC+AwXY4fMBwALBSnIOCCAEZm2A4B/yyXBaCuAASnENFIAwhSDBAA0cAjCKIP8PU8AAham4
-AKVKcBoK4ADpcc9wgACEBNV4IIAPIYEEIKAqdgLwAt5KcG7+BvCA4MomQRTKJiISgeZZ9BPBAIUS
-wiZ4RHkleAClDB0CFM9wgABIbgDZFiCABECFIKD1uiGgBfQA2Yu5IaD2ugXyIYCFIQEOIaA2COAA
-6XANFIEw5bkF8lgUADEFteG5BPJQFAAxArVRIQCBBvJKcIIJIARVFIEwDRSAMFEgwIAd8jXBVhQC
-MUpw3gkgBBLDuHCMIAKAyiHBD8oiwQfKIGEByiOBDwAAKwSkBKH9yiRhAFElwIHKJiIRSnBO/QXM
-13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChAhIBNuxwIKBuCu/+yXAA2c9woABEHTWghQev
-/rfA8cAmD4/+pMEB3YHAtgvv/qlxAN5N8ILAqgvv/gLZAsCLclIN4AMDwaR4LyUHkEDyAMEA2M93
-gAAobQ8gQAAEuSFnLyEKIC25UyEQAM9xgABcBUCBBCGAoAChB/SA4sQP4gjKICIIIMCOCCAEENkA
-wQDYiiMIAFRp+mICsmCigNtoqmmqz3KAAIQEFSICBGCCBCNDBGCiz3KAAEhuNnoAogGiz3KAAChu
-NHoAsgHmIcAQdmYHxf8FzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQISATbscCCgegrv
-/qlwoQav/qTA4HjxwB4MwAOOCs/+qwRP/+B48cAyDo/+hCgLDM9ygACEBPAiDQAAIYF/gABYsmiB
-BCOCD4AAAABEIw8CL7oGv0V/BCOCDwABAABBKk4DLLrlfkV+z3KAAMwEFXoDghB2NfIEI76PgAEA
-ACPyz3CAAEy1FIiH4B30z3CAALCvAIBRIECAF/K+u2ihRCMAAga4BCOBD4AAAAAvuSV4BCODDwAB
-AABBK0EDJXgsuwUjDgCA5cOiC/IvKUEDTiGABxAlDRDT/IDl+PXlBY/+4HjxwKLBi3CuC+/+CNkA
-wIDgz3GAAHgEAKEH8gYUADEDsQQUADECsaIJz/6iwNHA4H7xwKTBi3B+C+/+ENkFzNdwAAAAQAHY
-wiAKABe4x3AADgAAg7iduJ+47HEAoQISATbscCCgAMBRIACAA8AG9ALBJgxgBADaBfA2D+AEAcEi
-CM/+ANnPcKAARB01oKTA0cDgfuB4MNnPcKAAUAwioMHZz3CgAAQlIKDgfuB48cDODI/+z3AAAEQc
-Lg3v/gDecdgmDe/+BrjPcAAATBwaDe/+CN3PcAAAyBsODc/+z3AAAMwbBg3P/s9wAAAIHPoMz/7P
-cAAABBzyDM/+z3CgANQLOIAcgM9wnwC4/1gYAAgAJoAfAADAG9IM7/4E5mG9gOU39wDeBd0AJoAf
-AAAAHLoM7/4E5mG9gOU3960Ej/7geM9xoADQDxkRAIYcEQCGz3CgAMgfFRAChh6Az3CgAMQnGRAC
-hpwRAgAVEAKGLRAChi4QAoYvEAKGMBAChoARAgCEEQIAoRAChpARAgCiEACGlBEAAJgRAACMEQAA
-iBEAABiBz3GfALj/WBkACM9xnwC4/1gZQAjPcKAA0A87gDmAz3GmANQEFxAAhiwRAIAwEQCAOBEA
-gM9xoACIJACBAYECgQOBBIEFgQaBB4Fg8eB48cDhxc91gACIg6lwDgjv/gPZAYXPcaAAgCUMoQKF
-DaEAjVEgAIAA2I64BPIPoQPwEKGmD4/+yQOP/uB48cBGC4/+z3WAAOAEAIXPdoAAFInkkOlxZgxg
-A4Yh/ANRIMCAGnAF8h+GgLgfpiCFAJE4YAClVBaAEIDgFfTpcPoN4AaGIPwDgOAM8lEgAKAL8s9w
-gAAcDwmAUSBAgAX0H4aCuB+mRQOP/uB48cDeCo/+osHPcIAAFIk+gAQhgQ///w/QBCWAXwAA8C8l
-eM91gAAUiQ4O4AYepYDghAMhAJgdABDPcYAAAAAAgeu4GvIBgeu4QNjPIOIHyiCBDwAA0ADPIOEH
-z3KfALj/HaIEgQHg07gEoQUggA/Q/gAAFqJRJcDRBvLPcIAAcA8CiAbwA4WeCuADJIVehUQiAQyg
-4ZQdAhAE9IDYlB0CEFEgwIFAKAEGafRRIoDTgrkR8kQiPtMM9M9wgAAUiQGAUSAAgATyAg/ABhXw
-/g/ABhHwRSEABs9xgACgiSiJhiH9D1IhwQFFuSV4z3GgAIgkEKHPcIAAaIkAiIDgBPRRIoDSCfTP
-cKAADCQTgFMgwIBN8kQiAFNBKIEATXCGIPwDQSgCAVElgNHPcIAAFIkI8gS5WWHHcYAAgCsV8FEl
-QNMI8nRpW2MAI4EPgADAKwvwUSVA0gnyBLk6YgAigQ+AAAAsrBhAAKwQAgCA4h/yIIqXGEIAPNgA
-qhnws7pepVEigNPFIYIPAAAAB0UhAAbPcYAAoIkoiYYh/Q9SIcEBRbkleM9xoACIJBChiiHWAM9w
-oACAJS+gz3GgAMQnQREAhlEiwNPPIOIC0CDhAkEZGIDPdYAAFIkAlQQggA8AAMyA13AAAMiACfQL
-hVEgAIAF8joIgANP8B6F87hUFYIQafIaEQCGgOIFIIAPAAAAmhoZGIAH8gHaz3CgANQLUqAE2BAZ
-GIBNcS4Pb/6KIEQOBvBmCa/+iiCFDVEggMQE9FEhAMb48891gAAUic92oADEJy4WAZYWhSJ4ZLgQ
-eIYdBBDPcYAAHA++DWAHL5EaFgCWBCCAD////wAaHhiQERYAluu4CfIA2Iu4Ex4YkBrYGR4YkB6F
-USCAgQDZmfIUlVEgQIGV9M9woAAsIA+AgOCP9BDYQcDPcIAAsK8AgFEgQIAS8lElQNMQ8gHYQMAN
-8IDiBvIB2s9woADUC1KgBNgQGRiA2fFAwSuFz3CAAOyui3MEIYEPwAAAAMKANrkRJkCQgcJAIAQL
-MPLhlceAcL/0JEEACCbOEzB2TAAMAJQVgRBRIcCBIPTPdqAALCAvhoDhGvTGhjyVMHbI989xgADE
-kcKBJYAwdhD0gOME8gLZIKMjgIDig7kjoATyIIKmuSCiAcIO8COA47kBwgryAN6evs9zoAD8RMGj
-o7kjoCuFJKAjhSWgVBWAEIDgB/IAwILgzyJiAQL0h7oAwUHCVSVAGrIK4AEA2x+FlLgfpR6FkLge
-pQ3wz3GAAMh0DYEB4A2hENnPcKAAkCM9oH0Hb/6iwM9wpACQQU2Az3GAAOySQrEagFEgQMYDsQQg
-gA//AAAAMLgEsc9wgADskgDaCPLPcYAAFIkxgVEhgIIF8kKwQ7BEsOB/WbDgePHAxg5v/phwz3GA
-ABSJDpHPdoAA7JIAts9wpgDo/wuAz3WkALRFA6YMFQOWDRUClkQRiQAvJ8cA/9gQuCl0hCQDnAQj
-CAAF9FEhAJAs9DIVAJZTII8A/2cBtv/Y9H8IuO9/ZHhALwUSACUGAAAnxwMFJsYBQC8AFgQjgw8A
-/wAAQC8HFBtjACDIEf/YBSYGAgi4BSODAQQiBgD6YgAmQAEFeuW2b3gEI4MP/wAAACi7ZXhPegO2
-RLYEFQCWArYRgVEgAIIN8s9wgAAAWDIgQAKB4Mf2z3CmAOj/DYAD8ADYBqYFpgDYSiSAcAbajbqo
-IEADKdsSu/AjjwBAJgMfFXsB4uCjAeAAkTgeABFVJkEUGrbPcIAAYI/uCq/+CNobFQCWz3GlANjL
-GaYcFQCWGqYdFQCWG6YOgRymD4EdpiYVAJYeps9wpACQfxyA4QVv/h+m4HjxwGINb/4A289xoADI
-H0ARAAbPd6AA0A8ZFwCWz3KgAMQnTxIOhriBz3CAAOyuqKARzBB2z3WAABSJBvIfhVEggIAE8gHe
-BfARGpwzaHZSEhCGFRIThhvYFhoYgFEjwKAG9FEgQKBKIgAgB/QdhQHeWnaEuB2lUSMAoQbyVBWA
-EIDgBPIA2AbwHYWFuB2lAdg6cEwiAKDMISGgXPLPcp8AuP9YGgAIEIfPcIAAcA8PiBaiANrPcKAA
-/ESeukGgZaAehbC4HqWoFQAQZOAeoRDYDqEB2BUZGICSCK/+CdhRIEDHCvTPcYAAkAwLgQHghglg
-Aguh0gwAAkwhAKAL8s9xgABEdQWBAeCSDSACBaFRAgAATCIAoM91gAAUiWTyHYVRI8CghLgdpc9w
-gABEdQjyIoAB4SKgiiCFCQfwIYAB4SGgiiDFCKIKT/4GCUACTPBCEgCGBCC+jwDAAABE8gG1HoXz
-uDzyiiCEDn4Kb/6KIRADrg5ABwCVhiD8AIwgAoAy9AINQAeA4C70A9gSHxiQ4HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeBIfGJAT
-zBEaHDAG8ACV/gqgCDSVrBUBEIDhCPKXFYAQAKkA2KwdABBUFYAQgOAk8s92oAD8JTSGAdrPc4AA
-RHUGg4DhOGAGowXyz3GAAEkIQKlThieDWWEno4DgPoUB3lDyUSHAgU7yAdnPcIAAhAUgoEjwUSAA
-oA7yAdnPcIAASQggqM9xgABEdQOBAeADoT6F6fED2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgTCIAoBPMERoc
-MAv0HYXPcYAARHWCuB2lBIEB4AShAd4ehfC4CvKVFYAQpBUBEKlyjgngAgHbBPBKDQADH4VRIACA
-B/LPcIAA4I9eCoAEz3eAAAiVGYeA4AXyMg7AAwDYGaeKCwACz3CAABwPCIDruBHygOYP9AQggC//
-AF//4P7PcIAA7JKg2cTaPdtODG/+F7sehfC4CA/CA89wgADsrgCAgOBYCaINyiBiAF0CT/7xwAIK
-T/7PcYAAxInPcIAA4AQgoADZz3KAAJCJKaLPcIAA7K4koCWgLKLPcAAA/3/PcaAADCQBoRvYBKFR
-IADEz3aAABSJFfIdhoS4HabPcIAAkAQggAWBAeAFoYoghQkmCG/+JIECCgACaQIAAEQWgBDxhsK4
-BCePHwAAAAhUFoIQ+3+A4s91oADEJwDZFfLg2r8dmJCU2pUeghAE289ygABYBWCiAto8HYCQz3KA
-AMSRIaIH8EDZvx1YkNTZlR5CEAAgkQ+AAFiywBGBIAAgkg+AAFC2uBKAoAUh0wNOCmACBSDQA4Dg
-6AEBAAHYEB0YkMgRgCDPcYAAHJDleBumbBaAEMO4HHj0IQAAZB7AFF4eBBDAEoCg5XgcpnAWgBDD
-uBx49CEAAM9ygAA8kGAeBBBkFoAQw7gcePQiAQBoHgAUih5EEM9xgABMkPQhAACOHgQQaBaAEMO4
-HHj0IgIA9CEAAIwehBCQHgQQFMyGIP+FQA1BAs9wgAAcDwiA67iECcL/HPDPcYAA0JEAgWOBQ6Fm
-eAChBIEMFQGQEngleAwdAJAA2I+4Ex0YkAgVAJCguAgdAJAa2BkdGJAGDgACz3aAABSJHYZRIMCB
-gvTPdaAAxCcRFRCWUSDAowDa1fVRIECiHfRRIICjMvRRIACj5vVRIACgXPRRIMCgbPII2BMdGJAC
-CEACgOBi9ALYPB0AkCOGz3CAAMSRIaDQ8Sv9oBYAEJEVAZYB4MO5MHCgHgAQxvWKIggAEx2YkJEV
-AJbDuBBxvPMSHZiQuvE6FQCWUSCAgB/yz3GAANCRAIHguBn0gLgAoQHYA6GKIP8ABKE6FQCWhiD/
-AQO4AaEMFQCQRiAADwwdAJAIFQCQgLgIHQCQANiOuBMdGJBRJQDQkPME2c9woACQIz2givEi/QLY
-PB0AkCOGz3CAAMSRIaAehvO4fvMTHRiUdv4E8BMdGJSJBw/+VBaAEIDgCfRCFQCWBCC+jwDAAAAE
-9FEgAKIR8r8VAJaluL8dGJCKIAQAEx0YkGoOQA1UFoAQgOBY9VEggKAO9AohwA/rcgXYiiMNAook
-gw8RBC/9CiUABM9wgADsriqAz3CgAAREJqDE8eB44cXPdYAA7JIJpSqleLVLpQHYGbXgf8HFSiQA
-egDZqCCAAgDaz3CAAOySNXhAoAHh4H7gePHAng4P/gDez3GAAAAAwKHPcqAAyDsdgsKhgODBocOh
-A/QA2ArwBIHXcGWHIUP79YoghAAAoQGhgODEoQ3y0Nmfuc9wnwC4/z2ggtgUos9wAIARFA6iiiDF
-D891oADIHxkdGJAB2AhxCHIIcxYKL/2YcM9wgAAUANdwgAAUAAzyCiHAD+tyBdhb24okgw81Ay/9
-uHPPd6AA0A/Vp4XYCbjPdqAAwC96HhiQ9gnAB6ILwAguCUALQNnPcJ8AuP8yoMYOT/6A2c9woAAU
-BCygHR9YkIIOQAf6CsAGlg1gBwDYPggACwfYSB0YkFYKD/46DAAKz3CAADB0AJCH4GgLAgrmDoAK
-pgqADpoJwA0VhlIgAABRIACABvRWC6AKAd8Q8APfE4aauBOmIN4F2NClQx0YEADYYglv/o240aXP
-cIAAMHQAkIfgIAsBCo4JD/4uC0ADog+AA/oLAADCDkADmgnAA5YKwAnGC0AI2gnADFoMQA2qDUAN
-sgxP/Yogxg3PcYAAHA8NsQPYbRkCABvZz3CAACA25gugAjCoJgiP/zoMQA3WCo/+Fg+ADpYIwA12
-Dy/+6XBRBQ/+8cDSDC/+AdmlwRpwCiKAL4AA7ARmCW/+i3BMIECgABSFMAEUkTAG9AoigC+AAPAE
-TCUAgMT2TCUAgcv2CiHAD+tyBdic28UBL/1KJEAATCUAgCYBDgCocAAWjkAAFpRATCQApHpwhfaM
-JMOvKPQAFgBBABaPQAAWgEAAFgBBTCQApH4ACgCA5yXyz3CAAOQEAIBALM0gtX0Q4Lhg3ghv/gTZ
-z3CAAOQEAIBMIUCgHWXMJ2GTFfQA2Iy4FPAKIcAP63IF2KfbSiRAAEEBL/0KJQAFCiHAD+tyBdiw
-2/XxANgAtc9wgADkBCCAQCzAIBV4EmEZYQUiQAQAsQTdBvCBwATdeghv/qlxACKMIwAcAhXPcIAA
-hATwIAIEHt+A4i8pgQACJ0AQJPLPc4AAL200aCtjESOAgwnyACaBH4AAlIMWeQAZAgUALYETCyHA
-gAnyACaBH4AAlIMWeQQZAgUQIgKALymBAAInQBDg9UIjQCCA4OgGzf/CDw/+rQMv/qXAANhA8fHA
-4cWtwYt1qXDuDy/+DdkAwB14UyABAEQpPg2pcAAhgX+AAMhufghv/g3ahg8P/qkDL/6twOB48cAK
-IcAP63IF2IojjASKJIMPPQAv/UolAADgePHA4cUg289xoADIHGmhABYAQM9yoAAQFAyiABYFQAHd
-TCUAgMohwQ/KIsEHyiBhAcojgQ8AAPkA+Afh/MokQQMYGkABaBlAAQPYD6K5oWqhDg8P/jEDD/7x
-wLYKD/6kEAEA+bmiwXD0INnPc6AAyBwpo6QQAQBRIcCBLvIxiM91oAAQFCO5wLkDuQXhA9pPpUaF
-QcKN4RDeyibiEQYUDzGMJ8OfCPQEFA8x8XbMJ+qQAd5D9gDegObq9cWARX7HpbGIhiX8Hxi9pXrP
-daAAzBdaoBfwRYDPcaAAEBRHoaQQAQBRIYCCCfIxiNe6hiH8Dxi5RXk6oM91oADMFw3ZAdoD4Q0d
-mJAOHViQJoAZHViQJ4AaHViQKIAbHViQA9kUHViQcBABARAdWJBwEAEBz3WgAPQHBOEnpUejpBAB
-AJm5pBhAADECL/6iwOB48cADyKQQAQD5uQQPwf8D2c9woAAQFCWg0cDgfgDagOHKJE1w4HjoIO0B
-/9lcYCCsAeLgfvHAz3OAAOwEaHAE2ff/BGsE2fb/6PHgePHAgg3gCRDYb9kHuc9yoADwFzGiz3EA
-APD/OKLmDsAJ1vHgePHA8f/2/9LxgeDPcYAA7AQD9ARpAvAocATZyvEPe0i4D3jPcoAAAFb0IgAA
-QCgBAki4BXn0IsAAMHngfyd44HjxwBIJD/6lwQh2AosodZhwZMAAiwASBgERHAIweXACEgcBBBII
-ARAUADHkkgYSBQEAIMkDAJEvIUgSByBAAhB45/8AIIoBAZUvIogSByCAAhB44/8AIMYBApUvJogB
-ByCAARB43v8AIAcCA5UvJ8gBByDAARB42v8AJQUABJUvJUgBByBAARB41f8fZwWV8H/neBB40v8m
-lSFwEHgHeTx6D7klelB6ACKBAjB5ABxEMEeVJ3pceQ+6RXkweQAhggFQelx5AhyEMA+6RXkweQAh
-wgFQelx5BByEMA+6RXkweQAhQgFQelx5BhyEMA+6RXkweT9n8H/8eQgcxDMPv+V5MHk4YGlxxrmF
-uQi5BSHBAiC2EHgglQocBDAneBx4CLgFIAABAbYAwAGmAcACpgLAA6ZJAC/+pcDgfuB48cDhxQh1
-PojPcIAA5ARAgEAlABQDuTV5WWH+DC/+CtqpcPf/KQAP/vHApg/P/Qh27IgIkM9ygADsBLRvCHOG
-I/MPQisRAsd1gAAobWCF7btIcQPyJGrruIogwy8D9B4WkBBNjlEiAICc8uO4O/TruxTy/9gHrUok
-AHEA2KggQAMKYQAggw+AAJSD9ntEqwphAeAPeECrWvBMIQChjfYKIcAP63IF2IojCwFKJEAATQTv
-/AolQATuuEeNMiFABAAhgS+AAJSD9nkI8gSpBNgAKEAERXgHrTzwAKkPIkIER61e8EwgAKSU9owg
-w6/KIcIPyiLCB8ogYgHKI4IPAADYAsokYgD0A+L8yiUCBMlwvf8Ilu64BPICjgmtBPABjgitAIXr
-uBfyANlKJABxJ62oIIADACGAD4AAlIP2eAQYAgQAGAIEAeEveQGOCK0CjgmtKPBMIQChyiHKD8oi
-ygfKI4oPAAD1AkYH6v8F2AiWACGBL4AAlIPuuAeN9nkJ8gQZAgQE2QApQQQmeAet4PEAGQIEANkP
-IUEEJngHrQGOCK2NBs/9QYkEuMdwgAAobUioIongfymo4HgRiOB/wrjgeOB+4Hjhxc9ygADsBIDg
-wCIiAf/dFGkAIIMPgAAvbaCrSiQAcQDbqCCAA21iACOAD4AAlIM2eKSobWIB4297oKjgf8HF8cDS
-De/9mHClwSh3uHMA3gQjgA//AAAAGLoFem95CLn/2Ai4ZHgouAV5RXkI3fQkgAMneETAEBQAMRn/
-EhQCMWG9QCgBBAV5R3lEwRAUAjEUJIAzgOVAsAHmK/dTJcIFQKcAFA0BB9kG8BB9FCdMEAC0YbkU
-JEAwu3tPvQCQpXuB4XB7eGAz9wQggA8AAAD/ELgFel8F7/9Ap+B48cA2De/9INkA2s91oADIHCml
-z3GgAJQTW6HPc4AA5ARgg/Noz3aAABSJDIb1f1MgxAXwY/tjUyCPAIPnpMGLcRr0HoabuB6mNBaA
-EOKL8XAK9ChwQCMBBERrQCYDHPL+Ddoq8B2GkbiSuB2mz3CgAMwXK/CF5w70QSoCUkAjAATBuohz
-uP8ehpy4HqYN2hTwLLhTIAIAHoYDupm4HqbkgwXiBScAEQChBYMBoQaDAqEHgwOhA+LPcKAAzBfP
-caAAlBNcoQHagOIH9B6Gl7gepiDYCqUY8ADBA9oYGFiAAcEZGFiAAsEaGFiAA8EbGFiAFBiYgIYW
-AREQGFiABNknpRYYmICZBO/9pMDgeOB+4HjxwCYM7/0B2aHBsggv/otwIMDPdYAALCkApYogVwp+
-Cu/9AhIBNoogVwpyCu/9IIUAhUDZUSAAgEDBBvSaDS/+KHAs8M9wgABMgRoKD/4A28SFSiQAdOaF
-qCCABwDYz3GAAEyBdXkjiQ8gwADhucoiAgDKIiEARX7gucoiAgDKIiEARX9RIYCAyiAhACeFAeMl
-eAel5qXEpd4Pz/0AhSe4wLgbeL4Ib/4C4OUD7/2hwPHA4cWiwYHgAdjAeEDAiiCXCtoJ7/0REgE3
-iiCXCs4J7/0AwQDBz3KAACwpZYKA4aGCA4IK9CaCZH2keSZ7QcFloiV4A6IK8CSCBH2keSZ4JXtB
-wQOiZaKA4Q3yjgnv/YoglwqLcAjZW9oe2yIN7/0Yu30D7/2iwPHA4cWhwc91gADABKlwhg/v/QHZ
-iiBXCloJ7/0CEgE2QI2KIFcKIY0QukoJ7/1Fec9wgABkKACAgeAB2MB4QMCLcA4ML/4E2QCNUSAA
-gAGNBPRiC0AGBPD+C0AGGQPv/aHA4HjhxeHGmHDPcoAATCkFgiCCZoLIuBC4yLkFIQGAAYLIuxC7
-yLgFIwUAZ4ICgsi7ELvIuAUjBwBoggOCyLvIuBC7BSMGACTyABQOAC8oQQBOIIMHANgPIMAAEn0E
-IEMBpH5lfgAcgAPagqR+xXt6onmCBCCOAQQgwAGke8V7eaJ4gqR7BCFBg2V4GKLf9cHG4H/BxeB4
-8cD+Cc/9OnAFgaCByLgQuMi9BSUNkAGBJoHIuMi5ELkFIRAAAd4b8gQlgJMU8i8oAQBOIIIH8CGB
-IIDhAN8PJ48QCfIEJwAUQiAAgGB5yiBiAOZ9gOXbfuj1BQLP/eB48cChwQHYAg0gDUDAz3CAAEwp
-CoBRIACAyiACB8ohIgHKIoIPAABnAMojYg+QC+L9wCviBaHA0cDgfuB4ocHxwGIJz/2jwQh1SMDP
-doAATCkahvuGPIYEfyR/p39Bx74Pr/2KINgEiiDYBLIPr/2pcYDnFfSA5Wn0Dgvv/AfYgOBj8goh
-wA/rcgXYiiPGC0okAAA5Bq/8CiUAAQQUATGA4RnyIBQAMQsgQIAN8s9wgAC4BGCAz3EAAPhwDNhg
-ewPaCfCA4Af0z3CAALwEIIBgeQzYBhQBMYDhGfIiFAAxCyBAgA3yz3CAALgEYIDPcQAA+HAN2GB7
-BNoJ8IDgB/TPcIAAvAQggGB5DdgEJ1CTC/JOCu/8B9iKIBgIAg+v/QpxEvCA5RD0iiDYBPIOr/2K
-IccGQgrv/AfYiiAYBN4Or/3pcbD/vKYI3L8A7/2jwOB48cDhxaPBAdhAwM91gABMKalwgg7v/VzZ
-OoUbhSR4PIUEeYHAQcFm/wHAO4UEeUHBmg6v/YogWARVJUAfqXGF/89wgADEKkAlARuC/4twWgkv
-/gTZAcCm/1oLAA0AhYDgBfQFhYDgTA7B/2UA7/2jwPHA3g+P/aLBAd3PdoAATCk6hhuGJHg8hgQh
-EAA+Dq/9iiCYA0wgAKBVJk8XKvID8Lt9BCBAo/7zLygBAE4gkQfwJ0AUXB5AFIDgyiHBD8oiwQfK
-IGEByiOBDwAACgLKJAEEqASh/MolQQRAeIogmAPqDa/9KnEA2A8gQAQGIBAgCnB//4ogmAPSDa/9
-PIaxB6/9osDxwEoPj/2mwTpxGnJgwADYARwCMAHYAhwCMAMcAjCLcG4KIAuBwQTBCnAjIEAEBcID
-wIDgC/QKIcAP63IF2N7biiTDDzEEr/y4c0B4XQev/abA4HjxwPoOj/0acCh1SHdodjhjZtk92joI
-7/0XuoHgCfQKcBIIL/6pcelwxgjv/clxMQeP/eB48cDKDo/9CHYA3Yog2AMyDa/9yXHPcIAATCla
-gDuARHkA2g8iggMEIkMAQiMDgMojYgAvJsfwAd/KIEEDBvIcgCR4RXhH/+lw6QaP/eB/ANjxwHIO
-j/0acCh3OnLPdoAAHA8Uls91gABMdBC40g+gCAClgODKJyIQhSEHKU8hQCefuOxxAKHscQAZAAQI
-hlEgAIAF8gCFgbgApc9wgADMBgCIgOAE9ACFg7gApc9woAAsIBCAAN5tHRgQSiTAcMlxqCAABs9w
-gAAtCACIgOAM2MogIQBEKb4Dz3KAAJC9J3AzIgAAACGCD4AAzHUB4QCqgOce8gCFYhUPFqlxYxUE
-FoC4AKUA2Afw7HNAowQZkAMB4PfgQIG6989woADUC02gwKFiHdgTYx0YERDwANmpcgXw7HMAowTi
-AeH34QCCu/fPcaAA1AsNodkFr/3UHYAT8cDhxaHBCHU+D6/8F9jPcIAA9AQAgIDgFfSd2AAcBDAR
-zKlxHtoCHAQwAeAQeAQggA8AAP+/j7gRGhwwAMAYurD/TgjABa0Fr/2hwADY2vHxwOHFABYNQAXM
-AdrXcAAAAEACyMIiigAXusdyAA4AAFMlARCj/1ElQJDPcYAA9AQB2MogIQBtBa/9AKHxwOoMr/0A
-2M9xpwAUSAihR4HPdoAAlIZfplCBz3OnADREgB6AEAehz3LzD//8UKEWoaDZmrn1G1gAz3GlAAgM
-CBEFAEwlAIDKIcIPyiLCB8ogYgHKI4IPAAD/ArQBovzKJCIAz3KkALg9mxIDBs91oADIH3umphID
-BiDffKaSEgMGfaajEgMGfqZQ22KhmxoYAP/ZphpYAJIaWACjGlgAz3GkAOz/B6HPcAAA//8GoVEV
-EJYB2FEdGJDwpUMdGBAA2CYI7/2NuPGliiDEAM9xoADsJwahCoFoHgQQiiDNAAahCoFqHgQQz3Ao
-AAIBBqGKII0ABqFRHRiUVQSP/eB48cDhxQhyAd2A4cohwQ/KIsEHyiBhAcojgQ8AAJEAyiQhAPAA
-ofzKJQEBgOJE9lN6iiX/H4DhRPYzebN9FCGAAH4NIAY7eax4HQSv/S9w4HjxwIYLj/16cJpxSHca
-cwolACEA2s9xqwCg/1mhB9gaoVihIN7PdaAAyB/QpQHYQx0YEADYYg+v/Y240aUZ2c9wpwCYRzqg
-MgggCh7Yz3KnABRIHYK+gmwSEQBwEhIAAKcAGEAj97jFIIIPAP8AANMg4QX3vcUlgh8A/wAA0yXh
-FYohEADL/wh2qXCKIRAAyf8IdUApACKKIQgAxv8Id0AqACKKIQgAw//ReRnhLHkvcbF6GeJMei9y
-MHcAG4AjABxAI4T2ANgF8FBwfvYB2AkDr/0AHQIg4HjxwMYKr/0A2c9zoAC0D7yDPKPPcIAAlIZo
-EAIBELpPIk4AiL7PcqAA7CfGomoQDgEQvoUmjRDGot+Az3enABRIx6eAEA4A0KfPdqUACAwipvuA
-z3akALg9mx7YE/yAph7YE/2Akh7YEx6Aox4YEM9wpADs/yagiiCKAAaivKPWDKAAAdipAo/98cAW
-Co/9z3CAADB0B4iA4PQEIQCswc9wqwCg/2QQGQBoEBcAYBAYAAfdSv8A2c9wqwCg/zmguqA4oLII
-oAkB2M93oADIH1EXAJbPdqAA7CdAwAHYUR8YkCDYEKcB2EMfGBAA2NINr/2NuCDYEafPcacAFEis
-oQDYDaEOoQ+hz3AAAAEqBqbPcKUA6A+noCDYEKcF2EMfGBAA2J4Nr/2NuCDYEacB2M9xoAC0Dxyh
-z3AAAAIvBqbPcAAAwjAGps9wAABCSAamz3AAAAJKBqbPcAAAAmIGps9wAADCYwamSiAAIM9wgAAw
-dCSQC4hEKb4HGGAVeGq4ACBBDhUgACQ4YMdwgABEKwMQlAAEEJUAARCSAAIQlgAgiBC5BSGBDwAA
-Qi0mpiCIELkFIYEPAACCRiamAIgQuAUggA8AAEJgBqYg2BCnBdhDHxgQANjqDK/9jbgg2BGnSiEA
-IBDwz3CAAAiCFiBABEQYgAFBhUgYQAFAIVEgV6A4oM9wgAAwdAaQMnDoAg4Az3GnABRIXBlABEAq
-ACRPIEEAh7mJuSamCHGFIYsAJqaFIIwABqZMIQCgE/JMIUCgHfJMIYCgJfRALAAkBSCBDwAAgmAm
-pgUggA8AAEJiGPBALAAkBSCBDwAAgi0mpgUggA8AAEIvDPBALAAkBSCBDwAAwkYmpgUggA8AAIJI
-BqYg2BCnBdhDHxgQANgmDK/9jbgg2BGngcCCwUAkEzuJworDCiTABB3/K8CA4EbyCcBAKU0hx3WA
-AIyBAKUKwAGlAcAYpQLAGaVALgAkhSCKAAamINgQpwXYQx8YEADY0guv/Y24INgRp4PAhMGJworD
-CiTABAr/K8CA4CXyCcBMIQCgAqUKwAOlA8AapQTAG6Ui8kwhQKAq8kwhgKA09EAtACQFIIEPAACC
-YCamBSCADwAAQmIn8AohwA/rcgXYiiMEAabwCiHAD+tyBdiKI8QDoPBALQAkBSCBDwAAgi0mpgUg
-gA8AAEIvDfBALQAkBSCBDwAAwkYmpgUggA8AAIJIBqYg2BCnBdhDHxgQANgiC6/9jbgg2BGnhcCG
-wYnCisMKJMAE3v4rwIDgbPIJwAalCsAHpQXAHqUGwB+lINgQpwXYQx8YEADY6gqv/Y24INgRp0Aq
-ACSFIIoABqaHwIjBicKKwwokwATN/ivAgOBW8gnACMEEpQrAAcMFpQfAHKU9pQPBAiHCAAXDWGAC
-IMWATfJieUx5L3Cocaz+A8FAKI0gtH0VJU0UAnnHdYAAlIYCwATCIaUIwwIiAQAGwDtjAiMFgD3y
-Anosei9wqHGf/gTCBcMCIgEAA8AnpQIjBoA0HYARNPIGwAIghYBsBeL/TB1AEQohwA/rcgXYiiOF
-ARvwCiHAD+tyBdiKIwQKSiQAAEkDb/wKJQABCiHAD+tyBdiKI8QM9PEKIcAP63IF2IojxA4pA2/8
-iiSDDwohwA/rcgXYiiPED/fxCiHAD+tyBdiKI8UAiiSDDwEDb/wKJYABQCBQIEwggKByBMX/ANjP
-caAAtA8cob/+z3GrAKD/ZBlABmgZwAVgGQAGSiQAcQDZqCDADChwgCCCDRB4BriBuJe4BqYocIAg
-Qg8QeAa4gbiXuAamKHCAIMQGEHgGuIG4l7gGpihwgCCECBB4BriBuJe4BqYocIAghgAQeAa4gbiX
-uAamKHCAIEYCEHgGuIG4l7gGpgHhAMBRHxiQUQVv/azA4HjxwCINb/2YcKHBz3KAAPgEIIrPc4AA
-lIYBgoQTAwCQccwgwYDq8nBwBvLPcIAArIchiCCqSiTAcEogABCoIMACz3CAAKyHMiAAApBwA/JA
-IEgQTCDAkKQBBgDPcIAArIcBiJBwBvQEIQEBLyVHAAbwByAAAS8lBwBhogDbz3CgALQPcBASAHyg
-ABoCARTwQCCAIRB4BriBuEApASQleAamQCOBETB5BrmBuUAqABQleAamAePPcIAAMHQGkBBzMgEG
-AADZDyHBAAshQIEB2MonAgAN9AshAIHt889wgACshwGIkHDn8wonAAKA4xHygeNn8oLjBvSKIIYg
-iiFGAgzwCiHAD+tyBdiKIw4LZPC22r3ZGnJ5cc92oADsJ0ohACBKJABxCiJAFCp1qCCBAgAgQSNU
-a0AvAAEUeBpitXrHcoAADIcIkjB5QCmJAU8hQRAcfxC/5XkmpsC4uHgFIEAELyEIIAAjTxMJkvB/
-Br9PJ0YQHHlAKRMEBSOBISamwLi4eAUggQIvIkgQRSHAEAamCoaLcQCxCJIvJgEAABQAMdBwFPRF
-J88Q5qYKhgCxCZIAFAExHHgwcBT0AeVp8YoixAaKIYQIp/EKIcAP63IF2IojDwBKJAAAfQBv/Aol
-AAEKIcAP63IF2IojjwD08c9xoAC0D3AZgASBA2/9ocDgeADZz3CAAKyHIKghqOB/IqjgfuB48cD2
-Ck/9r8HPcIAAHA8IgM91gABEK8C4QMDPcIAAMHQkkAuIRCm+BxhgFXhquAAgQQ4AwBV4OGAZZSOJ
-QcEZZSSJuGACiELBQ8DPcIAAlIYAgCK4wLhEwM9wgACUhmQQAQHPcIAAyAYAkBBxSiEAICf0z3KA
-ACA2LYrPdoAArIeGIf8BYI5Due6KT4oCIcGAYY6GJ/8RyiFiAEO/DiPDg4Yi/wHKI2IAe3tleXtq
-Qo4OIsKAyiJiAAK6RXkC8AfZgOEGBCEARcHPcaAAtEdHEQGGgOHyAwEAz3KAACA2LYrPc4AArIeG
-If8BQ7kgqy6KhiH/AUO5IasvioYh/wFDuSKrz3GAAJSGZBkEAADZnrnPcKAAtEdTGFiARv3PdqAA
-yB9RFg+WAdhRHhiQINgQpgHYQx4YEADY3g1v/Y24INgRps9xgAAwdASRK4nPcqAA7CdEKL4HOWE1
-eWq5ACFADgDBNXk4YAllELkFIYEPAABCLSaiCWUQuQUhgQ8AAIJGJqIIZRC4BSCADwAAQmAGolEe
-2JPPcKcAFEgMgM9yDwAA/M93gACUhkbAAMACuBR4G2cdZxlnACcEEAAnBRAfZwmHYYOnhQbHIBQE
-AIDnIoEMFQUAG/QKu0R7yb2le891pwAUSG2lCrkkeohxyblFec9ypwAUSC6iQC2BAgQhgQ8PAAD8
-ybgleBrwCr1Efcm7pXvPdacAFEhtpUAsgwJkesm5RXnPcqcAFEguogq4BCCADw8AAPyoccm5JXjP
-cacAFEgPoUoiACAD2EfACiNAJAXAESCAhDoCAQDPcYAArIcyIYAEQnFIwc9xoAC0R2AZGIAQuJu4
-z3GAAKycIImfuIDhAdnAeQ+5JXjPcaAAtEdfGRiABfBCCW/9iiAIAM9woAC0R3EQAIYEIIAPDgAA
-AEEofoTx9QDfAvAB589wgAAwdAaQEHfKAQYACMAAiBEgwIP18wDAArgUeEnAAcECwIDnAiBZAM9w
-pwAUSPegC/KB53vygucL9IohhiCKI0YiBfC22L3ZOnB6cUokACGKdUAvWBFhvVEWEJYB2FEeGJAg
-2BCmAdhDHhgQANjqC2/9jbgg2BGmA8A1bSV4EHgQuIUgigDPcaAA7CcGoQAlQBQQeAa4gbiXuAah
-ACXAFBB4BriBuJe4BqFAIYAhEHgGuIG4BqFAI4AhEHgGuIG4BqFRHhiUQCQEPorAi8GMwo3D/Pwu
-wIDgDfTPcIAAlIZ8EAAGz3GAAJSGAeB8GRgACcAGwfV4gOHHcIAAlIYa9IvCYIKKwSCBisJgoovC
-IKKNwmCCjMEggYzCYKKNwiCiM4A0EBAACfCKIMQGiiGECI3xLYBMEBAAFiBAMwrCACCVD4AAjIEL
-wPAdgCD0HQAgCCKAD///Af8vJkAmBC4+IC9wxPwOIJcPAAAAAQvAiCB8AAQovgUvcApxvvwOIIEP
-AAAAAQkngC8AAP8BiSHHD0ggAABIIQEALsJUHRgggeJVHVggBfIEwoDiDPRUb0AqAyF0e3pitXrH
-coAADIcIsimyQiRUIEwkAKCMBs3/F/EHwGG4gOBAIlIguAXt/0fAOgpABe78BfAyDy/9iiAIAM9w
-oAC0R3EQAIYEIIAPDgAAAEEofoTx9XEGL/2vwPHAocGLcIoMb/0E2QDAUSAAgAQMgv8AwFEgQIAY
-C+L/yiCiAADAUSCAgHQNQgoAwFEgwIB4CkIKAMBRIACB5AlCBZ4IYAAB2M9xgK7gAexwIKACyOxx
-AKHPcoAAjIGKJIF9ANmoIMAB8CJDAOxwYKAB4QoJb/0A2KHA0cDgfuB48cDSDQ/9z3CAAJQFAICF
-4LwABQDPdqAArC8ahlIgAABRIACAVPTPcYAAjIcJgQHgCaHPcIAAuJxAgIDiA4AVeQXyCoEB4Aqh
-BPAYgQHgGKEYhs91oADIHyDfmrgYpgXY8KVDHRgQANhiCW/9jbjxpYz+GIazuLq4GKZk2PClQx0Y
-EADYRglv/Y248aXyC4AJPgkACRYJQAAF8PINL/2KIAgAz3CgAHhFAIAEIIAPDgAAAEEofoTz9c9x
-gAAcD0iBNJFTIgAArggv/QHb0g4v/BHYaQUP/eB48cD6DA/9z3ClAOgPB4DPcqQADEJTIASARCCN
-AEQgAwECgs92DwAA/AhxybnEeOOCKrjYd8R/QS+FEuSCUyZGAulyybrkfiq+BvKe4YT3jCFPiMT3
-ANkD8AHZTCQAgATynuBE9wDYBvCMIE+IPPcB2IDlG3gleAXyTCaAh0P3ANkF8IwmT4g99wHZgOUC
-uQV5BPJMJYCHRPcA2AbwjCVPiDz3AdiA4wO4BXkE8p7iRPcA2AbwjCJPiDz3AdiA4wS4BXkE8p7m
-RPcA2AbwjCZPmDz3AdgFuCV4QiAAgIUEL/3KIGIA4H8A2OB+4HjPcKAALCAQgOB/CeDgfuB44H8B
-2ADZlrnPcKAArC88oOB+4HjgfuB44H7geOB+4HjgfuB44H8A2OB+4HjgfuB44H7geOB+4HjgfuB4
-8cC+Cw/9z3CAABAGAICA4CAPAgjPd4AAAAAAh1EgwIBKIAAgGvIBh1EgwIBA2M8g4gfKIIEPAADQ
-AM8g4QfPcZ8AuP8doQSHAeDTuASnBSCAD9D+AAAWoRTM4LgA3j3yz3GgAMgfsBECAM9zgAAcD2oT
-AAFjuAgiAAAeoRDYDqEB2s9wgADEjRUZmIADGhgwz3CAAIiOBxoYMAiD67gJ8s9woAC0R0sYmIN3
-GJiAsguAA89wgAAoBQCIgOCsCIIJBCCPTzAAAADPcKAALCDPdaAAyB8j8O24yiWBH6AAyB/KIIEP
-oAAsIBjy7g8AAc9wgAAcDwiA67gH8gDZnrnPcKAA/EQioBTMz3WgAMgf77jPcKAALCAm9Ap3z3GA
-AJAMw6HFoQOAlQIgAAehFcxTIECAEvIHyAMSATYDGhgwBxpYMB4LgAPPcIAAKAUAiIDgGAiCCc91
-oADIH2ECIAAA3gTYChoYMB+FgOCKIAwAyiCCDwAAAAIOpQPYFbgSHRiQz3CAABAGAICA4MQNAggA
-hwQgvo8AAN94gAMBAM9wnwC4/92gdQMAAArIz3GfALj/FqHPcJ8AuP9YGAAIHoVRIEDFMfIKyIYg
-8Y8t9M91gACQDAOFAeACDyABA6XPcIAAHA8IgOu4CPIA2J64z3GgAPxEAqHPcIAAFIkdgIYgvo8E
-8gWFAeAFpc9wgAAAAACA67gH8gDZz3CfALj/PaBKIEAgFMzkuIT15riN9YYg/4Us8lEjAMCQ81Eg
-QMWM9RTMz3WAAER1USDAgDfygNgUGhwwFczruAjyGIUB4BilSiAAIAXwEIUB4BClz3CAACA2EohR
-IACA2AsiAMogYgCA5wTyF4UB4BelFMznuADeVPIVzAQghA8AAAAYDCSAjwAAAAgd9I4LoAIKcFEg
-AIAV8gjYm7gO8IogBAAUGhwwD4WA5wHgD6Xi8xaFAeAWpd7xChoYMG/wBNj88R4MgAAVzFEgwIAd
-8s9xoAAsIAWBJoEK4DBwMfcDEgE2AtgUGhwwUNjiDSAAmBEBAFYJgAPPcIAAKAUAiIDgUA5CCUvw
-A8igEAAA8LjJcBnyhgmAAADYlrgV8Oi4FvKSCqAAiiAEALYLoADJdQPIoBAAAPC4qXAF8l4JgAAA
-2JW49guAAL3x6bjPcqAAyB8H8kYJoAAB2ADYkLjz8e64CvJRIwDACPKKIAQADqIE2AoaGDAVEgE3
-77kR8kASAgbPcIAAjIkNkBByifevuRUaXDDPcIAA7K7AoM91oADIHwrIBCC+jwOA6EPoBcL/USBA
-xeAFwv8/haAVABAJIQAA5ODT9s9wgAAIgQCAUSBAgAvy3qUQ3zoKIAXpcIDgBfQB2B6l7qWKIAgA
-oB2AEw6lH4Wo4Ej3gOAE9IogBAAOpVYJQAkv2JW4Eh0YkM9wAQDA/BUdGJACCYAAz3KAAGAFAIKH
-4B/yz3CgADguBYAEIIAPwAAAANdwwAAAAA7y9dkFuc9wnwC4/zqgB9k7oGnZGLk5oAHYA/AA2IHg
-A/QH2ACiz3CAABAGAICA4MgKAgjPcYAAkAxEgQOBCCIAAAShRYEGgQgggAAGoXyFB4FIgQJ7AMoI
-IsIAiOBIoQn0A9nPcKAAQC0woAAagjME8AHgABoCMM9wgAAAAACABCC+jwAA33gF8s9wnwC4/92g
-z3CAABwPCIDruBTyz3CAANwDEHjPcaAAtEdJGRiAz3AARBQASxkYgEwZmIMD2HcZGIAJB8/8z3CA
-ACkFQIjgugjyz3GgAKwvGYGKuBmhUSJAgAfyz3GgAKwvGYGOuBmh4H7xwOHFB9kbGlgwz3CgANQH
-GhhYgA4QDYbPcYAAAABAgVEiAIILGlgzGvJBgVEiAIJA2s8i4gfKIoEPAADQAM8i4QfPc58AuP9d
-o0SBAeLTukShBSKCD9D+AABWo89xoABILL6hHxAAhgIaGDAIypzgzCCCjwAAkQAF8gAWAEAAFgBA
-BczPcZ8AuP8YoYogRgReDO/8AhIBNlkG7/wIyuB48cDhxc9xgAAcD0iBUSIAgCjyhiD/Ac9ygABQ
-WEO4CmIA24DiyiHBD8oiwQfKIGEByiOBDwAAWgDKJMEAwALh+8olIQCB4s9wqgAMUL6Bx/eAvb6h
-AdkloATwoL2+oWWg8QXP/PHAbg3P/Bpwz3eAACA2EI+GIP8BQijRAM92oAC0Ryp1BfAODu/8iiAI
-AHEWAJYEIIAPDgAAAEEofoT19UMWAJZGIAANQx4YkFcWAJa8uL+4Vx4YkF8WAJa/uF8eGJAA2J64
-Ux4YkBCPYB4YkMz/z3CAADB0B4iA4BTyEI+GIP8Bxg9v/0O4z3eAACwFFI8QdQjyz3CAAFA+FoBA
-eBQfQhTKCAAKQxYAlkwgwKBFIAANQx4YkIAADQAKcDMmAHCAANRbQCeBchR5AHkQvZu9z3CAAKyc
-AIifvYDgAdjAeA+4pXhfHhiQIPDPcIAArJwAiBC9gOAB2MB4D7iYuJ+4pXhFIMABXx4YkA7wEL3P
-cIAArJwAiJ+9gOAB2MB4D7ileF8eGJAKyITgBA7h+8ogYQSdBM/8CiHAD+tyBdiKI04HSiQAAFUB
-7/sKJQAB8cAqDO/8AdnPcIAAHA8IgMC4G3gA3s91oAC0R0sdmJN3HViQz3GgAIRE2KEC2XcdWJAA
-2Z65Ux1YkFQdWJDPcYAAOAFHHViQjrjPcYAAKABFIAYNSB1YkM9wgAAcD0kdmJMakAK4bLhEHRiQ
-HNhFHRiQz3CAAERLAYhGHRiQz3CAACA2EIhz/0okwHDPcYAA5JHJcqgggAPPcIAA1JxWeGGA8mr2
-fz9nAoBipwHiA6fPd4AALAUAh4DgBPJkHRiQQx2YkQHYfP/PcIAAHA8ogOu5EfLPcIAA3AMQeEkd
-GJDPcABEFABLHRiQTB2YkwPYBPBLHZiTAdh3HRiQUSEAgECHDvJTIkEAErlEIgADDrgleIYi/wMK
-ukV4EvBIcIYg8w8KuAQigQ8AAAAMBrkleAQigQ8AAAAwArkleM9xgADUSlED7/wCoaHB8cDKCs/8
-z3KAANScYIKlwWh1hiX+EyS9Dr0GIUIDwrsOu2V6TsIEIoMPAQAAwEErhANALA0GnL3Pc4AAHA9o
-g5+9z3aAACwFUSMAgM9zgABALBYjAwEF8vCD5KZxgwTw4INhg+Sm5rhjpgjbC/IL2wQivo8AAAAY
-yiOCDwAADwTkuHpzzyXiFgX06LjPJWIXUSCAggbyz3CAAGgFIIDpujHyBCGBDwEAAMAuuc9wgABQ
-WCtgSSODAGG7z3CAABwPYhCAAC7HMms0ecdxgABskOR4SBERBkkREgaGIP8OCbhALA4CxXgFfwQi
-gg8AAAAQRX+evRjjb3sDyLkYwgBX8Oi6IPJEwSTDoOPKJsIQyiYhEAQhjw8BAADAz3CAAABYa2AE
-IYEPBgAAADG5Lr87Y89xgABQWOlhYnk2fi7BK2AV8FMhwAAdeM9zgAAwWw5jBCGBDwEAAMDPcIAA
-UFguuShgYbgWfgHbmOaM9wohwA/rcgXYiiMGAYokgw+JBq/7uHYybjR5x3GAAGyQABERAAQREgBh
-uwQigg/vAADdJrplegPIUiLPA7kYggPPcoAATCkagluCRHhRIACCB/Iigc9wpwCISS+gOBQQMOlw
-hiDjD892oAC0R0EoFAIG8LoJ7/yKIAgAcRYAlgQggA8OAAAAQSh+hPT1iiD/D28eGJBrHhiQA9kP
-uc9woADIHxMYWIBZHpiUWh5YlFse2JNYHtiU+71KJQAAC/IegAK4QiCFA0glBQCocMm4BX3PcIAA
-1JwHgADZDyEBBSR4gODPcIAAzAQB2UCAwHlTIgCAr70I8oYifw9deg+6RX0F8IDhzyXiE1ceWJOA
-4Ab0gOEG2Mog4QED8ADYz3GAABwPKIFRIQCAE/JPIAECjbmXuRUeWJAFIIEPgABAOhoeWJAFIIAP
-gADAUxHwBSCBD4AAwCQVHliQBSCBD4AAAD4aHliQBSCAD4AAgFcXHhiQz3CAADB0BJCB4A30hBYB
-llAhAAMEIYEPAAAADK24ArkleAPwhBYAlhYeGJCMJc+PyiHGD8oixgfKIGYByiOGDwAA+ADkBKb7
-yiTGACpwugkgCgpxCNzvB6/8pcDgeKHB8cCOD6/8mHDPcIAA1JxggKTBaHCGIP4DJLgOuAZ5wrsO
-u2V5TcEEIYMPAQAAwC67geIB2MB4BrhWIEAIQCsNBpy9z3KAABwPSIKfvc92gAAsBVEiAIDPcoAA
-QCx2egXy8ILkplGCBPDggkGC5KbpuUOmLvIEIYIPAQAAwC66z3aAAFBYSmZJIoIAYbrPdoAAHA9i
-Fo4QLccCulR6x3KAAGyQ5H5IEhEGSRISBoYm/x4Jvgi7xXtlfwQhgQ8AAAAQJX+evU8gFAFPJNQh
-X/BRJECCzyBiAc8gIQHouZpwIfJDwSPDoOPKIMIAyiAhAM92gAAAWGtmBCGPDwYAAAAxvwQhgg8B
-AADA+2Muus93gABQWEpnYnoWIIUALcALZhXwUyHAAM9ygAAwWx14CGIEIYIPAQAAwC66z3OAAFBY
-SmNhuhYghQAB20wlAIaM9wohwA/rcgXYiiPJBm0Dr/uKJIMPQC2CAFR6x3KAAGyQABIRAAQSEgBh
-uwQhgQ/vAADdJrlleVIhzwPPcYAATCkagTuBJHhRIACCB/Iigs9wpwCISS+gNBQQMOlwhiDjD892
-oAC0R0EoEwIG8KIOr/yKIAgAcRYAlgQggA8OAAAAQSh+hPT1iiD/D28eGJBrHhiQA9kPuc9woADI
-HxMYWIBZHpiUWh5YlFse2JNYHhiV+71KJQAAC/IegAK4QiCFA0glBQCocMm4BX0A2c9wgADUnAeA
-DyHBBAR5z3CAAMwEgOEB2UCAwHlTIgCAr70I8oYifw9deg+6RX0F8IDhzyXiE1ceWJOA4Ab0gOEG
-2Mog4QED8ADYz3GAABwPKIFRIQCAE/JPIAECjbmXuRUeWJAFIIEPgABAOhoeWJAFIIAPgADAUxHw
-BSCBD4AAwCQVHliQBSCBD4AAAD4aHliQBSCAD4AAgFcXHhiQz3CAADB0BJCB4A30hBYBllAhAAME
-IYEPAAAADK24ArkleAPwhBYAlhYeGJCMJc+PyiHGD8oixgfKIGYByiOGDwAA+ADMAab7yiTGACpw
-og7gCQpxCNzXBK/8pMDgePHAcgyv/AK52nDPcIAAHA8fgDZ5ACGND4AA5JGA4KHBQMPK8giFBSCT
-ACAdwBQYFRUQEBUUEBQVERDnhapwABUQEIYg4w/PdqAAtEdBKBICBfD2DK/8iiAIAHEWAJYEIIAP
-DgAAAEEofoT19Yog/w9vHhiQax4YkAPZD7nPcKAAyB8TGFiAWR4YlVoeWJRbHliVWB7YlPu/SiUA
-AAryHoACuEIghQNIJQUAqHDJuAV/z3CAANScB4AA2Q8hgQQkeM9xgADMBIDgAdhAgcB4UyIBgK+/
-B/KGIn8PXXoPukV/BPCA4M8n4hNXHtiTgOEH9IDgBtjKIOEBAvAA2M9xgAAcDyiBUSEAgBLyTyAB
-Ao25l7kVHliQBSCBD4AAQDoaHliQBSCAD4AAwFMS8AUggQ+AAMAkFR5YkAUggQ+AAAA+Gh5YkAUg
-gA+AAIBXFx4YkM9wgAAwdASQgeAO9IQWAZZQIQADBCGBDwAAAAytuAK5JXgE8IQWAJYWHhiQjCXP
-j8ohxg/KIsYHyiBmAcojhg8AAPgAHACm+8okxgAqcPYM4AkKcc4N4AsAwADZz3CAABwPP6AAhQAe
-ACAFA6/8ocDxwM4Kr/wA24DhpcEK8kiBBCKCDwAAADBCIgOAyiNiAFJoVnrHcoAA5JHAgui+QMYR
-8iDAz3WAAABYMiUEEACKDWUEJoAfBgAAADG4ACBFAwTwAdiYcLhwrr6vvrC+QMaA48whIoCN9M9w
-gADUnM9zgAAUiZYTgQADiAshAIA48kgTgQAA3wDbUyFNAA8jQwNEIQ0DQr2GIf8DDydPE7xpBCcP
-kADZBHsPIUEDJHjKJwEQgOPKI8EDTCVAgBPyTCWAgBTyTCXAgELyCiHAD+tyBdiKIwsHSiQAABkH
-b/sKJQABDrtlfjfw5Xv98SGCz3WAAChtdGljZVEjQIIK8i8oAQBOIIEHANiOuDh4BX4j8EwlQIAO
-8kwlgIAS8kwlwIAW8gohwA/rcgXYiiPLDNXxz3CAADBvNngCiAfwz3CAADBvNngDiA64BX4F8I6+
-j76QvgQmgB8BAADALrjPcYAAOFsIYbBwVgAmAEDGCiHAD+tyBdiKI8sOeQZv+5h2DZEogYYgfwwE
-IYEPAAAAMCy5qWkceEAlgRMRIECDDyZOEEDGDfQKIcAP63IF2IojDAGKJMMPPQZv+7h1z3GAANSc
-AIGLc6CDhiD+AyS4DrgGfaCjAIHCuA64pXgAowDAz3OAABwPBCCBDwEAAMAuuUApBQZPJQUHqINP
-JcUHz3aAACwFUSUAkM91gABALDZ9BvLwheSmsYUF8OCFoYXkpum4o6Yt8qaCCLklfaaiBCCADwEA
-AMAuuM91gABQWAhlSSCAAGG4ArgUeMdwgABkkaqAy4BiE4AAIMcEIMQDz3CAAEyJERCGAE8lhQcE
-JgABCbgFeeV5iiAGBlHw6Lgd8kTAJMag5solghPKJSEQz3eAAABYzmcEII8PBgAAADG/BCCBDwEA
-AMD+Zi65z3eAAFBYKWfCeRLwUyDBAD15z3WAADBbLWUEIIEPAQAAwC65z3aAAFBYKWZhuTZ9mOWM
-9wohwA/rcgXYiiPMDookgw8FBW/7uHUybTR5x3GAAGyQoIHBgUIkQQAEIIAP7wAA3Sa4BXlSIcED
-iiAEAsSipaIcGkABCKImogHYH6MNAK/8pcAA2JC4z3GgAMgfFRkYgM9wgAAIgUaQW3pPIgMAWhEC
-hjgQgABkelhg2BkAAOB+4HjhxQDbz3KAAIh+FCINAGC1aLUaYiAawgDAHcQQKBrCAM9xgAAIgRZ5
-IpEwGsIA0B3EEIAd3BB4HUQQAdmIGkIAz3GAACh/FXlgoeAdxBDwHcQQ4H/BxeB48cDhxQh1GxIB
-Ns9wgACIfjR4EYiA4BLyA8gBgO24DvLPcIAAdGvwIEAAz3GAAKAEFHkAkRDgALEWCYAEG8jb/wPI
-AdmgGEAA8g1gBKlwz3CAAAAAAIBRIECBEvLPcaqqu7vPcJ8AuP82oDagNqA2oM9xoADIOw6BiLgO
-oREHT/zxwJYOb/xKJAByz3CgAIggAN6oIIAPh+Y58qCAz3GAAAiBz3KAAKiW1nloiUeCemKA5c9z
-gAAAf9R7HvQAJo0fgAD4fviNgucI9OCT+38jkYC/JH/gswbwgecE9CKRILMA2Titz3WgAMgc+oUg
-k+R5LLMF8CyTMHXD91lhA/Css7liiSHPDwQYUAAB5gDZz3CAAKiWaQZv/Ceg4HjxwPoNT/xRIMCB
-GxIBNs91gACIfgMSAjbPc4AABJA0ffGNEBWEEBLyAefpcDIShQCnkwIbAgHPdkEAgwCms891gAD0
-DOOrEfBAJEAAMRKFAAKrwBUNEeOrz3YhAIIAprPPdYAA+AywcMf3xKMAhQHgAKUEg1nwz3CAAKh+
-KGAB4ASrAYJRIACBsIpA8i8kyAPPd4AA5EoHh9KKgOAveQTyBYck8EkhwAA0bc93gAAobSFn9rkH
-8s9xgAAwb7Z5IYkC8ADZx3CAADBvtngEiAgmDhAIJkEQgHFJIcEDFm01eM9xgAAwcABhz3GAAEhu
-tnnPdYAAHA+9hSGBpXkEIYEPAAAACCZ4A/ADggKjmBKAACiLEHEG8gDYBKtg2Bi4BPAA2J24BKM9
-BU/84HjhxeHGz3CgABQEA9kjoBvIz3KAAASQYZLPcYAAiH7EihQhDQBotQAggw+AAKh+OOHAq2KC
-FXkGkmChAxIDNsAdBBAEgqATAQCGIcMPJXigGwAAwcbgf8HFGxICNgQgvo9gAAAAz3OAAIh+VHvH
-coAA+H4IcQbyA8gckFEggIIK8gQhgQ9hAAAA13EBAAAABvQA2ACzAdge8BTMUSDAgQMSATYN8jIR
-gQABizBwBPQA2AGr8vEB4AGrC/AxEYEAAIswcAX0ANgAq+bxAeAAqwLY4H8YqvHA+gtv/ATZCHUb
-Eg42BtgbGhgwz3egABQECqfPcIAA2FuCCo/8AIV6Cq/8BNkBhXIKr/w42SKFgOEG8gGFAJAQccz3
-CiHAD+tyBdh020okQADNAG/7uHNKCq/8A4UBhUKFIJAFhT4Kr/xCecqn9QNv/BsamDPgeM9xgABE
-BeB/A6HgePHAdgtP/CGACiUAkBCJw7jKIcEPyiLBB8ojgQ8AAK0AyiBhATHygOHKIcEPyiLBB8oj
-gQ8AAK4AyiBhASXyBLjPcYAAKG0HYQOFAJCGIPwAjCACgC2/wL8K9IQvCxwAIYB/gABAtSGAgbkh
-oAGFwoABhoDgBPIAhoDgDPQKIcAP63IF2LrbSiRAABEAb/u4c1EggMEF9FIMAAiA4AzyiiDOAkoJ
-b/zB2QCGgNkooAGGQHgc8AGFIJAiyBBxyiHND8oizQfKI40PAADHALoH7f8F2Klwqv8Bhsf/z3CA
-AHRr5qB2Di/86XD1Ak/8z3GAAEQFI4HgfyCg8cDhxQMSATaigSCF/g9v/CTaAYWA4OIgAgDdAk/8
-4HjxwF4Kb/wG2BsSDzYbGhgwz3WgABQECqUJhYDgAN4T8q4IQAQJhYDgDfIkFQUQCiHAD+tyBdiK
-I8QCSQcv+0okQADqpc9xoADQGxCBz3KAAIh+hrgQoROBkLgToR2KgOAbGtgzDPLPcIAAdGsGgM9x
-gACgBBR5AJEQ4ACxxrLOsiYaggPMGoQDiiBPC0YIb/yKIQQHMQJP/PHA4cUIdc9wgAB0a0aAz3CA
-APyyhCoLDAAgQg7PcIAAtH8AgFEgwIChwRTyFmnPc4AAMHAAY1EgQIIM9M9wgAAwbzZ4W4oCiIm6
-DrhFeAbwhg2v/ItwAMAApeUBb/yhwM9ygABwD1SKWWEweUFpUHDE9iJ4EHgD8ALYz3GgAMgfHqEQ
-2A6hAdgVGRiA4H7gePHANglP/ADfz3WgANAP9aUD3hLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44Hhhvowm/5/u9QPYGqXPcIAAcA/vqAHYFaVRAU/88cDmCG/8BdgA3Qu4qXHd/89xgAAU
-iR6B7rha8h2BUSAAgFbyPgwP+wDZnLnPcKAA0BswoAHZz3CkAJhAPKAEIL7PMAAAAAHlyiUiEFEj
-AMAn9FEgQMUF8lEhgMMi8lEgwMUO8lEhgMMK8s9wqgAABAGAhiA/C4PgFPLO/yDfz3agAMgf8KYB
-2EMeGBAA2FIMb/yNuPGmhOWmB8X/AvDF/1EgAMcA2Q/yANrPcKAA0BuculCgz3CAAJAEQIAQggHg
-EKLPcKQAmEA8oDbwlgsP+1EgQMUw9FEgAMUB5colIhBRIwDAz3agAMgfIN8N9PCmAdhDHhgQANjm
-C2/8jbjxpoTlWvfm8c91oADQDwDYFaXwpgHYQx4YEADYxgtv/I248aYD2Bqlz3GAAHAPANgPqQHY
-FaUZAE/88cCuDw/8AN/PdqAA0A/1pgPdEvDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eGG9jCX/n+71A9gaps9wgABwD++oAdgVps9xgAAUiR2BgLgdoZz/vgvAAbkHD/zgePHA4cXPcqAA
-0A+wgs9wgABwDy+IMHUA2wX0A9k6om+oAvDf/50HD/wA289yoADEJ4ogGAg8GsCAz3GgAMgfDqGA
-EQAAUSBAgM9wgADEkQ3yQhIChgQivo8AwAAABfJBgIDiA/JCoIAZwADgf2Gg4HgUzAQgvo8AAChA
-RfLjuCHyFRICN4DYz3GAAER167oUGhwwBvIYgQHgGKEF8BCBAeAQoVEiwIAH9ADZz3CgACwgL6AV
-zEYggALgfxUaHDBRIECBF/KKIAQAFBocMM9xgABEdQ+BAeAPoRXMANlGIIACFRocMM9woAAsIC+g
-4H4E2BQaHDDPcYAAkAwegQHg4H8eoeB+8cBGDg/8AN0g2M92gABMj0AmDxWyDGAFAKbPc6AAyB8B
-2BOjWIM5g1QTBAD4EwAAz3OgADAQYYPPc6AADCQCIgKAZ4MDIUEDQaYipgIkAwDPcoAAHA/PcYAA
-FIljpkwZRAMUklAZRANoggm2z3KlAAgMUyMAAAi2ABIEAE4ZRANTJEUBUyRCAEgZQgGD4sohwQ/K
-IsEHyiOBDwAAMw3MAiH7yiBhAQQkhQ8AAADgQS1CA5YZggA+ge65FB4AEQzyBLqBukV4CLYH2Afw
-FScMEKCkA/AE2AHgiOC69+u7sA7C/al3USCAxbrygOe49M9wgAAUiT6ABCGBDwAAAEAEIYBPAAAA
-QBBxAd/KJyIQyiViEM9xgABwDw+JAeAPeA+pz3GgALQPN4EwcADeCPTPcKAAqCAGgIwgg47M9wDf
-V//PcIAAkAQggAHdCIEB4AihgOeG8s9xgABMjwWBBCCADwAAAOBBKEQDz3CkAJBBdYBWgFEkAIC4
-ckihz3KAABSJZ6EF8kwaxAAI8EwahAMEI4MP//8AAGehUSRAgAXyMLtOGsQABfBOGoQDcHtnoVEk
-gIAF8lAaRAEI8FAahAMEJYMP//8AAGihDYAGoQQggA8AAAD+KbhSGgQAHoLuuCPyz3CqAAAEBIAJ
-oc9wgACwj0CIgOJAIAQBMvKA4loALgACEIUA9CSDAxXYE7jwIMMAz3CAAIiP1XgB5lB2YKC09xvw
-z3CAAMiPQIiA4kAgBAEW8oDiAhCFAM/39CSDAynYErjwIMMAz3CAAIiP1XgB5lB2YKCz90GpAhlC
-AYDnGPQEIL7PYAAAABL0z3CAAJAEIIAB3QGBYbgBoQeBAeAHoYoghQc2Ci/8FBIBN1EjAMAT8gDf
-Af+KIMUHIgov/Olxz3CAAJAEIIAB3QGBYbgBoQeBAeAHoUoML/z22AQgvs+AAQAAzCcikMwlIZAM
-889woAAwEAOAgOAA2Qvyz3CAAJAEQIAB3Sh3DIIB4AyigOUU8gLZz3CgAMgcKqAc/89wgAAUiUDZ
-PaAUzIYg+Y8G9ADYj7gUGhwwlQMv/Olw4HjhxTDbAN3PcKAAyBxpoAPaz3GgAMwXIRmYgE6hp6Bq
-oOB/wcXxwOHFz3GAAJAMDoEB4A6hz3GgAMQnGREAhoDgANoF8gLYEBkYgM91oADUC1el//7PcYAA
-FIkdgYe4HaHo/xCFgOAr8gPYEaXgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4EaUTzBEaHDCx/ukCD/wKIcAP63IF2M9zAACkCUok
-AAB9B+/6CiUAAVEhAMbxwB30z3CgAAwkB4CA4Bfyz3CAAJCJC4DPcaAAyB9k4B6hENgOoQHYFRkY
-gBoOL/wD2FEjAMAYD8L/0cDgfuB48cAOCg/8CHXPdoAAFIkdhi8mCPA89OC9EPSCuM9xgACQBECB
-HaYDggHgA6IggYogRQlSCC/8I4FRJUCQHYYR9IS4z3KAAJAEIIIdpgSBAeAEoSCCiiCFCSoIL/wk
-gc9woAAMJAOAUSDAgB2GEPKEuM9ygACQBCCCHaYFgQHgBaEggooghQn+D+/7JYE9hi8mSPAA3w30
-CiHAD+tyBdj824u7iiSDD40G7/pKJQAAz3WgANAPERUAloDggvLguRDyz3KAAJAEIIICgQHgAqEg
-googRQiuD+/7IoEK8FEhAIEU8rf/HYZRIMCBaPTPcKAAxCcZEACGgOAG8gLZz3CgAJAjPaBX/hzw
-rf8dhlEgwIFU9DmF6XIG8AARAFAB4k96QSmAABByuvcA2gbwABGAUAHiT3pTIUAAEHK69wPYEh0Y
-kOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HgSHRiQE8wRGhwwav4ehvO4CvLPcIAAnJbrqM9wgABcluywz3AAAP9/z3GgAAwkAaEb
-2AShTf+9AA/8CiHAD+tyBdgl2wa7bfHgePHA4cVQ3QDaz3OgAMgfr6NeowIgQgBeowHaFRuYgEDa
-TqMEIL7PAAIAELQOgf+NAA/84HjxwA4ID/zPcIAAFIkxgFEhQIIR8s9xgABwDy6JRBCCAER5USGA
-gEjayiKBDwAAkAAC8A7aANvPcaAAqCAngagQDQBZYbFxwiVFEMol5hKweArZlv04/s9wgADELgCQ
-z3agAMQnUSAAgQTyjCUDkgT3AN8V8M9woAC0D3ygz3CrAKD/eqC2CiAJANgZFgCWgOAE8gLYEB4Y
-kAHfGRYAloDgPvRRIQDGPPQD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgE8zPcYAAkAxqvREaHDATgQHgE6EU
-gbhgFKH6Ci/8AdiGCS//AdjS/VkH7/vpcOB48cDqDu/7wNjPdYAATI9BjSAaAjASakTgz3GgANQL
-2IEA20ImDhiA5somzBDRcEYADgDPcZ8AuP8Ygc9ygACQBJC4GKEYgbC4GKEgggWBAeAFoc9xgAAU
-iR2BhLgdoSCCiiDFCPoM7/slgQDYHP8A2D3wz3aAABwPyYYD4AQggA8AAPz/Kr7Avhe+x3YADgAA
-xXjsdgCmCMjsdgCmEczPdqAAiCRKJMBzAeAQeAQggA8AAP+/j7gRGhwwHqYA3qggAALwJY8T7HDg
-oAHmgOIA3cv3z3CAAIiP8CBOA+xwwKAB5VB1t/dtoQHYaQbP++B48cD+De/7wdggGgIwz3KAABwP
-GIoB3c9xgAAUiYbgdoHCJUETQCMAAxggQAMQfWIZBADPcKAA1AsYgADeQiAACIDgyiCMAwIlzhDR
-cD4ABgDPcp8AuP8YgpC4GKIYgrC4GKLPcoAAkARgggWDAeAFox2BhLgdoSCCiiDFCPIL7/slgQDY
-2v4A2BjwA+UEJY0fAAD8/529n73scKCgCMjscwCjGIo2gYbgAdjCIAEAGCEBAOxwIKAB2LEFz/vx
-wEIN7/sb2M92oADEJxUWDZYWHhiQA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoBPMERocMIogBAxGC+/7ANl9
-/eS9E/LPcIAAkAQggBGBAeARoUP9GRYAloDgBfIC2BAeGJBh/iLwUhYAllMgQQCD4dEl4ZAD8qL+
-GPDPcIAASQgB2SCoz3CAAJAEQIAGggHgBqLPcIAAFIkegFEgwIEG8s9wgACEBSCg0QTP+/HAYgzv
-+wDZz3AAAP9/z3WgAMQnEx0YkBvYFh0YkAHYEB0YkM92gAAUiR6G8bgF8qgeQBAI8BGGNoZGC6AB
-ANqoHgAQcv4dhue4BPIA2CXwLRUBllaGMHIG8oC4HaYA2Hz+9vEEJYFfAADwLx6GJXgephEVAZbp
-uQXyz3AAAODEC/DwuQTyAtiIHgQQ4LkH8s9wAACgxzkEz/tRIcCAG/II2BMdGJDr/oDg0vUC2Dwd
-AJAhFQGWz3CAAMSRIaARFQCWUSCAgAf0Uf4dhlEgwIG+9REVBZZRJYCADPQKIcAP63IF2IojxgOZ
-AO/6iiSDDwTYEx0YkIv/qvHgePHA4cXPcoAAFIkWgpjgz3GAAOSRBfJUEoAAgOAE8hmCuoIE8BuC
-vIJRgs9z/v//P2R4pHsEIoIPAAAAEEV4AKEA2AGhZXpJoQ7aSqHPcYAAWLJGCE//z3CAALCvAIBR
-IECACPLPcYAASLUuCG//AdhpA8/78cDiCs/7z3GAAAAAAIFRIACAG/IBgVEgAIBA2M8g4gfKIIEP
-AADQAM8g4QfPcp8AuP8dogSBAeDTuAShBSCAD9D+AAAWogDez3WAABSJ3aXepVQdghPfpYDYlB0C
-EM9wgAAIldmgz3CAANCRwKDPcIAA7K7CoBTMgB2AE1EgwICIHYQTqB2AEw7yFcxTIECACvLPcIAA
-HA8JgFEgQIBKIUAgBPJKIQAgz3CgAAQl1KARzBMaHDDG/FEhgMPPd4AAHA/PcYAATHQc8gDYjrge
-pc9wgACQBFThIKAblxy1HZeSHQQQiiCEDh61iiBEC3YI7/sA2QbZz3CgAMgcKaAU8M9wgACQBATh
-IKAalxy1HJeSHQQQThcAER61iiCEC0YI7/sA2c9xgACQBECBAIIB4ACiIIEBgQHgAaH62E4Ir/8A
-2dr8gODWBwEAz3CgAAwkz3EAAP9/IaDPcKAA0A8REACGgOAM8gohwA/rcgXYiiMOBookgw+dBq/6
-uHMB2c9woADQDxEYWIBoF4EQHJUCIFAAHoXuuCwCIQAvIAgkQB2EE89wqgAABAKAz3GlAAgMIIEE
-IIIPAAAA/yi6BCGBDwAAAOCJujt5RXlIhwQivo8ABgAAMaUE8oy5MaXPcoAATI8togyiz3GqAAAE
-IIFEFYMQlOMqohryBfaK4xj0I7kN8LfjDfLu4xL0RSn+AkEpwXBRIMCBwiFiAADbCvBFKf4CQSkB
-cfvxIrn58QDZAds2pc9wqgAABAGAPLILouS4yiNiAOG4yiNhAIYg/g9BKAQBEBIFAUkdAhEFJQAB
-CLLgu32lViFAAgPyANhQ8I7hjPegFwIQUHEI989yoADQD4ASAgBQcQnygLt9pdYOr/uKIAUI6/FV
-F4EQgeEE9JQXARA4YM9xgAD0ByCJgeES9ADZjbkJIEEAz3CgANAPGRAAhkIgAAhIIAAAEHEA2AP3
-AdiA4Bv0z3GfALj/GIGQuBihGIGwuBihz3GAAJAEQIEFggHgBaIdhSCBhLgdpYogxQhiDq/7JYGx
-8QHYgOAOAwEACnAA2eb9YheAEEQVgRBEIQUMBCBEAEQkAgFCLQUBoHLPcYAAFLPBuklhibk7pWwV
-gxBJFYEQBCMPAIYj/wMkf0S7f2fPc4AACFn0I88DXh3EE893gAAEtkpnibpcpXAVghBEeIYi/wMk
-eES6WGD0IwAABCEBAWAdBBARhaBxz3KAAChZ9CJDABmlz3KAADhZ9CJBAIodxBAapYwdxBCOHUQQ
-kB1EEI0CIABKHYITz3CmAAgEAYAEIIAPMAAAADS4USBAxkAdBBBAFQERDPTPcKAAqCAIgBlhMHme
-DW//CnAE8Apwrv0EIIBPgAEAANdwAAEAAADZFvTPcoAATI9AHUQQSR1CEDalKaKWFYEQAdhKHQIQ
-CJIEuYm5JXj3ASAACLJJHUIQz3CmAIwDXYBRIMDHBCKADzgAAABBKMEElh1CEAQigQ8AAADwJbgs
-uSV4EaXPdYAAFIkF8hGFjLgRpVMiwQJEFY4QNqXgvtEi4ocA2AL0AdjPc4AATI9Jo5YVghDokwS6
-5XpIs0QVBRA8s1MmwhBces93gAAEs09nHaX7pWwVjxDDvy8kwQPPd4AAHJD0Jw8RNBtAAV4dxBPP
-d4AA9LVPZ2QdQBH8pXAVjxDDvy8kwQPPd4AAHJD0Jw8RaB1AEWAdxBPPd4AAPJD0J4QQz3eAAEyQ
-9CeCEIodBBGMHQQRjh2EEJAdhBDPcqYAjANdggQijw8BAAAAML9KHcITSaNKFYIQgOIY8o3mCfKA
-uB2liiBFCBoMr/uKIRAKHYVRIACABvJh8EoOr/uKIFANUSAAxvrzXfDguFYhTgIE8gDYUfCO4ZD3
-z3OAABwPoBMCAFBxCPfPcqAA0A+AEg8A8XEJ8oC4HaXGC6/7iiAFCOjxVROAAIHgBPSUEwAAHmbP
-cIAA9AcAiIHgD/QA2I24CSYBEBkSAIZCIAAISCAAABBxANgC9wHYgOAc9M9xnwC4/xiBz3KAAJAE
-kLgYoRiBsLgYoSCCBYEB4AWhHYUggoS4HaWKIMUIVguv+yWBsvEB2IDgBfQA2LH8jQIAAEwhAKDP
-doAAFIkH8haGjuAF9B6GkbgepkoWgBCA4BH0yXXPcKAAeCZC2TKgHoXxuGwCAgBs/YDgXgICAE0C
-AACKIMUA/gqv+4oh0QXPcaYA1AQsEQCANBERgDgRD4DLERIGKnHGuelyhiL9Dwa6RXkqcoYi/Q8E
-ukV5BCCCDwIAAAAnukV5RCcCHA26RXnpcoYi8w8EIIAPOAAAAA66RXkluCV4RCeBEBS5JXiIuEQn
-ARJBKcGAUiBABRGmVB5CEMohgg8AAP//yiGBDwAAEB8acTaGP7YEIYEv/wMA/yi5NqYKC2ABANry
-v6geABA68kQWghAxhqDi0SHhgjTyBCGDjwAAAAEH8s91gAAAWE1lgeUJ9gQhjQ8AAAAk13UAAAAk
-IPIEIY0PBgAAADG9guU0AA0AguUJ9IDjFPLPdYAAAFhNZYLlDvSA4wPyzOIK9naGEnPKI44PAQCI
-DcwgzoDO99dwAQCIDcj3z3KAAJAMNYIB4TWiAd0a8M9zgAAAWEtjz3KAADB0RpJQcw/267kL8s9x
-gAAcDyiBBCG+jwAGAAAD8gDdAvAC3VQWgxDPcoAATI8okigaQAQHu4i7ZXkosjaGMBqABDyyMYbr
-ogQnjx8IAAIAHbItotd3CAAAADwK4QrKIEEDNoaA4b2mBPQeCsAKSvDPc4AAHA9VE4AAViFCAoHg
-AdjKICIAgeAE9JQTAAAaYs9wgAD0BwCIgeAR9ADYjbgJIgIAz3CgANQLGIBCIAAISCAAABByANgC
-9wHYgOAI8s9woAAwEAiAEHEE8oC9vaZTJX6QGvJRJQCQz3WAAER1DPKKIMUL1giv+4oh0QwAhQHg
-gwXv/wClCYUB4Amlj/zPcaAA1As18C4IT/368RD9gOD483X9CiYAkC/0A9jPcaAA1AsRoeB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HgRoRPMERocMADYEKElAo/7HoXxuATyQH7C8RTMhiD/hQbyA8gBgP24A/KV/YoLwAf08fHA4cUI
-dc9wgACQiQuAz3GgAMgfZOAeoRDYDqEB2BUZGIAF8EIKr/tp2AGFgOAF9FEjAMD48wGFwbiD4A/0
-z3CAAEkIAdkgqM9wgACQBCCABoEB4AahANgW8AGFUSAAgAf0z3GAABSJHYGCuB2hAYVRIECAB/TP
-cYAAFIkdgYS4HaEB2KEBj/vxwM9wgADIj2YKr/sY2c9wgACwj1oKr/sY2fsGT//geKHB8cDeCK/7
-mHEIdVpyz3KAAAAAAIJRIMCBocEa8gGCUSDAgUDYzyDiB8oggQ8AANAAzyDhB89xnwC4/x2hBIIB
-4NO4BKIFIIAP0P4AABahz3CAANiWBoAA2YHgAdjAeIDlQCgTAyryqXGGIfwAjCEChc9wgAAUiRD0
-z3GAAFgFIIFRIYCABvIg344QAAEJ8JjfihAAAQXwXhAAAQ7fz3GAANCRIIHgucAnIhHwei8gCCBK
-J0AgCvDPcIAA0JEgoPpxKHcacShyz3CAAOyuwICD5gb0w4BRJsCQC/RKIQAgCiZAJAogQDQKJUAk
-f/DAEAIAOBKOADcSgAAIvsV4ORKOABC+xXg6Eo4AGL7FeDQSjgBAIBAEMxKAAC8gCCQIvsV4NRKO
-ABC+xXg2Eo4Az3KgAPxEGL7FeEAgFQFdggDYUSKAgcwjIoAI8i8iSAU6cPpw2nAbcEvwTyPTI0Es
-QAPAuAS4FHiIcsa6SSLCBVR4USTAgs9ygACgWhBiBfJBKAIBFCIAACi4z3OAAKCJyIvPc4AAKG0D
-4M9yAAD8/wS+w2NAIBAh8rtEeC8gCCQH8ht4QCAQIS8gCCRAJcMhRHsIIM4AAibYEFEhAIDAJyER
-J28EIYEPAAD8/wggQgACIlYA2mJQeoohAiACEgEhQCAAJTBwR/YCIQEESCEAABB4AvAA2EDALyBI
-BIhxCnPGDyABSiQAAAokAKA/9ArYz3GgAMgfHqEQ2A6hAdgVGRiABfCOD2/7iiAKA1EgAMMO9M9w
-oAD8RB2ABCC+jzAAAAAE9FEjAMDv81EjAMDKIcIPyiLCB8ogYgHKI4IPAACSAsokIgC0A2L6yiUi
-AFEgAMMA2Ar0z3GAAJAMCYEB4AmhANiYuJpwTCQAoADeyiCCA8j0TCEAoM92gADQkRfyz3CgAPQH
-7aDPcIAAaK8xgFuJGokIukV4BLZdiRyJCLpFeAW2AIaBuACmA/AA2AKmTCcAoJryAIZRIACAO/LP
-cIAATIlMiM9wgAAAWDIghAAf2UwkAIAA2tz3z3ADABQAVnjPc6MAsP9Q4GBgz3cDABgAVn9Q52Nn
-LygBAAHiLyvBAAJ7MHPKIcUAkHKo90AsRAFCJAAIOGDPcYAAaFsIYSGGTyPTIwm4BXkChiV4AqYF
-I0AjDXEAsQ1xAMAAsQwSASANcCCgEBIBIQ1wILCKIIUA+gtv+6lxjCUClRTyjCUDkRvyjCUDlSHy
-CiHAD+tyBdjPcwAA5guKJIMPgQJv+rhzz3CAAJAEIIAPgQHgD6EuDuAASnAQ8M9wgACQBCCADoEB
-4A6hCPDPcIAAkAQggA2BAeANoQCGgOAG8iKGDXAgoADYAKZMIQCgz3GgAPQHANgS8gehAdgLoQPY
-CKFMGYAFAdgD8ADYqnELckpzMgygCgAUBDDPcqAA9AcA2SSiAd6A4AHYHgygCsB4AMEAIQAEz3Gg
-AMgf+BECAEJ4SCAAAF+BEHhQcEoABQAMEgIgz3CAAMSRQqCg2A+hANgfoc9ygABwD89wgAAUiVWK
-HJBCeADCTCQAoFhgH6EC2BUZGIAF8lEgQMYg2ALygNgOoYwlA5UH9M9wgAAUiRyQCPCMJQORCfTP
-cIAAjIkNkAoMb/8A2W4ND/8UzIYg+Y8K9IwlA5EA2M8goQPKICIBFBocMM9wgAAAAACAUSDAgQby
-z3GfALj/ANgdoc9xgADQkQDYAKHJcAjcIwRv+6HA8cD2C2/7ANkIdQGAwbiD4MogQSDKIEEABfKp
-cIz+SiBAIIHgEfIQhVEggIFF8hCFz3aAABSJUSDAgRryz3CAAHAPAogY8AHbAN858ADfVSZAGulx
-kNoaD6/+ANtAJQASnB4AEADYBbUE2ynwBYUmhc4LgABRIMCBlB4CEAfyHYaVuB2mHoaXuB6mH4YE
-IL6PEHAAAMonIhDo9Zy4H6bPcIAAsK8AgFEgQIDS8xCF7bjO8wHfzfEA3+lzz3KAABSJVBKOAM9x
-oAD0JoDmz3CAAMSREfTPdoAAcon0Js4TXJLaYs92gABwD9WOwnoQuoC6AvAC2kOhJYVMIACgIaAO
-9M9wgABJCAHZIKjPcIAAkAQggAaBAeAGoQoMD/89A2/7aHDgePHA0gpv+5DZosEIdkHBIYbBuYPh
-ANjKIAEgBvLJcEP+SiBAIM9xoAAsICaBgeAA3zB5HPIQhlEggIE08s91gAAUiRyVEHHJ9iWGz3CA
-AMSRAoAQcav0EIZRIMCBCPLPcIAAcA8CiAjwAdhC8AWGJoaqCoAAP4UEIb6PEHAAAJQdAhAQ9M9x
-gACwryCBUSFAgAHZR/JQhu26Q/JAwSh3Q/AA3yPwi3CA4APyAttgoAOBgOKDuAOhBfIAgqa4AKIs
-FgAABKEMFgAABaEAwQHCVSVAGnoNr/4B2x+FnrgfpUAmABKcHQAQGgsP/wDYz3WAABSJVBWCEIDi
-z3GgAPQmZfTPcoAAcon0IsMDXJV6Ys9zgABwD3WLYnoQuoC6VvBAxwDfUSDAgdP1bYYFhs9xgADs
-roHCBCODD8AAAAACgTa7ESDAgEAmBhJAIQQLIfIFlhwRBwBCIAUE9CTDAAgnQAFwcNf2z3CgACwg
-D4CA4BH0z3CgACwgZoAclXBwKAfG/89wgADEkWKABYEQc4zzA4FRIMCAlfMA2s9woAD8RJ66QaAD
-gaO4A6GL8c9xgACQBECBC4IB4AuiIIGKIEULjg8v+yuBbvEC2kOhRYZMIACgz3GAAMSRQaEN9M9x
-gABJCAHaQKnPcYAAkARAgSaCAeEmokUBb/uiwPHA3ghP+wh2FcxTIECACvIHEgE2ANiYEQEAIgmv
-/ghyAYbBuIPgyichEMolwRMG8slwwP0IdQHfgeXKI2EAQ/IQhlEggIEF9ADbaHA88BTMUSDAgCzy
-FcxTIECAGxICNg/0ACKBD4AAEH8B2ACpz3GAACA2MolRIQCA8ApC/hDYFBocMM9xgABEdRKBAeAS
-oQPIGxIBNoQQAgHPcIAABH81eCmAWWEpoAjd0PHPcIAAyHQrgAHhK6CaDi/7iiDFCQDbAdgC2c9y
-oAD0JiOiQ4aA589xgADEkUGhDvTPcYAASQgB2kCpz3GAAJAEQIEmggHhJqKA4AryANieuM9xoAD8
-RAGhANgFof4ID/85AG/7BSNAA/HAzg8P+wh2AYDBuIPgAN3KIEEDBPLJcIH9Ad2B4ADZLPIQhlEg
-gIEo8hTMz3KAAEx0USBAgRnyQNgUGhwwUBIABgHgUBoYABvIz3KAAIh+FHogqgMSATYA2JgRAQDK
-D2/+CHIK8KQSAQAB4aQaQADODS/7iiAFCgLZz3CgAPQmI6AjhoDlz3CAAMSRIaAO9M9wgABJCAHZ
-IKjPcIAAkAQggAaBAeAGoUoID/+NBy/7ANjgePHAz3KAABSJVBKBAIDhFPQ8ks9ygABwD1SKQnkQ
-uUUhQwHPcaAA9CZjoQDaz3GAAMSRQaFN/YHgyiBhAATyAggP/wDYvwQP//HAyg4P+wh1GnFBKQAB
-z3GAACBbw7gIYSSVBCGBDwAAAIDXcQAAAIAB2cB5NXghlQThMHAN8owgAqQJ9M9wgAAUiRaAjCAC
-hgPyENiX8CSV8gwv+4ogxAuMIAKsIvIO9owgAqBE8owgAqRm8owgAqiH9KlwmP6D8IwgA6QV8gj2
-jCADoH30qXCf/3nwjCADqMwggq8AAPAAc/SpcMf/b/CpcNb+a/DPcYAAAAAAgVEgAIEb8gGBUSAA
-gUDYzyDiB8oggQ8AANAAzyDhB89ynwC4/x2iBIEB4NO4BKEFIIAP0P4AABaiqXBC/0nwz3KAAAAA
-AIJRIACBGvIBglEgAIFA2M8g4gfKIIEPAADQAM8g4QfPcZ8AuP8doQSCAeDTuASiBSCAD9D+AAAW
-oYYIoACpcCXwz3GAAAAAAIFRIACBGvIBgVEgAIFA2M8g4gfKIIEPAADQAM8g4QfPcp8AuP8dogSB
-AeDTuAShBSCAD9D+AAAWorYKoACpcLUFD/tNccILL/uKIIUIYfHgePHAQg0P+892gAAUiR+GBCC+
-jwBwAABZ8i8pAQDPcIAAEAX0IE0AnBYCEADfpBYBEE8lgBDpcwL9gOAQ9IwlA5DPcYAADA0G9BOB
-AeAToT3wEoEB4BKhOfAfhv64L/LPdYAAIDYQjS6NEHEt8hKNUSDAgCn0MK1aDy/+A9hRIADDGfQA
-2Z65z3CgAPxEIaAwjYYh/wFDuRC5TyHCBs9xgACsnCCJn7qA4QHZwHkPuUV5LaASjYS4Eq0F8M9w
-gABQluCoXgnAAOUED/vgePHA4cUiCi//AN3PcYAAFIkdgVEgwIFe9M9woAAEJaKABCWNH/8AX/9T
-JYAQh+BF9FEigNNB8h6B+rg/9AQgvo8AHgAADvIH8M9wAAD2CeIMD/tRIoDA+vVRIgDAzyViEc9x
-gAAUiR6B+bjPJSISzyXiEs8lohMh9Pu4EvKIvYm9jb1PJcASvYGOuAQljR8CAAAAUiVNFCq9BX0P
-8Py4xSWCHwAAAAXPJeISzyWiE8UlgR8AAAAHz3CAAKCJCIjEuBi4USCAxAV9pA8i+8ogIggdBC/7
-qXDgePHAngsv+whyz3GAABSJAJGIEQMBz3WgANAPRCAEAwomwJBA2xAd2JBCLIQAhiD8A8omYhCo
-EQ8AQC6FFc9zgABMj/B+/bP8kxC+5X4MHZiTYYsCu0jjEB3YkGIRDgGIEQMB22PAkXB7USaAkkS4
-YhnEAAb0LpFTIcGAEPLPcIAAHA8JgFEgAIA92MAo4gXKIKEHwCghBgrwQCwBAThgz3GAAIArCGEX
-uAPjBSBAAQQjgw8AAPz/ZXiduJ+4DB0YkBHMAeAQeAQggA8AAP+/j7gRGhwwDh2YkCAVAJbPcIAA
-HA8IgOu4EPLkug707guv/Ehwz3CAAOySoNnE2j3bugwv+xe7AQMP+/HAkgov+4ohCADPdYAAxInP
-cKAADCQhoMSVz3CAABSJHoAadvG4hiD8I0nyUSWA0UXyjCADpEP0A9nPcKAA1AsxoOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hgx
-oKlwTf5RIMCABvLPcIAA4I/mCUABz3GgAMQnGREAhoDgBPIC2BAZGIAE2BMZGIAb2BYZGICS8M4M
-YAMKcAh3qXAKccH+CHYj/0QmfpQO8lEmAJEI8s9xgAAUiR2BgLgdoQGFpg/P/nrwgOcM8kz/z3GA
-ABSJPYFRIcCBcPR+/yvwA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoBPMERocMFEmwJAH8s9wgADgjxoJQAHP
-daAAxCcRFQCWUSCAgADeGvTODs/+z3CAABSJHYBRIMCBKvQRFQWWUSWAgAz0CiHAD+tyBdiKI4kH
-GQbv+Yokgw8E2BMdGJAb2BYdGJDPdYAACJUZhYDgBfKeDIAA2aXPcIAAAAAAgFEgAIEG8s9wnwC4
-/92gGQEP+/HAuggv+03Yz3KgAMQnLRIOhgm4GhoYgM9wgABoiSCIgOGhwQbyAdvPcaAA1AtyoQTZ
-EBpYgE1xhiHzD4whDIAB2cB5OWE0eQCIHuGA4MolQRAE8kAhDQMifgfwz3AAAMcPDgkP+1EggMQF
-9FEhAMb2889xoADQDxAZWIMlEQCGYMAlEQCGD3kBHAIwABQAMYwg2IHMIIKPAAAHCMogIgAH9Ijh
-AdjAeFIPIAoubs9yoADEJxoSAYYEIYEP////ABoaWIAREgGG67kJ8gDZi7kTGliAGtkZGliATQAv
-+6HA8cDSD8/6z3WAABSJz3CgAAwkPIBWhaHBAiJAAGS4EHiGHQQQEHLKIc4PyiLOB8ogbgHKI44P
-AAD5BMokLgC8BO75yiUOAQPIAYD9uAnyLyCHCowgAoYF9B6FnrgepQDZz3agAMQnIRYQls93oADU
-CxiHQiAACIDgyiBMAPzgQgAGAM9xnwC4/xiBkLgYoRiBsLgYoc9xgACQBECBBYIB4AWiHYUggYS4
-HaWKIMUIng3v+iWBFg3v/gDYCwQAAHIKQAOA4BoCIQCYHQAQz3KAAAAAAILruBryAYLruEDYzyDi
-B8oggQ8AANAAzyDhB89xnwC4/x2hBIIB4NO4BKIFIIAP0P4AABahUSXA0c92gAAcDwXyVhaAEAXw
-A4X+DiAAJIU+hZQdAhBEIQAMoOAI9FElwNIE9IDYlB0CEJQVgBBRIMCBA/KXuT6lUSGAgSjyFJVR
-IECBJPTuD4AGgOAg9M9woAAsIA+AgOAG8gPIAYD9uBbyHoWQuB6lz3CAALCvAIBRIECABvJRJUDT
-AdkD9ADZi3CQ2rYJb/4A289wgAAUiZQQgQBAKQIGhiH9D1IhwQFFuUV5z3KgAIgkMKIphuO5XoAD
-8um6A/IA2ALwAdhRIQCB0SJiggDZyiFiAPe6JXgPeBX0USKA0xPygOAR9EQiPtML9M9wgAAUiQGA
-USAAgAXyugpAAwPwugtAA891gAAUiR6F87gi8gTZz3CgAJAjPaBNcSYM7/qKIEQOBvBeDu/6iiAW
-BVEggMQE9FEhAMb48891gAAUiYYVABHPcYAAHA/GCuADL5EW8ACVBCCADwAAzIDXcAAAyIAH9AuF
-USAAgAPyK/8G8ATZz3CgAJAjPaAC2M93oADEJzwfAJCUFYAQz3GAAMSRUSDAgQQZAAQK8h2Flbgd
-pYogBQmeC+/6ANkr/gh2HYVRIMCBBgICAFMmQBCD4Ab0FRcAllEgwIBa8vYK7/7JcOsBAADPcYAA
-yHQNgQHgDaED2BGn4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeBGnE8zPcYAAxJERGhwwENgQHhiQAtg8HgCQPgrv/gQZAAQdhVEg
-wIG39BEWBZZRJYCAC/QKIcAP63IF2IojlwKNAe/5iiSDDwTYEx4YkBvYFh4YkKHwFMxRIMCAPoUL
-8gQhgA8AQEAA13AAQEAAA/SYuT6l8LkS8gDB1NipciYLb/8B24DgBPL+CIAACPDPcYAADA0SgQHg
-EqHPcIAASQgB3+Coz3CAAJAEIIAGgQHgBqEehfO4nA7CAx6F8LgQDYH+HoVRIMCBB/IB2c9wgACE
-BSCgz3GgAMgcANgHoTDYCqHJcAr+iiCEDTIK7/rJcQPIAYD9uBXyHoX4uBPyENgUGhwwz3CAAOCP
-ggsAARvIACCBD4AAEH8eheCpuLgepQCVhiD8AIwgAoAu9I4MwAOA4Cr0A9nPcKAA1AsxoOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HgxoBPMERocMB6F87gF9ACVggogBTSVdQPv+qHAz3KAAHAPVIpZYTB5QWlQcMT2IngQeAPwAtjP
-caAAyB8foYogGAgOoQLYFRkYgOB+4HjgeOB44HgKJIDwBSBEAOAgwQdEJP6AQSrEAIQAAgAvJALx
-QiEBAUIgAwHoIKIEBBEEAgQRBQIEEQYCBBEHAgQbCAEEG0gBBBuIAQQbyAEsACUARCI+gTwAIgBE
-IvyAQCHBAOAgwQdAI8MAqCCAAQERhAIBGwoBICDABwQRBAIEEQUCBBsIAdQH4f8EG0gBRCL8gAQR
-BALJB+//BBsIAUIhQQBCIEMAqCCAAQERhAIBGwoBICDAB/HAKgrv+gDYz3WAAIyTSiQAdIDeqCBA
-BQhxAeBPIMIBFiVDEEeriiIIAEApBAEAJIEPgAAobUChANpCscapwNh/HQIQz3WAAFQFwK3PcIAA
-DJSA2coK7/oocsGtz3CAAHAPNQLv+sKoosHxwLoJ7/qYckXBQSgBAkEoAwQHeSd7xrvHc4AADJQg
-i+e5EvQUFA4xz3KAAIyTFiJNAOCF8XAE9OKV0XcI8ieN57lnbfPzANgg8MaNgOYG9IDfz3CAAFQF
-4ajPcIAAcA/iiPF2BPSA3sKoxo02egAcgAMHjYe5AKvPcIAAVAVgiCCoAdhnqgzcnwHP+uB48cAm
-Cc/6z3GAANxbIYGjwULBz3GAAIQEFSERAAARDSCA5S8oQQNOII4HS/L0bsd3gAAobQaPz3GAAIyT
-FnkAgSKRjuYIHEQwyiBhAATyi3ICwcj/gOAu8gDYz3GAAFwFQIEPIIADLyAKIAQggKAAoQb0gOKs
-CSIFyiAiCM94egogABDZANiKIQgAABECIAK3IKfPcYAASG7WeQChAaHPcYAAKG4EIgIEABmAINR5
-ALEQJY2TLyhBA04gjge49ckA7/qjwKLB8cBmCM/6RcHPdYAAHA8ihTBwCPQmlRQUDjEwdgT0Vh2C
-EIDiDPTPdYAAVAXBjYDmANnKIEEAI/IhrY7iBPQB2B/wQSgNAgd9QSgBBKd5z3aAAFQFoI5TJUUR
-TCUAhMa5i/YKIcAP63IF2KPbIQWv+Yokgw9RJYCRBPIA2Fzxz3WAAIyTFiVNEeeNAKUUFAAx4K5G
-rQK1x3GAAAyUAIkHrQAZQgEAG0IBzPGiwUHBQSgCAgd6QSgBBEd5z3KAAAyUxrkqYue6EPQEFAMx
-z3GAAIyTVnlAgVBwBfRCkXByBvJHiee69fOA2APwBongf6LA4HjxwHoPr/q4cEokQACQ4Mohyg/K
-IsoHyiOKDwAA8wB8BKr5yiBqAUAtAwHHc4AAKG3Gi4wmApAA2A3yz3CAAIyTFiCNA6CFoKEmizZ4
-ApAAsohwlQeP+uB48cDhxc91gACMlM9xgAAcDwCBdBUCFhByIfQCkeoVAhcQch30dhUAFjoP7/93
-FQEWjCACgBPyz3KAAFgFIYIA2w8jAwAEuGZ5IaIAIIEPgAAobQCBqriIuAChANg5B6/69B0cEM9w
-gACgiSiIz3KAAGyWjCECgAKSQSgDAwvy67gJ9AS5x3GAAChtApEPIMAAArEA2OB/BLIA2kokAHRI
-cagggAPPcIAAcJXPc4AA8JU0e0CzNnhAoEGgAeFKJMBzANmoIEACz3CAAChuNHhAsAHhz3CAAFgF
-QaDPcIAAbJbgf0Sw8cA6Dq/6VGiGIvgDibpTIcMARXvPcoAAKG4Ueo/hiiUPHMogKQAJ9gCSAN4P
-Jk4QiiXPH8Z4ALJKJAB0ANqoIEAGz3eAAOiVVH/El6R+0XPPcIAAcJUM9ADexLdWeMCgwaDPcIAA
-EJZVeMCgAeI1Bo/64HjxwMYNr/oIc5hyz3aAAPCV9CZAEM9ygABwlVEgQILKIEEAyiQidMogIgDo
-IGIC9CYNEFElQJID8gHgkOBc9891gAAobnR94JUEu4Yj+AOJuw8nTxDgtQDdFnqgoqGiw7lleRR+
-ILbPcYAAEJYVeQAZAAED8IDYuQWP+uB4CHHDuM9zgADwlfQjAgDJulBxyiQidMogIgDoIGIC9CMC
-AMm6UHED8gHg4H7xwB4Nr/oA2aPBCHUBgMG4g+DKIEEAXAsi/8ogQgOB4BHyEIVRIICBD/IQhc92
-gAAUiVEgwIEa8s9wgABwDwKIGPAB3gLwAN4C2c9woAD0JiOgJYXPcIAAxJHuDW/+IaDJcCUFr/qj
-wAWFJoX2DM//lB4CEB+GBCC+jxBwAABh9M9wgACwrwCAUSBAgAXyUSVA0wHYAvQA2EDAlBaAEFEg
-wIFI9G2FJYXPcYAA7K6LcAQjgw/AAAAA4oE2uxEnwJBAJQISQCEECyXy5ZUcEQYAQicFFPQkwwAI
-Jk8BcHc2AAwAz3egACwgb4eA4xP05od8lnB3yPfPc4AAxJHig2WBcHcJ9IDgBPIC22CgA4GDuAvw
-A4HjuAryAN+ev89zoAD8ROGjo7gDoQuCBKEDggWhAMFVJkAakNpaD+/9ANsRhc9xgABYBQChQSgP
-A8O/lBaBEEEoBQVRIcCBFGkFIMQDBfIdhpW4HaZ98E8kQAKa/5Dg8gAGAM9xgAAQlpQWghDwIQMA
-QCoBBoYi/Q9SIsIBRbpFec9yoADEJ0EaWIACJcGAwCGEDwAAABAMv9dxAAAACJC/UfYFJ08RYhrY
-g4whAoDI9s9xgACQDAyBAeAMoQDZnblJ8OV7YhrYgNdxAADAD1IADAAOIYIPAAAAEM9xgABwlRZ5
-oOIAgQQRBQBQ9wDbDyODAGG7TiIPCAEowQNYeGV4AC2DAGV5FvBCIgIIANkPIYEAYblYeAV5iiD/
-Dwrwz3OAAJAMTYOKIP8PCHEB4k2jAdvPcoAATJZkqs9ygACMlOMaHAFyGhgAcxpYALjxANmcuR+G
-JXgfpkAlABLXBe//nB4AEPHAkgqP+hpwz3CAAAAAAIBRIICBosEh8s9wgAAAAAGAUSCAgUDYzyDi
-B8oggQ8AANAAzyDhB89ynwC4/x2iz3GAAAAABIEB4NO4BKEFIIAP0P4AABaiFcxVIFIk7bjRIGKA
-CvIHEgE2ANiYEQEAlgrv/QhyBBAAIIDgC/TPcKAA/CUjgC8giAQwuRBx9PcAEgAgAd1BwAQUADFB
-KBMDQBAAIFEggIEGFBExQfIVzOu4QPJAEAAgz3aAABSJUSDAgQbyz3CAAHAPAogI8BQQACAYEAEg
-FgrP/1EgwIGUHgIQyiRhIAvyHYYA35W4HaaKIAUJKgiv+ulxmneUFoAQz3GAALSRBLhGkQUgwARQ
-cAryz3KAAJAMAIJKJAAgAeAAogSR13AAAP//EPRKJAAgDvDPcIAAyHQrgADfAeEroN4Pb/qKIAUM
-mncCEAAhjCAChUX0BBAAIIDgC/TPcKAA/CUDgEAiASEweTC4MHDz9wDeSiQAdAHYyXGoIMAD8CIN
-IAHgUyUCEC+9hiV/H0V9O3pYfaV+AeEEEAEggOEL9M9xoAD8JSOBViICIlB6MLlQcfP3AN9KJAB0
-6XGoIAAE8CINIAHgUyUCEC+9hiV/H0V9O3pYfaV/AeEX8AIQACGc4DH0BBAAIIDgC/TPcKAA/CUD
-gEAiASEweTC4EHFz9/AiTiMIEg8gz3CgAPQmAtkjoAwQASDPcIAAxJEhoN4O7/4KcIHgHfTPcIAA
-AAAAgFEggIEH8s9xnwC4/wDYHaEB2KHwz3CAAAAAAIBRIICBB/IA2c9wnwC4/z2gENiT8EwkAKAj
-8s9woADELMegz3GAAKCJ6KAoiUArAiMQuZ+5RXlBKQIhRXkmoBXM67gN8hDZq7gUGlwwFRocMM9x
-gADAdQKBAeACoSoJT/4VEgE37LkG8gjYrLkVGlwwA/AA2EwkAKBV8s9zgACMlOATAgAUEA0gRCo+
-BwAjQQ6goRgQDSEB4qKxz3WAAKCJCBWEEOAbgADPdYAAtJEIGQIBCRnCBAoZRATDoaSV5KFALAME
-QCsCI2V6QSkDIaqxZXrPdqAAwC9HHpiQlOXAJYYfAACTAM9yoABoLPAiQgNLsY8WA5YI8KMWApaP
-FgOWUSIAgQX057v58wTw57vKIyEAQMMBFIIwxrvGulipeanPcYAAAAAggVEhgIEH8s9ynwC4/wDZ
-PaJlB2/6osDxwBYPT/oacM9wgABMlgSIgOAb8s9wgACMlHIQDgZzEA0Gz3GAAJAM4xARB89wgABY
-BeCAAoE0vwHgAqE18JoPb/qKIA8Dz3GgAMQnEREAhlEggIEA3/XzZBEChmQZ2IMC2BMZGICA4i8o
-gQBOIIEHEvLPcIAAcJU2eMCAoYDPcIAA8JX0IFEAz3CAABCW8CBPAAvwz3GAAJAMAYHpdel2OncB
-4AGhBBABIA1wIKAIEAEhDXAgsM9xgADQkQCBgOAG8kKBDXBAoADYAKHPcIAAHA8IgOu4yiCCA8oh
-QgPKIsIDbA8i/MojQgRTIcAgz3GAAFgFIIEUv1EhgIAMuOV4CfKCuA1xAKENcMCgDXCgoB/wDXEA
-oUokAHTgeKggwAJEJoEQD7lTJgAQJXgNcQChIr5KJAB04HioIMACRCWBEA+5UyUAECV4DXEAoSK9
-KQZP+uB4z3KAAHCVz3GgAAQlT6FWIgAEEaFWIgAFEKHgfkokAHQA2agggAIA2s9wgADwlTR4QLAB
-4ebx4HjxwIYNT/rPdYAAAAAghVEhgIEb8iGFUSGAgUDZzyHiB8ohgQ8AANAAzyHhB89ynwC4/z2i
-JIUB4dO5JKUFIYEP0P4AADaiz3aAALSRRJaU4sAihg8AAJMAz3GgAGgs8CGSAIDgXPIvjs9wgAAw
-b89yoAAsIM93gAAcDzZ4Iog8EhAADo44FxERgOCWACkAyiCpAIwgAaSKACUABNgA2AWiUNhFIUEC
-GNoWDqAAINv4uAjYN/QD2M9xoAD0BwWhhNoNcECwQiAAKA1yALJAhg1wQKBClg1wQLBAhw1wQKBC
-lw1wQLAGlkAqAiXDuAy4grgFeg1wQKAA2AShDo4B4A6uVgmgACpwAIVRIICBBvLPcZ8AuP8A2B2h
-Adge8ADYz3GgAMQsANpHoUih5pYMv5+/BSeDFGahz3OAAER1OYMB4TmjIIVRIYCBTq4G8s9xnwC4
-/12hjQRP+vHA4cUA3QzwRC0+FydwHNnF2h7bPg5v+hi7AeXPcIAAjJTgEAEAMHWw94kET/rgeOHF
-4caA4M9xgAColkWBJvLPc6AAyB9AEw4GQCiBAs91gAAUiUAVABHQfthg3JU+Zs9xgAAcD2kRjQCi
-fggmDRACfQkiQgMC2BUbGIBfoyKBz3CAAMSRIqDBxuB/wcXgeADZz3CAAMSRIKAhoOB/IqAA2s9w
-gADEkUGgz3CAABSJPJDPcIAAcA8ViAJ5gOHKIYwAz3KgAMgfH4IweRB4CCEBADB5AtgVGhiAP6Lg
-fuB48cDhxQh1iiAUDcYJb/qpcYHlz3GnAIhJANgL9M9wgAAcDwiAUSAAgAfYyiChAQ6hoQNP+vHA
-4cVRIADDz3WgAPQHLPInhRmFMHk4YAO4liBCBc9xoADIHx6hENgOoQHYFRkYgO4Ob/qB2FEgAMMW
-8s9wgABgBQHZI6ADyKQQAQCauaQYQABiDW/9AdjPcYAADA0EgQHgBKEZhYDgA/ID2AqlGYWA4ATy
-A9gKpSUDT/rxwKoKb/qYcEGB5LpwiULyz3aAAORKB4YIEYUAgOCyiWwSjzAD8qWGJPBJJ8AQ1GvP
-d4AAKG3GZ/a+CPLPdoAAMG92fsGOA/AA3sdwgAAwb3Z4BIgIJQ0QCCWNEwAlQBFJIM0DFmu1eM91
-gAAwcAVlz3CAAEhudnjPc4AAHA99gwGAZXgEIIAPAAAACAZ9A/Cjgei9mBlAAwDbCvKkEQAAANuX
-u5G4lLikGQAAUSQAgCPyG8jPdoAAdGvAuvAmDhDPcIAAeLKELgscMCBADgQggA8AQAAAPrge4Bh6
-RX3+vZgZQAMM8qQRAACFIwEEjLiRuKQZAACcGcAAHvD/vc9ygAAcDxKCEfKkEQ0AhSMBBJa7mLuN
-vZG9pBlAA5wZwACeuBKiCPCUu5a7nBnAAJ64n7gSot0BT/rhxeHGmBAOABsSAjYEJoEfAAAACDt5
-BCaNHwAAABAlfc9xgAB0a/AhggDpvoQqCwwAIYF/gAD8skAhAgaYEIMACPJEIwEMRLkuYom+yXEa
-8FEmAJLPcoAAGAVAggvyHOHCu35hyI55YTCJpX7QfkV5CPDDu3x7fmF5YTCJyI5FeYgYgAOleYwY
-QADBxuB/wcWhwfHA0ghP+gh1R8DovShw3gAhAEh2A7hAIJEFJ8HPcIAAAFgEJZIfBgAAAEEqQiQr
-YAQlgB/AAAAANripd3piz3OAAORbxr8IY0pjGmJBLYASUiAAAMC4A7gY4IXiyiCNDwEAiQ3VII4A
-LyAIIAQlgh8AAAAYz3CAAGxZ13IAAAAIHgAiAPAgwAOg4RIAAQDPcUJ70F4FKH4ACiDADipxBSk+
-AAogwA5MIgCgJLgB4ATyUyABADhg7b0CKIEjz3KAAFgPVZIR8s9zgABoWWCTBSs+AAAhgH8AAP8/
-Lrg4YI8AIABYYBV5hwAgAFhhUSVAklAAIQAnxbflIgALADNoUyUCEM9wgAB0WPAggAAFKT4ACiDA
-DgHgBvCK5cAo4QDAKKIAz3GAAHAPLonA2qR5hiH/DiK5OnraejcAIABYYDNoUyXAEBx4z3KAAIhY
-8CIAABbhBSk+AAogwA7PcoAAWA81kgHgFXkIktp4OGAQeAjcwwcP+uB4BCiADwAAL7pCKcJ0UHpE
-Kv4CAiBADhB4gOAE8gHiUHqD4ECxA/aA4AP0ANgC8IDY4H7geKHB8cAiDw/6osFKwTpwSHXpuRpz
-CiIAIS/yAtnPcKAAyBwpoCrBU23u4VB4BPSLcef/GfC34Qf0G3gQeItx5P8Q8JThA/QceAnwiuEE
-9AAchDAH8M9wAAD//wAcBDDgeADYz3KpAKT/uaIAFAExgrg3ohqiTvDouTDyTCIAoNEh4qFI9M9w
-pQCs/89zgABYD7igVZNok1tjAiDCIAPiIrpbYnpiSCJCAAW6RSJCA1agQSnCIcC6KsMHugQhgQ8A
-AAAgJbllekV5ibmOuTmgz3CgAKggCIAe8CrAgODKIcEPyiLBB8ogYQHKI4EPAADrDsokIQBkAyH5
-yiXBAAW9pXjPcaUArP8Woc9woACoIAiAz3CgAPxEBYAA3UojQCAEIL6PACgAAM9woAAsIAOAwiPC
-JAfwz3AAAEwPtg4P+s9woAD8RB2ATCMAoAQghA+AAAAABCCDDyAAAAAEII4PEAAAAAXyUSBAxgP0
-ANoC8AHaz3egANAbMYcEIL6PADgAAAQhgQ8AAACAzCIhgMAlYRAFIwIBJXoFIr6DBfSJ5ZgHzv+A
-4QXygOPMJiGQYPLPdaAAtEdrFQGW47kJ8s9xgABEdQyBAeAMoUvwUyG+gAnyz3GAAER1C4EB4Auh
-QfDnuT/0gOMI8s9xgACQDAmBAeAJoTfwgOYh8vq4CfLPcYAADA0GgQHgBqEr8Pm4CPLPcYAADA0I
-gQHgCKEj8HEVBJZvFQWWCiHAD+tyz3MAAHIPKQIv+QXYUSGAgc9xgACQDAXyHIEB4ByhC/AA2J64
-Ux0YkADYVx0YkAqBAeAKod3YAN2YvUYLL/qpcR7wEYfwuMogIQC4CGH6zyChA89woAD8RDmABoAL
-IECADfI2Dy/9AdgD2c9woAD0ByqgBd2YvQLwAN2A5RT0USHAoQvyTCIAoA70AdnPcKAA9AcsoAPZ
-BfAD2c9woAD0ByWgz3CAABQGAICA4Ajyz3KAABgxBYICcAWiz3GAAER1CoEB4Aqhz3CAALicIYDP
-cIAAHA8UkBBxDvTPcIAATCk6gBuAJHhRIACCyAji/8ogYgCpcAjcXwQv+qLA4HjxwA4ML/oA2c9w
-oAD8RJ65IaDPcKAA0BsRgO+4AN0L8noOL/0B2M9xgACQDB+BAeAfoQrIBCC+jwAAARADEg42IPKk
-FgAQ8rgc8s9xgABgBQGBgOAW8qGhBfBuDC/6iiCGCVEhgMX7889woADELKuA5NgSCi/6qXH+vVMl
-gRQf9AMSATagEQAA8LgA3aLyiiAIABQaHDD62OoJL/qgEQEAAxICNqQSAwD4uxHythIBAc9woACY
-Az6gm/CA4eLzmBYAEG4K7/8A2tzxABYBQTyyABYAQR2yABYAQA+iABYAQUAaBAAAFgBAEaIAFgBB
-SBoEAEQhAAOE4BnyGN5yGoQDABYOQIjg06IAFg5BUBqEAwAWDkFUGoQDB/QocIYg8w+MIAyAC/IY
-3hPwEN5yGoQDz3CAAASQp7AL8B7echqEAwAWAEAWogAWAEFcGgQAKHCGIP0MjCACggr0AubQfnIa
-hAMAFgBBYBoEAATwYBpEA+G+BPIAFgBBaHSEJAyQANgI8gAWAEAaogAWAEAbogjYdBINAb4SDwGi
-fwInjRMCfbgSgACYu6QawAACfdhgEHhyGgQAuhIAAbB9cBpEAyV4HLLPcKAAmAMegLYaBAAR8Iog
-EAAKGhgw+9iqCC/6oBEBAAPIoBCAAMTgEAwB/APZz3CgABQEI6B9Ag/68cACCg/6osEbEgE2z3eg
-ALwtz3CAABwPLqdqEBABz3CAAHRr8CBCAM9wgAD8soQqCwwAIFEOFRINN0AhEiZGJcARAxICNhUa
-HDCkEgAAhLikGgAAAZJAIRMigOAA3oYahAMJ8s9wgACIf/QgQACA4AbyAYLuuAT0oL2wfVMlfpBc
-AwEAz3CAAMB1B4DPc4AAwHUB4AejBxIDNqQbgAMBkoDgSvLPcIAAiH40eIAQAQeA4UL00BABAVMh
-wYAU9HISAQHgkiJ/uBKBACJ/8H/gGMQDpBIBAIYh848G8mi/8H/gGMQDcBIPAeAQAAEhkuJ48XDC
-Jw4QwiHOA3QSAAEZYbgSgAB0G4QDwLM4YBB4kBsEAL4bBAAQihCrAYIBowiKCKsSigDaEquWujPw
-ngkv+oogBAcPh/e4+vNPh/a6UyLAAifyjuBK989xgAAMDQOBtroB4AOhHfBkuAcSATYQeJAZBAAE
-IoAPAAAA8Cy4dBmEA8CxEKnBsQPIvhmEA2GAyKmGI/8NhLthoRKIEqn2ukwCAQAA2Ja49boHEgE2
-pBkAABHyxg2v/wDYBxIBNqQRAAAEIIIPAgAAAC26pXpQfUbwAYFRIACBWPLPd4AA5EoHh3KJgOBQ
-iWwShDAD8gWHI/AUas93gAAobQBn9rhJJMQACPLPcIAAMG9WeAGIA/AA2AAkjw+AADBvVn/kjwgj
-wwMIIwMASSPDAxZqdXjPc4AAMHAAY89zgABIblZ7QYPPc4AAHA99g2V6BCKCDwAAAAhGeJgZAAAA
-2Ja49LhBgYYi/w0f8oDiUvKYEYIAQCEAKUhgz3OAAEyQQMAgwsO6XHr0I4IAVvAKIcAP63IF2M9z
-AAA9C4okgw+tBO/4SiUAAJgRAwDpu5wZgAMj8oDigLikGQAALPKYEYAAz3KAABwPYhKCAIYg/wNE
-uDIiACCJuEDAIMNkeoYj/wOGIv8ORLt6Yk96z3OAAAhZ9COCACDwUSMAggrygOIK8pgRggBAIQAp
-SGAN8IDiBfQA2khwEPCYEYAAw7gceDIjACBAwCDCz3OAAByQw7pcevQjggCIGQAAmBEAAIQZhACQ
-EQEBAg6v/wDaBxICNgMSAzaEEgEBghoEAM92oADIHzhgEHiwGgQA+BYBELATDwEif89xgAAcD2QR
-AQECdz9nH2egFg4Q8H/Rd0IADQDPdoAAHA/ShpgTDwALJsCTF/RQitCLUHbRJyKSGPKYE48Az3KA
-AABY6mKB4tD2z3KAAChtBL7CYvG6CPLPcYAADA0RgQHgEaEO8DhgEHiGGwQAz3GAAMB1CIEVGlwz
-AeAIoX0G7/miwOB48cAuDs/5z3agAMgfoBYEEPgWAxCE4CX0AxICNqQSAAD0uHYSAQEH8s9wgACk
-kaGAA/CCEg0BFcxRIACBhBIAAQjyAiXCEAIkgwAIIwMABfCGEgMBG2PPd4AAHA9s8IHgR/QVEgI3
-A8jkungQAQEh8lEiQIDPd4AAHA9kFwIRCfJ+EA0BQn1ifQIkQwMq8IAQAwHPdYAAsG8AI4QAcIh2
-fWCVACMNAYQQAwG7YxrwpBACAPS6CPJwiM9ygACwb3Z6YJIE8IIQAwGAEA0Bz3eAABwPZBcCEV1l
-u2OEEA0Bu2OAEA0BumJ+EA0BIn0l8ILgz3eAABwPHfQDEg02FcxRIACBeBUBEWQXAhEJ8oAVABFC
-eGJ4AiQDAAfwghUDEYQVABFbYxtjgBUNESJ9BfAA22hxaHVochXMUSBAgGkXhBAI8gPIdhABAQIh
-AQFZYQnwgOMCIQEBxfZqFwARGWH4FgAQPWUCfR+GEHWM96DYD6YA2B+mP6YC2BUeGJCA2A6mFQXv
-+XB44HgbyMdwgACkfjSIAeEveYThNKgDEgI2jPbPcAMAhACgGgAAiiAIAAoaGDAL8IogEAAKGhgw
-z3ACAYQAoBoAAIogBADZAu/5ANnPcYAARHUNgQHgDaEbyMdwgACkfiyIAeEveSyoz3CAAERLAogQ
-ccn2iiAIAAoaGDCK2JC4DPAD2c9woAAUBCOgiiAQAAoaGDBC2Ji44H7gePHADgzv+QDZz3CgAPxE
-vYAEJb6fAAYAAAb0A8ikEAAA+rhU8gPfz3agANQH8qb6vQfyzv+KIAQASgrv+QDZ+b0K8tz/AxIC
-NghxoBoAADYK7/n82PO9AxIBNhHybyBDAKAZAACKIAgAChoYMIogRAISCu/5ANkDEgE28r0Q8gDY
-l7igGQAAiiAIAAoaGDCKIIQC8gnv+QDZAxIBNqQRAAD6uAryBdgQuKAZAACKIAgAChoYMM9wnwC4
-/1gYAAgTHtiToBEAAAPwKHCtA8/54HjxwEILz/kWCK//CHbJ/89xoADIHwh1QNgPoUARAQYweboJ
-r/3JcIkD7/mpcPHAA8ikEAAAUSAAgM9wgAAcDwTyHZAD8ByQ7/+A4Df0z3CgABQEA9kjoCDYFBoc
-MM9xgABEdRGBAeARoQPIANqYEAEAgBADAZQYQACeEAEBgBiEAJIYRAC+EAEBkBhEAKQQAQCsua25
-pBhAAH4QAQF+GIQAO2OwEAEBYnkwebAYRACCEAEBshhEANHA4H7geM9wgADYlgaAA9qB4AHYwHgM
-uIUgAwHPcaAA9AdFoQ1yALIDyADbXZANcECwA8hRgA1wQKADyEgQAgENcECwZKHgfuB48cA+Cu/5
-CHMQiTMRjQAB2kCrGxIPNs92gACwfu5mz3KAAOB+SNzBqxsSDzYCIg4D9CbOE8GzGxIONvAiggNB
-o0GBUSIAgRDy0onPcoAAMG8WetyrQIqGIn8MXHoEukV+3KsE8IDaXKsEuAV9vasckc9ygAAofw+z
-G8jwIgAABLMLyAWjVBEAAQyzAJENs6ARggBIowrIBCCADwIAQQDXcAIAAAAD9Ii6SKMKyAQgvo8A
-AEEQA/KJukijnBEAAc9zgABgBSa4wLhAKAIDD4HAuA24RXjRAe/5B6PgePHAYgnP+Qh1BvDPcAAA
-Yw0KCs/5z3agAMAvoxYAllEgAIH18wvIQB4YkBvIhuAG9LYOb/2pcIbwz3eAAOCPCo+A4AnyQCeA
-EkAlgRKiDu/5CtoDyAeIUSDAgAzyANj+DO/5kLgA2ZK5z3CgANAbMaDPcIAAcA8BiIHg7AthCcog
-IQwDyAOQJbjAuBe4x3AADgAARSABC+xwIKACEgE27HAgoCCF7HAgoCGF7HAgoCKF7HAgoCOF7HAg
-oCSF7HAgoCWF7HAgoCaF7HAgoCeF7HAgoCiF7HAgoAbwz3AAAEUNOgnP+aMWAJZRIACB9/MLyAQg
-gA8BAADwLLiU4MAghg8AAJMAz3GgAGgs8CENAM9wgABgBceA2di+Dq/5BSZBE2oL7/kFJkATKo+A
-4coggg8AALUEoA6i+c8h4gEA2AqviQDP+fHAHgjv+ZhwG8jPcYAAKH/wIQIAz3OAAIh+AxINNggc
-hAAbEg42QZWA4tR7yiIhAAzygBMAB4DgTPIA2oAbnADwG4QA4BuEAECzAYXuuA/0SLPQG4QAEI0E
-uMdwgAAobeWQgOfD9mG/5bAAJoAfgACkfkSoTKjPcIAACIHWeAKQwBuEANV5QKF4GwQAAYUEIIAP
-AAAAYNdwAAAAIA30z3CAAHRr8CCAA89xgACgBBR5AJEQ4ACxA9nPcKAAFAQwoIhwf//Z2M4Nr/kC
-EgE2PPBwFQAR4BMBAQIhDgAQdgf3wngCelB6gBucAM9yoADUBw8SDoYA2PAbhANwFQ0RwBsEAKJ5
-MHngG0QA0BMBAQHhMHnwEwUB0BtEAFMlfoDKIcIPyiLCB8ojgg8AAOcMyiSCDwAA/gAMBKL4yiBi
-AQPYExoYgEEHj/mhwfHAxg6P+aHBKHUacFpyBCG+jwEAAMA6cyz06L1AxQ3yIMHPcIAAAFgpYAQl
-gB8GAAAAMbg4YALwAdgEJYEfAgAAAddxAgAAAcogoQCB4A3yguAI8oPgANjKIOEBwCihAwfwA9gO
-uAPwANiOuAV9CnCGC+/8qXEKcKlxSnIqcwHdIg9v/5h1gOA99ArYz3GgAMgfHqEQ2A6hFRlYgwbw
-7g6v+YogCgNRIADDDfTPcKAA/EQdgAQgvo8wAAAABfRRIwDA7vNRIwDAyiHCD8oiwgfKIGIByiOC
-DwAAkgLKJCIAGAOi+MolIgBRIADDANgJ9M9xgACQDAmBAeAJoQDYmLgI3CMGr/mhwOB4ocHxwOHF
-USAAggh1qAAhAELAIsPPcIAAAFgEJYIfBgAAADG6a2AEJYAfwAAAADa4emLPc4AA5FsIY0pjQS2D
-ElIjAwDAuwO7GmIY44XiyiONDwEAiQ3VI44AcHFSACUAANjtvRgAIQACIcAAz3EcR8dxBSh+AAog
-wA4D8CK4QS1BE8C5BLk0ealyxrpJIsIFVHnrvc9ygACgWjJiBfJBKgEBFCGCAAUqPgBBKQByCNyT
-BY/5CiHAD+tyBdjPcwAABRFKJAAAKQKv+AolAAHgeOHFAxICNiCSQYJA4fS6wCGiAAPhz3OgANQH
-DxMNhgQhgQ8AAPz/sXAaYcj3G8gVIgEwHBEABh1lAiJBAxkTAIYQcT73DxuYgOB/wcXxwOHFA8ik
-EAEAmBACAFEhAIByEAEBSHAG8rYLb/8A2gh1B/AB4aoLb/8A2qxoAgvAAs9yoADIH/gSAQADyM9z
-gAAobRCIBLgAY+24BvQB2BOieIJZggbwAtgTonqCW4ICJUAQeGAQc8AibQANcQChDXBAoAAWAEAA
-FgBAA8jPcqAA9AdwEAEBaLknonAQAQFouTB5kQSv+XAYRADxwAIMj/mkEQAAosFRIACAz3CAABwP
-KHYD8huQAvAakJgWARAEIb6PAQAAwHYeBBAt9Oi5QcEO8iHCz3CAAABYSmAEIYAPBgAAADG4WGAD
-8AHYBCGCDwIAAAHXcgIAAAHKIKEAgeAO8oLgCfKD4ADYyiDhAcAooQMG8APYDrgE8ADYjrgFeZge
-QBCeFgARlB5AEJIeBBAQjs91oADUB0DAghYAEbIeBBAA2IAeBBB+HgQQA8hBkIDikBYQEQnyG8jP
-cYAAiH/0IQAAgOAS8hkVAJa44E73FczPcYAARHWGIIgCFRocMBWBAeDBAyAAFaEPFRGWgOIK8hvI
-z3GAAIh/9CEAAIDgBfJKI0AgBvAD2BMdGJBKIwAgAhISNgHZz3CAADAFIKAA2JG4z3GgANAbEaHP
-cIAA0AIQeM9yoAC0R0kaGIDPcIAANAXAoG8gQwBUGhiAEYELEg828bjKICEAqA6h+c8g4QNMI0Cg
-D/QHyAGQgOAh8s9xgAAMDQ6BAeAOoRCBAeAQoRfwA8gBkIDgE/IbyM9xgABYf/QhAABTIMCAC/TP
-cYAADA0OgQHgDqEPgQHgD6EDEgE2AYHuuA3yVBEAAVMgwIAH9M9xgAAMDQ2BAeANoQIWBRFMJQCA
-EvIBhu64yiHCD8oiwgfKIGIByiOCDwAAWQc8B2L4yiRiAACWsHDKIcwPyiLMB8ogbAHKI4wPAABb
-BxwHbPjKJGwAMI5TIcAAEK6GIf4DpBYAEES59rjAHkIQI/QLEgE2AiHCA4HiANgH8gInQhCMIsOP
-AvQB2IDgFfQVzM9xgABEdYYgiAIVGhwwFIEB4BShDx1YlAsa2DM1AiAAAhqYNAsa2DMCGpg0ANh0
-HgQQaguv+8lwz3GAAEBbdBYCEQlhWWHPcoAASFvwIgAAMHmkFgIQdB5EEAUghgCkHoARB8gBkIDg
-FfJMI0CgDvQBlrgWghA4YGCWWGAQeL4eBBA7YwAjhQAO8L4WABEJ8ECWuBaAEDpiWGAQeL4eBBC4
-cJAeBBAMIEChyiHCD8oiwgfKIGIByiOCDwAAkwccBmL4yiQCBADCEBaEEJByC/IKIcAP63IF2Ioj
-HgUBBm/4ABQFMA8VApZRJgCGtB6EEAfythYAEQ8dGJB/8AAWA0F8tgAWAkFdtgAWAkBPpgAWAkFA
-HoQQABYCQFGmABYCQUgehBBEIwIDhOIZ8hjfch7EEwAWD0CI4vOmABYPQVAexBMAFg9BVB7EEwf0
-aHKGIvMPjCIMgA3yGN8V8BDach6EEADfz3KAAASQ57IQ3wvwHt9yHsQTABYCQFamABYCQVwehBBo
-coYi/QyMIgKCCPQC5/B/ch7EEwAWAkED8ADa4b9gHoQQA/IAFgJByHSEJAyQANoJ8gAWAkBapgAW
-AkBbpgjaInjieAIggQC4FoAQAnkfZ7oWABEwefB/cB5EEGV4HLZPJgAGch7EE6QeABAPFQCWth4E
-EKQWABAIdIQkGpAk8lEgQIIf8gPIAZCA4BvyG8jPcYAAiH4UeYARAAeA4BH00BEAAWoWjxAB4MO4
-+GAPeGoeAhDODG/7yXBqHsITBPDCDG/7yXAPHViUNQGP//HAPg9P+RsSATbPcIAAdGvwIEIAz3CA
-AFiyQCAQCIQqCwwAIFMOtRMCJs9wgAAIgUCgz3KAAAAAAIJRIECAq8Ea8gGCUSBAgEDYzyDiB8og
-gQ8AANAAzyDhB89znwC4/x2jBIIB4NO4BKIFIIAP0P4AABajFMxRIACAlAYBAM9woADIHxMQAIbx
-uMogIQDQCqH5zyDhA89woADUBw8QAIYDEg42z3eAABwPtB4EEBCOUyDBAIYg/gNEuMAeAhAwrgoS
-EjYA2KQeABASpwvIBCCADwDAAADXcADAAACwjhf0G8jPcYAAiH4UeRGJgOAP9M9wgACwb7Z4IogI
-jhBxx/ZKcL4LL//Jcd/wUSIAoIXyBBYEEFEkAIFB8hvIz3KAAIh+z3OAAORKFHoREoUAR4MyjoDi
-D3gE8iWDJPBUbc9zgAAobUJj9rpJIMAAB/LPcoAAMG+2ekGKAvAA2sdwgAAwb7Z4BIgIIQEACCGB
-AKBxSSHBAxZtNXjPcYAAMHABYc9wgABIbrZ4QYAdh0V4BCCADwAAAAgGeQLwI4YbyM9ygAB0a/Ai
-AACYHkAQhCgLDDAgQC4EIIAPAEAAAEEoggdTJAAAHuJYeAV5/rmYHkAQCfIA2Iy4pB4AEFDYnB4A
-EHPw/7kO8gDYjbikHgAQz3BAAVAAnB4AEADYnrgSp2XwANikHgAQBdgUuJweABDA2Bi4EqdZ8FEi
-QKdK8gGGUSAAgTvyz3OAAORKB4MyjoDgbBKCMAPyJYMi8EkiwgAUbc9zgAAobQBj9rgI8s9wgAAw
-b7Z4AYgD8ADYx3KAADBvtnpEigghgQAIIQAASSDBAxZtNXjPcYAAMHABYc9wgABIbrZ4QYAdh0V4
-BCCADwAAAAgGeQLwI4aYHkAQG8jPcoAAwH4VeiCiANgE8AXYFLicHgAQUSIApQDYzyBiBMogIQCk
-HgAQA8gBgOy4z3CgAMgffhAAhtAg4gDPIOEAz3GgAMgffhkYgADYdB4EEF4Ob/vJcM9xgABAWwph
-dBYBEVlhMHl0HkQQz3GAAEhb8CEAAKQWARAleJgWARBRIUCCpB4AEAryO5eAuHYeRBB4HkQQpB4A
-EBLwKIdal1EhwIB2HoQQCPI7l4O4eB5EEKQeABAE8HgehBCeCi//yXCkFgIQRCJ+gowWgRAW8mIX
-gBAkeIYh/wNEuYYg/w44YM9xgAAYWfQhEQDPcYAACFn0IRAADvDDuc9wgAAskDx59CBRAM9wgAAc
-kPQgUADgusogAgQZ9JgWABBRIACCiBaAEMO40SIihQnyHHjPcYAATJD0IQAAB/AceM9xgAAckPQh
-AAAhhlEhwIDKICEAmBYFEFElAIKEHgQQUvKYFoEQz3CAAABYKWAEJYAPBgAAADG4GWEUbQAghA+A
-AChtABQAAAQgvo8AKAAAO/IE2LgeAhAA2I+4l7qkHoAQuh4EEAAUAAAEIL6PADAAACXyz3CAAORK
-YYB5pmaAInsWuwUjQwGuu6+7sLuYHsAQBYAEIIAPAQAAwAV7mB7AEAAUAAAEIIAPACAAACi4BSDF
-AJgeQBEH8M9wDECo/hmmA/AB2QPIAZCA4CjyG8jPc4AAiH/0IwMAgOMC9GGWuBaEEHQWBhEEJb6P
-AQAAwAAkgAF4YBB4OgPhAL4eBBCB4RbyguHMIeKADPIKIcAP63IF2BsBYACKI5gNYJbi8c9wgAAw
-b7Z4A4gH8M9wgAAwb7Z4AoiMFgEQDrgleIweABCEFwAQgOAH9M9wgAAMCACIgOBf8hsSATaG4Vvy
-AJa84LIADADPcIAAiH40eBGIgODRIiGAT/RRIgCgS/KeFgARUCWBA6+5sLmKuJ4eBBCYHkAQhBcA
-EC8oAQBOIIMHI7sO4wDYDyDAAAUhAwCYHsAQKHOGI/sPhiD7DwUjPoDPcoAAYAUIGkABGPIA2Jge
-AhCA4465IqIT8iiKz3CAAABYKGCB4M32guAF9AbYCKoH8AfYCKoF8A3YmB4CEKQWABC0uKQeABCe
-FgARp7ieHgQQmBYAEL4WARGWCC//ANqkFgIQBCK+jwAAADCCHgQQUvKMFgQQnBYBEZQeABGSHkQQ
-7LqAHgQUAxIDNg7yFNmQHkQQfh5EFHgTDQECIUEjMHmyHkQQEfAO2ZAeRBAA2X4eRBB4Ew0BSiEA
-IAIgQSMwebIeRBDPcYAACIEggYYhf48O9JgWDRBRJUCSCPRhk4DjBvSRupK6pB6AEBC5JXqkHoAQ
-MocEJIMPAAAAEFIjAwNleQQhgw8AAAAQfXtleTKnGfCYFgEQsh4EEJQeQBCeFgERSiAAIJIeRBC+
-FgERCiEAJJAeRBAA2YAeRBB+HkQQACEBJBlhhBYAEThgEHiwHgQQz3GfALj/VqGcFgAQFqEDEgE2
-khEAAYYNb/yUEQEAG/AD2M9yoADUByAaGIAB2BQaGIAAFgBACxoYMAAWAEACGhgwA8i0EAABDxoY
-gKIOL/nL2BsSATbPcIAAiH4UIEMAqJOA5QMSAjYd9JgSDQA1eK6gtqDPcIAAdGvwIEEAz3CAAKAE
-9CBAALwaBADQEwEBBCCADwAA8P/DuSV40BsEAAXw0BMAAbwaBAAB2KAaAACaCqAJsIqA4GYCIQAD
-EgM2CshRIICBWgICACGD+rkI8pDYkLhLAiAAoBsAAM9wgAAobUAgAgMEva1iwBOCALFyB/KR2JC4
-KwIgAKAbAADKg891oADIH6QVAhCMJv+fDfLCetdyAIAAAEf3h9iQuAMCIACgGwAA0Iv0buJgBCK+
-jwAAABP4YCry6boI8ovYkLjfASAAoBsAAOy6CPQFkIDgCPSI2JC4BPCF2JC4oBsAAM9wgAAcDxiI
-hODb9M9xgAAESQyBDyCAAwyhz3GAALQHAIEB4AChzfBCkDMTgAARIgCAJvILyAQggA8AwAAA13AA
-wAAAFPQIi4DgFfakEwAAtLikGwAAkhMAAae4khsEAJ4TAAGnuJ4bBAAK8FEhgIEG8o3YkLigGwAA
-o/AKyAQgvo8AAAEQdfLmDkACAxIDNghysBMOAagbAAAVhVUmQRbVuDBwz3WAAKiWRPcF2SelJYUC
-eeThyiAlAAkggACsGwAApBMAAPK4V/KYE4EAw7kLyDx5BCCGDwEAAPAbEg82z3CAAAiB9nilkKwT
-AABBLgYDCSBEA89wgAB0a/AgxQN+EwABgBMNAR1lz3CAAFgPF5C4YAgkDQACfQNtz3WAAABb8CVN
-ECK4BS0+EFMhDXAAJUAeLyQCAEAtQAE1eMdwgADUiKCQz3GgAMQsr6EBkBS/DqFALgAGnrjleAUg
-AAEKoc9xgABgBQHYAaEF8KAVAhCwEw4B0XJF9wXYGLigGwAAz3CAAPQHQYAgkwkhgQAAiIHgCPTP
-cKAAFAQJgBBxANgD9wHYgOAL9APYGLigGwAAz3GAAER1DoEB4A6hoBMAAAQgvo8BAQAAGvSSEwAB
-lBMBAJATAgGyEwMBCg7v/kokQAADEgI2oBIBACV4oBoAAM7Ymgsv+QISATYDEg02oBUAEAQgvo8B
-AQAABfICCQ//RwMAAQXMz3OfALj/GKPPcoAAYAUbEgE2AIIQcRvyz3CgADguBYAEIIAPwAAAANdw
-wAAAAAvy9dgFuBqjO6Np2Bi4GaMB2ALwANiB4AP0IKIKyAQgvo8AAAEQyiYhEH7ypBUAEPK4OPIB
-goDgAN858gDYAaKAFQARfhUPER9nz3CAAFgPF5AfZwbwNg0v+YoghglRIYDF+vPPcKAAxCzLgOTY
-2gov+clxUyaBFP6+zCEigA3ymBUAEHIL7/4A2s9xgABYDyiRIngfZwLwAN8DEgI2AN4J8M9wgAAI
-gTZ45ZAA3qlygOfPcaAAyB+sFQAQCPSkFQMQsbukHcAQBPAJIMADA9sYu2+h+BEDAIDnoWsIIEAD
-YnigGQAAANiYuA6hDPKkEgAA8bgVzMUgogTPIGEAFRocMAGSgOAJ8hvIz3GAAIh/9CEAAIDgBPIB
-gu64BvIVzIC4FRocMMzYIgov+QoSATYDEgI2pBIAAPi4CPK2EgEBz3CgAJgDPqCG8AAWA0F8sgAW
-AUE9sgAWAUAvogAWAUFAGkQAABYBQDGiABYBQUgaRABEIwEDhOEa8hjdchpEAwAWDUCI4bOiABYN
-QVAaRAMAFg1BVBpEAwj0aHGGIfMPjCEMgAzyGN0U8BDdchpEA89xgAAEkMexDPAe3XIaRAMAFgFA
-NqIAFgFBXBpEAGhxhiH9DIwhAoIL9ALlsH1yGkQDABYBQWAaRAAD8GAahAPhvQPyABYBQQh0hCQM
-kEokAAAJ8gAWAUBKJAACOqIAFgFAO6J0EgEBvhIPASJ/on+4EoEAAicPEZi4pBoAACJ/PWW6EgEB
-8H+wfc9woACYA2V5cBrEA3IaRAM8sh6AthoEALySRCUAE4TgU/IbyM9xgACIfhR5wBEAAaV4oYLP
-c4AABJDtvRyyCvJUEg0BvBIPAcO95X1UGkQDoZKA5Svy0BEPAVQSDQHDv+V9VBpEA4ARAQeA4QP0
-irgcsqQSAABRIACCC/JUEgABaBIBAcO4OGAQeGgaBACkEgAAUSBAggvyVBIBAWoSgADDuThgD3hq
-GgIAC8gEIIAPAMAAANdwAMAAAAT0x7MF8ADYi7gHsxyShiD9DIwgAoIO9BCKz3GAADJtBLgQYYHg
-BvRgEgABhLhgGgQACtjPcaAAyB8eoRDYDqEB2BUZGIAF8FIKL/mKIAoDUSAAww70z3CgAPxEHYAE
-IL6PMAAAAAT0USMAwO/zUSMAwA3yCiHAD+tyBdiKI4oESiQAAIEG7/cKJQABUSAAwwDYCfTPcYAA
-kAwJgQHgCaEA2Ji4gOAM8gPZz3CgABQEI6CKIBAAZwfgAAoaGDADyKQQAAAEIL6PAAAAMLvy9LgJ
-9P4Oz/7W2H4P7/gKEgE2A8ikEAEA7LlE8moP7/jN2MYKL/8B2AMSATYD2x2xz3CAANiWBoDPcaAA
-9AeB4AHYwHgMuGWhhSACDQ1zALMDyH2QDXBgsAPIb4DguwDaCPIIEwMgDXBgoAwTAyEH8A1wYKAD
-yEAQAwENcGCwA8hxgA1wYKADyEgQAwENcGCwRKFyDQ//ChIBNrMG4ADQ2OYO7/jR2AMSATYBgfi4
-D/LPcIAA0AcAkB2xz3CAANQHQIABgFGhEqEH8B4KL/8C2AMSATYdsb4ND/8DyPoML/94EAABgOBq
-BsIA0tiaDu/4ANkDEgM2mBMAAJQbAAABg/i4FfLPdYAA4I+pcMoNL/9ocRDYFBocMBXMo7gVGhww
-1g8v/6lwKwbAAJ4TAAGSGwQAvhMCAZAbhACSEwABlBMBAP4Ib/+CEwMBCHXP2DoO7/ipcfi9D/ID
-2c9woAAUBCOgiiAQAAoaGDD92N8F4ACpcQMSDjakFgAQ9LiaAoEAcI7PcoAAsG/PcIAAAACggHZ6
-USWAkSCSGvKhgFElgJFA3c8l4hfKJYEfAADQAM8l4RfPd58AuP+9p6SAAeXTvaSgBSWNH9D+AAC2
-pxXMUSBAgAzyz3CgACwgD4CEFg0RCCBAA6J4A/AocLAWDRFk5bFwFvfPcYAARHUbgQHgG6HPcIAA
-AAAAgFEggIEA3Qbyz3CfALj/vaAA2Lvwz3WAAChtBLtjZQDfBCOND4ADAAA3vWW9SCUNEAQjgw8Y
-AAAAM7sN4w8nzxAJIEEAAxKQAPoIb/+YFgAQCSDBA5gWABBBKEIDwLoEulR6CHPGu0kjwwV0euu4
-z3OAAKBaUmMG8kEqAAEUIIIAKLq4egNqBCCADwAA/P/PcoAApJEDos9yoADELA2iMBoABAvIGxID
-NgQggA8BAADwQSgNA0AtABaduBS7ZXgFeSqiz3KAAJAMHYIB4B2isgzv+OPYlOXKIUUDhfepcYAh
-wgHPcKAAGCzwIEAAlOXAJYYfAACTAM9woABoLPAgQAMF8J7Yvg7v+Iy4USGAxfvzz3CgAMQsq4Dk
-2GYM7/ipcQQljx/wBwAA/r00v1MlgRQH8oHnxfcAlhDgEHEE9wMSDjZW8RCOz3KAAChtBLgAYvu4
-1SHCA891gACkkSCl4qWYFgAQxgyv/gDaAaXPcYAARHUcgQHgHKEagQMSDjYA3R9nAdj6oYDgBACB
-AM93oADIH5QWBhCSFgcRz3CAAKSRIByAMSGAABAUAM9wpQCs/89ygAAcDy8kSABgGAAFTBIDAWYS
-BQGgcwIkwgAD4iK6W2J6YkgiQgAFukUiQgNWoFEnwIGA2soiQQMow2V6BCaDDwAAACAlu2V6ibqO
-ulmgQBcAFhXMUSBAgA/yoBcAEPgXAhBCeQIgWAB2FgERLyAINhlhBPCEFhgRA3E6HgQWH4cQccn3
-MHjPcYAAHA/CCS/+aRGBAM9woADUBwHZNKAzoAPYz3GgANQHDaEREQCGQMBA4A8ZGIAUGViDA8ik
-EAAAUSAAggXyygtAAQPwRx9Yk89woADUBw0QAYZAKAA0MHkFeQPIQYAAEBMBQcK4EJcAchACAQIi
-1QW6EAIBeYBCws9yoADUB4gawACkEAIAt7qkGIAAuaC4GEIDuhhEAwHA9rgH8s9zoABICEAjACMG
-8EAjACHPc6AATAgCwuJwBSGSACdoz3IAAPz/RHnPcoAApJFDggghggDPdqAA1AcVpgAbgAQCI0Al
-D6YCIkMAe6YD2TCmC8jPcYAAtJEEIIAPAQAA8Cy4AxIDNgSxD4MCJJQgAKFAEwABrqkCsRCLz3aA
-AAR/YBMDAVRoD6nDu2V6RrHPcIAApJFBgBsSAzZAJgUZz3GAAIh+UHh1fmmGViHEAnhgCaakFwAQ
-WGD4FwIQz3MAAPz/QnhDwM9yoADUCwHYEKIBwM9ygACkkUKCNbjAuAK6K+IXuGR6x3AADgAARXjs
-cgCiAhICNuxwQKDPcIAApJFCgOxwQKgbEgI2FCGAAFCI7HBAqOxwoLAbyPAkAgDscECgG8jwJQIA
-7HBAsOxwoLDscKCg7HCgoAsSAjbscECgAxICNgCSVBICARC4RXjscgCiAxIDNgGDUSAAgQ/yUotw
-i89wgAAwb3Z4AIiGIH8MHHgEuEV4AvCA2OxyAKoDyFCIMxCAAAS6BXrscECoA8hckOxwQLADEgI2
-nBIAAVEggIEA2M8gIgPKIEEDT4LAug26RXjPcoAAYAUHohvIqXYAIIIPgACwfqCqz3KAAAiBFnoU
-eaCxQpLAGUQDFSUAAKCgz3CAABwPeBmEAByQ0BlEA0TAz3CAAKSRIoA7dYDhwAMuAMonThM6dRp1
-qXdMIQCgtvIBgM9xoADIH5YgQQ8eoRDYDqEB2BUZGIAU8M9woAD8RB2ABCC+jwAWAAAH8vq4E/T5
-uA70/LgP9FEjAMAQ9M9xoAD0ByeB/7kA2OjzGPCKIIgAFPCKIEgAEvAB2c9wgABgBSOgSgzv+yhw
-z3GAAAwNBIEB4AShiiAIAgUnD5AqAyIAAN7PcaAA1AcPgRB4GREChljgUHDU9w+BEHgZEQKGWOBQ
-cMb3hBEAALLgN/cPgRB4GREChljgUHCMAA0AHhkYhB0RAIYHEgI2CxoYMB0RAIZAKAM0ScAdEQCG
-z3aAADAFALIdEQCGAaJWIAAiHhkYgB0RAIYAEhMBEHkFIdIAIYIA25G7hiDzD0HBz3GgANAbcaHP
-cYAASAMwec9zoAC0R0kbWIBAIAEiIKbPcYAANAVAoW8hQwBUG1iAjCAMgA/yGtgO8M9xgABEdR6B
-iiUQEQHgHqFVAiAAAN4g2Lpw4nAQeHIaBAAA3kwhAKAE9AMSATax8AHA9rgH8s9xoABICEAjACMG
-8EAjACHPcaAATAjicEbAAsBFwQUiEiAGwAfgz3GAAKSRI4EEIIAPAAD8/wggVgAMJgClWAAtAEfA
-USBAwzHyz3CAAKSRAYDPcaAAyB+WIEEPHqEQ2A6hAdgVGRiANgzv+EHYUSBAwxvyAdnPcIAAYAUj
-oLIK7/sB2M9xgAAMDQSBAeAEoYogCAIk8M9xgABEdR2BiiUSEAHgHaHE8M9woAD8RB2ABCC+jwAG
-AAAM8vq4yiCCDwAAAQIM9Pm4iiCIAAj0A9nPcKAAFAQloADYBScPkADep/QB2M9xoADUBxQZGIBV
-IEAkDxkYgFEiAML+9QbAz3GgANQHFaEFwgDeAiNAJQAagAQPoQfCAiSUJQImgCAboQPYEKEDyOlx
-yLkIiAy4JXgFEgE3ELkleOxxAKEJwEAhWTACGhgwBxIBNgPIABwANAMaWDAHGhgwAYEgkTS4UyAC
-AADAVHkD4QQhgQ8AAPz/QOAAIRAAGxIBNgfwFSJAMBwQAAYCIBAgFSJAMBwQAAYScPX3BczPcZ8A
-uP8Yoc9woAD8RD2ABCG+jwAGAABs9EwhAKAG9BTMUSAAgBPyz3CgANAbEYDxuMogIQDQCuH4zyDh
-AwDZkbnPcKAA0BsxoEwhAKAM8gfIUIhTIsEAhiL+A0S6wBiCADCoz3CgANQHFBiYgwPIQCFRICiI
-AeEoqAsSATbPcKAASCw9oM9wgACkkSKAMnFYBM3/AvDpdVMlfpBf9FEgQMND8s9wgACkkQGAz3Gg
-AMgfliBBDx6hENgOoQHYFRkYgEYK7/hB2FEgQMMt8gHZz3CAAGAFI6DCCO/7AdjPcYAADA0EgQHg
-BKGKIAgCNvBMIQCgiicQEAj0C8jPcqAASCyKJwgQHaL6uc9xgADAdQbyAIGAvwHgAKG/8QGBgb8B
-4AGhufHPcKAA/EQdgAQgvo8ABgAADPL6uMoggg8AAAECDPT5uIogiAAI9APZz3CgABQEJaDJcAV/
-gOcX8uG/DPIDyCmIAeEpqM9xgADAdQGBAeABoQrw4L8I8s9xgADAdQCBAeAAoel1A8jpcci5CIgM
-uCV4BRIBNxC5JXjscal0hCQCkQChQCFZMBXyz3GgANQHgBkABQXMqXLIuhC4RXjscgCizKEB2BQZ
-GIAeCm/+QCFZMAMSAjaSEgAB6rgHEgE2BvSSEQMBUSOAgjbyqriSGgQAkhEAAaq4mg0gBZIZBAAQ
-2c9woADQDxAYWIAkEAGGz3KAAOCPRZIweQK6RXkMGFiAFNkQGFiAz3GAAOCPZ5FGkRjZELtlegwY
-mIAQGFiAz3GAAOCPaZFIkRC7ZXoMGJiABvDPcIAA4I/KqM9xoADUC9ChgOV08s9wgACkkQKAM3DI
-9wja7HBAoEAhWTD28QvIBCCADwEAAPAsuJTgwCCGDwAAkwDPcqAAaCzwIgIAz3CAAGAFB4Dpv0V4
-DaED2s9xoADUB1Khz3CgAPAXRaAF8lIP7/4AwAXwExmYgBQZmIPnv8oggg8AAAYBFPTgv8oggg8A
-AAMBDvThv8oggg8AAAQBCPTiv4ogRAHKIIEPAAAHAXoKr/jpcc9yoAAsIDCCA8AwcAHZyiGGA0Qg
-g0APguTgAdjKIIYDgOHMIyGAzCAhgOvzz3AAKAgAChoYMATAZgpv/ADZ9QUAAM9wgAAgNhKIUSAA
-gBfyUSAAwxXyz3CAACA2D4jPcYAArJwQuCCJn7iA4QHZwHkPuSV4z3GgAPxEDaFMJACgDfLPcKAA
-9AdgGAAFz3GAAER1HYEB4B2hC8gEIIAPAQAA8Cy4lODAIIYPAACTAM9xoABoLPAhAADPcYAAYAUn
-gSV4z3GgANQLDaHPcKAA1AfMoIogBAKeCa/46XHqD6/+BMDPcKAA1AcZEACGwOA6BQ4AFcxRIECA
-MgUBAAPYz3GgANQHIBkYgM9woADUBwHZFBhYgM9wgAAwBcCgANnPcKAAyB+RuRMYWIDPcIAA0AIQ
-eM9yoAC0R0kaGIAHyM9xgAA0BQChbyBDAFQaGIDPcKAAyB8TEACGz3eAABwP8bjKICEAlA6h+M8g
-4QPPcKAA1AcPEACGBxINNgPZtB0EEM9woADUBxMYWIAQjVMgwQCGIP4DRLjAHQIQMK0QFZEQpB2A
-EwvIBCCADwDAAADXcADAAADSpxn0G8jPcYAAiH4UeRGJgOAR9M9wgACwbxYgQAQiiAiNEHHJ9s9w
-EiAAAHoPL/6pcVHwAYVRIACBPvLPc4AA5EpHgzKNgOJsygPyJYMm8EkgwABAKQIhz3OAAChtQmP2
-ugjyz3KAADBvFiJCBEGKA/AA2sdwgAAwbxYgQAQEiAghAQAIIYEASSHAA0ApgSEVec9wgAAwcCFg
-z3CAAEhuFiBABEGAHYdFeAQggA8AAAAIBnkD8COFmB1AEBvIz3KAAMB+FXogogDYnB2AE5G4pB0A
-EAPIAYDPcaAAyB/suH4RAIbQIOIAzyDhAH4ZGIB0HYQTPguv+qlwz3GAAEBbdBUCEQlhWWEweXQd
-RBDPcYAASFvwIQAApBUBECV4pB0AEJgVABBRIECCDPIbl3YdBBB4HQQQpBUAEIC4pB0AEBTwCIc6
-l1EgwIB2HUQQCvIbl3gdBBCkFQAQg7ikHQAQBPB4HUQQdg8v/qlwpBUBEEQhfoKMFYIQFvJiF4AQ
-RHiGIv8DRLqGIP8OWGDPcoAAGFn0IhIAz3KAAAhZ9CIQAA/wUyLAAM9ygAAskBx49CISAM9ygAAc
-kPQiEADgucogAgQY9JgVABBRIACCiBWAEMO40SEihQjyHHjPcYAATJD0IQAACPAceM9xgAAckPQh
-AAAhhVEhwIAF8oQdBBAD8IQdhBOYFQAQ6LhT8pgVghDPcYAAAFgEIIAPBgAAADG4SWEZYUApACHH
-cIAAKG1AgAQivo8AKAAAPvKkFQIQl7qkHYAQBNq4HYIQANqPurodhBBAgAQivo8AMAAAJvLPcoAA
-5EphgnmlZoIie5gVBRBAK4QFBSRDAa67r7uwu5gdwBBFggQigg8BAADAZXqYHYAQAIAEIIAPACAA
-ACi4RXiYHQAQCPDPcAxAqP4ZpQLwAdkDyAGQgOAn8hvIz3KAAIh/9CIAAIDgA/QBlb4dBBC4FYMQ
-dBUCEXpiWGAQeL4dBBCYFQUQBCW+jwEAAMAN9AohwA/rcgXYiiOYCnUEb/eKJIMPAJXj8YHhDfKC
-4cwh4oC4BAL/z3CAADBvFiBABAOIB/DPcIAAMG8WIEAEAoiMFQEQDrgleIwdABCYFQAQvhUBESoO
-L/4A2oIdBBCkFQAQBCC+jwAAADBT8owVABDPcYAACIGUHQAQnBUAEZIdBBCAHQQUpBUAEOy4AxIC
-Ng3yFNiQHQQQfh2EFHgSAwECIsAgEHgL8A7YkB0EEH4dhBN4EgMBAiDAIBB4sh0EEACBhiB/j6QV
-ARAN9JgVAxBRI0CCCfRBkoDiBfSRuZK5pB1AEBC4JXikHQAQjBUAEAQggA8AAAAQUiABAxKHJXgE
-IIEPAAAAED15JXgSpxXwmBUAEJQdABCeFQARkh0EEL4VABGQHQQQgB2EE34dhBOCFQARsh0EEIAV
-ABF+FQERGWGCFQARGWGEFQAROGAQeLAdBBCkFQAQz3GfALj/FqGcFQAQFqEHyM9xoADIH7AQAAGg
-EQEAZOAwcMoghQ8SKAgAhPfPcAAoCAAKGhgwFcwEIIAPAAACCILgCfQHEgE2iiAEANoKr/uYEQEA
-GxIBNs9wgACYfjR4wLADyGoMoAIakM9wgAAAAACAUSCAgcoDQQDPcJ8AuP/doL8DQACkFgAQtLik
-HgAQkhYAEae4kh4EEJQWABCQFgMRz3GlAKz/sBYCEc91gABYD3ihdZWolUjAu2NiegPiIrpbYnpi
-SCJCAAW6RSJCA1ahKMIEIIAPAAAAICW4RXiJuI64GaHPcKAAqCAIgAPZz3CgAPQHJaAbyJgWAhDP
-cYAAwH4VeUChAZaA4BTyG8jPcYAAiH4UedARAAFTIMCACvLwEQEBz3CgAJgDPqC2HkQQpBYAEOm4
-BfIKC0/6I/AIdIQkEpAM8vm4BAph+soggQMD2c9woAAQFCWgFfBRIACCBvLaC8AAVgzAAA3wcBYC
-Ec9woAD0BwDZR6DPcKAAyBwnoAPIpBAAAFEgAIEI9GYKT/7b2OIKb/gKEgE2AxIBNtPY1gpv+KQR
-AQADEgM2AYP5uAj0Ig5v/gTYAxIDNh2zz3CAANiWBoAB2oHgwHoMus91oAD0BxmFANmA4Mohwg/K
-IsIHBdjKI4IPAACfALYCYv/AKyIBHJNFeA1yALIDyF2QDXBAsAPIT4ANcECgA8hAEAIBDXBAsAPI
-UYANcECgA8hIEAIBDXBAsAMSAjYckoYg/wyE4B/yU4INcECgA8hQEAIBDXBAsAPIVBACAQ1wQLAD
-EgI2HJKGIPMPjCAMgAn0VoINcECgA8hcEAIBDXBAsAMSAjYckoYg/QyMIAKCGvRgEgIBDXBAsAMS
-AjakEgAA97gQ8lmCDXBAoAMSAjakEgAAt7ikGgAAOaK4GkIAuhpEAKQSAABRIICBBvIBgvC4lA6C
-/g/wOoINcCCgAxIBNqQRAACGIPOPBfI7gQ1wIKAB2AulA9gIpQMSATaSEQABUSCAggvylBEAAAQg
-gA8BAADAbgrgBC64z3CgAPxEHYAEIL6PAAYAADD04HjgeOB4USBAwyryA8jPcaAAyB+wEAABliBB
-Dx6hENgOoQHYFRkYgLYOb/hB2FEgQMMW8s9wgABgBQHZI6ADyKQQAQCauaQYQAAqDW/7AdjPcYAA
-DA0EgQHgBKF+Dk/+CHXU2PYIb/ipcQQlvp8GAMoACvLPcYAADA0HgQHgpwBgAAehA9nPcKAAFAQl
-oAMSATYBgVEgwIAk8qQRAABRIACAz3CAABwPA/K9kALwvJDPcYAAIDYSiVEgAIAU8i+Jz3CAAKyc
-ELkAiJ+5gOAB2MB4D7gleM9xoAD8RA2hBPB2EQ0BFcxTIECADvLV2G4Ib/gKEgE2CsgHEgE22g2v
-/hsSAjbPdoAA4I/JcJ4Pb/4DEgE2rg7P/cINT/6A4AYAQgADEgE2khEAAeq4BvKquD4K4ASSGQQA
-AxICNgohgC+AAMB+fhIBAYISAAGAEgMBOGDPcYAABH8bYxvIcHsVeQmBeGAJoQGCUSDAgFzy19jq
-Dy/4ANl6C+/7gNgKEgE2BCGBDwIAAQDXcQIAAAAVEgI3CfT9uAfyTyLAABUaHDAF8KO6UHgVGpww
-AxICNiGCUSGAgS7yi7iMuBUaHDAwijMSgADPc4AAtJEEuSV4z3GgADguJIEGsxDwLy5BEE4mghcA
-3g8mjhDGec92gABgfvQmjhDRcAnygOHx9c9wAAD//wSzBvBEs89wnwC4/1agCNgUGhwwz3GAAER1
-EYEB4BGhNPAQ2BQaHDAVzKO4FRocMJoIr/7JcNjYIg8v+AISATYDEgI2AZKA4AryG8jPcYAAiH/0
-IQAAgOAM8gGC7rgI9BvIAdoAIIEPgAAQf0CpFcxTIECACvIHEgE2iiAEAIYNb/uYEQEAIg1v/qlw
-A8gakB4PYAIbEgE2FcxRIMCAeAYhAAoSATayDi/419jPcIAABJADEg42AoDPdYAAHA+YHgAQ8I4K
-EhA2ANikHgAQEqULyAQggA8AwAAA13AAwAAAF/QbyM9xgACIfhR5EYmA4A/0z3CAALBv9ngiiAiO
-EHHH9gpwOg3v/clx4PBRIACgiPIBhlEgAIFC8hvIz3KAAIh+z3OAAORKFHoREoQAR4MyjoDiD3gD
-8iWDI/BJIMAAVG/Pc4AAKG1CY/a6CPLPcoAAMG/2ekGKA/AA2sdwgAAwb/Z4BIgIIQEACCGBAIBx
-SSHBAxZvNXjPcYAAMHABYc9wgABIbvZ4XYUBgEV4BCCADwAAAAgGeQPwI4aYHkAQG8jPcoAAdGvw
-IgIAz3CAAHiyhCoLDDAgQA4EIIAPAEAAAD64QYbAuh7gGHpFef65mB5AEAvypBYAEIy4pB4AEFDY
-nB4AEHLw/7kP8qQWABCNuKQeABDPcEABUACcHgAQANieuBKlYvAA2KQeABAF2BS4nB4AEMDYGLgS
-pVjwUSBAp0fyAYZRIACBOvLPc4AA5EongxKOgOFsEoIwBPIlgyPwSSLCADRvz3OAAChtIWP2uQfy
-z3GAADBv9nkhiQLwANnHcoAAMG/2ekSKCCCAAAggQABJIMEDFm81eM9xgAAwcAFhz3CAAEhu9nhd
-hQGARXgEIIAPAAAACAZ5A/AjhpgeQBAbyBUhACAgoADYA/AF2BS4nB4AEFEgAKUA2M8gYgTKICEA
-pB4AEAPIAYDPcaAAwB3suACB0CDiAM8g4QAAoQDYdB4EEOIPL/rJcM9xgABAWwphdBYBEVlhMHl0
-HkQQz3GAAEhb8CEAAKQWARAleKQeABCYFgAQUSBAggzyG5V2HgQQeB4EEKQWABCAuKQeABAU8AiF
-OpVRIMCAdh5EEAryG5V4HgQQpBYAEIO4pB4AEATweB5EEBoM7/3JcKQWARBEIX6CjBaCEBbyYhWA
-EER4hiL/A0S6hiD/Dlhgz3KAABhZ9CISAM9ygAAIWfQiEQAP8FMiwADPcoAALJAcePQiEgDPcoAA
-HJD0IhEA4LnKIEIEGPSYFgAQUSAAgogWgBDDuNEhIoUI8hx4z3GAAEyQ9CEAAAjwHHjPcYAAHJD0
-IQAAIYZRIcCAyiAhAIQeBBCYFgAQ6LhS8pgWghDPcYAAAFgEIIAPBgAAADG4SWEZYRRvx3CAACht
-QIAEIr6PACgAAD3ypBYCEJe6pB6AEATauB6CEADaj7q6HoQQQIAEIr6PADAAACXyz3KAAORKYYJ5
-pmaCInuYFgUQQCuEBQUkQwGuu6+7sLuYHsAQRYIEIoIPAQAAwEV7mB7AEACABCCADwAgAAAouGV4
-mB4AEAfwz3AMQKj+GaYD8AHZA8gBkIDgKvIbyM9ygACIf/QiAACA4AL0AZa+HgQQuBaDEHQWAhF6
-YlhgEHi+HgQQmBYFEAQlvo8BAADArgSB/4HhDvKC4cwh4oB4AcL+z3CAADBv9ngDiAnwAJbg8c9w
-gAAwb/Z4AoiMFgEQDrgleIweABCEFQAQgOAH9M9wgAAMCACIgOBp8hsSATaG4WXyAJa84MYADADP
-cIAAiH40eBGIgOBb9KQWABBRIACAVfRRIACgU/KeFgARz3GAAGAFirieHgQQmBYCEM9w/v//P0Kh
-BHqYHoAQhBUDEC8rwQBOI4AHI7hAIIMDANgPIMAABSIDAIYi+w+GIPsPBSI+gJgewBAe8gDYmB4C
-EAKBrrivuLC4USAAgk8gggNCoRPySInPcIAAAFhIYIHgzfaC4AX0BtgIqQfwB9gIqQXwDdiYHgIQ
-pBYAELS4pB4AEJ4WABGnuJ4eBBCYFgAQvhYBEQYK7/0A2oIeBBCkFgAQBCC+jwAAADBU8owWABCU
-HgAQnBYAEZIeBBCAHkQUpBYAEOy4AxICNgzyFNiQHgQQfh6EFHgSAQECIkAgEHgN8A7YkB4EEADY
-fh4EEHgSAQECIUAgEHiyHgQQz3CAAAiBAICGIH+PpBYBEA70mBYDEFEjQIII9EGSgOIG9JG5krmk
-HkAQELgleKQeABCMFgAQBCCADwAAABBSIAEDEoUleAQggQ8AAAAQPXkleBKlF/CYFgAQlB4AEJ4W
-ABGSHgQQvhYAEZAeBBAA2IAeBBB+HgQQghYAEbIeBBCAFgARfhYCEYIWAREaYoQWABFZYThgEHiw
-HgQQpBYAEM9xnwC4/xahnBYAEBahChIBNtzYPggP+N0BL/irwPHA4cVv2JW4z3WgAMgfEh0YkM9w
-AQBAPBUdGJAOC4/7iiAEAA6lEQIP+OB48cCKCS/4A9jPdqAA1AcTHhiQDxYRlgAWAUAAFg1A07nP
-cLD+AAAFec9ynwC4/zaiUyXBFCV4FqKveJzgyiHCD8oiwgfKIGIByiOCDwAA3QvKJMIAYAbi9sol
-IgAAFg9A8H8AFhBAQOdRIAClwCeiEAPnBCePHwAA/P8H8M9wAADxC8oJD/gZFgCWQicBFBBxNvcA
-IcAjDx4YkAPYIB4YkNrYZg/v96lxBCCALwAAAEA5AQ/48cDWCA/4CHXPcYAAAAAAge24giQDMRry
-AYHtuEDYzyDiB8oggQ8AANAAzyDhB89ynwC4/x2iBIEB4NO4BKEFIIAP0P4AABaii3DPcYAA7Fu6
-DS/9xNrPcKAAFAQB2SSgz3GAAER1E4HivQHgE6HTuAUggA+w/gAAz3GfALj/FqEb8hvIz3GgAGQu
-8CEQABDgSiEAIA8hESAB3ynwrP/PdoAA4I8Id8lw+g0v/otx0g4v/slwG/Cm/wh3ANgacDpwFfCO
-2FEmAJGQuKAcADAG8obYkLigHAAwgOfMJSGQ4PUD2c9woAAUBCOggOepdq/yANjPcYAAMAUAoQDZ
-z3CgAMgfkbkTGFiAz3CAANACEHjPcaAAtEdJGRiAi3DPcoAANAUAom8gQwBUGRiAz3CgAMgfExAA
-hvG4yiAhAJgLIfjPIOEDJMHhvlMhwACGIf4DRLnAHEIwZMBEJo0Ws/WA5wbyjNiQuKAcADC48QS4
-x3CAAChtQIBIdIQkDJAN8lEiQIKL2M8gIgTKIIEPAACIAM8gIQRX8EyIUHHKIIIPAACRAM8gIgRP
-9AHB+rkH8gHdkNiQuKAcADCQ8SKQMxSAMBEhAIAu8gvIBCCBDwDAAADXcQDAAAAm9CLBgOFEAAwA
-jdmQuQQggA8BAADwLLiU4KAcQDDKIgUAhPcIcoAiwgTPcaAAaCzwIYEAlODAIIYPAACHAM9xoAAY
-LPAhAAAV8ArBjCH/j1rzz3CgAMgfpBAAACJ413AAgAAAoAbG/4fYkLigHAAwAd1I8UQm/pII8s9w
-oAAUBAmAgOBM9eG+EfLPcKAAxCwQgAsgAIRC9c9wAACwHtoOD/gLIECEOvO5Bu/3gCQDMeB44cXh
-xqHBSiQAcgDZqCAADwAhgg+AAACzhCgLDATiMiJCDs9zgAAckM91gAAcD0DCIMLDulx69COCAEwV
-AxF6YnqVYrpbYwPiz3WAAABb8CVNECK6BS2+EFMhDnAAJkIeXXrVaDV+x3aAANSIQLYD4yK7BS3+
-EFMhA3AAI0IOXXpBtgHhocDBxuB/wcXxwOHFqcGLdalwz3GAALBc5gov/STaqXB2Cy/+AxIBNkoM
-L/6pcB0G7/epwPHAmg3P96HBz3GAAECOJIHPdYAAHA80FRARz3OAACyQBCGBDwAAABBFIUEDQMEg
-ws92oADIH8O6XHr0I4MAoBYCEAIjAwRQcwDfDvd+FgKWo7p+HpiQEHhwe3IOL/4U2vi4BPIA2CLw
-A9jPcaAA9AcFoeTaDXBAsA1w4LBChQ1wQKBGlQ1wQLBAhQ1wQKBClQ1wQLDkoeYJj/1AFgEWMHny
-CS/9CnAB2FUF7/ehwOB48cDPcIAAHA8YiIXgDvTPcAEAoIb+D0AAIgsAAQhxz3CAAMgspguAANHA
-4H55Bu/2F9jgePHAvgzP9892gADgLAWGA4DPdYAAlIZAgIQVABDPcS0AwMY4YAJ6gOLM9gCFgrhe
-Ca/6AKVqCa/6AdgAhaK4AKWEFQEQx3EtAMDGTgugAMlw2QTP989wgADgLAWAA4AggM9wgAAQhyKg
-iQUv+hHY4HjPcIAA4CwFgAOAIIDPcIAAEIfgfyKg4HjPcYAAlIYAgYC44H8AoeB4WQUv+hHY4Hjx
-wOHF9g9gADLYtGjuD2AANdgFfRi9kL3PcIAA1FwKCKAAk70ouKV4z3GAAIAFZQTv9wCh8cDPcYAA
-+CwAEQUATCVAgor3CiHAD+tyBdhI2+0A7/aKJIMPBaHPcIAAIC3wIEABQHjRwOB+4HjxwLILz/fP
-doAA+CwFhorgCfSKIJcJDgrv91zZCNgApkLwheDMIOKBPvTPcKAArC8agFIgAABRIACANvSKIBcM
-4gnv92fZEBYFEEwlAISL9wohwA/rcgXYadt5AO/2iiSDD89wgABMgRUgQAEgiM9wgAAABc9ygABk
-KAHdIagsiqOowLkiqFYPr/oEGkABAoYSD6/6AaYHpoog1weGCe/3c9mgpnkDz/fxwAYLz/fPdYAA
-+CwlhYLhAN4M9AohwA/rcgXY+NuYcwkA7/ZKJQAAg+EF9AHYBqVn8IThA/TGpWPwiuEc9M9wgABM
-gSCIz3CAAAAFz3KAAGQow6ghqCyKwLkiqMYOr/rBoooglwkWCe/3iiGEBAjYAKVH8M9woAAsIBCA
-R4UA31BwEgAvAMonbxCB4cwhIoA39Ioglw3mCO/36XEB2YDnz3CAAGQowHksqAGFAKWAIJcHygjv
-94ohRAsmhYHhz3CAAHQoAIAQ9IDgyiHBD8oiwQfKI4EPAAA1AQXYofPGpQPYDvCA4MogIQEK8oHn
-BfIFhYHgA/QB2ALwANiJ/3ECz/fgePHABgrP9891gAD4LCWFguHKIcEPyiLBB8ogYQHKI4EPAAB+
-AMokwQD8BqH2yiUhAIrhdgENADImQXCAAOBcQCeAcjR4AHgCha4Nr/oBpc9xgABkKAQRBQBMJQCE
-B6WL9wohwA/rcgXYktu9Bq/2iiSDD89wgABMgRUgQAFAiCyJz3CAAAAFAd5BqMC5IqiSDa/6w6iK
-INcH3g+v95bZwKWD8AOFgCCXB84Pr/ef2QOFBg4v+ACl2g3v+QHYz3CAAGQoIYDPcIAATIE1eCGI
-z3CAAAAFIagA2SKoAdlCDa/6I6hj8ADeqg3v+QDYJIXPcIAATIE1eCGIz3CAAAAFIagA2SKoGg2v
-+sOoT/CKIJcJZg+v97vZCNgApQDezg0v+MlwEBUFEEwlAISL9wohwA/rcgXYyNvxBa/2iiSDD89w
-gABMgRUgQAEgiM9wgAAABc9ygABkKMOoIagsisC5Iqi+DK/6BBpAAR/wlgrP9obgG/ReCu/2BtiG
-Cs/2mOA0C0EBOgrv9gbYD/CKIFcM6g6v9+LZjgyP+ooglwfaDq/36NkA2AClzQDP9+B48cBaCO/3
-iiDXDc92gAD4LLoOr/clhiWGAN2C4cohwQ/KIsEHyiBhAcojgQ8AAGEByiTBAEQFofbKJUEDiuFw
-AQ0AMiZBcIAA7FxAJ4ByNHgAeAjwjgzv+alwngxP+Ah1iiCXDmYOr/epcYHlIvTPcYAA2JYAgYq4
-AKHGDC/4AtiKIBcJRg6v94ohBgEG2ACmz3CAALgEz3EAAKQ6IKDPcKAALCAQgMdwAgAgvwimDvCO
-DC/4ANgChoAglwcODq/3iiHGBAKGAKYQFgUQTCUAhIv3CiHAD+tyBdiKI0YGnQSv9ookgw/PcIAA
-TIEVIEABIIjPcIAAAAXPcoAAZCijqCGoLIrAuSKoaguv+gQaQAFO8M9wgABMgSCIz3CAAAAFz3KA
-AGQoo6ghqCyKwLkiqEILr/qhoooglwmSDa/3iiEGCQjYAKY08AHdmgvv+alwz3GAAGQoQYHPcIAA
-TIEsiVV4QYjPcIAAAAXAuSKoQagCC6/6o6gc8IogVwxODa/3iiEGDfIKj/oS8M9wgAAABfIKj/rq
-Co/6geAK9IogVw0qDa/3iiGHAalwsv4ZB4/38cCqDo/3z3aAAPgsBYaE4Dr0AN16Cy/4qXDPcYAA
-2JYAgaq4AKGKIFcJ8gyv94ohBwgQFgUQB9hMJQCEAKaM9wohwA/rcgXYiiPHCH0Dr/aKJIMPz3CA
-AEyBFSBAASCIz3CAAAAFz3KAAGQoo6ghqCyKwLkiqE4Kr/oEGkABHgqP+gemkQaP9/HAIg6P989w
-oAAsIDCAz3WAAPgsCIUA3hBxBYXKJm8QgODMJmKQG/QChYAglwdmDK/3iiEHDwKFgOYB2cB5AKXP
-cIAAZCgsqM9xAABsOc9wgAC4BFYJb/ggoDUGj/fgeOB+4HjxwLoNr/dA2rDBz3GAAPhc1grv/Itw
-z3CAAPgsIICB4c9zgAAABQT0QYsR8M9wgABkKEGAz3CAAEyBVXhBiAOLQiAAgMogYgAaYs92gAAI
-BQGOAd8QcsInzhOA4cwhooAK9M9xgAB0KCCBCiVAkMolYhAH8IHhAd3CJUETAuUYuhC4RXhALwES
-BXmKINcKoguv96V5A44FvwS4+GC1eDAkADCBBa/3sMDPcYAAHA8pgVEhQIDhIMIHyiCiAES4z3GA
-AEQtw7gJYeC5BfJRJYDRHPRRIUCAHPLPcIAAHA84iIHhEfLPcIAAsK8AgFEgQIAH8s9wgABMtRSI
-h+AD8oLhBvRRJYDRBPIB2OB+4H8A2OHFRCIBU01yhiL8A01wTXAEJYBfAAAAIEEofoMI8s9wgACw
-rwCAUSBAgAT0ANgD8AHYiOES9M9wgAAcDxiIgeAF8lElQNEI8gTwhiX21wTyAdid8ADYm/CA4f71
-z3GAABSJVBGDAIDj9vXPc4AAsK9gg1EjQIAb8s9zgABMtXSLh+MV9GGBjCP/jxH0pJHPcwAA//9w
-dQv0ZYGMI/+PB/RskddzAAD//9TzhCgLDAAhgH+AAFiyaYDPdYAAOF1RI0CBBfJAJQMXA/BAJQMU
-GIgLY0EqAAEIZRZ7z3CAAFRdfLh4YCgQgwDguwbyHoGGIPaPGPLhuwbyHoFRIICCEvLiuwXyUSUA
-0gPyAdgL8OO7CPLPcKAADCQRgIwg/4/38wDYUSOAgcogIgDPcYAAsK8ggVEhQIAI8gQlvt8AAAAi
-yiBiAIDgFvLPc4AAFIk+g+i5HfKMIgKAzCKCjwAAUADMIoKPAADQABH0k7k+ow/wz3GAABwPKYHh
-uQj0jCICgAX0USGAgQPyAtjgf8HF4HjxwBoLj/fPcKAADCQYgEEohAdBLQBUwbiD4Ar3MyYAcIAA
-0F1AJwFyFHkAeQDYGPDPdYAAFImUFYAQQCgBBoYg/Q9SIMABRbgleM9xoACIJBChPoWzuT6lU/AB
-2EQoPg0AIYB/gADIbiGIz3WAABSJlBWCEM92oACIJFMhRQA+hUAqDwaGIv0PDCRAgVIiwgFFugXy
-5XpQpt7xz3OAALhdYoOaueV7ZXpQpj6lz3GgAMgcENpJoSSAz3KgAPAXJqIjgCaiIoAmoiGAJqKG
-FQERaLkweYYdRBBTIcGAwCAhCMAgIgwggDOiLGgggTOi+BABgjOi/BAAgBOiANgKooUCj/fgePHA
-Fgqv9wDbz3CgAAwkWIDPdYAAFImtcEEqhgeGIPcPlBWBECm4NnvAc8dzgACUgxV7AIvPc4AA5ARg
-g9No1X7XY9tjRCeFkFMnjhAEIo8PACAAAMwnIpAH9EwlAIDMJyGQAN8C9AHfkODAAAoAgObMJyKQ
-WvJMJUCBy/cKIcAP63IF2JDbtQZv9ookgw/Pd4AAuF3wJ4QTQCkFBoYh/Q9ALoYDUiHBAQUkhAEF
-JQ8BRbklf89xoADEJ0EZ2IOC5h30HoUQ2Zq4HqXPcKAAyBwpoAeDz3GgAPAXBqEGgwahBYMGoQSD
-BqEA2AqhhhUAEWi4EHiGHQQQJ/BKFYMQgOMj9EylhhUCEWS6g+ZQeoYdhBAJ9CsRAYZkulB6hh2E
-EC2lwguP+RHwQCkABoYh/Q9SIcEBRbkleM9xoACIJBChHoWzuB6lOQGP9+B4z3CgAMgcENkpoAHY
-z3GgAPAXCqEDEgM2HJOGIP+MKPQPg1EgAIAk8s9ygADIbgSCBqEDggahAoIGoQGCBqFwEwABHuBT
-IMCABPRAIgAIBPBAIgAMQIBToUxoQIJTofgQAoJTofwQAIAToQrwCIMGoQeDBqEGgwahBYMGoeB+
-4HjhxQMSDTbPc6AA8BcPhc9yoAD8FwijQBUAEQqyEYUIo0gVABEKshOFCKNQFQARCrIclYYg8w+M
-IAyAB/QWhQijXBUAEQqycBUBERyVCOEIsh2VCLJUFQARCLJgFQARCLIZhQejGoUHoxuFB6NyFQAR
-OGAQeAiyz3CgAPQHJ6AC2c9woADIHCeg4H/BxfHAiiBXBy4Ob/c+2QHYANk2C+AFiiIEANHA4H7x
-wJ4PT/fPd4AALCkBh0ogACAQ3gp1AqcA2QGHDyFBAwsgQIAN8keHz3CAAFQtRHnwIEADBSBQIIDg
-4iACAGG+gOYB5a99KvdCIACgtQdv98ogYgDxwFIPb/cIcQDeDyYOEM9wgABkKKCArg1v94ogFw/P
-c4AALCkBgwQggQMwdsohwg/KIsIHyiBiAcojgg8AAIYAyiTCACwEYvbKJSIA0nnDg0KDBCBAgCR+
-w6MBoyR6xYNCo8R5JaPMJaKQD/JKCw/4D3rPcIAAuARggM9xAQDUN2B7A9gN8IDgBfKA4swloZAH
-9M9wgAC8BCCAYHkD2CEHT/fgePHA4cUIdQDbDyMDAM9ygAAsKQOCIYJleAOiBYJleSGiZXgFovoM
-b/eKIFcPz3CAALgEYIDPcQEA1DcD2GB7qXJRIMCAB/TPcIAAZCjqCq/5AIDRBk/34HgKIkCAANnu
-AAEALyYA8EomQABOAAYATwAgAIol/w/geAoiQIAA2c4AAQBsACQALyYA8FwABQArCDUISiZAAAhx
-ANgCIb6A4CDFB0J5AeACIb6A4CDFB0J56wfv/wHgLy0BAEAlRQACJnzxAAAgAAAoQAHoIGIDLyAA
-gC8hSwACIb6AwCCGAcIhhgDgfhEAIABKIAAQSiBAEA4iQgAvIAsSziBFgIol/w8IAAUALy0BAEAl
-RQACJnzxAAAgAAAoQAFKJkAA6CAiAy8gAIAvIUsAAiG+gMAghgHCIYYASiYAAEIg/pDOIIIBRCB+
-kM4hggHgfq0BAADgeEaBgOII8iOBYIEigmJ5MHAA2AP2AdjgfvHAz3GAAJQtmHD4/4DgCfLPcYAA
-tC2IcPT/gOAD9ADYCfDPcYAA1C2IcPD/gOD58wHY0cDgfuB4CHM4YNW71bkwcza4xPcCI0IACvDP
-coAAqJZFggHgybgienpiFrjgf0V44HjxwOIMT/cIddd1JQAAgADYSvfPcYAAqJYlgTB10PcifQHg
-+fHPcIAAqJbFgKlwYg7v/8lxBS4+EAIlTR6MIBCAyiHGD8oixgfKIGYByiNmCcokJgCsAWb2yiUG
-ARa48QRv96V4AdrPc6AAsB9Zo36DgOAF8iJ7cHCD9wDYAvBIcOB+4HjPcqAALCBwgoDgCvICI0IA
-13IAgAAABvdQcIb3ANgF8HBwfvcB2OB+CHID8AHgIIiA4f714H9CePHAsODhxQh1g/a55cr2CiHA
-D+tyBdgS25h1LQFv9rhzQiUAHHUEb/cPeOB48cD2C2/32HAA3e//yWiA5pT2+HCpdzImgAOw4Ij2
-ueAG9u3/Mm84eAV9AedCJ0cATCcAgGG+MfclBG/3qXDgeAomAPCKIL8PyiBkAOB/LyADAOB/iiD/
-D/HAogtP95IKIAAIdYDgz3GgAMgfRYUN8vQRDgACgGSFxHpFe/QZwAAihQChCvD0EQAARHj0GQAA
-HNgYuBUZGIDNA0/3D9mauc9woACwHzWg4H7gePHATgtP9wh1z3agAMgfpBYAELhgpB4AEAHYE6ZY
-hjmGANgAIkKDASEBAFimOaYC2TOmOoZbhgAhQYMBIIAAOqYbphWGbg2gAKlxFaYXhmYNoACpcRem
-D9iauA6mz3CAANQt0//PcIAAlC3R/89wgAC0Lc//RQNP989xoADIH/QRAAAA2kYgwA/0GQAAD8ia
-uJu4nLgPGhgwHNgYuBUZGIBYoVmhWqFboc9wAAwPAKQZgAAOoQ/YDLgQoeB+8cCSCk/3z3WgANAb
-04X6vgbyz3CAAJQtegkAAPu+B/LPcIAAtC1uCQAA/L4G8s9wgADULV4JAAAc2Bi4E6XBAk/34Hjx
-wOHFJYBAgEIiAoDKImIAgOLKIcIPyiLCB8ogYgHKI4IPAABfAMokIgBEByL2yiUCAWCBMHMK8kKA
-ooNCfYDlBPZggzBz+vVBgwGjYKBBoACiRIClgFEiQIBAJQMWC/JGhYDiBvKigkKAQn2A5cP2AKNE
-gKWAUSLAgEAlAxcL8keFgOIG8qKCQoBCfYDlw/YAo0GAUHEF9BYO7/8FgCUCT/fgeECAEHII8mSC
-CyNAgAX0QIIQcvv1ANrgf0hw4HjxwIoJT/cIdgCAQiABgMohYgCA4QDYJvIlhkGGAd8wciCGQYZB
-oSCiAKbPcK3eAgABpqWGwH8GhRB2BvSpcALZ6f8GpaWGB4UQdgb0qXAI2eX/B6WA5wXylg3v/wWG
-AdiRAU/38cAmCU/3CHUoduX/CHfCpalws/95AW/36XDgeCCAEHHKISEA4H8ocPHA/ghP9wh3HvAA
-hiGGIaAAoQDYAKbPcK3eAgABpqWGBoUQdgX0qXAC2cz/BqWlhgeFEHYF9KlwCNnI/welI4Zgeclw
-6XDs/womAJAI8gOHIIAChiJ4gOCyB8z/Bg3v/+lwBQFP9+B48cDhxQh1A/DB/6lw4P+A4Pz1/QBP
-9+B44H7geIDhyiRNcOB46CAtAs9xoABQDCWBARhSAOB+4HjxwF4Ib/e4cJhxz3OAAIQFAYMig892
-gAAUic91gADUXQJ5HoY5uMG4FH0BFYcQz3CgANQLPBAGALBxz3WgANAPANpE9wDYRvCoFgAQz3Gg
-AMgfZOAeoRDYDqEB2BUZGIAZcwbwz3WgANAPCXMXFQCWIoMCIMABAnlIIQEAAYMCeUghAQBMJECA
-E/RQcdH3z3OAAAAuAoslFQ+WwbjTaAHgAqsDg9h/53gDowHi7/FRIwDAEvSwcc9zoADUC6gHxf8E
-EAEQAdigcQQYQBA8G4AB9QcP94oMD/u28eB48cCCDw/3z3CAAKCJCIiMIAKAKvI0aMdxgAAobcCB
-z3KAAEhuz3eAAHiW9pcWemGCUCaNFYYnux+goYwnRJCGIwEOYaIE9JG9oKEM8LG+gee2vsChBvSW
-vsChhSMBDmGi7gwP+ADZz3CAAHiWfQcv9y8YQgDhxeHGz3CAAKCJCIiMIAKAz3KAAJSWF/LSis9x
-gABIbrRox3WAAChtFnmA5gCFYYEF8pW4AKWruwTwtbgApYu7YaEA2BOqwcbgf8HF8cDCDg/3z3WA
-AHiWCoXPcoAASG5EIASDz3CAAKCJCIjUaMd2gAAobWCGFnrhghTyUCOBBSCmTCQAgYYnAR7hogT0
-kbkgpgXwsbu2u2CmQgwP+AfwlrtgpoUnAR7hoi8VgBCiuMUGL/cvHQIQ8cDhxc9wgABYskiAz3WA
-AHiWKYW3uri6BCGBDwMAAAAHuUV5KKACCK/4ANgJhc9xgABIblEggILPcIAAoIlIiBRqx3CAACht
-YIBWeUGBBvKVu2Cgq7oF8LW7YKCLui8VgBBBoaO4aQYv9y8dAhDgePHAyg0P96HBCHVAwc92gAAU
-iQCWSiZAIIYg/ACMIAKAwiaCJQLYynFY/4DgDvQehrO4HqYA2M9xgACUlhOpz3GAAFyWDLFp8EIl
-khBMdIQkA5D+8+B4z3WgANAPJRUOliUVD5ZKJEAgEBUVlgJvDCIAoMIkDiUvIwAlggigAMlwTCYA
-oBpwFCcRFRHyheYH8ovmANjKIGEAAvAC2M9xgAAALiSBCyEAgAPyANkC8AHZKnA2/4DgFPJMIICh
-I/LPcIAALC4WIAAEQIAGiBB2D/SA4g3y6XBgegDBFvDPcYAAFIkegbO4HqGm8QohwA/rcgXYiiPX
-BkokAAARAi/2CiUAAQHYoncQHdiTAiJSJIDgzCMioJz1AQUv96HA4cXPcIAAAC4giAHbgOFhqCDy
-z3KgALAfeaJ+gkKAo4BQdQDZGPTPcoAAhAVYioDiA/QB2grwQYACI40A13VMAEBLefchqChygeID
-9GGgIqjgf8HFoqDv8fHAagwP9xpwOnGKIEcN2gov94ohlgHPdoAAFIlMIACkz3WAAHiWAN+G9wzY
-6XH6/oDgDPQehi8dwhOzuB6mz3CAAFyW7LAg8KlwDNnr/s9ygAAALgCKgOD82QvyAJYkeIwgAoAF
-9CWVBJUneAOiQiAAIypxhv8AloYg/ACMIAKAKA/B/0UED/fxwO4LD/cIdoogRA9SCi/3yXGC5gDZ
-EffPcoAAFIkegrO4HqLPcIAAlJYzqM9wgABcliywevAC2NX+gOB28s9xoABQDAWBz3WAAHiWEq0F
-gROtCZWMIIiAYr448hf2h+Aj8owgxIHMJqGQW/TJcADZx/6A4FXyQCUAG8lxvf4vFYAQgLgvHQIQ
-S/CMIMiAOPKMIBCARfQFgQluheBoDeH/yiEhAD3wgeY79MlwANm4/oDgN/JAJYAbyXGu/i8VgBCB
-uC8dAhAt8I7mK/TPcIAAHA8YiIHgJfLJcADZrP6A4B/yz3KAAFyWSHAG2aH+QCIAAgbZn/4MkoG4
-EvCE5hH0yXAA2aL+gOAL8s9ygABclkAiAAUE2Zf+DJKAuAyyiiBEDz4JL/cplTEDD/fxwLoKD/cI
-dRpxz3CAAHiW9gsv9yTZz3CAABSJHoDPcoAATI85uFMgQQDPcIAA1F00eEGKIIgA21V5z3KgANQL
-L6LPcoAAhAUhiGGiAiVAEIDgyiDMAAKiTXGGIfwD0OHMIYKPAACAAA/yjCEDhBDyCiHAD+tyBdiK
-IxkPSiQAAGEH7/W4cwpxcf8D8JL/kQIP9+B48cAeCg/3z3KAABSJPoIacO65qsEA2BDyz3GAABwP
-YhGBAEQSgwDA3WR5hiH/DiK5On0I8M9wgAAcD0wQDQEC2IYSAQECeRGCBOECCe/8ANpaCGAAAiBP
-AwPYz3agAMgfE6YYhgDZQsAZhkPAGoZEwBuGRcC1hlwWERBAFgAWH2f8FgAQz3CAAHiWQIABgAAi
-woMBIEAAQMJMIECgQcCLcAv0hMFaC2AAhsIId89wgADcsCqQCvCCwUYLYACGwgh3z3CAAKiWJJDP
-coAAqJZlggbCBLtQc0ApgAKI91BwS/cCelBwvvcG8AoMYACGwAhyRsKC5xX0qXCaC2AASHEIdSpw
-kgtgAAbBBsM6cATCB8EFwAAiwoABIEAARMIW8IDnFfSpcJoLYABIcQh1KnCSC2AABsEEwTpwBsMF
-wAfCAiHBgETBAyCAAEXAgecK8s9wgAAcDxiIhODMJyGQANgD9AHYLyIHoDv0qXAqC2AAA9kIdSpw
-HgtgAAPZAMEIdwHAQCHBgEEgAABBwATAQMEFwUAgwIBBIQEARMASDyAARcFMIACgBvS1pgDAGKYB
-wBmmTCCAoAv0taYAwBimAcAZpvemBMAapgXAG6ZMIECgB/T3pgDAGqYBwBumiiAHDsIO7/ZKcUwi
-AKAB2cB5z3CAAARJNKiFAC/3qsDgeM9xgAD0LSCBANiD4cwhIoAC9AHY4H8PeAoiAIDxwBTy+P+A
-4MohwQ/KIsEHyiBhAcojgQ8AAKIGyiQhABQF4fXKJQEBz3CAAPQtQKDRwOB+8cDPcoAA9C0ggoDh
-yiHBD8oiwQfKIGEByiOBDwAAqwbKJCEA3ATh9colAQEBogHaz3GgAMgfUKFKGZgASBkYAN7x4Hjx
-wJoPz/bPcaQAtEUpEQCGz3aAAMh0EaYrEQCGAN0Sps9wpQAIDAOAGKYOEQCGEHowuFOmFKYPEQCG
-FabPcIAAUIlQiHKIWaY0iHqmC5A7pizgAiCPAAIgwgAieM9zgAD0LSCDXaaD4fymOAAtAB6mMyZB
-cIAA3F1AJwByNHgAeAPYwf9A2M7/t6YM8M9yoACoIDGCAoOiozhgF6YB2BKiAdhhB+/2FqbPcIAA
-hAUYiIDgB/LPcIAAAC4BiALwAdjgfuB48cDaDs/2z3WAAFiyxRUAFlEgQIEH8s9wgABMtRSIiOAF
-8gmFUSBAgYvyz3GAABSJA4HqDi/8JIGB4BH0z3GAALCvIIFRIUCACfLPcYAATLU0iYjhyiBhABLy
-gOAR9M9wgACwrwCAUSBAgAnyz3CAAEy1FIiH4ALYAvIA2Az/Xg6AAs9xgAColgaBRSBAAQahz3CA
-ABwPGIiE4M92gAB4liPyz3CAALR/Voh3jlBzz3GAAMh0BfIAgFEgAIAN9M9ygACEBQWCAeAFogDY
-BKIPgQHgD6EE8A6BAeAOoQmFUSBAgRAMwgDPcYAAhAUDgYDgC/IA2AOhz3GAAMQGAIGiuK4PoAIA
-oS8WgBBRIMCAdA+C/y8WgBBRIICA/A6C/4j/sf+A4GgP4vXKIOIFz3CAACA2EYiA4FgP4vXKICIF
-CQbP9uB48cDPcIAAXJYMkOC4BPLODg/8BvBRIECAXA4C/M9wgACUlhOIgeAH8oLgCPSW/YUFz/94
-/X0Fz/95Bc//8cBaDc/2z3CgAMQnUhABhkEQAIaGIOOPAN0G8uu50SGigUzyz3CAABwPCYDPdoAA
-eJZRIECBGPJKCEAHgOAK9BSOgeDKICEBNA6hAsohYQDPcIAAxJEAgFEggIAE8vIIr/wQlrSuz3CA
-AMSRoKBNcIYg/AOMIAKAHPTPcYAAhAUHgQHgB6HPcIAAHA8YiITggAnBBYogRw0yC+/2iiHKDnIP
-AAd3/74PoAUvIIgKBvCMIAOEEA/B/w0Fz/bPcYAAhAUJgYHgB/TPcKAAsB8bgAuh4H42uDa5MHDW
-IIUPAACAAOB/InjgePHAz3KAAIQFCYKB4A70z3CgALAfG4AMoiuC9f9GEgEBOGAQeEYaBABlBM//
-8cDhxc91gACEBQ+FgOAQ9AmFgeAM9CoOz/WY4Ajyz3CgALAfG4ANpQHYD6WNBM/28cDhxc91gACE
-BQ+FgOAY8gmFgeAU9PoNz/WY4BDyz3CgALAfG4AA2g6lLYXZ/0QVARFPpThgEHhEHQQQTQTP9gDZ
-z3CAAIQFK6AsoC2gLqAvoCWgMKAkoEYYRABEGEQA4H8qoPHAANnPcIAAhAUpoPT/z3CAABQuEgqP
-/7UDz/8Icc9wgAAULkWAQ4JhuWCCz3KAAIQFSILVunpiz3OAAKiWZYMFK34AACGBcMdxAAAAED0C
-j//gePHAz3GAAIQFCYGA4BX0AdgJoQDYCKHd/4oghw6yCe/2iiHPBc9wgAAcDxiIg+CcD+H/yiBh
-AUUDz//gePHAIgvv9oogxw+kwYYJ7/aKIdEPdg4ABYDg9A7C/891gACEBQiFKoWd/0QVARFGFQIR
-WWEwcADew/cCIE4AJYWA4RT0gOYS8gCFgOAO9ASFz3GAAMh02GAEpRCF2GAQpRCB2GAQoQnwMHbH
-9wImQBAwhThgEKWKIAgAGgnv9iSFBIVCxkDAEIUQ2UHABYWi2h7bQ8CLcKIM7/YYuwiFCqUA2AWl
-Rh0EEEQdBBAApT4M7/US2ASFheCM9wHYtP+SDI/5z3GAAMB1GIEB4BihBPAF2K//uQLv9qTA4HiA
-4AHYwiAMAM9ygAAALgCqAdgBqgDYAqoBogKiA6LgfySi4HgAFgBAaQbP9s9wgAD0LeB/AIDgePHA
-wgvv9RLYz3CgALAfO4DPcIAAhAUVAu//KKDPcaAAsB87gUEoggXVuEEpgwXVuQJ5z3CAAKiWYnoF
-gMm6BSi+ACdxz3CAAJQtA4AAgOB/OGDgeM9xoACwHzuBQSiDBdW4QSmCBdW5EHFbY0n3z3KAAKiW
-RYJZYQJ5AeMC8AJ5QCuABSV4zPEA2Za5z3CgANAbM6DgeFEjgMX/8+B+4HjxwGYJ7/YIc4ogCADP
-daAAyB8QpQHaQR2YEPT/z3aAAKiWI4YFhlMhTwUQd8ohzQ/KIs0HyiBtAcojjQ8AAI0AyiQtAEgG
-rfXKJQ0BgOPMI2KAQPRAhlilQYbPdoAAsK9ZpRSlNaUAhlEgQIBk8s9wgABMtRSIh+Be9DeFz3CA
-AOSw94UEIZAPwP8AADeIFYXVv24LIAAKudW4BSABBDelAtkzpVqFO4UCIMODyiDDABIAIwBfu6AW
-AxcKu+J7eGAA2wIiAoADIcEAWqU7pTTwguMy9M9zgACwr6ATAAcKuBalz3CAAFiyCYBRIECBHfLP
-cIAATLUUiIfgF/RTpRiFeYXPcYAA5LA3iQq5AiBAgEIpwgcapQMjgwB7pRWF4goAABelCPBOEwAG
-GqVPEwAGG6U3pZUAz/bxwDYIz/YKJgCQz3WAAKiWEfTPcIAA4F2pcaYN7/YU2s9wgACULXoPT//P
-cIAAtC0V8ILmDPTPcIAA6LCpcYIN7/YU2s9wgAC0LQ7wqXB6DO/2BdnPcIAAlC1GD0//z3CAANQt
-Og9P/wSVCrgFpQaFhiDDDwalyXCU/zYLj/UlAM/24HjPcIAAlC0ngIDhB/IDgECAAoFCeATwz3D/
-D///4H7geM9xgACULUaBgOKKIf8PIKAF8iKCIKAB2ALwAtjgfuB48cChwQhzi3D2/4LgANgH8gDA
-EHMB2MIgDgChwNHA4H7g2JC4ANrPcaAAyB8QoQnYsBkAALQZAAAV2G8ZGABq2EIZGAAA2Jq4D6Gk
-GYAAz3AADAAZDqHgfuHFUyBCBQQgjQ/A/wAAz3CAAKiWBYACIIMABCGCD8D/AADVuSJ4pXtFeBBz
-yiCtAAX3EHMA2MogZgDgf8HF4HjxwOHF2HC4cZhy7v8IdchwiHHs/xB1yiCtAAr3EHUA2MogRgGc
-D+b/yiEGASEHj/YIcyhyz3CgALAfG4ACIIAPAAIAAGhx3vGKIf8PIKDPc4AAlC1Gg4DiEvIkglEh
-QIAL8s9xgABkLzByB/LPcYAAfC8wcgb0QIJQc/H1AtgF8CKCIKAB2OB+z3GAANQtRoGA4ooh/w8g
-oAXyIoIgoAHYAvAC2OB+4HjxwC4Or/ZKJEAAwIGggAHf0XXCJAIB0XWhgWGAwifOEwHesXPAfrFz
-AdvCI84ATCQAgMwmIpDKI2IAC/SA4wb0gObMJyKQBPIC2wPwANuA4xTygeMO8oLjGvSggMCBAYAh
-gQIljZOgogMgQAABohDwANgAogGiDPCggcCAIYEBgAIljZOgogMhAQAhogkGr/ZocOB4BfBCecdw
-QAAAAM9ygAColkWCUHE391MgQwVwccAgjQ9AAAAAwCCNAOB/IngG8GJ5AiCAD0AAAADPcoAAqJZl
-gnBxN/dTIEIFOmJQc4P3OGAH8AIggA9AAAAAYng4YOB+8cA+DY/2CHUoduIOL/8BgKCFELlBLQAU
-OGDSDi//yXEQubB4OGDGDi//QC6BEn0Fr/YocNW41bkwcMf3z3KAAKiWRYJZYeB/DiBAAL3gFfKF
-4BHyB/aD4AvyhOAR9OB/BNil4AvyreAL9OB/AtjgfwDY4H8B2OB/A9jgfwXYBtjgfuB48cCB4OHF
-ANgJ9M9wgACPlgHdLgxv/6lxqXAVBY/24HjxwJIMj/YId89wgAAcDxiIhOAacUjyhOcA3Y4AJQDK
-IEUDz3aAAHiWQCYAE/ILb/8E2S6OsK5TIQAAEa5BKMAgoLkwcGAAJQACIEIAY7/xclQABgCA4g/y
-z3GgANAPEBEAhmG6WGAQGRiAJREAhg94AvAPjgDZUyCCIA8hgQAkeC8mB/DPcZ8AuP8QrhiBzyDi
-B9Ag4QcYoRiBnrgYoRiBvrgYoQHYUQSP9uB4g+DxwADYCfTPcIAAjJZmC2//A9kB2NHA4H7geIbg
-8cAA2A/0z3CAAJSWSgtv/wbZz3GAAMSRAIGCuAChAdjt8fHAmuDhxQDYjPfPdYAAnJYEbSILb/8E
-2QuNgrgLrQHYAQSP9vHAluDhxQDYjPfPdYAAnJapcP4Kb/8E2QuNg7gLrQHY3QOP9vHAZguv9gnZ
-z3aAAMQu6g+v9slwAJbPdYAA2JZRIACACPIB2EwdAhDyDK/1GNgJ8EwVgBCB4AX0AthMHQIQAJYi
-hiK4wLhNHQIQz3CAAMQvIKDPcaAALCBQgXKFAiLAAP+4A/RSpRCBA6XPcIAArC4AgEIgAIDKIGIA
-gOAI9M9wgABcLgCAgOAsCAIACIaA4AX0z3CAAKiWCJAVpQCWJbjAuIII7/8D2QoPj/YlA4/24H7g
-eM9xgABcLs9wgAD0XeEHr/YU2uB48cDhxc91gACsLgoJb/+pcM9wgABcLiCA4bke8hQQBAAYEAUA
-USEAgMwkIoDMJSKACPQKIcAP63IF2IUHb/W2234NL/8AJQABngjP/whxKglv/6lwvQKP9vHA4cXP
-dYAAXC6pcMoOr/YH2QgVBBAA2EYk/oPKIcIPyiLCB8ogYgHKI4IPAABpADQHYvXKJSIAQIXhuhPy
-4LoH8iWFgOEF8iaFgOEL9AohwA/rcgXYcdtKJAAACQdv9bhzz3EBALx8MqVRIgCBE6UjhQ7yDqUB
-hY/gL6UL8s9wAgDoDBKlAdgTpQXwLqX/2A+lxv/+DY/2IQKP9s9xgABcLgCBIoF/289ygADYllMg
-AIAmewT0LoKA4RX0gOAG8g6CCyDAgA/0MIKA4QT0BYKC4AfygOEH8hGCguAD9AHYAvAA2OB+4Hjh
-xeHGz3CAAFwuQIACgD/bBnsMcM92gABcLqKGz3GAANiWCyBAgwHYLoHCIAEACyFAg8C6BvIphlEh
-AIHPIGEACyDAwAn0z3GAANiWLoELIcCAANkC8gTZgOIG9IThCPKA4Ab0gOIF8oThA/QE2MHG4H/B
-xfHA5giv9gDZz3KAANiWBIKA4Aj0z3CAAFwuB4CA4APyAdnPdYAAXC7Pd4AAHA8Yj8CFhOBTJgMQ
-BfIJh1EgQIED9ADeOPAHhYDgBPQA2BGlgOPMISKADPIJhVEgAIEI8lEmAJEJ8gGFj+AF9ADYCHYU
-8ADYEfARhQHghOARpQjeRfcBhY/gANgI8s92oAAsINCGAdjDogjesIWA5Qv0gOMD9IDhB/SA4AX0
-TBKAAILgAvQE3pkAr/bJcOB48cAiCI/2pME6cBpxSHee/4DgUPLPdoAA2JYAhoDgSvTPcIAA0AUA
-gILgC/SKIAkIbg5v9oohyAIWDCAACNjPcYAAXC4AgVEgAIFLgQT0AYGP4Aryg+Iu8gDdp6GsoQPY
-C6EJ8IPiJvIA3amhp6ED2AihpKaKIIoIJg5v9iqBz3CgACwg0IBAxwbYQcBCxUPFAdge2SpyCHNK
-JAAACiUAAQAmhx8HACChIyAABAomAAHRB2/2pMDgePHAhODhxQh1DvQeDaAABN2KIIkG0g1v9ooh
-hgl6CyAAANhd8IThOPTPcIAAWLIYEIQATCQAgcohwQ/KIsEHyiBhAcojgQ8AAK4BTARh9colIQAk
-EAQAUSRAgcohwQ/KIsEHyiBhAcojgQ8AALABKARh9colIQCKIEkIbg1v9oohhgwWCyAAB9hqDGAA
-BN2aDIAAJfBTJX6QE/LPcIAA0AUAgILgzCAigRn0iiAJCDoNb/aKIQcB4gogAAjYD/CI4Qz0z3GA
-AFwuz3IBAMRZAd2pcDKBnf8D8ADdEQdv9qlw8cCWDk/2z3WAAFwuCIWD4DPyC4WD4DHyCYXPcaAA
-LCBRIACBC/IMhYHgCfQwgdoMb/aKIEoIAdgg8NCBCoUCJgEQBdgMuBBx1/eKIMoHugxv9slxENgJ
-pQ2FAiYBENdxAAAAUMn3iiDKB54Mb/bJcQHYDKUC8ADYiQZP9vHAFg5P9s9woAAsIPCAz3aAAFwu
-CoalhgInARCxcQb3BoYdZSJ9CfDPcgEAxFkB2DKGb//qpgCGz3aAAKwuUSBAgAzy9ggv/6lwGgyP
-/whxogwv/8lwBfA2DC//yXAhBk/24HjPcYAAXC4AgVEgAIHPcIAAyJJIgFMiAwAE9AGBj+AS8oDj
-DfJRIsCBCfTPcKAALCAQgA2hAdjgfwuhAtjgfwuhgOMM8lEiwIEI9M9woAAsIBCACqEB2APwAtgI
-oeB+4HjxwFYNb/YA2Zu5z3CgANAbMaDPcIAA0AUAgADeieDKIcYPyiLGB8ogZgHKI4YPAADYAMok
-hgNAAmb1yiXGAM91gAAAACCF8bkZ8iGF8blA2s8i4gfKIoEPAADQAM8i4QfPcZ8AuP9doUSFAeLT
-ukSlBSKCD9D+AABWoc9xgADsLvAhAABAeACF8bgG8s9wnwC4/92gLQVP9vHA4cXPcaAArC8cgb2B
-BH3PcIAAlAQAiIHgCfTPcMDfAQAcoSjZGLkb8IogSQYCC2/2iiEOCYogCQb2Cm/2qXH8vQryiiAK
-BeYKb/aKIQ4NngoABfa94ArC9gDZm7nPcKAA0BsxoM0ET/bgePHA4cXPdYAAyJbPcIAARF5AJQEU
-xgmv9kjaz3CAAKRez3GAANQFtgmv9gjaANnPcIAAxC4poM9wgADQBSCgz3CgACwgEICBBG/2FqXx
-wO3/ANjPcaAAwC+AGQAAE4GLuBOhz3DIADwAwBkAANHA4H7xwN4LT/bPdoAAEC/wJgEQz3eAANAF
-g+EAp1nyguDPdYAAyJYL9CqFgeEJ9IogCQgiCm/2ANkI2ACnguAa9ALYCqUA2c9woAD8RJ65IaDP
-cKAAtA8A2lygD8gEIIAP/v//Aw8aGDAPyIe4DxoYMC/w8CYBEIHhDPTPcIAAXC4AgFEgAIAE9ADY
-CqUD8CqlBMhRIICABPIWCg/6DfAA2p66ANnPcKAA/ERBoM9woAC0Dzygz3CAABwPGIiE4AX0xg8A
-BYDgA/TyDAACfQNP9uB48cDhxYogSQx6CW/2iiGKB/oOAALPcYAAWLJIgc91gADIljSRUyIAAIYO
-L/YB2wDYEqUOhYDgCPLPcIAAHA8YiITgBPQE2ATwbgnP/1IL7/8A2YDgFfQLhVEgwIAJ8oogiQYi
-CW/2iiHLAADYCPCKIEkHEglv9oohCwIC2K3/CQNP9uB48cAA2c9woADQG5u5MaAEyITgC/KKIIkG
-5ghv9oohygEA2KP/CvCKIAkJ1ghv9oohigME2J7/0v848eB48cDPcIAA0AUAgIPgBPTGDsAA7f8s
-8eB48cDKDW//4cXPdaAArC8Yhfq4C/IahVIgAABRIACABfIchfy4CfKKIEkGgghv9oohCQSKDsAA
-HIVRIACAGfLPcIAANC8AgEIgAIDKIGIAgOAP9M9ygADELgmChOBJ989xgADIli6BgeED9AHgCaI8
-hToIb/aKIIkNOg0P9T4PwASA4An0z3CAANAFAICD4CAPwf8dAk/24HjxwJIJT/YIdzpxiiDJCQYI
-b/aKIccIz3CAANQFIIABgFYhQQsU4DhgANkycMohxg/KIsYHyiBmAcojhg8AAOQByiQmAHwGJvXK
-JQYBz3CAAMiWDoCA4B3yz3CAABwPGIiE4Bfyz3CAAMiWCYCC4Mohwg/KIsIHyiBiAcojgg8AAOUB
-yiQiADwGIvXKJcIAz3agAMgfdB5YkM9wAAAQHHIJj/ZPIEEDz3AAABAcLgtP9ljYKgtv9gHZINgQ
-pjLYQx4YEADY0gxv9o24INgRps9wgADIlqQWEBAuDG//66A1hjIPL/aKIMkJz3WgAKwvPIUiDy/2
-iiDJCYogyQkWDy/2KnFRJ8CQQ/LPcIAAjAcAgIYgfw+C4AHYwHiB4Df0GBYAlqG4GB4YkIogEAAR
-phmF8LgZhQvyBCCADwgAAADXcAgAAAAB2MB4BvCGIH8PguAB2MB4gODt86DfEvDgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeGG/jCf/n+71GYWIuBml5gzP+M9wgADIlguAwLiB4AHYwHi+
-D6/2WnBaCOAAKnAB2OoPoAAKcRyF+bgb9BiFiLgYpaDfEfDgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeGG/jCf/n+31WgrAAKQWDxDPcAAAEBwWCI/2UCBBA89wAAAQHNYJT/ZuD6/2SnBW
-/1zYxglv9gHZINgQpjLYQx4YEADYcgtv9o24INgRphyF+bgN8s9wgADELgCQUSCAgcogIQKUCWH2
-yiGhAM9wAIIBABylANg+D6AA6XGRBw/24HjxwD4PL/YA2c92nwC4/72GPabPcaAAyDtWgUQiAwdW
-gTaBhiL/CGV6hiH/CAUhvoDx9WINgAC9poDgANgf8rIML/cA2IogiQdmDS/2iiEGDgPYw/4C2M9x
-gADIlgmhz3CAAFiyCYAluMC4Sg6v9g6hCNiKIf8PSv8B2DEHD/bgePHAvg4P9s92gADIllwWgRCA
-4aTBDPYKIcAP63IF2PPbSiQAALkDL/UKJQABBMiB4MohwQ/KIsEHyiOBDwAA9ADKIGEB7vOC4Qj0
-ANhcHgIQNghv9RjYU/DODaAA39iA4E3yDoYA3YDgsqYI8s9wgAAcDxiIhOAT9M9xgABcLrChsaEQ
-2Amhp6GppoogSQeiDC/2iiGEAwLYMPC+DYAAz3KAANQFYIJBgpYjgQEU4npiUHBKACUAAdkpps9w
-oAAsINCAz3ABALRyQMBBwULBQ8UocAbZAdqpc5h1uHUAJocfBwAgoR4L4ADYdYogCQdCDC/2iiGE
-BwHYef4xBi/2pMDxwL4ND/bPcIAAHA8YiITgyiHBD8oiwQfKIGEByiOBDwAALAHKJCEAtAIh9col
-wQAyDI//Ig2gAAh2gOYIdRL05gygAN/YgOAM8s9wgADUBSCAAYCWIYEBFOA4YBB1DfcOC+AAAdiK
-IIkGxgsv9oohRQEA2Fr+tQUP9uB48cA6DS/2iiD/D6HBQMDPdoAAyJYIhoDgANkI8s9woAAsIBCA
-KKYHpr4Lj/8uDK//GnAIcZoNr/8KcIDgd/TPcIAAXC4JgADfUSAAgcohwQ/KIsEHyiBhAcojgQ8A
-AGYByiTBA/wBIfXKJcEAiiDQB0ILL/aKIUUKEg5AAs9xAIIBAM9woACsLzygz3WfALj/dBUQEP2l
-z3KgAMg7FoI2goYg/wiGIf8IJXg2goYh/wgFIT6A8fX2C6AA/9h0HQAUgOA18gaGgODKIcIPyiLC
-B8ogYgHKI4IPAACAAcokIgCAASL1yiUCAa4IoACLcAolAJAd8oogSQa6Ci/2iiEGAoogCQauCi/2
-AMGKIAkGpgov9qlxiiCJB5oKL/aKIQYDA9gQ/qlwAMGe/nUEL/ahwPHAEgwP9rIKj/8iC6//CHUI
-cY4Mr/+pcITgCfSKIAkGYgov9oohSwct8M9woADIH6QQAQAVgM92gADIlkWGQnnXcQAAoA8A3cv3
-z3GAAKiWJYHVuEEpggBCeTBwhPcGhoDgEfSKIAkGGgov9oohCwqmpoogSQcOCi/2iiHLCgLY7P39
-Aw/24HjxwOHFz3CAABwPGBCEAEwkAIHKIcEPyiLBB8ogYQHKI4EPAAD8AoQAIfXKJSEAAgqP/3IK
-r/8IdQhx3guv/6lwvQMP9vHAz3CAABwPGIiE4MohwQ/KIsEHyiBhAcojgQ8AAA4DyiQhAEAAIfXK
-JcEAvgmP/4DgD/LCCOAAAdiKIEkIegkv9oohzAYH2Mf98g1AABUHj//gePHA4cXPcIAAHA8YiITg
-yiHBD8oiwQfKIGEByiOBDwAAUQPKJCEA7Afh9MolwQBqCY//2gmv/wh1CHFGC6//qXCGIL+OEvQa
-DI//geAO9ALdz3CAAMiWqqCKIEkHBgkv9oohjQipcKv9/QIP9vHAggoP9qbBz3CAAEReNoDPdYAA
-yJYXgETBKYVFwIPhzCEigDnyz3CAABwPGIiE4DPygeEB3wDeC/T+D6AA6XDPcIAAiH4diIDgyaUl
-8oogSQamCC/2iiEMDwPYCaURhdKlDNkVJAIwz3CgACwgsIDPcAEAbHJAwEHHQsdDxkSCANgIc5hw
-uHAAJYcfBwAgoToPoADYcFUCL/amwPHA5gkP9s9wgAAcDxiIhODKIcEPyiLBB8ogYQHKI4EPAABD
-AMokIQDgBuH0yiXBAIogBw4mCC/2ANnPdoAAeJYtjoDhBPIMjhBxDPYOCC/2iiCHDYoghw0CCC/2
-LI5c8M9woACwHxuAz3eAADCXAqeKIEkG5g/v9VXZiiAJBt4P7/Uih0yODY7PcYAAqJZokUCncHDP
-dYAA2JYBp4v2CLEA2U0dQhAB2SylNYUwcMP3FaUQjgSlEY6A4ATygOIE8gDYCvDPcIAAHA8JgFEg
-gID48wHYAqWKIEkGgg/v9XXZiiAJBnYP7/UihwKFQIeA4MogYgAYuAV6BIUKIQCAiiAJBsohYgAQ
-uVIP7/VFeZIKL/UC2DkBD/bxwNIIL/aKIEkGOg/v9ffZ2g9P/891gADYlghxhODMISKCEvTPcKAA
-LCAQgADaQqUDpc9wgAAwlwKA1bjHcAAAiBMJpQ2FgODKISIBAN4SCa//yXCE4AT0zaUW8AKFgOAJ
-8oogiQneDu/1iiHEBgXYCPCKIEkHzg7v9YohBAgC2HIMj/+5AA/28cBGCC/2mHEKIwCAyiHBD8oi
-wQfKIGEByiOBDwAASQHKJCEARAXh9MolAQHPcIAAZC8lgCOBz3eAAKiWQIHPcaAAsB/bgVMmTRU2
-vn5mXWUlh2G7BSn+ACd1AiWDEIwjF4dK989ygAAwl0GCBSp+ACd1XmZMJACAB/LPcYAAXC4zgYHh
-EfSeDq/+WCVBFs9wgAB8LwAlgR8AAIgThg6P/oogyQ4Z8M9wgACUL3YOr/5YJUEWz3CAAKwvACWB
-HwAAiBNiDo/+yXHJuc9wgAAwlyOgiiCJD+YN7/XJcQaHgbjNB+/1BqfgePHAz3CAAEwvzg2v/uHF
-z3CAABCXNYjPcIAAZC+A4c91gAAwlwv0IIBCIQGAyiFiAIDhBfIghYDhSfSeDY/+z3CAAHwvkg2P
-/kKFz3CgALAfG4A2uja4EHLF9whxgCEQAALwCHFghXpiYYV5YTByzfcKIcAP63IF2KPbSiQAAAUE
-7/S4c3piMHL+9yJ6T3pwcsohzQ/KIs0HyiONDwAAqgDKIG0BK/fPcYAAlC8ggUIhAYDKIWIAgOEG
-8lhgI4XJuDBwBfJIcADZlP8NB8/14HjxwOHFiiBJBvoM7/XB2c9wgAAcDxiIhODKIcEPyiLBB8og
-YQHKI4EPAADEAMokIQCAA+H0yiXBACIIL/UC2M91gADYlgKFgOAL8s9wgADELgGACaXPcKAALCAQ
-gAGlz3CAAKiWBoBRIACAI/LPcIAA0AUAgIbgzCBigcwgIoIE9FD/FfAEhYDgANkR8s9woAAsIBCA
-IqUDpc9wgAAwlwKA1bjHcAAAiBMJpQDYBKWh/1UGz/XgfuB48cDWDc/1z3GAABwPOImE4cohwQ/K
-IsEHyiBhAcojgQ8AAC4ByiQhANAC4fTKJcEAz3GAANiWKoGA4Ufyz3aAADQvIIZCIQGAyiFiAIDh
-PfSA4MohwQ/KIsEHyiBhAcojgQ8AADQByiQhAJAC4fTKJQEBJYYjgc93oACwH6CBO4fVuT1lz3GA
-AKiWJYFhuAUpPgAndYogCQ6yC+/1qXE7h4ogCQ6mC+/1NrnJcAYMr/5XJcEYz3CAAEwvACWBHwAA
-iBPyC4/+eQXP9eB48cDhxQh1z3CgALAfO4CKIEkObgvv9Ta5iiBJDmIL7/Uihc9wgAAcDxiIhODK
-IcEPyiLBB8ogYQHKI4EPAAB/AcokIQDoAeH0yiXBAM9xgADELgmBhOBE9wHgCaHPcYAAqJYGgUYg
-QAEGoc9wgADQBQCAguAK9IogyQcGC+/1iiGGA64Ir/8G2PkEz/XxwOHFCHXPcKAAsB87gIogiQ7i
-Cu/1NrmKIIkO1grv9SKFz3GAAKiWBoGCuAahCg7v9ALYwQTP9fHA4cUIdc9woACwHzuAiiDJD6oK
-7/U2uYogyQ+eCu/1IoXPcIAAHA8YiITgyiHBD8oiwQfKIGEByiOBDwAA7AHKJCEAJAHh9MolwQCK
-IMkHagrv9Yohxw0SCK//BtgB2c9wgADYli2gz3GAAKiWBoFGIEABSQTv9Qah4HjxwOHFCHXPcKAA
-sB87gIogCQ8uCu/1NrmKIAkPIgrv9SKFz3CAABwPGBCEAEwkAIHKIcEPyiLBB8ogYQHKI4EPAACy
-AagA4fTKJSEAz3GAANiWDIGA4AryBYGA4MwgYoAE8gDYyP8Y8M9xgAColgaBRiBAAQahz3CAANAF
-AICC4Ar0iiDJB7oJ7/WKIYcAYg9v/wbYrQPP9fHANgvP9Qh2z3CgALAfO4CKIAoAkgnv9Ta5iiAK
-AIoJ7/Uihs9wgAAcDxiIAN2E4MohwQ/KIsEHyiBhAcojgQ8AAA4CyiRBAwwA4fTKJcEAz3aAAKiW
-pqaKIEkISgnv9YohCAXyDm//B9gGhoK4Rgjv/wamz3CAANiWraBuDO/0AtghA8/14HjxwOHFCHXP
-cKAAsB87gIogSQ8OCe/1NrmKIEkPAgnv9SKFz3GAAKiWBoGCuAahNgzv9ALYz3GAANiWDIGA4A3y
-DYGA4AnyBYGA4MwgYoAsD+L/yiAiAM0Cz/XgePHAUgrP9c9wgABYsgmAz3GAANiWJbhTIACACqEA
-2AWhDaFZ8s9wgAAcDxiIhOBT8oogSQaOCO/1iiHIDM9woACwHzuAiiAJBnoI7/U2uc91gACULwCF
-QiAAgMogYgCB4Bj0Zgiv/qlwz3aAAGQvAIZCIACAyiBiAIDgDPSKIEoAQgjv9YohiA/JcKIIr/4i
-hc91gACsLwCFQiAAgMogYgCB4Bn0Igiv/qlwz3aAAHwvAIZCIACAyiBiAIDgC/SKIEoAAgjv9Yoh
-yQLJcF4Ir/4ihe0Bz/XgePHA4cXPcAAA///PdYAAMJcDpc9wgAA0L9YPT/7PcIAATC/OD0/+ANkg
-pQXYAaUipRIL7/QC2LkBz/XgePHAPgnP9Sh1z3GgACwgMIHPc4AAMHRGi4DiAN4E8keLgOID9AbY
-h+DKIcoPyiLKB8ogagHKI4oPAACNAsokKgAcBqr0yiXKAIblz3OAANiWAvI0o06DDyJCA06jz3KA
-AMQv8CIAAFKDOGACII0A/70C9BKjz3WAAFwuAoVBhQR6G8gRIgCADPIqpSYPr/WKIMoIAYWP4Mml
-AvTHpQ0Bz/XxwJoIz/UIdc92gADELgGGz3KAANiWCaLPcIAAFIkegAQlhB8AAAAg5rgmuFMgAwBB
-LUATwLgWIs8AAqck8s9zgABcLgmDAN8leMO5DydPEC+DCaMLIcCDAdgF8gyjHBsAAea9FfQOgzCD
-5HgFIECAEKMP8gDYCabPcKAALCAQgAOiB/DPcKAALCAQgAGiz3aAABwPGI6E4AwLoQTKIEEDGI6B
-4Bryz3CAALCvAIBRIECAJvLPcIAATLUUiIfgIPTPcIAAFImUEIAAz3GAAChtBLgAYe24FPLsvRLy
-z3CAABSJlBCAAAS4x3CAAChtIICIuSCgGg6v9YogCQYFAM/18cCeD4/1z3WAANiWIIUleAClEIWA
-4KHBBfQB2BClBYURpfIMb/mLcADBz3ABALRyMHAM8s9wAQBschBxBvLPcAEAxFkQcQX0Bg1gAAHY
-AN7+DO//wqXPcIAANC+2DU/+z3CAAEwvrg1P/s9wgACsLqINT/6KIIkGlg2v9XfZQgtv/8lwhQev
-9aHA4HjxwOHFCHWKIAkGeg2v9alxz3GAANiWAIGmeAChANgQoQWBVgwv/xGhXQeP9eHF4cYIdf/Z
-z3CrAKD/OaAE2c9woADIHCigFt4R8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Yb6M
-Jv+f7fXPcaAAwC8TgYDlzyDiAtAg4QIToYDlPNjKIIEPAACyDJO4lriXuMAZAADBxuB/wcXgePHA
-dgqgAUfYANrPcasAoP9ZoQfYGqFYodHA4H7xwFIOj/XPcQMAQA3PcKAAqCAtoM9xoADALxSBz3Wg
-AKwv8LgUgQzyBCCADwgAAADXcAgAAAAB2MB4B/CGIH8PguAB2MB4gOBs9BURAIaguBUZGIAE8M91
-oACsL89woADUCxuAgOBS8s9woACoIA2A5OCS9xyFz3GgAMAv+bgG9Ax0hCTCn+nzFREAhoC4FRkY
-gEjwiiAJBioMr/UnaM9xoADUCzuBHgyv9YogCQYscRIMr/WKIAkGOYUKDK/1iiAJBv4N7/Uk2Ahx
-+guv9YogCQbuDe/1iiAJAwhx5guv9YogCQbrdtoN7/Uk2Lhwz3CgANQLbBAEAAXYCiHAD8lycQKv
-9IojiQlRIYDGrvMZhVEgwIAG9KoN7/Uk2PK4pvOdBY/14H7geOB+4HjxwIogiQaSC6/1iiHMAToJ
-b/8A2F7x4HjxwOHFz3CAANAFABAEAM9wgADYlkwkwIHMJCKACvIUEAUACiHAD+tyBdgFAq/07dsA
-3aWgiiCJBkYLr/Xy2fIIb/+pcD0Fj/XxwMIMj/XPcIAAyJIIgM93gADYllEgwIEA3RX0iiBJBxYL
-r/XZ2QLevghv/8lwxafPcYAAXC6wobGhENgJoaehCvClp4ogiQbuCq/14tmaCG//qXDVBI/18cBm
-DK/1AdvPcIAAXC4AgM9ygAAwl8G4g+DBgsB7geYF9M9wgADELseAz3CAAJQvAIBCIACAyiBiAIDg
-QPTPcYAA2JYMgYDgzCMhgDj0AoLPc6AAsB/7gza4Nr/xcNYnjR8AAIAAQIK1gQAiEAD9ZRJ1TfcK
-IcAP63IF2IojRAYKJAAECQGv9Lh1gOYK9AohwA/rcgXYiiMEB/TxACCQIxJ1fvf+ZoogSQY2Cq/1
-iiEECQIggCNyC6//AdkNBI/18cCiC4/1CHaKIP8PAKbPcIAA2JYKgIDgyiUhEWryz3CAABwPGIiE
-4BX0pgsAAACmz3GAANQFQIEhgVYiQgsU4VlhMHAB2MIgDgATeFMgTQBQ8Lz/z3CAADQvAIDPd4AA
-xC5CIBGA4gogAMohYiAAps9xoACwH7uBKYdAJxATz3KAAKiW8CBBIEWCYbkFKn4A1b0ndYIlgRFI
-JQ0QEHXKJQYQT/fPcIAANC96CW/+SiFAIM9wgABML2oJT/6gps9xgADUBQCBIYFWIEALFOE4YBB1
-Ad3CJU4Ts31TJU2QCvJMIUCgBvQJh+4Mr//wIAAgEQOv9alw4HjxwLIKj/XPcIAAHA8YiITgz3aA
-ANiWFfQKhgHagOAAhsB6AdmA4M9wgAColgaAwHmA4MwiIYDMISKAXfJj8M9woAAsILCAEoYA2gIl
-AZDjhsoibwCxdwmGEAAvAPtgAiXPEIDnAN/D9gHf13EAQAAAyPeA4gbyAiWBH04AASAypgIlwRDX
-cQBAAADJ94DnB/ICJYEfTgABICOmIoaA4RPyIYY4YBBxx/cQdcv3MHWH9wfwMHWD9xB1w/cA2QLw
-AdkipgCGz3WAAKiWpoWA4AHYwHiA4QHZwHmGJX8ehuUA2wTyqoaA5QP0AduA58wiIoAD9ADYCPCA
-48whIoDMICKA+fMB2BUCj/XxwKYJj/UIdc92oADALxqGObhSIAAAUyAQABSGUSDAgADfB/T2Ce/1
-JNjyuALyAd9RFgCWgOAL9KMWAJYEIIAPAAAAD4wgEIAD9ADaAvAB2gQhgU8ABAAABCCATwIAAADX
-cAIAAABKJEAAwiQCAQxwhiA9AIDgSiVAAMIlQgFRIIDBCfLPcIAA0AUAgIHgANgC9AHYz3OAAGQo
-YoNRI4CACPLPdqAArC/chva+ANsD9AHb5L3KIGEgTCAAoCfy5b3KJ2EQgOcj8uO9yiFhAIDhHfLi
-vcoiYQCA4hny4b3KJGEATCQAgBPy4L3KJWEATCUAgA3y5r3KIGEAgOAH8lElwJHKI2EAgOMD9ADY
-AvAB2PkAj/XxwJhwz3CAAFiyCYDPcYAA2JYluMC4CqFz/4DgBfKIcLP/gOAD9ADYAvAB2BkCz//x
-wKHBANjPcoAA2JZNEoEAQMCB4YtwD/TPcaAALCAwgVSCQnnXcU4AACDF964Jz/4D8KoIz/6C4Ab0
-iiD/D6HA0cDgfs9wgACULQOAIIAAwCJ4gODKICwA8/HgeM9yoAAsIFCCInrPcYAA1AUVeQCBEHLK
-989wgABYsgmAUSBAgQLyQKHgfuB44cWKIf8Pz3CgALAfG4DPdYAAlC1jhWCDpoXVuIDlANoG8iKF
-YnmA4cohjAAJIQAAgiCBAUggAADgf8HF8cCaD0/1OnDPcIAA2JbngMC/gecB389wgABkKC2IwH+B
-4QTyANgd8M9xgAB0KCCBgOH68wgQBABRJECAyiHCD8oiwgfKIGIByiOCDwAA3gB0BGL0yiXCADYL
-b/jpcBpwiiBJBrINb/VG2YogyQmqDW/1KnHPcIAAREsAiM91oADIH1EggIAA3gbyfhUAlqC4fh0Y
-kM9woAC0D9ygD8gEIIAP/v//Aw8aGDAPyIe4DxoYMGIJQAJE2EkdGJAc3RLw4HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HhhvYwl/5/u9c91oADALxOF+rgK9IogSQYeDW/1XdnODWAC6XC+
-D6//6XDPcZ8AuP9dgc9wgADcBUCg3aHPcKAAyDs2gEQhAgc2gIYh/wgWgEV5RCAEBwUkfoDy9RoI
-z/9RFQCWgOAG9Ax0hCTCnxfyF4X5uBP0z3CAAIwHAIBRIECADfQKIcAP63IKJAAIURUFlgXYUQNv
-9Hjbgeck9IogSQaWDG/1gNkQhVEgAIAV9M9xgAAwdASRheAF9AuJguAL8kAVBBAKIcAP63IF2Ibb
-FQNv9LhziiAQARGlEIVRIACA/vUUhau4FKVPIEAmnLgZpc9woADIHxgQAYahuRgYWICKIRAAMaAJ
-2Qi5L6ATham4E6XPcIAA2JYHgIPgGvTPcIAA1AUAgFYgQAsCIQGgGAAPAAohwA/rcgXYrdtKJAAA
-pQJv9LhzEmmfuIgdABAaCg/+gB2AE89wgADcBb0Fb/XBoPHAUg1P9c91oADAL4AVDxBcFRAQ2oWI
-FREQz3CAANiWB4BKIkAgwLiB4M9wgADcBQGAwiKCJOC40fSAuM9xgADcBQGhiiAJDYoLb/XX2Yog
-CQ2CC2/1QS+BEIogCQ12C2/1CnGKIAkNagtv9clxiiAJDWILb/UqcTCFWgtv9YogCQ0zhU4Lb/WK
-IAkN/L4G8hCFUSAAgAT0ANgD8AHYTCIAoC8gByBA8oogCQ0mC2/17NkwhR4Lb/WKIAkNEIVRIICC
-DfRAFQQQTBUFEAohwA/rcgXYrQFv9O/bTCBAoM92oADIHyDfE/SKIBABEaXwpgrYQx4YEADYXgiv
-9Y248aYwhdIKb/WKIAkNiiAQABKl8KYF2EMeGBAA2D4Ir/WNuPGmEvAQhVEggIIO8kAVBBBMFQUQ
-CiHAD+tyBdhFAW/0iiOEAEwiAKAThQ/y+rgY8gohwA/rcgXYhNtKJAAAJQFv9AolAAH6uMohwQ/K
-IsEHyiOBDwAAiAAF2PHzB9jPdqAAyB8ZHhiQAdgIcQhyCHOyDy/0mHA6DK/1VNhRIACBCfTPcIAA
-3AUggM9wnwC4/z2ggBUPECK/Xggv/ulwz3GAAMB1DYH4YA2hANiAHQAQiB0AEAnYCLgOptUDT/Xg
-ePHAegtP9c9wgADYlgeASiBAIMC4geDPcYAA3AUBgcIgAiThuEL0gbgBoc92oADALxOG+rgE8hOG
-urgTpgLYEabPcIAAMHQAkIjgz3WgAMgfEfQg3/ClCthDHRgQANgaD2/1jbjxpQvwRRUAFuTgQAAF
-ABCGUSAAgPjzngyP/5YJYAIKcBUWAJaAuBUeGJCKINAHYglv9YohhQoyDIABug5P+AnYCLgOpTUD
-T/VcFgQQQBYFEAohwA/rcgXY5Qcv9IojhQbxwKYKT/WhwTpwKHVIdppzCiMAIQoiQCHIdwogwCGK
-IBkCDglv9QvBLMCA4CgUBTAJ8ipwqXHJcgpzxgkgAJh3EPAAHEAxKnCpcclyinMKJMAECiWABNh3
-KgggAAonAASZAm/1ocDgeOB+4HjxwAhxvghv9YogWQHmD8/40cDgfvHAFgpP9Tpw+nEaclpzCiAA
-MQokQCEKI4AhCiXAIQogwITPcYAANG3KIGIACHIEuAhhTCcAoAS4hiD+AwUglgDKIcwPyiLMB8og
-bAHKIywNyiRsAAgHLPTKJcwFz3WAALxKAYUA3slxygpv9TjaIIUc2AChAYUY2SCwanGEKQsMACGP
-f4AAWLI3hxAYggUzGIIDz3aAAOQFIaDJcSKgCiHAhCgYQAUxGMIFMhjCBTQYBATKIWIAlg2v9Qzg
-IYUM2BKpA4FRIECCDfQMic9ygABsWMO4HHgKYs9wgAD8skhgDKlMIwCgBvTPcIAAUJIF8M9wgABw
-kgOlz3IAAEgRQLBMIUCgGNpCpQTyiiIFAkCwDcKA4gT0z3ICAFAOQaa1FwIWUSIAgBHyGtpAsUKl
-QJBMIgCgh7pAsAfyz3CAAFwuBIAzGQIATCAAsBTyAYGYuAGhA4GfuAOhz3GAANAHABkEBSCHQYfP
-cIAA1AcgoEGgVg3v+Klw5QBP9eB48cCyCE/1ocEIdlpxOnIac4h3Cg+v/qh1gODMJiKQCvLPcIAA
-2JavoE4Kb/QD2A3wQMXJcEpxKnIA25hzuHPYdwonAASQ/8kAb/WhwPHA4cWA4c91gADsBRLyJoWA
-4Q30AKUWCm/0Ddi+CK//iiAIAAHYBqUO8CCFJXgL8A4Kb/QN2DIJr/+KIAgAANgGpQClpQBP9fHA
-JghP9Qh2AN/pcOlx6/8D2Ol1gOYacAjyE20UeMdwgADgL34Oz/2A5gnyE20UeMdwgAAoMG4Oz/1C
-IEAggOAB5Sr3z3CAAECX6XSdsDC8nrDPcIAA7AWqCSAB4KAtAE/14HjxwLYPD/XPcYAAxAYAgaC4
-AKEB2OL/z3CAAECXAICD4Mv3CiHAD+tyBdjc25hzvQQv9EolAACA4OAALgAA3s93gADsBc9wgACs
-XtV4IICzbgOAIqcDpxRuACCBD4AAQJdHkQaRELpFeEWRGnAEkRC6RXhDkVpwApEQukV4OnBCCu/9
-CnEih3pwtH0AJYAfgADsLyCgRg1v/ipwCHEAJYAfgADgL/4Nz/0MIICkhPdMIgCgJvQjh7NutH0A
-JYAfgAA0MCCgFg1v/mpwCHEAJYAfgAAoMM4Nz/2KIEwNXg0v9frZiiBMDVYNL/VqcYPmjvcKIcAP
-63IF2PzbmvGKIEwNOg0v9YohBADPcIAAQJcAgAHmEHYwB8X/9QYP9fHAz3CAAECXNgtv9Q3Z7gpP
-9bX/0cDgfvHAjg4P9Qh2iiBMC/oML/XJcYPmyiHGD8oixgfKIGYByiOGDwAAjQHKJMYAiAMm9Mol
-JgAUbs93gABAl/hgRZAkkBC6RXmA4RpwQ/LPcIAArF7VeCCAz3KAAOwFA4AkorNuBaK0fQAlgB+A
-AHwwBhACISCgBBAAIRC6Lgxv/kV4CHEAJYAfgABwMOYMz/3PcIAA7AUlgAAlgB+AAMQwBhACIQ4Q
-AyEgoAQQACEMEAEhELoQu0V41gjv/WV56gtP/ghxACWAH4AAuDCmDM/9XpcdlwDZDyGBAxC6RXgG
-IECAAd0dtzC4HrcX9M9xgADEBgCBoLh2D+AAAKHPcKAAsB8bgLKnDNmW2hGnVicAEh7bmg8v9Ri7
-ENrPcYAA7AUAgdh6RnjNBS/1AKHgePHAag0P9c92gADsBQDdC/AQ2Lh4CyEAgLwO4v/KIEIDAeWD
-5SCGtveA4cogIQDIDOH/yiEBAKEFD/XgePHAANnPcoAAQJcgos9wgADEBiCgPbIwuT6yPvHxwOHF
-AN3PcIAA7AWgoM9wgADEBqCgz3CAAECXqXSdsDC8nrCpcDD/qXCpcRz/WQUP9eB48cDaDA/1AN/P
-dYAAQJc+lQ8nDxAdlRC5JXgGIP6DP/TPcYAAxAYAgYC4AKHPcIAAyAbPcYAAtH8AkFaJEHIb9M9w
-gADKBgCQVIkQchP0z3CAAMwGAIgyiRBxDfQPyAQggA/+//8DDxoYMA/Ih7gPGhgwz3CgALAfG4AA
-3gzZltoQpdKlViUAEh7bag4v9Ri7AdjJcc4PYAOA2j6VHZUQuSV45XgdtTC4mQQv9R614Hio8eB4
-CHEA2Pzx4HgIcQHY+PHgeAhxAtj08eB48cDhxc9xgABAl36RXZEQu2V6ESIAgAHdCvQDuBR4x3CA
-AOAvYgrP/alwA/AA2FkED/XgePHA4cUodfL/gODKIEEDXAvh/8ohYQA9BA/14HgIcgDYENnw8Qhy
-Adgg2ezxCHIC2EDZ6PHxwOHFz3WAANyYII2MIcOPCvKA4Abyz3CAAAAxAgrP/f/YAK3PcIAAhJgA
-3bWgz3CAAJAFoKDPcYAAxAYAgaK4Pg3gAAChqXA6CeAAqXHRAw/14HjxwOHFz3GgALAfO4G6CS/1
-iiDMDc9wgACEBgCABCC+jwDAAAAI9M9wgADcmACIjCDDjwTyAdje/891gACMl6lwpg8v9VLZCgtA
-BaOFiiBMDnYJL/WpcU4PD/WKIIwOagkv9V/ZAglv/qlwCHHPcIAAADG+Cc/9/tnPcIAA3JhNAy/1
-IKj/2c9wgADcmCCoANnPcIAAhJjgfzWg4HjPcoAAtH92is9xgAAIBlSKYbEBoUCxKHAI2XPaHtux
-BC/1GLvxwOHFz3GAAIyXQYnPdYAAkAWA4s9zgADEBiCDBvIB2AClgrkgownwANpApaK5gOAgozgM
-wgAA2DYI4AAIcQDY5//JAg/14HjxwM9wgAAcDwmAUSBAgcogYgA4C2IEyiEiAM9xgADIBoogjAya
-CC/1IJEB2OP/0cDgfuB48cAaCi/1iiIEDs91gACMl892gAC0f0AlABSKDy/1QCYBFgGFIoUhpiGV
-AKY2riCNBCCADwAGAACA4AHYwHg0rhKuANnPcIAASggyDyAAIKgyDUADgOAF8gDYy/8h8M9xoACw
-HzuBJggv9YogTAwWCG/0AtjPcYAAHA9IgTSRUyIAADYN7/QB24ogjA7+D+/0ptkA2Z65z3CAAIQG
-IKDpAQ/14HjxwOHFCHX/2c9wgADcmCCobyBDADoPoAAB2c9xoACwHzuBxg/v9IogzA0FhQOAQoUg
-gIogiACyD+/0QnmtAQ/1gODxwA/YCfLiCg/0jglv/4DY0cDgfuoKD/QOCm//gNj+Dg/+guAG9PYI
-L/4A2PPx8fHgePHA5ggv9YogzA6iwWYP7/SKIcUCi3B+DS/1AtkDFI8wgufKIcoPyiLKB8ogagHK
-I4oPAABcAcokKgDoBerzyiXKAAIUgDDPdoAAEAaELwYfABQQMSQeAhDPcIAAhJoAIEEONIkKJUAu
-gOFAIBIFACBUDhzyiiBMDfoO7/SKIUUKiiBMDe4O7/TpcSYKb/VCIIAhAdgTtv/YJR4CEEAmABmu
-CW/1BNlo8EojACAmHsQUJR7CE891gADgmEAlERKidYtwqXF6DS/1AtpAJQASbg4v9UIggSEAJYEv
-gADgmAKBz3GAAKiWJYHVuDBwyiHGD8oixgfKIGYByiOGDwAAegHKJMYEHAXm88olxgQ+CGAF6XBK
-JIBwanGoIMADhCkGDy9wMiICIIDiBvIwIQIgAoUQciXyAeFAJgAZFglv9QTZAdkUHEIgbRUAFoC4
-bR0YEChwn/+KIEwNGg7v9IohhgSKIEwNDg7v9CKFiiBMDQYO7/TpccEH7/SiwAohwA/rcgXYiiOG
-AUokAACZBO/zCiUAAeB48cDPcYAAEAYDoRoJL/QQ2MIPL/+KIAQAGfHgePHASg/P9AAWDkChwYLm
-yiHGD8oixgfKIGYByiOGDwAAbQXKJMYATATm88olJgBAxot36XBqCG/1BNmKIMwKhg3v9MlxhC4G
-HwogQC4AIY1/gADcmmDccg2v/QIlABPPcIAA4JjeEAAGEHYR8rwVgJCA4CXy6XAE2ZnaHtvqCC/1
-GLsA2LwdApAZ8AAggS+AAFSaEIGBuBChz3CAABAGNICA4QHaBPJEoATYCPAA2TCgKqBLoCSgBdjL
-//UG7/ShwG0AL/QQ2OB48cDhxc91gAAQBhWFgOAh9GIMD/6C4FwO4f3KICEAAdgVpTIIL/QQ2D4I
-L/QP2IDgFqUI8h4IL/QP2EIPL/+A2M9xAQB8nAHYxglgA4DasQbP9OB48cAuDs/0z3WAABAGNBUQ
-EIwgw68I8oogDA2ODO/0iiFGDiDwgODKIcEPyiLBB8ogYQHKI4EPAAC+AcokIQAYA+HzyiUBBAhx
-giEGB89wgADgmA4gQACuD2/9iiEGDxpwz3CAAEScRYCMIsOP/9kG8jgYAAQtpQjwFBgABADYBKUt
-pcv/DQbP9PHA4cUIdYQoBg/PcoAA4JgAIkEObREABs9zgAAQBqC4bRkYAAKDBIiA4BTyA4GA4Moh
-wQ/KIsEHyiBhAcojgQ8AADQHyiQhAIQC4fPKJcEAAoGA4BL03hIABowgw48K8s9woACwHxuAAqHn
-GlgDEfCtowDYwf8N8EYLD/6ELQYfCHEAIYB/gAB8mv4Lj/2VBc/04HjxwBoN7/QC2ADdCHbPcIAA
-lJqELQYfMCBADlEgAIBQD+L/yiBCAwlugOAB5S/3ANjt/lUFz/TgePHA4cXPdYAAEAYjhc9wgAB4
-NfAgQABAeIDg+fM5Bc/0z3CgAAREB4CA4AHY4H/AeM9zoACoIDGDz3KAABgxA4I4YAOiAdgSo+B+
-4HjPcqAALCBmgs9xgAAQBhOBYngToRCCEqHm8eB44cXPcqAAyB+kEgMAz3GAABAGEoEQc8IjBgBE
-92J4E3u/ghOBu2N4YBOhAdhKGhgA4H/BxfHAQgzv9ADbz3CAABAGY6D/2s9wgADgmN4YmABKJIBw
-aHWoIAAIhC0GHwAhgX+AANyaz3eAAJQtoBnAgAbesBmAg892AQBEiawZgIO0GcCDvBnCgAAhgX+A
-AJSaYKEB5c9wgADgmOcYmADPcYAAlDUAgRzaQKAY2DYJoAACoS0Ez/TgeAHaz3GAABgxQ6kYoShw
-ZNl12h7bwQXv9Bi74HjxwJ4Lz/TPd4AA4JjnFw0WjCXDnzHy/9nnH1gQhC0GH6CgJ3cEj4DgCiBA
-LhH0AofPcYAAjAZmDm/9IIEIcc92oADIHxWGugwP/oDgA/QB2BTwz3GAABgxAo+gqQGpAdgTphyG
-AaEB2N//ANgAIIEvgACYmgCpANiJA8/08cAqC+/0AdqhwYHgz3GAAMAGQKEn9M91gABEnAWFjCDD
-jwryANqEKAYPACGBf4AAmJpAqc92gAAQBhCGgOAG8g+Gyv8A2BCm/9gFpYtwzv+A4AnyqgyAAADA
-DaYA2Cb/EfCSDO/zENiWDIAArgsv/4ogBACeCA/+guCYCuH9yiAhABUD7/ShwPHAmgrv9P/az3CA
-AOCY3hiYAOcYmAAA3s9xgAAQBsOhTaEB2s9wgADABkCg0KHVodah1KHAocGhAt3JcIQoBg8acAAh
-gX+AAFSaEIEAIY9/gADcmmDcRiDAABChugiv/QInABNhvYDlvB+Ck0AgQCAm9wHYwf+JAs/04HgA
-2M9xgAAYMQOpz3CAABAGSIACgEKpHOBWeESISakFiOB/CqnxwP4J7/SKIAwJz3WAABAGJIViCM/0
-BIWA4EP0z3eAAOCY3hcCFgDehCoGDwAnQB4CpSSIAduA4c+lcKUh8ugfmBMMEAUAz3GAAKiWBCWE
-D8D/AAAUEQYAQSwEBgUuPgEAIYR/PwD//wQkQQHpH1gQIJCMIYKGAdnCIU4ALqXIpSSAz3aAACic
-wLk6ts92gAAYMSiuQK4CiGSlAa4e8ASFgeAc9M7/ANgEpQKFJIiA4RL0KIUc4DZ4JIjPcIAAtH8W
-iBBxAdnAec9wgADABiCgAtgD8AHYA6WNAe/0AdjgePHAz3KAABAGAoIliIDhAdgF8gjZL6J5/wfw
-z3GAAMAGqgqgAACh2weP/+B48cDyCO/0iiBMCc92gAAQBiSGVg+v9KTBBIaA4KH0AoZIhiSAVnjP
-coAAtH8EIYEPAAYAAIDhAdl2iiAQjQDAeXB1CfTPd4AAKJz6l7SK8XUD8gDdBfCyirFx/fUB3YDl
-z3GAAMAGoKEV9M9xgADIBiCRMHMP9M9xgADKBiCRdIowcwn0z3GAAMwGIIlSijByA/IA2QLwAdmA
-4V3yJ4DPcIAARJwtoM9wgAAwl0GAz3CAAKiWBYAFKL4AQCmAchBxyiHGD8oixgfKIGYByiOGDwAA
-7ALKJCYAPAWm88olJgDPcIAAlAYAgMoKb/04YIDgA/S5/0nwD8gEIIAP////Aw8aGDBoFoAQAN2A
-4KWmCvTPcKAALCAQgMdwBwAgoRmmZBYHEM9wAQD4m0DABdhBwAHfQsdDxelwBtkE2gDbmHO4c/oM
-b//Yc2geQhPkpulwHPAA2ALZI6ZoHgIQFvAEhoHgAd0R9AWGgOAb9M9wgABEnC2Az3CAAJQGAIA2
-Cm/9OGCA4AXyAdjRB6/0pMBoHkITFg1v/wXYANgEpqvxBdgPpqlwCv8A2GgeAhDt8eB48cBCD4/0
-z3aAABAGBIaA4KTBDfQkhqINr/SKIIwIAoYEiIDgFPQC2ASmBIaB4En0BYaA4Dn0z3CgALAfG4Bi
-CC/+O4aA4Cz0ANgw8ADf5abPdaAAyB8Vhc9xgACUBt4Jb/0ggRumpBUHEM9wAQBUnEDABdhBwAHd
-QsVDx+lwBtkE2ulzmHe4dwAnhw8HACCh+gtv/9h3pKapcDDwWgxv/wXYBNgC8AXYgOAB2gP0Adgk
-8CuGgeEQ8lCmD6YM8ASGguAb9CSG8gyv9IogjAgLhoHgBPQB2A/wgODr9QKGsgzv/QOACHHPcIAA
-rDUyDU/9ANjL/t3xANhw8eB4z3KAABAGIoIliYDhE/LPcYAA4JjeEQMGz3GAAJSahCsGDzAhQQ5R
-IUCABfQI2A+iAdgLogDYCqIEogXYA6LgfvHACg6v9IogjAnPdYAAEAYkhWoMj/QEhYDgP/QihUiF
-QCEAB1Z4RIjPcIAAyAYAkBByAd4O9M9wgADKBkCQz3CAACicGpAQcgT0xKUA2EDwBImA4B7yz3CA
-AMAGAICA4Bj0z3CAAEScLYDPcIAAlAYAgFYIb/04YIDgDPSKIEwN+guv9IohTQIA2M7/Adgg8MSl
-Adgc8ASFgeAA3hr0IoXPc4AAHA9EgQWBHOFIowmjaIXPcIAAKJwakHZ5JInqCK/0yXPEpQPYA6UB
-2KkFj/QKIcAP63IF2IojzQqYdk0Cr/O4c89wgACUNSCAHNrPc4AAEAZAoUKDVSLBCSGgoBIBAK25
-oBpAAFUjwQWkGkAAnBIBAWiDJKBVIkENI6AA2eoaRABAIgEHdnkliaDhDPTPcYAAyAYgkUh0gCRE
-EyCsHtsD8BjbYqBVIkENeWFFAW/4JaDPcYAAGDFAIQADVSHCBVBwRvcA2QQYUABQcL334H7gePHA
-jgyP9M9wgADgmN4QAwZKIAAgguPKIcYPyiLGB8ogZgHKI4YPAADTB8okBgSIAabzyiXGAM9ygAAQ
-BkiChCsGDydwgOFWeKeAR/TPcIAAfDGKDa/0iiEPD89wgAA0MXoNr/Qg2c9wpQAIDACAUyBAgBLy
-geAS8oLgE/IKIcAP63IF2IojXwwKJAAEKQGv8wolAAT/2Qfw/9kIuQPw/9kQuc9yoAC0Rx4aWIAd
-GhiAGxpYgwDZkbnPcKAA0BsxoM9wgAAABBB4SRoYgG8gQwBUGhiAM/DPc6AAtEcbEwCGgOAO8goh
-wA/rchsTBYYF2ADbi7vBAK/zCiQABEsbGIQB2HcbGIAA2J64VBsYgIokw3/Pc4AAxF4KcKggQAQK
-Y891gAAYMc9xgAB8MVV9R4XwIQEAAeBZYSeluQOP9OB48cBSC6/0iiAMCqPBz3WAABAGJIWyCa/0
-AN4EhYDgJ/TeDEAAAdgEpQKFBIiA4EwCAQDPcIAAwAYAgIDgPAICAM9woAAsIAOAz3KAAEScLYIZ
-Yc9wgACQBgCAOGCKC+/9DKKA4BQCAQB08ASFguA79A6FgODKIcEPyiLBB8ogYQHKI4EPAACVA8ok
-gQPoB2HzyiXBAEKFKIVAIgAHNngmiGDBJogBHEIwJogCHEIwJ4hhwSeIBRxCMAeIi3EGHAIwDg3v
-9KgSAADPcKAALCAjgM9wgAAYMSGgxaVW/wPYBKXM8ASFg+A59EKFKIVAIgAHNngFiFEgQIER8gOS
-z3GgACwgI4HPc4AAGDFhgwq4YnkwcAX3CdgPpYjwBYWA4A30BIqA4Kryz3CAAEScugrv/QyAgOCi
-8gWFgOAG8gXYD6UB2Anwz3CAAMAGAICA4Jb0ANjv/pLwBIWB4Gv0Uf8ihUiFQCEAB1Z4RYjguhfy
-g7pFqM9ygABMdMeCz3OAAEScx6P3gsOC/mbIo/aCwoL+ZsmjwYJVgl5myqMFiFEgQIAr8oYJj/2A
-4MohwQ/KIsEHyiBhAcojgQ8AAOcDyiQhALQGYfPKJQEBdgmv/QLYqgmv/QjYIoUEiYLgCvQB2ACl
-ANgTpZIJr/1a2CKFBImB4AP0AdgBpQiFHOEWeQWJhiD/jMoggg8AADBDuAzi/8ohIgAChSiFHOA2
-eAWIhiD+hwTyAtgEpSrwBNgEpSbwJIWE4QHYIvQUpc93oADIHzyHz3CAABgxIaB+D2/0iiAMCs9w
-gAAYMQzZddoe2w4Lr/QYuxWHz3GAAJgG4gsv/SCBB6XEpQTYA6UB2EEBr/SjwPHAzgiP9M91gAAQ
-BgSFgOBq9AKFBIiA4BPyz3CAAMAGAICA4A30z3CAAEScOgnv/QyAgOAF8gDYlf4vAwAAz3agAMgf
-PIbPcIAAGDEBgEiFAnkChVZ4B4AQcYb3AdgEpQcDAAAAhYDgCvJRI0DACPIC2BUeGJCCCK/9HtgV
-hs91gAAQBqoJ7/0nhYDg2gIBABWGz3GAAJgGMgsv/SCBB6UChSiFHOA2eAWIhiD/jAnyz3AAADBD
-z3GAADQx4f4ChSiFHOA2eAWIUSBAgJoCAQAAhYDgBfIfhoDgjgICANL8hwIAAASFgeCN9CSFWg5v
-9IogTArPcaAALCAjgUoOb/SKIEwKAoUohRzgNngFEIYAAN5RJgCA1KU98s9ygAAYMc9wgABMdHaA
-IoB5Yc9zgABEnOmD2KpUEAQABBAFAAAlBQEoEwQA4nkCJQUB54McEAQAAiTEg2iDA4BieMongRMD
-8gHf+KqA4Q7yQCyDAHBxhPdPJ4AQBvCA4AbyTydAEA9/GKpBKcAAOGCwcEP3gr/4qlEmQIAp8gCF
-gOAN8s9xoAAsICaBE4UieM9xgAAYMQWhwKUF8AGFgOAD8sGlmvz+DI/9guAO8gohwA/rcgXYiiOT
-BUokAAAdBG/zCiUAAd4Ob/0A2AKFKIUc4DZ4BYiGIP+MBPIC2ASlt/AE2ASls/AEhYLgC/TPcAAA
-MEPPcYAANDGL/gTYBKUEhYTgqPQkhSYNb/SKIEwKz3CgACwgI4DPcIAAGDFAIBAHN6AKDW/0iiCM
-DSKFIBUEEEAhAAcWIAABBYhRIACAAN4d8kokwHDJcslzqCDAAfAgwCAB4xpiA99KJEBxANuoIMAB
-8CDAIwHnG2NQc8f3z3KAABgxGIqCuBiqz3CAAEScz6BMkUAkQABQcAilRvdtEQAGUSBAgAbyAdgQ
-pfX9V/APhZb8D8gEIIAP////Aw8aGDDPpfj8iiBMDXIMb/SKIdQGCIUihRZ5iiBMDV4Mb/QngQLY
-A6UChc9ygADABiSIgOEP9CiFHOA2eCSIz3CAALR/FogQcQHYwHgAoibwIIKA4QXyAdgDpSDwKIU2
-eCeAz3CAAEScLaDPcIAAMJdBgM9wgAColgWABSi+AEApgHIQccohxg/KIsYHyiOGDwAAMQV4Bub/
-BdjEpc0Fb/QB2AohwA/rcgXYiiMUD0okgAB5Am/zuHPgePHATg1P9M91gAAQBgSFgOChwUH0JIWu
-C2/0iiCMCgHez3CAAMAGwKAA2BSlKoUBpYDhAKUC2h70z3CAALR/z3eAAMgG4Jd2iPFzEvTPd4AA
-ygbgl3SI8XMK9HKIz3CAAMwGAIgQcwT0RKUE8MqlyXGB4RD0Rguv8wLYz3KAALR/FIo2ikCCaghv
-9AHbxKWd8ESlBIWB4An0JIUqC2/0iiCMCgLYBKUEhYLgM/QkhRYLb/SKIIwKz3GAAMgGiiCMDAIL
-b/Qgkc9xgADKBoogzAzyCm/0IJEChQSIgOAX8guFgOAV9M9ygABEnDCCD4IOIYMPBwAgoRBzR/cH
-2A+lAdgQpQulA/A4YA+iA9hc8ASFg+AQ9CSFrgpv9IogjAoPyAQggA////8DDxoYMATYTPAEhYTg
-HfQkhYoKb/SKIIwKUyDAQLYNIAAcpc9wgADgmN4QAQbPcIAAlJqEKQYPMCBADlEgQIAF2MogoQEs
-8ASFheAg9M92gADgmN4WABYE2ZnaHttAwItw3g1v9Bi73hYAFoQoBg8AIYB/gABUmjCAobkwoAHY
-C6UG2ASlANgO8ASFhuAJ9AbYA6UchYDgyiBiABt4BKUB2O0Db/ShwOB4z3CAAMiSKIDPcoAAEAYv
-eIHgC/QA289woAC0D3ygAtgDomSiA/AB2AWiyQFv9IogzAjgeM9wgABEnDmAz3KAABAGL3iB4AX0
-BNgEogPwAdgFoqEBb/SKIMwI4HjPcIAAyJIogM9ygAAQBi94geAF9ALYBKID8AHYBaJ5AW/0iiDM
-COB48cD+Cm/0iiBMDWYJb/SKIZcND8gA3gQggA////8DDxoYMHILb//JcM91gAAQBhaFgOCYCWL/
-yiBiADEDb/TVpQHZz3CAABAGJKAtBE//4HjxwN4PD/9+DQ//Yg5P/9HA4H7geDnZz3ClAAgMPqDg
-fvHA4cUA3VYJb/+pcNoOL/+pcN4PT/9qDQ//z3CAAJAF4QJv9KCg4HjxwM9xgACEBgCB13AAgAAA
-BPQ+CE//2fEAgddwAEAAAAz0z3GgALAfO4GuCG/0iiBMDOoPD//J8cfx4HjxwCoKT/SA4c91gACE
-Bg/yAKUBhYDgFPTGC2/zDthyCq/+CNgB2AGlCvAA3sClxgtv8w7Y5gqv/gjYwaVZAk/08cDPcAAA
-IE4CDe/84cXPdYAAjAYApc9wAAC4CwGlz3AAAIgT5gzP/AKlz3APAEBC2gzP/AOlBdjSDO/8C7gh
-Am/0BKXxwM9wgACgBgOAgOAb9HYLb/MV2IDgF/TPcIAAMHQHiIDgEfLPcIAAuARggM9xAQB4oAvY
-YHsE2iILb/MV2NHA4H7PcYAAWLIJgVEgQIEH9MURAAZRIECBCPKCCq/2E9h6Cq/2Edjt8evx4Hjx
-wDIJb/QH2DoNAADPdqAAtA/8hhpwANgcps9xoAAsIDCBig8v9IogkQVqDUABz3WAAKAG+gxgAQCl
-QIXPcYAAwHUBpUWh7gmgBAah/KZ2DiAACnARjYHgJPRAhYogRATPdYAAxDUjhRpiOGAQcgHYwiAO
-AIDgD/KKIBELLg8v9ADZOg3gAgTYAIWeDGABA6UG8DoN4AIE2AKFA6XyC8AC9QBP9PHAlghP9Nb/
-z3WAAKAGzg9gAQeFCHYHhRB2C/LyCiAByXBSDe/2x6WiCa/2Edj6C0ABz3CgACwgEIDJAG/0AqXx
-wKHB7//PcIAAoAYAgATZYtoe20DAi3BSCm/0GLuhwNHA4H7xwOHFz3WAAKAGEI2MIMOPDvTPcIAA
-1DUlgCOBIIHHcQ8AAKDmDs/8/tgQrXkAT/TxwOHFz3WAAKAGBoUbeJoL7/wihYDgBfIB2BGtkP9Z
-AE/04HjxwP/Zz3CAAKAGMKjo//T/M/HgePHAxg8P9Ah3fdgNuM9xgAColsWBYgnv/MlxjCACgM9x
-gACgBgDdh/cdeIwgAoAB5Xz3AChCAwUqvgMYGUAOgOcWuAWhA/T/2BCpEImMIMOPSA/B/9kHD/Tg
-fuB48cBuDw/0z3WAAMQ1AoUjhQHeEHHAfqlw5gtv9APZngtP9IDmA/IChQLwAIWtBy/0A6XgePHA
-Aglv8xXYp//PcYAAWLIJgVEgQIEH9MURAAZRIECBBPJOCK/2E9jPcIAAvAQggGB5C9ifBc//8cDK
-CG/zFdiTBe//ANjgeIDgAdnAec9wgACgBuB/I6DgfuB4z3KAAMAGYYKA4WV4AaIR8s9xgAC0fwSS
-dokQcxT0BZJ0iRBzEPQMijKJEHEM9A/IBCCAD/7//wMPGhgwD8iHuA8aGDDgfuB4z3KAALR/z3GA
-AMAGBJF2ihBzDPQFkXSKEHMI9AyJUooQcgT0AYED8ADY4H7PcoAAwAYhggZ54H8houB4z3GAAMAG
-AIGA4AvyAYGA4Av0D8gFIIAPAQAA/APwD8iQuA8aGDB1BA/84HjxwM9wgACwrwCAUSBAgCz0+g8v
-8xDYgOAk9M9ygAC0f89xgADABgSRdooQcxL0BZF0ihBzDvQMiVKKEHIK9AGBgOAM9A/IBSCADwEA
-APwE8A/IkLgPGhgwFgwP/NHA4H7d//7x/PHgeA/IkLgPGhgw/QMP/PHAIgmAAoDgB/LPcIAAgAcA
-gIbgB/TPcIAAwAYAgIDgA/QA2ALwAdjg8eB48cB6DQ/0CHcEIpMPAAYAAEwjAKAB3cB9BCKAD0AA
-AADXcEAAAABKIkAgz3aAALicGI7CIoIkEHUacQn0gOUF9BmOUnAD9ADYAvAB2C8hByDpcFoLIAGp
-cSCGMHcA2Af0IYYSccwhIaAC8gHYLyYH8BquO/IA2c9woAC0Dzygpg5P/ulwCnGpcmYL4AFKc6oL
-IACpcND/gOAG9DILQACuCE/9BPDWCE/96g1ABAGGz3WAAMAGBLUAhgW1GI4MrRIOYARKcASVz3KA
-ABwPJZUUsgiCgOHQICEAzyAiALm4urgFIMAECKLtBA/04HjxwJoMD/TPdaAAtA9wFRAQz3CAABwP
-CYCiwVEgQIEA3gvyCiHAD+tyBdiV24okww+RAS/zuHaLd+lw+ghv9ALZ3KXPcasAoP/ZoQfYGqHY
-oQAUADECFAExRCACAkIiAoJBKMMAyiJiAMC4mgrgAcC7ABQAMYYg/w1CIACCzgogAMogYgBwHQAU
-QcbpcGINb/QI2W0EL/SiwADZz3CAALicIaDNAO/2IqDhxeHGz3GgAMgcyIEIoQbdEfDgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/n+31yXDBxuB/wcXgeM9yrADUAQDZrRpYgKga
-WIBY289wgAAwdOgawIAAkIfgzCAiggPy7BrAgIEa2ACA24Ia2AAF24Ma2ABz274a2IB02wgawIAY
-GkCAvxrYgHfbDBrAgAPbHBrAgAfbvBrYgAAawIB/2xAaQIC9GtiABBrAgBQaQICqGliAqxpYgAHb
-rBpYgJMa2IAp2/AawICq23Ua2AAK23Ya2AB429QaQICYGtiAJ9uZGtiAINuaGtiAh+AB28B7iOAB
-2MB4BSD+gATyAtibGhiAfhpYAH8aWACAGlgA4H7geM9wAAABP89xqgDwQwWhz3AAAD49BqHPcgAA
-PT1HoYogzA8IoQnYjLgJoc9wAAAWHAqhz3AAAB8fC6HPcAAAHBYMoZHYBLgNoc9wAAADPw6hT6HP
-cAAAPT4QoYogxA8RoeB+4Hjhxc9xoADIHAihBt0R8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB4Yb2MJf+f7fXgf8HF4HjxwDYKL/QH2ADfj/8acJ//z3akALg9rBYAFs91pQDYy6K4rB4Y
-EAHY7KX2HhgQz3AVACsrmh4YENIKIADpcIogxACfHhgQz3CAADB0AJAB2YfgwHmI4AHYwHgFIH6A
-E/Ia2PMeGBD0HhgQZNjIHhgQqtjJHhgQadjMHhgQwNjNHhgQOdnPcKUACAw+oLX/CnDN/xjYlR4Y
-EM9xgADENeGhyNgCoQChA6HPcQEAiKDPcIAAyCnUGEAAlNgLpd0BD/TxwM9wgABskLoKL/SKIQQO
-z3CAALR/rgov9IohBQXRwOB+4HjPcoAAMHQnioDhBfQmioDhCfLPcawAkAGA4APYyiChAAWh4H7x
-wOHFCHUgkAKVQZUQuAV6KdgSuBUgQQBAoSCV8CBBADByDvKCD+/ziiDRAwKVIZUQuAV5cg/v84og
-0QNtAQ/08cDhxQh1IJAClUGVELgFehXYE7gVIEEAQKEglfAgQQAwcg7yQg/v84og0QMClSGVELgF
-eTIP7/OKINEDLQEP9PHA4cUIdSCQApVBlRC4BXor2BK4FSBBAEChIJXwIEEAMHIO8gIP7/OKINED
-ApUhlRC4BXnyDu/ziiDRA+0AD/TxwHYID/QodoDgzCYikA30CiHAD+tyBdiKI4YAiiTDD3UF7/K4
-c1MmfpDKIcIPyiLCB8ojgg8AAIQByiBiAfD1QYAghqKAWHlAgCR9KdkSuRUhggCgogCA8CEBADB1
-C/KGDu/ziiDRA4og0QN6Du/zqXFxAC/0BG7xwP4Pz/ModoDgzCYikA30CiHAD+tyBdiKIwYKiiTD
-D/0E7/K4c1MmfpDKIcIPyiLCB8ojgg8AAKoByiBiAfD1QYAghqKAWHlAgCR9FdkTuRUhggCgogCA
-8CEBADB1C/IODu/ziiDRA4og0QMCDu/zqXH5B+/zBG7xwIYPz/OA4Eh1y/cIdkCFYb5gegRtgOYI
-cRDlOffVB8/z4HjxwOHFiiBSDsoN7/N02c91gADsNalwQCWBFdIML/QW2gHYtQfv8zEdAhDgePHA
-Lg/P8wh2guDKIcYPyiLGB8ogZgHKI4YPAABPAMokJgA0BObyyiXGAM91gADsNQuFACaPH4AACDYQ
-dgT0FI+A4Dny+grv/wXYGnCKIBIOVg3v88lxRC6+FQAlQB5AkCGQCLpFec9ypAC4PZsaWAAikMoa
-WAAjkMsaWAAkkMQaWAAlkMYaWAAmkMcaWAAnkMIaWAAokMMaWAApkMUaWAAKkKMaGAAaDO//CnDL
-pQDYFK/hBs/z4HjxwOHFpsGKIJIN5gzv84XZi3D+Ci/0BtkAFAAxgOAU9EAkgDDPdYAA7DWpcdoL
-L/QW2gHYMB0CEAuFgOAMD+H/yiAhAAAUADGB4Bj0iiDSDZ4M7/OW2UAkgDDPdYAA7DVAJYEVogsv
-9BbaAdgrhTEdAhCB4dQOwf9SCg/0dQbv86bA4HjxwPYNz/PPcoAAIDYBghYShAAJJAQATCQAgAXy
-TCQAgsv3CiHAD+tyBdiKI8gB7QLv8kolAAIA22qiTCQAgGuibKLX92h3aHVocRJpFHgeYtOGAeHf
-Zx5i1IZYYBWA22MveZBxHWWsorH3a6LqovEFz/PgePHAgg3v85hwz3GAACA2bIkA3UAhAgpKJMBw
-4HioIEADESNAgwf0z3D/AP//FSJMAwCkAeWvfWuBqoFwdQyB1fYQdc/2EHMC28ogKQDKJWkQyiNs
-AMogLADKJawQFPAB2wLYAN0Q8BBzy/YQdQDdyiOpAMogaQAI9gHYAt0D8ALYAd0A2/AizwDwIkUD
-8CIAAAIlzgPNoQIgQAEOoQDYDyDAADwZAgAPIEADPRkCAD0F7/MAHMIA4HjxwMoM7/OKIBANocHP
-caAAsB87gQDeKgvv82DGrv+LcMr/z3WAACA2sBWCEIDiQCUBGgT0FI0Q8CDAeo3wIQ8AAYUFKP4A
-N3c29gHYFK2wHYITyXKA4swgYYAQ9CDC8CGDACGFWo0FKb4AN3PG9gLYFK0B2bAdQhCB4BvyguAP
-8oPgIvIKIcAP63IF2IojCwWKJMMPWQHv8rhzAYU5jQUpPgANhTdwBfc9FYAQB/CxFYAQgOD69TwV
-gBAzaCV4D3kNrRDwAYU5jQUpPgAthS8gQA4QcS33LoUwcKj3P9ktrRWNgeAM8oLgGvKD4AvyCiHA
-D+tyBdiKI0sOzPE8FYAQEPABhVmNBSo+AE2FLyBADhByBvdOhVBwP9hG9z0VgBBTaEV4Dq0aCu/z
-iiAQDS6NDRWFEA+NBSFBASV4hiD/AQwVhBBDuAskAIDKIcEPyiLBB8ojgQ8AAAcDlADh8sogYQEG
-ID6ByiHCD8oiwgfKI4IPAAAIA3gA4vLKIGIBtQPv86HA8cBCC+/zSiRAABpwwLiB4MIkAgEKc4Yj
-/gNEuwpwhiDxD0e4RCCCI1x6SHHPdYAAIDZMrQQgji8AAAAMSr64dtStBCCOLwAAADBMvtWtBCCP
-LwAAAEBOv7EdwhNTIr6AyiHBD8oiwQfKI4EPAAA2AcogYQEc8kwkAIAp8gQhAgBQcMohwg/KIsIH
-yiOCDwAAQAHKIGIBDPQEIMIAUHMO8gohwA/rcgXYiiNFAIokww+5B6/ySiUAAIDjQfQKIcAP63IF
-2IojhQDy8YPmA/aA5gj2CiHAD+tyBdiKIwUC6PGwdoX2TCUAgAj2CiHAD+tyBdiKI8UC3PFTIgQA
-RCKPAC8mwQMAJIQBhiL/DkK6gHJPerByQ/ZUrbhy0XJD9lWtSHaC4kT2ANqxHYIQsHZRjQX0gOID
-8gTaUa3RjYHmzCYikMwmIpEG9FNpJXpOrU2tgOPMJiKRBfJTa2V6Ta2A4MwmIpEE8lNoRXgOrRNp
-JXgPrQ2NEK1eDO/2ANgpAu/zPh0EFPHAxgnP8891gAAgNhGNgOAc8n4L7/IU2ADe0a3Src9wgAAc
-Dw2Qlv/PcIAAMHQHiIDgC/KKINgJq9n+D6/zBLlmDm/2AtjftYogkAzqD6/ziiHMCt0Bz/PxwALY
-z3GAACA2EakSiUUgQAISqQ+JUIkQcgbyEKnaC+/2AdjRwOB+8cAC2M9xgAAgNhGpEomAuKO4D3ih
-uBKpDYlQiRByBvIQqa4L7/YB2Orx4HjxwBIJz/PPdqAAsB8bhgDfz3WAACA2UyBQBQLYEa07hmoP
-r/OKIBAKD43gpeGl4qWGIP8BW2gOjawdwBMB2YYg/wFDuBByMq0D9AXZMq0HhRJwz/eBuTKt1f/P
-cYAAwHUUgQHgFKE7hoog0AoF8Nr/O4aKIFAMFg+P8/0Az/PgePHAA9nPcIAAIDYxqADZMqgtiFCI
-MHIG8jCoCgvv9gHYmPHgePHAbgjP8wh3z3CAABwPCYDPdYAAIDYluFMgEAAflRB3U/KKIJAJwg6v
-8+lxEY0B3tGtE63pcD7/UScAkAT0EY2E4Av0z3ECAgICng6v84ogkAyY/1LwE42A4ADZMvTRrawd
-QBAyrdat160K2BitBdpZrVDYGq0A2I64CKUJpQelA9hAHQIQBNhBHQIQQh0CEEMdghBEHYIQRR2C
-EAbYRh0CEEcdAhBIHQIQSR0CEAjYSh0CEAzYSx0CEDLYuB0AELAdQhCm/xGNgOAY8gjKkOAU9Ewg
-AKAS8gyNM2gleA6tDa3PcKAAsB87gLgVABA2uThgtB0AELr/2QeP8/HAdg+P8891gAAgNhaNIYUQ
-cUf3F40ihRBxYgAFAC2Fz3CAAGA2L2Ch/s9wgAAwdAeIgOAL8s9xAACwsK4Nr/OKINgJFgxv9gLY
-ANgNpQ6lAKUBpQKlrB0AEM92oACwHzuGig2v84ogUAqe/xuGNrgfZ8m/tB3AEyLwEo2huDiNQIUw
-cs92oACwHxKthvdg/zuGiiCQChLwO4ZHhdW5UHFI94G4Eq1a/zuGiiDQCgbwYf87hoogUAwyDY/z
-IQeP8/HAggjv8hTYiiDQBx4Nr/M62c9ygAAgNjGKgOEg8s9wgADYlgKAQiAAgMogYgAvJgfwFvSD
-4RH0z3CgALAfO4C0EgAANrkieMm4jCDHj8j3VP8hBc//u/8ZBc//FQXP//HA4cXPdYAAIDYSjVEg
-AIEJ8g2NEK3OCO/2AdgSjaS4Eq2tBo/z4HjxwC4Oj/PPdoAAIDYSjlEgAIBT8s9ygAAUiT6C5rkL
-9ACShiD8AIwgAoBH9FEhAIJD8gCGAeAApg+OhiD/AZYSjQBDuLFwOfQA2awWBRBKJMBwUhIEAagg
-wAXPcIAAYIk0eGCIESVAkEAkDwtALYAAFHg1eNhgBfLg48InxRDzoAHhQCVAAMK4rB4AEAGGAeAB
-pgCShiD8AIwgAoAE9AKGAeACpoog0Af6C6/ziiFSDjYPr/IU2OEFj/PgeKPB4cVCwQkUgTBDwoPh
-QcAA2Ar2gOHI9goUgTCA4cT2g+HD9gHYBxSCMAYUgzBQcwbyIsEwc8wiQoAD9AHYIcWB5RD0ChSB
-MCPDcHFK9gsUgjBQccwjqoCE9oDiyiBpAIHgDfSKIckPz3CAANAGIKCB5f/ZyiEiACGgwcXgf6PA
-o8FAwEHBBRSBMADYgeFCwg3yguEH8oPhDfQhwQDYDyBAAAMUgTAPIEAAAhSBMA8gQAAGFIEwgeEO
-8oLhB/KD4Q/0IcED4Q8gQAADFIEwA+EPIEAAAhSBMAPhDyBAAAkUgTCB4Q70AhSBMAq5TyECBAMU
-gTAMuSV6IcEOuUV5JXggwYHhCPQHFIEwIsIGuQi6RXkleOB/o8CVAs/z8cBSDI/zGnDPcIAAIDYQ
-iM92gAC4nIYg/wE7aAWGDiBAgM9xgAAwdCeJyiBiAIDhIvI6joDhzCAhgB7yAN0M3xJtFXjHcIAA
-UD4ggIDhBvICgIDgFfJAeGG/gOcB5TL3ANgars9wgAAgNhCIhiD/AUO4BaayDK//CnA9BI/zCiHA
-D+tyBdgt20okQADtAK/yuHPgePHAABaFQKbBTCUAhQAcQjFE9kwlAIJL9gohwA/rcgXYetvFAK/y
-SiRAAAAWgEABHAIwABaAQAIcAjAAFoBAAxwCMItwug7gAIHBAsKA4gz0CiHAD+tyBdiE24okww+J
-AK/yuHMEwGB6BcEDwYDhyiHBD8oiwQfKI4EPAACIAAXY7fMBwIDg4iBCAIoPj/OmwNHA4H7gfuB4
-8cAiC4/zOnAbfc9wpgCcP2QQEABRIACgJvQD3hHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44Hhhvowm/5/t9WG9jCX/n9/1CiHAD+tyEthM2wokQATxB2/yCiUABB0Dj/MA2M9xrADUAfgZ
-AID8GQCAAKGlGRiAphkYgKcZGICiGRiAoxkYgKQZGICfGRiAoBkYgKEZGIDPcoAA2AYAgosZGIAB
-gowZGICxEQCGg7ixGRiAshEAhoO4shkYgLMRAIaDuLMZGIDgfvHA4cUA3c9wgAAoBaCoz3CnAJhH
-uqDh/0oLgADPcKcAFEiooK0Cj/PxwDYKj/PPdYAA2AYChVEgAIAW9CoOb/8H2G4IYAAIdhoKQABW
-C0AAlgtAAEoJQACOD2//yXAChYC4AqVlAo/z8cDhxc91gADYBgKFUSBAgAz0Sg2AAOoLz/OyDAAD
-Ug3AAAKFgbgCpUECj/PxwMoJj/PPdYAA2AYChVEggIAu9M9wgAAwdAeIgOAo8s9zoADALxOD+rgG
-9BCDUSAAgA70/BMFAAohwA/rcgXYiiNGDaUGb/KKJAIBhg1v/wfY6gzgAAh2ugjAAM4MwADyDm//
-yXAChYK4AqXJAY/z8cDPc6AAwC8Tg/q4BfQQg1EgAIAN9PwTBQAKIcAP63IF2IojRg1VBm/yiiQC
-DL7/zf/PcIAAMHQHiIDgBPIyCEAA1P/RwOB+z3GsANQBsREAhqO4sRkYgLIRAIajuLIZGICzEQCG
-o7izGRiAAtifGRiAoBkYgKEZGIAB2KIZGICjGRiApBkYgKUZGICmGRiApxkYgAXY+BkAgPwZAIAA
-oeB+4HjPcKsAoP84gM9ygADYBiCiOYAA2yGieKB5oD/ZOqDgfvHAigiP8zpwAdjPdqcAFEgIpmYI
-oAAqcIDgAN8qcAb0SiBAI9j/CPDGCKAAGnd+CqAAKnDr///Ym7jPdacAmEccpYogEg3CDm/zKnHP
-cYAAKAUAiYDgyiHCD8oiwgfKIGIByiOCDwAADQPKJCIASAVi8solAgEB2ACp9qYvIAAEgLgapWUA
-j/PxwOHFocG4cADYQMBTJYAAgeAQ8oLgHfKE4CLyCiHAD+tyBdiKI4sGBQVv8ookgw/PcIAAMHQE
-kAHZz3WAAOuPhODAec9wAAAi0jR4DvDPcAAAI9LPdYAA7o8I8M9wAAAk0s91gADxjynZErnwIQEA
-DiGADwABAACSCeAAQMBAwItwqXESDa/zA9r5B2/zocDxwHYPT/PPcKYAnD8ZgFEgAIBU8s92gAAc
-D4QWABAvKAEATiCQB0Eo0CBMIICgCfcAII0vgACMDxSNgOAN9AohwA/rcgXYiiONAIokgw9RBG/y
-CiUABM93gADgj0AnwBJiCK/zCdkA2PYOYAAPIAAEgOAA2A8gAAQD9L7/A/DWCIAAA8gA2bkQgAAb
-eIC4Cq8UjWG4D3gUrYogUg1SDW/zDyEBBIQWARDPcIAArIA2oM9wgADUsiKgGv8hB0/z4HjPcQEA
-uMLPcgEARMOlBu/zANjgeIDg8cC4cQv0CiHAD+tyBdjU27kDb/KKJIMPz3GAANScIIFMJQCABCGB
-DwAHAABBKQMGANnKJE1x4HjoIK0D8CBFAAQlgg8BAADALrplelBzBPQB4UEFz/8KIcAP63IF2N3b
-aQNv8kokQADgeM9wgAAcDwiAz3GAANScUSAAgATyAYkD8AKJ4H8AqeB4CHFYiQGAgOICoQn0WYmA
-4sIgogDAIKEAAqHgfvHA/g1P86LBooFgkM92gADYBrh7o4FkfWOGpXumgQGQuHingWOmpHikhkAh
-DwSA4qV4BKYc8gGBAhzEMDC7BBzEMAAcBDAggYt1YHmpcAGHJIYCHEQwMLkEHEQwIIcAHAQwYHmp
-cADYA6YEpvkFb/OiwOB48cB2DU/zocEAFo1AABaPQAAWAEGCCW//B9gacILlBtkD9Pt5B+EFzAPh
-BCGBDwAA/P/XcAAAAEAB2MIgCgAXuMdwAA4AACV4nbifuOxxAKECEgE27HAgoOxwoKjPdqAAyB9R
-FhGWAdlRHliQINgQpkMeWBAA2A4Jr/ONuCDYEaaH5ZYBDQAyJk1zgADEX0AngHK0eAB4ABYBQAAW
-AECAuc9woADsJyagqfCA504BDgAAFgBBABYBQQAcRDAAFgFAGgsgAGG/ABQBMQa4gbgQuSV4z3Gg
-AOwnBqGA5yr3j/DscOCogOcWAQ4AABYAQAAWAUDqCiAAEHgGuEUgwgDPcKAA7CdGoAqAi3EAsQAU
-ATHscCCwYb+A5yn3cfAAFgBAPg4AAM9xoADsJwuhABYAQGXwgOfGAA4AABYAQAAWFEBBKBMEEHiW
-CiAAWnAGuEUgwADPdaAA7CcGpQqFi3EAsQAUADEGIMAEBSAABQAcBDBqCiAASnAAFAExBriBuBC5
-JXgGpWG/gOewB83/N/CA52oADgAAFgBBABYBQQAcRDAAFgFANgogAGG/ABQBMQa4RSCAARC5JXjP
-caAA7CcGoYDnKvcb8IDn2fcAFgBBABYBQQAcRDAAFgFAAgogAGG/ABQBMQa4RSDAARC5JXjPcaAA
-7CcGoYDnKfdRHliUGglv/wpwrg9v8wHYANh0HhiQuQNv86HACiHAD+tyBdiKI4YBSiQAAIkAb/IK
-JQAB4HjxwE4LT/MAFo1AABaQQAAWAEFWDy//B9g6cILlBtkE9EAgwSEFzAPhBCGBDwAA/P/XcAAA
-AEAB2MIgCgAXuMdwAA4AACV4nbifuOxxAKECEgE27HAgoOxwoKjPdqAAyB9RFhKWAdhRHhiQIN/w
-pkMeGBAA2N4Ob/ONuPGmheXWAA0AMyZNc4AAzF9AJ4BytHgAeAAWAUDPcKAA7CcmoFHwTCAAoJoA
-DgAKJAB04HioIEACABYBQM9woADsJyagQfDscAAYAgRMIACgdgAOAAokAHTgeKggwAIAFgFAz3Cg
-AOwnJqAqgOxwIKgr8AAWAUDPcKAA7CcroCPwTCAAoMokDXTgeOggbQcAFgNABCOBDwAAAP8ouVZp
-RSLNAM9xoADsJwQjgA//AAAApqGqgTC4OLuBugZ9pXsQu2V6RqFRHpiUpg8v/ypwOg5v8wHYXQJP
-8wohwA/rcgXYiiNIA0okAAAdBy/yCiUAAeB4AtjPcawA1AGfGRiAoBkYgKEZGIAB2KIZGICjGRiA
-pBkYgKUZGICmGRiApxkYgAXY+BkAgPwZAIAAoeB+4H7geAHZz3CgAMgcMKBL2c9wpAAcQCSg4H7g
-ePHAgglP8zpwGnFKI0AgwJAl8Ol2I/AVIcAk4JACEBIBQCNTINd3AAD7/y8jyCRz9td2AAD//x7y
-TCAAoMwmgZ8AAP7/FvJMIECgzCaBnwAA/f8Q8kwggKAI8s9wAAD7/xB22/VxAU/z13YAAPz/9/XP
-daAAyB9RFRSWAdlRHViQINgQpUMdWBAA2AYNb/ONuCDYEaUGv4G/QCoAJOV4z3GgAOwnBqFRHRiV
-2fHxwM9wgAAwdEaAguIqkAb0z3CAAOg6BfDPcIAA/DbO/6YMAABWDQAA0cDgfvHA4cXPcYAAMHQE
-kc9ygADUnIDgANtgohHygeAn8oLgPvIKIcAP63IF2IojSwdKJEAAsQUv8kolAAAH2Bi4AKJhqmKq
-SiTAcGhwqCAAAwDbjrsWIg0AYaUD2w67YqUB4APYBrEHsQDYF/AA2Jm4AKJS2AGqSiTAcAKqqCCA
-AgDdj70WIsAAoaCioAHjUtgC22axAdtnsaEAb/MAqgDYmLhKJMBwAKKoIIACAN2OvRYiwAChoKKg
-AeNh2AGqUtgCqufx4HjxwGILYAChwc9wgAAwdEeIgOIA2Y/yABxEMM9zoADALzOD+rkF9DCDUSEA
-gA30/BMFAAohwA/rcgXYiiNGDeEEL/KKJMsMA9vPcqAA7CdmomqCi3FgsQAUBTGodIQkA5DKIcIP
-yiLCB8ogYgHKI4IPAAD6AqgEIvLKJGIARCUDDES7ZLBEJQMDQrsvJsfwa6gD9AHba6hD22aiaoJg
-sQAUBTEUGEQBTCUAgMwlYoDMJaKAyiHCD8oiwgfKIGIByiOCDwAADgNYBCLyyiRiAIPbZqJqgmCx
-ABQFMVMlgwBosIfjzCMigMwjooHKIcIPyiLCB8ogYgHKI4IPAAAYAyAEIvLKJGIAiiPSAGaiSoJA
-sQAUBTFTJYEAh+EpsA/yCiHAD+tyBdiKI8wH9QMv8kokQAAksAfZKLApsKHA0cDgfvHAz3CAADB0
-BoCA4BHygeAW8oLgFvIKIcAP63IF2IojjQBKJAAAuQMv8golAAGA2c9wgADUnMUF7/8noADZ+vFA
-2fjx8cDPcIAAMHQEkIDgEfKB4MwgooAR8gohwA/rcgXYiiNOCUokQAB1Ay/ySiUAAM9xKhUVKgTw
-z3EqKhUVz3CAACwFdQXv/yCg8cDPcYAAMHQkkYDhRfKB4Q/yguEw8gohwA/rcgXYiiPPBUokQAAt
-Ay/ySiUAAAQggQ/z///PBCGADwMAAAACuAUhAgAEIYEPAAAADAQggA8AAAAMJXjPcYAAHA8ogQK4
-USEAgEV4GfQHIIAPDwAAAP0Ez//PcYAAHA8ogVEhAIAL9AQgvo8MAAAA0iCiBOAE4v/SIOIE2QTP
-/+B4ANnPcKAA7CcroOB+4H7gePHAgg0P8893oACsLxiHz3WgAMgfmrgYpyDYEKUF2EMdGBAA2FYJ
-b/ONuCDYEaUD3hHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhvowm/5/t9RiHs7i6
-uBinINgQpWTYQx0YEADYDglv8424INgRpXEFD/PxwAIND/MId891oADIH1EVEJYB2FEdGJAg3tCl
-Qx0YEADY3ghv84240aUglwGXBrmBuRC4JXjPcaAA7CcGoVEdGJQlBQ/z4HjxwL4MD/PPdaAAwC8T
-hc92oADIHyDfs7i6uBOlZNjwpkMeGBAA2JIIb/ONuPGm8KYF2EMeGBAA2H4Ib/ONuPGmE4X6uAX0
-EIVRIACADfT8FQUQCiHAD+tyBdiKI0YNhQEv8ookzQYGC4//BgzP/gTIhOAM9M9xgABYskiBNJFT
-IgAA3g/v8gHbnQQP84ogVwehAi/ziiENA/HAJgwv8wHYz3WgAMgfURUPllEdGJAg3tClQx0YEADY
-/g8v84240aXPcYAABiHPcKAA7CcmoM9xgABGOiagz3GAAMZTJqDPcYAAxiQmoM9xgAAGPiagz3GA
-AIZXJqBRHdiTz3GnAIhJANgQoSEED/PPcIAAByHPcaAA7CcGoc9wgABHOgahz3CAAMdTBqHPcIAA
-xyQGoc9wgAAHPgahz3CAAIdXBqFJ2c9wpwCISTCg4H7gePHAbgsv8wHYz3agAMgfURYQllEeGJAg
-3bCmQx4YEADYSg8v8424sabH2JS4z3egAOwnBqfPcAMAgisGp89wAwDCRAanz3ADAEJeBqfPcAMA
-AiwGp89wAwBCRQanz3ADAMJeBqfPcQAAwnTPcAMAwnQGp89wAwCCbwanz3ADAIJsBqfG2JC4Bqcm
-p7CmCthDHhgQANjWDi/zjbixps9wAACCbwansKYK2EMeGBAA2L4OL/ONuLGmz3AAAIJsBqewpgrY
-Qx4YEADYog4v8424sabPcAAAAiwGp7CmCthDHhgQANiKDi/zjbixps9wAABCRQansKYK2EMeGBAA
-2G4OL/ONuLGmz3AAAMJeBqewpgrYQx4YEADYVg4v8424sabPcAAAgisGp7CmCthDHhgQANg6Di/z
-jbixps9wAADCRAansKYK2EMeGBAA2CIOL/ONuLGmz3AAAEJeBqewpgrYQx4YEADYBg4v8424sabP
-cBMAxgAGp7CmMthDHhgQANjuDS/zjbixplEeGJRJAg/z4HhRIACAz3KAAOwGC/KA4VHYwCgiBMog
-YQTAKCEEAvAA2OB/AKLxwL4JL/MB2M91oADIH1EVD5ZRHRiQIN7QpUMdGBAA2JYNL/ONuNGlz3AA
-AMIsz3GgAOwnBqHPcAAAAkYGoc9wAADCXwahUR3Yk90BD/PgePHAbgkP889xoACsLzqBUiEBAFEh
-AIA+9IDgHvIg3Xj/z3agAMgfURYPlgHYUR4YkLCmQx4YEADYLg0v8424sabPcQYAAnXPcKAA7Ccm
-oFEe2JME8MYPT//PdqAAyB9RFg+WAdhRHhiQIN2wpkMeGBAA2PYML/ONuLGmz3CAABwPD4DPcaAA
-7CeAuAahUR7Yk0UBD/PxwNYIL/MB2c91oADsJyalgODPcqAArC8S9BiCz3WgAMgfIN6auBiiBdjQ
-pUMdGBAA2KIML/ONuNGlQPAVglEgAIDKIcEPyiLBB8ogYQHKIyEPyiTBAKgF4fHKJcEAz3DAAEdo
-BqXPcBMAxwAGpc9wEAAGaQalIN/H2JW4BqXPdqAAyB9RFhCWUR5YkPCmQx5YEADYPgwv84248abP
-cAAAQi0Gpc9wAACCRgalz3AAAEJgBqVRHhiUgQAP8/HA2HBTIIEAz3CAADhbKGCB4A7yCiHAD+ty
-BdiKI4UPiiSDDx0F7/EKJYABz3GAADB0CBEFAUwlAIAM8gohwA/rcgXYiiMGAPkE7/GKJIMPz3CA
-ABwPCIBRIACAC/QIkYDgB/KG4Af0USYAgAPyANgC8AHY0cDgfrhwwriB4PHADvKC4CLyhOA28goh
-wA/rcgXY/9utBO/xiiSDD89wgAAcDwiAz3GgAOwnUSAAgMoggg8DAAYhyiCBDwMAxiQGoc9wBABG
-Sy3wz3CAABwPCIDPcaAA7CdRIACAyiCCDwMARjrKIIEPAwAGPgahz3AEAMZkF/DPcIAAHA8IgM9x
-oADsJ1EgAIDKIIIPAwDGU8oggQ8DAIZXBqHPcAQAxjEGoarx4HjxwPoO7/IB2M92oADIH1EWD5ZR
-HhiQIN2wpkMeGBAA2NIKL/ONuLGmz3CAAMcgz3GgAOwnBqHPcIAABzoGoc9wgACHUwahz3CAAIck
-BqHPcIAAxz0Goc9wgABHVwahiiCKAAahiiCLAAahiiCMAAahz3AkAAcBBqGKIIUABqHPcAMAByEG
-oc9wAwDHJAahz3AEAEdLBqHPcAMARzoGoc9wAwAHPgahz3AEAMdkBqHPcAMAx1MGoc9wAwCHVwah
-z3AEAMcxBqFRHtiTmQbP8uB48cChwc9xgAAcDyiBLygBAMC5ACGDDwAAItJOIIEHKdgSuPAgwADP
-coAA6480eVlhQMCLcIILL/MD2qHA0cDgfvHA4g3P8hpwz3WgAMgfURURlgHeUR2YkyDf8KVDHZgT
-ANjCCS/zjbjxpc9wLAAGAc9xoADsJwahUyCAIIHgEvKC4CzyhOBH8gohwA/rcgXYiiPFDIokgw+1
-Au/xCiUABM9wgAAcDwiAUSAAgMoggg+AAMYgyiCBD4AAhiQGoc9wAwDCAgahz3BIAEIBBqHPcKcA
-FEjXoDvwz3CAABwPCIBRIACAyiCCD4AABjrKIIEPgADGPQahz3ADAAIDBqHPcEoAQgEGoQLZz3Cn
-ABRIN6Ad8M9wgAAcDwiAUSAAgMoggg+AAIZTyiCBD4AARlcGoc9wAwCCAgahz3BMAEIBBqHPcacA
-FEgA2BehUR1YlDUFz/LgeIC4z3GgAOwnBqHgfgnZ4H8goOB48cAyDS/zKNgIcYYh/AMkuc9ygAAw
-dCCyRCABAyK5IbLBuPkE7/8CsvHA4cUGDS/zANhBKAECwLnPdYAAMHQmrSm4wLgHre4ML/NQ2MG4
-7QTv8gal4H7gePHAagzv8gHYz3agAMgfURYPllEeGJAg3bCmQx4YEADYQggv8424sabPcCAABgHP
-caAA7CcGoc9wcACCAgahUR7Yk5EEz/LgeM9xIAAHAc9woADsJyag4H7gfuB44H7geM9wgAD0PeB/
-E4DgePHA+gvP8gh3GnEB2c9wpwCYRzqgIN7PdaAAyB/QpQrYQx0YEADY0g/v8o240aXPcacAFEgM
-gYDgA/Q+gQLwPYEAGEAg97nFIYIPAP8AANMh4QUNBO/yIKfxwKILz/LPcIAAMHQmiIDhz3aAAPQ9
-0AIhAKLBB4iA4MQCAQCKIJEF8gnv8gDZhg+v/gXYDqbD2M91oADsJwalCoXPd6cAFEgAtoogxAAG
-pQqFz3GnAJhHAbaKIMUABqUKhQK2iiDLAAalCoUDtoogzwAGpQqFBLbPcAAAgw0GpQqFBbbPcAAA
-ww0GpQqFBrbPcAAAAw4GpQqFB7YIhwSmDYcFpg6HBqYcgQemF4cIphaHCabPcKUACAwCgAqmz3Cr
-AKD/GIALps9wqwCg/xmADKbPcKsAoP8agA2mz3AFAMYDBqXG2JC4BqXPcCwAAgEGpc9wWgBCAQal
-iiCLAAalz3BAAIcNBqXPcNEAwg0Gpc9wwAAHDgalAdgIpwDYDacOp89wUAD/AByhAdgXpwDYFqfP
-cKUACAxQ2SKg/NjPcasAoP8YoXPYGaEagYG4GqHPcBEABg4GpYtwgcGT/zWGAMAieIQohAMUhjaG
-AnkKDG/7L3ABwoIgxALPcYAAAIMWoRKmz3CgAMgfVaFREBCGAdlRGFiAINjPcaAAyB8QoQHYQxkY
-AADY9g3v8o24INnPcKAAyB8xoM9wQACGDQalz3AQAAIOBqXPcKAAyB9RGBiEi3CBwXX/NYYAwCJ4
-BCiADwAAdAkUhjaGAnmKC2/7L3ABwk/gz3GAAACDGKETplehz3CgAMgfURAQhgHZURhYgCDZMKAB
-2UMYWAAA2IIN7/KNuCDZz3CgAMgfMaABlhC4hSCEAAalApYQuIUghQAGpQOWELiFIIsABqUElhC4
-hSCPAAalBZYQuAUggA8AAIINBqUGlhC4BSCADwAAwg0GpQeWELgFIIAPAAACDgalz3CgAMgfURgY
-hASGKoYIpwWGgOENpwaGDqcIhhenCYYWp89wpQAIDCKgDfIEEgQ2AhIFNgohwA/rcgXYDQav8fvb
-C4bPcasAoP8YoQyGGaENhhqhXg6v/g6GiiDRBT4Pr/IyhhKGIQHv8qLA4H8B2PHArgjP8s9wgAAw
-dAeIgOCcAiEAosHPcKAAyB9REBCGAdlRGFiAINkwoAHZQxhYAADYfgzv8o24INnPcKAAyB8xoIIM
-r/4F2M91gAD0PQ6lw9jPdqAA7CcGpgqGz3enABRIALWKIMQABqYKhgG1iiDFAAamCoYCtYogywAG
-pgqGA7WKIM8ABqYKhgS1z3AAAIMNBqYKhgW1z3AAAMMNBqYKhga1z3AAAAMOBqYKhge1CIcEpQ2H
-BaUOhwalz3CnAJhHPIAnpTeHKKU2hymlz3GlAAgMIoEqpc9xqwCg/ziBK6XPcasAoP85gSylz3Gr
-AKD/OoEtpc9xBQDGAyamxtmQuSamz3EsAAIBJqbPcVoAQgEmpoohiwAmps9xQACHDSamz3HRAMIN
-JqbPccAABw4mpgHZKKcA2S2nLqfPcVAA/wA8oAHYF6cA2BanUNnPcKUACAwioPzZz3CrAKD/OKBz
-2TmgGoDPcasAoP+BuBqhz3AqAAIOBqaLcIHBz/4Awc9wgAAAgzSlMqABwS+gz3AaAAIOBqaLcIHB
-yP4Awc9wgAAAgzWlM6ABwTCgz3AmAAIOBqaLcIHBwP4Awc9wgAAAgzSgNqUBwTGgz3CgAMgfURAR
-hgHZURhYgCDZMKAB2UMYWAAA2MoK7/KNuCDZz3CgAMgfMaABlRC4hSCEAAamApUQuIUghQAGpgOV
-ELiFIIsABqYElRC4hSCPAAamBZUQuAUggA8AAIINBqYGlRC4BSCADwAAwg0GpgeVELgFIIAPAAAC
-Dgamz3CgAMgfURhYhASFKoUIpwWFgOENpwaFDqcIhRenCYUWp89wpQAIDCKgDfIEEgQ2AhIFNgoh
-wA/rcgXYVQOv8fvbC4XPcasAoP8YoQyFGaENhRqhpguv/g6Fz3CgAMgfURgYhGEGr/KiwOB44H7g
-eKHB8cD6Da/ymHDPcIAAuJwQEAYAz3CAAFA+BYC4cYDgocGGJfcPhvLPcoAA8AYFgtBwCPQGgpBw
-BPQHgrBwevIAHAAxIMMBFIAww7tTIMgAAhSAMEAuwQBTIMkAeGMUeDZ5OGDPc4AANKIOY0wlAIDJ
-dYYl/R+7fXhg4YgFJYcT6XCGIP0PG3gFfwAgDhLUfj5m2GMCiH5mCHWGJf0fu33DjgUlCBDJcIYg
-/Q8beAV+ACFAEhR4GWE4YwSIO2MIdYYl/R+7fWWLpXhocYYh/Q87eSV7GvLPdaoA4AczhVEhAIAL
-8uilJB3AEcqlLB0AEmylDaUY8CAdwBHppSgdABLLpQylbaUQ8Am/BSfBEc91pwAUSCOlCb4FJgES
-JKUJu2V4BaUUGoABGBoAARwaQAEI3DcFr/KhwACIAdtgoWi4ArgVeMdwgABQPkOAQ6FBgEGhQoBC
-oUSARKHgf2Cg4HjPcYAAQD/PcIAAzD7gfyKgUQIP9eB+4HjPcAEATNjPcYAATClhGRgAz3ABALwq
-gOBVIUMHQCECAwXyEaMbgZG4G6HPcAEA/NiA4AbyCKMbgYi4G6HPcAEAON6A4AXyHaIbgYO4G6Hg
-fvHANgyv8kokAADPc6UACAwIEwUATCUAgMohwg/KIsIHyiOCDwAAPAIwAaLxyiBiAUDYAqPPcIAA
-uJyggM9ygABAP4okgXSIcagggAOELQIaL3AeYvQmThDPd6YAAIA1fwHhwKfHcIAAuD9WkM9xpACg
-P12hF5AeoQgbQAEhBI/y8cCyC4/ypcEIdyh2tg9v/gfYGnABhgzdBBwEMAQXARQGHEQwMLkIHEQw
-EBYBFGB5gcABhmG9DBwEMAEXgRQOHEQwMLkQHEQwEBYBFGB5g8CA5TH37giv/gpwvQOv8qXA8cBW
-C4/yz3CAAFA+AICA4JLyz3agAMgfURYPlgHYUR4YkCDdsKZDHhgQANgiD6/yjbixps9w0QBCLc9x
-oADsJwahz3DRAIJGBqHPcNEAQmAGoc9wgAAgNlEe2JMQiIYg/wFDuClohuHMAA0Az3WAALicBIUz
-JkFwgADUX0AngnQGuBR4NHrHcIAA9JwAes9xgACQQE/wz3GAAGBBEOBL8M9xgAAwQiDgRfDPcYAA
-kEAw4Lz/BIXPcoAANJ3PcYAAYEEGuBR4NvDPdoAAdJ3PcYAAkEBw4LP/BIXPcYAAMEIGuBR42GAn
-8M9xgABgQVDgrP/PcoAAVJ0EhRfwz3aAAJSdz3GAAJBAgCACBKX/BIXPcYAAYEEGuBR42GCh/wSF
-z3KAAKSdBrgUeM9xgAAwQlhgnP+JAo/y8cAeCq/yAdjPdaAAyB9RFQ+WUR0YkCDe0KVDHRgQANj2
-Da/yjbjRpc9ygADwBgCKz3GgAOwnELgFIIAPAADCaQahAYoQuAUggA8AAAJqBqFRHdiTMQKP8vHA
-xgmv8gHYz3WgAMgfURUPllEdGJAg3tClQx0YEADYng2v8o240aXPcIAA8AYikIa5ELkFIYIPAADC
-Es9xoADsJ0ahA5AQuAUggA8AAAITBqFRHdiT2QGP8uB48cBuCY/yz3WAAPAGyI0JjcK+wrgWfs9+
-og8v/w3YBriBuBC+xXjPcaAA7CcGoQOFz3GlAOgPBqEEhQehnQGP8vHAKgmP8s92pQDoDyaGp4bP
-cIAA8AYA3yOgpKBeDy//DdgGuIG4z3GgAOwnBqHmpkUlzR+npl0Bj/LgePHA2giP8qLBOnAacQDd
-7gxv/gfYmnAC2alwWnB6cQDbNGgCcSh1FCEAIGhywoUEEA8F2H/DhQHixH+D4uV7IOW29wGBAhzE
-MDC7ABwEMCCBBBzEMGB5i3BCI0EggOG+B+3/QCJAIBYOb/6KcMEAr/KiwOB48cDPcIAAUD4PgIDg
-D/LPcIAAuJwEgM9xgACQQ89ygAAspAK4FHhYYNn/0cDgfuB48cA6CI/yz3CAAFA+FICA4IXyRgxv
-/gfYenDPcIAAIDYQiIYg/wFDuClohuHoAA0Az3aAALicRIbPcIAArKQzJkFwgADcX0AgEAsEulR6
-QCARCkAgEgZAIA8IQCANBFhgQCcCcjR6AHrPcYAA8ENR8M9xgAAQRATgS/DPcYAAMEQI4Efwz3GA
-APBDDODCCS//ANoEhs9xgAAQRAS4FHi4YDfwz3GAAPBDHOCmCS//ANoEhs9xgAAwRAS4FHj4YCnw
-z3GAABBEFOCGCS//ANoEhs9xgAAwRAS4FHhCcBnwz3GAAPBDJOBqCS//ANoEhs9xgAAQRAS4FHgi
-cFYJL/8A2gSGz3GAADBEBLgUeAJwQgkv/wHawgxv/mpweQdP8uB48cAKJQCAz3GAAPAGIBEEACPy
-TCQAgM9ypAC4PQDbDvSbEgAGCaGmEgAGCqGSEgAGC6GjEgAGDKGbGtgA/9imGhgAkhoYAKMaGAAB
-2s9woAC0D1ygJvBMJACAyiHBD8oiwQfKI4EPAAAwBOQDYfHKIGEBCYHPcqQAuD2bGhgACoGmGhgA
-C4GSGhgADIGjGhgABMjPcqAAtA+GIP8OIrgcoiAZQAEb8eB4vQSP8rkEj/LgfuB48cByDk/yosEI
-dyh2SHV2Cm/+B9iA5xpw0vcBhWG/ABwEMAQWARQCHEQwMLkEHEQwEBUBFGB5i3CA5zH3xgtv/gpw
-lQZv8qLAz3CAALicIIADgIDhRCh+AwAhgH+AAORfA/IMiAPwxBCAAOB+8cDhxc91gAC4nOoP7/6p
-cLhwAIWA4BLySiSAc89zgADkXwDZqCBAAkQpfgMyI0IOsHIg8gHhFPAA2UokgHnPcoAAjGCoIAAD
-WSJDBUQpfgMnc7gTgwCwcwzyAeEKIcAP63IF2IojBQXFAm/xSiSAAhEGb/IocOB4gOHhxQXyz3KA
-AGBFBPDPcoAAUESA4wr0gOEI8gHZz3CmAKQAN6AQ8EokQHQA2aggAAMWIkAAoYBggCnYErgB4XV4
-oKDgf8HF8cBGDU/yocEacCh2SHWKIBEFrgtv8oohyQGKIBEFogtv8gpxiiARBZYLb/LJcYogEQWO
-C2/yqXHPcKAALCBQgM9xgAAkB0KhUIBigWJ6QaFAKIMhRSPPAM9zoADsJ+ajaoOLcmCyQYFQdQAU
-DzHI98R/8Xbq9TUFb/KhwM9wgAAMDaqAz3CAALicDBAEAAohwA8QvetyEL8F2IojCQQFJEQDzQFv
-8QUnhRPgePHAmgxP8qHBz3GAAAwNCoEg3QHgCqHPcKAAyB9REBCGAdlRGFiAsKBDGFgAANhqCK/y
-jbjPcKAAyB+xoM9wwABHaM92oADsJwamz3GAAMw+BIGB4BP0BoHPd4AAuJxAeBgXhRBMJQCAFfTP
-cAEABgEGps9wEgAGBBTwCiHAD+tyBdiKI0YDSiQAADkBb/EKJQABz3ABAAcBBqbPcBIABwQGpgAX
-BBDPc4AA5F/PcgAAAjNMJACAz3EAAIJMA4cY8kQofgMAIc1wxtiSuAamz3A5AAIzBqbPcDkAgkwG
-ps9wOQACZgamx9iVuBLwViPNBUQofgMndcfYkrgGpkamJqbPcAAAAmYGpsbYlbgGpgfZz3CnABRI
-K6AsoM9xqgDgBwHYE6EBh1mPqHGIc3j/z3AQAIdyBqYBjRC4BSCADwAAQnIGpgWNELgFIIAPAABC
-cAamBI0QuAUggA8AAIJwBqYDjRC4BSCADwAAwnAGpgKNELgFIIAPAAACcQamCY0QuAUggA8AAEJx
-BqYIjRC4BSCADwAAgnEGpgeNELgFIIAPAADCcQamBo0QuAUggA8AAAJyBqYLjRC4BSCADwAAgnMG
-pgqNELgFIIAPAADGcwamz3ABAEZqBqbPcKAAyB+kEA0Az3CAAAZ0BqbPcIAAB3QGps9wgADGcwam
-z3BAAEJ0BqbPcIAAx3MGps9wAgBGagamz3AQAMZqBqZYjwCPJI+A4gHawHqCCyACeY8k2BjZM9pJ
-/89wEADHagamz3AQAIZyBqYGDwAC9gtAAiTYAdkz2kH/z3CgAMgfpBAAAM9xgAAMDaJ4CaHPcAIA
-R2oGps9wZQDCbgamz3AAAMMJBqYKhotxALEAFAExgOHMIeKHMfSCCG/yiiCRBM9xgAAkBwCRAeAA
-sQGRgeAR9M9wgAAMDSgQBAAAFAUxCiHAD+tyBdgBBy/xiiNIDILgE/TPcIAADA0oEAQATCRAgMv3
-ABQFMQohwA/rcgXY2QYv8YojSA3PcKAAyB9RGBiEzwTP//HAoglP8s91oADAL9OF+r4F9NCFUSYA
-kA30/BUFEAohwA/rcgXYiiNGDZkGL/GKJAkIz3WAALicAKUhpVitea3V/gOly/4Epf4N7/cA2M9w
-gAAwdAeIgOCoDML/sQFP8uB+4HjxwDoJb/KA2KHBYMAFzAQSBTYCHAQwTCUAgQDYARwCMAryABQE
-MAohwA/rcgXYMQYv8YHbz3CAAIAHAICA4AACAgBqCg/+gOD0AQIAz3CAAFwuAIBRIACB8vSKIAoP
-Ug8v8gISATaGCoAAz3CAACCmBg9v8oohCw/PcIAAIKYFkM93gAAwB4YgfwwceFMggIAE9AOHhrgD
-p892gAAYqvzcAiYAE9IOb/IY2c9wgAAgpi6QwNwCJgATvg5v8ni5wNxAFoWQAiYAE0wlAIAHpwvy
-CiHAD+tyBdiq24UFL/GKJIMPQRaNkEAlhRBAJYAfTCWAiA94IB8CEMr3CiHAD+tyBdiw21kFL/GK
-JIMPwNwCJgATz3GAAPylrg1v8qhyz3CAACCmDpDPdYAAHK4AtwDZKfAAFgJAz3CAAISrNXhAoAAW
-AkHPcIAABKw0eECwABaAQFJpVHrHcoAA9KkQqhGqEqoAFoBAFKoVqhaqABYAQc9ygAA4rDV6BrIA
-FgBBAeEHss9wgAAgpgOIEHGmB8X/z3CAACCmdgmAAloJb/ET2AIIr/wE2ALIqh0YkM9wgACAByCA
-z3WAAIQHAIUYuRC4BXmIueoNL/KKIIsAAdnPcIAAgAcgoADYAKU+Ca/yAMDPcoAAsK8AguG4QvLP
-cYAATLU0iYfhIfTPc4AAtH/PcYAAZLXGkbaL0XXPcYAAWLIH9MQRDQZ0i8C9cHUK8sURAwZRI0CB
-BvIpgVEhQIEF9ALZqRpYAIO4AKIa8M9xgACIRgSBAeAEoc9woADUAxyQmgiP8gDAwgiv8gLZJgig
-AALYiiBKD0oNL/IA2TUHL/KhwOB48cDCDg/yz3aAADAHA4bPdYAAhAcvKAEgiiALAR4NL/IghSOG
-UCEMAKe8UCQMkgDfBvKqCKAATiDAJxzwKHSEJAaQG/IJhoHgBvSSCKAATiDAJ+mmA4aGIAYAA6aK
-IEsA2gwv8gDZCoaA4ATyQHjqprUGL/IB2ACFgOCq9FEhAICK9AiOz3GAAISrAdrwIQEAArgmelR4
-z3GAAESsEGEKuAymx3AAAAAY3gjv+kogQCAId89wgABYsroQAQbPcIAAiH40eBGIgOC+DmABwiAC
-JIDnzCAioMwgIoBQ8s9wgAD8q0SQz3CAAMgGAJAQcs9xgAAcDxn0z3eAACCmBYdIgVMgBABTIgMA
-kHMP9GOPgePEIIEPAAYAAMQigQ8ABgAAzCCBgAPyANgC8AHYSYEPps92gACAB2CGUSJAgUCFAN8Y
-uxC6RXsR8oDgD/QYiYPgC/RPI0EC5gsv8oogiwAC2ACm4KWG8U8jAQKJuc4LL/KKIIsAA9j28YDn
-B/SKIAsIiiHFCiHwz3GAAJAMF4EB4BehcPF6DmAAAdjPcIAAWLIJgCW4Cg9gAcC46g4v8RPYCg5v
-/ATYwg5AAM9wgABsrDaAiiDKD3YLD/JU8QohwA/rcgXYiiOGA0okgAANAi/xuHPgePHA4gwv8oog
-SwGkwc92gACEB0YLL/Ighs91gAAwBwOFCHSEJIaQIIYb8oDhaAri/MogIgEA30QdwhPPdYAAgAcA
-hSCGGLhAKQIEBXqIuoogiwAGCy/yRXkB2AClgvCA4UT0D8gEIIAP////Aw8aGDCKIMsA4gov8gDZ
-IIbPd4AAgAcAhxC5GLgFeYUhSADKCi/yiiCLAALYAKcB2ACmRBWAEIDgCfTPcKAALCAQgMdwBwAg
-oRClQBUHEM9wAQCk9UDABNhBwAHfQscA2EPA6XAG2QTaANuYc7hzUgnv/NhzANhEHQIQPvCB4SD0
-A9i2Dq/6C7iA4AHfFvREHcITmgnv/ATYIIbPdYAAgAcAhRC5GLgFeYi5Qgov8oogiwDgpQDYAKYB
-3x7wguEg9IK4A6XPcoAAiEYGggDfRB3CE891gACABwHgBqIAhRC5GLgFeYi5Bgov8oogiwAB2ACl
-4KbpcOkDL/KkwAohwA/rcgXYiiPHB0okgACNAC/xuHPgePHAYgsv8oogiwHPdoAAhAfGCS/yIIbP
-dYAAMAcDhYYgeY8V8s91gACABwCFIIYYuBC5BXmFIRgAngkv8oogiwAG2AClANgAptbwA9jWDa/6
-C7iA4CCGCPTPdYAAgAcAhRi46PGA4cr0KI3PcIAAOKzPd4AAIKY1eEeQZpCA4gQXBBEDhxvycHLK
-IcUPyiLFB8ojhQ8AABECyiBlAZf3gOAN8hByyiHGD8oixgfKI4YPAAATAsogZgFJ95BzTPcKIcAP
-63IF2IojyAVKJEAAuQfv8LhzgOAN8hBzyiHGD8oixgfKI4YPAAAZAgXYb/cPhYDgHPQLhYDgGPTP
-cKAAyB8B2lOgGIANpc9wgAAErPQgQQDGCC/yiiBLBoogSwa6CC/yLYUB2AulaI3PcYAABKxFh89w
-gAAcD/QhwQBIoGaHNLBpoGWXbbBTIgAAtg3v8QDbKI0Kh89ygAAEqgK5NHl+DG/yWWHPd4AAgAeK
-IEsHZggv8iCHdgxv9AHYLg9AACiNz3CAAISr8CBAAFEgAIAI8s9woADIHwHZM6AYgASlIIYAhxC5
-GLgFeYq5Kggv8oogiwAE2ACnKI0A2ACmz3CAAASs9CBBAA4IL/KKIAsEz3GgAMgfPIH+D+/xiiAL
-BA+FgOAH9ADYegpgAQhxtgvP/QHY1QEP8gohwA/rcgXYiiNJBkokgAB9Bu/wuHPgePHAUgkv8oog
-ywHPdoAAhAe2D+/xIIbPdYAAMAcIjc93gACEq/AnAhDgui3yAdkCuEZ5NHjPcYAARKwQYQq4DKWa
-DK/6JIWA4B3yiiBLCHoP7/GKIckMog6P9SCGz3WAAIAHAIUQuRi4BXmFIVQBWg/v8YogiwAF2ACl
-AKbrASAAANgDhYYgeY8H9ADYhguv+oy4gOAI9M91gACABwCFGLgghtfwz3CAACCmA4AuDK/6LYWA
-4CCGP/IPhYDgO/TPd4AAgAcAhxC5GLgFeYUhGAD2Du/xiiCLAAbYAKfPcYAAiEYAgQDf4KYB4ACh
-KI3PcIAABKz0IEEAzg7v8YogywWKIMsFwg7v8SyFz3GgACwgI4G2Du/xiiDLBYogywWqDu/xJIWK
-IMsFng7v8S2F6XCb8IDhM/ReC0AACI3wJwAQIIbPd4AAgAdAh+C4ELlAKgMGZXkP8oC4BaUA2Aal
-CLoleoogiwBiDu/xRSKBAQbYhfHPcqAAsB8B2BmiHoKFIRQABKUegg6lPg7v8YogiwAF2ACnANgA
-pknwhuFF9EWFz3eAAIAH4Loc8gaFDgxAAACHQIZAKAEGELoIuEV5BXmKIIsAAg7v8YC5AdgAps9w
-gABwRgoMj/WKIEsEANki8IDiCPIvKoEATiKABwal4PEAhxC5GLgFeYUhFADKDe/xiiCLAAXYAKcA
-2ACmAdjPcaAAyB8ToRiBDqU8gYogSwSmDc/xA/CB4QP0Adgd8ILhHfQDhc9ygACIRoS4A6UHgs91
-gACABwHgB6IAhRi4ELkFeYUhGAByDe/xiiCLAAbYAKUA2ACmVQfP8QohwA/rcgXYiiNLCEokgAD9
-A+/wuHPxwM4Oz/GODwABgODKIcEPyiLBB8ogYQHKI4EPAAD4AsokIQDQA+HwyiUhAM92gAAwBwOG
-hiB5jwf0ANhWCa/6jLiA4Bf0z3aAAIAHAIbPdYAAhAcghRi4ELkFeYUhGADmDO/xiiCLAAbYAKaB
-AyAAAN7Pd4AAIKYDh+IJr/othoDgdPIPhoDgcPQshs9wAAABFAghAACZIAoAwgmv+iSGSI7PcYAA
-BKyA4M91gACIRvQhgQAt8pIM7/GKIEsGiiDLBIYM7/Eshs9xoAAsICOBdgzv8YogywSKIMsEagzv
-8SSGiiDLBGIM7/Ethp4LQAAshQDYIR4CEAiOAeEspQHgI48PeDBwRgArAAiuyPAAhQHgAKUyDO/x
-iiDLBYogywUmDO/xLIbPcaAALCAjgRoM7/GKIMsFiiDLBQ4M7/EkhoogywUCDO/xLYbPd4AAgAcg
-h891gACEBwCFGLkQuAV5fwIgAIUhGADODUAAgODPdYAAhAcghS7ySI7PcIAAOKwB31V4BpAKuAym
-z3CgALAf+aAegADbZqYQuQSmz3CAAISr8CCAAIC4BabPdoAAgAcAhhi4BXmFIZABjgvv8YogiwAE
-2ACmBtgApSsCIAAA3oDhoPQMhoYIr/okhoDgE/Ighc92gACABwCGELkYuAV5hSFUAVIL7/GKIIsA
-BdgApuTxKI7PcIAAhKsacPAgQAAB2QZ5A5eA4GrygOFo9AKXCrg6CK/6LoaA4OTyz3KAAEx0N4IW
-giJ4IoJDgkJ5GWEDlzBwqAAFAP4K7/GKIIsEz3GgACwgI4HuCu/xiiCLBM9xgACIRgGBAeAiCmAA
-AaEojgHaAeEvefAgQCAGehJpVHjPcoAARKwQYgDaIR6CEEOPCrhQcSiuDKaG9k4MYAAA3qnwx3AA
-AAAY6g5P+iCFz3aAAIAHQIZAKQMEgOAYumV6DfKFIgwAiiCLAHoK7/FFeQPYAKYA3o3whSIYAIog
-iwBmCu/xRXkG2PbxIIXPdoAAgAcAhhC5GLgFeYUhVAFGCu/xiiCLAAXYAKYApXLwheF09AyGRg9v
-+iSGgOBq8oogywQiCu/xLIbPcaAALCAjgRYK7/GKIMsEUglAAADYIR4CEAiOIIUB4Aiuz3CAAIAH
-AIAQuRi4BXmFIRQA6gnv8YogiwAF2c9wgACAByCgANgApSOPCI4wcCQHyv/PcYAAhKvwIQEAAdoC
-uCZ6VHjPcYAARKwQYQq4DKbHcAAAABjyDU/6z3GAAIAHIIFAhRi5gOAQukV5DvKFIQwAignv8Yog
-iwAD2c9wgACAByCgAN4O8IUhGADPd4AAgAcA3mYJ7/GKIIsABtgAp8ClA/AB3kED7/HJcAohwA/r
-cgXYiiNPAUokgADtB6/wuHPgePHAwgrv8YogSwLPdYAAhAcmCe/xIIUAhYDgQ/QA2c9woAC0Dzyg
-z3eAAIAHiiALBwYJ7/EghzIIj/XPdoAAtH9AhlMiAAD2DK/9No7PcIAAWLIJgCW4wLhqCyABANmK
-IMsD1gjv8TaOz3CgALAfAd7ZoD6Az3CAADAHJKAAhyCFQCgCBhC5CLhFeQV5iiCLAKYI7/GCuQTY
-AKXJcIfwhOCH9GIMr/0B34YIL/EC2KoNj/G+DS/+6XDPcIAAzH+6DQ/yigwv9OlwBMhRIICABfK+
-CI/1DPAA2p66ANnPcKAA/ERBoM9woAC0Dzygz3aAAIAHiiBLB0II7/EghoogCwTPcYAAHA8yCO/x
-NJEghgCFQCkCBgi5ELgFeoogiwAaCO/xRXkA2AClz3CAABwPCYBRIECBIIYX8s9wgAAwBw+AgOAR
-9M9wgAAcDxiIg+AL9Bi5hSEcAOIPr/GKIIsAB9gi8DoLj/3PcIAAIKYEgCCGQIUYuYDgELpFeQny
-z3CAADAHA4CGIDmPCPKIuaoPr/GKIIsA4KYJ8Iu5ng+v8YogiwAI2ACmANgApYEBz/EKIcAP63IF
-2Ioj0ApKJIAAKQav8Lhz8cD+CO/xiiCLAqTBz3WAAIQHYg+v8SCFAIWA4F70z3OAADAH44PPdoAA
-gAfpdIQkhpBAhhC4QCoBBgV5MPQPg4DgK/QIukV5iiCLACYPr/GAuQHewKXPcKAALCCwgM9wAQCk
-9UDABNhBwELGANhDwAbZBNoIc5hwuHAAJYcfBwAgocYNb/zYcIogCwXmDq/xANnJcCzwUScAkAny
-iLnWDq/xiiCLAAHYDfDPcIAAIKYEgIDgC/KLuboOr/GKIIsACNgApgDYAKUS8Ai6iiCLAKIOr/FF
-efjxgeAf9M9wgAAwBwOAhiB5jwT0AdiTBI//wg1v/ATYIIXPdoAAgAcAhhC5GLgFeYi5ag6v8Yog
-iwAB2ACm2PGC4BX0z3KAADAHI4LPdoAAgAcQuIW5I6LPcoAAiEYoggHhKKIghhi5BXnj8QohwA/r
-cgXYiiMRDUokgADRBK/wuHPxwKoPr/GKIMsCz3WAAIQHCg6v8SCFiiDLAs92gAAgpvoNr/EkhiCF
-gOEz9P7Zz3CAADAHIaC+De/6BIYIcc9wgAC8Rj4OT/rPcYAAiEYKgQHgCqEeCe/wE9hCCC/8BNge
-CY/9z3CAAIAHAIAghUAoAgYQuQi4RXkFeYogiwCeDa/xRSHBAAPYAKUB2B3wg+Ed9M9ygACIRguC
-z3aAAIAHELkB4AuiAIYYuAV5iLluDa/xiiCLAAHYAKYA2AClz3GAADAHC6FRB4/xCiHAD+tyBdiK
-I1IJSiSAAPEDr/C4c/HA3gvP8ADY0cDgfvHA4cWjwQh1iiCLAyINr/Gpcc9wgAA4ByCIARxCM89w
-gAACrPQgQABgwc9xoADIHwMcAjAA2AIcAjAB2BOhGYGE2kLAGIEe2wzZQcCLcIYI7/EYu89xgACw
-rwCBo7gAodEGr/GjwOB48cBSDq/xiiCLAM92gACAB0CGz3eAAIQHIIcYuhC5qgyv8UV5AN2gps92
-gAA0BwCGjCDDj6CnB/LPcIAAvEaODE/6z3CAADgHoKjPcIAAPAegoM9wgABcB6Cg/9hdBq/xAKbg
-ePHA4cUIdbYPr/AT2M9wgABYsgmAJbjCD+AAwLjGDu/7BNipcMT/3v+eD0/9iiALADIMr/GpcTEG
-j/HgePHArg2v8YHYocFgwADfBcwBHMIzAhwEMIogiwcKDK/xR9nPdoAAgAeKIIsH+guv8SCGiiCL
-B891gACEB+oLr/EghQCGgOAQ8s9xgAA8BwCBgbgAoc9xgACIRgOBAeADoQHYA/AC2BpwAMAmD+/x
-CnFMIICgOvLPcIAANAcAgIwgw48c8oogCwCeC6/xZtnPcIAAvEaWC0/6/9nPcIAANAcgoCCFQIaK
-IIsAELkYunoLr/FFeeCm4KUAhoDgBPQAhYDgBvJiDo/8gOAQ8oogCwBWC6/xb9nPcIAAPAcAgC8o
-AQBOIMAHuP8pBa/xocDgePHAz3CAAPylQYjPcYAAWKk+Cu/xAuLPcIAAMAcgkM9wgAAgpi6w0cDg
-fuB4z3CAAIAHAICA4MwgYoAE9ADYBfCI4P7zAdjgfvHAdgyP8Rpwz3WAAIAHAIUodoDgSHcG9IDm
-4iCCAzrwiiALAMoKr/GKIYYOiiALAL4Kr/Hpcc9wgAA0BwCAjCDDjwfyz3CAALxGqgpP+s9wgABY
-B89xgAA8B8CgAIEFf+Chz3GAAIhGAoEB4AKhz3GAAFQHABkABAPwugwAAACFgOD99c9wgACEBwCA
-gOD39UkEj/HxwM9wgACABwCAgOAJ8s9xgACIRgmBAeAJoQLYd/+X8fHAz3GAAIAHiiALBi4Kr/Eg
-gW4Nr/AT2BYM7/sE2P/Zz3CAADQHIKCB8eB48cCaC6/xHNkKJACAz3OAAHBGAIPPdYAAIKYgoEAl
-ABcBowiFANmtuAilz3CAAHgHCaXPcIAAHKkDoxjYAqPPcIAAGKoaGESACfTPcIAAWKnPcYAATAcA
-oT/wz3CAAEwHAIABiEQsvghAIIYAz3CAAFOmMiBCDi8mhwHPcIAAUAcC4k96gOIAEIUAAiWAANf2
-ACGOD4AAPKZELL4IFuYyJk4eOGAAII8PgAAcqQHhL3lQccCvAiWAAKz2z3GAABypOGDPcYAATAcA
-oS6VAiGBATB5WWEutQWjDpUpA6/xBKPxwL4Kj/Glwc91gAA4BwCNz3aAAASs9CYBEBYJr/GKIAsD
-z3CAACCmBYDAuA0cAjAAjfQmABAB289xoADIH2PAc6EZgQDaQcAYgQ4cgjBAwBWBDxyCMETDFNlC
-wItwgtoe23IMr/EYu8ECr/GlwOB48cBOCo/xpMHPdYAAOAcAjc92gAAErPQmARCmCK/xiiBLA89w
-gAAgpgWAwLgBHAIwAI30JgAQz3GgAMgfYMAA2AIcAjADHAIwAdgToRmBg9pCwBiBHttBwM9wgABM
-dDuAB4A4YEPAi3AQ2foLr/EYu0kCr/GkwOB48cDSCY/xz3aAAIQHIIaB4QvyCiHAD+tyBdjS20ok
-AADVBm/wuHPPdYAAgAdAhYLizCLigcohwg/KIsIHyiOCDwAA0wAF2Oz1z3CAAMiSIBCAAIHgCPLP
-cIAAIKYCiFEgAIA09ILiAN8O9Bi6ELlFeYUhDADSD2/xiiCLAAPYAKXgpjjwJgtP/c9wgAA8BwCA
-IIZRIACAAIUQuRi4BXkI9M9wgAAgpgSAgOAJ9Ii5mg9v8YogiwAB2OPxi7mKD2/xiiCLAAjY3fEP
-yBC5BSCADwEAAPwPGhgwQCoABgV5CLpFeYogiwBiD2/xgbkC2ACmSQGP8fHA3giP8c92gAAAAACG
-USCAghvyAYZRIICCQNjPIOIHyiCBDwAA0ADPIOEHz3GfALj/HaEEhgHg07gEpgUggA/Q/gAAFqEB
-2c9wgABRByCoz3CAAIAHIICE4Qj0z3WAAIQHYIWB4w3yCiHAD+tyBdiKI8QBSiQAAIkFb/C4c89w
-gADIrCAQgABAKQIGELsIuYHgZXpFeR30z3eAAEgHAIcA2g8iAgDPcIAARAdggEZ7YKCKIIsAng5v
-8UUhgQEG2ACliiBLBI4Ob/EghwjwiiCLAIIOb/GBuQLYAKUAhlEggIIH8gDZz3CfALj/PaBZAI/x
-4HjxwO4PT/HPcYAAPAcAgc91gACAB892gACEB4C4AKHPcYAAiEYFgQHgBaEghQCGGLkQuAV5hSEY
-ACYOb/GKIIsABtgApQDYFQCv8QCm8cDPcIAAIKZEkIDiIfLPcIAAUQcAiIDgG/TPcIAAOAcgiM9w
-gACEq/AgQABRIACAD/TPcYAATHQbgSeBGWEwcgf30g1v8YogywcB2ALwANizAs//8cBKD0/xz3WA
-AIAHABUFEEwlQILKIcYPyiLGB8ogZgHKI4YPAABVAEQEZvDKJKYAz3eAAAAAAIdRIICCGvIBh1Eg
-gIJA2c8h4gfKIYEPAADQAM8h4QfPcJ8AuP89oCSHAeHTuSSnBSGBD9D+AAA2oACFwYUIuCKFBX4w
-dgjyELmKIEsFOg1v8cV5wqUghc9wgACMYvAgQABAeIDg6vMAh1EggIIG8gDZz3CfALj/PaABB0/x
-8cCaDm/xiiD/D891oAA4LseFB6U/2AYLr/IW2SYMj/LHpeUGT/HgePHA4cWKIMoF2gxv8YohRQUS
-DG/yAdjPcKUACAwA3aKgBMiE4EgJQfDPcQAAzAnOD2/wBtgPyAUggA8BAAD8DxoYMATIUSCAgATy
-8gwP9QzwANmeuc9woAD8RCGgz3CgALQPvKDd/74LD/tCDi/9AdjKD2/wAdhxBk/x4HjxwOHF63WK
-IIoFXgxv8YohRASKIIoFUgxv8alxz3WAAIwHAIVRIECAFfQDhVIggAADpQnwz3CgAKggDYDk4PQA
-BQAiDq/xVNhEIAEBA4UwcPL1iiCKBRIMb/GKIYQIBMiE4B30z3GAALR/AYGluAGhz3GAAFiyxREA
-BqW4xRkYAAmBpbgJoSW4wLjPcYAA2JZ+Ce//CqGCCU/xiiCKBcoLb/GKIQQMANrPcKAA/ESeukGg
-z3CgALQPANk8oA/IBCCAD/7//wMPGhgwD8iHuA8aGDB/2Aq4z3GgANAbE6F/2BChANiVuBChz3EB
-AKz9kg5v8AbYz3GgAPA2BIFGIMABBKGU2CoPb/EY2YogigVaC2/xIIUAhVEgQICgDSL7yiAiAIog
-igVCC2/xHHk9BU/xCiHAD+tyBdiKI0QHSiQAANUBb/AKJQAB8cDhxaHBz3WAAIwHRJUilYogSgUQ
-ugoLb/FFeUKFIYVQcR7yBMiE4EDBBfRPIQABQMCA4QT0gOIEDsL/i3AE2aHaPdt+Dm/xF7shhYDh
-B/IChYDgA/SZ/yGFIqWA4SbyANrPcKAA/ESeukGgz3CgALQPANk8oA/IBCCAD/7//wMPGhgwD8iH
-uA8aGDB/2Aq4z3GgANAbE6F/2BChANiVuBChwg1v8AHYeQRv8aHA4HjxwOHFABYAQILgz3WAAIwH
-AKUX9ADZz3CfALj/PaDPcqAAyDsWgkQgAQcWgoYg/wgFeRaChiD/CAUgfoDx9Q4Ij/EghYThNAAN
-ADMmQXCAALBiQCeAcjR4AHgSDK/xVNhRIECACvIBhYG4AaW5/wbwZv8E8NYIz/r5A0/xz3KAAIwH
-IYIleOB/AaLgeM9ygACMByGCBnngfyGi4HgA2Zy5z3CgAKwvPaDgfuB48cDhxc9zoACsLxmD8LgZ
-gwDdDPIEIIAPCAAAANdwCAAAAAHYwHgH8IYgfw+C4AHYwHiA4BfyGYMEIIAPDgAAAEIgAIDKIGIA
-geAN8gohwA/rcmQTBAAF2HrbGQBv8EolAABeC6/xVNjkuEQgAQIW8s9ynwC4/72iz3WgAMg7VoV2
-hYYi/wiGI/8IZXp2hYYj/wgFI76A8vXPcoAAjAdRIECAAYLPIGIA0CBhAFEggIABog3yBIIQcQny
-JKIB2c9wgACxBlYJL/0gqP0CT/HgePHAANicuM9xoACsLxyhGoFRIICCGoEL8qq4GqEagVEgAIDx
-8wHYu/8J8Iq4GqEagVEgAIDn9QHYsv8A2Zu5z3CgANAbMaC7/2P/z3CAAIwHAYBCIACAyiBiANHA
-4H7gePHAIgpP8c9xAIIBAM9woACsLzygz3CAAIwHAYCA4AT04P8W8Nn+wgov+z/YgOAQ9CDez3Wg
-AMgf0KUK2EMdGBAA2NYNb/GNuNGl0P5BAk/xqPHgePHAiiBKBjoIb/EA2cr+nP9E/4DZz3CgANAb
-MKDF8eB4z3CAANRIMQbP9OB48cAKDIABz3CAAFiyGBCEAEwkAIEI9AmAUSBAgQTydg8AAA/wTCRA
-gAnyz3CAAEy1FBCFAEwlwIEF9NYIAADRwOB+CiHAD+tyBdh5Bi/wbtvxwFIJT/EAFgBAz3CAAOgH
-AIDPdYAA7KyD4AAWAEBVJU4UFfTPdYAA1EYApQRttg1v8Q/ZVSVAFFIPb/EilQHZz3CAADSyJKgm
-8AClBG2WDW/xD9nJcDYPb/EilR6Vz3KAAKQH2WDYYAEQhQBMJQCAIKIS9AKF8LjKIcEPyiLBB8og
-YQHKI4EPAADiAOQFIfDKJGEAKQFP8Qhyz3CAAOxIJYAjgWCBz3GgALAfO4HVuXlhEOF1B+/5Qnng
-ePHA4cXQ/94MT/HPcIAAHA8YiIHgLPTPcYAA7KzPcoAA1EgAgmCBYKAAghzbYKgEaQGiz3CAAKwH
-A6FVIUAEA6IY2AKiVSHABQWiAYEA3VoZRAMEogKBrbhWD2AAAqGA4Ab0qXDe/z4PYAAG2J0AT/Hx
-wOHFz3WgAMgfFYXPcZ8AuP/VuBahZg7P/xUVAJaQuB4dGJAOD2AAANhxAE/x4HjxwOHFAdjPcaAA
-yB8ToRiBrMFJwBmBz3WAAMiSz3GAAEC1SsABgaG4AaEIheC4CvJRIMCBBvQmCE/6cglv8BfYi3Gp
-cDoNb/Ek2s9wgACkByCAAomA4BP0BIlRIACAD/IPyAQggA/+//8DDxoYMA/IhriMuI+4kLgK8A/I
-BSCADwEAAPwPGhgwD8isuA8aGDBOCQ/wi3Aw2ZDaHttuCW/xGLvPcJ8AuP8C2TagKMCB4Mohwg/K
-IsIHyiBiAcojgg8AAB4ByiQiAEwEIvDKJSIAPg5AAIDgB/QA2Jn/Jg5gAAbYiQcv8azA8cAKDy/x
-MNrPcZ8AuP9WoRsaGDDPcqAA1AcaGhiAHxIAhgDfAd4CGhgwCBKFMEwlAIfKIcIPyiLCB8ogYgHK
-I4IPAACKAegDIvDKJIIDGRINhgPYIBoYgBQamIMPEgOGABYAQAAWAEAAFgFBABYAQQAWAEAPGtiA
-9LhA4TB5BPIC4TB5A2kEIIAPAAD8/xB1jgANAA8SAIZA4B4aGIAdEgGGHhoYgK25HRpYgI4OQACA
-4Czyz3WgADguB4XPcQAABAqouAel0g8v8A3YB4WFuAelz3CAALCvAICGIP6BD8gK8gUggA8AAADU
-DxoYMA/IkLgG8AUggA8BAAD8DxoYMDYOYAAC2A3wD8gFIIAPAQAA/A8aGDAPyKy4DxoYMM9wgAAw
-BeCgANmRuc9woADQGzGgz3CAANACEHjPcaAAtEdJGRiAz3KAAMSNz3CAADQFQKBvIEMAVBkYgPIJ
-L/QKGpgzEQYv8QDY8cCmDQ/xABaFQAAWgEAAFoBAABaAQEwlAITKIckPyiLJB8ogaQHKI4kPAABO
-AJgCKfDKJGkAANlMJQCAz3aAAARJKabS9yhyABaDQBRrz3WAAChtAGVRIECCDPQB4rByDyHBACmm
-sveKCU/xpQUP8QohwA/rcgXYXNtKJAAASQIv8AolAAHgeM9xgAAESQqBgOAF9A2BgOAD8gDYBfAG
-gYHg/fMB2OB/D3jgePHA4cVyCSAACHXPcYAAqJYlkYDhYAAMAIDgLvLPcIAAoIlIiADZz3OAAARJ
-DIMPIYEACyBAgCD0jCICgBzyhiX8EIwlApAO8owlApQH8oogzw4aCy/xn9kO8A2DJXgNowuDBXkr
-ozRqx3GAAChtAIGouACh+QQP8fHAfgwv8QDYSiTAc+B4qCBABzRox3GAACht4IHPdYAABEkA3g8m
-DhBBLwMSUSMAgGyFBfTGe2ylBvALI4CDBPSov+ChAeChBA/x4HjhxUokwHMA26ggAAYA3c9xgAAE
-SQyBDyXNEAsgQIMN9AuBCyBAgwn0FGvHcIAAKG0ggIi5IKAB4+B/wcXxwM9wgAAESSAQBQBMJcCA
-yiHGD8oixgfKIGYByiOGDwAASAD0ACbwyiSmAM9wgAC4YvAgQAFAeNHA4H7xwL4LD/EIdc92gAAE
-SYogTwoeCi/xKIYIhhB1RfeA5colAhAC9KimiiCPCgIKL/GpcfkDD/HgeM9wgAAESeB/CIDgePHA
-iiBPC+YJL/H92TYNL/AJ2ADY6v/S8fHA9/8A2YLgzCBigMogQgAC9AHYD3jG8fHAAdjPcYAABEkD
-oc9woAAsIAOABKECgYHg0AjB9Lbx8cCKIE8Mlgkv8YHZ5gwv8AnYrPHxwBYLD/Hj/4HgDPIKIcAP
-63IF2JPbiiTDDx0AL/C4c891gAAESSOFgeEChQ/0geAA2QXyFI2A4AXytgkgACalDPAjpQHYBqUI
-8IDgBvQB3hoJ7//GpcKlz3CAAKiWBZCA4DQOyf8dAw/x4HjxwKYKD/HPdYAABElJhYDiL/IHhYHg
-L/QWjQDZaoXLhQ8hAQAkekIiAoAke8oiYgCA4wHbJH7Ae4DmAd7shcB+5HmA4QHZwHmA4swjIoDM
-JiKQzCEigAfyFa0A2c4JIAAnpRaNAeAPeJDgFq0D9ADYFq2dAg/x4HjxwM9xgAAESc9wgADEYq4P
-L/E42ioJYAAA2NHA4H7gePHADgoP8QAWAEDPcIAAtH8BgFEgQIEM9AohwA/rcgXYh9uKJMMPDQfv
-77hzABYAQM91gADsrACl5G3pcGYOL/EP2VUlThTJcAIIb/EilRIOD/EIFQUQUSUAhMohwQ/KIsEH
-yiBhAcojgQ8AAI8AxAbh78okYQDPcIAA1EgggECFQKEggBzaQKnPcYAAuAcjpRjZIqBVJcEVJaDh
-oCGFw6AkoADYWh0EEAKFrbh+CGAAAqWA4Bf0z3CAAKiWJZCA4YogjwvH9r4P7/Ci2XILAAAG8LIP
-7/Cn2f4KAABCCGAADdiVAQ/x4HjxwCYJD/HPdoAAyJIIhuC4rMEK8lEgwIEG9HYJD/rCCi/wF9iL
-cclwig4v8STaAdjPcaAAyB8ToRiBAN1JwBmBz3eAAARJSsAGhzDZkNoe20vAi3DqCi/xGLuhtqim
-oaa8rqOnCg3v/wLYz3CAAKiWBZCA4MT2qqetpwXwpgsgAKlwZocB2c9ygADABwCCgePAeYDjOGAA
-ogHYIYLAeDhgAaLtAC/xrMDxwHoIL/E42qLBGnDPdYAAPEkBhQDfYgkv8elxIYUY2M9zgAAcDwCx
-F4NTIM4gz3KAADRtAaFAKAAhCGIzGcIDQCgEAYhwhiD+A8V4EKnPcKAALCAQgMdwBwAgoQqhBtgx
-GQIAMhkCABaD+rEDoUAhAANKDq/0CnEDhZDZgcIgsItxighv9gpwgeDKIcIPyiLCB8ogYgHKI4IP
-AABqAMokYgAABeLvyiUCBADAUSAAgAryiiBPDj4O7/Bu2SGFAYGjuAGhI4WLcAThQg0v8QbaAYXP
-cYAAyAcioDIMr/SpcM9wgAAESRUYAgT1B+/wosDxwJIP7/CKIE8O+g3v8IjZAdjPdYAABEkHpc92
-gADIkoogTw7eDe/wKIYVjQDaLIUPIgIACyGAgCb0KoVFeciGKqVrhQS44L7HcIAAKG0ggAzyUSbA
-kQr0ZXpLpai5IKCKIA8OmdkJ8EZ7a6WIuSCgiiAPDqDZjg3P8IogDw6GDe/wK4V5B8/w8cAGD8/w
-z3CAAARJwIAA35a//mYGDS/6yXAIcc9wgABUScINr/n+Zs91gAColgWVJYUKuNlh5gwv+g4gQACY
-cM9wgABsSZ4Nr/mIcc4ML/rJcJhwz3CAAIRJig2v+Yhxz3CAAARJwKAFhf5mHmYFlQq4qgwv+g4g
-gAMIcc9wgACcSWINj/npBs/w4HjxwHoOz/DPdoAABEmghgDflr/9ZXoML/qpcAhxz3CAAERKNg2v
-+f1lZgwv+qlwCHHPcIAAXEoiDY/5qQbv8KCm8cA6Ds/wz3CgALAfu4AA3pa+BCWNH8D/AADdZRTl
-ACWPH4AAAAAqDC/6qXAIcc9wgAB0SuIMj/kWDC/62GUIcc9wgACMStIMj/kGDC/66XAIcc9wgACk
-Sr4Mj/nPcIAABElBBu/w4KDxwM4Nz/DPcKAAsB/7gADdlr0EJ48fwP8AAL9nEOcAJ5AfgAAAAMIL
-L/rpcAhxz3CAALRJegyv+b9nz3aAAKiWBZYlhgq4+WGeCy/6DiBAAAhxz3CAAMxJVgyP+YoLL/rp
-cAhxz3CAAORJRgyv+b9nBYYfZwWWCrhuCy/6DiDAAwhxz3CAAPxJJgyv+QJ1Wgsv+gpwCHHPcIAA
-FEoSDI/5z3GAAARJABkABAWWJYYKuLlhNgsv+g4gQAAIcc9wgAAsSu4Lj/ltBc/w4HjxwAYNz/Ci
-wYDgyiGBD63erd4H8iWAI4EggQKAAnleC+/wiiBPDc92gAAESQGGgeAQ9IogTw1GC+/wiiEGBgDY
-AaaSDu/vCdgGCe//ANhu8DYJz/+B4AHYwHgvJQeQEfKKIA8NFgvv8Iohxgk+Co/0AdhyC+//BqbW
-CO//AtgKCc//guAM8gohwA/rcgXYiiPGDIokww+VAe/vuHMPyAUggA8BAAD8DxoYMEoOr+8A354I
-7//pcB4O7+8J2M9wgAColgWQgOBkAAwACoZBwAuGHg+v/0DAgOAI8oDlyiCBDwAAQAAUDQH7i3AI
-2ZTaHtsuDu/wGLuKII8Oggrv8IohBwSKII8Odgrv8CuGiiCPDmoK7/AqhoDlB/S+D4//jgmP9AHY
-B6brpkUE7/CiwOB48cDaC+/wiiAPCkIK7/CKIQUCEg6P/IDgz3WAAARJFvSKIM8OJgrv8IohhQMB
-2AGlz3CAAKiWBZCA4MX2Hg+P/0LwANij/0DwD8gEIIAP/v//Aw8aGDAPyIe4DxoYMA/IkLgPGhgw
-Xg2v7wDezgtP9B4N7+8J2CSFz3CgACwgA4DHcQAAABQieNdwAIAAAEn3iiAPCrYJ7/CKIYUKw6W6
-D6//wqWA4HgPof/KIGEAz3CAAKiWBZCA4MogiQ8AAEAAfAsJ+4EDz/DxwOHFCHUFgAOAQoUggIog
-DwtyCe/wQnnPcIAAqJYFkIDgxPb5/gPwG/+pcMP/WQPP8OB48cDWCs/wz3WAANiWD4VKIAAggODK
-IcEPyiLBB8ogYQHKI6EMyiQBBNQHoe/KJcEAAdrPcYAAyJJgeEihPB0AFGYM7+8D2PUCz/DgePHA
-bgrP8NpwmnH6cgojACEKIkAhyHcKIMAhCiHAg89wgAA0bcohYgAocgS5KGBMJACgBLiGIP4DBSCR
-AMohzA/KIswHyiBsAcojjA8AAHcAyiRsAFwHrO/KJQwFz3WAALxKAYUA3slxHgvv8DjaAIUc2SCg
-AYUQ2YQvCxwAIZV/gABYsiCwXBUBIDMYggPPdoAA0AcQGEIEmbkhoEAmARMioAohwIMoGAAEMRgC
-BTIYAgU0GMQFyiFiAOYNL/EM4CGFCNgSqQGBjbgBoQOBUSBAgg70DInPcoAAbFjDuBx4CmLPcIAA
-/LJIYAypgOcG9M9ygABQkgXwz3KAAHCSQ6Wk2ACyTCZAoBDYAqUE9KTYjLgAsgzAgODKIcEPyiLB
-B8ogYQHKI4EPAACoAMokIQCABqHvyiXBAEwjAKAEphDyAYGYuAGhA4GfuAOhABUBIAQVACAAHoQU
-IaYCpr4Nb/SpcFUBz/DgeM9wgADIkiiAz3CfALj/ANo2oAjZ7HAgoAPZz3CgABQEJaACyOxxAKHP
-cKAA1AtNoOB+4HjPcYAA5AfgfwCh4HjPcIAA5AfgfwCA4HjgfuB44H7geOB+4HjgfuB44H7geOB+
-4HjgfuB44H8A2OB/ANjgfuB4ocHgf6HA4HjgfuB44H7gePHA4cUCyM91gAAESwClBG0mDe/wAtnP
-cYAOBADscCCgqgvv8ACF9QDP8OB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4
-8cAAFgBBz3KAAARLBrIAFgVBQCIBBA4aRAFMJYCEyiHCD8oiwgfKIGIByiOCDwAAcwBEBaLvyiQi
-AADaB/AAFgBBFCGMAAC0AeIvIEIBEHK39lIMz/DRwOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+
-4HjgfuB44H7geOB+4HjPcIAA6AfgfwCA4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7g
-eOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4
-4H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfwHY4H7geOB+4Hjg
-fuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB48cD+Do/w
-GnHPd4AAREsgj1EhAIBG8s9xgADwByCJgOHMICGgPvKB4Ab0z3CAALicoYAD8ADdjuUD94DlAvQA
-3c9xgAC4nBiJgOAE9IDlBPQA3gTwooEE3oogEwEaDa/wqXGKIFMBEg2v8Mlxz3CAABwPGIiD4Mwg
-IoHMIOKBzCAiggjyiiATAe4Mr/Cl2QrwCpcQdQj0C5cQdswgIaAE9ADYIfAB2M9xoADIHw2hz3CA
-APAHAYjLt6q3BL4QuMV9BX2KIBMBsgyv8LzZiiATAaYMr/Cpcc9woADIH38YWIMB2IEGj/DgePHA
-Gg6v8AhxxP+A4DzyIN3PdqAAyB+wpjLYQx4YEADY8gnv8I24saawph7YQx4YEADY4gnv8I24saZ/
-Fg+WiiATAUEvDRTEvUYMr/Dm2YogEwE+DK/w6XGKIBMBMgyv8Klxz3GAAPAHAYkB2hB1wiKKAIDl
-QKnI9gDYDaaB4gT0BNgBqf0Fj/Dhxc9ygABESyCKAN3guWTYyiBBA+G5z3OgAMAdBqIJ8gzYAKMB
-ggOiAoIEogTwoKOjoqSiz3CAABwPCYBRIECB0SGigATyAIOAuACj4H/BxfHA4cUA3c9woADAHaCg
-qXCpcYz/z3CAAERLo6CkoJ0Fr/CmoIDgz3GAAERLBPRAIQADBPBAIQAEAIDPcaAAwB1RIACAAIHP
-IOIA0CDhAACh4H7gePHA8gyv8APZz3aAAERLdgnv8MlwoI5EJUARheAM9AohwA/rcgXYadtKJEAA
-5QGv70AtBRIBjoPgw/ZjuAGuAgnP8B0Fj/DgeOB+4HjgfuB44cVSIIAAz3GgAHwdBKkC3RHw4Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HhhvYwl/5/t9eB/wcXgeM9woAB8HQSI4H7gePHA
-QgyP8DpwenFachpzANjp/wTY6P9MIQCg1PcqdQDfQiFAIOJ4ASsOIMC+TyaAEOH/RSaAEeD/Yb2A
-5QHnMvcE2N3/TCIAoADZABhAINf3SnUodgbY2P9hvef/QiJBIMJ5wLg4eAAQASAFeQAYQCAE2NH/
-gOUB5i73ANjO/x0Ej/DgePHAocGLcwjYBdkIctz/IMChwNHA4H7gePHAnguP8FpwOnEKI4CgGnMK
-JQAhzCAhoBDyTCMAoMwgIqAM9AohwA/rcgXYQ9uKJIMPqQCv77hzANiacLf/BNi2/0wiAKDU90p2
-inVCIkAgongBKQ8gwL9PJ4AQr/9FJ4ARrv9hvoDmAeUy9wDdE/BBLcAQMiMOIFMlgRBOIcABGX7A
-vk8mgBCk/0UmgBGj/wHlQCjAIBB1rPcA2J//TCUAoBvyFPDR/1EgAIAY8iDez3WgAMgf0KVk2EMd
-GBAA2O4Or/CNuNGlgCQBKQwkgK8AAIgTqfeKIP8PA/AA2BEDj/DgeAjYBtkA2khzmHKK8fHAxgqP
-8Ah1KHdIdvr/TyVBFBjY6XLJc0okQAC9/xEDj/DgePHAngqP8KnBz3egACwgQBcQEA4Ob+8A3c9x
-gACQDBGBAeARoYtwugjv8ATZF/CBxslwrgjv8CDZABQAMclxINrn/wV9ABQAMSDgABwEMAIUADFC
-IAAIAhwEMAIUATGg4Wf2gOEM8oHGdgjv8MlwABQAMclxAhQCMdn/BX3QhzzYAiYOFJIIr/DJcYDl
-yiWBEwLI7gvv8KlxaQKv8KnA4HgdeM9xoABgHRKxFJHgfuB48cDhxQh1KHMH8Klw+f8CGxQAAuWw
-fWG6jCL/j/f1TQKP8OB48cDhxQh1KHMJ8Klw8P8Aq0i4AasC5bB9AuNhuowi/4/19SUCj/DgePHA
-4cWhwQhzKHUB4l16EPBocOX/ABwEMAJrEHji/wIcBDAAwATjcHsEHRAQYbqMIv+P8PXpAa/wocDg
-ePHAagmP8Ah20gnv8CTYUSAAgMohwQ/KIsEHyiBhAcojgQ8AABcCyiQhAGQGYe/KJcEAz3WgAMAv
-gOYThVH0+rgS8hOFIN6zuLq4E6XPdaAAyB9k2NClQx0YEADYBg2v8I240aX02ADZtgnv8AHaNNgA
-2ZG5qgnv8ADaMNiKIQYAngnv8ADaNNgA2QPakgnv8BS6Sgnv8DDYwriB4AP0ANgH8ATdP9g6D2/w
-qXGpcM9yAQDGA89xoADsJ0ahz3GgALQPPIGA4UryAhIENgohwA/rcgXYiiOJALUFb++4c5q4E6Ug
-3892oADIH/CmiiAPCkMeGBAA2G4Mr/CNuPGmE4WzuLq4E6Vk2PCmQx4YEADYUgyv8I248abwpgHY
-Qx4YEADYQgyv8I248aYThfq4BvQQhVEgAIAO9PwVBRAKIcAP63IF2IojRg1FBW/viiTIDkTYSR4Y
-kKXxeQCP8PHACgiP8KHBKHbPd6AALCBAFxAQgOIA3QAcRDMw9DJoBCGBDwAA/P8iCq/wLNgQhwIg
-AASMIA+KCfdGCO/wLNhRIACACHX18wfwIIaAuSCmMg5v8D/YKgjv8DTY9bgO8iCGgbkgph4Ob/A/
-2DTYANkA2lII7/CVujC9VfAPeRC5BSGBDwAAgv3PdaAA7CcmpQQggA8AAAAfSLiGuBC4BSCADwAA
-Qv0GpRCHAiAABIwgD4oP989wAAAD/QalCoWLcQCxABQAMVEgAIDw8wfwIIaAuSCmrg1v8D/Yz3AA
-AEP8BqUKhUAkgTAAsQIUADFRIICACPIghoG5IKaKDW/wP9jPcAAAg/8GpQqFi3EAsSDAz3IAAMP/
-RqVKhQi4QLEgxQV9QNheDW/wqXGpcEEHb/ChwOB4z3EBAMcDz3CgAOwnJqDgfvHAyg5v8ALZosEA
-3kHGNg2v8ItwPtgqDW/wAhIBNj7YHg1v8AAUATE+2BYNb/ACFAExBczXcAAAAEAB2MIgCgAXuAAg
-gQ8ADgAAAhQAMRt4D+AEIIAPAAD8/yV4nbifuOxxAKECEgE27HAgoAAUATHscCCwAhQBMexwILAC
-FAUxUSUAgMohwg/KIsIHyiBiAcojgg8AAJoBVANi78okggPPcQAAIiKaDG/wPtgB2C3/AcHPdaAA
-LCDwhSV4QcAP8AAUADGBwQHaff/scQCxABQAMQHmAeAAHAQwAhQAMRB2sPbE/zCFPthWDG/w4nk/
-2E4Mb/ABwf4Ir/ABwDUGb/CiwOB48cChwRB4TyABBJG5i3MY2BDaWf71Ae//ABQAMfHAqg1P8Ah2
-KHcSDq/wMNgIcYYhBgDSD2/wMNj+Da/wMNhRIECC/PXbfoG+QC8NFCzYtg9v8AUlgRPiDa/wMNhR
-IECC+/WKINEP1gtv8AUlgRPBBU/w4HiB4M9xgAD0BwT0AdgAqQGpAImB4MoggQ8AAMQJyiCCDwAA
-gADgfwGhANjPcoAA9AcBqgCqz3GAADB0BomA4AryB4mA4AbyAJGO4AT0AdgAqgDY2PHxwOHFCHXP
-cIAAcA8BiIHgE/QH8GYIT++eDW/wT9jPcKAA1AsYgADZQiAACIDgyiBMABB1MPdBBU/w4HjPcFhY
-WFjPcaUATBWxGRgAz3BwcFhYshkYAM9wAAQWoLMZGADPcDEIU7S0GRgAz3ACAJ1QtRkYAM9wMAQR
-gLYZGADPcEEJPfC3GRgAz3ACAKl0uBkYAOB+4H7geOB+4HjgfuB44H7geOB+4HjxwAohwA/rcgXY
-JttKJAAAaQFv7wolAAHxwAohwA/rcgXYK9tKJAAAUQFv7wolAAHPcAIAmBvPcYAA/AcAoc9wAgCU
-GwGhz3ACAJwbAqHPcAIAoBvgfwOhz3ACABgbz3GAAPwHAKEBoQKhz3ACABwb4H8DoeB+4HjgfuB4
-4H7geOB+4HjxwNYLb/Bq2KLBi3EB2mYJ4ABIc4DgDvQKIcAP63IF2IojzwuKJIEKzQBv70olAACB
-wUTYAdo+CeAASHOA4A70CiHAD+tyBdiKI88MiiQBAaUAb+9KJQAABBQAMYwgkIxcAAsAQCSBMGvY
-AdoGCeAASHOA4A30CiHAD+tyBdiKI88PiiTBCnEAb+9KJQAAAhQAMc92gAAMCBt4QSjFAEwlAIoE
-HkAR0vYKIcAP63IF2Ioj0ABBAG/viiTBCh3Yz3aAAAwIAaa4cAAUADHPdYAARLhALYIAqXGaCOAA
-AduA4A30ABQEMQQWBRAKIcAP63IF2AUAb++KI1ADQYaA4gDY0fYWJQEQYImGI/8NI7uB4wb0YYmA
-4wTyYrthqQHgUHCx9gDYHQNv8KLA4HjxwKIKb/CKIgQKocHPdYAAXAgAlc92gADguclxSiAAIAAc
-BDQiCOAAAduA4A70ABUEEQohwA/rcgXYz3MAAAIMiQcv74olBAoAjoTgyiHLD8oiywfKIGsByiOL
-DwAABwzKJAsEZAcr78olywCqCq/wNNjwuDbymP+A4A/yCiHAD+tyBdjPcwAADgxKJAAAPQcv7wol
-AAGLcUXYAdqqD6AAAduA4MohwQ/KIsEHyiBhAcojgQ8AABEMyiSBDwAARQAIByHvyiUBBAAUADEB
-2YYg/g/A4MB5z3CAAAwIIqgb8M9wgABeCACQz3GAADC8DtpU4BB4Ug+gAAHbgODKIcEPyiLBB8oj
-gQ8AABkMyiBhAb3z9QFv8KHADngseClqANgPIEAAJ3BaeOB/DiDAAOB48cB2CU/wz3CAAAwIHYgF
-8EAnQAAPePhwz3CAAAwIHojwcI4ACwAA2QfYRCk+B1lwL3AZcYQvAwEncM9xgADguQAhBAAfFMQA
-GWEeEcUAOXAA3gAhjR+AAOC51X3njYhxBdrpcAUVwxDg/0AogRA0eYQvAQUncdR5x3GAAEy82HEA
-qelwqHEH2gYVwxDX/wHmz36G5r4H6/8BHgIAQiJAEIDgQCBBEIYH7f8vebLxMQFP8OB4gOAb9Iwh
-wo02ACoAAdpKJIBx4HioIEAEz3OAAMG6RCo+BzIjQw5wccv2gOMH8obiB/IB4k96ANoD8GG6T3rg
-f0hw4HjxwHIIT/AacIDhOnKUACwAAN9acRUgwCNMIQCgoIgCiAvyz3aAAGBLFX4CuBR4x3CAAPRN
-CvDPdoAAmEsVfgK4FHjHcIAAnE4hiFEhAIAk8gUQwQAirgYQwAADripwqXHX/wCugODMIGKAyiAh
-ABPyRCg+BwAhgH+AAOC5xRCCAOEQgQACJYAQEHgHuMIJ7/hCeQGuQiJBIIDhegft/wHnLQBP8PHA
-z3CAADB0BoCB4M9xgAAMCALaB/RcqQDYHakB2B6pC/CC4AT0XKkB2AXwA9gcqQDYHaleqUD/i//P
-cYAAHGMggc9wgACUUQHaxf/PcYAAIGMggc9wgADwUQDawP/RwOB+4HiB4PHAuHEY9EwlAIDE9kwl
-gIPL9gohwA/rcgXYiiOSBHkEL++Yc0AtgABkuMdwgABgSxvwz3CAAJRQMiBBAYwhw4/KIcEPyiLB
-B8ogYQHKI4EPAACYBEQEIe/KJMEAz3CAAJhLNXjL8QJ5LXlMeVYhAXJHuThg4H8PeOB48cD2Dg/w
-CHYodUh3GnNPeRC5D3gIuAV5iiBHCFINL/Clec9wgAAMCAGIgOD2AQIAgOfMICKgCfIsbS95z3CA
-AAwIP6gG8M9wgAAMCL+oqXHPcoAADAggGkIDIRqCAyIawgMjGgIEyXDH/wAQhwDhiM9wgAAMCN2I
-HogQdpwBCQBELz4HL3GELgMRCiRADgAhTQ7PcIAA5LkdZUAvggBUeoQuARUKJUAOACJADgAgiA+A
-AEy8ACaDH4AAKAhMJwCAzCdigCX0GhXAEADZDKsbFcAQSiSAcRCrGI0Uq6ggAAYUIEAQQYhzbnR7
-NXvHc4AAQL0AEMAASKsVJUIQCasBEsAAAeEKqwCKL3kLq33wARXAEIDgF/QA2kyrUKtUq0okgHEA
-2agggAMTbhR4NXjHcIAAQL1IqEmoSqhLqAHhL3lj8Gy6ACJAAXy5ACREAAAghg+AAEy8ACSAD4AA
-5LkaiDqN6XKi/wyrACSAD4AA5LkbiDuN6XKe/xCrz3KAAOS5ACSAABiIOI0AJIUA6XKY/xSrANtK
-IYARFCbLABQgxBABE4AQARSBAOlykf8zbjR5dXkAIYoPgABAvQgaAhAAE4AQABSBAOlyif8JGgIQ
-FSXLABUlxBABE4AQARSBAOlyg/8KGgIQABOAEAAUgQDpcn//CxoCEEIhSRBMIQCQAeOYB+3/b3sB
-5s9wgAAMCB6Iz34QdmwGzP8A2c9wgAAMCCCoOQUP8OB48cDCDA/wp8EacFpxSHU6cwojACGLcM9x
-gAAAY+IJb/Ua2s9xgAAMCAGBAN6A4LQALgCYcAIRhQBMIICjAdrPcYAARLgWIYMDAIvCIowARCCP
-AP1/8XJC9EwjQKAE9EGLEnII8kwjAKA49EGLgOI29EQgAgIjulB1MPRMJUCAGPREIAIBQSqCgAb0
-RCAPBEEvPpEL8oHiB/REIAIEJLqB4gPyANoC8AHaT3oI8EQgAgQkuoDiAdrAeoHiEPRMIQCmAdrC
-IooAhiD/DiK4UHAN8oDizCVhkAnyAeaQdlwHxf+KIP8PEfAyJEA0geAG9EJx1nkCEcAACfCC4AX0
-BhPAAAPwBxPAABUEL/CnwPHAwgsv8EokQAAIdhpxSHdodbn/jCD/jxH0yXAKcelyqXMA3Zh1tP+M
-IP+PB/SKIAcKCgov8MlxqXDtAw/w4Hj44Jb2z3OAAEBMBosQcgvyB4sQcgfyDosQcgXyD4sQcgb0
-geHMIaKAAdgD8gDY4H7xwEYLL/CKIIcIz3aAAAwIugkv8D+OAY6A4Hz0z3CAACgIQiAQByEWgBA/
-ju3+z3GAALR/IBaAEFaJEHIYFtMQDPQhFoAQNIkwcAj0GRbAEAkgwAQvIwUgHo79jhB3tAAJAADd
-SiKAIxqOgOAR8kQvvhMAJUAeGBbCEM9xgAB4vZkhAgoZYZYhwgpAqTTwSCNAIC8hBSDPcIAAXEyr
-YB+O6XEiFoIQu/8JIEEELXkAIMAjz3KAAGxMqmIwEIAAQngJIEEARC++EwAlRB4fjgAkhQ+AAHi9
-GB1CAOlxqXK9/wAkgQ+AAHi9GBHBAAJ5LXkYHUIAQiJSIEwiAKAB5WwH7f+vfQHnHo7vfxB3VgfM
-/40CD/DhxeHGABHNAIDlRPYA3aCpgOAS8tTlhPdT3aCpz3CAADRNFCBOA6COoKoAEcEANHgBiBHw
-1OWE91PdoKnPcIAAjEwUIE4DoI6gqgARwQA0eAGIAKvBxuB/wcXgePHA5gkv8LhyCHcodc9wgAC0
-f892gAAMCCAWgxA2iHBxo8EA2mb0NIghFoAQEHFi9BMWhhBMJgCABfKA5wP0RaY38FMlgJAF8oXg
-ZgALAJDlg/aX5cP2ANoC8AHaTCYAgAbyIhaAEIDgANgD8gHYz3GAAEBMqWHPc4AAeL1EL74TmSMC
-CidxO2MzI4QPAABYBRQiwQPZYWyJAdlAwUHAQCYAFULAANgIcQoL4AD4dwK9tH3HdYAAbJCA5yKF
-CfKB5w/yguce9NG5BYYSuA/wBYYEIYEP/wcA/gV5IqUS8AWGBCGBD/wH/wEJuAV5IqUK8ADZAr20
-fQAlgB+AAHSQIKBaD+/viiCUDUUBL/CjwOB4ocHxwNIID/ChwWXCCHYodc9wgADKBoXBi3JAJEMw
-AIid/0QuvhYAJUAeFBTBMM93gACIuVknjxr4YJjlViDACngAKgAgqFMlgBCF4EwACgBGJc0Rr30d
-8AEUgDAAJoEfgABskFJtVHpZYSDCAKlELr4WACVAHkSpFBTBMPhgViDACiCoyXCpcZr/AeWvfVMl
-gBCF4KL2IPABFIIwEm0UeAAmgR+AAGyQOGBAqCDCRKjJcKlxj/8Q8EIlABYPeAEUgTDHdoAAhJEC
-uBR4HmYgwCiuDK4I3GsAL/ChwPHA6g/P76HBGnCKIAcJYg7v7wpxz3CAAAwIAYiA4EohACC59M9w
-gABATDIgEwTPcIAADAjdiB6IEHZaAQkAKncKIkAkAvA6dUQuvhMAI0Auz3GAAHi9mSECChlhMyGN
-DwAAWAVMIACmu32tfVb2z3GAAEwpGoE7gSR4USAAgg7yz3CAAAwIE4iLc8lx+gjgAKlyAMACfa19
-z3CAACgIfLjYYCwQwQDPcoAAoAYAigXaqXNv/UokgHEA3agggAVzbnR7tXvPcoAAQL15YimJgOF6
-YgvyEHEQ8hBxE/aF5Vf2AeWvfQrwQiWSEC8ihyRhva99EfALEs8AANkqdQzwgOVKIgAgyiVhEAXy
-QiVSEC8ihyQB2YDhLfJzbnR7FSNBA893gABAvTpnACdFEBUjgwR5ZymJSYowcn9n64/Y9gIiRAAL
-FYIABL/wfyJ4BLovJAgBAieDEGx4LyBGDm4Ir/iIcQ54An8I5+5/RL/tf0wgAKaE9grn7X/JcApx
-6XJq/wHmz3CAAAwIHojPfhB2ugbM/7EG7++hwPHAXg7P789woAC0D3AQEACKIMcIz3GAAKAGvgzv
-7yCBz3eAAAwIAY+A4ADdLvTPcKAAtA+8oD6PHY8wcBD2z3OAAGy5f9oUIA4AfmZYrrmuAeAPeDBw
-Bdparvb2AN0O3s9wgABcTKhggP9hvoDmAeWvfTj3z3CAAKAGAIDPcaAAtA8Jp3AZAAQ5Bs/vCHEF
-IYEPrd4AAEEE7++KIIcJ4HjxwOHFz3WAAKAGiiDHCSoM7+8ghc9xgAAMCAGJgOAM9ACFKYFNaDBy
-wCBsAcwhDIAwD8n/BQbP789xAACt3vkD7++KIIcJ4HjxwAAWgEDPcYAADAgYqQAWhEAAFoBAUCS+
-gRmpABaAQMohwg/KIsIHyiBiAcojgg8AAPEKaALi7solwgBRJICBANjKIGEAG6nPcIAAyAYAkIDg
-BPJ0/rH/cgkP8KMFj//xwBoNz+8Idc92gAAMCAmOEHUodwT0CI4QdyDyqXBAJoEU8gmgAEAmwhQS
-jq96M44Yugi4BXqKIFQNVgvv70V5Mo5AJgATTg2gAFOOEo56DKAAM46pruiuKQXP74Hg8cC4cRj0
-TCUAgMT2TCWAg8r2CiHAD+tyBdiX28UB7+6Yc0AtgAAUeGy4x3CAAPRNHPDPcIAAlFAyIEABjCDD
-j8ohwQ/KIsEHyiBhAcojgQ8AAJ0AjAHh7sokwQACuBR4x3CAAJxO0cDgfvHAUgzP7892gADKBgCO
-z3eAAMgGII/g/0GIz3WAAEgI47oglwbyAdgArYogxwNI8AKAgOAF8gDYAK2QuT7wUSIAgTHyz3KA
-ALR/FooQcSv0AJZ0inBwJ/TPcIAAzAYAiFKKEHIf9M9wgAAcDwmAUSBAgRnyQYWA4gDbDvLPcKAA
-LCAQgEJ413AxAQAtRPcB2kCtBPBgrQDaELqKIEcDRXkO8AGNgOAH8gHYAK2KIAcDBvAA2ACtkbmK
-IAcECgrP7/kD7+8AjeB4gODxwA70sv/PcaAALCAwgcdxSWsA0iKg5gnv74oghwWK8eB4gODxwNhx
-CvSo/wDZIqCKIMcFygnv78hxfPHgePHA4cXPdYAASAiKIEcGsgnv7ymNBNheDK/7AdkIjSmN6P+h
-A8/v4HjxwM9xgABICIogxwaKCe/vKYnPcIAA3E2CCY/4WPHgeOHFUyANAKCpBCCBDwAGAABCIQGA
-BCCAD0AAAADKIWIAIKrXcEAAAAAB2MB4AKvgf8HF4HjxwNIK7+/YcQomgJCIdcwjIoAG8kImBgEv
-JocByHF9/4Dmz3GAAEgIA6Ei8iSIArk0eUOIA+FRIgCAAhCFAA30CiHAD+tyBdiKI0gEmHOlB6/u
-CiWAAQhhUSBAgAr0CiHAD+tyBdiKI0gF8vEBEIUAUSUAgMohwQ/KIsEHyiOBDwAAIgLKIGEB4vPh
-vdElIoHKIcIPyiLCB8ogYgHKI4IPAAApAkwHou7KJIIBUSUAkBHyUSXAgMohwQ/KIsEHyiBhAcoj
-gQ8AADACKAeh7sokgQFtAs/v4HjxwO4Jz++hwQh2KHcacgDdz3CgALQPcBARAIogxwBOCO/vyXHP
-cKAAtA+8oItxQCRCMEAkgzDpcK//TCAAoAX0SiQAAAnwz3CAAIyXAYiA4Pj1SiSAACDAARSCMMlx
-AhSDMLL/z3CAAEgIKYiA4cwmQpAF8iOAqqiioeW/FvLPcYAAtH9WiVB2EPRUiVMnAxBQcwz0BCeP
-HwAGAACA5wHaMonAejByBfKiqKGgoKiKIMcAug+v78lxz3GgALQPcBlABI0B7++hwPHAMgnv74og
-BwbPdoAASAiSD6/vJIYV3QSGMmgB4DR5x3GAAJxOBKYCgYDgEfLPc6AALCBwg2J413BJawDSANrH
-90KhiiDHBVoPr+8giQSGquCE9wDYBKZhvYDlvAfN/z0Bz+/xwM9xgACgBooghwEyD6/vIIHj/89w
-gADIBgCQgOBcDML/VQTP/+B48cCeCO/v2HGhwRpwi3FAJEIwQCSDMMhwYv8BFIAwgOAJ8gIUgDCA
-4AXyQiAQIS8gByQgwApx7P4BFIEwgOEE8qKIA/ChiIogxwHODq/vyHFAKAAmQC0CFAV6ARSAMAIU
-gTAIuAV6iiDHAa4Or+9FeeG90SXikAXyUSUAkQzyCiHAD+tyBdiKI00BmHM5Ba/uCiUABG0A7++h
-wOB48cDhxTj/z3CAABwPGIiE4M91gACMlwv0iiAPCl4Or++KIYoCAo0hhc//Ao0hhQHaeP9NAM/v
-4HjouAjyBCC+jwAAABgB2AP0ANjgfwCp4HjxwK4Pj++hwRpwAN7PcKAAtA9wEBEAz3CgALQP3KCK
-IEcBCg6v7wpxhCgGLwAhjX+AAOCYIfBAJQAXFiCEAwUUgACGIP6HGPIEhYtxQCSDMEAkTzDpchj/
-qBUAEOlx4/8gwAQUgQABFIIwAhSDMEokwAAe/wHmDJUQdr4Hxf+KIEcBqg2v7wpxz3GgALQPcBlA
-BPMFz//geIQoCwwAIYF/gABYsigRgAAogRkF7/8A2vHAj/9CCc//qQLP/89xgAC0f89wgADIBgCQ
-VokQchX0z3CAAMoGAJBUiRByDfTPcIAAzAYAiDKJEHEH9M9xgABICAGJAqngfvHAug6P7xpwz3GA
-ALR/z3aAAMgGAJZWiRByz3WAAEgIEfTPcIAAygYAkFSJEHIL9M9wgADMBgCIMokQcQP0Ao0C8ADY
-Aa2K/s9wgADMBkCIz3GAAMoGAIkgjoDiAdrAegpzAN+Yd+P+A4UBiFEgAIEglgfyAdgDrYogRwME
-8OOtiiCHA64Mj++VBo/v8cAuDo/vocEIdQDez3CgALQPcBAQAM9woAC0D9yg442KIAcBggyv7+lx
-BJWLcUAkgzCA4AHYwHgvJwAABYVAJEIwvP4KhUAkQTCH/4DnlSVDHtn3ViUAHPAggAOpcYAhCADU
-ecC4BSDAAS8kBwAgiSDAARSCMAIUgzC7/gHm8Xaq94ogBwEiDK/v6XHPcaAAtA9wGQAEkQXP/+B4
-8cCSDY/vz3CAABwPKBCQAKiAiiAHAvYLr+8KcVMlABAKcS7+AYhRIACByiHCD8oiwgfKIGIByiOC
-DwAAWgPKJMIAeAKi7solAgStBY/v4HjPcKAALCAwgM9wgABICOB/IaDgePHA4cXPdYAASAgAjYDg
-EfQ0/oDgDfSKIEcEAN2KC6/vqXGQ2ZC5A8igGEAAFPADjYDgEfLPcKAAAAQsiIwhAoAA3Qn0Yguv
-74oghwSR2ZC56/EB3VUFr++pcOB48cDWDI/vz3aAAHiWFI6B4BH0BNjqDW/7AdnPcIAAygYAiM9x
-gADIBiCJSf4A2BSuLvD2joDnLPLPdYAASAgKjWG4EHcX8lz+z3CAANxNz3GAAKiWJYFBbwUpvgBW
-C2/4L3GKIIcGz3GAAMgG3gqv7yCRz3CAAMoGAJDqrQitz3CAAMgGAJAJrQDYFq41joDhCPLPcIAA
-ygYAiDb+ANgVrp0Er+8B2OB4gODxwPTYCPSWDM/vUCABAPTYB/CKDM/vCHH02IC5Tg6P79HA4H7g
-eIDg8cA02Af0bgzP71AgQQQF8GYMz+9PIEEEKg6v7zTY7fHgePHA3guP7xpwSgzv7zDYmHApuFEg
-AIDKIcIPyiLCB8ogYgHKI4IPAADPANwAou7KJSIALNjqDa/vQCiBIAHfiiAPChpwDgzv7zDYmHAp
-uFEgAIAX8ownD5o08iDdz3agAMgfsKYB2EMeGBAA2G4Pr++NuLGmQiBAIIDgAecj99YL7+802E8g
-AQWVuZYNr+802MIL7+8s2Ah1ugvv7zTY9bgZ8kfYsgmv7wLZCiHAD+tyBdjr20okAABNAK/uCiUA
-AQohwA/rcgXY29s9AK/uSiUAAPS4yiCCDwAARwB4CaLvyiFiAF0Dr+9BLQAU8cD2Cq/vNNheC8/v
-8LjPd4AAvL0R8gDeyXCs/wHYtf+KJRAQyXC8/xQnjBNhvYDlALQB5jj3KQOP7+B48cC6Cq/vNNih
-wQDeQMYA3xoL7++Mv/C4F/I6CS//AdgD3Qq9+GYQeItxhgov/wHaz3GAALzF1HlhvYDlALEB5jL3
-ogsP/90Cr++hwM9xoABgHRKxFJHgfvHAXgqP7wh2KHVIdxpzxgrv7zTY8LgN9GG/jCf/nxjyyXD1
-/wIdFBAB5tB+9vFMIACgBvLPcYAAvL0F8M9xgAC8xft61HlKD6/0qXB1Aq/vAdjgePHAAgqP71pw
-GnE6cmhwsgsv+ArZoWhqCu/vSnAEIEAEBCEBJDBwFfIg3892oADIH/CmCthDHhgQANjODa/vjbjx
-pmG9jCX/nyf2ANgC8AHYDQKP7/HA07hPIAEGmbk6Ce/viiARAkoJ7++KIBEElwXP/+B48cDhxUh1
-QCkCBlMgwQSKIBEBEgnv70V5iiARAwYJ7++pcfEBj+/gePHAdgmP7wh2KHXs/whyyXAD2aZ68f/N
-AY/v4HjxwFoJj+8Idih15f8IcslwA9mleur/sQGP7+B48cDMuBC4TyCBAJ+5aguv7/TY9NgC2c9z
-AQCghihyxP+A4MogIQALBc//4HjxwBIJr+8k2EILr+8E2STYAdnPcwAAqGEocrr/gODKIcEPyiLB
-B8ogYQHKI4EPAAACAcokIQD8BWHuyiUBAc9wAAAMMADZmrnc/yDez3WgAMgf0KUK2EMdGBAA2KoM
-r++NuNGlz3AAAAwwANmaucz/iiAJBNYKr+9vIUMAAQGP7/HAhgiv7wDZB9gacTpwAN5AKAAhFHjH
-cIAArKQVII0DAJWMIAKNAN+E9owghYLJ9v/YALWKIBEDyg5v7wDZAZ284AX2jCA/gUf24bWKIBED
-sg5v7wDZAebPfozmtAfL/0IhQCCA4EAgQSCiB+3/L3l1AI/v8cDhxc9wgABcCACQz3GAAKykqNoB
-3YAgRAsQeJ4N7/+pc4DgyiHBD8oiwQfKIGEByiOBDwAAwADKJCEAAAVh7solAQHS/89wgABQPkUA
-r++0oOB48cDKD0/vCg3P/892gABcCGbYIm4B2lIN7/9Ic4DgCvQKIcAP63IF2M3biiSBCTbwAhYF
-EUwlAIDMJYKPAAD//wr0CiHAD+tyBdjQ250Eb+6KJIEJZ9jJcQHaDg3v/0hzgOAK9AohwA/rcgXY
-09uKJMEJFPABliRuAdoB4BB46gzv/0hzgOChlgz0CiHAD+tyBdjW20AlRBBRBG/uSiUAAAJtEHgm
-bgHavgzv/0hzgOAK9AohwA/rcqGWBdjZ20AlhBDs8XEHT+/xwOYOT++hwRpwOnKA4Wh2wgAsAADY
-mnEVIA0gz3GAAFwIABWTEAIVkhC6cOONIZEBjQHaOGAQeItxZgzv/0hzgOAT8gAUADFMIQCgQCqC
-IAQggQ8AAAD/R7lUehXyx3KAAPRNFPDPcIAAXAjBkKGNCiHAD+tyBdj22wAmRBOlA2/uCiVABcdy
-gACcToDmABrCBATyAqoD8AGqUSAAgBTygOYN8gOKgLgDqhJvFHgbYmOLWGCBu2Oo5KqA5gPyJqoC
-8CWqQiRBIIDhTgft/0AlQCBlBm/vocDxwM9wgACUUQ7ZAdoA28f/z3CAAMxRCdkB2khzw//PcIAA
-8FEq2QDaANvA/89wgACYUgvZANoB27z/0cDgfuB48cCI/+//Cg4P/w4IAABw//Xx4HjxwMYNT++j
-wUohACCLcSpwSiAAIQpyXgvv/ypzgODKIcEPyiLBB8ogYQHKI4EPAADuAMokQQTAAmHuyiUBBAAU
-hTDPcYAAZAgAGUIBTCUAgMohyw/KIssHyiBrAcojiw8AAPYAkAJr7sokywAAwEEoAgJBKA4DUyLE
-AFMmxRACGQIBAxlCAUwkwIDMJeyAyiHJD8oiyQfKI4kPAAD8AFgCae7KIGkBQSgCBFMixgAEGYIB
-QSgCBVMixQAFGUIBTCZAgMwl4YDKIcIPyiLCB8ogYgHKI4IPAAACARwCYu7KJIIBQSgCBlMixAAG
-GQIBQSgFBwcZQgFMJECAzCVsgMohyQ/KIskHyiOJDwAACAHoAWnuyiBpAQQUhTCMJQGEtgAsAAEZ
-QgEKIcAP63IF2IojRAPFAW/umHPPdYAAvN0A3wPwAefvf0EoAQLDuTB3cAAKAADeEvBAKYEgNHkK
-FIAwFSFBAQHmz34UeblhABkEBIAgAiMvIAgkAMBBKAEGw7kB4TB2vgfK/4LBCnAC2uYJ7/8A2wsU
-hDAvKAEBTiCFBy8lRwFMJcCArgfL/wohwA/rcgXYQQFv7oojRAtAIVEgLyFHJEEoAQTDuTJxcgfJ
-/wXwTCYAgGQHyf9BKAEFw7mA4Qp1rgAsAEogACBKIgAgBfBAIlIgLyKHJEEoAQPDuVJxfgAMAEoh
-ACAV8AK+1H4KFIAwFSZOEUAhUSAvIUckFH4AJoAfgAC83aCwgCUCE7B9AMBBKAEHAeEycbYHzP8w
-uMO4ACAOBILBqXAC2iYJ7/8A2wsUhDAvKAEBTiCFBy8lRwFMJcCApAfr/89+CiHAD+tyBdiBAG/u
-iiOFAUAgUCAvIAckQSgBBcO5EnFgB8n/09kIuQDYA97Pc4AAvN0A2rJoVH19ZTi1AeJPeoLiViEB
-CDB5t/ZhvoDmAeAPeDD3YQNv76PAgODxwLhwyfZMJYCDBfYA2ACpAKoT8EwlgIiH9owlAYDKIGwA
-9vaMJQGJi/aMJQKDB/YC2ACpAdgAqtHA4H6MJUKEhvaMJUKJA9j29gohwA/rcgXYiiPGAdUHL+6Y
-c+B44cXhxs9zgABkCEaTUyJNgBfyguUX9BGrBZMwq8SDKd0SvRUlDBDApCiLgOEG8lYgAQgweTV9
-wKUB4AWzA/ATqzKrAeJGs8HG4H/BxbhwViEAAoDg8cCYccT2jCACgIr2CiHAD+tyBdhlBy/uiiNH
-B89wgAAsYxQgAAGAEAEBBCl+AS9ywBBAB0IqAwTBu1K6BCh+AS9xQikABMG4UrmB48AiaQCB4MAh
-aQCIIj4Af9wJIgADiCE+AIkhwQ+A4NYgKwiA4dYhKwjO/4nx8cC+CU/vosFAwEHCQCgUBUApFwUA
-3UAqEwVAKxIFAd5KJYAhqXcE8Ap1yncAwBW4E3gUIMAFegvv9wfZAiBQAwIgQCNqC+/3DtnMfgoh
-QC4EKT5wL3CsfgAhDXUdZQHAFbgTeBQggARGC+/3B9kCINYDAibAIzoL7/cO2QQofgQvcex+ACHA
-dBlhQi0AFVS5vP9CJVUgTCUAoAHmjAft/89+ZQFv76LA8cAyCU/vCHYacc91gABkCOaVCvDMf/IK
-7/dAKUBxRbgKca7/JpWMIRCAtvZpAU/v8cD2CE/vocE6cQDfgODKIcEPyiLBB8ogYQHKI4EPAABx
-AsokwQAEBiHuyiXBA89xgABkCEWx5rFMIQCgyiXOE2QALgDKJs4TGndadwTwyXcadWpwQCBTAItx
-AdpKDq//ANsAFA0xLyPIJKl2Kb3Ivr/l2SUpFEwiAKDKIMIDyiGCA8oiAgSkDuL/yiNCA8lwqXGG
-/0IhUSBMIQCgsgft/0AiUiDJcKlxyv+lAG/vocDxwEIIT++acBpxz3WAAGQIxY0EjR5mknbKIcwP
-yiLMB8ogbAHKI4wPAADSAsokDAVIBSzuyiWMAwDfAN4i8ADYCK1qcIrZKnLC/wiNUyfBEBi5w7gc
-uAV5z3gQuAV5iiBUDWoOL+8FIYEELyHIBBC5iiBUDVYOL+8FIUEEAebPfgAlAhRGigFqEHZb9kAs
-gCAUePV41HjPc4AAvN0QYwoiAKAyb+zzQCCTAC8jyCTUeYDiO2MwExEBw/UB2MLxAefvf4PndgfL
-/80HD+/xwHoPD++hwQh1enEacs9xgABkCMWJBIkeZnJ2yiHMD8oizAfKIGwByiOMDwAAGwPKJMwE
-eAQs7soljAMA3wDeIPABFIAwAR0SEAYRgSCA4QEUgDAD9AEdEhAgwAMUgjABFIEwGLgUugV6AhSA
-MBC4BXqKIJQNig0v70V5AebPfs9xgABkCAAhAAQGiAHgEHZ2ACoAACERBEArgCAUePV41HjPcYAA
-vN00IRIAUyfAEBi4z3kQuQV5iiCUDUINL+8FIYEETCIAoADZFvKLcUpwAtpaDK//ANuA4LX1CiHA
-D+tyBdiKIwwMCiSABMEDL+5KJYAAAR1SEAYRgCCA4MD1AR1SELzxAefvf4PnMgfL/w/x4HjxwOHF
-AN2go4HgzCEhgBfyoOJF9qCjANgJ8MDiBtgG9kIiAAhDuALgAKNQeRC5EH2KIJQNtgwv76V5tQYP
-7+B48cAqDi/vANihwUh2iHIKIkAhCiGAIQrBCiDAIUwmQIAAocwmbJDMIKygzvYKIcAP63IF2Ioj
-TgsKJEAEHQMv7golAARMIUCgzCAhoMohwQ/KIsEHyiOBDwAAswMF2O7zaHCGIPwDRLhk34QoAQkv
-dYAlDxrDu3tjdXsowEQqvgyB4H1lAiVNHgv0W3pNeotzKnAKccv/AMAVeBV4An2pcGYPr/dk2ex4
-AiVEHongyiBqAsoiCgBJ9oDgyiArAMoiCwCD9kFoQCjPIPV/z3OAAChrFScBEFV/TCEAoHlh+2MN
-9IDmBvSoEQ6GqBMAhhLwihEOhooTAIYM8IDmBvSQEQ6AkBMAgAbwGBEOgBgTAIApwYHhiiH+AMAm
-QRDAIEEAwniIcSx4L3DeDq/3ZNm4YNhg1g6v9wrZKOBIIAEAjCFDgsohig8AAMgAz3CAABRmmSBB
-BzV4wBAABowiQqAluBB4RfaMIgGgDfYKIcAP63IF2IojUQ2KJEIA4QEv7golgATPcYAAJGRZIcEP
-FSGBBIARAQYtuTB5LHgKwEIphHWMJMePABgAAcohzQ/KIs0HyiBtAcojjQ8AAJQEnAEt7solDQSK
-IJQN4gov74hxuQQv76HAAAAAAAAAAAAAAAAAAQAAAAAAAADAD4AAVBCAAABsgAAQAIAAjASAAAQI
-wBAKABNkbAWAgQAAwBYEARNiD1wAIgoAAEAABgBwGgAAYQAAEyQAABMlAADAF8ggwBBwRcAQEAjA
-EAAAEyQAABMlBAjAEQ8UFSIEABUm+/8wMgMAEyQYCMARHAjAEQ8UFSIBABUmBAAwMDAAEyTsHMAR
-AwATJFAUwBEEGMARAAATJBBFwBEYCMARD3wTIggAzBEAABMlAAATJDRIxxEPexMiAQATMAQowBEP
-FBUiBAAVJuwGgIEAAMAWwiwTJAQowBECRhMkBCjAEcJfEyQEKMARD00TIgQQxRECABMk8BzAEQEA
-EyTsHMARAAATJHAAEyUQHMARAAATJQAAEyTgHMARAQATJCQQwBEAAAAhAAATJQAAEyQPRQAiAFwA
-OQMAAGICYABiAABYOF0AAGEkEMARAIATJDgcwBEPcxMiggETMAQowBEPdBMiAgITMAQowBEPdRMi
-QgITMAQowBEPFBUiAQAVJg9yEyIIAMwRD0QAIgoAAEAAQABwDgAAYQAAEyUCABMk7BzAEQ92EyIY
-CMoRCQATQBwIyhEJABNAIAjKEQ94EyIEAMoRAAABJAAAASUGAABhD3YTIixIxxEPeBMiAADGEQMA
-ASQAAAElAAATJcIsEyQEKMARAkYTJAQowBHCXxMkBCjAEQ9FACIAXAA5JwAAZAAAEyQBABMlOBzA
-EQ93EyLgHMARDwETIgQIwBEPAhMiBCjAEQ8HEyIEKMARDwQTIgQowBECAHFwBwAAYf8AEyUCEBMk
-BCjAEQAAEyUAABMkyEnHEQYAAGEAABMlAhATJAQowBEAABMlSQATJMhJxxEPcBMiAQATMAQowBED
-ABMkAAATJQQIwBEAABMkOEXAEQ8DEyIYKMARBAAAYQAAWDgAABMkAQATJTgcwBEAAAAhnGuAgQAA
-wBY8BMARMAWAgQAAwBYEARtiEATAEAMAGyRUBMARJATAEQgEwBBca4CBAADAFwgEwBA4a4CBAADA
-FwAAGyUDHBtiQAAbJDAcwBEFAABhNAWAgQAAwBYPGxkiCASggTjwxIAAABskAgAbJTgcwBEAAAAh
-MAWAgQAAwBZMBMARNAWAgQAAwBYPGxkiSASggTjwxIAAABskAgAbJTgcwBEAAAAhAAAAhTAFgIEA
-AMAWDxsEIhAEG2YPARtoFBzAEAoAG0AEABtuAwAAYQ8cHSIBAB0m+Q8AYWQMABAAwAYRAQAEJ/wA
-BGQAABskAgAbJTgcwBEAAAAhAAAbJUAAGyQwHMARAAAAIQ8cHSIYAR0mGADHEPySgIEAAMAXIADH
-EASTgIEAAMAXAAAAIXwxgIECAFxuEQAAYfhBxBAPGwkiAAsJOQIACmIDAQpiBAIKYgAACUAEAABh
-CQAJQAIAAGEKAAlAAAAAYQIACUEACRooAADAFgEAGyYAAMAXBAAdJgEACCfpAAhkAAAAIQAAAACM
-AQAAAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsOQAAODsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAABSEgAAAAAAAAAAAAAAAAAABAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-wACQANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAADIkoAAAAAAAAAAAABAl4AA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAsAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAiJyAACycAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAD/AQAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMisgACY9gEAAAAA
-AAAAAAD//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIkoAAhP8BAAAAAADIkoAA
-UAYCAAAAAAAAAAAAyJKAAOgHAgAAAAAAAAAAAAAAAADIkoAAAAAAAAAAAAAAAAAA/wAAAAAHAAAA
-AAAAAAAAABgbAgAYGwIAGBsCABwbAgAAAAAAHQAAAAAAAAAAAAAAAAAAAAAAAAB/fwABAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAQIECAAIECAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADECAAAFQAAANQtgAA4KwAAOCsAADgrAAAMQgAA
-OCsAADgrAABYPQAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAArB4AAFwgAAB0
-IAAA5CEAAGwiAADoIQAAOCsAADgrAACATgAASFAAADRRAAA4KwAAOCsAADgrAAD8TAAAFGQAABBk
-AABoZAAAOCsAADgrAAA4KwAAGEQAADgrAABMZAAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsA
-ADgrAAAQQgAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAA
-OCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAAIRQAAOCsAADgrAAA4
-KwAAOCsAADgrAADwRQAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgr
-AABQawAAOCsAAHhsAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAACBvAAA4KwAAOCsA
-ADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAAMyAAQAkhAEAOCsAAHiGAQA4KwAA
-KIgBABRUAQA4KwAAOCsAAABSAAA4KwAAOCsAADgrAAA4KwAAOCsAADzeAQDE8QEAOCsAADgrAAA4
-KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAACsGAIAOCsAADgrAAA4KwAA2P0BADgr
-AADUAQIAOCsAAPwpAgA4KwAAoCUAAKQlAAA4KwAAOCsAAIgSAgBMcgAAOCsAADgrAAA4KwAAfPsB
-ADgrAAA4KwAAWE0BAAygAQA4KwAAOCsAADgrAAD8qAEANFUBADgrAAA4KwAAOCsAADgrAAA4KwAA
-OCsAALSzAQA4KwAAgA8CAIQPAgCQDwIAlA8CAIgPAgCMDwIAmA8CADgrAAA4KwAAOCsAADgrAAA4
-KwAAOCsAADgrAAA4KwAAOCsAAPBTAAA4KwAAOCsAADgrAAA4KwAAOCsAANQOAgAkDwIAEEgAADgr
-AAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsA
-ADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAAA4KwAA
-OCsAADgrAAA4KwAAOCsAADgrAAA4KwAAOCsAADgrAACQSQAAGEoAAKxKAABgSwAAJIEAADhLAAA4
-KwAAOCsAADgrAAA4KwAAOCsAAIhJAACMSQAAOCsAADgrAAAwUgAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAIwMAACMDAAAjAwAAIwMAACMDAAAjAwAAIwMAACMDAAAjAwAAIwM
-AACMDAAAjAwAAIwMAACMDAAAjAwAAIwMAACMDAAAjAwAAIwMAACMDAAAjAwAAIwMAACMDAAAjAwA
-AIwMAACMDAAAjAwAAIwMAACMDAAAjAwAAIwMAAC8DQAAAAAAALxaAQCMDAAAnAkAAIwMAACMDAAA
-jAwAAMwJAADoPAEAZIMAAIwMAACMDAAABAoAAAQKAAAECgAABAoAAAQKAAAECgAABAoAAIwMAACM
-DAAAjAwAAIwMAAD8CwAAjAwAAIwMAACMDAAAjAwAAIwMAADADQAAjAwAAIwMAACACQAAAwAAAJwM
-AgACAAAA6GgBAAQAAACcaQEABQAAANwNAAAGAAAAIDQAAAgAAAAADwIAEwAAACz4AQAJAAAAgAMC
-AAoAAACcDwIADgAAABSdAQAPAAAAYIoBABAAAACYigEAGAAAACRaAQANAAAAEIIBABcAAABIcgAA
-EQAAAKSBAAASAAAAWEwBAAEAAABY/QEAFAAAAMCwAQAVAAAAQKABAAcAAACQbwAAFgAAAOwpAgAZ
-AAAAvA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAABAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEAAAABAQAAAAAA
-ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e
-4eEDDh7h4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e4eEDDh7hPDw8PDw8PDw8PDw8PDw8PDw8PDw8
-PDw8PDw8PDw8PDwVFRUVPDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAAADw8PDw8PDw8PDw8PDw8
-PDw8PDw8PDw8PDw8PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAAAAAAAAAAAAAAAAA8PDw8PDw8
-PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8PDw8FRUVFTw8PDwAAAAAAAAAAAAAAAAAAAAA
-kAYAADH6rwCQBgAAMfqvAJAGAAAx+q8AkAYAADH6rwCQBgAAMfqvAJAGAAAx+q8AkAYAADH6rwCQ
-BgAAMfqvAEMFAAAx+q8AQwUAADH6rwBDBQAAMfqvAEMFAAAx+q8AQwUAADH6rwBDBQAAMfqvAEMF
-AAAx+q8AQwUAADH6rwAAAAAA3sMJAAAAAAAAAAAAAAAAALQqAQABAAAAlC2AAAAAAAAAAAAAAAAA
-AFQrAQAVAAAA1C2AAAAAAAAAAAAAAgAAAAMAAAAAAAAACAAAAAAAAAAwjBEAIL8CAAAAAADIKwEA
-cCwBAHQtAQAgLwEAdC0BACAvAQDQMAEAWDEBALgxAQCAgICAgICAgAGAAoCAgICAAAAAALg3AQC4
-NwEAAAAAAAAAAAAAAAAAAAAAALg3AQC4NwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJQt
-gACULYAApCCgADggoAABAAAA/P///wAAAAAAAAAAtC2AALQtgACoIKAAPCCgAAgAAADz////AAAA
-AAAAAADULYAA1C2AAKwgoABsIKAAMAAAAM////8AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAA
-AAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAbE0BAAUAAADULYAAwFIBAAD/AwDgUgEAAP8FAMxTAQAA
-/y0A8FMBAAD/PQCoUwEAAP8EAIxTAQAA/yUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAABgWQEABgAAAJQtgAAAAAAALAEAAF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAAAAAAAAAA
-vGABALxhAQA4YgEAQF0BAGhcAQBoYwEA8GMBADRkAQCIZAEAAAAAAAMAAAACAAAAAwAAAAMAAAAD
-AAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAbGoBAAoAAACULYAAAAAAAAAAAAAAAAAA+GoBAAoA
-AACULYAAAAAAAAAAAAAAAAAArGsBAAoAAACULYAAAAAAAAAAAAAAAAAAzGwBAAoAAACULYAAAAAA
-AAAAAAAAAAAAMGsBAAoAAACULYAAAAAAAAAAAAAAAAAARGwBAAoAAACULYAAAAAAABAAAAAAgAAA
-AACgABAnAADoAwAA6AMAAAAAAAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAAAAAAAAAAAPg+AQAK
-AAAAlC2AAAAAAAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAA
-AAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAAAAAAAAAA
-APg+AQAKAAAAlC2AAAAAAAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAAAAAAAAAAAPg+AQAKAAAA
-lC2AAAAAAAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAAAAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAA
-AAAAAAAAAPg+AQAKAAAAlC2AAAAAAAAAAAAAAAAAAASGAQAKAAAAlC2AAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4jQEAhI4BAHCRAQAklAEApJYBACiaAQA0kAEARAWAAJCS
-gAAYAAAAUJKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvJwBAAYAAACULYAA/////wAAAAD/////////
-/wAAAAAAAAAAAAAAAJyfAQAFAAAA1C2AAG4AbgBpAMAAoABQAIAAvgBQAX0APgBuAG4AaQDAAKAA
-UACAAL4AUAF9AD4AAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIBAQACAQABAgICAAEB
-AAIBAgECAAIAAQID//8AALkB3wCxABsAFgEbAHwBGwCvABsAFAEbAHoBGwBsAKAA0QCgADcBoABv
-AIMAcQCDAHYAgwBzADMAbgAzAHAAMwByADMA1wAzAD0BMwDUAQYA0AEAAH4APADjADwASQE8AHgA
-SQDdAEkAQwFJAH8AWgDkAFoASgFaAKoAPwCrAAEADwE/ABABAQB1AT8AdgEBAHkAagDeAGoARAFq
-AKgAAAANAQAAcwEAAKYANwCnAAEACwE3AAwBAQBxATcAcgEBAAQACACcAcwAnQHMAJ4BzACfAcwA
-1QHMANYBzADXAcwAtABHABkBRwCAAUcAkAAiAPUAIgBbASIAoQCIAAYBiABsAYgAlAAAAJUAAACY
-AMAAmQCgAJYAkACXAAAAlAABAJUAAQCYAMAAmQCgAJYAkACXAAAAlAACAJUAAwCYAMAAmQCgAJYA
-kACXAAAAlAADAJUABwCYAMAAmQCgAJYAkACXAAAA+gAAAPkAAAACAZAAAwHTAAABgwD+ABMA/AAz
-AP0AdwD6AAEA+QABAAIBkAADAdMAAAGDAP4AEwD8ADMA/QB3APoAAgD5AAMAAgGQAAMB0wAAAYMA
-/gATAPwAMwD9AHcA+gADAPkABwACAZIAAwHTAAABgwD+ABMA/AAzAP0AdwBfAQAAYQEAAGgBkABp
-AdMAZgGDAGQBEwBiATMAYwF3AF8BAQBhAQEAaAGQAGkB0wBmAYMAZAETAGIBMwBjAXcAXwECAGEB
-AwBoAZAAaQHTAGYBgwBkARMAYgEzAGMBdwBfAQMAYQEHAGgBkABpAdMAZgGDAGQBEwBiATMAYwF3
-AIUAAACGAAAAhwBQAIgAAACJAKAAigAAAIsA0ACMAAAAhQABAIYAAQCHAFAAiAAAAIkAoACKAAAA
-iwDQAIwAAACFAAIAhgADAIcAUACIAAAAiQCgAIoAAACLANAAjAAAAIUAAwCGAAcAhwBQAIgAAACJ
-AKAAigAAAIsA0ACMAAAA6wAAAOoAAADsAFAA7QAAAO4AoADvAAAA8ADQAPEAAADrAAEA6gABAOwA
-UADtAAAA7gCgAO8AAADwANAA8QAAAOsAAgDqAAMA7ABQAO0AAADuAKAA7wAAAPAA0ADxAAAA6wAD
-AOoABwDsAFAA7QAAAO4AoADvAAAA8ADQAPEAAABRAQAAUAEAAFIBUABTAQAAVAGgAFUBAABWAdAA
-VwEAAFEBAQBQAQEAUgFQAFMBAABUAaAAVQEAAFYB0ABXAQAAUQECAFABAwBSAVAAUwEAAFQBoABV
-AQAAVgHQAFcBAABRAQMAUAEHAFIBUABTAQAAVAGgAFUBAABWAdAAVwEAAPv/AAD//wAAuQHfALEA
-GwAWARsAfAEbAK8AGwAUARsAegEbAGwAoADRAKAANwGgAG8AgwBxAIMAdgCDAHMAMwBuADMAcAAz
-AHIAMwDXADMAPQEzANQBBgDQAQAAfgA8AOMAPABJATwAeABJAN0ASQBDAUkAfwBaAOQAWgBKAVoA
-qgA/AKsAAQAPAT8AEAEBAHUBPwB2AQEAeQBqAN4AagBEAWoAqAAAAA0BAABzAQAApgA3AKcAAQAL
-ATcADAEBAHEBNwByAQEABAAIAJwBzACdAcwAngHMAJ8BiADVAcwA1gHMANcBzAC0AEcAGQFHAIAB
-RwCQACIA9QAiAFsBIgChAIgABgGIAGwBiAD6AAAA+QAAAAIBlwADAdAAAAGNAP4AEQD8ADMA/QB3
-APoAAQD5AAEAAgGXAAMB0AAAAY0A/gARAPwAMwD9AHcA+gACAPkAAwACAZcAAwHQAAABjQD+ABEA
-/AAzAP0AdwD6AAMA+QAHAAIBlwADAdAAAAGNAP4AEQD8ADMA/QB3AF8BAABhAQAAaAGXAGkB0ABm
-AY0AZAERAGIBMwBjAXcAXwEBAGEBAQBoAZcAaQHQAGYBjQBkAREAYgEzAGMBdwBfAQIAYQEDAGgB
-lwBpAdAAZgGNAGQBEQBiATMAYwF3AF8BAwBhAQcAaAGXAGkB0ABmAY0AZAERAGIBMwBjAXcA6wAA
-AOoAAADsAFUA7QAAAO4AqgDvAAAA8ADdAPEAAADrAAEA6gABAOwAVQDtAAAA7gCqAO8AAADwAN0A
-8QAAAOsAAgDqAAMA7ABVAO0AAADuAKoA7wAAAPAA3QDxAAAA6wADAOoABwDsAFUA7QAAAO4AqgDv
-AAAA8ADdAPEAAABRAQAAUAEAAFIBVQBTAQAAVAGqAFUBAABWAd0AVwEAAFEBAQBQAQEAUgFVAFMB
-AABUAaoAVQEAAFYB3QBXAQAAUQECAFABAwBSAVUAUwEAAFQBqgBVAQAAVgHdAFcBAABRAQMAUAEH
-AFIBVQBTAQAAVAGqAFUBAABWAd0AVwEAAPv/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAcswEAINQBAPScgABABQAAAAAAAByzAQBItAEANKKAAPgBAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAD42AEA/NYBACykgABUAAAAAAAAAByzAQAs1wEArKSAAFABAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAEAAAAcswEAQNMBAEA/gABQAQAAAAAAAByzAQBY1QEA8AaAAAIAAAAAAAAA
-HLMBALDVAQD0BoAABAAAAAAAAAD02AEASLQBAICkgAAqAAAAAAAAAByzAQBM1gEAAAAAAAAAAAAA
-AAAAHLMBAAzWAQD4BoAABAAAAAAAAAAAAAAAAAAAAAEAAgACAAMABAAEAAUABgAGAAcACAAIAAkA
-CgAKAAsADAAMAA0ADgAOAA8AJgAnACgAKAApACoARgBGAEcASABIAEkASgBKAEsATABoAGkAagBq
-AGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAdAB0AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUA
-dQB1AHUAdQB1AHUADwA/AAAAAAAAAAAAAAAAAAAAAQACAAIAAwAEAAQABQAGAAYABwAIAAgACQAK
-AAoACwAkACQAJQAmACYAJwBEAEQARQBGAEYARwBIAEgASQBKAEoASwBMAEwATQBqAGoAawBsAGwA
-bQBuAG4AbwBwAHAAcQByAHIAcwB0AHQAdQB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2
-AHYAdgB2AHYADgA/AESmAQAS0gAAAAAAAP//DwBwwgEAtgAAAAAAAAD/AAAAcMIBALcAAAAAAAAA
-/wAAAHDCAQC4AAAAAAAAAP8AAABwwgEAuQAAAAAAAAD/AAAAcMIBALoAAAAAAAAA/wAAAHDCAQC7
-AAAAAAAAAP8AAABwwgEAvQAAAAAAAAD/AAAAcMIBAL4AAAAAAAAA/wAAAHDCAQC/AAAAAAAAAP8A
-AABwwgEAwAAAAAAAAAD/AAAAcMIBAMEAAAAAAAAA/wAAAHDCAQDCAAAAAAAAAP8AAABEpgEAE9IA
-AAAAAAD//w8AcMIBABsBAAAAAAAA/wAAAHDCAQAcAQAAAAAAAP8AAABwwgEAHQEAAAAAAAD/AAAA
-cMIBAB4BAAAAAAAA/wAAAHDCAQAfAQAAAAAAAP8AAABwwgEAIAEAAAAAAAD/AAAAcMIBACIBAAAA
-AAAA/wAAAHDCAQAjAQAAAAAAAP8AAABwwgEAJAEAAAAAAAD/AAAAcMIBACUBAAAAAAAA/wAAAHDC
-AQAmAQAAAAAAAP8AAABwwgEAJwEAAAAAAAD/AAAARKYBABTSAAAAAAAA//8PAHDCAQCCAQAAAAAA
-AP8AAABwwgEAgwEAAAAAAAD/AAAAcMIBAIQBAAAAAAAA/wAAAHDCAQCFAQAAAAAAAP8AAABwwgEA
-hgEAAAAAAAD/AAAAcMIBAIcBAAAAAAAA/wAAAHDCAQCJAQAAAAAAAP8AAABwwgEAigEAAAAAAAD/
-AAAAcMIBAIsBAAAAAAAA/wAAAHDCAQCMAQAAAAAAAP8AAABwwgEAjQEAAAAAAAD/AAAAcMIBAI4B
-AAAAAAAA/wAAAESmAQAI0gAAAAAAAP//AwCEpgEAAIIAAAAAAAD/AQAAhKYBAAGCAAAAAAAA/wEA
-AESmAQAJ0gAAAAAAAP//AwCEpgEAAoIAAAAAAAD/AQAAhKYBAAOCAAAAAAAA/wEAAESmAQAK0gAA
-AAAAAP//AwCEpgEABIIAAAAAAAD/AQAAhKYBAAWCAAAAAAAA/wEAAESmAQAG0gAAAAAAAP8BAABE
-pgEAB9IAAAAAAAD/AwAARKYBAAbSAAAJAAAAAP4DAESmAQAH0gAACgAAAAD8DwBEpgEABtIAABIA
-AAAAAPwHRKYBAAfSAAAUAAAAAADwP0SmAQAV0gAAAAAAAP8DAABEpgEADNIAAAAAAAD/AQAARKYB
-ABXSAAAKAAAAAPwPAESmAQAM0gAACQAAAAD+AwBEpgEAFdIAABQAAAAAAPA/RKYBAAzSAAASAAAA
-AAD8BzCAAACqqqqqMYAAAKqqqqoygAAAAKqqqjOAAAAAAAAANIAAAAAAAAA1gAAAAAAAADaAAAAA
-AAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAAAAAAA7gAAAAAAAADyAAAAAAAAAPYAAAKqq
-CgA+gAAAqqqqqj+AAACqqqqqQIAAAAAAAAAwgAAAqqqqqjGAAACqqqqqMoAAAACqqqozgAAAAAAA
-ADSAAAAAAAAANYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAAAAAAAA
-O4AAAAAAAAA8gAAAAAAAAD2AAACqqgoAPoAAAKqqqqo/gAAAqqqqqkCAAAAAAAAAMIAAAAAAAAAx
-gAAAAAAAADKAAAAAAAAAM4AAAAAAAAA0gAAAqqqqqjWAAACqqqqqNoAAAAAAAAA3gAAAAAAAADiA
-AAAAAAAAOYAAAAAAAAA6gAAAqqqqCjuAAACqqqqqPIAAAAAAAAA9gAAAAAAAAD6AAAAAAAAAP4AA
-AAAAAABAgAAAAAAAADCAAAAAAAAAMYAAAAAAAAAygAAAAAAAADOAAAAAAAAANIAAAKqqqqo1gAAA
-qqqqqjaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAKqqqgo7gAAAqqqqqjyAAAAA
-AAAAPYAAAAAAAAA+gAAAAAAAAD+AAAAAAAAAQIAAAAAAAABEBYAAkJKAABgAAABQkoAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAsPMBAAYAAACULYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAABEBYAAkJKAABgAAABQkoAAAAAAAAAAAAAAAAAAAAAAAAAAAABU
-/wEABgAAAJQtgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAEQFgACQkoAAGAAAAFCSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAKALAgAEAAAAlC2A
-AAAAAAAAAAAAAAAAAHAKAgAEAAAAlC2AAAAAAAAAAAAAAAAAAGgMAgAGAAAAlC2AAAAAAAAAAAAA
-AAAAAHAKAgAEAAAAlC2AAAAAAAAAAAAAAAAAAKALAgAEAAAAlC2AAAAAAAAAAAAAAAAAAHAKAgAE
-AAAAlC2AAAAAAAAAAAAAAAAAAKALAgAEAAAAlC2AAAAAAAAAAAAAAAAAAHAKAgAEAAAAlC2AAAAA
-AAAAAAAAAAAAAGgMAgAGAAAAlC2AAAAAAAAAAAAAAAAAAHAKAgAEAAAAlC2AAAAAAAAAAAAAAAAA
-AKALAgAEAAAAlC2AAAAAAAAAAAAAAAAAAGgMAgAGAAAAlC2AAAAAAAAAAAAAAAAAAKALAgAEAAAA
-lC2AAAAAAAAAAAAAAAAAAKALAgAEAAAAlC2AAAAAAAAAAAAAAAAAAGgMAgAGAAAAlC2AAEQFgACQ
-koAAGAAAAFCSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAFAUAAAAAAAAAAAAAAAAAAAAAAP8A/wAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAwQEBAQEBQYH
-CAgICAgJCgsMDQAAAAUGBwgNDg8QFRYXGBkAAAoNERQKDREUGRkZGQoKAAAAAAAABgYGBgkJCQkA
-BgAAbjtoO2I7XDtuOmg6YjpcOm45aDliOVw5bitoK2IrXCtuKmgqYipcKm4paCliKVwpbhtoG2Ib
-XBtuGmgaYhpcGm4ZaBliGVwZbhhoGGIYXBhuF2gXYhdcF24WaBZiFlwWbhVoFWIVXBVuFGgUYhRc
-FG4TaBNiE1wTbhJoEmISXBJuEWgRYhFcEW4QaBBiEFwQVxBSEE0QSRBuAWgBYgFcAW4AaABiAFwA
-bjtoO2I7XDtuOmg6YjpcOm45aDliOVw5bjhoOGI4XDhuN2g3YjdcN24paCliKVwpbihoKGIoXChu
-J2gnYidcJ24ZaBliGVwZbhhoGGIYXBhuF2gXYhdcF24JaAliCVwJbghoCGIIXAhuB2gHYgdcB24G
-aAZiBlwGbgVoBWIFXAVuBGgEYgRcBG4DaANiA1wDbgJoAmICXAJuAWgBYgFcAW4AaABiAFwAAAAA
-AAAAAAAAAAAALCwCAAgAAADULYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAA/////////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/////////////////////////////
-/////////////////////////////////////////////////wEEAAACBQEAAwYCAAQHAwAFCAQA
-BgkFAAcKBgAICwcACQwIAAoNCQALDgoADA8LAA0QDAAOEQ0AAUAABAJBAQQDQgIEBEMDBAVEBAQG
-RQUEB0YGBAhHBwQJSAgEtxMiALgUIwC5FSQAuxYlALwXJgC9GCcAwBkoAMQaKQAHGwAACBwBAAsd
-AgAMHgMAEB8EACIhBQAkIgYAJiMHACgkCAAqJQkALCYKAC4nCwAwKAwANCkNADgqDgA8Kw8AQCwQ
-AGQuEQBoLxIAbDATAHAxFAB0MhUAeDMWAHw0FwCANRgAhDYZAIg3GgCMOBsAkTocAJU7HQCZPB4A
-nT0fAKE+IAClPyEAJEkGAixKCgI0Sw0BPEwPAWRNEQFsThMBdE8VAXxQFwGEURkBlVIdAZ1THwEA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQYCBgYGAwYGBgYGBgYEAAAAAAPAD8AAQAA
-AA8APwABAAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAgAAAA8APwABAAAA
-AAAAAAEAAAACAAAAAwAAAAAAAAAEAAAAAgAAAAUAAAAPFBkeKAoFALAJAaUAPDg0MCwoJCAcGBQQ
-DAgEAAwIBAA8ODQwLCgkIBwYFBAMCAQCCAAOAAAADgEBAAECAQEBAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClxoT4me6N9g3/vdax3lSRUGADAqnOfVYZ52K1
-5k2a7EWPnR9AiYf6Fe/rssmOC/vsQWez/V/qRb8j91OW5FubwnUc4a49akxabEF+AvVPg1xo9FE0
-0Qj5k+Jzq1NiPyoMCFKVZUZenSgwoTcPCrUvCQ42JJsbPd8mzWlOzX+f6hsSnh10WC40LTay3O60
-+1v2pE12YbfOfXtSPt1xXpcT9aZouQAALMFgQB/jyHnttr7URo3ZZ0ty3pTUmOiwSoVruyrF5U8W
-7cWG15pVZpQRz4oQ6QYEgf7woER4uiXjS/Oi/l3AgIoFrT+8IUhwBPHfY8F3da9jQjAgGuUO/W2/
-TIEUGDUmL8PhvqI1zIg5LleT8lWC/Ed6rMjnuisyleagwJgZ0Z5/o2ZEflSrO4MLyowpx9NrPCh5
-p+K8HRZ2rTvbVmROdB4U25IKDGxI5Lhdn26970OmxKg5pDE304vyMtVDi1lut9qMAWSx0pzgSbTY
-+qwH8yXPr8qO9OlHGBDVb4jwb0pyXCQ48VfHc1GXI8t8oZzoIT7dltxhhg2FD5DgQnzEcarM2JAF
-BgH3Ehyjwl9q+a7QaZEXWJknOrknONkT67MrMyK70nCpiQenM7YtIjySFSDJSYf/qnhQeqWPA/hZ
-gAkXGtplMdfGhLjQw4KwKXdaER7Le/yo1m06LAEBAQEBAQEBAgICAgICAgIDAwMDAwMDAwQEBAQE
-BAQEAQICAgICAgMDAwMDAwMDAwMDAwMDBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAEBAgEC
-AgN//wcPHz8BAwEDDwcBBw8fP3///wUABwIDBAYGdNFFF+iiiy4NDwUHCQsBAwoUN25VVVUBS2gv
-AVVVVQXjOI4DqqqqAnEcxwGqqqoKx3EcBw8PDwcGBwIDBAUAAQgJCwooACgAMAAsACwAKAA8ADQA
-KAAoADQAMAAsACwARAA8AEAAPACMAGwAWABIAPQAsAAsACwAPAA0ADAALABUAEQAVABUAGwAYABc
-AFQAjAB4ADoBAgHVAN8A2gCiAHUAfwBqARoB2QDoAAoBugB5AIgAigUqAzkBqAGKBcoC2QBIAcoB
-SgHiAPkAygHqAIIAmQD0AkQCtQHVAZQChAH1AEECrACQAIQAgAB4AHgAeAB0AGbmAACd2ImdTuzE
-TjRIgzQndmInGqRBGhM7sRMRGIERD/zAD07sxE4ndmInGqRBGhM7sRMN0iANiZ3YCQiMwAgHfuAH
-NEiDNBqkQRoRGIERDdIgDQiMwAgGaZAGsLLVBQVUQAUndmInEzuxEw3SIA2JndgJBmmQBsRO7AQE
-RmAEAz/wA6qqqqoapEEaEzuxEw/8wA8RGIERDdIgDQqogAoTO7ETD/zADw/8wA8N0iANC7RACwu0
-QAuJndgJDdIgDQqogAoKqIAKCIzACAd4gAcHeIAHBmmQBg/8wA8N0iANC7RACw3SIA0LtEALiZ3Y
-CQiMwAiJndgJCIzACAd+4AcHfuAHwSwpBwqogAoIjMAIB3iABwiMwAgHeIAHBmmQBrCy1QUGaZAG
-sLLVBQVUQAUFVEAF1h3GBEADgAbACQANgBMAGkAdgCCABgANgBMAGgAnADSAOgBBwAmAE0AdACeA
-OgBOwFeAYZkDMwfZCnMOphXmHIAgGSQzB3MOphXmHFkrzDkAQTNI2QqmFYAgWSsAQaZWgGFZbDAA
-AAA2AAAADAAAABIAAAAYAAAAJAAAAAYAAAAJAAAAAAAAAAAAAAAYIBQUDg4UFAUGAQIDBAAAAAEB
-AgECAgMEDAwIBAwEBEAAAACAAAAAAAEAAAACAABAAAAAAAQAAEAAAABAAAAAEBESExQVFhcYGRob
-HB0eHyAhIiMkJSYnKCkqKywtLi9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNk
-ZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/MxMAAAAHBw8HDw8XLQAPIADwYQAAAAAAAAAAAAAB
-AgQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAADA5OjUyOjE5AAAAAE8usABqsKKwkrBjAAGtrXsArZOcra1gAAkAAAACAAAAAAAA
-AAAAAAAJAAAAAgAAAAAAAAAAAAAACQAAAAMAAAABAAAACQAAAAkAAAACAAAAAgAAAAkAAAABAgEC
-AwQAAAUGBwgJCgAAAAUGAAIEAAUAAAAAAAUHAQMEAAUBAAAAQCNAJSEhISFAQEBAQAUEBAEBQEBA
-QAUFQEAMDEANDAwBAQEFQEAFBQAEAARAQAAEQEBABUBAQEBABUBAQAUFBQEBAQFABQUFAQUBAUAF
-BQVABUAFBQUFBQQAAAAcEQAAHDIAABwzAAAEAAAAHBUAAAIAFwBsAHAEdAh0DAAEBAYAAAAAAAAA
-AGQAAAAAkAEACgAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAQAAABAAAAAAAAAA
-AQAAAAEAAAAAAAAA/wAAAP8AAAAAAAAAAAAAALx8AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAEAAAAFAAAAAAQAAGQAAABQgwEAWIMBAGCDAQC4gwEAwIMBAMiDAQAHBwcHBwcH
-BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcGBgYGBgUF
-BQUFBAQEBAQDAwMDAwICAgICAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAolQ8BOfJgABxctYDQAAAAEDgkdLTcAAAQOCR0sOwABEAAB
-AAAAAoAAAUIGAhAAAiAAAAPAAAFDBgMQAALAAAADwAABQwYEEAACQAAAAoAAAUQGBREAAEAAAAPA
-AAFFBgYRAADgAAADwAABRQYHEQABAAAAAoAAAUYGCBEAAiAAAAPAAAFHBgkRAALAAAADwAABRwYK
-EQACQAAAAoAAAUgGCxIAAEAAAAPAAAFJBgwSAADgAAADwAABSQYNEgABAAAAAoAAAUoGDhIAAgAA
-AAKAAAFMBgAAIhYAAIAAAAMAAAFZACQWAAEAAAADAAABWgAmFgACAAAABAAAAVoAKBYAAgAAAAMA
-AAFbACoWAAKAAAADAAABXAAsFwAAAAAABAAAAVwALhcAAIAAAAMAAAFdADAXAAEAAAADAAABXgA0
-FwACAAAAAwAAAV8ANhcAAoAAAAMAAAFgADgYAAAAAAAEAAABYAA8GAABAAAAAwAAAWIAPhgAAgAA
-AAQAAAFiAEAYAAIAAAADAAABYwBkGwACAAAAAwAAAW8BZhsAAoAAAAMAAAFwAWgcAAAAAAAEAAAB
-cAFsHAABAAAAAwAAAXIBbhwAAgAAAAQAAAFyAXAcAAIAAAADAAABcwJ0HQAAAAAABAAAAXQCdh0A
-AIAAAAMAAAF1AngdAAEAAAADAAABdgJ8HQACAAAAAwAAAXcDfh0AAoAAAAMAAAF4A4AeAAAAAAAE
-AAABeAOEHgABAAAAAwAAAXoDhh4AAgAAAAQAAAF6BIgeAAIAAAADAAABewSMHwAAAAAABAAAAXwE
-kR8AAUAAAAMAAAF+BJUfAAMAAAAEAAABfwWXHwACwAAAAwAAAYAFmSAAAEAAAAMAAAGBBZ0gAAFA
-AAADAAABggWfIAABwAAAAwAAAYMFoSAAAwAAAAQAAAGDBaUhAABAAAADAAABhQUAALDwAQCw4AEA
-lOIBABTkAQAk5gEApOgBALTsAQB47gEA0O8BAAAPCw8NAAAAUAQCAGQEAgDQBAIAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEB
-AQECAgICAgICAgMDAwMDAwMDAQIAAA4AAAAqAAAACQAAAAsAAAAV9mP2sPb89kb3kPfY9x/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/9
-qf2C/Vn9MP0F/dn8q/x9/E38HPzq+7b7gftL+xT73Pqi+mf6K/ru+bD5cPkv+e34qfhl+B/42PeQ
-90b3/Paw9mP2cLmDupa7qry+vdK+57/8wBHCJ8M9xFPFasaAx5fIr8nGyt7L9swPzifPQNBZ0XLS
-jNOm1L/V2tb01w7ZKdpE21/cet2W3rHfzeDp4QXjIeQ+5Vrmd+eT6LDpzerq6wftJO5C71/wffGa
-8rjz1fTz9RH3L/hM+Wr6iPum/MT94v4AAB4BPAJaA3gElgW0BtEH7wgNCisLSAxmDYMOoQ++ENwR
-+RIWFDMVUBZtF4kYphnCGt8b+xwXHjMfTyBqIYYioSO8JNcl8iYMKCYpQSpaK3Qsji2nLsAv2TDx
-MQozIjQ6NVE2aTeAOJY5rTrDO9k87z0EPxlALkFCQlZDakR9RcULZBJQnRsSv2DVEeo8kREjGk8R
-G+IOEcp/0BBY35MQBe5YEBqaHxDU0ucPVoixD5mrfA9bLkkPGAMXD/oc5g7Rb7YOBPCHDo2SWg7u
-TC4OKBUDDrbh2A2Bqa8N4GOHDY8IYA2ojzkNnfETDTkn7wyUKcsMFPKnDGZ6hQx6vGMMg7JCDPFW
-IgxspAIM1ZXjC0EmxQv3UKcLbRGKC0ZjbQtSQlELh6o1CwOYGgsKBwALA/TlCnZbzAoMOrMKjYya
-Ct5PggoBgWoKEB1TCkMhPAroiiUKZVcPCjeE+QnvDuQJNvXOCcU0uglsy6UJCbeRCY/1fQkBhWoJ
-cGNXCQGPRAm5WxkAahEZAPTHGABWfxgAjDcYAJXwFwBuqhcAFGUXAIUgFwDA3BYAwZkWAIZXFgAO
-FhYAVdUVAFqVFQAbVhUAlBcVAMXZFACsnBQARWAUAI8kFACI6RMALq8TAH91EwB6PBMAGwQTAGHM
-EgBLlRIA1l4SAAEpEgDK8xEALr8RAC2LEQDEVxEA8SQRALTyEAAKwRAA8Y8QAGhfEABuLxAAAAAQ
-AB3RDwDDog8A8nQPAKZHDwDgGg8AnO4OANrCDgCZlw4A1mwOAJBCDgDHGA4AeO8NAKHGDQBDng0A
-W3YNAOhODQDoJw0AWwENAD7bDACStQwAU5AMAIJrDAAdRwwAIiMMAJH/CwBo3AsAprkLAEqXCwBT
-dQsAv1MLAI4yCwC9EQsATfEKADzRCgCJsQoAM5IKADlzCgCaVAoAVDYKAGcYCgDR+gkAk90JAKrA
-CQAWpAkA1YcJAOdrCQBLUAkAATUJAAYaCQBa/wgA/OQIAOvKCAAnsQgAr5cIAIF+CACdZQgAAU0I
-AK40CACiHAgA3QQIAF3tBwAi1gcALL8HAHioBwAHkgcA2HsHAOplBwA8UAcAzToHAJ4lBwCsEAcA
-+PsGAIHnBgBF0wYARb8GAH+rBgD0lwYAoYQGAIdxBgCmXgYA+0sGAIc5BgBKJwYAQRUGAG4DBgDP
-8QUAY+AFACvPBQAlvgUAUa0FAK6cBQA8jAUA+nsFAOhrBQAFXAUAUEwFAMo8BQBxLQUARB4FAEUP
-BQBxAAUAyfEEAEzjBAD51AQA0MYEANG4BAD6qgQATZ0EAMePBABpggQAMnUEACJoBAA4WwQAdE4E
-ANVBBABcNQQABikEANYcBADIEAQA3gQEABf5AwBz7QMA8eEDAJDWAwBRywMAMsADADS1AwBXqgMA
-mZ8DAPuUAwB8igMAG4ADANl1AwC2awMAr2EDAMdXAwD7TQMATEQDALk6AwBCMQMA6CcDAKgeAwCE
-FQMAegwDAIsDAwC2+gIA+/ECAFnpAgDR4AIAYtgCAAzQAgDOxwIAqL8CAJq3AgCjrwIAxKcCAPyf
-AgBLmAIAsJACACyJAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn////zv///7X///+c////AAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAA5////87///+1////nP///wAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAOf////O////tf///5z///8TAQAA4QAAAK8AAAB9AAAAfQAAAK8AAADIAAAAyAAAAMgAAADI
-AAAAEwEAAOEAAACvAAAAfQAAAH0AAACvAAAAyAAAAMgAAADIAAAAyAAAABMBAADhAAAArwAAAH0A
-AAB9AAAArwAAAMgAAADIAAAAyAAAAMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAlgAAAJYAAACWAAAAlgAAAJYAAAB9AAAAfQAAAH0AAAB9AAAAfQAAAJYAAACWAAAA
-lgAAAJYAAACWAAAAfQAAAH0AAAB9AAAAfQAAAH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAXgEAACwBAAATAQAA+gAAAOEAAADIAAAArwAAAH0AAABkAAAAZAAAAF4B
-AAAsAQAAEwEAAPoAAADhAAAAyAAAAK8AAAB9AAAAZAAAAGQAAAAAAAAA/////wAAAAAAAAAAAQAA
-AAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAABAAAAAQAAAAAAAAAAAAAABQUFBQUFBQUAAAAAgA0AAAAgAACADQAAgA0AAAAgAACA
-DQAAAAYAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIIAPAABAAGkgAABpIEAAaSAAAGkgQAAgIIAPAADo
-AGkgAABpIEAAaSAAAGkgQAAgIIAPAABkBmkgAABpIEAAaSAAAEogAABKIQAASiIAAEojAABKJAAA
-SiUAAEomAABKJwAASiAAEEohABBKIgAQSiMAEEokABBKJQAQSiYAEEonABBKIAAgSiEAIEoiACBK
-IwAgSiQAIEolACBKJgAgSicAIEogADBKIQAwCiSAP4EAAEBBLJwwQCycMEIkHDQKIoA/gAA4cwoj
-ADfmDwAASiYAcGkgQABKJgBwSiYAcEomAHBKJgBwABYAcIAAZARAeCAgQIcAAAAAAAAAAAAA4cDh
-weHCz3CgAMgfFhABhs9ygACYhyCiEhABhiGiExABhiKiFBABhiOiFRABhiSiJBABhiaiz3GfALj/
-VqGKIf8PEhhYgBMYWIAUGFiAFRhYgCQYWIDBwsHBwcAgIECHDMjPcqAAyB8OGhiADcgPGhiADsgQ
-GhiADxIBNgHIJHgRGhiAEMgtGhiA4H7hxPwcyL78HEi+4cDhweHC4cP8HAix/BxIsfwciLH8HMix
-/BwIsvwcSLL8HIiy/BzIsvwcCL9qJIAQ4cRqJMAQ4cTxwM9woADQGxSAz3GAAGAEBCCAj89RBOEA
-oQryLykBAM9wgAA0D/AgQABAeNr/0cDBxGskwBDBxGskgBDBxJ90BBQLNAQUCjQEFAk0BBQINAQU
-BzQEFAY0BBQFNAQUBDTBw8HCwcHBwMHERSx+EAomQH7BxGskgBTBxCAgQIcMyIe4DBoYMA3Im7gN
-GhgwDsgOGhgwD8iHuA8aGDAQyBAaGDDgfuB48cAMyJW4DBoYMA3Im7gNGhgwD8iKuI24kLgPGhgw
-z3CAAGwQGIgbCFEAD8jPcQAAiAysuA8aGDA+DiAAD9hn2IYKIAGKIQYK0cDgfvHAz3CAALy1AICG
-IP6BCfQPyAUggA8AAADUDxoYMKH/iiBVBVYKIAGKIUYO6PHgeM9xAwBADc9woACoIC2gz3GAAIwE
-QIEBagChz3CgADguBYAEIIAPwAAAAB0IgA/AAAAASNjPcZ8AuP8aoVuhadgYuBmhz3CAAMgJJYAj
-gSCBx3EAAIgT5QLACeB4z3CAAMgJeQLACeB48cBuCwABz3eAAGAEiHUG6A0IUQAB2APwANgLrwXp
-DwlRAAHYAvAA2AqvBuoNClEAAdgD8ADYDK8A2M92oADIHxgeGJALj4ohEAAO6AiPDOjPcAMAQA1F
-HhgQMKYC2BgeGJAD8DGmCo8Y6AmPFujPcAIApkEgHhiQz3CAACgAIR4YkM9wgABcBCIeGJAYFgCW
-RSAAAxgeGJAMjwjoGBYAloUgAQQYHhiQDwtRABgWAJaIuBgeGJDPcIAAMHwAkI7gzCCiggb0GBYA
-loC4GB4YkBjtANiUuM91gACABAClcdgGuMYMIAH82SCFz3AAAEwctgwgAZ+5GBYAloW4GB4YkNUC
-AAHPcaqqu7vPcJ8AuP82oDagNqA2oM9xoADIOw6BiLgOoWkgQAD+8eB48cClwUHAQsEMHAAxEBxA
-Mc9xgAB8dDQZwA8wGQAPLBnADigZgA4kGUAOz3CAAHx0IBhAC89wgAB8dBwYAAvPcIAAfHQYGMAK
-z3CAAHx0FBiACs9wgAB8dBAYwAjPcIAAfHQMGIAIz3CAAHx0CBhACM9xgAAAdIAZAAh8GcAHeBmA
-B3QZQAdwGQAHbBkAB2gZgAZkGUAGYBkABlwZwAVYGYAFVBlABVAZAAVMGcAESBmABEQZQARAGQAE
-76HOoa2hjKEsGcACKBmAAiQZQAIgGQACHBnAARgZgAEUGUABEBkAAWOhaiAAA9gZAABqIMAC1BkA
-AGoggALQGQAAaiBAAcgZAABqIAABxBkAAGogwADAGQAAaiCAALwZAABqIEAAuBkAAGogAAC0GQAA
-aiCAAcwZAADQ2J+4z3GfALj/HaHPcIAAAADEgFMlxDVTJsU117oB5tO+xKBTI8AEBSaOH9D+AADW
-oQUggA+w/gAAFqEYgVMnzjUA3ZS4GKFAwwHAAsHJcwwUBjB+D+AAEBQHMM9woAC0D7ygz3GgAMg7
-LoEWD+AAfdhaDkABFgsgAalwCNgA2cYKIAGZuc9wgAAwfACQjuDMIKKCyiCBD+AAxDHKISEA4A8h
-Ac8hoQX9Bc//8cA6CCABe9jODuAA4dnPcYAAfHQ0GcAPMBkADywZwA4oGYAOJBlADs9wgAB8dCAY
-QAvPcIAAfHQcGAALz3CAAHx0GBjACs9wgAB8dBQYgArPcIAAfHQQGMAIz3CAAHx0DBiACM9wgAB8
-dAgYQAjPcYAAAHSAGQAIfBnAB3gZgAd0GUAHcBkAB2wZAAdoGYAGZBlABmAZAAZcGcAFWBmABVQZ
-QAVQGQAFTBnABEgZgAREGUAEQBkABO+hzqGtoYyhLBnAAigZgAIkGUACIBkAAhwZwAEYGYABFBlA
-ARAZAAFjoWogAAPYGQAAaiDAAtQZAABqIIAC0BkAAGogQAHIGQAAaiAAAcQZAABqIMAAwBkAAGog
-gAC8GQAAaiBAALgZAABqIAAAtBkAAGoggAHMGQAA63bPdaAAyB8ZFRGWz3AAAEQccg8gAQogwC9a
-cM9wgABsKiOAz3OfALj/z3eAAAAABIcB4NO4IukZFQKWQQreAF2DQN6fvt2jBKcFIIAP0P4AABaj
-WBuAByEVAJYiFQCWBCGBD/8A/P8AgRajCNgZHRiQVqNdo9EGwADQ2Z+5PaMEpwUggA/Q/gAAFqPP
-cIAAgAQAgAsggIQI8lgbgAR+CUACDNgt8IwhBKAm8owhAaAi8kIhQSBFCRUEMyZBcIAAAFxAJwBy
-NHgAeEohQCAN2BfwSiGAIATYE/AT2EohACEP8EohACIU2AvwSiEAJBXYB/AW2AXwF9gD8A/Yz3OA
-AOANcIMKcclyCiRABOUD7/8KJYAE4HhFAs//8cDGDMAAddiCDOAAiiEKA64MAAACDoACYf6iCAAA
-CiHAD+tyBtiKI0oHSiQAAKkD7/8KJQAB4HjxwATpGQgSCAohwA/rcgXY49tKJEAAiQPv/7hzz3KA
-ADQPFXogotHA4H7geADZnrkZec9ygAAsDwGCJXjgfwGiANmeuRl5z3KAACwPAYImeOB/AaIA2Z65
-GXnPcIAALA8BgCR4QiAAgOB/yiBiAOB4z3CAACwPAYDgfy8oAQDgePHA+g+P/+B44HjgeOB4aSCA
-AW8hPwBpIAAA9/HxwGrYsgvgAIohxAUA2I24ug7gAwoaGDAUzIYg/4oJ8s9wgAApBQCIgOCgCwIE
-r/HxwMYLAATPcYAA4AnwIQAAQHjPcKAA0BuA2lCgz3CAAAAAAIAA2Q8IHgLPcJ8AuP89oJXx8cDe
-DMAAz3GAAAAAAIE5CN4AAYFRIMCAQNjPIOIHyiCBDwAA0ADPIOEHz3KfALj/HaIEgQHg07gEoQUg
-gA/Q/gAAFqLPcIAAYASggM9wgABsEAiABCWNHw8AAOAB3g0I3wKODsALjujPcaAAtEcA2EsZGIB3
-GZiDANieuFQZGIDPcoAAmAQgguGCBCWEHwEAAABALIAApHgEJYMfAAAAQAd5A7sgoqR7BHlnfwYl
-QBDhogQlgR8AAACALyICAUV5ArnkewQljR8CAAAAZnikeSZ4LygBAE4gQQTPcIAAfHPwIEIAz3CA
-AFC7hCoLDDAgQA5TIECAGxpYMCr0z3CfALj/OKAvCZEBz3KAAIiGCZIL6BsamDPJcc9ygADgDRuC
-AeAbohTwDJIS6ATZGxpYMPTxhOHMIWKACvTPcIAAiIYOkAboBtkbGlgw6PHPcqAAFAQqos9wgABE
-CQCIDQhRAAmCuOAA2IP3AdiI6M9woACIIDV4wKA48M9xgAAwBQDYAKEA2ZG5z3CgAMgfExhYgM9w
-gADQAhB4z3WgALRHSR0YkM9xgADElc9wgAA0BSCgbydDEFQd2JOuDOADChqYMy4NwAuQ6ADYkbjP
-caAAyB8TGRiAz3CAAAAEEHhJHRiQVB3Yk2EDwADxwPYKwADPcYAAsA6AEQAAz3WgAMgfLy4BEM9w
-AwBADUUdGBAA30MO0BfPcoAAAAAAgjcIngQBgvK4QNvPI+IHyiOBDwAA0ADPI+EHz3CfALj/faBk
-ggHj07tkogUjgw/Q/gAAdqDwIYADQHgZDtAXz3CAAAAAAIANCJ4Ez3CfALj//aCA2BUdGJDVAsAA
-4HjxwM9xgABgBHzY0gjgACCBCiHAD+tyBdj920okAAAJAO//CiUAAeB48cDhxc9wgABgBKCAa9gE
-JY0fDwAA4J4I4ACKIQgLLyhBAzYMoA9OIEAECiUAgMohwg/KIsIHyiBiAcojgg8AADICvAei/8ok
-YgB/2Aq4z3GgANAbE6F/2BChXQLAAOB48cDhxc91gAAAAACFNQjeAwGF77hA2M8g4gfKIIEPAADQ
-AM8g4QfPcZ8AuP8doQSFAeDTuASlBSCAD9D+AAAWoWvYEgjgAIohyA+uC6APBNgKJQCAyiHCD8oi
-wgfKIGIByiOCDwAAQQI0B6L/yiRiAACFEQjeAwDZz3CfALj/PaDVAcAASiTAdQDZqCDAA89wgAC0
-DzZ4YYBAgM9wgACwDgHhVXhgoOB+4H7geA0JXkcNyL24DRoYMADZnbnPcKAA0BsxoOB+4HjgfuB4
-8cCB4MwgooAF9M9ygABsEATwz3KAAGS4z3GAALSHgeDMIOKAKfRogmChaYJhoXyKaKl9immpKhKD
-AGqpKxKDAGupLBKDAGypdJJ2qW2SZ7F3kmixaILAu3SpaIIEI4MPAAYAAIDjAdvAe3KphBICAFQZ
-mAAc8GCBaKJhgWmiaIl8qmmJfapqiSoawgBriSsawgBsiSwawgB2iXSyZ5FtsmiRd7JUEQMGhBrA
-AA0IkQDeCyABQCEABtHA4H7PcIAAZLgggM9yoACAJSaiIpAnoiKAKqImkCuiz3GAALy1IIFRIUCA
-IIAV9CiiIpApoiKAMaImkDKiIoA3oiaQOKIigDuiJpA8oiCAOaIikDqiIIA1oiKQNqIhAUAQ4Hjx
-wPYPgADPcIAAeJ4A3tSoz3CAALy1AIApCF4ACN/JdYDlzCWikMwlIpHMJWKRVA1iBMogQgNhv+kP
-dZAB5R3wiiQBcc9xgACIhqgggAEEGZAD4HgA2UokAHLPcoAA4IioIMACFiJAAHaQz3CAAACHNHgB
-4WCwz3WAAGS4z3eAAFCaQCUAEiRv6gzgAAbaqXBAJ4ES3gzgAAbaQCUAEkAnARTSDOAABtoYjSEI
-EQGKIA8Kug2gAIohmggoFYAQTg7gECiFCg6ADwmFFwheAYoghw6aDaAAiiEaDgYMwAnPcIAAvLUA
-gFEgQICADIEEz3EAAP//z3CAAASXLKAroAUamDOo/1kHgADxwO4OoAAA2oQoCwwAIYN/gABkuLUb
-mADPdoAAEFy0aLpmUoIChgAhgX+AAGC6z3eAAASJuhuYAGGG3BnAAGWG4BkAAAaG5BnAAOgZAAAW
-J4AQFiaBEAjgBOFSD+AFCNrdZRSFFn4Wf0AnABIkbj4P4AUI2uEGgADxwADY4f/SCCAGANjPcIAA
-zC5WDkAJz3CAAAwvSg5ACVoLAAZqCUAFAdgA2X4IYA+A2iYKQAzaC4AP0grACUYMwArCCUAKANg2
-CWAQCHEaD4AMhgsACskFz//gePHA4cUA3c9wgABcBaCgz3CAAFyerLACDuAJqXAqCo//igxgDKlw
-jg1ABm4IgASqCkAL6gygDKlwtgyADFUGgADxwN4NgACjwQ0IkQDPdYAAbBAI8IQoCwwAIY1/gABk
-uA0IkQDPdoAAaKUJ8M9xgAAsu4QoCwwAIU4OLZU8eihwhiHxD0e5wrqGIP4DJHpEuFBxyiHCD8oi
-wgfKIGIByiOCDwAAPATKJCIAMAOi/8olAgFIhTu6UyICgECuTZXAukGuDPJ3lYYj/wlDu2eud5WG
-I/4HRbtorhHqz3KAAFg3FSIDAACLNXoCrgGLA64CiwSuA4sFrgOKCvAB2SmuAtgCriOuANgErgPY
-Ba4GrotwyXHGDeAFDNoAwAHB/g2gDALCi3DJcbIN4AUM2gDAAcFqDqAMAsLPcYAA2AYAoQ2VRLgA
-2S+lDQgeAIohCAAvpQkIXgCLuS+lCQieAI25L6UpBaAAo8DgePHAsgygAJhwhCgLDAAhgH+AAGS4
-VSBGCiiAVSDFC89ygAAYBVEhwICKIQgAyiEhACCiSiQAcgDZqCBAD891gABYYPyILmXkfi8qgQNO
-IoMHz3KAAHxgb2IAJkMA4KtUEI8A5H4vLoETTiaPF+5iyKvIgCEO3hBdiIbh0yKmAC8qgQBOIo0H
-z3KAAIRgqmIR8M92gABsYC5mzmW8iMR9bBCOAMR9Ly1BE04ljhfKYlCrAeFKJAByANqoIMAP3IjP
-c4AAZGBPY891gAB8YOR+LymBA04hjwfvZQAmgQD8qVQQjwDkfi8ugRNOJo8X7mUkGYIDyIAfDt4Q
-fYiA4tMjoQAvK8EATiONB89zgACEYKtjEPAE6slqA/BIds5jfIjEe2wQjgDEey8rwQBOI44Hy2Us
-GcIAAeJKJABxANqoIAAFz3GAAGBgfYhJYQAljAAB4mR5LylBAE4hgwfPcYAAhGBpYSCsjg6gCIhw
-sQOAAOB48cBCC4AADwiRAM9xgABsEAfwhCgLDAAhgX+AAGS46YFYiUEvwxDAuxe7x3MAAIAc5L/P
-IyIG4L9O3c8jogDKJYIfAABOAYbizyVhElEPXxHPcoAAtIcWEoUAz3KAAHC7RpLPdoAAZLjFFgQW
-GQpBAcQWAhZTIgUAz3KAALSHVIoTCkABQSxCAQsKHgBJhhMKXwENDF8BSYYHCl4BgbvPcoAAWLtU
-iofizyPhAFEnAJLPI6IFiBnAAIwZQAMNCJEAz3GAAGwQCPCEKAsMACGBf4AAZLhpEYMAThEOAQ4j
-gg8AADoBCbpifkV+WpFiehK6RX5bkWJ6QCrNBcV9BCW+nwDwAADKIcIPyiLCB8ogYgHKI4IPAADF
-AM8j4gLKJMIA4Adi/8olQgOQGUADDQiRAM91gABsEAjwhCgLDAAhjX+AAGS4z3CAADB8AJCO4Mwg
-ooIp8gfYQgrgAAq4BCCADwcAAAAwuGcIFQIzJgBwgAB0XEAngXIUeQB5iiAEAJQdABAf8IogEACU
-HQAQGfAA2Iu4lB0AEBXwANiMuJQdABAP8ADYjbiUHQAQC/AD2Ay4lB0AEAXwANiOuJQdABCCIAEB
-6QGgAJQdABAKIcAP63IF2Prbi7tKJAAAKQdv/wolAAHgePHAXgmAAAh1DQiRAM92gABsEAjwhC0L
-HAAhjn+AAGS4AdloHkIQAN+AHsATTNhOHgQQBdgQpgrYG7YQ2Bq2FNhMHgQQLdhQHgQQJthSHgQQ
-SiQAculwqCCADc9ygAC4YPQiAwDPcoAAHJgUemCyz3KAAMhg9CIDAM9ygAAsmBR6YLLPcoAA2GD0
-IgMAz3KAADyYFHpgss9ygADoYPQiAwDPcoAATJgUemCyz3KAAPhg9CIDAM9ygABcmBR6AeBgsgiG
-DwheAQTaYh6CEAPwYh7CExkIHgEJ2WoeRBAu2l22AtppHoIQCvAU2moehBAy2l22aR5CEBTZWY5Z
-YTB5ah5EEBrhPLYXCB4ACthkHgQQBthmHgQQB9gH8BDYZB4EEGYexBMF2BCmqXCX/jyOKHBUHkIQ
-hiADAOa5bB4CEMoiQQAM8lAhwwFvelQewhBQIMMBb3hsHsIQEQleAUhzhiMDAG96VB7CEAsJHgGl
-uGweAhANCd4ApLpUHoIQMQ2QEKlwy/7PcIAAOLuELQscMCBADlEgQIDx2MAoIgHKIIEPAACTAMAo
-IQGgHgAQGNiNuBemCIZRIMCAz3CAAGS4BvK+EIAAibgE8KUQgAAWps9woACsLxmAMLjAuM4KIBBV
-HgIQCIYEIL6PAAYAAAvyNrjAuBt4AeBuHgQQAtiAHgAQA/BuHsQTANgcph2mqXAE/yiGAdpIc0Ep
-AAU1uVIgAABSIQEAwLjAucoLb/+YcpkHQADgeM9wgABsEAiAz3GkABxAwLgTeMG4EqHgfvHA4cXP
-dYAAbBBXlc9xgADcBlfYAKELCh4AX9gAoQsKngCFuAChCwpeAIe4AKHPcYAAaKVAiQDZgOLKIEEA
-z3GlAOgPBqHPcaAApDABgYDizyDiANAg4QABoVIPwAwwhc9woADIHCig8g8gDQ+FHQdAAOB44cXP
-cIAAbBApgEQhg4AA2iP0iwoVBAAijQ+AANAsAI2guACtgBWAEKC4gB0CEEAVgBCguEAdAhAQjaC4
-EK2QFYAQoLiQHQIQUBWAEKC4UB0CEAHi3/FHChUEACKND4AA0CwAjYC4AK2AFYAQgLiAHQIQQBWA
-EIC4QB0CEBCNgLgQrZAVgBCAuJAdAhBQFYAQgLhQHQIQAeLf8SUJngHPcoAA0CwIioC4CKqIEoAA
-gLiIGgIASBKAAIC4EfCR689ygADQLAiKoLgIqogSgACguIgaAgBIEoAAoLhIGgIAANg9CR4ASiQA
-dOB4qCBABi0IngAAIIMPgADQLCATgQCAuSAbQgCgE4EAgLmgG0IAYBOBAIC5YBtCAAHgHfBKJAB0
-4HioIEAGLQieAAAggw+AANAsIBOCAKC6IBuCAKATggCguqAbggBgE4IAoLpgG4IAAeDgf8HF4Hjx
-wEYNYAAH2s92oADIH0gemJDPdYAAbBCAFQAQz3GrAKD/TB4YkADYGaFaoRihiiAEAA+mahUAEc93
-gAAwfLAeABC0HgAQH9gIuA6mCIVRIACAANiLuBXyEKbqD8APz3GgAKQwAYGEuAGhBJc1CFEBANmU
-uc9woAAERCWgEvARpsYPwA/PcaAApDABgaS4AaEElxEIUQHPcaAABEQA2AWhz3CAAMwEAIAVCB4A
-hiD/DiK4FLjPcaAABEQFoVj/ogyADF3/ef/PcAAAVVVaHhiQAdhZHhiQCIXPcaYAKAARCN4EANgP
-oTYIABAE8AHYD6FuFQERz3CmAOgHJqBGDYADMg1gDA2VB48K6Iog2AmuCmAAAdmODiADAtgF8N4L
-oAMB2IgVABDPcaAAxCcPGRiAjBUCEM9woAAwEESgz3CAABSREHiPGRiAz3KAAMSRUHiWIgIAELpF
-eJAZGICKIAQAkhkYgJAVABBAl0AZAIDPcIAA0CxTGRiADxEAho7in7gPGRiAzCKiggf0CBEAgIUg
-hAAIGQCAEQqRAggRAICKuAgZAIAP2BAZAICUFQAQHBkYgAiFHQheB7YM4A8A2L4M4A8B2M9xpgD0
-zwHYEqEE8KIMwA/ZA0AA8cBqC0AACiUAkM9wgABkuBpxBfTFEAEGAvApgCW5TwkeAM9ygAC0h89x
-gABwuyaRdooTC0EAxBABBlSKwLkVCYAAxRABBg0JXgEpgB8JXwEKIcAP63IF2M9zAAARCUokAADN
-AG//CiUAAYQtCxwvd892gABsEPhgyXEqCKAAKdrPcYAAaKUAJ4AfgAAsu14IoAAM2s9woAC0DwDf
-/KBIhlMiAAB6CyAMNJYeDQADX/+A5dgMYQzKIGEABMgLCJ4ASg4ABAvwANmeuc9woAD8RCGgz3Cg
-ALQP/KBMIACgiA3iD8ogYgDPdYAAoAQMjYbo5g8ADQHYDK3VAkAA8cBmCkAACiUAkAHYEPIEyBsI
-nwAKIcAP63IF2IojRw5KJAAADQBv/7hzANiELQscz3aAAGS4ACZPHoQoCwxAJgEZMCFADkmHJbgl
-ulMgEQBTIhIA6XCqDmAADdmiCqAQqXAJhyW4UyAQAIbtA9g9/IP8BPBuDMAPPQgQIEwiAKDKIcIP
-yiLCB8ojgg8AABsCyiBiAcb1eg5ACLYPoAAB2M93gAC8tQ8JESAWDIAKGgyAChbwmg+gAADYz3eA
-ALy1g+3P/AjwGgzADwCHUSBAgBwMwg9MIQCggAuB/6lwDv6KCqABqXAE2AQaGDBdCREgz3GAALSH
-z3CAAHC7BpBWiREKAQDEFgAWNInAuBkIQADFFgAWEQheAQmGDQheAQCHKQhfAKlwCnF3/3/ZEbnP
-cKAAsB80oB4JQAgPyAUggA8BAAD8DxoYMACHRQheAM9xgAC0h89wgABwuwaQVokTCgEAxBYAFjSJ
-wLgXCEAAxRYAFlEgQIEJhtEgYoEI9BiOz3GAAGwQGKkJhgmhAd52D+ALyXDPcIAAsQaeDeALwKgZ
-DVEQz3CAAFi7FIgNCNEBTCAAoJgLwg9uC8AP/gxAAMYI4AIA2P0AQADgePHAANiM/1IMD//PcYAA
-tIcWiVoLYBA0iTUAj//xwIYIQADPdoAAZLgIdQsIUQDphgPwxRYPFiW/hC0LHAAmUB4kEAAgwL9R
-IECByiHBD8oiwQfKIGEByiOBDwAArQLKJCEABAYh/8olAQHPcIAAwBABiMxxs+1Agc9xgAC0h0Ch
-ABYDQIDgYaEAFoNAaKkAFoNAaakAFgBBAvIPtgAWgEAEIoIPAAYAAAqpABaAQIDiC6kAFoBAAdoM
-qQAWgEAAFgBBwHoHsQAWAEEIsQAWAEBSqcYOb/8E2DjwIIHPcoAAXLzEHlgQABYBQIDgxR5YEAAW
-gUAUGkKAABaBQBUaQoDMcAjyIJDPcIAAcLshsAPwAJAAFoBAz3GAAGC8IhoCgAAWgEAjGgKAABaA
-QCQaAoAAFoBAABYAQQ4ZBIAAFgBBIhkEgAAWAECveID9UgigAalwz3GAALSHVonPcIAAcLsGkJ3v
-EQoBAMQWABY0icC4HwhAAMUWABYXCF4BCYYTCF4Bz3CAALy1AIATCF8AJBABIKlwJbnAuej+wgnA
-D1ILQABlBwAA4HjxwADYnP/PcYAAtIcWibYJYBA0iZEGT//xwADZz3CgALQPPKByD4AMQgvADAIJ
-AAwWCCANANj/2c9wqwCg/zmgAtgGC2AABBoYMF0GT//geIQoCwwAIYB/gABguuAQAgDPcYAAsInc
-EAMAYBmAgOQQAgDoEAAAXBnAgGwZgIDgf3AZAIDxwHIOIAAS2anBCHbSDGAAi3BKJABxANqoIIAC
-FiSAMCiICwmSAGG5KKgB4gHCAsGELgscACGAf4AAYLrcGIAABcLgGEAABsG0buQYgADHdYAAEFxI
-FREQ6BhAAM9wgAAEiQogQC4WIEAECOCDwcoOYAUI2vSFz3CAAASJh8H2eAjgtg5gBQjaAMAAII0v
-gABkuLUdGBATCB4Auh3YE7sVABaAuAbwuh1YFLsVABaguLsdGBDPcIAAQLhUiDaIRCo+CwAhgH+A
-AJy2NXgGiBB2/A7h/8oggQO1FQAWUSBAgPHYwCgiAcoggQ8AAJMAwCghAdIJYACgHQAQ2QUgAKnA
-ANiA8fHApcGLcP4JYAAF2QDCKwoeAM9wgABsEBiIHwhRAADYmrjPcaAAyB8PoQHApBkAAMPYGrgO
-oSsKngAGEgI2ANlKJAByqCBAA7hxg3EoiQAiQDFkGEIAFQpOAEAlQQBiCUAApcDRwOB+CiHAD+ty
-BdiKI48DwQIv/0okQADxwM9wgABsEAmAUSBAgcohwg/KIsIHyiBiAcojgg8AABcHyiRiAJQCIv/K
-JcIAvg0ADMYMYAkB2M9wgABYuxSIRQjRAc9wgABMuwuAOQheAc9wgADotgqQz3GAAKieJYEKuDBw
-yiHCD8oiwgfKIGIByiOCDwAAIQfKJCIAPAIi/8olwgCiCA//AgvgCwDY7gjAC7IIQAANBE//4Hjx
-wALYv/zF/f0DT//xwFIMAAAA3s91oAC0D9yl8gzgC2h3+P9WDiAM6XAEyAsIngDKD8ADCPAA2Z65
-z3CgAPxEIaDcpYEEAACEKAsMz3GAAEy7MCFCDs9wgADgiFZ4dpDPcYAAtIfEGdwAF5DPc4AAsInF
-GRwAz3CAAASJVngMiJAbAoAA2OB/xxkcAPHAXg1P/zoOgA+yDU//bQNP/+B48cDCCyAARNrPdYAA
-EFzEbc9xgAAIiSYJYACpcEokgHAA2agggAgUadhgcYCEKQsMACGCf4AAZLgAIYB/gABguroa2AAA
-27Ua2ABhhUKFAeHcGMAAZYXgGIAARoXkGMAA6BiAAMkDAADPcIAAtIeVBCAAiiEFBeB48cBCCyAA
-ANqhwUDCABaOQAAWjUAAFoNAABaQQBztqXfPcYAAkKUjiYYn/BdFv8O95nngucoiQgNgwuG5yiJC
-A8oiIQABHIIwUSGAgMolIRACHEIzpOjPcIAAtIe2iPSIsXPMJsGTEfIKIcAP63JAKwQEEL4F2Ioj
-XQsFJEQDiQAv/wUmxRMAxUAgDgbPd4AAZLhUGFgDhB9AEyHwz3CAAHC7BpAVCwEAz3eAAGS4xBcA
-FsC4Gw4AEAohwA/rcgXYiiOdDZhzQQAv/0olAAAAxc92gAAIt90fWBNAIEEgSSEBBjR57g4gAMlw
-QiDAJUggAAAbCHQAANsA2gAWAUAB4vsK1IAB4/ULBIBWJgAZxg4gAAbZz3CAALy1AIAzCF4Az3GA
-ALSHz3CAAHC7BpBWiREKAQDEFwAWNInAuBMJAADFFwAWCwheAQmHHwhfAXYNYADJcM9wgADoEKKg
-iiASDVoIIACpcSoOAAA9AiAAocAA2Ejx8cChwYtwWg4gAAHZABQFMEwlAIDKIcEPyiLBB8ogYQHK
-I4EPAACuB2gH4f7KJGEAz3CAAJCl5g0gAAMYQgGhwNHA4H7xwI4JAADPc4AApBFDgwDfz3WgACwg
-sIXSatR+fmalpgSmAeKMIgiAJqZDo4X3AoPjowHgAqPBAQAA4HgA2M9xoADIHxihGaEB2A6h4H7g
-ePHAPgkgAFlxOXLIcehyAd3PdqAAyB+zpgXfz3WAABAR4KUBpQTASKUJpRWGJ6UKpRiGGB1AEQul
-GYYUHQARDKWgFgAQZKUNpaQWABAMHUASDqWoFgAQCB2AEg+lz3ABALAJEKUuCWAAKNgRpSYJYAAA
-2BKlUyfAdROlAshUHQAXFqUSFgCWUB0AFxelExYAls9ygAAQERilFBYAlkokQHkZpRUWAJYA2Rql
-JBYAlhulFhYAlhylz3CAAOANEIAdpc9wgAAQEXgYgArPcIAAEBF8GMAKz3CAAIwRBBgAC4QaQAvP
-cKAAyBwIgIgaAADPcIAAgAUAgIwaAACoIIAC8CJDAM9wnwC4/wHhdqCZAAAA/ByItvwcSLb8HAi2
-/BzItfwciLX8HEi1/BwItfwcyLT8HIi0/BxItPwcCLT8HMiz/ByIs/wcSLPgfuB4BNw43TXw4HgE
-3DTdM/DgeATcMN0x8OB4BNws3S/w4HgE3CjdLfDgeATcJN0r8OB4BNwg3Snw4HgE3BzdJ/DgeATc
-GN0l8OB4BNwU3SPw4HgE3BDdIfDgeATcDN0f8OB4BNwI3Rzw4HgE3ATdGfA0FBowMBQZMCwUGDAo
-FBcwJBQWMCAUFTAcFBQwGBQTMBQUEjAQFBEwDBQQMALHAcawJE0zsCQfM+B+8cDPcYAA4A0QoeB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeNHA4H7geOHF4cZA
-KQ0CJX1ALQMUpXslCjQCCHVTJX6QBvIBHVIQYbr78UEqjgDBukImTpAEHdAQ/fUJ6i8kiXDgeKgg
-QAEBHVIQ4HjBxuB/wcUocgDZ2PHgePHAsg7P/6HBCHfPdqAArC8ZhgQggA9wAAAA13AgAAAAAdjA
-eC8mB/AodRpyE/SKIEkG+gzv/4ohTQQ5hu4M7/+KIAkGiiAJBuIM7/+pcQDYJPARzAAcRDNPIMED
-AeAQeAQggA8AAP+/j7gCHEQwERocMN4JoA9AJwASB+cEJ48fAAD8/wUnABSduJ+47HEAoQDB7HAg
-oAHYfQbv/6HA4HgiuQbw7HJgogTgYbn5CbWAYIAA2c9woADUC22gz3CgAEQdNaDgfuB48cDyDc//
-CHYodShwSHFocsr/geDKIIEDwA/h/8ohQQM9Bs//4cXPcoAAsASkis9ynwC4/wXtz3PQuv7KfqIa
-ojuiDu3PcKAAOC4FgAQggA/AAAAA8QiAj8AAAABp2Bi4GaLgf8HF4HjxwIYNz/8Id89xgACwBAWJ
-AN6pwUDGiwgRAAHdpanPcYAAgH7PcKAAzCstoADYj7gRGhwwIRqCM6IOoAyLcBoKAAjPcAEAsAlB
-wIogUABCwM9wgAAEawCIZMUC3REcAjAAwBIcQjMTHAIwz3CAAKQRRcDPcIAAEBFGwM9wgACABQCA
-Q8Yg2QHaR8BIx4HAPdsXu8L/CNgB2cn/BBpYM1EF7/+pwAPaz3GgABQERaHPcaAA1AsNoeB+8cDh
-xc9yoADUCwPdsaIA23CiBRICN9dyAAAAQAHawiKKABe6x3IADgAARSICBp26n7rsdUClAtogGoIw
-CBINNuxyoKIREgI3AeIRGpww7HIAogISAjbscECg7HAgoAHYz3WgAMgfE6U4hexwIKAZhd//dB3Y
-kM9xoADIOw6BiLgOocUEz//gePHAANgIEoEw3P8IEoUwCiHAD+tyB9iKI9EE7QHv/kokAADgeADa
-A/AB4kEogQD9CkSA4H7PcYAA4A1AGcAHz3GgAMgfXIGduJ64TRkYgOB44HjgeOB44HjgeOB44Hgc
-geB+4HgD2s9xoAAUBEWhz3GgAPwLDKngfgPaz3GgABQERaHPcaAACAwAseB+BcwA2tdwAAAAQAHY
-wiAKABe4x3AADgAATyCBAJ25n7nscCCgz3CgABQEA9kloAISATbPcKAA1AstoM9woABEHVWg4H6n
-CRAAQCHCA8O5nwk1BCS6MyZBcIAAgFxAJwNyNHsAewAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAW
-AUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYB
-QAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUBCIkKABBhQAL714H7hxSLq
-Y2rBuj0KNQEiuzMmgnCAAJBcQCeNclR9AH0EEAIEBBmQAAQQAgQEGZAABBACBAQZkABCI0OABBAC
-BAQZkADv9f8Ez//hxakKEABAIsMDw7qdCjUEJLszJoJwgACUXEAnjXJUfQB9ARCCBAEZkgABEIIE
-ARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQB
-GZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAQiNDgAEQ
-ggQBGZIAv/VTBM//8cDeCc//KHZGIc0AHWUiuZX/wb4dDlAQEQ6QEBsO0RAAFoBAAR0SEAAWgEAB
-HRIQABaAQACtFQLP/+B4gOHKJE1w4HjoIK0BABYBQQIYVADgfuB4gOHKJE1w4HjoIK0BABaBQAEY
-UgDgfuB48cByCe//UyFCAE4iDQHPcqAAFATJggDbDiaCHwAAAAZQccohxg/KIsYHyiBmAcojhg8A
-APwByiRmAPQGpv7KJcYAgOHKJE1wyiLNAOggLQJOYM9xoAA4BAHiyKkdDVAQEQ2QEB0N0RDPcKAA
-OARoqM9woAA4BGioz3CgADgEaKhdAc//4cUA2g/woIANc6CjoYANc6CjooANc6Cjo4ANc6CjEOAB
-4kEpAwHjCsSAANsG8AQQDQQNcqCiAeNTIcIAIrrzC4SAANsG8AEQjQQNcqCqAeNTIUIA8wuEgAcD
-z/8A289ynwC4/xqie6I+os9wAGwEABmi4H7xwHII7/8A2qHBGnDPcNS6/spAwM9xnwC4/2gZAAQE
-2Buhi3AeoZ26z3CgANAbUaDPcABtABAZoQXw9gjv/4ogSQH7CV7HABQFMHsNgQ/Uuv7KIN3Pc6AA
-yB+wowHYQxsYAADYjbgA/7Gjz3GfALj/aBkABATYG6GLcB6hANiduBMbGIDPcABtABAZoQXwogjv
-/4ogCQb7CV7HABQFMAwlgI/Uuv7KyiHBD8oiwQfKIGEByiOBDwAAXAJ8BaH+yiQBBJkB7/+ocM9x
-gACwBGSJz3KfALj/BuvPcdC6/so+ohqiDuvPcKAAOC4FgAQggA/AAAAA8QiAj8AAAABq2Bi4GaIc
-guB+4HjxwHIPr/+YcCh2SHXt/wYggQOIcKV5ZP7FB4//z3GgADQfBKEB2AehCIGA6AWB4H7xwD4P
-r/9KJAACAN3PdwAABB2pdhUigDMcEAEGANjPcqAAFATKoqiiJ6IEoj1liOFoucohDgDpcE/+QiRE
-ACDn1Qx1gAHmYQeP/+B4QSmBgAnyLyRJcKggwAEEEAIE7HFAoeB+8cDeDo//CHUodmoKYA9AIQAC
-BczXcAAAAEAB2MIgCgAXuAAggQ8ADgAAB24EIIAPAAD8/yV4nbifuOxxAKECEgE27HAgoCK+BfDs
-cQChBOVhvvsOtZAAhWj+8QaP/+B4B9nPcqAA1AcaGliADegZEgGGCSBDAA8SAYYCIMCAeWEPGliA
-9fXgfqHB8cAFEgI313IAAABAAdrCIooAF7rHcgAOAACDuuxzQKPscgCiKHBS/tHA4H+hwPHA4cXP
-cIAAMHwmiC7pJ4gs6aCQT20XChUCMyaCcIAApFxAJ4FyVHkAeQDZEfAkkAfdgOEB2cB5C/AkkAjd
-heEB2cB5BfAkkIThAdnAeR0JUAAIEAUBCiHAD+tyENiKI88FgQOv/ph1MQaP/6HB8cCyDY//z3KA
-AF0JQIqA4kTAi/KN6QohwA/rcgXYiiNPCUokQABNA6/+uHNggQPrQYGI6s9ygACsiHCCYKFRgkGh
-JMaA5sohwQ/KIsEHyiOBDwAA7wPKIGEB5POA4sohwQ/KIsEHyiOBDwAA8APKIGEB2PMxCF4CBCCA
-DwEAAMAuuM9ygABQYAhiSSCAAGG4ArgUeMdwgABkmWqgIYEroEXwOQgeAqDmyiWCE8olIRAEIIIP
-AQAAwM93gAAAYM5nBCCADwYAAAAxuC66HmbPcIAAUGBIYMJ4E/BTIMIAXXrPdYAAMGNNZQQggA8B
-AADALrjPcoAAUGAIYmG4Fn0SbRR4x3CAAGyYYKAhgR8NNBYhoAohwA/rcgXYiiOQA4okgw9RAq/+
-uHUI3PMEj//hxeHGz3GAAF0JIIkl6QDbSiQAds9ygABsmKggwAMyazR5JWA+YqCmPWChhRlhoaYi
-gQHjIqZIEAEGSBpYAEkQAQZJGlgASxABBksaWABMEAAGTBoYAG8Fj//gePHALgyv/7hxz3KAACh1
-BLkwIkQAosEPDF4Dz3OAAPi7BPDPc4AACLlAIwIGQCMBB1EkQILKIcIPyiLCB8ojgg8AADUEpAGi
-/sogYgHPdoAAMHhALY0BpmZAxiDFCw4eEsK9qmEN8BMOXhJEJQEcRLkqYom6BfBTJcEQPHkqY89x
-gAAwdxYhQQEiiQ65RXkgoAkEr/+iwOB4lQDgBwjY4HjxwI4Lr/8B2c9wgAC0KSCgAN3PdoAAuAQW
-JkATA4CA4OIgAgBAJU2Q+PPGDa/+BtjJA4//8cBaC4//CHXPcIAAtCmgoM92gAAwLoogVwuyCa//
-IIaKIFcLpgmv/yWGfg2v/gbYHw2QEADdz3aAALgEFiZAEwSAgODiIAIAQCVNkPjzeQOP/+B48cAG
-C4//CHaKINcMagmv/8lxz3WAALQpbgygAsKlAoVZCFAALwiQAG8IEQFWDIACz3AAAGg4z3GAALgE
-AKHPcAAALDoBoQDY2f++D6AHBdgj8M9wAABUOM9xgAC4BAChz3AAAMw6AaHE/xYMgAICDIACANgN
-rRHw9guAAs9wAABUOM9xgAC4BAChz3AAAMw6AaEA2Mb/3QKP/+B48cCKIFcH1giv/3fZANnPcIAA
-MC4goAHY0//RwOB+4HjxwM9wgAC0KQKAFwieAIogVweqCK//jdkyD6AHCtjv8fHA4cUIdYogFwqS
-CK//qXHPcYAAtCkCgT8IngDPcIAAfCoAgI3tIrjAuA2pAtjPcYAAMC4CoQPYA6EA2AzwI7jAuA2p
-BNjPcYAAMC4CoQXYA6EG2AShSQKP/+B48cDOCY//z3WAALQpAoUfCJ8AEBIENgohwA/rcgXYiiNF
-B2kHb/5KJQAA7gqAAu4KoAIIdgHYDK0tDlEQz3CAAAgF6gqAAqoMwAcIdYog1wruD2//qXGJ5cwl
-opBwDqIHyiBCA9UBj//xwNoKgALPcIAATIkgiM9wgAAABc9ygAC0KSGoLIrAuSKoANkjqKIKoAIh
-orIKgAIA2Zu5z3CgANAbMaBt8eB48cDhxQDdz3KAAMQpoKIQ20okgHOpcaggAAIWIkAAYaCioAHh
-z3CAADgqPgqv/xDZz3CAAEgqMgqv/yTZz3GAADAuoKGhoQjYBaFRAa//pqHxwOHFz3CAALQpAoAz
-CJ4AiiBXBzIPb/+KIUYJAN2pcKP/qXBW/9P/4v+KIJcHGg9v/4ohRg3PcIAAMC6goA0Bj//gePHA
-z3GAALQpIoFRIYCAzCBigIANogfKIKIBFfHxwM9xgAC0KSKBUSGAgMwgYoBkDaIHyiDiAQfx8cAK
-JACAyiHCD8oiwgfKIGIByiOCDwAAvAP8BWL+yiXCAM9wgAC4BBYgAAEjoN8F7/9EoPHAIgiP/wh2
-iiCYAIoOb//Jcc91gAC0KYogFw56Dm//IYUhhQDfkOEE9AHfwaXJcSUPUBDPcIAATIkVIIIDNXgg
-iGCKEQnCAAGIIYoJCEIAAIWO6IogVwc+Dm//iiEJD8GlxgygBwPYAdgD8ADYHQCP/+B48cDhxQhx
-ENgA20okgHPPdYAATImYc6gggAYpCQ4Bz3KAAMQpFiICAQQSBQAhDRUEFSVCEUCKUHPKIEsByiOL
-AEAkRAAvJAcB3QdP/wohwA/rcgXYGQVv/oojBw/xwFIPb/8Icc92gAC0KQQWBRAbDRQECiHAD+ty
-BdiKI8oG8QRv/ookgw+eDW//iiBYAIogFw6SDW//IYYBhs91gAA4Kgllgg1v/4ogFwchhihliwhT
-AM9wgABMiTV44YgQ2AGmz3WAAMQpiiBXDloNb/8ghYogFwdODW//6XEAhYDgyiAhASnyx/8IcQGm
-kODKIcEPyiLBB8ogYQHKI4EPAAC8AsokwQBoBGH+yiUhABYNb/+KIBcOIYbPcIAATIk1eAGIFwjD
-A4ogVwf6DG//iiHLAAPYgguAB+EGT//geM9wgAC0KQKAgeAB2OB/wiABAOB48cBODk//enAacVpy
-AN9AKAEEiiAYAL4Mb/9FeUwjgKPKIcoPyiLKB8ogagHKI4oPAAD8AsokygTkA2r+yiXKAEwiAKTK
-IcoPyiLKB8ogagHKI4oPAAD9AsokigTAA2r+yiXKAM92gADEKRYmzRQEFZEQiiDXDl4Mb/8qcQ8K
-QSTPcIAAtCkAgFTwGQkQJAAhgS+AADgqAIlhuACp6XAK8IogVwcuDG//iiFMBAHYOncAIoIvgAA4
-KiCKTCEApAHhIKrKIcoPyiLKB8ogagHKI4oPAAAYA8okSgREA2r+yiXKBCUIUADPcIAATIkVIEIE
-FSCABCCIYIoNC0IAAYghihkJAwCKIFcHygtv/4ohzAcEHYAUCB0AFACGDyDABACmSnBH/89xgAC0
-KSCBA7gleHUFT//xwCoNT/8IdSh3SHZAKAEEiiDYAIoLb/9Fec9xgABIKiARBABMJACByiHGD8oi
-xgfKIGYByiOGDwAAPAOsAmb+yiUmABYhAAGkqOCgxahAJEAACKE9BW//AtjgePHA4cXPcoAASCoI
-ghHoz3WAALgEYbgIohZ6YIUEiiCCYHtFis9ygABIKgiC9OgZBU//4HjxwJIMT/86cI7gyiHKD8oi
-ygfKIGoByiOKDwAAlgPKJEoEOAJq/solygDPdYAAxCkWJU4UBBaQEIog1w/SCm//KnGKINcOygpv
-/wpxANgCphDYAaYA2Q8hQQQAhSZ4AKU7CBAkTCAApMohyg/KIsoHyiBqAcojig8AAKcDyiQKBNgB
-av7KJUoEACCBL4AAOCoAiWG4AKkKcCz/WQRP/+B44H7geOHF4cYQ2QDez3WAAEyJn3HJc6ggwAMX
-CI4DFSWCE0CKUHPKIYsDyiOLAAHmz34ocMHG4H/BxeB48cC6C2//iiCXD0ogACDPd4AAxCkeCm//
-IIcO3gp1AIcXCE4DFidAEwKAB+hAeAUgAAQvIAcgYb4B5ecOdZCvfQDYAKdMIACgAdjVA2//wiAM
-AOB48cBeC0//r8EIdwDez3CgAGQu8CDSAxsSEDYbGtgz9dgFuIINb//pcRvIz3WgANQHGh0YkA8V
-EZYZFQCWKujA5kT3GRUOlv3xABYAQAAWBUAAHEAxIMB7CBEHgcCaD2//DtkjwGG4Y8AMwA7oz3Gf
-ALj/GqEtwBuhA8Aeoc9wAGwEABmhDx1YlO4KQAcPFRGWz3CgAMAvURAAhgsggITO9c9wAABkHhoL
-j/+RCM6DGRUAlsToGxoYNPXYBbjmDG//CnEbyBodGJDxAm//r8AKIcAP63IF2IojWQtRAG/+iiQI
-AOB48cDODk//GQBP/uB4ABYBQSCwABaCQFMiQQAhoEEqwQBSIQEAwLkoqEEqgQDAuSmoQSoBAcC5
-MKgAFoFAz3GgAMgcKIHgfyOg8cABgBDoMwhQADMIkAAKIcAP63IF2P/bSiQAAOEHL/4KJQABAdnP
-cKAAyBwpoPINb/8U2AjwAtn38QHZz3CgAMgcKaDRwOB+8cAS6CcIUAApCJAACiHAD+tyBdiKIwUH
-SiQAAJkHL/4KJQABKdgSuAfwFdgTuAXwT3or2BK4NXhAoOLx8cDhxQh1lg1v/xTYI4XPcKAAyBwo
-oB0CT//gePHAnglP/6XBi3fpcMb/6XDU/yLAFugAFg5BJMAD6AAWAEEA3QnwAcAAFgJAyXHf/wHm
-0H4B5QAUATHvDUSQE/AA3QzwABYBQQPqABYAQQHAABYCQAHl1f8AFAEx6Q1kkCTCJMCF6AsJHgAA
-FgBBBczXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKECEgE27HAgoOlw0/8mDG//AdgA2c9w
-oABEHTWgXQFv/6XA8cABgBPoIwhQACMIkAAKIcAP63IF2IojBAlKJAAAkQYv/golAAEC2ALwAdjP
-caAAyBwJoZoMb/8U2F7x8cAS6C0IUAAvCJAACiHAD+tyBdiKI4YDSiQAAFUGL/4KJQABKdgSuPAg
-QAAAokbxFdgTuPrxK9gSuPjx8cB2CE//pcGLd+lwfP/pcN7/ABQBMQXMArnXcAAAAEAB2MIgCgAX
-uMdwAA4AAAvhBCGBDwAA/P8leJ24n7jscQChAhIBNuxwIKAAFAEx7HAgsAkUgDAI6M9wpgCcPxmA
-+QhRgCLAFugAFg1BJMAE6AAWAEEA3gnw7HIBwKlx0v8B5bB9AeYAFAEx8Q5EkBLwAN0L8AAWAUED
-6gAWAEHscgHAyf8B5QAUATHtDWSQJMIkwIboCQkeAAAWAEHpcID/6gtv/wHYANnPcKAARB01oFnx
-4HjxwKIPL/8B2AAWgkAAFopAABaJQAAWhkBEJr6DRCKDE8B4CiFAgsohYgAB4YDjyiOBAMojIgCA
-4MogQgLKICEAQNwEIguTG2NveyT0BcwB3ddwAAAAQBJrwiVKEwzgF70EIIAPAAD8/8d1AA4AAKV4
-nbifuOx1AKUCEg027HCgoOx1AB2CEuxwYKgA2+xwYLDlCXQAANj4cBlxgeDKI4EByiJBAsojggJE
-I4EDguFKJUAAwiVCAVIjDgDAvkQjAAyQ4AHbwHug4AHYwHgFIMQAABYNQGG6T3qW6SMKdAAA3yCF
-gOYE5QT0ABYNQAkLERDscCCgAeftD4SQIIUJCxEQ7HAgoAYlPoES8h8KdAAA2AAWAUCA5iClBOUE
-9AAWDUAB4PEIhIAAFgBAAKULJECBHPIpCnQAANgAFgFA4IUE6+d5A/DleSClgOYE5QP0ABYNQAHg
-5QiEgAAWAEAghQTrJ3gD8CV4AKVCIEEQKwl1gEAnQAANCxEQSgpv/wHYB/AD2c9woAAUBCWgANnP
-cKAARB01oHUGD/9RAk//8cAGDi//ANnPcKAA0A81oAAWA0EAFgJBBcwxC14C13AAAABAAdjCIAoA
-F7gAII0PAA4AAEAiAQPPcAAA/P8keKV4nbifuBPw13AAAABAAd3CJUoTF73HdQAOAABAIgEDz3AA
-APz/JHileOxxAKECyOxxAKHscECw7HEA2ACxhQseAiNqBCGBDwAA/P8TC94Az3WgADgECK0B2GG5
-MHkdCx4BoWgIvQV9z3agABAEuLYC4A94YrkweQDdFPDDaBi+4mjvfxC/5X7haO9/CL/lfgV+z3eg
-ABQEy6cE4A94AeXaad0NhJMA3gjwz3WgADgECK0B4A94AeZTIU0A7w5EkxELXgEB2c9woADQDxEY
-WIATC54BA9jPcaAAFAQQoQHYBKERC94AABaBQOxwIKhhuhMLHgEPCpQAABYBQexwILBiukQjgYFB
-KoAAFfQA3gvwz3WgAAAE7I0AFo1A7HXgrQHmsmgPDkUT6QvfgQAWj0D28S0JkQAA2Qrwz3WgANQD
-3JUAFg1B7HXAtQHhG30RCUUD6wvfgQAWDkH38SsLngCA4MokDXDgeOgg7QMTC94Bz3CgAJgDPYAA
-FgBAA/AAFgFA7HAgoADZBvAAFoNA7HBgqAHhUyJAAPMJBIBKCG//AdgA2M9xoADQDxEZGIDPcaAA
-FAQEoQTIz3GgANAPIrjAuBWhaQQP//HAAgwv/wDZSiQAcqggQAIAFgJAFSJAMBwYmAAB4QAWDUAA
-Fg5AngxP/89woAAUBKygz3CgANQL3KAOCE//MQQP/+B44cXhxiSIz3KAAKxcpojCuS5iANkPIYED
-z3OAAIyJdhMCBobtJnp2G5gAHfBFeXYbWAAliBUjjQN5HVgQJohFiFlhfB1YECCAjCEQgET3iiEQ
-ACCgI7l3G1gAAIAquHgbGAAA2c9woADwNiygeRMBBiWgfBMBBiagehMBBiegfRMBBiigexMBBimg
-fhMBBiqgdxMBBiugeBMBBi2gdhMBBiSgwcbgf8HF8cDhxaLBi3WpcJYPL/8C2alw0v9GDw//cQMv
-/6LA4HjxwIjoz3CAAGSLLgwv/yTZ6QDP//HA3gov/5hwkODKIcYPyiLGB8ogZgHKI4YPAABbA4AA
-Jv7KJSYEANpKJAB0z3aAAMwEqCBAD0AsgwFVe8dzgAAweCCDz3WAACh1QCwAAd25AGUgo/G40SEi
-ggnyoIvPd4AAAGCtZxcNkxDPdYAAMHcWJQ0RoI0LDR4QnrkV8C24wLgVJg8Q44dSIU0CCydAkwzy
-z3WAAIS4hCgLDDAlQB7bCJ6Hn7kgowHinQIP/+B48cAeCg//ABYSQQAWAEHPcYAAKHVAKgAhAWGi
-wUEpQANTIBMATCIApMohxg/KIsYHyiOGDwAA/QSOASYAyiBmAVEhQILKIcIPyiLCB8ojgg8AAP4E
-Bdi59M9wgAAwdxYggAQ6cFYOL/8C2c9wgACwdxYggARGDi//AtlAKpAhz3WAADB4ACUAFDIOL/8Q
-2YtwKg4v/wHZACUAFEYJYAsQ2QERgCCQ4Mohyg/KIsoHyiBqAcojig8AACEFyiRqADAH6v3KJYoE
-SiQAdADYqCDBBxUgASAwJUUQBCWPjwAAAAEEHEAxP/Ihxs9xgAAAYAQlhA8GAAAAy2FBLEEEoOZ6
-YdEl4YIq8gTvFQuTAAQlhA8AAAAkRQyADwAAACQ9CdUACwmRABrvNQuRAATvzOYW9s9xgAAwfCaR
-IQnCACEN3gLPc4AAhLiEKwssMCNBDgQhvo8ABgAABPQA2wPwAdtvewPwAdpIcwQlgQ8BAADALrnP
-doAAOGMpZjByAdnCIU0AgOPMISKAEvIB4AIRgCDPcYAAUGAIYT8IUAAKIcAP63IF2IojFA4R8M9z
-gACEuIQrCywwI0QOCiHAD+tyBdgxBu/9iiNUDUokQAAlBu/9SiUAAAMRgCAIYYLgyiHCD8oiwgfK
-I4IPAAA6BQXY7fVKcFj/z3CAALB3FiCABECQz3EAABgVCSJBAG4ML/8gsGkAL/+iwPHAGggv/wLZ
-z3CAAMwEcg4P/89wgADMBECAz3agAOwnz3egAAREz3WAADB8eQoeACuGRCKAAIYi/w4iuqG5FLq0
-uQV6BSGDAAQhgQ8QAAIABCKCDxAAAgBrpiV6RacolYfhzCGigQ/0z3GgAMgcB+gB2B6hqgmACwXw
-ANgeoRIKgAsElV0IUQHPcIAAzAQAgFEI3gAE2c9woABEHSWgI6AkoCDwz3CgAMgcAdk+oAuGgbgL
-pmoJgAsElR8IUQHPcIAAbBAIgBMIHgAA2JS4BacLhpS4BfAA2AWnC4a0uAumggsP/50Hz/7hxTRo
-z3KAACh1IWItucC5hCkLDAAhgX+AAGS4SIFRIgCAz3KAAJClQYIJ8jyJgOHFIoEPAAAKAgPyRSJC
-A0okAHQA26gggAI2aHV5ACGND4AAMHhApQHjAN3Pc4AAMHcWIwIAoKqhqgHZIqoD2SOqSiQAcalx
-qCDAAXphFnqkqgHh4H/BxeB4JQSP/yEEj//xwAAWAEDPcYAAbCoAoR8IUQAAFgBADLgEIIAPAQAA
-8AGhABYAQAKhEfCC4AAWAEAL9EYgwgBDoQAWAEDPcKAA0BteoAPwABYAQAXM13AAAABAAdjCIAoA
-F7jHcAAOAACDuJ24n7jscQChAhIBNuxwIKBSCS//AdgA2c9woABEHTWgKQSP/+B48cAAFgJAocFA
-wgEUgDAPCB4Az3GAALCXBPDPcYAAyJdAoWCJAdoI8AAWAEAVIYwAAKQB4n149QiFgBcLHgAAFgBB
-A/AA2BUhjAAApAHi+QqUgQXM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscgCiAhICNuxwQKDC
-CS//AokA2c9woABEHTWgocDRwOB+8cDhxQAWA0DPcYAAAABgoQAWAkAA3UGhABYAQAKhABYAQAOh
-pKElC94H/7pA2M8g4gfKIIEPAADQAM8g4QfPcZ8AuP8doQbwz3CfALj/vaAFzNdwAAAAQAHYwiAK
-ABe4x3AADgAAg7iduJ+47HEAoQISATbscCCgMggv/wHYz3CgAEQdtaB9Bc/+4HjxwOHFz3WAAMwE
-BG0aCy//CNkBhc9xoAC4HgKhAoUDoSYJD/9RBc/+8cDhxaHBAN1AxQAWAUAAFgBAOQlQAAXM13AA
-AABAAdjCIAoAF7jHcAAOAABFIAADnbifuOxxAKECEgE27HAgoOxwoKCpcCDw4g2gC4twBcwB2ddw
-AAAAQAHYwiAKABe4x3AADgAAhLiduJ+47HIAogISAjbscECg7HAgoADB7HAgoAHYcg/P/s9woABE
-HbWgvQTv/qHA4HjxwDYMz/4KJgCQOnFP8i8ogQNOII0H2tiaCu/+qXEbGlgzQCUAFEogACAPIBAg
-9dgFuEYO7/6pcRvIz3egABQECqfPcaAAZC7wIQEACYeS6M9woADAL1EQAIYLIECACvTPcAAAsB4u
-DA//CyAAhBb02thCCu/+iiGaCymHNgrv/trYz3GgAMAvUREBhiYK7/7a2G4M4AYqcDIJoAKpcADY
-DyBAAwYmDpCz9c9xgABgBQCBB9obGpgwPQjQAc9woAA4LgWABCCAD8AAAAAhCIAPwAAAAPXYBbjP
-c58AuP8ao1ujadgYuBmjAdgD8ADYCQhRAEChz3CgABQESqCZA8/+8cDhxQISDTYAFgBBABYBQcW4
-grm7/3IP7/4CGlgzmQPP/uB48cAOC+/+gNjPd6AAwC+lFxKWFBcRlgDepR+Yk89yoABkLhQfmJMv
-KwEATiOBB/AiQwBlfgDbDyNDAAYgwID19U8mwBakHxiQpBcAlv0I3oejFwCWBCCADwAAAA+MIBCA
-+PPz2AW4gNnqDO/+n7kbEhA29dgFuAfd2gzv/qlxz3CgABQEqqAbGlgzB/AD2c9woAAUBCWgz3Cg
-ABQEqYAe7XbtQS2AkAryLyQJcOB4qCCAAQAWAEDgeFMlTZAJ8i8kSXPgeKggQAEAFoBA4HjPcKAA
-FASpgObx89iWCi//BbjBCN+H9dgFuGoM7/4Kcc9xoAAUBCgZAAQbGhg0I+4vKIEDTiCBB5ThyiJF
-AIT3KHKAIsIBz3CgABgs8CCDAJThyiJFAIT3KHKAIsIEz3CgAGgsVXhgoADYDyBAAAYmDpDf9YDZ
-z3CgANAbMKClH5iUFB9YlBUCz/7xwLYJ7/4X2bfBi3dCDu/+6XAjwEohQCBTINIAhiD+A0IoEAEh
-CjIkDByCNAohwA/rcgXYiiPODQokQARFB6/9CiWABBLGLb4gwMC+QCoNIcd1gAAodVEgAIAAhYYg
-9w819IDgyiHBD8oiwQfKI4EPAAC+AwXY4vMBwALBSnJqDCAEZm0f6MlwpgngAEpxDRSAMIUgwQAN
-HAIwiiD/D1PAAIWpuAClSnBmCeAA6XHPcIAAhATVeCCADyGBBCCgKnYC8ALeSnBz/gbwgODKJkEU
-yiYiEq8OURATwQCFEsImeER5JXgApQwdAhTPcIAASHYA2RYggARAhSCgIaALCl8FANmLuSGgDwqe
-BSGAhSEBDiGghg+gAOlwDRSBMAsJXgFYFAAxBbUNCV4AUBQAMQK1DwkeAUpw3g0gBFUUgTANFIAw
-PwjeADXBVhQCMUpwOg4gBBLDuHCMIAKAyiHBD8oiwQfKIGEByiOBDwAAKwQUBqH9yiRhAFElwIHK
-JiIRSnBZ/QXM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChAhIBNuxwIKA6C+/+yXAA2c9w
-oABEHTWgWQDv/rfA8cD6D4/+pMEB3YHAggzv/qlxAN5N8ILAdgzv/gLZAsCLcrYJIAQDwaR4LyUH
-kEDyAMEA2M93gAAodQ8gQAAEuSFnLyEKIC25UyEQAM9xgABcBUCBBCGAoAChB/SA4hAIIgnKICII
-IMDqDCAEENkAwQDYiiMIAFRp+mICsmCigNtoqmmqz3KAAIQEFSICBGCCBCNDBGCiz3KAAEh2NnoA
-ogGiz3KAACh2NHoAsgHmIcBnDgSQBczXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKECEgE2
-7HAgoEYL7/6pcHkHr/6kwPHAhggABF4Lz/4ZBU//4HjxwAoPj/6EKAsMz3KAAIQE8CINAAAhgX+A
-AGS4aIEEI4IPgAAAAEQjDwIvuga/RX8EI4IPAAEAAEEqTgMsuuV+RX7PcoAAzAQVegOCZQ4AEAQj
-vo+AAQAAIvLPcIAAWLsUiD0I0QHPcIAAvLUAgDEIXgC+u2ihRCMAAga4BCOBD4AAAAAvuSV4BCOD
-DwABAABBK0EDJXgsuwUjDgDDogrtLylBA04hgAcQJQ0Q4Pz67cEGj/7xwKLBi3B6DO/+CNkAwM9x
-gAB4BAChCOgGFAAxA7EEFAAxArF6Cs/+osDRwOB+4HjxwKTBi3BKDO/+ENkFzNdwAAAAQAHYwiAK
-ABe4x3AADgAAg7iduJ+47HEAoQISATbscCCgAMBRIACAA8AG9ALBOgigBADaBfD6CiAFAcH6CM/+
-ANnPcKAARB01oKTA0cDgfuB4MNnPcKAAUAwioMHZz3CgAAQlIKDgfuB48cCuDY/+z3AAAEQc8g3v
-/gDecdjqDe/+BrjPcAAATBzeDe/+CN3PcAAAyBvSDc/+z3AAAMwbyg3P/s9wAAAIHL4Nz/7PcAAA
-BBy2Dc/+z3CgANQLOIAcgM9wnwC4/1gYAAgAJoAfAADAG5YN7/4E5mG98w1VkADeBd0AJoAfAAAA
-HH4N7/4E5mG98w1VkI0Fj/7geM9xoADQDxkRAIYcEQCGz3CgAMgfFRAChh6Az3CgAMQnGRAChpwR
-AgAVEAKGLRAChi4QAoYvEAKGMBAChoARAgCEEQIAoRAChpARAgCiEACGlBEAAJgRAACMEQAAiBEA
-ABiBz3GfALj/WBkACM9xnwC4/1gZQAjPcKAA0A87gDmAz3GmANQEFxAAhiwRAIAwEQCAOBEAgM9x
-oACIJACBAYECgQOBBIEFgQaBB4Fg8eB48cDhxc91gACIi6lw5gjv/gPZAYXPcaAAgCUMoQKFDaEA
-jVEgAIAA2I64BPIPoQPwEKF+CM/+qQSP/uB48cAmDI/+z3WAAOAEAIXPdoAAFJHkkOlxNgmgA4Yh
-/AMacA0I3gAfhoC4H6YghQCROGAApVQWgBCS6Olwug/gBoYg/AMJ6BkIHiDPcIAAbBAJgA0IXwAf
-hoK4H6YtBI/+8cDKC4/+osHPcIAAFJE+gAQhgQ///w/QBCWAXwAA8C8leM91gAAUkc4P4AYepYDg
-VAMhAJgdABDPcYAAAAAAgTUI3gIBgeu4QNjPIOIHyiCBDwAA0ADPIOEHz3KfALj/HaIEgQHg07gE
-oQUggA/Q/gAAFqIPDd5Rz3CAAMAQAogF8AOFEg/gAySFXoVEIgEMlB0CEAsJEQiA2JQdAhBAKAEG
-xwjfAYK5IwqeU0QiPtMK9M9wgAAUkQGADQgeALIIAAcV8KoJAAcR8EUhAAbPcYAAoJEoiYYh/Q9S
-IcEBRbkleM9xoACIJBChz3CAAGiRAIiE6BMKn1LPcKAADCQTgFMgwIBJ8kQiAFNBKIEATXCGIPwD
-QSgCAc9wgAAUkRMNnlEEuVlhx3GAANAsEvAVDV5TdGlbYwAjgQ+AABAtCvAVDV5SBLk6YgAigQ+A
-AFAtrBhAAKwQAgAf6iCKlxhCADzYAKoZ8LO6XqVRIoDTxSGCDwAAAAdFIQAGz3GAAKCRKImGIf0P
-UiHBAUW5JXjPcaAAiCQQoYoh1gDPcKAAgCUvoM9xoADEJ0ERAIZRIsDTzyDiAtAg4QJBGRiAz3WA
-ABSRAJUEIIAPAADMgBUIgQ8AAMiAC4UNCB4AAg2AA03wHoVUFYIQywjeBBoRAIYFIIAPAAAAmhoZ
-GIAH6gHaz3CgANQLUqAE2BAZGIBNcTIIr/6KIEQOBvBqCq/+iiCFDQkIn0T1CR7Gz3WAABSRz3ag
-AMQnLhYBlhaFInhkuBB4hh0EEM9xgABsECYPYAcvkRoWAJYEIIAP////ABoeGJARFgCWEwjeAgDY
-i7gTHhiQGtgZHhiQHoVRIICBANmP8hSVUSBAgYv0z3CgACwgD4CA4IX0ENhBwM9wgAC8tQCAIwhe
-AB8NXlMB2EDADPAH6gHaz3CgANQLUqAE2BAZGIDb8UDBK4XPcIAA+LSLcwQhgQ/AAAAAwoA2uYHC
-QCAEC1cOThDhlceAcL/0JEEACCbOE0cJgwOUFYEQPwnfAc92oAAsIC+GmenGhjyVEwmFA89xgADE
-mcKBJYAfDkEQBOsC2SCjI4CDuSOgBeoggqa5IKIBwg3wI4ABwhcJ3gAA3p6+z3OgAPxEwaOjuSOg
-K4UkoCOFJaBUFYAQB+gAwILgzyJiAQL0h7oAwUHCVSVAGt4IIAIA2x+FlLgfpR6FkLgepQ3wz3GA
-AMh8DYEB4A2hENnPcKAAkCM9oJkAr/6iwM9wpACQQU2Az3GAAOyaQrEagAOxBCCAD/8AAAAwuASx
-z3CAAOyaANoRCF5Gz3GAABSRMYELCZ4CQrBDsESw4H9ZsOB48cDmD2/+mHDPcYAAFJEOkc92gADs
-mgC2z3CmAOj/C4DPdaQAtEUDpgwVA5YNFQKWRBGJAC8nxwD/2BC4KXSEJAOcBCMIAAT0WwkfEDIV
-AJZTII8A/2cBtv/Y9H8IuO9/ZHhALwUSACUGAAAnxwMFJsYBQC8AFgQjgw8A/wAAQC8HFBtjACDI
-Ef/YBSYGAgi4BSODAQQiBgD6YgAmQAEFeuW2b3gEI4MP/wAAACi7ZXhPegO2RLYEFQCWArYRgR8I
-HgLPcIAAAGAyIEACDwiSAM9wpgDo/w2AA/AA2AamBaYA2EokgHAG2o26qCBAAynbErvwI48AQCYD
-HxV7AeLgowHgAJE4HgARVSZBFBq2z3CAAGCXBgyv/gjaGxUAls9xpQDYyxmmHBUAlhqmHRUAlhum
-DoEcpg+BHaYmFQCWHqbPcKQAkH8cgAUHb/4fpuB48cCGDm/+ANvPcaAAyB9AEQAGz3egANAPGRcA
-ls9yoADEJ08SDoa4gc9wgAD4tKigEczPdYAAFJELDgAQH4ULCJ4AAd4E8BEanDNodlISEIYVEhOG
-G9gWGhiAEQvfIFEgQKBKIgAgB/QdhQHeWnaEuB2lDQseIVQVgBAE6ADYBvAdhYW4HaUB2DpwTCIA
-oMwhIaBY8s9ynwC4/1gaAAgQh89wgADAEA+IFqIA2s9woAD8RJ66QaBloB6FsLgepagVABBk4B6h
-ENgOoQHYFRkYgLYJr/4J2BcIX0fPcYAA4A0LgQHgUg9gAguhvgpAAhsJECDPcYAARH0FgQHgegtg
-AgWhOQIAAM91gAAUkccKECAdhYS4HaXPcIAARH0RC94gIoAB4SKgiiCFCQfwIYAB4SGgiiDFCNYL
-T/7aDkACS/BCEgCGBCC+jwDAAABD8gG1HoV7CN4EiiCEDrILb/6KIRADJgiABwCVhiD8AIwgAoAx
-9IoOQAev6APYEh8YkOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HgSHxiQE8wRGhwwBfAAla4LoAg0lawVARAI6ZcVgBAAqQDYrB0A
-EFQVgBAh6M92oAD8JTSGAdrPc4AARH0GgzhgBqMF6c9xgACZCUCpU4Yng1lhJ6M+hQHenwgQAJsJ
-3gEB2c9wgACEBSCgRfAhCB4gAdnPcIAAmQkgqM9xgABEfQOBAeADoT6F6/ED2c9woADUCzGg4Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeDGgE8wRGhwwGQoRIB2Fz3GAAER9grgdpQSBAeAEoQHeHoUXCB4ElRWAEKQVARCpcg4P4AIB
-2wPwdgpAAx+FDwgeAM9wgADgl44OgATPd4AACJ0ZhwbougoABADYGaeGCUACz3CAAGwQCIAjCN4C
-j+4EIIAv/wBf/+r+z3CAAOyaoNnE2j3bkg1v/he7HoXwuJALAgTPcIAA+LQAgIDgmAziDcogYgCl
-A0/+8cBKC0/+z3GAAMSRz3CAAOAEIKAA2c9ygACQkSmiz3CAAPi0JKAloCyiz3AAAP9/z3GgAAwk
-AaEb2AShz3aAABSRLQgeRB2GhLgdps9wgACQBCCABYEB4AWhiiCFCXIJb/4kgQYIQAJTAgAARBaA
-EPGGwrgEJ48fAAAACFQWghD7f891oADEJwDZFerg2r8dmJCU2pUeghAE289ygABYBWCiAto8HYCQ
-z3KAAMSZIaIH8EDZvx1YkNTZlR5CEAAgkQ+AAGS4wBGBIAAgkg+AAFy8uBKAoAUh0wMeCKACBSDQ
-A4Dg6/IB2BAdGJDIEYAgz3GAAByY5XgbpmwWgBDDuBx49CEAAGQewBReHgQQwBKAoOV4HKZwFoAQ
-w7gcePQhAADPcoAAPJhgHgQQZBaAEMO4HHj0IgEAaB4AFIoeRBDPcYAATJj0IQAAjh4EEGgWgBDD
-uBx49CICAPQhAACMHoQQkB4EEBTMhiD/hfwKgQLPcIAAbBAIgOu4uAnC/x3wz3GAANCZAIFjgUOh
-ZngAoQSBDBUBkBJ4JXgMHQCQANiPuBMdGJAIFQCQoLgIHQCQGtgZHRiQ8gtAAs92gAAUkR2GUSDA
-gXv0z3WgAMQnERUQlgDarQjfozUIXyJfCJ8j1wgfo7MIHyDXCN4gCNgTHRiQ6g1AAsMIEQAC2Dwd
-AJAjhs9wgADEmSGg1/FJ/aAWABCRFQGWAeDDuaAeABCbCEGAiiIIABMdmJCRFQCWw7iHCQCAEh2Y
-kL/xOhUAlkMIngDPcYAA0JkAgTcIHwCAuAChAdgDoYog/wAEoToVAJaGIP8BA7gBoQwVAJBGIAAP
-DB0AkAgVAJCAuAgdAJAA2I64Ex0YkDMNHtAE2c9woACQIz2gkfE//QLYPB0AkCOGz3CAAMSZIaAe
-hvO4hfMTHRiUhf4D8BMdGJTpAE/+VBaAEInoQhUAlgQgvo8AwAAAA/QlCB4ivxUAlqW4vx0YkIog
-BAATHRiQwgnADVQWgBCA4GP1HQifIAohwA/rcgXYiiMNAookgw8RBi/9CiUABM9wgAD4tCqAz3Cg
-AAREJqDH8eB44cXPdYAA7JoJpSqleLVLpQHYGbXgf8HFSiQAegDZqCCAAgDaz3CAAOyaNXhAoAHh
-4H7gePHAAghP/gDez3GAAAAAwKHPcqAAyDsdgsKhwaHDoYToANgL8ASB/QiBj2WHIUOKIIQAAKEB
-ocShDejQ2Z+5z3CfALj/PaCC2BSiz3AAgBEUDqKKIMUPz3WgAMgfGR0YkAHYCHEIcghzLgwv/Zhw
-z3CAABQAHQiAD4AAFAAKIcAP63IF2FvbiiSDDzkFL/24c893oADQD9WnhdgJuM92oADAL3oeGJA2
-C8AHFgzACLIIAAtA2c9wnwC4/zKgCgiP/oDZz3CgABQELKAdH1iQDgiAB/YMwAYqD2AHANjOD4AK
-B9hIHRiQygsP/tYLAArPcIAAMHwAkIfgBAsCCqIOQAqqC4AOQgvADRWGUiAAAA8IHwAmC2AKAd8P
-8APfE4aauBOmIN4F2NClQx0YEADYxgpv/o240aXPcIAAMHwAkIfgvAoBCgILD/4mCIADUgzAA+IL
-AACyC4ADQg7AA2YKwAmuDEAIfgzADLoPgA0KCcANng5P/Yogxg3PcYAAbBANsQPYbRkCABvZz3CA
-AKykjgngAjCorgiP/5oPgA0CDI/++g+ADj4KwA3WCG/+6XC9Bg/+4HjxwDoOL/4B2aXBGnAKIoAv
-gADsBMYKb/6LcAAUhTABFJEwDwhRIAoigC+AAPAECw1SABkNUgEKIcAP63IF2JzbzQMv/UokQABM
-JQCAGAEOAKhwABaOQAAWlEAPDDIkenCMJMOvJfQAFgBBABaPQAAWgEAAFgBBfQwTJCbvz3CAAOQE
-AIBALM0gtX0Q4LhgTgpv/gTZz3CAAOQEAIBMIUCgHWXMJ2GTFvQA2Iy4E/AKIcAP63IF2KfbSiRA
-AFEDL/0KJQAFCiHAD+tyBdiw2/bxANgAtc9wgADkBCCAQCzAIBV4EmEZYQUiQAQAsQTdB/CBwATd
-5glv/qlxACKMIwAcAhXPcIAAhATwIAIEHt8vKYEAAidAECPqz3OAAC91NGgrYxULjgMAJoEfgACU
-ixZ5ABkCBQAtgRMLIcCACPIAJoEfgACUixZ5BBkCBRAiAoAvKYEAAidAEOD1QiNAIIDg8gbN/zIJ
-T/4lBS/+pcDgeADYSPHxwOHFrcGLdalwXglv/g3ZAMAdeFMgAQBEKT4NqXAAIYF/gADIduoJb/4N
-2vYIT/4hBS/+rcDgePHACiHAD+tyBdiKI4wEiiSDD1ECL/1KJQAA4HjxwOHFINvPcaAAyBxpoQAW
-AEDPcqAAEBQMogAWBUAB3UwlAIDKIcEPyiLBB8ogYQHKI4EPAAD5AAwCIf3KJEEDGBpAAWgZQAED
-2A+iuaFqoX4IT/6pBA/+8cAuDA/+pBABAKLB2wlfBiDZz3OgAMgcKaOkEAEAXQneATGIz3WgABAU
-I7nAuQO5BeED2k+lRoVBwo3hEN7KJuIRBhQPMYwnw58J9AQUDzHxdswn6pAB3kL2AN7r7sWARX7H
-pbGIhiX8Hxi9pXrPdaAAzBdaoBbwRYDPcaAAEBRHoaQQAQAVCZ4CMYjXuoYh/A8YuUV5OqDPdaAA
-zBcN2QHaA+ENHZiQDh1YkCaAGR1YkCeAGh1YkCiAGx1YkAPZFB1YkHAQAQEQHViQcBABAc91oAD0
-BwThJ6VHo6QQAQCZuaQYQACxAy/+osDxwAPIpBABAPm5DA/B/wPZz3CgABAUJaDRwOB+ANqA4cok
-TXDoIK0B/9lcYCCsAeLgfuB48cDPc4AA7ARocATZ9/8EawTZ9v/o8eB48cA2DeAJENhv2Qe5z3Kg
-APAXMaLPcQAA8P84opoOwAnW8eB48cDx//b/0vHPcYAA7AQLCFEABGkC8ChwBNnK8Q97SLgPeM9y
-gAAAXvQiAABAKAECSLgFefQiwAAweeB/J3jgePHAkgoP/qXBCHYCiyh1mHBkwACLABIGAREcAjB5
-cAISBwEEEggBEBQAMeSSBhIFAQAgyQMAkS8hSBIHIEACEHjn/wAgigEBlS8iiBIHIIACEHjj/wAg
-xgEClS8miAEHIIABEHje/wAgBwIDlS8nyAEHIMABEHja/wAlBQAElS8lSAEHIEABEHjV/x9nBZXw
-f+d4EHjS/yaVIXAQeAd5PHoPuSV6UHoAIoECMHkAHEQwR5Unelx5D7pFeTB5ACGCAVB6XHkCHIQw
-D7pFeTB5ACHCAVB6XHkEHIQwD7pFeTB5ACFCAVB6XHkGHIQwD7pFeTB5P2fwf/x5CBzEMw+/5Xkw
-eThgaXHGuYW5CLkFIcECILYQeCCVChwEMCd4HHgIuAUgAAEBtgDAAaYBwAKmAsADpskBL/6lwOB+
-4HjxwOHFCHU+iM9wgADkBECAQCUAFAO5NXlZYXIOL/4K2qlw9/+pAQ/+8cAmCQ/+CHbsiAiQz3KA
-AOwEtG8Ic4Yj8w9CKxECx3WAACh1YIVIcQcLXgMkauu4iiDDLwP0HhaQEE2OUSIAgJryeQjfAC0L
-3gL/2AetSiQAcQDYqCBAAwphACCDD4AAlIv2e0SrCmEB4A94QKtY8B0JEiEKIcAP63IF2IojCwFK
-JEAAaQbv/AolQATuuEeNMiFABAAhgS+AAJSL9nkJ8gSpBNgAKEAERXgHrTrwAKkPIkIER61e8CkI
-EiSMIMOvyiHCD8oiwgfKIGIByiOCDwAA2ALKJGIAFAbi/MolAgTJcL7/CJYNCJ4DAo4JrQTwAY4I
-rQCFMwjeAgDZSiQAcSetqCCAAwAhgA+AAJSL9ngEGAIEABgCBAHhL3kBjgitAo4JrSjwTCEAocoh
-yg/KIsoHyiOKDwAA9QJIB+r/BdgIlgAhgS+AAJSL7rgHjfZ5CfIEGQIEBNkAKUEEJngHreDxABkC
-BADZDyFBBCZ4B60BjgitEQAP/kGJBLjHcIAAKHVIqCKJ4H8pqOB4EYjgf8K44HjgfuB44cXPcoAA
-7ASA4MAiIgH/3RRpACCDD4AAL3Wgq0okAHEA26gggANtYgAjgA+AAJSLNnikqG1iAeNve6Co4H/B
-xfHAVg/v/ZhwpcEod7hzAN4EI4AP/wAAABi6BXpveQi5/9gIuGR4KLgFeUV5CN30JIADJ3hEwBAU
-ADEa/xIUAjFhvUAoAQQFeUd5RMEQFAIxFCSAM0Cw2w11kAHmUyXCBUCnABQNAQfZBvAQfRQnTBAA
-tGG5FCRAMLt7T70AkKV7cHvrCbWAeGAEIIAPAAAA/xC4BXpjBe//QKfgePHAug7v/SDZANrPdaAA
-yBwppc9xoACUE1uhz3OAAOQEYIPzaM92gAAUkQyG9X9TIMQF8GP7Y1MgjwCkwYtxOQ/REB6Gm7ge
-pjQWgBDiixkIwQMocEAjAQREa0AmAxzz/g3aKvAdhpG4krgdps9woADMFyvwHQ9REUEqAlJAIwAE
-wbqIc7j/HoacuB6mDdoU8Cy4UyACAB6GA7qZuB6m5IMF4gUnABEAoQWDAaEGgwKhB4MDoQPiz3Cg
-AMwXz3GgAJQTXKEB2ojqHoaXuB6mINgKpRnwAMED2hgYWIABwRkYWIACwRoYWIADwRsYWIAUGJiA
-hhYBERAYWIAE2SelFhiYgCEG7/2kwOB+4HjxwK4N7/0B2aHBMgov/otwIMDPdYAAfCoApYogVwoG
-DO/9AhIBNoogVwr6C+/9IIUAhUDZQMEPCB8A/g4v/ihwK/DPcIAATImOCw/+ANvEhUokAHTmhagg
-wAcA2M9xgABMiXV5I4kPIMAA4bnKIgIAyiIhAEV+4LnKIgIAyiIhAEV/USGAgMogIQAnhQHjJXgH
-pealxKViCQ/+AIUnuMC4G3gOCm/+AuBtBe/9ocDgePHA4cWiwYHgAdjAeEDAiiCXCmIL7/0REgE3
-iiCXClYL7/0AwQDBz3KAAHwqZYKhggOCi+kmgmR9pHkme0HBZaIleAOiCfAkggR9pHkmeCV7QcED
-omWiDekaC+/9iiCXCotwCNlb2h7bqg7v/Ri7CQXv/aLA8cDhxaHBz3WAAMAEqXAKCS/+AdmKIFcK
-5grv/QISATZAjYogVwohjRC61grv/UV5z3CAALQpAICB4AHYwHhAwItwcg0v/gTZAI1RIACAAY0E
-9JoNQAYE8DIOQAalBO/9ocDgeOHF4caYcM9ygACcKgWCIIJmgsi4ELjIuQUhAYABgsi7ELvIuAUj
-BQBnggKCyLsQu8i4BSMHAGiCA4LIu8i4ELsFIwYAJPIAFA4ALyhBAE4ggwcA2A8gwAASfQQgQwGk
-fmV+AByAA9qCpH7Fe3qieYIEII4BBCDAAaR7xXt5oniCpHsEIUGDZXgYot/1wcbgf8HF4HjxwIoL
-z/06cAWBoIHIuBC4yL0FJQ2QAYEmgci4yLkQuQUhEAAB3hnyBCWAkxPyLygBAE4gggfwIYEgAN8P
-J48QCOkEJwAUQiAAgGB5yiBiAOZ9237q7ZUDz/3gePHAocEB2GoOYA1AwM9wgACcKgqAUSAAgMog
-AgfKISIByiKCDwAAZwDKI2IPHA3i/cAr4gWhwNHA4H7geKHB8cDyCs/9o8EIdUjAz3aAAJwqGob7
-hjyGBH8kf6d/QcdOCe/9iiDYBIog2ARCCe/9qXGU78sNERA6De/8B9i/CBAACiHAD+tyBdiKI8YL
-SiQAAGUA7/wKJQABBBQBMRjpIBQAMQsgQIAN8s9wgAC4BGCAz3EAAKhuDNhgewPaCPCI6M9wgAC8
-BCCAYHkM2AYUATEY6SIUADELIECADfLPcIAAuARggM9xAACobg3YYHsE2gjwiOjPcIAAvAQggGB5
-DdgEJ1CTCvKCDO/8B9iKIBgImgjv/QpxEvCQ7Yog2ASOCO/9iiHHBnYM7/wH2IogGAR6CO/96XGz
-/7ymCNxbAu/9o8DgePHA4cWjwQHYQMDPdYAAnCqpcAoIL/5c2TqFG4UkeDyFBHmBwEHBav8BwDuF
-BHlBwTYI7/2KIFgEVSVAH6lxif/PcIAAFCxAJQEbhv+LcM4KL/4E2QHAqf++DEANAIWG6AWFgOBY
-DsH/AQLv/aPA4HjxwHoJz/2iwQHdz3aAAJwqOoYbhiR4PIYEIRAA2g+v/YogmANVJk8XVwgQIALw
-u30EIECj/fMvKAEATiCRB/AnQBRcHkAUgODKIcEPyiLBB8ogYQHKI4EPAAAKAsokAQTgBqH8yiVB
-BEB4iiCYA4oPr/0qcQDYDyBABAYgECAKcIL/iiCYA3IPr/08hk0B7/2iwOB48cDmCM/9psE6cRpy
-YMAA2AEcAjAB2AIcAjADHAIwi3AeCuAKgcEEwQpwIyBABAXCA8CM6AohwA/rcgXY3tuKJMMPbQav
-/LhzQHj9AO/9psDxwJoIz/0acCh1SHdodjhjZtk92tYJ7/0XuhcIUQAKcI4JL/6pcelwYgrv/clx
-0QDP/eB48cBqCM/9CHYA3Yog2APSDq/9yXHPcIAAnCpagDuARHkA2g8iggMEIkMAQiMDgMojYgAv
-JsfwAd/KIEEDBvIcgCR4RXhL/+lwiQDP/eB/ANjhxVIggADPcaAAfB0EqQLdEfDgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/n+314H/BxeB4z3CgAHwdBIjgfuB48cC+D4/9OnB6
-cVpyGnMA2On/BNjo/ysJVCAqdQDfQiFAIOJ4ASsOIMC+TyaAEOL/RSaAEeD/Yb3nDXWQAecE2N3/
-ANkzCnQgABhAIEp1KHYG2Nn/Yb3o/0IiQSDCecC4OHgAEAEgBXkAGEAgBNjS/+ENdZAB5gDYz/+d
-B4/94HjxwKHBi3MI2AXZCHLd/yDAocDRwOB+4HjxwB4Pj/1acDpxCiOAoBpzCiUAIcwgIaAQ8kwj
-AKDMICKgDPQKIcAP63IF2EPbiiSDD8UEr/y4cwDYmnC4/wTYt/8rClQgSnaKdUIiQCCieAEpDyDA
-v08ngBCx/0UngBGv/2G+5w51kAHlAN0S8EEtwBAyIw4gUyWBEE4hwAEZfsC+TyaAEKb/RSaAEaT/
-AeVAKMAg2w0EkADYof8zDRAgE/DS/zEIHgAg3s91oADIH9ClZNhDHRgQANhuCu/9jbjRpYAkASnf
-DISvAACIE4og/w8D8ADYmQaP/eB4CNgG2QDaSHOYco7x8cBODo/9CHUod0h2+v9PJUEUGNjpcslz
-SiRAAL//mQaP/eB48cAmDo/9qcHPd6AALCBAFxAQRgqv/ADdz3GAAOANEYEB4BGhi3AuDO/9BNkX
-8IHGyXAiDO/9INkAFAAxyXEg2uf/BX0AFAAxIOAAHAQwAhQAMUIgAAgCHAQwAhQBMdMJE4gN6YHG
-7gvv/clwABQAMclxAhQCMdr/BX3QhzzYAiYOFB4Mr/3JcYDlyiWBEwLISg/v/alx9QWv/anAHXjP
-caAAYB0SsRSR4H7gePHA4cUIdShzB/CpcPn/AhsUAALlsH1huowi/4/39dkFj/3gePHA4cUIdShz
-CfCpcPD/AKtIuAGrAuWwfQLjYbqMIv+P9fWxBY/94HjxwOHFocEIcyh1AeJdehDwaHDl/wAcBDAC
-axB44v8CHAQwAMAE43B7BB0QEGG6jCL/j/D1dQWv/aHA4HjxwPYMj/0IdkIN7/0k2FEgAIDKIcEP
-yiLBB8ogYQHKI4EPAAAXAsokIQCMAqH8yiXBAM91oADALxOFpw4RECkIngYThSDes7i6uBOlz3Wg
-AMgfZNjQpUMdGBAA2IoI7/2NuNGl9NgA2SIN7/0B2jTYANmRuRYN7/0A2jDYiiEGAAoN7/0A2jTY
-ANkD2v4M7/0UuroM7/0w2MK4CwhRAADYB/AE3T/Yxgqv/alxqXDPcgEAxgPPcaAA7CdGoc9xoAC0
-DzyBkwkQAAISBDYKIcAP63IF2IojiQDdAa/8uHOauBOlIN/PdqAAyB/wpoogDwpDHhgQANjyD6/9
-jbjxphOFs7i6uBOlZNjwpkMeGBAA2NYPr/2NuPGm8KYB2EMeGBAA2MYPr/2NuPGmE4ULCJ8GEIUf
-CB8A/BUFEAohwA/rcgXYiiNGDXEBr/yKJMgORNhJHhiQpfEJBI/94HjxwJYLj/2hwSh2z3egACwg
-QBcQEADdABxEM7DqMmgEIYEPAAD8/64Nr/0s2BCHAiAABIwgD4oJ97YL7/0s2Ah17QgegAfwIIaA
-uSCmwgmv/T/Yngvv/TTYHQheBSCGgbkgpq4Jr/0/2DTYANkA2sIL7/2VujC9U/APeRC5BSGBDwAA
-gv3PdaAA7CcmpQQggA8AAAAfSLiGuBC4BSCADwAAQv0GpRCHAiAABIwgD4oO989wAAAD/QalCoWL
-cQCxABQAMeUIHoAI8CCGgLkgpkIJr/0/2M9wAABD/AalCoVAJIEwALECFAAxEQieACCGgbkgph4J
-r/0/2M9wAACD/walCoWLcQCxIMDPcgAAw/9GpUqFCLhAsSDFBX1A2PIIr/2pcalw1QKv/aHA4HjP
-cQEAxwPPcKAA7CcmoOB+8cBeCq/9AtmiwQDeQca2CO/9i3A+2L4Ir/0CEgE2PtiyCK/9ABQBMT7Y
-qgiv/QIUATEFzNdwAAAAQAHYwiAKABe4ACCBDwAOAAACFAAxG3gP4AQggA8AAPz/JXiduJ+47HEA
-oQISATbscCCgABQBMexwILACFAEx7HAgsAIUBTFRJQCAyiHCD8oiwgfKIGIByiOCDwAAmgGEB2L8
-yiSCA89xAAAiIi4Ir/0+2AHYL/8Bwc91oAAsIPCFJXhBwA/wABQAMYHBAdp//+xxALEAFAAxAeYB
-4AAcBDACFAAx5Q4CkMT/MIU+2OoPb/3ieT/Y4g9v/QHBigyv/QHAyQGv/aLA4HjxwKHBEHhPIAEE
-kbmLcxjYENpf/gkC7/8AFAAx8cA+CY/9CHYod4oJ7/0w2AhxhiEGAGILr/0w2HYJ7/0w2P0IX4Lb
-foG+QC8NFCzYRguv/QUlgRNaCe/9MNj9CF+CiiDRD24Pb/0FJYETWQGP/eB48cDiCI/9GnAodzpy
-z3aAAGwQFJbPdYAATHwQuBYJoAgApYDgyiciEIUhBylPIUAnn7jscQCh7HEAGQAECIYNCB4AAIWB
-uAClz3CAAMwGAIiE6ACFg7gApc9woAAsIBCAAN5tHRgQSiTAcMlxqCAABs9wgAB9CQCIgOAM2Mog
-IQBEKb4Dz3KAAKjDJ3AzIgAAACGCD4AAzH0B4QCqHe8AhWIVDxapcWMVBBaAuAClANgG8OxzQKME
-GZADAeD34ECBuffPcKAA1AtNoMChYh3YE2MdGBEP8ADZqXIG8OxzAKME4gHh9+EAgrr3z3GgANQL
-DaFRAK/91B2AE+B48cDhxaHBCHVKCq/8F9jPcIAA9AQAgJbondgAHAQwEcypcR7aAhwEMAHgEHgE
-IIAPAAD/v4+4ERocMADAGLqy/0oMgAUhAK/9ocDgeADY2vHxwOHFABYNQAXMAdrXcAAAAEACyMIi
-igAXusdyAA4AAFMlARCk/1ElQJDPcYAA9AQB2MogIQDhB2/9AKHxwF4Pb/0A2M9xpwAUSAihR4HP
-doAAlI5fplCBz3OnADREgB6AEAehz3LzD//8UKEWoaDZmrn1G1gAz3GlAAgMCBEFAEwlAIDKIcIP
-yiLCB8ogYgHKI4IPAAD/AsQEYvzKJCIAz3KkALg9mxIDBs91oADIH3umphIDBiDffKaSEgMGfaaj
-EgMGfqZQ22KhmxoYAP/ZphpYAJIaWACjGlgAz3GkAOz/B6HPcAAA//8GoVEVEJYB2FEdGJDwpUMd
-GBAA2JIKr/2NuPGliiDEAM9xoADsJwahCoFoHgQQiiDNAAahCoFqHgQQz3AoAAIBBqGKII0ABqFR
-HRiUyQZP/eB48cDhxQhyAd2A4cohwQ/KIsEHyiBhAcojgQ8AAJEAyiQhAAAEYfzKJQEBgOJE9lN6
-iiX/HwkJEwAzebN9FCGAAJYIIAY7eax4kQZv/S9w4HjxwPoNT/16cJpxSHcacwolACEA2s9xqwCg
-/1mhB9gaoVihIN7PdaAAyB/QpQHYQx0YEADYzgmv/Y240aUZ2c9wpwCYRzqgCgmgCR7Yz3KnABRI
-HYK+gmwSEQBwEhIAAKcAGEAj97jFIIIPAP8AANMg4QX3vcUlgh8A/wAA0yXhFYohEADL/wh2qXCK
-IRAAyf8IdUApACKKIQgAxv8Id0AqACKKIQgAw//ReRnhLHkvcbF6GeJMei9yABuAIw0PYhAAHEAj
-ANgF8P0Ig4AB2H0Fb/0AHQIg4HjxwDoNb/0A2c9zoAC0D7yDPKPPcIAAlI5oEAIBELpPIk4AiL7P
-cqAA7CfGomoQDgEQvoUmjRDGot+Az3enABRIx6eAEA4A0KfPdqUACAwipvuAz3akALg9mx7YE/yA
-ph7YE/2Akh7YEx6Aox4YEM9wpADs/yagiiCKAAaivKNyDKAAAdgdBU/98cCKDE/9z3CAADB8B4iA
-4OYEIQCswc9wqwCg/2QQGQBoEBcAYBAYAAfdSv8A2c9wqwCg/zmguqA4oFoJYAkB2M93oADIH1EX
-AJbPdqAA7CdAwAHYUR8YkCDYEKcB2EMfGBAA2D4Ir/2NuCDYEafPcacAFEisoQDYDaEOoQ+hz3AA
-AAEqBqbPcKUA6A+noCDYEKcF2EMfGBAA2AoIr/2NuCDYEacB2M9xoAC0Dxyhz3AAAAIvBqbPcAAA
-wjAGps9wAABCSAamz3AAAAJKBqbPcAAAAmIGps9wAADCYwamSiAAIM9wgAAwfCSQC4hEKb4HGGAV
-eGq4ACBBDhUgACQ4YMdwgACULAMQlAAEEJUAARCSAAIQlgAgiBC5BSGBDwAAQi0mpiCIELkFIYEP
-AACCRiamAIgQuAUggA8AAEJgBqYg2BCnBdhDHxgQANhWD2/9jbgg2BGnSiEAIBDwz3CAAAiKFiBA
-BEQYgAFBhUgYQAFAIVEgV6A4oM9wgAAwfAaQMnDaAg4Az3GnABRIXBlABEAqACRPIEEAh7mJuSam
-CHGFIYsAJqaFIIwABqYlCRAgOQlQIE0JkSBALAAkBSCBDwAAgmAmpgUggA8AAEJiGfBALAAkBSCB
-DwAAgi0mpgUggA8AAEIvDfBALAAkBSCBDwAAwkYmpgUggA8AAIJIBqYg2BCnBdhDHxgQANiWDm/9
-jbgg2BGngcCCwUAkEzuJworDCiTABB//K8CHCBAACcBAKU0hx3WAAIyJAKUKwAGlAcAYpQLAGaVA
-LgAkhSCKAAamINgQpwXYQx8YEADYRg5v/Y24INgRp4PAhMGJworDCiTABAv/K8Ai6AnAAqUKwAOl
-A8AapQTAG6VDCRAgVwlQIGsJkSBALQAkBSCBDwAAgmAmpgUggA8AAEJiJvAKIcAP63IF2IojBAGn
-8AohwA/rcgXYiiPEA5/wQC0AJAUggQ8AAIItJqYFIIAPAABCLwzwQC0AJAUggQ8AAMJGJqYFIIAP
-AACCSAamINgQpwXYQx8YEADYng1v/Y24INgRp4XAhsGJworDCiTABOH+K8DbCBAACcAGpQrAB6UF
-wB6lBsAfpSDYEKcF2EMfGBAA2GINb/2NuCDYEadAKgAkhSCKAAamh8CIwYnCisMKJMAE0P4rwK8I
-EAAJwAjBBKUKwAHDBaUHwBylPaUDwQIhwgAFw1hgAiDFgEzyYnlMeS9wqHGw/gPBQCiNILR9FSVN
-FAJ5x3WAAJSOAsAEwiGlCMMCIgEABsA7YwIjBYA88gJ6LHovcKhxo/4EwgXDAiIBAAPAJ6UCIwaA
-NB2AETPyBsACIIWAeAXi/0wdQBEKIcAP63IF2IojhQEa8AohwA/rcgXYiiMECkokAABpBi/8CiUA
-AQohwA/rcgXYiiPEDPXxCiHAD+tyBdiKI8QORQYv/Iokgw8KIcAP63IF2IojxA/28QohwA/rcgXY
-iiPFAIokgw8hBi/8CiWAAUAgUCBMIICgggTF/wDYz3GgALQPHKHC/s9xqwCg/2QZQAZoGcAFYBkA
-BkokAHEA2aggAA0ocIAggg0QeAa4gbiXuAamKHCAIEIPEHgGuIG4l7gGpihwgCDEBhB4BriBuJe4
-BqYocIAghAgQeAa4gbiXuAamKHCAIIYAEHgGuIG4l7gGpihwgCBGAhB4BriBuJe4BqYB4QDAUR8Y
-kNUHL/2swPHApg8v/ZhwocHPcoAA+AQgis9zgACUjgGChBMDAJBxzCDBgOnyEQjAAM9wgACsjyGI
-IKpKJMBwSiAAEKggwALPcIAArI8yIAACCwgAAUAgSBBMIMCQogEGAM9wgACsjwGIEQgBAQQhAQEv
-JUcABvAHIAABLyUHAGGiANvPcKAAtA9wEBIAfKAAGgIBFPBAIIAhEHgGuIG4QCkBJCV4BqZAI4ER
-MHkGuYG5QCoAFCV4BqYB489wgAAwfAaQEHMwAQYAANkPIcEACyFAgQHYyicCAA30CyEAge3zz3CA
-AKyPAYjTCACBCicAAhLr0QtQAA8LkQCKIIYgiiFGAgvwCiHAD+tyBdiKIw4LZfC22r3ZGnJ5cc92
-oADsJ0ohACBKJABxCiJAFCp1qCBBAgAgQSNUa0AvAAEUeBpitXrHcoAADI8IkjB5QCmJAU8hQRAc
-fxC/5XkmpsC4uHgFIEAELyEIIAAjTxMJkvB/Br9PJ0YQHHlAKRMEBSOBISamwLi4eAUggQIvIkgQ
-RSHAEAamCoaLcQCxCJIvJgEAABQAMSsIgQFFJ88Q5qYKhgCxCZIAFAExHHgrCEEAAeVr8YoixAaK
-IYQIpvEKIcAP63IF2IojDwBKJAAAoQMv/AolAAEKIcAP63IF2IojjwD18c9xoAC0D3AZgAQJBi/9
-ocAA2c9wgACsjyCoIajgfyKo4H7gePHAfg0P/a/Bz3CAAGwQCIDPdYAAlCzAuEDAz3CAADB8JJAL
-iEQpvgcYYBV4argAIEEOAMAVeDhgGWUjiUHBGWUkibhgAohCwUPAz3CAAJSOAIAiuMC4RMDPcIAA
-lI5kEAEBz3CAAMgGAJBKIQAgUwkBAM9ygACspC2Kz3aAAKyPhiH/AWCOQ7nuik+KAiHBgGGOhif/
-EcohYgBDvw4jw4OGIv8ByiNiAHt7ZXl7akKODiLCgMoiYgACukV5AvAH2YDh9gMhAEXBz3GgALRH
-RxEBhoDh4gMBAM9ygACspC2Kz3OAAKyPhiH/AUO5IKsuioYh/wFDuSGrL4qGIf8BQ7kiq89xgACU
-jmQZBAAA2Z65z3CgALRHUxhYgEv9z3agAMgfURYPlgHYUR4YkCDYEKYB2EMeGBAA2F4Ib/2NuCDY
-EabPcYAAMHwEkSuJz3KgAOwnRCi+BzlhNXlquQAhQA4AwTV5OGAJZRC5BSGBDwAAQi0mogllELkF
-IYEPAACCRiaiCGUQuAUggA8AAEJgBqJRHtiTz3CnABRIDIDPcg8AAPzPd4AAlI5GwADAArgUeBtn
-HWcZZwAnBBAAJwUQH2cJh2GDp4UGxyAUBAAigQwVBQCc7wq7RHvJvaV7z3WnABRIbaUKuSR6iHHJ
-uUV5z3KnABRILqJALYECBCGBDw8AAPzJuCV4G/AKvUR9ybule891pwAUSG2lQCyDAmR6yblFec9y
-pwAUSC6iCrgEIIAPDwAA/KhxybkleM9xpwAUSA+hSiIAIAPYR8AKI0AkBcARIICELgIBAM9xgACs
-jzIhgARCcUjBz3GgALRHYBkYgBC4m7jPcYAAaKUgiZ+4gOEB2cB5D7kleM9xoAC0R18ZGIAG8MoL
-L/2KIAgAz3CgALRHcRAAhgQggA8OAAAAQSh+hPL1AN8D8AHnz3CAADB8BpAQd74BBgAIwACI7QjO
-gwDAArgUeEnAAcECwAIgWQDPcKcAFEj3oArv9Q9QEBkPkRCKIYYgiiNGIgbwtti92TpwenFKJAAh
-inVAL1gRYb1RFhCWAdhRHhiQINgQpgHYQx4YEADYcg4v/Y24INgRpgPANW0leBB4ELiFIIoAz3Gg
-AOwnBqEAJUAUEHgGuIG4l7gGoQAlwBQQeAa4gbiXuAahQCGAIRB4BriBuAahQCOAIRB4BriBuAah
-UR4YlEAkBD6KwIvBjMKNwwP9LsCN6M9wgACUjnwQAAbPcYAAlI4B4HwZGAAJwAbB9XjHcIAAlI6b
-6YvCYIKKwSCBisJgoovCIKKNwmCCjMEggYzCYKKNwiCiM4A0EBAACvCKIMQGiiGECI7xLYBMEBAA
-FiBAMwrCACCVD4AAjIkLwPAdgCD0HQAgCCKAD///Af8vJkAmBC4+IC9wzPwOIJcPAAAAAQvAiCB8
-AAQovgUvcApxxvwOIIEPAAAAAQkngC8AAP8BiSHHD0ggAABIIQEALsJUHRggVR1YIAsKUAAEwozq
-VG9AKgMhdHt6YrV6x3KAAAyPCLIpskIkVCBMJACgkgbN/xzxB8BhuIDgQCJSIMIF7f9HwPf8BfDK
-CS/9iiAIAM9woAC0R3EQAIYEIIAPDgAAAEEofoTx9QkBL/2vwPHAocGLcA4PL/0E2QDAUSAAgCgM
-gv8AwFEgQIAoC+L/yiCiAADAUSCAgCgOwgkAwFEgwIAsC8IJZghgAAHYz3GAruAB7HAgoALI7HEA
-oc9ygACMiYokgX0A2aggAALwIkMA7HBgoAHhogsv/QDYocDRwOB+8cB2CA/9z3CAAJQFAIC7CFQB
-z3agAKwvGoZSIAAAqwgfAM9xgACMjwmBAeAJoc9wgAB0pUCAA4AVeQbqCoEB4AqhBfAYgQHgGKEY
-hs91oADIHyDfmrgYpgXY8KVDHRgQANgGDC/9jbjxpZX+GIazuLq4GKZk2PClQx0YEADY6gsv/Y24
-8aX+DAAJHgrACOYIQAAG8JoIL/2KIAgAz3CgAHhFAIAEIIAPDgAAAEEofoTy9c9xgABsEEiBNJFT
-IgAAZgvv/AHbFgov/BHYEQAP/fHApg/P/M9wpQDoDweAz3KkAAxCUyAEgEQgjQBEIAMBAoLPdg8A
-APwIccm5xHjjgiq42HfEf0EvhRLkglMmRgLpcsm65H4qvgbyDQmUB4whT4jE9wDZA/AB2QsMEAAL
-CJUHANgF8IwgT4g99wHYG3gleATtCQ6VBwDZBvCMJk+IPPcB2QK5BXkD7QsNlQcA2AXwjCVPiD33
-AdgDuAV5BOsJCpUHANgG8IwiT4g89wHYBLgFeQPrCw6VFwDYBfCMJk+YPfcB2AW4JXhCIACAQQfv
-/MogYgDgeOB/ANjgfuB4z3CgACwgEIDgfwng4H7geOB/AdgA2Za5z3CgAKwvPKDgfuB44H7geOB+
-4HjgfuB44H7geOB/ANjgfuB44H7geOB+4HjgfuB44H7gePHAdg7P/M9wgAAQBgCAgOCkCAIIz3eA
-AAAAAIdKIAAgNwjeAAGHUSDAgEDYzyDiB8oggQ8AANAAzyDhB89xnwC4/x2hBIcB4NO4BKcFIIAP
-0P4AABahFMwA3n0IHgDPcaAAyB+wEQIAz3OAAGwQahMAAWO4CCIAAB6hENgOoQHaz3CAAMSVFRmY
-gAMaGDDPcIAAiJYHGhgwCIMVCN4Cz3CgALRHSxiYg3cYmIAyCYADz3CAACgFAIiA4MwJAgkEII9P
-MAAAAM9woAAsIM91oADIHyTw7bjKJYEfoADIH8oggQ+gACwgGfISDwABz3CAAGwQCIARCN4CANme
-uc9woAD8RCKgFMzPdaAAyB/vuM9woAAsICX0CnfPcYAA4A3DocWhA4B/AiAAB6EVzFMgQIAR8gfI
-AxIBNgMaGDAHGlgwngiAA89wgAAoBQCIgOA4CQIJz3WgAMgfSwIgAADeBNgKGhgwH4WA4IogDADK
-IIIPAAAAAg6lA9gVuBIdGJDPcIAAEAYAgIDgSA/CBwCHBCC+jwAA33hoAwEAz3CfALj/3aBdAwAA
-CsjPcZ8AuP8Woc9wnwC4/1gYAAgehWMIXkUKyIYg8Y8t9M91gADgDQOFAeAqDiABA6XPcIAAbBAI
-gBEI3gIA2J64z3GgAPxEAqHPcIAAFJEdgIYgvo8E8gWFAeAFpc9wgAAAAACADwjeAgDZz3CfALj/
-PaBKIEAgFMwLCB+BHQifgYYg/4Uo8icLHsAjCF/FFMzPdYAARH1rCN4AgNgUGhwwFcwTCN4CGIUB
-4BilSiAAIATwEIUB4BClz3CAAKykEohRIACAwAsiAMogYgAE7xeFAeAXpRTMAN6hCN4BFcwEIIQP
-AAAAGD0MgQ8AAAAIngmgAgpwKQgeAAjYm7gN8IogBAAUGhwwD4UB4A+lZO8WhQHgFqXg8QoaGDBu
-8ATY/fHOC4AAFcw/CN4Az3GgACwgBYEmgQrg6QkEgAMSATYC2BQaHDBQ2M4NIACYEQEA6g5AA89w
-gAAoBQCIgOCAD8IISvADyKAQAADwuMlwGfJKCYAAANiWuBXwLQgeAk4KoACKIAQAagugAMl1A8ig
-EAAA8LipcAXyIgmAAADYlbiqC4AAvvHPcqAAyB8TCF4CCgmgAAHYANiQuPPxFwieAxMLHkCKIAQA
-DqIE2AoaGDAVEgE3JQneA0ASAgbPcIAAjJENkBUKBACvuRUaXDDPcIAA+LTAoM91oADIHwrIBCC+
-jwOA6EP6BcL/USBAxfIFwv8/haAVABAJIQAA5ODQ9s9wgAAIiQCAGQheAN6lEN+eDuAE6XCE6AHY
-HqXupYogCACgHYATDqUfhREIFQqE6IogBAAOpXYLwAgv2JW4Eh0YkM9wAQDA/BUdGJDKCIAAz3KA
-AGAFAIJDCNABz3CgADguBYAEIIAPwAAAACUIgA/AAAAA9dkFuc9wnwC4/zqgB9k7oGnZGLk5oAHY
-A/AA2AsIUQAH2ACiz3CAABAGAICA4GgMwgfPcYAA4A1EgQOBCCIAAAShRYEGgQgggAAGoXyFB4FI
-gQJ7AMoIIsIASKEXCBECA9nPcKAAQC0woAAagjME8AHgABoCMM9wgAAAAACABCC+jwAA33gF8s9w
-nwC4/92gz3CAAGwQCIAtCN4Cz3CAANwDEHjPcaAAtEdJGRiAz3AARBQASxkYgEwZmIMD2HcZGIDd
-Ac/8z3CAACkFQIgRCh4Az3GgAKwvGYGKuBmhEQpeAM9xoACsLxmBjrgZoeB+4HjxwOHFB9kbGlgw
-z3CgANQHGhhYgA4QDYbPcYAAAABAgQsaWDM3Ch4CQYFRIgCCQNrPIuIHyiKBDwAA0ADPIuEHz3Of
-ALj/XaNEgQHi07pEoQUigg/Q/gAAVqPPcaAASCy+oR8QAIYCGhgwCMqc4Mwggo8AAJEABvIAFgBA
-ABYAQAXMz3GfALj/GKGKIEYENg+v/AISATYxAe/8CMrxwOHFz3GAAGwQSIFTCh4AhiD/Ac9ygABQ
-YEO4CmIA24DiyiHBD8oiwQfKIGEByiOBDwAAWgDKJMEAOAah+8olIQDPcKoADFARCrQAvoGAvb6h
-AdkloAXwoL2+oWWgzQDP/OB48cBGCM/8GnDPd4AArKQQj4Yg/wFCKNEAz3agALRHKnUF8OYI7/yK
-IAgAcRYAlgQggA8OAAAAQSh+hPX1QxYAlkYgAA1DHhiQVxYAlry4v7hXHhiQXxYAlr+4Xx4YkADY
-nrhTHhiQEI9gHhiQzP/PcIAAMHwHiBXoEI+GIP8BHgiv/0O4z3eAACwFFI8TDQAQz3CAAMw+FoBA
-eBQfQhTCCYAJQxYAlkUgAA1DHhiQgwgVIQpwMyYAcIAA1GNAJwFyFHkAeRC9m73PcIAAaKUAiJ+9
-gOAB2MB4D7ileF8eGJAf8M9wgABopQCIEL2A4AHYwHgPuJi4n7ileEUgwAFfHhiQD/AQvc9wgABo
-pQCIn72A4AHYwHgPuKV4Xx4YkArIhOB8CeH7yiBhBH0Hj/wKIcAP63IF2IojTgdKJAAA0QSv+wol
-AAHgePHABg+v/AHZz3CAAGwQCIDAuBt4AN7PdaAAtEdLHZiTdx1YkM9xoACERNihAtl3HViQANme
-uVMdWJBUHViQz3GAADgBRx1YkI64z3GAACgARSAGDUgdWJDPcIAAbBBJHZiTGpACuGy4RB0YkBzY
-RR0YkM9wgABEvgGIRh0YkM9wgACspBCIdP9KJMBwz3GAAOSZyXKoIIADz3CAAJClVnhhgPJq9n8/
-ZwKAYqcB4gOnz3eAACwFAIcD6GQdGJBDHZiRAdh9/89wgABsECiAJQneAs9wgADcAxB4SR0YkM9w
-AEQUAEsdGJBMHZiTA9gF8EsdmJMB2HcdGJBAhx0JHgBTIkEAErlEIgADDrgleIYi/wMKukV4EvBI
-cIYg8w8KuAQigQ8AAAAMBrkleAQigQ8AAAAwArkleM9xgABQUjEGr/wCoaHB8cCqDY/8z3KAAJCl
-YIKlwWh1hiX+EyS9Dr0GIUIDwrsOu2V6TsIEIoMPAQAAwEErhANALA0GnL3Pc4AAbBBog5+9z3aA
-ACwFUSMAgM9zgACQLRYjAwEF8vCD5KZxgwTw4INhg+Sm5rhjpgjbC/IL2wQivo8AAAAYyiOCDwAA
-DwTkuHpzzyXiFgX06LjPJWIXDwieAs9wgABoBSCAZQpeAgQhgQ8BAADALrnPcIAAUGArYEkjgwBh
-u89wgABsEGIQgAAuxzJrNHnHcYAAbJjkeEgREQZJERIGhiD/Dgm4QCwOAsV4BX8EIoIPAAAAEEV/
-nr0Y4297A8i5GMIAWPBDCh4CRMEkw6DjyibCEMomIRAEIY8PAQAAwM9wgAAAYGtgBCGBDwYAAAAx
-uS6/O2PPcYAAUGDpYWJ5Nn4uwStgFPBTIcAAHXjPc4AAMGMOYwQhgQ8BAADAz3CAAFBgLrkoYGG4
-Fn4B2xsOFBYKIcAP63IF2IojBgGKJIMPBQKv+7h2Mm40ecdxgABsmAAREQAEERIAYbsEIoIP7wAA
-3Sa6ZXoDyFIizwO5GIIDz3KAAJwqGoJbgkR4DwgeAiKBz3CnAIhJL6A4FBAw6XCGIOMPz3agALRH
-QSgUAgbwngyv/IogCABxFgCWBCCADw4AAABBKH6E9PWKIP8Pbx4YkGseGJAD2Q+5z3CgAMgfExhY
-gFkemJRaHliUWx7Yk1ge2JT7vUolAAAL8h6AArhCIIUDSCUFAKhwybgFfc9wgACQpQeAANkPIQEF
-JHiA4M9wgADMBAHZQIDAeVMiAICvvQjyhiJ/D116D7pFfQXwgOHPJeITVx5Yk4fogOEG2Mog4QEC
-8ADYz3GAAGwQKIEnCR4ATyABAo25l7kVHliQBSCBD4AAQDoaHliQBSCAD4AAwFMR8AUggQ+AAMAk
-FR5YkAUggQ+AAAA+Gh5YkAUggA+AAIBXFx4YkM9wgAAwfASQHwhRAIQWAZZQIQADBCGBDwAAAAyt
-uAK5JXgD8IQWAJYWHhiQjCXPj8ohxg/KIsYHyiBmAcojhg8AAPgAaACm+8okxgAqcLoKoAkKcQjc
-1wKv/KXA4HihwfHAdgqv/Jhwz3CAAJClYICkwWhwhiD+AyS4DrgGecK7DrtleU3BBCGDDwEAAMAu
-u4HiAdjAeAa4ViBACEArDQacvc9ygABsEEiCn73PdoAALAVRIgCAz3KAAJAtdnoF8vCC5KZRggTw
-4IJBguSmQ6ZhCV4CBCGCDwEAAMAuus92gABQYEpmSSKCAGG6z3aAAGwQYhaOEC3HArpUesdygABs
-mOR+SBIRBkkSEgaGJv8eCb4Iu8V7ZX8EIYEPAAAAECV/nr1PIBQBTyTUIV7wUSRAgs8gYgHPICEB
-mnBHCR4CQ8Ejw6DjyiDCAMogIQDPdoAAAGBrZgQhjw8GAAAAMb8EIYIPAQAAwPtjLrrPd4AAUGBK
-Z2J6FiCFAC3AC2YV8FMhwADPcoAAMGMdeAhiBCGCDwEAAMAuus9zgABQYEpjYboWIIUAAdsbDRQG
-CiHAD+tyBdiKI8kG9QZv+4okgw9ALYIAVHrHcoAAbJgAEhEABBISAGG7BCGBD+8AAN0muWV5UiHP
-A89xgACcKhqBO4EkeA8IHgIigs9wpwCISS+gNBQQMOlwhiDjD892oAC0R0EoEwIG8I4Jr/yKIAgA
-cRYAlgQggA8OAAAAQSh+hPT1iiD/D28eGJBrHhiQA9kPuc9woADIHxMYWIBZHpiUWh5YlFse2JNY
-HhiV+71KJQAAC/IegAK4QiCFA0glBQCocMm4BX0A2c9wgACQpQeADyHBBAR5z3CAAMwEgOEB2UCA
-wHlTIgCAr70I8oYifw9deg+6RX0F8IDhzyXiE1ceWJOH6IDhBtjKIOEBAvAA2M9xgABsECiBJwke
-AE8gAQKNuZe5FR5YkAUggQ+AAEA6Gh5YkAUggA+AAMBTEfAFIIEPgADAJBUeWJAFIIEPgAAAPhoe
-WJAFIIAPgACAVxceGJDPcIAAMHwEkB8IUQCEFgGWUCEAAwQhgQ8AAAAMrbgCuSV4A/CEFgCWFh4Y
-kIwlz4/KIcYPyiLGB8ogZgHKI4YPAAD4AFgFZvvKJMYAKnCqD2AJCnEI3McHb/ykwOB48cBiD2/8
-ArnacM9wgABsEB+ANnkAIY0PgADkmYDgocFAw8jyCIUFIJMAIB3AFBgVFRAQFRQQFBUREOeFqnAA
-FRAQhiDjD892oAC0R0EoEgIF8OYPb/yKIAgAcRYAlgQggA8OAAAAQSh+hPX1iiD/D28eGJBrHhiQ
-A9kPuc9woADIHxMYWIBZHhiVWh5YlFseWJVYHtiU+79KJQAACvIegAK4QiCFA0glBQCocMm4BX/P
-cIAAkKUHgADZDyGBBCR4z3GAAMwEgOAB2ECBwHhTIgGAr78H8oYifw9deg+6RX8E8IDgzyfiE1ce
-2JOG6YDgBtjKIOEBA/AA2M9xgABsECiBKQkeAE8gAQKNuZe5FR5YkAUggQ+AAEA6Gh5YkAUggA+A
-AMBTEvAFIIEPgADAJBUeWJAFIIEPgAAAPhoeWJAFIIAPgACAVxceGJDPcIAAMHwEkB0IUQCEFgGW
-UCEAAwQhgQ8AAAAMrbgCuSV4BPCEFgCWFh4YkIwlz4/KIcYPyiLGB8ogZgHKI4YPAAD4AKwDZvvK
-JMYAKnACDmAJCnHiCCAMAMAA2c9wgABsED+gAIUAHgAg+QVv/KHA8cDCDW/8ANulwQvpSIEEIoIP
-AAAAMEIiA4DKI2IAUmhWesdygADkmcCCQMYlDh4SIMDPdYAAAGAyJQQQAIoNZQQmgB8GAAAAMbgA
-IEUDBfAB2JhwuHCuvq++sL5AxoDjzCEigIT0z3CAAJClz3OAABSRlhOBAAOICyEAgDTySBOBAADf
-ANtTIU0ADyNDA0QhDQNCvYYh/wMPJ08TvGkEJw+QANkEew8hQQMkeMonARCA48ojwQMnDVAAKQ2Q
-AIEN0AAKIcAP63IF2IojCwdKJAAAsQJv+wolAAEOu2V+M/Dle/3xIYLPdYAAKHV0aWNlFwteAi8o
-AQBOIIEHANiOuDh4BX4f8B0NUAAlDZAAMQ3QAAohwA/rcgXYiiPLDNnxz3CAADB3NngCiAfwz3CA
-ADB3NngDiA64BX4F8I6+j76QvgQmgB8BAADALrjPcYAAOGMIYVMIZQFAxgohwA/rcgXYiiPLDh0C
-b/uYdg2RKIGGIH8MBCGBDwAAADAsualpHHhAJYETDyZOEEDGGwhPAwohwA/rcgXYiiMMAYokww/h
-AW/7uHXPcYAAkKUAgYtzoIOGIP4DJLgOuAZ9oKMAgcK4DrileACjAMDPc4AAbBAEIIEPAQAAwC65
-QCkFBk8lBQeog08lxQfPdoAALAVRJQCQz3WAAJAtNn0G8vCF5KaxhQXw4IWhheSmo6ZbCF4CpoII
-uSV9pqIEIIAPAQAAwC64z3WAAFBgCGVJIIAAYbgCuBR4x3CAAGSZqoDLgGITgAAgxwQgxAPPcIAA
-TJEREIYATyWFBwQmAAEJuAV55XmKIAYGUfA/CB4CRMAkxqDmyiWCE8olIRDPd4AAAGDOZwQgjw8G
-AAAAMb8EIIEPAQAAwP5mLrnPd4AAUGApZ8J5EvBTIMEAPXnPdYAAMGMtZQQggQ8BAADALrnPdoAA
-UGApZmG5Nn0dDRQWCiHAD+tyBdiKI8wOiiSDD6kAb/u4dTJtNHnHcYAAbJiggcGBQiRBAAQggA/v
-AADdJrgFeVIhwQOKIAQCxKKlohwaQAEIoiaiAdgfoxUDb/ylwADYkLjPcaAAyB8VGRiAz3CAAAiJ
-RpBbek8iAwBaEQKGOBCAAGR6WGDYGQAA4H7geOHFANvPcoAAiIYUIg0AYLVotRpiIBrCAMAdxBAo
-GsIAz3GAAAiJFnkikTAawgDQHcQQgB3cEHgdRBAB2YgaQgDPcYAAKIcVeWCh4B3EEPAdxBDgf8HF
-4HjxwOHFCHUbEgE2z3CAAIiGNHgRiBHoA8gBgB8IXgPPcIAAfHPwIEAAz3GAAKAEFHkAkRDgALG2
-DUAEG8jb/wPIAdmgGEAAmgpgBKlwz3CAAAAAAIAlCF4Bz3Gqqru7z3CfALj/NqA2oDagNqDPcaAA
-yDsOgYi4DqEdAk/88cCiCW/8SiQAcs9woACIIADeqCBAD3UO0BGggM9xgAAIic9ygAContZ5aIlH
-gnpiz3OAAACH1Hud7QAmjR+AAPiG+I0TD5EQ4JP7fyORgL8kf+CzBfALD1EQIpEgswDZOK3PdaAA
-yBz6hSCT5HksswTwLJMJCUUDWWEE8KyzuWKJIc8PBBhQAAHmANnPcIAAqJ55AW/8J6DxwAoJT/wb
-EgE2z3WAAIiGAxICNs9zgAAEmDR98Y0QFYQQJwjeAQHn6XAyEoUAp5MCGwIBz3ZBAIMAprPPdYAA
-RA7jqxDwQCRAADEShQACq8AVDRHjq892IQCCAKazz3WAAEgOEQ0FAMSjAIUB4AClBINY8M9wgACo
-hihgAeAEqwGCsIp/CB4BLyTIA893gABgUgeH0ooveQPoBYcj8EkhwAA0bc93gAAodSFnEQmeBc9x
-gAAwd7Z5IYkD8ADZx3CAADB3tngEiAgmDhAIJkEQgHFJIcEDFm01eM9xgAAweABhz3GAAEh2tnnP
-dYAAbBC9hSGBpXkEIYEPAAAACCZ4AvADggKjmBKAACiLDwkAAADYBKtg2Bi4A/AA2J24BKNRAE/8
-4cXhxs9woAAUBAPZI6AbyM9ygAAEmGGSz3GAAIiGxIoUIQ0AaLUAIIMPgACohjjhwKtighV5BpJg
-oQMSAzbAHQQQBIKgEwEAhiHDDyV4oBsAAMHG4H/BxRsSAjYEIL6PYAAAAM9zgACIhlR7x3KAAPiG
-CHEF8gPIHJAXCJ4CBCGBD2EAAAATCYEPAQAAAADYALMB2BzwFMwDEgE2GwjeATIRgQABiw0IQQAA
-2AGr8/EB4AGrC/AxEYEAAIsLCEEAANgAq+fxAeAAqwLY4H8YqvHAFg8v/ATZCHUbEg42BtgbGhgw
-z3egABQECqfPcIAA2GOKDU/8AIWCDW/8BNkBhXoNb/w42SKFBekBhQCQGwhFAAohwA/rcgXYdNtK
-JEAAhQQv+7hzVg1v/AOFAYVChSCQBYVGDW/8QnnKpxEHL/wbGpgzz3GAAEQF4H8DoeB48cCWDg/8
-IYAKJQCQEInDuMohwQ/KIsEHyiOBDwAArQDKIGEBL/KA4cohwQ/KIsEHyiOBDwAArgDKIGEBI/IE
-uM9xgAAodQdhA4UAkIYg/ACMIAKALb/Avwr0hC8LHAAhgH+AAEy7IYCBuSGgAYXCgAGGBOgAhozo
-CiHAD+tyBdi620okQADRAy/7uHMLCJ9Bvg3ABwzoiiDOAnIML/zB2QCGgNkooAGGQHgc8AGFIJAi
-yBBxyiHND8oizQfKI40PAADHAL4H7f8F2Klwrf8Bhsn/z3CAAHxz5qCqCS/86XAdBg/8z3GAAEQF
-I4HgfyCg8cDhxQMSATaigSCFFgtv/CTaAYWA4OIgAgAFBg/84HjxwIYNL/wG2BsSDzYbGhgwz3Wg
-ABQECqUJhQDeEeh2DQAECYUN6CQVBRAKIcAP63IF2IojxAIRAy/7SiRAAOqlz3GgANAbEIHPcoAA
-iIaGuBChE4GQuBOhHYobGtgzDejPcIAAfHMGgM9xgACgBBR5AJEQ4ACxxrLOsiYaggPMGoQDiiBP
-C3YLL/yKIQQHYQUP/OB48cDhxQh1z3CAAHxzRoDPcIAACLmEKgsMACBCDs9wgAC0hwCAocEpCN4A
-FmnPc4AAMHgAYxkIXwLPcIAAMHc2eFuKAoiJug64RXgG8H4Ir/yLcADAAKUVBS/8ocDPcoAAwBBU
-illhMHlBaQ0KAwAieBB4A/AC2M9xoADIHx6hENgOoQHYFRkYgOB+4HjxwGYMD/wA3891oADQD/Wl
-A94S8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Yb6MJv+f7vUD2Bqlz3CAAMAQ76gB
-2BWlgQQP/PHAFgwv/AXYAN0LuKlx3f/PcYAAFJEegaUIngMdgaEIHgAiCA/7ANmcuc9woADQGzCg
-AdnPcKQAmEA8oAQgvs8wAAAAAeXKJSIQSQsfQAsIXkVDCZ5DHQjeRRkJnkPPcKoAAAQBgIYgPwsr
-CNAA0f8g3892oADIH/CmAdhDHhgQANiGDy/8jbjxprUNFJED8Mj/ANkfCB5HANrPcKAA0BuculCg
-z3CAAJAEQIAQggHgEKLPcKQAmEA8oDTwhg/P+mEIX0VRIADFAeXKJSIQz3agAMgfIN8fCx9A8KYB
-2EMeGBAA2CIPL/yNuPGmNQ0VEejxz3WgANAPANgVpfCmAdhDHhgQANgCDy/8jbjxpgPYGqXPcYAA
-wBAA2A+pAdgVpV0DD/zxwPIKD/wA3892oADQD/WmA90S8OB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44HjgeOB4Yb2MJf+f7vUD2Bqmz3CAAMAQ76gB2BWmz3GAABSRHYGAuB2hof9CCsAB/QIP/OB4
-8cDhxc9yoADQD7CCz3CAAMAQL4gA2w8NQRAD2Tqib6gC8N//4QIP/ADbz3KgAMQniiAYCDwawIDP
-caAAyB8OoYARAABRIECAz3CAAMSZDPJCEgKGBCK+jwDAAAAE8kGAAupCoIAZwADgf2GgFMwEIL6P
-AAAoQEPyQQjeABUSAjeA2M9xgABEfRQaHDANCt4CGIEB4BihBfAQgQHgEKERCt8AANnPcKAALCAv
-oBXMRiCAAuB/FRocMC8IXgGKIAQAFBocMM9xgABEfQ+BAeAPoRXMANlGIIACFRocMM9woAAsIC+g
-4H4E2BQaHDDPcYAA4A0egQHg4H8eoeB+8cCSCQ/8AN0g2M92gABMl0AmDxUyCGAFAKbPc6AAyB8B
-2BOjWIM5g1QTBAD4EwAAz3OgADAQYYPPc6AADCQCIgKAZ4MDIUEDQaYipgIkAwDPcoAAbBDPcYAA
-FJFjpkwZRAMUklAZRANoggm2z3KlAAgMUyMAAAi2ABIEAE4ZRANTJEUBUyRCAEgZQgGD4sohwQ/K
-IsEHyiOBDwAAMw20BuH6yiBhAQQkhQ8AAADgQS1CA5YZggA+gRQeABEZCZ4DBLqBukV4CLYH2Afw
-FScMEKCkA/AE2AHg9QgUguu7mAjC/al3USCAxbTygOey9M9wgAAUkT6ABCGBDwAAAEAEIYBPAAAA
-QBBxAd/KJyIQyiViEM9xgADAEA+JAeAPeA+pz3GgALQPN4EA3hUIQQDPcKAAqCAGgIwgg47M9wDf
-Wf/PcIAAkAQggAHdCIEB4AihgOeA8s9xgABMlwWBBCCADwAAAOBBKEQDz3CkAJBBdYBWgLhySKHP
-coAAFJFnoQ0MHgBMGsQACfBMGoQDBCODD///AABnoQ8MXgAwu04axAAF8E4ahANwe2ehDQyeAFAa
-RAEJ8FAahAMEJYMP//8AAGihDYAGoQQggA8AAAD+KbhSGgQAHoJFCJ4Dz3CqAAAEBIAJoc9wgACw
-l0CIQCAEATDqWwp0AAIQhQD0JIMDFdgTuPAgwwDPcIAAiJfVeAHm6w6kkGCgG/DPcIAAyJdAiEAg
-BAEW6icKdAACEIUA9CSDAynYErjwIMMAz3CAAIiX1XgB5usOpJBgoEGpAhlCAZfvBCC+z2AAAAAT
-9M9wgACQBCCAAd0BgWG4AaEHgQHgB6GKIIUHkg3v+xQSATcrCx5AAN8H/4ogxQd+De/76XHPcIAA
-kAQggAHdAYFhuAGhB4EB4Aehpg/v+/bYBCC+z4ABAADMJyKQzCUhkBTzz3CgADAQA4AA2Qroz3CA
-AJAEQIAB3Sh3DIIB4AyiFO0C2c9woADIHCqgIv/PcIAAFJFA2T2gFMyGIPmPBvQA2I+4FBocMPUG
-7/vpcOB44cUw2wDdz3CgAMgcaaAD2s9xoADMFyEZmIBOoaegaqDgf8HF8cDhxc9xgADgDQ6BAeAO
-oc9xoADEJxkRAIYA2gToAtgQGRiAz3WgANQLV6UF/89xgAAUkR2Bh7gdoen/EIUr6APYEaXgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB4EaUTzBEaHDC5/k0Gz/sKIcAP63IF2M9zAACkCUokAAB9A+/6CiUAAfHAOwkfRs9woAAMJAeA
-F+jPcIAAkJELgM9xoADIH2TgHqEQ2A6hAdgVGRiAegkv/APYUSMAwCAPwv/RwOB+4HjxwHYNz/sI
-dc92gAAUkR2GLyYI8Dv0JQ0fEIK4z3GAAJAEQIEdpgOCAeADoiCBiiBFCboL7/sjgR2GJQ1fEIS4
-z3KAAJAEIIIdpgSBAeAEoSCCiiCFCZYL7/skgc9woAAMJAOAUSDAgB2GEfKEuM9ygACQBCCCHaYF
-gQHgBaEggooghQlmC+/7JYE9hi8mSPAA3w70CiHAD+tyBdj824u7iiSDD5EC7/pKJQAAz3WgANAP
-ERUAloDgffIjCR4Az3KAAJAEIIICgQHgAqEggoogRQgaC+/7IoEH8CkJHgG5/x2GzwjfAc9woADE
-JxkQAIYG6ALZz3CgAJAjPaBi/hvwsP8dhqsI3wE5helyBfAAEQBQAeJPekEpgAD3CgSAANoF8AAR
-gFAB4k96UyFAAPcKBIAD2BIdGJDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Eh0YkBPMERocMHX+HoYXCN4Ez3CAAJye66jPcIAA
-XJ7ssM9wAAD/f89xoAAMJAGhG9gEoVH/MQTP+wohwA/rcgXYJdsGu3Lx8cDhxVDdANrPc6AAyB+v
-o16jAiBCAF6jAdoVG5iAQNpOowQgvs8AAgAQ+A6B/wEEz/vgePHAggvP+89wgAAUkTGAJQleAs9x
-gADAEC6JRBCCAER5USGAgEjayiKBDwAAkAAD8A7aANvPcaAAqCAngagQDQBZYbFxwiVFEMol5hKw
-eArZp/1E/s9wgAD8LwCQz3agAMQnDQgeAYwlA5IE9wDfFPDPcKAAtA98oM9wqwCg/3qgSgygCADY
-GRYAlgXoAtgQHhiQAd8ZFgCWfQgRAHkJH0YD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgE8zPcYAA4A1qvREa
-HDATgQHgE6EUgbhgFKFuDu/7AdgqCi//Adjg/dUC7/vpcOB48cBmCu/7wNjPdYAATJdBjSAaAjAS
-akTgz3GgANQL2IEA20ImDhiA5somzBBFDgUQz3GfALj/GIHPcoAAkASQuBihGIGwuBihIIIFgQHg
-BaHPcYAAFJEdgYS4HaEggoogxQh6CO/7JYEA2CL/ANg+8M92gABsEMmGA+AEIIAPAAD8/yq+wL4X
-vsd2AA4AAMV47HYApgjI7HYAphHMz3agAIgkSiTAcwHgEHgEIIAPAAD/v4+4ERocMB6mAN6oIMAB
-8CWPE+xw4KAB5h0KdAAA3c9wgACIl/AgTgPscMCgAeXxDYSQbaEB2OUBz/vxwH4J7/vB2CAaAjDP
-coAAbBAYigHdz3GAABSRhuB2gcIlQRNAIwADGCBAAxB9YhkEAM9woADUCxiAAN5CIAAIgODKIIwD
-AiXOEEEIhQPPcp8AuP8YgpC4GKIYgrC4GKLPcoAAkARgggWDAeAFox2BhLgdoSCCiiDFCHYPr/sl
-gQDY4f4A2BnwA+UEJY0fAAD8/529n73scKCgCMjscwCjGIo2gYbgAdjCIAEAGCEBAOxwIKAB2DUB
-z/vgePHAwgjv+xvYz3agAMQnFRYNlhYeGJAD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgE8wRGhwwiiAEDMYO
-r/sA2Yv9JQ0eEc9wgACQBCCAEYEB4BGhUv0ZFgCWBOgC2BAeGJBp/iLwUhYAllMgQQCD4dEl4ZAE
-8qj+GPDPcIAAmQkB2SCoz3CAAJAEQIAGggHgBqLPcIAAFJEegA0I3gHPcIAAhAUgoFUAz/vxwOYP
-r/sA2c9wAAD/f891oADEJxMdGJAb2BYdGJAB2BAdGJDPdoAAFJEehgsIXgSoHkAQCPARhjaG/gmg
-AQDaqB4AEHr+HYYJCN4BANgl8C0VAZZWhhEKQACAuB2mANiD/vbxBCWBXwAA8C8ehiV4HqYRFQGW
-DwleAs9wAAAMyAvwDQkeBALYiB4EEA8JHgDPcAAAsMq9B4/7MwneAAjYEx0YkO/+1OgC2DwdAJAh
-FQGWz3CAAMSZIaARFQCWDwifAFv+HYaJCN+BERUFlhsNnwAKIcAP63IF2IojxgPFBK/6iiSDDwTY
-Ex0YkI7/sPHxwOHFz3KAABSRFoLPcYAA5JkNCBAGVBKAAAXoGYK6ggPwG4K8glGCz3P+//8/ZHik
-ewQigg8AAAAQRXgAoQDYAaFlekmhDtpKoc9xgABkuOIIT//PcIAAvLUAgBEIXgDPcYAAVLvOCG//
-Adj9Bo/78cB2Do/7z3GAAAAAAIE5CB4AAYFRIACAQNjPIOIHyiCBDwAA0ADPIOEHz3KfALj/HaIE
-gQHg07gEoQUggA/Q/gAAFqIA3s91gAAUkd2l3qVUHYIT36WA2JQdAhDPcIAACJ3ZoM9wgADQmcCg
-z3CAAPi0wqAUzIAdgBOIHYQTqB2AEyEI3gAVzFMgQIAK8s9wgABsEAmAUSBAgEohQCAE8kohACDP
-cKAABCXUoBHMExocMNv8z3eAAGwQz3GAAEx8OwmeQwDYjrgepc9wgACQBFThIKAblxy1HZeSHQQQ
-iiCEDh61iiBECw4Mr/sA2QbZz3CgAMgcKaAT8M9wgACQBAThIKAalxy1HJeSHQQQThcAER61iiCE
-C94Lr/sA2c9xgACQBECBAIIB4ACiIIEBgQHgAaH62LoIr/8A2e38gOCwBwEAz3CgAAwkz3EAAP9/
-IaDPcKAA0A8REACGDOgKIcAP63IF2IojDgaKJIMP1QKv+rhzAdnPcKAA0A8RGFiAaBeBEByVAiBQ
-AB6F7rgqAiEALyAIJEAdhBPPcKoAAAQCgM9xpQAIDCCBBCCCDwAAAP8ougQhgQ8AAADgibo7eUV5
-SIcEIr6PAAYAADGlBPKMuTGlz3KAAEyXLaIMos9xqgAABCCBRBWDEJTjKqIa8gX2NQuRAiO5DfAf
-C9AN7uMS9EUp/gJBKcFwUSDAgcIhYgAA2wrwRSn+AkEpAXH78SK5+fEA2QHbNqXPcKoAAAQBgDyy
-C6LkuMojYgDhuMojYQCGIP4PQSgEARASBQFJHQIRBSUAAQiyfaVWIUACCwseAADYT/AdCZQDoBcC
-EBUKRADPcqAA0A+AEgIAEwmAAIC7faVyCq/7iiAFCOvxVReBEA0JUQCUFwEQOGDPcYAARAkgiSUJ
-UQAA2Y25CSBBAM9woADQDxkQAIZCIAAISCAAABBxANgD9wHYnOjPcZ8AuP8YgZC4GKEYgbC4GKHP
-cYAAkARAgQWCAeAFoh2FIIGEuB2liiDFCP4Jr/slgbPxAdiA4PwCAQAKcADZ8P1iF4AQRBWBEEQh
-BQwEIEQARCQCAUItBQGgcs9xgAAgucG6SWGJuTulbBWDEEkVgRAEIw8AhiP/AyR/RLt/Z89zgAAI
-YfQjzwNeHcQTz3eAABC8SmeJulylcBWCEER4hiL/AyR4RLpYYPQjAAAEIQEBYB0EEBGFoHHPcoAA
-KGH0IkMAGaXPcoAAOGH0IkEAih3EEBqljB3EEI4dRBCQHUQQewIgAEodghPPcKYACAQBgAQggA8w
-AAAANLhAHQQQQBUBERkIX0bPcKAAqCAIgBlhMHkODm//CnAE8Apwuf0EIIBPgAEAAADZMwiBDwAB
-AADPcoAATJdAHUQQSR1CEDalKaKWFYEQAdhKHQIQCJIEuYm5JXgIsvLwSR1CEM9wpgCMA12ABCKA
-DzgAAABBKMEElh1CEAQigQ8AAADwJbgsuSV4EaXPdYAAFJELCN5HEYWMuBGlUyLBAkQVjhA2peC+
-0SLihwDYAvQB2M9zgABMl0mjlhWCEOiTBLrlekizRBUFEDyzUybCEFx6z3eAABC5T2cdpfulbBWP
-EMO/LyTBA893gAAcmPQnDxE0G0ABXh3EE893gAAAvE9nZB1AEfylcBWPEMO/LyTBA893gAAcmPQn
-DxFoHUARYB3EE893gAA8mPQnhBDPd4AATJj0J4IQih0EEYwdBBGOHYQQkB2EEM9ypgCMA12CBCKP
-DwEAAAAwv0odwhNJo0oVghAX6hUOUBOAuB2liiBFCL4Pb/uKIRAKHYURCB4AXvDyCa/7iiBQDfkI
-HsZa8FYhTgILCB4AANhP8CMJlAPPc4AAbBCgEwIAEwpEAM9yoADQD4ASDwAVCcADgLgdpXIPb/uK
-IAUI6fFVE4AACwhRAJQTAAAeZs9wgABECQCIIQhRAADYjbgJJgEQGRIAhkIgAAhIIAAAEHEA2AP3
-Adic6M9xnwC4/xiBz3KAAJAEkLgYoRiBsLgYoSCCBYEB4AWhHYUggoS4HaWKIMUIAg9v+yWBs/EB
-2IboANjD/H0CAADPdoAAFJETCRAgFoYLCJEDHoaRuB6mShaAEJLoyXXPcKAAeCZC2TKgHoXxuF4C
-AgB5/YDgUgICAEECAACKIMUArg5v+4oh0QXPcaYA1AQsEQCANBERgDgRD4DLERIGKnHGuelyhiL9
-Dwa6RXkqcoYi/Q8EukV5BCCCDwIAAAAnukV5RCcCHA26RXnpcoYi8w8EIIAPOAAAAA66RXkluCV4
-RCeBEBS5JXiIuEQnARJBKcGAUiBABRGmVB5CEMohgg8AAP//yiGBDwAAEB8acTaGP7YEIYEv/wMA
-/yi5NqbyCWABANqoHgAQcQ+eFEQWghAxhqDi0SHhgjDyBCGDjwAAAAEI8s91gAAAYE1lFQ2TEAQh
-jQ8AAAAkQQ2AHwAAACQEIY0PBgAAADG9MQ3VEBUNkRAU6891gAAAYE1lHQ2REAPrzOIK9naGEnPK
-I44PAQCIDcwgzoDO9xUOBXABAIgNz3KAAOANNYIB4TWiAd0a8M9zgAAAYEtjz3KAADB8RpIfCsIA
-FwneAs9xgABsECiBBCG+jwAGAAAD8gDdAvAC3VQWgxDPcoAATJcokigaQAQHu4i7ZXkosjaGMBqA
-BDyyMYbrogQnjx8IAAIAHbItotd3CAAAAOwP4QrKIEEDNoa9poXpzg/ACkjwz3OAAGwQVROAAFYh
-QgKB4AHYyiAiAAsIUQCUEwAAGmLPcIAARAkAiCUIUQAA2I24CSICAM9woADUCxiAQiAACEggAAAQ
-cgDYA/cB2Ajoz3CgADAQCIAJCQAAgL29plMlfpAa8lElAJDPdYAARH0M8oogxQuSDG/7iiHRDACF
-AeCRBe//AKUJhQHgCaWh/M9xoADUCzTwogoP/frxH/146IT9CiYAkC70A9jPcaAA1AsRoeB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HgRoRPMERocMADYEKHhBU/7HoULCF4EQH7C8RTMhiD/hQXyA8gBgAkIXgeh/W4OQAfz8eB48cDh
-xQh1z3CAAJCRC4DPcaAAyB9k4B6hENgOoQHYFRkYgAXw/g1v+2nYAYWD6PkLHsABhcG4IwjRAM9w
-gACZCQHZIKjPcIAAkAQggAaBAeAGoQDYFPABhREIHwDPcYAAFJEdgYK4HaEBhRMIXwDPcYAAFJEd
-gYS4HaEB2GUFT/vxwM9wgADIlyYOb/sY2c9wgACwlxoOb/sY2VcHT//geKHB8cCiDG/7mHEIdVpy
-z3KAAAAAAIKhwTcI3gEBglEgwIFA2M8g4gfKIIEPAADQAM8g4QfPcZ8AuP8doQSCAeDTuASiBSCA
-D9D+AAAWoc9wgADYngaAANmB4AHYwHhAKBMDKe2pcYYh/ACMIQKFz3CAABSRD/TPcYAAWAUggQ8J
-ngAg344QAAEI8JjfihAAAQTwXhAAAQ7fz3GAANCZIIHgucAnIhHwei8gCCBKJ0AgCfDPcIAA0Jkg
-oPpxKHcacShyz3CAAPi0wIANDtEQw4AXDt8QSiEAIAomQCQKIEA0CiVAJH7wwBACADgSjgA3EoAA
-CL7FeDkSjgAQvsV4OhKOABi+xXg0Eo4AQCAQBDMSgAAvIAgkCL7FeDUSjgAQvsV4NhKOAM9yoAD8
-RBi+xXhAIBUBXYIA2FEigIHMIyKACPIvIkgFOnD6cNpwG3BK8E8j0yNBLEADwLgEuBR4iHLGukki
-wgVUeM9ygACgYhBiDQzeAkEoAgEUIgAAKLjPc4AAoJHIi89zgAAodQPgz3IAAPz/BL7DY0AgECFE
-eC8gCCQRC54EG3hAIBAhLyAIJEAlwyFEewggzgACJtgQUSEAgMAnIREnbwQhgQ8AAPz/CCBCAAIi
-VgDaYlB6iiECIAISASFAIAAlEQhDAAIhAQRIIQAAEHgD8ADYQMAvIEgEiHEKc74OIAFKJAAACiQA
-oDz0CtjPcaAAyB8eoRDYDqEB2BUZGIAG8FoLb/uKIAoDGwgfQ89woAD8RB2ABCC+jzAAAAAD9OUL
-HsBRIwDAyiHCD8oiwgfKIGIByiOCDwAAkgLKJCIAJABi+solIgBRIADDANgJ9M9xgADgDQmBAeAJ
-oQDYmLiacEwkAKAA3sogggPE9M92gADQmTMJECDPcKAA9AftoM9wgAB0tTGAW4kaiQi6RXgEtl2J
-HIkIukV4BbYAhoG4AKYD8ADYAqZMJwCglvIAhncIHgDPcIAATJFMiM9wgAAAYDIghAAf2T0MdAAA
-2s9wAwAUAFZ4z3OjALD/UOBgYM93AwAYAFZ/UOdjZy8oAQAB4i8rwQACezBzyiHFANEKBIFALEQB
-QiQACDhgz3GAAGhjCGEhhk8j0yMJuAV5AoYleAKmBSNAIw1xALENcQDAALEMEgEgDXAgoBASASEN
-cCCwiiCFANIPL/upcYwlApUU8owlA5Eb8owlA5Uh8gohwA/rcgXYz3MAAOYLiiSDD/UGL/q4c89w
-gACQBCCAD4EB4A+hXg3gAEpwEPDPcIAAkAQggA6BAeAOoQjwz3CAAJAEIIANgQHgDaEAhgfoIoYN
-cCCgANgAps9xoAD0BwDYKQkQIAehAdgLoQPYCKFMGYAFAdgD8ADYqnELckpzBgrgCgAUBDDPcqAA
-9AcA2SSiAd6A4AHY8gngCsB4AMEAIQAEz3GgAMgf+BECAEJ4SCAAAF+BEHhHCIQADBICIM9wgADE
-mUKgoNgPoQDYH6HPcoAAwBDPcIAAFJFVihyQQngAwlhgH6EC2BUZGIAPDBAgUSBAxiDYAvKA2A6h
-jCUDlQf0z3CAABSRHJAI8IwlA5EJ9M9wgACMkQ2Qdgxv/wDZBg4P/xTMhiD5jwr0jCUDkQDYzyCh
-A8ogIgEUGhwwz3CAAAAAAIAPCN4Bz3GfALj/ANgdoc9xgADQmQDYAKHJcAjcAwBv+6HA4HjxwNYP
-L/sA2Qh1AYDBuIPgyiBBIMogQQAF8qlwlf5KIEAgIwhQABCFhwieARCFz3aAABSRNQjeAc9wgADA
-EAKIGPAB2wDfN/AA31UmQBrpcZDaDgjv/gDbQCUAEpweABAA2AW1BNsn8AWFJoU6C4AAlB4CEBEI
-3gEdhpW4HaYehpe4HqYfhgQgvo8QcAAAyiciEOr1nLgfps9wgAC8tQCAqQhegBCFpQhegwHfz/EA
-3+lzz3KAABSRVBKOAM9xoAD0Js9wgADEmZDuz3aAAHKR9CbOE1yS2mLPdoAAwBDVjsJ6ELqAugPw
-AtpDoSWFIaAdCBEgz3CAAJkJAdkgqM9wgACQBCCABoEB4AahrgwP/ykHL/tocOB48cC+Di/7kNmi
-wQh2QcEhhsG5g+EA2MogASAG8slwT/5KIEAgz3GgACwgJoEA3zB5NQhQABCGaQieAc91gAAUkRyV
-FQhDACWGz3CAAMSZAoAQcaT0EIYVCN4Bz3CAAMAQAogI8AHYQPAFhiaGIgqAAD+FBCG+jxBwAACU
-HQIQEPTPcYAAvLUggVEhQIAB2UXyUIaHCl4DQMEod0HwAN8h8ItwBOgC22CgA4GDuAOhBeoAgqa4
-AKIsFgAABKEMFgAABaEAwQHCVSVAGn4Or/4B2x+FnrgfpUAmABKcHQAQxgsP/wDYz3WAABSRVBWC
-EM9xoAD0JsEKEQDPcoAAcpH0IsMDXJV6Ys9zgADAEHWLYnoQuoC6UfBAxwDfqwjfgW2GBYbPcYAA
-+LSBwgQjgw/AAAAAAoE2u0AmBhJAIQQLQwjOAAWWHBEHAEIgBQT0JMMACCdAASsLAwDPcKAALCAP
-gI/oz3CgACwgZoAclTUIxYDPcIAAxJligAWBKQsAgAOBNwjegADaz3CgAPxEnrpBoAOBo7gDoZHx
-z3GAAJAEQIELggHgC6IggYogRQuKCy/7K4F28QLaQ6FFhs9xgADEmUGhHwgRIM9xgACZCQHaQKnP
-cYAAkARAgSaCAeEmokUFL/uiwPHA3gwP+wh2FcxTIECACvIHEgE2ANiYEQEAOgqv/ghyAYbBuIPg
-yichEMolwRMG8slw0f0IdQHfgeXKI2EAQfIQhg0InwEA22hwPPAUzF0I3gAVzFMgQIAbEgI2D/QA
-IoEPgAAQhwHYAKnPcYAArKQyiVEhAIAcDEL+ENgUGhwwz3GAAER9EoEB4BKhA8gbEgE2hBACAc9w
-gAAEhzV4KYBZYSmgCN3R8c9wgADIfCuAAeEroJ4KL/uKIMUJANsB2ALZz3KgAPQmI6JDhs9xgADE
-mUGhje/PcYAAmQkB2kCpz3GAAJAEQIEmggHhJqIK6ADYnrjPcaAA/EQBoQDYBaG+CQ//QQQv+wUj
-QAPxwNYLD/sIdgGAwbiD4ADdyiBBAwTyyXCU/QHdANlZCFAAEIZRCJ4BFMzPcoAATHwzCF4BQNgU
-GhwwUBIABgHgUBoYABvIz3KAAIiGFHogqgMSATYA2JgRAQDuCK/+CHIK8KQSAQAB4aQaQADaCS/7
-iiAFCgLZz3CgAPQmI6Ajhs9wgADEmSGgje3PcIAAmQkB2SCoz3CAAJAEIIAGgQHgBqESCQ//nQMv
-+wDY8cDPcoAAFJFUEoEAk+k8ks9ygADAEFSKQnkQuUUhQwHPcaAA9CZjoQDaz3GAAMSZQaFj/YHg
-yiBhAAXyyggP/wDYawUP/+B48cDaCg/7CHUacUEpAAHPcYAAIGPDuAhhJJUEIYEPAAAAgNdxAAAA
-gAHZwHk1eCGVBOEfCEAAjCACpAn0z3CAABSRFoCMIAKGA/IQ2JTwJJUCCS/7iiDEC4wgAqwi8g72
-jCACoEPyjCACpGTyjCACqIT0qXCk/oDwjCADpBXyCPaMIAOgevSpcKH/dvCMIAOozCCCrwAA8ABw
-9Klwx/9s8Klw3/5o8M9xgAAAAACBOQgeAQGBUSAAgUDYzyDiB8oggQ8AANAAzyDhB89ynwC4/x2i
-BIEB4NO4BKEFIIAP0P4AABaiqXBH/0bwz3KAAAAAAII5CB4BAYJRIACBQNjPIOIHyiCBDwAA0ADP
-IOEHz3GfALj/HaEEggHg07gEogUggA/Q/gAAFqEeCKAAqXAk8M9xgAAAAACBNwgeAQGBUSAAgUDY
-zyDiB8oggQ8AANAAzyDhB89ynwC4/x2iBIEB4NO4BKEFIIAP0P4AABaiPgqgAKlwyQEP+01x2g/v
-+ooghQhl8fHAWgkP+892gAAUkR+GBCC+jwBwAABW8i8pAQDPcIAAEAX0IE0AnBYCEADfpBYBEE8l
-gBDpcxf9j+iMJQOQz3GAAFwOBfQTgQHgE6E68BKBAeASoTbwH4ZdCJ4Hz3WAAKykEI0ujVkJAAAS
-jVEI3wAwrZ4Ib/4D2DUIH0MA2Z65z3CgAPxEIaAwjYYh/wFDuRC5TyHCBs9xgABopSCJn7qA4QHZ
-wHkPuUV5LaASjYS4Eq0G8M9wgABQnuCougjAAAEBD/vxwOHF3gov/wDdz3GAABSRHYFRIMCBXPTP
-cKAABCWigAQljR//AF//UyWAEIcI0QGDCp5THoF/CJ8GBCC+jwAeAAAO8gbwz3AAAPYJAgkP+/cK
-n8BRIgDAzyViEc9xgAAUkR6B+bjPJSISzyXiEs8lohMh9CUI3gaIvYm9jb1PJcASvYGOuAQljR8C
-AAAAUiVNFCq9BX0P8Py4xSWCHwAAAAXPJeISzyWiE8UlgR8AAAAHz3CAAKCRCIjEuBi4USCAxAV9
-wAsi+8ogIghBAC/7qXDgePHAwg/v+ghyz3GAABSRAJGIEQMBz3WgANAPRCAEAwomwJBA2xAd2JBC
-LIQAhiD8A8omYhCoEQ8AQC6FFc9zgABMl/B+/bP8kxC+5X4MHZiTYYsCu0jjEB3YkGIRDgGIEQMB
-22PAkXB7RLhiGcQADw6fEi6RUyHBgA/yz3CAAGwQCYBRIACAPdjAKOIFyiChB8AoIQYJ8EAsAQE4
-YM9xgADQLAhhF7gD4wUgQAEEI4MPAAD8/2V4nbifuAwdGJARzAHgEHgEIIAPAAD/v4+4ERocMA4d
-mJAgFQCWz3CAAGwQCIAjCN4CHwofAfYOb/xIcM9wgADsmqDZxNo929oIL/sXuykHz/rgePHAtg7v
-+oohCADPdYAAxJHPcKAADCQhoMSVz3CAABSRHoAadoYg/CONCF4EiQ2eUYwgA6RA9APZz3CgANQL
-MaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
-eOB44HjgeOB4MaCpcFb+EQjeAM9wgADgl/oIQAHPcaAAxCcZEQCGBegC2BAZGIAE2BMZGIAb2BYZ
-GICK8NIJYAMKcAh3qXAKccf+CHYn/0QmfpQO8hEOHhHPcYAAFJEdgYC4HaEBhWoID/9y8ArvUP/P
-cYAAFJE9gdUJ3wGB/yvwA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoBPMERocMBEO3hDPcIAA4Jc2CEABz3Wg
-AMQnERUAlgDeMQifAJ4Pz/7PcIAAFJEdgFEI3wERFQWWGQ2fAAohwA/rcgXYiiOJB+0C7/mKJIMP
-BNgTHRiQG9gWHRiQz3WAAAidGYUE6B4MgADZpc9wgAAAAACADQgeAc9wnwC4/92gVQXP+vHA9gzv
-+k3Yz3KgAMQnLRIOhgm4GhoYgM9wgABokSCIocEH6QHbz3GgANQLcqEE2RAaWIBNcYYh8w+MIQyA
-AdnAeTlhNHkAiB7hgODKJUEQA/JAIQ0DIn4G8M9wAADHD0oNz/oJCJ9E8wkexs9xoADQDxAZWIMl
-EQCGYMAlEQCGD3kBHAIwABQAMYwg2IHMIIKPAAAHCMogIgAI9IjhAdjAeI4NYAoubs9yoADEJxoS
-AYYEIYEP////ABoaWIAREgGGFQneAgDZi7kTGliAGtkZGliAjQTv+qHA4HjxwBIMz/rPdYAAFJHP
-cKAADCQ8gFaFocECIkAAZLgQeIYdBBAQcsohzg/KIs4HyiBuAcojjg8AAPkEyiQuAJgB7vnKJQ4B
-A8gBgBcIXgcvIIcKjCAChgX0HoWeuB6lANnPdqAAxCchFhCWz3egANQLGIdCIAAIgODKIEwA/OBC
-AAYAz3GfALj/GIGQuBihGIGwuBihz3GAAJAEQIEFggHgBaIdhSCBhLgdpYogxQjeCe/6JYHuDe/+
-ANjfAwAAhg8AA4Dg+AEhAJgdABDPcoAAAAAAgjUI3gIBguu4QNjPIOIHyiCBDwAA0ADPIOEHz3Gf
-ALj/HaEEggHg07gEogUggA/Q/gAAFqHPdoAAbBANDd5RVhaAEAbwA4XKDiAAJIU+hZQdAhBEIQAM
-EQgRCA0N31KA2JQdAhCUFYAQCQjeAZe5PqVJCZ4BFJVFCF8BggqABp7oz3CgACwgD4AF6APIAYAt
-CF4HHoWQuB6lz3CAALy1AIANCF4AUSVA0wHZA/QA2YtwkNoWC2/+ANvPcIAAFJGUEIEAQCkCBoYh
-/Q9SIcEBRblFec9yoACIJDCiKYZegAsJ3gALCl4CANgC8AHYUSEAgdEiYoIA2cohYgAleA94KQrf
-BSUKnlOQ6EQiPtMK9M9wgAAUkQGADQgeAM4PAAME8MYIQAPPdYAAFJEehUMI3gQE2c9woACQIz2g
-TXF6CO/6iiBEDgXwtgrv+oogFgULCJ9E9wkexs91gAAUkYYVABHPcYAAbBCCD6ADL5EU8ACVBCCA
-DwAAzIATCIEPAADIgAuFCwgeADP/BvAE2c9woACQIz2gAtjPd6AAxCc8HwCQlBWAEM9xgADEmQQZ
-AAQXCN4BHYWVuB2liiAFCfoPr/oA2Tv+CHYdhVEgwIH2AQIAUyZAEA0I0QAVFwCWsQjeAO4L7/7J
-cO/wz3GAAMh8DYEB4A2hA9gRp+B44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgRpxPMz3GAAMSZERocMBDYEB4YkALYPB4AkD4L7/4E
-GQAEHYVRIMCBsfQRFgWWGw2fAAohwA/rcgXYiiOXAo0Gr/mKJIMPBNgTHhiQG9gWHhiQnfAUzD6F
-GQjeAAQhgA8AQEAADQiBDwBAQACYuT6lJQkeBADB1NipcsoLb/8B2wTopgiAAAjwz3GAAFwOEoEB
-4BKhz3CAAJkJAd/gqM9wgACQBCCABoEB4AahHoXzuEgLwgMehfC4MA6B/h6FEQjeAQHZz3CAAIQF
-IKDPcaAAyBwA2AehMNgKoclwG/6KIIQNng6v+slxA8gBgC0IXgcehSkIHgYQ2BQaHDDPcIAA4Jfa
-CgABG8gAIIEPgAAQhx6F4Km4uB6lAJWGIPwAjCACgC70SgnAA6roA9nPcKAA1AsxoOB44HjgeOB4
-4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hgx
-oBPMERocMB6FDwjfBACVag7gBDSV4Qev+qHAz3KAAMAQVIpZYTB5QWkNCgMAIngQeAPwAtjPcaAA
-yB8foYogGAgOoQLYFRkYgOB+4HjgeAokgPAFIEQA4CDBB0Qk/oBBKsQAhAACAC8kAvFCIQEBQiAD
-AeggogQEEQQCBBEFAgQRBgIEEQcCBBsIAQQbSAEEG4gBBBvIASwAJQBEIj6BPAAiAEQi/IBAIcEA
-4CDBB0AjwwCoIIABARGEAgEbCgEgIMAHBBEEAgQRBQIEGwgB1Afh/wQbSAFEIvyABBEEAskH7/8E
-GwgBQiFBAEIgQwCoIIABARGEAgEbCgEgIMAH8cCaDq/6ANjPdYAAjJtKJAB0gN6oIEAFCHEB4E8g
-wgEWJUMQR6uKIggAQCkEAQAkgQ+AACh1QKEA2kKxxqnA2H8dAhDPdYAAVAXArc9wgAAMnIDZOg+v
-+ihywa3PcIAAwBClBq/6wqiiwfHAKg6v+phyRcFBKAECQSgDBAd5J3vGu8dzgAAMnCCLKQnfARQU
-DjHPcoAAjJsWIk0A4IUNCMED4pURD4ATJ41nbecJ3oEA2B/wxo2H7oDfz3CAAFQF4ajPcIAAwBDi
-iAsOwROA3sKoxo02egAcgAMHjYe5AKvPcIAAVAVgiCCoAdhnqgzcDwaP+vHAmg2P+s9xgADcYyGB
-o8FCwc9xgACEBBUhEQAAEQ0gLyhBA04gjgeVDRAQ9G7Hd4AAKHUGj89xgACMmxZ5AIEikY7mCBxE
-MMogYQAE8otyAsHJ/y3oANjPcYAAXAVAgQ8ggAMvIAogBCCAoAChB/SA4pwN4gTKICIIz3h2CiAA
-ENkA2IohCAAAEQIgArcgp89xgABIdtZ5AKEBoc9xgAAodgQiAgQAGYAg1HkAsRAljZMvKEEDTiCO
-B7r1PQWv+qPA4HiiwfHA2gyP+kXBz3WAAGwQIoUVCEEAJpUUFA4xCQ5BEFYdghCL6s91gABUBcGN
-gOYA2cogQQAi8iGtCwqRAwHYHPBBKA0CB31BKAEEp3nPdoAAVAWgjlMlRREbDTIExrkKIcAP63IF
-2KPbNQKv+Yokgw8LDZ4RANhf8c91gACMmxYlTRHnjQClFBQAMeCuRq0CtcdxgAAMnACJB60AGUIB
-ABtCAc3x4HiiwUHBQSgCAgd6QSgBBEd5z3KAAAycxrkqYiUK3wEEFAMxz3GAAIybVnlAgQsIgQBC
-kREKwABHiesK3oGA2APwBongf6LA4HjxwPILr/q4cEokQACQ4Mohyg/KIsoHyiOKDwAA8wCQAar5
-yiBqAUAtAwHHc4AAKHXGi4wmApAA2A3yz3CAAIybFiCNA6CFoKEmizZ4ApAAsohwDQSP+uB48cDh
-xc91gACMnM9xgABsEACBdBUCFkcKAQACkeoVAhc7CgEAdhUAFjoP7/93FQEWjCACgBPyz3KAAFgF
-IYIA2w8jAwAEuGZ5IaIAIIEPgAAodQCBqriIuAChANixA6/69B0cEM9wgACgkSiIz3KAAGyejCEC
-gAKSQSgDAwvyFwjfAgS5x3GAACh1ApEPIMAAArEA2OB/BLIA2kokAHRIcagggAPPcIAAcJ3Pc4AA
-8J00e0CzNnhAoEGgAeFKJMBzANmoIEACz3CAACh2NHhAsAHhz3CAAFgFQaDPcIAAbJ7gf0Sw8cCy
-Cq/6VGiGIvgDibpTIcMARXvPcoAAKHYUeo/hiiUPHMogKQAJ9gCSAN4PJk4QiiXPH8Z4ALJKJAB0
-ANqoIEAGz3eAAOidVH/El6R+z3CAAHCdGQuBAwDexLdWeMCgwaDPcIAAEJ5VeMCgAeKtAo/64Hjx
-wD4Kr/oIc5hyz3aAAPCd9CZAEM9ygABwnVEgQILKIEEAyiQidMogIgDoICIC9CYNEAkNXhIB4DsI
-FQTPdYAAKHZ0feCVBLuGI/gDibsPJ08Q4LUA3RZ6oKKhosO5ZXkUfiC2z3GAABCeFXkAGQABAvCA
-2DECj/oIccO4z3OAAPCd9CMCAMm6UHHKJCJ0yiAiAOggYgL0IwIAyboHCYAAAeDgfvHAmgmv+gDZ
-o8EIdQGAwbiD4MogQQAcDCL/yiBCAyMIUAAQhR8IngEQhc92gAAUkTUI3gHPcIAAwBACiBjwAd4C
-8ADeAtnPcKAA9CYjoCWFz3CAAMSZJg9v/iGgyXClAa/6o8AFhSaF/gzP/5QeAhAfhgQgvo8QcAAA
-W/TPcIAAvLUAgA0IXgBRJUDTAdgD9ADYQMCUFoAQiQjfAW2FJYXPcYAA+LSLcAQjgw/AAAAA4oE2
-u0AlAhJAIQQLRw/OEOWVHBEGAEInBRT0JMMACCZPATMLwwPPd6AALCBvh5Pr5od8lhMLxQPPc4AA
-xJnig2WBEw/BEAToAttgoAOBg7gL8AOBFQjeAADfnr/Pc6AA/ETho6O4A6ELggShA4IFoQDBVSZA
-GpDa9ggv/gDbEYXPcYAAWAUAoUEoDwPDv5QWgRBBKAUFFGkFIMQDDQneAR2GlbgdpnzwTyRAAp7/
-8QgVBM9xgAAQnpQWghDwIQMAQCoBBoYi/Q9SIsIBRbpFec9yoADEJ0EaWIACJcGAwCGEDwAAABAM
-v9dxAAAACJC/UfYFJ08RYhrYg4whAoDI9s9xgADgDQyBAeAMoQDZnblI8OV7YhrYgFUOQ3AAAMAP
-DiGCDwAAABDPcYAAcJ0WeQCBJwo1CAQRBQAA2w8jgwBhu04iDwgBKMEDWHhleAAtgwBleRXwQiIC
-CADZDyGBAGG5WHgFeYog/w8L8M9zgADgDU2DiiD/DwhxAeJNowHbz3KAAEyeZKrPcoAAjJzjGhwB
-choYAHMaWAC68QDZnLkfhiV4H6ZAJQAS6wXv/5weABDgePHAIg9P+hpwz3CAAAAAAICiwUUIngHP
-cIAAAAABgFEggIFA2M8g4gfKIIEPAADQAM8g4QfPcp8AuP8dos9xgAAAAASBAeDTuAShBSCAD9D+
-AAAWohXMVSBSJO240SBigAnyBxIBNgDYmBEBAD4M7/0IcgQQACCL6M9woAD8JSOALyCIBDC57whF
-gAASACAB3UHABBQAMUEoEwNAEAAgBhQRMYMIngEVzIEI3gJAEAAgz3aAABSREQjeAc9wgADAEAKI
-CPAUEAAgGBABIDYKz/9RIMCBlB4CEMokYSAL8h2GAN+VuB2miiAFCcIMb/rpcZp3lBaAEM9xgAC0
-mQS4RpEFIMAEFQiAAM9ygADgDQCCSiQAIAHgAKIEkSkIgQ8AAP//SiQAIA7wz3CAAMh8K4AA3wHh
-K6B2DG/6iiAFDJp3AhAAIYwgAoVD9AQQACCM6M9woAD8JQOAQCIBITB5MLjrCQWAAN5KJAB0AdjJ
-caggAATwIg0gAeBTJQIQL72GJX8fRX07elh9pX4B4QQQASCL6c9xoAD8JSOBViICIlB6MLntCkWA
-AN9KJAB06XGoIAAE8CINIAHgUyUCEC+9hiV/H0V9O3pYfaV/AeEW8AIQACFjCBEHBBAAIIzoz3Cg
-APwlA4BAIgEhMHkwuOsJBYDwIk4jCBIPIM9woAD0JgLZI6AMEAEgz3CAAMSZIaDCD+/+CnA5CFEA
-z3CAAAAAAIAPCJ4Bz3GfALj/ANgdoQHYnPDPcIAAAAAAgBEIngEA2c9wnwC4/z2gENiQ8EcMECDP
-cKAAxCzHoM9xgACgkeigKIlAKwIjELmfuUV5QSkCIUV5JqAVzB8I3gIQ2au4FBpcMBUaHDDPcYAA
-wH0CgQHgAqGGCk/+FRIBNxEJHgMI2Ky5FRpcMAPwANirDBAgz3OAAIyc4BMCABQQDSBEKj4HACNB
-DqChGBANIQHiorHPdYAAoJEIFYQQ4BuAAM91gAC0mQgZAgEJGcIEChlEBMOhpJXkoUAsAwRAKwIj
-ZXpBKQMhqrFles92oADAL0cemJCU5cAlhh8AAJMAz3KgAGgs8CJCA0uxjxYDlgjwoxYClo8WA5YL
-Ch8B9QvegQTw57vKIyEAQMMBFIIwxrvGulipeanPcYAAAAAggREJngHPcp8AuP8A2T2iDQRv+qLA
-4HjxwL4LT/oacM9wgABMngSIGujPcIAAjJxyEA4GcxANBs9xgADgDeMQEQfPcIAAWAXggAKBNL8B
-4AKhNPBCDG/6iiAPA89xoADEJxERAIYA3+0InoFkEQKGZBnYgwLYExkYgC8ogQBOIIEHE+rPcIAA
-cJ02eMCAoYDPcIAA8J30IFEAz3CAABCe8CBPAArwz3GAAOANAYHpdel2OncB4AGhBBABIA1wIKAI
-EAEhDXAgsM9xgADQmQCBBuhCgQ1wQKAA2AChz3CAAGwQCIDruMogggPKIUIDyiLCA7gKIvzKI0IE
-UyHAIM9xgABYBSCBFL8MuOV4FQmeAIK4DXEAoQ1wwKANcKCgHvANcQChSiQAdKggwAJEJoEQD7lT
-JgAQJXgNcQChIr5KJAB0qCAAA0QlgRAPuVMlABAleA1xAKEivd0CT/rPcoAAcJ3PcaAABCVPoVYi
-AAQRoVYiAAUQoeB+SiQAdADZqCCAAgDaz3CAAPCdNHhAsAHh5vHgePHAPgpP+s91gAAAACCFOQme
-ASGFUSGAgUDZzyHiB8ohgQ8AANAAzyHhB89ynwC4/z2iJIUB4dO5JKUFIYEP0P4AADaiz3aAALSZ
-RJaU4sAihg8AAJMAz3GgAGgs8CGSALkIEAAvjs9wgAAwd89yoAAsIM93gABsEDZ4Iog8EhAADo44
-FxERgOCSACkAyiCpAIwgAaSGACUABNgA2AWiUNhFIUECGNq+DaAAINv4uAjYNfQD2M9xoAD0BwWh
-hNoNcECwQiAAKA1yALJAhg1wQKBClg1wQLBAhw1wQKBClw1wQLAGlkAqAiXDuAy4grgFeg1wQKAA
-2AShDo4B4A6uDgmgACpwAIURCJ4Bz3GfALj/ANgdoQHYHfAA2M9xoADELADaR6FIoeaWDL+fvwUn
-gxRmoc9zgABEfTmDAeE5oyCFTq4PCZ4Bz3GfALj/XaFNAU/64HjxwOHFAN0M8EQtPhcncBzZxdoe
-2/YKb/oYuwHlz3CAAIyc4BABAOUNRJBFAU/64HjhxeHGz3GAAKieRYEl6M9zoADIH0ATDgZAKIEC
-z3WAABSRQBUAEdB+2GDclT5mz3GAAGwQaRGNAKJ+CCYNEAJ9CSJCAwLYFRsYgF+jIoHPcIAAxJki
-oMHG4H/BxQDZz3CAAMSZIKAhoOB/IqAA2s9wgADEmUGgz3CAABSRPJDPcIAAwBAViAJ5gOHKIYwA
-z3KgAMgfH4IweRB4CCEBADB5AtgVGhiAP6LgfuB48cDhxQh1iiAUDYYOL/qpcc9xpwCISQDYFw1R
-EM9wgABsEAiAUSAAgAfYyiChAQ6hYQBP+vHA4cXPdaAA9AdZCB5DJ4UZhTB5OGADuJYgQgXPcaAA
-yB8eoRDYDqEB2BUZGICqC2/6gdgtCB5Dz3CAAGAFAdkjoAPIpBABAJq5pBhAAE4Pb/0B2M9xgABc
-DgSBAeAEoRmFBOgD2AqlGYUE6APYCqXtBw/68cByDy/6mHBBgXCJgwoeAc92gABgUgeGCBGFALKJ
-bBKPMATopYYl8EknwBDUa893gAAodcZnEw6eFc92gAAwd3Z+wY4C8ADex3CAADB3dngEiAglDRAI
-JY0TACVAEUkgzQMWa7V4z3WAADB4BWXPcIAASHZ2eM9zgABsEH2DAYBleAQggA8AAAAIBn0C8KOB
-6L2YGUADANsJ8qQRAAAA25e7kbiUuKQZAABLDB4AG8jPdoAAfHPAuvAmDhDPcIAAhLiELgscMCBA
-DgQggA8AQAAAPrge4Bh6RX2YGUADHQ2eF6QRAACFIwEEjLiRuKQZAACcGcAAHvDPcoAAbBASgiMN
-3hekEQ0AhSMBBJa7mLuNvZG9pBlAA5wZwACeuBKiCPCUu5a7nBnAAJ64n7gSoqkGD/rhxeHGmBAO
-ABsSAjYEJoEfAAAACDt5BCaNHwAAABAlfc9xgAB8c/AhggCEKgsMACGBf4AACLlAIQIGmBCDABUO
-XhJEIwEMRLkuYom+yXEZ8M9ygAAYBUCCGQ4eEhzhwrt+YciOeWEwiaV+0H5FeQnww7t8e35heWEw
-iciORXmIGIADpXmMGEAAwcbgf8HF4HihwfHAng0P+gh1R8DovShw3AAhAEh2A7hAIJEFJ8HPcIAA
-AGAEJZIfBgAAAEEqQiQrYAQlgB/AAAAANripd3piz3OAAORjxr8IY0pjGmJBLYASUiAAAMC4A7gY
-4IXiyiCNDwEAiQ3VII4ALyAIIAQlgh8AAAAYz3CAAGxh13IAAAAIHgAiAPAgwAOg4RIAAQDPcUJ7
-0F4FKH4ACiDADipxBSk+AAogwA4kuAHgCwoQIFMgAQA4YAIogSPPcoAAqBBVkiUNXhPPc4AAaGFg
-kwUrPgAAIYB/AAD/Py64OGCRACAAWGAVeYkAIABYYVElQJJOACEAJ8W35SAACwAzaFMlAhDPcIAA
-dGDwIIAABSk+AAogwA4B4AfwiuXAKOEAwCiiAM9xgADAEC6JwNqkeYYh/w4iuTp62no1ACAAWGAz
-aFMlwBAceM9ygACIYPAiAAAW4QUpPgAKIMAOz3KAAKgQNZIB4BV5CJLaeDhgEHgI3I8ED/oEKIAP
-AAAvukIpwnRQekQq/gICIEAOEHgD6AHiUHoLCDMBQLGD6ADYAvCA2OB+4HihwfHA9gsP+qLBSsE6
-cEh1GnMKIgAhYwleAgLZz3CgAMgcKaAqwVNt7uFQeAT0i3Ho/xnwDwnRDRt4EHiLceX/EPALCREF
-HHgJ8A0JkQIAHIQwB/DPcAAA//8AHAQw4HgA2M9yqQCk/7miABQBMYK4N6Iaok7wZQkeAkwiAKDR
-IeKhSPTPcKUArP/Pc4AAqBC4oFWTaJNbYwIgwiAD4iK6W2J6YkgiQgAFukUiQgNWoEEpwiHAuirD
-B7oEIYEPAAAAICW5ZXpFeYm5jrk5oM9woACoIAiAHvAqwIDgyiHBD8oiwQfKIGEByiOBDwAA6w7K
-JCEA1AAh+colwQAFvaV4z3GlAKz/FqHPcKAAqCAIgM9woAD8RAWAAN1KI0AgBCC+jwAoAADPcKAA
-LCADgMIjwiQH8M9wAABMD4oLD/rPcKAA/EQdgAQghA+AAAAABCCDDyAAAAAEII4PEAAAAAsLECAL
-CF9GANoC8AHaz3egANAbMYcEIL6PADgAAAQhgQ8AAACAzCIhgMAlYRAFIwIBJXoFIr6DBPSdDZSS
-BemA48wmIZBe8s91oAC0R2sVAZYTCd4Az3GAAER9DIEB4AyhSfBTIb6ACfLPcYAARH0LgQHgC6E/
-8H8J3wEJ689xgADgDQmBAeAJoTXwIe4TCJ4Gz3GAAFwOBoEB4AahK/AVCF4Gz3GAAFwOCIEB4Aih
-I/BxFQSWbxUFlgohwA/rcs9zAAByD6UH7/gF2FEhgIHPcYAA4A0F8hyBAeAcoQvwANieuFMdGJAA
-2FcdGJAKgQHgCqHd2ADdmL0mCC/6qXEe8BGH8LjKICEAkA0h+s8goQPPcKAA/EQ5gAaACyBAgA3y
-Pglv/QHYA9nPcKAA9AcqoAXdmL0C8ADdke0ZCd4hHwoRIAHZz3CgAPQHLKAD2QbwA9nPcKAA9Acl
-oM9wgAAUBgCACOjPcoAAUDIFggJwBaLPcYAARH0KgQHgCqHPcIAAdKUhgM9wgABsEBSQHQkBAM9w
-gACcKjqAG4AkeFEgAILwCOL/yiBiAKlwCNxHAS/6osDgePHA9ggv+gDZz3CgAPxEnrkhoM9woADQ
-GxGAAN0XCN4Dighv/QHYz3GAAOANH4EB4B+hCsgEIL6PAAABEAMSDjYe8qQWABA5CJ4Ez3GAAGAF
-AYEW6KGhBvBWCS/6iiCGCfkJnsXPcKAAxCyrgOTY/g7v+alxUyWBFD8NnxcDEgE2oBEAAPC4AN2h
-8oogCAAUGhww+tjWDu/5oBEBAAMSAjakEgMAIQseBrYSAQHPcKAAmAM+oJrwZOmYFgAQjgrv/wDa
-3vEAFgFBPLIAFgBBHbIAFgBAD6IAFgBBQBoEAAAWAEARogAWAEFIGgQARCEAAzUIEAEY3nIahAMA
-Fg5A06IAFg5BUBqEAwAWDkFUGoQDEQgRAihwhiDzD4wgDIAM8hjeFPAQ3nIahAPPcIAABJinsAzw
-Ht5yGoQDABYAQBaiABYAQVwaBAAocIYg/QyMIAKCC/QC5tB+chqEAwAWAEFgGgQAA/BgGkQDCw5e
-EAAWAEFodIQkDJAA2AnyABYAQBqiABYAQBuiCNh0Eg0BvhIPAaJ/AieNEwJ9uBKAAJi7pBrAAAJ9
-2GAQeHIaBAC6EgABsH1wGkQDJXgcss9woACYAx6AthoEABDwiiAQAAoaGDD72JYN7/mgEQEAA8ig
-EIAAxOB4D8H7A9nPcKAAFAQjoG0Hz/ngePHA7g7P+aLBGxIBNs93oAC8Lc9wgABsEC6nahAQAc9w
-gAB8c/AgQgDPcIAACLmEKgsMACBRDhUSDTdAIRImRiXAEQMSAjYVGhwwpBIAAIS4pBoAAAGSQCET
-IgDehhqEAwfoz3CAAIiH9CBAAAboAYIJCJ8DoL2wfVMlfpBOAwEAz3CAAMB9B4DPc4AAwH0B4Aej
-BxIDNqQbgAMBkpUIEADPcIAAiIY0eIAQAQeFCREA0BABAVMhwYAU9HISAQHgkiJ/uBKBACJ/8H/g
-GMQDpBIBAIYh848G8mi/8H/gGMQDcBIPAeAQAAEhkuJ48XDCJw4QwiHOA3QSAAEZYbgSgAB0G4QD
-wLM4YBB4kBsEAL4bBAAQihCrAYIBowiKCKsSigDaEquWujPwjg7v+YogBAcPh/kI3oVPh1MiwAJP
-Cp4FFQiVA89xgABcDgOBtroB4AOhHfBkuAcSATYQeJAZBAAEIoAPAAAA8Cy4dBmEA8CxEKnBsQPI
-vhmEA2GAyKmGI/8NhLthoRKIEqn2uj4CAQAA2Ja4BxIBNqQZAAAjCl4F7g2v/wDYBxIBNqQRAAAE
-IIIPAgAAAC26pXpQfUTwAYGxCB4Bz3eAAGBSB4dyiVCJbBKEMAPoBYcj8BRqz3eAACh1AGdJJMQA
-EQieBc9wgAAwd1Z4AYgD8ADYACSPD4AAMHdWf+SPCCPDAwgjAwBJI8MDFmp1eM9zgAAweABjz3OA
-AEh2VntBg89zgABsEH2DZXoEIoIPAAAACEZ4mBkAAADYlrhBgYYi/w1DCB4FoQoQAJgRggBAIQAp
-SGDPc4AATJhAwCDCw7pcevQjggBS8AohwA/rcgXYz3MAAD0LiiSDDz0C7/hKJQAAmBEDAJwZgANJ
-C14CgLikGQAAKOqYEYAAz3KAAGwQYhKCAIYg/wNEuDIiACCJuEDAIMNkeoYj/wOGIv8ORLt6Yk96
-z3OAAAhh9COCAB7wEwseAgjqmBGCAEAhAClIYAvwheoA2khwEPCYEYAAw7gceDIjACBAwCDCz3OA
-AByYw7pcevQjggCIGQAAmBEAAIQZhACQEQEBMg6v/wDaBxICNgMSAzaEEgEBghoEAM92oADIHzhg
-EHiwGgQA+BYBELATDwEif89xgABsEGQRAQECdz9nH2egFg4Q8H9BDsQTz3aAAGwQ0oaYEw8ACybA
-kxb0UIrQi1B20ScikhfymBOPAM9ygAAAYOpiIwqSAM9ygAAodQS+wmITCl4Ez3GAAFwOEYEB4BGh
-DfA4YBB4hhsEAM9xgADAfQiBFRpcMwHgCKF9A+/5osDxwC4Lz/nPdqAAyB+gFgQQ+BYDEEsIEQED
-EgI2pBIAAHYSAQEPCB4Fz3CAAKSZoYAD8IISDQEVzFEgAIGEEgABCPICJcIQAiSDAAgjAwAF8IYS
-AwEbY893gABsEGvwkwhRABUSAjcDyHgQAQFDCh4BUSJAgM93gABsEGQXAhEJ8n4QDQFCfWJ9AiRD
-AyrwgBADAc91gACwdwAjhABwiHZ9YJUAIw0BhBADAbtjGvCkEAIAFQoeBXCIz3KAALB3dnpgkgTw
-ghADAYAQDQHPd4AAbBBkFwIRXWW7Y4QQDQG7Y4AQDQG6Yn4QDQEifSTwz3eAAGwQOQiRAAMSDTYV
-zHgVARFkFwIRFQgeAYAVABFCeGJ4AiQDAAjwghUDEYQVABFbYxtjgBUNESJ9BvAA22hxaHVochXM
-aReEEBUIXgADyHYQAQECIQEBWWEJ8A8LcgACIQEBahcAERlh+BYAED1lAn0fhhkNBBCg2A+mANgf
-pj+mAtgVHhiQgNgOphkC7/lweOB4G8jHcIAApIY0iAHhL3k0qB0JMgEDEgI2z3ADAIQAoBoAAIog
-CAAKGhgwC/CKIBAAChoYMM9wAgGEAKAaAACKIAQA3Qev+QDZz3GAAER9DYEB4A2hG8jHcIAApIYs
-iAHhL3ksqM9wgABEvgKIEwhDAIogCAAKGhgwitiQuAzwA9nPcKAAFAQjoIogEAAKGhgwQtiYuOB+
-4HjxwBIJ7/kA2c9woAD8RL2ABCW+nwAGAAAG9APIpBAAAKkIngYD3892oADUB/KmEw2eFs7/iiAE
-AE4Pr/kA2RkNXhbc/wMSAjYIcaAaAAA6D6/5/NgDEgE2Iw3eFG8gQwCgGQAAiiAIAAoaGDCKIEQC
-Fg+v+QDZAxIBNiUNnhQA2Je4oBkAAIogCAAKGhgwiiCEAvYOr/kA2QMSATakEQAAFQieBgXYELig
-GQAAiiAIAAoaGDDPcJ8AuP9YGAAIEx7Yk6ARAAAD8ChwsQDP+eB48cBGCM/5Wgiv/wh2yf/PcaAA
-yB8IdUDYD6FAEQEGMHmOC6/9yXCNAO/5qXDxwAPIpBAAAFEgAIDPcIAAbBAE8h2QA/AckO//tujP
-cKAAFAQD2SOgINgUGhwwz3GAAER9EYEB4BGhA8gA2pgQAQCAEAMBlBhAAJ4QAQGAGIQAkhhEAL4Q
-AQGQGEQApBABAKy5rbmkGEAAfhABAX4YhAA7Y7AQAQFieTB5sBhEAIIQAQGyGEQA0cDgfs9wgADY
-ngaAA9qB4AHYwHgMuIUgAwHPcaAA9AdFoQ1yALIDyADbXZANcECwA8hRgA1wQKADyEgQAgENcECw
-ZKHgfuB48cBGD6/5CHMQiTMRjQAB2kCrGxIPNs92gACwhu5mz3KAAOCGSNzBqxsSDzYCIg4D9CbO
-E8GzGxIONvAiggNBo0GBIwoeAdKJz3KAADB3Fnrcq0CKhiJ/DFx6BLpFftyrA/CA2lyrBLgFfb2r
-HJHPcoAAKIcPsxvI8CIAAASzC8gFo1QRAAEMswCRDbOgEYIASKMKyAQggA8CAEEADQiBDwIAAACI
-ukijCsgEIL6PAABBEATyibpIo5wRAAHPc4AAYAUmuMC4QCgCAw+BwLgNuEV43Qav+Qej8cBuDo/5
-CHUG8M9wAABjDRYPj/nPdqAAwC+jFgCW7wgegQvIQB4YkBvIDwiRAZ4Ir/2pcILwz3eAAOCXCo8J
-6EAngBJAJYESogvv+QraA8gHiBsI3gAA2AYK7/mQuADZkrnPcKAA0BsxoM9wgADAEAGIgeCQCWEJ
-yiAhDAPIA5AluMC4F7jHcAAOAABFIAEL7HAgoAISATbscCCgIIXscCCgIYXscCCgIoXscCCgI4Xs
-cCCgJIXscCCgJYXscCCgJoXscCCgJ4XscCCgKIXscCCgB/DPcAAARQ1ODo/5oxYAlvUIHoELyAQg
-gA8BAADwLLiU4MAghg8AAJMAz3GgAGgs8CENAM9wgABgBceA2djSC6/5BSZBE3YI7/kFJkATKo+A
-4coggg8AALUEtAui+c8h4gEA2AqvnQWP+fHAMg2v+ZhwG8jPcYAAKIfwIQIAz3OAAIiGAxINNggc
-hAAbEg42QZWA4tR7yiIhAAzygBMAB50IEAAA2oAbnADwG4QA4BuEAECzAYUfCJ8DSLPQG4QAEI0E
-uMdwgAAodeWQCw9SEGG/5bAAJoAfgACkhkSoTKjPcIAACInWeAKQwBuEANV5QKF4GwQAAYUEIIAP
-AAAAYCMIgQ8AAAAgz3CAAHxz8CCAA89xgACgBBR5AJEQ4ACxA9nPcKAAFAQwoIhwgf/Z2OIKr/kC
-EgE2PPBwFQAR4BMBAQIhDgAPCIQDwngCelB6gBucAM9yoADUBw8SDoYA2PAbhANwFQ0RwBsEAKJ5
-MHngG0QA0BMBAQHhMHnwEwUB0BtEAFMlfoDKIcIPyiLCB8ojgg8AAOcMyiSCDwAA/gC8AaL4yiBi
-AQPYExoYgFUEj/mhwfHA2guP+aHBKHUacFpyBCG+jwEAAMA6cyz0QMUfDR4SIMHPcIAAAGApYAQl
-gB8GAAAAMbg4YALwAdgEJYEfAgAAAddxAgAAAcogoQAfCFAAFQiQAIPgANjKIOEBwCihAwfwA9gO
-uAPwANiOuAV9CnC6De/8qXEKcKlxSnIqcwHdYg9v/5h1uugK2M9xoADIHx6hENgOoRUZWIMF8AYM
-r/mKIAoDHQgfQ89woAD8RB2ABCC+jzAAAAAE9OMLHsBRIwDAyiHCD8oiwgfKIGIByiOCDwAAkgLK
-JCIAzACi+MolIgBRIADDANgK9M9xgADgDQmBAeAJoQDYmLgI3D8Dr/mhwKHB8cDhxVEgAIIIdagA
-IQBCwCLDz3CAAABgBCWCHwYAAAAxumtgBCWAH8AAAAA2uHpiz3OAAORjCGNKY0EtgxJSIwMAwLsD
-uxpiGOOF4sojjQ8BAIkN1SOOAHBxUgAlAADY7b0YACEAAiHAAM9xHEfHcQUofgAKIMAOA/AiuEEt
-QRPAuQS5NHmpcsa6SSLCBVR5z3KAAKBiMmIPDd4SQSoBARQhggAFKj4AQSkAcgjcrwKP+QohwA/r
-cgXYz3MAAAURSiQAAOEHb/gKJQAB4HjhxQMSAjYgkkGCQOH0usAhogAD4c9zoADUBw8TDYYEIYEP
-AAD8/xUNJRAaYRvIFSIBMBwRAAYdZQIiQQMZEwCG/QhEgA8bmIDgf8HF8cDhxQPIpBABAJgQAgBR
-IQCAchABAUhwBvIGDG//ANoIdQfwAeH6C2//ANqsaFIIwALPcqAAyB/4EgEAA8jPc4AAKHUQiAS4
-AGMRCF8DAdgToniCWYIG8ALYE6J6gluCAiVAEHhgEHPAIm0ADXEAoQ1wQKAAFgBAABYAQAPIz3Kg
-APQHcBABAWi5J6JwEAEBaLkwea0Br/lwGEQA8cAeCY/5pBEAAKLBUSAAgM9wgABsECh2A/IbkALw
-GpCYFgEQBCG+jwEAAMB2HgQQLfRBwR0JHgIhws9wgAAAYEpgBCGADwYAAAAxuFhgA/AB2AQhgg8C
-AAAB13ICAAAByiChAB0IUAATCJAAg+AA2Mog4QHAKKEDBvAD2A64BPAA2I64BXmYHkAQnhYAEZQe
-QBCSHgQQEI7PdaAA1AdAwIIWABGyHgQQANiAHgQQfh4EEAPIQZCQFhARCeobyM9xgACIh/QhAAAS
-6BkVAJYhCBUOFczPcYAARH2GIIgCFRocMBWBAeCnAyAAFaEPFRGWCOobyM9xgACIh/QhAAAF6Eoj
-QCAG8APYEx0YkEojACACEhI2AdnPcIAAMAUgoADYkbjPcaAA0BsRoc9wgADQAhB4z3KgALRHSRoY
-gM9wgAA0BcCgbyBDAFQaGIARgQsSDzbxuMogIQDEC6H5zyDhAx8LUSAHyAGQIOjPcYAAXA4OgQHg
-DqEQgQHgEKEW8APIAZAU6BvIz3GAAFiH9CEAAFMgwIAK9M9xgABcDg6BAeAOoQ+BAeAPoQMSATYB
-gR0IngNUEQABUyDAgAj0z3GAAFwODYEB4A2hAhYFESUNEAABhu64yiHCD8oiwgfKIGIByiOCDwAA
-WQcEBWL4yiRiAACWsHDKIcwPyiLMB8ogbAHKI4wPAABbB+QEbPjKJGwAMI5TIcAAEK6GIf4DpBYA
-EES5wB5CEEkInwULEgE2AiHCAwDYDwpQAAInQhCMIsOPAvQB2JToFczPcYAARH2GIIgCFRocMBSB
-AeAUoQ8dWJQLGtgzJwIgAAIamDQLGtgzAhqYNADYdB4EEBYPb/vJcM9xgABAY3QWAhEJYVlhz3KA
-AEhj8CIAADB5pBYCEHQeRBAFIIYApB6AEQfIAZAU6B8LUSABlrgWghA4YGCWWGAQeL4eBBA7YwAj
-hQAN8L4WABEK8ECWuBaAEDpiWGAQeL4eBBC4cJAeBBAMIEChyiHCD8oiwgfKIGIByiOCDwAAkwfs
-A2L4yiQCBADCEBaEEBkKAAEKIcAP63IF2IojHgXNA2/4ABQFMA8VApa0HoQQDw4eBrYWABEPHRiQ
-f/AAFgNBfLYAFgJBXbYAFgJAT6YAFgJBQB6EEAAWAkBRpgAWAkFIHoQQRCMCAzcKEAEY33IexBMA
-Fg9A86YAFg9BUB7EEwAWD0FUHsQTEwoRAmhyhiLzD4wiDIAN8hjfFfAQ2nIehBAA389ygAAEmOey
-EN8L8B7fch7EEwAWAkBWpgAWAkFcHoQQaHKGIv0MjCICggj0Aufwf3IexBMAFgJBA/AA2mAehBAL
-D14QABYCQch0hCQMkADaCfIAFgJAWqYAFgJAW6YI2iJ44ngCIIEAuBaAEAJ5H2e6FgARMHnwf3Ae
-RBBleBy2TyYABnIexBOkHgAQDxUAlrYeBBCkFgAQCHSEJBqQIfI9CF4CA8gBkBroG8jPcYAAiIYU
-eYARAAeS6NARAAFqFo8QAeDDuPhgD3hqHgIQjghv+8lwah7CEwXwgghv+8lwDx1YlHMBj//gePHA
-dgxP+RsSATbPcIAAfHPPc4AAAADwIEIAz3CAAGS4QCAQCIQqCwwAIFMOtRMCJs9wgAAIiUCgAIOr
-wTcIXgABg1EgQIBA2M8g4gfKIIEPAADQAM8g4QfPcp8AuP8dogSDAeDTuASjBSCAD9D+AAAWohTM
-USAAgEwGAQDPcKAA0BsRgPG4yiAhAAQIofnPIOEDz3CgANQHDxAAhgMSDjbPd4AAbBC0HgQQEI5T
-IMEAhiD+A0S4wB4CEDCuChISNgDYpB4AEBKnC8gEIIAPAMAAALCOMQiBDwDAAAAbyM9xgACIhhR5
-EYmO6M9wgACwd7Z4IogIjhEIQwBKcDIML//JcdvwUSIAoILyBBYEEIUMHgEbyM9ygACIhs9zgABg
-UhR6ERKFAEeDMo4PeAPqJYMj8FRtz3OAACh1QmNJIMAAEQqeBc9ygAAwd7Z6QYoD8ADax3CAADB3
-tngEiAghAQAIIYEAoHFJIcEDFm01eM9xgAAweAFhz3CAAEh2tnhBgB2HRXgEIIAPAAAACAZ5A/Aj
-hhvIz3KAAHxz8CIAAJgeQBCEKAsMMCBALgQggA8AQAAAQSiCB1MkAAAe4lh4BXmYHkAQFQmeBwDY
-jLikHgAQUNicHgAQcfAfCd4HANiNuKQeABDPcEABUACcHgAQANieuBKnYfAA2KQeABAF2BS4nB4A
-EMDYGLgSp1fwkQpeJwGGdwgeAc9zgABgUgeDMo5sEoIwA+glgyLwSSLCABRtz3OAACh1AGMRCJ4F
-z3CAADB3tngBiAPwANjHcoAAMHe2ekSKCCGBAAghAABJIMEDFm01eM9xgAAweAFhz3CAAEh2tnhB
-gB2HRXgEIIAPAAAACAZ5AvAjhpgeQBAbyM9ygADAhhV6IKIA2ATwBdgUuJweABBRIgClANjPIGIE
-yiAhAKQeABAA2HQeBBBCCm/7yXDPcYAAQGMKYXQWARFZYTB5dB5EEM9xgABIY/AhAQCkFgAQJXiY
-FgEQpB4AEBkJXgI7l4C4dh5EEHgeRBCkHgAQEfAoh1qXdh6EEBMJ3gA7l4O4eB5EEKQeABAD8Hge
-hBBCCy//yXCkFgIQRCJ+gowWgRAV8mIXgBAkeIYh/wNEuYYg/w44YM9xgAAYYfQhEQDPcYAACGH0
-IRAADfDDuc9wgAAsmDx59CBRAM9wgAAcmPQgUADgusogAgQY9JgWABBRIACCiBaAEMO40SIihQjy
-HHjPcYAATJj0IQAACPAceM9xgAAcmPQhAAAhhlEhwIDKICEAmBYFEIQeBBCpDR4CmBaBEM9wgAAA
-YClgBCWADwYAAAAxuBlhFG0AIIQPgAAodQAUAAAEIL6PACgAADvyBNi4HgIQANiPuJe6pB6AELoe
-BBAAFAAABCC+jwAwAAAl8s9wgABgUmGAeaZmgCJ7FrsFI0MBrruvu7C7mB7AEAWABCCADwEAAMAF
-e5gewBAAFAAABCCADwAgAAAouAUgxQCYHkARB/DPcAxAqP4ZpgPwAdkDyAGQKOgbyM9zgACIh/Qj
-AACC6AGWuBaEEHQWBhEEJb6PAQAAwAAkgwF4YBB4ngLhAL4eBBAtCVAAguHMIeKADPIKIcAP63IF
-2OEAYACKI5gNAJbi8c9wgAAwd7Z4A4gH8M9wgAAwd7Z4AoiMFgEQDrgleIweABCEFwAQiOjPcIAA
-XAkAiLsIEAAbEgE2swmQAQCWrwhSD89wgACIhjR4EYiA4NEiIYBN9JcKHiCeFgARUCWBA6+5sLmK
-uJ4eBBCYHkAQhBcAEC8oAQBOIIMHI7sO4wDYDyDAAAUhAwCYHsAQKHOGI/sPhiD7DwUjPoDPcoAA
-YAUIGkABFvIA2JgeAhCOuSKiE+sois9wgAAAYChgGwiSAAsIkQAG2AiqB/AH2AiqBfAN2JgeAhCk
-FgAQtLikHgAQnhYAEae4nh4EEJgWABC+FgERRgkv/wDapBYCEAQivo8AAAAwgh4EEFDyjBYEEJwW
-ARGUHgARkh5EEIAeBBQDEgM2IQoeAxTZkB5EEH4eRBR4Ew0BAiFBIzB5sh5EEBHwDtmQHkQQANl+
-HkQQeBMNAUohACACIEEjMHmyHkQQz3GAAAiJIIGGIX+PDPSYFg0QEQ1fEmGThuuRupK6pB6AEBC5
-JXqkHoAQMocEJIMPAAAAEFIjAwNleQQhgw8AAAAQfXtleTKnGfCYFgEQsh4EEJQeQBCeFgERSiAA
-IJIeRBC+FgERCiEAJJAeRBAA2YAeRBB+HkQQACEBJBlhhBYAEThgEHiwHgQQz3GfALj/VqGcFgAQ
-FqEDEgE2khEAASYIr/yUEQEAG/AD2M9yoADUByAaGIAB2BQaGIAAFgBACxoYMAAWAEACGhgwA8i0
-EAABDxoYgCIML/nL2BsSATbPcIAAiIYUIEIAqJIDEgM2nu2YEw0ANXiuoLagz3CAAHxz8CBBAM9w
-gACgBPQgQAC8GwQA0BIBAQQggA8AAPD/w7kleNAaBAAG8NASAAG8GwQAAdigGwAAxg9gCbCLgOBe
-AiEAAxIDNgrIUSCAgU4CAgAhgxMJngaQ2JC4QwIgAKAbAADPcIAAKHVAIAIDBL2tYsATggARCkAD
-kdiQuB8CIACgGwAAyoPPdaAAyB+kFQIQjCb/nwzywnoVCoUPAIAAAIfYkLj3ASAAoBsAANCL9G7i
-YAQivo8AAAAT+GAn8hEKXgKL2JC4oBsAAOnwDwofAwWQieiI2JC4A/CF2JC4oBsAAM9wgABsEBiI
-hODX9M9xgACAUAyBDyCAAwyhz3GAANwIAIEB4AChyfBCkDMTgABLCg4AC8gEIIAPAMAAADEIgQ8A
-wAAACIspCFMApBMAALS4pBsAAJITAAGnuJIbBACeEwABp7ieGwQACfAPCZ4BjdiQuKAbAACh8ArI
-BCC+jwAAARB08p4MQAIDEgM2CHKwEw4BqBsAABWFVSZBFtW4z3WAAKieCwhFAAXZJ6UlhQJ55OHK
-ICUACSCAAKwbAACkEwAAsQieBJgTjQDDvQvIvH0EIIYPAQAA8BsSATbPcIAACIk2eKwTDwAFkAkn
-BBDPcIAAfHPwIEUAfhMAAYATDwEfZ89wgACoEBeQ+GAIJA8AAn8Db893gAAAY/AnTxMiuAUvPhBT
-IQ9wACdAHi8kAgBALUABtXjHcIAA1JDgkM91oADELO+lAZBBLgYDFLkOpUAuAAaeuCV4BSAAAQql
-z3GAAGAFAdgBoQbwoBUCELATDgENCoUDBdgYuKAbAADPcIAARAlBgCCTCSGBAACIEwhRAM9woAAU
-BAmAEHEA2AL3AdiL6APYGLigGwAAz3GAAER9DoEB4A6hoBMAAAQgvo8BAQAAGvSSEwABlBMBAJAT
-AgGyEwMBwg7v/kokQAADEgI2oBIBACV4oBoAAM7YJgkv+QISATYDEg02oBUAEAQgvo8BAQAABfKm
-CQ//bQIAAQXMz3OfALj/GKPPcoAAYAUbEgE2AII3CQAAz3CgADguBYAEIIAPwAAAABsIgA/AAAAA
-9dgFuBqjO6Np2Bi4GaMB2ALwANgHCFEAIKIKyAQgvo8AAAEQyiYhEHnypBUAEHMIngQBgoDgAN84
-8gDYAaJ+FQARgBUPER9nz3CAAKgQF5AfZwbwwgov+Yoghgn5CZ7Fz3CgAMQsy4Dk2GoIL/nJcVMm
-gRT+vswhIoAO8pgVABAyDO/+ANrPcYAAqBAokSJ4H2cD8ADfAxIBNgDeCPDPcIAACIk2eOWQAN6p
-cc9yoADIH6wVAxCI76QVABCxuKQdABAE8AkjwwMD2Bi4D6L4EgAAoWgII0MDAnugGsAAANiYuA6i
-C++kEQAA8bgVzMUgogTPIGEAFRocMAGRCOgbyM9ygACIh/QiAAAF6AGBDwieAxXMgLgVGhwwzNi2
-D+/4ChIBNgMSAjakEgEAEwkeBrYSAQHPcKAAmAM+oIXwABYDQXyyABYAQR2yABYAQA+iABYAQUAa
-BAAAFgBAEaIAFgBBSBoEAEQjAAM3CBABGN1yGkQDABYNQLOiABYNQVAaRAMAFg1BVBpEAxMIEQJo
-cIYg8w+MIAyAC/IY3RPwEN1yGkQDz3CAAASYx7AL8B7dchpEAwAWAEAWogAWAEFcGgQAaHCGIP0M
-jCACggr0AuWwfXIaRAMAFgBBYBoEAATwYBqEAwkNXhAAFgBBKHSEJAyQSiQAAAryABYAQEokAAIa
-ogAWAEAbonQSAAG+Eg8BAn+if7gSgAACJw8RmLmkGkAAAn+4YBB4choEALoSAAHwf3AaxANleByy
-z3CgAJgDHoC2GgQAvJJEJQATlwgQARvIz3OAAIiGFHvAEwABz3GAAASYBX0BgryyFwheA1QSAAG8
-Eg8Bw7jleFQaBAABkiPo0BMPAVQSAAHDv+V4VBoEAIATAweE64q9vLKkEgMAFQseAmgSDwFTIM0A
-/WWwfWgaRAMTC14CahKDAMO4eGAPeGoaAgALyAQggA8AwAAADQiBDwDAAADHsQXwANiLuAexHJKG
-IP0MjCACgg70EIrPcYAAMnUEuBBhEQhRAGASAAGEuGAaBAAK2M9xoADIHx6hENgOoQHYFRkYgAXw
-+g/v+IogCgMdCB9Dz3CgAPxEHYAEIL6PMAAAAAT04wsewB0LHkAKIcAP63IF2IojigRKJAAAyQTv
-9wolAAFRIADDANgK9M9xgADgDQmBAeAJoQDYmLgM6APZz3CgABQEI6CKIBAAsQbgAAoaGDADyKQQ
-AAAEIL6PAAAAMLvyEwgfBcIPz/7W2C4N7/gKEgE2A8ikEAEAiQkeAxoN7/jN2HYLL/8B2AMSATYD
-2x2xz3CAANieBoDPcaAA9AeB4AHYwHgMuGWhhSACDQ1zALMDyH2QDXBgsAPIb4AA2hULHgAIEwMg
-DXBgoAwTAyEH8A1wYKADyEAQAwENcGCwA8hxgA1wYKADyEgQAwENcGCwRKEeDg//ChIBNv0F4ADQ
-2JYM7/jR2AMSATYBgR8IHgbPcIAA+AgAkB2xz3CAAPwIQIABgFGhEqEH8M4KL/8C2AMSATYdsWYO
-D/8DyKYNL/94EAABgOC0BcIA0thKDO/4ANkDEgM2mBMAAJQbAAABgysIHgbPdYAA4JepcHIOL/9o
-cRDYFBocMBXMo7gVGhwwcghv/6lwdQXAAJ4TAAGSGwQAvhMCAZAbhACSEwABlBMBAJoJb/+CEwMB
-CHXP2OoL7/ipcR8NHhYD2c9woAAUBCOgiiAQAAoaGDD92CkF4ACpcQMSDjakFgAQ9Lg2AoEAcI7P
-coAAsHfPcIAAAACggHZ6IJI3DZ4RoYBRJYCRQN3PJeIXyiWBHwAA0ADPJeEXz3efALj/vaekgAHl
-072koAUljR/Q/gAAtqcVzBkIXgDPcKAALCAPgIQWDREIIEADongD8ChwsBYNEWTlKw0EEM9xgABE
-fRuBAeAboc9wgAAAAACAAN0PCJ4Bz3CfALj/vaAA2Lnwz3WAACh1BLtjZQDfBCOND4ADAAA3vWW9
-SCUNEAQjgw8YAAAAM7sN4w8nzxAJIEEAAxKQAJYJb/+YFgAQmBYCEAkgwQNBKkADwLh0aHR7SHDG
-uEkgwAUUe89wgACgYnNgDwreAkErAAEUIMMAKLu4ewNrBCCADwAA/P/PcoAApJkDos9yoADELA2i
-MBoABAvIGxIDNgQggA8BAADwQSgNA0AtABaduBS7ZXgFeSqiz3KAAOANHYIB4B2iZgrv+OPYlOXK
-IUUDhPepcYAhwgHPcKAAGCzwIEAAlOXAJYYfAACTAM9woABoLPAgQAMG8J7Ydgzv+Iy4+Qmexc9w
-oADELKuA5NgeCu/4qXEEJY8f8AcAADS/UyWBFBMNnhcPD5QQAJYQ4A0IRAADEg42WPEQjs9ygAAo
-dQS4AGL7uNUhwgPPdYAApJkgpeKlmBYAELINr/4A2gGlz3GAAER9HIEDEg42AN0B4ByhGoH4YBqh
-AdiA4KgHQQDPd6AAyB+UFgYQkhYHEc9wgACkmSAcgDEhgAAQFQDPcqUArP/PcIAAbBBgGkAFTBAE
-AWYQBQEwewAlAAECewPjIrt4Y3hgSCBAAAW4RSBAAxaiUSfAgYDYyiBBAyjDZXgEJoMPAAAAICW7
-ZXiJuI64GaJAFwAWFcwfCF4AoBcAEPgXAhBCeQIgVwB2FgERLyfIJRlhBPCEFhcR4nE6HsQVH4cX
-CEUAMHjPcYAAbBASCy/+aRGBAM9woADUBwHZNKAzoAPYz3GgANQHDaEREQCGQMBA4A8ZGIAUGViD
-A8ikEAAADQgeAjoKQAEE8EcfWJPPcKAA1AcNEAKGQC8AJFB6BXoDyCGAABATAUHBuBCZAHIQAQEC
-IVQGuhABAXmAQsHPcaAA1AeIGcAApBABALe5pBhAALmguBhCA7oYRAMBwBEIngXPcKAASAhAIwEj
-B/BAIwEhz3CgAEwIAsMjcQUi0gBHac9zAAD8/2R6z3OAAKSZY4MIIsMAz3agANQHNaYAGIAEAiMA
-JQ+mAiOBADumA9kwpgvIAiXVIM9xgAC0mQQggA8BAADwLLgDEgM2BLEPg66pAKFAEwABz3aAAASH
-ArEQi0AmBRlgEwMBVGgPqcO7ZXpGsc9wgACkmUGAGxIDNs9xgACIhlB4dX5phlYhxAJ4YAmmpBcA
-EM9zAAD8/xpi+BcAEAJ6Q8LPcqAA1AsB2BCiAcDPcoAApJlCgjW4wLgCuiviF7hkesdwAA4AAEV4
-7HIAogISAjbscECgz3CAAKSZQoDscECoGxICNhQhgABQiOxwQKjscKCwG8jwJAIA7HBAoBvI8CUC
-AOxwQLDscKCw7HCgoOxwoKALEgI27HBAoAPIQJBUEAABELpFeOxyAKIDEgI2AYIhCB4BEopwis9y
-gAAwd3Z6QIqGIn8MXHoEukV4A/CA2OxyAKoDyFCIMxCAAAS6BXrscECoA8hckOxwQLADEgM2nBMA
-AVEggIEA2s8iIgPKIkEDD4PAuA24RXjPcoAAYAUHohvIqXYAIIIPgACwhqCqz3KAAAiJFnoUeaCx
-QpLAGUQDFSUAAKCgz3CAAGwQeBmEAByQ0BlEA0TAz3CAAKSZIoAbdYDhpAMuAMonThM6dRp1qXdM
-IQCgtfIBgM9xoADIH5YgQQ8eoRDYDqEB2BUZGIAS8M9woAD8RB2ABCC+jwAWAAAI8icInwYdCF8G
-HwgfByELH0DPcaAA9AcngQDY1wnehxjwiiCIABTwiiBIABLwAdnPcIAAYAUjoDYP7/socM9xgABc
-DgSBAeAEoYogCAIFJw+QEgMiAADez3GgANQHD4EQeBkRAoZY4CsKBQAPgRB4GREChljgDQoFAIQR
-AADvCNWMD4EQeBkRAoZY4I8KBAAeGRiEHREAhgcSAjYLGhgwHREAhkAvAyRJwB0RAIbPdoAAMAUA
-sh0RAIYBolYgACIeGRiAHREAhgASEwEQeQUh0gAhggDbkbuGIPMPQcHPcaAA0Btxoc9xgABIAzB5
-z3OgALRHSRtYgEAgASIgps9xgAA0BUChbyFDAFQbWICMIAyADvIa2A3wz3GAAER9HoGKJRARAeAe
-oUECIAAA3iDYmnAjcBB4choEAADeDQkRIAMSATar8AHAEwieBc9xoABICEAjACMG8EAjACHPcaAA
-TAgjcEbAAsBFwQUiEiAGwAfgz3GAAKSZI4EEIIAPAAD8/wggVgBVDaQlR8BjCF5Dz3CAAKSZAYDP
-caAAyB+WIEEPHqEQ2A6hAdgVGRiA+gnv+EHYOwheQwHZz3CAAGAFI6CqDe/7AdjPcYAAXA4EgQHg
-BKGKIAgCJPDPcYAARH0dgYolEhAB4B2hvvDPcKAA/EQdgAQgvo8ABgAADPL6uMoggg8AAAECDPT5
-uIogiAAI9APZz3CgABQEJaAA2AUnD5AA3qH0AdjPcaAA1AcUGRiAVSBAJA8ZGIABCh9CBsDPcaAA
-1AcVoQXCAN4CIwAlABqABA+hB8ICJZUlAiaAIBuhA9gQoQPI6XHIuQiIDLgFeQXMELgleOxxAKEJ
-wEAgWDACGhgwBxIBNgPIABwANAMaWDAHGhgwQYEgkQDANLrAulR5A+FA4AQhgQ8AAPz/ACEQABsS
-ATYI8BUiQDAcEAAGAiAQIBUiQDAcEAAG7QgFoAXMz3GfALj/GKHPcKAA/EQ9gAQhvo8ABgAAaPQL
-CREgFMwpCB4Az3CgANAbEYDxuMogIQCgCOH4zyDhAwDZkbnPcKAA0BsxoBkJECAHyFCIUyLBAIYi
-/gNEusAYggAwqM9woADUBxQYmIMDyEAhUSAoiAHhKKgLEgE2z3CgAEgsPaDPcIAApJkigDJxcgTN
-/wLw6XVTJX6QXfSHCF5Dz3CAAKSZAYDPcaAAyB+WIEEPHqEQ2A6hAdgVGRiAGgjv+EHYXwheQwHZ
-z3CAAGAFI6DKC+/7AdjPcYAAXA4EgQHgBKGKIAgCNvBMIQCgiicQEAj0C8jPcqAASCyKJwgQHaL6
-uc9xgADAfQbyAIGAvwHgAKHB8QGBgb8B4AGhu/HPcKAA/EQdgAQgvo8ABgAADPL6uMoggg8AAAEC
-DPT5uIogiAAI9APZz3CgABQEJaDJcAV/GO8bD14QA8gpiAHhKajPcYAAwH0BgQHgAaEJ8BMPHhDP
-cYAAwH0AgQHgAKHpdQPI6XHIuQiIDLgleAUSATcQuSV47HGpdIQkApEAoUAgWDAW8s9xoADUB4AZ
-QAUFzKlyyLoQuEV47HIAosyhAdgUGRiAPgtv/kAgWDADEgI2khIAAQcSATYNCJ8CkhEDAW0LngKq
-uJIaBACSEQABqrjaCeAEkhkEABDZz3CgANAPEBhYgCQQAYbPcoAA4JdFkjB5ArpFeQwYWIAU2RAY
-WIDPcYAA4JdnkUaRGNkQu2V6DBiYgBAYWIDPcYAA4JdpkUiRELtlegwYmIAG8M9wgADgl8qoz3Gg
-ANQL0KHpDRAQz3CAAKSZAoARCAUwCNrscECgQCBYMPbxC8gEIIAPAQAA8Cy4lODAIIYPAACTAM9y
-oABoLPAiAgDPcIAAYAUHgEV4DaED2s9xoADUB1Khz3CgAPAXRaAPD14SGggv/wDABfATGZiAFBmY
-g+e/yiCCDwAABgEU9OC/yiCCDwAAAwEO9OG/yiCCDwAABAEI9OK/iiBEAcoggQ8AAAcBXgiv+Olx
-z3KgACwgMIIDwDBwAdnKIYYDRCCDQA+C5OAB2MoghgOA4cwjIYDMICGA6/PPcAAoCAAKGhgwBMAa
-DW/8ANnFBQAAz3CAAKykEogvCB4AKwgeQ89wgACspA+Iz3GAAGilELggiZ+4gOEB2cB5D7kleM9x
-oAD8RA2hHQ0QIM9woAD0B2AYQAXPcYAARH0dgQHgHaELyAQggA8BAADwLLiU4MAghg8AAJMAz3Gg
-AGgs8CEAAM9xgABgBSeBJXjPcaAA1AsNoc9woADUB8ygiiAEAooPb/jpcc4I7/4EwM9woADUBxkQ
-AIbA4BIFDgAVzFEgQIAGBQEAA9jPcaAA1AcgGRiAz3CgANQHAdkUGFiAz3CAADAFwKAA2c9woADI
-H5G5ExhYgM9wgADQAhB4z3KgALRHSRoYgAfIz3GAADQFAKFvIEMAVBoYgM9woADIHxMQAIbPd4AA
-bBDxuMogIQB0DKH4zyDhA89woADUBw8QAIYHEg02A9m0HQQQz3CgANQHExhYgBCNUyDBAIYg/gNE
-uMAdAhAwrRAVkRCkHYATC8gEIIAPAMAAANKnNwiBDwDAAAAbyM9xgACIhhR5EYmR6M9wgACwdxYg
-QAQiiAiNEwhDAM9wEiAAAJ4Ib/6pcVDwAYV/CB4Bz3OAAGBSJ4MSjWwSgjAE6SWDJ/BJIsIAQCkB
-Ic9zgAAodSFjEwmeBc9xgAAwdxYhQQQhiQLwANnHcoAAMHcWIkIERIoIIIAACCBAAEkgwQNAKYAh
-NXjPcYAAMHgBYc9wgABIdhYgQARdhwGARXgEIIAPAAAACAZ5AvAjhZgdQBAbyM9ygADAhhV6IKIA
-2JwdgBORuKQdABB0HYQTwg9v+qlwz3GAAEBjCmF0FQERWWEweXQdRBDPcYAASGPwIQEApBUAECV4
-pB0AEJgVABAdCF4CG5d2HQQQeB0EEKQVABCAuKQdABAT8AiHOpd2HUQQFwjeABuXeB0EEKQVABCD
-uKQdABAD8HgdRBC6CG/+qXCkFQEQRCF+gowVghAV8mIXgBBEeIYi/wNEuoYg/w5YYM9ygAAYYfQi
-EADPcoAACGH0IhIADfDDus9wgAAsmFx69CCQAM9wgAAcmPQgkgDgucogggQY9JgVABBRIACCiBWA
-EMO40SEihQjyHHjPcYAATJj0IQAACPAceM9xgAAcmPQhAAAhhQ0J3gCEHQQQBPCEHYQTmBUAEK8I
-HgKYFYIQz3GAAABgBCCADwYAAAAxuElhGWFAKQAhACCED4AAKHUAFAAABCC+jwAoAAA+8qQVABCX
-uKQdABAE2LgdAhAA2I+4uh0EEAAUAAAEIL6PADAAACbyz3CAAGBSQYBZpUaAInpAKoMFmBUCEGV6
-rrqvurC6mB2AEAWABCCADwEAAMBFeJgdABAAFAIABCKCDwAgAAAoukV4mB0AEAjwz3AMQKj+GaUC
-8AHZA8gBkCXoG8jPcoAAiIf0IgAAg+gBlb4dBBC4FYMQdBUCEXpiWGAQeL4dBBCYFQUQBCW+jwEA
-AMAN9AohwA/rcgXYiiOYCiEDb/eKJIMPAJXj8R8JUACC4cwh4oBUBQL/z3CAADB3FiBABCOIB/DP
-cIAAMHcWIEAEIoiMFQAQDrkleIwdABCYFQAQvhUBEW4PL/4A2oIdBBCkFQAQBCC+jwAAADBR8owV
-ABDPcoAACImUHQAQnBUAEZIdBBCAHYQUpBUAEAMSATYbCB4DFNiQHQQQfh0EFHgRAwECIMAgEHgL
-8A7YkB0EEH4dhBN4EQMBAiLAIBB4sh0EEACChiB/j6QVAhAL9JgVAxATC18CIZGF6ZG6krqkHYAQ
-ELhFeKQdABCMFQAQBCCADwAAABBSIAEDEocleAQggQ8AAAAQPXkleBKnFfCYFQAQlB0AEJ4VABGS
-HQQQvhUAEZAdBBCAHYQTfh2EE4IVABGyHQQQgBUAEX4VAREZYYIVABEZYYQVABE4YBB4sB0EEKQV
-ABDPcZ8AuP8WoZwVABAWoQfIz3GgAMgfsBAAAaARAQBk4DBwyiCFDxIoCACE989wACgIAAoaGDAV
-zAQggA8AAAIIFwiRAAcSATaKIAQADg6v+5gRAQAbEgE2z3CAAJiGNHjAsAPI/gmgAhqQz3CAAAAA
-AIBRIICBeANBAM9wnwC4/92gbQNAAKQWABC0uKQeABCSFgARp7iSHgQQlBYAEJAWAxHPcaUArP9I
-wLAWAhF4oc9zgACoELWTaJO7Y2J6A+IiultiemJIIkIABbpFIkIDVqEowgQggA8AAAAgJbhFeIm4
-jrgZoc9woACoIAiAA9nPcKAA9AcloBvImBYCEM9xgADAhhV5QKEBlhPoG8jPcYAAiIYUedARAAFT
-IMCACfLwEQEBz3CgAJgDPqC2HkQQpBYAEA0IXgKiDw/6I/AIdIQkEpAN8vm4pA4h+soggQMD2c9w
-oAAQFCWgE/ARCB4CogrAABoLwAAN8HAWAhHPcKAA9AcA2Uegz3CgAMgcJ6ADyKQQAAATCB8BkgtP
-/tvY/ghv+AoSATYDEgE209juCG/4pBEBAAMSAzYBgxMIXwY+D2/+BNgDEgM2HbPPcIAA2J4GgAHa
-geDAegy6z3WgAPQHGYUA2YDgyiHCD8oiwgcF2Mojgg8AAJ8AIANi/8ArIgEck0V4DXIAsgPIXZAN
-cECwA8hPgA1wQKADyEAQAgENcECwA8hRgA1wQKADyEgQAgENcECwAxICNhyShiD/DEEIEAFTgg1w
-QKADyFAQAgENcECwA8hUEAIBDXBAsAMSAjYckoYg8w+MIAyACvRWgg1wQKADyFwQAgENcECwAxIC
-NhyShiD9DIwgAoIb9GASAgENcECwAxICNqQSAAAjCN4FWYINcECgAxICNqQSAAC3uKQaAAA5orga
-QgC6GkQApBIAABEIngEBgvC4lA+C/g/wOoINcCCgAxIBNqQRAACGIPOPBfI7gQ1wIKAB2AulA9gI
-pQMSATaSEQABGQieApQRAAAEIIAPAQAAwOoOYAQuuM9woAD8RB2ABCC+jwAGAAAt9OB44HjgeFMI
-XkMDyM9xoADIH7AQAAGWIEEPHqEQ2A6hAdgVGRiAzgxv+EHYLwheQ89wgABgBQHZI6ADyKQQAQCa
-uaQYQAByCK/7AdjPcYAAXA4EgQHgBKGeD0/+CHXU2BoPL/ipcQQlvp8GAMoACfLPcYAAXA4HgQHg
-YQBgAAehA9nPcKAAFAQloAMSATYBgUsI3gCkEQAAUSAAgM9wgABsEAPyvZAC8LyQz3GAAKykEokr
-CB4AD4nPcYAAaKUQuCCJn7iA4QHZwHkPuSV4z3GgAPxEDaED8HYRDQEVzFMgQIAN8tXYkg4v+AoS
-ATYKyAcSATbmDq/+GxICNs92gADgl8lwvgiv/gMSATYWCA/+5g5P/oDgxAcCAAMSATaSEQABDwie
-Aqq4wg5gBJIZBAADEgI2CiGAL4AAwIZ+EgEBghIAAYASAwE4YM9xgAAEhxtjG8hwexV5CYF4YAmh
-AYK5CN4A19gSDi/4ANmSDu/7gNgKEgI2BCKCDwIAAQAVEgE3FwqBDwIAAAAPCF4HTyHAABUaHDAF
-8KO5MHgVGlwwAxICNiGCXQmeAYu4jLgVGhwwEIozEoEABLgleM9zgAC0mc9xoAA4LiSBBrMR8C8u
-QRBOJoIXAN4PJo4QxnnPdoAAYIb0Jo4QEwiAA/Lpz3AAAP//BLMG8ESzz3CfALj/VqAI2BQaHDDP
-cYAARH0RgQHgEaEy8BDYFBocMBXMo7gVGhwwsgmv/slw2NhODS/4AhIBNgMSAjYBkgjoG8jPcYAA
-iIf0IQAADOgBghUInwMbyAHaACCBD4AAEIdAqRXMUyBAgAryBxIBNoogBADWCK/7mBEBAE4Ob/6p
-cAPIGpDODGACGxIBNhXMUSDAgEIGIQAKEgE24gwv+NfYz3CAAASYAxIONgKAz3eAAGwQmB4AELCO
-ChIQNgDYpB4AEBKnC8gEIIAPAMAAADEIgQ8AwAAAG8jPcYAAiIYUeRGJjujPcIAAsHe2eCKICI4R
-CEMACnCiDu/9yXHc8FEgAKCF8gGGgwgeARvIz3KAAIiGz3OAAGBSFHoREoQAR4Myjg94BOolgyTw
-SSDAAFRtz3OAACh1QmMTCp4Fz3KAADB3tnpBigLwANrHcIAAMHe2eASICCEBAAghgQCAcUkhwQMW
-bTV4z3GAADB4AWHPcIAASHa2eF2HAYBFeAQggA8AAAAIBnkC8COGmB5AEBvIz3KAAHxz8CICAM9w
-gACEuIQqCwwwIEAOBCCADwBAAAA+uEGGwLoe4Bh6RXmYHkAQGQmeB6QWABCMuKQeABBQ2JweABBw
-8CEJ3gekFgAQjbikHgAQz3BAAVAAnB4AEADYnrgSp2DwANikHgAQBdgUuJweABDA2Bi4EqdU8I8I
-XicBhnUIHgHPc4AAYFIHgzKObBKCMAToJYMj8EkiwgAUbc9zgAAodQBjEwieBc9wgAAwd7Z4AYgC
-8ADYx3KAADB3tnpEigghgQAIIQAASSDBAxZtNXjPcYAAMHgBYc9wgABIdrZ4QYAdh0V4BCCADwAA
-AAgGeQPwI4aYHkAQG8gVIQAgIKAA2APwBdgUuJweABBRIAClANjPIGIEyiAhAKQeABAA2HQeBBCy
-DC/6yXDPcYAAQGMKYXQWARFZYTB5dB5EEM9xgABIY/AhAQCkFgAQJXikHgAQmBYAEBsIXgIbl3Ye
-BBB4HgQQpBYAEIC4pB4AEBLwCIc6l3YeRBAZCN4AG5d4HgQQpBYAEIO4pB4AEATweB5EEKYN7/3J
-cKQWARBEIX6CjBaCEBbyYheAEER4hiL/A0S6hiD/Dlhgz3KAABhh9CIRAM9ygAAIYfQiEgAP8FMi
-wADPcoAALJgcePQiEQDPcoAAHJj0IhIA4LnKIIIEGPSYFgAQUSAAgogWgBDDuNEhIoUI8hx4z3GA
-AEyY9CEAAAjwHHjPcYAAHJj0IQAAIYZRIcCAyiAhAIQeBBCYFgAQrwgeApgWghDPcYAAAGAEIIAP
-BgAAADG4SWFALQQRACSED4AAKHUZYQAUAAAEIL6PACgAAD7ypBYAEJe4pB4AEATYuB4CEADYj7i6
-HgQQABQAAAQgvo8AMAAAJPLPcoAAYFIBghmmBoIieJgWAxAWuGV4rrivuLC4mB4AEEWCBCKCDwEA
-AMBFeJgeABAAFAIABCKCDwAgAAAoukV4mB4AEAjwz3AMQKj+GaYC8AHZA8gBkCnoG8jPcoAAiIf0
-IgAAg+gBlr4eBBC4FoMQdBYCEXpiWGAQeL4eBBCYFgUQBCW+jwEAAMDyBIH/HwlQAILhzCHigFwC
-wv7PcIAAMHe2eAOICPAAlt/xz3CAADB3tngCiIwWARAOuCV4jB4AEIQXABCH6M9wgABcCQCIzQgQ
-ABsSATbFCZABAJa9CFIPz3CAAIiGNHgRiLEIEQCkFgAQqQgfAKUIHiCeFgARz3GAAGAFirieHgQQ
-mBYCEM9w/v//P0KhBHqYHoAQhBcAEC8oAQBOIIMHI7sA2A7jDyDAAAUiAwCGIvsPhiD7DwUiPoCY
-HsAQHfIA2JgeAhACga64r7iwuE8gggNCoSkIHgJIic9wgAAAYEhgHQiSAA0IkQAG2AipCPAH2Aip
-BPAN2JgeAhCkFgAQtLikHgAQnhYAEae4nh4EEJgWABC+FgERmgvv/QDagh4EEKQWABAEIL6PAAAA
-MFPyjBYAEJQeABCcFgARkh4EEIAehBSkFgAQAxICNhsIHgMU2JAeBBB+HkQUeBIBAQIhQCAQeAzw
-DtiQHgQQANh+HgQQeBIBAQIiQCAQeLIeBBDPcIAACIkAgIYgf4+kFgEQC/SYFgMQEwtfAkGSheqR
-uZK5pB5AEBC4JXikHgAQjBYAEAQggA8AAAAQUiABAxKHJXgEIIEPAAAAED15JXgSpxbwmBYAEJQe
-ABCeFgARkh4EEL4WABGQHgQQANiAHgQQfh4EEIIWABGyHgQQgBYAEX4WAhGCFgERGmKEFgARWWE4
-YBB4sB4EEKQWABDPcZ8AuP8WoZwWABAWoQoSATbc2KIOz/dBAC/4q8DgePHA4cVv2JW4z3WgAMgf
-Eh0YkM9wAQBAPBUdGJBmDo/7iiAEAA6ldQAP+OB48cDuD+/3A9jPdqAA1AcTHhiQDxYRlgAWAUAA
-Fg1A07nPcLD+AAAFec9ynwC4/zaiUyXBFCV4FqKveJzgyiHCD8oiwgfKIGIByiOCDwAA3QvKJMIA
-YAXi9solIgAAFg9A8H8AFhBAQOdRIAClwCeiEAPnBCePHwAA/P8H8M9wAADxCy4ID/gZFgCWQicB
-FPEIRIAAIcAjDx4YkAPYIB4YkNrYyg3v96lxBCCALwAAAECdB8/38cA6D8/3CHXPcYAAAAAAgYIk
-AzE1CF4DAYHtuEDYzyDiB8oggQ8AANAAzyDhB89ynwC4/x2iBIEB4NO4BKEFIIAP0P4AABaii3DP
-cYAA7GOuDy/9xNrPcKAAFAQB2SSgz3GAAER9E4EB4BOh07gFIIAPsP4AAM9xnwC4/xahOw2eEBvI
-z3GgAGQu8CEQABDgSiEAIA8hESAB3yjwrP/PdoAA4JcId8lwVg8v/otxKghv/slwGvCm/wh3ANga
-cDpwFPCO2JC4oBwAMA8OHhGG2JC4oBwAMIDnzCUhkOD1A9nPcKAAFAQjoIDnqXar8gDYz3GAADAF
-AKEA2c9woADIH5G5ExhYgM9wgADQAhB4z3GgALRHSRkYgItwz3KAADQFAKJvIEMAVBkYgM9woADI
-HxMQAIbxuMogIQD4CSH4zyDhAyTBUyHAAIYh/gNEucAcQjBkwEQmjRZrDl+QBu+M2JC4oBwAMLnx
-BLjHcIAAKHVAgEh0hCQMkA3yUSJAgovYzyAiBMoggQ8AAIgAzyAhBFXwTIhQccoggg8AAJEAzyAi
-BE30AcETCZ4GAd2Q2JC4oBwAMJHxIpAzFIAwXQkOAAvIBCCBDwDAAABRCYEPAMAAACLBRQlSAI3Z
-kLkEIIAPAQAA8Cy4lOCgHEAwyiIFAIT3CHKAIsIEz3GgAGgs8CGBAJTgwCCGDwAAhwDPcaAAGCzw
-IQAAFfAKwYwh/49d889woADIH6QQAAAieNdwAIAAAKYGxv+H2JC4oBwAMAHdS/FEJv6SCPLPcKAA
-FAQJgIDgT/UjDl4Qz3CgAMQsEIALIACERfXPcAAAsB4qDQ/4CyBAhD3zJQXv94AkAzHgeOHF4cah
-wUokAHIA2aggAA8AIYIPgAAMuYQoCwwE4jIiQg7Pc4AAHJjPdYAAbBBAwiDCw7pcevQjggBMFQMR
-emJ6lWK6W2MD4s91gAAAY/AlTRAiugUtvhBTIQ5wACZCHl161Wg1fsd2gADUkEC2A+MiuwUt/hBT
-IQNwACNCDl16QbYB4aHAwcbgf8HF8cDhxanBi3WpcM9xgACwZOIML/0k2qlw2gwv/gMSATaqDS/+
-qXCJBO/3qcDxwAYMz/ehwc9xgABAliSBz3WAAGwQNBUQEc9zgAAsmAQhgQ8AAAAQRSFBA0DBIMLP
-d6AAyB/Dulx69CODAKAXAhACIwMEFwrkAADeEHhwe9IPL/4U2gsIHgYA2CHwA9jPcaAA9AcFoeTa
-DXBAsA1wwLBChQ1wQKBGlQ1wQLBAhQ1wQKBClQ1wQLDEoZoLj/1AFwEWMHn+Cy/9CnAB2M0D7/eh
-wPHAz3CAAGwQGIghCFEBz3ABAKCGEg9AAM4JAAEIcc9wgAAYLqYKgADRwOB+iQXv9hfY4HjxwOHF
-pg9gADLYtGieD2AANdgFfRi9kL3PcIAA1GS6D2AAk70ouKV4z3GAAIAFfQPv9wCh8cDPcYAAMC4A
-EQUAFw1UAgohwA/rcgXYSNulAO/2iiSDDwWhz3CAAFgu8CBAAUB40cDgfvHAzgrP9892gAAwLgWG
-FwiRAooglwkqCe/3XNkI2ACmQPCF4Mwg4oE89M9woACsLxqAUiAAAG0IHwCKIBcMAgnv92fZEBYF
-EBcNFAQKIcAP63IF2GnbNQDv9ookgw/PcIAATIkVIEABIIjPcIAAAAXPcoAAtCkB3SGoLIqjqMC5
-Iqi+C+/6BBpAAQKGegvv+gGmB6aKINcHpgjv93PZoKaZAs/38cAmCs/3z3WAADAuJYUA3hkJkQAK
-IcAP63IF2PjbmHPFB6/2SiUAAAsJ0QAB2AalZ/ALCREBxqVj8D0JkQLPcIAATIkgiM9wgAAABc9y
-gAC0KcOoIagsisC5IqguC+/6waKKIJcJNgjv94ohhAQI2AClR/DPcKAALCAQgEeFAN9QcBIALwDK
-J28QgeHMISKAN/SKIJcNBgjv9+lxAdmA589wgAC0KcB5LKgBhQClgCCXB+oPr/eKIUQLJoXPcIAA
-xCkAgCEJUQCA4MohwQ/KIsEHyiOBDwAANQEF2KHzxqUD2A7wgODKICEBCvILD1AQBYULCFEAAdgC
-8ADYi/+RAc/34HjxwCYJz/fPdYAAMC4lhYLhyiHBD8oiwQfKIGEByiOBDwAAfgDKJMEAuAah9sol
-IQCK4XIBDQAyJkFwgADgZEAngHI0eAB4AoUWCu/6AaXPcYAAtCkEEQUAGQ00BAelCiHAD+tyBdiS
-23kGr/aKJIMPz3CAAEyJFSBAAUCILInPcIAAAAUB3kGowLkiqPoJ7/rDqIog1wcCD6/3ltnApYPw
-A4WAIJcH8g6v95/ZA4XuDC/4AKVyC+/5AdjPcIAAtCkhgM9wgABMiTV4IYjPcIAAAAUhqADZIqgB
-2a4J7/ojqGHwAN5CC+/5ANgkhc9wgABMiTV4IYjPcIAAAAUhqADZIqiGCe/6w6hN8IoglwmKDq/3
-u9kI2AClAN62DC/4yXAQFQUQFw0UBAohwA/rcgXYyNuxBa/2iiSDD89wgABMiRUgQAEgiM9wgAAA
-Bc9ygAC0KcOoIagsisC5IqgqCe/6BBpAAR/wUgrP9jsIkQEaCu/2BthCCs/2mOAwCkEB9gnv9gbY
-D/CKIFcMDg6v9+LZ+gjP+ooglwf+Da/36NkA2ACl8QeP9+B48cB+D6/3iiDXDc92gAAwLt4Nr/cl
-hiWGAN2C4cohwQ/KIsEHyiBhAcojgQ8AAGEByiTBAAQFofbKJUEDiuFuAQ0AMiZBcIAA7GRAJ4By
-NHgAeAjwKgrv+alwZgtP+Ah1iiCXDooNr/epcUkNURDPcYAA2J4AgYq4AKGuCy/4AtiKIBcJag2v
-94ohBgEG2ACmz3CAALgEz3EAAJw5IKDPcKAALCAQgMdwAgAgvwimDvB2Cy/4ANgChoAglwcyDa/3
-iiHGBAKGAKYQFgUQGQ0UBAohwA/rcgXYiiNGBl0Er/aKJIMPz3CAAEyJFSBAASCIz3CAAAAFz3KA
-ALQpo6ghqCyKwLkiqNoPr/oEGkABT/DPcIAATIkgiM9wgAAABc9ygAC0KaOoIagsisC5IqiyD6/6
-oaKKIJcJtgyv94ohBgkI2ACmM/AB3TYJ7/mpcM9xgAC0KUGBz3CAAEyJLIlVeEGIz3CAAAAFwLki
-qEGocg+v+qOoG/CKIFcMdgyv94ohBg1iD4/6E/DPcIAAAAViD4/6Wg+P+hcIUQCKIFcNUgyv94oh
-hwGpcLX+QQaP9+B48cDODY/3z3aAADAuBYZ3CBEBAN1iCi/4qXDPcYAA2J4Agaq4AKGKIFcJFgyv
-94ohBwgQFgUQB9gbDTQEAKYKIcAP63IF2IojxwhBA6/2iiSDD89wgABMiRUgQAEgiM9wgAAABc9y
-gAC0KaOoIagsisC5Iqi6Dq/6BBpAAYoOj/oHprkFj/fgePHARg2P989woAAsIDCAz3WAADAuCIUA
-3hBxBYXKJm8QgODMJmKQG/QChYAglweKC6/3iiEHDwKFgOYB2cB5AKXPcIAAtCksqM9xAABoOM9w
-gAC4BCIIb/ggoFkFj/fgeOB+4HjxwN4Mr/dA2rDBz3GAAPhkig3v/Itwz3CAADAuIIDPc4AAAAUJ
-CVEAQYsR8M9wgAC0KUGAz3CAAEyJVXhBiAOLQiAAgMogYgAaYs92gAAIBQGOAd8QcsInzhOA4cwh
-ooAK9M9xgADEKSCBCiVAkMolYhAH8IHhAd3CJUETAuUYuhC4RXhALwESBXmKINcKxgqv96V5A44F
-vwS4+GC1eDAkADClBK/3sMDPcYAAbBApgVEhQIDhIMIHyiCiAES4z3GAAHwuw7gJYQkJHgA1DZ9R
-NQleAM9wgABsEDiIIQlQAM9wgAC8tQCAEQheAM9wgABYuxSICQjQAQ0JkQAJDZ5RAdjgfuB/ANjh
-xUQiAVNNcoYi/ANNcE1wBCWAXwAAACBBKH6DB/LPcIAAvLUAgAsIXwAA2ALwAdglCRECz3CAAGwQ
-GIgLCFAAEQ1eUQTwhiX21wTyAdiU8ADYkvD+6c9xgAAUkVQRgwD4689zgAC8tWCDOQteAM9zgABY
-u3SLLQvRAWGBjCP/jxD0pJHPcwAA//8ZDcEQZYGMI/+PBvRskbULgI8AAP//hCgLDAAhgH+AAGS4
-aYDPdYAAOGULC14BQCUDFwPwQCUDFBiIC2NBKgABCGUWe89wgABUZXy4eGAoEIMADQseAB6BhiD2
-jxbyCwteAB6BJQieAgsLngALDR5SAdgL8BUL3gDPcKAADCQRgIwg/4/38wDYUSOAgcogIgDPcYAA
-vLUggRMJXgAEJb7fAAAAIsogYgAW6M9zgAAUkT6DOQkeAowiAoDMIoKPAABQAMwigo8AANAAEPST
-uT6jDvDPcYAAbBApgQ8JXwCMIgKABPQJCZ4BAtjgf8HF8cBeCo/3z3CgAAwkGIBBKIQHQS0AVMG4
-FQgVATMmAHCAANBlQCcBchR5AHkA2Bjwz3WAABSRlBWAEEAoAQaGIP0PUiDAAUW4JXjPcaAAiCQQ
-oT6Fs7k+pVLwAdhEKD4NACGAf4AAyHYhiM91gAAUkZQVghDPdqAAiCRTIUUAPoVAKg8GhiL9D1Ii
-wgFFug0MQAHlelCm4PHPc4AAuGVig5q55XtlelCmPqXPcaAAyBwQ2kmhJIDPcqAA8BcmoiOAJqIi
-gCaiIYAmooYVARFouTB5hh1EEFMhwYDAICEIwCAiDCCAM6IsaCCBM6L4EAGCM6L8EACAE6IA2Aqi
-yQGP9/HAXgmv9wDbz3CgAAwkWIDPdYAAFJGtcEEqhgeGIPcPlBWBECm4NnvAc8dzgACUixV7AIvP
-c4AA5ARgg9No1X7XY9tjRCeFkFMnjhAEIo8PACAAAMwnIpAH9EwlAIDMJyGQAN8C9AHfuwgTBIDm
-zCcikFnyFw2UAQohwA/rcgXYkNudBm/2iiSDD893gAC4ZfAnhBNAKQUGhiH9D0AuhgNSIcEBBSSE
-AQUlDwFFuSV/z3GgAMQnQRnYgz8OkRAehRDZmrgepc9woADIHCmgB4PPcaAA8BcGoQaDBqEFgwah
-BIMGoQDYCqGGFQARaLgQeIYdBBAm8EoVgxCk60ylhhUCEWS6UHqGHYQQFQ7RECsRAYZkulB6hh2E
-EC2ligmP+RDwQCkABoYh/Q9SIcEBRbkleM9xoACIJBChHoWzuB6lhQCP989woADIHBDZKaAB2M9x
-oADwFwqhAxIDNhyThiD/jCf0D4NLCB4Az3KAAMh2BIIGoQOCBqECggahAYIGoXATAAEe4FMgwIAF
-9EAiAAgD8EAiAAxAgFOhTGhAglOh+BACglOh/BAAgBOhCfAIgwahB4MGoQaDBqEFgwah4H7hxQMS
-DTbPc6AA8BcPhc9yoAD8FwijQBUAEQqyEYUIo0gVABEKshOFCKNQFQARCrIclYYg8w+MIAyAB/QW
-hQijXBUAEQqycBUBERyVCOEIsh2VCLJUFQARCLJgFQARCLIZhQejGoUHoxuFB6NyFQAROGAQeAiy
-z3CgAPQHJ6AC2c9woADIHCeg4H/BxfHAiiBXB4INb/c+2QHYANk2CSAGiiIEANHA4H7xwPIOT/fP
-d4AAfCoBh0ogACAQ3gp1AqcA2QGHDyFBAwsgQIAN8keHz3CAAIwuRHnwIEADBSBQIIDg4iACAGG+
-AeXZDnWQr31CIACgCQdv98ogYgDxwKYOb/cIcQDeDyYOEM9wgAC0KaCAAg1v94ogFw/Pc4AAfCoB
-gwQggQMwdsohwg/KIsIHyiBiAcojgg8AAIYAyiTCABwEYvbKJSIA0nnDg0KDBCBAgCR+w6MBoyR6
-xYNCo8R5JaPMJaKQD/JCCg/4D3rPcIAAuARggM9xAQDQN2B7A9gM8AbogOLMJaGQCPTPcIAAvAQg
-gGB5A9h1Bk/38cDhxQh1ANsPIwMAz3KAAHwqA4IhgmV4A6IFgmV5IaJleAWiUgxv94ogVw/PcIAA
-uARggM9xAQDQNwPYYHupchEI3wDPcIAAtCm+CK/5AIApBk/3CiJAgADZ7gABAC8mAPBKJkAATgAG
-AE8AIACKJf8P4HgKIkCAANnOAAEAbAAkAC8mAPBcAAUAKwg1CEomQAAIcQDYAiG+gOAgxQdCeQHg
-AiG+gOAgxQdCeesH7/8B4C8tAQBAJUUAAiZ88QAAIAAAKEAB6CBiAy8gAIAvIUsAAiG+gMAghgHC
-IYYA4H4RACAASiAAEEogQBAOIkIALyALEs4gRYCKJf8PCAAFAC8tAQBAJUUAAiZ88QAAIAAAKEAB
-SiZAAOggIgMvIACALyFLAAIhvoDAIIYBwiGGAEomAABCIP6QziCCAUQgfpDOIYIB4H6dAQAA4HhG
-gQnqI4FggSKCYnkwcADYAvYB2OB+4HjxwM9xgADMLphw+P8H6M9xgADsLohw9f+D6ADYCPDPcYAA
-DC+IcPH/eegB2NHA4H4Iczhg1bvVuQ0J5QA2uAIjQgAK8M9ygAConkWCAeDJuCJ6emIWuOB/RXjg
-ePHARgxP9wh113UlAACAANhK989xgAConiWBJQlFAyJ9AeD58c9wgAConsWAqXBqDu//yXEFLj4Q
-AiVNHowgEIDKIcYPyiLGB8ogZgHKI2YJyiQmAKwBZvbKJQYBFrhVBG/3pXgB2s9zoACwH1mjfoME
-6CJ7CQjEAADYA/BIcOB+z3KgACwgcIIJ6AIjQgATDoRwAIAAAA8IhAAA2ATw/wjFgAHY4H7geAhy
-A/AB4CCI/ungf0J44HjxwOHFCwgyDAh1GQ2SHgohwA/rcgXYEtuYdTEBb/a4c0IlABzdA2/3D3jg
-ePHAXgtv99hwAN3v/8loKw4SEPhwqXcyJoADFQgSDBEIkw7t/zJvOHgFfQHnQidHAOcPdYBhvpED
-b/epcAomAPCKIL8PyiBkAOB/LyADAOB/iiD/D/HADgtP94YKIAAIdc9xoADIH0WFDOj0EQ4AAoBk
-hcR6RXv0GcAAIoUAoQvw9BEAAER49BkAABzYGLgVGRiAPQNP9+B4D9mauc9woACwHzWg4H7gePHA
-ugpP9wh1z3agAMgfpBYAELhgpB4AEAHYE6ZYhjmGANgAIkKDASEBAFimOaYC2TOmOoZbhgAhQYMB
-IIAAOqYbphWG8gygAKlxFaYXhuoMoACpcRemD9iauA6mz3CAAAwv0//PcIAAzC7R/89wgADsLs//
-sQJP989xoADIH/QRAAAA2kYgwA/0GQAAD8iauJu4nLgPGhgwHNgYuBUZGIBYoVmhWqFboc9wAAwP
-AKQZgAAOoQ/YDLgQoeB+8cD+CU/3z3WgANAb04URDp4Wz3CAAMwubgkAAA8O3hbPcIAA7C5iCQAA
-EQ4eF89wgAAML1IJAAAc2Bi4E6UtAk/34HjxwOHFJYBAgEIiAoDKImIAgOLKIcIPyiLCB8ogYgHK
-I4IPAABfAMokIgBMByL2yiUCAWCBFQtAAEKAooNCfQ0NUxBgg/ULQYBBgwGjYKBBoACiRIClgEAl
-AxYXCl4ARoUG6qKCQoBCfQcNUhAAo0SApYBAJQMXFwreAEeFBuqigkKAQn0HDVIQAKNBgAsJgQAe
-Du//BYCZAU/34HhAgBUKAABkggsjQIAF9ECC9woBgADa4H9IcOB48cD+CE/3CHYAgEIgAYDKIWIA
-ANgk6SWGQYYB3zByIIZBhkGhIKIAps9wrd4CAAGmpYbAfwaFDw4BEKlwAtnq/walpYYHhQ8OARCp
-cAjZ5v8HpQXvog3v/wWGAdgJAU/38cCeCE/3CHUodub/CHfCpalwtv/xAG/36XDgeCCAEHHKISEA
-4H8ocPHAdghP9wh3HvAAhiGGIaAAoQDYAKbPcK3eAgABpqWGBoUPDgEQqXAC2c3/BqWlhgeFDw4B
-EKlwCNnJ/welI4Zgeclw6XDs/womAJAH8gOHIIAChiJ4twhSgBYN7//pcH0AT/fxwOHFCHUD8MP/
-qXDh//7oeQBP9+B+4HiA4cokTXDoIG0Cz3GgAFAMJYEBGFIA4H7xwOIPL/e4cJhxz3OAAIQFAYMi
-g892gAAUkc91gADUZQJ5HoY5uMG4FH0BFYcQz3CgANQLPBAGAM91oADQDw0JZQEA2gDYQ/CoFgAQ
-z3GgAMgfZOAeoRDYDqEB2BUZGIAZcwbwz3WgANAPCXMXFQCWIoMCIMABAnlIIQEAAYMCeUghAQAp
-DFEAJQpFAM9zgAA4LwKLJRUPlsG402gB4AKrA4PYf+d4A6MB4vDxIwsfQM9zoADUC7EJRIEEEAEQ
-AdigcQQYQBA8G4ABgQcP97YIT/u68fHADg8P989wgACgkQiIjCACgCryNGjHcYAAKHXAgc9ygABI
-ds93gAB4nvaXFnphglAmjRWGJ7sfoKGMJ0SQhiMBDmGiBPSRvaChDPCxvra+wKERD1EQlr7AoYUj
-AQ5hotILD/gA2c9wgAB4ngkHL/cvGEIA4cXhxs9wgACgkQiIjCACgM9ygACUnhby0orPcYAASHa0
-aMd1gAAodRZ5AIVhgQbulbgApau7BfC1uACli7thoQDYE6rBxuB/wcXgePHATg4P9891gAB4ngqF
-z3KAAEh2RCAEg89wgACgkQiI1GjHdoAAKHVghhZ64YIT8lAjgQUgpoYnAR7hogsMEQGRuSCmBPCx
-u7a7YKYmCw/4BvCWu2CmhScBHuGiLxWAEKK4VQYv9y8dAhDgePHA4cXPcIAAZLhIgM91gAB4nimF
-t7q4ugQhgQ8DAAAAB7lFeSigtg5v+ADYCYXPcYAASHZRIICCz3CAAKCRSIgUasdwgAAodWCAVnlB
-gQbylbtgoKu6BfC1u2Cgi7ovFYAQQaGjuPUFL/cvHQIQ4HjxwFYND/ehwQh1QMHPdoAAFJEAlkom
-QCCGIPwAjCACgMImgiUC2MpxWv+P6B6Gs7gepgDYz3GAAJSeE6nPcYAAXJ4MsWTwQiWSEEx0hCQD
-kP3z4HjPdaAA0A8lFQ6WJRUPlkokQCAQFRWWAm8MIgCgwiQOJS8jACUmCKAAyXAacBQnERUjDhAg
-Dw5QEYvmANjKIGEAAvAC2M9xgAA4LySBCyEAgAPyANkC8AHZKnA5/xHoSQiQIc9wgABkLxYgAARA
-gAaIHQ4BEAzq6XBgegDBFfDPcYAAFJEegbO4HqGr8QohwA/rcgXYiiPXBkokAABBAi/2CiUAAQHY
-oncQHdiTAiJSJIDgzCMioKH1lQQv96HA4Hjhxc9wgAA4LyCIAdthqCDpz3KgALAfeaJ+gkKAo4AA
-2TENgRDPcoAAhAVYioPqAdoK8EGAAiONAPcNhZ9MAEBLIagocgcKUQBhoCKo4H/BxaKg7/HxwAIM
-D/cacDpxiiBHDXIKL/eKIZYBz3aAABSRz3WAAHieEQg0JADfDNjpcf/+jOgehi8dwhOzuB6mz3CA
-AFye7LAf8KlwDNny/s9ygAA4LwCK/NkK6ACWJHiMIAKABvQllQSVJ3gDokIgACMqcYv/AJaGIPwA
-jCACgDQPwf/lAw/34HjxwIoLD/cIdoogRA/uCS/3yXEnDvUQANnPcoAAFJEegrO4HqLPcIAAlJ4z
-qM9wgABcniywd/AC2Nv+gOBz8s9xoABQDAWBz3WAAHieEq0FgROtCZWMIIiAYr438hf2SwjQAYwg
-xIHMJqGQWPTJcADZzf6pCBAAQCUAG8lxxP4vFYAQgLgvHQIQSPCMIMiANvKMIBCAQvQFgQluheB4
-DeH/yiEhADrwdQ5REMlwANm+/jToQCWAG8lxtf4vFYAQgbgvHQIQKvBVDpETz3CAAGwQGIhJCFAA
-yXAA2bP+HujPcoAAXJ5IcAbZqf5AIgACBtmn/gySgbgR8CEOERHJcADZqf4M6M9ygABcnkAiAAUE
-2Z/+DJKAuAyyiiBED94IL/cpldUCD/fgePHAWgoP9wh1GnHPcIAAeJ6SCy/3JNnPcIAAFJEegM9y
-gABMlzm4UyBBAM9wgADUZTR4QYogiADbVXnPcqAA1Asvos9ygACEBSGIYaICJUAQgODKIMwAAqJN
-cYYh/APQ4cwhgo8AAIAAD/KMIQOEEPIKIcAP63IF2IojGQ9KJAAAnQfv9bhzCnFz/wPwk/8xAg/3
-4HjxwL4JD/fPcoAAFJE+ghpwqsEA2CEJngPPcYAAbBBiEYEARBKDAMDdZHmGIf8OIrk6fQjwz3CA
-AGwQTBANAQLYhhIBAQJ5EYIE4dYL7/wA2i4IYAACIE8DA9jPdqAAyB8TphiGANlCwBmGQ8AahkTA
-G4ZFwLWGXBYREEAWABYfZ/wWABDPcIAAeJ5AgAGAACLCgwEgQABAwkHAi3AZCFEghMEaC2AAhsII
-d89wgADotiqQC/CCwQYLYACGwgh3z3CAAKieJJDPcoAAqJ5lggbCBLsXC6QAQCmAAhkIhQACev8I
-hIAF8MYLYACGwAhyRsItD5EQqXBWC2AASHEIdSpwSgtgAAbBBsM6cATCB8EFwAAiwoABIEAARMIW
-8JXvqXBWC2AASHEIdSpwTgtgAAbBBME6cAbDBcAHwgIhwYBEwQMggABFwBkPUBDPcIAAbBAYiITg
-zCchkADYA/QB2C8iB6A49Klw5gpgAAPZCHUqcNoKYAAD2QDBCHcBwEAhwYBBIAAAQcAEwEDBBcFA
-IMCAQSEBAETA6g4gAEXBDwgRILWmAMAYpgHAGaYbCJEgtaYAwBimAcAZpvemBMAapgXAG6YRCFEg
-96YAwBqmAcAbpoogBw5qDu/2SnFMIgCgAdnAec9wgACAUDSoMQAv96rAz3GAACwvIIEA2IPhzCEi
-gAL0Adjgfw94CiIAgPHAFPL4/4DgyiHBD8oiwQfKIGEByiOBDwAAogbKJCEAXAXh9colAQHPcIAA
-LC9AoNHA4H7xwM9ygAAsLyCCgOHKIcEPyiLBB8ogYQHKI4EPAACrBsokIQAkBeH1yiUBAQGiAdrP
-caAAyB9QoUoZmABIGRgA3vHgePHARg/P9s9xpAC0RSkRAIbPdoAAyHwRpisRAIYA3RKmz3ClAAgM
-A4AYpg4RAIYQejC4U6YUpg8RAIYVps9wgABQkVCIcohZpjSIeqYLkDumLOACII8AAiDCACJ4z3OA
-ACwvIINdpvymNwk1AR6mMyZBcIAA3GVAJ4ByNHgAeAPYwf9A2M7/t6YL8M9yoACoIDGCAoOiozhg
-F6YB2BKiAdgNB+/2FqbgeM9wgACEBRiIBujPcIAAOC8BiAPwAdjgfvHAig7P9s91gABkuMUVABYR
-CF4Bz3CAAFi7FIgNCBACCYVRIECBh/LPcYAAFJEDgSIKb/wkgSMIUQDPcYAAvLUggRcJXgDPcYAA
-WLs0iYjhyiBhABDykejPcIAAvLUAgBMIXgDPcIAAWLsUiIfgAtgC8gDYEv9uDIACz3GAAKieBoFF
-IEABBqHPcIAAbBAYiM92gAB4nkkIEAHPcIAAtIdWiHeOz3GAAMh8DQuAAACAHQgfAM9ygACEBQWC
-AeAFogDYBKIPgQHgD6EF8A6BAeAOoQmFUSBAgWwLwgDPcYAAhAUDgQvoANgDoc9xgADEBgCBoriu
-DaACAKEvFoAQUSDAgKQPgv8vFoAQUSCAgCwPgv+M/7X/gOC8D+L1yiDiBc9wgACspBGIgOCsD+L1
-yiAiBcUFz/bgePHAz3CAAFyeDJANCB4AEgpP/AbwUSBAgKAJQvzPcIAAlJ4TiA8IUAARCJEAov2V
-Bc//hP2NBc//iQXP//HAFg3P9s9woADEJ1IQAYZBEACGhiDjjwDdBvLrudEhooFJ8s9wgABsEAmA
-z3aAAHieLwheAaoPAAeK6BSOgeDKICEBQAyhAsohYQDPcIAAxJkAgAsIngD2C6/8EJa0rs9wgADE
-maCgTXCGIPwDjCACgB30z3GAAIQFB4EB4Aehz3CAAGwQGIiE4FAKwQWKIEcN9grv9oohyg7eDgAH
-fP+SCOAFLyCICgXwjCADhBgPwf/RBM/24HjPcYAAhAUJgQ8IUQDPcKAAsB8bgAuh4H42uDa5MHDW
-IIUPAACAAOB/InjgePHAz3KAAIQFCYIhCFEAz3CgALAfG4AMoiuC9f9GEgEBOGAQeEYaBAB5BM//
-8cDhxc91gACEBQ+Fj+gJhRsIUQCCDs/1EwgQBs9woACwHxuADaUB2A+lUQTP9uB48cDhxc91gACE
-BQ+FF+gJhSsIUQBSDs/1IwgQBs9woACwHxuAANoOpS2F2v9EFQERT6U4YBB4RB0EEBEEz/bgeADZ
-z3CAAIQFK6AsoC2gLqAvoCWgMKAkoEYYRABEGEQA4H8qoPHAANnPcIAAhAUpoPT/z3CAAEwvXgqP
-/8kDz/8Icc9wgABML0WAQ4JhuWCCz3KAAIQFSILVunpiz3OAAKieZYMFK34AACGBcMdxAAAAEIUC
-j//gePHAz3GAAIQFCYGW6AHYCaEA2Aih3f+KIIcOdgnv9oohzwXPcIAAbBAYiIPgnA/h/8ogYQFZ
-A8//8cDmCu/2iiDHD6TBSgnv9ooh0Q/+DEAFgOD4DsL/z3WAAIQFCIUqhZ7/RBUBEUYVAhFZYTBw
-AN7D9wIgTgAlhZHpEe4AhY/oBIXPcYAAyHzYYASlEIXYYBClEIHYYBChCPARCYUDAiZAEDCFOGAQ
-pYogCADiCO/2JIUEhULGQMAQhRDZQcAFhaLaHttDwItwZgzv9hi7CIUKpQDYBaVGHQQQRB0EEACl
-ngzv9RLYBIUbCFQBAdi3/7YJz/nPcYAAwH0YgQHgGKED8AXYsf+FAu/2pMCA4AHYwiAMAM9ygAA4
-LwCqAdgBqgDYAqoBogKiA6LgfySi4HgAFgBALQbP9s9wgAAsL+B/AIDgePHAJgzv9RLYz3CgALAf
-O4DPcIAAhAU1Au//KKDPcaAAsB87gUEoggXVuEEpgwXVuQJ5z3CAAKieYnoFgMm6BSi+ACdxz3CA
-AMwuA4AAgOB/OGDgeM9xoACwHzuBQSiDBdW4QSmCBdW5FwklAFtjz3KAAKieRYJZYQJ5AeMC8AJ5
-QCuABSV4zPEA2Za5z3CgANAbM6DgeAMLnkXgfvHANgnv9ghziiAIAM91oADIHxClAdpBHZgQ9f/P
-doAAqJ4jhgWGUyFPBRB3yiHND8oizQfKIG0ByiONDwAAjQDKJC0AtAat9colDQGA48wjYoA/9ECG
-WKVBhs92gAC8tVmlFKU1pQCGyQheAM9wgABYuxSIvQjRATeFz3CAAPC294UEIZAPwP8AADeIFYXV
-v1YLIAAKudW4BSABBDelAtkzpVqFO4UCIMODyiDDABQAIwBfu6AWAxcKu+J7eGAA2wIiAoADIcEA
-WqU7pTLwZQuRAM9zgAC8taATAAcKuBalz3CAAGS4CYA7CF4Bz3CAAFi7FIgvCNEBU6UYhXmFz3GA
-APC2N4kKuQIgQIBCKcIHGqUDI4MAe6UVhc4KAAAXpQjwThMABhqlTxMABhulN6VpAM/28cAKCM/2
-CiYAkM91gAConhH0z3CAAOBlqXFqDe/2FNrPcIAAzC7SD0//z3CAAOwuFfAdDpEQz3CAAPS2qXFG
-De/2FNrPcIAA7C4O8KlwRgzv9gXZz3CAAMwung9P/89wgAAML5IPT/8ElQq4BaUGhYYgww8Gpclw
-lf+6C4/1+QeP9uB4z3CAAMwuJ4AG6QOAQIACgUJ4BfDPcP8P///gfs9xgADMLkaBiiH/DyCgBuoi
-giCgAdgD8ALY4H7xwKHBCHOLcPf/guAA2AfyAMAQcwHYwiAOAKHA0cDgfuDYkLgA2s9xoADIHxCh
-CdiwGQAAtBkAABXYbxkYAGrYQhkYAADYmrgPoaQZgADPcAAMABkOoeB+4cVTIEIFBCCND8D/AADP
-cIAAqJ4FgAIggwAEIYIPwP8AANW5Inile0V4EHPKIK0ABfcQcwDYyiBmAOB/wcXgePHA4cXYcLhx
-mHLu/wh1yHCIcez/EHXKIK0ACvcQdQDYyiBGAZwP5v/KIQYB/QaP9ghzKHLPcKAAsB8bgAIggA8A
-AgAAaHHe8Yoh/w8goM9zgADMLkaDEuokghsJXgDPcYAAnDAPCkAAz3GAALQwEQpBAECC5QuBgALY
-BfAigiCgAdjgfs9xgAAML0aBiiH/DyCgBuoigiCgAdgD8ALY4H7xwBIOr/ZKJEAAwIGggAHf0XXC
-JAIB0XWhgWGAwifOEwHesXPAfrFzAdvCI84ATCQAgMwmIpDKI2IACvSF64DmzCcikAPyAtsC8ADb
-FOshC1AAOQuRAKCAwIEBgCGBAiWNk6CiAyBAAAGiEPAA2ACiAaIM8KCBwIAhgQGAAiWNk6CiAyEB
-ACGi8QWv9mhw4HgF8EJ5x3BAAAAAz3KAAKieRYLzCkSAUyBDBXBxwCCND0AAAADAII0A4H8ieAbw
-YnkCIIAPQAAAAM9ygAConmWC7wtEgFMgQgU6YgsLhAA4YAfwAiCAD0AAAABieDhg4H7xwCYNj/YI
-dSh2bg8v/wGAoIUQuUEtABQ4YF4PL//JcRC5sHg4YFIPL/9ALoESZQWv9ihw1bjVuQ8JBQDPcoAA
-qJ5Fgllh4H8OIEAAKwhQD4XgEfIH9hsI0AAnCBEB4H8E2BsIUAkbCFEL4H8C2OB/ANjgfwHY4H8D
-2OB/BdgG2OB+4HjxwIHg4cUA2An0z3CAAI+eAd2WDG//qXGpcP0Ej/bgePHAegyP9gh3z3CAAGwQ
-GIgacY8IEAGE5wDdiAAlAMogRQPPdoAAeJ5AJgATWgxv/wTZLo6wrlMhAAARrkEowCCguV8IZAAC
-IEIAY79TCsUDDurPcaAA0A8QEQCGYbpYYBAZGIAlEQCGD3gD8A+OANlTIIIgDyGBACR4LyYH8M9x
-nwC4/xCuGIHPIOIH0CDhBxihGIGeuBihGIG+uBihAdg9BI/2g+DxwADYCfTPcIAAjJ7WC2//A9kB
-2NHA4H7geIbg8cAA2A/0z3CAAJSeugtv/wbZz3GAAMSZAIGCuAChAdjt8fHAmuDhxQDYjPfPdYAA
-nJ4EbZILb/8E2QuNgrgLrQHY8QOP9vHAluDhxQDYjPfPdYAAnJ6pcG4Lb/8E2QuNg7gLrQHYzQOP
-9vHAVguv9gnZz3aAAPwv0g+v9slwAJbPdYAA2J4TCB4AAdhMHQIQfg2v9RjYCPBMFYAQDQhRAALY
-TB0CEACWIoYiuMC4TR0CEM9wgAD8MCCgz3GgACwgUIFyhQIiwAAJCN8HUqUQgQOlz3CAAOQvAIBC
-IACAyiBiAIjoz3CAAJQvAICA4CwIAgAIhoboz3CAAKieCJAVpQCWJbjAuKoI7/8D2foOj/YdA4/2
-4HjgfuB4z3GAAJQvz3CAAPRlyQev9hTa4HjxwOHFz3WAAOQviglv/6lwz3CAAJQvIIA9CV4AFBAE
-ABgQBQBRIQCAzCQigMwlIoAI9AohwA/rcgXYFQCv9bbbDg4v/wAlAAHGCM//CHGmCW//qXCxAo/2
-8cDhxc91gACUL6lwtg6v9gfZCBUEEADYRiT+g8ohwg/KIsIHyiBiAcojgg8AAGkAxAdi9colIgBA
-hScKXgAPCh4AJYUD6SaFi+kKIcAP63IF2HHbSiQAAJ0Hb/W4c89xAQAcezKlE6UjhR8KHgEOpQGF
-L6UZCNADz3ACADANEqUB2BOlBPAupf/YD6XH//INj/YdAo/24HjPcYAAlC8AgSKBf9vPcoAA2J5T
-IACAJnsD9C6CkekG6A6CCyDAgA30MIKF6QWCDwiQAAfpEYILCJEAAdgC8ADY4H7geOHF4cbPcIAA
-lC9AgAKAP9sGewxwz3aAAJQvoobPcYAA2J4LIECDAdgugcIgAQALIUCDwLoG8imGUSEAgc8gYQAL
-IMDACfTPcYAA2J4ugQshwIAA2QLyBNmE6g8JEAGF6ATqCQkRAQTYwcbgf8HF4HjxwOoIr/YA2c9y
-gADYngSChujPcIAAlC8HgAPoAdnPdYAAlC/Pd4AAbBAYj8CFUyYDEA0IEAEJhwkIXwEA3jLwB4WE
-6ADYEaWA48whIoAK8gmFEQgeARcOHhEBhQsI0QMA2Ah2FPAA2BHwEYUB4BGlDwg1AQjeAYWP4ADY
-CPLPdqAALCDQhgHYw6II3rCFie2C64fphehMEoAACQiRAATesQCv9slw4HjxwDoIj/akwTpwGnFI
-d6b/nwgQAM92gADYngCGkwgRAM9wgADQBQCAFwiRAIogCQiGDm/2iiHIAgYMIAAI2M9xgACULwCB
-S4ELCB8BAYEXCNADXwrQAADdp6GsoQPYC6EI8E8K0AAA3amhp6ED2AihpKaKIIoIQg5v9iqBz3Cg
-ACwg0IBAxwbYQcBCxUPFAdge2SpyCHNKJAAACiUAAQAmhx8HACChIyAABAomAAHtB2/2pMDxwOHF
-CHUhCBEBvgygAATdiiCJBu4Nb/aKIYYJbgsgAADYXfBxCREBz3CAAGS4GBCEAEwkAIHKIcEPyiLB
-B8ogYQHKI4EPAACuAQQFYfXKJSEAJBAEAFEkQIHKIcEPyiLBB8ogYQHKI4EPAACwAeAEYfXKJSEA
-iiBJCIoNb/aKIYYMCgsgAAfYKgxgAATdOgyAACXwUyV+kBPyz3CAANAFAICC4MwgIoEZ9IogCQhW
-DW/2iiEHAdYKIAAI2A/wHQkRAs9xgACUL89yAQD0WAHdqXAygZ7/A/AA3S0Hb/apcPHAsg5P9s91
-gACULwiFaQjQAAuFYQjQAAmFz3GgACwgGQgeAQyFFQhRADCB9gxv9oogSggB2CHw0IEKhQImARAF
-2Ay4MQhFAIogygfWDG/2yXEQ2AmlDYUCJgEQGQ5FcAAAAFCKIMoHugxv9slxAdgMpQPwANipBk/2
-4HjxwDIOT/bPcKAALCDwgM92gACULwqGpYYCJwEQDQ1EEAaGHWUifQnwz3IBAPRYAdgyhnD/6qYA
-hs92gADkLxsIXgCyCS//qXBqDI//CHFKDS//yXAE8OIML//JcD0GT/bPcYAAlC8AgVEgAIHPcIAA
-yJpIgFMiAwAE9AGBIQjQAwvrFwrfAc9woAAsIBCADaEB2OB/C6EC2OB/C6EK6xUK3wHPcKAALCAQ
-gAqhAdgD8ALYCKHgfuB48cB+DW/2ANmbuc9woADQGzGgz3CAANAFAIAA3ongyiHGD8oixgfKIGYB
-yiOGDwAA2ADKJIYDBANm9colxgDPdYAAAAAghTcJXgQhhfG5QNrPIuIHyiKBDwAA0ADPIuEHz3Gf
-ALj/XaFEhQHi07pEpQUigg/Q/gAAVqHPcYAAJDDwIQAAQHgAhQ0IXgTPcJ8AuP/doFUFT/bxwOHF
-z3GgAKwvHIG9gQR9z3CAAJQEAIgTCFEAz3DA3wEAHKEo2Ri5G/CKIEkGKgtv9oohDgmKIAkGHgtv
-9qlxFQ0eF4ogCgUOC2/2iiEODfYLAAX2vcQKwvYA2Zu5z3CgANAbMaD1BE/24HjxwOHFz3WAAMie
-z3CAAERmQCUBFN4Jr/ZI2s9wgACkZs9xgADUBc4Jr/YI2gDZz3CAAPwvKaDPcIAA0AUgoM9woAAs
-IBCAqQRv9hal8cDt/wDYz3GgAMAvgBkAABOBi7gToc9wyAA8AMAZAADRwOB+8cAGDE/2z3aAAEgw
-8CYBEM93gADQBQCnrQnQAM91gADInhsIkQAqhRMJUQCKIAkISgpv9gDZCNgApzkIkQAC2AqlANnP
-cKAA/ESeuSGgz3CgALQPANpcoA/IBCCAD/7//wMPGhgwD8iHuA8aGDAs8PAmARAXCVEAz3CAAJQv
-AIALCB8AANgKpQLwKqUEyA0IngASDw/6DfAA2p66ANnPcKAA/ERBoM9woAC0Dzygz3CAAGwQGIgN
-CBEB/ghABYToYgsAAqkDT/bxwOHFiiBJDKoJb/aKIYoHXg0AAs9xgABkuEiBz3WAAMieNJFTIgAA
-xg4v9gHbANgSpQ6FB+jPcIAAbBAYiAsIEQEE2APwognP/2oL7/8A2ZToC4UVCN4AiiCJBlYJb/aK
-IcsAANgJ8IogSQdGCW/2iiELAgLYsf89A0/28cAA2c9woADQG5u5MaAEyBcIEAGKIIkGHglv9ooh
-ygEA2Kf/CvCKIAkJDglv9oohigME2KL/1P9A8eB48cDPcIAA0AUAgA0I0QASDsAA7f808eB48cBC
-Dm//4cXPdaAArC8YhRUIngYahVIgAAANCB4AHIUVCB4HiiBJBroIb/aKIQkE1g3AAByFNQgeAM9w
-gABsMACAQiAAgMogYgCQ6M9ygAD8LwmCFQgVAc9xgADIni6BCQlRAAHgCaI8hXoIb/aKIIkNKg4P
-9bYIAAWJ6M9wgADQBQCAg+AoD8H/XQJP9uB48cDSCU/2CHc6cYogyQlGCG/2iiHHCM9wgADUBSCA
-AYBWIUELFOA4YADZMnDKIcYPyiLGB8ogZgHKI4YPAADkAcokJgBYByb1yiUGAc9wgADIng6AHOjP
-cIAAbBAYiDEIEAHPcIAAyJ4JgILgyiHCD8oiwgfKIGIByiOCDwAA5QHKJCIAGAci9colwgDPdqAA
-yB90HliQz3AAABAclgmP9k8gQQPPcAAAEBxuC0/2WNhmC2/2Adkg2BCmMthDHhgQANgODW/2jbgg
-2BGmz3CAAMiepBYQELIMb//roDWGdg8v9oogyQnPdaAArC88hWYPL/aKIMkJiiDJCVoPL/YqcYUP
-3hDPcIAAtAgAgIYgfw+C4AHYwHhxCFEAGBYAlqG4GB4YkIogEAARphmF8LgZhQvyBCCADwgAAADX
-cAgAAAAB2MB4BvCGIH8PguAB2MB4beig3xHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
-4Hhhv4wn/5/t9RmFiLgZpaIKD/nPcIAAyJ4LgMC4geAB2MB4ug+v9lpw6g+gACpwAdh+D6AACnEc
-hTkIXwYYhYi4GKWg3xLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhv4wn/5/u9cIJ
-wACkFg8Qz3AAABAcQgiP9lAgQQPPcAAAEBwWCk/2ag+v9kpwWv9c2AoKb/YB2SDYEKYy2EMeGBAA
-2K4Lb/aNuCDYEaYchR0IXgbPcIAA/C8AkFEggIHKICEC1Alh9sohoQDPcACCAQAcpQDY0g6gAOlx
-1QcP9vHAhg8v9gDZz3afALj/vYY9ps9xoADIO1aBRCIDB1aBNoGGIv8IZXqGIf8IBSG+gPH1Eg2A
-AL2mgOAA2B/yVgwv9wDYiiCJB64NL/aKIQYOA9jL/gLYz3GAAMieCaHPcIAAZLgJgCW4wLhKDq/2
-DqEI2Ioh/w9M/wHYeQcP9uB48cAGDw/2z3aAAMieXBaBEB0JcwCkwQohwA/rcgXY89tKJAAAnQQv
-9QolAAEEyIHgyiHBD8oiwQfKI4EPAAD0AMogYQHu8xUJkQAA2FweAhAWCW/1GNhR8GYNoADf2JsI
-EAAOhgDdsqYH6M9wgABsEBiIKQgRAc9xgACUL7ChsaEQ2Amhp6GppoogSQfqDC/2iiGEAwLYMPBS
-DYAAz3KAANQFYIJBgpYjgQEU4npiSwikAAHZKabPcKAALCDQgM9wAQB4cUDAQcFCwUPFKHAG2QHa
-qXOYdbh1ACaHHwcAIKF6CuAA2HWKIAkHjgwv9oohhAcB2IL+fQYv9qTA8cAKDg/2z3CAAGwQGIiE
-4MohwQ/KIsEHyiBhAcojgQ8AACwByiQhAJwDIfXKJcEAfgyP/7oMoAAIdgh1kO6GDKAA39gM6M9w
-gADUBSCAAYCWIYEBFOA4YBsIRANqCuAAAdiKIIkGFgwv9oohRQEA2GT+BQYP9uB48cCKDS/2iiD/
-D6HBQMDPdoAAyJ4IhgDZB+jPcKAALCAQgCimB6YSDI//fgyv/xpwCHHSDa//CnDvCBEAz3CAAJQv
-CYAA31EgAIHKIcEPyiLBB8ogYQHKI4EPAABmAcokwQPsAiH1yiXBAIog0AeWCy/2iiFFCg4OAALP
-cQCCAQDPcKAArC88oM91nwC4/3QVEBD9pc9yoADIOxaCNoKGIP8IhiH/CCV4NoKGIf8IBSE+gPL1
-lgugAP/YdB0AFDXoBoaA4Mohwg/KIsIHyiBiAcojgg8AAIAByiQiAHACIvXKJQIBdgigAItwCiUA
-kB3yiiBJBg4LL/aKIQYCiiAJBgILL/YAwYogCQb6Ci/2qXGKIIkH7gov9oohBgMD2Bv+qXAAwaP+
-yQQv9qHA8cBmDA/2BguP/3ILr/8IdQhxxgyv/6lwEwgRAYogCQa2Ci/2iiFLByzwz3CgAMgfpBAB
-ABWAz3aAAMieRYZCeddxAACgDwDdy/fPcYAAqJ4lgdW4QSmCAEJ5CwhEAAaGkOiKIAkGcgov9ooh
-CwqmpoogSQdiCi/2iiHLCgLY+P1RBA/28cDhxc9wgABsEBgQhABMJACByiHBD8oiwQfKIGEByiOB
-DwAA/AJ4ASH1yiUhAFoKj//GCq//CHUIcRoMr/+pcBUED/bxwM9wgABsEBiIhODKIcEPyiLBB8og
-YQHKI4EPAAAOA8okIQA0ASH1yiXBABYKj/8O6CoI4AAB2IogSQjSCS/2iiHMBgfY1P2+DUAARQeP
-//HA4cXPcIAAbBAYiITgyiHBD8oiwQfKIGEByiOBDwAAUQPKJCEA5AAh9colwQDGCY//Mgqv/wh1
-CHGGC6//qXCGIL+OEvRaDI//IQhRAALdz3CAAMieqqCKIEkHYgkv9oohjQipcLj9WQMP9vHA3goP
-9qbBz3CAAERmNoDPdYAAyJ4XgETBKYVFwIPhzCEigDjyz3CAAGwQGIhpCBABAd8A3hkJUQBmD6AA
-6XDPcIAAiIYdiMmlJuiKIEkGAgkv9oohDA8D2AmlEYXSpQzZFSQCMM9woAAsILCAz3ABADBxQMBB
-x0LHQ8ZEggDYCHOYcLhwACWHHwcAIKGqDqAA2HCxAi/2psDgePHAQgoP9s9wgABsEBiIhODKIcEP
-yiLBB8ogYQHKI4EPAABDAMokIQDYB+H0yiXBAIogBw6CCC/2ANnPdoAAeJ4tjgXpDI4bCEIAbggv
-9ooghw2KIIcNYggv9iyOWPDPcKAAsB8bgM93gAAwnwKniiBJBkYIL/ZV2YogCQY6CC/2IodMjg2O
-z3GAAKieaJFAp891gADYnh0I4gABpwixANlNHUIQAdkspTWFCQkFABWlEI4EpRGOA+gD6gDYCPDP
-cIAAbBAJgPcInoAB2AKliiBJBuYP7/V12YogCQbaD+/1IocChUCHgODKIGIAGLgFegSFCiEAgIog
-CQbKIWIAELm2D+/1RXmOCy/1AtidAQ/28cA2CS/2iiBJBp4P7/X32ToIj//PdYAA2J4IcYTgzCEi
-ghL0z3CgACwgEIAA2kKlA6XPcIAAMJ8CgNW4x3AAAIgTCaUNhYDgyiEiAQDeWgmv/8lwCQgRAc2l
-FfAChQroiiCJCUIP7/WKIcQGBdgJ8IogSQcyD+/1iiEECALYsgyP/yEBD/bgePHAqggv9phxCiMA
-gMohwQ/KIsEHyiBhAcojgQ8AAEkByiQhAEQG4fTKJQEBz3CAAJwwJYAjgc93gAConkCBz3GgALAf
-24FTJk0VNr5+Zl1lJYdhuwUp/gAndQIlgxCMIxeHSvfPcoAAMJ9BggUqfgAndV5mEQwQAM9xgACU
-LzOBJQlRAIoPr/5YJUEWz3CAALQwACWBHwAAiBN2D4/+iiDJDhrwz3CAAMwwZg+v/lglQRbPcIAA
-5DAAJYEfAACIE04Pj/7Jccm5z3CAADCfI6CKIIkPSg7v9clxBoeBuDUAL/YGp/HAz3CAAIQwwg6v
-/uHFz3CAABCfNYjPcIAAnDDPdYAAMJ+L6SCAQiEBgMohYgAF6SCFlQkRAJYOj/7PcIAAtDCKDo/+
-QoXPcKAAsB8bgDa6NrgPCIUACHGAIRAAAvAIcWCFemJhhXlhGwmFAAohwA/rcgXYo9tKJAAADQXv
-9LhzemIBCYUAInpPenByyiHND8oizQfKI40PAACqAMogbQEr989xgADMMCCBQiEBgMohYgAH6Vhg
-I4XJuA0IQABIcADZl/95B8/18cDhxYogSQZqDe/1wdnPcIAAbBAYiITgyiHBD8oiwQfKIGEByiOB
-DwAAxADKJCEAjATh9MolwQAqCS/1AtjPdYAA2J4ChQzoz3CAAPwvAYAJpc9woAAsIBCAAaXPcIAA
-qJ4GgEUIHgDPcIAA0AUAgIbgzCBigcwgIoIE9FT/FPAEhQDZEOjPcKAALCAQgCKlA6XPcIAAMJ8C
-gNW4x3AAAIgTCaUA2ASlpP/NBs/14HjgfuB48cBKDs/1z3GAAGwQOImE4cohwQ/KIsEHyiBhAcoj
-gQ8AAC4ByiQhAOAD4fTKJcEAz3GAANieKoGNCRAAz3aAAGwwIIZCIQGAyiFiALzpgODKIcEPyiLB
-B8ogYQHKI4EPAAA0AcokIQCgA+H0yiUBASWGI4HPd6AAsB+ggTuH1bk9Zc9xgAConiWBYbgFKT4A
-J3WKIAkOKgzv9alxO4eKIAkOHgzv9Ta5yXAGDa/+VyXBGM9wgACEMAAlgR8AAIgT7gyP/u0Fz/Xx
-wOHFCHXPcKAAsB87gIogSQ7mC+/1NrmKIEkO2gvv9SKFz3CAAGwQGIiE4MohwQ/KIsEHyiBhAcoj
-gQ8AAH8ByiQhAPwC4fTKJcEAz3GAAPwvCYEJCBUBAeAJoc9xgACongaBRiBAAQahz3CAANAFAIAZ
-CJEAiiDJB34L7/WKIYYD/giv/wbYcQXP9fHA4cUIdc9woACwHzuAiiCJDloL7/U2uYogiQ5OC+/1
-IoXPcYAAqJ4GgYK4BqEaD+/0Atg5Bc/18cDhxQh1z3CgALAfO4CKIMkPIgvv9Ta5iiDJDxYL7/Ui
-hc9wgABsEBiIhODKIcEPyiLBB8ogYQHKI4EPAADsAcokIQA4AuH0yiXBAIogyQfiCu/1iiHHDWII
-r/8G2AHZz3CAANieLaDPcYAAqJ4GgUYgQAHBBO/1BqHgePHA4cUIdc9woACwHzuAiiAJD6YK7/U2
-uYogCQ+aCu/1IoXPcIAAbBAYEIQATCQAgcohwQ/KIsEHyiBhAcojgQ8AALIBvAHh9MolIQDPcYAA
-2J4MgQnoBYGA4MwgYoAF8gDYyf8X8M9xgACongaBRiBAAQahz3CAANAFAIAXCJEAiiDJBzIK7/WK
-IYcAsg9v/wbYKQTP9eB48cCuC8/1CHbPcKAAsB87gIogCgAKCu/1NrmKIAoAAgrv9SKGz3CAAGwQ
-GIgA3YTgyiHBD8oiwQfKIGEByiOBDwAADgLKJEEDIAHh9MolwQDPdoAAqJ6mpoogSQjCCe/1iiEI
-BUIPb/8H2AaGgrhiCO//BqbPcIAA2J6toH4N7/QC2JkDz/XgePHA4cUIdc9woACwHzuAiiBJD4YJ
-7/U2uYogSQ96Ce/1IoXPcYAAqJ4GgYK4BqFGDe/0AtjPcYAA2J4MgQvoDYEJ6AWBgODMIGKAMA/i
-/8ogIgBJA8/14HjxwM4Kz/XPcIAAZLgJgM9xgADYniW4UyAAgAqhANgFoQ2hV/LPcIAAbBAYiKMI
-EAGKIEkGCgnv9YohyAzPcKAAsB87gIogCQb2CO/1NrnPdYAAzDAAhUIgAIDKIGIAMwhRAG4Jr/6p
-cM92gACcMACGQiAAgMogYgCL6IogSgDCCO/1iiGID8lwpgmv/iKFz3WAAOQwAIVCIACAyiBiADMI
-UQAuCa/+qXDPdoAAtDAAhkIgAIDKIGIAi+iKIEoAggjv9YohyQLJcGYJr/4ihW0Cz/XgePHA4cXP
-cAAA///PdYAAMJ8Dpc9wgABsMOIIj/7PcIAAhDDaCI/+ANkgpQXYAaUipSoM7/QC2DkCz/XgePHA
-vgnP9Sh1z3GgACwgMIHPc4AAMHxGiwDeBOpHi4PqBtiH4Mohyg/KIsoHyiBqAcojig8AAI0CyiQq
-ADwHqvTKJcoAz3OAANieCQ2QETSjToMPIkIDTqPPcoAA/DDwIgAAUoM4YAIgjQAJDd8XEqPPdYAA
-lC8ChUGFBHobyBsKDgAqpaoPr/WKIMoIAYXJpQcI0QPHpZUBz/XgePHAHgnP9Qh1z3aAAPwvAYbP
-coAA2J4Jos9wgAAUkR6ABCWEHwAAACDmuCa4UyADAEEtQBPAuBYizwACpyTyz3OAAJQvCYMA3yV4
-w7kPJ08QL4MJowshwIMB2AXyDKMcGwABLw2fEQ6DMIPkeAUgQIAQow/yANgJps9woAAsIBCAA6IH
-8M9woAAsIBCAAaLPdoAAbBAYjoTgpAyhBMogQQMYjjcIUADPcIAAvLUAgE8IXgDPcIAAWLsUiEMI
-0QHPcIAAFJGUEIAAz3GAACh1BLgAYSsIXgMnDR4Tz3CAABSRlBCAAAS4x3CAACh1IICIuSCgog6v
-9YogCQaNAM/14HjxwCIIz/XPdYAA2J4ghSV4AKUQhaHBhugB2BClBYURpU4Kr/mLcADBz3ABAHhx
-GwhAAM9wAQAwcQ8JAADPcAEA9FgNCQEAmgxgAAHYAN4KDe//wqXPcIAAbDDKDk/+z3CAAIQwvg5P
-/s9wgADkL7YOT/6KIIkGHg6v9XfZngtv/8lwDQDv9aHA8cDhxQh1iiAJBgIOr/Wpcc9xgADYngCB
-pngAoQDYEKEFgeoML/8RoeUHj/XhxeHGCHX/2c9wqwCg/zmgBNnPcKAAyBwooBbeEfDgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG+jCb/n+31z3GgAMAvE4GA5c8g4gLQIOECE6GA5TzY
-yiCBDwAAsgyTuJa4l7jAGQAAwcbgf8HF4HjxwDIJoAFH2ADaz3GrAKD/WaEH2BqhWKHRwOB+8cDa
-Do/1z3EDAEANz3CgAKggLaDPcaAAwC8Ugc91oACsL/C4FIEM8gQggA8IAAAA13AIAAAAAdjAeAfw
-hiB/D4LgAdjAeNkIEQAVEQCGoLgVGRiABPDPdaAArC/PcKAA1AsbgKUIEADPcKAAqCANgOTgkvcc
-hc9xoADALw0IXwYMdIQkwp/p8xURAIaAuBUZGIBG8IogCQayDK/1J2jPcaAA1As7gaYMr/WKIAkG
-LHGaDK/1iiAJBjmFkgyv9YogCQZqDu/1JNgIcYIMr/WKIAkGWg7v9YogCQMIcW4Mr/WKIAkG63ZG
-Du/1JNi4cM9woADUC2wQBAAF2AohwA/JcpUDr/SKI4kJYQmexhmFEQjfABoO7/Uk2FEInoQpBo/1
-4H7geOB+4HjxwIogiQYeDK/1iiHMAZ4Jb/8A2GDx4HjxwOHFz3CAANAFABAEAM9wgADYnkwkwIHM
-JCKACvIUEAUACiHAD+tyBdgtA6/07dsA3aWgiiCJBtILr/Xy2VYJb/+pcMkFj/XxwE4Nj/XPcIAA
-yJoIgM93gADYngDdLQjfAYogSQemC6/12dkC3iYJb//JcMWnz3GAAJQvsKGxoRDYCaGnoQvwpaeK
-IIkGfguv9eLZ/ghv/6lwZQWP9eB48cDyDK/1AdvPcIAAlC8AgM9ygAAwn8G4g+DBgsB7Dw5REM9w
-gAD8L8eAz3CAAMwwAIBCIACAyiBiAIMIEQDPcYAA2J4MgYDgzCMhgDf0AoLPc6AAsB/7gza4Nr/x
-cNYnjR8AAIAAQIK1gQAiEAD9ZRsNBRQKIcAP63IF2IojRAYKJAAEMQKv9Lh1i+4KIcAP63IF2Ioj
-BAf08QAgkCP/DQWU/maKIEkGwgqv9YohBAkCIIAjmguv/wHZnQSP9eB48cAuDI/1CHaKIP8PAKbP
-cIAA2J4KgIDgyiUhEWnyz3CAAGwQGIgvCBEBegsAAACmz3GAANQFQIEhgVYiQgsU4VlhMHAB2MIg
-DgATeFMgTQBP8Lz/z3CAAGwwAIDPd4AA/C9CIBGAugogAMohYiAAps9xoACwH7uBKYdAJxATz3KA
-AKie8CBBIEWCYbkFKn4A1b0ndYIlgRFIJQ0QEHXKJQYQT/fPcIAAbDCSCm/+SiFAIM9wgACEMIIK
-T/6gps9xgADUBQCBIYFWIEALFOE4YBB1Ad3CJU4Ts31TJU2QCfIPCVEgCYcKDa//8CAAIKEDr/Wp
-cPHAQguP9c9wgABsEBiIz3aAANieKwgRAQqGAdqA4ACGwHoB2YDgz3CAAKieBoDAeYDgzCIhgMwh
-IoBZ8l/wz3CgACwgsIAShgDaAiUBkOOGyiJvALF3CYYQAC8A+2ACJc8QgOcA38P2Ad8XDkVwAEAA
-AAfqAiWBH04AASAypgIlwRAXDkVwAEAAAAfvAiWBH04AASAjpiKGEukhhjhgEQhFABkIRQMRDUQQ
-CPAJDUQQCQhFAwDZA/AB2SKmAIbPdYAAqJ6mhYDgAdjAeIDhAdnAeYYlfx4A2wkNkBGqhoPtAduA
-58wiIoAD9ADYCPCA48whIoDMICKA+fMB2K0Cj/XxwD4Kj/UIdc92oADALxqGObhSIAAAUyAQABSG
-AN8RCN8Adgrv9STY8rgD8gHfURYAlovooxYAlgQggA8AAAAPjCAQgAP0ANoC8AHaBCGBTwAEAAAE
-IIBPAgAAANdwAgAAAEokQADCJAIBDHCGID0AgOBKJUAAwiVCARUInkHPcIAA0AUAgIHgANgD9AHY
-z3OAALQpYoMVC54Az3agAKwv3IYA2wcOnxUB2+S9yiBhIEMIECDlvconYRAd7+O9yiFhABnp4r3K
-ImEAFerhvcokYQAjDBAA4L3KJWEAFw0QAOa9yiBhAAfoUSXAkcojYQCD6wDYAvAB2KkBj/XxwJhw
-z3CAAGS4CYDPcYAA2J4luMC4CqF7/wXoiHC6/4PoANgC8AHYRQLP//HAocEA2M9ygADYnk0SgQBA
-wItwHwlRAM9xoAAsIDCBVIJCeQ8ORXBOAAAghgrP/gPwhgnP/hEIkQCKIP8PocDRwOB+z3CAAMwu
-A4AggADAIniA4MogLADz8eB4z3KgACwgUIIies9xgADUBRV5AIETCIUAz3CAAGS4CYAHCF4BQKHg
-fuHFiiH/D89woACwHxuAz3WAAMwuY4Vgg6aF1biA5QDaBvIihWJ5gOHKIYwACSEAAIIggQFIIAAA
-4H/BxfHAUgiP9Tpwz3CAANie54DAv4HnAd/PcYAAtCkNicB/CQhQAADYHPDPcIAAxCkAgHroCBEE
-AFEkQIDKIcIPyiLCB8ogYgHKI4IPAADeAMwFYvTKJcIAOgmv+OlwGnCKIEkGbg5v9UbZiiDJCWIO
-b/Uqcc9woAC0DwDe3KAPyAQggA/+//8DDxoYMA/Ih7gPGhgwYgggAhzdRNnPcKAAyBwpoBLw4Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HhhvYwl/5/u9c91oADALxOFFQifBoogSQbyDW/1
-XdnGDCAC6XAKCO//6XDPcZ8AuP9dgc9wgADcBUCg3aHPcKAAyDs2gEQhAgc2gIYh/wgWgEV5RCAE
-BwUkfoDy9WYIz/9RFQCWhegMdIQkwp8V8heFJwhfBs9wgAC0CACAGwhfAAohwA/rcgokAAhRFQWW
-BdjFBG/0eNtJD1EQiiBJBm4Nb/WA2RCFLQgfAM9xgAAwfASRDQhRAQuJGQiQAEAVBBAKIcAP63IF
-2IbbjQRv9LhziiAQARGlEIX/CB+AFIWruBSlTyBAJpy4GaXPcKAAyB8YEAGGobkYGFiAiiEQADGg
-CdkIuS+gE4WpuBOlz3CAANieB4A1CNEAz3CAANQFAIBWIEALAiEBoBgADwAKIcAP63IF2K3bSiQA
-AB0Eb/S4cxJpn7iIHQAQigsP/oAdgBPPcIAA3AWZBm/1waDxwC4OT/XPdaAAwC+AFQ8QXBUQENqF
-iBUREM9wgADYngeASiJAIMC4geDPcIAA3AUBgMIigiTguMr0gLjPcYAA3AUBoYogCQ1mDG/119mK
-IAkNXgxv9UEvgRCKIAkNUgxv9QpxiiAJDUYMb/XJcYogCQ0+DG/1KnEwhTYMb/WKIAkNM4UqDG/1
-iiAJDQsOHhcQhQsIHwAA2ALwAdgvIAcgfQoQIIogCQ0GDG/17Nkwhf4Lb/WKIAkNEIUdCJ8CQBUE
-EEwVBRAKIcAP63IF2C0Db/Tv2892oADIHyDfJwhRIIogEAERpfCmCthDHhgQANg6Ca/1jbjxpjCF
-tgtv9YogCQ2KIBAAEqXwpgXYQx4YEADYGgmv9Y248aYR8BCFHwieAkAVBBBMFQUQCiHAD+tyBdjJ
-Am/0iiOEABOFHwoQIDEIngYKIcAP63IF2ITbSiQAAKkCb/QKJQAB+rjKIcEPyiLBB8ojgQ8AAIgA
-Bdjx8wfYz3agAMgfGR4YkAHYCHEIcghzSglv9JhwBg2v9VTYFQgfAc9wgADcBSCAz3CfALj/PaCA
-FQ8QIr/eCS/+6XDPcYAAwH0NgfhgDaEA2IAdABCIHQAQCdgIuA6mvQRP9fHAZgxP9c9wgADYngeA
-SiBAIMC4geDPcYAA3AUBgcIgAiSFCF8AgbgBoc92oADALxOGDQieBhOGurgTpgLYEabPcIAAMHwA
-kM91oADIHyUIEQIg3/ClCthDHRgQANj+D2/1jbjxpQnwRRUAFuTgnvcQhvkIHoAGDY//rgggAgpw
-FRYAloC4FR4YkIog0AdSCm/1iiGFCsoMQAHODI/4CdgIuA6lJQRP9VwWBBBAFgUQCiHAD+tyBdhx
-AW/0iiOFBvHAlgtP9aHBOnAodUh2mnMKIwAhCiJAIch3CiDAIYogGQL+CW/1C8EswCgUBTAK6Cpw
-qXHJcgpzsgkgAJh3EfAAHEAxKnCpcclyinMKJMAECiWABNh3KgggAAonAASNA2/1ocDgfuB48cAI
-cbIJb/WKIFkBsg0P+dHA4H7xwAoLT/U6cPpxGnJacwogADEKJEAhCiOAIQolwCEKIMCEz3GAADR1
-yiBiAAhyBLgIYUwnAKAEuIYg/gMFIJYAyiHMD8oizAfKIGwByiMsDcokbACYAGz0yiXMBc91gAA4
-UgGFAN7Jcb4Lb/U42iCFHNgAoQGFGNkgsGpxhCkLDAAhj3+AAGS4N4cQGIIFMxiCA892gADkBSGg
-yXEioAohwIQoGEAFMRjCBTIYwgU0GAQEyiFiAFIOr/UM4CGFDNgSqQOBHQhfAgyJz3KAAGxgw7gc
-eApiz3CAAAi5SGAMqQ0LESDPcIAAUJoF8M9wgABwmgOlz3IAAEgRQLAY2kKlCwlQIIoiBQJAsA3C
-hOrPcgIAkA5BprUXAhYjCh4AGtpAsUKlQJCHukCwEwoQIM9wgACULwSAMxkCACsIEDABgZi4AaED
-gZ+4A6HPcYAA+AgAGQQFIIdBh89wgAD8CCCgQaA6Cy/5qXDlAU/18cC2CU/1ocEIdlpxOnIac4h3
-Fgjv/qh1gODMJiKQCvLPcIAA2J6voOoLb/QD2A3wQMXJcEpxKnIA25hzuHPYdwonAASU/80Bb/Wh
-wPHA4cXPdYAA7AUS6SaFjekApbYLb/QN2EIJr/+KIAgAAdgGpQ7wIIUleAvwrgtv9A3Ysgmv/4og
-CAAA2AalAKWtAU/18cAuCU/1CHYA3+lw6XHs/wPY6XUacAnuE20UeMdwgAAYMRYID/4J7hNtFHjH
-cIAAYDEGCA/+QiBAIN0IdYAB5c9wgABAn+l0nbAwvJ6wz3CAAOwF+gggAeCgOQFP9eB48cDCCE/1
-z3GAAMQGAIGguAChAdjj/89wgABAnwCAGwgUAQohwA/rcgXY3NuYc2UGL/RKJQAA3Qh0AADez3eA
-AOwFz3CAAKxm1XgggLNuA4AipwOnFG4AIIEPgABAn0eRBpEQukV4RZEacASRELpFeEORWnACkRC6
-RXg6cOoL7/0KcSKHenC0fQAlgB+AACQxIKCKDm/+KnAIcQAlgB+AABgxlg/P/QsIhCRPChEgI4ez
-brR9ACWAH4AAbDEgoF4Ob/5qcAhxACWAH4AAYDFqD8/9iiBMDXIOL/X62YogTA1mDi/1anEfDtQQ
-CiHAD+tyBdj825zxiiBMDU4OL/WKIQQAz3CAAECfAIAB5jcOBJAJAE/18cDPcIAAQJ9CDG/1Ddn6
-C0/1t//RwOB+8cCiDw/1CHaKIEwLDg4v9clxg+bKIcYPyiLGB8ogZgHKI4YPAACNAcokxgA4BSb0
-yiUmABRuz3eAAECf+GBFkCSQELpFeRpwhwkQAM9wgACsZtV4IIDPcoAA7AUDgCSis24ForR9ACWA
-H4AAtDEGEAIhIKAEEAAhELp2DW/+RXgIcQAlgB+AAKgxgg7P/c9wgADsBSWAACWAH4AA/DEGEAIh
-DhADISCgBBAAIQwQASEQuhC7RXiGCu/9ZXkyDU/+CHEAJYAfgADwMUIOz/1elx2XANkPIYEDELpF
-eAYgQIAB3R23MLgetxf0z3GAAMQGAIGguM4O4AAAoc9woACwHxuAsqcM2ZbaEadWJwASHtuqCG/1
-GLsQ2s9xgADsBQCB2HpGeOEGL/UAoeB48cB+Dg/1z3aAAOwFAN0L8BDYuHgLIQCAvA7i/8ogQgMB
-5fEN9JAghoDhyiAhANgM4f/KIQEAtQYP9eB48cAA2c9ygABAnyCiz3CAAMQGIKA9sjC5PrI+8fHA
-4cUA3c9wgADsBaCgz3CAAMQGoKDPcIAAQJ+pdJ2wMLyesKlwM/+pcKlxIP9tBg/14HjxwO4ND/UA
-3891gABAnz6VDycPEB2VELkleAYg/oM/9M9xgADEBgCBgLgAoc9wgADIBs9xgAC0hwCQVok3CgEA
-z3CAAMoGAJBUiSsKAQDPcIAAzAYAiDKJGwkBAA/IBCCAD/7//wMPGhgwD8iHuA8aGDDPcKAAsB8b
-gADeDNmW2hCl0qVWJQASHtt6Dy/1GLsB2Mlxjg+gA4DaPpUdlRC5JXjleB21MLitBS/1HrXgeKjx
-4HgIcQDY/PHgeAhxAdj48eB4CHEC2PTx4HjxwOHFz3GAAECffpFdkRC7ZXoB3RcKDwADuBR4x3CA
-ABgxBgzP/alwAvAA2G0FD/XxwOHFKHXz/4DgyiBBA3AL4f/KIWEAVQUP9eB4CHIA2BDZ8PEIcgHY
-INns8QhyAthA2ejx8cDhxc91gADcoCCNjCHDjwnyB+jPcIAAODKqC8/9/9gArc9wgACEoADdtaDP
-cIAAkAWgoM9xgADEBgCBorieDOAAAKGpcL4I4ACpcekED/XxwOHFz3GgALAfO4HWCi/1iiDMDc9w
-gACEBgCABCC+jwDAAAAI9M9wgADcoACIjCDDjwTyAdjf/891gACMn6lwughv9VLZ0gtABaOFiiBM
-DpIKL/WpcWIIT/WKIIwOhgov9V/ZUgpv/qlwCHHPcIAAODJiC8/9/tnPcIAA3KBpBC/1IKj/2c9w
-gADcoCCoANnPcIAAhKDgfzWg4HjPcoAAtId2is9xgAAIBlSKYbEBoUCxKHAI2XPaHtvJBS/1GLvx
-wOHFz3GAAIyfQYnPdYAAkAXPc4AAxAYggwfqAdgApYK5IKMI8ADaQKWiuYDgIKOYC8IAANi+D6AA
-CHEA2Oj/5QMP9fHAz3CAAGwQCYBRIECByiBiAGAOogTKISIAz3GAAMgGiiCMDLoJL/UgkQHY5P/R
-wOB+4HjxwDoLL/WKIgQOz3WAAIyfz3aAALSHQCUAFJoIb/VAJgEWAYUihSGmIZUApjauII0EIIAP
-AAYAAIDgAdjAeDSuEq4A2c9wgACaCRYPIAAgqBYNgAME6ADYzP8i8M9xoACwHzuBRgkv9YogTAy6
-CW/0AtjPcYAAbBBIgTSRUyIAAGYO7/QB24ogjA4iCS/1ptkA2Z65z3CAAIQGIKAJAw/18cDhxQh1
-/9nPcIAA3KAgqG8gQwDGDqAAAdnPcaAAsB87geoIL/WKIMwNBYUDgEKFIICKIIgA1ggv9UJ50QIP
-9YDg8cAP2AnyngwP9C4Kb/+A2NHA4H6mDA/0qgpv/4DYVghP/g0IkQBuCi/+ANjz8fHx4HjxwAoK
-L/WKIMwOosGKCC/1iiHFAotwmg4v9QLZAxSPMILnyiHKD8oiygfKIGoByiOKDwAAXAHKJCoAqAfq
-88olygACFIAwz3aAABAGhC8GHwAUEDEkHgIQz3CAAISiACBBDjSJCiVALkAgEgUAIFQOG+mKIEwN
-Iggv9YohRQqKIEwNFggv9elxIgtv9UIggCEB2BO2/9glHgIQQCYAGa4Kb/UE2WbwSiMAICYexBQl
-HsITz3WAAOCgQCUREqJ1i3CpcZYOL/UC2kAlABJ+Dy/1QiCBIQAlgS+AAOCgAoHPcYAAqJ4lgdW4
-MHDKIcYPyiLGB8ogZgHKI4YPAAB6AcokxgTgBubzyiXGBBIJYAXpcEokgHBqcaggwAOEKQYPL3Ay
-IgIgBuowIQIgAoVLCgAAAeFAJgAZFgpv9QTZAdkUHEIgbRUAFoC4bR0YEChwoP+KIEwNQg/v9Ioh
-hgSKIEwNNg/v9CKFiiBMDS4P7/TpcekAL/WiwAohwA/rcgXYiiOGAUokAABdBu/zCiUAAeB48cDP
-cYAAEAYDodoKL/QQ2GYIb/+KIAQAG/HgePHAcggP9QAWDkChwYLmyiHGD8oixgfKIGYByiOGDwAA
-bQXKJMYAEAbm88olJgBAxot36XBqCW/1BNmKIMwKrg7v9MlxhC4GHwogQC4AIY1/gADcomDcJg+v
-/QIlABPPcIAA4KDeEAAGIQ4AELwVgJAj6OlwBNmZ2h7bEgov9Ri7ANi8HQKQGfAAIIEvgABUohCB
-gbgQoc9wgAAQBjSAAdoE6USgBNgI8ADZMKAqoEugJKAF2Mz/IQAv9aHAMQIv9BDY4HjxwOHFz3WA
-ABAGFYWf6MYND/6C4NwP4f3KICEAAdgVpfYJL/QQ2AYKL/QP2BalCOjmCS/0D9jqDy//gNjPcQEA
-NJoB2KIJoAOA2uEHz/TgePHAXg/P9M91gAAQBjQVEBCMIMOvCPKKIAwNvg3v9IohRg4g8IDgyiHB
-D8oiwQfKIGEByiOBDwAAvgHKJCEA5ATh88olAQQIcYIhBgfPcIAA4KAOIEAAggmv/YohBg8acM9w
-gABEpEWAjCLDj//ZBvI4GAAELaUI8BQYAAQA2ASlLaXM/z0Hz/TxwOHFCHWEKAYPz3KAAOCgACJB
-Dm0RAAbPc4AAEAaguG0ZGAACgwSIE+gDgYDgyiHBD8oiwQfKIGEByiOBDwAANAfKJCEAVATh88ol
-wQACgZLo3hIABowgw48K8s9woACwHxuAAqHnGlgDEfCtowDYwv8N8K4MD/6ELQYfCHEAIYB/gAB8
-oroNj/3JBs/04HjxwE4O7/QC2ADdCHbPcIAAlKKELQYfMCBADlEgAIBUD+L/yiBCAwlu4wh1gAHl
-ANjx/okGz/TgePHA4cXPdYAAEAYjhc9wgACwNvAgQABAeHnocQbP9OB4z3CgAAREB4CA4AHY4H/A
-eM9zoACoIDGDz3KAAFAyA4I4YAOiAdgSo+B+4HjPcqAALCBmgs9xgAAQBhOBYngToRCCEqHm8eB4
-4cXPcqAAyB+kEgMAz3GAABAGEoEQc8IjBgBE92J4E3u/ghOBu2N4YBOhAdhKGhgA4H/BxfHAdg3v
-9ADbz3CAABAGY6D/2s9wgADgoN4YmABKJIBwaHWoIAAIhC0GHwAhgX+AANyiz3eAAMwuoBnAgAbe
-sBmAg892AQBkh6wZgIO0GcCDvBnCgAAhgX+AAJSiYKEB5c9wgADgoOcYmADPcYAAzDYAgRzaQKAY
-2NIIoAACoWEFz/TgeAHaz3GAAFAyQ6kYoShwZNl12h7b8Qbv9Bi74HjxwNIMz/TPd4AA4KDnFw0W
-jCXDny/y/9nnH1gQhC0GH6CgJ3cEjwogQC6R6AKHz3GAAIwGNgiv/SCBCHHPdqAAyB8VhhIOD/6D
-6AHYFPDPcYAAUDICj6CpAakB2BOmHIYBoQHY4P8A2AAggS+AAJiiAKkA2MEEz/TxwGIM7/QB2qHB
-z3GAAMAGQKFPCFEAz3WAAESkBYWMIMOPCvIA2oQoBg8AIYF/gACYokCpz3aAABAGEIYF6A+Gy/8A
-2BCm/9gFpYtwz/8J6CoMgAAAwA2mANgp/xHwZg7v8xDYFgyAAGIML/+KIAQADgoP/oLgKAzh/cog
-IQBRBO/0ocDxwNYL7/T/2s9wgADgoN4YmADnGJgAAN7PcYAAEAbDoU2hAdrPcIAAwAZAoNCh1aHW
-odShwKHBoQLdyXCEKAYPGnAAIYF/gABUohCBACGPf4AA3KJg3EYgwAAQoYIKr/0CJwATYb28H4KT
-1Q11kEAgQCAB2ML/xQPP9OB4ANjPcYAAUDIDqc9wgAAQBkiAAoBCqRzgVnhEiEmpBYjgfwqp8cA6
-C+/0iiAMCc91gAAQBiSFngnP9ASFhQgRAM93gADgoN4XAhYA3oQqBg8AJ0AeAqUkiAHbz6VwpSLp
-6B+YEwwQBQDPcYAAqJ4EJYQPwP8AABQRBgBBLAQGBS4+AQAhhH8/AP//BCRBAekfWBAgkIwhgoYB
-2cIhTgAupcilJIDPdoAAKKTAuTq2z3aAAFAyKK5ArgKIZKUBrh7wBIU5CFEAz/8A2ASlAoUkiJLp
-KIUc4DZ4JIjPcIAAtIcWiBBxAdnAec9wgADABiCgAtgD8AHYA6XNAu/0AdjgePHAz3KAABAGAoIl
-iAHYBukI2S+ie/8I8M9xgADABjYKoAAAofcHj//xwDYK7/SKIEwJz3aAABAGJIaaCO/0pMEEhoDg
-nvQChkiGJIBWeM9ygAC0hwQhgQ8ABgAAgOEB2XaKIBCNAMB5Ew3BEM93gAAopPqXtIoLDcATAN0F
-8LKK+wlBgwHdz3GAAMAGoKGW7c9xgADIBiCRIQtBAM9xgADKBiCRdIoVC0EAz3GAAMwGIIlSigkK
-QAAA2QPwAdm5CRAAJ4DPcIAARKQtoM9wgAAwn0GAz3CAAKieBYAFKL4AQCmAchBxyiHGD8oixgfK
-IGYByiOGDwAA7ALKJCYAIAem88olJgDPcIAAlAYAgLYMb/04YIPou/9G8A/IBCCAD////wMPGhgw
-aBaAEADdpaaJ6M9woAAsIBCAx3AHACChGaZkFgcQz3ABALCZQMAF2EHAAd9Cx0PF6XAG2QTaANuY
-c7hzUg1v/9hzaB5CE+Sm6XAb8ADYAtkjpmgeAhAV8ASGAd0hCFEABYaa6M9wgABEpC2Az3CAAJQG
-AIAmDG/9OGAG6AHYIQHv9KTAaB5CE24Nb/8F2ADYBKav8QXYD6apcBD/ANhoHgIQ7vHxwJIIz/TP
-doAAEAYEhqTBi+gkhvIOr/SKIIwIAoYEiJLoAtgEpgSGjQhRAAWGuejPcKAAsB8bgNoJL/47hqzo
-ANgw8ADf5abPdaAAyB8Vhc9xgACUBtILb/0ggRumpBUHEM9wAQAMmkDABdhBwAHdQsVDx+lwBtkE
-2ulzmHe4dwAnhw8HACChYgxv/9h3pKapcC7wvgxv/wXYBNgC8AXYAdqE6AHYJPArhiMJUABQpg+m
-DfAEhjcIkQAkhkoOr/SKIIwIC4YLCFEAAdgN8OzoAoZCDu/9A4AIcc9wgADkNhYPT/0A2NT+3vEA
-2Hfx4HjPcoAAEAYigiWJE+nPcYAA4KDeEQMGz3GAAJSihCsGDzAhQQ4LCV8ACNgPogHYC6IA2Aqi
-BKIF2AOi4H7xwGoPr/SKIIwJz3WAABAGJIXKDY/0BIV5CBEAIoVIhUAhAAdWeESIz3CAAMgGAJAB
-3iEKAQDPcIAAygZAkM9wgAAopBqQDQoBAMSlANg98ASJHejPcIAAwAYAgJfoz3CAAESkLYDPcIAA
-lAYAgF4Kb/04YIvoiiBMDWINr/SKIU0CANjQ/wHYH/DEpQHYHfAEhQDeNwhRACKFz3OAAGwQRIEF
-gRzhSKMJo2iFz3CAACikGpB2eSSJXgqv9MlzxKUD2AOlAdgRB4/0CiHAD+tyBdiKI80KmHZNBK/z
-uHPgeM9wgADMNiCAHNrPc4AAEAZAoUKDVSLBCSGgoBIBAK25oBpAAFUjwQWkGkAAnBIBAWiDJKBV
-IkENI6AA2eoaRABAIgEHdnkliRkJEQjPcYAAyAYgkUh0gCREEyCsHtsD8BjbYqBVIkENeWGJB2/4
-JaDPcYAAUDJAIQADVSHCBREIhQAA2QQYUAD7CISA4H7gePHA8g2P9M9wgADgoN4QAwZKIAAgguPK
-IcYPyiLGB8ogZgHKI4YPAADTB8okBgSIA6bzyiXGAM9ygAAQBkiChCsGDydwVningI8JEQDPcIAA
-tDLqDq/0iiEPD89wgABsMtoOr/Qg2c9wpQAIDACAUyBAgBLyJQhQACcIkAAKIcAP63IF2IojXwwK
-JAAEKQOv8wolAAT/2Qfw/9kIuQPw/9kQuc9yoAC0Rx4aWIAdGhiAGxpYgwDZkbnPcKAA0BsxoM9w
-gAAABBB4SRoYgG8gQwBUGhiAMvDPc6AAtEcbEwCGDegKIcAP63IbEwWGBdgA24u7xQKv8wokAARL
-GxiEAdh3GxiAANieuFQbGICKJMN/z3OAAMRmCnCoIAAECmPPdYAAUDLPcYAAtDJVfUeF8CEBAAHg
-WWEnpR0Fj/TxwLoMr/SKIAwKo8HPdYAAEAYkhRoLr/QA3gSFpuiSDEAAAdgEpQKFBIiA4EICAQDP
-cIAAwAYAgIDgNgICAM9woAAsIAOAz3KAAESkLYIZYc9wgACQBgCAOGAaDe/9DKKA4A4CAQBy8ASF
-eQiRAA6FgODKIcEPyiLBB8ogYQHKI4EPAACVA8okgQPwAaHzyiXBAEKFKIVAIgAHNngmiGDBJogB
-HEIwJogCHEIwJ4hhwSeIBRxCMAeIi3EGHAIwSg7v9KgSAADPcKAALCAjgM9wgABQMiGgxaVX/wPY
-BKXJ8ASFbwjRAEKFKIVAIgAHNngFiCcIXgEDks9xoAAsICOBz3OAAFAyYYMKuGJ5CwkEAAnYD6WF
-8AWFjOgEioDgqfLPcIAARKRODO/9DICA4KHyBYUG6AXYD6UB2Anwz3CAAMAGAICA4JX0ANj0/pHw
-BIXVCFEAVP8ihUiFQCEAB1Z4RYgzCh4Ag7pFqM9ygABMfMeCz3OAAESkx6P3gsOC/mbIo/aCwoL+
-ZsmjwYJVgl5myqMFiFkIXgBKC4/9gODKIcEPyiLBB8ogYQHKI4EPAADnA8okIQDEAKHzyiUBAT4L
-r/0C2G4Lr/0I2CKFBIkXCJEAAdgApQDYE6VaC6/9WtgihQSJCQhRAAHYAaUIhRzhFnkFiYYg/4zK
-IIIPAAAwQ8QM4v/KISIAAoUohRzgNngFiIYg/ocF8gLYBKUp8ATYBKUn8CSFAdhHCREBFKXPd6AA
-yB88h89wgABQMiGg8giv9IogDArPcIAAUDIM2XXaHtt+DK/0GLsVh89xgACYBu4NL/0ggQelxKUE
-2AOlAdixAq/0o8DgePHAPgqP9M91gAAQBgSFzQgRAAKFBIgS6M9wgADABgCAjOjPcIAARKTSCu/9
-DIAG6ADYnP4TAwAAz3agAMgfPIbPcIAAUDIBgEiFAnkChVZ4B4APCQQAAdgEpe8CAAAAhQnoEwte
-QALYFR4YkE4Kr/0e2BWGz3WAABAGSgvv/SeFgODGAgEAFYbPcYAAmAZKDS/9IIEHpQKFKIUc4DZ4
-BYiGIP+MCPLPcAAAMEPPcYAAbDLn/gKFKIUc4DZ4BYhRIECAhgIBAACFBegfhoDgegICAOT8cwIA
-AASFgeCH9CSF1g9v9IogTArPcaAALCAjgcYPb/SKIEwKAoUohRzgNngFEIYAAN7UpXkOHgDPcoAA
-UDLPcIAATHx2gCKAeWHPc4AARKTpg9iqVBAEAAQQBQAAJQUBKBMEAOJ5AiUFAeeDHBAEAAIkxINo
-gwOAYnjKJ4ETBPIB3/iqDelALIMADQnEAE8ngBAF8AXoTydAEA9/GKpBKcAAOGAJCEUBgr/4qk8O
-XgAAhQ7oz3GgACwgJoEThSJ4z3GAAFAyBaHApQXwAYUD6MGlr/y6Do/9HQiQAAohwA/rcgXYiiOT
-BUokAABBBm/zCiUAAboIr/0A2AKFKIUc4DZ4BYiGIP+MBPIC2ASls/AE2ASlr/AEhRcIkQDPcAAA
-MEPPcYAAbDKU/gTYBKUEhYTgpPQkha4Ob/SKIEwKz3CgACwgI4DPcIAAUDJAIBAHN6CSDm/0iiCM
-DSKFIBUEEEAhAAcWIAABBYgA3j0IHgBKJMBwyXLJc6gggAHwIMAgAeMaYgPfSiRAcQDbqCCAAfAg
-wCMB5xtjEQrFAM9ygABQMhiKgrgYqs9wgABEpM+gTJFAJEAAEQilAAilbREABg0IXgAB2BClAf5V
-8A+FrPwPyAQggA////8DDxoYMM+lDP2KIEwN/g1v9Ioh1AYIhSKFFnmKIEwN6g1v9CeBAtgDpQKF
-z3KAAMAGJIiO6SiFHOA2eCSIz3CAALSHFogQcQHYwHgAoibwIIIF6QHYA6Ug8CiFNngngM9wgABE
-pC2gz3CAADCfQYDPcIAAqJ4FgAUovgBAKYByEHHKIcYPyiLGB8ojhg8AADEFgAbm/wXYxKVdB2/0
-AdgKIcAP63IF2IojFA9KJIAApQRv87hz4HjxwN4OT/TPdYAAEAYEhaHBgQgRACSFPg1v9IogjAoB
-3s9wgADABsCgANgUpSqFAaUApQLanenPcIAAtIfPd4AAyAbgl3aIJwvBA893gADKBuCXdIgXC8ED
-cojPcIAAzAYAiAsLAQBEpQPwyqXJcSMJUQBeDa/zAtjPcoAAtIcUijaKQIIKCm/0AdvEpZrwRKUE
-hRUIUQAkhboMb/SKIIwKAtgEpQSFZQiRACSFpgxv9IogjArPcYAAyAaKIIwMlgxv9CCRz3GAAMoG
-iiDMDIYMb/QgkQKFBIgW6AuFlOjPcoAARKQwgg+CDiGDDwcAIKERCwUAB9gPpQHYEKULpQTwOGAP
-ogPYXfAEhSMI0QAkhUIMb/SKIIwKD8gEIIAP////Aw8aGDAE2EvwBIU9CBEBJIUiDG/0iiCMClMg
-wECWDSAAHKXPcIAA4KDeEAEGz3CAAJSihCkGDzAgQA5RIECABdjKIKEBLfAEhUMIUQHPdoAA4KDe
-FgAWBNmZ2h7bQMCLcHIPb/QYu94WABaEKAYPACGAf4AAVKIwgKG5MKAB2AulBtgEpQDYDfAEhRUI
-kQEG2AOlHIWA4MogYgAbeASlAdiFBW/0ocDPcIAAyJoogM9ygAAQBi94FwhRAADbz3CgALQPfKAC
-2AOiZKID8AHYBaJhA2/0iiDMCOB4z3CAAESkOYDPcoAAEAYveAsIUQAE2ASiA/AB2AWiOQNv9Iog
-zAjgeM9wgADImiiAz3KAABAGL3gLCFEAAtgEogPwAdgFohEDb/SKIMwI4HjxwJYMb/SKIEwN/gpv
-9Iohlw0PyADeBCCAD////wMPGhgw4gtv/8lwz3WAABAGFoWA4AwKYv/KIGIAyQRv9NWlAdnPcIAA
-EAYkoJkET//gePHAWghP/wIOD//GDk//0cDgfuB4OdnPcKUACAw+oOB+8cDhxQDdyglv/6lwWg8v
-/6lwOgiP/+4ND//PcIAAkAV5BG/0oKDgePHAz3GAAIQGAIERCIEPAIAAALYIT//Z8QCBIQiBDwBA
-AADPcaAAsB87gUYKb/SKIEwMYghP/8nxx/HgePHAwgtP9M91gACEBg3pAKUBhZTo+g1v8w7Yiguv
-/gjYAdgBpQrwAN7ApfoNb/MO2PoLr/4I2MGl9QNP9PHAz3AAACBOOg/v/OHFz3WAAIwGAKXPcAAA
-uAsBpc9wAACIEx4Pz/wCpc9wDwBAQhIPz/wDpQXYCg/v/Au4vQNv9ASl8cDPcIAAoAYDgJroqg1v
-8xXYlujPcIAAMHwHiBDoz3CAALgEYIDPcQEAFJ4L2GB7BNpeDW/zFdjRwOB+z3GAAGS4CYENCF8B
-xREABhMIXgGGCq/2E9iCCq/2Edju8e7x8cDaCm/0B9gWDQAAz3agALQP/IYacADYHKbPcaAALCAw
-gTIJb/SKIJEFLg0AAc91gACgBr4MIAEApUCFz3GAAMB9AaVFoT4LoAQGofymUg4gAApwEY1LCFEA
-QIWKIEQEz3WAAPw2I4UaYjhgEHIB2MIgDgAO6IogEQvaCG/0ANkeCCADBNgAhWIMIAEDpQfwHggg
-AwTYAoUDpeYOwAKhAk/04HjxwD4KT/TW/891gACgBpIPIAEHhQh2B4UXDgAQwgrgAMlwcgwv98el
-qgmv9hHYvgsAAc9woAAsIBCAcQJv9AKl8cChwe//z3CAAKAGAIAE2WLaHttAwItw9gtv9Bi7ocDR
-wOB+8cDhxc91gACgBhCNjCDDjw70z3CAAAw3JYAjgSCBx3EPAACgFgkP/f7YEK0hAk/08cDhxc91
-gACgBgaFG3jaDe/8IoUE6AHYEa2U/wECT/TxwP/Zz3CAAKAGMKjp//X/OPHgePHAcglP9Ah3fdgN
-uM9xgAConsWBsgvv/MlxjCACgM9xgACgBgDdh/cdeIwgAoAB5Xz3AChCAwUqvgMYGUAOFrgFoYTv
-/9gQqRCJjCDDj1APwf+JAU/04HjgfuB48cAaCU/0z3WAAPw2AoUjhQHeEHHAfqlwig1v9APZQg1P
-9ATuAoUD8ACFXQFv9AOl8cBKC2/zFdip/89xgABkuAmBDwhfAcURAAYNCF4BYgiv9hPYz3CAALwE
-IIBgeQvYsQXP//HAFgtv8xXYpQXv/wDY4HiA4AHZwHnPcIAAoAbgfyOg4H7geM9ygADABmGCZXgB
-ohDpz3GAALSHBJJ2iSsLAQAFknSJIwsBAAyKMokbCQEAD8gEIIAP/v//Aw8aGDAPyIe4DxoYMOB+
-z3KAALSHz3GAAMAGBJF2ihkLAQAFkXSKEQsBAAyJUooJCgEAAYED8ADY4H7PcoAAwAYhggZ54H8h
-ouB4z3GAAMAGAIEJ6AGBi+gPyAUggA8BAAD8A/APyJC4DxoYMM0HD/zgePHAz3CAALy1AIBXCF8A
-Ugpv8xDYo+jPcoAAtIfPcYAAwAYEkXaKJwsBAAWRdIofCwEADIlSihcKAQABgYvoD8gFIIAPAQAA
-/APwD8iQuA8aGDB2Dw/80cDgfuD//fH98Q/IkLgPGhgwXQcP/PHAqgnAAgjoz3CAAKwIAIAPCJEB
-z3CAAMAGAICD6ADYAvAB2OPx4HjxwEIPD/QIdwQikw8ABgAATCMAoAHdwH0EIoAPQAAAANdwQAAA
-AEoiQCDPdoAAdKUYjsIigiQacRENARCE7RmOCQiBBADYA/AB2C8hByDpcEoL4ACpcSCGANgRD0EQ
-IYYSccwhIaAD8gHYLyYH8BquOfIA2c9woAC0Dzyg5g9P/ulwCnGpcjoLoAFKc6YLIACpcNL/huiu
-DwAAugpP/QTw4gpP/V4PQAQBhs91gADABgS1AIYFtRiODK2GD2AESnAElc9ygABsECWVFLIIgoDh
-0CAhAM8gIgC5uLq4BSDABAiiuQYP9OB48cBmDg/0z3WgALQPcBUQEM9wgABsEAmAosEA3hkIXgEK
-IcAP63IF2JXbiiTDD/0DL/O4dot36XC+Cm/0Atncpc9xqwCg/9mhB9gaodihABQAMQIUATFEIAIC
-QiICgkEowwDKImIAwLhuCqABwLsAFAAxhiD/DUIgAILSCiAAyiBiAHAdABRBxulwCg9v9AjZOQYv
-9KLA4HgA2c9wgAB0pSGgEQAv9yKg4cXhxs9xoADIHMiBCKEG3RHw4HjgeOB44HjgeOB44HjgeOB4
-4HjgeOB44HjgeOB44HhhvYwl/5/t9clwwcbgf8HF4HjPcqwA1AEA2a0aWICoGliAWNvPcIAAMHzo
-GsCAAJCH4MwgIoID8uwawICBGtgAgNuCGtgABduDGtgAc9u+GtiAdNsIGsCAGBpAgL8a2IB32wwa
-wIAD2xwawIAH27wa2IAAGsCAf9sQGkCAvRrYgAQawIAUGkCAqhpYgKsaWIAB26waWICTGtiAKdvw
-GsCAqtt1GtgACtt2GtgAeNvUGkCAmBrYgCfbmRrYgCDbmhrYgIfgAdvAe4jgAdjAeAUg/oAE8gLY
-mxoYgH4aWAB/GlgAgBpYAOB+4HjPcAAAAT/PcaoA8EMFoc9wAAA+PQahz3IAAD09R6GKIMwPCKEJ
-2Iy4CaHPcAAAFhwKoc9wAAAfHwuhz3AAABwWDKGR2AS4DaHPcAAAAz8OoU+hz3AAAD0+EKGKIMQP
-EaHgfuB44cXPcaAAyBwIoQbdEfDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/
-n+314H/BxeB48cACDC/0B9gA34//GnCf/892pAC4PawWABbPdaUA2MuiuKweGBAB2Oyl9h4YEM9w
-FQArK5oeGBDOCiAA6XCKIMQAnx4YEM9wgAAwfACQAdmH4MB5iOAB2MB4BSB+gBPyGtjzHhgQ9B4Y
-EGTYyB4YEKrYyR4YEGnYzB4YEMDYzR4YEDnZz3ClAAgMPqC1/wpwzf8Y2JUeGBDPcYAA/DbhocjY
-AqEAoQOhz3EBACSez3CAABgr1BhAAJTYC6WpAw/08cDPcIAAbJiCDC/0iiEEDs9wgAC0h3YML/SK
-IQUF0cDgfuB4z3KAADB8J4qD6SaKCenPcawAkAGA4APYyiChAAWh4H7xwOHFCHUgkAKVQZUQuAV6
-KdgSuBUgQQBAoSCV8CBBAB0KQABSCS/0iiDRAwKVIZUQuAV5Qgkv9Iog0QM9Aw/08cDhxQh1IJAC
-lUGVELgFehXYE7gVIEEAQKEglfAgQQAdCkAAEgkv9Iog0QMClSGVELgFeQIJL/SKINED/QIP9PHA
-4cUIdSCQApVBlRC4BXor2BK4FSBBAEChIJXwIEEAHQpAANIIL/SKINEDApUhlRC4BXnCCC/0iiDR
-A70CD/TxwEYKD/QodoDgzCYikA30CiHAD+tyBdiKI4YAiiTDD+EH7/K4c1MmfpDKIcIPyiLCB8oj
-gg8AAIQByiBiAfD1QYAghqKAWHlAgCR9KdkSuRUhggCgogCA8CEBABcNQBBWCC/0iiDRA4og0QNK
-CC/0qXFBAi/0BG7xwM4JD/QodoDgzCYikA30CiHAD+tyBdiKIwYKiiTDD2kH7/K4c1MmfpDKIcIP
-yiLCB8ojgg8AAKoByiBiAfD1QYAghqKAWHlAgCR9FdkTuRUhggCgogCA8CEBABcNQBDeD+/ziiDR
-A4og0QPSD+/zqXHJAS/0BG7xwFYJD/QbCHQASHUIdkCFYb5gegRtCHH3DnWQEOWlAQ/04HjxwOHF
-iiBSDpoP7/N02c91gAAkN6lwQCWBFZIOL/QW2gHYhQEv9DEdAhDgePHA/ggP9Ah2guDKIcYPyiLG
-B8ogZgHKI4YPAABPAMokJgCgBubyyiXGAM91gAAkNwuFACaPH4AAQDcLDgEQFI846AIL7/8F2Bpw
-iiASDioP7/PJcUQuvhUAJUAeQJAhkAi6RXnPcqQAuD2bGlgAIpDKGlgAI5DLGlgAJJDEGlgAJZDG
-GlgAJpDHGlgAJ5DCGlgAKJDDGlgAKZDFGlgACpCjGhgAHgzv/wpwy6UA2BSvsQAP9PHA4cWmwYog
-kg26Du/zhdmLcMoML/QG2QAUADGT6EAkgDDPdYAAJDepcaINL/QW2gHYMB0CEAuFgOAUD+H/yiAh
-AAAUADEzCFEAiiDSDXYO7/OW2UAkgDDPdYAAJDdAJYEVag0v9BbaAdgrhTEdAhCB4dwOwf8iDA/0
-TQAv9KbA8cDOD+/zCHMIdoYj/gNEuwh3hifxH0e/RCCBAzx5z3WAAKykLK0EIIQPAAAADEIsgAIU
-rQQmhB8AAAAwQiwAAxWtBCaEHwAAAEBTIb6AQiyAA7EdAhAN9AohwA/rcgXYS9uKJMMPKQXv8kol
-AAARjYHgzCAigMwgIoEG9FNpJXpOrU2tgOPMICKBBfJTa2V6Ta2A58wgIoEE8hNv5XgOrRNpJXgP
-rQ2NEK3aDi/3ANiFB+/z37XgeKTx4HjgfuB44H7geOB+4HjgfuB4o8HhxULBCRSBMEPCQcAZCTMB
-ANgRCVIAChSBMAkJUgAHCRIBAdgHFIIwBhSDMBELgAAiwTBzzCJCgAP0AdghxSENURAKFIEwI8MZ
-CcMACxSCMFBxzCOqgIT2gOLKIGkAGwhRAIohyQ/PcIAA0AYioIHl/9nKISIAI6DBxeB/o8CjwUDA
-QcEFFIEwANiB4ULCDfKC4Qfyg+EN9CHBANgPIEAAAxSBMA8gQAACFIEwDyBAAAYUgTAhCVAAEwmQ
-ACMJ0QAhwQPhDyBAAAMUgTAD4Q8gQAACFIEwA+EPIEAACRSBMCEJUQACFIEwCrlPIQIEAxSBMAy5
-JXohwQ65RXkleCDBFQlRAAcUgTAiwga5CLpFeSV44H+jwBEED/TxwOINz/MacM9wgACspBCIz3aA
-AHSlhiD/ATtoBYYOIECAz3GAADB8J4nKIGIAIek6joDhzCAhgBvyAN0M3xJtFXjHcIAAzD4ggAXp
-AoAW6EB4Yb/rD3WQAeUA2Bquz3CAAKykEIiGIP8BQ7gFpnoM7/8KcNEFz/MKIcAP63IF2C3bSiRA
-ACED7/K4c/HAABaFQKbBDQ0zBQAcQjEXDRMCCiHAD+tyBdh62/0C7/JKJEAAABaAQAEcAjAAFoBA
-AhwCMAAWgEADHAIwi3BqDuAAgcECwovqCiHAD+tyBdiE24okww/BAu/yuHMEwGB6BcEDwYDhyiHB
-D8oiwQfKI4EPAACIAAXY7vMBwIDg4iBCAB4JD/SmwNHA4H7geOB+4HjxwL4Mz/M6cBt9z3CmAJw/
-ZBAQAE8IHyAD3hLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhvowm/5/u9WG9jCX/
-n+H1CiHAD+tyEthM2wokQAQtAu/yCiUABL0Ez/PgeADYz3GsANQB+BkAgPwZAIAAoaUZGICmGRiA
-pxkYgKIZGICjGRiApBkYgJ8ZGICgGRiAoRkYgM9ygADgBgCCixkYgAGCjBkYgLERAIaDuLEZGICy
-EQCGg7iyGRiAsxEAhoO4sxkYgOB+8cDhxQDdz3CAACgFoKjPcKcAmEe6oOH/AguAAM9wpwAUSKig
-SQTP8/HA0gvP8891gADgBgKFLwgfAP4Nr/8H2DoIYAAIduYJQAAiC0AAYgtAABoJQABiD6//yXAC
-hYC4AqUFBM/z4HjxwOHFz3WAAOAGAoUbCF8AAg2AAFoND/TmDkADAg3AAAKFgbgCpeEDz/PgePHA
-ZgvP8891gADgBgKFWwifAM9wgAAwfAeIJ+jPc6AAwC8TgwsInwYQgx8IHwD8EwUACiHAD+tyBdiK
-I0YN5QDv8ookAgFeDa//B9ieDOAACHZ6CMAAhgzAAMoOr//JcAKFgrgCpW0Dz/PgePHAz3OgAMAv
-E4MNCJ8GEIMdCB8A/BMFAAohwA/rcgXYiiNGDZEA7/KKJAIMv//P/89wgAAwfAeIBOgGCEAA1v/R
-wOB+z3GsANQBsREAhqO4sRkYgLIRAIajuLIZGICzEQCGo7izGRiAAtifGRiAoBkYgKEZGIAB2KIZ
-GICjGRiApBkYgKUZGICmGRiApxkYgAXY+BkAgPwZAIAAoeB+4HjPcKsAoP84gM9ygADgBiCiOYAA
-2yGieKB5oD/ZOqDgfvHALgrP8zpwAdjPdqcAFEgIpi4IoAAqcIDgAN8qcAb0SiBAI9j/CPCGCKAA
-Gnc+CqAAKnDr///Ym7jPdacAmEccpYogEg1mCO/zKnHPcYAAKAUAiYDgyiHCD8oiwgfKIGIByiOC
-DwAADQPKJCIAiAei8solAgEB2ACp9qYvIAAEgLgapQkCz/PxwOHFocG4cADYQMBTJYAAIQhQADsI
-kABFCBABCiHAD+tyBdiKI4sGRQev8ookgw/PcIAAMHwEkAHZz3WAAOuXhODAec9wAAAi0jR4DvDP
-cAAAI9LPdYAA7pcI8M9wAAAk0s91gADxlynZErnwIQEADiGADwABAABOCeAAQMBAwItwqXGmDu/z
-A9qdAe/zocDxwBoJz/PPcKYAnD8ZgKcIHgDPdoAAbBCEFgAQLygBAE4gkAdBKNAgEQjVIAAgjS+A
-ANwQFI2O6AohwA/rcgXYiiONAIokgw+VBq/yCiUABM93gADgl0AnwBIKCu/zCdkA2MYOYAAPIAAE
-gOAA2A8gAAQE9L//BPCaCIAAA8gA2bkQgAAbeIC4Cq8UjWG4D3gUrYogUg3+Dq/zDyEBBIQWARDP
-cIAArIg2oM9wgADguCKgHv/JAM/zz3EBADC4z3IBALy4BQBv9ADY4HjxwLhxiugKIcAP63IF2NTb
-AQav8ookgw/PcYAAkKUggUwlAIAEIYEPAAcAAEEpAwYA2cokTXHoIK0D8CBFAAQlgg8BAADALrpl
-eg0LgQAB4U0Fz/8KIcAP63IF2N3btQWv8kokQADgeM9wgABsEAiAz3GAAJClCwgeAAGJAvACieB/
-AKkIcViJAYACoYjqWYmA4sIgogDAIKEAAqHgfuB48cCyD4/zosGigWCQz3aAAOAGuHujgWR9Y4al
-e6aBAZC4eKeBY6akeKSGQCEPBKV4BKYd6gGBAhzEMDC7BBzEMAAcBDAggYt1YHmpcAGHJIYCHEQw
-MLkEHEQwIIcAHAQwYHmpcADYA6YEprEHr/OiwPHALg+P86HBABaNQAAWj0AAFgBBbgmv/wfYGnCC
-5QbZA/T7eQfhBcwD4QQhgQ8AAPz/13AAAABAAdjCIAoAF7jHcAAOAAAleJ24n7jscQChAhIBNuxw
-IKDscKCoz3agAMgfURYRlgHZUR5YkCDYEKZDHlgQANi+Cu/zjbgg2BGmh+WQAQ0AMiZNc4AAxGdA
-J4BytHgAeAAWAUAAFgBAgLnPcKAA7CcmoKbwgOdIAQ4AABYAQQAWAUEAHEQwABYBQAILIABhvwAU
-ATEGuIG4ELkleM9xoADsJwah2Q9VkIzw7HDgqIDnEAEOAAAWAEAAFgFA0gogABB4BrhFIMIAz3Cg
-AOwnRqAKgItxALEAFAEx7HAgsGG/1w9VkG7wABYAQCIOAADPcaAA7CcLoQAWAEBi8MUPVBAAFgBA
-ABYUQEEoEwQQeH4KIABacAa4RSDAAM91oADsJwalCoWLcQCxABQAMQYgwAQFIAAFABwEMFYKIABK
-cAAUATEGuIG4ELkleAalYb+zD1WQNvBtD1QQABYAQQAWAUEAHEQwABYBQCYKIABhvwAUATEGuEUg
-gAEQuSV4z3GgAOwnBqHXD1WQHPA1D1QQABYAQQAWAUEAHEQwABYBQO4JIABhvwAUATEGuEUgwAEQ
-uSV4z3GgAOwnBqHVD1WQUR5YlAoJr/8KcGYJ7/MB2ADYdB4YkHkFr/OhwAohwA/rcgXYiiOGAUok
-AADhAq/yCiUAAfHADg2P8wAWjUAAFpBAABYAQUoPb/8H2DpwguUG2QT0QCDBIQXMA+EEIYEPAAD8
-/9dwAAAAQAHYwiAKABe4x3AADgAAJXiduJ+47HEAoQISATbscCCg7HCgqM92oADIH1EWEpYB2FEe
-GJAg3/CmQx4YEADYlgjv84248abHDZURMyZNc4AAzGdAJwBytHgAeAAWAUDPcKAA7CcmoEnwkwhU
-IAokAHSoIEACABYBQM9woADsJyagPfDscAAYAgRzCFQgCiQAdKggAAMAFgFAz3CgAOwnJqAqgOxw
-IKgp8AAWAUDPcKAA7CcroCPwTCAAoMokDXToIG0HABYDQAQjgQ8AAAD/KLlWaUUizQDPcaAA7CcE
-I4AP/wAAAKahqoEwuDi7gboGfaV7ELtlekahUR6YlKoPb/8qcAII7/MB2C0Ej/MKIcAP63IF2Ioj
-SANKJAAAiQGv8golAAHgeALYz3GsANQBnxkYgKAZGIChGRiAAdiiGRiAoxkYgKQZGIClGRiAphkY
-gKcZGIAF2PgZAID8GQCAAKHgfuB+4HgB2c9woADIHDCgS9nPcKQAHEAkoOB+4HjxwFILj/M6cBpx
-SiNAIMCQJPDpdiLwFSHAJOCQAhASAUAjUyDXdwAA+/8vI8gkc/Y/DoAfAAD//0wgAKDMJoGfAAD+
-/xXyTCBAoMwmgZ8AAP3/D/ITCJAgz3AAAPv/uw4BkEUDj/P1DoGfAAD8/891oADIH1EVFJYB2VEd
-WJAg2BClQx1YEADYzg6v8424INgRpQa/gb9AKgAk5XjPcaAA7CcGoVEdGJXY8eB48cDPcIAAMHxG
-gCqQDQqRAM9wgABkOwXwz3CAAHg3zv+eDAAATg0AANHA4H7xwOHFz3GAADB8BJHPcoAAkKUA22Ci
-EuhRCFAAfwiQAAohwA/rcgXYiiNLB0okQAAdAK/ySiUAAAfYGLgAomGqYqpKJMBwaHCoIMACANuO
-uxYiDQBhpQPbDrtipQHgA9gGsQexANgY8ADYmbgAolLYAapKJMBwAqqoIEACAN2PvRYiwAChoKKg
-AeNS2ALbZrEB22excQKv8wCqANiYuEokwHAAoqggQAIA3Y69FiLAAKGgoqAB42HYAapS2AKq6PHx
-wFILYAChwc9wgAAwfEeIgOIA2Y7yABxEMM9zoADALzODDQmfBjCDHQkfAPwTBQAKIcAP63IF2Ioj
-Rg1RB2/yiiTLDAPbz3KgAOwnZqJqgotxYLEAFAUxqHSEJAOQyiHCD8oiwgfKIGIByiOCDwAA+gIc
-B2LyyiRiAEQlAwxEu2SwRCUDA0K7LybH8GuoBPQB22uoQ9tmomqCYLEAFAUxFBhEAUwlAIDMJWKA
-zCWigMohwg/KIsIHyiBiAcojgg8AAA4DyAZi8sokYgCD22aiaoJgsQAUBTFTJYMAaLCH48wjIoDM
-I6KByiHCD8oiwgfKIGIByiOCDwAAGAOQBmLyyiRiAIoj0gBmokqCQLEAFAUxUyWBACmwIQnQAQoh
-wA/rcgXYiiPMB2UGb/JKJEAAJLAH2SiwKbChwNHA4H7gePHAz3CAADB8BoAS6C8IUAAvCJAACiHA
-D+tyBdiKI40ASiQAACkGb/IKJQABgNnPcIAAkKXJBe//J6AA2fnxQNn38eB48cDPcIAAMHwEkBLo
-geDMIKKAEvIKIcAP63IF2IojTglKJEAA5QVv8kolAADPcSoVFSoF8M9xKioVFc9wgAAsBXkF7/8g
-oOB48cDPcYAAMHwkkYsJEAAjCVAAYwmQAAohwA/rcgXYiiPPBUokQACdBW/ySiUAAAQggQ/z///P
-BCGADwMAAAACuAUhAgAEIYEPAAAADAQggA8AAAAMJXjPcYAAbBAogQK4RXgzCR8AByCADw8AAAAF
-Bc//z3GAAGwQKIEbCR8ABCC+jwwAAADSIKIE6ATi/9Ig4gThBM//4HgA2c9woADsJyug4H7gfuB4
-8cBaD0/zz3egAKwvGIfPdaAAyB+auBinINgQpQXYQx0YEADYJguv8424INgRpQPeEfDgeOB44Hjg
-eOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG+jCb/n+31GIezuLq4GKcg2BClZNhDHRgQANjeCq/z
-jbgg2BGlSQdP8/HA2g5P8wh3z3WgAMgfURUQlgHYUR0YkCDe0KVDHRgQANiuCq/zjbjRpSCXAZcG
-uYG5ELgleM9xoADsJwahUR0YlP0GT/PgePHAlg5P8891oADALxOFz3agAMgfIN+zuLq4E6Vk2PCm
-Qx4YEADYYgqv84248abwpgXYQx4YEADYTgqv84248aYThQ0InwYQhR0IHwD8FQUQCiHAD+tyBdiK
-I0YN+QNv8ookzQY+C4//NgwP/wTIGwgRAc9xgABkuEiBNJFTIgAAxglv8wHbeQZP8+B4iiBXB3kE
-b/OKIQ0D8cD+DW/zAdjPdaAAyB9RFQ+WUR0YkCDe0KVDHRgQANjOCa/zjbjRpc9xgAAGIc9woADs
-Jyagz3GAAEY6JqDPcYAAxlMmoM9xgADGJCagz3GAAAY+JqDPcYAAhlcmoFEd2JPPcacAiEkA2BCh
-+QVP889wgAAHIc9xoADsJwahz3CAAEc6BqHPcIAAx1MGoc9wgADHJAahz3CAAAc+BqHPcIAAh1cG
-oUnZz3CnAIhJMKDgfuB48cBGDW/zAdjPdqAAyB9RFhCWUR4YkCDdsKZDHhgQANgaCa/zjbixpsfY
-lLjPd6AA7CcGp89wAwCCKwanz3ADAMJEBqfPcAMAQl4Gp89wAwACLAanz3ADAEJFBqfPcAMAwl4G
-p89xAADCdM9wAwDCdAanz3ADAIJvBqfPcAMAgmwGp8bYkLgGpyansKYK2EMeGBAA2KYIr/ONuLGm
-z3AAAIJvBqewpgrYQx4YEADYjgiv8424sabPcAAAgmwGp7CmCthDHhgQANhyCK/zjbixps9wAAAC
-LAansKYK2EMeGBAA2FoIr/ONuLGmz3AAAEJFBqewpgrYQx4YEADYPgiv8424sabPcAAAwl4Gp7Cm
-CthDHhgQANgmCK/zjbixps9wAACCKwansKYK2EMeGBAA2AoIr/ONuLGmz3AAAMJEBqewpgrYQx4Y
-EADY8g9v8424sabPcAAAQl4Gp7CmCthDHhgQANjWD2/zjbixps9wEwDGAAansKYy2EMeGBAA2L4P
-b/ONuLGmUR4YlCEET/PgeM9ygAD0BhkIHgCA4VHYwCgiBMogYQTAKCEEA/AA2OB/AKLgePHAlgtv
-8wHYz3WgAMgfURUPllEdGJAg3tClQx0YEADYZg9v84240aXPcAAAwizPcaAA7CcGoc9wAAACRgah
-z3AAAMJfBqFRHdiTtQNP8+B48cBGC0/zz3GgAKwvOoFSIQEAfQkfAB7oIN15/892oADIH1EWD5YB
-2FEeGJCwpkMeGBAA2AIPb/ONuLGmz3EGAAJ1z3CgAOwnJqBRHtiTBPACCI//z3agAMgfURYPlgHY
-UR4YkCDdsKZDHhgQANjKDm/zjbixps9wgABsEA+Az3GgAOwngLgGoVEe2JMhA0/z8cCyCm/zAdnP
-daAA7Ccmpc9yoACsL5PoGILPdaAAyB8g3pq4GKIF2NClQx0YEADYdg5v84240aU/8BWCUSAAgMoh
-wQ/KIsEHyiBhAcojIQ/KJMEAIABh8solwQDPcMAAR2gGpc9wEwDHAAalz3AQAAZpBqUg38fYlbgG
-pc92oADIH1EWEJZRHliQ8KZDHlgQANgWDm/zjbjxps9wAABCLQalz3AAAIJGBqXPcAAAQmAGpVEe
-GJRhAk/z4HjxwNhwUyCBAM9wgAA4YyhgHQhQAAohwA/rcgXYiiOFD4okgw+VBy/yCiWAAc9xgAAw
-fAgRBQEbDRAACiHAD+tyBdiKIwYAdQcv8ookgw/PcIAAbBAIgBcIHwAIkQXoDwiRAQsOHgAA2ALw
-AdjRwOB+uHDCuPHAIQhQAEkIkABxCBABCiHAD+tyBdj/2y0HL/KKJIMPz3CAAGwQCIDPcaAA7CdR
-IACAyiCCDwMABiHKIIEPAwDGJAahz3AEAEZLLfDPcIAAbBAIgM9xoADsJ1EgAIDKIIIPAwBGOsog
-gQ8DAAY+BqHPcAQAxmQX8M9wgABsEAiAz3GgAOwnUSAAgMoggg8DAMZTyiCBDwMAhlcGoc9wBADG
-MQahqvHgePHA3ghv8wHYz3agAMgfURYPllEeGJAg3bCmQx4YEADYrgxv8424sabPcIAAxyDPcaAA
-7CcGoc9wgAAHOgahz3CAAIdTBqHPcIAAhyQGoc9wgADHPQahz3CAAEdXBqGKIIoABqGKIIsABqGK
-IIwABqHPcCQABwEGoYoghQAGoc9wAwAHIQahz3ADAMckBqHPcAQAR0sGoc9wAwBHOgahz3ADAAc+
-BqHPcAQAx2QGoc9wAwDHUwahz3ADAIdXBqHPcAQAxzEGoVEe2JN9AE/z4HjxwKHBz3GAAGwQKIEv
-KAEAwLkAIYMPAAAi0k4ggQcp2BK48CDAAM9ygADrlzR5WWFAwItwVg1v8wPaocDRwOB+8cDGDw/z
-GnDPdaAAyB9RFRGWAd5RHZiTIN/wpUMdmBMA2J4Lb/ONuPGlz3AsAAYBz3GgAOwnBqFTIIAgJQhQ
-AFkIkACPCBABCiHAD+tyBdiKI8UMiiSDDzUFL/IKJQAEz3CAAGwQCIBRIACAyiCCD4AAxiDKIIEP
-gACGJAahz3ADAMICBqHPcEgAQgEGoc9wpwAUSNegO/DPcIAAbBAIgFEgAIDKIIIPgAAGOsoggQ+A
-AMY9BqHPcAMAAgMGoc9wSgBCAQahAtnPcKcAFEg3oB3wz3CAAGwQCIBRIACAyiCCD4AAhlPKIIEP
-gABGVwahz3ADAIICBqHPcEwAQgEGoc9xpwAUSADYF6FRHViUGQcP8+B4gLjPcaAA7CcGoeB+Cdng
-fyCg4HjxwPoOb/Mo2AhxhiH8AyS5z3KAADB8ILJEIAEDIrkhssG4+QTv/wKy8cDhxc4Ob/MA2EEo
-AQLAuc91gAAwfCatKbjAuAettg5v81DYwbjRBi/zBqXgfuB48cBODi/zAdjPdqAAyB9RFg+WUR4Y
-kCDdsKZDHhgQANgeCm/zjbixps9wIAAGAc9xoADsJwahz3BwAIICBqFRHtiTdQYP8+B4z3EgAAcB
-z3CgAOwnJqDgfuB+4HjgfuB4z3CAAHA+4H8TgOB48cDeDQ/zCHcacQHZz3CnAJhHOqAg3s91oADI
-H9ClCthDHRgQANiuCW/zjbjRpc9xpwAUSAyBhOg+gQPwPYEAGEAg97nFIYIPAP8AANMh4QXxBS/z
-IKfgePHAhg0P889wgAAwfCaIgOHPdoAAcD7OAiEAosEHiIDgwgIBAIogkQXWCy/zANmeD+/+BdgO
-psPYz3WgAOwnBqUKhc93pwAUSAC2iiDEAAalCoXPcacAmEcBtoogxQAGpQqFAraKIMsABqUKhQO2
-iiDPAAalCoUEts9wAACDDQalCoUFts9wAADDDQalCoUGts9wAAADDgalCoUHtgiHBKYNhwWmDocG
-phyBB6YXhwimFocJps9wpQAIDAKACqbPcKsAoP8YgAumz3CrAKD/GYAMps9wqwCg/xqADabPcAUA
-xgMGpcbYkLgGpc9wLAACAQalz3BaAEIBBqWKIIsABqXPcEAAhw0Gpc9w0QDCDQalz3DAAAcOBqUB
-2AinANgNpw6nz3BQAP8AHKEB2BenANgWp89wpQAIDFDZIqD82M9xqwCg/xihc9gZoRqBgbgaoc9w
-EQAGDgali3CBwZP/NYYAwCJ4hCiEAxSGNoYCeZIOr/svcAHCgiDEAs9xgAAAixahEqbPcKAAyB9V
-oVEQEIYB2VEYWIAg2M9xoADIHxChAdhDGRgAANjSDy/zjbgg2c9woADIHzGgz3BAAIYNBqXPcBAA
-Ag4Gpc9woADIH1EYGISLcIHBdf81hgDAIngEKIAPAAB0CRSGNoYCeRIOr/svcAHCT+DPcYAAAIsY
-oROmV6HPcKAAyB9REBCGAdlRGFiAINkwoAHZQxhYAADYXg8v8424INnPcKAAyB8xoAGWELiFIIQA
-BqUClhC4hSCFAAalA5YQuIUgiwAGpQSWELiFII8ABqUFlhC4BSCADwAAgg0GpQaWELgFIIAPAADC
-DQalB5YQuAUggA8AAAIOBqXPcKAAyB9RGBiEBIYqhginBYYNpwaGDqcIhhenCYYWp89wpQAIDCKg
-DOkEEgQ2AhIFNgohwA/rcgXYkQAv8vvbC4bPcasAoP8YoQyGGaENhhqheg7v/g6GiiDRBSIJL/My
-hhKGBQMv86LA4HjgfwHY8cCSCg/zz3CAADB8B4iA4JoCIQCiwc9woADIH1EQEIYB2VEYWIAg2TCg
-AdlDGFgAANhaDi/zjbgg2c9woADIHzGgmgzv/gXYz3WAAHA+DqXD2M92oADsJwamCobPd6cAFEgA
-tYogxAAGpgqGAbWKIMUABqYKhgK1iiDLAAamCoYDtYogzwAGpgqGBLXPcAAAgw0GpgqGBbXPcAAA
-ww0GpgqGBrXPcAAAAw4GpgqGB7UIhwSlDYcFpQ6HBqXPcKcAmEc8gCelN4copTaHKaXPcaUACAwi
-gSqlz3GrAKD/OIErpc9xqwCg/zmBLKXPcasAoP86gS2lz3EFAMYDJqbG2ZC5JqbPcSwAAgEmps9x
-WgBCASamiiGLACamz3FAAIcNJqbPcdEAwg0mps9xwAAHDiamAdkopwDZLacup89xUAD/ADygAdgX
-pwDYFqdQ2c9wpQAIDCKg/NnPcKsAoP84oHPZOaAagM9xqwCg/4G4GqHPcCoAAg4GpotwgcHP/gDB
-z3CAAACLNKUyoAHBL6DPcBoAAg4GpotwgcHI/gDBz3CAAACLNaUzoAHBMKDPcCYAAg4GpotwgcHA
-/gDBz3CAAACLNKA2pQHBMaDPcKAAyB9REBGGAdlRGFiAINkwoAHZQxhYAADYpgwv8424INnPcKAA
-yB8xoAGVELiFIIQABqYClRC4hSCFAAamA5UQuIUgiwAGpgSVELiFII8ABqYFlRC4BSCADwAAgg0G
-pgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqbPcKAAyB9RGFiEBIUqhQinBYUNpwaFDqcIhRen
-CYUWp89wpQAIDCKgDOkEEgQ2AhIFNgohwA/rcgXY2QXv8fvbC4XPcasAoP8YoQyFGaENhRqhwgvv
-/g6Fz3CgAMgfURgYhEkAL/OiwOB+4HihwfHA4g/v8phwz3CAAHSlEBAGAM9wgADMPgWAuHGA4KHB
-hiX3D4Tyz3KAAPgGBYIRCIEBBoINCAEBB4LxCEABABwAMSDDARSAMMO7UyDIAAIUgDBALsEAUyDJ
-AHhjFHg2eThgz3OAAPCqDmPJdYYl/R+7fXhg4YgFJYcT6XCGIP0PG3gFfwAgDhLUfj5m2GMCiH5m
-CHWGJf0fu33DjgUlCBDJcIYg/Q8beAV+ACFAEhR4GWE4YwSIO2MIdYYl/R+7fWWLpXhocYYh/Q87
-eSV7NQ0QAM91qgDgBzOFFwkeAOilJB3AEcqlLB0AEmylDaUY8CAdwBHppSgdABLLpQylbaUQ8Am/
-BSfBEc91pwAUSCOlCb4FJgESJKUJu2V4BaUUGoABGBoAARwaQAEI3CMH7/KhwACIAdtgoWi4ArgV
-eMdwgADMPkOAQ6FBgEGhQoBCoUSARKHgf2Cg4HjPcYAAvD/PcIAASD/gfyKgyQGP9eB+4HjPcAEA
-tM3PcYAAnCphGRgAz3ABAGDOVSFCB0AhAwMG6AiiG4GIuBuhz3ABAJDTBugdoxuBg7gboc9wAQCU
-1AboAqIbgYK4G6HPcAEAONUG6ACiG4GAuBuh4H7gePHAFg7v8kokAADPc6UACAwIEwUATCUAgMoh
-wg/KIsIHyiOCDwAAPAKsA+LxyiBiAUDYAqPPcIAAdKWggM9ygAC8P4okgXSIcagggAOELQIaL3Ae
-YvQmThDPd6YAAIA1fwHhwKfHcIAANEBWkM9xpACgP12hF5AeoQgbQAEBBs/y8cCSDc/ypcEIdyh2
-yg+v/gfYGnABhgzdBBwEMAQXARQGHEQwMLkIHEQwEBYBFGB5gcABhmG9DBwEMAEXgRQOHEQwMLkQ
-HEQwEBYBFGB5g8DjDVWQAgnv/gpwnQXv8qXA8cA2Dc/yz3CAAMw+AICA4JHyz3agAMgfURYPlgHY
-UR4YkCDdsKZDHhgQANj6CC/zjbixps9w0QBCLc9xoADsJwahz3DRAIJGBqHPcNEAQmAGoc9wgACs
-pFEe2JMQiIYg/wFDuClozwnVAc91gAB0pQSFMyZBcIAA1GdAJwJ1BrgUeDR6x3CAALClAHrPcYAA
-DEFQ8M9xgADcQRDgSvDPcYAArEIg4Ebwz3GAAAxBMOC8/wSFz3KAAPClz3GAANxBBrgUeDXwz3aA
-ADCmz3GAAAxBcOCz/wSFz3GAAKxCBrgUeNhgJvDPcYAA3EFQ4K3/z3KAABCmBIUW8M92gABQps9x
-gAAMQYAgAgSm/wSFz3GAANxBBrgUeNhgov8Ehc9ygABgpga4FHjPcYAArEJYYJz/bQTP8uB48cD+
-C+/yAdjPdaAAyB9RFQ+WUR0YkCDe0KVDHRgQANjOD+/yjbjRpc9ygAD4BgCKz3GgAOwnELgFIIAP
-AADCaQahAYoQuAUggA8AAAJqBqFRHdiTEQTP8vHApgvv8gHYz3WgAMgfURUPllEdGJAg3tClQx0Y
-EADYdg/v8o240aXPcIAA+AYikIa5ELkFIYIPAADCEs9xoADsJ0ahA5AQuAUggA8AAAITBqFRHdiT
-uQPP8uB48cBOC8/yz3WAAPgGyI0JjcK+wrgWfs9+sg8v/w3YBriBuBC+xXjPcaAA7CcGoQOFz3Gl
-AOgPBqEEhQehfQPP8vHACgvP8s92pQDoDyaGp4bPcIAA+AYA3yOgpKBuDy//DdgGuIG4z3GgAOwn
-BqHmpkUlzR+npj0Dz/LgePHAugrP8qLBOnAacQDdAg2v/gfYmnAC2alwWnB6cQDbNGgCcSh1FCEA
-IGhywoUEEA8F2H/DhQHixH/le/EK9IAg5QGBAhzEMDC7ABwEMCCBBBzEMGB5i3BCI0Egvwl1gEAi
-QCAqDq/+inClAu/yosDxwM9wgADMPg+AEOjPcIAAdKUEgM9xgAAMRM9ygADorAK4FHhYYNv/0cDg
-fvHAIgrP8s9wgADMPhSAgOCF8mIMr/4H2Hpwz3CAAKykEIiGIP8BQ7gpaIbh6AANAM92gAB0pUSG
-z3CAAGitMyZBcIAA3GdAIBALBLpUekAgEQpAIBIGQCAPCEAgDQRYYEAnAnI0egB6z3GAAGxEUfDP
-cYAAjEQE4Evwz3GAAKxECOBH8M9xgABsRAzg9gkv/wDaBIbPcYAAjEQEuBR4uGA38M9xgABsRBzg
-2gkv/wDaBIbPcYAArEQEuBR4+GAp8M9xgACMRBTgugkv/wDaBIbPcYAArEQEuBR4QnAZ8M9xgABs
-RCTgngkv/wDaBIbPcYAAjEQEuBR4InCKCS//ANoEhs9xgACsRAS4FHgCcHYJL/8B2t4Mr/5qcGEB
-z/LgePHACiUAgM9xgAD4BiARBAAi8s9ypAC4PQDbHwwRAJsSAAYJoaYSAAYKoZISAAYLoaMSAAYM
-oZsa2AD/2KYaGACSGhgAoxoYAAHaz3CgALQPXKAn8EwkAIDKIcEPyiLBB8ojgQ8AADAEaAah8cog
-YQEJgc9ypAC4PZsaGAAKgaYaGAALgZIaGAAMgaMaGAAEyM9yoAC0D4Yg/w4iuByiIBlAAR7xlQbP
-8pEGz/LgfuB48cBeCM/yosEIdyh2SHWWCq/+B9gpD3QQGnABhWG/ABwEMAQWARQCHEQwMLkEHEQw
-EBUBFGB5i3DjD1WQ5guv/gpwgQDv8qLAz3CAAHSlIIADgEQofgMAIYB/gADkZwTpDIgE8MQQgADg
-fuB48cDhxc91gAB0pSIIL/+pcLhwAIUR6EokgHPPc4AA5GcA2agggAJEKX4DMiNCDkMKQAEB4RPw
-ANlKJIB5z3KAAIxoqCBAA1kiQwVEKX4DJ3O4E4MAGwtAAQHhCiHAD+tyBdiKIwUFUQWv8UokgAIB
-AO/yKHDhxQbpz3KAANxFBfDPcoAAzESJ6wfpAdnPcKYApAA3oA/wSiRAdADZqCDAAhYiQAChgGCA
-KdgSuAHhdXigoOB/wcXgePHAOg+P8qHBGnAodkh1iiARBaINr/KKIckBiiARBZYNr/IKcYogEQWK
-Da/yyXGKIBEFgg2v8qlxz3CgACwgUIDPcYAALAdCoVCAYoFiekGhQCiDIUUjzwDPc6AA7Cfmo2qD
-i3JgskGBFQplAwAUDzHEf9kOwZMpB6/yocDPcIAAXA6qgM9wgAB0pQwQBAAKIcAPEL3rchC/BdiK
-IwkEBSREA10Er/EFJ4UT4HjxwI4Oj/Khwc9xgABcDgqBIN0B4Aqhz3CgAMgfURAQhgHZURhYgLCg
-QxhYAADYVgrv8o24z3CgAMgfsaDPcMAAR2jPdqAA7CcGps9xgABIPwSBKQhRAAaBz3eAAHSlQHgY
-F4UQLQ0RAM9wAQAGAQamz3ASAAYEFfAKIcAP63IF2IojRgNKJAAAyQOv8QolAAHPcAEABwEGps9w
-EgAHBAamABcEEM9zgADkZ89yAAACM89xAACCTAOHMQwQAEQofgMAIc1wxtiSuAamz3A5AAIzBqbP
-cDkAgkwGps9wOQACZgamx9iVuBLwViPNBUQofgMndcfYkrgGpkamJqbPcAAAAmYGpsbYlbgGpgfZ
-z3CnABRIK6AsoM9xqgDgBwHYE6EBh1mPqHGIc3r/z3AQAIdyBqYBjRC4BSCADwAAQnIGpgWNELgF
-IIAPAABCcAamBI0QuAUggA8AAIJwBqYDjRC4BSCADwAAwnAGpgKNELgFIIAPAAACcQamCY0QuAUg
-gA8AAEJxBqYIjRC4BSCADwAAgnEGpgeNELgFIIAPAADCcQamBo0QuAUggA8AAAJyBqYLjRC4BSCA
-DwAAgnMGpgqNELgFIIAPAADGcwamz3ABAEZqBqbPcKAAyB+kEA0Az3CAAAZ0BqbPcIAAB3QGps9w
-gADGcwamz3BAAEJ0BqbPcIAAx3MGps9wAgBGagamz3AQAMZqBqZYjwCPJI+A4gHawHqODWACeY8k
-2BjZM9pK/89wEADHagamz3AQAIZyBqb+CIACyg2AAiTYAdkz2kL/z3CgAMgfpBAAAM9xgABcDqJ4
-CaHPcAIAR2oGps9wZQDCbgamz3AAAMMJBqYKhotxALEAFAExgOHMIeKHMPR6Cq/yiiCRBM9xgAAs
-BwCRAeAAsQGRIwhRAM9wgABcDigQBAAAFAUxCiHAD+tyBdiVAa/xiiNIDCkIkQDPcIAAXA4oEAQA
-GQyUAAAUBTEKIcAP63IF2G0Br/GKI0gNz3CgAMgfURgYhNcEz//gePHAmguP8s91oADAL9OFDQ6f
-FtCFHQ4fEPwVBRAKIcAP63IF2IojRg0tAa/xiiQJCM91gAB0pQClIaVYrXmt2f4Dpc/+BKU6C2/4
-ANjPcIAAMHwHiIDgsAzC/60Dj/LgePHAtMGKIJgDogmv8gPZRgxgAItwiiCYA5IJr/IL2YogmAOK
-Ca/yEdm0wNHA4H7gePHA4cWhwYtxMgjv8gHaAMHPcIAA2LSA4cohgQ8AAEQABfKB4YjZyiEiDIC5
-IKgA3aioydklsALZIaj/2SGwpagg2SSoA9mSCyACKaipcDEDr/KhwPHAsgqv8gDZz3aAAJwqF4bP
-dYAAwK8PIQEAGYYkeEIgAIDKIGIAocEB3xcIUQDPcQAAQCwJ2JIJ7/RWJYIUN4YA2A8gQAA4hiR4
-QiAAgMogYgAA2SUIUQAJ2GDAARxCMAIcwjMDHMIzi3AE2VYlghSmCe/0iiMHDgDYoQKv8qHA8cC0
-wYogmAOeCK/yAtkmDKAAi3CKIJgDjgiv8gnZtMDRwOB+8cAOCq/yANnPdYAAnCoXhc92gABIsg8h
-AQAZhSR4QiAAgMogYgChwQHfFwhRAM9xAABALBDY7gjv9FUmwhg3hQDYDyBAADiFJHhCIACAyiBi
-AADZIwhRABDYYMABHEIwAhzCMwMcwjOLcATZVSbCGAIJ7/QocwDY/QGv8qHA4HjxwLTBiiCYA/oP
-b/IA2eoPoACLcIogmAPqD2/yENm0wNHA4H7xwOHFocGLcZYOr/IB2gDAz3GAANi0gODKIIEPAABE
-AAXygeCI2MogIgyAuACpAN2oqcnYBbEC2AGp/9gBsaWpINgEqQPY9gkgAgmpqXCVAa/yocDxwOHF
-ocGLcUIOr/IB2gAUBDDPdYAAuK7PcIAA7EapcRPa9grgAADbABQEMM9wgAA4B1UlwRQD2t4K4AAC
-289wgAAUR1YlwRIS2qIL4AAAwwDYPQGv8qHA8cDCCK/yANgIcZ4PoAAC2gHYANmSD6AAAtoC2ArZ
-ig+gAALaz3KAADgHhBIAAM91SwBLS89xgABYRxUiAwACgwKhBIPPdmgf/wCMGkADxKEDoaqhz3CA
-ADhHENo2CuAAANvNAK/yANjxwFoIj/Khwc92gAA4B4QWAhCLdRUmjBBYFAARqXGN6qoIwACEFgAQ
-AMEVJgAQWBAAAca5C/CWCMAAhBYAEADBFSYAEFgQAAGHuQIIwADPcIAAmEfPcYAAsEeqCuAAC9pf
-hgXYSNnmD6AADyGBAIQWABAVJgAQYBAAAVII4ACpcYQWABAAwRUmABBgEAABvg+gAMa5hBYAEBUm
-ABBoEAABKgjgAKlxhBYAEADBFSYAEGgQAAGWD6AAxrkA2AkAr/KhwOB48cDhxaLBaHVaYlR6E2kW
-eBpix3KAAEywi3AkajII7/cG2qlwi3EqCO/3BtoA2N0Hb/KiwPHATg9v8gHaGnDPcYAAjGoAgaXB
-QsACkYTBDBwEMHYMr/IKcATCz3GAADgHgsMKcMO6RMI+geb/IsByDOAAB9kIdgkUgDBmDOAAB9ka
-cMlwANkI2gpzSiRAAk4N4ABKJUAECHcKFIAwQgzgAAfZWnALFIAwNgzgAAfZenBKcADZCNpqc0ok
-QAIeDeAASiVABEDAI8AWDOAAB9kIdQ0UgDAKDOAAB9k6cKlwANkI2ipzSiRAAvIM4ABKJUAEQcDP
-cAAACNLpcYINoAAA2kHYCbjJcXYNoAAB2s9wAAABggpxZg2gAAHaAMHPcAAACdJaDaAAANrPcAAA
-AoJKcUoNoAAB2s9wAAADgmpxPg2gAAHaAcHPcAAACtIuDaAAANrPcAAABIKpcSINoAAB2s9wAAAF
-gipxEg2gAAHaANhpBm/ypcDgePHAo8GLcUoLr/ID2s9wgAAwfASQguAB2MB4s+gAwc9wAAAb0o/p
-AdnaDKAAANrPcAAAHNIB2c4MoAAA2gLYCtkv8CMJUQAC2boMoAAA2s9wAAAc0gLZrgygAADaAtgU
-2R/wBNmeDKAAANrPcAAAHNIA2ZIMoAAA2gLYIdkR8M9wAAAb0gLZfgygAADaz3AAABzSANluDKAA
-ANoC2BHZZgygAALaAsHPcAAABdJWDKAAANoBwdLYCLg7eQHhRgygAADaANijwNHA4H7gePHATg1P
-8qnBQMBBwQDYSMCCxZ4K4ACpcITGlgrgAMlwhseOCuAA6XAAwItyLgrgABfZAcCBwiYK4AAX2QDA
-egrgAKlxAcByCuAAyXGpcKlxcgrgAKlyyXDJcWoK4ADJcqlwyXF+CuAA6XIGwAfBiMO+COAAAdoI
-wD0Fb/KpwOB48cDKDE/yGnDPdoAAOAcfhoDggfQG2K4MoAAA2Qpwz3Kt3u++OgjgAADZCnBR/4Pg
-WgIBAM9wAAAH0s9xAw/wwHYLoAAA2s9wAAAG0gDZagugAChyP4YKcATaCiSAD63e777+D6AA/9sK
-cJP/g+AeAgEAz3AAACDSVSbBG74LoAAE2s9wAAAh0lYmARauC6AABNq8FgAQwBYBELr/CHXPcAAA
-B9LPceQQDjkOC6AAANrPcAAABtIA2f4KoAAocj+GCnAE2gokgA+t3u++kg+gAP/bCnB4/4Pg2fLP
-cAAAINJVJsEbVgugAATaz3AAACHSViYBFkYLoAAE2rwWABDAFgEQoP8CIFADjCAEroj3AN8H8IHg
-CNjKIGICf/EB30wgAKDKJSoQUfaAFgAQjuAB2MIgDgAH6B+GgOAB38oloRED8gDdqXd/CFIgewiD
-LwAAfJLPcAAAUMPqDe/6CnGA4MogbADH9owgAojKIIYPAACfAM9xgACcSfAhAAAVeMYN7/qKIQ8K
-HWVD2IweABDPcAAAC9LPcUMAQ0MeCqAAANojDdQSH4aN6IAWABCO4AHYwiAOAIHgCN3KJ6EQA/II
-3QHfdw4DdAAAJPTPcQAAUMNyDe/6CnCA4MogbADH9owgAojKIIYPAACfAM9xgACcSfAhAAAVeE4N
-7/qKIQ8KP4ab6YAWARCO4QHZwiFOACsJUQAPCNQATiCNAwDfDfBOIM0CAN/PcAAAC9LPcVIAUlKG
-CaAA6XIfhgS//WWI6AbYggqgAKlxAtgK2RvwJwhRAAjYcgqgAKlxz3CAADB8BJAB2YLgwHkC2IDh
-FNnKIWIEB/AJ2E4KoACpcQLYIdk6CaAAAtqIHkATANilAk/y4HjxwDYKb/IE2qTBGnBmD2/yi3EA
-wc92gAA4B3+Gz3CAAPxHBBQRMADd8CDCAM9wgAAISPAgzwDPcAAABtJYeeoIoACpcs9wAAAH0gAp
-wSPaCKAAqXIKcM9yrd7vvnINoACIFgEQCnCf/lEI0AA/hgLCCnAKJIAPrd7vvlYNoAADwwpw6f41
-CNAAz3AAACDSVSbBGxoJoAAE2s9wAAAh0lYmARYKCaAABNq8FgAQwBYBEBD/qB4AEKlw3QFv8qTA
-4HjxwH4JT/KhwQh1ACSOAGJ+AiZOEaByYnoCIgKBANhAwA3yLH6Ldi9wSHEyDqAAyXL+DaAAyXAA
-wAJ9qXCpAW/yocDgePHAPglv8ookww8Ids91gAC0B2qFSIUKJYAPrd7vvimFemKqDKAAA9vJcLX/
-lwjQAAuFSoUKJYAPrd7vvmiFKYUMpclwemIE24IMoACKJMMPyXCr/28I0AALhUqFCiWAD63e775o
-hSmFDaXJcGJ6A9taDKAAiiTDD8lwof9HCNAAC4VKhQolgA+t3u++aIUphQ6lyXBiegTbMgygAIok
-ww/JcJf/HwjQACwVBRA4FQQQCoUohTwdQBFMhW2FwP8KpQDY6QBP8uB48cByCG/yAdsId891gAC0
-B0mFKIUKJYAPrd7vvgDeWWFKheILoACYdulwg/+RCNAAC4UphQLbSIUMpelwCiWAD63e775ZYUqF
-ugugAJh26XB5/20I0AALhSmFAdtIhQ2l6XAKJYAPrd7vvkJ5SoWWC6AAmHbpcHD/RQjQAAuFKYUC
-20iFDqXpcAolgA+t3u++QnlKhW4LoACYdulwZv8hCNAALBUFEDgVBBAJhSiFPB1AEUyFbYWQ/wml
-yXAdAE/y8cCqDy/yAdqhwTpw2gxv8otxz3aAADgHPobPdYAAuK5WJUAUArk0eQAgUAAAwM9xrd7v
-vh6mDgugACpwKnCP/1Ulzx2DCNAAANgF8JgWABAB4JQWARAhCGUAmB4AEM9xrd7vvt4KoAAqcCpw
-tf/hCNGAK/CkFgIQjCIEix6G0/aMIoOET/YM6BUI1QE/hlJoVHq6YnjiNXpDkgPw/9qkHoAQP4ag
-FgMQGGAUeBUgTSBgtUG1NHiIFgEQH2eMFgAQIK8BrwDYRQcv8qHA8cDiDi/yCNkacALYz3aAADgH
-lB4AEArYnB4AEM9yrd7vvlYKoAAKcApwav3pCNAAAN2aCaAAqXDPcIAAMHwEkAHfvqaC4MB/qXDP
-cYAAyEfwIQAAAdmO4IAeABDCIU4A4gmgAIQeQBC/pgDYBe+A4MwgooAv8s9xrd7vvvoJoAAKcApw
-af2RCNAAz3Gt3u++5gmgAApwCnB+/X0I0ACgHkAT/9ikHgAQz3Gt3u++ygmgAApwCnBZ/l0I0AAK
-cM9yrd7vvrIJoAA+hgpwmv9JCNAAH4YB4JkI9IAfph6GAeBrCPSBHqbPca3e776KCaAACnD2DKAA
-CnAdCNAACnDPcq3e775yCaAAENkKcDH9g+DKICIAMQYP8vHA4cWhwYtx+gpv8gHaABQEMM91gADA
-r89wgABETKlxFdquD2AAANsAFAQwz3CAAPwHVSVBFQPalg9gAALbz3CAAMRMViUBExLaWgigAADD
-ANj1BS/yocDxwHINL/JKJEACKHUacgDfB9mA4MogYgATeMK4z3aAAHBMAaYips9waB//AAOmCnDp
-cQjaCnOKC6AASiVABA6mCnDpcQjaCnNKJEACcgugAEolQAQPpgpw6XEI2gpzSiRAAl4LoABKJUAE
-EKaE7QHYEaYK8AsNURAC2BGmBPAJDZEQ8abypv/YANkJ2ghzSiSAAi4LoABKJcAEANkT2v/bSiQA
-BRoLoABKJUAHE6bPcCAAICAhBS/yB6bgeIDgANnKIEEABfKB4AHYyiCiAEjZDyEBAM9wgADoTOB/
-MbDgePHAkgwv8gTapMEacL4Jb/KLcQLAA8MA3alxCNpKJEACvgqgAEolQAQIcQHAUgtgAKlyCnDP
-cq3e777uD2AAAMFSCa//CnBtCNAAz3aAAPwHz3AAACDSViZBE6oLYAAE2s9wAAAh0lUmwRaaC2AA
-BNo6hvuGQSnABcC4GLgTeCV4QS/BFcC5GLkzeSV/GqbPcQAAaB/7pnYOr/oIuBymz3EAAGgfZg6v
-+kAvABIdpqlwRQQv8qTA4HjxwMoLL/KKIA8KgiQCOppxenJac4h1qHcKIYAhCiDAISYJoACewYpw
-HgmgAItxgsZqcBYJoADJcUpwDgmgAITBqXAGCaAAhsGIxelw+gigAKlxKnDyCKAAisEKcOoIoACM
-walwisFOCaAAkMKLcMlxQgmgAJLCyXCEwToJoACUwobAqXEuCaAAlsKYxpDAksHCCKAAyXKax5TA
-lsG2CKAA6XLJcOlxDgmgAJzCnMCeweIIoACOwp/FhgigAARtjsCWCaAAJG23CBAAhsCKwaYIoABA
-JQITi3CEwZoIoABAJQIVlMBAJQETagigAMlykMBAJQEVXgigAOlyyXDpcbYIoACcwozAnMFKCKAA
-yXLCCKAAyXDJcI7BegigAEAlAheSwEAlARMuCKAAyXKWwEAlARUiCKAA6XLJcOlxdgigAJzCjMCc
-wQ4IoADJcslwjsFCCKAAQCUCGTYIoABAJQAXz3GAAPwHGKEmCKAAQCUAGc9xgAD8BxmhB/AA2c9w
-gAD8BzigOaCZAi/ygCQCOuB48cBSCi/yCtqqwQh2dg8v8otxBtguCmAAAcEI2CYKYAABwQnYHgpg
-AAHBEBQEMMlwAMECwgolgA+t3u++og1gAAPDyXBd/38I0ADPdYAA/AcchRgUBDASpR2FAMEKJYAP
-rd7vvgLCFaXJcHYNYAAFw8lwUv9PCNAAHIUgFAQwE6UdhQDBCiWAD63e774CwhalyXBODWAAB8PJ
-cEj/JwjQAHyFdBUGEMlwVBUEEFgVBRB0pSQUBzAyhVwdgBFThW3/ANj9AS/yqsDxwG4JL/IM2Lpx
-OnLPd4AA/AeEFxMQfBcQEADdmnDPcIAADE3wIFIDanDSC6/6SnECcBN4xguv+oohDwoIdogXABC6
-C6/6SnGAFwEQOGATeKoLr/qKIQ8KumVUekAtwSA2eVlhx3GAAEywDQkRIMSpBakJ8AsJUSDGqQep
-A/DIqQmpQiRAIJkIdYAB5TEBL/IA2OB48cDKCA/yp8G6cADfRsdKJ8AgSiSAIUojwCRKIIA1z3aA
-APwH66bpcVp3gOHKIoEvAAAI0sojISXKIOE1yifhJMokoSWB4coigS8AAAnSyiMhJcog4TXKJ2El
-yiQhJoLhyiKBLwAACtIT2cojQSDKIKEFyiABMMokASDKJ0EgANkH2EXAz3WAABxMNX0AhdpxAdmO
-4MIhTgAqpoDhyiHBJcohwiSA4cogASXKIAImogtAAM9xgAA4TMlwA9oKCmAAAtsKhiuGCtqt/s9w
-gABETM9xgABwTBXa7glgAADbC4bW/s9wgADETM9xgADoTLIKYAAS2gCFz3EgACAgCKbPcAAAC9LW
-DiAAANqKJb8dQMVBxQrYQsDPcK3e775DwKpwK4YqckpzSiSAAkolgAJKJoACUgtgAE4mBwCqcFr/
-g+DV8hiGz3EQABAQDKYZhg2mz3AAAAvShg4gAADaQMVBxQrYQsDPcK3e775DwKpwK4YKckpzSiSA
-AgolAAEKJgABAgtgAE4kBwCqcEf/g+Cv8jiGWYaGxQ2GLqZPphN4VHhMhh+mE3hTejR6gB6AEIoh
-DwrmDWAAqXKAFgAQGBQQMIohDwoTeNINYACpcgbAiiEPCkTAH4YTeL4NYACpcgbAiiEPCkIgmQKA
-FgAQE3iqDWAAqXIGxc9wAAAL0s9xIAAgIGq91g0gAADaABxANgrYQcVCwM9wrd7vvkPAEBQFMCuG
-QCCEIqpwKnJKc0AlhQIKJgABTgpgAPh1qnAa/68I0AAYhhCmGYYRpguGhugG2BYPIABWJsETC4YR
-CFEACNgGDyAAVibBEwuGEQiRAAnY9g4gAFYmwRMehsO4Cwh0Ax6mC9geps9xgAAMTfAhAgARhjCG
-THiEHkAeTHlMhogeQB6E6k2GCupOhoTqT4YG6oDhzCAhgAn0/6aAHsAThB7AE4gewBOqcMpxS4Yo
-/wXAYbiA4K4F7f9AJkEgK4YB4YPhSgXl/yumANghBu/xp8DxwAYO7/EI2c9yrd7vvoYJYAAIdslw
-CP5PCNAAAN3KCGAAqXDPca3e775qCWAAyXDJcDj/MwjQAM9xrd7vvlYJYADJcA4Lb//JcB8I0ADJ
-cM9yrd7vvj4JYAAQ2clw9v2D4MogQgMNBs/x4HjxwJoNz/Ghwc92gAD8B0qGi3UVJowQBJSpcYvq
-7g0AAAqGAMEVJgAQBJDGuQnw3g0AAAqGAMEVJgAQBJCHuU4NAABLhgXYSNlCDSAADyGBAAqGFSYA
-EAiQsg0gAKlxCoYAwRUmABAIkCINIADGuQqGFSYAEAyQlg0gAKlxCoYAwRUmABAMkAYNIADGuQDY
-eQXv8aHA8cDhxaHBi3EuCi/yAdoAFAQwz3WAAEiyz3CAAEhNqXEX2uIOIAAA2wAUBDDPcIAAjAhV
-JcEVA9rKDiAAAtvPcIAA4E1WJUETC9qODyAAAMMA2CkF7/GhwPHArgzv8RfapsHPdkAf/wDPdVAA
-UFDPcIAASE3PcYAAeE1eDiAAANvPcAAAC9IAHAQwz3AAAALSAhwEMM9wAAAb0gQcBDDPcAAAHNJC
-xQYcBDDPdYAAjAgChQDZQ8YPIQEAA4VEwYLBBNpFwItwEg4gAADbz3GAANRNqXAD2gIOIAAC2wDY
-lQTv8abA8cDhxaHBz3CAAIwIIoBQ2A8gTQDPcIAA4E3PcYAA+E2qDiAAC9oF2AAcBDACHEQzi3BA
-JIEwlg4gAAHaANiZ8fHAosGLcQ4JL/IC2gDAANkE2khzSiRAAQ4KYABKJcABCHGyCyAAS9gA2KLA
-0cDgfvHAngvP8a7BenBacTpyGnOCxf4IYACpcITG9ghgAMlw7ghgAIbA6ghgAIjA4ghgAIrAjMfa
-CGAA6XBqcBfZfghgAItySnAX2XIIYACBwgDAxghgAKlxAcC+CGAAyXGpcKlxwghgAKlyyXDJcbYI
-YADJcqlwyXHOCGAAhsIqcBfZOghgAItyCnAX2TIIYACBwgDAhghgAKlxAcB+CGAAyXGpcKlxfghg
-AKlyyXDJcXYIYADJcqlwyXGKCGAAiMLPcAAATRlSCGAAisGIwIrBVghgAOly6XAL2doIYADpcobA
-RglgAOlxgOAB2Br2z3AAAIwWJghgAIrBiMCKwSYIYADpculwC9muCGAA6XKGwBoJYADpcYDgAtjK
-ICoA2QLv8a7A4HjxwHYK7/EB2qHBmnCyD+/xi3EAwc9wgAA8Tc92gACMCPAgQAAips9xrd7vvgOm
-7g0gAIpwinBr/6cI0ADPca3e777aDSAAinCKcIn/kwjQAIpwD9nPc63e777CDSAAAtqKcJP/SiIA
-IB/fdwjQABAWEBAUFhEQCiOAJAPwWnVKdR7wqXcc8AAnjRS9fbB9inCpcc9zrd7vvoINIAAK2opw
-g/8/CNAARIYKcCpxZYaM/9MIUIDJCJCASiNAIAIngBQJCJQAwwsQoIHgyiXOE89wgAAQTvQgQAOm
-pgemANjtAe/xocDPcIAAxLIosOB/SbDxwJ4J7/EI2c9yrd7vvh4NIAAIdslwIf9jCNAAAdnPdYAA
-jAgipc9yrd7vvv4MIADJcMlwt/9HCNAAIoUB4esJtIAipSyVyXBOlev/z3Gt3u++2gwgAMlwNg8v
-/8lwHwjQAMlwz3Kt3u++wgwgABDZyXAK/4PgyiAiAJEBz/HgePHADgnP8TpwKHUack4Lr/0H2Ewg
-gKBacBvyDPYnCBAgTQhRIBXYE7gVIEAEoKAb8CsIECQ5CBEoKnBWCC/yqXER8CnYErgVIEAEoKAL
-8CvYErgVIEAEoKAF8M9woADsJ7mgegyv/UpwAQHP8QohwA/rcgXYO9sKJEAEYQav8AolAATgePHA
-igjP8TpwKHUacsoKr/0H2FpwDwieILoL7/3I2FAgkCBMIICgGfII9iMIECBFCFEgFdgTuA3wJQgQ
-JDUIESjiD+/xKnAApQ/wKdgSuPAgQAQApQnwK9gSuPvxz3CgAOwnGYAApfILr/1KcHkAz/EKIcAP
-63IF2GzbCiRABNkFr/AKJQAE4HjxwAYIz/E6cBpxz3WgAMgfURUPlgHYUR0YkCDe0KVDHRgQANja
-C+/xjbjRpSIKr/0H2M9zoADALzODDQmfBjCDHQkfAPwTBQAKIcAP63IF2IojRg15Ba/wiiQCAS8i
-CARAKYEhgbkQukV5z3KgAOwnJqJRHdiTWguP/e0Hj/HgePHAhg+P8aHBGnAod892oADIH1EWEZYB
-2FEeGJAg3bCmQx4YEADYWgvv8Y24saaiCa/9B9jPc6AAwC8zgwsJnwYwgx8JHwD8EwUACiHAD+ty
-BdiKI0YN+QSv8IokQghAKJAhRSDDIM9yoADsJ2aiSoKLcUCxABQBMSCnUR5YlNIKj/1lB6/xocDx
-wPYOj/FacDpxSHcac891oADIH1EVE5YB2FEdGJAg3tClQx0YEADYzgrv8Y240aUWCa/9B9jPc6AA
-wC8zgw0JnwYwgx0JHwD8EwUACiHAD+tyBdiKI0YNbQSv8IokQwAA2Q8hAQRJaUV5ANoPIsIDaWpF
-e0Z7Znkwe0AqkiFFIsIhELtles9zoADsJ0ajACnCIyR6UHpFIoEhELpFeSajUR3YlCIKj/2lBo/x
-8cBSDo/xCHc6cRpzHQp0AADeSHX0J4ATFSGBIwpyav9hvfUNdZAB5okGj/HxwCYOj/EIdzpxGnMd
-CnQAAN5IdfQngBPwIYEjCnI+/2G99Q11kAHmXQaP8fHACwzeAOn/AvDz/9HA4H7xwOoNj/EIdzpx
-GnMdCnQAAN5IdfAngBMVIYEjCnJQ/2G99Q11kAHmIQaP8fHAvg2P8Qh3OnEacx0KdAAA3kh18CeA
-E/AhgSMKciT/Yb31DXWQAeb1BY/x8cALDN4A6f8C8PP/zPHgePHAhg2P8aHBCHcacSEKdAAA3kh1
-9CeAE4txef8AwBQgjCNhvQC08Q11kAHmvQWv8aHA4HjxwFINj/EIdxpxHQp0AADeSHX0J4AT9CCB
-I0z/Yb33DXWQAeaRBY/x8cALC94A6P8C8PT/lvHgePHAEg2P8Vpwz3agAMgfURYQlgHYUR4YkCDd
-sKZDHhgQANjuCO/xjbixpjYPb/0H2Dpwz3WgAOwn64XmDC/+SnALpVEeGJSaCK/9KnAhBa/x6XDg
-ePHAzgyP8Qh2Ag9v/QfYz3GgAOwnuYHZoXIIj/0dBa/xqXDgePHA4cUIcY7gAdjCIA0AAN3Pc6sA
-oP+5owfaWqO4owHa8ggv/0hzYgmv/QHY8QSP8bkFj/HxwPILAABqDK/xUNlFwEogACCGxfr/JQg1
-JQQVARQFwBUgAAQgoEAgUCDvCYGPrd7vviTcnwSP8QohwA/rcgXYiiMHBJhz7QGv8AolAATgePHA
-+guP8VpwGnHacPpxOnJ6cwDYmnBvJUMQCHZKIMA3O3AId7pw6XCqcZoLIAAB2gAgQIMBIYEDigsg
-AAtyQiBYsMpzQyEZMPJxzCDBgAr3ACdPkwEllSMCJhagAydXIKlwyXGKCyAAAdoFIH6ACHUodtv1
-6XCqcelyogsgAKpzAiISoOlwAyBQIKpxNgsgAAHaBSI+pAh1KHYQ8gUlvpMM8ipwANlKcnILIAAK
-c6lyigsgAMlzmnAqcADZ6XJeCyAAqnMAJAIgcQOv8QAbgCAggADagOFF9gHaM3kgoIAhAYB/3MAh
-BANHuSCgA+ozeSCg4H4ggAe54H8goKHB8cDhxULAmHFIdYDgANpE9gHaE3hCwILA+P8CwAPqE3h6
-DS/6iHEApQjccwOP8eHF4cYA3TMJ0AcLCdMHCwkTAADYE/AZCfMHH95OIfwH4HioIIABDyWNE2G+
-CQhOAKV4A/CmeACiAdjBxuB/wcXxwKHBANpAwoty7v8AwKHA0cDgfgDZIKDgfyGgCHJfuECh4H8B
-oeB48cCSCo/xSHVAgGGAwYEAgXYKIADJcQCl5QKv8SGl4HjhxeHGwIBhgKCBAYEAJY2TASDAAKCi
-AaLN8eB44H8AgPHAUgqP8Uh1wYBAgWGBAIBeCiAAyXEApaUCr/EhpeB44cVggKCBAYAhgQIjQ4Ng
-ogMgQAABouB/wcXgeECAIYBOIgOAANoDIkIAYKDgf0Gg8cACCo/xSHXBgACAKHKCCyAAyXEApVkC
-r/EhpZ/hzCDuh8wgToAG9wJ5QWkLChEIiiH/DwbwANkPIYEAYbkYeeB/KHDxwLoJr/HYcCh2SHGI
-dclw8v8Id6lwqHHw/whxAC6AAwR/Jn8AK0ADJHj5Aa/x5XhggECBAYAhgVBzzCBBgOEgwQfKICEA
-MHCG9gT2CQrFAOB/AdiKIP8P4H7gePHAYgmP8Uh2gOAB3UT2iiX/HxN4CQkTALN9M3kUIQAAsgsv
-+jt5rHgAHkAeoQGv8QHY4HjxwOHFz3CAAMw+qIBaYlR6E2kWeFhguGBocY4Or/EG2oEBr/EA2OB4
-8cACCa/xANnPdoAAnCoXhs91gAC4rg8hAQAZhiR4QiAAgMogYgChwQHfFwhRAM9xAABALAvY4g+v
-81YlQhQ3hgDYDyBAADiGJHhCIACAyiBiAADZIwhRAAvYYMABHEIwAhzCMwMcwjOLcATZViVCFPYP
-r/NU2wDY8QCv8aHA4Hj8HIix/BxIsfwcCLHhw+HC4cHhwAfAHBzAMeHA4H8BwFMiQoHgfE4iA4gW
-AAwAASjMAAApgQAAKIAA4H+FeU4jAwAAKMEA4H8CeOB4UyJCgeB8TiIDiBYADAAAKcwAASmBAAEo
-gADgf4V4TiMDAAEpwADgfyJ54HgIdADYBSp+AC9xBSo+AwAgQI4BIcEOBSs+A+B/J3HgeDMAIABK
-JAAAByHEAC8mQPBKJQAAEAAmAC8kBAEOIECBAyVBAIDjDgADAA4iQoEDJcMABSOFgDABAQB5c0h0
-CHIocwolwIJKIgAQGgAEAMAiIRjKJQGDLy9BAcAiYxDAIsMRSicAAAolwIDAJyEIFgAEAMolgYAv
-KEEBwCdjAMAnAwAOJ4eCyickAEAnRwAKJcABTCcAiADZEAAkAADYSHFocgDbQicHiAokQHEoAAEA
-TicKiH4AAQAAKYACASnBAQAqhQKgcQEqwgEAK4UCASvDAaByTCIAmGoACQCoIIAFACAAgAEhQYAB
-IoKAASPDAAIiAoMDI8OCDAAGAAAiAoMBI8OCwCBmAEIkPoBKJQAAIAABAAwACgAOIkKBAyXDAC8k
-AIEMAAMADiBAgQMlQQDgfihwSHFocgDbICCADwEAsPeoIIADACAAgAEhQYABIoKAkXLCIgYDxSBm
-ACAggA8BAOT3ANoJagDbLyECACAggA8BAAz44HhTIkKB4HxOIgOIFgAMAAApzAACKYEAASiAAOB/
-hXhOIwMAAinAAOB/QinBB/HAocGA2GDABcwCHAQwz3CgANQDHJC6D4/xAMDaD6/xAtlyCCAAAtih
-wNHA4H7geOB/ANjgfwDY4H8A2OB/ANjgfwDY4H8A2OB/ANjgfwDY4H8A2PHAocGB2GDABcwCHAQw
-AMCSD6/xAtmhwNHA4H7gfuB44H8A2OB+4HjgfuB44H7geOB+4HjgfuB44H7gePHAo8EA2WDBARwC
-MAMcQjACHEIwAdjPcaAAyB8ToRmBhNpCwBiBHtsM2UHAi3CeD2/xGLujwNHA4H7geOB+4HjgfuB4
-4H7geOB+4HjgfuB44H8A2PHACiHAD+tyBdgO24okww8RA2/wuHPgePHATg1v8Yog/w/PdaAAOC7H
-hQelP9j6CK/yFtkWCo/yx6WZBU/x4HjxwOHFiiDKBY4Lb/GKIUUFIgpv8gHYz3ClAAgMAN2ioATI
-hOCsCEHwz3EAALQJGg9v8AbYD8gFIIAPAQAA/A8aGDAEyAsIngB2CE/1C/AA2Z65z3CgAPxEIaDP
-cKAAtA+8oN7/OgoP+0oLL/0B2BoPb/AB2CUFT/HxwOHF63WKIIoFFgtv8YohRASKIIoFCgtv8alx
-z3WAALQIAIUtCF8AA4VSIIAAA6UI8M9woACoIA2A5ODyAAUAvgyv8VTYRCABAQOF5whBgIogigXK
-Cm/xiiGECATIPQgRAc9xgAC0hwGBpbgBoc9xgABkuMURAAaluMUZGAAJgaW4CaEluMC4z3GAANie
-Vg7v/wqhRghP8YogigWCCm/xiiEEDADaz3CgAPxEnrpBoM9woAC0DwDZPKAPyAQggA/+//8DDxoY
-MA/Ih7gPGhgwf9gKuM9xoADQGxOhf9gQoQDYlbgQoc9xAQAs/uINb/AG2M9xoADwNgSBRiDAAQSh
-lNjiDW/xGNmKIIoFEgpv8SCFAIVRIECAEAwi+8ogIgCKIIoF+glv8Rx5+QNP8QohwA/rcgXYiiNE
-B0okAAAtAW/wCiUAAeB48cDhxaHBz3WAALQIRJUilYogSgUQusIJb/FFeUKFIYU3CYAABMhAwQsI
-EQFPIQABQMCF6YDiDA7C/4twBNmh2j3bNg1v8Re7IYUG6QKFhOia/yGFIqUm6QDaz3CgAPxEnrpB
-oM9woAC0DwDZPKAPyAQggA/+//8DDxoYMA/Ih7gPGhgwf9gKuM9xoADQGxOhf9gQoQDYlbgQoRoN
-b/AB2DkDb/GhwOB48cDhxQAWAEDPdYAAtAgApS8IkQAA2c9wnwC4/z2gz3KgAMg7FoJEIAEHFoKG
-IP8IBXkWgoYg/wgFIH6A8fXGDk/xIIUxCVUBMyZBcIAAlGpAJwByNHgAeLYKr/FU2BkIXgABhYG4
-AaW8/wbwaf8E8KYPj/q9Ak/xz3KAALQIIYIleOB/AaLgeM9ygAC0CCGCBnngfyGi4HgA2Zy5z3Cg
-AKwvPaDgfuB48cDhxc9zoACsLxmD8LgZgwDdDPIEIIAPCAAAANdwCAAAAAHYwHgH8IYgfw+C4AHY
-wHgY6BmDBCCADw4AAABCIACAyiBiAB0IUAAKIcAP63JkEwQABdh623kHL/BKJQAABgqv8VTYRCAB
-Ai8IHgHPcp8AuP+9os91oADIO1aFdoWGIv8IhiP/CGV6doWGI/8IBSO+gPH1z3KAALQIUSBAgAGC
-zyBiANAgYQABohsIngAEghcJAAAkogHZz3CAALEGdg7v/CCoxQFP8eB48cAA2Jy4z3GgAKwvHKEa
-gVEggIIagQryqrgaoRqB5wgegAHYvP8J8Iq4GqEagdcIH4AB2LT/ANmbuc9woADQGzGgvf9o/89w
-gAC0CAGAQiAAgMogYgDRwOB+4HjxwO4IT/HPcQCCAQDPcKAArC88oM9wgAC0CAGAg+ji/xTw4P5G
-CS/7P9iQ6CDez3WgAMgf0KUK2EMdGBAA2J4Mb/GNuNGl1/4RAU/xrPHgePHAiiBKBgoPL/EA2dH+
-n/9K/4DZz3CgANAbMKDH8eB4z3CAAFBQ4QEP9eB48cCCCoABz3CAAGS4GBCEABEMEQEJgA0IXgFO
-DwAADfATDFAAz3CAAFi7FBCFAA8N0QHWCAAA0cDgfgohwA/rcgXY7QUv8G7b8cAqCE/xABYAQM9w
-gAA8CQCAz3WAANiyg+AAFgBAVSVOFBX0z3WAAFBOAKUEbYYMb/EP2VUlQBQWDm/xIpUB2c9wgABA
-uCSoJfAApQRtZgxv8Q/ZyXD6DW/xIpUelc9ygADMCNlg2GABEIUAIKInDREAAoXwuMohwQ/KIsEH
-yiBhAcojgQ8AAOIAXAUh8MokYQAFAE/x4HgIcs9wgABoUCWAI4Fggc9xoACwHzuB1bl5YRDh1Qbv
-+UJ54HjxwOHF0P+uC0/xz3CAAGwQGIhbCFEAz3GAANiyz3KAAFBQAIJggWCgAIIc22CoBGkBos9w
-gADUCAOhVSFABAOiGNgColUhwAUFogGBAN1aGUQDBKICga24Hg9gAAKhh+ipcN//Bg9gAAbYeQcP
-8eB48cDhxc91oADIHxWFz3GfALj/1bgWoW4Oz/8VFQCWkLgeHRiQ1g5gAADYSQcP8eB48cDhxQHY
-z3GgAMgfE6EYgazBScAZgc91gADIms9xgABMu0rAAYGhuAGhCIUTCB4ADwjfAVIPD/riCG/wF9iL
-calwBgxv8STaz3CAAMwIIIACiZLoBIkhCB4AD8gEIIAP/v//Aw8aGDAPyIa4jLiPuJC4C/APyAUg
-gA8BAAD8DxoYMA/IrLgPGhgw3ggP8ItwMNmQ2h7bSghv8Ri7z3CfALj/Atk2oCjAgeDKIcIPyiLC
-B8ogYgHKI4IPAAAeAcokIgDIAyLwyiUiAA4OQACH6ADYm//2DWAABthpBi/xrMDxwOoNL/Ew2s9x
-nwC4/1ahGxoYMM9yoADUBxoaGIAfEgCGAN8B3gIaGDAIEoUwTCUAh8ohwg/KIsIHyiBiAcojgg8A
-AIoBZAMi8MokggMZEg2GA9ggGhiAFBqYgw8SA4YAFgBAABYAQAAWAUEAFgBBABYAQA8a2IBA4TB5
-CQgeBQLhMHkDaQQggA8AAPz/jwhEAw8SAIZA4B4aGIAdEgGGHhoYgK25HRpYgGoPgAAs6M91oAA4
-LgeFz3EAAOgJqLgHpU4PL/AN2AeFhbgHpc9wgAC8tQCAhiD+gQ/ICvIFIIAPAAAA1A8aGDAPyJC4
-BvAFIIAPAQAA/A8aGDASD6AAAtgN8A/IBSCADwEAAPwPGhgwD8isuA8aGDDPcIAAMAXgoADZkbnP
-cKAA0BsxoM9wgADQAhB4z3GgALRHSRkYgM9ygADElc9wgAA0BUCgbyBDAFQZGIAeDi/0ChqYM/UE
-L/EA2PHAigwP8QAWhUAAFoBAABaAQAAWgEBMJQCEyiHJD8oiyQfKIGkByiOJDwAATgAYAinwyiRp
-AADZz3aAAIBQKQ10ACmmKHIAFoNAFGvPdYAAKHUAZRkIXwIB4g8hwQDrCmSBKaZqCE/xjQQP8Qoh
-wA/rcgXYXNtKJAAAzQEv8AolAAHgeM9xgACAUAqBg+gNgQPoANgF8AaB+whQgAHY4H8PeOB48cDh
-xWoJIAAIdc9xgAConiWRYQlSAC7oz3CAAKCRSIgA2c9zgACAUAyDDyGBAAsgQIAg9IwiAoAc8oYl
-/BCMJQKQDvKMJQKUB/KKIM8OCgov8Z/ZDvANgyV4DaMLgwV5K6M0asdxgAAodQCBqLgAoekDD/Hx
-wG4LL/EA2EokwHOoIAAHNGjHcYAAKHXggc91gACAUADeDyYOEEEvAxJRIwCAbIUE9MZ7bKUH8Asj
-gIMD9Ki/4KEB4JEDD/HhxUokwHMA26ggAAYA3c9xgACAUAyBDyXNEAsgQIMN9AuBCyBAgwn0FGvH
-cIAAKHUggIi5IKAB4+B/wcXxwM9wgACAUCAQBQBMJcCAyiHGD8oixgfKIGYByiOGDwAASACEACbw
-yiSmAM9wgACcavAgQAFAeNHA4H7xwLIKD/EIdc92gACAUIogTwoSCS/xKIYIhg8NBRCA5colAhAC
-9KimiiCPCvYIL/Gpce0CD/HgeM9wgACAUOB/CIDgePHAiiBPC9oIL/H92cIML/AJ2ADY6v/S8fHA
-9/8A2YLgzCBigMogQgAC9AHYD3jG8fHAAdjPcYAAgFADoc9woAAsIAOABKECgYHgnAzB9Lbx8cCK
-IE8Miggv8YHZcgwv8AnYrPHxwAoKD/Hj/xkIUAAKIcAP63IF2JPbiiTDD60H7++4c891gACAUCOF
-AoUhCVEAANkJCFAAFI0G6KoJIAAmpQzwI6UB2AalCPCG6AHeQgnv/8alwqXPcIAAqJ4FkIDgPA7J
-/xUCD/HgePHAngkP8c91gACAUEmFMOoHhWEIUQAWjQDZaoXLhQ8hAQAkekIiAoAke8oiYgCA4wHb
-JH7Ae4DmAd7shcB+5HmA4QHZwHmA4swjIoDMJiKQzCEigAbyFa0A2coJIAAnpRaNAeAPeBatCQgR
-BADYFq2VAQ/x8cDPcYAAgFDPcIAAqGqaDi/xONoWCWAAANjRwOB+4HjxwAoJD/EAFgBAz3CAALSH
-AYAbCF8BCiHAD+tyBdiH24okww+lBu/vuHMAFgBAz3WAANiyAKXkbelwXg0v8Q/ZVSVOFMlw7g4v
-8SKVBg0P8QgVBRBRJQCEyiHBD8oiwQfKIGEByiOBDwAAjwBcBuHvyiRhAM9wgABQUCCAQIVAoSCA
-HNpAqc9xgADgCCOlGNkioFUlwRUloOGgIYXDoCSgANhaHQQQAoWtuG4IYAACpZfoz3CAAKieJZAX
-CXIAiiCPC74O7/Ci2XILAAAG8LIO7/Cn2f4KAAAyCGAADdiVAA/x4HjxwCYID/HPdoAAyJoIhqzB
-EwgeAA8I3wHKCA/6Wgov8BfYi3HJcH4NL/Ek2gHYz3GgAMgfE6EYgQDdScAZgc93gACAUErABocw
-2ZDaHttLwItw6gkv8Ri7obaopqGmvK6jpxoN7/8C2M9wgACongWQCwhSAKqnracE8KoLIACpcGaH
-AdnPcoAA6AgAgoHjwHmA4zhgAKIB2CGCwHg4YAGi7Qfv8KzA4HjxwHoP7/A42qLBGnDPdYAAuFAB
-hQDfYggv8elxIYUY2M9zgABsEACxF4NTIM4gz3KAADR1AaFAKAAhCGIzGcIDQCgEAYhwhiD+A8V4
-EKnPcKAALCAQgMdwBwAgoQqhBtgxGQIAMhkCABaD+rEDoUAhAAMeCu/0CnEDhZDZgcIgsItxEgtv
-9gpwgeDKIcIPyiLCB8ogYgHKI4IPAABqAMokYgCcBOLvyiUCBADAFwgeAIogTw4+De/wbtkhhQGB
-o7gBoSOFi3AE4TIML/EG2gGFz3GAAPAIIqASCO/0qXDPcIAAgFAVGAIE9Qbv8KLA4HjxwJIO7/CK
-IE8O+gzv8IjZAdjPdYAAgFAHpc92gADImoogTw7eDO/wKIYVjQDaLIUPIgIACyGAgCX0KoVFeciG
-KqVrhQS4x3CAACh1IIAbDh4QFw7fEWV6S6WouSCgiiAPDpnZCPBGe2uliLkgoIogDw6g2Y4Mz/CK
-IA8Ohgzv8CuFfQbP8OB48cAGDs/wz3CAAIBQwIAA35a//mY6DC/6yXAIcc9wgADQUEoNr/n+Zs91
-gACongWVJYUKuNlhGgwv+g4gQACYcM9wgADoUCYNr/mIcQIML/rJcJhwz3CAAABREg2v+Yhxz3CA
-AIBQwKAFhf5mHmYFlQq43gsv+g4ggAMIcc9wgAAYUeoMj/npBc/w4HjxwHoNz/DPdoAAgFCghgDf
-lr/9Za4LL/qpcAhxz3CAAMBRvgyv+f1lmgsv+qlwCHHPcIAA2FGqDI/5qQXv8KCm8cA6Dc/wz3Cg
-ALAfu4AA3pa+BCWNH8D/AADdZRTlACWPH4AAAABeCy/6qXAIcc9wgADwUWoMj/lKCy/62GUIcc9w
-gAAIUloMj/k6Cy/66XAIcc9wgAAgUkYMj/nPcIAAgFBBBe/w4KDxwM4Mz/DPcKAAsB/7gADdlr0E
-J48fwP8AAL9nEOcAJ5AfgAAAAPYKL/rpcAhxz3CAADBRAgyv+b9nz3aAAKieBZYlhgq4+WHSCi/6
-DiBAAAhxz3CAAEhR3guP+b4KL/rpcAhxz3CAAGBRzguv+b9nBYYfZwWWCriiCi/6DiDAAwhxz3CA
-AHhRrguv+QJ1jgov+gpwCHHPcIAAkFGaC4/5z3GAAIBQABkABAWWJYYKuLlhagov+g4gQAAIcc9w
-gACoUXYLj/ltBM/w4HjxwAYMz/CiwYDgyiGBD63erd4H8iWAI4EggQKAAnleCu/wiiBPDc92gACA
-UAGGJQhRAIogTw1GCu/wiiEGBgDYAaYqDu/vCdgSCe//ANhr8EIJz/+B4AHYwHgvJQeQEfKKIA8N
-Fgrv8IohxgkWDo/0AdhyC+//BqbiCO//AtgWCc//HQiQAAohwA/rcgXYiiPGDIokww8xAe/vuHMP
-yAUggA8BAAD8DxoYMPoNr+8A36oI7//pcLYN7+8J2M9wgACongWQXwhSAAqGQcALhjoPr/9AwAjo
-gOXKIIEPAABAAJALAfuLcAjZlNoe2y4N7/AYu4ogjw6GCe/wiiEHBIogjw56Ce/wK4aKII8Obgnv
-8CqGiO3OD4//ag2P9AHYB6brpk0D7/CiwPHA4grv8IogDwpKCe/wiiEFAlYLj/zPdYAAgFCV6Iog
-zw4yCe/wiiGFAwHYAaXPcIAAqJ4FkA0IUgA6D4//Q/AA2Kb/P/APyAQggA/+//8DDxoYMA/Ih7gP
-GhgwD8iQuA8aGDAWDa/vAN7SD0/0wgzv7wnYJIXPcKAALCADgMdxAAAAFCJ4GQiFDwCAAACKIA8K
-wgjv8IohhQrDpc4Pr//CpYDgjA+h/8ogYQDPcIAAqJ4FkIDgyiCJDwAAQAAECgn7jQLP8OB48cDh
-xQh1BYADgEKFIICKIA8Legjv8EJ5z3CAAKieBZAJCFIA+/4D8B3/qXDD/2ECz/DgePHA3gnP8M91
-gADYng+FSiAAIIDgyiHBD8oiwQfKIGEByiOhDMokAQR4B6HvyiXBAAHaz3GAAMiaYHhIoTwdABQG
-DO/vA9j9Ac/w4HjxwHYJz/DacJpx+nIKIwAhCiJAIch3CiDAIQohwIPPcIAANHXKIWIAKHIEuShg
-TCQAoAS4hiD+AwUgkQDKIcwPyiLMB8ogbAHKI4wPAAB3AMokbAAAB6zvyiUMBc91gAA4UgGFAN7J
-cSYK7/A42gCFHNkgoAGFENmELwscACGVf4AAZLggsFwVASAzGIIDz3aAAPgIEBhCBJm5IaBAJgET
-IqAKIcCDKBgABDEYAgUyGAIFNBjEBcohYgC2DC/xDOAhhQjYEqkBgY24AaEDgR8IXwIMic9ygABs
-YMO4HHgKYs9wgAAIuUhgDKmG789ygABQmgXwz3KAAHCaQ6Wk2ACyENgCpQsOUSCk2Iy4ALIMwIDg
-yiHBD8oiwQfKIGEByiOBDwAAqADKJCEALAah78olwQAEpiELECABgZi4AaEDgZ+4A6EAFQEgBBUA
-IAAehBQhpgKmrgmv9KlwZQDP8OB4z3CAAMiaKIDPcJ8AuP8A2jagCNnscCCgA9nPcKAAFAQloALI
-7HEAoc9woADUC02g4H7geM9xgAAMCeB/AKHgeM9wgAAMCeB/AIDgePHA6g+v8IogTw8A3c92gAAQ
-CU4Or/CKIYgEiiBPD0IOr/Ajhs9xgK4MAOxwIKACyOxxAKFAJg8SBfAgiexwIKgB5fsN8pG5Z89w
-oAAUBAPaRaAgic9woAD8Cyyo9QeP8PHA4cXPdYAAEAmpcAoM7/AC2Yogzw/qDa/wcNnh/4ogzw/e
-Da/wII2KIM8P0g2v8CGVAI05CF4AGQiQAAohwA/rcgXYd9tKJEAAAQWv77hzz3GgAMgfsBEAAB6h
-ENgOoSaFz3CAAOgQIqBS8DUIngCE4Mohwg/KIsIHyiOCDwAAgwAF2OH1ANnPcIAArAYgoAHZz3CA
-ALEGtgtv/CCoOPAnCN4AAdmI4Mohwg/KIsIHyiOCDwAAjQAF2Mf1z3CAAKwGIKAk8DUIHgACFQUR
-DQ3SA4wlw4/L9gohwA/rcgXYl9tpBK/vSiRAAM9xgADoEAKBBqUA2AKhz3GgAMgfsBEAAB6hENgO
-oQHYBKX1Bo/wiiIEAM9xoADIH0+hsBkAAE6hENgOoZECj+/gePHAz3CAAKgQF5D3/x/Yz3GgAMgf
-CLgOoX/YlbgSGRiAz3ABAMD8FRkYgNHA4H7geIogEACdBK/w0dngePHAIg6v8APYz3WgANQHIB0Y
-kAHYFB0YkBkVD5YPFQGWz3aAABAJJ6YAFgBAABYAQPB/CKYAFgBBErYPHViQQOAKpgXwGRUPlvB/
-iiBQAEoMr/DpcQqG8Q8EkDEGj/DgePHAxg2v8IogUACKJv8fKgyv8OfZ2gmP7wxxz3WAAGAEIKUR
-DkAQEgyv8IogUADAhTMI30HPcIAAYAQAgFMggIHq8y8oAQBOIIIHz3GAABAJAtgEoc9woAAUBEqg
-RaHR/xzwFgzP84wgQoHKIcIPyiLCB8ogYgHKI4IPAAD1AMokYgAAA6LvyiXCAGz/tv8A2c9wgAAQ
-CSSgmQWP8APYz3KgANQHIBoYgAHYFBoYgA8SAYYAFgBAABYAQAAWAEAAFgBADxpYgA8SAIYM4B4a
-GIAdEgGGHhoYgIO5HRpYgOB+8cDPcIAAEAkFgM9xoADUBxsaGDAaGRiADhEAhh8RBYYLGhgwAhpY
-MQjKnODKIcIPyiLCB8ogYgHKI4IPAAC2AWACou/KJGIA3f8v2JW4z3GgANAbEKHPcAEAwPwToSnx
-8cCCDI/wz3eAAMSVAxrYM89wgACIlgcaGDAB2AoaGDB6/wDdz3CAADAFoKAA2ZG5z3CgANAbMaDP
-cIAA0AIQeM92oAC0R0keGJDPcIAANAXgoG8gQwBUHhiQjg8P989wgAAoBQCIgOAkCML8ChIFNjEN
-3gAB2AoaGDAbyM9xgACIhhR5samwqQPZz3CgABQEI6DPcYAAEAkDgQHgA6EO8BkNnwJvFgSWCiHA
-D+tyBdiRAa/viiOHDcjYPgqv8IohRw4pBI/w4HjxwOHFqcGLdalwz3GAAOBqZgzv9STaAdhgwAIc
-BDALyEXAG8gMuIUgSABIwCIN7/apcAEEr/CpwPHAgguv8IogkADuCa/wiiFECs91gAAQCRQVBRAB
-3kwlgIHKIcEPyiLBB8ogYQHKI4EPAAAqAQwBoe/KJIEDmf+w/+L/z3CgANQL0KAQ2M9yoADIH89x
-oACwHw+iCvAQ2M9yoADIH89xoACwHw+iAd4VGpiDQBIDBuGVYn/+ohShLg9P75//z3CgANQL0aDT
-CN7Bz3CgABQECYCA4PAKgviWCc/zjCBCgcwggo8AAPwADPIKIcAP63IF2IojRQNKJEAAgQCv77hz
-z3KgANQLANkwoowgQoEQ9Mj+z3CAABAJAIgZCB4ACiHAD+tyBdiKI4UE5/HqC4/xC//PcYAAEAkA
-2OkCr/AEofHAiiAQAeoIr/CKIcUNK//PcIAAEAkEgBroguDMIOKADPIKIcAP63IF2IojRgGKJMMP
-CQCv77hzsP+KIBABsgiv8IohBgIWCo/4A/AA//sDz//gePHAp/7PcKAA0BuA2TCgz3CAABAJAIiG
-IH+MlA/B/9cDz//gePHA4cXPdYAA2LQAjTEIXwAuDa/8BtjPcacAMEwUEQCGA6UVEQCGBKUWEQCG
-BaUXEQCGBqUYEQCGB6UJ8AGNB+gA2c9wpwCYRzqgCY0PCNAAQCUAE9YK7/AU2SECj/DgePHAlgmP
-8M92gADYtACOocFEIA0HIr06cIYh/CfGC2/8B9hBKU8hGnCM7QohwA/rcgXYiiOMAIokgw8pB2/v
-uHMLJ0CTyiHCD8oiwgfKI4IPAAAFA8ogYgHv9Q69iL2Vva4NL/1Axc9xgACQpQCBi3KGIP4DJLhA
-KIMDAIJmeACiIIHCuQ65JXgAogDBAN1BKYADQSnCA8C4wLoEIYQPAQAAwAi4CrowuUV4wLlAKQID
-BXoAjkEshANBKIMBQShBAcC7wLkLuwm5ZXlBKMMBDbtleUV5gLnPcqAA7CcmokAswQDlec9yqwCg
-/zqiz3GgALQPvKEhjs9ypwA0RPYaWAAllmGW82n1fxC/BSPSA/UamARkjuWOUSBAgPca2AD4GtgD
-z3OnABRIQSmCIVgbAAFXo89yoACARHCCz3elAKz/RiMDBXCiAMIEIoIPIQAAwSa6VafKIIIPAQD/
-/wX0AMBeDe/2FOEYpyDAibiOuBmnAI4VCF4AQCYAE1IJ7/AU2QLwAN3PdqAA9AekpkIMT+/PcYAA
-2LQBiYToAIkRCF8AAdmQuc9wpwCYRzygA9gEpgEIHkPPcYAA2LQBiYToAIkVCF8Az3KnAJhHcBqA
-BAiJgLgaogCJdwheAKsIHsP/CN7Bdg6P84wgAoPMIIKPAAD8AA3yCiHAD+tyBdiKI04CSiRAAF0F
-b++4c4wgAoMZ9M91gADYtKlwFgyv8APZAI1RIACAyiHCD8oiwgfKI4IPAACOA8ogYgHk9Vr/A/DC
-CI/xUguv8IDYBfBKC6/wgNhU/wDaz3GgAPQHRKED2AqhCaFJof4Kb/wKcIkHb/ChwPHAz3GAADB8
-JJEA2ILhzCFigAP0AdgvJgfwz3GAANi0AIkH8oYgPwVFIAAKAKkLCB4AWP8C8D//xwDP//HAz3CA
-ANi0eguv8APZ7v+zAM//4H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB/ANjgfwDY4H7geKHB
-4H+hwOB44H7geOB+4HjxwOHFAsjPdYAAgFIApQRtJguv8ALZz3GADgQA7HAgoKoJr/AAhf0GT/Dg
-eOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7gePHAABYAQc9ygACAUgayABYFQUAi
-AQQOGkQBTCWAhMohwg/KIsIHyiBiAcojgg8AAHMA6ANi78okIgAA2gfwABYAQRQhjAAAtAHiLyBC
-AfMKAoBSCo/w0cDgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4z3CAADwJ
-4H8AgOB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7g
-eOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4
-4H7geOB+4HjgfuB44H7geOB+4HjgfuB44H8B2OB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4Hjg
-fuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfwHY8cDPcIAA
-RL56Ca/wA9kyCY/w0cDgfuB4AtjPcaAAwB0NoSHYBqEB2Aeh4H4A2c9woADAHSegJqAtoOB+z3GA
-AEQJDQhRAAHYAKkBqQCJgeDKIIEPAADECcoggg8AAIAA4H8BoQDYz3KAAEQJAaoAqs9xgAAwfAaJ
-COgHiQboAJEJCJEDAdgAqgDY2vHxwOHFCHXPcIAAwBABiCsIUQAH8IIIT+8KDW/wT9jPcKAA1AsY
-gADZQiAACIDgyiBMAOUIRIOtBE/w4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjxwAohwA/rcgXY
-JttKJAAAxQFv7wolAAHxwAohwA/rcgXYK9tKJAAArQFv7wolAAHPcAIAKBvPcYAATAkAoc9wAgAk
-GwGhz3ACACwbAqHPcAIAMBvgfwOhz3ACAKgaz3GAAEwJAKEBoQKhz3ACAKwa4H8DoeB+4HjgfuB4
-4H7geOB+4HjxwJYLb/Bq2KLBi3EB2sII4ABIc43oCiHAD+tyBdiKI88LiiSBCi0Bb+9KJQAAgcFE
-2AHamgjgAEhzjugKIcAP63IF2IojzwyKJAEBBQFv70olAAAEFAAxXwiCDwAAMgRAJIEwa9gB2mYI
-4ABIc47oCiHAD+tyBdiKI88PiiTBCtEAb+9KJQAAAhQAMc92gABcCRt4QSjFAEwlAIoEHkAR0fYK
-IcAP63IF2Ioj0AClAG/viiTBCh3Yz3aAAFwJAaa4cAAUADHPdYAAXL5ALYIAqXH+D6AAAduN6AAU
-BDEEFgUQCiHAD+tyBdhpAG/viiNQA0GGJQpyAADYFiUBEGCJhiP/DSO7DwtRAGGJA+tiu2GpAeDn
-CIKAANjpAm/wosDxwG4Kb/CKIgQKocHPdYAArAkAlc92gAD4v8lxSiAAIAAcBDSKD6AAAduP6AAV
-BBEKIcAP63IF2M9zAAACDPUHL++KJQQKAI6E4Mohyw/KIssHyiBrAcojiw8AAAcMyiQLBNAHK+/K
-JcsAXgqv8DTYbQgeBJv/D+gKIcAP63IF2M9zAAAODEokAACpBy/vCiUAAYtxRdgB2hYPoAAB24Dg
-yiHBD8oiwQfKIGEByiOBDwAAEQzKJIEPAABFAHQHIe/KJQEEABQAMQHZhiD+D8DgwHnPcIAAXAki
-qBvwz3CAAK4JAJDPcYAASMIO2lTgEHi+DqAAAduA4MohwQ/KIsEHyiOBDwAAGQzKIGEBvfPFAW/w
-ocAOeCx4KWoA2A8gQAAncFp44H8OIMAA4HjxwEYJT/DPcIAAXAkdiAXwQCdAAA94+HDPcIAAXAke
-iIkIwgEA2QfYRCk+B1lwL3AZcYQvAwEncM9xgAD4vwAhBAAfFMQAGWEeEcUAOXAA3gAhjR+AAPi/
-1X3njYhxBdrpcAUVwxDh/0AogRA0eYQvAQUncdR5x3GAAGTC2HEAqelwqHEH2gYVwxDY/wHmz37B
-DrKRAR4CAEIiQBBAIEEQiQh1gC95tvEFAU/wl+iMIcKNAdpX9kokgHGoIEAEz3OAANnARCo+BzIj
-Qw4XC0MAB+sTCpABAeJPegDaA/Bhuk964H9IcOB48cBSCE/wGnA6cpEJcgAA31pxFSDAI6CIAogb
-CRAgz3aAAMBSFX4CuBR4x3CAAFRVCvDPdoAA+FIVfgK4FHjHcIAA/FUhiEsJHgAFEMEAIq4GEMAA
-A64qcKlx2/8AroDgzCBigMogIQAS8kQoPgcAIYB/gAD4v8UQggDhEIEAAiWAEBB4B7hOCu/4QnkB
-rkIiQSCBCXWAAecVAE/w8cDPcIAAMHwGgM9xgABcCQLaEwhRAFypANgdqQHYHqkL8A0IkQBcqQHY
-BfAD2BypANgdqV6pR/+R/89xgAAkayCBz3CAAPRYAdrH/89xgAAoayCBz3CAAFBZANrC/9HA4H7g
-ePHAuHEtCFEACQ1SABcN0gMKIcAP63IF2IojkgQBBS/vmHNALYAAZLjHcIAAwFIb8M9wgAD0VzIg
-QQGMIcOPyiHBD8oiwQfKIGEByiOBDwAAmATMBCHvyiTBAM9wgAD4UjV4zfECeS15THlWIQFyR7k4
-YOB/D3jgePHA4g4P8Ah2KHVIdxpzT3kQuQ94CLgFeYogRwg+DS/wpXnPcIAAXAkBiIDg8AECAIDn
-zCAioAnyLG0vec9wgABcCT+oBvDPcIAAXAm/qKlxz3KAAFwJIBpCAyEaggMiGsIDIxoCBMlwyP8A
-EIcA4YjPcIAAXAndiB6IEHaWAQkARC8+By9xhC4DEQokQA4AIU0Oz3CAAPy/HWVAL4IAVHqELgEV
-CiVADgAiQA4AIIgPgABkwgAmgx+AAHgJTCcAgMwnYoAl9BoVwBAA2QyrGxXAEEokgHEQqxiNFKuo
-IAAGFCBAEEGIc250ezV7x3OAAFjDABDAAEirFSVCEAmrARLAAAHhCqsAii95C6t68AEVwBCY6ADa
-TKtQq1SrSiSAcQDZqCDAAxNuFHg1eMdwgABYw0ioSahKqEuoAeEveWLwbLoAIkABfLkAJEQAACCG
-D4AAZMIAJIAPgAD8vxqIOo3pcqP/DKsAJIAPgAD8vxuIO43pcp7/EKvPcoAA/L8AJIAAGIg4jQAk
-hQDpcpj/FKsA20ohgBEUJssAFCDEEAETgBABFIEA6XKR/zNuNHl1eQAhig+AAFjDCBoCEAATgBAA
-FIEA6XKK/wkaAhAVJcsAFSXEEAETgBABFIEA6XKE/woaAhAAE4AQABSBAOlygP8LGgIQQiFJEAHj
-nwl1kG97AebPcIAAXAkeiM9+EHZ0Bsz/ANnPcIAAXAkgqCkFD/DxwLYMD/CnwRpwWnFIdTpzCiMA
-IYtwz3GAAAhrZg1v9Rraz3GAAFwJAYEA3qkIdACYcAIRhQBMIICjAdrPcYAAXL4WIYMDAIvCIowA
-RCCPAP1/fwrBAw0LUSBBiw0KAARvCxEgQYu16kQgAgIjumMNgRAzDVEARCACAUEqgoAH9EQgDwRB
-Lz6RCvIRClEARCACBCS6CQpQAADaA/AB2k96B/BEIAIEJLqA4gHawHojClEATCEApgHawiKKAIYg
-/w4iuBsIgACA4swlYZAH8gHmZw4EkYog/w8R8DIkQDQRCFEAQnHWeQIRwAAJ8AsIkQAGE8AAA/AH
-E8AAFQQv8KfA8cDCCy/wSiRAAAh2GnFId2h1vP+MIP+PEfTJcApx6XKpcwDdmHW3/4wg/48H9Iog
-BwoKCi/wyXGpcO0DD/DgePjglvbPc4AAoFMGixcKAAAHixMKAAAOiwsKAAAPixEKAQCB4cwhooAB
-2APyANjgfvHARgsv8IoghwjPdoAAXAm6CS/wP44Bju8IEQDPcIAAeAlCIBAHIRaAED+O8/7PcYAA
-tIcgFoAQVokYFtMQHQoBACEWgBA0iREIQQAZFsAQCSDABC8jBSAejv2OqwjCAwDdSiKAIxqOEehE
-L74TACVAHhgWwhDPcYAAkMOZIQIKGWGWIcIKQKk08EgjQCAvIQUgz3CAALxTq2AfjulxIhaCELz/
-CSBBBC15ACDAI89ygADMU6piMBCAAEJ4CSBBAEQvvhMAJUQeH44AJIUPgACQwxgdQgDpcalyvv8A
-JIEPgACQwxgRwQACeS15GB1CAEIiUiAB5XMKdaCvfQHnHo7vf2EIw4OZAg/w4HjhxeHGABHNAAkN
-ExAA3aCpEejU5YP3U92gqc9wgACUVBQgTgOgjqCqABHBADR4AYgQ8NTlg/dT3aCpz3CAAOxTFCBO
-A6COoKoAEcEANHgBiACrwcbgf8HF8cDyCS/wuHIIdyh1z3CAALSHz3aAAFwJIBaDEDaIo8EA2scJ
-wQA0iCEWgBC7CQEAExaGEAsOEACD70WmNfBTJYCQBPJjCFIBCQ0SFAkNEhYA2gPwAdoRDhAAIhaA
-EIDgANgD8gHYz3GAAKBTqWHPc4AAkMNEL74TmSMCCidxO2MzI4QPAABYBRQiwQPZYWyJAdlAwUHA
-QCYAFULAANgIcWYK4AD4dwK9tH3HdYAAbJgihQrvIQ9QED8PkRDRuQWGErgQ8AWGBCGBD/8HAP4F
-eSKlE/AFhgQhgQ/8B/8BCbgFeSKlCfAA2QK9tH0AJYAfgAB0mCCgcg/v74oglA1dAS/wo8ChwfHA
-6ggP8KHBZcIIdih1z3CAAMoGhcGLckAkQzAAiKH/RC6+FgAlQB4UFMEwz3eAAKC/WSePGvhgViDA
-CnkNMxYgqFMlgBBNCFMBRiXNEa99HfABFIAwACaBH4AAbJhSbVR6WWEgwgCpRC6+FgAlQB5EqRQU
-wTD4YFYgwAogqMlwqXGe/wHlr31TJYAQyQhSgSDwARSCMBJtFHgAJoEfgABsmDhgQKggwkSoyXCp
-cZP/EPBCJQAWD3gBFIEwx3aAAISZArgUeB5mIMAorgyuCNyHAC/wocDxwAYID/ChwRpwiiAHCX4O
-7+8Kcc9wgABcCQGIgOBKIQAgtPTPcIAAoFMyIBMEz3CAAFwJ3YgeiBB2UAEJACp3CiJAJALwOnVE
-Lr4TACNALs9xgACQw5khAgoZYTMhjQ8AAFgFu30xCDMmrX3PcYAAnCoagTuBJHgdCB4Cz3CAAFwJ
-E4iLc8lxYgjgAKlyAMACfa19z3CAAHgJfLjYYCwQwQDPcoAAoAYAigXaqXOD/UokgHEA3aggQAVz
-bnR7tXvPcoAAWMN5YimJemIK6SMJAAApCEIAMQ1TEQHlr30L8EIlkhAvIockYb2vfRDwCxLPAADZ
-KnUN8IDlSiIAIMolYRAG8kIlUhAvIockAdkt6XNudHsVI0EDz3eAAFjDOmcAJ0UQFSODBHlnKYlJ
-in9nNQmjAOuPAiJEAAsVggAEv/B/IngEui8kCAECJ4MQbHgvIEYONgmv+IhxDngCfwjn7n9Ev+1/
-CwgSJgrn7X/JcApx6XJt/wHmz3CAAFwJHojPfhB2wgbM/9UG7++hwOB48cCCDs/vz3CgALQPcBAQ
-AIogxwjPcYAAoAbiDO/vIIHPd4AAXAkBjwDdr+jPcKAAtA+8oD6PHY8jCQIAz3OAAIS/f9oUIA4A
-fmZYrrmuAeAPeAXa7wkjgFquAN0O3s9wgAC8U6hgg/9hvgHl8w51kK99z3CAAKAGAIDPcaAAtA8J
-p3AZAARhBs/v4HgIcQUhgQ+t3gAAZQTv74oghwngePHA4cXPdYAAoAaKIMcJTgzv7yCFz3GAAFwJ
-AYmL6ACFKYFNaDBywCBsAcwhDIA0D8n/LQbP7+B4z3EAAK3eHQTv74oghwngePHAABaAQM9xgABc
-CRipABaEQAAWgEBQJL6BGakAFoBAyiHCD8oiwgfKIGIByiOCDwAA8QooA+LuyiXCAFEkgIEA2Mog
-YQAbqc9wgADIBgCQA+h+/rH/kgkP8OMFj//gePHAPg3P7wh1z3aAAFwJCY4odw0NARAIjkEPABCp
-cEAmgRR6CaAAQCbCFBKOr3ozjhi6CLgFeoogVA16C+/vRXkyjkAmABPGDKAAU44SjvYLoAAzjqmu
-6K5NBc/v8cC4cS0IUQAJDVIAFQ3SAwohwA/rcgXYl9uJAu/umHNALYAAFHhsuMdwgABUVRzwz3CA
-APRXMiBAAYwgw4/KIcEPyiLBB8ogYQHKI4EPAACdAFAC4e7KJMEAArgUeMdwgAD8VdHA4H7xwHoM
-z+/PdoAAygYAjs93gADIBiCP4f9BiM91gACYCSCXEQreAAHYAK2KIMcDQ/ACgAboANgArZC5O/Bf
-Ch4Bz3KAALSHFopTCQEAAJZ0iksIwQDPcIAAzAYAiFKKPwoBAM9wgABsEAmAMwheAUGFANsO6s9w
-oAAsIBCAQngRCIUPMQEALQHaQK0E8GCtANoQuoogRwNFeQ3wAY0G6AHYAK2KIAcDB/AA2ACtkbmK
-IAcEPgrP7y0E7+8AjfHAj+i2/89xoAAsIDCBx3FJawDSIqAeCu/viiCHBZLx8cDYcYnorv8A2SKg
-iiDHBQIK7+/IcYbx8cDhxc91gACYCYogRwbuCe/vKY0E2OYKr/sB2QiNKY3q/90Dz+/gePHAz3GA
-AJgJiiDHBsYJ7+8pic9wgAA8VUoKj/hi8eB44cVTIA0AoKkEIIEPAAYAAEIhAYAEIIAPQAAAAMoh
-YgAgqtdwQAAAAAHYwHgAq+B/wcXgePHADgvv79hxCiaAkIh1zCMigAbyQiYGAS8mhwHIcYP/z3GA
-AJgJA6Ef7iSIArk0eUOIA+ECEIUAGwofAAohwA/rcgXYiiNIBJhzgQDv7golgAEIYRcIXwAKIcAP
-63IF2IojSAXy8QEQhQBRJQCAyiHBD8oiwQfKI4EPAAAiAsogYQHk8+G90SUigcohwg/KIsIHyiBi
-Acojgg8AACkCLADi7sokggEnDR4QUSXAgMohwQ/KIsEHyiBhAcojgQ8AADACCADh7sokgQGxAs/v
-4HjxwDIKz++hwQh2KHcacgDdz3CgALQPcBARAIogxwCSCO/vyXHPcKAAtA+8oItxQCRCMEAkgzDp
-cLH/DQgRIEokAAAJ8M9wgACMnwGI+ehKJIAAIMABFIIwyXECFIMwtf/PcIAAmAkpiIDhzCZCkAXy
-I4CqqKKhMQ9eEc9xgAC0h1aJJQ6BEFSJUycDEBkLgQAEJ48fAAYAAIDnAdoyicB6CwpAAKKooaCg
-qIogxwACCO/vyXHPcaAAtA9wGUAE1QHv76HA8cB6Ce/viiAHBs92gACYCdoPr+8khhXdBIYyaAHg
-NHnHcYAA/FUEpgKBEujPc6AALCBwg2J413BJawDSANrI90KhiiDHBaYPr+8giQSGCwiUCgDYBKZh
-vcENVZCJAc/v8cDPcYAAoAaKIIcBfg+v7yCB5P/PcIAAyAYAkIDggAzC/3kEz//gePHA6gjv79hx
-ocEacItxQCRCMEAkgzDIcGb/ARSAMAnoAhSAMAXoQiAQIS8gByQgwApx9/4BFIEwA+miiALwoYiK
-IMcBHg+v78hxQCgAJkAtAhQFegEUgDACFIEwCLgFeoogxwH+Dq/vRXnhvdEl4pAD8h0NHhEKIcAP
-63IF2IojTQGYcykGr+4KJQAEwQDv76HA4HjxwOHFPv/PcIAAbBAYiM91gACMnxcIEQGKIA8Ksg6v
-74ohigICjSGF0f8CjSGFAdp8/6EAz+/geBEIHgIEIL6PAAAAGAHYA/QA2OB/AKngePHAAgjP76HB
-GnAA3s9woAC0D3AQEQDPcKAAtA/coIogRwFeDq/vCnGEKAYvACGNf4AA4KAh8EAlABcWIIQDBRSA
-AIYg/ocY8gSFi3FAJIMwQCRPMOlyHv+oFQAQ6XHj/yDABBSBAAEUgjACFIMwSiTAACT/AeYMlb8O
-BJCKIEcB/g2v7wpxz3GgALQPcBlABP8Fz/+EKAsMACGBf4AAZLgoEYAAKIEtBe//ANrxwJL/dgnP
-/9kCz//PcYAAtIfPcIAAyAYAkFaJKwoBAM9wgADKBgCQVIkfCgEAz3CAAMwGAIgyiQ8JAQDPcYAA
-mAkBiQKp4H7xwBIPj+8acM9xgAC0h892gADIBgCWVonPdYAAmAknCgEAz3CAAMoGAJBUiRcKAQDP
-cIAAzAYAiDKJCwkBAAKNAvAA2AGtlv7PcIAAzAZAiM9xgADKBgCJII6A4gHawHoKcwDfmHfq/gOF
-AYgglhEIHgEB2AOtiiBHAwXw462KIIcDCg2P7/EGj+/gePHAhg6P76HBCHUA3s9woAC0D3AQEADP
-cKAAtA/coOONiiAHAdoMr+/pcQSVi3FAJIMwgOAB2MB4LycAAAWFQCRCMMP+CoVAJEEwiP83D3QQ
-lSVDHlYlABzwIIADqXGAIQgA1HnAuAUgwAEvJAcAIIkgwAEUgjACFIMwwv4B5tkOxJOKIAcBegyv
-7+lxz3GgALQPcBkABJUFz//gePHA6g2P789wgABsECgQkACogIogBwJODK/vCnFTJQAQCnE7/gGI
-USAAgcohwg/KIsIHyiBiAcojgg8AAFoDyiTCAGwDou7KJQIEBQaP7+B4z3CgACwgMIDPcIAAmAng
-fyGg4HjxwOHFz3WAAJgJAI2P6EH+jeiKIEcEAN3mC6/vqXGQ2ZC5A8igGEAAE/ADjRDoz3CgAAAE
-LIiMIQKAAN0I9MILr++KIIcEkdmQue3xAd21Ba/vqXDxwDYNj+/PdoAAeJ4UjicIUQAE2JYMb/sB
-2c9wgADKBgCIz3GAAMgGIIlU/gDYFK4t8PaOK+/PdYAAmAkKjWG4MQ8AEGX+z3CAADxVz3GAAKie
-JYFBbwUpvgBCDG/4L3GKIIcGz3GAAMgGQguv7yCRz3CAAMoGAJDqrQitz3CAAMgGAJAJrQDYFq41
-jgjpz3CAAMoGAIhB/gDYFa4BBa/vAdjgeIDg8cD02Aj03gzP71AgAQD02Afw0gzP7whx9NiAua4O
-j+/RwOB+4HiA4PHANNgH9LYMz+9QIEEEBfCuDM/vTyBBBIoOr+802O3x4HjxwEIMj+8acJIM7+8w
-2JhwKbhRIACAyiHCD8oiwgfKIGIByiOCDwAAzwDcAaLuyiUiACzYSg6v70AogSAB34ogDwoacFYM
-7+8w2JhwKbgxCB4AjCcPmjXyIN3PdqAAyB+wpgHYQx4YEADYzg+v7424saZCIEAgzwh1gAHnHgzv
-7zTYTyABBZW59g2v7zTYDgzv7yzYCHUGDO/vNNg1CF4FR9gaCq/vAtkKIcAP63IF2OvbSiQAAFEB
-r+4KJQABCiHAD+tyBdjb2z0Br+5KJQAA9LjKIIIPAABHAOAJou/KIWIAxQOv70EtABTgePHAWguv
-7zTYpgvP7893gADUwycIHgQA3slwrP8B2LX/iiUQEMlwvP8UJ4wTYb0AtPUNdZAB5o0Dj+/gePHA
-Hguv7zTYocEA3kDGAN9iC+/vjL8zCB4EEg7v8QHYA90KvfhmEHiLcV4P7/EB2s9xgADUy9R5Yb0A
-sekNdZAB5nIID/JBA6/vocDPcaAAYB0SsRSR4H7xwMIKj+8Idih1SHcacw4L7+802BsIHwRhv4wn
-/58X8slw9f8CHRQQAebQfvbxDwgQIM9xgADUwwTwz3GAANTL+3rUeT4L7/SpcN0Cr+8B2PHAagqP
-71pwGnE6cmhwvgwv+ArZoWi2Cu/vSnAEIEAEBCEBJCsIQAAg3892oADIH/CmCthDHhgQANguDq/v
-jbjxpmG9jCX/nyf2ANgC8AHYdQKP7/HA07hPIAEGmbmOCe/viiARAp4J7++KIBEEmwXP/+B48cDh
-xUh1QCkCBlMgwQSKIBEBZgnv70V5iiARA1oJ7++pcVkCj+/gePHA3gmP7wh2KHXs/whyyXAD2aZ6
-8f81Ao/v4HjxwMIJj+8Idih15f8IcslwA9mleur/GQKP7+B48cDMuBC4TyCBAJ+5zguv7/TY9NgC
-2c9zAQCghihyxP+A4MogIQAPBc//4HjxwHoJr+8k2KYLr+8E2STYAdnPcwAAqGEocrr/gODKIcEP
-yiLBB8ogYQHKI4EPAAACAcokIQAAB2HuyiUBAc9wAAAMMADZmrnc/yDez3WgAMgf0KUK2EMdGBAA
-2AoNr++NuNGlz3AAAAwwANmaucz/iiAJBDoLr+9vIUMAaQGP7/HA7giv7wDZB9gacTpwAN5AKAAh
-FHjHcIAAaK0VII0DAJWMIAKNAN+E9owghYLJ9v/YALWKIBEDMg9v7wDZAZ0LCFMPjCA/gUf24bWK
-IBEDGg9v7wDZAebPfrkOEpNCIUAgQCBBIKcIdYAveeEAj+/xwOHFz3CAAKwJAJDPcYAAaK2o2gHd
-gCBECxB4pg3v/6lzgODKIcEPyiLBB8ogYQHKI4EPAADAAMokIQAIBmHuyiUBAdP/z3CAAMw+sQCv
-77Sg4HjxwDYIj+8SDc//z3aAAKwJZtgibgHaWg3v/0hziegKIcAP63IF2M3biiSBCTPwAhYFEUwl
-AIDMJYKPAAD//wv0CiHAD+tyBdjQ26kFb+6KJIEJZ9jJcQHaFg3v/0hziugKIcAP63IF2NPbiiTB
-CRPwAZYkbgHaAeAQePYM7/9Ic6GWjegKIcAP63IF2NbbQCVEEGEFb+5KJQAAAm0QeCZuAdrODO//
-SHOK6AohwA/rcqGWBdjZ20AlhBDt8eUHT+/xwFoPT++hwRpwOnJodrcJcgAA2JpxFSANIM9xgACs
-CQAVkxACFZIQunDjjSGRAY0B2jhgEHiLcXYM7/9IcxLoABQAMUAqgiAEIIEPAAAA/0e5VHotCRAg
-x3KAAFRVFfDPcIAArAnBkKGNCiHAD+tyBdj22wAmRBO5BG/uCiVABcdygAD8VQAawgQE7gKqA/AB
-qicIHgAN7gOKgLgDqhJvFHgbYmOLWGCBu2Oo5KoE7iaqA/AlqkIkQSBdCXWAQCVAIOkGb++hwPHA
-z3CAAPRYDtkB2gDby//PcIAALFkJ2QHaSHPH/89wgABQWSrZANoA28T/z3CAAPhZC9kA2gHbwP/R
-wOB+4HjxwI7/7/+mDg//DggAAHb/9fHgePHASg5P76PBSiEAIItxKnBKIAAhCnJ+C+//KnOA4Moh
-wQ/KIsEHyiBhAcojgQ8AAO4AyiRBBOADYe7KJQEEABSFMM9xgAC0CQAZQgFMJQCAyiHLD8oiywfK
-IGsByiOLDwAA9gCwA2vuyiTLAADAQSgCAkEoDgNTIsQAUybFEAIZAgEDGUIBTCTAgMwl7IDKIckP
-yiLJB8ojiQ8AAPwAeANp7sogaQFBKAIEUyLGAAQZggFBKAIFUyLFAAUZQgFMJkCAzCXhgMohwg/K
-IsIHyiBiAcojgg8AAAIBPANi7sokggFBKAIGUyLEAAYZAgFBKAUHBxlCAUwkQIDMJWyAyiHJD8oi
-yQfKI4kPAAAIAQgDae7KIGkBBBSFMIwlAYSsACwAARlCAQohwA/rcgXYiiNEA+UCb+6Yc891gADU
-4wDfA/AB5+9/QSgBAsO5aQ9DEADeE/BAKYEgNHkKFIAwFSFBAQHmz34UeblhABkEBIAgAiMvIAgk
-AMBBKAEGw7kB4cMOQ5CCwQpwAtoKCu//ANsLFIQwLygBAU4ghQcvJUcBtQ3SgAohwA/rcgXYaQJv
-7oojRAtAIVEgLyFHJEEoAQTDuX8JQqAE8HEOU4BBKAEFw7kKdaUJcgBKIAAgSiIAIAXwQCJSIC8i
-hyRBKAEDw7l3CkMgSiEAIBTwAr7UfgoUgDAVJk4RQCFRIC8hRyQUfgAmgB+AANTjoLCAJQITsH0A
-wEEoAQcB4bsJQ6AwuMO4ACAOBILBqXAC2loJ7/8A2wsUhDAvKAEBTiCFBy8lRwGrDfKAz34KIcAP
-63IF2LkBb+6KI4UBQCBQIC8gByRBKAEFw7lpCEKg09kIuQDYA97Pc4AA1OMA2rJoVH19ZTi1AeJP
-elYhAQjxCrKAMHlhvgHg5w51kA94/QNv76PA4HjxwBUIcgC4cA0N0wMA2ACpAKoT8A8NkgiMJQGA
-yiBsAPf2jCUBiYv2jCUCgwf2AtgAqQHYAKrRwOB+jCVChIb2jCVCiQPY9vYKIcAP63IF2IojxgER
-AW/umHPgeOHF4cbPc4AAtAlGk1MiTYAW8jENkRARqwWTMKvEgyndEr0VJQwQwKQoiwfpViABCDB5
-NX3ApQHgBbME8BOrMqsB4kazwcbgf8HF4Hi4cFYhAALxwA0IcgCYcYwgAoCK9gohwA/rcgXYoQBv
-7oojRwfPcIAANGsUIAABgBABAQQpfgEvcsAQQAdCKgMEwbtSugQofgEvcUIpAATBuFK5gePAImkA
-geDAIWkAiCI+AH/cCSIAA4ghPgCJIcEPgODWICsIgOHWISsIzv+J8fHAXgpP76LBQMBBwkAoFAVA
-KRcFAN1AKhMFQCsSBQHeSiWAIal3BPAKdcp3AMAVuBN4FCDABb4M7/cH2QIgUAMCIEAjrgzv9w7Z
-zH4KIUAuBCk+cC9wrH4AIQ11HWUBwBW4E3gUIIAEigzv9wfZAiDWAwImwCN+DO/3DtkEKH4EL3Hs
-fgAhwHQZYUItABVUubz/QiVVIAHmkQ11oM9+CQJv76LA8cDWCU/vCHYacc91gAC0CeaVCvDMfzoM
-7/dAKUBxRbgKca//JpWMIRCAtvYNAk/v8cCaCU/vocE6cQDfgODKIcEPyiLBB8ogYQHKI4EPAABx
-AsokwQBEByHuyiXBA89xgAC0CUWx5rFMIQCgyiXOE2AALgDKJs4TGndadwTwyXcadWpwQCBTAItx
-AdqKDq//ANsAFA0xLyPIJKl2Kb3Ivr/l2SUpFEwiAKDKIMIDyiGCA8oiAgSoDuL/yiNCA8lwqXGH
-/0IhUSC3CXWgQCJSIMlwqXHL/00Bb++hwPHA6ghP75pwGnHPdYAAtAnFjQSNHmaSdsohzA/KIswH
-yiBsAcojjA8AANICyiQMBYwGLO7KJYwDAN8A3iLwANgIrWpwitkqcsP/CI1TJ8EQGLnDuBy4BXnP
-eBC4BXmKIFQNEg8v7wUhgQQvIcgEELmKIFQN/g4v7wUhQQQB5s9+ACUCFEaKAWo1DgMQQCyAIBR4
-9XjUeM9zgADU4xBjCiIAoDJv7PNAIJMALyPIJNR5O2MwExEBxeoB2MTxAefvf3sP0pB5AE/v8cAm
-CE/vocEIdXpxGnLPcYAAtAnFiQSJHmZydsohzA/KIswHyiBsAcojjA8AABsDyiTMBMAFLO7KJYwD
-AN8A3h/wARSAMAEdEhAGEYEgARSAMITpAR0SECDAAxSCMAEUgTAYuBS6BXoCFIAwELgFeooglA02
-Di/vRXkB5s9+z3GAALQJACEABAaIAeBzDiMQACERBEArgCAUePV41HjPcYAA1OM0IRIAUyfAEBi4
-z3kQuQV5iiCUDfINL+8FIYEEANkvChAgi3FKcALapgyv/wDbcwgRgAohwA/rcgXYiiMMDAokgAQR
-BS/uSiWAAAEdUhAGEYAgw+gBHVIQv/EB5+9/Pw/SkBfx8cDhxQDdoKOB4MwhIYAX8gsKEwigowDY
-CfDA4gbYBvZCIgAIQ7gC4ACjUHkQuRB9iiCUDW4NL++leW0HD+/gePHA4g4v7wDYocFIdohyCiJA
-IQohgCEKwQogwCFMJkCAAKHMJmyQzCCsoM72CiHAD+tyBdiKI04LCiRABHEEL+4KJQAETCFAoMwg
-IaDKIcEPyiLBB8ojgQ8AALMDBdju82hwhiD8A0S4ZN+EKAEJL3WAJQ8aw7t7Y3V7KMBEKr4MfWUC
-JU0eGwhRAFt6TXqLcypwCnHL/wDAFXgVeAJ9qXDCCO/3ZNnseAIlRB6J4MogagLKIgoASfaA4Mog
-KwDKIgsAg/ZBaEAozyD1f89zgAAwcxUnARBVf3lh+2MbCREghu6oEQ6GqBMAhhHwihEOhooTAIYL
-8IfukBEOgJATAIAF8BgRDoAYEwCAKcGB4Yoh/gDAJkEQwCBBAMJ4iHEseC9wQgjv92TZuGDYYDYI
-7/cK2SjgSCABAIwhQ4LKIYoPAADIAM9wgAAcbpkgQQc1eMAQAAaMIkKgJbgQeET2jCIBoA72CiHA
-D+tyBdiKI1ENiiRCADkDL+4KJYAEz3GAACxsWSHBDxUhgQSAEQEGLbkweSx4CsBCKYR1jCTHjwAY
-AAHKIc0PyiLNB8ogbQHKI40PAACUBPgCLe7KJQ0EiiCUDaILL++IcXUFL++hwAAAAAAAAAAAAAAA
-AAAAAQAAAAAAAAAQEYAApBGAAAB0gAAQAIAAjASAAAQIwBAKABNkbAWAgQAAwBYEARNiD1wAIgoA
-AEAABgBwGgAAYQAAEyQAABMlAADAF8ggwBBwRcAQEAjAEAAAEyQAABMlBAjAEQ8UFSIEABUm+/8w
-MgMAEyQYCMARHAjAEQ8UFSIBABUmBAAwMDAAEyTsHMARAwATJFAUwBEEGMARAAATJBBFwBEYCMAR
-D3wTIggAzBEAABMlAAATJDRIxxEPexMiAQATMAQowBEPFBUiBAAVJvQGgIEAAMAWwiwTJAQowBEC
-RhMkBCjAEcJfEyQEKMARD00TIgQQxRECABMk8BzAEQEAEyTsHMARAAATJHAAEyUQHMARAAATJQAA
-EyTgHMARAQATJCQQwBEAAAAhAAATJQAAEyQPRQAiAFwAOQMAAGICYABiAABYOF0AAGEkEMARAIAT
-JDgcwBEPcxMiggETMAQowBEPdBMiAgITMAQowBEPdRMiQgITMAQowBEPFBUiAQAVJg9yEyIIAMwR
-D0QAIgoAAEAAQABwDgAAYQAAEyUCABMk7BzAEQ92EyIYCMoRCQATQBwIyhEJABNAIAjKEQ94EyIE
-AMoRAAABJAAAASUGAABhD3YTIixIxxEPeBMiAADGEQMAASQAAAElAAATJcIsEyQEKMARAkYTJAQo
-wBHCXxMkBCjAEQ9FACIAXAA5JwAAZAAAEyQBABMlOBzAEQ93EyLgHMARDwETIgQIwBEPAhMiBCjA
-EQ8HEyIEKMARDwQTIgQowBECAHFwBwAAYf8AEyUCEBMkBCjAEQAAEyUAABMkyEnHEQYAAGEAABMl
-AhATJAQowBEAABMlSQATJMhJxxEPcBMiAQATMAQowBEDABMkAAATJQQIwBEAABMkOEXAEQ8DEyIY
-KMARBAAAYQAAWDgAABMkAQATJTgcwBEAAAAhpHOAgQAAwBY8BMARMAWAgQAAwBYEARtiEATAEAMA
-GyRUBMARJATAEQgEwBBkc4CBAADAFwgEwBBAc4CBAADAFwAAGyUDHBtiQAAbJDAcwBEFAABhNAWA
-gQAAwBYPGxkiCASggTjwxIAAABskAgAbJTgcwBEAAAAhMAWAgQAAwBZMBMARNAWAgQAAwBYPGxki
-SASggTjwxIAAABskAgAbJTgcwBEAAAAhAAAAhTAFgIEAAMAWDxsEIhAEG2YPARtoFBzAEAoAG0AE
-ABtuAwAAYQ8cHSIBAB0m+Q8AYWQMABAAwAYRAQAEJ/wABGQAABskAgAbJTgcwBEAAAAhAAAbJUAA
-GyQwHMARAAAAIQ8cHSIYAR0mGADHEPyagIEAAMAXIADHEASbgIEAAMAXAAAAIbQygIECAFxuEQAA
-YfhBxBAPGwkiAAsJOQIACmIDAQpiBAIKYgAACUAEAABhCQAJQAIAAGEKAAlAAAAAYQIACUEACRoo
-AADAFgEAGyYAAMAXBAAdJgEACCfpAAhkAAAAIQAAAACMAQAAAQEBAQEAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AABoOAAALDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSMgAAAAAAAAAAA
-AAAAAAABAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwACQANAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAMAAADImoAAAAAAAAAAAABAn4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAD/
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiKSAAOSZAQAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AQAAAAAA
-AAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAEBAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAABAAIAAAAAAAAABwAAAAcAAAAHAAAAAgAAAAIAAACDAAAAkgAAAOgA
-AAD3AAAATgEAAF0BAAAAAAEAAgAAAAYACAAJAAAABwAAAAAAAAACAAAAAgAAAIMAAACSAAAA6AAA
-APcAAABOAQAAXQEAAAAAAQACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAAAAgwAAAJIAAADo
-AAAA9wAAAE4BAABdAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAQACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiagAD8/wEAAAAAAMiagACgBgIAAAAAAAAAAADI
-moAAOAgCAAAAAAAAAAAAAAAAAMiagAAAAAAAAAAAAAEADwBkAAEAHAmAAAAAAAAAAAAABwAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAKgaAgCoGgIAqBoCAKwaAgAAAAAAHQAA
-AAAAAAAAAAAAAAAAAAAAAAB/fwABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIECAAIECAAAAAA
-AAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs
-CAAAFQAAAAwvgACAKgAAgCoAAIAqAAC8QAAAgCoAAIAqAABAPAAAgCoAAIAqAACAKgAAgCoAAIAq
-AACAKgAAgCoAAIAqAACAKgAAIB4AAMgfAADgHwAATCEAAMwhAABQIQAAgCoAAIAqAAAETQAAxE4A
-AKxPAACAKgAAgCoAAIAqAACISwAA7GEAAOhhAABAYgAAgCoAAIAqAACAKgAAyEIAAIAqAAAkYgAA
-gCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAADAQAAAgCoAAIAqAACAKgAAgCoAAIAqAACA
-KgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAq
-AACAKgAAgCoAAIAqAAC0QwAAgCoAAIAqAACAKgAAgCoAAIAqAACYRAAAgCoAAIAqAACAKgAAgCoA
-AIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAAAYaQAAgCoAADxqAACAKgAAgCoAAIAqAACAKgAA
-gCoAAIAqAACAKgAAgCoAANRsAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACA
-KgAAgCoAAAh/AQBYggEAgCoAAKSEAQCAKgAAUIYBAHRTAQCAKgAAgCoAAHBQAACAKgAAgCoAAIAq
-AACAKgAAgCoAAID4AQDU+AEAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoA
-AIAqAABodAAAgCoAAIAqAACAKgAAWP4BAIAqAABAAgIAgCoAACgpAgCAKgAA8CQAAPQkAACAKgAA
-gCoAANAZAgAodwAAgCoAAIAqAACAKgAADPwBAIAqAACAKgAA3EwBALCdAQCAKgAAgCoAAIAqAAB4
-pgEAkFQBAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAGypAQCAKgAAyBgCAMwYAgDYGAIA3BgCANAY
-AgDUGAIA4BgCAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAGBSAACAKgAAgCoA
-AIAqAACAKgAAgCoAABwYAgBsGAIArEYAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAA
-gCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACA
-KgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAqAACAKgAAgCoAAIAq
-AAAkSAAArEgAADxJAADwSQAA3IUAAMhJAACAKgAAgCoAAIAqAACAKgAAgCoAABxIAAAgSAAAgCoA
-AIAqAACgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAMAABgDAAAYAwA
-AGAMAABgDAAAYAwAAGAMAABgDAAAYAwAAGAMAABgDAAAYAwAAGAMAABgDAAAYAwAAGAMAABgDAAA
-YAwAAGAMAABgDAAAYAwAAGAMAABgDAAAYAwAAGAMAABgDAAAYAwAAGAMAABgDAAAYAwAAGAMAACQ
-DQAAAAAAAORZAQBgDAAAhAkAAGAMAABgDAAAYAwAALQJAADMPAEA/IcAAGAMAABgDAAA6AkAAOgJ
-AADoCQAA6AkAAOgJAADoCQAA6AkAAGAMAABgDAAAYAwAAGAMAADQCwAAYAwAAGAMAABgDAAAYAwA
-AGAMAACUDQAAYAwAAGAMAABoCQAAAwAAAOQMAgACAAAAyGcBAAQAAAB4aAEABQAAALANAAAGAAAA
-NDMAAAgAAABIGAIAEwAAAGT5AQAJAAAA3AMCAAoAAADkGAIADgAAAMyaAQAPAAAAfIgBABAAAAC0
-iAEAGAAAAExZAQANAAAATIABABcAAAAkdwAAEQAAAFCGAAASAAAA5EsBAAEAAADc/QEAFAAAALin
-AQAVAAAA4J0BAAcAAABEbQAAFgAAABgpAgAZAAAAkA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAACAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAEAAAAAEAAAABAQAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//
-////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAA4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e
-4eEDDh7hPDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDwVFRUVPDw8PBUVFRU8PDw8AAAA
-AAAAAAAAAAAAAAAAADw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8FRUVFTw8PDwVFRUV
-PDw8PAAAAAAAAAAAAAAAAAAAAAA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8
-PDw8FRUVFTw8PDwAAAAAAAAAAAAAAAAAAAAAkAYAADH6rwCQBgAAMfqvAJAGAAAx+q8AkAYAADH6
-rwCQBgAAMfqvAJAGAAAx+q8AkAYAADH6rwCQBgAAMfqvAEMFAAAx+q8AQwUAADH6rwBDBQAAMfqv
-AEMFAAAx+q8AQwUAADH6rwBDBQAAMfqvAEMFAAAx+q8AQwUAADH6rwAAAAAA3sMJAAAAAAAAAAAA
-AAAAAIwrAQABAAAAzC6AAAAAAAAAAAAAAgAAAAMAAAAAAAAACAAAAAAAAAAwjBEAIL8CAAAAAAD8
-KwEAoCwBAKQtAQBMLwEApC0BAEwvAQD8MAEAhDEBAOQxAQCAgICAgICAgAGAAoCAgICAAAAAALQ3
-AQC0NwEAAAAAAAAAAAAAAAAAAAAAALQ3AQC0NwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AMwugADMLoAApCCgADggoAABAAAA/P///wAAAAAAAAAA7C6AAOwugACoIKAAPCCgAAgAAADz////
-AAAAAAAAAAAML4AADC+AAKwgoABsIKAAMAAAAM////8AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAA
-AAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAA8EwBAAUAAAAML4AAKFIBAAD/AwBIUgEAAP8FACxT
-AQAA/y0AUFMBAAD/PQAIUwEAAP8EAOxSAQAA/yUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAACUWAEABgAAAMwugAAAAAAALAEAAF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAAAAAA
-AAAAxF8BAMBgAQA4YQEAWFwBAIhbAQBkYgEA6GIBACxjAQB8YwEAAAAAAAMAAAACAAAAAwAAAAMA
-AAADAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAARGkBAAoAAADMLoAAAAAAAAAAAAAAAAAA0GkB
-AAoAAADMLoAAAAAAAAAAAAAAAAAAhGoBAAoAAADMLoAAAAAAAAAAAAAAAAAApGsBAAoAAADMLoAA
-AAAAAAAAAAAAAAAACGoBAAoAAADMLoAAAAAAAAAAAAAAAAAAHGsBAAoAAADMLoAAAAAAABAAAAAA
-gAAAAACgABAnAADoAwAA6AMAAAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAAAAAAAMg+
-AQAKAAAAzC6AAAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6A
-AAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAA
-AAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAAAAAAAMg+AQAK
-AAAAzC6AAAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAA
-AAAAAAAAAAAAAMg+AQAKAAAAzC6AAAAAAAAAAAAAAAAAADCEAQAKAAAAzC6AAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMiwEAkIwBAGCPAQAMkgEAhJQBAOiXAQA0jgEARAWA
-AJCagAAYAAAAUJqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdJoBAAYAAADMLoAA/////wAAAAD/////
-/////wAAAAAAAAAAAAAAAECdAQAFAAAADC+AAG4AbgBpAMAAoABQAIAAvgBQAX0APgBuAG4AaQDA
-AKAAUACAAL4AUAF9AD4AAAAAAAEBAAAAAAAAAAECAQEAAgEAAQICAgABAQACAQIBAgACAAECA///
-AAC5Ad8AsQAbABYBGwB8ARsArwAbABQBGwB6ARsAbACgANEAoAA3AaAAbwCDAHEAgwB2AIMAcwAz
-AG4AMwBwADMAcgAzANcAMwA9ATMA1AEGANABAAB+ADwA4wA8AEkBPAB4AEkA3QBJAEMBSQB/AFoA
-5ABaAEoBWgCqAD8AqwABAA8BPwAQAQEAdQE/AHYBAQB5AGoA3gBqAEQBagCoAAAADQEAAHMBAACm
-ADcApwABAAsBNwAMAQEAcQE3AHIBAQAEAAgAnAHMAJ0BzACeAcwAnwHMANUBzADWAcwA1wHMALQA
-RwAZAUcAgAFHAJAAIgD1ACIAWwEiAKEAiAAGAYgAbAGIAJQAAACVAAAAmADAAJkAoACWAJAAlwAA
-AJQAAQCVAAEAmADAAJkAoACWAJAAlwAAAJQAAgCVAAMAmADAAJkAoACWAJAAlwAAAJQAAwCVAAcA
-mADAAJkAoACWAJAAlwAAAPoAAAD5AAAAAgGQAAMB0wAAAYMA/gATAPwAMwD9AHcA+gABAPkAAQAC
-AZAAAwHTAAABgwD+ABMA/AAzAP0AdwD6AAIA+QADAAIBkAADAdMAAAGDAP4AEwD8ADMA/QB3APoA
-AwD5AAcAAgGSAAMB0wAAAYMA/gATAPwAMwD9AHcAXwEAAGEBAABoAZAAaQHTAGYBgwBkARMAYgEz
-AGMBdwBfAQEAYQEBAGgBkABpAdMAZgGDAGQBEwBiATMAYwF3AF8BAgBhAQMAaAGQAGkB0wBmAYMA
-ZAETAGIBMwBjAXcAXwEDAGEBBwBoAZAAaQHTAGYBgwBkARMAYgEzAGMBdwCFAAAAhgAAAIcAUACI
-AAAAiQCgAIoAAACLANAAjAAAAIUAAQCGAAEAhwBQAIgAAACJAKAAigAAAIsA0ACMAAAAhQACAIYA
-AwCHAFAAiAAAAIkAoACKAAAAiwDQAIwAAACFAAMAhgAHAIcAUACIAAAAiQCgAIoAAACLANAAjAAA
-AOsAAADqAAAA7ABQAO0AAADuAKAA7wAAAPAA0ADxAAAA6wABAOoAAQDsAFAA7QAAAO4AoADvAAAA
-8ADQAPEAAADrAAIA6gADAOwAUADtAAAA7gCgAO8AAADwANAA8QAAAOsAAwDqAAcA7ABQAO0AAADu
-AKAA7wAAAPAA0ADxAAAAUQEAAFABAABSAVAAUwEAAFQBoABVAQAAVgHQAFcBAABRAQEAUAEBAFIB
-UABTAQAAVAGgAFUBAABWAdAAVwEAAFEBAgBQAQMAUgFQAFMBAABUAaAAVQEAAFYB0ABXAQAAUQED
-AFABBwBSAVAAUwEAAFQBoABVAQAAVgHQAFcBAAD7/wAA//8AALkB3wCxABsAFgEbAHwBGwCvABsA
-FAEbAHoBGwBsAKAA0QCgADcBoABvAIMAcQCDAHYAgwBzADMAbgAzAHAAMwByADMA1wAzAD0BMwDU
-AQYA0AEAAH4APADjADwASQE8AHgASQDdAEkAQwFJAH8AWgDkAFoASgFaAKoAPwCrAAEADwE/ABAB
-AQB1AT8AdgEBAHkAagDeAGoARAFqAKgAAAANAQAAcwEAAKYANwCnAAEACwE3AAwBAQBxATcAcgEB
-AAQACACcAcwAnQHMAJ4BzACfAYgA1QHMANYBzADXAcwAtABHABkBRwCAAUcAkAAiAPUAIgBbASIA
-oQCIAAYBiABsAYgA+gAAAPkAAAACAZcAAwHQAAABjQD+ABEA/AAzAP0AdwD6AAEA+QABAAIBlwAD
-AdAAAAGNAP4AEQD8ADMA/QB3APoAAgD5AAMAAgGXAAMB0AAAAY0A/gARAPwAMwD9AHcA+gADAPkA
-BwACAZcAAwHQAAABjQD+ABEA/AAzAP0AdwBfAQAAYQEAAGgBlwBpAdAAZgGNAGQBEQBiATMAYwF3
-AF8BAQBhAQEAaAGXAGkB0ABmAY0AZAERAGIBMwBjAXcAXwECAGEBAwBoAZcAaQHQAGYBjQBkAREA
-YgEzAGMBdwBfAQMAYQEHAGgBlwBpAdAAZgGNAGQBEQBiATMAYwF3AOsAAADqAAAA7ABVAO0AAADu
-AKoA7wAAAPAA3QDxAAAA6wABAOoAAQDsAFUA7QAAAO4AqgDvAAAA8ADdAPEAAADrAAIA6gADAOwA
-VQDtAAAA7gCqAO8AAADwAN0A8QAAAOsAAwDqAAcA7ABVAO0AAADuAKoA7wAAAPAA3QDxAAAAUQEA
-AFABAABSAVUAUwEAAFQBqgBVAQAAVgHdAFcBAABRAQEAUAEBAFIBVQBTAQAAVAGqAFUBAABWAd0A
-VwEAAFEBAgBQAQMAUgFVAFMBAABUAaoAVQEAAFYB3QBXAQAAUQEDAFABBwBSAVUAUwEAAFQBqgBV
-AQAAVgHdAFcBAAD7/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3KgB
-AJDJAQCwpYAAQAUAAAAAAADcqAEA/KkBAPCqgAD4AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-XM4BAGjMAQDorIAAVAAAAAAAAADcqAEAlMwBAGitgABQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB
-AAAA3KgBALDIAQC8P4AAUAEAAAAAAADcqAEAyMoBAPgGgAACAAAAAAAAANyoAQAgywEA/AaAAAQA
-AAAAAAAAWM4BAPypAQA8rYAAKgAAAAAAAADcqAEAvMsBAAAAAAAAAAAAAAAAANyoAQB8ywEAAAeA
-AAQAAAAAAAAAAAAAAAAAAAABAAIAAgADAAQABAAFAAYABgAHAAgACAAJAAoACgALAAwADAANAA4A
-DgAPACYAJwAoACgAKQAqAEYARgBHAEgASABJAEoASgBLAEwAaABpAGoAagBrAGwAbABtAG4AbgBv
-AHAAcABxAHIAcgBzAHQAdAB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AA8A
-PwAAAAAAAAAAAAAAAAAAAAEAAgACAAMABAAEAAUABgAGAAcACAAIAAkACgAKAAsAJAAkACUAJgAm
-ACcARABEAEUARgBGAEcASABIAEkASgBKAEsATABMAE0AagBqAGsAbABsAG0AbgBuAG8AcABwAHEA
-cgByAHMAdAB0AHUAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AA4APwDE
-owEAEtIAAAAAAAD//w8A6LcBALYAAAAAAAAA/wAAAOi3AQC3AAAAAAAAAP8AAADotwEAuAAAAAAA
-AAD/AAAA6LcBALkAAAAAAAAA/wAAAOi3AQC6AAAAAAAAAP8AAADotwEAuwAAAAAAAAD/AAAA6LcB
-AL0AAAAAAAAA/wAAAOi3AQC+AAAAAAAAAP8AAADotwEAvwAAAAAAAAD/AAAA6LcBAMAAAAAAAAAA
-/wAAAOi3AQDBAAAAAAAAAP8AAADotwEAwgAAAAAAAAD/AAAAxKMBABPSAAAAAAAA//8PAOi3AQAb
-AQAAAAAAAP8AAADotwEAHAEAAAAAAAD/AAAA6LcBAB0BAAAAAAAA/wAAAOi3AQAeAQAAAAAAAP8A
-AADotwEAHwEAAAAAAAD/AAAA6LcBACABAAAAAAAA/wAAAOi3AQAiAQAAAAAAAP8AAADotwEAIwEA
-AAAAAAD/AAAA6LcBACQBAAAAAAAA/wAAAOi3AQAlAQAAAAAAAP8AAADotwEAJgEAAAAAAAD/AAAA
-6LcBACcBAAAAAAAA/wAAAMSjAQAU0gAAAAAAAP//DwDotwEAggEAAAAAAAD/AAAA6LcBAIMBAAAA
-AAAA/wAAAOi3AQCEAQAAAAAAAP8AAADotwEAhQEAAAAAAAD/AAAA6LcBAIYBAAAAAAAA/wAAAOi3
-AQCHAQAAAAAAAP8AAADotwEAiQEAAAAAAAD/AAAA6LcBAIoBAAAAAAAA/wAAAOi3AQCLAQAAAAAA
-AP8AAADotwEAjAEAAAAAAAD/AAAA6LcBAI0BAAAAAAAA/wAAAOi3AQCOAQAAAAAAAP8AAADEowEA
-CNIAAAAAAAD//wMABKQBAACCAAAAAAAA/wEAAASkAQABggAAAAAAAP8BAADEowEACdIAAAAAAAD/
-/wMABKQBAAKCAAAAAAAA/wEAAASkAQADggAAAAAAAP8BAADEowEACtIAAAAAAAD//wMABKQBAASC
-AAAAAAAA/wEAAASkAQAFggAAAAAAAP8BAADEowEABtIAAAAAAAD/AQAAxKMBAAfSAAAAAAAA/wMA
-AMSjAQAG0gAACQAAAAD+AwDEowEAB9IAAAoAAAAA/A8AxKMBAAbSAAASAAAAAAD8B8SjAQAH0gAA
-FAAAAAAA8D/EowEAFdIAAAAAAAD/AwAAxKMBAAzSAAAAAAAA/wEAAMSjAQAV0gAACgAAAAD8DwDE
-owEADNIAAAkAAAAA/gMAxKMBABXSAAAUAAAAAADwP8SjAQAM0gAAEgAAAAAA/AcwgAAAqqqqqjGA
-AACqqqqqMoAAAACqqqozgAAAAAAAADSAAAAAAAAANYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAA
-AAAAAAA5gAAAAAAAADqAAAAAAAAAO4AAAAAAAAA8gAAAAAAAAD2AAACqqgoAPoAAAKqqqqo/gAAA
-qqqqqkCAAAAAAAAAMIAAAKqqqqoxgAAAqqqqqjKAAAAAqqqqM4AAAAAAAAA0gAAAAAAAADWAAAAA
-AAAANoAAAAAAAAA3gAAAAAAAADiAAAAAAAAAOYAAAAAAAAA6gAAAAAAAADuAAAAAAAAAPIAAAAAA
-AAA9gAAAqqoKAD6AAACqqqqqP4AAAKqqqqpAgAAAAAAAADCAAAAAAAAAMYAAAAAAAAAygAAAAAAA
-ADOAAAAAAAAANIAAAKqqqqo1gAAAqqqqqjaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAA
-OoAAAKqqqgo7gAAAqqqqqjyAAAAAAAAAPYAAAAAAAAA+gAAAAAAAAD+AAAAAAAAAQIAAAAAAAAAw
-gAAAAAAAADGAAAAAAAAAMoAAAAAAAAAzgAAAAAAAADSAAACqqqqqNYAAAKqqqqo2gAAAAAAAADeA
-AAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAACqqqoKO4AAAKqqqqo8gAAAAAAAAD2AAAAAAAAAPoAA
-AAAAAAA/gAAAAAAAAECAAAAAAAAAHNIN0hHSENIC0gHSA9Ib0gvSAIAF0hLSE9IU0gRDBtIH0gTS
-cNIAALUAGgGBAQUABAAGAAgACQAKAAsADACDAJIA6AD3AE4BXQEPAATSDdIR0hDSAtIB0gPSG9IA
-gAXSC9IS0hPSFNIEQ3DSAAAAAAEAAAD///////////////8DAAAAAgAAAAMAAAADAAAAAAAAAP//
-//8AAAAAAAAAAAAAAAD/AwAAAAAAALUAGgGBAQQADwAGAAgACQAKAAsADAAAAAAAAAAAACwAAQAV
-ABUAFQABAAEAAQAAADgAAABoAAAAdAAAAIAAAACMAAAAnQAAAAcAAAAEAAAACAAAABAAAABAAAAA
-gAAAACAAAAAAAAAACQAAABIAAAAAAAAACgAAABQAAAAc0g3SEdIQ0gLSAdID0hvSC9IAgAXSEtIT
-0hTSBEMG0gfSBNIJEAAAtQAaAYEBBQAEAAYACAAJAAoACwAMAIMAkgDoAPcATgFdAQ8ALgAAAGwA
-AAB0AAAAgAAAAIwAAACdAAAABwAAAAQAAAAIAAAAEAAAAEAAAACAAAAAIAAAAAAAAAAJAAAAEgAA
-AAAAAAAKAAAAFAAAADgAAABoAAAAdAAAAIAAAACMAAAAnQAAAAcAAAAAAAAAAAAAAAoAAAAN0hHS
-ENIC0gHSA9Ib0gvSAIAF0hLSE9IU0gRDCNIJ0grSHNIG0gfScNIAAAEAAAAAAAAAAAAAAAAAAAAD
-AAAABAAAAAMAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAD/AwAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAALUAGgGBAQQADwCDAOgATgGSAPcAXQEGAAgACQAKAAsADAAFAAAAAAAAACwAAQAA
-AAAAAAAAAAAAAAAAAAAAAAABAAEAAQAAAP////8AAAAALQEAAN0BAABaAgAAugIAAAoDAABNAwAA
-hwMAALoDAADoAwAAEQQAADcEAABZBAAAegQAAJgEAAC0BAAAzgQAAOcEAAD+BAAAFQUAACoFAAA+
-BQAAUQUAAGQFAAB1BQAAhgUAAJcFAACnBQAAtgUAAMUFAADTBQAA4QUAAO4FAAD7BQAACAYAABQG
-AAAgBgAAKwYAADcGAABCBgAATAYAAFcGAABhBgAAawYAAHUGAAB+BgAAiAYAAJEGAACaBgAAogYA
-AKsGAAC0BgAAvAYAAMQGAADMBgAA1AYAANsGAADjBgAA6gYAAPIGAAD5BgAAAAcAAAcHAAAOBwAA
-FAcAABsHAAAiBwAAKAcAAC4HAAA1BwAAOwcAAEEHAABHBwAATQcAAFMHAABYBwAAXgcAAGQHAABp
-BwAAbwcAAHQHAAB5BwAAfwcAAIQHAACJBwAAjgcAAJMHAACYBwAAnQcAAKIHAACnBwAAqwcAALAH
-AAC1BwAAuQcAAL4HAADCBwAAxwcAAMsHAADQBwAA1AcAANgHAADcBwAA4QcAAOUHAADpBwAA7QcA
-APEHAAD1BwAA+QcAAP0HAAABCAAABQgAAAgIAAAMCAAAEAgAABQIAAAXCAAAGwgAAB8IAAAiCAAA
-JggAACkIAAAtCAAAMAgAADQIAAA3CAAAOwgAAD4IAABBCAAARQgAAEgIAABLCAAATwgAAFIIAABV
-CAAAWAgAAFsIAABfCAAAYggAAGUIAABoCAAAawgAAG4IAABxCAAAdAgAAHcIAAB6CAAAfQgAAIAI
-AACCCAAAhQgAAIgIAACLCAAAjggAAJEIAACTCAAAlggAAJkIAAA4AAAAaAAAAHQAAACAAAAAjAAA
-AJ0AAAAHAAAAAAAAAAAAAAAKAAAADdIR0hDSAtIB0gPSG9IL0gCABdIS0hPSFNIEQwjSCdIK0hzS
-BtIH0nDSAAABAAAAAAAAAAAAAAAAAAAAAwAAAAQAAAADAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAA
-AAAA/wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1ABoBgQEEAA8AgwDoAE4BkgD3AF0B
-BgAIAAkACgALAAwABQAAAAAAAAAsAAEAAAAAAAAAAAAAAAAAAAAAAAAAAQABAAEAAADfAAAAGQEA
-AGIBAAC+AQAAMgIAAMMCAAB7AwAAYgQAAIQFAADyBgAAvggAAAILAAABAAAAAgAAAAAAAAAL0g7S
-DdII0gnSCtIS0hPSFNIR0hDSAtIB0gPSAIAF0gRDG9Ic0gTSAEUw0jHSAAAAAAAAAQAAAAEAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAABwAAAAAAAAADAAAABAAAAAMAAAAAAAAA/wMAAAMA
-AAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAALUAGgGBAQUABAAPABAACgALAAwATgAA
-AAAAAAAAAAAALAABAAAAAQABAAEAAAAAAAAAAAABAAEAAgACAAIAAwADAAQABAAFAAUABgAGAAcA
-BwAIAAgACQAJAAoACgALAAsADAAMAA0ADQAOAA4ADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQFgACQmoAAGAAAAFCagAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAMz/AQAGAAAAzC6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAARAWAAJCagAAYAAAAUJqAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-6AsCAAQAAADMLoAAAAAAAAAAAAAAAAAAwAoCAAQAAADMLoAAAAAAAAAAAAAAAAAAsAwCAAYAAADM
-LoAAAAAAAAAAAAAAAAAAwAoCAAQAAADMLoAAAAAAAAAAAAAAAAAA6AsCAAQAAADMLoAAAAAAAAAA
-AAAAAAAAwAoCAAQAAADMLoAAAAAAAAAAAAAAAAAA6AsCAAQAAADMLoAAAAAAAAAAAAAAAAAAwAoC
-AAQAAADMLoAAAAAAAAAAAAAAAAAAsAwCAAYAAADMLoAAAAAAAAAAAAAAAAAAwAoCAAQAAADMLoAA
-AAAAAAAAAAAAAAAA6AsCAAQAAADMLoAAAAAAAAAAAAAAAAAAsAwCAAYAAADMLoAAAAAAAAAAAAAA
-AAAA6AsCAAQAAADMLoAAAAAAAAAAAAAAAAAA6AsCAAQAAADMLoAAAAAAAAAAAAAAAAAAsAwCAAYA
-AADMLoAARAWAAJCagAAYAAAAUJqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgMEBAQEBAUGBwgICAgICQoLDA0AAAAFBgcI
-DQ4PEBUWFxgZAAAKDREUCg0RFBkZGRkKCgAAAAAAAAYGBgYJCQkJAAYAAG47aDtiO1w7bjpoOmI6
-XDpuOWg5YjlcOW4raCtiK1wrbipoKmIqXCpuKWgpYilcKW4baBtiG1wbbhpoGmIaXBpuGWgZYhlc
-GW4YaBhiGFwYbhdoF2IXXBduFmgWYhZcFm4VaBViFVwVbhRoFGIUXBRuE2gTYhNcE24SaBJiElwS
-bhFoEWIRXBFuEGgQYhBcEFcQUhBNEEkQbgFoAWIBXAFuAGgAYgBcAG47aDtiO1w7bjpoOmI6XDpu
-OWg5YjlcOW44aDhiOFw4bjdoN2I3XDduKWgpYilcKW4oaChiKFwobidoJ2InXCduGWgZYhlcGW4Y
-aBhiGFwYbhdoF2IXXBduCWgJYglcCW4IaAhiCFwIbgdoB2IHXAduBmgGYgZcBm4FaAViBVwFbgRo
-BGIEXARuA2gDYgNcA24CaAJiAlwCbgFoAWIBXAFuAGgAYgBcAAAAAAAAAAAAAAAAAEArAgAIAAAA
-DC+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////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////////////////////////////////////////////////////
-//////////////////////////8BBAAAAgUBAAMGAgAEBwMABQgEAAYJBQAHCgYACAsHAAkMCAAK
-DQkACw4KAAwPCwANEAwADhENAAFAAAQCQQEEA0ICBARDAwQFRAQEBkUFBAdGBgQIRwcECUgIBLcT
-IgC4FCMAuRUkALsWJQC8FyYAvRgnAMAZKADEGikABxsAAAgcAQALHQIADB4DABAfBAAiIQUAJCIG
-ACYjBwAoJAgAKiUJACwmCgAuJwsAMCgMADQpDQA4Kg4APCsPAEAsEABkLhEAaC8SAGwwEwBwMRQA
-dDIVAHgzFgB8NBcAgDUYAIQ2GQCINxoAjDgbAJE6HACVOx0AmTweAJ09HwChPiAApT8hACRJBgIs
-SgoCNEsNATxMDwFkTREBbE4TAXRPFQF8UBcBhFEZAZVSHQGdUx8BAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAABBgIGBgYDBgYGBgYGBgQAAAAAA8APwABAAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/
-AAEAAAAPAD8AAQAAAA8APwACAAAADwA/AAEAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAQAAAACAAAA
-BQAAAA8UGR4oCgUAsAkBpQA8ODQwLCgkIBwYFBAMCAQADAgEADw4NDAsKCQgHBgUEAwIBAIIAA4A
-AAAOAQEAAQIBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AKXGhPiZ7o32Df+91rHeVJFQYAMCqc59VhnnYrXmTZrsRY+dH0CJh/oV7+uyyY4L++xBZ7P9X+pF
-vyP3U5bkW5vCdRzhrj1qTFpsQX4C9U+DXGj0UTTRCPmT4nOrU2I/KgwIUpVlRl6dKDChNw8KtS8J
-DjYkmxs93ybNaU7Nf5/qGxKeHXRYLjQtNrLc7rT7W/akTXZht859e1I+3XFelxP1pmi5AAAswWBA
-H+PIee22vtRGjdlnS3LelNSY6LBKhWu7KsXlTxbtxYbXmlVmlBHPihDpBgSB/vCgRHi6JeNL86L+
-XcCAigWtP7whSHAE8d9jwXd1r2NCMCAa5Q79bb9MgRQYNSYvw+G+ojXMiDkuV5PyVYL8R3qsyOe6
-KzKV5qDAmBnRnn+jZkR+VKs7gwvKjCnH02s8KHmn4rwdFnatO9tWZE50HhTbkgoMbEjkuF2fbr3v
-Q6bEqDmkMTfTi/Iy1UOLWW632owBZLHSnOBJtNj6rAfzJc+vyo706UcYENVviPBvSnJcJDjxV8dz
-UZcjy3yhnOghPt2W3GGGDYUPkOBCfMRxqszYkAUGAfcSHKPCX2r5rtBpkRdYmSc6uSc42RPrsysz
-IrvScKmJB6czti0iPJIVIMlJh/+qeFB6pY8D+FmACRca2mUx18aEuNDDgrApd1oRHst7/KjWbTos
-AQEBAQEBAQECAgICAgICAgMDAwMDAwMDBAQEBAQEBAQBAgICAgICAwMDAwMDAwMDAwMDAwMEBAQE
-BAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAQECAQICA3//Bw8fPwEDAQMPBwEHDx8/f///BQAHAgME
-BgZ00UUX6KKLLg0PBQcJCwEDChQ3blVVVQFLaC8BVVVVBeM4jgOqqqoCcRzHAaqqqgrHcRwHDw8P
-BwYHAgMEBQABCAkLCigAKAAwACwALAAoADwANAAoACgANAAwACwALABEADwAQAA8AIwAbABYAEgA
-9ACwACwALAA8ADQAMAAsAFQARABUAFQAbABgAFwAVACMAHgAOgECAdUA3wDaAKIAdQB/AGoBGgHZ
-AOgACgG6AHkAiACKBSoDOQGoAYoFygLZAEgBygFKAeIA+QDKAeoAggCZAPQCRAK1AdUBlAKEAfUA
-QQKsAJAAhACAAHgAeAB4AHQAZuYAAJ3YiZ1O7MRONEiDNCd2YicapEEaEzuxExEYgREP/MAPTuzE
-Tid2YicapEEaEzuxEw3SIA2JndgJCIzACAd+4Ac0SIM0GqRBGhEYgREN0iANCIzACAZpkAawstUF
-BVRABSd2YicTO7ETDdIgDYmd2AkGaZAGxE7sBARGYAQDP/ADqqqqqhqkQRoTO7ETD/zADxEYgREN
-0iANCqiAChM7sRMP/MAPD/zADw3SIA0LtEALC7RAC4md2AkN0iANCqiACgqogAoIjMAIB3iABwd4
-gAcGaZAGD/zADw3SIA0LtEALDdIgDQu0QAuJndgJCIzACImd2AkIjMAIB37gBwd+4AfBLCkHCqiA
-CgiMwAgHeIAHCIzACAd4gAcGaZAGsLLVBQZpkAawstUFBVRABQVUQAXWHcYEQAOABsAJAA2AEwAa
-QB2AIIAGAA2AEwAaACcANIA6AEHACYATQB0AJ4A6AE7AV4BhmQMzB9kKcw6mFeYcgCAZJDMHcw6m
-FeYcWSvMOQBBM0jZCqYVgCBZKwBBplaAYVlsMAAAADYAAAAMAAAAEgAAABgAAAAkAAAABgAAAAkA
-AAAAAAAAAAAAABggFBQODhQUBQYBAgMEAAAAAQECAQICAwQMDAgEDAQEQAAAAIAAAAAAAQAAAAIA
-AEAAAAAABAAAQAAAAEAAAAAQERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uL0BBQkNERUZH
-SElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8z
-EwAAAAcHDwcPDxctAA8gAPBhAAAAAAAAAAAAAAECBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDk6NDk6MDkAAAAATi2uAGmu
-oK6QrmIAAaysegCskpusrF8ACQAAAAIAAAAAAAAAAAAAAAkAAAACAAAAAAAAAAAAAAAJAAAAAwAA
-AAEAAAAJAAAACQAAAAIAAAACAAAACQAAAAECAQIDBAAABQYHCAkKAAAABQYAAgQABQAAAAAABQcB
-AwQABQEAAABAI0AlISEhIUBAQEBABQQEAQFAQEBABQVAQAwMQA0MDAEBAQVAQAUFAAQABEBAAARA
-QEAFQEBAQEAFQEBABQUFAQEBAUAFBQUBBQEBQAUFBUAFQAUFBQUFBAAAABwRAAAcMgAAHDMAAAQA
-AAAcFQAAAgAXAGwAcAR0CHQMAAQEBgAAAAAAAAAAZAAAAACQAQAKAAAAAAAAAAAAAAAAAAAA/wAA
-AAAAAAAAAAAAAAAAAAAAAAABAAAAEAAAAAAAAAABAAAAAQAAAAAAAAD/AAAA/wAAAAAAAAAAAAAA
-HHsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAAABAAAZAAAAIyB
-AQCUgQEAnIEBAPCBAQD4gQEAAIIBAAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH
-BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwYGBgYGBQUFBQUEBAQEBAMDAwMDAgICAgIBAQEBAQAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiVDvU56
-lQAHFCdZLgAAAAQOCR0tNwAABA4JHSw7AAEQAAEAAAACgAABQgYCEAACIAAAA8AAAUMGAxAAAsAA
-AAPAAAFDBgQQAAJAAAACgAABRAYFEQAAQAAAA8AAAUUGBhEAAOAAAAPAAAFFBgcRAAEAAAACgAAB
-RgYIEQACIAAAA8AAAUcGCREAAsAAAAPAAAFHBgoRAAJAAAACgAABSAYLEgAAQAAAA8AAAUkGDBIA
-AOAAAAPAAAFJBg0SAAEAAAACgAABSgYOEgACAAAAAoAAAUwGAAAiFgAAgAAAAwAAAVkAJBYAAQAA
-AAMAAAFaACYWAAIAAAAEAAABWgAoFgACAAAAAwAAAVsAKhYAAoAAAAMAAAFcACwXAAAAAAAEAAAB
-XAAuFwAAgAAAAwAAAV0AMBcAAQAAAAMAAAFeADQXAAIAAAADAAABXwA2FwACgAAAAwAAAWAAOBgA
-AAAAAAQAAAFgADwYAAEAAAADAAABYgA+GAACAAAABAAAAWIAQBgAAgAAAAMAAAFjAGQbAAIAAAAD
-AAABbwFmGwACgAAAAwAAAXABaBwAAAAAAAQAAAFwAWwcAAEAAAADAAABcgFuHAACAAAABAAAAXIB
-cBwAAgAAAAMAAAFzAnQdAAAAAAAEAAABdAJ2HQAAgAAAAwAAAXUCeB0AAQAAAAMAAAF2AnwdAAIA
-AAADAAABdwN+HQACgAAAAwAAAXgDgB4AAAAAAAQAAAF4A4QeAAEAAAADAAABegOGHgACAAAABAAA
-AXoEiB4AAgAAAAMAAAF7BIwfAAAAAAAEAAABfASRHwABQAAAAwAAAX4ElR8AAwAAAAQAAAF/BZcf
-AALAAAADAAABgAWZIAAAQAAAAwAAAYEFnSAAAUAAAAMAAAGCBZ8gAAHAAAADAAABgwWhIAADAAAA
-BAAAAYMFpSEAAEAAAAMAAAGFBQAAAAAAAAAAAAAADgoODAAAAKwEAgDABAIAKAUCAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAEBAQEBAQEBAgICAgICAgIDAwMDAwMDAwEC
-AAAOAAAAKgAAAAkAAAALAAAAFfZj9rD2/PZG95D32Pcf+GX4qfjt+C/5cPmw+e75K/pn+qL63PoU
-+0v7gfu2++r7HPxN/H38q/zZ/AX9MP1Z/YL9qf3P/fT9F/45/lr+ev6Y/rb+0v7t/gb/Hv81/0v/
-YP9z/4X/lv+m/7T/wf/N/9j/4f/p//D/9v/6//3//////////f/6//b/8P/p/+H/2P/N/8H/tP+m
-/5b/hf9z/2D/S/81/x7/Bv/t/tL+tv6Y/nr+Wv45/hf+9P3P/an9gv1Z/TD9Bf3Z/Kv8ffxN/Bz8
-6vu2+4H7S/sU+9z6ovpn+iv67vmw+XD5L/nt+Kn4Zfgf+Nj3kPdG9/z2sPZj9nC5g7qWu6q8vr3S
-vue//MARwifDPcRTxWrGgMeXyK/Jxsrey/bMD84nz0DQWdFy0ozTptS/1drW9NcO2SnaRNtf3Hrd
-lt6x383g6eEF4yHkPuVa5nfnk+iw6c3q6usH7STuQu9f8H3xmvK489X08/UR9y/4TPlq+oj7pvzE
-/eL+AAAeATwCWgN4BJYFtAbRB+8IDQorC0gMZg2DDqEPvhDcEfkSFhQzFVAWbReJGKYZwhrfG/sc
-Fx4zH08gaiGGIqEjvCTXJfImDCgmKUEqWit0LI4tpy7AL9kw8TEKMyI0OjVRNmk3gDiWOa06wzvZ
-PO89BD8ZQC5BQkJWQ2pEfUXFC2QSUJ0bEr9g1RHqPJERIxpPERviDhHKf9AQWN+TEAXuWBAamh8Q
-1NLnD1aIsQ+Zq3wPWy5JDxgDFw/6HOYO0W+2DgTwhw6NkloO7kwuDigVAw624dgNgamvDeBjhw2P
-CGANqI85DZ3xEw05J+8MlCnLDBTypwxmeoUMerxjDIOyQgzxViIMbKQCDNWV4wtBJsUL91CnC20R
-igtGY20LUkJRC4eqNQsDmBoLCgcACwP05Qp2W8wKDDqzCo2MmgreT4IKAYFqChAdUwpDITwK6Iol
-CmVXDwo3hPkJ7w7kCTb1zgnFNLoJbMulCQm3kQmP9X0JAYVqCXBjVwkBj0QJuVsZAGoRGQD0xxgA
-Vn8YAIw3GACV8BcAbqoXABRlFwCFIBcAwNwWAMGZFgCGVxYADhYWAFXVFQBalRUAG1YVAJQXFQDF
-2RQArJwUAEVgFACPJBQAiOkTAC6vEwB/dRMAejwTABsEEwBhzBIAS5USANZeEgABKRIAyvMRAC6/
-EQAtixEAxFcRAPEkEQC08hAACsEQAPGPEABoXxAAbi8QAAAAEAAd0Q8Aw6IPAPJ0DwCmRw8A4BoP
-AJzuDgDawg4AmZcOANZsDgCQQg4AxxgOAHjvDQChxg0AQ54NAFt2DQDoTg0A6CcNAFsBDQA+2wwA
-krUMAFOQDACCawwAHUcMACIjDACR/wsAaNwLAKa5CwBKlwsAU3ULAL9TCwCOMgsAvRELAE3xCgA8
-0QoAibEKADOSCgA5cwoAmlQKAFQ2CgBnGAoA0foJAJPdCQCqwAkAFqQJANWHCQDnawkAS1AJAAE1
-CQAGGgkAWv8IAPzkCADryggAJ7EIAK+XCACBfggAnWUIAAFNCACuNAgAohwIAN0ECABd7QcAItYH
-ACy/BwB4qAcAB5IHANh7BwDqZQcAPFAHAM06BwCeJQcArBAHAPj7BgCB5wYARdMGAEW/BgB/qwYA
-9JcGAKGEBgCHcQYApl4GAPtLBgCHOQYASicGAEEVBgBuAwYAz/EFAGPgBQArzwUAJb4FAFGtBQCu
-nAUAPIwFAPp7BQDoawUABVwFAFBMBQDKPAUAcS0FAEQeBQBFDwUAcQAFAMnxBABM4wQA+dQEANDG
-BADRuAQA+qoEAE2dBADHjwQAaYIEADJ1BAAiaAQAOFsEAHROBADVQQQAXDUEAAYpBADWHAQAyBAE
-AN4EBAAX+QMAc+0DAPHhAwCQ1gMAUcsDADLAAwA0tQMAV6oDAJmfAwD7lAMAfIoDABuAAwDZdQMA
-tmsDAK9hAwDHVwMA+00DAExEAwC5OgMAQjEDAOgnAwCoHgMAhBUDAHoMAwCLAwMAtvoCAPvxAgBZ
-6QIA0eACAGLYAgAM0AIAzscCAKi/AgCatwIAo68CAMSnAgD8nwIAS5gCALCQAgAsiQIAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAA5////87///+1////nP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AOf////O////tf///5z///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn////zv///7X///+c////
-EwEAAOEAAACvAAAAfQAAAH0AAACvAAAAyAAAAMgAAADIAAAAyAAAABMBAADhAAAArwAAAH0AAAB9
-AAAArwAAAMgAAADIAAAAyAAAAMgAAAATAQAA4QAAAK8AAAB9AAAAfQAAAK8AAADIAAAAyAAAAMgA
-AADIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJYAAACWAAAAlgAA
-AJYAAACWAAAAfQAAAH0AAAB9AAAAfQAAAH0AAACWAAAAlgAAAJYAAACWAAAAlgAAAH0AAAB9AAAA
-fQAAAH0AAAB9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF4BAAAs
-AQAAEwEAAPoAAADhAAAAyAAAAK8AAAB9AAAAZAAAAGQAAABeAQAALAEAABMBAAD6AAAA4QAAAMgA
-AACvAAAAfQAAAGQAAABkAAAAAAAAAP////8AAAAAAAAAAAEAAAAAAAAAYAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAA
-AAAAAAUFBQUFBQUFAAAAAIANAAAAIAAAgA0AAIANAAAAIAAAgA0AAAAGAAAABAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAA=
-====
diff --git a/sys/contrib/dev/iwn/iwlwifi-6000-9.193.4.1.fw.uu b/sys/contrib/dev/iwn/iwlwifi-6000-9.193.4.1.fw.uu
new file mode 100644
index 000000000000..2cfa6cc6ab9e
--- /dev/null
+++ b/sys/contrib/dev/iwn/iwlwifi-6000-9.193.4.1.fw.uu
@@ -0,0 +1,8152 @@
+Copyright (c) 2006-2010, 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-6000-9.193.4.1.fw.uu
+AQTBCf5MAAAUSAIAAEABAJhFAgAAQAEAAAAAACAggA8AAEAAaSAAAGkgQABpIAAAaSBAACAggA8A
+AOgAaSAAAGkgQABpIAAAaSBAACAggA8AAHgGaSAAAGkgQABpIAAASiAAAEohAABKIgAASiMAAEok
+AABKJQAASiYAAEonAABKIAAQSiEAEEoiABBKIwAQSiQAEEolABBKJgAQSicAEEogACBKIQAgSiIA
+IEojACBKJAAgSiUAIEomACBKJwAgSiAAMEohADAKJIA/gQAAQEEsnDBALJwwQiQcNAoigD+AADCD
+CiMANz4IQABKJgBwaSBAAEomAHBKJgBwSiYAcEomAHAAFgBwgABkBEB4ICBAhwAAAAAAAAAAAADh
+wOHB4cLPcKAAyB8WEAGGz3KAAJiXIKISEAGGIaITEAGGIqIUEAGGI6IVEAGGJKIkEAGGJqLPcZ8A
+uP9WoYoh/w8SGFiAExhYgBQYWIAVGFiAJBhYgMHCwcHBwCAgQIcMyM9yoADIHw4aGIANyA8aGIAO
+yBAaGIAPEgE2AcgkeBEaGIAQyC0aGIDgfuHE/BzIvvwcSL7hwOHB4cLhw/wcCLH8HEix/ByIsfwc
+yLH8HAiy/BxIsvwciLL8HMiy/BwIv2okgBDhxGokwBDhxPHAz3CgANAbFIDPcYAAYAQEIICPz1EE
+4QChCvIvKQEAz3CAANwN8CBAAEB42v/RwMHEayTAEMHEaySAEMHEn3QEFAs0BBQKNAQUCTQEFAg0
+BBQHNAQUBjQEFAU0BBQENMHDwcLBwcHAwcRFLH4QCiZAfsHEaySAFMHEICBAhwzIh7gMGhgwDcib
+uA0aGDAOyA4aGDAPyIe4DxoYMBDIEBoYMOB+4HjxwAzIlbgMGhgwDcibuA0aGDAPyIq4jbiQuA8a
+GDDPcIAAHA8YiIHgC/QPyM9xAAD0DKy4DxoYMJYOIAAP2GfYdgsgAYohRwbRwOB+8cDPcIAAsMcA
+gIYg/oEJ9A/IBSCADwAAANQPGhgwof+KIFUFRgsgAYohhwro8eB4z3EDAEANz3CgAKggLaDPcYAA
+jARAgQFqAKHPcKAAOC4FgAQggA/AAAAA13DAAAAACvJI2M9xnwC4/xqhW6Fp2Bi4GaHPcIAAaAgl
+gCOBIIHHcQAAiBNFBsAJ4HjPcIAAaAjVBcAJ4HjxwLIMAAGA4M93gABgBIh1BfKB4AX0AdgC8ADY
+C6+A4QXygeEF9AHYAvAA2AqvgOIF8oHiBfQB2ALwANgMrwDYz3agAMgfGB4YkAuPgOCKIRAAD/II
+j4DgC/LPcAMAQA1FHhgQMKYC2BgeGJAC8DGmCo+A4BnyCY+A4Bfyz3ACABJIIB4YkM9wgAAoACEe
+GJDPcIAAXAQiHhiQGBYAlkUgAAMYHhiQDI+A4AjyGBYAloUgAQQYHhiQgeMH9BgWAJaIuBgeGJDP
+cIAAMIwAkI7gzCCiggb0GBYAloC4GB4YkIDlGfIA2JS4z3WAAIAEAKVx2Aa4+g0gAfzZIIXPcAAA
+TBzuDSABn7kYFgCWhbgYHhiQCQQAAeB4z3Gqqru7z3CfALj/NqA2oDagNqDPcaAAyDsOgYi4DqFp
+IEAA/vHgePHApcFBwELBDBwAMRAcQDHPcYAAfIQ0GcAPMBkADywZwA4oGYAOJBlADs9wgAB8hCAY
+QAvPcIAAfIQcGAALz3CAAHyEGBjACs9wgAB8hBQYgArPcIAAfIQQGMAIz3CAAHyEDBiACM9wgAB8
+hAgYQAjPcYAAAISAGQAIfBnAB3gZgAd0GUAHcBkAB2wZAAdoGYAGZBlABmAZAAZcGcAFWBmABVQZ
+QAVQGQAFTBnABEgZgAREGUAEQBkABO+hzqGtoYyhLBnAAigZgAIkGUACIBkAAhwZwAEYGYABFBlA
+ARAZAAFjoWogAAPYGQAAaiDAAtQZAABqIIAC0BkAAGogQAHIGQAAaiAAAcQZAABqIMAAwBkAAGog
+gAC8GQAAaiBAALgZAABqIAAAtBkAAGoggAHMGQAA0NifuM9xnwC4/x2hz3CAAAAAxIBTJcQ1UybF
+Nde6AebTvsSgUyPABAUmjh/Q/gAA1qEFIIAPsP4AABahGIFTJ841AN2UuBihQMMBwALByXMMFAYw
+WgggARAUBzDPcKAAtA+8oM9xoADIOy6B8g/gAH3YcgiAAU4MIAGpcAjYANn6CyABmbnPcIAAMIwA
+kI7gzCCigsoggQ/gAMQxyiEhACQJYQHPIaEF/QXP//HAagkgAXvYqg/gAPDZz3GAAHyENBnADzAZ
+AA8sGcAOKBmADiQZQA7PcIAAfIQgGEALz3CAAHyEHBgAC89wgAB8hBgYwArPcIAAfIQUGIAKz3CA
+AHyEEBjACM9wgAB8hAwYgAjPcIAAfIQIGEAIz3GAAACEgBkACHwZwAd4GYAHdBlAB3AZAAdsGQAH
+aBmABmQZQAZgGQAGXBnABVgZgAVUGUAFUBkABUwZwARIGYAERBlABEAZAATvoc6hraGMoSwZwAIo
+GYACJBlAAiAZAAIcGcABGBmAARQZQAEQGQABY6FqIAAD2BkAAGogwALUGQAAaiCAAtAZAABqIEAB
+yBkAAGogAAHEGQAAaiDAAMAZAABqIIAAvBkAAGogQAC4GQAAaiAAALQZAABqIIABzBkAAAogwCfP
+daAAyB8ZFRKWz3AAAEQcvghgAQohwC96cM9wgAAcQSOAz3afALj/z3CAAAAARICA4QHiUyLDBCTy
+GRUCllEiwIAe8l2GQN+fv/2mZKAFI4MP0P4AAHamWB6AFyEVAJYiFQCWBCGBD/8A/P8AgRamCNgZ
+HRiQVqZdpvkHwADQ2Z+5PaZkoAUjgw/Q/gAAdqYH2DoIYAEKuFMgQQcH2PoJIAEKuM9woADUCxiA
+QiAACEggAADPd4AAgAzPcYAAgAQggdQfABALIcCEyiUiE8ogYgAy9EwigKAP9FEjgKUJ8oDgB/RB
+K00lwL0c5QHYJPAE3SHwjCIEoBzyTCIAohTyCvZMIkCgDvJMIgChFPQT3RPwTCIApAryjCIBoAz0
+Ft0L8A3dCfAU3QfwFd0F8BfdA/AP3QDYgeAG9FgewBSyCkACcYepcCpxCnIKJIAEnQPv/wolwATt
+Ac//8cBeDcAAddgaDeAAiiFKD8IMAAAaCMACS/6iCAAACiHAD+tyBtiKI4sDSiQAAGUD7/8KJQAB
+4HiA4fHAA/Kg4Iv2CiHAD+tyBdj020okQABBA+//uHPPcoAA3A0VeiCi0cDgfgDZnrkZec9ygADU
+DQGCJXjgfwGiANmeuRl5z3KAANQNAYImeOB/AaIA2Z65GXnPcIAA1A0BgCR4QiAAgOB/yiBiAOB4
+z3CAANQNAYDgfy8oAQDgePHAog+P/+B44HjgeOB4aSCAAW8hPwBpIAAA9/HxwGrYSgzgAIohBAYA
+2I24NglgBQoaGDAUzIYg/4oJ8s9wgAAYBQCIgOCcDkIFsPHxwMIOQAXPcYAAgAjwIQAAQHjPcKAA
+0BuA2lCgz3CAAAAAAIBRIACCANkG8s9wnwC4/z2glPHgePHAxg3AAM9xgAAAAACBUSDAgBvyAYFR
+IMCAQNjPIOIHyiCBDwAA0ADPIOEHz3KfALj/HaIEgQHg07gEoQUggA/Q/gAAFqLPcIAAYASggM9w
+gAAcDwiABCWNHw8AAODruAHeBvT+CwAMgOAO9M9xoAC0RwDYSxkYgHcZmIMA2J64VBkYgM9ygACY
+BCCC4YIEJYQfAQAAAEAsgACkeAQlgx8AAABAB3kDuyCipHsEeWd/BiVAEOGiBCWBHwAAAIAvIgIB
+RXkCueR7BCWNHwIAAABmeKR5JngvKAEATiBBBM9wgAB0g/AgQgDPcIAATM2EKgsMMCBADlMgQIAb
+GlgwLfTPcJ8AuP84oIbhGfTPcoAAiJYJkoDgDPIbGpgzyXHPcoAAgAwcggHgHKIX8AySgOAT8gTZ
+GxpYMPPxhOHMIWKAC/TPcIAAiJYOkIDgBfIG2RsaWDDl8c9yoAAUBCqiz3CAAOQHAIiB4AX0CYK4
+4ADYgvcB2IDgCPTPcKAAiCA1eMCgOfDPcYAAIAUA2AChANmRuc9woADIHxMYWIDPcIAA0AIQeM91
+oAC0R0kdGJDPcYAAZKbPcIAAJAUgoG8nQxBUHdiTGg8gBQoamDOWCgAMgOAR9ADYkbjPcaAAyB8T
+GRiAz3CAAAAEEHhJHRiQVB3Ykz0EwADgePHAzgvAAM9xgABYDYARAADPdaAAyB8vLgEQz3ADAEAN
+n+ZFHRgQAN8f8s9ygAAAAACC8rgZ8gGC8rhA288j4gfKI4EPAADQAM8j4QfPcJ8AuP99oGSCAePT
+u2SiBSODD9D+AAB2oPAhgANAeJ/mDPLPcIAAAAAAgPK4BvLPcJ8AuP/9oIDYFR0YkK0DwADgePHA
+z3GAAGAEfNhWCeAAIIEKIcAP63IF2IojhANKJAAArQev/wolAAHxwOHFz3CAAGAEoIBr2AQljR8P
+AADgIgngAIohCAgvKEEDGgjgD04gQAQKJQCAyiHCD8oiwgfKIGIByiOCDwAAJgJkB6L/yiRiAH/Y
+CrjPcaAA0BsToX/YEKE1A8AA4HjxwOHFz3WAAAAAAIXvuBryAYXvuEDYzyDiB8oggQ8AANAAzyDh
+B89xnwC4/x2hBIUB4NO4BKUFIIAP0P4AABaha9iWCOAAiiHIDJIPoA8E2AolAIDKIcIPyiLCB8og
+YgHKI4IPAAA1AtwGov/KJGIAAIXvuAbyANnPcJ8AuP89oK0CwABKJAB2ANmoIMADz3CAAFwONnhh
+gECAz3CAAFgNAeFVeGCg4H7gfuB4USFAxwXyDci9uA0aGDAA2Z25z3CgANAbMaDgfuB+4HjxwIHg
+zCCigAX0z3KAABwPBPDPcoAAYMrPcYAAtJeB4Mwg4oAp9GiCYKFpgmGhfIpoqX2KaakqEoMAaqkr
+EoMAa6ksEoMAbKl0knapbZJnsXeSaLFogsC7dKloggQjgw8ABgAAgOMB28B7cqmEEgIAVBmYABzw
+YIFoomGBaaJoiXyqaYl9qmqJKhrCAGuJKxrCAGyJLBrCAHaJdLJnkW2yaJF3slQRAwaEGsAAguAG
+9O4MIAFAIQAG0cDgfs9wgABgyiCAz3KgAIAlJqIikCeiIoAqoiaQK6LPcYAAsMcggVEhQIAggBX0
+KKIikCmiIoAxoiaQMqIigDeiJpA4oiKAO6ImkDyiIIA5oiKQOqIggDWiIpA2olkEABDgePHAzgjA
+AM9wgAB4rgDe1KjPcIAAsMcAgFEgQIAT8gjfyXWA5cwlopDMJSKRzCVikdgI4gXKIEIDYb+A5wHl
+M/cc8IokAXHPcYAAiJaoIEABBBmQA+B4ANlKJAByz3KAAOCYqCAAAxYiQAB2kM9wgAAAlzR4AeFg
+sM91gABgys93gADwqkAlABIkb9IN4AAG2qlwQCeBEsYN4AAG2kAlABJAJwEUtg3gAAbaGI2E4A/0
+iiAPCjoOoACKIdoMKBWAEK4LIBEohTIKwA8JhVEgQIEJ8ooghw4aDqAAiiGbAn4PwAnPcIAAsMcA
+gFEgQIBgDoEDz3EAAP//z3CAAKSnLKAroAUamDOn/y0AwADxwMIPoAAA2oQoCwwAIYN/gABgyrUb
+mADPdoAAAGy0aLpmUoIChgAhgX+AAFzMz3eAAASZuhuYAGGG3BnAAGWG4BkAAAaG5BnAAOgZAAAW
+J4AQFiaBEAjgBOGyDeAFCNrdZRSFFn4Wf0AnABIkbp4N4AUI2rUHgADxwADY4f82D+AFANjPcIAA
+rEVKCYAJz3CAAOxFPgmACcIJAAb2C0AEAdgA2YIOIA+A2uoPQAzyD4APSg7ACY4IAAuWDUAKANha
+DCAQCHHPcIAAXGMAiFEggIAI8s9xoADAHQCBoLgAoXoIAA0KDwAKqQXP//HA4cUA3c9wgABMBaCg
+z3CAAFyurLBqCSAKqXCiCY//SgqgDKlwMgxABvoLwAWqD0ALzgrgDKlwmgrADBEHgADxwJoOgACC
+4KPBBvTPdYAAHA8I8IQoCwwAIY1/gABgyoLgBvTPdoAArLQJ8M9xgAAozYQoCwwAIU4OLZU8eihw
+hiHxD0e5wrqGIP4DJHpEuFBxyiHCD8oiwgfKIGIByiOCDwAAUATKJCIAvAKi/8olAgFIhTu6UyIC
+gECuTZXAukGuDPJ3lYYj/wlDu2eud5WGI/4HRbtoroDiEvLPcoAA9E4VIgMAAIs1egKuAYsDrgKL
+BK4DiwWuA4oL8AHZKa4C2AKuI64A2ASuA9gFrgaui3DJcQoM4AUM2gDAAcGiCyANAsKLcMlx9gvg
+BQzaAMABwQ4MIA0Cws9xgADABgChDZVEuOC4ANkvpQXyiiEIAC+l4bgD8ou5L6VRIICABPKNuS+l
+4QWgAKPA4HjxwGoNoACYcIQoCwwAIYB/gABgylUgRgoogFUgxQtRIcCAiiEIAMohIQDYGEQASiQA
+cgDZqCCAD891gABYcPyILmXkfi8qgQNOIoMHz3KAAHxwb2IAJkMA4KtUEI8A5H4vLoETTiaPF+5i
+yKvIgFEmwJAP8l2IhuHTIqYALyqBAE4ijQfPcoAAhHCqYhDwz3aAAGxwLmbOZbyIxH1sEI4AxH0v
+LUETTiWOF8piUKsB4UokAHIA2qgggQDciM9zgABkcE9jz3WAAHxw5H4vKYEDTiGPB+9lACaBAPyp
+VBCPAOR+Ly6BE04mjxfuZSQZggPIgFEmwJAP8n2IgOLTI6EALyvBAE4jjQfPc4AAhHCrYxHwgOID
+8slqAvBIds5jfIjEe2wQjgDEey8rwQBOI44Hy2UsGcIAAeJKJABxANqoIEAFz3GAAGBwfYhJYQAl
+jAAB4mR5LylBAE4hgwfPcYAAhHBpYSCsJgjgCIhwZQSAAPHA+guAAILgBfTPcYAAHA8H8IQoCwwA
+IYF/gABgyumBWIlBL8MQwLsXu8dzAACAHOS/zyMiBuC/Tt3PI6IAyiWCHwAATgGG4s8lYRLlvyz0
+z3KAALSXFhKFAM9ygABszUaSsHLPdoAAYMrFFgQWDPTEFgIWUyIFAM9ygAC0l1SKsHIL8kEsQgFR
+IgCABfJJhlEiQIEJ9FEkQIEG9EmGUSJAgQPygbvPcoAAVM1UiofizyPhAFEnAJLPI6IFguCIGcAA
+jBlAAwb0z3GAABwPCPCEKAsMACGBf4AAYMppEYMAThEOAQ4jgg8AADoBCbpifkV+WpFiehK6RX5b
+kWJ6QCrNBcV9BCW+nwDwAADKIcIPyiLCB8ogYgHKI4IPAADqAM8j4gLKJMIAYAdi/8olQgOC4JAZ
+QAMG9M91gAAcDwjwhCgLDAAhjX+AAGDKz3CAADCMAJCO4MwgooIq8gfYDgvgAAq4BCCADwcAAAAw
+uIfgZAANADMmAHCAAGRsQCcBchR5AHmKIAQAlB0AEB7wiiAQAJQdABAa8ADYi7iUHQAQFPAA2Iy4
+lB0AEBDwANiNuJQdABAK8APYDLiUHQAQBvAA2I64lB0AEIIgAQGVAqAAlB0AEAohwA/rcgXYz3MA
+AB8JSiQAAKUGb/8KJQAB4HjxwAoKgACC4Ah1BvTPdoAAHA8I8IQtCxwAIY5/gABgygHZaB5CEADf
+gB7AE0zYTh4EEAXYEKYK2Bu2ENgathTYTB4EEC3YUB4EECbYUh4EEEokAHLpcKgggA3PcoAAuHD0
+IgMAz3KAALyoFHpgss9ygADIcPQiAwDPcoAAzKgUemCyz3KAANhw9CIDAM9ygADcqBR6YLLPcoAA
+6HD0IgMAz3KAAOyoFHpgss9ygAD4cPQiAwDPcoAA/KgUegHgYLIIhuW4BfIE2mIeghAD8GIewhPk
+uAryCdlqHkQQLtpdtgLaaR6CEArwFNpqHoQQMtpdtmkeQhAU2VmOUSAAgFlhMHlqHkQQGuE8tgry
+CthkHgQQBthmHgQQB9gI8BDYZB4EEGYexBMF2BCmqXCS/jyOKHBUHkIQhiADAOa5bB4CEMoiQQAL
+8lAhwwFvelQewhBQIMMBb3hsHsIQ5bkH8khzhiMDAG96VB7CEOS5BPKluGweAhBRIcCABPKkulQe
+ghCC5RjyqXDH/s9wgAA0zYQtCxwwIEAOUSBAgPHYwCgiAcoggQ8AAJMAwCghAaAeABAY2I24F6YI
+hlEgwIDPcIAAYMoG8r4QgACJuATwpRCAABamz3CgAKwvGYAwuMC4Ng8gEFUeAhAIhgQgvo8ABgAA
+C/I2uMC4G3gB4G4eBBAC2IAeABAD8G4exBMA2BymHaapcAD/KIYB2khzQSkABTW5UiAAAFIhAQDA
+uMC5Lgtv/5hyQQCAAOB4z3CAABwPCIDPcaQAHEDAuBN4wbgSoeB+8cDhxc91gAAcD1eVz3GAAMQG
+4LpX2AChA/Jf2ACh4roD8oW4AKFRIkCABPKHuAChz3GAAKy0QIkA2YDiyiBBAM9xpQDoDwahz3Gg
+AKQwAYGA4s8g4gDQIOEAAaGmDEANMIXPcKAAyBwooBIOoA0PhcEHQADhxc9wgAAcDymARCGDgADa
+JPSQ4ooABgAAIo0PgACYQwCNoLgArYAVgBCguIAdAhBAFYAQoLhAHQIQEI2guBCtkBWAEKC4kB0C
+EFAVgBCguFAdAhAB4t/xkOJGAAYAACKND4AAmEMAjYC4AK2AFYAQgLiAHQIQQBWAEIC4QB0CEBCN
+gLgQrZAVgBCAuJAdAhBQFYAQgLhQHQIQAeLe8ea5EPLPcoAAmEMIioC4CKqIEoAAgLiIGgIASBKA
+AIC4EvCA4xL0z3KAAJhDCIqguAiqiBKAAKC4iBoCAEgSgACguEgaAgBRIQCAANge8kokAHTgeKgg
+QAbiuBTyACCDD4AAmEMgE4EAgLkgG0IAoBOBAIC5oBtCAGATgQCAuWAbQgAB4B3wSiQAdOB4qCBA
+BuK4FPIAIIMPgACYQyATggCguiAbggCgE4IAoLqgG4IAYBOCAKC6YBuCAAHg4H/BxeB48cDmDWAA
+B9rPdqAAyB9IHpiQz3WAABwPgBUAEM9xqwCg/0weGJAA2BmhWqEYoYogBAAPpmoVABHPd4AAMIyw
+HgAQtB4AEB/YCLgOpgiFUSAAgADYi7gV8hCmVgzAD89xoACkMAGBhLgBoQSXheAa9ADZlLnPcKAA
+BEQloBLwEaZ+DMAPz3GgAKQwAYGkuAGhBJeF4Ab0z3GgAAREANgFoc9wgADMBACA4LgK8oYg/w4i
+uBS4z3GgAAREBaFW/8oJAA1b/3f/z3AAAFVVWh4YkAHYWR4YkAiFz3GmACgA87gG8gDYD6GaDAAQ
+BPAB2A+hbhUBEc9wpgDoByag/g/ABM4PoAwNlQePgOAL8oog2An2CmAAAdm+CSADAtgE8JIO4AQB
+2IgVABDPcaAAxCcPGRiAjBUCEM9woAAwEESgz3CAALShEHiPGRiAz3KAAGSiUHiWIgIAELpFeJAZ
+GICKIAQAkhkYgJAVABBAl0AZAIDPcIAAmENTGRiADxEAho7in7gPGRiAzCKiggj0CBEAgIUghAAI
+GQCAiuIH9AgRAICKuAgZAIAP2BAZAICUFQAQHBkYgAiF/bgN8rYPoA8A2LoPoA8B2M9xpgD0zwHY
+EqED8KIPgA95BEAA4HjxwAYMQAAKJQCQz3CAAGDKGnEF9MUQAQYC8CmAJblRIQCAKPLPcoAAtJfP
+cYAAbM0mkXaKMHMI9MQQAQZUisC5UHEL8sUQAQZRIUCBBfIpgFEhQIEO9AohwA/rcgXYz3MAADYJ
+SiQAADEAb/8KJQABhC0LHC93z3aAABwP+GDJccoIoAAp2s9xgACstAAngB+AACjNAgmgAAzaz3Cg
+ALQPAN/8oEiGUyIAADIJYAw0lkIIAANc/4DlVArhDMogYQAEyFEggIAF8roPAAML8ADZnrnPcKAA
+/EQhoM9woAC0D/ygTCAAoGQJ4g/KIGIAz3WAAKAEDI2A4AX0AguADQHYDK1pA0AA4HjxwPYKQAAK
+JQCQAdgR8gTIUSCAgAz0CiHAD+tyBdiKIwgDSiQAAG0HL/+4cwDYhC0LHM92gABgygAmTx6EKAsM
+QCYBGTAhQA5JhyW4JbpTIBEAUyISAOlwPg9gAA3Zyg+gEKlwCYeA5SW4UyAQAAb0A9gq/HD8BPBa
+D4APTCAAoB7yTCIAoMohwg/KIsIHyiOCDwAALwLKIGIBxfXuD0AIHgngAAHYTCEAoM93gACwxwX0
+LgnACjIJwAoX8AIJ4AAA2IDlz3eAALDHBPS7/Anw/g6ADwCHUSBAgAQPgg9MIQCgTAuB/6lwBP6+
+C6ABqXBMIQCgBNgEGhgwMfTPcYAAtJfPcIAAbM0GkFaJEHII9MQWABY0icC4MHAP8sUWABZRIECB
+CfIJhlEgQIEF8gCHUSBAgBP0qXAKcXD/f9kRuc9woACwHzSgkglACA/IBSCADwEAAPwPGhgwAIdR
+IECAIPLPcYAAtJfPcIAAbM0GkFaJEHIH9MQWABY0icC4MHAJ8sUWABZRIECBCYbRIGKBCPQYjs9x
+gAAcDxipCYYJoQHe9gwgDMlwz3CAAKEGDgsgDMCogeUM9M9wgABUzRSIh+AG9EwgAKB0DoIPSg6A
+D0IPQAh+DUAAugugAgDYdQFAAOB48cAA2Ib/hgsP/89xgAC0lxaJNgigEDSJ1QdP//HA/ghAAIHg
+z3aAAGDKGnAD9KmGA/DFFg0WJb2EKAssACZPHgmHwL1RIECByiHBD8oiwQfKIGEByiOBDwAAwQLK
+JCEATAUh/8olAQTPcIAAcA9MIACgAYjMcTT0QIHPcYAAtJdAoQAWA0CA4GGhABaDQGipABaDQGmp
+ABYAQQPyD7YAFoBABCKCDwAGAAAKqQAWgECA4gupABaAQAHaDKkAFoBAABYAQcB6B7EAFgBBCLEA
+FgBAUqliDm//BNg58CCBz3KAAFjOxB5YEAAWAUCA4MUeWBAAFoFAFBpCgAAWgUAVGkKAzHAH8iCQ
+z3CAAGzNIbAC8ACQABaAQM9xgABcziIaAoAAFoBAIxoCgAAWgEAkGgKAABaAQAAWAEEOGQSAABYA
+QSIZBIAAFgBALyAHBHL9cgmgAQpwz3GAALSXFomA5c9ygABszUaSHvRQcAf0xBYAFjSJwLgwcBHy
+xRYAFlEgQIEN8gmGUSBAgQnyz3CAALDHAIBRIECABvQphwpwJbnAud3+jgyAD8YLQADRBwAA8cAA
+2Jr/z3GAALSXFomKDmAQNIkpBk//8cAA2c9woAC0DzygkgwADeoJQA2WDgAM/g1gDQDY/9nPcKsA
+oP85oALYfgtgAAQaGDD1BU//4HiEKAsMACGAf4AAXMzgEAIAz3GAALCZ3BADAGAZgIDkEAIA6BAA
+AFwZwIBsGYCA4H9wGQCA8cDiDiAAEtmpwQh2Vg1gAItwSiQAcQDaqCCAAhYkgDAoiIHhw/ZhuSio
+AeIBwgLBhC4LHAAhgH+AAFzM3BiAAAXC4BhAAAbBtG7kGIAAx3WAAABsSBUREOgYQADPcIAABJkK
+IEAuFiBABAjgg8HGDGAFCNr0hc9wgAAEmYfB9ngI4LIMYAUI2gDAACCNL4AAYMpRIACAtR0YEAjy
+uh3YE7sVABaAuAfwuh1YFLsVABaguLsdGBDPcIAANMpUiDaIRCo+CwAhgH+AAJDINXgGiBB2/A7h
+/8oggQO1FQAWUSBAgPHYwCgiAcoggQ8AAJMAwCghAUYKYACgHQAQRQYgAKnA4HgA2H7x8cClwYtw
+cgpgAAXZAMLguhPyz3CAABwPGIiB4A30ANiauM9xoADIHw+hAcCkGQAAw9gauA6hUSKAgBbyBhIC
+NgDZSiQAcuB4qCCAA7hxg3EoiREiQIAAIkAxZBhCAAnyQCVBAM4JQAClwNHA4H4KIcAP63IF2Ioj
+jwj5AS//SiRAAOB48cDPcIAAHA8JgFEgQIHKIcIPyiLCB8ogYgHKI4IPAAApB8okYgDIASL/yiXC
+AMoOQAzWD2AJAdjPcIAAVM0UiIfgI/TPcIAASM0LgFEgQIEb8s9wgADcyAqQz3GAAKiuJYEKuDBw
+yiHCD8oiwgfKIGIByiOCDwAAMwfKJCIAcAEi/8olwgDCD8/+agggDADYQg7ACxoJQACVA0//8cAC
+2K38tv2JA0//8cC2DAAAAN7PdaAAtA/cpXYKIAxod/j/ogugDOlwBMhRIICABPIKCQADCfAA2Z65
+z3CgAPxEIaDcpeUEAADgeIQoCwzPcYAASM0wIUIOz3CAAOCYVnh2kM9xgAC0l8QZ3AAXkM9zgACw
+mcUZHADPcIAABJlWeAyIkBsCgADY4H/HGRwA8cDqDE//+giAD1YNT//1Ak//4HjxwCIMIABE2s91
+gAAAbMRtz3GAAAiZlglgAKlwSiSAcADZqCCACBRp2GBxgIQpCwwAIYJ/gABgygAhgH+AAFzMuhrY
+AADbtRrYAGGFQoUB4dwYwABlheAYgABGheQYwADoGIAAKQQAAM9wgAC0l/kEIACKIQUF4HjxwKIL
+IAAA2qHBQMIAFo5AABaNQAAWg0AAFpBAgOUd8ql3z3GAANS0I4mGJ/wXRb/DveZ54LnKIkIDYMLh
+ucoiQgPKIiEAARyCMFEhgIDKJSEQAhxCM4DgJPTPcIAAtJe2iPSIsXPMJsGTEfIKIcAP63JAKwQE
+EL4F2Ioj3gIFJEQDtQfv/gUmxRMAxUAgDgbPd4AAYMpUGFgDhB9AEyHwz3CAAGzNBpAQcwr0z3eA
+AGDKxBcAFsC4EHYN8gohwA/rcgXYiiMeBZhzbQfv/kolAAAAxc92gAD8yN0fWBNAIEEgSSEBBjR5
+Ug8gAMlwQiDAJUggAACA4ADby/cA2gAWAUAB4oPivfcB4xBzuPdWJgAZKg8gAAbZz3CAALDHAIBR
+IECAGvLPcYAAtJfPcIAAbM0GkFaJEHIH9MQXABY0icC4EHEK8sUXABZRIECBBvIJh1EgQIEO9AIO
+YADJcM9wgACYD6KgiiASDV4IIACpcYYOAACRAiAAocDgeADYQvHxwKHBi3C2DiAAAdkAFAUwTCUA
+gMohwQ/KIsEHyiBhAcojgQ8AAMwHjAbh/sokYQDPcIAA1LRCDiAAAxhCAaHA0cDgfvHA4gkAAM9z
+gABUEEODAN/PdaAALCCwhdJq1H5+ZqWmBKYB4owiEIAmpkOjhfcCg+OjAeACoxUCAADgeADYz3Gg
+AMgfGKEZoQHYDqHgfuB48cBqCQAACHe6cdpy+nMKIgAhCiNAIQohgCHPcAAAyBviCWAACiDAIRtw
+z3AAAMwb0glAADtwz3AAAAQcxglAAM92oADIH5pwAdgTpgXYz3WAAMAPAKXhpQ7AIB0AFAmlFYYc
+HUAUCqUYhhgdwBQLpRmGFB2AFAyloBYAEBAdwBUNpaQWABAMHYAVDqWoFgAQCB1AFQ+lz3ABAMEJ
+EKVmCWAAKNgRpV4JYAAA2BKlUyfAdROlAshUHQAXFqUSFgCWUB0AFxelExYAls9ygADADxilFBYA
+llMkASMZpRUWAJYQuRqlJBYAlkokQHkbpRYWAJYcpc9wgACADBGAHaXPcIAAwA94GIAKz3CAAMAP
+fBjACs9wgAA8EAQYAAuEGkALz3CgAMgcCICIGgAAz3CAAHAFAICMGgAALyAHBgi4BXkvIEcGJXiQ
+GgAAANioIEAC8CIDAM9xnwC4/wHgdqFNAAAA4Hj8HIi2/BxItvwcCLb8HMi1/ByItfwcSLX8HAi1
+/BzItPwciLT8HEi0/BwItPwcyLP8HIiz/BxIs+B+4HgE3DjdNfDgeATcNN0z8OB4BNww3THw4HgE
+3CzdL/DgeATcKN0t8OB4BNwk3Svw4HgE3CDdKfDgeATcHN0n8OB4BNwY3SXw4HgE3BTdI/DgeATc
+EN0h8OB4BNwM3R/w4HgE3AjdHPDgeATcBN0Z8DQUGjAwFBkwLBQYMCgUFzAkFBYwIBQVMBwUFDAY
+FBMwFBQSMBAUETAMFBAwAscBxrAkTTOwJB8z4H7xwM9xgACADBGh4HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB40cDgfuB44cXhxkApDQIlfUAtAxSI4qV7CHWQ
+91MlfpAG8gEdUhBhuvvxQSqOAMG6QiZOkAQd0BD99YDiCvIvJIlw4HioIIABAR1SEOB4wcbgf8HF
+4HgocgDZ1vHgePHArg7P/6HBCHfPdqAArC8ZhgQggA9wAAAA13AgAAAAAdjAeC8mB/AodRpyE/SK
+IEkGogzv/4ohTQg5hpYM7/+KIAkGiiAJBooM7/+pcQDYJPARzAAcRDNPIMEDAeAQeAQggA8AAP+/
+j7gCHEQwERocMJ4NoA9AJwASB+cEJ48fAAD8/wUnABSduJ+47HEAoQDB7HAgoAHYeQbv/6HA4Hgi
+uQbw7HJgogTgYbmB4WCAOvcA2c9woADUC22gz3CgAEQdNaDgfuB48cDuDc//CHYodShwSHFocsr/
+geDKIIEDwA/h/8ohQQM5Bs//4cXPcoAAsASkioDlz3KfALj/BvLPc9C6/sp+ohqiO6KA5Q7yz3Cg
+ADguBYAEIIAPwAAAANdwwAAAAPbzadgYuBmi4H/BxeB48cB+Dc//CHfPcYAAsAQFiQDegOCpwUDG
+Q/QB3aWpz3GAAICOz3CgAMwrLaAA2I+4ERocMCEagjMSDCANi3CeCwAIz3ABAMEJQcCKIFAAQsDP
+cIAA/HoAiGTFAt0RHAIwAMASHEIzExwCMM9wgABUEEXAz3CAAMAPRsDPcIAAcAUAgEPGINkB2kfA
+SMeBwD3bF7vB/wjYAdnI/wQaWDNJBe//qcAD2s9xoAAUBEWhz3GgANQLDaHgfvHA4cXPcqAA1AsD
+3bGiANtwogUSAjfXcgAAAEAB2sIiigAXusdyAA4AAEUiAgadup+67HVApQLaIBqCMAgSDTbscqCi
+ERICNwHiERqcMOxyAKICEgI27HBAoOxwIKAB2M91oADIHxOlOIXscCCgGYXf/3Qd2JDPcaAAyDsO
+gYi4DqG9BM//4HjxwADYCBKBMNz/CBKFMAohwA/rcgfYiiPRCLUA7/5KJAAA4HgA2gPwAeJBKIEA
+MHK89+B+z3GAAIAMRBnAB89xoADIH1yBnbieuE0ZGIDgeOB44HjgeOB44HjgeOB4HIHgfuB4A9rP
+caAAFARFoc9xoAD8Cwyp4H4D2s9xoAAUBEWhz3GgAAgMALHgfgXMANrXcAAAAEAB2MIgCgAXuMdw
+AA4AAE8ggQCduZ+57HAgoM9woAAUBAPZJaACEgE2z3CgANQLLaDPcKAARB1VoOB+gOFU8kAhwgPD
+uY/hnAAtACS6MyZBcIAAcGxAJ4NyNHsAewAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAA
+ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAA
+FgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUBCIkKABBhQAL/14H7geIDi4cUi8mNq
+wbqD4jwALQAiuzMmgnCAAIBsQCeNclR9AH0EEAIEBBmQAAQQAgQEGZAABBACBAQZkABCI0OABBAC
+BAQZkADv9fcEz/+A4uHFU/JAIsMDw7qP4p4ALQAkuzMmgnCAAIRsQCcNclR9AH0BEIIEARmSAAEQ
+ggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCC
+BAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgBCI0OA
+ARCCBAEZkgC+9UsEz//gePHAygnP/yh2RiHNAB1lIrmS/8G+geYO8oLmCPKD5g30ABaAQAEdEhAA
+FoBAAR0SEAAWgEAArQECz//geIDhyiRNcOB46CCtAQAWAUECGFQA4H7geIDhyiRNcOB46CCtAQAW
+gUABGFIA4H7gePHAXgnv/1MhQgBOIg0Bz3KgABQEyYIA2w4mgh8AAAAGUHHKIcYPyiLGB8ogZgHK
+I4YPAAAMAsokZgCwBab+yiXGAIDhyiRNcMoizQDoIC0CTmDPcaAAOAQB4sipgeUO8oLlCPKD5Q70
+z3CgADgEaKjPcKAAOARoqM9woAA4BGioSQHP/+HFANoP8KCADXOgo6GADXOgo6KADXOgo6OADXOg
+oxDgAeJBKQMBcHKv9wDbBvAEEA0EDXKgogHjUyHCACK6UHO39wDbBvABEI0EDXKgqgHjUyFCAFBz
+uff7As//ANvPcp8AuP8aonuiPqLPcABsBAAZouB+8cBeCO//ANqhwRpwz3DUuv7KQMDPcZ8AuP9o
+GQAEBNgboYtwHqGdus9woADQG1Ggz3AAbQAQGaEF8OII7/+KIEkFUSFAx/vzABQFMAwlgI/Uuv7K
+OvQg3c9zoADIH7CjAdhDGxgAANiNuPz+saPPcZ8AuP9oGQAEBNgboYtwHqEA2J24ExsYgM9wAG0A
+EBmhBfCKCO//iiAJClEhQMf78wAUBTAMJYCP1Lr+ysohwQ/KIsEHyiBhAcojgQ8AAGwCMASh/sok
+AQSBAe//qHDgeM9xgACwBGSJgOPPcp8AuP8F8s9x0Lr+yj6iGqKA4w7yz3CgADguBYAEIIAPwAAA
+ANdwwAAAAPbzatgYuBmiHILgfuB48cBSD6//mHAodkh17P8GIIEDiHCleV3+pQeP/89xoAA0HwSh
+AdgHoQiBgOD+9QWB4H7gePHAGg+v/0okAAIA3c93AAAEHal2FSKAMxwQAQYA2M9yoAAUBMqiqKIn
+ogSiPWWI4Wi5yiEOAOlwR/5CJEQATCQAgCDnAeYo9zkHj/9BKYGACvIvJElw4HioIIABBBACBOxx
+QKHgfuB48cC2Do//CHUodgYOYA9AIQACBczXcAAAAEAB2MIgCgAXuAAggQ8ADgAAB24EIIAPAAD8
+/yV4nbifuOxxAKECEgE27HAgoCK+BfDscQChBOVhvoHmAIU792D+yQaP/+B4B9nPcqAA1AcaGliA
+gOAO8hkSAYYJIEMADxIBhgIgwIB5YQ8aWID29eB+4HihwfHABRICN9dyAAAAQAHawiKKABe6x3IA
+DgAAg7rsc0Cj7HIAoihwSf7RwOB/ocDxwOHFz3CAADCMJoiA4TDyJ4iA4SzyoJBPbYfiCfczJoJw
+gACUbEAngXJUeQB5ANkR8CSQB92A4QHZwHkL8CSQCN2F4QHZwHkF8CSQhOEB2cB5geEM8ggQBQEK
+IcAP63IQ2IojzwkhAq/+mHUBBo//ocHxwIINj//PcoAA/QdAioDiRMCO8oDhDPQKIcAP63IF2Ioj
+Tw1KJEAA7QGv/rhzYIGA4wTyQYGA4gn0z3KAAKyYcIJgoVGCQaEkxoDmyiHBD8oiwQfKI4EPAAD/
+A8ogYQHj84DiyiHBD8oiwQfKI4EPAAAABMogYQHX8+m4F/IEIIAPAQAAwC64z3KAAFBwCGJJIIAA
+YbgCuBR4x3CAAASqaqAhgSugRPDouBvyoObKJYITyiUhEAQggg8BAADAz3eAAABwzmcEIIAPBgAA
+ADG4LroeZs9wgABQcEhgwngS8FMgwgBdes91gAAwc01lBCCADwEAAMAuuM9ygABQcAhiYbgWfRJt
+FHjHcIAADKlgoJjlIYEhoIz3CiHAD+tyBdiKI5AHiiSDD+0Ar/64dQjcvwSP/+B44cXhxs9xgAD9
+ByCJgOEm8gDbSiQAds9ygAAMqagggAMyazR5JWA+YqCmPWChhRlhoaYigQHjIqZIEAEGSBpYAEkQ
+AQZJGlgASxABBksaWABMEAAGTBoYADUFj//xwPYLr/+4cc9ygAAohQS5MCJEAFEkQIOiwQbyz3OA
+APTNBfDPc4AABMtAIwIGQCMBB1EkQILKIcIPyiLCB8ojgg8AAEUEPACi/sogYgHPdoAAMIhALY0B
+pmbovkDGIMUE8sK9qmEP8FEmQJIH8kQlARxEuSpiiboF8FMlwRA8eSpjz3GAADCHFiFBASKJDrlF
+eSCgzQOv/6LA4HjlAeAHCNjgePHATguv/4ogVw7PdYAAdEBeCa//IIWKIBcHz3GAACxBTgmv/yGB
+AN7ApRDfSiSAc8lxqCAAAhYlQBDhoMKgAeHPcIAA6EBSDK//ENnPcIAA+EBGDK//JNnPcIAALEE6
+DK//INnPcYAAZEDAoeGhAdgIqQmpxbHDoYoglwfyCK//iiFOBs9xgAAQRcChwaEI2AWhxqEC2AKh
+A9gDocShz3ARADCMB6HPcAIAIL8JA6//CKHgePHAngqv/wHZz3CAAGRAIKAA3c92gAC4BBYmQBMD
+gIDg4iACAEAlTZD48+oLr/4G2NkCj//xwGoKj/8Idc9wgABkQKCgz3aAABBFiiBXC24Ir/8ghoog
+VwtiCK//JYaiC6/+BtiC5Q/yAN3PdoAAuAQWJkATBICA4OIgAgBAJU2Q+POJAo//4HjxwBYKj/8I
+doog1wwmCK//yXHPdYAAZEA+DmACw6UDhYDgLPKB4BfyguA39CYOQALPcAAAJDrPcYAAuAQAoc9w
+AAAAPAGhANjZ/1oI4AcF2CPwz3AAABQ6z3GAALgEAKHPcAAAxDwBocT/5g1AAtINQAIA2AmtEfDG
+DUACz3AAABQ6z3GAALgEAKHPcAAAxDwBoQDYxv/tAY//4HjxwIogVweSD2//gNmH/wDY1f/RwOB+
+4HjxwM9wgABkQAOAguDgD6EHyiChAvPx4HjxwOHFCHWKIBcKXg9v/6lxz3GAAGRAA4GC4CD0gOXP
+cIAALEEAgA70IrjAuAmpAtjPcYAAEEUCoQPYA6EA2A3wI7jAuAmpBNjPcYAAEEUCoQXYA6EG2ASh
+ZQGP//HA7giP/891gABkQAOFguAN8hASBDYKIcAP63IF2IojRQlZBW/+SiUAAM4MQALODGACCHaB
+5gHYCK0W9M9wgACMQ8oMQAKSDcAHCHWKINcKug5v/6lxieXMJaKQHA+iB8ogQgP1AI//8cC6DEAC
+z3CAAEyZIIjPcIAAgEPPcoAAZEAhqCiKwLkiqADZI6iCDGACIaKSDEACANmbuc9woADQGzGgcfHg
+ePHAz3CAAGRAA4CC4A30iiBXB1IOb/+KIUYJANi4/wDYb//o/zT/XfHxwM9xgABkQCOBguHMICGA
+mA6hB8ogoQFP8eB48cDPcYAAZEAjgYLhzCAhgHwOoQfKIOEBQfHgePHACiQAgMohwg/KIsIHyiBi
+Acojgg8AANkDWARi/solwgDPcIAAuAQWIAABI6BEoCfx4HjxwK4PT/8IdoogmADCDW//yXHPdYAA
+ZECKIBcOsg1v/yGFIYUA35DhBPQB38GlyXGB5xPyz3CAAEyZFSCCAzV4IIhgijBzCfYBiCGKEHEF
+9gCFgOAN9IogVwd2DW//iiHJDsGl2g2gBwPYAdgC8ADYpQdP//HA4cUIcRDYANtKJIBzz3WAAEyZ
+mHOoIAAHESEAgRTyz3KAAHRAFiICAQQSBQBMJQCEUPcVJUIRQIpQc8ogSwHKI4sAQCREAC8kBwFl
+B0//CiHAD+tyBdhxA2/+iiPHDfHA2g5v/whxz3aAAGRABBYFEEwlAISM9wohwA/rcgXYiiOKBkUD
+b/6KJIMPzgxv/4ogWACKIBcOwgxv/yGGAYbPdYAA6EAJZbIMb/+KIBcHIYYoZYDgigAJAM9wgABM
+mTV44YgQ2AGmz3WAAHRAiiBXDooMb/8ghYogFwd+DG//6XEAhYDgyiAhASnyxf8IcQGmkODKIcEP
+yiLBB8ogYQHKI4EPAAC7AsokwQC8AmH+yiUhAEYMb/+KIBcOIYbPcIAATJk1eAGIEHfL9oogVwcq
+DG//iiGLAAPYkgyAB2UGT//geM9wgABkQAOAgODgf8ogYgDxwNoNT/9acCh3OnJAKAEEiiAYAPIL
+b/9FeUwigKPKIcoPyiLKB8ogagHKI4oPAAD8AsokigRAAmr+yiXKAEwhAKTKIcoPyiLKB8ogagHK
+I4oPAAD9AsokSgQcAmr+yiXKAM92gAB0QBYmjRQEFZAQiiDXDpILb/8KcQwhAKQH9M9wgABkQACA
+XvBMIACkyiBhAELyTCAApMohyg/KIsoHyiBqAcojig8AABEDyiQKBMQBav7KJYoEz3CAAEyZFSAB
+BBUgQARgiECJcHKH9gGIIYkQcUAAKgAA2IogVwcqC2//iiGMBQAggi+AAOhAAIqA4AHZDfQAFgUQ
+CiHAD+tyBdiKI8wGcQFv/gokAARhuACqKHCB4Az0ACGBL4AA6EAAiQQdQBTipQHgAKkAhg8ggAQA
+pipwQf/PcYAAZEAggQO4JXjxBE//8cCeDE//CHUod0h2QCgBBIog2ACqCm//RXnPcYAA+EAgEQQA
+TCQAgcohxg/KIsYHyiBmAcojhg8AAEID8ABm/solJgAWIQABpKjgoMWoQCRAAAihsQRv/wLY4Hjx
+wOHFz3KAAPhACIKA4BPyz3WAALgEYbgIohZ6YIUEiiCCYHtFis9ygAD4QAiCgODz9YkET//gePHA
+AgxP/zpwjuDKIcoPyiLKB8ogagHKI4oPAACyA8okSgR4AGr+yiXKAM92gAB0QBYmTRQEFZAQiiDX
+D+4Jb/8qcYog1w7mCW//CnEA2AKlENgBpQDYDyBABKCGTCAApAZ9oKYt8kwgAKTKIcoPyiLKB8og
+agHKI4oPAADDA8okCgQYAGr+yiVKBAAggS+AAOhAAImA4MohwQ/KIsEHyiBhAcojgQ8AAMQDyiQB
+BOwHIf7KJUEDYbgAqQpwHf+lA0//4HjgfuB44cXhxhDZAN7PdYAATJmfcclzqCAABBEggIMK8hUl
+ghNAilBzyiGLA8ojiwAB5s9+KHDBxuB/wcXxwAYLb/+KIJcPSiAAIM93gAB0QBYJb/8ghw7eCnUA
+hxEgQIML8hYnQBMCgIDgB/JAeAUgAAQvIAcgYb6A5gHlr30v9wDYAKdMIACgAdgdA2//wiAMAOB4
+8cCuCk//CHbPcKAAZC7wII8DGxIQNhsamDP12AW40gxv/8lxG8jPdaAAFAQKpQmFgOCECkIHz3Cg
+AMAvURAAhgsgwIP19c9wAABkHtYKj/8RIICD7fMJhYDg6/UbGhg09dgFuIoMb/8KcRvICqWlAk//
+4HjxwI4OT/+hBg/+4HgAFgFBILAAFoJAUyJBACGgQSrBAFIhAQDAuSioQSqBAMC5KahBKgEBwLkw
+qAAWgUDPcaAAyBwogeB/I6DxwAGAgOAS8oHgGfKC4BnyCiHAD+tyBdiKI8QDSiQAAGUGL/4KJQAB
+AdnPcKAAyBwpoK4Nb/8U2AjwAtn38QHZz3CgAMgcKaDRwOB+gODxwBHygeAS8oLgE/IKIcAP63IF
+2IojBQtKJAAAHQYv/golAAEp2BK4CPAV2BO4BPBPeivYErg1eECg4PHgePHA4cUIdU4Nb/8U2COF
+z3CgAMgcKKDNAU//4HjxwE4JT/+lwYt36XDE/+lw0v8iwIDgGPIAFg5BJMCA4APyABYAQQDdCfAB
+wAAWAkDJcd3/AebQfgHlABQBMTB1tfcU8ADdDfAAFgFBgOIE8gAWAEEBwAAWAkAB5dL/ABQBMTB1
+JMKy9yTAgOAG9FEhAIAE8gAWAEEFzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQISATbs
+cCCg6XDR/9ILb/8B2ADZz3CgAEQdNaABAW//pcDgePHAAYCA4BTygeAQ8oLgEPIKIcAP63IF2Ioj
+BA1KJAAAAQUv/golAAEC2APwAdjPcaAAyBwJoUYMb/8U2FTx4HiA4PHAEfKB4BXyguAW8gohwA/r
+cgXYiiOGB0okAADFBC/+CiUAASnYErjwIEAAAKI68RXYE7j78SvYErj38eB48cASCE//pcGLd+lw
+df/pcNz/ABQBMQXMArnXcAAAAEAB2MIgCgAXuMdwAA4AAAvhBCGBDwAA/P8leJ24n7jscQChAhIB
+NuxwIKAAFAEx7HAgsAkUgDCA4Afyz3CmAJw/GYCB4Pv1IsCA4BfyABYNQSTAgOAD8gAWAEEA3gjw
+7HIBwKlxz/8B5bB9AeYAFAExMHa39xLwAN0L8AAWAUGA4gPyABYAQexyAcDG/wHlABQBMTB1JMKz
+9yTAgOAG9FEhAIAE8gAWAEHpcHj/ggtv/wHYANnPcKAARB01oE7x4HjxwDIPL/8B2AAWgkAAFopA
+ABaJQAAWhkBEJr6DRCKDE8B4CiFAgsohYgAB4YDjyiOBAMojIgCA4MogQgLKICEAQNwEIguTG2Nv
+eyT0BcwB3ddwAAAAQBJrwiVKEwzgF70EIIAPAAD8/8d1AA4AAKV4nbifuOx1AKUCEg027HCgoOx1
+AB2CEuxwYKgA2+xwYLCA4fIALgAA2PhwGXGB4MojgQHKIkECyiOCAkQjgQOC4UolQADCJUIBUiMO
+AMC+RCMADJDgAdvAe6DgAdjAeAUgxAAAFg1AgOFhuk96GPSA4gDf0PcghYDmBOUE9AAWDUBMIwCQ
+A/TscCCgAedQd7T3IIVMIwCQBPTscCCgBiU+gRLygOIA2M33ABYBQIDmIKUE5QT0ABYNQAHgUHC2
+9wAWAEAApQskQIEe8oDiANjT9wAWAUDghYDjA/LneQLw5XkgpYDmBOUE9AAWDUAB4FBwsPcAFgBA
+IIWA4wTyJ3gD8CV4AKVCIEEQgOEgB+3/QCdAAEwjAJAG9NIJb/8B2AfwA9nPcKAAFAQloADZz3Cg
+AEQdNaD1BQ//2QFP//HAhg0v/wDZz3CgANAPNaAAFgNBABYCQem7BcwW8tdwAAAAQAHYwiAKABe4
+ACCNDwAOAABAIgEDz3AAAPz/JHileJ24n7gT8NdwAAAAQAHdwiVKExe9x3UADgAAQCIBA89wAAD8
+/yR4pXjscQChAsjscQCh7HBAsOxxANgAsei7QPIjauO7BCGBDwAA/P8J8s91oAA4BAitAdhhuTB5
+5LsM8qFoCL0Ffc92oAAQBLi2AuAPeGK5MHkA3RTww2gYvuJo738Qv+V+4Wjvfwi/5X4Ffs93oAAU
+BMunBOAPeAHl2mnRdaz3AN4I8M91oAA4BAitAeAPeAHmUyFNALF2t/fluwjyAdnPcKAA0A8RGFiA
+5rsJ8gPYz3GgABQEEKEB2ASh47sG8gAWgUDscCCoYbrkuwnygeLH9wAWAUHscCCwYrpEI4GBQSqA
+ABX0AN4L8M91oAAABOyNABaNQOx14K0B5rJosXZH9+e79PUAFo9A9vGC4RT0ANkK8M91oADUA9yV
+ABYNQex1wLUB4Rt9sXFG9+e78/UAFg5B9/HiuxXygODKJA1w4HjoIO0D57sJ8s9woACYAz2AABYA
+QAPwABYBQOxwIKAA2QbwABaDQOxwYKgB4VMiQAAQcbn30g8v/wHYANjPcaAA0A8RGRiAz3GgABQE
+BKEEyM9xoADQDyK4wLgVoekDD//xwIILL/8A2UokAHLgeKgggAIAFgJAFSJAMBwYmAAB4QAWDUAA
+Fg5APgxP/89woAAUBKygz3CgANQL3KCSDw//rQMP/+HF4cYkiM9ygACcbKaIwrkuYgDZDyGBA4Dl
+z3OAAIyZdhMCBgX0Jnp2G5gAHPBFeXYbWAAliBUjjQN5HVgQJohFiFlhfB1YECCAjCEQgEX3iiEQ
+ACCgI7l3G1gAAIAquHgbGAAA2c9woADwNiygeRMBBiWgfBMBBiagehMBBiegfRMBBiigexMBBimg
+fhMBBiqgdxMBBiugeBMBBi2gdhMBBiSgwcbgf8HF4HjxwOHFosGLdalwGg8v/wLZqXDR/8oOD//t
+Ai//osDgeIDg8cAH9M9wgABkm6oLL/8k2bEAz//gePHAVgov/5hwkODKIcYPyiLGB8ogZgHKI4YP
+AABrA8gG5v3KJSYEANpKJAB0z3aAAMwEqCCAD0AsgwFVe8dzgAAwiCCDz3WAACiFQCwAAd25AGUg
+o/G40SEiggnyoIvPd4AAAHCtZ4HlCvbPdYAAMIcWJQ0RoI1RJQCQBPKeuRbwLbjAuBUmDxDjh1Ih
+TQILJ0CTDfLPdYAAgMqEKAsMMCVAHv647POfuSCjAeIRAg//8cCaCQ//osEAFhFBABYAQUApDiHH
+doAAKIUAhkwhAKQtuFMgEgCO9wohwA/rcgXYiiNUA0okQAD9Be/9CiVABM9wgAAwhxYgQAQacO4N
+L/8C2c9wgACwhxYgQATeDS//AtlAKY0hACWAH4AAMIjODS//ENmLcMYNL/8B2QCGUSBAggfycg0P
+/20BL/+iwAAlgB+AADCIRg2gCxDZARCAIJDgyiHKD8oiygfKI4oPAAA6BYQH6v/KIGoBSiQAdADZ
+qCABChUlQhDPcIAAMIgwIIUABCWDjwAAAAEEHEAxRvIhxs9wgAAAcAQlhA8GAAAAQSxCBM9goOb4
+YtEl4YIx8oDjBPKB5wv2BCWEDwAAACQMJICPAAAAJCPyguJCAA0AguIG9IDjHfKC5xv0gOME8szm
+F/bPcoAAMIxGklB3EfZRJcCCD/LPc4AAgMqEKgssMCNCDgQivo8ABgAAA/QA2wLwAdtvewTwAdgI
+cwQlgg8BAADALrrPdoAAOHNKZlBwAdjCIA0AgOPMICKAEfIB4QIQgCDPcYAAUHAIYYHgHvIKIcAP
+63IF2IojVQQQ8M9zgACAyoQqCywwI0QOCiHAD+tyBdhxBO/9iiOVA0okQABlBO/9SiUAAAMQgCAI
+YYLgyiHCD8oiwgfKI4IPAABTBQXY7vUqcFf/z3CAALCHFiBABECQz3EAABgVCSJBACCwOvHgePHA
+kg/v/gLZz3CAAMwE/g0P/89wgADMBECAz3agAOwnz3egAAREz3WAADCM4Lo+8iuGRCKAAIYi/w4i
+uqG5FLq0uQV6BSGDAAQhgQ8QAAIABCKCDxAAAgBrpiV6RacolYfhzCGigRD0gODPcaAAyBwG8gHY
+HqFaD8ALBvAA2B6hvg/ACwSVheAv9M9wgADMBACAUSDAgCnyBNnPcKAARB0loCOgJKAh8M9woADI
+HAHZPqALhoG4C6YWD8ALBJWF4A70z3CAABwPCIBRIACACPIA2JS4BacLhpS4BvAA2AWnC4a0uAum
+/goP/xEHz/7geOHFNGjPcoAAKIUhYi25wLmEKQsMACGBf4AAYMpIgVEiAIDPcoAA1LRBggnyPImA
+4cUigQ8AAAoCA/JFIkIDSiQAdADbqCCAAjZodXkAIY0PgAAwiEClAeMA3c9zgAAwhxYjAgCgqqGq
+AdkiqgPZI6pKJABxqXGoIMABemEWeqSqAeHgf8HF4HjdA4//2QOP//HAABYAQIHgz3GAABxBAKEN
+9AAWAEAMuAQggA8BAADwAaEAFgBAAqER8ILgABYAQAv0RiDCAEOhABYAQM9woADQG16gA/AAFgBA
+BczXcAAAAEAB2MIgCgAXuMdwAA4AAIO4nbifuOxxAKECEgE27HAgoMoIL/8B2ADZz3CgAEQdNaDl
+A4//4HjxwAAWAkChwUDCARSAMFEgAIAG8s9xgABQqAXwz3GAAGioQKFgiQHaB/AAFgBAFSGMAACk
+AeJ9eBBy+fdRIwCACfIAFgBBA/AA2BUhjAAApAHiheL69wXM13AAAABAAdjCIAoAF7jHcAAOAACD
+uJ24n7jscgCiAhICNuxwQKA2CS//AokA2c9woABEHTWgocDRwOB+8cDhxQAWA0DPcYAAAABgoQAW
+AkAA3UGhABYAQP+7AqEAFgBAA6GkoRDy/7pA2M8g4gfKIIEPAADQAM8g4QfPcZ8AuP8doQbwz3Cf
+ALj/vaAFzNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQISATbscCCgpg/v/gHYz3CgAEQd
+taDpBM/+4HjxwOHFz3WAAMwEBG2aCi//CNkBhc9xoAC4HgKhAoUDoZoID/+9BM/+8cDhxaHBAN1A
+xQAWAUAAFgBAgeEa8gXM13AAAABAAdjCIAoAF7jHcAAOAABFIAADnbifuOxxAKECEgE27HAgoOxw
+oKCpcCDwxgogDItwBcwB2ddwAAAAQAHYwiAKABe4x3AADgAAhLiduJ+47HIAogISAjbscECg7HAg
+oADB7HAgoAHY5g7P/s9woABEHbWgKQTv/qHA4HjxwKILz/4KJgCQOnFQ8i8ogQNOII0H2tiyCe/+
+qXEbGlgzQCUAFEogACAPIBAg9dgFuLYN7/6pcRvIz3egABQECqfPcaAAZC7wIQEACYeA4BH0z3Cg
+AMAvURAAhgsgQIAJ9M9wAACwHrILD/8LIACEFfTa2FYJ7/6KIdoHKYdOCe/+2tjPcaAAwC9REQGG
+Pgnv/trYrgzgBipwTgvgA6lwANgPIEADBiYOkLP1z3GAAFAFAIEH2ofgGxqYMB3yz3CgADguBYAE
+IIAPwAAAANdwwAAAAA3y9dgFuM9znwC4/xqjW6Np2Bi4GaMB2ALwANiB4AP0QKHPcKAAFARKoAUD
+z/7gePHA4cUCEg02ABYAQQAWAUHFuIK5uv/iDu/+AhpYMwEDz/7gePHAdgrv/oDYz3egAMAvpRcS
+lhQXEZYA3qUfmJPPcqAAZC4UH5iTLysBAE4jgQfwIkMAZX4A2w8jQwAGIMCA9fVPJsAWpB8YkKQX
+AJb/uP7zoxcAlgQggA8AAAAPjCAQgPjz89gFuIDZVgzv/p+5GxIQNvXYBbgH3UYM7/6pcc9woAAU
+BKqgGxpYMwfwA9nPcKAAFAQloM9woAAUBKmAgOUe8oDl9PNBLYCQCvIvJAlw4HioIIABABYAQOB4
+UyVNkAnyLyRJc+B4qCBAAQAWgEDgeM9woAAUBKmA5fHz2BYKL/8FuP+43/X12AW40gvv/gpxz3Gg
+ABQEKBkABIDmGxoYNCTyLyiBA04ggQeU4coiRQCF9yhygCLCAc9woAAYLPAggwCU4coiRQCF9yhy
+gCLCBM9woABoLFV4YKAA2A8gQAAGJg6Q4PWA2c9woADQGzCgpR+YlBQfWJR5Ac/+4HjxwBYJ7/4X
+2bfBi3eqDe/+6XAjwEohQCBTINIAhiD+A0wiAKRCKBABDByCNI32CiHAD+tyBdiKI88BCiRABHUF
+r/0KJYAEEsYtviDAwL5AKg0hx3WAACiFUSAAgACFhiD3Dzf0gODKIcEPyiLBB8ojgQ8AAM4DBdjh
+8wHAAsFKclYJIARmbYDgH/LJcE4K4ABKcQ0UgDCFIMEADRwCMIog/w9TwACFqbgApUpwDgrgAOlx
+z3CAAIQE1XgggA8hgQQgoCp2AvAC3kpwbv4G8IDgyiZBFMomIhKB5ln0E8EAhRLCJnhEeSV4AKUM
+HQIUz3CAAEiGANkWIIAEQIUgoPW6IaAF9ADZi7khoPa6BfIhgIUhAQ4hoCoI4ADpcA0UgTDluQXy
+WBQAMQW14bkE8lAUADECtVEhAIEG8kpwygogBFUUgTANFIAwUSDAgB3yNcFWFAIxSnAmCyAEEsO4
+cIwgAoDKIcEPyiLBB8ogYQHKI4EPAAA7BDwEof3KJGEAUSXAgcomIhFKcFH9BczXcAAAAEAB2MIg
+CgAXuMdwAA4AAIO4nbifuOxxAKECEgE27HAgoJoK7/7JcADZz3CgAEQdNaCxB6/+t8DxwFIPj/6k
+wQHdgcDiC+/+qXEA3k3wgsDWC+/+AtkCwItymg7gAwPBpHgvJQeQQPIAwQDYz3eAACiFDyBAAAS5
+IWcvIQogLblTIRAAz3GAAEwFQIEEIYCgAKEH9IDi5AoiCcogIgggwNYJIAQQ2QDBANiKIwgAVGn6
+YgKyYKKA22iqaarPcoAAhAQVIgIEYIIEI0MEYKLPcoAASIY2egCiAaLPcoAAKIY0egCyAeYhwBB2
+ZgfF/wXM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChAhIBNuxwIKCmCu/+qXDNBq/+pMDg
+ePHAZg3AA7oKz/65BE//4HjxwF4Oj/6EKAsMz3KAAIQE8CINAAAhgX+AAGDKaIEEI4IPgAAAAEQj
+DwIvuga/RX8EI4IPAAEAAEEqTgMsuuV+RX7PcoAAzAQVegOCEHY18gQjvo+AAQAAI/LPcIAAVM0U
+iIfgHfTPcIAAsMcAgFEgQIAX8r67aKFEIwACBrgEI4EPgAAAAC+5JXgEI4MPAAEAAEErQQMleCy7
+BSMOAIDlw6IL8i8pQQNOIYAHECUNENb8gOX49REGj/7gePHAosGLcNoL7/4I2QDAgODPcYAAeAQA
+oQfyBhQAMQOxBBQAMQKxzgnP/qLA0cDgfvHApMGLcKoL7/4Q2QXM13AAAABAAdjCIAoAF7jHcAAO
+AACDuJ24n7jscQChAhIBNuxwIKAAwFEgAIADwAb0AsF2DWAEANoF8NoIIAUBwU4Iz/4A2c9woABE
+HTWgpMDRwOB+4HjB2c9woAAEJSCg4H7xwAYNj/7PcAAARBxmDe/+AN5x2F4N7/4GuM9wAABMHFIN
+7/4I3c9wAADIG0YNz/7PcAAAzBs+Dc/+z3AAAAgcMg3P/s9wAAAEHCoNz/7PcKAA1As4gByAz3Cf
+ALj/WBgACAAmgB8AAMAbCg3v/gTmYb2A5Tf3AN4F3QAmgB8AAAAc8gzv/gTmYb2A5Tf35QSP/uB4
+z3GgANAPGREAhhwRAIbPcKAAyB8VEAKGHoDPcKAAxCcZEAKGnBECABUQAoYtEAKGLhAChi8QAoYw
+EAKGgBECAIQRAgChEAKGkBECAKIQAIaUEQAAmBEAAIwRAACIEQAAGIHPcZ8AuP9YGQAIz3GfALj/
+WBlACM9woADQDzuAOYDPcaYA1AQXEACGLBEAgDARAIA4EQCAz3GgAIgkAIEBgQKBA4EEgQWBBoEH
+gWDx4HjxwOHFz3WAAIibqXBGCO/+A9kBhc9xoACAJQyhAoUNoQCNUSAAgADYjrgE8g+hA/AQod4P
+j/4BBI/+4HjxwH4Lj/7PdYAA4AQAhc92gAC0oeSQ6XHiCqAChiH8A1EgwIAacAXyH4aAuB+mIIUA
+kThgAKVUFoAQgOAV9Olw1gggB4Yg/AOA4AzyUSAAoAvyz3CAABwPCYBRIECABfQfhoK4H6Z9A4/+
+4HjxwBYLj/6iwc9wgAC0oT6ABCGBD///D9AEJYBfAADwLyV4z3WAALSh6gggBx6lgOCEAyEAmB0A
+EM9xgAAAAACB67ga8gGB67hA2M8g4gfKIIEPAADQAM8g4QfPcp8AuP8dogSBAeDTuAShBSCAD9D+
+AAAWolElwNEG8s9wgABwDwKIBvADhfIL4AMkhV6FRCIBDKDhlB0CEAT0gNiUHQIQUSDAgUAoAQZp
+9FEigNOCuRHyRCI+0wz0z3CAALShAYBRIACABPLeCQAHFfDaCgAHEfBFIQAGz3GAAECiKImGIf0P
+UiHBAUW5JXjPcaAAiCQQoc9wgAAIogCIgOAE9FEigNIJ9M9woAAMJBOAUyDAgE3yRCIAU0EogQBN
+cIYg/ANBKAIBUSWA0c9wgAC0oQjyBLlZYcdxgACYQxXwUSVA0wjydGlbYwAjgQ+AANhDC/BRJUDS
+CfIEuTpiACKBD4AAGESsGEAArBACAIDiH/IgipcYQgA82ACqGfCzul6lUSKA08Uhgg8AAAAHRSEA
+Bs9xgABAoiiJhiH9D1IhwQFFuSV4z3GgAIgkEKGKIdYAz3CgAIAlL6DPcaAAxCdBEQCGUSLA088g
+4gLQIOECQRkYgM91gAC0oQCVBCCADwAAzIDXcAAAyIAJ9AuFUSAAgAXytg6AAk/wHoXzuFQVghBp
+8hoRAIaA4gUggA8AAACaGhkYgAfyAdrPcKAA1AtSoATYEBkYgE1xEg9v/oogRA4G8J4Jr/6KIAYC
+USCAxAT0USEAxvjzz3WAALShz3agAMQnLhYBlhaFInhkuBB4hh0EEM9xgAAcD9oIoAcvkRoWAJYE
+IIAP////ABoeGJARFgCW67gJ8gDYi7gTHhiQGtgZHhiQHoVRIICBANmZ8hSVUSBAgZX0z3CgACwg
+D4CA4I/0ENhBwM9wgACwxwCAUSBAgBLyUSVA0xDyAdhAwA3wgOIG8gHaz3CgANQLUqAE2BAZGIDZ
+8UDBK4XPcIAA7MaLcwQhgQ/AAAAAwoA2uREmQJCBwkAgBAsw8uGVx4Bwv/QkQQAIJs4TMHZMAAwA
+lBWBEFEhwIEg9M92oAAsIC+GgOEa9MaGPJUwdsj3z3GAAGSqwoElgDB2EPSA4wTyAtkgoyOAgOKD
+uSOgBPIggqa5IKIBwg7wI4DjuQHCCvIA3p6+z3OgAPxEwaOjuSOgK4UkoCOFJaBUFYAQgOAH8gDA
+guDPImIBAvSHugDBQcJVJUAakgpgAwDbH4WUuB+lHoWQuB6lDfDPcYAAyIwNgQHgDaEQ2c9woACQ
+Iz2gtQdv/qLAz3CkAJBBTYDPcYAAiKBCsRqAUSBAxgOxBCCAD/8AAAAwuASxz3CAAIigANoI8s9x
+gAC0oTGBUSGAggXyQrBDsESw4H9ZsOB48cD+Dm/+mHDPcYAAtKEOkc92gACIoAC2z3CmAOj/C4DP
+daQAtEUDpgwVA5YNFQKWRBGJAC8nxwD/2BC4KXSEJAOcBCMIAAX0USEAkCz0MhUAllMgjwD/ZwG2
+/9j0fwi4739keEAvBRIAJQYAACfHAwUmxgFALwAWBCODDwD/AABALwcUG2MAIMgR/9gFJgYCCLgF
+I4MBBCIGAPpiACZAAQV65bZveAQjgw//AAAAKLtleE96A7ZEtgQVAJYCthGBUSAAgg3yz3CAAABw
+MiBAAoHgx/bPcKYA6P8NgAPwANgGpgWmANhKJIBwBtqNuqggQAMp2xK78COPAEAmAx8VewHi4KMB
+4ACROB4AEVUmQRQats9wgAAAqCYLr/4I2hsVAJbPcaUA2MsZphwVAJYaph0VAJYbpg6BHKYPgR2m
+JhUAlh6mz3CkAJB/HIAZBm/+H6bgePHAmg1v/gDbz3GgAMgfQBEABs93oADQDxkXAJbPcqAAxCdP
+Eg6GuIHPcIAA7MaooBHMEHbPdYAAtKEG8h+FUSCAgATyAd4F8BEanDNodlISEIYVEhOGG9gWGhiA
+USPAoAb0USBAoEoiACAH9B2FAd5adoS4HaVRIwChBvJUFYAQgOAE8gDYBvAdhYW4HaUB2DpwTCIA
+oMwhIaBc8s9ynwC4/1gaAAgQh89wgABwDw+IFqIA2s9woAD8RJ66QaBloB6FsLgepagVABBk4B6h
+ENgOoQHYFRkYgMoIr/4J2FEgQMcK9M9xgACADAuBAeCGD2ABC6HSCkABTCEAoAvyz3GAAESNBYEB
+4JILYAEFoVECAABMIgCgz3WAALShZPIdhVEjwKCEuB2lz3CAAESNCPIigAHhIqCKIIUJB/AhgAHh
+IaCKIMUIhgpP/gYPQAFM8EISAIYEIL6PAMAAAETyAbUehfO4PPKKIIQOYgpv/oohkAfKCYAHAJWG
+IPwAjCACgDL0HgiAB4DgLvQD2BIfGJDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Eh8YkBPMERocMAbwAJUqDqAINJWsFQEQgOEI
+8pcVgBAAqQDYrB0AEFQVgBCA4CTyz3agAPwlNIYB2s9zgABEjQaDgOE4YAajBfLPcYAAOQhAqVOG
+J4NZYSejgOA+hQHeUPJRIcCBTvIB2c9wgAB0BSCgSPBRIACgDvIB2c9wgAA5CCCoz3GAAESNA4EB
+4AOhPoXp8QPZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaBMIgCgE8wRGhwwC/Qdhc9xgABEjYK4HaUEgQHgBKEB
+3h6F8LgK8pUVgBCkFQEQqXLWD+ABAdsE8MYLQAIfhVEgAIAH8s9wgACAqAoMgATPd4AACK0Zh4Dg
+BfKSD8ADANgZp4oJQAHPcIAAHA8IgOu4EfKA5g/0BCCAL/8AX//g/s9wgACIoKDZxNo924YMb/4X
+ux6F8LhoCAIEz3CAAOzGAICA4OgNog3KIGIAlQJP/vHAOgpP/s9xgABkos9wgADgBCCgANnPcoAA
+MKIpos9wgADsxiSgJaAsos9wAAD/f89xoAAMJAGhG9gEoVEgAMTPdoAAtKEV8h2GhLgdps9wgACQ
+BCCABYEB4AWhiiCFCQoIb/4kgQIIQAFpAgAARBaAEPGGwrgEJ48fAAAACFQWghD7f4Diz3WgAMQn
+ANkV8uDavx2YkJTalR6CEATbz3KAAEgFYKIC2jwdgJDPcoAAZKohogfwQNm/HViQ1NmVHkIQACCR
+D4AAYMrAEYEgACCSD4AAWM64EoCgBSHTA7oIoAEFINADgODoAQEAAdgQHRiQyBGAIM9xgAC8qOV4
+G6ZsFoAQw7gcePQhAABkHsAUXh4EEMASgKDleBymcBaAEMO4HHj0IQAAz3KAANyoYB4EEGQWgBDD
+uBx49CIBAGgeABSKHkQQz3GAAOyo9CEAAI4eBBBoFoAQw7gcePQiAgD0IQAAjB6EEJAeBBAUzIYg
+/4VMC4EBz3CAABwPCIDruIQJwv8c8M9xgABwqgCBY4FDoWZ4AKEEgQwVAZASeCV4DB0AkADYj7gT
+HRiQCBUAkKC4CB0AkBrYGR0YkAYMQAHPdoAAtKEdhlEgwIGC9M91oADEJxEVEJZRIMCjANrV9VEg
+QKId9FEggKMy9FEgAKPm9VEgAKBc9FEgwKBs8gjYEx0YkG4OQAGA4GL0Atg8HQCQI4bPcIAAZKoh
+oNDxK/2gFgAQkRUBlgHgw7kwcKAeABDG9YoiCAATHZiQkRUAlsO4EHG88xIdmJC68ToVAJZRIICA
+H/LPcYAAcKoAgeC4GfSAuAChAdgDoYog/wAEoToVAJaGIP8BA7gBoQwVAJBGIAAPDB0AkAgVAJCA
+uAgdAJAA2I64Ex0YkFElANCQ8wTZz3CgAJAjPaCK8SL9Atg8HQCQI4bPcIAAZKohoB6G87h+8xMd
+GJR2/gTwEx0YlMEHD/5UFoAQgOAJ9EIVAJYEIL6PAMAAAAT0USAAohHyvxUAlqW4vx0YkIogBAAT
+HRiQ+gqADVQWgBCA4Fj1USCAoA70CiHAD+tyBdiKI40GiiSDD7UDL/0KJQAEz3CAAOzGKoDPcKAA
+BEQmoMTx4Hjhxc91gACIoAmlKqV4tUulAdgZteB/wcVKJAB6ANmoIIACANrPcIAAiKA1eECgAeHg
+fuB48cDWDg/+AN7PcYAAAADAoc9yoADIOx2CwqGA4MGhw6ED9ADYCvAEgddwZYchQ/v1iiCEAACh
+AaGA4MShDfLQ2Z+5z3CfALj/PaCC2BSiz3AAgBEUDqKKIMUPz3WgAMgfGR0YkAHYCHEIcghzugkv
+/Zhwz3CAABQA13CAABQADPIKIcAP63IF2GrbiiSDD9kCL/24c893oADQD9WnhdgJuM92oADAL3oe
+GJAGDcAHKg/ACPoMQAtA2c9wnwC4/zKg/g5P/oDZz3CgABQELKAdH1iQkgmAB9YNwAamCKAHANhO
+CwALB9hIHRiQOgoP/soPAArPcIAAMIwAkIfg+A4CCvYJwAoeD4AOKg7ADRWGUiAAAFEgAIAG9FYO
+oAoB3xDwA98Thpq4E6Yg3gXY0KVDHRgQANiaCW/+jbjRpc9wgAAwjACQh+CwDgEKcgkP/oIMQAMC
+CcAD+gsAABYIgAP6CsADJg7ACfIOQAgaDsAM6giADToKgA2WDE/9iiDGDc9xgAAcDw2xA9htGQIA
+G9nPcIAAOE4SCuABMKgyCI//ygiADcILj/6OC8AOJg3ADa4PL/7pcIkFD/7xwAoNL/4B2aXBGnAK
+IoAvgADsBJ4Jb/6LcEwgQKAAFIUwARSRMAb0CiKAL4AA8ARMJQCAxPZMJQCBy/YKIcAP63IF2Kzb
+aQEv/UokQABMJQCAJgEOAKhwABaOQAAWlEBMJACkenCF9owkw68o9AAWAEEAFo9AABaAQAAWAEFM
+JACkfgAKAIDnJfLPcIAA5AQAgEAszSC1fRDguGAWCW/+BNnPcIAA5AQAgEwhQKAdZcwnYZMV9ADY
+jLgU8AohwA/rcgXYt9tKJEAA5QAv/QolAAUKIcAP63IF2MDb9fEA2AC1z3CAAOQEIIBALMAgFXgS
+YRlhBSJABACxBN0G8IHABN2yCG/+qXEAIowjABwCFc9wgACEBPAgAgQe34DiLymBAAInQBAk8s9z
+gAAvhTRoK2MRI4CDCfIAJoEfgACUmxZ5ABkCBQAtgRMLIcCACfIAJoEfgACUmxZ5BBkCBRAiAoAv
+KYEAAidAEOD1QiNAIIDg6AbN//oPD/7lAy/+pcAA2EDx8cDhxa3Bi3WpcCYIb/4N2QDAHXhTIAEA
+RCk+DalwACGBf4AAyIa2CG/+Ddq+Dw/+4QMv/q3A4HjxwAohwA/rcgXYiiOMCIokgw/hB+/8SiUA
+AOB48cDhxSDbz3GgAMgcaaEAFgBAz3KgABAUDKIAFgVAAd1MJQCAyiHBD8oiwQfKIGEByiOBDwAA
+CQGcB+H8yiRBAxgaQAFoGUABA9gPormhaqFGDw/+aQMP/vHA7goP/qQQAQD5uaLBcPQg2c9zoADI
+HCmjpBABAFEhwIEu8jGIz3WgABAUI7nAuQO5BeED2k+lRoVBwo3hEN7KJuIRBhQPMYwnw58I9AQU
+DzHxdswn6pAB3kP2AN6A5ur1xYBFfselsYiGJfwfGL2les91oADMF1qgF/BFgM9xoAAQFEehpBAB
+AFEhgIIJ8jGI17qGIfwPGLlFeTqgz3WgAMwXDdkB2gPhDR2YkA4dWJAmgBkdWJAngBodWJAogBsd
+WJAD2RQdWJBwEAEBEB1YkHAQAQHPdaAA9AcE4SelR6OkEAEAmbmkGEAAaQIv/qLA4HjxwAPIpBAB
+APm5BA/B/wPZz3CgABAUJaDRwOB+ANqA4cokTXDgeOgg7QH/2VxgIKwB4uB+8cDPc4AA7ARocATZ
+9/8EawTZ9v/o8eB48cASCSAKENhv2Qe5z3KgAPAXMaLPcQAA8P84onYKAArW8eB48cDx//b/0vGB
+4M9xgADsBAP0BGkC8ChwBNnK8Q97SLgPeM9ygAAAbvQiAABAKAECSLgFefQiwAAweeB/J3jgePHA
+SgkP/qXBCHYCiyh1mHBkwACLABIGAREcAjB5cAISBwEEEggBEBQAMeSSBhIFAQAgyQMAkS8hSBIH
+IEACEHjn/wAgigEBlS8iiBIHIIACEHjj/wAgxgEClS8miAEHIIABEHje/wAgBwIDlS8nyAEHIMAB
+EHja/wAlBQAElS8lSAEHIEABEHjV/x9nBZXwf+d4EHjS/yaVIXAQeAd5PHoPuSV6UHoAIoECMHkA
+HEQwR5Unelx5D7pFeTB5ACGCAVB6XHkCHIQwD7pFeTB5ACHCAVB6XHkEHIQwD7pFeTB5ACFCAVB6
+XHkGHIQwD7pFeTB5P2fwf/x5CBzEMw+/5XkweThgaXHGuYW5CLkFIcECILYQeCCVChwEMCd4HHgI
+uAUgAAEBtgDAAaYBwAKmAsADpoEAL/6lwOB+4HjxwOHFCHU+iM9wgADkBECAQCUAFAO5NXlZYTYN
+L/4K2qlw9/9hAA/+8cDeD8/9CHbsiAiQz3KAAOwEtG8Ic4Yj8w9CKxECx3WAACiFYIXtu0hxA/Ik
+auu4iiDDLwP0HhaQEE2OUSIAgJzy47g79Ou7FPL/2AetSiQAcQDYqCBAAwphACCDD4AAlJv2e0Sr
+CmEB4A94QKta8EwhAKGN9gohwA/rcgXYiiMLBUokQADxA+/8CiVABO64R40yIUAEACGBL4AAlJv2
+eQjyBKkE2AAoQARFeAetPPAAqQ8iQgRHrV7wTCAApJT2jCDDr8ohwg/KIsIHyiBiAcojgg8AAOgC
+yiRiAJgD4vzKJQIEyXC9/wiW7rgE8gKOCa0E8AGOCK0Aheu4F/IA2UokAHEnragggAMAIYAPgACU
+m/Z4BBgCBAAYAgQB4S95AY4IrQKOCa0o8EwhAKHKIcoPyiLKB8ojig8AAAUDRgfq/wXYCJYAIYEv
+gACUm+64B432eQnyBBkCBATZAClBBCZ4B63g8QAZAgQA2Q8hQQQmeAetAY4IrcUGz/1BiQS4x3CA
+ACiFSKgiieB/KajgeBGI4H/CuOB44H7geOHFz3KAAOwEgODAIiIB/90UaQAggw+AAC+FoKtKJABx
+ANuoIIADbWIAI4APgACUmzZ4pKhtYgHjb3ugqOB/wcXxwAoO7/2YcKXBKHe4cwDeBCOAD/8AAAAY
+ugV6b3kIuf/YCLhkeCi4BXlFeQjd9CSAAyd4RMAQFAAxGf8SFAIxYb1AKAEEBXlHeUTBEBQCMRQk
+gDOA5UCwAeYr91MlwgVApwAUDQEH2QbwEH0UJ0wQALRhuRQkQDC7e0+9AJCle4HhcHt4YDP3BCCA
+DwAAAP8QuAV6XwXv/0Cn4HjxwG4N7/0g2QDaz3WgAMgcKaXPcaAAlBNboc9zgADkBGCD82jPdoAA
+tKEMhvV/UyDEBfBj+2NTII8Ag+ekwYtxGvQehpu4HqY0FoAQ4ovxcAr0KHBAIwEERGtAJgMc8v4N
+2irwHYaRuJK4HabPcKAAzBcr8IXnDvRBKgJSQCMABMG6iHO4/x6GnLgepg3aFPAsuFMgAgAehgO6
+mbgepuSDBeIFJwARAKEFgwGhBoMCoQeDA6ED4s9woADMF89xoACUE1yhAdqA4gf0HoaXuB6mINgK
+pRjwAMED2hgYWIABwRkYWIACwRoYWIADwRsYWIAUGJiAhhYBERAYWIAE2SelFhiYgNEE7/2kwOB4
+4H7gePHAXgzv/QHZocHqCC/+i3AgwM91gAAsQQCliiBXCmIK7/0CEgE2iiBXClYK7/0ghQCFQNlR
+IACAQMEG9NINL/4ocCzwz3CAAEyZUgoP/gDbxIVKJAB05oWoIIAHANjPcYAATJl1eUOJDyDAAOG6
+yiECAMohIQAlfuC6yiECAMohIQAlf1EigIDKICEAJ4UB4yV4B6XmpcSlFggP/gCFJ7jAuEAgRADP
+cIAAZEAMEAUATCUAgAX0mglv/ohwFvBMJICAzCWhgBLyTCRAgMwlYYDKIcIPyiLCB8ojgg8AAHcA
+DADi/MogYgHdA+/9ocDgePHA4cWiwYHgAdjAeEDAiiCXCn4J7/0REgE3iiCXCnIJ7/0AwQDBz3KA
+ACxBZYKA4aGCA4IK9CaCZH2keSZ7QcFloiV4A6IK8CSCBH2keSZ4JXtBwQOiZaKA4Q3yMgnv/Yog
+lwqLcAjZW9oe2xoN7/0Yu3UD7/2iwPHA4cWhwc91gADABKlwfg/v/QHZiiBXCv4I7/0CEgE2QI2K
+IFcKIY0Quu4I7/1Fec9wgABkQACAgeAB2MB4QMCLcAYML/4E2QCNUSAAgAGNBPT+DUAGBPCaDkAG
+EQPv/aHA4HjhxeHGmHDPcoAATEEFgiCCZoLIuBC4yLkFIQGAAYLIuxC7yLgFIwUAZ4ICgsi7ELvI
+uAUjBwBoggOCyLvIuBC7BSMGACTyABQOAC8oQQBOIIMHANgPIMAAEn0EIEMBpH5lfgAcgAPagqR+
+xXt6onmCBCCOAQQgwAGke8V7eaJ4gqR7BCFBg2V4GKLf9cHG4H/BxeB48cD2Cc/9OnAFgaCByLgQ
+uMi9BSUNkAGBJoHIuMi5ELkFIRAAAd4b8gQlgJMU8i8oAQBOIIIH8CGBIIDhAN8PJ48QCfIEJwAU
+QiAAgGB5yiBiAOZ9gOXbfuj1/QHP/eB48cChwQHYUglgDUDAz3CAAExBCoBRIACAyiACB8ohIgHK
+IoIPAABnAMojYg+IC+L9wCviBaHA0cDgfuB4ocHxwFoJz/2jwQh1SMDPdoAATEEahvuGPIYEfyR/
+p39Bx2IPr/2KINgEiiDYBFYPr/2pcYDnFfSA5Wn0sgrv/AfYgOBj8gohwA/rcgXYiiNGD0okAACd
+Ba/8CiUAAQQUATGA4RnyIBQAMQsgQIAN8s9wgAC4BGCAz3EAAJRxDNhgewPaCfCA4Af0z3CAALwE
+IIBgeQzYBhQBMYDhGfIiFAAxCyBAgA3yz3CAALgEYIDPcQAAlHEN2GB7BNoJ8IDgB/TPcIAAvAQg
+gGB5DdgEJ1CTC/LyCe/8B9iKIBgIpg6v/QpxEvCA5RD0iiDYBJYOr/2KIUcK5gnv/AfYiiAYBIIO
+r/3pcbD/vKYI3LcA7/2jwOB48cDhxaPBAdhAwM91gABMQalweg7v/VzZOoUbhSR4PIUEeYHAQcFm
+/wHAO4UEeUHBPg6v/YogWARVJUAfqXGF/89wgADEQkAlARuC/4twUgkv/gTZAcCm/6oPAA0AhYDg
+BfQFhYDgTA7B/10A7/2jwPHA1g+P/aLBAd3PdoAATEE6hhuGJHg8hgQhEADiDa/9iiCYA0wgAKBV
+Jk8XKvID8Lt9BCBAo/7zLygBAE4gkQfwJ0AUXB5AFIDgyiHBD8oiwQfKIGEByiOBDwAAGALKJAEE
+DASh/MolQQRAeIogmAOODa/9KnEA2A8gQAQGIBAgCnB//4ogmAN2Da/9PIapB6/9osDxwEIPj/2m
+wTpxGnJgwADYARwCMAHYAhwCMAMcAjCLcFYOIAuBwQTBCnAjIEAEBcIDwIDgC/QKIcAP63IF2Ozb
+iiTDD5UDr/y4c0B4VQev/abA4HjxwPIOj/0acCh1SHdodjhjZtk92jII7/0XuoHgCfQKcAoIL/6p
+celwvgjv/clxKQeP/eB48cDCDo/9CHYA3Yog2APWDK/9yXHPcIAATEFagDuARHkA2g8iggMEIkMA
+QiMDgMojYgAvJsfwAd/KIEEDBvIcgCR4RXhH/+lw4QaP/eB/ANjxwGoOj/0acCh3OnLPdoAAHA8U
+ls91gABMjBC4IgvgCAClgODKJyIQhSEHKU8hQCefuOxxAKHscQAZAAQIhlEgAIAF8gCFgbgApc9w
+gAC8BgCIgOAE9ACFg7gApc9woAAsIBCAAN5tHRgQSiTAcMlxqCAABs9wgAD+BwCIgOAM2MogIQBE
+Kb4Dz3KAAEzQJ3AzIgAAACGCD4AAzI0B4QCqgOce8gCFYhUPFqlxYxUEFoC4AKUA2Afw7HNAowQZ
+kAMB4PfgQIG6989woADUC02gwKFiHdgTYx0YERDwANmpcgXw7HMAowTiAeH34QCCu/fPcaAA1AsN
+odEFr/3UHYAT8cDhxaHBCHXiDq/8F9jPcIAA9AQAgIDgFfSd2AAcBDARzKlxHtoCHAQwAeAQeAQg
+gA8AAP+/j7gRGhwwAMAYurD/ugrABaUFr/2hwADY2vHxwOHFABYNQAXMAdrXcAAAAEACyMIiigAX
+usdyAA4AAFMlARCj/1ElQJDPcYAA9AQB2MogIQBlBa/9AKHxwOIMr/0A2M9xpwAUSAihR4HPdoAA
+lJ5fplCBz3OnADREgB6AEAehz3LzD//8UKEWoaDZmrn1G1gAz3GlAAgMCBEFAEwlAIDKIcIPyiLC
+B8ogYgHKI4IPAAAbAxgBovzKJCIAz3KkALg9mxIDBs91oADIH3umphIDBiDffKaSEgMGfaajEgMG
+fqZQ22KhmxoYAP/ZphpYAJIaWACjGlgAz3GkAOz/B6HPcAAA//8GoVEVEJYB2FEdGJDwpUMdGBAA
+2B4I7/2NuPGliiDEAM9xoADsJwahCoFoHgQQiiDNAAahCoFqHgQQz3AoAAIBBqGKII0ABqFRHRiU
+TQSP/eB48cDhxQhyAd2A4cohwQ/KIsEHyiBhAcojgQ8AAKIAyiQhAFQAofzKJQEBgOJE9lN6iiX/
+H4DhRPYzebN9FCGAABoIYAY7eax4FQSv/S9w4HjxwH4Lj/16cJpxSHcacwolACEA2s9xqwCg/1mh
+B9gaoVihIN7PdaAAyB/QpQHYQx0YEADYWg+v/Y240aUZ2c9wpwCYRzqgggsgCh7Yz3KnABRIHYK+
+gmwSEQBwEhIAAKcAGEAj97jFIIIPAP8AANMg4QX3vcUlgh8A/wAA0yXhFYohEADL/wh2qXCKIRAA
+yf8IdUApACKKIQgAxv8Id0AqACKKIQgAw//ReRnhLHkvcbF6GeJMei9yMHcAG4AjABxAI4T2ANgF
+8FBwfvYB2AEDr/0AHQIg4HjxwL4Kr/0A2c9zoAC0D7yDPKPPcIAAlJ5oEAIBELpPIk4AiL7PcqAA
+7CfGomoQDgEQvoUmjRDGot+Az3enABRIx6eAEA4A0KfPdqUACAwipvuAz3akALg9mx7YE/yAph7Y
+E/2Akh7YEx6Aox4YEM9wpADs/yagiiCKAAaivKMKDCACAdihAo/98cAOCo/9z3CAADCMB4iA4PQE
+IQCswc9wqwCg/2QQGQBoEBcAYBAYAAfdSv8A2c9wqwCg/zmguqA4oAIMoAkB2M93oADIH1EXAJbP
+dqAA7CdAwAHYUR8YkCDYEKcB2EMfGBAA2MoNr/2NuCDYEafPcacAFEisoQDYDaEOoQ+hz3AAAAEq
+BqbPcKUA6A+noCDYEKcF2EMfGBAA2JYNr/2NuCDYEacB2M9xoAC0Dxyhz3AAAAIvBqbPcAAAwjAG
+ps9wAABCSAamz3AAAAJKBqbPcAAAAmIGps9wAADCYwamSiAAIM9wgAAwjCSQC4hEKb4HGGAVeGq4
+ACBBDhUgACQ4YMdwgABEQwMQlAAEEJUAARCSAAIQlgAgiBC5BSGBDwAAQi0mpiCIELkFIYEPAACC
+RiamAIgQuAUggA8AAEJgBqYg2BCnBdhDHxgQANjiDK/9jbgg2BGnSiEAIBDwz3CAAAiaFiBABEQY
+gAFBhUgYQAFAIVEgV6A4oM9wgAAwjAaQMnDoAg4Az3GnABRIXBlABEAqACRPIEEAh7mJuSamCHGF
+IYsAJqaFIIwABqZMIQCgE/JMIUCgHfJMIYCgJfRALAAkBSCBDwAAgmAmpgUggA8AAEJiGPBALAAk
+BSCBDwAAgi0mpgUggA8AAEIvDPBALAAkBSCBDwAAwkYmpgUggA8AAIJIBqYg2BCnBdhDHxgQANge
+DK/9jbgg2BGngcCCwUAkEzuJworDCiTABB3/K8CA4EbyCcBAKU0hx3WAAIyZAKUKwAGlAcAYpQLA
+GaVALgAkhSCKAAamINgQpwXYQx8YEADYyguv/Y24INgRp4PAhMGJworDCiTABAr/K8CA4CXyCcBM
+IQCgAqUKwAOlA8AapQTAG6Ui8kwhQKAq8kwhgKA09EAtACQFIIEPAACCYCamBSCADwAAQmIn8Aoh
+wA/rcgXYiiNEBabwCiHAD+tyBdiKIwQIoPBALQAkBSCBDwAAgi0mpgUggA8AAEIvDfBALQAkBSCB
+DwAAwkYmpgUggA8AAIJIBqYg2BCnBdhDHxgQANgaC6/9jbgg2BGnhcCGwYnCisMKJMAE3v4rwIDg
+bPIJwAalCsAHpQXAHqUGwB+lINgQpwXYQx8YEADY4gqv/Y24INgRp0AqACSFIIoABqaHwIjBicKK
+wwokwATN/ivAgOBW8gnACMEEpQrAAcMFpQfAHKU9pQPBAiHCAAXDWGACIMWATfJieUx5L3Cocaz+
+A8FAKI0gtH0VJU0UAnnHdYAAlJ4CwATCIaUIwwIiAQAGwDtjAiMFgD3yAnosei9wqHGf/gTCBcMC
+IgEAA8AnpQIjBoA0HYARNPIGwAIghYBsBeL/TB1AEQohwA/rcgXYiiPFBRvwCiHAD+tyBdiKI0QO
+SiQAAK0Cb/wKJQABCiHAD+tyBdiKIwUB9PEKIcAP63IF2IojBQONAm/8iiSDDwohwA/rcgXYiiMF
+BPfxCiHAD+tyBdiKIwUFiiSDD2UCb/wKJYABQCBQIEwggKByBMX/ANjPcaAAtA8cob/+z3GrAKD/
+ZBlABmgZwAVgGQAGSiQAcQDZqCDADChwgCCCDRB4BriBuJe4BqYocIAgQg8QeAa4gbiXuAamKHCA
+IMQGEHgGuIG4l7gGpihwgCCECBB4BriBuJe4BqYocIAghgAQeAa4gbiXuAamKHCAIEYCEHgGuIG4
+l7gGpgHhAMBRHxiQSQVv/azA4HjxwBoNb/2YcKHBz3KAAPgEIIrPc4AAlJ4BgoQTAwCQccwgwYDq
+8nBwBvLPcIAArJ8hiCCqSiTAcEogABCoIMACz3CAAKyfMiAAApBwA/JAIEgQTCDAkKQBBgDPcIAA
+rJ8BiJBwBvQEIQEBLyVHAAbwByAAAS8lBwBhogDbz3CgALQPcBASAHygABoCARTwQCCAIRB4BriB
+uEApASQleAamQCOBETB5BrmBuUAqABQleAamAePPcIAAMIwGkBBzMgEGAADZDyHBAAshQIEB2Mon
+AgAN9AshAIHt889wgACsnwGIkHDn8wonAAKA4xHygeNn8oLjBvSKIIYgiiFGAgzwCiHAD+tyBdiK
+Iw8CZPC22r3ZGnJ5cc92oADsJ0ohACBKJABxCiJAFCp1qCCBAgAgQSNUa0AvAAEUeBpitXrHcoAA
+DJ8IkjB5QCmJAU8hQRAcfxC/5XkmpsC4uHgFIEAELyEIIAAjTxMJkvB/Br9PJ0YQHHlAKRMEBSOB
+ISamwLi4eAUggQIvIkgQRSHAEAamCoaLcQCxCJIvJgEAABQAMdBwFPRFJ88Q5qYKhgCxCZIAFAEx
+HHgwcBT0AeVp8YoixAaKIYQIp/EKIcAP63IF2IojDwdKJAAA4Qcv/AolAAEKIcAP63IF2Iojjwf0
+8c9xoAC0D3AZgAR5A2/9ocDgeADZz3CAAKyfIKghqOB/IqjgfuB48cDuCk/9r8HPcIAAHA8IgM91
+gABEQ8C4QMDPcIAAMIwkkAuIRCm+BxhgFXhquAAgQQ4AwBV4OGAZZSOJQcEZZSSJuGACiELBQ8DP
+cIAAlJ4AgCK4wLhEwM9wgACUnmQQAQHPcIAAuAYAkBBxSiEAICf0z3KAADhOLYrPdoAArJ+GIf8B
+YI5Due6KT4oCIcGAYY6GJ/8RyiFiAEO/DiPDg4Yi/wHKI2IAe3tleXtqQo4OIsKAyiJiAAK6RXkC
+8AfZgOEGBCEARcHPcaAAtEdHEQGGgOHyAwEAz3KAADhOLYrPc4AArJ+GIf8BQ7kgqy6KhiH/AUO5
+IasvioYh/wFDuSKrz3GAAJSeZBkEAADZnrnPcKAAtEdTGFiARv3PdqAAyB9RFg+WAdhRHhiQINgQ
+pgHYQx4YEADY1g1v/Y24INgRps9xgAAwjASRK4nPcqAA7CdEKL4HOWE1eWq5ACFADgDBNXk4YAll
+ELkFIYEPAABCLSaiCWUQuQUhgQ8AAIJGJqIIZRC4BSCADwAAQmAGolEe2JPPcKcAFEgMgM9yDwAA
+/M93gACUnkbAAMACuBR4G2cdZxlnACcEEAAnBRAfZwmHYYOnhQbHIBQEAIDnIoEMFQUAG/QKu0R7
+yb2le891pwAUSG2lCrkkeohxyblFec9ypwAUSC6iQC2BAgQhgQ8PAAD8ybgleBrwCr1Efcm7pXvP
+dacAFEhtpUAsgwJkesm5RXnPcqcAFEguogq4BCCADw8AAPyoccm5JXjPcacAFEgPoUoiACAD2EfA
+CiNAJAXAESCAhDoCAQDPcYAArJ8yIYAEQnFIwc9xoAC0R2AZGIAQuJu4z3GAAKy0IImfuIDhAdnA
+eQ+5JXjPcaAAtEdfGRiABfA6CW/9iiCIA89woAC0R3EQAIYEIIAPDgAAAEEofoTx9QDfAvAB589w
+gAAwjAaQEHfKAQYACMAAiBEgwIP18wDAArgUeEnAAcECwIDnAiBZAM9wpwAUSPegC/KB53vygucL
+9IohhiCKI0YiBfC22L3ZOnB6cUokACGKdUAvWBFhvVEWEJYB2FEeGJAg2BCmAdhDHhgQANjiC2/9
+jbgg2BGmA8A1bSV4EHgQuIUgigDPcaAA7CcGoQAlQBQQeAa4gbiXuAahACXAFBB4BriBuJe4BqFA
+IYAhEHgGuIG4BqFAI4AhEHgGuIG4BqFRHhiUQCQEPorAi8GMwo3D/PwuwIDgDfTPcIAAlJ58EAAG
+z3GAAJSeAeB8GRgACcAGwfV4gOHHcIAAlJ4a9IvCYIKKwSCBisJgoovCIKKNwmCCjMEggYzCYKKN
+wiCiM4A0EBAACfCKIMQGiiGECI3xLYBMEBAAFiBAMwrCACCVD4AAjJkLwPAdgCD0HQAgCCKAD///
+Af8vJkAmBC4+IC9wxPwOIJcPAAAAAQvAiCB8AAQovgUvcApxvvwOIIEPAAAAAQkngC8AAP8BiSHH
+D0ggAABIIQEALsJUHRgggeJVHVggBfIEwoDiDPRUb0AqAyF0e3pitXrHcoAADJ8IsimyQiRUIEwk
+AKCMBs3/F/EHwGG4gOBAIlIguAXt/0fApgxABe78BfAqDy/9iiCIA89woAC0R3EQAIYEIIAPDgAA
+AEEofoTx9WkGL/2vwPHAocGLcIIMb/0E2QDAUSAAgAQMgv8AwFEgQIAYC+L/yiCiAADAUSCAgBAO
+QgoAwFEgwIC4CIIKAMBRIACBUAxCBdIPoAEB2M9xgK7gAexwIKACyOxxAKHPcoAAjJmKJIF9ANmo
+IMAB8CJDAOxwYKAB4QIJb/0A2KHA0cDgfuB48cDKDQ/9z3CAAIQFAICF4LwABQDPdqAArC8ahlIg
+AABRIACAVPTPcYAAjJ8JgQHgCaHPcIAAuLRAgIDiA4AVeQXyCoEB4AqhBPAYgQHgGKEYhs91oADI
+HyDfmrgYpgXY8KVDHRgQANhaCW/9jbjxpYz+GIazuLq4GKZk2PClQx0YEADYPglv/Y248aWyDoAJ
+jgwACUoIwAEF8OoNL/2KIIgDz3CgAHhFAIAEIIAPDgAAAEEofoTz9c9xgAAcD0iBNJFTIgAAUggv
+/QHbdg4v/BHYYQUP/eB48cDyDA/9z3ClAOgPB4DPcqQADEJTIASARCCNAEQgAwECgs92DwAA/Ahx
+ybnEeOOCKrjYd8R/QS+FEuSCUyZGAulyybrkfiq+BvKe4YT3jCFPiMT3ANkD8AHZTCQAgATynuBE
+9wDYBvCMIE+IPPcB2IDlG3gleAXyTCaAh0P3ANkF8IwmT4g99wHZgOUCuQV5BPJMJYCHRPcA2Abw
+jCVPiDz3AdiA4wO4BXkE8p7iRPcA2AbwjCJPiDz3AdiA4wS4BXkE8p7mRPcA2AbwjCZPmDz3AdgF
+uCV4QiAAgH0EL/3KIGIA4H8A2OB+4HjPcKAALCAQgOB/CeDgfuB44H8B2ADZlrnPcKAArC88oOB+
+4HjgfuB44H7geOB+4HjgfuB44H8A2OB+4HjgfuB44H7geOB+4HjgfuB4z3KAAHAPVIpZYTB5QWlQ
+cMT2IngQeAPwAtjPcaAAyB8eoRDYDqEB2BUZGIDgfuB48cCKCw/9AN/PdaAA0A/1pQPeEvDgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG+jCb/n+71A9gapc9wgABwD++oAdgVpaUDD/3x
+wDoLL/0F2ADdC7ipcd3/z3GAALShHoHuuGDyHYFRIACAXPL+Dc/7ANmcuc9woADQGzCgAdnPcKQA
+mEA8oAQgvs8wAAAAAeXKJSIQUSMAwCf0USBAxQXyUSGAwyjyUSDAxQ7yUSGAwwryz3CqAAAEAYCG
+ID8Lg+Aa8s7/IN/PdqAAyB/wpgHYQx4YEADYpg4v/Y248aaE5aYHxf8I8MX/z3GAAMCNCYEB4Amh
+USAAxwDZD/IA2s9woADQG5y6UKDPcIAAkARAgBCCAeAQos9wpACYQDygPfBKDc/7USBAxTf0USAA
+xQHlyiUiEFEjAMDPdqAAyB8g3w708KYB2EMeGBAA2C4OL/2NuPGmhOVCAAYA5vHPdaAA0A8A2BWl
+8KYB2EMeGBAA2AoOL/2NuAPY8aYapQDYz3GAAHAPD6nPcYAAwI0JgQHgCaEB2BWlVQIP/eB48cDm
+CQ/9AN/PdqAA0A/1pgPdEvDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/n+71
+A9gaps9wgABwD++oAdgVps9xgAC0oR2BgLgdoZX/Hg+AAvEBD/3gePHA4cXPcqAA0A+wgs9wgABw
+Dy+IMHUA2wX0A9k6om+oAvDf/9UBD/0A289yoADEJ4ogGAg8GsCAz3GgAMgfDqGAEQAAUSBAgM9w
+gABkqg3yQhIChgQivo8AwAAABfJBgIDiA/JCoIAZwADgf2Gg4HgUzAQgvo8AAChARfLjuCHyFRIC
+N4DYz3GAAESN67oUGhwwBvIYgQHgGKEF8BCBAeAQoVEiwIAH9ADZz3CgACwgL6AVzEYggALgfxUa
+HDBRIECBF/KKIAQAFBocMM9xgABEjQ+BAeAPoRXMANlGIIACFRocMM9woAAsIC+g4H4E2BQaHDDP
+cYAAgAwfgQHg4H8foeB+8cB+CA/9AN0g2M92gADsp0AmDxXOCWAGAKbPc6AAyB8B2BOjWIM5g1QT
+BAD4EwAAz3OgADAQYYPPc6AADCQCIgKAZ4MDIUEDQaYipgIkAwDPcoAAHA/PcYAAtKFjpkwZRAMU
+klAZRANoggm2z3KlAAgMUyMAAAi2ABIEAE4ZRANTJEUBUyRCAEgZQgGD4sohwQ/KIsEHyiOBDwAA
+Vg1wBOH7yiBhAQQkhQ8AAADgQS1CA5YZggA+ge65FB4AEQzyBLqBukV4CLYH2AfwFScMEKCkA/AE
+2AHgiOC69+u7sAjC/ql3USCAxbrygOe49M9wgAC0oT6ABCGBDwAAAEAEIYBPAAAAQBBxAd/KJyIQ
+yiViEM9xgABwDw+JAeAPeA+pz3GgALQPN4EwcADeCPTPcKAAqCAGgIwgg47M9wDfV//PcIAAkAQg
+gAHdCIEB4AihgOeG8s9xgADspwWBBCCADwAAAOBBKEQDz3CkAJBBdYBWgFEkAIC4ckihz3KAALSh
+Z6EF8kwaxAAI8EwahAMEI4MP//8AAGehUSRAgAXyMLtOGsQABfBOGoQDcHtnoVEkgIAF8lAaRAEI
+8FAahAMEJYMP//8AAGihDYAGoQQggA8AAAD+KbhSGgQAHoLuuCPyz3CqAAAEBIAJoc9wgABQqECI
+gOJAIAQBMvKA4loALgACEIUA9CSDAxXYE7jwIMMAz3CAACio1XgB5lB2YKC09xvwz3CAAGioQIiA
+4kAgBAEW8oDiAhCFAM/39CSDAynYErjwIMMAz3CAACio1XgB5lB2YKCz90GpAhlCAYDnGPQEIL7P
+YAAAABL0z3CAAJAEIIAB3QGBYbgBoQeBAeAHoYoghQcaDO/8FBIBN1EjAMAT8gDfAf+KIMUHBgzv
+/Olxz3CAAJAEIIAB3QGBYbgBoQeBAeAHoYIO7/yKIEQCBCC+z4ABAADMJyKQzCUhkAzzz3CgADAQ
+A4CA4ADZCvLPcIAAkARAgAHdKHcMggHgDKKA5RXyAtnPcKAAyBwqoBz/z3CAALShQNk9oBTMhiD5
+jwX0ANiPuBQaHDDNBe/86XDhxTDbAN3PcKAAyBxpoAPaz3GgAMwXIRmYgE6hp6BqoOB/wcXxwOHF
+z3GAAIAMDoEB4A6hz3GgAMQnGREAhoDgANoF8gLYEBkYgM91oADUC1el//7PcYAAtKEdgYe4HaHo
+/xCFgOAr8gPYEaXgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB4EaUTzBEaHDCx/iEFz/wKIcAP63IF2M9zAAC8CUokAAAhAe/7CiUA
+AVEhAMbxwE30z3CgAAwkB4CA4Efyz3CAADCiC4DPcaAAyB9k4B6hENgOoQHYFRkYgFIIL/0L2FEh
+AMYz9FEgQMcA2iTyz3GgANQLFoE4gSTgMHBP91EhAMYE9FEjAMD881EjAMAS9FEggMQQ9BnwANnP
+cKAA/ESeuSGgRaDPcYAAgAwPgQHgD6HPcJ8AuP9cGMAIz3CfALj/XBgACK3/0cDgfuB48cDmC8/8
+CHXPdoAAtKEdhi8mCPA89OC9EPSCuM9xgACQBECBHaYDggHgA6IggYogRQnWCe/8I4FRJUCQHYYR
+9IS4z3KAAJAEIIIdpgSBAeAEoSCCiiCFCa4J7/wkgc9woAAMJAOAUSDAgB2GEPKEuM9ygACQBCCC
+HaYFgQHgBaEggooghQmCCe/8JYE9hi8mSPAA3w70CiHAD+tyBdjPcwAAEQmKJIMPzQev+0olAADP
+daAA0A8RFQCWgOCF8kQhfoIT8lEhAIAX8s9ygACQBCCCAoEB4AKhIIKKIEUIKgnv/CKBCfBRIQCB
+FfKc/x2GUSDAgWf0z3CgAMQnGRAAhoDgB/IC2c9woACQIz2gPf4b8JP/HYZRIMCBVfQ5helyBfAA
+EQBQAeJPekEpgAAQcrn3ANoF8AARgFAB4k96UyFAABByufcD2BIdGJDgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4Eh0YkBPMERoc
+MFD+HobzuAnyz3CAAJyu66jPcIAAXK7ssM9wAAD/f89xoAAMJAGhG9gEoTL/jQLP/AohwA/rcs9z
+AABYCQXYaPHgePHA4cVQ3QDaz3OgAMgfr6NeowIgQgBeowHaFRuYgEDaTqMEIL7PAAIAECwOgf9Z
+As/84HjxwNoJz/zPcIAAtKExgFEhQIIR8s9xgABwDy6JRBCCAER5USGAgEjayiKBDwAAkAAC8A7a
+ANvPcaAAqCAngagQDQBZYbFxwiVFEMol5hKweArZdP0d/s9wgADcRgCQz3agAMQnUSAAgQTyjCUD
+kgT3AN8V8M9woAC0D3ygz3CrAKD/eqAWCCAKANgZFgCWgOAE8gLYEB4YkAHfGRYAloDgPvRRIQDG
+PPQD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeDGgE8zPcYAAgAxqvREaHDAUgQHgFKEVgbhgFaHGDO/8AdiOCmAB
+Adi3/SUB7/zpcOB48cC2CO/8wNjPdYAA7KdBjSAaAjASakTgz3GgANQL2IEA20ImDhiA5somzBDR
+cEYADgDPcZ8AuP8Ygc9ygACQBJC4GKEYgbC4GKEgggWBAeAFoc9xgAC0oR2Bg7gdoSCCiiDFCHIO
+r/wlgQDYGf8A2D3wz3aAABwPyYYD4AQggA8AAPz/Kr7Avhe+x3YADgAAxXjsdgCmCMjsdgCmEczP
+dqAAiCRKJMBzAeAQeAQggA8AAP+/j7gRGhwwHqYA3qggAALwJY8T7HDgoAHmgOIA3cv3z3CAACio
+8CBOA+xwwKAB5VB1t/dtoQHYNQDP/OB4wdggGgIwz3KAABwPGIoB289xgAC0oYbgFoHCI8EADOAY
+IMAAYhkEAGIRAAED4AQggA8AAPz/nbifuOxzAKMIyOxzAKMYijaBhuAB2MIgAQAYIQEA7HAgoOB/
+AdjxwG4Pr/wb2M92oADEJxUWDZYWHhiQA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoBPMERocMIogBAweDa/8
+ANl6/eS9E/LPcIAAkAQggBGBAeARoUD9GRYAloDgBfIC2BAeGJBe/iLwUhYAllMgQQCD4dEl4ZAD
+8rf+GPDPcIAAOQgB2SCoz3CAAJAEQIAGggHgBqLPcIAAtKEegFEgwIEG8s9wgAB0BSCg/QaP/PHA
+jg6v/ADZz3AAAP9/z3WgAMQnEx0YkBvYFh0YkAHYEB0YkM92gAC0oR6G8bgF8qgeQBAI8BGGNoaW
+DmACANqoHgAQb/4dhue4BPIA2CXwLRUBllaGMHIG8oC4HaYA2JH+9vEEJYFfAADwLx6GJXgephEV
+AZbpuQXyz3AAALirC/DwuQTyAtiIHgQQ4LkH8s9wAAB4rmUGj/xRIcCAG/II2BMdGJAD/4Dg0vUC
+2DwdAJAhFQGWz3CAAGSqIaARFQCWUSCAgAf0Tv4dhlEgwIG+9REVBZZRJYCADPQKIcAP63IF2Ioj
+RggxAq/7iiSDDwTYEx0YkIv/qvHgePHA4cXPcoAAtKEWgpjgz3GAAISqBfJUEoAAgOAE8hmCuoIE
+8BuCvIJRgs9z/v//P2R4pHsEIoIPAAAAEEV4AKEA2AGhZXpJoQ7aSqHPcYAAYMoaCoABz3CAALDH
+AIBRIECACPLPcYAAUM0CCqABAdiVBY/88cAODY/8z3GAAAAAAIFRIACAG/IBgVEgAIBA2M8g4gfK
+IIEPAADQAM8g4QfPcp8AuP8dogSBAeDTuAShBSCAD9D+AAAWogDez3WAALSh3aXepVQdghPfpYDY
+lB0CEM9wgAAIrdmgz3CAAHCqwKDPcIAA7MbCoBTMgB2AE1EgwICIHYQTqB2AEw7yFcxTIECACvLP
+cIAAHA8JgFEgQIBKIUAgBPJKIQAgz3CgAAQl1KAw2c9woABQDCKgEcwTGhwwwPxRIYDDz3eAABwP
+z3GAAEyMHfIA2I64HqXPcIAAkARU4SCgG5cctR2Xkh0EEIoghA4etYogRAtCCq/8ANkG2c9woADI
+HCmgE/DPcIAAkAQE4SCgGpcctRyXkh0EEE4XABEetYoghAsSCq/8ANnPcYAAkARAgQCCAeAAoiCB
+AYEB4AGh+tgeCK//ANnU/IDg6AcBAM9woAAMJM9xAAD/fyGgz3CgANAPERAAhoDgDfIKIcAP63IF
+2IojTgyKJIMPKQCv+7hzAdnPcKAA0A8RGFiAaBeBEByVAiBQAB6F7rgaAiEALyAIJEAdhBPPcKoA
+AAQCgM9xpQAIDCCBBCCCDwAAAP8ougQhgQ8AAADgO3mJuiV6KIcEIb6PAAYAAFGlA/KMulGlz3OA
+AOynTaMMo89xqgAABCCBRBWCEJTiKqMZ8gb2iuIZ9CO5DvC34g7y7uIT9EUp/gJBKcFwUSDAgcIh
+YgAA2AvwRSn+AkEpAXH68SK5+PEA2QHYNqXPcqoAAARBgjyzS6PkusogYgDhusogYQCGIv4PQSoE
+ARATBQFJHQIRHaUFJQIBSLNVIcMG4LjPcgAAfA8JI4IAA/IA2DvwjuGM96AXAxBwcQj3z3OgANAP
+gBMDAHBxCfKAuB2lmgiv/IogBQjr8c9woADQDxkQAIZCIAAISCAAABBy3PfPcZ8AuP8YgZC4GKEY
+gbC4GKHPcYAAkARAgQWCAeAFoh2FIIGDuB2liiDFCE4Ir/wlgcfxAdiA4An0AN/PdaAA1AsA2Iz9
+MwYAAApwANkA/mIXgBBEFYEQBCBEAIYh/wNCKQUBRCQCAaByz3GAABzLwbpJYYm5O6VsFYMQSRWB
+EAQjDwCGI/8DRLskf39nz3OAAAhx9CPPA0odghNeHcQTz3eAAAzOSmeJulylcBWCEER4hiL/AyR4
+RLpYYPQjAAAEIQEBYB0EEBGFoHHPcoAAKHH0IkMAGaXPcoAAOHH0IkEAih3EEBqljB3EEI4dRBCQ
+HUQQYQIgAADfz3CmAAgEAYAEIIAPMAAAADS4USBAxkAdBBBAFQERC/TPcKAAqCAIgBlhMHl+DW//
+CnAD8Apwx/0EIIBPgAEAANdwAAEAAADfFvQB2JYVghBKHQIQz3CAAOynKJAEuom6QB3EE0kdwhP2
+pemgRXkosOXwSR3CE89wpgCMA12AUSDAxwQigQ84AAAAQSnABJYdAhAEIoAPAAAA8Cy4JbkleBGl
+z3WAALShBfIRhYy4EaVTIsECRBWEEDalUSQAgNEi4ocA2AP0AdjPdoAA7KdJppYVghBolgS6ZXpI
+tnGFPLZTJMIAXHrPd4AADMtPZx2l+6VsFY8Qw78vJcEDz3eAALyo9CdPEW2mXh3EE893gAD8zU9n
+eaX8pXAVjxDDvy8lwQPPd4AAvKj0J08ReqVgHcQTz3eAANyo9CeFEM9zpgCMA893gADsqPQnghCK
+HUQRjB1EEY4dhBCQHYQQfYMEI48PAQAAADC/Sh3CE2mmShWDEIDjANoZ8kwkQIMK8oC4HaWKIEUI
++g1v/IohUQAdhVEgAIAH8nXwggiv/IogkQNRIADG+/NI8FUhzgbguM9zAAB8DwkmwxAE8gDYPPCO
+4Y/3z3aAAJgPyYbRcQn3z3egANAPgBcOENFxCPKAuB2log1v/IogBQjq8RkXAJZCIAAIgODKIIwA
+EHPb989xnwC4/xiBz3KAAJAEkLgYoRiBsLgYoSCCBYEB4AWhHYUggoO4HaWKIMUIWg1v/CWBxvEB
+2IDgJ/IA30whAKDPdoAAtKEH8haGjuAF9B6GkbgepkoWgBCA4Br0yXXPcKAAeCZC2TKgHoXxuLwC
+AgCQ/YDgrAIBAMr9gOCsAgIAoQIAAADYvvyZAiAAAN+KIMUA8gxv/IohEQvPcaYA1AQsEQCANBER
+gDgRDYDLERIGKnHGualyhiL9Dwa6RXkqcoYi/Q8EukV5BCCCDwIAAAAnukV5RCUCHA26RXmpcoYi
+8w8EIIAPOAAAAA66RXkluCV4RCWBEBS5JXiIuEQlARJBKcGAUiBABRGmVB5CEMohgg8AAP//yiGB
+DwAAEB8acTaGP7YEIYEv/wMA/yi5NqZ6DiACANryvageABA98kQWghAxhqDi0SHhgjXyBCGEjwAA
+AAEI8s9zgAAAcEtjgeMK9gQhgw8AAAAk13MAAAAkI/IEIYMPBgAAADG7guM2AA0AguML9EwkAIAV
+8s9zgAAAcEtjguMP9EwkAIAE8sziC/Z2hhJzyiOODwEAiA3MIM6AzffXcAEAiA3H989ygACADDaC
+AeE2ogHZGvDPc4AAAHBKY89zgAAwjGaTcHIP9uu5CvLPcYAAHA8ogQQhvo8ABgAABfJKIAAgA/AC
+2RpxVBaBEM9ygADspygaQAQHuWiSiLlleSiyNoYwGoAEPLIxhquiBCWNHwgAAgAdsi2i13UIAAAA
+1AjhC8ogAQQWhoDgdB4AFAT0tgjAC2rwz3GgANAPgBEBADBwCvJPIAEgPabPcoAARI0gggHhIKJU
+FoEQgOFs4AvyCSCBDwAAagbPcKAA0A8iGFiABvDPcQAAfA8JIEEAz3CgANAPGRAAhkIgAAhIIAAA
+EHFCAA4Az3GfALj/GIGQuBihGIGwuBihz3GAAJAEQIEFggHgBaIdhiCBg7gdpoogxQiqCm/8JYHP
+cYAARI0CgQHgAqEdhkQg/oIU8oYgv40K8oogxQuGCm/8iiESB0ECz//PcYAARI0JgQHgCaGd/ATw
+AgoP/s91oADUCy/wbf0KJgCQLvQD2M91oADUCxGl4HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeBGlE8wRGhww8KUxBE/8HoXxuAPy
+QH7I8RTMhiD/hQXyA8gBgP24AvKO/e4IwAjz8eB48cDhxQh1z3CAADCiC4DPcaAAyB9k4B6hENgO
+oQHYFRkYgAXwTgxv/HvYAYWA4AX0USMAwPjzAYXBuIPgD/TPcIAAOQgB2SCoz3CAAJAEIIAGgQHg
+BqEA2BbwAYVRIACAB/TPcYAAtKEdgYK4HaEBhVEgQIAH9M9xgAC0oR2BhLgdoQHYrQNP/PHAz3CA
+AGiocgxv/BjZz3CAAFCoZgxv/BjZLwdP/+B4AdoA2c9woAC0D1ygz3CAAMCNKaB1BG/7GNjgeKHB
+8cDOCk/8CHdacs9ygAAAAACCmnFRIMCBocE6cxvyAYJRIMCBQNjPIOIHyiCBDwAA0ADPIOEHz3Gf
+ALj/HaEEggHg07gEogUggA/Q/gAAFqHPcYAA2K4mgQDYgeEB2cB5gOdAKRMDP/LPc4AAtKGUE4EA
+57kJ9M9wgAAohQS5IGAtuMC46XGGIfwAjCEChRR7EfTPcIAASAUAgFEggIAF8iDdjhMOAQjwmN2K
+Ew4BBPBeEw4BDt2KIIUAWghv/KlxiiCFAFIIb/zJcc9wgABwqgCA4LjAJSIRsHovIIgjSidAIAnw
+z3GAAHCqAKH6cAh1GnAIcs9zgADsxiCDg+EF9CODUSHAgAr0SiEAIAomQCQKIEA0CiVAJIHwwBMC
+ADgSgwA3EoEACLtleTkSgwAQu2V5OhKDABi7ZXk0EoMAQCEQBDMSgQAvIAgkCLtleTUSgwAQu2V5
+NhKDAM9yoAD8RBi7ZXlAIRUBXYIA2VEigIHMISKgCfIvIkgFOnH6cdpxG3FL8E8j0yNBLEIjwLoE
+ulR6inHGuUkhwQU0elEkwKLPcYAAoHJRYQbyQSkCARQiQQAouQPhz3YAAPz/BCGDA89xgABAokiJ
+z3GAACiFBLpBYUAgECHyuS8gCCQH8nt7QCAQIS8gCCRAJcEhJH4II4IDAiKYA1EgAIDAJSERJ20E
+IYEPAAD8/wgjQAACIFYAGmJQeoohAiACEgEhQCAAJTBwSPYCIQEESCEBADB5QMEE8ADYQMAvIEgE
+inEKc6YKIAJKJAAACiQAoD70CtjPcaAAyB8eoRDYDqEB2BUZGIAG8EoJb/yKIMoHUSAAww30z3Cg
+APxEHYAEIL6PMAAAAAX0USMAwO7zUSMAwMohwg/KIsIHyiBiAcojgg8AAKUCyiQiAOAEIvvKJSIA
+USAAwwDYCfTPcYAAgAwJgQHgCaEA2Ji4mnBMJACgyiUiEMogQgPI9EwhAKDPdoAAcKoX8s9woAD0
+B62gz3CAAGjHMYBbiRqJCLpFeAS2XYkciQi6RXgFtgCGgbgApgPwANgCpkwnAKCa8gCGUSAAgDvy
+z3CAAOyhTIjPcIAAAHAyIIQAH9lMJACAANrc989wAwAUAFZ4z3OjALD/UOBgYM91AwAYAFZ9UOVj
+ZS8oAQAB4i8rwQACezBzyiHFAJByqPdALEABQiAACBlhz3CAAGhzKGAhhk8j0yMJuAV5AoYleAKm
+BSPAIw1xALENcQDAALEMEgEgDXAgoBASASENcCCwiiCFAGINL/zpcYwnApUU8ownA5Eb8ownA5Uh
+8gohwA/rcgXYz3MAAAgMiiSDD6kDL/u4c89wgACQBCCAD4EB4A+hEgngAUpwEPDPcIAAkAQggA6B
+AeAOoQjwz3CAAJAEIIANgQHgDaEAhoDgBvIihg1wIKAA2ACmTCEAoM9xoAD0BwDYEvIHoQHYC6ED
+2AihTBmABQHYA/AA2KpxC3JKc0YKoAsAFAQwz3KgAPQHANkkogHdgOAB2DIKoAvAeADBACEABM9x
+oADIH/gRAgBCeEggAABfgRB4UHBKAAUADBICIM9wgABkqkKgoNgPoQDYH6HPcoAAcA/PcIAAtKFV
+ihyQQngAwkwkAKBYYB+hAtgVGRiABfJRIEDGINgC8oDYDqGMJwOVB/TPcIAAtKEckAjwjCcDkQn0
+z3CAACyiDZD6C2//ANnyDA//FMyGIPmPCvSMJwORANjPIKEDyiAiARQaHDDPcIAAAAAAgFEgwIEG
+8s9xnwC4/wDYHaHPcYAAcKoA2AChqXAI3N8FL/yhwPHAsg0v/ADZCHUBgMG4g+DKIEEgyiBBAAXy
+qXB4/kogQCCB4BHyEIVRIICBRfIQhc92gAC0oVEgwIEa8s9wgABwDwKIGPAB2wDfOfAA31UmQBrp
+cZDafgggAQDbQCUAEpweABAA2AW1BNsp8AWFJoWmDkABUSDAgZQeAhAH8h2Glbgdph6Gl7geph+G
+BCC+jxBwAADKJyIQ6PWcuB+mz3CAALDHAIBRIECA0vMQhe24zvMB383xAN/pc89ygAC0oVQSjgDP
+caAA9CaA5s9wgABkqhH0z3aAABKi9CbOE1yS2mLPdoAAcA/VjsJ6ELqAugLwAtpDoSWFTCAAoCGg
+DvTPcIAAOQgB2SCoz3CAAJAEIIAGgQHgBqGOCw//+QQv/Ghw4HjxwI4ML/yQ2aLBCHZBwSGGwbmD
+4QDYyiABIAbyyXAv/kogQCDPcaAALCAmgYHgAN8weRzyEIZRIICBNPLPdYAAtKEclRBxyfYlhs9w
+gABkqgKAEHGr9BCGUSDAgQjyz3CAAHAPAogI8AHYQvAFhiaGgg1AAT+FBCG+jxBwAACUHQIQEPTP
+cYAAsMcggVEhQIAB2UfyUIbtukPyQMEod0PwAN8j8ItwgOAD8gLbYKADgYDig7gDoQXyAIKmuACi
+LBYAAAShDBYAAAWhAMEBwlUlQBreDuAAAdsfhZ64H6VAJgASnB0AEJ4KD/8A2M91gAC0oVQVghCA
+4s9xoAD0JmX0z3KAABKi9CLDA1yVemLPc4AAcA91i2J6ELqAulbwQMcA31EgwIHT9W2GBYbPcYAA
+7MaBwgQjgw/AAAAAAoE2uxEgwIBAJgYSQCEECyHyBZYcEQcAQiAFBPQkwwAIJ0ABcHDX9s9woAAs
+IA+AgOAR9M9woAAsIGaAHJVwcCgHxv/PcIAAZKpigAWBEHOM8wOBUSDAgJXzANrPcKAA/ESeukGg
+A4GjuAOhi/HPcYAAkARAgQuCAeALoiCBiiBFC/YIL/wrgW7xAtpDoUWGTCAAoM9xgABkqkGhDfTP
+cYAAOQgB2kCpz3GAAJAEQIEmggHhJqIBAy/8osDxwJoKD/wIdhXMUyBAgAryBxIBNgDYmBEBAIYK
+4AAIcgGGwbiD4MonIRDKJcETBvLJcKz9CHUB34HlyiNhAEPyEIZRIICBBfQA22hwPPAUzFEgwIAs
+8hXMUyBAgBsSAjYP9AAigQ+AABCXAdgAqc9xgAA4TjKJUSEAgOgLggAQ2BQaHDDPcYAARI0SgQHg
+EqEDyBsSATaEEAIBz3CAAASXNXgpgFlhKaAI3dDxz3CAAMiMK4AB4SugAggv/IogxQkA2wHYAtnP
+cqAA9CYjokOGgOfPcYAAZKpBoQ70z3GAADkIAdpAqc9xgACQBECBJoIB4SaigOAK8gDYnrjPcaAA
+/EQBoQDYBaGCCA//9QEv/AUjQAPxwIoJD/wIdgGAwbiD4ADdyiBBAwTyyXBt/QHdgeAA2SzyEIZR
+IICBKPIUzM9ygABMjFEgQIEZ8kDYFBocMFASAAYB4FAaGAAbyM9ygACIlhR6IKoDEgE2ANiYEQEA
+LgngAAhyCvCkEgEAAeGkGkAANg/v+4ogBQoC2c9woAD0JiOgI4aA5c9wgABkqiGgDvTPcIAAOQgB
+2SCoz3CAAJAEIIAGgQHgBqHOD8/+SQEv/ADY4HjxwM9ygAC0oVQSgQCA4RT0PJLPcoAAcA9UikJ5
+ELlFIUMBz3GgAPQmY6EA2s9xgABkqkGhOf2B4MogYQAE8oYPz/4A2KMED//xwIYID/wIdRpxQSkA
+Ac9xgAAgc8O4CGEklQQhgQ8AAACA13EAAACAAdnAeTV4IZUE4TBwDfKMIAKkCfTPcIAAtKEWgIwg
+AoYD8hDYl/AklVoO7/uKIMQLjCACrCLyDvaMIAKgRPKMIAKkZvKMIAKoh/SpcJj+g/CMIAOkFfII
+9owgA6B99Klwn/958IwgA6jMIIKvAADwAHP0qXDH/2/wqXDW/mvwz3GAAAAAAIFRIACBG/IBgVEg
+AIFA2M8g4gfKIIEPAADQAM8g4QfPcp8AuP8dogSBAeDTuAShBSCAD9D+AAAWoqlwQv9J8M9ygAAA
+AACCUSAAgRryAYJRIACBQNjPIOIHyiCBDwAA0ADPIOEHz3GfALj/HaEEggHg07gEogUggA/Q/gAA
+FqFqC2ABqXAl8M9xgAAAAACBUSAAgRryAYFRIACBQNjPIOIHyiCBDwAA0ADPIOEHz3KfALj/HaIE
+gQHg07gEoQUggA/Q/gAAFqKaDWABqXBxB8/7TXEqDe/7iiCFCGHx4HjxwP4Oz/vPdoAAtKEfhgQg
+vo8AcAAAWfIvKQEAz3CAAAAF9CBNAJwWAhAA36QWARBPJYAQ6XP1/IDgEPSMJQOQz3GAAPwMBvQU
+gQHgFKE98BOBAeAToTnwH4b+uC/yz3WAADhOEI0ujRBxLfISjVEgwIAp9DCtUgigAAPYUSAAwxn0
+ANmeuc9woAD8RCGgMI2GIf8BQ7kQuU8hwgbPcYAArLQgiZ+6gOEB2cB5D7lFeS2gEo2EuBKtBfDP
+cIAAUK7gqEIMgAGhBs/74HjxwOHFpgkv/wDdz3GAALShHYFRIMCBXvTPcKAABCWigAQljR//AF//
+UyWAEIfgRfRRIoDTQfIegfq4P/QEIL6PAB4AAA7yB/DPcAAADgqeDs/7USKAwPr1USIAwM8lYhHP
+cYAAtKEegfm4zyUiEs8l4hLPJaITIfT7uBLyiL2JvY29TyXAEr2BjrgEJY0fAgAAAFIlTRQqvQV9
+D/D8uMUlgh8AAAAFzyXiEs8lohPFJYEfAAAAB89wgABAogiIxLgYuFEggMQFfWAJIvzKICII2QXv
++6lw4HjxwFoN7/sIcs9xgAC0oQCRiBEDAc91oADQD0QgBAMKJsCQQNsQHdiQQiyEAIYg/APKJmIQ
+qBEPAEAuhRXPc4AA7Kfwfv2z/JMQvuV+DB2Yk2GLArtI4xAd2JBiEQ4BiBEDAdtjwJFwe1EmgJJE
+uGIZxAAG9C6RUyHBgBDyz3CAABwPCYBRIACAPdjAKOIFyiChB8AoIQYK8EAsAQE4YM9xgACYQwhh
+F7gD4wUgQAEEI4MPAAD8/2V4nbifuAwdGJARzAHgEHgEIIAPAAD/v4+4ERocMA4dmJAgFQCWz3CA
+ABwPCIDruBDy5LoO9HINb/1IcM9wgACIoKDZxNo923YO7/sXu70Ez/vxwE4M7/uKIQgAz3WAAGSi
+z3CgAAwkIaDElc9wgAC0oR6AGnbxuIYg/CNJ8lElgNFF8owgA6RD9APZz3CgANQLMaDgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+MaCpcE3+USDAgAbyz3CAAICoFg0AAs9xoADEJxkRAIaA4ATyAtgQGRiABNgTGRiAG9gWGRiAkvAu
+CWAECnAId6lwCnHB/gh2I/9EJn6UDvJRJgCRCPLPcYAAtKEdgYC4HaEBhYoPz/568IDnDPJM/89x
+gAC0oT2BUSHAgXD0fv8r8APZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaATzBEaHDBRJsCQB/LPcIAAgKhKDAAC
+z3WgAMQnERUAllEggIAA3hr0Ug7P/s9wgAC0oR2AUSDAgSr0ERUFllElgIAM9AohwA/rcgXYiiNJ
+DUEHr/qKJIMPBNgTHRiQG9gWHRiQz3WAAAitGYWA4AXygg9AAdmlz3CAAAAAAIBRIACBBvLPcJ8A
+uP/doNUCz/vxwHYK7/tN2M9yoADEJy0SDoYJuBoaGIDPcIAACKIgiIDhocEG8gHbz3GgANQLcqEE
+2RAaWIBNcYYh8w+MIQyAAdnAeTlhNHkAiB7hgODKJUEQBPJAIQ0DIn4H8M9wAADsD8oKz/tRIIDE
+BfRRIQDG9vPPcaAA0A8QGViDJREAhmDAJREAhg95ARwCMAAUADGMINiBzCCCjwAABwjKICIAB/SI
+4QHYwHhmDSALLm7PcqAAxCcaEgGGBCGBD////wAaGliAERIBhuu5CfIA2Yu5ExpYgBrZGRpYgAkC
+7/uhwPHAjgnP+892gAC0oc9woAAMJDyAVoahwQIiQABkuBB4hh4EEBByyiHOD8oizgfKIG4ByiOO
+DwAAJAXKJC4A5AWu+solDgEDyAGA/bgJ8i8ghwqMIAKGBfQehp64HqbPdaAAxCchFRCWJg8ABIDg
+HAIhAJgeABDPcoAAAAAAguu4GfIBguu4QNjPIOIHyiCBDwAA0ADPIOEHz3GfALj/HaEEggHg07gE
+ogUggA/Q/gAAFqFRJcDRz3WAABwPBPJWFYAQBvADhi4KIAEkhj6GlB4CEEQhAAyg4Af0USXA0gX0
+gNiUHgIQlBaAEFEgwIEE8pe5PqZRIYCBJ/IUllEgQIEj9FoNgAeA4B/0z3CgACwgD4CA4AXyA8gB
+gP24FfIehpC4HqbPcIAAsMcAgFEgQIAF8lElQNMB2QL0ANmLcJDabgugAADbz3CAALShlBCBAEAp
+AgaGIf0PUiHBAUW5RXnPcqAAiCQwoimF47legATy6boE8gDYA/AB2FEhAIHRImKCANnKIWIA97ol
+eA94FvRRIoDTEvKA4BD0RCI+0wz0z3CAALShAYBRIACABPJyDwAEBPBuCEAEz3WAALShHoXzuCPy
+BNnPcKAAkCM9oE1x4g2v+4ogRA4F8HII7/uKIFYLUSCAxAX0USEAxvfzz3WAALShhhUAEc9xgAAc
+D74PoAQvkRXwAJUEIIAPAADMgNdwAADIgAj0C4VRIACABPJA/wfwBNnPcKAAkCM9oALYz3egAMQn
+PB8AkJQVgBDPcYAAZKpRIMCBBBkABAnyHYWVuB2liiAFCVoNr/sA2UH+CHYdhVEgwIEKAgIAUyZA
+EIPgB/QVFwCWUSDAgFzyMgvv/slw7wEAAM9xgADIjA2BAeANoQPZz3CgANQLMaDgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaAT
+zM9xgABkqhEaHDAQ2BAdGJAC2DwdAJASCu/+BBkABB2GUSDAgbf0ERUFllElgIAL9AohwA/rcgXY
+iiPXCAUDr/qKJIMPBNgTHRiQG9gWHRiQofAUzFEgwIA+hQvyBCGADwBAQADXcABAQAAD9Ji5PqXw
+uRLyAMHU2KlyQgtv/wHbgOAE8jIMQAEI8M9xgAD8DBOBAeAToc9wgAA5CAHf4KjPcIAAkAQggAaB
+AeAGoR6F87iMC8IEHoXwuOQMgf4ehVEgwIEH8gHZz3CAAHQFIKDPcaAAyBwA2AehMNgKoclwHv6K
+IIQN6guv+8lxA8gBgP24FfIehfi4E/IQ2BQaHDDPcIAAgKgCD8ABG8gAIIEPgAAQlx6F4Km4uB6l
+AJWGIPwAjCACgC70fgnABIDgKvQD2c9woADUCzGg4HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeDGgE8wRGhwwHoXzuAX0AJWCD+AF
+NJWBBa/7ocDPcoAAcA9UillhMHlBaVBwxPYieBB4A/AC2M9xoADIHx+hiiAYCA6hAtgVGRiA4H7x
+wOIMj/vPcIAAAAYAgIDgoAvCBs92gAAAAACGUSDAgEogACAa8gGGUSDAgEDYzyDiB8oggQ8AANAA
+zyDhB89xnwC4/x2hBIYB4NO4BKYFIIAP0P4AABahFMzguADfQPLPcaAAyB+wEQIAz3OAABwPahMA
+AWO4CCIAAB6hENgOoQHaz3CAAGSmFRmYgAMaGDDPcIAAKKcHGhgwCIPruAnyz3CgALRHSxjYg3cY
+mIBSDgACz3CAABAFAIiA4AXy9gqACDYMgAgEIJFPMAAAAM9yoAAsIM91oADIHzPw7bjKJYEfoADI
+H8oigQ+gACwgJ/LiDs/+z3CAAMCNCYCMIAKNiPdODa/6GNjPcKAAtA/8oM9wgAAcDwiA67gI8gDZ
+nrnPcKAA/EQioBTMz3WgAMgfz3KgACwg77ga9AohACTPcYAAgAzjoeWhA4LTAiAAB6H+DK/6GNgA
+389woAC0D/ygz3WgAMgftwIgABp2BNgKGhgwH4WA4IogDADKIIIPAAAAAg6lA9gVuBIdGJDPcIAA
+AAYAgIDgOArCBgCGBCC+jwAA33jWAwEAz3CfALj//aDLAwAACsjPcZ8AuP8Woc9wnwC4/1gYAAge
+hVEgQMU68grIhiDxjzb0z3WAAIAMA4UB4AOl7g3v/gHez3CAAMCNCYCMIAKNXAfG/89wgAAcDwiA
+67gH8gDYnrjPcaAA/EQCoc9wgAC0oR2AhiC+jwXyBYUB4AWlz3CAAAAAAIDruAbyANnPcJ8AuP89
+oEogQCAUzOS4DfTmuBv0hiD/hUzyUSMAwAnyUSBAxQf0HvAVzFMgQIAG9M91oADIHwDf1/AHyAMS
+ATYDGhgwBxpYMIIMAALPcIAAEAUAiIDg7fMmCYAIZgqACOnxFMzPdYAARI1RIMCANvKA2BQaHDAV
+zOu4B/IYhQHgGKVKIAAgBPAQhQHgEKXPcIAAOE4SiFEgAIDgCyIAyiBiAEwhAKAE8heFAeAXpRTM
+57gA31fyFcwEIIAPAAAAGNdwAAAACB30hg0gAQpwUSAAgBXyCNibuBDwiiAEABQaHDAPhUwhAKAB
+4A+l4vMWhQHgFqXe8QoaGDBy8ATY/PGSDIAAFcxRIMCAIPLPcaAALCAFgSaBCuAwcDH3AxIBNgLY
+FBocMFDY6g0gAJgRAQCaCwACz3CAABAFAIiA4FDyPgiACH4JgAhM8APIoBAAAPC46XAa8vIJgAAA
+2Ja4FPDouBXyAgugAIogBAAmDKAA6XUDyKAQAADwuKlwBvLKCYAAANiVuGIMgAC58em4z3KgAMgf
+CPKyCaAAAdgA2JC49PHuuAvyUSMAwAfyiiAEAA6iBNgKGhgwFRIBN++5EPJAEgIGz3CAACyiDZAQ
+coj3r7kVGlwwz3CAAOzG4KDPdaAAyB8KyAQgvo8DgOhDkAXC/1EgQMWIBcL/P4WgFQAQCSEAAOTg
+0vbPcIAACJkAgFEgQIAM8v6lEN5yDaADyXCA4AT0Adgepc6liiAIAKAdwBMOpR+FqOBJ94DgBfSK
+IAQADqV2DcAHL9iVuBIdGJDPcAEAwPwVHRiQbgmAAM9ygABQBQCCh+Ag8s9woAA4LgWABCCAD8AA
+AADXcMAAAAAP8vXZBbnPcJ8AuP86oAfZO6Bp2Ri5OaAB2ALwANiB4AT0B9gAos9wgAAABgCAgODo
+DoIGz3GAAIAMA4FEgQgiAAAEoQWBRoEIIgAABqF8hQeBSIECewDKCCLCAIjgSKEK9APZz3CgAEAt
+MKAAGsIzBfAB4AAaAjDPcIAAAAAAgAQgvo8AAN94BvLPcJ8AuP/9oM9wgAAcDwiA67gV8s9wgADc
+AxB4z3GgALRHSRkYgM9wAEQUAEsZGIBMGdiDA9h3GRiAyQdP++B4z3CAABgFQIjgugjyz3GgAKwv
+GYGKuBmhUSJAgAfyz3GgAKwvGYGOuBmh4H7xwOHFB9kbGlgwz3CgANQHGhhYgA4QDYbPcYAAAABA
+gVEiAIILGlgzGvJBgVEiAIJA2s8i4gfKIoEPAADQAM8i4QfPc58AuP9do0SBAeLTukShBSKCD9D+
+AABWo89xoABILL6hHxAAhgIaGDAIypzgzCCCjwAAkQAF8gAWAEAAFgBABczPcZ8AuP8YoYogRgTO
+DG/7AhIBNh0Hb/sIyuB48cDhxc9xgAAcD0iBUSIAgCjyhiD/Ac9ygABQcEO4CmIA24DiyiHBD8oi
+wQfKIGEByiOBDwAAbADKJMEA8AJh+solIQCB4s9wqgAMUL6Bx/eAvb6hAdkloATwoL2+oWWgtQZP
++/HAMg5P+xpwz3eAADhOEI+GIP8BQijRAM92oAC0Ryp1BfDSDm/7iiCIA3EWAJYEIIAPDgAAAEEo
+foT19UMWAJZGIAANQx4YkFcWAJa8uL+4Vx4YkF8WAJa/uF8eGJAA2J64Ux4YkBCPYB4YkMz/z3CA
+ADCMB4iA4BTyEI+GIP8Bkggv/kO4z3eAABwFFI8QdQjyz3CAAGhWFoBAeBQfQhQiDYAIQxYAlkwg
+wKBFIAANQx4YkIAADQAKcDMmAHCAANRzQCeBchR5AHkQvZu9z3CAAKy0AIifvYDgAdjAeA+4pXhf
+HhiQIPDPcIAArLQAiBC9gOAB2MB4D7iYuJ+4pXhFIMABXx4YkA7wEL3PcIAArLQAiJ+9gOAB2MB4
+D7ileF8eGJAKyITgdA5h+sogYQRhBU/7CiHAD+tyBdiKIw4KSiQAAIUBb/oKJQAB8cDuDG/7AdnP
+cIAAHA8IgMC4G3gA3s91oAC0R0sdmJN3HViQz3GgAIRE2KEC2XcdWJAA2Z65Ux1YkFQdWJDPcYAA
+OAFHHViQjrjPcYAAKABFIAYNSB1YkM9wgAAcD0kdmJMakAK4bLhEHRiQHNhFHRiQz3CAAFxjAYhG
+HRiQz3CAADhOEIhz/0okwHDPcYAAhKrJcqgggAPPcIAA1LRWeGGA8mr2fz9nAoBipwHiA6fPd4AA
+HAUAh4DgBPJkHRiQQx2YkQHYfP/PcIAAHA8ogOu5EfLPcIAA3AMQeEkdGJDPcABEFABLHRiQTB2Y
+kwPYBPBLHZiTAdh3HRiQUSEAgECHDvJTIkEAErlEIgADDrgleIYi/wMKukV4EvBIcIYg8w8KuAQi
+gQ8AAAAMBrkleAQigQ8AAAAwArkleM9xgADsYhUEb/sCoaHB8cCOC2/7mHCmwQQgg48AAAAET8EG
+8s9wgABYBSCAz3CAANS0AIBAwQhyhiL+AyS6QCqNAw/CwrgOuKZ6BSCGADwcgDEEJoAPAQAAwC64
+QCgNBpy9z3KAABwPSIKfvc93gAAcBVEiAIDPcoAAWEQWegby0ILEp1GCBfDAgkGCxKdRJICBQ6cI
+2gvyC9oEJr6PAAAAGMoigg8AAA8EUSQAgTpyzyXiFgX0USQAgs8lYhdRJkCCQfKA48ohwg/KIsIH
+yiBiAcojgg8AAG4BaAci+solggEEIYEPAQAAwC65z3KAAFBwLmJJJo4QYb7PcYAAHA9iEYEAL8MI
+uFJuVHpkecdygAAMqUgSDwZJEhIGRCEEAUAsQQIleGV4BCaBDwAAABAFIRMAnr0Y5s9+A8i5GIID
+dPCA4xXyUSEAgkTBJMEQ8s9wgAAAcChggeDK9oLgBfQG2GDABfAH2GDAA/BgwQDA6Lge8kTAJMKg
+4sohggDKISEABCCDDwEAAMDPdoAAAHBKZgQggA8GAAAAMbguuxpiz3CAAFBwaGBCeBPwUyDBAM9y
+gAAwcz15KWIEIIAPAQAAwC64z3KAAFBwCGJhuBYhBQBMJQCGjPcKIcAP63IF2IojRgNdBi/6iiSD
+D1EmAIIB2AfyL8HPcIAAAHAoYEAtggBUesdygAAMqeCCYbgEJoEP7wAA3Sa5JXhSINMDA8gEEhIA
+uRhCAc9xgABMQRqBO4EkeFEgAIIG8iKCz3CnAIhJL6A8FBAwanCGIOMPz3agALRHQSgUAgXwEgpv
++4ogiANxFgCWBCCADw4AAABBKH6E9fWKIP8Pbx4YkGseGJAD2Q+5z3CgAMgfExhYgFkemJRaHtiT
+Wx7YlFgeWJT7vUolAAAK8h6AArhCIIUDSCUFAKhwybgFfc9wgADUtAeAANkPIQEFJHjPcYAAzASA
+4AHYQIHAeFMiAYCvvQfyhiJ/D116D7pFfQTwgODPJeITVx5Yk4DhB/SA4AbYyiDhAQLwANjPcYAA
+HA8ogVEhAIAS8k8gAQKNuZe5FR5YkAUggQ+AAEA6Gh5YkAUggA+AAMBTEvAFIIEPgADAJBUeWJAF
+IIEPgAAAPhoeWJAFIIAPgACAVxceGJDPcIAAMIwEkIHgDvSEFgGWUCEAAwQhgQ8AAAAMrbgCuSV4
+BPCEFgCWFh4YkIwlz4/KIcYPyiLGB8ogZgHKI4YPAAAKAaQEJvrKJMYA6XACDqAICnEI3EcAb/um
+wKHB8cDmDy/7mHDPcIAA1LRggKTBaHCGIP4DJLgOuAZ5wrsOu2V5TcEEIYMPAQAAwC67geIB2MB4
+BrhWIEAIQCsNBpy9z3KAABwPSIKfvc92gAAcBVEiAIDPcoAAWER2egXy8ILkplGCBPDggkGC5Kbp
+uUOmLvIEIYIPAQAAwC66z3aAAFBwSmZJIoIAYbrPdoAAHA9iFo4QLccCulR6x3KAAAyp5H5IEhEG
+SRISBoYm/x4Jvgi7xXtlfwQhgQ8AAAAQJX+evU8gFAFPJNQhX/BRJECCzyBiAc8gIQHouZpwIfJD
+wSPDoOPKIMIAyiAhAM92gAAAcGtmBCGPDwYAAAAxvwQhgg8BAADA+2Muus93gABQcEpnYnoWIIUA
+LcALZhXwUyHAAM9ygAAwcx14CGIEIYIPAQAAwC66z3OAAFBwSmNhuhYghQAB20wlAIaM9wohwA/r
+cgXYiiOJCTEDL/qKJIMPQC2CAFR6x3KAAAypABIRAAQSEgBhuwQhgQ/vAADdJrlleVIhzwPPcYAA
+TEEagTuBJHhRIACCB/Iigs9wpwCISS+gNBQQMOlwhiDjD892oAC0R0EoEwIG8PoOL/uKIIgDcRYA
+lgQggA8OAAAAQSh+hPT1iiD/D28eGJBrHhiQA9kPuc9woADIHxMYWIBZHpiUWh5YlFse2JNYHhiV
++71KJQAAC/IegAK4QiCFA0glBQCocMm4BX0A2c9wgADUtAeADyHBBAR5z3CAAMwEgOEB2UCAwHlT
+IgCAr70I8oYifw9deg+6RX0F8IDhzyXiE1ceWJOA4Ab0gOEG2Mog4QED8ADYz3GAABwPKIFRIQCA
+E/JPIAECjbmXuRUeWJAFIIEPgABAOhoeWJAFIIAPgADAUxHwBSCBD4AAwCQVHliQBSCBD4AAAD4a
+HliQBSCAD4AAgFcXHhiQz3CAADCMBJCB4A30hBYBllAhAAMEIYEPAAAADK24ArkleAPwhBYAlhYe
+GJCMJc+PyiHGD8oixgfKIGYByiOGDwAACgGQASb6yiTGACpw6gqgCApxCNwvBS/7pMDgePHAygwv
++wK52nDPcIAAHA8fgDZ5ACGND4AAhKqA4KHBQMPK8giFBSCTACAdwBQYFRUQEBUUEBQVERDnhapw
+ABUQEIYg4w/PdqAAtEdBKBICBfBODS/7iiCIA3EWAJYEIIAPDgAAAEEofoT19Yog/w9vHhiQax4Y
+kAPZD7nPcKAAyB8TGFiAWR4YlVoeWJRbHliVWB7YlPu/SiUAAAryHoACuEIghQNIJQUAqHDJuAV/
+z3CAANS0B4AA2Q8hgQQkeM9xgADMBIDgAdhAgcB4UyIBgK+/B/KGIn8PXXoPukV/BPCA4M8n4hNX
+HtiTgOEH9IDgBtjKIOEBAvAA2M9xgAAcDyiBUSEAgBLyTyABAo25l7kVHliQBSCBD4AAQDoaHliQ
+BSCAD4AAwFMS8AUggQ+AAMAkFR5YkAUggQ+AAAA+Gh5YkAUggA+AAIBXFx4YkM9wgAAwjASQgeAO
+9IQWAZZQIQADBCGBDwAAAAytuAK5JXgE8IQWAJYWHhiQjCXPj8ohxg/KIsYHyiBmAcojhg8AAAoB
+4Afm+cokxgAqcD4JoAgKcX4KoAoAwADZz3CAABwPP6AAhQAeACBdAy/7ocDxwCYLL/sA24DhpcEK
+8kiBBCKCDwAAADBCIgOAyiNiAFJoVnrHcoAAhKrAgui+QMYR8iDAz3WAAABwMiUEEACKDWUEJoAf
+BgAAADG4ACBFAwTwAdiYcLhwrr6vvrC+QMaA48whIoCN9M9wgADUtM9zgAC0oZYTgQADiAshAIA4
+8kgTgQAA3wDbUyFNAA8jQwNEIQ0DQr2GIf8DDydPE7xpBCcPkADZBHsPIUEDJHjKJwEQgOPKI8ED
+TCVAgBPyTCWAgBTyTCXAgELyCiHAD+tyBdiKI8sJSiQAAN0G7/kKJQABDrtlfjfw5Xv98SGCz3WA
+ACiFdGljZVEjQIIK8i8oAQBOIIEHANiOuDh4BX4j8EwlQIAO8kwlgIAS8kwlwIAW8gohwA/rcgXY
+iiOLD9Xxz3CAADCHNngCiAfwz3CAADCHNngDiA64BX4F8I6+j76QvgQmgB8BAADALrjPcYAAOHMI
+YbBwVgAmAEDGCiHAD+tyBdiKI4wBPQbv+Zh2DZEogYYgfwwEIYEPAAAAMCy5qWkceEAlgRMRIECD
+DyZOEEDGDfQKIcAP63IF2IojzAOKJMMPAQbv+bh1z3GAANS0AIGLc6CDhiD+AyS4DrgGfaCjAIHC
+uA64pXgAowDAz3OAABwPBCCBDwEAAMAuuUApBQZPJQUHqINPJcUHz3aAABwFUSUAkM91gABYRDZ9
+BvLwheSmsYUF8OCFoYXkpum4o6Yt8qaCCLklfaaiBCCADwEAAMAuuM91gABQcAhlSSCAAGG4ArgU
+eMdwgAAEqqqAy4BiE4AAIMcEIMQDz3CAAOyhERCGAE8lhQcEJgABCbgFeeV5iiAGBlHw6Lgd8kTA
+JMag5solghPKJSEQz3eAAABwzmcEII8PBgAAADG/BCCBDwEAAMD+Zi65z3eAAFBwKWfCeRLwUyDB
+AD15z3WAADBzLWUEIIEPAQAAwC65z3aAAFBwKWZhuTZ9mOWM9wohwA/rcgXYiiONAYokgw/JBO/5
+uHUybTR5x3GAAAypoIHBgUIkQQAEIIAP7wAA3Sa4BXlSIcEDiiAEAsSipaIcGkABCKImogHYH6Nl
+AC/7pcAA2JC4z3GgAMgfFRkYgM9wgAAImUaQW3pPIgMAWhEChjgQgABkelhg2BkAAOB+4HjhxQDb
+z3KAAIiWFCINAGC1aLUaYiAawgDAHcQQKBrCAM9xgAAImRZ5IpEwGsIA0B3EEIAd3BB4HUQQAdmI
+GkIAz3GAACiXFXlgoeAdxBDwHcQQ4H/BxeB48cDhxQh1GxIBNs9wgACIljR4EYiA4BLyA8gBgO24
+DvLPcIAAdIPwIEAAz3GAAKAEFHkAkRDgALHiCwADG8jb/wPIAdmgGEAAvgggA6lwz3CAAAAAAIBR
+IECBEvLPcaqqu7vPcJ8AuP82oDagNqA2oM9xoADIOw6BiLgOoWkHz/rxwO4O7/pKJAByz3CgAIgg
+AN6oIIAPh+Y58qCAz3GAAAiZz3KAAKiu1nloiUeCemKA5c9zgAAAl9R7HvQAJo0fgAD4lviNgucI
+9OCT+38jkYC/JH/gswbwgecE9CKRILMA2Titz3WgAMgc+oUgk+R5LLMF8CyTMHXD91lhA/Css7li
+iSHPDwQYUAAB5gDZz3CAAKiuwQbv+ieg4HjxwFIOz/pRIMCBGxIBNs91gACIlgMSAjbPc4AApKg0
+ffGNEBWEEBLyAefpcDIShQCnkwIbAgHPdkEAgwCms891gADoDOOrEfBAJEAAMRKFAAKrwBUNEeOr
+z3YhAIIAprPPdYAA7AywcMf3xKMAhQHgAKUEg1nwz3CAAKiWKGAB4ASrAYJRIACBsIpA8i8kyAPP
+d4AA/GIHh9KKgOAveQTyBYck8EkhwAA0bc93gAAohSFn9rkH8s9xgAAwh7Z5IYkC8ADZx3CAADCH
+tngEiAgmDhAIJkEQgHFJIcEDFm01eM9xgAAwiABhz3GAAEiGtnnPdYAAHA+9hSGBpXkEIYEPAAAA
+CCZ4A/ADggKjmBKAACiLEHEG8gDYBKtg2Bi4BPAA2J24BKOVBc/64HjhxeHGz3CgABQEA9kjoBvI
+z3KAAKSoYZLPcYAAiJbEihQhDQBotQAggw+AAKiWOOHAq2KCFXkGkmChAxIDNsAdBBAEgqATAQCG
+IcMPJXigGwAAwcbgf8HFGxICNgQgvo9gAAAAz3OAAIiWVHvHcoAA+JYIcQbyA8gckFEggIIK8gQh
+gQ9hAAAA13EBAAAABvQA2ACzAdge8BTMUSDAgQMSATYN8jIRgQABizBwBPQA2AGr8vEB4AGrC/Ax
+EYEAAIswcAX0ANgAq+bxAeAAqwLY4H8YqvHAUgzv+gTZCHUbEg42BtgbGhgwz3egABQECqfPcIAA
+2HPaCg/7AIXSCi/7BNkBhcoKL/s42SKFgOEG8gGFAJAQccz3CiHAD+tyBdiE20okQACRAO/5uHOi
+Ci/7A4UBhUKFIJAFhZYKL/tCecqnTQTv+hsamDPgeM9xgAA0BeB/A6HgePHAzgvP+iGACiUAkBCJ
+w7jKIcEPyiLBB8ojgQ8AAL0AyiBhATHygOHKIcEPyiLBB8ojgQ8AAL4AyiBhASXyBLjPcYAAKIUH
+YQOFAJCGIPwAjCACgC2/wL8K9IQvCxwAIYB/gABIzSGAgbkhoAGFwoABhoDgBPIAhoDgDPQKIcAP
+63IF2MrbSiRAANUHr/m4c1EggMEF9AIIwAaA4AzyiiDOAk4J7/rR2QCGgNkooAGGQHgc8AGFIJAi
+yBBxyiHND8oizQfKI40PAADXALoH7f8F2Klwqv8Bhsf/z3CAAHSD5qB6Dq/66XBNA8/6z3GAADQF
+I4HgfyCg8cDhxQMSATaigSCFVggv+yTaAYWA4OIgAgA1A8/64HjxwLYK7/oG2BsSDzYbGhgwz3Wg
+ABQECqUJhYDgAN4T8noLwAIJhYDgDfIkFQUQCiHAD+tyBdiKI8QGDQev+UokQADqpc9xoADQGxCB
+z3KAAIiWhrgQoROBkLgToR2KgOAbGtgzDPLPcIAAdIMGgM9xgACgBBR5AJEQ4ACxxrLOsiYaggPM
+GoQDiiBPC0oI7/qKIQQLiQLP+vHA4cUIdc9wgAB0g0aAz3CAAATLhCoLDAAgQg7PcIAAtJcAgFEg
+wIChwRTyFmnPc4AAMIgAY1EgQIIM9M9wgAAwhzZ4W4oCiIm6DrhFeAbw3g0v+4twAMAApT0C7/qh
+wOB44HgKJIDwBSBEAOAgwQdEJP6AQSrEAIQAAgAvJALxQiEBAUIgAwHoIKIEBBEEAgQRBQIEEQYC
+BBEHAgQbCAEEG0gBBBuIAQQbyAEsACUARCI+gTwAIgBEIvyAQCHBAOAgwQdAI8MAqCCAAQERhAIB
+GwoBICDABwQRBAIEEQUCBBsIAdQH4f8EG0gBRCL8gAQRBALJB+//BBsIAUIhQQBCIEMAqCCAAQER
+hAIBGwoBICDAB/HADgnv+gDYz3WAAIyrSiQAdIDeqCBABQhxAeBPIMIBFiVDEEeriiIIAEApBAEA
+JIEPgAAohUChANpCscapwNh/HQIQz3WAAEQFwK3PcIAADKyA2a4J7/oocsGtz3CAAHAPGQHv+sKo
+osHxwJ4I7/qYckXBQSgBAkEoAwQHeSd7xrvHc4AADKwgi+e5EvQUFA4xz3KAAIyrFiJNAOCF8XAE
+9OKV0XcI8ieN57lnbfPzANgg8MaNgOYG9IDfz3CAAEQF4ajPcIAAcA/iiPF2BPSA3sKoxo02egAc
+gAMHjYe5AKvPcIAARAVgiCCoAdhnqgzcgwDP+uB48cAKCM/6z3GAANxzIYGjwULBz3GAAIQEFSER
+AAARDSCA5S8oQQNOII4HS/L0bsd3gAAohQaPz3GAAIyrFnkAgSKRjuYIHEQwyiBhAATyi3ICwcj/
+gOAu8gDYz3GAAEwFQIEPIIADLyAKIAQggKAAoQb0gOKECyIFyiAiCM94egogABDZANiKIQgAABEC
+IAK3IKfPcYAASIbWeQChAaHPcYAAKIYEIgIEABmAINR5ALEQJY2TLyhBA04gjge49a0Hr/qjwKLB
+8cBKD4/6RcHPdYAAHA8ihTBwCPQmlRQUDjEwdgT0Vh2CEIDiDPTPdYAARAXBjYDmANnKIEEAI/Ih
+rY7iBPQB2B/wQSgNAgd9QSgBBKd5z3aAAEQFoI5TJUURTCUAhMa5i/YKIcAP63IF2LPbcQOv+Yok
+gw9RJYCRBPIA2Fzxz3WAAIyrFiVNEeeNAKUUFAAx4K5GrQK1x3GAAAysAIkHrQAZQgEAG0IBzPGi
+wUHBQSgCAgd6QSgBBEd5z3KAAAysxrkqYue6EPQEFAMxz3GAAIyrVnlAgVBwBfRCkXByBvJHiee6
+9fOA2APwBongf6LA4HjxwF4Or/q4cEokQACQ4Mohyg/KIsoHyiOKDwAAAwHMAqr5yiBqAUAtAwHH
+c4AAKIXGi4wmApAA2A3yz3CAAIyrFiCNA6CFoKEmizZ4ApAAsohweQaP+uB48cDhxc91gACMrM9x
+gAAcDwCBdBUCFhByIfQCkeoVAhcQch30dhUAFjoP7/93FQEWjCACgBPyz3KAAEgFIYIA2w8jAwAE
+uGZ5IaIAIIEPgAAohQCBqriIuAChANgdBq/69B0cEM9wgABAoiiIz3KAAGyujCECgAKSQSgDAwvy
+67gJ9AS5x3GAACiFApEPIMAAArEA2OB/BLIA2kokAHRIcagggAPPcIAAcK3Pc4AA8K00e0CzNnhA
+oEGgAeFKJMBzANmoIEACz3CAACiGNHhAsAHhz3CAAEgFQaDPcIAAbK7gf0Sw8cAeDa/6VGiGIvgD
+ibpTIcMARXvPcoAAKIYUeo/hiiUPHMogKQAJ9gCSAN4PJk4QiiXPH8Z4ALJKJAB0ANqoIEAGz3eA
+AOitVH/El6R+0XPPcIAAcK0M9ADexLdWeMCgwaDPcIAAEK5VeMCgAeIZBY/64HjxwKoMr/qYcgh1
+z3aAAPCt9CZAEM93gABwrVEgQILKIEEAyiQidMogIgDoIGIC9CYCEFEiQIID8gHgkOBGAAYALbvA
+u89ygAAohrR6QCuFAmCSBL2GJfgTib0PI0MAYLIA2hZ/QKdBp8O5pXkFIUMBFH5gts9xgAAQrhV5
+ABkAAQLwgNiNBI/6CHHDuM9zgADwrfQjAgDJulBxyiQidMogIgDoIGIC9CMCAMm6UHED8gHg4H7x
+wPYLr/oA2aPBCHUBgMG4g+DKIEEAKAhi/sogQgOB4BHyEIVRIICBD/IQhc92gAC0oVEgwIEa8s9w
+gABwDwKIGPAB3gLwAN4C2c9woAD0JiOgJYXPcIAAZKqOCq/9IaDJcP0Dr/qjwAWFJoXqDM//lB4C
+EB+GBCC+jxBwAABh9M9wgACwxwCAUSBAgAXyUSVA0wHYAvQA2EDAlBaAEFEgwIFI9G2FJYXPcYAA
+7MaLcAQjgw/AAAAA4oE2uxEnwJBAJQISQCEECyXy5ZUcEQYAQicFFPQkwwAIJk8BcHc2AAwAz3eg
+ACwgb4eA4xP05od8lnB3yPfPc4AAZKrig2WBcHcJ9IDgBPIC22CgA4GDuAvwA4HjuAryAN+ev89z
+oAD8ROGjo7gDoQuCBKEDggWhAMFVJkAakNraDW//ANsRhc9xgABIBQChQSgPA8O/lBaBEEEoBQVR
+IcCBFGkFIMQDBfIdhpW4HaZ98E8kQAKa/5Dg8gAGAM9xgAAQrpQWghDwIQMAQCoBBoYi/Q9SIsIB
+RbpFec9yoADEJ0EaWIACJcGAwCGEDwAAABAMv9dxAAAACJC/UfYFJ08RYhrYg4whAoDI9s9xgACA
+DAyBAeAMoQDZnblJ8OV7YhrYgNdxAADAD1IADAAOIYIPAAAAEM9xgABwrRZ5oOIAgQQRBQBQ9wDb
+DyODAGG7TiIPCAEowQNYeGV4AC2DAGV5FvBCIgIIANkPIYEAYblYeAV5iiD/Dwrwz3OAAIAMTYOK
+IP8PCHEB4k2jAdvPcoAATK5kqs9ygACMrOMaHAFyGhgAcxpYALjxANmcuR+GJXgfpkAlABLXBe//
+nB4AEPHAagmP+hpwz3CAAAAAAIBRIICBosEh8s9wgAAAAAGAUSCAgUDYzyDiB8oggQ8AANAAzyDh
+B89ynwC4/x2iz3GAAAAABIEB4NO4BKEFIIAP0P4AABaiFcxVIFIk7bjRIGKACvIHEgE2ANiYEQEA
+Fglv/whyBBAAIIDgC/TPcKAA/CUjgC8giAQwuRBx9PcAEgAgAd1BwAQUADFBKBMDQBAAIFEggIEG
+FBExQfIVzOu4QPJAEAAgz3aAALShUSDAgQbyz3CAAHAPAogI8BQQACAYEAEgCgrP/1EgwIGUHgIQ
+yiRhIAvyHYYA35W4HaaKIAUJrg5v+ulxmneUFoAQz3GAAFSqBLhGkQUgwARQcAryz3KAAIAMAIJK
+JAAgAeAAogSR13AAAP//EPRKJAAgDvDPcIAAyIwrgADfAeEroGIOb/qKIAUMmncCEAAhjCAChUX0
+BBAAIIDgC/TPcKAA/CUDgEAiASEweTC4MHDz9wDeSiQAdAHYyXGoIMAD8CINIAHgUyUCEC+9hiV/
+H0V9O3pYfaV+AeEEEAEggOEL9M9xoAD8JSOBViICIlB6MLlQcfP3AN9KJAB06XGoIAAE8CINIAHg
+UyUCEC+9hiV/H0V9O3pYfaV/AeEX8AIQACGc4DH0BBAAIIDgC/TPcKAA/CUDgEAiASEweTC4EHFz
+9/AiTiMIEg8gz3CgAPQmAtkjoAwQASDPcIAAZKohoKoLL/4KcIHgHfTPcIAAAAAAgFEggIEH8s9x
+nwC4/wDYHaEB2KHwz3CAAAAAAIBRIICBB/IA2c9wnwC4/z2gENiT8EwkAKAj8s9woADELMegz3GA
+AECi6KAoiUArAiMQuZ+5RXlBKQIhRXkmoBXM67gN8hDZq7gUGlwwFRocMM9xgADAjQKBAeACocoN
+T/0VEgE37LkG8gjYrLkVGlwwA/AA2EwkAKBV8s9zgACMrOATAgAUEA0gRCo+BwAjQQ6goRgQDSEB
+4qKxz3WAAECiCBWEEOAbgADPdYAAVKoIGQIBCRnCBAoZRATDoaSV5KFALAMEQCsCI2V6QSkDIaqx
+ZXrPdqAAwC9HHpiQlOXAJYYfAACTAM9yoABoLPAiQgNLsY8WA5YI8KMWApaPFgOWUSIAgQX057v5
+8wTw57vKIyEAQMMBFIIwxrvGulipeanPcYAAAAAggVEhgIEH8s9ynwC4/wDZPaI9Bm/6osDxwO4N
+T/oacM9wgABMrgSIgOAb8s9wgACMrHIQDgZzEA0Gz3GAAIAM4xARB89wgABIBeCAAoE0vwHgAqE1
+8HIOb/qKIA8Iz3GgAMQnEREAhlEggIEA3/XzZBEChmQZ2IMC2BMZGICA4i8ogQBOIIEHEvLPcIAA
+cK02eMCAoYDPcIAA8K30IFEAz3CAABCu8CBPAAvwz3GAAIAMAYHpdel2OncB4AGhBBABIA1wIKAI
+EAEhDXAgsM9xgABwqgCBgOAG8kKBDXBAoADYAKHPcIAAHA8IgOu4yiCCA8ohQgPKIsIDDA4i/Moj
+QgRTIcAgz3GAAEgFIIEUv1EhgIAMuOV4CfKCuA1xAKENcMCgDXCgoB/wDXEAoUokAHTgeKggwAJE
+JoEQD7lTJgAQJXgNcQChIr5KJAB04HioIMACRCWBEA+5UyUAECV4DXEAoSK9AQVP+uB4z3KAAHCt
+z3GgAAQlT6FWIgAEEaFWIgAFEKHgfkokAHQA2agggAIA2s9wgADwrTR4QLAB4ebx4HjxwF4MT/rP
+dYAAAAAghVEhgIEb8iGFUSGAgUDZzyHiB8ohgQ8AANAAzyHhB89ynwC4/z2iJIUB4dO5JKUFIYEP
+0P4AADaiz3aAAFSqRJaU4sAihg8AAJMAz3GgAGgs8CGSAIDgXPIvjs9wgAAwh89yoAAsIM93gAAc
+DzZ4Iog8EhAADo44FxERgOCWACkAyiCpAIwgAaSKACUABNgA2AWiUNhFIUECGNpmDqAAINv4uAjY
+N/QD2M9xoAD0BwWhhNoNcECwQiAAKA1yALJAhg1wQKBClg1wQLBAhw1wQKBClw1wQLAGlkAqAiXD
+uAy4grgFeg1wQKAA2AShDo4B4A6uogmgACpwAIVRIICBBvLPcZ8AuP8A2B2hAdge8ADYz3GgAMQs
+ANpHoUih5pYMv5+/BSeDFGahz3OAAESNOYMB4TmjIIVRIYCBTq4G8s9xnwC4/12hZQNP+vHA4cUA
+3QzwRC0+FydwHNnF2h7bFg1v+hi7AeXPcIAAjKzgEAEAMHWw92EDT/rgeOHF4caA4M9xgACorkWB
+JvLPc6AAyB9AEw4GQCiBAs91gAC0oUAVABHQfthg3JU+Zs9xgAAcD2kRjQCifggmDRACfQkiQgMC
+2BUbGIBfoyKBz3CAAGSqIqDBxuB/wcXgeADZz3CAAGSqIKAhoOB/IqAA2s9wgABkqkGgz3CAALSh
+PJDPcIAAcA8ViAJ5gOHKIYwAz3KgAMgfH4IweRB4CCEBADB5AtgVGhiAP6LgfuB48cDhxQh1iiAU
+DUoIb/qpcYHlz3GnAIhJANgL9M9wgAAcDwiAUSAAgAfYyiChAQ6heQJP+vHA4cVRIADDz3WgAPQH
+LPInhRmFMHk4YAO4liBCBc9xoADIHx6hENgOoQHYFRkYgMYNb/qB2FEgAMMW8s9wgABQBQHZI6AD
+yKQQAQCauaQYQAB2C+/+AdjPcYAA/AwFgQHgBaEZhYDgA/ID2AqlGYWA4ATyA9gKpf0BT/rxwIIJ
+b/qYcEGB5LpwiULyz3aAAPxiB4YIEYUAgOCyiWwSjzAD8qWGJPBJJ8AQ1GvPd4AAKIXGZ/a+CPLP
+doAAMId2fsGOA/AA3sdwgAAwh3Z4BIgIJQ0QCCWNEwAlQBFJIM0DFmu1eM91gAAwiAVlz3CAAEiG
+dnjPc4AAHA99gwGAZXgEIIAPAAAACAZ9A/Cjgei9mBlAAwDbCvKkEQAAANuXu5G4lLikGQAAUSQA
+gCPyG8jPdoAAdIPAuvAmDhDPcIAAgMqELgscMCBADgQggA8AQAAAPrge4Bh6RX3+vZgZQAMM8qQR
+AACFIwEEjLiRuKQZAACcGcAAHvD/vc9ygAAcDxKCEfKkEQ0AhSMBBJa7mLuNvZG9pBlAA5wZwACe
+uBKiCPCUu5a7nBnAAJ64n7gSorUAT/rhxeHGmBAOABsSAjYEJoEfAAAACDt5BCaNHwAAABAlfc9x
+gAB0g/AhggDPcYAABMuEKgsMACFCDum+QCIBBpgQgwAJ8kQjAgxEuk5hib7JchbwUSYAkjqSC/Ic
+4sK7fmLIjnpiUIqlftB+JXoI8MO7fHt+YnpiUIrIjiV6iBiAA6V6jBiAAMHG4H/BxaHB8cCuDw/6
+CHVHwOi9KHDeACEASHYDuEAgkQUnwc9wgAAAcAQlkh8GAAAAQSpCJCtgBCWAH8AAAAA2uKl3emLP
+c4AA5HPGvwhjSmMaYkEtgBJSIAAAwLgDuBjgheLKII0PAQCJDdUgjgAvIAggBCWCHwAAABjPcIAA
+bHHXcgAAAAgeACIA8CDAA6DhEgABAM9xQnvQXgUofgAKIMAOKnEFKT4ACiDADkwiAKAkuAHgBPJT
+IAEAOGDtvQIogSPPcoAAWA9VkhHyz3OAAGhxYJMFKz4AACGAfwAA/z8uuDhgjwAgAFhgFXmHACAA
+WGFRJUCSUAAhACfFt+UiAAsAM2hTJQIQz3CAAHRw8CCAAAUpPgAKIMAOAeAG8IrlwCjhAMAoogDP
+cYAAcA8uicDapHmGIf8OIrk6etp6NwAgAFhgM2hTJcAQHHjPcoAAiHDwIgAAFuEFKT4ACiDADs9y
+gABYDzWSAeAVeQiS2ng4YBB4CNyfBg/64HgEKIAPAAAvukIpwnRQekQq/gICIEAOEHiA4ATyAeJQ
+eoPgQLED9oDgA/QA2ALwgNjgfuB4ocHxwP4ND/qiwUrBOnBIdem5GnMKIgAhL/IC2c9woADIHCmg
+KsFTbe7hUHgE9Itx5/8Z8LfhB/QbeBB4i3Hk/xDwlOED9Bx4CfCK4QT0AByEMAfwz3AAAP//ABwE
+MOB4ANjPcqkApP+5ogAUATGCuDeiGqJO8Oi5MPJMIgCg0SHioUj0z3ClAKz/z3OAAFgPuKBVk2iT
+W2MCIMIgA+IiultiemJIIkIABbpFIkIDVqBBKcIhwLoqwwe6BCGBDwAAACAluWV6RXmJuY65OaDP
+cKAAqCAIgB7wKsCA4MohwQ/KIsEHyiBhAcojgQ8AAFYPyiQhAKwBIfnKJcEABb2leM9xpQCs/xah
+z3CgAKggCIDPcKAA/EQFgADdSiNAIAQgvo8AKAAAz3CgACwgA4DCI8IkBvA/2JYNL/oGuM9woAD8
+RB2ATCMAoAQghA+AAAAABCCODyAAAAAEIIMPEAAAAATyUSBAxgT0ANoD8AHaz3egANAbMYcEIL6P
+ADgAAAQhgQ8AAACAzCIhgMAlYRAFJgIRJXoFIv6ABPSJ5ZgHzv+A4QbygObMIyGAZvLPdaAAtEdr
+FQGW47kJ8s9xgABEjQyBAeAMoULdT/BTIb6ACfLPcYAARI0LgQHgC6FE8Oe5QvSA5gjyz3GAAIAM
+CYEB4AmhOvCA4yTy+rgL8s9xgAD8DAeBAN2RvQHgB6Et8Pm4CfLPcYAA/AwJgULdAeAJoSPwcRUE
+lm8VBZYKIcAP63LPcwAA6Q9tAC/5BdhRIYCBz3GAAIAMBvIdgQHgHaEM8ADYnrhTHRiQANhXHRiQ
+CoEB4AqhAN3d2ADZygkv+pi5mL0e8BGH8LjKICEAjA8h+s8goQPPcKAA/EQ5gAaACyBAgA3yRg2v
+/gHYA9nPcKAA9AcqoAXdmL0C8ADdgOUU9FEhwKEL8kwiAKAO9AHYz3GgAPQHDKED2AXwA9jPcaAA
+9AcFoc9wgAAEBgCAgOAI8s9ygAAwSQWCAnAFos9xgABEjQqBUSGAogHgCqEL8gPIlBAAAAQggA8B
+AADAPg2gBi64z3CAALi0IYDPcIAAHA8UkBBxDfTPcIAATEE6gBuAJHhRIACCrAji/8ogYgCpcAjc
+GwMv+qLA8cDKCi/6ANnPcKAA/ESeuSGgz3CgANAbEYDvuADdC/JyDK/+AdjPcYAA/AwBgQHgAaEK
+yAQgvo8AAAEQAxIONiDypBYAEPK4HPLPcYAAUAUBgYDgFvKhoQXwKgsv+oogRg5RIYDF+/PPcKAA
+xCyrgOTYeggv+qlx/r1TJYEUH/QDEgE2oBEAAPC4AN2i8oogCAAUGhww+thSCC/6oBEBAAMSAjak
+EgMA+LsR8rYSAQHPcKAAmAM+oJvwgOHi85gWABBOCu//ANrc8QAWAUE8sgAWAEEdsgAWAEAPogAW
+AEFAGgQAABYAQBGiABYAQUgaBABEIQADhOAZ8hjechqEAwAWDkCI4NOiABYOQVAahAMAFg5BVBqE
+Awf0KHCGIPMPjCAMgAvyGN4T8BDechqEA89wgACkqKewC/Ae3nIahAMAFgBAFqIAFgBBXBoEAChw
+hiD9DIwgAoIK9ALm0H5yGoQDABYAQWAaBAAE8GAaRAPhvgTyABYAQWh0hCQMkADYCPIAFgBAGqIA
+FgBAG6II2HQSDQG+Eg8Bon8CJ40TAn24EoAAmLukGsAAAn3YYBB4choEALoSAAGwfXAaRAMleByy
+z3CgAJgDHoC2GgQAEfCKIBAAChoYMPvYEg/v+aARAQADyKAQgADE4JQKAfwD2c9woAAUBCOgOQEP
++vHAvggP+qLBGxIBNs93oAC8Lc9wgAAcDy6nahAQAc9wgAB0g/AgQgDPcIAABMuEKgsMACBRDhUS
+DTdAIRImRiXAEQMSAjYVGhwwpBIAAIS4pBoAAAGSQCETIoDgAN6GGoQDCfLPcIAAiJf0IEAAgOAG
+8gGC7rgE9KC9sH1TJX6QXAMBAM9wgADAjQeAz3OAAMCNAeAHowcSAzakG4ADAZKA4Eryz3CAAIiW
+NHiAEAEHgOFC9NAQAQFTIcGAFPRyEgEB4JIif7gSgQAif/B/4BjEA6QSAQCGIfOPBvJov/B/4BjE
+A3ASDwHgEAABIZLiePFwwicOEMIhzgN0EgABGWG4EoAAdBuEA8CzOGAQeJAbBAC+GwQAEIoQqwGC
+AaMIigirEooA2hKrlroz8FoIL/qKIMQLD4f3uPrzT4f2ulMiwAIn8o7gSvfPcYAA/AwEgba6AeAE
+oR3wZLgHEgE2EHiQGQQABCKADwAAAPAsuHQZhAPAsRCpwbEDyL4ZhANhgMiphiP/DYS7YaESiBKp
+9rpMAgEAANiWuPW6BxIBNqQZAAAR8qoNr/8A2AcSATakEQAABCCCDwIAAAAtuqV6UH1G8AGBUSAA
+gVjyz3eAAPxiB4dyiYDgUIlsEoQwA/IFhyPwFGrPd4AAKIUAZ/a4SSTEAAjyz3CAADCHVngBiAPw
+ANgAJI8PgAAwh1Z/5I8II8MDCCMDAEkjwwMWanV4z3OAADCIAGPPc4AASIZWe0GDz3OAABwPfYNl
+egQigg8AAAAIRniYGQAAANiWuPS4QYGGIv8NH/KA4lLymBGCAEAhAClIYM9zgADsqEDAIMLDulx6
+9COCAFbwCiHAD+tyBdjPcwAARQuKJIMP1QLv+EolAACYEQMA6bucGYADI/KA4oC4pBkAACzymBGA
+AM9ygAAcD2ISggCGIP8DRLgyIgAgibhAwCDDZHqGI/8DhiL/DkS7emJPes9zgAAIcfQjggAg8FEj
+AIIK8oDiCvKYEYIAQCEAKUhgDfCA4gX0ANpIcBDwmBGAAMO4HHgyIwAgQMAgws9zgAC8qMO6XHr0
+I4IAiBkAAJgRAACEGYQAkBEBAeINr/8A2gcSAjYDEgM2hBIBAYIaBADPdqAAyB84YBB4sBoEAPgW
+ARCwEw8BIn/PcYAAHA9kEQEBAnc/Zx9noBYOEPB/0XdCAA0Az3aAABwP0oaYEw8ACybAkxf0UIrQ
+i1B20ScikhjymBOPAM9ygAAAcOpigeLQ9s9ygAAohQS+wmLxugjyz3GAAPwMEoEB4BKhDvA4YBB4
+hhsEAM9xgADAjQiBFRpcMwHgCKE5Be/5osDgePHA6gzP+c92oADIH6AWBBD4FgMQhOAl9AMSAjak
+EgAA9Lh2EgEBB/LPcIAARKqhgAPwghINARXMUSAAgYQSAAEI8gIlwhACJIMACCMDAAXwhhIDARtj
+z3eAABwPbPCB4Ef0FRICNwPI5Lp4EAEBIfJRIkCAz3eAABwPZBcCEQnyfhANAUJ9Yn0CJEMDKvCA
+EAMBz3WAALCHACOEAHCIdn1glQAjDQGEEAMBu2Ma8KQQAgD0ugjycIjPcoAAsId2emCSBPCCEAMB
+gBANAc93gAAcD2QXAhFdZbtjhBANAbtjgBANAbpifhANASJ9JfCC4M93gAAcDx30AxINNhXMUSAA
+gXgVARFkFwIRCfKAFQARQnhieAIkAwAH8IIVAxGEFQARW2MbY4AVDREifQXwANtocWh1aHIVzFEg
+QIBpF4QQCPIDyHYQAQECIQEBWWEJ8IDjAiEBAcX2ahcAERlh+BYAED1lAn0fhhB1jPeg2A+mANgf
+pj+mAtgVHhiQgNgOptED7/lweOB4G8jHcIAApJY0iAHhL3mE4TSoAxICNoz2z3ADAIQAoBoAAIog
+CAAKGhgwC/CKIBAAChoYMM9wAgGEAKAaAACKIAQAQQHv+QDZz3GAAESNDYEB4A2hG8jHcIAApJYs
+iAHhL3ksqM9wgABcYwKIEHHJ9oogCAAKGhgwitiQuAzwA9nPcKAAFAQjoIogEAAKGhgwQtiYuOB+
+4HjxwMoK7/kA2c9woAD8RN2ABCa+nwAGAAAG9APIpBAAAPq4bPID3891oADUB/Kl+r4i8gMSAjaS
+EgABUSCAghbyz3CAAJgPIqDPcIAArJg2oM9wgABgyoQYQADdGFgAkhIAAaq4khoEAMD/iiAEAH4I
+7/kA2fm+C/LO/wMSAjYIcaAaAABmCO/5/NjzvgPIEPJvIUMAoBhAAIogCAAKGhgwiiBEAkYI7/kA
+2QPI8r4Q8gDZl7mgGEAAiiAIAAoaGDCKIIQCJgjv+QDZA8ikEAEA+rkK8gXZELmgGEAAiiEIAAoa
+WDDPcZ8AuP9YGQAIEx3Yk6AQAAAD8ChwOQLP+eB48cDOCc/5yg9v/wh2vf/PcaAAyB8IdUDYD6FA
+EQEGMHnyDa/8yXAVAu/5qXDxwAPIpBAAAFEgAIDPcIAAHA8E8h2QA/AckO//gOA39M9woAAUBAPZ
+I6Ag2BQaHDDPcYAARI0RgQHgEaEDyADamBABAIAQAwGUGEAAnhABAYAYhACSGEQAvhABAZAYRACk
+EAEArLmtuaQYQAB+EAEBfhiEADtjsBABAWJ5MHmwGEQAghABAbIYRADRwOB+4HjPcIAA2K4GgAPa
+geAB2MB4DLiFIAMBz3GgAPQHRaENcgCyA8gA212QDXBAsAPIUYANcECgA8hIEAIBDXBAsGSh4H7g
+ePHAygjv+QhzEIkzEY0AAdpAqxsSDzbPdoAAsJbuZs9ygADglkjcwasbEg82AiIOA/QmzhPBsxsS
+DjbwIoIDQaNBgVEiAIEQ8tKJz3KAADCHFnrcq0CKhiJ/DFx6BLpFftyrBPCA2lyrBLgFfb2rHJHP
+coAAKJcPsxvI8CIAAASzC8gFo1QRAAEMswCRDbOgEYIASKMKyAQggA8CAEEA13ACAAAAA/SIukij
+CsgEIL6PAABBEAPyibpIo5wRAAHPc4AAUAUmuMC4QCgCAw+BwLgNuEV4XQDv+Qej4HjxwO4Pj/kI
+dQbwz3AAAMwNlgjP+c92oADAL6MWAJZRIACB9fMLyEAeGJAbyIbgBvTqDO/+qXCG8M93gACAqAqP
+gOAJ8kAngBJAJYESLg3v+QraA8gHiFEgwIAM8gDYigvv+ZC4ANmSuc9woADQGzGgz3CAAHAPAYiB
+4NAOYQnKICEMA8gDkCW4wLgXuMdwAA4AAEUgAQvscCCgAhIBNuxwIKAghexwIKAhhexwIKAihexw
+IKAjhexwIKAkhexwIKAlhexwIKAmhexwIKAnhexwIKAohexwIKAG8M9wAACuDcYPj/mjFgCWUSAA
+gffzC8gEIIAPAQAA8Cy4lODAIIYPAACTAM9xoABoLPAhDQDPcIAAUAXHgNnY9gyv+QUmQRP2Ce/5
+BSZAEyqPgOHKIIIPAAC1BNgMovnPIeIBANgKrxUHj/nxwKoOr/mYcBvIz3aAACiX8CYBEM9zgACI
+lgMSDTYIHEQAGxIBNkGVgOI0e8oiIQAM8oATAAeA4E3yANqAG5wA8BuEAOAbhABAswGF7rgP9Eiz
+0BuEABCNBLjHcIAAKIXlkIDnw/Zhv+WwACGAD4AApJZEqEyoVKjPcIAACJk2eAKQwBuEADV+QKZ4
+GwQAAYUEIIAPAAAAYNdwAAAAIA70z3CAAHSD8CBAAM9xgACgBBR5AJEQ4ACxA9nPcKAAFAQwoIhw
+fv/Z2AIMr/kCEgE2O/BwFQAR4BMBAQIhDgAQdgb3wngCelB6gBucAM9yoADUBw8SDoYA2PAbhANw
+FQ0RwBsEAKJ5MHngG0QA0BMBAQHhMHnwEwUB0BtEAFMlfoDKIcIPyiLCB8ojgg8AAE8NyiSCDwAA
+/gAAAqL4yiBiAQPYExoYgM0Fj/ngeKHB8cBODY/5ocEodRpwWnIEIb6PAQAAwDpzLPTovUDFDfIg
+wc9wgAAAcClgBCWAHwYAAAAxuDhgAvAB2AQlgR8CAAAB13ECAAAByiChAIHgDfKC4Ajyg+AA2Mog
+4QHAKKEDB/AD2A64A/AA2I64BX0KcEoJb/6pcQpwqXFKcipzAd3ODm//mHWA4D30CtjPcaAAyB8e
+oRDYDqEVGViDBvB2Da/5iiDKB1EgAMMN9M9woAD8RB2ABCC+jzAAAAAF9FEjAMDu81EjAMDKIcIP
+yiLCB8ogYgHKI4IPAAClAsokIgAMAaL4yiUiAFEgAMMA2An0z3GAAIAMCYEB4AmhANiYuAjcqwSv
++aHA4HihwfHA4cVRIACCCHWoACEAQsAiw89wgAAAcAQlgh8GAAAAMbprYAQlgB/AAAAANrh6Ys9z
+gADkcwhjSmNBLYMSUiMDAMC7A7saYhjjheLKI40PAQCJDdUjjgBwcVIAJQAA2O29GAAhAAIhwADP
+cRxHx3EFKH4ACiDADgPwIrhBLUETwLkEuTR5qXLGukkiwgVUeeu9z3KAAKByMmIF8kEqAQEUIYIA
+BSo+AEEpAHII3BsEj/kKIcAP63IF2M9zAAB8EUokAAAdAK/4CiUAAeB44cUDEgI2IJJBgkDh9LrA
+IaIAA+HPc6AA1AcPEw2GBCGBDwAA/P+xcBphyPcbyBUiATAcEQAGHWUCIkEDGRMAhhBxPvcPG5iA
+4H/BxfHA4cUDyKQQAQCYEAIAUSEAgHIQAQFIcAbyYgtv/wDaCHUH8AHhVgtv/wDarGhuDMACz3Kg
+AMgf+BIBAAPIz3OAACiFEIgEuABj7bgG9AHYE6J4glmCBvAC2BOieoJbggIlQBB4YBBzwCJtAA1x
+AKENcECgABYAQAAWAEADyM9yoAD0B3AQAQFouSeicBABAWi5MHkZA6/5cBhEAPHAigqP+aQRAACi
+wVEgAIDPcIAAHA8odgPyG5AC8BqQmBYBEAQhvo8BAADAdh4EEC306LlBwQ7yIcLPcIAAAHBKYAQh
+gA8GAAAAMbhYYAPwAdgEIYIPAgAAAddyAgAAAcogoQCB4A7yguAJ8oPgANjKIOEBwCihAwbwA9gO
+uATwANiOuAV5mB5AEJ4WABGUHkAQkh4EEBCOz3WgANQHQMCCFgARsh4EEADYgB4EEH4eBBADyEGQ
+gOKQFhARCfIbyM9xgACIl/QhAACA4BLyGRUAlrjgTvcVzM9xgABEjYYgiAIVGhwwFYEB4MEDIAAV
+oQ8VEZaA4gryG8jPcYAAiJf0IQAAgOAF8kojQCAG8APYEx0YkEojACACEhI2AdnPcIAAIAUgoADY
+kbjPcaAA0BsRoc9wgADQAhB4z3KgALRHSRoYgM9wgAAkBcCgbyBDAFQaGIARgQsSDzbxuMogIQAw
+DaH5zyDhA0wjQKAP9AfIAZCA4CHyz3GAAPwMD4EB4A+hEYEB4BGhF/ADyAGQgOAT8hvIz3GAAFiX
+9CEAAFMgwIAL9M9xgAD8DA+BAeAPoRCBAeAQoQMSATYBge64DfJUEQABUyDAgAf0z3GAAPwMDoEB
+4A6hAhYFEUwlAIAS8gGG7rjKIcIPyiLCB8ogYgHKI4IPAABhBzAFYvjKJGIAAJawcMohzA/KIswH
+yiBsAcojjA8AAGMHEAVs+MokbAAwjlMhwAAQroYh/gOkFgAQRLn2uMAeQhAj9AsSATYCIcIDgeIA
+2AfyAidCEIwiw48C9AHYgOAV9BXMz3GAAESNhiCIAhUaHDAUgQHgFKEPHViUCxrYMzUCIAACGpg0
+CxrYMwIamDQA2HQeBBC6Ca/7yXDPcYAAQHN0FgIRCWFZYc9ygABIc/AiAAAweaQWAhB0HkQQBSCG
+AKQegBEHyAGQgOAV8kwjQKAO9AGWuBaCEDhgYJZYYBB4vh4EEDtjACOFAA7wvhYAEQnwQJa4FoAQ
+OmJYYBB4vh4EELhwkB4EEAwgQKHKIcIPyiLCB8ogYgHKI4IPAACbBxAEYvjKJAIEAMIQFoQQkHIL
+8gohwA/rcgXYiiMeB/UDb/gAFAUwDxUCllEmAIa0HoQQB/K2FgARDx0YkH/wABYDQXy2ABYCQV22
+ABYCQE+mABYCQUAehBAAFgJAUaYAFgJBSB6EEEQjAgOE4hnyGN9yHsQTABYPQIji86YAFg9BUB7E
+EwAWD0FUHsQTB/RocoYi8w+MIgyADfIY3xXwENpyHoQQAN/PcoAApKjnshDfC/Ae33IexBMAFgJA
+VqYAFgJBXB6EEGhyhiL9DIwiAoII9ALn8H9yHsQTABYCQQPwANrhv2AehBAD8gAWAkHIdIQkDJAA
+2gnyABYCQFqmABYCQFumCNoieOJ4AiCBALgWgBACeR9nuhYAETB58H9wHkQQZXgctk8mAAZyHsQT
+pB4AEA8VAJa2HgQQpBYAEAh0hCQakCTyUSBAgh/yA8gBkIDgG/IbyM9xgACIlhR5gBEAB4DgEfTQ
+EQABahaPEAHgw7j4YA94ah4CEB4Lb/vJcGoewhME8BILb/vJcA8dWJQBAY//8cDGDU/5GxIBNs9w
+gAB0g/AgQgDPcIAAYMpAIBAIhCoLDAAgUw61EwImz3CAAAiZQKDPcoAAAAAAglEgQICrwRryAYJR
+IECAQNjPIOIHyiCBDwAA0ADPIOEHz3OfALj/HaMEggHg07gEogUggA/Q/gAAFqMUzFEgAICUBgEA
+z3CgAMgfExAAhvG4yiAhAFgJofnPIOEDz3CgANQHDxAAhgMSDjbPd4AAHA+0HgQQEI5TIMEAhiD+
+A0S4wB4CEDCuChISNgDYpB4AEBKnC8gEIIAPAMAAANdwAMAAALCOF/QbyM9xgACIlhR5EYmA4A/0
+z3CAALCHtngiiAiOEHHH9kpwbgsv/8lx3vBRIgCghfIEFgQQUSQAgUHyG8jPcoAAiJbPc4AA/GIU
+ehEShQBHgzKOgOIPeATyJYMk8FRtz3OAACiFQmP2ukkgwAAH8s9ygAAwh7Z6QYoC8ADax3CAADCH
+tngEiAghAQAIIYEAoHFJIcEDFm01eM9xgAAwiAFhz3CAAEiGtnhBgB2HRXgEIIAPAAAACAZ5AvAj
+hhvIz3KAAHSD8CIAAJgeQBCEKAsMMCBALgQggA8AQAAAQSiCB1MkAAAe4lh4BXn+uZgeQBAJ8gDY
+jLikHgAQUNicHgAQcvD/uQ7yANiNuKQeABDPcEABUACcHgAQANieuBKnZPAA2KQeABAF2BS4nB4A
+EMDYGLgSp1jwUSJAp0nyAYZRIACBOvLPc4AA/GIng1KOgOFsygTyJYMj8EkgwAA0bc9zgAAohSFj
+9rkH8s9xgAAwh7Z5IYkC8ADZx3CAADCHtngEiAgiAgAIIkEASSHBAxZtNXjPcYAAMIgBYc9wgABI
+hrZ4XYcBgEV4BCCADwAAAAgGeQPwI4aYHkAQG8jPcoAAwJYVeiCiANgD8AXYFLicHgAQUSIApQDY
+zyBiBMogIQCkHgAQA8gBgOy4z3CgAMgffhAAhtAg4gDPIOEAz3GgAMgffhkYgADYdB4EEK4Mb/vJ
+cM9xgABAcwphdBYBEVlhMHl0HkQQz3GAAEhz8CEBAKQWABAleJgWARBRIUCCpB4AEAvyO5eAuHYe
+RBB4HkQQpB4AEBHwKIdal1EhwIB2HoQQCfI7l4O4eB5EEKQeABAD8HgehBBSCi//yXCkFgEQRCF+
+gowWgBAV8mIXghAEeoYg/wNEuIYi/w4aYs9wgAAYcfQgkQDPcIAACHH0IJAADfDDuM9ygADMqBx4
+9CIRAM9ygAC8qPQiEADgucogAgQY9JgWABBRIACCiBaAEMO40SEihQjyHHjPcoAA7Kj0IgAACPAc
+eM9ygAC8qPQiAABBhlEiwIDKICEAmBYFEFElAIKEHgQQVPKYFoIQz3CAAABwQC0EEQAkhA+AACiF
+SmAEJYAPBgAAADG4GmIAFAAABCC+jwAoAAA78gTYuB4CEADYj7iXuaQeQBC6HgQQABQAAAQgvo8A
+MAAAJfLPcIAA/GJhgHmmZoBCexa7BSNDAa67r7uwu5gewBAFgAQggA8BAADABXuYHsAQABQAAAQg
+gA8AIAAAKLgFIMUAmB5AEQfwz3AMQKj+GaYD8AHaAxIGNgIWAAGA4CryG8jPc4AAiJf0IwAAgOAC
+9AGWuBaEEHQWBxEEJb6PAQAAwAAkwwEAIwQALyQIASwD4QC+HgQRgeIW8oLizCLigAzyCiHAD+ty
+BdgHAWAAiiMZBgCW4PHPcIAAMIe2eAOIB/DPcIAAMIe2eAKIjBYCEA64RXiMHgAQhBcAEIDgB/TP
+cIAA/AcAiIDgXPIbEgI2huJY8gCWtuCsAAwAz3CAAIiWVHgRiIDgTvSkFgAA7LjRISGASPRRIgCg
+RPKeFgARUCWNA6+9sL1PIIICnh6EEJgeQBOEFwMQp7iKuLS5LyvBAE4jggcjug7iANueHgQQDyOD
+AM9wgABQBaQeQBAFJcIQQqCpcWhwhiH7D4Yg+w8FIT6AmB6AEBHyBCWNHwAAAAgEI4MPAAAACAUl
+/pAH8qi6q7qYHoAQDdgC8ADYmB4CEJgWABCIcUIIL/8A2qQWAhAEIr6PAAAAMIIeBBBS8owWBBCc
+FgERlB4AEZIeRBDsuoAeBBQDEgM2DvIU2ZAeRBB+HkQUeBMNAQIhQSMwebIeRBAR8A7ZkB5EEADZ
+fh5EEHgTDQFKIQAgAiBBIzB5sh5EEM9xgAAImSCBhiF/jw70mBYNEFElQJII9GGTgOMG9JG6krqk
+HoAQELkleqQegBAyhwQkgw8AAAAQUiMDA2V5BCGDDwAAABB9e2V5MqcZ8JgWARCyHgQQlB5AEJ4W
+ARFKIAAgkh5EEL4WAREKIQAkkB5EEADZgB5EEH4eRBAAIQMkhBYBEXhgOGAQeLAeBBDPcZ8AuP9W
+oZwWABAWoQMSATaSEQABSgvv/ZQRAQAb8APYz3KgANQHIBoYgAHYFBoYgAAWAEALGhgwABYAQAIa
+GDADyLQQAAEPGhiA1gwv+cvYGxIDNs9wgACIlhQgwQCokYDlAxICNh30mBINAHV4rqC2oM9wgAB0
+g/AgwwDPcIAAoAT0IMAAvBoEANARAwEEIIAPAADw/8O7ZXjQGQQABfDQEQABvBoEAAHYoBoAAGIN
+oAmwioDgZgIhAAMSAzYKyFEggIFaAgIAIYP6uQjykNiQuEsCIACgGwAAz3CAACiFQCACAwS9rWLA
+E4IAsXIH8pHYkLgrAiAAoBsAAMqDz3WgAMgfpBUCEIwm/58N8sJ613IAgAAAR/eH2JC4AwIgAKAb
+AABQi/Rq5mAEJr6fAAAAE/hgKvLpvgjyi9iQuN8BIACgGwAA7L4I9AWQgOAI9IjYkLgE8IXYkLig
+GwAAz3CAABwPGIiE4Nv0z3GAABxhDIEPIIAADKHPcYAApAcAgQHgAKHN8EKQMxOAABEiAIAm8gvI
+BCCADwDAAADXcADAAAAU9AiLgOAV9qQTAAC0uKQbAACSEwABp7iSGwQAnhMAAae4nhsEAArwUSGA
+gQbyjdiQuKAbAACj8ArIBCC+jwAAARB18kYIgAIDEgM2CHawEwIBqBsAABWFVSJBBtW4MHDPdYAA
+qK5E9wXZJ6UlhQJ55OHKICUACSCAA6wbAACkEwAA8rhX8pgTgQDDuQvIPHkEIIYPAQAA8BsSDTbP
+cIAACJm2eKwTDwAFkAknBBDPcIAAdIPwIEUDgBMAAX4TDwEfZ89wgABYDxeQ+GAIJA8AAn8Db893
+gAAAc/AnTxAiuAUvPhBTIQ9wACdAHi8kAgBALUABNXjHcIAAdKHgkM9xoADELO+hAZBBLgYDFL0O
+oUAuAAaeuKV4BSAAAQqhz3GAAFAFAdgBoQXwoBUOELATAgFQdkX3BdgYuKAbAADPcIAA5AdBgCCT
+CSGBAACIgeAI9M9woAAUBAmAEHEA2AP3AdiA4Av0A9gYuKAbAADPcYAARI0OgQHgDqGgEwAABCC+
+jwEBAAAa9JITAAGUEwEAkBMCAbITAwG2De/+SiRAAAMSAjagEgEAJXigGgAAztjOCS/5AhIBNgMS
+DTagFQAQBCC+jwEBAAAF8s4ID/9jAwABBczPc58AuP8Yo89ygABQBRsSATYAghBxG/LPcKAAOC4F
+gAQggA/AAAAA13DAAAAAC/L12AW4GqM7o2nYGLgZowHYAvAA2IHgA/QgogrIBCC+jwAAARDKJiEQ
+fvKkFQAQ8rg48gGCgOAA3znyANgBooAVABF+FQ8RH2fPcIAAWA8XkB9nBvC+Cy/5iiBGDlEhgMX6
+889woADELMuA5NgOCS/5yXFTJoEU/r7MISKADfKYFQAQHgvv/gDaz3GAAFgPKJEieB9nAvAA3wMS
+ATYA3gnwz3CAAAiZNnjlkADeqXGA589yoADIH6wVABAI9KQVAxCxu6QdwBAE8AkgwAMD2xi7b6L4
+EgMAgOehawggQANieKAaAAAA2Ji4DqIM8qQRAADxuBXMxSCiBM8gYQAVGhwwAZGA4AnyG8jPcoAA
+iJf0IgAAgOAE8gGB7rgG8hXMgLgVGhwwzNhWCC/5ChIBNgMSAjakEgEA+LkI8rYSAQHPcKAAmAM+
+oIbwABYDQXyyABYAQR2yABYAQA+iABYAQUAaBAAAFgBAEaIAFgBBSBoEAEQjAAOE4BryGN1yGkQD
+ABYNQIjgs6IAFg1BUBpEAwAWDUFUGkQDCPRocIYg8w+MIAyADPIY3RTwEN1yGkQDz3CAAKSox7AM
+8B7dchpEAwAWAEAWogAWAEFcGgQAaHCGIP0MjCACggv0AuWwfXIaRAMAFgBBYBoEAAPwYBqEA+G9
+A/IAFgBBKHSEJAyQSiQAAAnyABYAQEokAAIaogAWAEAbonQSAAG+Eg8BAn+if7gSgAACJw8RmLmk
+GkAAAn+4YBB4choEALoSAAHwf3AaxANleByyz3CgAJgDHoC2GgQAfJJEIwADhOBN8hvIz3WAAIiW
+FH3AFQARZXhhgs9xgACkqO27HLIK8lQSAwG8Eg8Bw7vle1QaxABhkoDjJfLQFQMRVBIPAcO75XtU
+GsQAgBUNF4DlA/SKuByypBIAAOi4CfJoEg8BUyPNAP1lsH1oGkQDUSBAggnyahKAAMO7eGAPeGoa
+AgALyAQggA8AwAAA13AAwAAABPTHsQXwANiLuAexHJKGIP0MjCACgg70EIrPcYAAMoUEuBBhgeAG
+9GASAAGEuGAaBAAK2M9xoADIHx6hENgOoQHYFRkYgAXw5ggv+YogygdRIADDDvTPcKAA/EQdgAQg
+vo8wAAAABPRRIwDA7/NRIwDADfIKIcAP63IF2IojSglKJAAAgQTv9wolAAFRIADDANgJ9M9xgACA
+DAmBAeAJoQDYmLiA4AzyA9nPcKAAFAQjoIogEACPB+AAChoYMAPIpBAAAAQgvo8AAAAwu/L0uAn0
+1g7P/tbYvg3v+AoSATYDyKQQAQDsuUTyqg3v+M3Yngov/wHYAxIBNgPbHbHPcIAA2K4GgM9xoAD0
+B4HgAdjAeAy4ZaGFIAINDXMAswPIfZANcGCwA8hvgOC7ANoI8ggTAyANcGCgDBMDIQfwDXBgoAPI
+QBADAQ1wYLADyHGADXBgoAPISBADAQ1wYLBEoXoND/8KEgE22wbgANDYJg3v+NHYAxIBNgGB+LgP
+8s9wgADABwCQHbHPcIAAxAdAgAGAUaESoQfw9gkv/wLYAxIBNh2xxg0P/wPIAg0v/3gQAAGA4JIG
+wgDS2NoM7/gA2QMSAzaYEwAAlBsAAAGD+LgV8s91gACAqKlw0g0v/2hxENgUGhwwFcyjuBUaHDDe
+Dy//qXBTBsAAnhMAAZIbBAC+EwIBkBuEAJITAAGUEwEACglv/4ITAwEIdc/Yegzv+Klx+L0P8gPZ
+z3CgABQEI6CKIBAAChoYMP3YBwbgAKlxAxIONqQWABD0uKACgQBwjs9ygACwh89wgAAAAKCAdnpR
+JYCRIJIa8qGAUSWAkUDdzyXiF8olgR8AANAAzyXhF893nwC4/72npIAB5dO9pKAFJY0f0P4AALan
+FcxRIECADPLPcKAALCAPgIQWDREIIEADongD8ChwsBYNEWTlsXAW989xgABEjRuBAeAboc9wgAAA
+AACAUSCAgQDdBvLPcJ8AuP+9oADYvPDPdYAAKIUEu2NlAN8EI40PgAMAADe9Zb1IJQ0QBCODDxgA
+AAAzuw3jDyfPEAkgQQADEpAABglv/5gWABCYFgMQCSDBA0ErQAPAuFRoVHpocMa4SSDABRR667vP
+cIAAoHJSYAbyQSoAARQgggAourh6A2oEIIAPAAD8/89ygABEqgOiz3KgAMQsDaIwGgAEC8gbEgM2
+BCCADwEAAPBBKA0DQC0AFp24FLtleAV5KqLPcoAAgAweggHgHqLyCu/449iU5cohRQOF96lxgCHC
+Ac9woAAYLPAgQACU5cAlhh8AAJMAz3CgAGgs8CBAAwbwz3AAABURTg3P+FEhgMX5889woADELKuA
+5NiiCu/4qXEEJY8f8AcAAP69NL9TJYEUCPKB58b3AJYQ4BBxBfcDEg42VPEQjs9ygAAohQS4AGL7
+uNUhwgPPdYAARKogpeKlmBYAEH4Mr/4A2gGlz3GAAESNHIEDEg42AN0B4ByhGoH4YBqhAdiA4AoA
+gQDPd6AAyB+UFgYQkhYHEc9wgABEqiAcgDEhgAAQFQDPcqUArP/PcIAAHA8vJUgAYBpABWYQBAFM
+EAABgHACJQMAA+Miu3hjeGBIIEAABbhFIEADFqJRJ8CBgNjKIEEDKMNleAQmgw8AAAAgJbtleIm4
+jrgZokAXABYVzFEgQIAO8qAXABD4FwIQQnkCIFgAdhYBES8gCDYZYQXwhBYYEQNxOh4EFh+HEHHK
+9zB4z3GAABwPRg4v/WkRgQDPcKAA1AcB2TSgM6AD2M9xoADUBw2hEREAhkDAQOAPGRiAFBlYgwPI
+pBAAAFEgAIIE8gINQAEE8EcfWJPPcKAA1AcNEACGQCgCNBB4BXoDyCGAABATAUHBuBCZAHIQAQEC
+IVQGuhABAXmAQsHPcaAA1AeIGcAApBABALe5pBhAALmguBhCA7oYRAMBwPa4CPLPcaAASAhAIwAj
+B/BAIwAhz3GgAEwIAsMjcAUi0gBnaM9yAAD8/2R6z3OAAESqY4MIIsMAz3agANQHFaYAGYAEAiMA
+JQ+mAiOBADumA9kwpgvIAiXVIM9xgABUqgQggA8BAADwLLgDEgM2BLEPg66pAKFAEwABz3aAAASX
+ArEQi0AmBRlgEwMBVGgPqcO7ZXpGsc9wgABEqkGAGxIDNs9xgACIllB4dX5phlYhxAJ4YAmmpBcA
+EFhg+BcCEEJ4Q8DPcqAA1AsB2BCiAcDPcoAARKpigs9yAAD8/zW4wLgCuxe4K+NkesdwAA4AAEV4
+7HIAogISAjbscECgz3CAAESqQoDscECoGxICNhQhgABQiOxwQKjscKCwG8jwJAIA7HBAoBvI8CUC
+AOxwQLDscKCw7HCgoOxwoKALEgI27HBAoAMSAjYAklQSAgEQuEV47HIAogMSAjYBglEgAIEO8hKK
+cIrPcoAAMId2ekCKhiJ/DFx6BLpFeAPwgNjscgCqA8hQiDMQgAAEugV67HBAqAPIXJDscECwAxID
+NpwTAAFRIICBANrPIiIDyiJBAw+DwLgNuEV4z3KAAFAFB6IbyKl2ACCCD4AAsJagqs9ygAAImRZ6
+FHmgsUKSwBlEAxUlAACgoM9wgAAcD3gZhAAckNAZRANEwM9wgABEqiKA+nWA4bwDLgDKJ04TOnUa
+dal3TCEAoLfyAYDPcaAAyB+WIEEPHqEQ2A6hAdgVGRiAE/DPcKAA/EQdgAQgvo8AFgAACPL6uBT0
++bgP9Py4EPRRIwDAD/TPcaAA9Acngf+5ANjp8xfwiiCIABXwiiBIABHwAdnPcIAAUAUjoBYKb/0o
+cM9xgAD8DAWBAeAFoYogCAIFJw+QKgMiAADez3GgANQHD4EQeBkRAoZY4FBw1fcPgRB4GREChljg
+UHDF94QRAACy4Db3D4EQeBkRAoZY4FBwjgANAB4ZGIQdEQCGBxICNgsaGDAdEQCGz3aAACAFScAd
+EQCGALIdEQCGAaJWIAAiHhkYgB0RA4ZAKAA0cHkFIRIAAYIAEhMBANmRuUHAz3CgANAbMaDPcIAA
+SAMQeM9xoAC0R0kZGIBAIAAiAKbPcIAAJAVAoG8gQwBUGRiAhiPzD4wjDIAO8hrYDfDPcYAARI0e
+gYolEBEB4B6hVQIgAADeINiacCNwEHhyGgQAAN5MIQCgBfQDEgE2sPABwPa4CPLPcaAASAhAIwAj
+B/BAIwAhz3GgAEwII3BGwALARcEFIhIgBsAH4M9xgABEqiOBBCCADwAA/P8IIFYADCZApVoALQBH
+wFEgQMMw8s9wgABEqgGAz3GgAMgfliBBDx6hENgOoQHYFRkYgMYK7/hB2FEgQMMc8gHZz3CAAFAF
+I6CCCG/9AdjPcYAA/AwFgQHgBaGKIAgCI/DPcYAARI0dgYolEhAB4B2hxPDPcKAA/EQdgAQgvo8A
+BgAAC/L6uMoggg8AAAECC/T5uIogiAAH9APZz3CgABQEJaAA2AUnD5AA3qX0AdjPcaAA1AcUGRiA
+VSBAJA8ZGIBRIgDC//UGwM9xoADUBxWhBcIA3gIjACUAGoAED6EHwgIllSUCJoAgG6ED2BChA8jp
+cci5CIgMuCV4BRIBNxC5JXjscQChCcBAJ1cgAhoYMAcSATYDyAAcADQDGlgwBxoYMEGBIJEAwDS6
+wLpUeQPhQOAEIYEPAAD8/wAhEAAbEgE2B/AVIkAwHBAABgIgECAVIkAwHBAABhJw9fcFzM9xnwC4
+/xihz3CgAPxEPYAEIb6PAAYAAGz0TCEAoAb0FMxRIACAE/LPcKAA0BsRgPG4yiAhAGQJ4fjPIOED
+ANmRuc9woADQGzGgTCEAoAzyB8hQiFMiwQCGIv4DRLrAGIIAMKjPcKAA1AcUGJiDA8hAIVEgKIgB
+4SioCxIBNs9woABILD2gz3CAAESqIoAycVoEzf8C8Ol1UyV+kF/0USBAw0Pyz3CAAESqAYDPcaAA
+yB+WIEEPHqEQ2A6hAdgVGRiA2gjv+EHYUSBAwy3yAdnPcIAAUAUjoJIOL/0B2M9xgAD8DAWBAeAF
+oYogCAI28EwhAKCKJxAQCPQLyM9yoABILIonCBAdovq5z3GAAMCNBvIAgYC/AeAAob/xAYGBvwHg
+AaG58c9woAD8RB2ABCC+jwAGAAAM8vq4yiCCDwAAAQIM9Pm4iiCIAAj0A9nPcKAAFAQloMlwBX+A
+5xfy4b8M8gPIKYgB4Smoz3GAAMCNAYEB4AGhCvDgvwjyz3GAAMCNAIEB4ACh6XUDyOlxyLkIiAy4
+JXgFEgE3ELkleOxxqXSEJAKRAKFAJ1cgFfLPcaAA1AeAGUAFBcypcsi6ELhFeOxyAKLMoQHYFBkY
+gNoJb/5AJ1cgAxICNpISAAHquAcSATYG9JIRAwFRI4CCNvKquJIaBACSEQABqrgGDyAFkhkEABDZ
+z3CgANAPEBhYgCQQAobPcYAAgKglkVB6ArlFeQwYWIAU2RAYWIDPcYAAgKhnkUaRGNkQu2V6DBiY
+gBAYWIDPcYAAgKhpkUiRELtlegwYmIAG8M9wgACAqMqoz3GgANQL0KGA5XTyz3CAAESqAoDycMj3
+CNrscECgQCdXIPbxC8gEIIAPAQAA8Cy4lODAIIYPAACTAM9yoABoLPAiAgDPcIAAUAUHgOm/RXgN
+oQPaz3GgANQHUqHPcKAA8BdFoAXyXg/v/gDABfATGZiAFBmYg+e/yiCCDwAABgEU9OC/yiCCDwAA
+AwEO9OG/yiCCDwAABAEI9OK/iiBEAcoggQ8AAAcBugiv+Olxz3KgACwgMIIDwDBwAdnKIYYDRCCD
+QA+C5OAB2MoghgOA4cwjIYDMICGA6/PPcAAoCAAKGhgwBMCmDm/7ANn7BQAAz3CAADhOEohRIACA
+F/JRIADDFfLPcIAAOE4viM9wgACstBC5AIifuYDgAdjAeA+4JXjPcaAA/EQNoUwlAKAN8s9woAD0
+B2AYQAXPcYAARI0dgQHgHaELyAQggA8BAADwLLiU4MAghg8AAJMAz3GgAGgs8CEAAM9xgABQBSeB
+JXjPcaAA1AsNoc9woADUB8ygiiAEAt4Pb/jpcfIPr/4EwM9woADUBxkQAIbA4EAFDgAVzFEgQIA4
+BQEAA9jPcaAA1AcgGRiAz3CgANQHAdkUGFiAz3CAACAFwKAA2c9woADIH5G5ExhYgM9wgADQAhB4
+z3KgALRHSRoYgAfIz3GAACQFAKFvIEMAVBoYgM9woADIHxMQAIbPd4AAHA/xuMogIQAoDaH4zyDh
+A89woADUBw8QAIYHEg02A9m0HQQQz3CgANQHExhYgBCNUyDBAIYg/gNEuMAdAhAwrRAVkRCkHYAT
+C8gEIIAPAMAAANdwAMAAANKnGfQbyM9xgACIlhR5EYmA4BH0z3CAALCHFiBABCKICI0Qccn2z3AS
+IAAANg8v/qlxUvABhVEgAIE/8s9zgAD8YieDEo2A4WwSgjAE8iWDJ/BJIsIAQCkBIc9zgAAohSFj
+9rkJ8s9xgAAwhxYhQQQhiQLwANnHcoAAMIcWIkIERIoIIIAACCBAAEkgwANAKYEhFXnPcIAAMIgh
+YM9wgABIhhYgQARdhwGARXgEIIAPAAAACAZ5AvAjhZgdQBAbyM9ygADAlhV6IKIA2JwdgBORuKQd
+ABADyAGAz3GgAMgf7Lh+EQCG0CDiAM8g4QB+GRiAdB2EE5YJr/qpcM9xgABAcwphdBUBEVlhMHl0
+HUQQz3GAAEhz8CEBAKQVABAleKQdABCYFQAQUSBAgg3yG5d2HQQQeB0EEKQVABCAuKQdABAT8AiH
+OpdRIMCAdh1EEAvyG5d4HQQQpBUAEIO4pB0AEAPweB1EEDIPL/6pcKQVARBEIX6CjBWCEBXyYheA
+EER4hiL/A0S6hiD/Dlhgz3KAABhx9CISAM9ygAAIcfQiEAAN8MO6z3CAAMyoXHr0IJIAz3CAALyo
+9CCQAOC5yiACBBj0mBUAEFEgAIKIFYAQw7jRISKFCPIceM9xgADsqPQhAAAI8Bx4z3GAALyo9CEA
+ACGFUSHAgAXyhB0EEAPwhB2EE5gVABDouFbymBWCEM9xgAAAcAQggA8GAAAAMbhJYRlhQCkAIQAg
+hA+AACiFABQAAAQgvo8AKAAAP/KkFQAQl7ikHQAQBNi4HQIQANiPuLodBBAAFAAABCC+jwAwAAAl
+8s9wgAD8YkGAWaVGgCJ6QCqDBZgVAhBleq66r7qwupgdgBAFgAQggA8BAADARXiYHQAQABQCAAQi
+gg8AIAAAKLpFeJgdABAH8M9wDECo/hmlA/AB2QPIAZCA4CbyG8jPcoAAiJf0IgAAgOAC9AGVvh0E
+ELgVgxB0FQIRemJYYBB4vh0EEJgVBRAEJb6PAQAAwA70CiHAD+tyBdiKIxkDbQJv94okgw8AleTx
+geEO8oLhzCHigMgEAv/PcIAAMIcWIEAEI4gI8M9wgAAwhxYgQAQiiIwVABAOuSV4jB0AEJgVABC+
+FQER2g0v/gDagh0EEKQVABAEIL6PAAAAMFTyjBUAEM9ygAAImZQdABCcFQARkh0EEIAdBBSkFQAQ
+7LgDEgE2DPIU2JAdBBB+HYQUeBEDAQIiwCAQeAzwDtiQHQQQfh2EE3gRAwECIMAgEHiyHQQQAIKG
+IH+PpBUCEA70mBUDEFEjQIII9CGRgOEG9JG6krqkHYAQELhFeKQdABCMFQAQBCCADwAAABBSIAED
+EocleAQggQ8AAAAQPXkleBKnFvCYFQAQlB0AEJ4VABGSHQQQvhUAEZAdBBCAHYQTfh2EE4IVABGy
+HQQQgBUAEX4VAREZYYIVABEZYYQVABE4YBB4sB0EEKQVABDPcZ8AuP8WoZwVABAWoQfIz3GgAMgf
+sBAAAaARAQBk4DBwyiCFDxIoCACF989wACgIAAoaGDAVzAQggA8AAAIIguAK9AcSATaKIAQAoggv
+/ZgRAQAbEgE2z3CAAJiWNHjAsAPI6g2gAhqQz3CAAAAAAIBRIICB7gNBAM9wnwC4/92g4wNAAKQW
+ABC0uKQeABCSFgARp7iSHgQQlBYAEJAWAxHPcaUArP9IwLAWAhF4oc9zgABYD7WTaJO7Y2J6A+Ii
+ultiemJIIkIABbpFIkIDVqEowgQggA8AAAAgJbhFeIm4jrgZoc9woACoIAiAA9nPcKAA9AcloBvI
+mBYCEM9xgADAlhV5QKEBloDgE/IbyM9xgACIlhR50BEAAVMgwIAJ8vARAQHPcKAAmAM+oLYeRBCk
+FgAQ6bgE8mIJT/ok8Ah0hCQSkA3y+bhcCGH6yiCBAwPZz3CgABAUJaAU8FEgAIIH8goNwACGDcAA
+DPBwFgIRz3CgAPQHANlHoM9woADIHCegA8ikEAAAUSAAgQn0NgpP/tvYHglv+AoSATYDEgE209gO
+CW/4pBEBAAMSAzYBg/m4B/T2DW/+BNgDEgM2HbPPcIAA2K4GgAHageDAegy6z3WgAPQHGYUA2YDg
+yiHCD8oiwgfKI4IPAAABCrICYv8F2ByTRXgNcgCyA8hdkA1wQLADyE+ADXBAoAPIQBACAQ1wQLAD
+yFGADXBAoAPISBACAQ1wQLADEgI2HJKGIP8MhOAe8lOCDXBAoAPIUBACAQ1wQLADyFQQAgENcECw
+AxICNhyShiDzD4wgDIAK9FaCDXBAoAPIXBACAQ1wQLADEgI2HJKGIP0MjCACghv0YBICAQ1wQLAD
+EgI2pBIAAPe4EfJZgg1wQKADEgI2pBIAALe4pBoAADmiuBpCALoaRACkEgAAUSCAgQfyAYLwuJwO
+gv4O8DqCDXAgoAMSATakEQAAhiDzjwTyO4ENcCCgAdgLpQPYCKXPcKAA/EQdgAQgvo8ABgAAL/Tg
+eOB44HhRIEDDKfIDyM9xoADIH7AQAAGWIEEPHqEQ2A6hAdgVGRiAag1v+EHYUSBAwxXyz3CAAFAF
+AdkjoAPIpBABAJq5pBhAABYL7/wB2M9xgAD8DAWBAeAFoXYOT/4acM9wgAAQBQCIgeAz9M91gAAU
+BSCFbg/gAEAhgA+B4Cf0z3CgACwgMIAAFQUQsHHG97CAAiVNEQjwEIAOJY0P/////x1lvuXKIc0P
+yiLNB8ogbQHKI40PAADmA2wFLffKJE0Dzgxv+E4lgB/aCEAF1NjmDi/4CnEEIL6vBgDKAAryz3GA
+APwMCIEB4H8AYAAIoQPZz3CgABQEJaADEgE2AYFRIMCAJPKkEQAAUSAAgM9wgAAcDwPyvZAC8LyQ
+z3GAADhOEolRIACAFPIPic9xgACstBC4IImfuIDhAdnAeQ+5JXjPcaAA/EQNoQTwdhENARXMUyBA
+gA7y1dheDi/4ChIBNgrIBxIBNpYNr/4bEgI2z3aAAICoyXBWD2/+AxIBNhoOz/1KDU/+gODeBwIA
+AxIBNpIRAAHquAbyqrhaC+AEkhkEAAMSAjYKIYAvgADAln4SAQGCEgABgBIDAThgz3GAAASXG2Mb
+yHB7FXkJgXhgCaEBglEgwIBc8tfY2g0v+ADZZglv/YDYChICNgQigg8CAAEA13ICAAAAFRIBNwn0
+/bgH8k8hwAAVGhwwBfCjuTB4FRpcMAMSAjYhglEhgIEu8ou4jLgVGhwwEIozEoEABLgleM9zgABU
+qs9xoAA4LiSBBrMQ8C8uQRBOJoIXAN4PJo4QxnnPdoAAYJb0Jo4Q0XAJ8oDh8fXPcAAA//8Eswbw
+RLPPcJ8AuP9WoAjYFBocMM9xgABEjRGBAeARoTTwENgUGhwwFcyjuBUaHDBSCK/+yXDY2BINL/gC
+EgE2AxICNgGSgOAK8hvIz3GAAIiX9CEAAIDgDPIBgu64CPQbyAHaACCBD4AAEJdAqRXMUyBAgAry
+BxIBNoogBAAGC+/8mBEBANoMb/6pcAPIGpBWCKACGxIBNhXMUSDAgFAGIQAKEgE2ogwv+NfYz3CA
+AKSoAxINNgKAz3aAABwPmB0AEPCNChIQNgDYpB0AEBKmC8gEIIAPAMAAANdwAMAAABf0G8jPcYAA
+iJYUeRGJgOAP9M9wgACwh/Z4IogIjRBxx/YKcKYM7/2pceHwUSAAoInyAYVRIACBQvIbyM9ygACI
+ls9zgAD8YhR6ERKEAEeDMo2A4g94A/IlgyPwSSDAAFRvz3OAACiFQmP2ugjyz3KAADCH9npBigPw
+ANrHcIAAMIf2eASICCEBAAghgQCAcUkhwQMWbzV4z3GAADCIAWHPcIAASIb2eF2GAYBFeAQggA8A
+AAAIBnkD8COFmB1AEBvIz3KAAHSD8CICAM9wgACAyoQqCwwwIEAOBCCADwBAAABBKIIHAYXAuB7i
+WHgFef65mB1AEArypBUAEIy4pB0AEFDYnB0AEHPw/7kQ8qQVABCNuKQdABDPcEABUACcHQAQANie
+uBKmY/AA2KQdABAF2BS4nB0AEMDYGLgSplfwUSBAp0jyAYVRIACBO/LPc4AA/GIHgzKNgOBsEoIw
+A/IlgyLwSSLCABRvz3OAACiFAGP2uAjyz3CAADCH9ngBiAPwANjHcoAAMIf2ekSKCCGBAAghAABJ
+IMEDFm81eM9xgAAwiAFhz3CAAEiG9nhBgB2GRXgEIIAPAAAACAZ5AvAjhZgdQBAbyBUhACAgoADY
+BPAF2BS4nB0AEFEgAKUA2M8gYgTKICEApB0AEAPIAYDPcaAAwB3suACB0CDiAM8g4QAAoQDYdB0E
+EOoNL/qpcM9xgABAc3QVAhEJYVlhMHl0HUQQz3GAAEhz8CEAAKQVARAleKQdABCYFQAQUSBAgg3y
+G5Z2HQQQeB0EEKQVABCAuKQdABAT8AiGOpZRIMCAdh1EEAvyG5Z4HQQQpBUAEIO4pB0AEAPweB1E
+EIYL7/2pcKQVARBEIX6CjBWCEBXyYhaAEER4hiL/A0S6hiD/Dlhgz3KAABhx9CIRAM9ygAAIcfQi
+EgAO8FMiwADPcoAAzKgcePQiEQDPcoAAvKj0IhIA4LnKIIIEGfSYFQAQUSAAgogVgBDDuNEhIoUJ
+8hx4z3GAAOyo9CEAAAfwHHjPcYAAvKj0IQAAIYVRIcCAyiAhAIQdBBCYFQAQ6LhT8pgVghDPcYAA
+AHAEIIAPBgAAADG4SWEZYRRvx3CAACiFQIAEIr6PACgAAD7ypBUCEJe6pB2AEATauB2CEADaj7q6
+HYQQQIAEIr6PADAAACbyz3KAAPxiYYJ5pWaCInuYFQUQQCuEBQUkQwGuu6+7sLuYHcAQRYIEIoIP
+AQAAwGV6mB2AEACABCCADwAgAAAouAV6mB2AEAjwz3AMQKj+GaUC8AHZAxICNgGSgOAr8hvIz3OA
+AIiX9CMDAIDjAvRhlb4dxBC4FYUQdBUEEQAlAAF4YBB4vh0EEJgVBRAEJb6PAQAAwFwEgf+B4Q/y
+guHMIeKAOAHC/s9wgAAwh/Z4A4gI8GCV3vHPcIAAMIf2eAKIjBUBEA64JXiMHQAQhBYAEIDgCPTP
+cIAA/AcAiIDgU/IbEgE2huFP8gCVtuCWAAwAz3CAAIiWNHgRiIDgQ/SkEgAA7Lg/9KQVABBRIACA
+O/RRIACgN/KeFQARirieHQQQmBUAEK64r7iwuJgdABCEFgEQLylBAE4hggdBKsEADuEPIEAAmB0A
+EKQVABC0uKQdABCeFQARp7ieHQQQmBUAEOi4z3GAAFAFAqEI8uu4CPKouKu4mB0AEA3YA/AA2Jgd
+AhCYFQAQvhUBEZYJ7/0A2oIdBBCkFQAQBCC+jwAAADBU8owVABCUHQAQnBUAEZIdBBCAHYQUpBUA
+EOy4AxICNgzyFNiQHQQQfh1EFHgSAQECIUAgEHgN8A7YkB0EEADYfh0EEHgSAQECIkAgEHiyHQQQ
+z3CAAAiZAICGIH+PpBUBEA70mBUDEFEjQIII9EGSgOIG9JG5krmkHUAQELgleKQdABCMFQAQBCCA
+DwAAABBSIAEDEoYleAQggQ8AAAAQPXkleBKmF/CYFQAQlB0AEJ4VABGSHQQQvhUAEZAdBBAA2IAd
+BBB+HQQQghUAEbIdBBCAFQARfhUCEYIVAREaYoQVABFZYThgEHiwHQQQpBUAEM9xnwC4/xahnBUA
+EBahChIBNtzYVg7P90kAL/irwPHA4cVv2JW4z3WgAMgfEh0YkM9wAQBAPBUdGJAiCQ/9iiAEAA6l
+fQAP+OB48cDyD+/3A9iuwc92oADUBxMeGJAPFhCWGRYAlsDgvvcAFgFAABYPQNO5z3Cw/gAABXnP
+dZ8AuP82pVMnwRQleBal73ic4Mohwg/KIsIHyiBiAcojgg8AAO8LyiTCADAE4vbKJSIAi3AqDC/4
+DtkGFAExABQAMVEhAIHAIKIAA+AEIJIPAAD8/wvAgOBWIhEiEPIapSzAG6UCwB6lz3AAbAQAGaUG
+8M9wAAARDAoID/gZFgCWUnC59wAhACQPHhiQA9ggHhiQ5dhWDe/36XEBwAQggA8AAABAdQfv967A
+4HjxwBYP7/cD2M92oADUBxMeGJAPFhGWABYBQAAWDUDTuc9wsP4AAAV5z3KfALj/NqJTJcEUJXgW
+oq94nODKIcIPyiLCB8ogYgHKI4IPAABFDMokwgBYA+L2yiUiAAAWD0DwfwAWEEBA51EgAKXAJ6IQ
+A+cEJ48fAAD8/wfwz3AAAFkMVg/P9xkWAJZCJwEUEHE29wAhwCMPHhiQA9ggHhiQ2tieDO/3qXEE
+IIAvAAAAQMUGz/fxwGIOz/cIdc9xgAAAAACB7biCJAMxGvIBge24QNjPIOIHyiCBDwAA0ADPIOEH
+z3KfALj/HaIEgQHg07gEoQUggA/Q/gAAFqKLcM9xgADsc2IML/3E2s9woAAUBAHZJKDPcYAARI0T
+geK9AeATodO4BSCAD7D+AADPcZ8AuP8WoRvyG8jPcaAAZC7wIRAAEOBKIQAgDyERIAHfKfCs/892
+gACAqAh3yXD6DC/+i3HSDS/+yXAb8Kb/CHcA2BpwOnAV8I7YUSYAkZC4oBwAMAbyhtiQuKAcADCA
+58wlIZDg9QPZz3CgABQEI6CA56l2r/IA2M9xgAAgBQChANnPcKAAyB+RuRMYWIDPcIAA0AIQeM9x
+oAC0R0kZGICLcM9ygAAkBQCibyBDAFQZGIDPcKAAyB8TEACG8bjKICEAJAkh+M8g4QMkweG+UyHA
+AIYh/gNEucAcQjBkwEQmjRaz9YDnBvKM2JC4oBwAMLjxBLjHcIAAKIVAgEh0hCQMkA3yUSJAgovY
+zyAiBMoggQ8AAIgAzyAhBFfwTIhQccoggg8AAJEAzyAiBE/0AcH6uQfyAd2Q2JC4oBwAMJDxIpAz
+FIAwESEAgC7yC8gEIIEPAMAAANdxAMAAACb0IsGA4UQADACN2ZC5BCCADwEAAPAsuJTgoBxAMMoi
+BQCE9whygCLCBM9xoABoLPAhgQCU4MAghg8AAIcAz3GgABgs8CEAABXwCsGMIf+PWvPPcKAAyB+k
+EAAAInjXcACAAACgBsb/h9iQuKAcADAB3UjxRCb+kgjyz3CgABQECYCA4Ez14b4R8s9woADELBCA
+CyAAhEL1z3AAALAeZgwP+AsgQIQ680UE7/eAJAMx4HjhxeHGocFKJAByANmoIAAPACGCD4AACMuE
+KAsMBOIyIkIOz3OAALyoz3WAABwPQMIgwsO6XHr0I4IATBUDEXpiepViultjA+LPdYAAAHPwJU0Q
+IroFLb4QUyEOcAAmQh5detVoNX7HdoAAdKFAtgPjIrsFLf4QUyEDcAAjQg5dekG2AeGhwMHG4H/B
+xfHA4cWpwYt1qXDPcYAAsHSOCS/9JNqpcHYKL/4DEgE2Sgsv/qlwqQPv96nA8cAmC8/3ocHPcYAA
+4KYkgc91gAAcDzQVEBHPc4AAzKgEIYEPAAAAEEUhQQNAwSDCz3agAMgfw7pcevQjgwCgFgIQAiMD
+BFBzAN8O934WApajun4emJAQeHB7dg0v/hTa+LgE8gDYIvAD2M9xoAD0BwWh5NoNcECwDXDgsEKF
+DXBAoEaVDXBAsECFDXBAoEKVDXBAsOShmgiP/UAWARYweXINL/wKcAHY4QLv96HA4HjxwM9wgAAc
+DxiIheAO9M9wAQCghi4IgACSCwABCHHPcIAA4ETWC4AA0cDgfrED7/YX2OB48cBKCs/3z3aAAPhE
+BYYDgM91gACUnkCAhBUAEM9xLQDAxjhgAnqA4sz2AIWCuPIOb/oApf4Ob/oB2ACForgApYQVARDH
+cS0AwMZ+C6AAyXBlAs/3z3CAAPhEBYADgCCAz3CAABCfIqAdAy/6EdjgeM9wgAD4RAWAA4AggM9w
+gAAQn+B/IqDgeM9xgACUngCBgLjgfwCh4HjtAi/6EdjgePHA4cUmCKAAMNi0aB4IoAA22AV9GL3P
+cIAA1HQ6CKAAkL0ouKV4z3GAAHAF8QHv9wCh4HjxwM9xgAAQRQARBQBMJUCCivcKIcAP63IF2Fbb
+5QWv9ookgw8Foc9wgAA4RfAgQAFAeNHA4H7gePHAPgnP9892gAAQRQWGiuAJ9IoglwlGD6/3atkI
+2ACmQvCF4Mwg4oE+9M9woACsLxqAUiAAAFEgAIA29IogFwwaD6/3ddkQFgUQTCUAhIv3CiHAD+ty
+Bdh323EFr/aKJIMPz3CAAEyZFSBAASCIz3CAAIBDz3KAAGRAAd0hqCiKo6jAuSKo6gyv+gQaQAEC
+hqYMr/oBpgemiiDXB74Or/eB2aCmBQHP9/HAkgjP9892gAAQRSWGguEA3Q30CiHAD+tyBdiKI4QA
+mHMBBa/2SiUAAIPhBPQB2Aama/CE4QT0pqZn8IrhHfTPcIAATJkgiM9wgACAQ89ygABkQKOoIago
+isC5IqhaDK/6oaKKIJcJSg6v94ohBAcI2ACmSfDPcKAALCAQgEeGAN9QcBAALwDKJ28QgeHMISKA
+O/SKIJcNGg6v9+lxBYaI4An0gOcB2cB5z3CAAGRAKKgBhgCmgCCXB/oNr/eKIYQPJoaB4c9wgAB0
+QACAEPSA4MohwQ/KIsEHyiOBDwAARgEF2J7zpqYD2A7wgODKICEBCvKB5wXyBYaB4AP0AdgC8ADY
+h//1B4/34HjxwIoPj/fPdYAAEEUlhYLhyiHBD8oiwQfKIGEByiOBDwAAjQDKJMEA7AOh9solIQCK
+4XYBDQAyJkFwgADgdEAngHI0eAB4AoU6C6/6AaXPcYAAZEAEEQUATCUAhAeli/cKIcAP63IF2Jzb
+rQOv9ookgw/PcIAATJkVIEABQIgoic9wgACAQwHeQajAuSKoHguv+sOoiiDXBw4Nr/eg2cClg/AD
+hYAglwf+DK/3qdkDhT4ML/gApWYL7/kB2M9wgABkQCGAz3CAAEyZNXghiM9wgACAQyGoANkiqAHZ
+zgqv+iOoY/AA3jYL7/kA2CSFz3CAAEyZNXghiM9wgACAQyGoANkiqKYKr/rDqE/wiiCXCZYMr/fF
+2QjYAKUA3gYML/jJcBAVBRBMJQCEi/cKIcAP63IF2NLb4QKv9ookgw/PcIAATJkVIEABIIjPcIAA
+gEPPcoAAZEDDqCGoKIrAuSKoSgqv+gQaQAEf8MYPj/aG4Bv0jg+v9gbYtg+P9pngkAtBAWoPr/YG
+2A/wiiBXDBoMr/fs2RoKj/qKIJcHCgyv9/LZANgApVEGj/fgePHA3g2P9892gAAQRSWGguEA3RT0
+z3CAAHRAABAEAM9wgACMQwQQBQAKIcAP63IF2DkCr/aKI8ULiOEU9M9wgAB0QAAQBADPcIAAjEME
+EAUACiHAD+tyBdgRAq/2iiOFDJoLr/eKINcNJYaK4WQBDQAyJkFwgADsdEAnAHI0eAB4B/DuCe/5
+qXBKCk/4CHWKIJcOaguv96lxgeUe9M9xgADYrgCBirgAoc4KL/gC2IogFwlKC6/3iiFGBQbYAKbP
+cQAAbDvPcIAAuAQOCa/6IKAHpg7wogov+ADYAoaAIJcHGguv94ohxggChgCmEBYFEEwlAISL9woh
+wA/rcgXYiiNGCmkBr/aKJIMPz3CAAEyZFSBAASCIz3CAAIBDz3KAAGRAo6ghqCiKwLkiqNIIr/oE
+GkABTvDPcIAATJkgiM9wgACAQ89ygABkQKOoIagoisC5IqiqCK/6oaKKIJcJngqv94ohBg0I2ACm
+NPAB3QIJ7/mpcM9xgABkQEGBz3CAAEyZKIlVeEGIz3CAAIBDwLkiqEGoagiv+qOoHPCKIFcMWgqv
+94ohBwFaCI/6EvDPcIAAgENaCI/6UgiP+oHgCvSKIFcNNgqv94ohhwWpcKf+eQSP9/HACgyP9892
+gAAQRQWGhOA69ADdjgkv+Klwz3GAANiuAIGquAChiiBXCf4Jr/eKIQcMEBYFEAfYTCUAhACmjPcK
+IcAP63IF2IojxwxJAK/2iiSDD89wgABMmRUgQAEgiM9wgACAQ89ygABkQKOoIagoisC5Iqi2D2/6
+BBpAAYYPT/oHpvEDj/fxwIILj/fPcKAALCAwgM91gAAQRQeFAN4QcQWFyiZvEIDgzCZikB70AoWA
+IJcHcgmv94ohCAMChQClBYWI4An0gOYB2cB5z3CAAGRAKKjPcQAAJDrPcIAAuATmDi/4IKCNA4/3
+4H7gePHAFguv90DasMHPcYAA+HROCe/8i3DPcIAAEEUggIHhz3OAAIBDBPRBixHwz3CAAGRAQYDP
+cIAATJlVeEGIA4tCIACAyiBiABpiz3aAAIxDAY4B3xBywifOE4DhzCGigAr0z3GAAHRAIIEKJUCQ
+yiViEAfwgeEB3cIlQRMC5Ri6ELhFeEAvARIFeYog1wqqCK/3pXkDjgW/BLj4YLV4MCQAMN0Cr/ew
+wM9xgAAcDymBUSFAgOEgwgfKIKIARLjPcYAAXEXDuAlh4LkF8lElgNEc9FEhQIAc8s9wgAAcDziI
+geER8s9wgACwxwCAUSBAgAfyz3CAAFTNFIiH4APyguEG9FElgNEE8gHY4H7gfwDY4cVEIgFTTXKG
+IvwDTXBNcAQlgF8AAAAgQSh+gwjyz3CAALDHAIBRIECABPQA2APwAdiI4RL0z3CAABwPGIiB4AXy
+USVA0QjyBPCGJfbXBPIB2J3wANib8IDh/vXPcYAAtKFUEYMAgOP29c9zgACwx2CDUSNAgBvyz3OA
+AFTNdIuH4xX0YYGMI/+PEfSkkc9zAAD//3B1C/RlgYwj/48H9GyR13MAAP//1POEKAsMACGAf4AA
+YMppgM91gAA4dVEjQIEF8kAlAxcD8EAlAxQYiAtjQSoAAQhlFnvPcIAAVHV8uHhgKBCDAOC7BvIe
+gYYg9o8Y8uG7BvIegVEggIIS8uK7BfJRJQDSA/IB2Avw47sI8s9woAAMJBGAjCD/j/fzANhRI4CB
+yiAiAM9xgACwxyCBUSFAgAjyBCW+3wAAACLKIGIAgOAW8s9zgAC0oT6D6Lkd8owiAoDMIoKPAABQ
+AMwigo8AANAAEfSTuT6jD/DPcYAAHA8pgeG5CPSMIgKABfRRIYCBA/IC2OB/wcXgePHAdgiP989w
+oAAMJBiAQSiEB0EtAFTBuIPgCvczJgBwgADQdUAnAXIUeQB5ANgY8M91gAC0oZQVgBBAKAEGhiD9
+D1IgwAFFuCV4z3GgAIgkEKE+hbO5PqVT8AHYRCg+DQAhgH+AAMiGIYjPdYAAtKGUFYIQz3agAIgk
+UyFFAD6FQCoPBoYi/Q8MJECBUiLCAUW6BfLlelCm3vHPc4AAuHVig5q55XtlelCmPqXPcaAAyBwQ
+2kmhJIDPcqAA8BcmoiOAJqIigCaiIYAmooYVARFouTB5hh1EEFMhwYDAICEIwCAiDCCAM6IsaCCB
+M6L4EAGCM6L8EACAE6IA2Aqi4QdP9+B48cByD2/3ANvPcKAADCRYgM91gAC0oa1wQSqGB4Yg9w+U
+FYEQKbg2e8Bzx3OAAJSbFXsAi89zgADkBGCD02jVftdj22NEJ4WQUyeOEAQijw8AIAAAzCcikAf0
+TCUAgMwnIZAA3wL0Ad+Q4MAACgCA5swnIpBa8kwlQIHL9wohwA/rcgXYoNt9A2/2iiSDD893gAC4
+dfAnhBNAKQUGhiH9D0AuhgNSIcEBBSSEAQUlDwFFuSV/z3GgAMQnQRnYg4LmHfQehRDZmrgepc9w
+oADIHCmgB4PPcaAA8BcGoQaDBqEFgwahBIMGoQDYCqGGFQARaLgQeIYdBBAn8EoVgxCA4yP0TKWG
+FQIRZLqD5lB6hh2EEAn0KxEBhmS6UHqGHYQQLaXmCI/5EfBAKQAGhiH9D1IhwQFFuSV4z3GgAIgk
+EKEehbO4HqWVBk/34HjPcKAAyBwQ2SmgAdjPcaAA8BcKoQMSAzYck4Yg/4wo9A+DUSAAgCTyz3KA
+AMiGBIIGoQOCBqECggahAYIGoXATAAEe4FMgwIAE9EAiAAgE8EAiAAxAgFOhTGhAglOh+BACglOh
+/BAAgBOhCvAIgwahB4MGoQaDBqEFgwah4H7geOHFAxINNs9zoADwFw+Fz3KgAPwXCKNAFQARCrIR
+hQijSBUAEQqyE4UIo1AVABEKshyVhiDzD4wgDIAH9BaFCKNcFQARCrJwFQERHJUI4QiyHZUIslQV
+ABEIsmAVABEIshmFB6MahQejG4UHo3IVABE4YBB4CLLPcKAA9AcnoALZz3CgAMgcJ6Dgf8HF8cCK
+IFcHNgtv90zZAdgA2W4M4AWKIgQA0cDgfvHA+gxP9893gAAsQQGHSiAAIBDeCnUCpwDZAYcPIUED
+CyBAgA3yR4fPcIAAbEVEefAgQAMFIFAggODiIAIAYb6A5gHlr30q90IgAKARBW/3yiBiAPHArgxv
+9whxAN4PJg4Qz3CAAGRAoIC2Cm/3iiAXD89zgAAsQQGDBCCBAzB2yiHCD8oiwgfKIGIByiOCDwAA
+lADKJMIA9ABi9solIgDSecODQoMEIECAJH7DowGjJHrFg0KjxHklo8wlopAP8v4ID/gPes9wgAC4
+BGCAz3EBAAw7YHsD2A3wgOAF8oDizCWhkAf0z3CAALwEIIBgeQPYfQRP9+B48cDhxQh1ANsPIwMA
+z3KAACxBA4IhgmV4A6IFgmV5IaJleAWiAgpv94ogVw/PcIAAuARggM9xAQAMOwPYYHupclEgwIAH
+9M9wgABkQE4Ir/kAgC0ET/fgeAoiQIAA2e4AAQAvJgDwSiZAAE4ABgBPACAAiiX/D+B4CiJAgADZ
+zgABAGwAJAAvJgDwXAAFACsINQhKJkAACHEA2AIhvoDgIMUHQnkB4AIhvoDgIMUHQnnrB+//AeAv
+LQEAQCVFAAImfPEAACAAAChAAeggYgMvIACALyFLAAIhvoDAIIYBwiGGAOB+EQAgAEogABBKIEAQ
+DiJCAC8gCxLOIEWAiiX/DwgABQAvLQEAQCVFAAImfPEAACAAAChAAUomQADoICIDLyAAgC8hSwAC
+Ib6AwCCGAcIhhgBKJgAAQiD+kM4gggFEIH6QziGCAeB+rQEAAOB4RoGA4gjyI4FggSKCYnkwcADY
+A/YB2OB+8cDPcYAArEWYcPj/gOAJ8s9xgADMRYhw9P+A4AP0ANgJ8M9xgADsRYhw8P+A4PnzAdjR
+wOB+4HgIczhg1bvVuTBzNrjE9wIjQgAK8M9ygACorkWCAeDJuCJ6emIWuOB/RXjgePHAPgpP9wh1
+13UlAACAANhK989xgACoriWBMHXQ9yJ9AeD58c9wgACorsWAqXBiDu//yXEFLj4QAiVNHowgEIDK
+IcYPyiLGB8ogZgHKIyYNyiQmAHQGJvbKJQYBFrhNAm/3pXgB2s9zoACwH1mjfoOA4AXyIntwcIP3
+ANgC8Ehw4H7geM9yoAAsIHCCgOAK8gIjQgDXcgCAAAAG91BwhvcA2AXwcHB+9wHY4H4IcgPwAeAg
+iIDh/vXgf0J48cCw4OHFCHWD9rnlyvYKIcAP63IF2CLbmHX1BS/2uHNCJQAc0QFv9w944HjxwFIJ
+b/fYcADd7//JaIDmlPb4cKl3MiaAA7DgiPa54Ab27f8ybzh4BX0B50InRwBMJwCAYb4x94EBb/ep
+cOB4CiYA8Iogvw/KIGQA4H8vIAMA4H+KIP8P8cD+CE/3kgogAAh1gODPcaAAyB9FhQ3y9BEOAAKA
+ZIXEekV79BnAACKFAKEK8PQRAABEePQZAAAc2Bi4FRkYgCkBT/cP2Zq5z3CgALAfNaDgfuB48cCq
+CE/3CHXPdqAAyB+kFgAQuGCkHgAQAdgTpliGOYYA2AAiQoMBIQEAWKY5pgLZM6Y6hluGACFBgwEg
+gAA6phumFYaiDaAAqXEVpheGmg2gAKlxF6YP2Jq4DqbPcIAA7EXT/89wgACsRdH/z3CAAMxFz/+h
+AE/3z3GgAMgf9BEAAADaRiDAD/QZAAAPyJq4m7icuA8aGDAc2Bi4FRkYgFihWaFaoVuhz3AADA8A
+pBmAAA6hD9gMuBCh4H7xwO4PD/fPdaAA0BvThfq+BvLPcIAArEV6CQAA+74H8s9wgADMRW4JAAD8
+vgbyz3CAAOxFXgkAABzYGLgTpR0AT/fgePHA4cUlgECAQiICgMoiYgCA4sohwg/KIsIHyiBiAcoj
+gg8AAG8AyiQiAAwEIvbKJQIBYIEwcwryQoCig0J9gOUE9mCDMHP69UGDAaNgoEGgAKJEgKWAUSJA
+gEAlAxYL8kaFgOIG8qKCQoBCfYDlw/YAo0SApYBRIsCAQCUDFwvyR4WA4gbyooJCgEJ9gOXD9gCj
+QYBQcQX0Fg7v/wWAgQcP9+B4QIAQcgjyZIILI0CABfRAghBy+/UA2uB/SHDgePHA5g4P9wh2AIBC
+IAGAyiFiAIDhANgm8iWGQYYB3zByIIZBhkGhIKIAps9wrd4CAAGmpYbAfwaFEHYG9KlwAtnp/wal
+pYYHhRB2BvSpcAjZ5f8HpYDnBfKWDe//BYYB2O0GD/fxwIIOD/cIdSh25f8Id8KlqXCz/9UGL/fp
+cOB4IIAQccohIQDgfyhw8cBaDg/3CHce8ACGIYYhoAChANgAps9wrd4CAAGmpYYGhRB2BfSpcALZ
+zP8GpaWGB4UQdgX0qXAI2cj/B6UjhmB5yXDpcOz/CiYAkAjyA4cggAKGIniA4LIHzP8GDe//6XBh
+Bg/34HjxwOHFCHUD8MH/qXDg/4Dg/PVZBg/34HjgfuB4gOHKJE1w4HjoIC0Cz3GgAFAMJYEBGFIA
+4H7gePHAug0v97hwmHHPc4AAdAUBgyKDz3aAALShz3WAANR1Ankehjm4wbgUfQEVhxDPcKAA1As8
+EAYAsHHPdaAA0A8A2kT3ANhG8KgWABDPcaAAyB9k4B6hENgOoQHYFRkYgBlzBvDPdaAA0A8JcxcV
+AJYigwIgwAECeUghAQABgwJ5SCEBAEwkQIAT9FBx0ffPc4AAGEYCiyUVD5bBuNNoAeACqwOD2H/n
+eAOjAeLv8VEjAMAS9LBxz3OgANQLqAfF/wQQARAB2KBxBBhAEDwbgAFRBQ/3rg8P+rbx4HjxwN4M
+D/fPcIAAQKIIiIwgAoAq8jRox3GAACiFwIHPcoAASIbPd4AAeK72lxZ6YYJQJo0Vhie7H6ChjCdE
+kIYjAQ5hogT0kb2goQzwsb6B57a+wKEG9Ja+wKGFIwEOYaIqCg/4ANnPcIAAeK7ZBC/3LxhCAOHF
+4cbPcIAAQKIIiIwgAoDPcoAAlK4X8tKKz3GAAEiGtGjHdYAAKIUWeYDmAIVhgQXylbgApau7BPC1
+uACli7thoQDYE6rBxuB/wcXxwB4MD/fPcIAAQKIIiIwgAoAv8s91gAB4riqFz3KAAEiG1GjHdoAA
+KIVghkQhBIMWeuGCE/JQI4EFIKZMJACBhicBHuGiBfSRuSCmBPCxu7a7YKZ2CQ/4BvCWu2CmhScB
+HuGiLxWAEKK4Lx0CEBkED/fgePHArgsP9892gABAogiOjCACgDLyz3CAAGDKSIDPdYAAeK4phbe6
+uLoEIYEPAwAAAAe5RXkooBoNb/gA2AmFSI7PcYAASIZRIICCFGrHcIAAKIVggFZ5QYEF8pW7YKCr
+ugTwtbtgoIu6LxWAEEGho7gvHQIQpQMP9/HAFgsP96HBCHVAwc92gAC0oQCWSiZAIIYg/ACMIAKA
+wiaCJQLYynFU/4DgDvQehrO4HqYA2M9xgACUrhOpz3GAAFyuDLFp8EIlkhBMdIQkA5D+8+B4z3Wg
+ANAPJRUOliUVD5ZKJEAgEBUVlgJvDCIAoMIkDiUvIwAlpgigAMlwTCYAoBpwFCcRFRHyheYH8ovm
+ANjKIGEAAvAC2M9xgAAYRiSBCyEAgAPyANkC8AHZKnAy/4DgFPJMIIChI/LPcIAAREYWIAAEQIAG
+iBB2D/SA4g3y6XBgegDBFvDPcYAAtKEegbO4HqGm8QohwA/rcgXYiiPXDEokAADJBu/1CiUAAQHY
+oncQHdiTAiJSJIDgzCMioJz1TQIv96HA4cXPcIAAGEYgiAHbgOFhqCDyz3KgALAfeaJ+gkKAo4BQ
+dQDZGPTPcoAAdAVYioDiA/QB2grwQYACI40A13VMAEBLefchqChygeID9GGgIqjgf8HFoqDv8fHA
+tgkP9xpwOnGKIEcN0g/v9oohlgfPdoAAtKFMIACkz3WAAHiuAN+G9wzY6XH2/oDgDPQehi8dwhOz
+uB6mz3CAAFyu7LAg8KlwDNnn/s9ygAAYRgCKgOD82QvyAJYkeIwgAoAF9CWVBJUneAOiQiAAIypx
+hv8AloYg/ACMIAKAKA/B/5EBD/fxwDoJD/ehwQh2iiBED0oP7/bJcYLmANkQ989ygAC0oR6Cs7ge
+os9wgACUrjOoz3CAAFyuLLCR8ALY0f6A4I3yz3GgAFAMBYHPdYAAeK4SrQWBE60JlYwgiIBivk3y
+E/aH4B/yjCDEgXL0guYw9MlwANnD/oDgLPJAJQAbyXG5/iDwjCDIgFPyjCAQgGD0BYEJboXgcA3h
+/8ohIQBY8IHmVvTJcADZtv6A4FLyQCWAG8lxrP4vFYAQgbgvHQIQSPAvFYAQgLgvHQIQQvCB5kD0
+yXAA2ar+gOA68otwyXGh/iDAUyABAIYgfw8sHUIQHHgtHQIQ5vGO5ir0z3CAABwPGIiB4CTyyXAA
+2Z3+gOAg8s9ygABcrkhwBtmS/kAiAAIG2ZD+DJKBuBHwhOYQ9MlwANmT/oDgDPLPcoAAXK5AIgAF
+BNmH/gySgLgMsoogRA8GDu/2KZVRAC/3ocDxwNYPz/YIdRpxz3CAAHiuEgkv9yTZz3CAALShHoDP
+coAA7Kc5uFMgQQDPcIAA1HU0eEGKIIgA21V5z3KgANQLL6LPcoAAdAUhiGGiAiVAEIDgyiDMAAKi
+TXGGIfwD0OHMIYKPAACAAA/yjCEDhBDyCiHAD+tyBdiKI1oHSiQAAOkD7/W4cwpxZf8D8Ib/rQfP
+9uB48cA6D8/2z3KAALShPoIacO65qsEA2BDyz3GAABwPYhGBAEQSgwDA3WR5hiH/DiK5On0I8M9w
+gAAcD0wQDQEC2IYSAQECeRGCBOFCD6/8ANpaCGAAAiBPAwPYz3agAMgfE6YYhgDZQsAZhkPAGoZE
+wBuGRcC1hlwWERBAFgAWH2f8FgAQz3CAAHiuQIABgAAiwoMBIEAAQMJMIECgQcCLcAv0hMFOC2AA
+hsIId89wgADcyCqQCvCCwToLYACGwgh3z3CAAKiuJJDPcoAAqK5lggbCBLtQc0ApgAKI91BwS/cC
+elBwvvcG8P4LYACGwAhyRsKC5xX0qXCOC2AASHEIdSpwhgtgAAbBBsM6cATCB8EFwAAiwoABIEAA
+RMIW8IDnFfSpcI4LYABIcQh1KnCGC2AABsEEwTpwBsMFwAfCAiHBgETBAyCAAEXAgecK8s9wgAAc
+DxiIhODMJyGQANgD9AHYLyIHoDv0qXAeC2AAA9kIdSpwEgtgAAPZAMEIdwHAQCHBgEEgAABBwATA
+QMEFwUAgwIBBIQEARMASDyAARcFMIACgBvS1pgDAGKYBwBmmTCCAoAv0taYAwBimAcAZpvemBMAa
+pgXAG6ZMIECgB/T3pgDAGqYBwBumiiAHDooL7/ZKcUwiAKAB2cB5z3CAABxhNKihBe/2qsDgeM9x
+gAAMRiCBANiD4cwhIoAC9AHY4H8PeAoiAIDxwBTy+P+A4MohwQ/KIsEHyiBhAcojgQ8AAMMGyiQh
+AJwB4fXKJQEBz3CAAAxGQKDRwOB+8cDPcoAADEYggoDhyiHBD8oiwQfKIGEByiOBDwAAzAbKJCEA
+ZAHh9colAQEBogHaz3GgAMgfUKFKGZgASBkYAN7x4HjxwLYMz/bPcaQAtEUpEQCGz3aAAMiMEaYr
+EQCGAN0Sps9wpQAIDAOAGKYOEQCGEHowuFOmFKYPEQCGFabPcIAA8KFQiHKIWaY0iHqmC5A7pizg
+AiCPAAIgwgAieM9zgAAMRiCDXaaD4fymOAAtAB6mMyZBcIAA3HVAJwByNHgAeAPYwf9A2M7/t6YM
+8M9yoACoIDGCAoOiozhgF6YB2BKiAdh9BO/2FqbPcIAAdAUYiIDgB/LPcIAAGEYBiALwAdjgfuB4
+8cD2C8/2z3WAAGDKxRUAFlEgQIEH8s9wgABUzRSIiOAF8gmFUSBAgYvyz3GAALShA4EiDS/8JIGB
+4BH0z3GAALDHIIFRIUCACfLPcYAAVM00iYjhyiBhABLygOAR9M9wgACwxwCAUSBAgAnyz3CAAFTN
+FIiH4ALYAvIA2Az/0g6AAs9xgACorgaBRSBAAQahz3CAABwPGIiE4M92gAB4riPyz3CAALSXVoh3
+jlBzz3GAAMiMBfIAgFEgAIAN9M9ygAB0BQWCAeAFogDYBKIPgQHgD6EE8A6BAeAOoQmFUSBAgSAM
+wgDPcYAAdAUDgYDgC/IA2AOhz3GAALQGAIGiuCII4AIAoS8WgBBRIMCAPA+C/y8WgBBRIICAvA6C
+/4j/sf+A4DAM4vXKIOIFz3CAADhOEYiA4CAM4vXKICIFJQPP9uB48cDPcIAAXK4MkOC4BPIGDQ/8
+BvBRIECAlAwC/M9wgACUrhOIgeAH8oLgCPSG/YUFz/9o/X0Fz/95Bc//8cB2Cs/2z3CgAMQnUhAB
+hkEQAIaGIOOPAN0G8uu50SGigUzyz3CAABwPCYDPdoAAeK5RIECBGPKmCUAHgOAK9BSOgeDKICEB
+qA6hAsohYQDPcIAAZKoAgFEggIAE8jYPb/wQlrSuz3CAAGSqoKBNcIYg/AOMIAKAHPTPcYAAdAUH
+gQHgB6HPcIAAHA8YiITg8ArBBYogRw36D6/2iiELBc4IQAd3/yoJ4AUvIIgKBvCMIAOEEA/B/ykC
+z/bPcYAAdAUJgYHgB/TPcKAAsB8bgAuh4H42uDa5MHDWIIUPAACAAOB/InjgePHAz3KAAHQFCYKB
+4A70z3CgALAfG4AMoiuC9f9GEgEBOGAQeEYaBABlBM//8cDhxc91gAB0BQ+FgOAQ9AmFgeAM9PIK
+z/WZ4Ajyz3CgALAfG4ANpQHYD6WpAc/28cDhxc91gAB0BQ+FgOAY8gmFgeAU9MIKz/WZ4BDyz3Cg
+ALAfG4AA2g6lLYXZ/0QVARFPpThgEHhEHQQQaQHP9gDZz3CAAHQFK6AsoC2gLqAvoCWgMKAkoEYY
+RABEGEQA4H8qoPHAANnPcIAAdAUpoPT/z3CAACxG0gmP/7UDz/8Icc9wgAAsRkWAQ4JhuWCCz3KA
+AHQFSILVunpiz3OAAKiuZYMFK34AACGBcMdxAAAAEP0Bj//gePHAz3GAAHQFCYGA4BX0AdgJoQDY
+CKHd/4oghw56Dq/2iiHPC89wgAAcDxiIg+CcD+H/yiBhAUUDz//gePHAPgjv9oogxw+kwU4Or/aK
+IdIFbg8ABYDg9A7C/891gAB0BQiFKoWd/0QVARFGFQIRWWEwcADew/cCIE4AJYWA4RT0gOYS8gCF
+gOAO9ASFz3GAAMiM2GAEpRCF2GAQpRCB2GAQoQnwMHbH9wImQBAwhThgEKWKIAgA4g2v9iSFBIVC
+xkDAEIUQ2UHABYWi2h7bQ8CLcL4J7/YYuwiFCqUA2AWlRh0EEEQdBBAApQYJ7/US2ASFheCM9wHY
+tP+2CY/5z3GAAMCNGIEB4BihBPAF2K//1Qev9qTA4HiA4AHYwiAMAM9ygAAYRgCqAdgBqgDYAqoB
+ogKiA6LgfySi4HgAFgBAhQPP9s9wgAAMRuB/AIDgePHAigjv9RLYz3CgALAfO4DPcIAAdAUVAu//
+KKDPcaAAsB87gUEoggXVuEEpgwXVuQJ5z3CAAKiuYnoFgMm6BSi+ACdxz3CAAKxFA4AAgOB/OGDg
+eM9xoACwHzuBQSiDBdW4QSmCBdW5EHFbY0n3z3KAAKiuRYJZYQJ5AeMC8AJ5QCuABSV4zPEA2Za5
+z3CgANAbM6DgeFEjgMX/8+B+4HjxwIIOr/YB2gh2iiAIAM91oADIHxClQR2YEPT/z3eAAKiuY4cF
+h1MjQQUQccohzQ/KIs0HyiBtAcojjQ8AAJ0AyiQtANACrfXKJQ0BgObMJmKQPfQgh892gACwxzil
+IYc5pRSldaUAhlEgQIBd8s9wgABUzRSIh+BX9DeF94UVhQQhkA/A/wAA1b9qCyAAqhYBFtW4BSAB
+BAIgw4M3pQLZM6VahTuFyiDDABQAIwBfu6AWAxcKu+J7eGAA2wIiAoADIcEAWqU7pS/wguYt9M9x
+gACwx6ARAAcKuBalz3CAAGDKCYBRIECBGPLPcIAAVM0UiIfgEvRTpViFGYUA26oRAQYCIkKAAyDA
+AFqlG6UVheIKAAAXpQnwThEABhqlTxEABhuld6XBBY/24HjxwF4Nj/YKJgCQz3WAAKiuEfTPcIAA
+4HWpcc4K7/YU2s9wgACsRUYPT//PcIAAzEUV8ILmDPTPcIAA6MipcaoK7/YU2s9wgADMRQ7wqXCi
+Ce/2BdnPcIAArEUSD0//z3CAAOxFBg9P/wSVCrgFpQaFhiDDDwalyXCX/8oPT/VNBY/24HjPcIAA
+rEUngIDhB/IDgECAAoFCeATwz3D/D///4H7geM9xgACsRUaBgOKKIf8PIKAF8iKCIKAB2ALwAtjg
+fuB48cChwQhzi3D2/4LgANgH8gDAEHMB2MIgDgChwNHA4H7g2JC4ANrPcaAAyB8QoQnYsBkAALQZ
+AAAV2G8ZGABq2EIZGAAA2Jq4D6GkGYAAz3AADAAZDqHgfuHFUyBCBQQgjQ/A/wAAz3CAAKiuBYAC
+IIMABCGCD8D/AADVuSJ4pXtFeBBzyiCtAAX3EHMA2MogZgDgf8HF4HjxwOHF2HC4cZhy7v8Idchw
+iHHs/xB1yiCtAAr3EHUA2MogRgGcD+b/yiEGAUkEj/YIcyhyz3CgALAfG4ACIIAPAAIAAGhx3vGK
+If8PIKDPc4AArEVGg4DiEvIkglEhQIAL8s9xgAB8RzByB/LPcYAAlEcwcgb0QIJQc/H1AtgF8CKC
+IKAB2OB+z3GAAOxFRoGA4ooh/w8goAXyIoIgoAHYAvAC2OB+4HjxwFYLr/ZKJEAAwIGggAHf0XXC
+JAIB0XWhgWGAwifOEwHesXPAfrFzAdvCI84ATCQAgMwmIpDKI2IAC/SA4wb0gObMJyKQBPIC2wPw
+ANuA4xTygeMO8oLjGvSggMCBAYAhgQIljZOgogMgQAABohDwANgAogGiDPCggcCAIYEBgAIljZOg
+ogMhAQAhojEDr/ZocOB4BfBCecdwQAAAAM9ygACorkWCUHE391MgQwVwccAgjQ9AAAAAwCCNAOB/
+IngG8GJ5AiCAD0AAAADPcoAAqK5lgnBxN/dTIEIFOmJQc4P3OGAH8AIggA9AAAAAYng4YOB+8cBm
+Co/2CHUodq4OL/8BgKCFELlBLQAUOGCeDi//yXEQubB4OGCSDi//QC6BEqUCr/YocNW41bkwcMf3
+z3KAAKiuRYJZYeB/DiBAAL3gFfKF4BHyB/aD4AvyhOAR9OB/BNil4AvyreAL9OB/AtjgfwDY4H8B
+2OB/A9jgfwXYBtjgfuB48cCB4OHFANgJ9M9wgACPrgHd+gtv/6lxqXA9Ao/24HjxwLoJj/YId89w
+gAAcDxiIhOAacUjyhOcA3Y4AJQDKIEUDz3aAAHiuQCYAE74Lb/8E2S6OsK5TIQAAEa5BKMAgoLkw
+cGAAJQACIEIAY7/xclQABgCA4g/yz3GgANAPEBEAhmG6WGAQGRiAJREAhg94AvAPjgDZUyCCIA8h
+gQAkeC8mB/DPcZ8AuP8QrhiBzyDiB9Ag4QcYoRiBnrgYoRiBvrgYoQHYeQGP9uB4g+DxwADYCfTP
+cIAAjK4yC2//A9kB2NHA4H7geIbg8cAA2A/0z3CAAJSuFgtv/wbZz3GAAGSqAIGCuAChAdjt8fHA
+muDhxQDYjPfPdYAAnK4Ebe4Kb/8E2QuNgrgLrQHYKQGP9vHAluDhxQDYjPfPdYAAnK6pcMoKb/8E
+2QuNg7gLrQHYBQGP9vHAjgiv9gnZz3aAANxGEg2v9slwAJbPdYAA2K5RIACACPIB2EwdAhDGCa/1
+GdgJ8EwVgBCB4AX0AthMHQIQAJYihiK4wLhNHQIQz3CAANxHIKDPcaAALCBQgXKFAiLAAP+4A/RS
+pRCBA6XPcIAAxEYAgEIgAIDKIGIAgOAI9M9wgAB0RgCAgOAsCAIACIaA4AX0z3CAAKiuCJAVpQCW
+JbjAuI4I7/8D2TIMj/ZNAI/24H7geM9xgAB0Rs9wgAD0dQkFr/YU2uB48cDhxc91gADERtYIb/+p
+cM9wgAB0RiCA4bke8hQQBAAYEAUAUSEAgMwkIoDMJSKACPQKIcAP63IF2BkEb/XE20oNL/8AJQAB
+qgjP/whx9ghv/6lw5QdP9vHA4cXPdYAAdEapcPILr/YH2QgVBBAA2EYk/oPKIcIPyiLCB8ogYgHK
+I4IPAAB3AMgDYvXKJSIAQIXhuhPy4LoH8iWFgOEF8iaFgOEL9AohwA/rcgXYf9tKJAAAnQNv9bhz
+z3EBAKCAMqVRIgCBE6UjhQ7yDqUBhY/gL6UL8s9wAgDUERKlAdgTpQXwLqX/2A+lxv8mC4/2SQdP
+9s9xgAB0RgCBIoF/289ygADYrlMgAIAmewT0LoKA4RX0gOAG8g6CCyDAgA/0MIKA4QT0BYKC4Afy
+gOEH8hGCguAD9AHYAvAA2OB+4HjhxeHGz3CAAHRGQIACgD/bBnsMcM92gAB0RqKGz3GAANiuCyBA
+gwHYLoHCIAEACyFAg8C6BvIphlEhAIHPIGEACyDAwAn0z3GAANiuLoELIcCAANkC8gTZgOIG9ITh
+CPKA4Ab0gOIF8oThA/QE2MHG4H/BxfHADg5v9gDZz3KAANiuBIKA4Aj0z3CAAHRGB4CA4APyAdnP
+dYAAdEbPd4AAHA8Yj8CFhOBTJgMQBfIJh1EgQIED9ADeOPAHhYDgBPQA2BGlgOPMISKADPIJhVEg
+AIEI8lEmAJEJ8gGFj+AF9ADYCHYU8ADYEfARhQHghOARpQjeRfcBhY/gANgI8s92oAAsINCGAdjD
+ogjesIWA5Qv0gOMD9IDhB/SA4AX0TBKAAILgAvQE3sEFb/bJcOB48cBKDU/2pME6cBpxSHee/4Dg
+UPLPdoAA2K4AhoDgSvTPcIAAwAUAgILgC/SKIAkIQgtv9oohSAYWDCAACNjPcYAAdEYAgVEgAIFL
+gQT0AYGP4Aryg+Iu8gDdp6GsoQPYC6EJ8IPiJvIA3amhp6ED2AihpKaKIIoI+gpv9iqBz3CgACwg
+0IBAxwbYQcBCxUPFAdge2SpyCHNKJAAACiUAAQAmhx8HACChIyAABAomAAH5BG/2pMDgePHAhODh
+xQh1DvQ6DaAABN2KIIkGpgpv9oohBg16CyAAANhd8IThOPTPcIAAYMoYEIQATCQAgcohwQ/KIsEH
+yiBhAcojgQ8AALwB4ABh9colIQAkEAQAUSRAgcohwQ/KIsEHyiBhAcojgQ8AAL4BvABh9colIQCK
+IEkIQgpv9oohBwAWCyAAB9iGDGAABN22DIAAJfBTJX6QE/LPcIAAwAUAgILgzCAigRn0iiAJCA4K
+b/aKIYcE4gogAAjYD/CI4Qz0z3GAAHRGz3IBADBdAd2pcDKBnf8D8ADdOQRv9qlw8cC+C0/2z3WA
+AHRGCIWD4DPyC4WD4DHyCYXPcaAALCBRIACBC/IMhYHgCfQwga4Jb/aKIEoIAdgg8NCBCoUCJgEQ
+BdgMuBBx1/eKIMoHjglv9slxENgJpQ2FAiYBENdxAAAAUMn3iiDKB3IJb/bJcQHYDKUC8ADYsQNP
+9vHAPgtP9s9woAAsIPCAz3aAAHRGCoalhgInARCxcQb3BoYdZSJ9CfDPcgEAMF0B2DKGb//qpgCG
+z3aAAMRGUSBAgAzywggv/6lwJgyP/whxbgwv/8lwBfACDC//yXBJA0/24HjPcYAAdEYAgVEgAIHP
+cIAAaKtIgFMiAwAE9AGBj+AS8oDjDfJRIsCBCfTPcKAALCAQgA2hAdjgfwuhAtjgfwuhgOMM8lEi
+wIEI9M9woAAsIBCACqEB2APwAtgIoeB+4HjxwH4Kb/YA2Zu5z3CgANAbMaDPcIAAwAUAgADeieDK
+IcYPyiLGB8ogZgHKI4YPAADmAMokhgPUBib1yiXGAM91gAAAACCF8bkZ8iGF8blA2s8i4gfKIoEP
+AADQAM8i4QfPcZ8AuP9doUSFAeLTukSlBSKCD9D+AABWoc9xgAAER/AhAABAeACF8bgG8s9wnwC4
+/92gVQJP9vHA4cXPcaAArC8cgb2BBH3PcIAAlAQAiIHgCfTPcMDfAQAcoSjZGLkb8IogSQbWDy/2
+iiFODIogCQbKDy/2qXH8vQryiiAKBboPL/aKIU8A8gsABfa9pAjC9gDZm7nPcKAA0BsxoPUBT/bg
+ePHA4cXPdYAAyK7PcIAARHZAJQEU7g5v9kjaz3CAAKR2z3GAAMQF3g5v9gjaANnPcIAA3EYpoM9w
+gADABSCgz3CgACwgEICpAW/2FqXxwO3/ANjPcaAAwC+AGQAAE4GLuBOhz3DIADwAwBkAANHA4H7x
+wAYJT/bPdoAAKEfwJgEQz3eAAMAFg+EAp1nyguDPdYAAyK4L9CqFgeEJ9IogCQj2Di/2ANkI2ACn
+guAa9ALYCqUA2c9woAD8RJ65IaDPcKAAtA8A2lygD8gEIIAP/v//Aw8aGDAPyIe4DxoYMC/w8CYB
+EIHhDPTPcIAAdEYAgFEgAIAE9ADYCqUD8CqlBMhRIICABPLqDA/5DfAA2p66ANnPcKAA/ERBoM9w
+oAC0Dzygz3CAABwPGIiE4AX0QglABYDgA/RyDQACpQBP9uB48cDhxYogSQxODi/2iiHKCnoPAALP
+cYAAYMpIgc91gADIrjSRUyIAAFoLL/YB2wDYEqUOhYDgCPLPcIAAHA8YiITgBPQE2ATwbgnP/1IL
+7/8A2YDgFfQLhVEgwIAJ8oogiQb2DS/2iiELBADYCPCKIEkH5g0v9oohSwUC2K3/MQBP9uB48cAA
+2c9woADQG5u5MaAEyITgC/KKIIkGug0v9oohCgUA2KP/CvCKIAkJqg0v9oohygYE2J7/0v848eB4
+8cDPcIAAwAUAgIPgBPQ+D8AA7f8s8eB48cDWDW//4cXPdaAArC8Yhfq4C/IahVIgAABRIACABfIc
+hfy4CPKKIEkGVg0v9iRoAg/AAByFUSAAgBryz3CAAExHAIBCIACAyiBiAIDgEPTPcoAA3EYJgoTg
+SvfPcYAAyK4ugYHhBPQB4AmiPIUSDS/2iiCJDdIJD/WWCAAFgOAI9M9wgADABQCAg+AgD8H/RQcP
+9vHAvg4P9gh3OnGKIMkJ3gwv9oohRwzPcIAAxAUggAGAViFBCxTgOGAycMohxg/KIsYHyiBmAcoj
+hg8AAPIByiQmABgDJvXKJQYBz3CAAMiuDoCA4Bzyz3CAABwPGIiE4Bbyz3CAAMiuCYCC4Mohwg/K
+IsIHyiBiAcojgg8AAPMByiQiANQCIvXKJcIAOg2AAFjYdghv9gHZz3agAMgfINgQpjLYQx4YEADY
+Ggpv9o24INgRps9wgADIrqQWEBBaDG//66A1hiYML/aKIMkJz3WgAKwvPIUWDC/2iiDJCYogyQkK
+DC/2KnFRJ8CQQvLPcIAAfAcAgIYgfw+C4AHYwHiB4Dj0GBYAlqG4GB4YkIogEAARphmF8LgZhQzy
+BCCADwgAAADXcAgAAAAB2MB4B/CGIH8PguAB2MB4gODs86DfEfDgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeGG/jCf/n+31GYWIuBmlMgrP+M9wgADIrguAwLiB4AHYwHguDa/2WnDGCOAA
+KnAB2FYI4AAKcRyF+bga9BiFiLgYpaDfEvDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eGG/jCf/n+717grAAKQWDxD2DK/2SnBk/1zYJg8v9gHZINgQpjLYQx4YEADYzghv9o24INgRphyF
++bgO8s9wgADcRgCQUSCAgcogIQLwDiH2yiGhAM9wAIIBABylANjCD6AA6XHtBA/28cCeDC/2ANnP
+dp8AuP+9hj2mHNkV8M9zoADIOzaDRCECBzaDhiH/CCV6NoOGIf8IRXnPcqAAqCBNguTiiveA4ev1
+AgmAAL2mgOAP9ADYK/A4EwQAWBMFAAohwA/rcgXYyQAv9S/bygkv9wDYiiCJB0oKL/aKIYcBA9jH
+/gLYz3GAAMiuCaHPcIAAYMoJgCW4wLjKC6/2DqEI2Ioh/w9N/wHYaQQP9uB48cDyCw/2z3WAAMiu
+XBWBEIDhpMEN9gohwA/rcgXYiiNEAEokAABdAC/1CiUAAQTIgeDKIcEPyiLBB8ojgQ8AAAIByiBh
+Ae/zguEJ9ADYXB0CEBoNL/UZ2FXwKg6gAIogxguA4E/yDoUA3oDg0qUI8s9wgAAcDxiIhOAT9M9x
+gAB0RtCh0aEQ2Amhx6HJpYogSQeCCS/2iiEEBwLYMvAWDqAAiicEG89zgADEBUCDYYOVIkEA+mIU
+43piUHBGACUAAdkppc9woAAsILCAz3ABAIB3QMBBwULBQ8YocAbZAdrJc5h2uHYAJYcfBwAgoZ4L
+4ADYdoogCQcaCS/26XEB2Hv+WQMv9qTA8cDuCg/2z3CAABwPGIiE4MohwQ/KIsEHyiBhAcojgQ8A
+ADoByiQhAFAH4fTKJcEAOgyP/3YNoAAIdoDmCHUT9DoNoACKIMYLgOAN8s9wgADEBSCAAYCWIYEB
+FOA4YBB1DPeOC+AAAdiKIIkGnggv9oohxQQA2Fz+4QIP9vHAagov9oog/w+hwUDAz3aAAMiuCIaA
+4ADZCPLPcKAALCAQgCimB6bGC4//Ngyv/xpwCHGiDa//CnCA4Ij0z3CAAHRGCYAA31EgAIHKIcEP
+yiLBB8ogYQHKI4EPAAB0AcokwQOYBuH0yiXBAIog0AceCC/2iiHFDZoOQALPcQCCAQDPcKAArC88
+oM91nwC4/3QVEBD9pRzZFfDPcKAAyDs2gFaAhiH/CIYi/whFeVaAhiL/CEV5z3KgAKggTYLk4pr3
+gOHr9ToMoACKIMcLdB0AFIDgPPIGhoDgGfIKIcAP63IF2IojhgNKJAAAEQbv9AolAAE4EAQAWBAF
+AAohwA/rcgXY+QXv9C/b9gmgAItwCiUAkBzyiiBJBnYP7/WKIYYFiiAJBmoP7/UAwYogCQZeD+/1
+qXGKIIkHVg/v9YohhgYD2An+qXAAwZf+gQEv9qHA4HjxwB4JD/aWCo//Bguv/wh1CHFyDK//qXCE
+4An0iiAJBhoP7/WKIYsKLfDPcKAAyB+kEAEAFYDPdoAAyK5FhkJ513EAAKAPAN3L989xgACoriWB
+1bhBKYIAQnkwcIT3BoaA4BH0iiAJBtIO7/WKIUsNpqaKIEkHxg7v9YohCw4C2OX9CQEP9uB48cDh
+xc9wgAAcDxgQhABMJACByiHBD8oiwQfKIGEByiOBDwAACQP8BOH0yiUhAOYJj/9WCq//CHUIccIL
+r/+pcMkAD/bxwM9wgAAcDxiIhODKIcEPyiLBB8ogYQHKI4EPAAAbA8okIQC4BOH0yiXBAKIJj/+A
+4A/yHgngAAHYiiBJCDIO7/WKIQwKB9jA/TIPQAD5Bo//4HjxwOHFz3CAABwPGIiE4MohwQ/KIsEH
+yiBhAcojgQ8AAF4DyiQhAGQE4fTKJcEATgmP/74Jr/8IdQhxKguv/6lwhiC/jhL0/guP/4HgDvQC
+3c9wgADIrqqgiiBJB74N7/WKIc0LqXCk/QkAD/bxwI4Pz/Wmwc9wgABEdjaAz3WAAMiuF4BEwSmF
+RcCD4cwhIoA58s9wgAAcDxiIhOAz8oHhAd8A3gv0WgjgAOlwz3CAAIiWHYiA4MmlJfKKIEkGXg3v
+9YohTQID2AmlEYXSpQzZFSQCMM9woAAsILCAz3ABADR3QMBBx0LHQ8ZEggDYCHOYcLhwACWHHwcA
+IKGWD6AA2HBhB+/1psDxwPIOz/XPcIAAHA8YiITgyiHBD8oiwQfKIGEByiOBDwAAUQDKJCEAWAPh
+9MolwQCKIAcO3gzv9QDZz3aAAHiuLY6A4QTyDI4QcQz2xgzv9Yoghw2KIIcNugzv9SyOXPDPcKAA
+sB8bgM93gAAwrwKniiBJBp4M7/Vj2YogCQaWDO/1IodMjg2Oz3GAAKiuaJFAp3Bwz3WAANiuAaeL
+9gixANlNHUIQAdkspTWFMHDD9xWlEI4EpRGOgOAE8oDiBPIA2Arwz3CAABwPCYBRIICA+PMB2AKl
+iiBJBjoM7/WD2YogCQYuDO/1IocChUCHgODKIGIAGLgFegSFCiEAgIogCQbKIWIAELkKDO/1RXlK
+D+/0AthFBs/18cDeDe/1iiBJBvIL7/WKIUQBvg9P/891gADYrghxhODMISKCEfTPcKAALCAQgADa
+QqUDpc9wgAAwrwKA1bjHcAAAiBMJpQ2FgODKISIBAN7yCK//yXCE4AP0zaUU8AKFgOAK8oogiQmS
+C+/1iiFECgXYCPCKIEkHggvv9Rx5AthWDI//xQXP9fHAUg3v9ZhxCiMAgMohwQ/KIsEHyiBhAcoj
+gQ8AAFcByiQhALwB4fTKJQEBz3CAAHxHJYAjgc93gACorkCBz3GgALAf24FTJk0VNr5+Zl1lJYdh
+uwUp/gAndQIlgxCMIxeHSvfPcoAAMK9BggUqfgAndV5mTCQAgAfyz3GAAHRGM4GB4RH0Tg6v/lgl
+QRbPcIAAlEcAJYEfAACIEzYOj/6KIMkOGfDPcIAArEcmDq/+WCVBFs9wgADERwAlgR8AAIgTEg6P
+/slxybnPcIAAMK8joIogiQ+eCu/1yXEGh4G42QTv9Qan4HjxwM9wgABkR34Nr/7hxc9wgAAQrzWI
+z3CAAHxHgOHPdYAAMK8L9CCAQiEBgMohYgCA4QXyIIWA4Un0Tg2P/s9wgACUR0INj/5Chc9woACw
+HxuANro2uBByxfcIcYAhEAAC8AhxYIV6YmGFeWEwcs33CiHAD+tyBdix20okAAB9AO/0uHN6YjBy
+/vciek96cHLKIc0PyiLNB8ojjQ8AALgAyiBtASv3z3GAAKxHIIFCIQGAyiFiAIDhBvJYYCOFybgw
+cAXySHAA2ZT/GQTP9eB48cDhxYogSQayCe/1z9nPcIAAHA8YiITgyiHBD8oiwQfKIGEByiOBDwAA
+0gDKJCEA+Aeh9MolwQDaDO/0AtjPdYAA2K4ChYDgC/LPcIAA3EYBgAmlz3CgACwgEIABpc9wgACo
+rgaAUSAAgCPyz3CAAMAFAICG4MwgYoHMICKCBPRQ/xXwBIWA4ADZEfLPcKAALCAQgCKlA6XPcIAA
+MK8CgNW4x3AAAIgTCaUA2ASlof9hA8/14H7gePHA4grP9c9xgAAcDziJhOHKIcEPyiLBB8ogYQHK
+I4EPAAA8AcokIQBIB6H0yiXBAM9xgADYriqBgOFH8s92gABMRyCGQiEBgMohYgCA4T30gODKIcEP
+yiLBB8ogYQHKI4EPAABCAcokIQAIB6H0yiUBASWGI4HPd6AAsB+ggTuH1bk9Zc9xgACoriWBYbgF
+KT4AJ3WKIAkOagjv9alxO4eKIAkOXgjv9Ta5yXC2C6/+VyXBGM9wgABkRwAlgR8AAIgToguP/oUC
+z/XgePHA4cUIdc9woACwHzuAiiBJDiYI7/U2uYogSQ4aCO/1IoXPcIAAHA8YiITgyiHBD8oiwQfK
+IGEByiOBDwAAjQHKJCEAYAah9MolwQDPcYAA3EYJgYTgRPcB4Amhz3GAAKiuBoFGIEABBqHPcIAA
+wAUAgILgCvSKIMkHvg+v9YohBgeSCK//BtgFAs/18cDhxQh1z3CgALAfO4CKIIkOmg+v9Ta5iiCJ
+Do4Pr/Uihc9xgACorgaBgrgGocIK7/QC2M0Bz/XxwOHFCHXPcKAAsB87gIogyQ9iD6/1NrmKIMkP
+Vg+v9SKFz3CAABwPGIiE4MohwQ/KIsEHyiBhAcojgQ8AAPoByiQhAJwFofTKJcEAiiDJByIPr/WK
+IUgB9g9v/wbYAdnPcIAA2K4toM9xgACorgaBRiBAAVUB7/UGoeB48cDhxQh1z3CgALAfO4CKIAkP
+5g6v9Ta5iiAJD9oOr/Uihc9wgAAcDxgQhABMJACByiHBD8oiwQfKIGEByiOBDwAAwAEgBaH0yiUh
+AM9xgADYrgyBgOAK8gWBgODMIGKABPIA2Mj/GPDPcYAAqK4GgUYgQAEGoc9wgADABQCAguAK9Iog
+yQdyDq/1iiEHBEYPb/8G2LkAz/XxwEIIz/UIds9woACwHzuAiiAKAEoOr/U2uYogCgBCDq/1IobP
+cIAAHA8YiADdhODKIcEPyiLBB8ogYQHKI4EPAAAcAsokQQOEBKH0yiXBAM92gACorqamiiBJCAIO
+r/WKIYgI1g5v/wfYBoaCuEYI7/8Gps9wgADYrq2gJgnv9ALYLQDP9eB48cDhxQh1z3CgALAfO4CK
+IEkPxg2v9Ta5iiBJD7oNr/Uihc9xgACorgaBgrgGoe4I7/QC2M9xgADYrgyBgOAN8g2BgOAJ8gWB
+gODMIGKALA/i/8ogIgDZB4/14HjxwF4Pj/XPcIAAYMoJgM9xgADYriW4UyAAgAqhANgFoQ2hWfLP
+cIAAHA8YiITgU/KKIEkGRg2v9YohSQDPcKAAsB87gIogCQYyDa/1NrnPdYAArEcAhUIgAIDKIGIA
+geAY9BYIr/6pcM92gAB8RwCGQiAAgMogYgCA4Az0iiBKAPoMr/WKIQkDyXBSCK/+IoXPdYAAxEcA
+hUIgAIDKIGIAgeAZ9NIPb/6pcM92gACURwCGQiAAgMogYgCA4Av0iiBKALoMr/WKIUkGyXAOCK/+
+IoX5Bo/14HjxwOHFz3AAAP//z3WAADCvA6XPcIAATEeGD0/+z3CAAGRHfg9P/gDZIKUF2AGlIqXK
+D6/0AtjFBo/14HjxwEoOj/Uodc9xoAAsIDCBz3OAADCMRouA4gDeBPJHi4DiA/QG2IfgyiHKD8oi
+ygfKIGoByiOKDwAAnwLKJCoAlAKq9MolygCG5c9zgADYrgLyNKNOgw8iQgNOo89ygADcR/AiAABS
+gzhgAiCNAP+9AvQSo891gAB0RgKFQYUEehvIESIAgAzyKqXeC6/1iiDKCAGFj+DJpQL0x6UZBo/1
+8cCmDY/1CHXPdoAA3EYBhs9ygADYrgmiz3CAALShHoAEJYQfAAAAIOa4JrhTIAMAQS1AE8C4FiLP
+AAKnJPLPc4AAdEYJgwDfJXjDuQ8nTxAvgwmjCyHAgwHYBfIMoxwbAAHmvRX0DoMwg+R4BSBAgBCj
+D/IA2Ammz3CgACwgEIADogfwz3CgACwgEIABos92gAAcDxiOhOBoDKEEyiBBAxiOgeAa8s9wgACw
+xwCAUSBAgCbyz3CAAFTNFIiH4CD0z3CAALShlBCAAM9xgAAohQS4AGHtuBTy7L0S8s9wgAC0oZQQ
+gAAEuMdwgAAohSCAiLkgoNIKr/WKIAkGEQWP9fHAqgyP9c91gADYriCFJXgApRCFgOChwQX0AdgQ
+pQWFEaWmCe/6i3AAwc9wAQCAdzBwDPLPcAEANHcQcQbyz3ABADBdEHEF9GINYAAB2ADe/gzv/8Kl
+z3CAAExHZg1P/s9wgABkR14NT/7PcIAAxEZSDU/+iiCJBk4Kr/WG2SYLb//JcJEEr/WhwOB48cDh
+xQh1iiAJBjIKr/Wpcc9xgADYrgCBpngAoQDYEKEFgToML/8RoWkEj/XhxeHGCHX/2c9wqwCg/zmg
+BNnPcKAAyBwooBbeEfDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG+jCb/n+31z3Gg
+AMAvE4GA5c8g4gLQIOECE6GA5TzYyiCBDwAAsgyTuJa4l7jAGQAAwcbgf8HF4HjxwNoKoAFH2ADa
+z3GrAKD/WaEH2BqhWKHRwOB+8cBOC4/1CHXPdqAAwC8ahjm4UiAAAFMgEAAUhlEgwIAA3wn0pgvv
+9STY8rjKIsEjA/JKIkAgURYAloDgCvSjFgCWBCCADwAAAA+MIBCABPQA3gPwAd4EIZFPAAQAAM9w
+AAAIHGYLz/U/uFIgAgAEIIBPAgAAANdwAgAAAAHZwHkMcIYgPQCA4EokQADCJAIBUSCAwQjyz3CA
+AMAFAICB4ADYA/QB2M9zgABkQGODguMI9M93oACsL/yH9r8A2wP0AdvlvcogYSBMIACgB/Lmvcoi
+YSBMIgCgA/QA2Cjw473KIWEgTCEAoPnz5L3KImEAgOL18+K9yiZhEIDm7/PhvcohYQCA4evz4L3K
+JGEATCQAgOXz573KIGEAgODf81ElAJLKI2EAgOPZ8wHYfQKv9Q944HjxwOHFz3EDAEANz3CgAKgg
+LaDPcaAAwC8UgfC4FIEM8gQggA8IAAAA13AIAAAAAdjAeAfwhiB/D4LgAdjAeIDgXfQVEQCGoLgV
+GRiAEfDPcKAAqCANgOTgz3WgAKwvjvcchfm4RfQMdIQkwp9B9FrYl/+A4O3zQ/CKIAkGyg9v9Yoh
+SQzPcaAA1As7gboPb/WKIAkGLHGyD2/1iiAJBjmFpg9v9YogCQbuCe/1JNgIcZYPb/WKIAkG3gnv
+9YogCQMIcYYPb/WKIAkG63XKCe/1JNi4cM9woADUC2wQBAAF2AohwA+pctEFb/SKIwkOz3GgAMwr
+EoGAuBKhpQGP9eB44H7geOB+4HjxwIogiQY6D2/1iiFMBg4Ib/8A2K0Fz//xwM9wAAAIHG4J7/Wh
+wf+4DfLPcKAALCAQgATZfNo920DAi3D6Cq/1F7uhwNHA4H7xwOHFz3CAAMAFABAEAM9wgADYrkwk
+wIHMJCKACvIUEAUACiHAD+tyBdg9BW/0/NsA3aWgiiCJBr4Ob/WKIUQAkg8v/6lwCQGP9eB48cCK
+CI/1z3CAAGirCIDPd4AA2K5RIMCBAN0V9IogSQeKDm/16NkC3l4PL//JcMWnz3GAAHRGsKGxoRDY
+CaGnoQrwpaeKIIkGYg5v9fHZOg8v/6lwnQCP9fHALgiv9QHbz3CAAHRGAIDPcoAAMK/BuIPgwYLA
+e4HmBfTPcIAA3EbHgM9wgACsRwCAQiAAgMogYgCA4ED0z3GAANiuDIGA4MwjIYA49AKCz3OgALAf
++4M2uDa/8XDWJ40fAACAAECCtYEAIhAA/WUSdU33CiHAD+tyBdiKIwQKCiQABD0Eb/S4dYDmCvQK
+IcAP63IF2IojxAr08QAgkCMSdX73/maKIEkGqg1v9YohxAwCIIAjLgqv/wHZ1QdP9fHAag9P9Qh2
+iiD/DwCmz3CAANiuCoCA4MolIRFq8s9wgAAcDxiIhOAV9JIKAAAAps9xgADEBUCBIYFWIkILFOFZ
+YTBwAdjCIA4AE3hTIE0AUPC8/89wgABMRwCAz3eAANxGQiARgM4JIADKIWIgAKbPcaAAsB+7gSmH
+QCcQE89ygACorvAgQSBFgmG5BSp+ANW9J3WCJYERSCUNEBB1yiUGEE/3z3CAAExH5g8v/kohQCDP
+cIAAZEfWDw/+oKbPcYAAxAUAgSGBViBACxThOGAQdQHdwiVOE7N9UyVNkAryTCFAoAb0CYeqC6//
+8CAAINkGb/WpcOB48cB6Dk/1z3CAABwPGIiE4M92gADYrhX0CoYB2oDgAIbAegHZgODPcIAAqK4G
+gMB5gODMIiGAzCEigF3yY/DPcKAALCCwgBKGANoCJQGQ44bKIm8AsXcJhhAALwD7YAIlzxCA5wDf
+w/YB39dxAEAAAMj3gOIG8gIlgR9OAAEgMqYCJcEQ13EAQAAAyfeA5wfyAiWBH04AASAjpiKGgOET
+8iGGOGAQccf3EHXL9zB1h/cH8DB1g/cQdcP3ANkC8AHZIqYAhs91gACorqaFgOAB2MB4gOEB2cB5
+hiV/HoblANsE8qqGgOUD9AHbgOfMIiKAA/QA2AjwgOPMISKAzCAigPnzAdjdBU/18cCYcM9wgABg
+ygmAz3GAANiuJbjAuAqhuP+A4AXyiHB+/oDgA/QA2ALwAdjpAc//8cChwQDYz3KAANiuTRKBAEDA
+geGLcA/0z3GgACwgMIFUgkJ513FOAAAgxfdiCc/+A/BeCM/+guAG9Iog/w+hwNHA4H7PcIAArEUD
+gCCAAMAieIDgyiAsAPPx4HjPcqAALCBQgiJ6z3GAAMQFFXkAgRByyvfPcIAAYMoJgFEgQIEC8kCh
+4H7geOHFiiH/D89woACwHxuAz3WAAKxFY4Vgg6aF1biA5QDaBvIihWJ5gOHKIYwACSEAAIIggQFI
+IAAA4H/BxfHAcgxP9Tpwz3CAANiuB4BKIkAgwLiB4M9wgABkQCmIwiKCJIHhBPIA2B3wz3GAAHRA
+IIGA4frzDBAEAEwkgIDKIcIPyiLCB8ogYgHKI4IPAADuALgAYvTKJcIAFghv+EpwGnCKIEkGNgpv
+9VTZiiDJCS4Kb/Uqcc9wgABcYwCIz3agAMgfUSCAgADfBvJ+FgCWoLh+HhiQz3CgALQP/KAPyAQg
+gA/+//8DDxoYMA/Ih7gPGhgwEglgAhzdRNhJHhiQEvDgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeGG9jCX/n+71z3WgAMAvE4X6uAr0iiBJBqIJb/Vr2QYPYAJKcIoPr/9KcM9xnwC4/12B
+z3CAAMwFQKD9oRzZFfDPc6AAyDsWg0QgAQcWg1aDhiD/CAV5RRYAFoYi/wjk4EgAJQBFeYDh7PUO
+Cc//URUAloDgBfQMdIQkwp8h8heF+bgf9M9wgAB8BwCAUSBAgBf0CiHAD+tyCiQACFEVBZYF2IkH
+L/SG2zgTBABYEwUACiHAD+tyBdhxBy/0L9tMIkCgJfSKIEkG8ghv9Y7ZEIVRIACAFPTPcYAAMIwE
+kYXgBPQLiYLgDPJAFQQQCiHAD+tyBdiU2zUHL/S4c4ogEAERpRCFUSAAgP31FIWruBSlTyBAJpy4
+GaXPcKAAyB8YEAGGobkYGFiAiiEQADGgCdkIuS+gE4WpuBOlz3CAANiuB4CD4Bn0z3CAAMQFAIBW
+IEALAiEBoBoADwAKIcAP63IF2LvbSiQAAMEGL/S4cxJpn7iIHQAQcgkP/oAdwBPPcIAAzAVlAm/1
+4aDgePHAAgpP9c91oADAL4AVDxBcFRAQ2oWIFREQz3CAANiuB4BKIkAgwLiB4M9wgADMBQGAwiKC
+JOC40fSAuM9xgADMBQGhiiAJDeYPL/Xl2YogCQ3eDy/1QS+BEIogCQ3SDy/1CnGKIAkNxg8v9clx
+iiAJDb4PL/UqcTCFtg8v9YogCQ0zhaoPL/WKIAkN/L4G8hCFUSAAgAT0ANgD8AHYTCIAoC8gByBA
+8oogCQ2CDy/1+tkwhXoPL/WKIAkNEIVRIICCDfRAFQQQTBUFEAohwA/rcgXYyQUv9P3bTCBAoM92
+oADIHyDfE/SKIBABEaXwpgrYQx4YEADYDg1v9Y248aYwhS4PL/WKIAkNiiAQABKl8KYF2EMeGBAA
+2O4Mb/WNuPGmEvAQhVEggIIO8kAVBBBMFQUQCiHAD+tyBdhhBS/0iiMEBEwiAKAThQ/y+rgY8goh
+wA/rcgXYpdtKJAAAQQUv9AolAAH6uMohwQ/KIsEHyiOBDwAAqQAF2PHzB9jPdqAAyB8ZHhiQAdgI
+cQhyCHPOCy/0mHDqCK/1VNhRIACBCfTPcIAAzAUggM9wnwC4/z2ggBUPECK/sg/v/elwz3GAAMCN
+DYH4YA2hANiAHQAQiB0AEAnYCLgOpoUAT/XgePHAKghP9c9wgADYrgeASiBAIMC4geDPcYAAzAUB
+gcIgAiThuEL0gbgBoc92oADALxOG+rgE8hOGurgTpgLYEabPcIAAMIwAkIjgz3WgAMgfEfQg3/Cl
+CthDHRgQANjKC2/1jbjxpQvwRRUAFuTgQAAFABCGUSAAgPjzQgyP/6YKYAIKcBUWAJaAuBUeGJCK
+INAHvg0v9YohBQ46DIABpgrP+QnYCLgOpeUHD/VcFgQQQBYFEAohwA/rcgXYAQQv9IojBQrxwFYP
+D/WhwTpwKHVIdppzCiMAIQoiQCHIdwogwCGKIBkCag0v9QvBLMCA4CgUBTAJ8ipwqXHJcgpzygkg
+AJh3EPAAHEAxKnCpcclyinMKJMAECiWABNh3KgggAAonAARJBy/1ocDgeOB+4HjxwAhxGg0v9Yog
+WQE+DE/60cDgfvHAxg4P9Tpw+nEaclpzCiAAMQokQCEKI4AhCiXAIQogwITPcYAANIXKIGIACHIE
+uAhhTCcAoAS4hiD+AwUglgDKIcwPyiLMB8ogbAHKI4wPAABEAMokbAAgAyz0yiXMBc91gADUYgGF
+AN7JcXYPL/U42iCFHNgAoQGFGNkgsGpxhCkLDAAhj3+AAGDKN4cQGIIFMxiCA892gADUBSGgyXEi
+oAohwIQoGEAFMRjCBTIYwgU0GAQEyiFiAEIKr/UM4CGFDNgSqQOBUSBAgg30DInPcoAAbHDDuBx4
+CmLPcIAABMtIYAypTCMAoAb0z3CAAPCqBfDPcIAAEKsDpc9yAABIEUCwTCFAoBjaQqUE8ooiBQJA
+sA3CgOIE9M9yAgA8E0GmtRcCFlEiAIAR8hraQLFCpUCQTCIAoIe6QLAH8s9wgAB0RgSAMxkCAEwg
+ALAU8gGBmLgBoQOBn7gDoc9xgADABwAZBAUgh0GHz3CAAMQHIKBBoKoJb/qpcJEFD/XgePHAXg0P
+9aHBCHZacTpyGnOId44Or/6odYDgzCYikAryz3CAANiur6CmDi/0A9gN8EDFyXBKcSpyANuYc7hz
+2HcKJwAEj/91BS/1ocDxwOHFgOHPdYAA3AUS8iaFgOEN9AClbg4v9A3YXgiv/4ogCAAB2AalDvAg
+hSV4C/BmDi/0DdjSCK//iiAIAADYBqUApVEFD/XxwNIMD/UIdgDf6XDpcev/A9jpdYDmGnAI8hNt
+FHjHcIAA+EfODc/9gOYJ8hNtFHjHcIAAQEi+Dc/9QiBAIIDgAeUq989wgABAr+l0nbAwvJ6wz3CA
+ANwFrgkgAeCg2QQP9eB48cBiDA/1z3GAALQGAIGguAChAdji/89wgABArwCAg+DL9wohwA/rcgXY
+7NuYc9UAL/RKJQAAgODkAC4AAN7Pd4AA3AXPcIAArHbVeCCAs24DgCKnA6cUbgAggQ+AAECvR5EG
+kRC6RXhFkRpwBJEQukV4Q5FacAKRELpFeDpwkgnv/QpxIod6cLR9ACWAH4AABEggoNYMb/4qcAhx
+ACWAH4AA+EdODc/9DCCApIT3TCIAoCj0I4ezbrR9ACWAH4AATEggoKYMb/5qcAhxACWAH4AAQEge
+Dc/9iiBMDbYJL/WKIYQCiiBMDaoJL/VqcYPmjvcKIcAP63IF2IojBAOY8YogTA2OCS/1iiEEBM9w
+gABArwCAAeYQdiwHxf+dAw/18cDPcIAAQK/eDy/1DdmWDw/1tP/RwOB+8cA2Cw/1CHaKIEwLTgkv
+9clxg+bKIcYPyiLGB8ogZgHKI4YPAACdAcokxgCcB+bzyiUmABRuz3eAAECv+GBFkCSQELpFeYDh
+GnBD8s9wgACsdtV4IIDPcoAA3AUDgCSis24ForR9ACWAH4AAlEgGEAIhIKAEEAAhELq6C2/+RXgI
+cQAlgB+AAIhIMgzP/c9wgADcBSWAACWAH4AA3EgGEAIhDhADISCgBBAAIQwQASEQuhC7RXgiCO/9
+ZXl2C0/+CHEAJYAfgADQSPILz/1elx2XANkPIYEDELpFeAYgQIAB3R23MLgetxf0z3GAALQGAIGg
+uHYP4AAAoc9woACwHxuAsqcM2ZbaEadWJwASHttCDC/1GLsQ2s9xgADcBQCB2HpGeHUCL/UAoeB4
+8cASCg/1z3aAANwFAN0L8BDYuHgLIQCAvA7i/8ogQgMB5YPlIIa294DhyiAhAMQM4f/KIQEASQIP
+9eB48cAA2c9ygABAryCiz3CAALQGIKA9sjC5PrI+8fHA4cUA3c9wgADcBaCgz3CAALQGoKDPcIAA
+QK+pdJ2wMLyesKlwL/+pcKlxG/8BAg/14HjxwIIJD/UA3891gABArz6VDycPEB2VELkleAYg/oM/
+9M9xgAC0BgCBgLgAoc9wgAC4Bs9xgAC0lwCQVokQchv0z3CAALoGAJBUiRByE/TPcIAAvAYAiDKJ
+EHEN9A/IBCCAD/7//wMPGhgwD8iHuA8aGDDPcKAAsB8bgADeDNmW2hCl0qVWJQASHtsSCy/1GLsB
+2MlxUgigA4DaPpUdlRC5JXjleB21MLhBAS/1HrXgeKjx4HgIcQDY/PHgeAhxAdj48eB4CHEC2PTx
+4HjxwOHFz3GAAECvfpFdkRC7ZXoRIgCAAd0K9AO4FHjHcIAA+EeuCc/9qXAD8ADYAQEP9eB48cDh
+xSh18v+A4MogQQNYC+H/yiFhAOUAD/XgeAhyANgQ2fDxCHIB2CDZ7PEIcgLYQNno8fHA4cXPdYAA
+3LAgjYwhw48K8oDgBvLPcIAAGElOCc/9/9gArc9wgACEsADdtaDPcIAAgAWgoM9xgAC0BgCBorg+
+DeAAAKGpcDoJ4ACpcXkAD/XgePHA4cXPcaAAsB87gQ4O7/SKIMwNz3CAAHQGAIAEIL6PAMAAAAj0
+z3CAANywAIiMIMOPBPIB2N7/z3WAAIyvqXBODC/1UtnyC0AFo4WKIEwOyg3v9Klx9gsP9YogjA6+
+De/0ctmOCG/+qXAIcc9wgAAYSQoJz/3+2c9wgADcsPUH7/QgqP/Zz3CAANywIKgA2c9wgACEsOB/
+NaDgeM9ygAC0l3aKz3GAAPgFVIphsQGhQLEocAjZc9oe21kBL/UYu/HA4cXPcYAAjK9Bic91gACA
+BYDiz3OAALQGIIMG8gHYAKWCuSCjCfAA2kClormA4CCjOAzCAADYNgjgAAhxANjn/3EHz/TgePHA
+z3CAABwPCYBRIECByiBiADgMYgTKISIAz3GAALgGiiCMDO4M7/QgkQHY4//RwOB+4HjxwMIO7/SK
+IgQOz3WAAIyvz3aAALSXQCUAFDIML/VAJgEWAYUihSGmIZUApjauII0EIIAPAAYAAIDgAdjAeDSu
+Eq4A2c9wgAA6CDIPIAAgqLYNQAOA4AXyANjL/yHwz3GgALAfO4F6DO/0iiBMDGoML/QC2M9xgAAc
+D0iBNJFTIgAAignv9AHbiiCMDlIM7/S62QDZnrnPcIAAdAYgoJEGz/TgePHA4cUIdf/Zz3CAANyw
+IKhvIEMAOg+gAAHZz3GgALAfO4EaDO/0iiDMDQWFA4BChSCAiiCIAAYM7/RCeVUGz/SA4PHAD9gJ
+8jYPz/MqCW//gNjRwOB+Pg/P86oJb/+A2IoOD/6C4Ab0gggv/gDY8/Hx8eB48cCODe/0iiDMDqLB
+ugvv9IohxQaLcCYKL/UC2QMUjzCC58ohyg/KIsoHyiBqAcojig8AAGwByiQqAPwB6vPKJcoAAhSA
+MM92gAAABoQvBh8AFBAxJB4CEM9wgACEsgAgQQ40iQolQC6A4UAgEgUAIFQOHPKKIEwNTgvv9Ioh
+RQ6KIEwNQgvv9Olxzg4v9UIggCEB2BO2/9glHgIQQCYAGVYOL/UE2WjwSiMAICYexBQlHsITz3WA
+AOCwQCUREqJ1i3CpcSIKL/UC2kAlABIWCy/1QiCBIQAlgS+AAOCwAoHPcYAAqK4lgdW4MHDKIcYP
+yiLGB8ogZgHKI4YPAACKAcokxgQwAebzyiXGBCYJYAXpcEokgHBqcaggwAOEKQYPL3AyIgIggOIG
+8jAhAiAChRByJfIB4UAmABm+DS/1BNkB2RQcQiBtFQAWgLhtHRgQKHCf/4ogTA1uCu/0iiGGCIog
+TA1iCu/0IoWKIEwNWgrv9OlxaQTv9KLACiHAD+tyBdiKI4YFSiQAAK0A7/MKJQAB4HjxwM9xgAAA
+BgOhbg3v8xDYXg8v/4ogBAAZ8eB48cDyC8/0ABYOQKHBgubKIcYPyiLGB8ogZgHKI4YPAAB9Bcok
+xgBgAObzyiUmAEDGi3fpcBINL/UE2YogzAraCe/0yXGELgYfCiBALgAhjX+AANyyYNy+DK/9AiUA
+E89wgADgsN4QAAYQdhHyvBWAkIDgJfLpcATZmdoe25IN7/QYuwDYvB0CkBnwACCBL4AAVLIQgYG4
+EKHPcIAAAAY0gIDhAdoE8kSgBNgI8ADZMKAqoEugJKAF2Mv/nQPv9KHAwQTv8xDY4HjxwOHFz3WA
+AAAGFYWA4CH07gsP/oLg6A3h/cogIQAB2BWlhgzv8xDYkgzv8w/YgOAWpQjycgzv8w/Y3g4v/4DY
+z3EBAGigAdhKCmADgNpZA8/04HjxwNYKz/TPdYAAAAY0FRAQjCDDrwjyiiAMDeII7/SKIUcCIPCA
+4MohwQ/KIsEHyiBhAcojgQ8AAM4ByiQhACwHofPKJQEECHGCIQYHz3CAAOCwDiBAAPoOb/2KIQYP
+GnDPcIAARLRFgIwiw4//2QbyOBgABC2lCPAUGAAEANgEpS2ly/+1As/08cDhxQh1hCgGD89ygADg
+sAAiQQ5tEQAGz3OAAAAGoLhtGRgAAoMEiIDgFPIDgYDgyiHBD8oiwQfKIGEByiOBDwAARAfKJCEA
+mAah88olwQACgYDgEvTeEgAGjCDDjwryz3CgALAfG4ACoecaWAMR8K2jANjB/w3w0goP/oQtBh8I
+cQAhgH+AAHyySguP/T0Cz/TgePHAwgnv9ALYAN0Ids9wgACUsoQtBh8wIEAOUSAAgFAP4v/KIEID
+CW6A4AHlL/cA2O3+/QHP9OB48cDhxc91gAAABiOFz3CAAJBN8CBAAEB4gOD58+EBz/TPcKAABEQH
+gIDgAdjgf8B4z3OgAKggMYPPcoAAMEkDgjhgA6IB2BKj4H7geM9yoAAsIGaCz3GAAAAGE4FieBOh
+EIISoebx4Hjhxc9yoADIH6QSAwDPcYAAAAYSgRBzwiMGAET3YngTe7+CE4G7Y3hgE6EB2EoaGADg
+f8HF8cDqCO/0ANvPcIAAAAZjoP/az3CAAOCw3hiYAEokgHBodaggAAiELQYfACGBf4AA3LLPd4AA
+rEWgGcCABt6wGYCDz3YBADCNrBmAg7QZwIO8GcKAACGBf4AAlLJgoQHlz3CAAOCw5xiYAM9xgACs
+TQCBHNpAoBjYNgmgAAKh1QDP9OB4AdrPcYAAMElDqRihKHBk2XXaHttpAu/0GLvgePHARgjP9M93
+gADgsOcXDRaMJcOfMfL/2ecfWBCELQYfoKAndwSPgOAKIEAuEfQCh89xgAB8BrINb/0ggQhxz3ag
+AMgfFYY6DA/+gOAD9AHYFPDPcYAAMEkCj6CpAakB2BOmHIYBoQHY3/8A2AAggS+AAJiyAKkA2DEA
+z/TxwNIPr/QB2qHBgeDPcYAAsAZAoSf0z3WAAES0BYWMIMOPCvIA2oQoBg8AIYF/gACYskCpz3aA
+AAAGEIaA4AbyD4bK/wDYEKb/2AWli3DO/4DgCfKqDIAAAMANpgDYJv8R8OYI7/MQ2JYMgABKCy//
+iiAEACoID/6C4CQK4f3KICEAvQev9KHA8cBCD6/0/9rPcIAA4LDeGJgA5xiYAADez3GAAAAGw6FN
+oQHaz3CAALAGQKDQodWh1qHUocChwaEC3clwhCgGDxpwACGBf4AAVLIQgQAhj3+AANyyYNxGIMAA
+EKEGCK/9AicAE2G9gOW8H4KTQCBAICb3AdjB/zEHj/TgeADYz3GAADBJA6nPcIAAAAZIgAKAQqkc
+4FZ4RIhJqQWI4H8KqfHApg6v9IogDAnPdYAAAAYkhbYMj/QEhYDgQ/TPd4AA4LDeFwIWAN6EKgYP
+ACdAHgKlJIgB24Dhz6VwpSHy6B+YEwwQBQDPcYAAqK4EJYQPwP8AABQRBgBBLAQGBS4+AQAhhH8/
+AP//BCRBAekfWBAgkIwhgoYB2cIhTgAupcilJIDPdoAAKLTAuTq2z3aAADBJKK5ArgKIZKUBrh7w
+BIWB4Bz0zv8A2ASlAoUkiIDhEvQohRzgNngkiM9wgAC0lxaIEHEB2cB5z3CAALAGIKAC2APwAdgD
+pTUGr/QB2OB48cDPcoAAAAYCgiWIgOEB2AXyCNkvonn/B/DPcYAAsAaqCqAAAKHbB4//4HjxwJoN
+r/SKIEwJz3aAAAAGJIaqC6/0pMEEhoDgofQChkiGJIBWeM9ygAC0lwQhgQ8ABgAAgOEB2XaKIBCN
+AMB5cHUJ9M93gAAotPqXtIrxdQPyAN0F8LKKsXH99QHdgOXPcYAAsAagoRX0z3GAALgGIJEwcw/0
+z3GAALoGIJF0ijBzCfTPcYAAvAYgiVKKMHID8gDZAvAB2YDhXfIngM9wgABEtC2gz3CAADCvQYDP
+cIAAqK4FgAUovgBAKYByEHHKIcYPyiLGB8ogZgHKI4YPAAD8AsokJgBQAabzyiUmAM9wgACEBgCA
+Fgpv/ThggOAD9Ln/SfAPyAQggA////8DDxoYMGgWgBAA3YDgpaYK9M9woAAsIBCAx3AHACChGaZk
+FgcQz3ABAOSfQMAF2EHAAd9Cx0PF6XAG2QTaANuYc7hz8gxv/9hzaB5CE+Sm6XAc8ADYAtkjpmge
+AhAW8ASGgeAB3RH0BYaA4Bv0z3CAAES0LYDPcIAAhAYAgIIJb/04YIDgBfIB2HkEr/SkwGgeQhMO
+DW//BdgA2ASmq/EF2A+mqXAK/wDYaB4CEO3x4HjxwOoLj/TPdoAAAAYEhoDgpMEN9CSG9gmv9Iog
+jAgChgSIgOAU9ALYBKYEhoHgSfQFhoDgOfTPcKAAsB8bgOIP7/07hoDgLPQA2DDwAN/lps91oADI
+HxWFz3GAAIQGKglv/SCBG6akFQcQz3ABAECgQMAF2EHAAd1CxUPH6XAG2QTa6XOYd7h3ACeHDwcA
+IKHyC2//2HekpqlwMPBSDG//BdgE2ALwBdiA4AHaA/QB2CTwK4aB4RDyUKYPpgzwBIaC4Bv0JIZG
+Ca/0iiCMCAuGgeAE9AHYD/CA4Ov1AoY+DO/9A4AIcc9wgADETX4MT/0A2Mv+3fEA2HDx4HjPcoAA
+AAYigiWJgOET8s9xgADgsN4RAwbPcYAAlLKEKwYPMCFBDlEhQIAF9AjYD6IB2AuiANgKogSiBdgD
+ouB+8cCyCq/0iiCMCc91gAAABiSFvgiP9ASFgOA/9CKFSIVAIQAHVnhEiM9wgAC4BgCQEHIB3g70
+z3CAALoGQJDPcIAAKLQakBByBPTEpQDYQPAEiYDgHvLPcIAAsAYAgIDgGPTPcIAARLQtgM9wgACE
+BgCAog8v/ThggOAM9IogTA1OCK/0iiFNBgDYzv8B2CDwxKUB2BzwBIWB4ADeGvQihc9zgAAcD0SB
+BYEc4UijCaNohc9wgAAotBqQdnkkiT4Nb/TJc8SlA9gDpQHYUQKP9AohwA/rcgXYiiPNDph2YQZv
+87hzz3CAAKxNIIAc2s9zgAAABkChQoNVIsEJIaCgEgEArbmgGkAAVSPBBaQaQACcEgEBaIMkoFUi
+QQ0joADZ6hpEAEAiAQd2eSWJoOEM9M9xgAC4BiCRSHSAJEQTIKwe2wPwGNtioFUiQQ15YZUFr/kl
+oM9xgAAwSUAhAANVIcIFUHBG9wDZBBhQAFBwvffgfuB48cA2CY/0z3CAAOCw3hADBkogACCC48oh
+xg/KIsYHyiBmAcojhg8AAOMHyiQGBJwFZvPKJcYAz3KAAAAGSIKEKwYPJ3CA4VZ4p4BH9M9wgACU
+STIKr/SKIQ8Pz3CAAExJIgqv9CDZz3ClAAgMAIBTIECAEvKB4BLyguAT8gohwA/rcgXYAduLuwok
+AAQ9BW/zCiUABP/ZB/D/2Qi5A/D/2RC5z3KgALRHHhpYgB0aGIAbGliDANmRuc9woADQGzGgz3CA
+AAAEEHhJGhiAbyBDAFQaGIAz8M9zoAC0RxsTAIaA4A7yCiHAD+tyGxMFhgXYENuLu9UEb/MKJAAE
+SxsYhAHYdxsYgADYnrhUGxiAiiTDf89zgADEdgpwqCBABApjz3WAADBJz3GAAJRJVX1HhfAhAQAB
+4FlhJ6VhAI/04HjxwPoPb/SKIAwKo8HPdYAAAAYkhQYOb/QA3gSFgOAn9N4MQAAB2ASlAoUEiIDg
+TAIBAM9wgACwBgCAgOA8AgIAz3CgACwgA4DPcoAARLQtghlhz3CAAIAGAIA4YAoL7/0MooDgFAIB
+AHTwBIWC4Dv0DoWA4MohwQ/KIsEHyiBhAcojgQ8AAKUDyiSBA/wDYfPKJcEAQoUohUAiAAc2eCaI
+YMEmiAEcQjAmiAIcQjAniGHBJ4gFHEIwB4iLcQYcAjC2Ce/0qBIAAM9woAAsICOAz3CAADBJIaDF
+pVb/A9gEpczwBIWD4Dn0QoUohUAiAAc2eAWIUSBAgRHyA5LPcaAALCAjgc9zgAAwSWGDCrhieTBw
+BfcJ2A+liPAFhYDgDfQEioDgqvLPcIAARLQ6Cu/9DICA4KLyBYWA4AbyBdgPpQHYCfDPcIAAsAYA
+gIDglvQA2O/+kvAEhYHga/RR/yKFSIVAIQAHVnhFiOC6F/KDukWoz3KAAEyMx4LPc4AARLTHo/eC
+w4L+Zsij9oLCgv5myaPBglWCXmbKowWIUSBAgCvyEgmP/YDgyiHBD8oiwQfKIGEByiOBDwAA9wPK
+JCEAyAJh88olAQECCa/9Atg2Ca/9CNgihQSJguAK9AHYAKUA2BOlHgmv/VrYIoUEiYHgA/QB2AGl
+CIUc4RZ5BYmGIP+MyiCCDwAAMEO4DOL/yiEiAAKFKIUc4DZ4BYiGIP6HBPIC2ASlKvAE2ASlJvAk
+hYThAdgi9BSlz3egAMgfPIfPcIAAMEkhoNILb/SKIAwKz3CAADBJDNl12h7btg9v9Bi7FYfPcYAA
+iAYuCy/9IIEHpcSlBNgDpQHY6QVv9KPA8cB2DU/0z3WAAAAGBIWA4Gr0AoUEiIDgE/LPcIAAsAYA
+gIDgDfTPcIAARLS6CO/9DICA4AXyANiV/i8DAADPdqAAyB88hs9wgAAwSQGASIUCeQKFVngHgBBx
+hvcB2ASlBwMAAACFgOAK8lEjQMAI8gLYFR4YkA4Ir/0e2BWGz3WAAAAGKgnv/SeFgODaAgEAFYbP
+cYAAiAZ+Ci/9IIEHpQKFKIUc4DZ4BYiGIP+MCfLPcAAAMEPPcYAATEnh/gKFKIUc4DZ4BYhRIECA
+mgIBAACFgOAF8h+GgOCOAgIA0vyHAgAABIWB4I30JIWuCm/0iiBMCs9xoAAsICOBngpv9IogTAoC
+hSiFHOA2eAUQhgAA3lEmAIDUpT3yz3KAADBJz3CAAEyMdoAigHlhz3OAAES06YPYqlQQBAAEEAUA
+ACUFASgTBADieQIlBQHngxwQBAACJMSDaIMDgGJ4yieBEwPyAd/4qoDhDvJALIMAcHGE908ngBAG
+8IDgBvJPJ0AQD38YqkEpwAA4YLBwQ/eCv/iqUSZAgCnyAIWA4A3yz3GgACwgJoEThSJ4z3GAADBJ
+BaHApQXwAYWA4APywaWa/IoMj/2C4A7yCiHAD+tyBdiKI5MJSiQAADEAb/MKJQABag5v/QDYAoUo
+hRzgNngFiIYg/4wE8gLYBKW38ATYBKWz8ASFguAL9M9wAAAwQ89xgABMSYv+BNgEpQSFhOCo9CSF
+eglv9IogTArPcKAALCAjgM9wgAAwSUAgEAc3oF4Jb/SKIIwNIoUgFQQQQCEABxYgAAEFiFEgAIAA
+3h3ySiTAcMlyyXOoIMAB8CDAIAHjGmID30okQHEA26ggwAHwIMAjAecbY1Bzx/fPcoAAMEkYioK4
+GKrPcIAARLTPoEyRQCRAAFBwCKVG920RAAZRIECABvIB2BCl9f1X8A+FlvwPyAQggA////8DDxoY
+MM+l+PyKIEwNxghv9Ioh1AoIhSKFFnmKIEwNsghv9CeBAtgDpQKFz3KAALAGJIiA4Q/0KIUc4DZ4
+JIjPcIAAtJcWiBBxAdjAeACiJvAggoDhBfIB2AOlIPAohTZ4J4DPcIAARLQtoM9wgAAwr0GAz3CA
+AKiuBYAFKL4AQCmAchBxyiHGD8oixgfKI4YPAABBBXgG5v8F2MSldQJv9AHYCiHAD+tyBdiKIxUD
+SiSAAI0GL/O4c+B48cD2CU/0z3WAAAAGBIWA4KHBQfQkhQIIb/SKIIwKAd7PcIAAsAbAoADYFKUq
+hQGlgOEApQLaHvTPcIAAtJfPd4AAuAbgl3aI8XMS9M93gAC6BuCXdIjxcwr0cojPcIAAvAYAiBBz
+BPREpQTwyqXJcYHhEPSaD2/zAtjPcoAAtJcUijaKQIK+DC/0AdvEpZ3wRKUEhYHgCfQkhX4PL/SK
+IIwKAtgEpQSFguAz9CSFag8v9IogjArPcYAAuAaKIIwMVg8v9CCRz3GAALoGiiDMDEYPL/QgkQKF
+BIiA4BfyC4WA4BX0z3KAAES0MIIPgg4hgw8HACChEHNH9wfYD6UB2BClC6UD8DhgD6ID2FzwBIWD
+4BD0JIUCDy/0iiCMCg/IBCCAD////wMPGhgwBNhM8ASFhOAd9CSF3g4v9IogjApTIMBAtg0gAByl
+z3CAAOCw3hABBs9wgACUsoQpBg8wIEAOUSBAgAXYyiChASzwBIWF4CD0z3aAAOCw3hYAFgTZmdoe
+20DAi3CGCm/0GLveFgAWhCgGDwAhgH+AAFSyMIChuTCgAdgLpQbYBKUA2A7wBIWG4An0BtgDpRyF
+gODKIGIAG3gEpQHYlQBv9KHA4HjPcIAAaKsogM9ygAAABi94geAL9ADbz3CgALQPfKAC2AOiZKID
+8AHYBaIdBi/0iiDMCOB4z3CAAES0OYDPcoAAAAYveIHgBfQE2ASiA/AB2AWi9QUv9IogzAjgeM9w
+gABoqyiAz3KAAAAGL3iB4AX0AtgEogPwAdgFos0FL/SKIMwI4HjxwKYPL/SKIEwNug0v9IohmAEP
+yADeBCCAD////wMPGhgwcgtv/8lwz3WAAAAGFoWA4JgJYv/KIGIA2Qcv9NWlAdnPcIAAAAYkoC0E
+T//gePHA3g8P/34ND/9iDk//0cDgfuB4OdnPcKUACAw+oOB+8cDhxQDdVglv/6lw2g4v/6lw3g9P
+/2oND//PcIAAgAWJBy/0oKDgePHAz3GAAHQGAIHXcACAAAAE9D4IT//Z8QCB13AAQAAADPTPcaAA
+sB87gQINL/SKIEwM6g8P/8nxx/HgePHA0g4P9IDhz3WAAHQGD/IApQGFgOAU9BoIb/MO2A4Kr/4I
+2AHYAaUK8ADewKUaCG/zDtiCCq/+CNjBpQEHD/TxwM9wAAAgTk4M7/zhxc91gAB8BgClz3AAALgL
+AaXPcAAAiBMyDM/8AqXPcA8AQEImDM/8A6UF2B4M7/wLuMkGL/QEpfHAz3CAAJAGA4CA4Bv0yg8v
+8xXYgOAX9M9wgAAwjAeIgOAR8s9wgAC4BGCAz3EBAGSkC9hgewTadg8v8xXY0cDgfs9xgABgygmB
+USBAgQf0xREABlEgQIEI8jIPb/YT2CoPb/YR2O3x6/HgePHA2g0v9AfYOg0AAM92oAC0D/yGGnAA
+2Bymz3GgACwgMIHeCy/0iiCRBVoIgAHPdYAAkAY2DWABAKVAhc9xgADAjQGlRaHWCqAEBqH8pnYO
+IAAKcBGNgeAk9ECFiiBEBM91gADcTSOFGmI4YBByAdjCIA4AgOAP8oogEQuCCy/0ANnqDeACBNgA
+hdoMYAEDpQbw6g3gAgTYAoUDpXoMwAKdBQ/08cA+DQ/01v/PdYAAkAYaC6ABB4UIdgeFEHYL8nIK
+IAHJcAIK7/bHpVIOb/YR2DYMQAHPcKAALCAQgHEFL/QCpfHAocHv/89wgACQBgCABNli2h7bQMCL
+cPoOL/QYu6HA0cDgfvHA4cXPdYAAkAYQjYwgw48O9M9wgADsTSWAI4EggcdxDwAAoDIOz/z+2BCt
+IQUP9PHA4cXPdYAAkAYGhRt45grv/CKFgOAF8gHYEa2Q/wEFD/TgePHA/9nPcIAAkAYwqOj/9P8z
+8eB48cBuDA/0CHd92A24z3GAAKiuxYGuCO/8yXGMIAKAz3GAAJAGAN2H9x14jCACgAHlfPcAKEID
+BSq+AxgZQA6A5xa4BaED9P/YEKkQiYwgw49ID8H/gQQP9OB+4HjxwBYMD/TPdYAA3E0ChSOFAd4Q
+ccB+qXCOCG/0A9lGCE/0gOYD8gKFAvAAhVUEL/QDpeB48cBWDS/zFdin/89xgABgygmBUSBAgQf0
+xREABlEgQIEE8v4Mb/YT2M9wgAC8BCCAYHkL2J8Fz//xwB4NL/MV2JMF7/8A2OB4gOAB2cB5z3CA
+AJAG4H8joOB+4HjPcoAAsAZhgoDhZXgBohHyz3GAALSXBJJ2iRBzFPQFknSJEHMQ9AyKMokQcQz0
+D8gEIIAP/v//Aw8aGDAPyIe4DxoYMOB+4HjPcoAAtJfPcYAAsAYEkXaKEHMM9AWRdIoQcwj0DIlS
+ihByBPQBgQPwANjgfs9ygACwBiGCBnngfyGi4HjPcYAAsAYAgYDgC/IBgYDgC/QPyAUggA8BAAD8
+A/APyJC4DxoYMLECD/zgePHAz3CAALDHAIBRIECALPRODC/zENiA4CT0z3KAALSXz3GAALAGBJF2
+ihBzEvQFkXSKEHMO9AyJUooQcgr0AYGA4Az0D8gFIIAPAQAA/ATwD8iQuA8aGDBSCg/80cDgft3/
+/vH88eB4D8iQuA8aGDA5Ag/88cCmCYACgOAH8s9wgABwBwCAhuAH9M9wgACwBgCAgOAD9ADYAvAB
+2ODx4HjxwCIKD/QIdwQikw8ABgAATCMAoAHdwH0EIoAPQAAAANdwQAAAAEoiQCDPdoAAuLQYjsIi
+giQQdRpxCfSA5QX0GY5ScAP0ANgC8AHYLyEHIOlwYgwgAalxIIYwdwDYB/QhhhJxzCEhoALyAdgv
+JgfwGq478gDZz3CgALQPPKBCDk/+6XAKcaly7gvgAUpzqgsgAKlw0P+A4Ab0MgtAADoIT/0E8GII
+T/3SDkAEAYbPdYAAsAYEtQCGBbUYjgyt+g5gBEpwBJXPcoAAHA8llRSyCIKA4dAgIQDPICIAubi6
+uAUgwAQIopUBD/TgePHAQgkP9M91oAC0D3AVEBDPcIAAHA8JgKLBUSBAgQDeC/IKIcAP63IF2Knb
+iiTDD6UF7/K4dot36XCiDS/0Atncpc9xqwCg/9mhB9gaodihABQAMQIUATFEIAICQiICgkEowwDK
+ImIAwLgiC+ABwLsAFAAxhiD/DUIgAILOCiAAyiBiAHAdABRBxulwCgpv9AjZFQEv9KLAANnPcIAA
+uLQhoH0Fr/YioOHF4cbPcaAAyBzIgQihBt0R8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB4Yb2MJf+f7fXJcMHG4H/BxeB4z3KsANQBANmtGliAqBpYgFjbz3CAADCM6BrAgACQh+DMICKC
+A/LsGsCAgRrYAIDbghrYAAXbgxrYAHPbvhrYgHTbCBrAgBgaQIC/GtiAd9sMGsCAA9scGsCAB9u8
+GtiAABrAgH/bEBpAgL0a2IAEGsCAFBpAgKoaWICrGliAAdusGliAkxrYgCnb8BrAgKrbdRrYAArb
+dhrYAHjb1BpAgJga2IAn25ka2IAg25oa2ICH4AHbwHuI4AHYwHgFIP6ABPIC2JsaGIB+GlgAfxpY
+AIAaWADgfuB4z3AAAAE/z3GqAPBDBaHPcAAAPj0Goc9yAAA9PUehiiDMDwihCdiMuAmhz3AAABYc
+CqHPcAAAHx8Loc9wAAAcFgyhkdgEuA2hz3AAAAM/DqFPoc9wAAA9PhChiiDEDxGh4H7geOHFz3Gg
+AMgcCKEG3RHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HhhvYwl/5/t9eB/wcXgePHA
+3g7v8wfYAN+P/xpwn//PdqQAuD2sFgAWz3WlANjLorisHhgQAdjspfYeGBDPcBUAKyuaHhgQ0gog
+AOlwiiDEAJ8eGBDPcIAAMIwAkAHZh+DAeYjgAdjAeAUgfoAT8hrY8x4YEPQeGBBk2MgeGBCq2Mke
+GBBp2MweGBDA2M0eGBA52c9wpQAIDD6gtf8KcM3/GNiVHhgQz3GAANxN4aHI2AKhAKEDoc9xAQB0
+pM9wgADIQdQYQACU2AulhQbP8/HAz3CAAAypYg/v84ohBA7PcIAAtJdWD+/ziiEFBdHA4H7geM9y
+gAAwjCeKgOEF9CaKgOEJ8s9xrACQAYDgA9jKIKEABaHgfvHA4cUIdSCQApVBlRC4BXop2BK4FSBB
+AEChIJXwIEEAMHIO8tYL7/OKINEDApUhlRC4BXnGC+/ziiDRAxUGz/PxwOHFCHUgkAKVQZUQuAV6
+FdgTuBUgQQBAoSCV8CBBADByDvKWC+/ziiDRAwKVIZUQuAV5hgvv84og0QPVBc/z8cDhxQh1IJAC
+lUGVELgFeivYErgVIEEAQKEglfAgQQAwcg7yVgvv84og0QMClSGVELgFeUYL7/OKINEDlQXP8/HA
+Hg3P8yh2gODMJiKQDfQKIcAP63IF2IojBgWKJMMPiQHv8rhzUyZ+kMohwg/KIsIHyiOCDwAAlgHK
+IGIB8PVBgCCGooBYeUCAJH0p2RK5FSGCAKCiAIDwIQEAMHUL8toK7/OKINEDiiDRA84K7/OpcRkF
+7/MEbvHApgzP8yh2gODMJiKQDfQKIcAP63IF2Iojhg6KJMMPEQHv8rhzUyZ+kMohwg/KIsIHyiOC
+DwAAvAHKIGIB8PVBgCCGooBYeUCAJH0V2RO5FSGCAKCiAIDwIQEAMHUL8mIK7/OKINEDiiDRA1YK
+7/OpcaEE7/MEbvHALgzP84DgSHXL9wh2QIVhvmB6BG2A5ghxEOU5930Ez/PgePHA4cWKIFIOHgrv
+84HZz3WAAAROqXBAJYEVegkv9BbaAdhdBO/zMR0CEOB48cDWC8/zCHaC4Mohxg/KIsYHyiBmAcoj
+hg8AAFwAyiQmAEgA5vLKJcYAz3WAAAROC4UAJo8fgAAgThB2BPQUj4DgOfL6Cu//BdgacIogEg6q
+Ce/zyXFELr4VACVAHkCQIZAIukV5z3KkALg9mxpYACKQyhpYACOQyxpYACSQxBpYACWQxhpYACaQ
+xxpYACeQwhpYACiQwxpYACmQxRpYAAqQoxoYABoM7/8KcMulANgUr4kDz/PgePHA4cWmwYogkg06
+Ce/zktmLcKYP7/MG2QAUADGA4BT0QCSAMM91gAAETqlxgggv9BbaAdgwHQIQC4WA4AwP4f/KICEA
+ABQAMYHgGPSKININ8gjv86PZQCSAMM91gAAETkAlgRVKCC/0FtoB2CuFMR0CEIHh1A7B//oOz/Md
+A+/zpsDgePHAngrP889ygAA4TgGCFhKEAAkkBABMJACABfJMJACCy/cKIcAP63IF2IojCAUBB6/y
+SiUAAgDbaqJMJACAa6Jsotf3aHdodWhxEmkUeB5i04YB4d9nHmLUhlhgFYDbYy95kHEdZayisfdr
+ouqimQLP8+B48cAqCu/zmHDPcYAAOE5siQDdQCECCkokwHDgeKggQAMRI0CDB/TPcP8A//8VIkwD
+AKQB5a99a4GqgXB1DIHV9hB1z/YQcwLbyiApAMolaRDKI2wAyiAsAMolrBAU8AHbAtgA3RDwEHPL
+9hB1AN3KI6kAyiBpAAj2AdgC3QPwAtgB3QDb8CLPAPAiRQPwIgAAAiXOA82hAiBAAQ6hANgPIMAA
+PBkCAA8gQAM9GQIA5QHv8wAcwgDgePHAcgnv84ogEA2hwc9xoACwHzuBAN5+D6/zYMau/4twyv/P
+dYAAOE6wFYIQgOJAJQEaBPQUjRDwIMB6jfAhDwABhQUo/gA3dzb2AdgUrbAdghPJcoDizCBhgBD0
+IMLwIYMAIYVajQUpvgA3c8b2AtgUrQHZsB1CEIHgG/KC4A/yg+Ai8gohwA/rcgXYiiNLCIokww9t
+Ba/yuHMBhTmNBSk+AA2FN3AF9z0VgBAH8LEVgBCA4Pr1PBWAEDNoJXgPeQ2tEPABhTmNBSk+AC2F
+LyBADhBxLfcuhTBwqPc/2S2tFY2B4AzyguAa8oPgC/IKIcAP63IF2IojjAHM8TwVgBAQ8AGFWY0F
+Kj4ATYUvIEAOEHIG906FUHA/2Eb3PRWAEFNoRXgOrW4Or/OKIBANLo0NFYUQD40FIUEBJXiGIP8B
+DBWEEEO4CyQAgMohwQ/KIsEHyiOBDwAAFAOoBKHyyiBhAQYgPoHKIcIPyiLCB8ojgg8AABUDjASi
+8sogYgFdAO/zocDxwOoPr/NKJEAAGnDAuIHgwiQCAQpzhiP+A0S7CnCGIPEPR7hEIIIjXHpIcc91
+gAA4TkytBCCOLwAAAAxKvrh21K0EII4vAAAAMEy+1a0EII8vAAAAQE6/sR3CE1MivoDKIcEPyiLB
+B8ojgQ8AAEMByiBhARzyTCQAgCnyBCECAFBwyiHCD8oiwgfKI4IPAABNAcogYgEM9AQgwgBQcw7y
+CiHAD+tyBdiKI4UDiiTDD80Dr/JKJQAAgONB9AohwA/rcgXYiiPFA/Lxg+YD9oDmCPYKIcAP63IF
+2IojRQXo8bB2hfZMJQCACPYKIcAP63IF2IojBQbc8VMiBABEIo8ALybBAwAkhAGGIv8OQrqAck96
+sHJD9lStuHLRckP2Va1IdoLiRPYA2rEdghCwdlGNBfSA4gPyBNpRrdGNgebMJiKQzCYikQb0U2kl
+ek6tTa2A48wmIpEF8lNrZXpNrYDgzCYikQTyU2hFeA6tE2kleA+tDY0QrUIIb/gA2NEGr/M+HQQU
+8cBuDo/zz3WAADhOEY2A4Bzy0g+v8hTYAN7RrdKtz3CAABwPDZCW/89wgAAwjAeIgOAL8oog2Amr
+2VIMr/MEuRYLb/YC2N+1iiCQDD4Mr/OKIQwOhQaP8/HAAtjPcYAAOE4RqRKJRSBAAhKpD4lQiRBy
+BvIQqb4PL/gB2NHA4H7xwALYz3GAADhOEakSiYC4o7gPeKG4EqkNiVCJEHIG8hCpkg8v+AHY6vHg
+ePHAug2P8892oACwHxuGAN/PdYAAOE5TIFAFAtgRrTuGvguv84ogEAoPjeCl4aXipYYg/wFbaA6N
+rB3AEwHZhiD/AUO4EHIyrQP0BdkyrQeFEnDP94G5Mq3V/89xgADAjRSBAeAUoTuGiiDQCgXw2v87
+hoogUAxqC4/zpQWP8+B48cAD2c9wgAA4TjGoANkyqC2IUIgwcgbyMKjuDi/4AdiY8eB48cAWDY/z
+CHfPcIAAHA8JgM91gAA4TiW4UyAQAB+VEHdT8oogkAkWC6/z6XERjQHe0a0TrelwPv9RJwCQBPQR
+jYTgC/TPcQICAgLyCq/ziiCQDJj/UvATjYDgANky9NGtrB1AEDKt1q3XrQrYGK0F2lmtUNgarQDY
+jrgIpQmlB6UD2EAdAhAE2EEdAhBCHQIQQx2CEEQdghBFHYIQBthGHQIQRx0CEEgdAhBJHQIQCNhK
+HQIQDNhLHQIQMti4HQAQsB1CEKb/EY2A4BjyCMqQ4BT0TCAAoBLyDI0zaCV4Dq0Nrc9woACwHzuA
+uBUAEDa5OGC0HQAQuv+BBI/z8cAeDI/zz3WAADhOFo0hhRBxR/cXjSKFEHFiAAUALYXPcIAAeE4v
+YKH+z3CAADCMB4iA4Avyz3EAALCwAgqv84og2AnGCG/2AtgA2A2lDqUApQGlAqWsHQAQz3agALAf
+O4beCa/ziiBQCp7/G4Y2uB9nyb+0HcATIvASjaG4OI1AhTByz3agALAfEq2G92D/O4aKIJAKEvA7
+hkeF1blQcUj3gbgSrVr/O4aKINAKBvBh/zuGiiBQDIYJj/PJA4/z8cDWDK/yFNiKINAHcgmv80fZ
+z3KAADhOMYqA4SDyz3CAANiuAoBCIACAyiBiAC8mB/AW9IPhEfTPcKAAsB87gLQSAAA2uSJ4ybiM
+IMePyPdU/yEFz/+7/xkFz/8VBc//8cDhxc91gAA4ThKNUSAAgQnyDY0QrbIML/gB2BKNpLgSrVUD
+j/PgePHA1gqP8892gAA4ThKOUSAAgFPyz3KAALShPoLmuQv0AJKGIPwAjCACgEf0USEAgkPyAIYB
+4ACmD46GIP8BlhKNAEO4sXA59ADZrBYFEEokwHBSEgQBqCDABc9wgAAAojR4YIgRJUCQQCQPC0At
+gAAUeDV42GAF8uDjwifFEPOgAeFAJUAAwrisHgAQAYYB4AGmAJKGIPwAjCACgAT0AoYB4AKmiiDQ
+B04Ir/OKIZMBiguv8hTYiQKP8+B4o8HhxULBCRSBMEPCg+FBwADYCvaA4cj2ChSBMIDhxPaD4cP2
+AdgHFIIwBhSDMFBzBvIiwTBzzCJCgAP0AdghxYHlEPQKFIEwI8NwcUr2CxSCMFBxzCOqgIT2gOLK
+IGkAgeAN9IohyQ/PcIAAwAYgoIHl/9nKISIAIaDBxeB/o8CjwUDAQcEFFIEwANiB4ULCDfKC4Qfy
+g+EN9CHBANgPIEAAAxSBMA8gQAACFIEwDyBAAAYUgTCB4Q7yguEH8oPhD/QhwQPhDyBAAAMUgTAD
+4Q8gQAACFIEwA+EPIEAACRSBMIHhDvQCFIEwCrlPIQIEAxSBMAy5JXohwQ65RXkleCDBgeEI9AcU
+gTAiwga5CLpFeSV44H+jwD0Hj/PxwPoIj/MacM9wgAA4ThCIz3aAALi0hiD/ATtoBYYOIECAz3GA
+ADCMJ4nKIGIAgOEi8jqOgOHMICGAHvIA3QzfEm0VeMdwgABoViCAgOEG8gKAgOAV8kB4Yb+A5wHl
+MvcA2Bquz3CAADhOEIiGIP8BQ7gFprIMr/8KcOUAj/MKIcAP63IF2DvbSiRAAAEFb/K4c+B48cAA
+FoVApsFMJQCFABxCMUT2TCUAgkv2CiHAD+tyBdiI29kEb/JKJEAAABaAQAEcAjAAFoBAAhwCMAAW
+gEADHAIwi3BSD+AAgcECwoDiDPQKIcAP63IF2JLbiiTDD50Eb/K4cwTAYHoFwQPBgOHKIcEPyiLB
+B8ojgQ8AAJYABdjt8wHAgODiIEIAMgyP86bA0cDgfuB+4HjxwMoPT/M6cBt9z3CmAJw/ZBAQAFEg
+AKAm9APeEfDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG+jCb/n+31Yb2MJf+f3/UK
+IcAP63IS2FrbCiRABAUEb/IKJQAExQdP8/HAbg9P8891gADIBgKFUSAAgBb0ug5v/wfYfghgAAh2
+KgpAAGYLQACmC0AAWglAAB4Ir//JcAKFgLgCpZ0HT/PxwOHFz3WAAMgGAoVRIECADPQWDoAAIgnP
+80IOAAN6DsAAAoWBuAKleQdP8/HAAg9P8891gADIBgKFUSCAgC70z3CAADCMB4iA4Cjyz3OgAMAv
+E4P6uAb0EINRIACADvT8EwUACiHAD+tyBdiKI0cBSQNv8ookwgQWDm//B9gSDuAACHaWDoAA9g3A
+AIIPb//JcAKFgrgCpQEHT/PxwM9zoADALxOD+rgF9BCDUSAAgA30/BMFAAohwA/rcgXYiiNHAfkC
+b/KKJMIPvv/N/89wgAAwjAeIgOAE8kIIQADU/9HA4H7PcawA1AGxEQCGo7ixGRiAshEAhqO4shkY
+gLMRAIajuLMZGIAC2J8ZGICgGRiAoRkYgAHYohkYgKMZGICkGRiApRkYgKYZGICnGRiABdj4GQCA
+/BkAgACh4H7geM9wqwCg/ziAz3KAAMgGIKI5gADbIaJ4oHmgP9k6oOB+8cDCDU/zOnAB2M92pwAU
+SAimAgqgACpwgOAA3ypwBvRKIEAj2P8I8GIKoAAad0oLoAAqcOv//9ibuM91pwCYRxyliiASDaYL
+b/Mqcc9xgAAQBQCJgODKIcIPyiLCB8ogYgHKI4IPAADtAsokIgDsAWLyyiUCAQHYAKn2pi8gAASA
+uBqlz3CgACwgMIDPcIAAFAWRBW/zIKDxwOHFocG4cADYQMBTJYAAgeAQ8oLgHfKE4CLyCiHAD+ty
+BdiKI4oOmQFv8ookgw/PcIAAMIwEkAHZz3WAAIuohODAec9wAAAi0jR4DvDPcAAAI9LPdYAAjqgI
+8M9wAAAk0s91gACRqCnZErnwIQEADiGADwABAACqCuAAQMBAwItwqXE6Cq/zA9ohBW/zocDxwJ4M
+T/PPcKYAnD8ZgFEgAIBU8s92gAAcD4QWABAvKAEATiCQB0Eo0CBMIICgCfcAII0vgACMDxSNgOAN
+9AohwA/rcgXYiiOMA4okgw/lAG/yCiUABM93gACAqEAnwBKKDW/zCdkA2IIIoAAPIAAEgOAA2A8g
+AAQD9L7/A/CSCYAAA8gA2bkQgAAbeIC4Cq8UjWG4D3gUrYogUg0mCm/zDyEBBIQWARDPcIAArJg2
+oM9wgADcyiKgsgpAAEUET/PPcQEAOMbPcgEAxMb1A+/zANjgeIDg8cC4cQv0CiHAD+tyBdjj200A
+b/KKJIMPz3GAANS0IIFMJQCABCGBDwAHAABBKQMGANnKJE1x4HjoIK0D8CBFAAQlgg8BAADALrpl
+elBzBPQB4TEFz/8KIcAP63IF2Ozb/Qcv8kokQADgeM9wgAAcDwiAz3GAANS0USAAgATyAYkD8AKJ
+4H8AqeB4CHFYiQGAgOICoQn0WYmA4sIgogDAIKEAAqHgfvHAJgtP86LBooFgkM92gADIBrh7o4Fk
+fWOGpXumgQGQuHingWOmpHikhkAhDwSA4qV4BKYc8gGBAhzEMDC7BBzEMAAcBDAggYt1YHmpcAGH
+JIYCHEQwMLkEHEQwIIcAHAQwYHmpcADYA6YEpiEDb/OiwOB48cCeCk/zocEAFo1AABaPQAAWAEEC
+Cm//B9gacILlBtkD9Pt5B+EFzAPhBCGBDwAA/P/XcAAAAEAB2MIgCgAXuMdwAA4AACV4nbifuOxx
+AKECEgE27HAgoOxwoKjPdqAAyB9RFhGWAdlRHliQINgQpkMeWBAA2DYOb/ONuCDYEaaH5ZYBDQAy
+Jk1zgADEd0AngHK0eAB4ABYBQAAWAECAuc9woADsJyagqfCA504BDgAAFgBBABYBQQAcRDAAFgFA
+GgsgAGG/ABQBMQa4gbgQuSV4z3GgAOwnBqGA5yr3j/DscOCogOcWAQ4AABYAQAAWAUDqCiAAEHgG
+uEUgwgDPcKAA7CdGoAqAi3EAsQAUATHscCCwYb+A5yn3cfAAFgBAPg4AAM9xoADsJwuhABYAQGXw
+gOfGAA4AABYAQAAWFEBBKBMEEHiWCiAAWnAGuEUgwADPdaAA7CcGpQqFi3EAsQAUADEGIMAEBSAA
+BQAcBDBqCiAASnAAFAExBriBuBC5JXgGpWG/gOewB83/N/CA52oADgAAFgBBABYBQQAcRDAAFgFA
+NgogAGG/ABQBMQa4RSCAARC5JXjPcaAA7CcGoYDnKvcb8IDn2fcAFgBBABYBQQAcRDAAFgFAAgog
+AGG/ABQBMQa4RSDAARC5JXjPcaAA7CcGoYDnKfdRHliUmglv/wpw1gxv8wHYANh0HhiQ4QBv86HA
+CiHAD+tyBdiKI0YFSiQAAB0FL/IKJQAB4HjxwHYIT/MAFo1AABaQQAAWAEHWDy//B9g6cILlBtkE
+9EAgwSEFzAPhBCGBDwAA/P/XcAAAAEAB2MIgCgAXuMdwAA4AACV4nbifuOxxAKECEgE27HAgoOxw
+oKjPdqAAyB9RFhKWAdhRHhiQIN/wpkMeGBAA2AYMb/ONuPGmheXWAA0AMyZNc4AAzHdAJ4BytHgA
+eAAWAUDPcKAA7CcmoFHwTCAAoJoADgAKJAB04HioIEACABYBQM9woADsJyagQfDscAAYAgRMIACg
+dgAOAAokAHTgeKggwAIAFgFAz3CgAOwnJqAqgOxwIKgr8AAWAUDPcKAA7CcroCPwTCAAoMokDXTg
+eOggbQcAFgNABCOBDwAAAP8ouVZpRSLNAM9xoADsJwQjgA//AAAApqGqgTC4OLuBugZ9pXsQu2V6
+RqFRHpiUJghv/ypwYgtv8wHYhQcP8wohwA/rcgXYiiMIB0okAACxAy/yCiUAAeB4AtjPcawA1AGf
+GRiAoBkYgKEZGIAB2KIZGICjGRiApBkYgKUZGICmGRiApxkYgAXY+BkAgPwZAIAAoeB+4H7geAHZ
+z3CgAMgcMKBL2c9wpAAcQCSg4H7gePHAqg4P8zpwGnFKI0AgwJAl8Ol2I/AVIcAk4JACEBIBQCNT
+INd3AAD7/y8jyCRz9td2AAD//x7yTCAAoMwmgZ8AAP7/FvJMIECgzCaBnwAA/f8Q8kwggKAI8s9w
+AAD7/xB22/WZBg/z13YAAPz/9/XPdaAAyB9RFRSWAdlRHViQINgQpUMdWBAA2C4Kb/ONuCDYEaUG
+v4G/QCoAJOV4z3GgAOwnBqFRHRiV2fHxwM9wgAAwjEaAguIqkAb0z3CAAABTBfDPcIAAFE/O/y4O
+AADeDgAA0cDgfvHA4cXPcYAAMIwEkc9ygADUtIDgANtgohHygeAn8oLgPvIKIcAP63IF2IojywpK
+JEAARQIv8kolAAAH2Bi4AKJhqmKqSiTAcGhwqCAAAwDbjrsWIg0AYaUD2w67YqUB4APYBrEHsQDY
+F/AA2Jm4AKJS2AGqSiTAcAKqqCCAAgDdj70WIsAAoaCioAHjUtgC22axAdtnsckFL/MAqgDYmLhK
+JMBwAKKoIIACAN2OvRYiwAChoKKgAeNh2AGqUtgCqufx4HjxwB4MYAChwc9wgAAwjEeIgOIA2Y/y
+ABxEMM9zoADALzOD+rkF9DCDUSEAgA30/BMFAAohwA/rcgXYiiNHAXUBL/KKJEwAA9vPcqAA7Cdm
+omqCi3FgsQAUBTGodIQkA5DKIcIPyiLCB8ogYgHKI4IPAAAIAzwBIvLKJGIARCUDDES7ZLBEJQMD
+QrsvJsfwa6gD9AHba6hD22aiaoJgsQAUBTEUGEQBTCUAgMwlYoDMJaKAyiHCD8oiwgfKIGIByiOC
+DwAAHAPsACLyyiRiAIPbZqJqgmCxABQFMVMlgwBosIfjzCMigMwjooHKIcIPyiLCB8ogYgHKI4IP
+AAAmA7QAIvLKJGIAiiPSAGaiSoJAsQAUBTFTJYEAh+EpsA/yCiHAD+tyBdiKI0wLiQAv8kokQAAk
+sAfZKLApsKHA0cDgfvHAz3CAADCMBoCA4BHygeAW8oLgFvIKIcAP63IF2IojDQRKJAAATQAv8gol
+AAGA2c9wgADUtMUF7/8noADZ+vFA2fjx8cDPcIAAMIwEkIDgEfKB4MwgooAR8gohwA/rcgXYiiPO
+DEokQAAJAC/ySiUAAM9xKhUVKgTwz3EqKhUVz3CAABwFdQXv/yCg8cDPcYAAMIwkkYDhRfKB4Q/y
+guEw8gohwA/rcgXYiiNPCUokQADBB+/xSiUAAAQggQ/z///PBCGADwMAAAACuAUhAgAEIYEPAAAA
+DAQggA8AAAAMJXjPcYAAHA8ogQK4USEAgEV4GfQHIIAPDwAAAP0Ez//PcYAAHA8ogVEhAIAL9AQg
+vo8MAAAA0iCiBOAE4v/SIOIE2QTP/+B4ANnPcKAA7CcroOB+4H7gePHAqgoP889xoACsLxiBz3Wg
+AMgfIN6auBihBdjQpUMdGBAA2H4OL/ONuNGlA98S8OB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB4Yb+MJ/+f7vXPcaAArC8YgbO4urgYoWTY0KVDHRgQANgyDi/zjbjRpdClCthDHRgQANgi
+Di/zjbjRpYkCD/PgePHAFgoP8wh3z3WgAMgfURUQlgHYUR0YkCDe0KVDHRgQANjyDS/zjbjRpSCX
+AZcGuYG5ELgleM9xoADsJwahUR0YlDkCD/PgePHA0gkP8891oADALxOFz3agAMgfIN+zuLq4E6Vk
+2PCmQx4YEADYpg0v84248abwpgXYQx4YEADYkg0v84248aYThfq4BfQQhVEgAIAN9PwVBRAKIcAP
+63IF2IojRwEFBu/xiiRNCuIKj/9yDM/+BMiE4Az0z3GAAGDKSIE0kVMiAACeDO/yAduxAQ/ziiBX
+B2EH7/KKIY0G4H7geADYz3GsANQB+BkAgPwZAIAAoaUZGICmGRiApxkYgKIZGICjGRiApBkYgJ8Z
+GICgGRiAoRkYgM9wgADIBgCAixkYgM9wgADMBgCAjBkYgLERAIaDuLEZGICyEQCGg7iyGRiAsxEA
+hoO4sxkYgOB+4HjxwMYIL/MB2M92oADIH1EWD5ZRHhiQIN2wpkMeGBAA2J4ML/ONuLGmz3CAAMcg
+z3GgAOwnBqHPcIAABzoGoc9wgACHUwahz3CAAIckBqHPcIAAxz0Goc9wgABHVwahiiCKAAahiiCL
+AAahiiCMAAahz3AkAAcBBqGKIIUABqHPcAMAByEGoc9wAwDHJAahz3AEAEdLBqHPcAMARzoGoc9w
+AwAHPgahz3AEAMdkBqHPcAMAx1MGoc9wAwCHVwahz3AEAMcxBqFRHtiTZQAP8+B48cD6D8/yz3aA
+ABAFAI6A4A3yAN3PcKcAmEe6oKn/xf/PcKcAFEiooKCuPQAP8+B48cDGD+/yAdjPdqAAyB9RFg+W
+UR4YkCDdsKZDHhgQANieCy/zjbixps9xgAAGIc9woADsJyagz3GAAEY6JqDPcYAAxlMmoM9xgADG
+JCagz3GAAAY+JqDPcYAAhlcmoFEe2JPPcacAiEkA2BChwQfP8s9wgAAHIc9xoADsJwahz3CAAEc6
+BqHPcIAAx1MGoc9wgADHJAahz3CAAAc+BqHPcIAAh1cGoUnZz3CnAIhJMKDgfuB48cAOD+/yAdjP
+dqAAyB9RFhCWUR4YkCDdsKZDHhgQANjqCi/zjbixpsfYlLjPd6AA7CcGp89wAwCCKwanz3ADAMJE
+BqfPcAMAQl4Gp89wAwACLAanz3ADAEJFBqfPcAMAwl4Gp89xAADCdM9wAwDCdAanz3ADAIJvBqfP
+cAMAgmwGp8bYkLgGpyansKYK2EMeGBAA2HYKL/ONuLGmz3AAAIJvBqewpgrYQx4YEADYXgov8424
+sabPcAAAgmwGp7CmCthDHhgQANhCCi/zjbixps9wAAACLAansKYK2EMeGBAA2CoKL/ONuLGmz3AA
+AEJFBqewpgrYQx4YEADYDgov8424sabPcAAAwl4Gp7CmCthDHhgQANj2CS/zjbixps9wAACCKwan
+sKYK2EMeGBAA2NoJL/ONuLGmz3AAAMJEBqewpgrYQx4YEADYwgkv8424sabPcAAAQl4Gp7CmCthD
+HhgQANimCS/zjbixps9wEwDGAAansKYy2EMeGBAA2I4JL/ONuLGmUR4YlOkFz/LgeFEgAIDPcoAA
+3AYL8oDhUdjAKCIEyiBhBMAoIQQC8ADY4H8AovHAXg3v8gHYz3WgAMgfURUPllEdGJAg3tClQx0Y
+EADYNgkv84240aXPcAAAwizPcaAA7CcGoc9wAAACRgahz3AAAMJfBqFRHdiTfQXP8uB48cAODc/y
+z3GgAKwvOoFSIQEAUSEAgD70gOAe8iDdeP/PdqAAyB9RFg+WAdhRHhiQsKZDHhgQANjOCC/zjbix
+ps9xBgACdc9woADsJyagUR7YkwTwLg5P/892oADIH1EWD5YB2FEeGJAg3bCmQx4YEADYlggv8424
+sabPcIAAHA8PgM9xoADsJ4C4BqFRHtiT5QTP8vHAdgzv8gHZz3WgAOwnJqWA4M9yoACsLxL0GILP
+daAAyB8g3pq4GKIF2NClQx0YEADYQggv84240aVC8BWCUSAAgMohwQ/KIsEHyiBhAcojgQ8AAE0A
+yiTBALAA4fHKJcEAz3DAAEdoBqXPcBMAxwAGpc9wEAAGaQalIN/H2JW4BqXPdqAAyB9RFhCWUR5Y
+kPCmQx5YEADY2g/v8o248abPcAAAQi0Gpc9wAACCRgalz3AAAEJgBqVRHhiUHQTP8vHA2HBTIIEA
+z3CAADhzKGCB4A7yCiHAD+tyBdiKI4cIiiSDDyUA7/EKJYABz3GAADCMCBEFAUwlAIAM8gohwA/r
+cgXYiiMHCQEA7/GKJIMPz3CAABwPCIBRIACAC/QIkYDgB/KG4Af0USYAgAPyANgC8AHY0cDgfrhw
+wriB4PHAD/KC4CPyhOA38gohwA/rcgXYiiMEBLUHr/GKJIMPz3CAABwPCIDPcaAA7CdRIACAyiCC
+DwMABiHKIIEPAwDGJAahz3AEAEZLLPDPcIAAHA8IgM9xoADsJ1EgAIDKIIIPAwBGOsoggQ8DAAY+
+BqHPcAQAxmQW8M9wgAAcDwiAz3GgAOwnUSAAgMoggg8DAMZTyiCBDwMAhlcGoc9wBADGMQahqvHx
+wKHBz3GAABwPKIEvKAEAwLkAIYMPAAAi0k4ggQcp2BK48CDAAM9ygACLqDR5WWFAwItw7g/v8gPa
+ocDRwOB+8cBOCs/yGnDPdaAAyB9RFRGWAd5RHZiTIN/wpUMdmBMA2C4O7/KNuPGlz3AsAAYBz3Gg
+AOwnBqFTIIAggeAS8oLgLPKE4EfyCiHAD+tyBdiKI8cFiiSDD40Gr/EKJQAEz3CAABwPCIBRIACA
+yiCCD4AAxiDKIIEPgACGJAahz3ADAMICBqHPcEgAQgEGoc9wpwAUSNegO/DPcIAAHA8IgFEgAIDK
+IIIPgAAGOsoggQ+AAMY9BqHPcAMAAgMGoc9wSgBCAQahAtnPcKcAFEg3oB3wz3CAABwPCIBRIACA
+yiCCD4AAhlPKIIEPgABGVwahz3ADAIICBqHPcEwAQgEGoc9xpwAUSADYF6FRHViUoQHP8uB4gLjP
+caAA7CcGoeB+CdngfyCg4HjxwJ4JL/Mo2AhxhiH8AyS5z3KAADCMILJEIAEDIrkhssG4yQXv/wKy
+8cDhxXIJL/MA2EEoAQLAuc91gAAwjCatKbjAuAetWgkv81DYwbhZAe/yBqXgfuB48cDWCO/yAdjP
+dqAAyB9RFg+WUR4YkCDdsKZDHhgQANiuDO/yjbixps9wIAAGAc9xoADsJwahz3BwAIICBqFRHtiT
+/QDP8uB4z3EgAAcBz3CgAOwnJqDgfuB+4HjgfuB4z3CAAAxW4H8TgOB48cBmCM/yCHcacQHZz3Cn
+AJhHOqAg3s91oADIH9ClCthDHRgQANg+DO/yjbjRpc9xpwAUSAyBgOAD9D6BAvA9gQAYQCD3ucUh
+gg8A/wAA0yHhBXkA7/Igp/HACgjP8s9wgAAwjAeIgOCeAiEAosHPcKAAyB9REBCGAdlRGFiAINkw
+oAHZQxhYAADY2gvv8o24INnPcKAAyB8xoDYPr/4F2M91gAAMVg6lw9jPdqAA7CcGpgqGz3enABRI
+ALWKIMQABqYKhgG1iiDFAAamCoYCtYogywAGpgqGA7WKIM8ABqYKhgS1z3AAAIMNBqYKhgW1z3AA
+AMMNBqYKhga1z3AAAAMOBqYKhge1CIcEpQ2HBaUOhwalz3CnAJhHPIAnpTeHKKU2hymlz3GlAAgM
+IoEqpc9xqwCg/ziBK6XPcasAoP85gSylz3GrAKD/OoEtpc9xBQDGAyamxtmQuSamz3EsAAIBJqbP
+cVoAQgEmpoohiwAmps9xQACHDSamz3HRAMINJqbPccAABw4mpgHZKKcA2S2nLqfPcVAA/wA8oAHY
+F6cA2BanUNnPcKUACAwioPzZz3CrAKD/OKBz2TmgGoDPcasAoP+BuBqhz3AqAAIOBqaLcIHBi/8A
+wc9wgAAAmzSlMqABwS+gz3AaAAIOBqaLcIHBhP8Awc9wgAAAmzWlM6ABwTCgz3AmAAIOBqaLcIHB
+fP8Awc9wgAAAmzSgNqUBwTGgz3CgAMgfURARhgHZURhYgCDZMKAB2UMYWAAA2CYK7/KNuCDZz3Cg
+AMgfMaABlRC4hSCEAAamApUQuIUghQAGpgOVELiFIIsABqYElRC4hSCPAAamBZUQuAUggA8AAIIN
+BqYGlRC4BSCADwAAwg0GpgeVELgFIIAPAAACDgamz3CgAMgfURhYhASFKoUIpwWFgOENpwaFDqcI
+hRenCYUWp89wpQAIDCKgDvIEEgQ2AhIFNgohwA/rcgXYHQKv8YojRAILhc9xqwCg/xihDIUZoQ2F
+GqFaDq/+DoXPcKAAyB9RGBiEvQWv8qLA8cBWDY/yz3CAADCMJoiA4c91gAAMVqLBBPIHiIDgBvQj
+AyAASBUEEAPYGnCKIJEFAN9OC6/y6XGKDK/+BdgOpcPYz3agAOwnBqYKhgC1iiDEAAamCoYBtYog
+xQAGpgqGArWKIMsABqYKhgO1iiDPAAamCoYEtc9wAACDDQamCoYFtc9wAADDDQamCoYGtc9wAAAD
+DgamCoYHtc9wpwAUSCiAJKUtgA6AJaUGpc9wpwCYRzyAJ6XPcacAFEhXgTaBSKUppc9xpQAIDCKB
+Adoqpc9xqwCg/ziBK6XPcasAoP85gSylz3GrAKD/OoEtpc9xBQDGAyamxtmQuSamz3EsAAIBJqbP
+cVoAQgEmpoohiwAmps9xQACHDSamz3HRAMINJqbPccAABw4mps9xpwAUSEih7aHuoc9xUAD/ADyg
+z3CnABRIV6D2oFDZz3ClAAgMIqD82c9wqwCg/zigc9k5oBqAz3GrAKD/gbgaoc9wEQAGDgami3CB
+wd/+NYUAwCJ4hCiEAxSFNoUCeUoIb/svcAHCgiDEAs9xgAAAmxKlFqFVoc93oADIH1EXEZYB2FEf
+GJAg2BCnAdhDHxgQANiaD6/yjbgg2BGnz3BAAIYNBqbPcBAAAg4GplEfWJSLcIHBxf41hQDAIngE
+KIAPAAB0CRSFNoUCed4PL/svcAHCT+DPcYAAAJsTpRihV6FRFxGWAdhRHxiQINgQpwHYQx8YEADY
+Ng+v8o24INgRpwGVELiFIIQABqYClRC4hSCFAAamA5UQuIUgiwAGpgSVELiFII8ABqYFlRC4BSCA
+DwAAgg0GpgaVELgFIIAPAADCDQamB5UQuAUggA8AAAIOBqZRH1iUJIXPcKcAFEgooCWFLaAmhS6g
+KIU3oCmFNqAqhc9wpQAIDIDhIqAs9AuFz3GrAKD/GKEMhRmhDYUaoYYLr/4OhTKFjCGCgEX2jCG/
+iEwACQAg2BCnCthDHxgQANh6Dq/yjbgg2BGnmf6KINEFkgiv8jKFQiBAIIDgMgXN/xLwBBIENgIS
+BTYKIcAP63IF2N0Gb/GKI0QCZgiv8oog0QVIFQQQjCSCgET2jCS/iAv2CiHAD+tyBdiKI8QOsQZv
+8bhzuwTv/4hw4H8B2OB+4HihwfHACgqv8phwz3CAALi0EBAGAM9wgABoVgWAuHGA4KHBhiX3D4by
+z3KAAOAGBYLQcAj0BoKQcAT0B4KwcHryABwAMSDDARSAMMO7UyDIAAIUgDBALsEAUyDJAHhjFHg2
+eThgz3OAADS6DmNMJQCAyXWGJf0fu314YOGIBSWHE+lwhiD9Dxt4BX8AIA4S1H4+ZthjAoh+Zgh1
+hiX9H7t9w44FJQgQyXCGIP0PG3gFfgAhQBIUeBlhOGMEiDtjCHWGJf0fu31li6V4aHGGIf0PO3kl
+exryz3WqAOAHM4VRIQCAC/LopSQdwBHKpSwdABJspQ2lGPAgHcAR6aUoHQASy6UMpW2lEPAJvwUn
+wRHPdacAFEgjpQm+BSYBEiSlCbtleAWlFBqAARgaAAEcGkABCNxHAa/yocAAiAHbYKFouAK4FXjH
+cIAAaFZDgEOhQYBBoUKAQqFEgESh4H9goOB4z3GAAFhXz3CAAORW4H8ioGkGz/TgfuB48cAGDwAD
+z3ABAMQtgOAK8s9xgABMQbgZAAAbgZG4G6HPcAEAcN2A4Anyz3GAAExBlBkAABuBiLgbodHA4H7g
+ePHAVgiv8kokAADPc6UACAwIEwUATCUAgMohwg/KIsIHyiOCDwAASAK8BGLxyiBiAUDYAqPPcIAA
+uLSggM9ygABYV4okgXSIcagggAOELQIaL3AeYvQmThDPd6YAAIA1fwHhwKfHcIAA0FdWkM9xpACg
+P12hF5AeoQgbQAFBAI/y8cDSD0/ypcEIdyh2Lg9v/gfYGnABhgzdBBwEMAQXARQGHEQwMLkIHEQw
+EBYBFGB5gcABhmG9DBwEMAEXgRQOHEQwMLkQHEQwEBYBFGB5g8CA5TH3Zgiv/gpw3Qdv8qXA8cB2
+D0/yz3CAAGhWAICA4JLyz3agAMgfURYPlgHYUR4YkCDdsKZDHhgQANhCC6/yjbixps9w0QBCLc9x
+oADsJwahz3DRAIJGBqHPcNEAQmAGoc9wgAA4TlEe2JMQiIYg/wFDuClohuHMAA0Az3WAALi0BIUz
+JkFwgADUd0AngnQGuBR4NHrHcIAA9LQAes9xgACoWE/wz3GAAHhZEOBL8M9xgABIWiDgRfDPcYAA
+qFgw4Lz/BIXPcoAANLXPcYAAeFkGuBR4NvDPdoAAdLXPcYAAqFhw4LP/BIXPcYAASFoGuBR42GAn
+8M9xgAB4WVDgrP/PcoAAVLUEhRfwz3aAAJS1z3GAAKhYgCACBKX/BIXPcYAAeFkGuBR42GCh/wSF
+z3KAAKS1BrgUeM9xgABIWlhgnP+pBk/y8cA+Dm/yAdjPdaAAyB9RFQ+WUR0YkCDe0KVDHRgQANgW
+Cq/yjbjRpc9ygADgBgCKz3GgAOwnELgFIIAPAADCaQahAYoQuAUggA8AAAJqBqFRHdiTUQZP8vHA
+5g1v8gHYz3WgAMgfURUPllEdGJAg3tClQx0YEADYvgmv8o240aXPcIAA4AYikIa5ELkFIYIPAADC
+Es9xoADsJ0ahA5AQuAUggA8AAAITBqFRHdiT+QVP8uB48cCODU/yz3WAAOAGyI0JjcK+wrgWfs9+
+mg4v/w3YBriBuBC+xXjPcaAA7CcGoQOFz3GlAOgPBqEEhQehvQVP8vHASg1P8s92pQDoDyaGp4bP
+cIAA4AYA3yOgpKBWDi//DdgGuIG4z3GgAOwnBqHmpkUlzR+npn0FT/LgePHA+gxP8qLBOnAacQDd
+Zgxv/gfYmnAC2alwWnB6cQDbNGgCcSh1FCEAIGhywoUEEA8F2H/DhQHixH+D4uV7IOW29wGBAhzE
+MDC7ABwEMCCBBBzEMGB5i3BCI0EggOG+B+3/QCJAII4Nb/6KcOEEb/KiwOB48cDPcIAAaFYPgIDg
+D/LPcIAAuLQEgM9xgACoW89ygAAsvAK4FHhYYNn/FwTP/+B48cBaDE/yz3CAAGhWFICA4IXyvgtv
+/gfYenDPcIAAOE4QiIYg/wFDuClohuHoAA0Az3aAALi0RIbPcIAArLwzJkFwgADcd0AgEAsEulR6
+QCARCkAgEgZAIA8IQCANBFhgQCcCcjR6AHrPcYAACFxR8M9xgAAoXATgS/DPcYAASFwI4Efwz3GA
+AAhcDOC6CC//ANoEhs9xgAAoXAS4FHi4YDfwz3GAAAhcHOCeCC//ANoEhs9xgABIXAS4FHj4YCnw
+z3GAAChcFOB+CC//ANoEhs9xgABIXAS4FHhCcBnwz3GAAAhcJOBiCC//ANoEhs9xgAAoXAS4FHgi
+cE4IL/8A2gSGz3GAAEhcBLgUeAJwOggv/wHaOgxv/mpwmQNP8uB48cAKJQCAz3GAAOAGIBEEACPy
+TCQAgM9ypAC4PQDbDvSbEgAGCaGmEgAGCqGSEgAGC6GjEgAGDKGbGtgA/9imGhgAkhoYAKMaGAAB
+2s9woAC0D1ygJvBMJACAyiHBD8oiwQfKI4EPAABBBHAHIfHKIGEBCYHPcqQAuD2bGhgACoGmGhgA
+C4GSGhgADIGjGhgABMjPcqAAtA+GIP8OIrgcok8C7/8gGUAB3QCP8tkAj/LgfuB48cCSCk/yosEI
+dyh2SHXuCW/+B9iA5xpw0vcBhWG/ABwEMAQWARQCHEQwMLkEHEQwEBUBFGB5i3CA5zH3Pgtv/gpw
+tQJv8qLAz3CAALi0IIADgIDhRCh+AwAhgH+AAOR3A/IMiAPwxBCAAOB+8cDhxc91gAC4tOIO7/6p
+cLhwAIWA4BLySiSAc89zgADkdwDZqCBAAkQpfgMyI0IOsHIg8gHhFPAA2UokgHnPcoAAjHioIAAD
+WSJDBUQpfgMnc7gTgwCwcwzyAeEKIcAP63IF2IojBQlRBi/xSiSAAjECb/IocOB4gOHhxQXyz3KA
+AHhdBPDPcoAAaFyA4wr0gOEI8gHZz3CmAKQAN6AQ8EokQHQA2aggAAMWIkAAoYBggCnYErgB4XV4
+oKDgf8HF8cBmCU/yocEacCh2SHWKIBEFeg8v8oohSQaKIBEFbg8v8gpxiiARBWIPL/LJcYogEQVa
+Dy/yqXHPcKAALCBQgM9xgAAUB0KhUIBigWJ6QaFAKIMhRSPPAM9zoADsJ+ajaoOLcmCyQYFQdQAU
+DzHI98R/8Xbq9VUBb/KhwM9wgAD8DKuAz3CAALi0DBAEAAohwA8QvetyEL8F2IojiQgFJEQDWQUv
+8QUnhRPgePHAughP8qHBz3GAAPwMC4Eg3QHgC6HPcKAAyB9REBCGAdlRGFiAsKBDGFgAANiKDG/y
+jbjPcKAAyB+xoM9wwABHaM92oADsJwamz3GAAORWBIGB4BP0BoHPd4AAuLRAeBgXhRBMJQCAFfTP
+cAEABgEGps9wEgAGBBTwCiHAD+tyBdiKI0YHSiQAAMUEL/EKJQABz3ABAAcBBqbPcBIABwQGpgAX
+BBDPc4AA5HfPcgAAAjNMJACAz3EAAIJMA4cY8kQofgMAIc1wxtiSuAamz3A5AAIzBqbPcDkAgkwG
+ps9wOQACZgamx9iVuBLwViPNBUQofgMndcfYkrgGpkamJqbPcAAAAmYGpsbYlbgGpgfZz3CnABRI
+K6AsoM9xqgDgBwHYE6EBh1mPqHGIc3j/z3AQAIdyBqYBjRC4BSCADwAAQnIGpgWNELgFIIAPAABC
+cAamBI0QuAUggA8AAIJwBqYDjRC4BSCADwAAwnAGpgKNELgFIIAPAAACcQamCY0QuAUggA8AAEJx
+BqYIjRC4BSCADwAAgnEGpgeNELgFIIAPAADCcQamBo0QuAUggA8AAAJyBqYLjRC4BSCADwAAgnMG
+pgqNELgFIIAPAADGcwamz3ABAEZqBqbPcKAAyB+kEA0Az3CAAAZ0BqbPcIAAB3QGps9wgADGcwam
+z3BAAEJ0BqbPcIAAx3MGps9wAgBGagamz3AQAMZqBqZYjwCPJI+A4gHawHr6CyACeY8k2BjZM9pJ
+/89wEADHagamz3AQAIZyBqZ6DwACVgxAAiTYAdkz2kH/z3CgAMgfpBAAAM9xgAD8DKJ4CqHPcAIA
+R2oGps9wZQDCbgamz3AAAMMJBqYKhotxALEAFAExgOHMIeKHMfRODC/yiiCRBM9xgAAUBwCRAeAA
+sQGRgeAR9M9wgAD8DCwQBAAAFAUxCiHAD+tyBdiNAi/xiiPJAILgE/TPcIAA/AwsEAQATCRAgMv3
+ABQFMQohwA/rcgXYZQIv8YojyQHPcKAAyB9RGBiEzwTP//HAwg0P8s91oADAL9OF+r4F9NCFUSYA
+kA30/BUFEAohwA/rcgXYiiNHASUCL/GKJIkMz3WAALi0AKUhpVitea3V/gOly/4EpUYL7/cA2M9w
+gAAwjAeIgOCoDML/0QUP8vHAXg0v8oDYocFgwAXMBBIFNgIcBDBMJQCBANgBHAIwCvIAFAQwCiHA
+D+tyBdjBAS/xktvPcIAAcAcAgIDgAAICAOYJD/6A4PQBAgDPcIAAdEYAgFEgAIHy9IogCg8iCy/y
+AhIBNoYKgADPcIAAIL4qC2/yiiELD89wgAAgvgWQz3eAACAHhiB/DBx4UyCAgAT0A4eGuAOnz3aA
+ABjC/NwCJgAT9gpv8hjZz3CAACC+LpDA3AImABPiCm/yeLnA3EAWhZACJgATTCUAgAenC/IKIcAP
+63IF2LvbFQEv8Yokgw9BFo2QQCWFEEAlgB9MJYCID3ggHwIQyvcKIcAP63IF2MHb6QAv8Yokgw/A
+3AImABPPcYAA/L3SCW/yqHLPcIAAIL4OkM91gAAcxgC3ANkp8AAWAkDPcIAAhMM1eECgABYCQc9w
+gAAExDR4QLAAFoBAUmlUesdygAD0wRCqEaoSqgAWgEAUqhWqFqoAFgBBz3KAADjENXoGsgAWAEEB
+4Qeyz3CAACC+A4gQcaYHxf/PcIAAIL7aCYACKg0v8RPYGg9v/ATYAsiqHRiQz3CAAHAHIIDPdYAA
+dAcAhRi5ELgFeYi5ugkv8oogiwAB2c9wgABwByCgANgApWINb/IAwM9ygACwxwCC4bhC8s9xgABU
+zTSJh+Eh9M9zgAC0l89xgABszcaRtovRdc9xgABgygf0xBENBnSLwL1wdQryxREDBlEjQIEG8imB
+USFAgQX0AtmpGlgAg7gAohrwz3GAAKBeBIEB4AShz3CgANQDHJC+DE/yAMDmDG/yAtkmCKAAAtiK
+IEoPGgkv8gDZWQMv8qHA4HjxwOYKD/LPdoAAIAcDhs91gAB0By8oASCKIAsB7ggv8iCFI4ZQIQwA
+p7xQJAySAN8G8qoIoABOIMAnHPAodIQkBpAb8gmGgeAG9JIIoABOIMAn6aYDhoYgBgADpoogSwCq
+CC/yANkKhoDgBPJAeOqm2QIv8gHYAIWA4Kr0USEAgIr0CI7PcYAAhMMB2vAhAQACuCZ6VHjPcYAA
+RMQQYQq4DKbHcAAAABimD6/6SiBAIAh3z3CAAGDKuhABBs9wgACIljR4EYiA4DoPYAHCIAIkgOfM
+ICKgzCAigFDyz3CAAPzDRJDPcIAAuAYAkBByz3GAABwPGfTPd4AAIL4Fh0iBUyAEAFMiAwCQcw/0
+Y4+B48QggQ8ABgAAxCKBDwAGAADMIIGAA/IA2ALwAdhJgQ+mz3aAAHAHYIZRIkCBQIUA3xi7ELpF
+exHygOAP9BiJg+AL9E8jQQK2D+/xiiCLAALYAKbgpYbxTyMBAom5ng/v8YogiwAD2PbxgOcH9Iog
+CwiKIUUPIfDPcYAAgAwYgQHgGKFw8XoOYAAB2M9wgABgygmAJbiGD2ABwLi6Ci/xE9giDW/8BNjC
+DkAAz3CAAGzENoCKIMoPRg/P8VTxCiHAD+tyBdiKIwYISiSAAJ0F7/C4c+B48cAGCS/yiiBLAaTB
+z3aAAHQHFg/v8SCGz3WAACAHA4UIdIQkhpAghhvygOHcCeL8yiAiAQDfRB3CE891gABwBwCFIIYY
+uEApAgQFeoi6iiCLANYO7/FFeQHYAKWC8IDhRPQPyAQggA////8DDxoYMIogywCyDu/xANkghs93
+gABwBwCHELkYuAV5hSFIAJoO7/GKIIsAAtgApwHYAKZEFYAQgOAJ9M9woAAsIBCAx3AHACChEKVA
+FQcQz3ABABT6QMAE2EHAAd9CxwDYQ8DpcAbZBNoA25hzuHPGCO/82HMA2EQdAhA+8IHhIPQD2H4N
+r/oLuIDgAd8W9EQdwhMOCe/8BNgghs91gABwBwCFELkYuAV5iLkSDu/xiiCLAOClANgApgHfHvCC
+4SD0grgDpc9ygACgXgaCAN9EHcITz3WAAHAHAeAGogCFELkYuAV5iLnWDe/xiiCLAAHYAKXgpulw
+DQAv8qTACiHAD+tyBdiKI0cMSiSAAB0E7/C4c+B48cCGD+/xiiCLAc92gAB0B5YN7/Eghs91gAAg
+BwOFhiB5jxXyz3WAAHAHAIUghhi4ELkFeYUhGABuDe/xiiCLAAbYAKUA2ACm1vAD2J4Mr/oLuIDg
+IIYI9M91gABwBwCFGLjo8YDhyvQojc9wgAA4xM93gAAgvjV4R5BmkIDiBBcEEQOHG/JwcsohxQ/K
+IsUHyiOFDwAAIwLKIGUBl/eA4A3yEHLKIcYPyiLGB8ojhg8AACUCyiBmAUn3kHNM9wohwA/rcgXY
+iiNICkokQABJA+/wuHOA4A3yEHPKIcYPyiLGB8ojhg8AACsCBdhv9w+FgOAc9AuFgOAY9M9woADI
+HwHaU6AYgA2lz3CAAATE9CBBAJYM7/GKIEsGiiBLBooM7/EthQHYC6Vojc9xgAAExEWHz3CAABwP
+9CHBAEigZoc0sGmgZZdtsFMiAACGCe/xANsojQqHz3KAAATCArk0eaIIb/JZYc93gABwB4ogSwc2
+DO/xIIeiCG/0AdguD0AAKI3PcIAAhMPwIEAAUSAAgAjyz3CgAMgfAdkzoBiABKUghgCHELkYuAV5
+irn6C+/xiiCLAATYAKcojQDYAKbPcIAABMT0IEEA3gvv8YogCwTPcaAAyB88gc4L7/GKIAsED4WA
+4Af0ANj2CmABCHEyC8/9Adj5Bc/xCiHAD+tyBdiKI8kKSiSAAA0C7/C4c+B48cB2De/xiiDLAc92
+gAB0B4YL7/Eghs91gAAgBwiNz3eAAITD8CcCEOC6LfIB2QK4Rnk0eM9xgABExBBhCrgMpWILr/ok
+hYDgHfKKIEsISgvv8YohSgFuCg/3IIbPdYAAcAcAhRC5GLgFeYUhVAEqC+/xiiCLAAXYAKUApusB
+IAAA2AOFhiB5jwf0ANhOCq/6jLiA4Aj0z3WAAHAHAIUYuCCG1/DPcIAAIL4DgPYKr/othYDgIIY/
+8g+FgOA79M93gABwBwCHELkYuAV5hSEYAMYK7/GKIIsABtgAp89xgACgXgCBAN/gpgHgAKEojc9w
+gAAExPQgQQCeCu/xiiDLBYogywWSCu/xLIXPcaAALCAjgYYK7/GKIMsFiiDLBXoK7/EkhYogywVu
+Cu/xLYXpcJvwgOEz9F4LQAAIjfAnABAghs93gABwB0CH4LgQuUAqAwZleQ/ygLgFpQDYBqUIuiV6
+iiCLADIK7/FFIoEBBtiF8c9yoACwHwHYGaIegoUhFAAEpR6CDqUOCu/xiiCLAAXYAKcA2ACmSfCG
+4UX0RYXPd4AAcAfguhzyBoUODEAAAIdAhkAoAQYQugi4RXkFeYogiwDSCe/xgLkB2ACmz3CAAIhe
+1g/P9oogSwQA2SLwgOII8i8qgQBOIoAHBqXg8QCHELkYuAV5hSEUAJoJ7/GKIIsABdgApwDYAKYB
+2M9xoADIHxOhGIEOpTyBiiBLBHYJz/ED8IHhA/QB2B3wguEd9AOFz3KAAKBehLgDpQeCz3WAAHAH
+AeAHogCFGLgQuQV5hSEYAEIJ7/GKIIsABtgApQDYAKZ5A8/xCiHAD+tyBdiKI8sMSiSAAI0Hr/C4
+c/HA8grP8QoIQAGA4MohwQ/KIsEHyiBhAcojgQ8AAAoDyiQhAGAHofDKJSEAz3aAACAHA4aGIHmP
+B/QA2B4Ir/qMuIDgF/TPdoAAcAcAhs91gAB0ByCFGLgQuQV5hSEYALYI7/GKIIsABtgApoEDIAAA
+3s93gAAgvgOHqgiv+i2GgOB08g+GgOBw9CyGz3AAAAEUCCEAAJkgCgCKCK/6JIZIjs9xgAAExIDg
+z3WAAKBe9CGBAC3yYgjv8YogSwaKIMsEVgjv8SyGz3GgACwgI4FGCO/xiiDLBIogywQ6CO/xJIaK
+IMsEMgjv8S2GngtAACyFANghHgIQCI4B4SylAeAjjw94MHBGACsACK7I8ACFAeAApQII7/GKIMsF
+iiDLBfYPr/Eshs9xoAAsICOB6g+v8YogywWKIMsF3g+v8SSGiiDLBdIPr/Eths93gABwByCHz3WA
+AHQHAIUYuRC4BXl/AiAAhSEYAM4NQACA4M91gAB0ByCFLvJIjs9wgAA4xAHfVXgGkAq4DKbPcKAA
+sB/5oB6AANtmphC5BKbPcIAAhMPwIIAAgLgFps92gABwBwCGGLgFeYUhkAFeD6/xiiCLAATYAKYG
+2AClKwIgAADegOGg9AyGTg9v+iSGgOAT8iCFz3aAAHAHAIYQuRi4BXmFIVQBIg+v8YogiwAF2ACm
+5PEojs9wgACEwxpw8CBAAAHZBnkDl4DgavKA4Wj0ApcKuAIPb/ouhoDg5PLPcoAATIw3ghaCIngi
+gkOCQnkZYQOXMHCoAAUAzg6v8YogiwTPcaAALCAjgb4Or/GKIIsEz3GAAKBeAYEB4CIKYAABoSiO
+AdoB4S958CBAIAZ6EmlUeM9ygABExBBiANohHoIQQ48KuFBxKK4Mpob2TgxgAADeqfDHcAAAABiy
+DU/6IIXPdoAAcAdAhkApAwSA4Bi6ZXoN8oUiDACKIIsASg6v8UV5A9gApgDejfCFIhgAiiCLADYO
+r/FFeQbY9vEghc92gABwBwCGELkYuAV5hSFUARYOr/GKIIsABdgApgClcvCF4XT0DIYODm/6JIaA
+4GryiiDLBPINr/Eshs9xoAAsICOB5g2v8YogywRSCUAAANghHgIQCI4ghQHgCK7PcIAAcAcAgBC5
+GLgFeYUhFAC6Da/xiiCLAAXZz3CAAHAHIKAA2AClI48IjjBwJAfK/89xgACEw/AhAQAB2gK4JnpU
+eM9xgABExBBhCrgMpsdwAAAAGLoMT/rPcYAAcAcggUCFGLmA4BC6RXkO8oUhDABaDa/xiiCLAAPZ
+z3CAAHAHIKAA3g7whSEYAM93gABwBwDeNg2v8YogiwAG2ACnwKUD8AHeZQev8clwCiHAD+tyBdiK
+I88FSiSAAH0Dr/C4c+B48cDmDq/xiiBLAs91gAB0B/YMr/EghQCFgOBD9ADZz3CgALQPPKDPd4AA
+cAeKIAsH1gyv8SCH/gvP9s92gAC0l0CGUyIAAHIMr/02js9wgABgygmAJbjAuOYLIAEA2YogywOm
+DK/xNo7PcKAAsB8B3tmgPoDPcIAAIAckoACHIIVAKAIGELkIuEV5BXmKIIsAdgyv8YK5BNgApclw
+h/CE4If03guv/QHfVgzv8ALYegmP8ToNL/7pcM9wgADMl94JD/K2CC/06XAEyFEggIAF8o4Kj/QM
+8ADanroA2c9woAD8REGgz3CgALQPPKDPdoAAcAeKIEsHEgyv8SCGiiALBM9xgAAcDwIMr/E0kSCG
+AIVAKQIGCLkQuAV6iiCLAOoLr/FFeQDYAKXPcIAAHA8JgFEgQIEghhfyz3CAACAHD4CA4BH0z3CA
+ABwPGIiD4Av0GLmFIRwAsguv8YogiwAH2CLwtgqP/c9wgAAgvgSAIIZAhRi5gOAQukV5CfLPcIAA
+IAcDgIYgOY8I8oi5eguv8YogiwDgpgnwi7luC6/xiiCLAAjYAKYA2AClpQWP8QohwA/rcgXYiiNQ
+D0okgAC5Aa/wuHPxwCINr/GKIIsCpMHPdYAAdAcyC6/xIIUAhYDgXvTPc4AAIAfjg892gABwB+l0
+hCSGkECGELhAKgEGBXkw9A+DgOAr9Ai6RXmKIIsA9gqv8YC5Ad7Apc9woAAsILCAz3ABABT6QMAE
+2EHAQsYA2EPABtkE2ghzmHC4cAAlhx8HACChOg1v/NhwiiALBbYKr/EA2clwLPBRJwCQCfKIuaYK
+r/GKIIsAAdgN8M9wgAAgvgSAgOAL8ou5igqv8YogiwAI2ACmANgApRLwCLqKIIsAcgqv8UV5+PGB
+4B/0z3CAACAHA4CGIHmPBPQB2JMEj/82DW/8BNgghc92gABwBwCGELkYuAV5iLk6Cq/xiiCLAAHY
+AKbY8YLgFfTPcoAAIAcjgs92gABwBxC4hbkjos9ygACgXiiCAeEooiCGGLkFeePxCiHAD+tyBdiK
+I5IBSiSAAGEAr/C4c/HAzguv8YogywLPdYAAdAfaCa/xIIWKIMsCz3aAACC+ygmv8SSGIIWA4TP0
+/tnPcIAAIAchoMYM7/oEhghxz3CAANReBg1P+s9xgACgXgqBAeAKoe4Mr/AT2FoP7/sE2JoIj/3P
+cIAAcAcAgCCFQCgCBhC5CLhFeQV5iiCLAG4Jr/FFIcEAA9gApQHYHfCD4R30z3KAAKBeC4LPdoAA
+cAcQuQHgC6IAhhi4BXmIuT4Jr/GKIIsAAdgApgDYAKXPcYAAIAcLoXUDj/EKIcAP63IF2Ioj0g1K
+JIAAgQdv8Lhz8cCuD4/wANjRwOB+8cDhxaPBCHWKIIsD8giv8alxz3CAACgHIIgBHEIzz3CAAALE
+9CBAAGDBz3GgAMgfAxwCMADYAhwCMAHYE6EZgYTaQsAYgR7bDNlBwItwqgyv8Ri7z3GAALDHAIGj
+uACh9QKv8aPA4HjxwHYKr/GKIIsAz3aAAHAHQIbPd4AAdAcghxi6ELl6CK/xRXkA3aCmz3aAACQH
+AIaMIMOPoKcH8s9wgADUXlYLT/rPcIAAKAegqM9wgAAsB6Cgz3CAAEwHoKD/2IECr/EApuB48cDh
+xQh1hguv8BPYz3CAAGDKCYAluD4IIAHAuN4N7/sE2KlwxP/e/xoPT/2KIAsAAgiv8alxVQKP8eB4
+8cDSCa/xgdihwWDAAN8FzAEcwjMCHAQwiiCLB9oPb/FX2c92gABwB4ogiwfKD2/xIIaKIIsHz3WA
+AHQHug9v8SCFAIaA4BDyz3GAACwHAIGBuAChz3GAAKBeA4EB4AOhAdgD8ALYGnAAwEoL7/EKcUwg
+gKA68s9wgAAkBwCAjCDDjxzyiiALAG4Pb/F22c9wgADUXl4KT/r/2c9wgAAkByCgIIVAhoogiwAQ
+uRi6Sg9v8UV54KbgpQCGgOAE9ACFgOAG8t4Nj/yA4BDyiiALACYPb/F/2c9wgAAsBwCALygBAE4g
+wAe4/00Br/GhwOB48cDPcIAA/L1BiM9xgABYwWIOr/EC4s9wgAAgByCQz3CAACC+LrDRwOB+4HjP
+cIAAcAcAgIDgzCBigAT0ANgF8Ijg/vMB2OB+8cCaCI/xGnDPdYAAcAcAhSh2gOBIdwb0gObiIIID
+OvCKIAsAmg5v8YohBwOKIAsAjg5v8elxz3CAACQHAICMIMOPB/LPcIAA1F5yCU/6z3CAAEgHz3GA
+ACwHwKAAgQV/4KHPcYAAoF4CgQHgAqHPcYAARAcAGQAEA/C6DAAAAIWA4P31z3CAAHQHAICA4Pf1
+bQCP8fHAz3CAAHAHAICA4Anyz3GAAKBeCYEB4AmhAth3/5fx8cDPcYAAcAeKIAsG/g1v8SCBPgmv
+8BPYLgvv+wTY/9nPcIAAJAcgoIHx4HjxwL4Pb/Ec2QokAIDPc4AAiF4Ag891gAAgviCgQCUAFwGj
+CIUA2a24CKXPcIAAaAcJpc9wgAAcwQOjGNgCo89wgAAYwhoYRIAJ9M9wgABYwc9xgAA8BwChP/DP
+cIAAPAcAgAGIRCy+CEAghgDPcIAAU74yIEIOLyaHAc9wgABABwLiT3qA4gAQhQACJYAA1/YAIY4P
+gAA8vkQsvggW5jImTh44YAAgjw+AABzBAeEveVBxwK8CJYAArPbPcYAAHME4YM9xgAA8BwChLpUC
+IYEBMHlZYS61BaMOlU0Hb/EEo/HA4g5P8aXBz3WAACgHAI3PdoAABMT0JgEQ5gxv8YogCwPPcIAA
+IL4FgMC4DRwCMACN9CYAEAHbz3GgAMgfY8BzoRmBANpBwBiBDhyCMEDAFYEPHIIwRMMU2ULAi3CC
+2h7blgiv8Ri75QZv8aXA4HjxwHIOT/Gkwc91gAAoBwCNz3aAAATE9CYBEHYMb/GKIEsDz3CAACC+
+BYDAuAEcAjAAjfQmABDPcaAAyB9gwADYAhwCMAMcAjAB2BOhGYGD2kLAGIEe20HAz3CAAEyMO4AH
+gDhgQ8CLcBDZHgiv8Ri7bQZv8aTA4HjxwPYNT/HPdoAAdAcghoHhC/IKIcAP63IF2OLbSiQAAGUC
+b/C4c891gABwB0CFguLMIuKByiHCD8oiwgfKI4IPAADjAAXY7PXPcIAAaKsgEIAAgeAI8s9wgAAg
+vgKIUSAAgDT0guIA3w70GLoQuUV5hSEMAKILb/GKIIsAA9gApeCmOPCiCk/9z3CAACwHAIAghlEg
+AIAAhRC5GLgFeQj0z3CAACC+BICA4An0iLlqC2/xiiCLAAHY4/GLuVoLb/GKIIsACNjd8Q/IELkF
+IIAPAQAA/A8aGDBAKgAGBXkIukV5iiCLADILb/GBuQLYAKZtBU/x8cACDU/xz3aAAAAAAIZRIICC
+G/IBhlEggIJA2M8g4gfKIIEPAADQAM8g4QfPcZ8AuP8doQSGAeDTuASmBSCAD9D+AAAWoQHZz3CA
+AEEHIKjPcIAAcAcggIThCPTPdYAAdAdghYHjDfIKIcAP63IF2IojxAVKJAAAGQFv8Lhzz3CAAMjE
+IBCAAEApAgYQuwi5geBlekV5HfTPd4AAOAcAhwDaDyICAM9wgAA0B2CARntgoIogiwBuCm/xRSGB
+AQbYAKWKIEsEXgpv8SCHCPCKIIsAUgpv8YG5AtgApQCGUSCAggfyANnPcJ8AuP89oH0ET/HgePHA
+EgxP8c9xgAAsBwCBz3WAAHAHz3aAAHQHgLgAoc9xgACgXgWBAeAFoSCFAIYYuRC4BXmFIRgA9glv
+8YogiwAG2AClANg5BG/xAKbxwM9wgAAgvkSQgOIh8s9wgABBBwCIgOAb9M9wgAAoByCIz3CAAITD
+8CBAAFEgAIAP9M9xgABMjBuBJ4EZYTByB/eiCW/xiiDLBwHYAvAA2LMCz//xwG4LT/HPdYAAcAcA
+FQUQTCVAgsohxg/KIsYHyiBmAcojhg8AAGIA1Acm8MokpgDPd4AAAAAAh1EggIIa8gGHUSCAgkDZ
+zyHiB8ohgQ8AANAAzyHhB89wnwC4/z2gJIcB4dO5JKcFIYEP0P4AADagAIXBhQi4IoUFfjB2CPIQ
+uYogSwUKCW/xxXnCpSCFz3CAAIx68CBAAEB4gODq8wCHUSCAggbyANnPcJ8AuP89oCUDT/HxwL4K
+b/GKIP8Pz3WgADgux4UHpT/Y/g5v8hbZHgiP8selCQNP8eB48cDhxYogygWqCG/xiiHFCBYIb/IB
+2M9wpQAIDADdoqAEyITg2AwB8M9xAAAMCp4Lb/AG2A/IBSCADwEAAPwPGhgwBMhRIICABPLCDg/0
+DPAA2Z65z3CgAPxEIaDPcKAAtA+8oN3/ugoP+74NL/0B2JoLb/AB2JUCT/HgePHA4cXrdYogigUu
+CG/xiiHEB4ogigUiCG/xqXHPdYAAfAcAhVEgQIAV9AOFUiCAAAOlCfDPcKAAqCANgOTg9gAFAEYK
+r/FU2EQgAQEDhTBw8vWKIIoF4g8v8YohBAwEyITgHfTPcYAAtJcBgaW4AaHPcYAAYMrFEQAGpbjF
+GRgACYGluAmhJbjAuM9xgADYrn4J7/8KoVIND/GKIIoFmg8v8YohhA8A2s9woAD8RJ66QaDPcKAA
+tA8A2TygD8gEIIAP/v//Aw8aGDAPyIe4DxoYMH/YCrjPcaAA0BsToX/YEKEA2JW4EKHPcQIAbAJi
+Cm/wBtjPcaAA8DYEgUYgwAEEoZTYTgtv8RjZiiCKBSoPL/EghQCFUSBAgGQMIvvKICIAiiCKBRIP
+L/GKIUUGYQFP8QohwA/rcgXYiiPECkokAABlBS/wCiUAAeB48cDhxaHBz3WAAHwHRJUilYogSgUQ
+utYOL/FFeUKFIYVQcR7yBMiE4EDBBfRPIQABQMCA4QT0gOIADsL/i3AE2aHaPdueCm/xF7shhYDh
+B/IChYDgA/SY/yGFIqWA4SbyANrPcKAA/ESeukGgz3CgALQPANk8oA/IBCCAD/7//wMPGhgwD8iH
+uA8aGDB/2Aq4z3GgANAbE6F/2BChANiVuBChjglv8AHYmQBv8aHA4HjxwOHFABYAQILgz3WAAHwH
+AKUf9ADZz3CfALj/PaAc2RXwz3CgAMg7NoBEIQIHNoCGIf8IJXo2gIYh/whFec9yoACoIE2C5OKR
+94Dh6/UeDE/xIIWE4UoADQAzJkFwgACwekAngHI0eAB4OBAEAFgQBQAKIcAP63IF2DEEL/Av2woI
+r/FU2FEgQIAL8gGFgbgBpbD/BfBc/wPwqg+P+vUHD/HgeM9ygAB8ByGCJXjgfwGi4HjPcoAAfAch
+ggZ54H8houB4ANmcuc9woACsLz2g4H7gePHA4cXPc6AArC8Zg/C4GYMA3QzyBCCADwgAAADXcAgA
+AAAB2MB4B/CGIH8PguAB2MB4gOAX8hmDBCCADw4AAABCIACAyiBiAIHgDfIKIcAP63JkEwQABdiI
+230DL/BKJQAAVg9v8VTY5LhEIAECHvLPcp8AuP+9ohzaFvDPc6AAyDtWg7aDhiL/CIYl/xileraD
+hiX/GKV6z3WgAKggrYXk5Y33gOLs9VEgQIDPcoAAfAcBgg7ygbgN8DgTBABYEwUACiHAD+tyBdgN
+Ay/wL9uhuFEggIABogzyBIIQcQryJKIB2c9wgAChBoIIL/0gqM0GD/HxwADYnLjPcaAArC8coRqB
+USCAghqBC/KquBqhGoFRIACA8fMB2LL/CfCKuBqhGoFRIACA5/UB2Kn/ANmbuc9woADQGzGgsv9Q
+/89wgAB8BwGAQiAAgMogYgDRwOB+4HjxwPYND/HPcQCCAQDPcKAArC88oM9wgAB8BwGAgOAE9OD/
+FvDF/jYJL/tv2IDgEPQg3s91oADIH9ClCthDHRgQANiqCW/xjbjRpbz+FQYP8ajx4HjxwIogSga6
+Cy/xANm2/pP/Mf+A2c9woADQGzCgxfHgeM9wgADsYK0BT/bgePHAHgyAAc9wgABgyhgQhABMJACB
+CPQJgFEgQIEE8p4PAAAP8EwkQIAJ8s9wgABUzRQQhQBMJcCBBfTWCAAA0cDgfgohwA/rcgXYuQEv
+8HXb8cAmDQ/xABYAQM9wgADYBwCAz3WAAOzEg+AAFgBAVSVOFBX0z3WAAOxeAKUEbYoJb/EP2VUl
+QBQmC2/xIpUB2c9wgAA0yiSoJvAApQRtaglv8Q/ZyXAKC2/xIpUelc9ygACUB9lg2GABEIUATCUA
+gCCiEvQChfC4yiHBD8oiwQfKIGEByiOBDwAA8QAkASHwyiRhAP0ED/EIcs9wgAAEYSWAI4Fggc9x
+oACwHzuB1bl5YRDh7QXv+UJ54HjxwOHF0P+yCE/xz3CAABwPGIiB4Cz0z3GAAOzEz3KAAOxgAIJg
+gWCgAIIc22CoBGkBos9wgACcBwOhVSFABAOiGNgColUhwAUFogGBAN1aGUQDBKICga24gg9gAAKh
+gOAG9Klw3v9qD2AABthxBA/x8cDhxc91oADIHxWFz3GfALj/1bgWoWYOz/8VFQCWkLgeHRiQOg9g
+AADYRQQP8eB48cDhxQHYz3GgAMgfE6EYgazBScAZgc91gABoq89xgABIzUrAAYGhuAGhCIXguAry
+USDAgQb03g4P+vIML/AX2ItxqXAOCW/xJNrPcIAAlAcggAKJgOAT9ASJUSAAgA/yD8gEIIAP/v//
+Aw8aGDAPyIa4jLiPuJC4CvAPyAUggA8BAAD8DxoYMA/IrLgPGhgwjgzP74twMNmQ2h7bQg0v8Ri7
+z3CfALj/Atk2oCjAgeDKIcIPyiLCB8ogYgHKI4IPAAAtAcokIgCMB+LvyiUiAGoOQACA4Af0ANiZ
+/1IOYAAG2F0DL/GswPHA3gov8TDaz3GfALj/VqEbGhgwz3GgANQHGhkYgB8RAIYB3wIaGDAIEoUw
+TCUAh8ohwg/KIsIHyiBiAcojgg8AAJkBKAfi78okwgMZEQKGA9ggGRiAFBnYgw8RDYYAFgBAABYA
+QAAWA0EAFgBBABYOQA8ZWIP0vlYjAAIQeATyAuAQeAPgBCCADwAA/P8QcrAADQAPEQKGQOIeGZiA
+HREAhh4ZmICtuB0ZGIC6DkAAgOA98s92oAA4LgeGz3EAAEQKqLgHplILL/AN2M91gACwxyeGqxUA
+FiV4B6aKIBUMHggv8YohxwKKIBUMEggv8asVARYA2KsdGBAAhYYg/oEPyAvyBSCADwAAANQPGhgw
+D8iQuAXwBSCADwEAAPwPGhgwQg5gAALYDPAPyAUggA8BAAD8DxoYMA/IrLgPGhgwz3GAACAFANgA
+oQDZkbnPcKAA0BsxoM9wgADQAhB4z3GgALRHSRkYgM9ygABkps9wgAAkBUCgbyBDAFQZGIB6DG/1
+ChrYM8EBL/EA2PHAVgkP8QAWhUAAFoBAABaAQAAWgEBMJQCEyiHJD8oiyQfKIGkByiOJDwAAWwC0
+BenvyiRpAADZTCUAgM92gAAcYSmm0vcocgAWg0AUa891gAAohQBlUSBAggz0AeKwcg8hwQApprL3
+Og0P8VUBD/EKIcAP63IF2GnbSiQAAGUF7+8KJQAB4HjPcYAAHGEKgYDgBfQNgYDgA/IA2AXwBoGB
+4P3zAdjgfw944HjxwOHFcgkgAAh1z3GAAKiuJZGA4WAADACA4C7yz3CAAECiSIgA2c9zgAAcYQyD
+DyGBAAsgQIAg9IwiAoAc8oYl/BCMJQKQDvKMJQKUB/KKIM8Odg7v8KzZDvANgyV4DaMLgwV5K6M0
+asdxgAAohQCBqLgAoakAD/HxwC4IL/EA2EokwHPgeKggQAc0aMdxgAAoheCBz3WAABxhAN4PJg4Q
+QS8DElEjAIBshQX0xntspQbwCyOAgwT0qL/goQHgUQAP8eB44cVKJMBzANuoIAAGAN3PcYAAHGEM
+gQ8lzRALIECDDfQLgQsgQIMJ9BRrx3CAACiFIICIuSCgAePgf8HF8cDPcIAAHGEgEAUATCXAgMoh
+xg/KIsYHyiBmAcojhg8AAFUAEATm78okpgDPcIAAuHrwIEABQHjRwOB+8cBuD8/wCHXPdoAAHGGK
+IE8Keg3v8CiGCIYQdUX3gOXKJQIQAvSopoogjwpeDe/wqXGpB8/w4HjPcIAAHGHgfwiA4HjxwIog
+TwtCDe/wiiGEApIIL/AJ2ADY6v/Q8eB48cD2/wDZguDMIGKAyiBCAAL0AdgPeMTx8cAB2M9xgAAc
+YQOhz3CgACwgA4AEoQKBgeAkDAH2tPHxwIogTwzuDO/wjtk+CC/wCdiq8fHAwg7P8OL/geAM8goh
+wA/rcgXYoNuKJMMPNQPv77hzz3WAABxhI4WB4QKFD/SB4ADZBfIUjYDgBfK2CSAAJqUM8COlAdgG
+pQjwgOAG9AHe8gjv/8alwqXPcIAAqK4FkIDgMA7J/8kGz/DgePHAUg7P8M91gAAcYUmFgOIv8geF
+geAv9BaNANlqhcuFDyEBACR6QiICgCR7yiJiAIDjAdskfsB7gOYB3uyFwH7keYDhAdnAeYDizCMi
+gMwmIpDMISKAB/IVrQDZzgkgACelFo0B4A94kOAWrQP0ANgWrUkGz/DgePHAz3GAABxhz3CAAMR6
+Wgsv8TjaLglgAADY0cDgfuB48cC6Dc/wABYAQM9wgAC0lwGAUSBAgQz0CiHAD+tyBdiU24okww8l
+Au/vuHMAFgBAz3WAAOzEAKXkbelwEgov8Q/ZVSVOFMlwrgsv8SKVvgkP8QgVBRBRJQCEyiHBD8oi
+wQfKIGEByiOBDwAAnADcAeHvyiRhAM9wgADsYCCAQIVAoSCAHNpAqc9xgACoByOlGNkioFUlwRUl
+oOGgIYXDoCSgANhaHQQQAoWtuIIIYAACpYDgF/TPcIAAqK4lkIDhiiCPC8f2Fgvv8K/ZcgsAAAbw
+Cgvv8LTZ/goAAEYIYAAN2EEFz/DgePHA0gzP8M92gABoqwiG4LiswQryUSDAgQb0BggP+hoO7+8X
+2ItxyXA2Ci/xJNoB2M9xoADIHxOhGIEA3UnAGYHPd4AAHGFKwAaHMNmQ2h7bS8CLcJYO7/AYu6G2
+qKahpryuo6cGDe//AtjPcIAAqK4FkIDgxPaqp62nBfCmCyAAqXBmhwHZz3KAALAHAIKB48B5gOM4
+YACiAdghgsB4OGABopkE7/CswPHAJgzv8DjaosEacM91gABUYQGFAN8ODe/w6XEhhRjYz3OAABwP
+ALEXg1MgziDPcoAANIUBoUAoACEIYjMZwgNAKAQBiHCGIP4DxXgQqc9woAAsIBCAx3AHACChCqEG
+2DEZAgAyGQIAFoP6sQOhQCEAA54JL/YKcQOFkNmBwiCwi3FSDS/2CnCB4Mohwg/KIsIHyiBiAcoj
+gg8AAHcAyiRiABgA4u/KJQIEAMBRIACACvKKIE8Olgnv8HvZIYUBgaO4AaEjhYtwBOHuCC/xBtoB
+hc9xgAC4ByKghg/v9alwz3CAABxhFRgCBKED7/CiwPHAPgvv8IogTw5SCe/wldkB2M91gAAcYQel
+z3aAAGiriiBPDjYJ7/AohhWNANoshQ8iAgALIYCAJvQqhUV5yIYqpWuFBLjgvsdwgAAohSCADPJR
+JsCRCvRlekulqLkgoIogDw6m2QnwRntrpYi5IKCKIA8OrdnmCM/wiiAPDt4I7/ArhSUDz/DxwLIK
+z/DPcIAAHGHAgADflr/+ZpYLL/rJcAhxz3CAAGxhEgyv+f5mz3WAAKiuBZUlhQq42WF2Cy/6DiBA
+AJhwz3CAAIRh7guv+YhxXgsv+slwmHDPcIAAnGHaC6/5iHHPcIAAHGHAoAWF/mYeZgWVCrg6Cy/6
+DiCAAwhxz3CAALRhsguP+ZUCz/DgePHAJgrP8M92gAAcYaCGAN+Wv/1lCgsv+qlwCHHPcIAAXGKG
+C6/5/WX2Ci/6qXAIcc9wgAB0YnILj/lVAu/woKbxwOYJz/DPcKAAsB+7gADelr4EJY0fwP8AAN1l
+FOUAJY8fgAAAALoKL/qpcAhxz3CAAIxiMguP+aYKL/rYZQhxz3CAAKRiIguP+ZYKL/rpcAhxz3CA
+ALxiDguP+c9wgAAcYe0B7/DgoPHAegnP8M9woACwH/uAAN2WvQQnjx/A/wAAv2cQ5wAnkB+AAAAA
+Ugov+ulwCHHPcIAAzGHKCq/5v2fPdoAAqK4FliWGCrj5YS4KL/oOIEAACHHPcIAA5GGmCo/5Ggov
++ulwCHHPcIAA/GGWCq/5v2cFhh9nBZYKuP4JL/oOIMADCHHPcIAAFGJ2Cq/5AnXqCS/6CnAIcc9w
+gAAsYmIKj/nPcYAAHGEAGQAEBZYlhgq4uWHGCS/6DiBAAAhxz3CAAERiPgqP+RkBz/DgePHAsgjP
+8KLBgODKIYEPrd6t3gfyJYAjgSCBAoACebYOr/CKIE8Nz3aAABxhAYaB4BD0iiBPDZ4Or/CKIUYJ
+ANgBpuoJ7+8J2AIJ7/8A2G7wMgnP/4HgAdjAeC8lB5AR8oogDw1uDq/wiiEGDZINz/UB2HIL7/8G
+ptII7/8C2AYJz/+C4AzyCiHAD+tyBdiKIwcAiiTDD60Er++4cw/IBSCADwEAAPwPGhgwYgmv7wDf
+mgjv/+lwdgnv7wnYz3CAAKiuBZCA4GQADAAKhkHAC4YaD6//QMCA4AjygOXKIIEPAABAALQLAfuL
+cAjZlNoe29oJ7/AYu4ogjw7aDa/wiiFHB4ogjw7ODa/wK4aKII8Owg2v8CqGgOUH9LoPj//iDM/1
+AdgHpuum8Qev8KLA4HjxwIYPr/CKIA8Kmg2v8IohRQUWDY/8gODPdYAAHGEW9Iogzw5+Da/wiiHF
+BgHYAaXPcIAAqK4FkIDgxfYaD4//QvAA2KP/QPAPyAQggA/+//8DDxoYMA/Ih7gPGhgwD8iQuA8a
+GDB2CK/vAN4iD4/1dgjv7wnYJIXPcKAALCADgMdxAAAAFCJ413AAgAAASfeKIA8KDg2v8IohxQ3D
+pbYPr//CpYDgdA+h/8ogYQDPcIAAqK4FkIDgyiCJDwAAQAAcCgn7LQeP8PHA4cUIdQWAA4BChSCA
+iiAPC8oMr/BCec9wgACorgWQgODE9vn+A/Ab/6lww/8FB4/w4HjxwIIOj/DPdYAA2K4PhUogACCA
+4MohwQ/KIsEHyiBhAcojgQ8AAEIAyiQBBOgCoe/KJcEAAdrPcYAAaKtgeEihPB0AFLoPr+8D2J0G
+j/DgePHAFg6P8NpwmnH6cgojACEKIkAhyHcKIMAhCiHAg89wgAA0hcohYgAocgS5KGBMJACgBLiG
+IP4DBSCRAMohzA/KIswHyiBsAcojjA8AAIcAyiRsAHACrO/KJQwFz3WAANRiAYUA3slxxg6v8Dja
+AIUc2SCgAYUQ2YQvCxwAIZV/gABgyiCwXBUBIDMYggPPdoAAwAcQGEIEmbkhoEAmARMioAohwIMo
+GAAEMRgCBTIYAgU0GMQFyiFiAI4JL/EM4CGFCNgSqQGBjbgBoQOBUSBAgg70DInPcoAAbHDDuBx4
+CmLPcIAABMtIYAypgOcG9M9ygADwqgXwz3KAABCrQ6Wk2ACyTCZAoBDYAqUE9KTYjLgAsgzAgODK
+IcEPyiLBB8ogYQHKI4EPAAC4AMokIQCUAaHvyiXBAEwjAKAEphDyAYGYuAGhA4GfuAOhABUBIAQV
+ACAAHoQUIaYCpg4J7/WpcP0Ej/DgeM9wgABoqyiAz3CfALj/ANo2oAjZ7HAgoAPZz3CgABQEJaAC
+yOxxAKHPcKAA1AtNoOB+4HjPcYAA1AfgfwCh4HjPcIAA1AfgfwCA4HjgfuB44H7geOB+4HjgfuB4
+4H7geOB+4HjgfuB44H8A2OB/ANjgfuB4ocHgf6HA4HjgfuB44H7gePHA4cUCyM91gAAcYwClBG3O
+CO/wAtnPcYAOBADscCCgUg+v8ACFnQSP8OB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+
+4HjgfuB48cAAFgBBz3KAABxjBrIAFgVBQCIBBA4aRAFMJYCEyiHCD8oiwgfKIGIByiOCDwAAggBY
+AKLvyiQiAADaB/AAFgBBFCGMAAC0AeIvIEIBEHK39voPj/DRwOB+4HjgfuB44H7geOB+4HjgfuB4
+4H7geOB+4HjgfuB44H7geOB+4HjPcIAA2AfgfwCA4HjgfuB44H7geOB+4HjgfuB44H7geOB+4Hjg
+fuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+
+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfwHY4H7g
+eOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4
+8cCmCo/wGnHPd4AAXGMgj1EhAIBG8s9xgADgByCJgOHMICGgPvKB4Ab0z3CAALi0oYAD8ADdjuUD
+94DlAvQA3c9xgAC4tBiJgOAE9IDlBPQA3gTwooEE3oogEwFuCK/wqXGKIFMBZgiv8Mlxz3CAABwP
+GIiD4MwgIoHMIOKBzCAiggjyiiATAUIIr/Cz2QrwCpcQdQj0C5cQdswgIaAE9ADYIfAB2M9xoADI
+Hw2hz3CAAOAHAYjLt6q3BL4QuMV9BX2KIBMBBgiv8MrZiiATAfoPb/Cpcc9woADIH38YWIMB2CkC
+j/DgePHAwgmv8AhxxP+A4DzyIN3PdqAAyB+wpjLYQx4YEADYmg2v8I24saawph7YQx4YEADYig2v
+8I24saZ/Fg+WiiATAUEvDRTEvZoPb/D02YogEwGSD2/w6XGKIBMBhg9v8Klxz3GAAOAHAYkB2hB1
+wiKKAIDlQKnI9gDYDaaB4gT0BNgBqaUBj/Dhxc9ygABcYyCKAN3guWTYyiBBA+G5z3OgAMAdBqIJ
+8gzYAKMBggOiAoIEogTwoKOjoqSiz3CAABwPCYBRIECB0SGigATyAIOAuACj4H/BxfHA4cUA3c9w
+oADAHaCgqXCpcYz/z3CAAFxjo6CkoEUBr/CmoIDgz3GAAFxjBPRAIQADBPBAIQAEAIDPcaAAwB1R
+IACAAIHPIOIA0CDhAACh4H7gePHAmgiv8APZz3aAAFxjHg2v8MlwoI5EJUARheAM9AohwA/rcgXY
+d9tKJEAA+QRv70AtBRIBjoPgw/ZjuAGuqgyP8MUAj/DgeOB+4HjgfuB44cVSIIAAz3GgAHwdBKkC
+3RHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HhhvYwl/5/t9eB/wcXgeM9woAB8HQSI
+4H7gePHA6g9P8DpwenFachpzANjp/wTY6P9MIQCg1PcqdQDfQiFAIOJ4ASsOIMC+TyaAEOH/RSaA
+EeD/Yb2A5QHnMvcE2N3/TCIAoADZABhAINf3SnUodgbY2P9hvef/QiJBIMJ5wLg4eAAQASAFeQAY
+QCAE2NH/gOUB5i73ANjO/8UHT/DgePHAocGLcwjYBdkIctz/IMChwNHA4H7gePHARg9P8FpwOnEK
+I4CgGnMKJQAhzCAhoBDyTCMAoMwgIqAM9AohwA/rcgXYVtuKJIMPvQNv77hzANiacLf/BNi2/0wi
+AKDU90p2inVCIkAgongBKQ8gwL9PJ4AQr/9FJ4ARrv9hvoDmAeUy9wDdE/BBLcAQMiMOIFMlgRBO
+IcABGX7Avk8mgBCk/0UmgBGj/wHlQCjAIBB1rPcA2J//TCUAoBvyFPDR/1EgAIAY8iDez3WgAMgf
+0KVk2EMdGBAA2JYKr/CNuNGlgCQBKQwkgK8AAIgTqfeKIP8PA/AA2LkGT/DgeAjYBtkA2khzmHKK
+8fHAbg5P8Ah1KHdIdvr/TyVBFBjY6XLJc0okQAC9/7kGT/DgePHARg5P8KnBz3egACwgQBcQECIJ
+b+8A3c9xgACADBKBAeASoYtwYgyv8ATZF/CBxslwVgyv8CDZABQAMclxINrn/wV9ABQAMSDgABwE
+MAIUADFCIAAIAhwEMAIUATGg4Wf2gOEM8oHGHgyv8MlwABQAMclxAhQCMdn/BX3QhzzYAiYOFOYL
+b/DJcYDlyiWBEwLIlg+v8KlxEQZv8KnA4HgdeM9xoABgHRKxFJHgfuB48cDhxQh1KHMH8Klw+f8C
+GxQAAuWwfWG6jCL/j/f19QVP8OB48cDhxQh1KHMJ8Klw8P8Aq0i4AasC5bB9AuNhuowi/4/19c0F
+T/DgePHA4cWhwQhzKHUB4l16EPBocOX/ABwEMAJrEHji/wIcBDAAwATjcHsEHRAQYbqMIv+P8PWR
+BW/wocDgePHAEg1P8Ah2eg2v8CTYUSAAgMohwQ/KIsEHyiBhAcojgQ8AACoCyiQhAHgBYe/KJcEA
+z3WgAMAvgOYThVH0+rgS8hOFIN6zuLq4E6XPdaAAyB9k2NClQx0YEADYrgiv8I240aX02ADZXg2v
+8AHaNNgA2ZG5Ug2v8ADaMNiKIQYARg2v8ADaNNgA2QPaOg2v8BS68gyv8DDYwriB4AP0ANgH8ATd
+P9iOCm/wqXGpcM9yAQDGA89xoADsJ0ahz3GgALQPPIGA4UryAhIENgohwA/rcgXYiiPJBMkAb++4
+c5q4E6Ug3892oADIH/CmiiAPCkMeGBAA2BYIr/CNuPGmE4WzuLq4E6Vk2PCmQx4YEADY+g9v8I24
+8abwpgHYQx4YEADY6g9v8I248aYThfq4BvQQhVEgAIAO9PwVBRAKIcAP63IF2IojRwFZAG/viiQJ
+A0TYSR4YkKXxIQRP8PHAsgtP8KHBKHbPd6AALCBAFxAQgOIA3QAcRDMw9DJoBCGBDwAA/P/KDW/w
+LNgQhwIgAASMIA+KCffuC6/wLNhRIACACHX18wfwIIaAuSCmhglv8D/Y0guv8DTY9bgO8iCGgbkg
+pnIJb/A/2DTYANkA2voLr/CVujC9VfAPeRC5BSGBDwAAgv3PdaAA7CcmpQQggA8AAAAfSLiGuBC4
+BSCADwAAQv0GpRCHAiAABIwgD4oP989wAAAD/QalCoWLcQCxABQAMVEgAIDw8wfwIIaAuSCmAglv
+8D/Yz3AAAEP8BqUKhUAkgTAAsQIUADFRIICACPIghoG5IKbeCG/wP9jPcAAAg/8GpQqFi3EAsSDA
+z3IAAMP/RqVKhQi4QLEgxQV9QNiyCG/wqXGpcOkCb/ChwOB4z3EBAMcDz3CgAOwnJqDgfvHAcgpv
+8ALZosEA3kHG3giv8ItwPth+CG/wAhIBNj7Ycghv8AAUATE+2GoIb/ACFAExBczXcAAAAEAB2MIg
+CgAXuAAggQ8ADgAAAhQAMRt4D+AEIIAPAAD8/yV4nbifuOxxAKECEgE27HAgoAAUATHscCCwAhQB
+MexwILACFAUxUSUAgMohwg/KIsIHyiBiAcojgg8AAK0BaAYi78okggPPcQAAIiLuDy/wPtgB2C3/
+AcHPdaAALCDwhSV4QcAP8AAUADGBwQHaff/scQCxABQAMQHmAeAAHAQwAhQAMRB2sPbE/zCFPtiq
+Dy/w4nk/2KIPL/ABwaYMb/ABwN0Bb/CiwOB48cChwRB4TyABBJG5i3MY2BDaWf71Ae//ABQAMfHA
+UglP8Ah2KHe6Ca/wMNgIcYYhBgB6C2/wMNimCa/wMNhRIECC/PXbfoG+QC8NFCzYXgtv8AUlgROK
+Ca/wMNhRIECC+/WKINEPKg8v8AUlgRNpAU/w4HiB4M9xgADkBwT0AdgAqQGpAImB4MoggQ8AAMQJ
+yiCCDwAAgADgfwGhANjPcoAA5AcBqgCqz3GAADCMBomA4AryB4mA4AbyAJGO4AT0AdgAqgDY2PHx
+wOHFCHXPcIAAcA8BiIHgE/QH8HoLD+9GCW/wXtjPcKAA1AsYgADZQiAACIDgyiBMABB1MPfpAE/w
+4HjPcFhYWFjPcaUATBWxGRgAz3BwcFhYshkYAM9wAAQWoLMZGADPcDEIU7S0GRgAz3ACAJ1QtRkY
+AM9wMAQRgLYZGADPcEEJPfC3GRgAz3ACAKl0uBkYAOB+4H7geOB+4HjgfuB44H7geOB+4HjxwAoh
+wA/rcgXYNttKJAAAfQQv7wolAAHxwAohwA/rcgXYO9tKJAAAZQQv7wolAAHPcAIAhCDPcYAA7AcA
+oc9wAgCAIAGhz3ACAIggAqHPcAIAjCDgfwOhz3ACAAQgz3GAAOwHAKEBoQKhz3ACAAgg4H8DoeB+
+4HjgfuB44H7geOB+4HjxwH4PL/Bq2KLBi3EB2kYJ4ABIc4DgDvQKIcAP63IF2IojjwyKJIEK4QMv
+70olAACBwUTYAdoeCeAASHOA4A70CiHAD+tyBdiKI48NiiQBAbkDL+9KJQAABBQAMYwgkIxcAAsA
+QCSBMGvYAdrmCOAASHOA4A30CiHAD+tyBdiKI5AAiiTBCoUDL+9KJQAAAhQAMc92gAD8Bxt4QSjF
+AEwlAIoEHkAR0vYKIcAP63IF2IojkAFVAy/viiTBCh3Yz3aAAPwHAaa4cAAUADHPdYAAeNBALYIA
+qXF6COAAAduA4A30ABQEMQQWBRAKIcAP63IF2BkDL++KIxAEQYaA4gDY0fYWJQEQYImGI/8NI7uB
+4wb0YYmA4wTyYrthqQHgUHCx9gDYxQYv8KLA4HjxwEoOL/CKIgQKocHPdYAATAgAlc92gAAU0slx
+SiAAIAAcBDQCCOAAAduA4A70ABUEEQohwA/rcgXYz3MAAAoMnQIv74olBAoAjoTgyiHLD8oiywfK
+IGsByiOLDwAADwzKJAsEeAIr78olywBSDm/wNNjwuDbymP+A4A/yCiHAD+tyBdjPcwAAFgxKJAAA
+UQIv7wolAAGLcUXYAdqKD6AAAduA4MohwQ/KIsEHyiBhAcojgQ8AABkMyiSBDwAARQAcAiHvyiUB
+BAAUADEB2YYg/g/A4MB5z3CAAPwHI6gb8M9wgABOCACQz3GAAGTUDtpU4BB4Mg+gAAHbgODKIcEP
+yiLBB8ojgQ8AACEMyiBhAb3znQUv8KHADngseClqANgPIEAAJ3BaeOB/DiDAAOB48cAeDQ/wz3CA
+APwHHYgF8EAnQAAPePhwz3CAAPwHHojwcI4ACwAA2QfYRCk+B1lwL3AZcYQvAwEncM9xgAAU0gAh
+BAAfFMQAGWEeEcUAOXAA3gAhjR+AABTS1X3njYhxBdrpcAUVwxDg/0AogRA0eYQvAQUncdR5x3GA
+AIDU2HEAqelwqHEH2gYVwxDX/wHmz36G5r4H6/8BHgIAQiJAEIDgQCBBEIYH7f8vebLx2QQP8OB4
+gOAb9Iwhwo02ACoAAdpKJIBx4HioIEAEz3OAAPXSRCo+BzIjQw5wccv2gOMH8obiB/IB4k96ANoD
+8GG6T3rgf0hw4HjxwBoMD/AacIDhOnKUACwAAN9acRUgwCNMIQCgoIgCiAvyz3aAAHhjFX4CuBR4
+x3CAAAxmCvDPdoAAsGMVfgK4FHjHcIAAtGYhiFEhAIAk8gUQwQAirgYQwAADripwqXHX/wCugODM
+IGKAyiAhABPyRCg+BwAhgH+AABTSxRCCAOEQgQACJYAQEHgHuA4I7/hCeQGuQiJBIIDhegft/wHn
+1QMP8PHAz3CAADCMBoCB4M9xgAD8BwLaB/RcqQDYHakB2B6pC/CC4AT0XKkB2AXwA9gcqQDYHale
+qUD/i//PcYAAHHsggc9wgACsaQHaxf/PcYAAIHsggc9wgAAIagDawP/RwOB+4HiB4PHAuHEY9Ewl
+AIDE9kwlgIPL9gohwA/rcgXYiiNSBY0H7+6Yc0AtgABkuMdwgAB4Yxvwz3CAAKxoMiBBAYwhw4/K
+IcEPyiLBB8ogYQHKI4EPAACbBFgH4e7KJMEAz3CAALBjNXjL8QJ5LXlMeVYhAXJHuThg4H8PeOB4
+8cCeCg/wCHYodUh3GnNPeRC5D3gIuAV5iiBHCKYIL/Clec9wgAD8BwGIgOD0AQIAgOfMICKgCfIs
+bS95z3CAAPwHP6gG8M9wgAD8B7+oqXHPcoAA/AcgGkIDwqohGsIDIhoCBMlwyP8AEIcA4YjPcIAA
+/AfdiB6IEHaeAQkARC8+By9xhC4DEQokQA4AIU0Oz3CAABjSHWVAL4IAVHqELgEVCiVADgAiQA4A
+IIgPgACA1AAmgx+AABgITCcAgMwnYoAm9BoVwBAA2QyrGxXAEEokgHEQqxiNFKuoIEAGFCBAEEGI
+c250ezV7x3OAAGTVABDAAFirFSVCEBmrARLAAAHhGqsAii95G6t+8AEVwBCA4Bj0ANpMq1CrVKtK
+JIBxANmoIMADE24UeDV4x3CAAGTVWKhZqFqoW6gB4S95ZPBsugAiQAF8uQAkRAAAIIYPgACA1AAk
+gA+AABjSGog6jelyo/8MqwAkgA+AABjSG4g7jelynv8Qq89ygAAY0gAkgAAYiDiNACSFAOlymP8U
+qwDbSiGAERQmywAUIMQQAROAEAEUgQDpcpH/M240eXV5ACGKD4AAZNUYGgIQABOAEAAUgQDpcor/
+GRoCEBUlywAVJcQQAROAEAEUgQDpcoT/GhoCEAATgBAAFIEA6XKA/xsaAhBCIUkQTCEAkAHjmgft
+/297AebPcIAA/AceiM9+EHZuBsz/ANnPcIAA/AcgqOEAD/DxwG4ID/CnwRpwWnFIdTpzCiMAIYtw
+z3GAAAB7qg4v9Rraz3GAAPwHAYEA3oDgtAAuAJhwAxGFAEwggKMB2s9xgAB40BYhgwMAi8IijABE
+II8A/X/xckL0TCNAoAT0QYsScgjyTCMAoDj0QYuA4jb0RCACAiO6UHUw9EwlQIAY9EQgAgFBKoKA
+BvREIA8EQS8+kQvygeIH9EQgAgQkuoHiA/IA2gLwAdpPegjwRCACBCS6gOIB2sB6geIQ9EwhAKYB
+2sIiigCGIP8OIrhQcA3ygOLMJWGQCfIB5pB2XAfF/4og/w8R8DIkQDSB4Ab0QnHWeQIRwAAJ8ILg
+BfQGE8AAA/AHE8AAwQfv76fA8cBuD+/vSiRAAAh2GnFId2h1uf+MIP+PEfTJcApx6XKpcwDdmHW0
+/4wg/48H9IogBwpiDe/vyXGpcJkHz+/gePjglvbPc4AAWGQGixByC/IHixByB/IOixByBfIPixBy
+BvSB4cwhooAB2APyANjgfvHA8g7v74oghwjPdoAA/AcSDe/vP44BjoDgdfQCjj+O8f7PcYAAtJfP
+cIAAGAhCIBAHIBaAEFaJEHIYFtIQDPQCjjSJMHAI9BkWwBAJIIAELyIFIB6O/Y4Qd6oACQAA3Uoj
+gCMajoDgDfJEL74TACVAHhgWwhAAIIEPgABA0EypM/BIIkAgLyEFIM9wgAB0ZKtgH47pcSEWghC+
+/wkgQQQteQAgwCPPcoAAhGSqYjAQgABCeAkgQQBEL74TACVFHh+OACWED4AAQNAMHEIA6XGpcsD/
+ACWCD4AAQNAMEsEAAnkMHEIAQiNTIEwjAKAB5XQH7f+vfQHnHo7vfxB3YgfM/0kGz+/geOHF4cYA
+Ec0AgOVE9gDdoKmA4BLy1OWE91PdoKnPcIAATGUUIE4DoI6gqgARwQA0eAGIEfDU5YT3U92gqc9w
+gACkZBQgTgOgjqCqABHBADR4AYgAq8HG4H/BxeB48cCeDe/vuHIIdyh1z3CAALSXz3aAAPwHIBaD
+EDaIcHGjwQDaY/Q0iAKOEHFf9BMWhhBMJgCABvKA5wT0RaY08FMlgJAE8oXgXAALAJDlhPaX5cT2
+ANoD8AHaTCYAgAfyIRaAEIDgANgC8gHYz3GAAFhkqWFEL74TJ3EAIYMPgABA0AwTxAAUIsED2WFs
+iQHZQMFBwEAmABVCwADYCHE2C+AA+HcCvbR9x3WAAAypgOdChQ7ygecU8oLnIvQFhlMiQQQSuAUg
+QgBCpRrwJYYEIoIP/wcA/iV6QqUS8AQigQ/8B/8BRYYJuvfxANkCvbR9ACWAH4AAFKkgoChyiiCU
+Db4K7+9IcQEF7++jwKHB8cCODM/vocFlwgh2KHXPcIAAugaFwYtyQCRDMACInv9ELr4WACVAHhQU
+wTDPd4AArNGYJ8EW+GCY5ZUgQQh4ACoAIKhTJYAQheBMAAoARiXNEa99HfABFIAwACaBH4AADKlS
+bVR6WWEgwgCpRC6+FgAlQB5EqRQUwTD4YJUgQQggqMlwqXGb/wHlr31TJYAQheCi9iDwARSCMBJt
+FHgAJoEfgAAMqThgQKggwkSoyXCpcZD/EPBCJQAWD3gBFIEwx3aAACSqArgUeB5mIMAorgyuCNwn
+BO/vocDxwKYLz++hwRpwSiEAIAAcQDSKIAcJwgnv7wpxz3CAAPwHAYiA4LX0z3CAAFhkMiATBM9w
+gAD8B92IHogQdlIBCQAqdwoiQCQC8Dp1RC6+EwAjQC4AIIEPgABA0AwRzQBMIACmu32tfVb2z3GA
+AExBGoE7gSR4USAAgg7yz3CAAPwHE4iLc8lxIgngAKlyAMACfa19z3CAABgIfLjYYCwQwQDPcoAA
+kAYAigXaqXN1/UokgHEA3agggAVzbnR7tXvPcoAAZNV5YjmJgOF6YgvyEHEQ8hBxE/aF5Vf2AeWv
+fQrwQiWSEC8ihyRhva99EfAbEs8AANkqdQzwgOVKIgAgyiVhEAXyQiVSEC8ihyQB2YDhLfLzbvR/
+FSdCE89xgABk1VthACGFABUnjxQ6Z/lhOYl5izBz+4rY9hsVggAEvwIjRADwfwS6LyQIAQIngxAi
+eGx4LyBGDtIOb/iIcQ54An8I5+5/RL/tf0wgAKaE9grn7X/JcApx6XJr/wHmz3CAAPwHHojPfhB2
+wgbM/3EC7++hwPHAHgrP789woAC0D3AQEACKIMcIz3GAAJAGKgjv7yCBz3eAAPwHAY+A4ADdLvTP
+cKAAtA+8oD6PHY8wcBD2z3OAAKzRf9oUIA4AfmZMrq2uAeAPeDBwBdpOrvb2AN0O3s9wgAB0ZKhg
+gf9hvoDmAeWvfTj3z3CAAJAGAIDPcaAAtA8Jp3AZAAT5Ac/vCHEFIYEPrd4AAK0Hr++KIIcJ4Hjx
+wOHFz3WAAJAGiiDHCZYPr+8ghc9xgAD8BwGJgOAM9ACFKYFNaDBywCBsAcwhDIAwD8n/xQHP789x
+AACt3mUHr++KIIcJ4HjxwAAWgEDPcYAA/AcYqQAWhEAAFoBAUCS+gRmpABaAQMohwg/KIsIHyiBi
+Acojgg8AAPkKlAWi7solwgBRJICBANjKIGEAG6nPcIAAuAYAkIDgBPJ5/rH/Mg3P77sFj//xwNoI
+z+8Idc92gAD8BwmOEHUodwT0CI4QdyDyqXBAJoEUGgqgAEAmwhQSjq96M44Yugi4BXqKIFQNwg6v
+70V5Mo5AJgATdg2gAFOOEo6iDKAAM46pruiu6QDP74Hg8cC4cRj0TCUAgMT2TCWAg8r2CiHAD+ty
+Bdie2/EEr+6Yc0AtgAAUeGy4x3CAAAxmHPDPcIAArGgyIEABjCDDj8ohwQ/KIsEHyiBhAcojgQ8A
+AKQAuASh7sokwQACuBR4x3CAALRm0cDgfvHAEgjP7892gAC6BgCOz3eAALgGII/g/0GIz3WAADgI
+47oglwbyAdgArYogxwNI8AKAgOAF8gDYAK2QuT7wUSIAgTHyz3KAALSXFooQcSv0AJZ0inBwJ/TP
+cIAAvAYAiFKKEHIf9M9wgAAcDwmAUSBAgRnyQYWA4gDbDvLPcKAALCAQgEJ413AxAQAtRPcB2kCt
+BPBgrQDaELqKIEcDRXkO8AGNgOAH8gHYAK2KIAcDBvAA2ACtkbmKIAcEdg2P77kHr+8AjeB4gODx
+wA70sv/PcaAALCAwgcdxSWsA0iKgUg2v74oghwWK8eB4gODxwNhxCvSo/wDZIqCKIMcFNg2v78hx
+fPHgePHA4cXPdYAAOAiKIEcGHg2v7ymNBNh2C6/7AdkIjSmN6P9hB4/v4HjxwM9xgAA4CIogxwb2
+DK/vKYnPcIAA9GXmD0/4WPHgeOHFUyANAKCpBCCBDwAGAABCIQGABCCAD0AAAADKIWIAIKrXcEAA
+AAAB2MB4AKvgf8HF4HjxwJIOr+/YcQomgJCIdcwjIoAG8kImBgEvJocByHF9/4Dmz3GAADgIA6Ei
+8iSIArk0eUOIA+FRIgCAAhCFAA30CiHAD+tyBdiKIwgGmHPRAq/uCiWAAQhhUSBAgAr0CiHAD+ty
+BdiKIwgH8vEBEIUAUSUAgMohwQ/KIsEHyiOBDwAAKQLKIGEB4vPhvdElIoHKIcIPyiLCB8ogYgHK
+I4IPAAAwAngCou7KJIIBUSUAkBHyUSXAgMohwQ/KIsEHyiBhAcojgQ8AADcCVAKh7sokgQEtBo/v
+4HjxwK4Nj++hwQh2KHcacgDdz3CgALQPcBARAIogxwC6C6/vyXHPcKAAtA+8oItxQCRCMEAkgzDp
+cK//TCAAoAX0SiQAAAnwz3CAAIyvAYiA4Pj1SiSAACDAARSCMMlxAhSDMLL/z3CAADgIKYiA4cwm
+QpAF8iOAqqiioeW/FvLPcYAAtJdWiVB2EPRUiVMnAxBQcwz0BCePHwAGAACA5wHaMonAejByBfKi
+qKGgoKiKIMcAJguv78lxz3GgALQPcBlABE0Fr++hwPHA8gyv74ogBwbPdoAAOAj+Cq/vJIYV3QSG
+MmgB4DR5x3GAALRmBKYCgYDgEfLPc6AALCBwg2J413BJawDSANrH90KhiiDHBcYKr+8giQSGquCE
+9wDYBKZhvYDlvAfN//0Ej+/xwM9xgACQBooghwGeCq/vIIHj/89wgAC4BgCQgOBcDML/VQTP/+B4
+8cBeDK/v2HGhwRpwi3FAJEIwQCSDMMhwYv8BFIAwgOAJ8gIUgDCA4AXyQiAQIS8gByQgwApx7P4B
+FIEwgOEE8qKIA/ChiIogxwE6Cq/vyHFAKAAmQC0CFAV6ARSAMAIUgTAIuAV6iiDHARoKr+9FeeG9
+0SXikAXyUSUAkQzyCiHAD+tyBdiKIw0DmHNlAK/uCiUABC0Er++hwOB48cDhxTj/z3CAABwPGIiE
+4M91gACMrwv0iiAPCsoJr++KIUoEAo0hhc//Ao0hhQHaeP8NBI/v4HjouAjyBCC+jwAAABgB2AP0
+ANjgfwCp4HjxwG4Lj++hwRpwAN7PcKAAtA9wEBEAz3CgALQP3KCKIEcBdgmv7wpxhCgGLwAhjX+A
+AOCwIfBAJQAXFiCEAwUUgACGIP6HGPIEhYtxQCSDMEAkTzDpchj/qBUAEOlx4/8gwAQUgQABFIIw
+AhSDMEokwAAe/wHmDJUQdr4Hxf+KIEcBFgmv7wpxz3GgALQPcBlABPMFz//geIQoCwwAIYF/gABg
+yigRgAAogRkF7/8A2vHAj/9CCc//qQLP/89xgAC0l89wgAC4BgCQVokQchX0z3CAALoGAJBUiRBy
+DfTPcIAAvAYAiDKJEHEH9M9xgAA4CAGJAqngfvHAegqP7xpwz3GAALSXz3aAALgGAJZWiRByz3WA
+ADgIEfTPcIAAugYAkFSJEHIL9M9wgAC8BgCIMokQcQP0Ao0C8ADYAa2K/s9wgAC8BkCIz3GAALoG
+AIkgjoDiAdrAegpzAN+Yd+P+A4UBiFEgAIEglgfyAdgDrYogRwME8OOtiiCHAxoIj+9VAo/v8cDu
+CY/vocEIdQDez3CgALQPcBAQAM9woAC0D9yg442KIAcB7g9v7+lxBJWLcUAkgzCA4AHYwHgvJwAA
+BYVAJEIwvP4KhUAkQTCH/4DnlSVDHtn3ViUAHPAggAOpcYAhCADUecC4BSDAAS8kBwAgiSDAARSC
+MAIUgzC7/gHm8Xaq94ogBwGOD2/v6XHPcaAAtA9wGQAEkQXP/+B48cBSCY/vz3CAABwPKBCQAKiA
+iiAHAmIPb+8KcVMlABAKcS7+AYhRIACByiHCD8oiwgfKIGIByiOCDwAAYQPKJMIApAVi7solAgRt
+AY/v4HjPcKAALCAwgM9wgAA4COB/IaDgePHA4cXPdYAAOAgAjYDgEfQ0/oDgDfSKIEcEAN32Dm/v
+qXGQ2ZC5A8igGEAAFPADjYDgEfLPcKAAAAQsiIwhAoAA3Qn0zg5v74oghwSR2ZC56/EB3RUBr++p
+cOB48cCWCI/vz3aAAHiuFI6B4BH0BNgCDW/7AdnPcIAAugYAiM9xgAC4BiCJSf4A2BSuLvD2joDn
+LPLPdYAAOAgKjWG4EHcX8lz+z3CAAPRlz3GAAKiuJYFBbwUpvgC6CW/4L3GKIIcGz3GAALgGSg5v
+7yCRz3CAALoGAJDqrQitz3CAALgGAJAJrQDYFq41joDhCPLPcIAAugYAiDb+ANgVrl0Ar+8B2OB4
+gODxwPTYCPRWCM/vUCABAPTYB/BKCM/vCHH02IC5DgqP79HA4H7geIDg8cA02Af0LgjP71AgQQQF
+8CYIz+9PIEEE6gmv7zTY7fHgePHAng9P7xpwCgjv7zDYmHApuFEgAIDKIcIPyiLCB8ogYgHKI4IP
+AADNAAgEYu7KJSIALNiqCa/vQCiBIAHfiiAPChpwzg+v7zDYmHApuFEgAIAX8ownD5o08iDdz3ag
+AMgfsKYB2EMeGBAA2C4Lr++NuLGmQiBAIIDgAecj95YPr+802E8gAQWVuVYJr+802IIPr+8s2Ah1
+eg+v7zTY9bgZ8kfYHg1v7wLZCiHAD+tyBdjp20okAAB5A2/uCiUAAQohwA/rcgXY2dtpA2/uSiUA
+APS4yiCCDwAARwDkDGLvyiFiAB0Hb+9BLQAU8cC2Dm/vNNgeD4/v8LjPd4AAxNUR8gDeyXCs/wHY
+tf+KJRAQyXC8/xQnjBNhvYDlALQB5jj36QZP7+B48cB6Dm/vAdihwQDeQMYA31oJL/+MvwPdCr34
+ZhB4i3GmCi//AdrPcYAAxN3UeWG9gOUAsQHmM/fCCw//pQZv76HA4HjPcaAAYB0SsRSR4H7xwCYO
+T+8Idih1SHcac44Or+802PC4EPRMIACgDPJhv4wn/58X8slw8/8CHRQQAebQfvfxTCAAoAXyz3GA
+AMTVBPDPcYAAxN37etR5Jgyv9KlwOQZv7wHY8cDGDU/vWnAacTpyaHAaCi/4CtmhaC4Or+9KcAQg
+QAQEIQEkMHAV8iDfz3agAMgf8KYK2EMeGBAA2JIJr++NuPGmYb2MJf+fJ/YA2ALwAdjRBU/v8cDT
+uE8gAQaZuf4Mr++KIBECDg2v74ogEQSbBc//4HjxwOHFSHVAKQIGUyDBBIogEQHWDK/vRXmKIBED
+ygyv76lxtQVP7+B48cA6DU/vCHYodez/CHLJcAPZpnrx/5EFT+/gePHAHg1P7wh2KHXl/whyyXAD
+2aV66v91BU/v4HjxwMy4ELhPIIEAn7kuD2/v9Nj02ALZz3MBAKCGKHLE/4DgyiAhAA8Fz//gePHA
+1gxv7yTYBg9v7wTZJNgB2c9zAACoYShyuv+A4MohwQ/KIsEHyiBhAcojgQ8AAAAByiQhACwBYe7K
+JQEBz3AAAAwwANmaudz/IN7PdaAAyB/QpQrYQx0YEADYbgiv74240aXPcAAADDAA2Zq5zP+KIAkE
+mg5v728hQwDFBE/v8cBKDG/vANkH2BpxOnAA3kAoACEUeMdwgACsvBUgjQMAlYwgAo0A34T2jCCF
+gsn2/9gAtYogEQM6Cm/v/9kBnbzgBfaMID+BR/bhtYogEQMiCm/vANkB5s9+jOa0B8v/QiFAIIDg
+QCBBIKIH7f8veTkET+/xwOHFz3CAAEwIAJDPcYAArLyo2gHdgCBECxB4mg3v/6lzgODKIcEPyiLB
+B8ogYQHKI4EPAADMAMokIQAwAGHuyiUBAdL/z3CAAGhWCQRv77Sg4HjxwI4LT+8ODc//z3aAAEwI
+ZtgibgHaTg3v/0hzgOAK9AohwA/rcgXY29uKJIEJNvACFgURTCUAgMwlgo8AAP//CvQKIcAP63IF
+2N7bzQcv7ookgQln2MlxAdoKDe//SHOA4Ar0CiHAD+tyBdjh24okwQkU8AGWJG4B2gHgEHjmDO//
+SHOA4KGWDPQKIcAP63IF2OTbQCVEEIEHL+5KJQAAAm0QeCZuAdq6DO//SHOA4Ar0CiHAD+tyoZYF
+2OfbQCWEEOzxNQNP7/HAqgpP76HBGnA6coDhaHbEACwAANiacRUgDSDPcYAATAgAFZMQAhWSELpw
+440hkQGNAdo4YBB4i3FiDO//SHOA4BPyABQAMUwhAKBAKoIgBCCBDwAAAP9HuVR6FvLHcoAADGYV
+8M9wgABMCMGQoY0KIcAP63IF2IojBAEAJkQT0QYv7golQAXHcoAAtGaA5gAawgQD8gKqAvABqlEg
+AIAT8oDmDPIDioC4A6oSbxR4G2Jji1hggbtjqOSqgOYE8iaqA/AlqkIkQSCA4UoH7f9AJUAgJQJv
+76HA4HjxwM9wgACsaQ7ZAdoA28b/z3CAAORpCdkB2khzwv/PcIAACGoq2QDaANu//89wgACwagvZ
+ANoB27v/0cDgfuB48cCH/+//Ig4P/zYIAABv//Xx4HjPcAEAwNzPcYAATEFhGRgAz3ACABBIgOBA
+IQIDBfIdohuBg7gboeB+8cBeCU/vo8FKIQAgi3EqcEogACEKci4L7/8qc4DgyiHBD8oiwQfKIGEB
+yiOBDwAA9wDKJEEExAUh7solAQQAFIUwz3GAAFQIABlCAUwlAIDKIcsPyiLLB8ogawHKI4sPAAD/
+AJQFK+7KJMsAAMBBKAICQSgOA1MixABTJsUQAhkCAQMZQgFMJMCAzCXsgMohyQ/KIskHyiOJDwAA
+BQFcBSnuyiBpAUEoAgRTIsYABBmCAUEoAgVTIsUABRlCAUwmQIDMJeGAyiHCD8oiwgfKIGIByiOC
+DwAACwEgBSLuyiSCAUEoAgZTIsQABhkCAUEoBQcHGUIBTCRAgMwlbIDKIckPyiLJB8ojiQ8AABEB
+7AQp7sogaQEEFIUwjCUBhLYALAABGUIBCiHAD+tyBdiKI4QFyQQv7phzz3WAAMT1AN8D8AHn739B
+KAECw7kwd3AACgAA3hLwQCmBIDR5ChSAMBUhQQEB5s9+FHm5YQAZBASAIAIjLyAIJADAQSgBBsO5
+AeEwdr4Hyv+CwQpwAtq2Ce//ANsLFIQwLygBAU4ghQcvJUcBTCXAgK4Hy/8KIcAP63IF2EUEL+6K
+I4QNQCFRIC8hRyRBKAEEw7kycXIHyf8F8EwmAIBkB8n/QSgBBcO5gOEKda4ALABKIAAgSiIAIAXw
+QCJSIC8ihyRBKAEDw7lScX4ADABKIQAgFfACvtR+ChSAMBUmThFAIVEgLyFHJBR+ACaAH4AAxPWg
+sIAlAhOwfQDAQSgBBwHhMnG2B8z/MLjDuAAgDgSCwalwAtr2CO//ANsLFIQwLygBAU4ghQcvJUcB
+TCXAgKQH6//PfgohwA/rcgXYhQMv7oojxQNAIFAgLyAHJEEoAQXDuRJxYAfJ/9PZCLkA2APez3OA
+AMT1ANqyaFR9fWU4tQHiT3qC4lYhAQgwebf2Yb6A5gHgD3gw9/kGL++jwIDg8cC4cMn2TCWAgwX2
+ANgAqQCqE/BMJYCIh/aMJQGAyiBsAPb2jCUBiYv2jCUCgwf2AtgAqQHYAKrRwOB+jCVChIb2jCVC
+iQPY9vYKIcAP63IF2IojBgTZAi/umHPgeOHF4cbPc4AAVAhGk1MiTYAX8oLlF/QRqwWTMKvEgynd
+Er0VJQwQwKQoi4DhBvJWIAEIMHk1fcClAeAFswPwE6syqwHiRrPBxuB/wcW4cFYhAAKA4PHAmHHE
+9owgAoCK9gohwA/rcgXYaQIv7oojhwnPcIAALHsUIAABgBABAQQpfgEvcsAQQAdCKgMEwbtSugQo
+fgEvcUIpAATBuFK5gePAImkAgeDAIWkAiCI+AH/cCSIAA4ghPgCJIcEPgODWICsIgOHWISsIzv+J
+8fHAVg0P76LBQMBBwkAoFAVAKRcFAN1AKhMFQCsSBQHeSiWAIal3BPAKdcp3AMAVuBN4FCDABbYJ
+7/cH2QIgUAMCIEAjpgnv9w7ZzH4KIUAuBCk+cC9wrH4AIQ11HWUBwBW4E3gUIIAEggnv9wfZAiDW
+AwImwCN2Ce/3DtkEKH4EL3HsfgAhwHQZYUItABVUubz/QiVVIEwlAKAB5owH7f/Pfv0EL++iwPHA
+ygwP7wh2GnHPdYAAVAjmlQrwzH8uCe/3QClAcUW4CnGu/yaVjCEQgLb2AQUP7/HAjgwP76HBOnEA
+34DgyiHBD8oiwQfKIGEByiOBDwAAegLKJMEACAEh7solwQPPcYAAVAhFseaxTCEAoMolzhNkAC4A
+yibOExp3WncE8Ml3GnVqcEAgUwCLcQHaGg6v/wDbABQNMS8jyCSpdim9yL6/5dklKRRMIgCgyiDC
+A8ohggPKIgIEpA7i/8ojQgPJcKlxhv9CIVEgTCEAoLIH7f9AIlIgyXCpccr/PQQv76HA8cDaCw/v
+mnAacc91gABUCMWNBI0eZpJ2yiHMD8oizAfKIGwByiOMDwAA2wLKJAwFTAAs7soljAMA3wDeIvAA
+2AitanCK2Spywv8IjVMnwRAYucO4HLgFec94ELgFeYogVA2uCS/vBSGBBC8hyAQQuYogVA2aCS/v
+BSFBBAHmz34AJQIURooBahB2W/ZALIAgFHj1eNR4z3OAAMT1EGMKIgCgMm/s80AgkwAvI8gk1HmA
+4jtjMBMRAcP1AdjC8QHn73+D53YHy/9lAw/v8cASCw/vocEIdXpxGnLPcYAAVAjFiQSJHmZydsoh
+zA/KIswHyiBsAcojjA8AACQDyiTMBHwH7O3KJYwDAN8A3iDwARSAMAEdEhAGEYEggOEBFIAwA/QB
+HRIQIMADFIIwARSBMBi4FLoFegIUgDAQuAV6iiCUDc4IL+9FeQHmz37PcYAAVAgAIQAEBogB4BB2
+dgAqAAAhEQRAK4AgFHj1eNR4z3GAAMT1NCESAFMnwBAYuM95ELkFeYoglA2GCC/vBSGBBEwiAKAA
+2Rbyi3FKcALaKgyv/wDbgOC19QohwA/rcgXYiiNMDgokgATFBu/tSiWAAAEdUhAGEYAggODA9QEd
+UhC88QHn73+D5zIHy/8P8eB48cDhxQDdoKOB4MwhIYAX8qDiRfagowDYCfDA4gbYBvZCIgAIQ7gC
+4ACjUHkQuRB9iiCUDfoP7+6leU0CD+/gePHAwgkv7wDYocFIdohyCiJAIQohgCEKwQogwCFMJkCA
+AKHMJmyQzCCsoM72CiHAD+tyBdiKI44NCiRABCEG7+0KJQAETCFAoMwgIaDKIcEPyiLBB8ojgQ8A
+ALwDBdju82hwhiD8A0S4ZN+EKAEJL3WAJQ8aw7t7Y3V7KMBEKr4MgeB9ZQIlTR4L9Ft6TXqLcypw
+CnHL/wDAFXgVeAJ9qXCiDa/3ZNnseAIlRB6J4MogagLKIgoASfaA4MogKwDKIgsAg/ZBaEAozyD1
+f89zgAAogxUnARBVf0whAKB5YftjDfSA5gb0qBEOhqgTAIYS8IoRDoaKEwCGDPCA5gb0kBEOgJAT
+AIAG8BgRDoAYEwCAKcGB4Yoh/gDAJkEQwCBBAMJ4iHEseC9wGg2v92TZuGDYYBINr/cK2SjgSCAB
+AIwhQ4LKIYoPAADIAM9wgAAUfpkgQQc1eMAQAAaMIkKgJbgQeEX2jCIBoA32CiHAD+tyBdiKI5EP
+iiRCAOUE7+0KJYAEz3GAACR8WSHBDxUhgQSAEQEGLbkweSx4CsBCKYR1jCTHjwAYAAHKIc0PyiLN
+B8ogbQHKI40PAACdBKAE7e3KJQ0EiiCUDSYO7+6IcVEAL++hwOB+AAAAAAAAAAAAAAAAAAABAAAA
+AAAAAMAPgABUEIAAAISAABAAgACMBIAABAjAEAoAE2RcBYCBAADAFgQBE2IPXAAiCgAAQAAGAHAa
+AABhAAATJAAAEyUAAMAXyCDAEHBFwBAQCMAQAAATJAAAEyUECMARDxQVIgQAFSb7/zAyAwATJBgI
+wBEcCMARDxQVIgEAFSYEADAwMAATJOwcwBEDABMkUBTAEQQYwBEAABMkEEXAERgIwBEPfBMiCADM
+EQAAEyUAABMkNEjHEQ97EyIBABMwBCjAEQ8UFSIEABUm3AaAgQAAwBbCLBMkBCjAEQJGEyQEKMAR
+wl8TJAQowBEPTRMiBBDFEQIAEyTwHMARAQATJOwcwBEAABMkcAATJRAcwBEAABMlAAATJOAcwBEB
+ABMkJBDAEQAAACEAABMlAAATJA9FACIAXAA5AwAAYgJgAGIAAFg4XQAAYSQQwBEAgBMkOBzAEQ9z
+EyKCARMwBCjAEQ90EyICAhMwBCjAEQ91EyJCAhMwBCjAEQ8UFSIBABUmD3ITIggAzBEPRAAiCgAA
+QABAAHAOAABhAAATJQIAEyTsHMARD3YTIhgIyhEJABNAHAjKEQkAE0AgCMoRD3gTIgQAyhEAAAEk
+AAABJQYAAGEPdhMiLEjHEQ94EyIAAMYRAwABJAAAASUAABMlwiwTJAQowBECRhMkBCjAEcJfEyQE
+KMARD0UAIgBcADknAABkAAATJAEAEyU4HMARD3cTIuAcwBEPARMiBAjAEQ8CEyIEKMARDwcTIgQo
+wBEPBBMiBCjAEQIAcXAHAABh/wATJQIQEyQEKMARAAATJQAAEyTISccRBgAAYQAAEyUCEBMkBCjA
+EQAAEyVJABMkyEnHEQ9wEyIBABMwBCjAEQMAEyQAABMlBAjAEQAAEyQ4RcARDwMTIhgowBEEAABh
+AABYOAAAEyQBABMlOBzAEQAAACGcg4CBAADAFjwEwBEgBYCBAADAFgQBG2IQBMAQAwAbJFQEwBEk
+BMARCATAEFyDgIEAAMAXCATAEDiDgIEAAMAXAAAbJQMcG2JAABskMBzAEQUAAGEkBYCBAADAFg8b
+GSIIBKCBOPDEgAAAGyQCABslOBzAEQAAACEgBYCBAADAFkwEwBEkBYCBAADAFg8bGSJIBKCBOPDE
+gAAAGyQCABslOBzAEQAAACEAAACFIAWAgQAAwBYPGwQiEAQbZg8BG2gUHMAQCgAbQAQAG24DAABh
+DxwdIgEAHSb5DwBhZAwAEADABhEBAAQn/AAEZAAAGyQCABslOBzAEQAAACEAABslQAAbJDAcwBEA
+AAAhDxwdIhgBHSYYAMcQmKCAgQAAwBcgAMcQoKCAgQAAwBcAAAAhlEmAgQIAXG4RAABh+EHEEA8b
+CSIACwk5AgAKYgMBCmIEAgpiAAAJQAQAAGEJAAlAAgAAYQoACUAAAABhAgAJQQAJGigAAMAWAQAb
+JgAAwBcEAB0mAQAIJ+kACGQAAAAhAAAAAIwBAAABAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ6AAAA
+PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFJyAAAAAAAAAAAAAAAAAAAEA
+AAAHAAAAAAAAAMAAkADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAaKuAAAAA
+AAAAAAAAQK+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAIi0gAAYoAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wEAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADI
+xIAACPsBAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaKuAAEQE
+AgAAAAAAaKuAADgLAgAAAAAAAAAAAGirgADQDAIAAAAAAAAAAAAAAAAAaKuAAAAAAAAAAAAAAAAA
+AP8AAAAABwAAAAAAAAAAAAAEIAIABCACAAQgAgAIIAIAAAAAAB0AAAAAAAAAAAAAAAAAAAAAAAAA
+f38AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECBAgACBAgAAAAAAAAAAABAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAkAABUAAADsRYAAzCsAAMwr
+AADMKwAAgEIAAMwrAADMKwAAzD0AAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsA
+AOweAACcIAAAtCAAACQiAACsIgAAKCIAAMwrAADMKwAA6E4AALBQAACcUQAAzCsAAMwrAADMKwAA
+ZE0AAHBkAABsZAAAxGQAAMwrAADMKwAAzCsAAIxEAADMKwAAqGQAAMwrAADMKwAAzCsAAMwrAADM
+KwAAzCsAAMwrAADMKwAAhEIAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwr
+AADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAfEUA
+AMwrAADMKwAAzCsAAMwrAADMKwAAZEYAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAA
+zCsAAMwrAADMKwAArGsAAMwrAAAUbQAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAAC8
+bwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAAC4hAEAEIgBAMwr
+AABkigEAzCsAABSMAQCAVwEAzCsAAMwrAABoUgAAzCsAAMwrAADMKwAAzCsAAMwrAACs4gEANPYB
+AMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAmB0CAMwrAADMKwAA
+zCsAAJgCAgDMKwAAuAYCAMwrAADQLgIAzCsAAOAlAADkJQAAzCsAAMwrAAB0FwIA6HIAAMwrAADM
+KwAAzCsAAPD/AQDMKwAAzCsAANBQAQD4owEAzCsAAMwrAADMKwAA6KwBAKBYAQDMKwAAzCsAAMwr
+AADMKwAAzCsAAMwrAACgtwEAzCsAAGwUAgBwFAIAfBQCAIAUAgB0FAIAeBQCAIQUAgDMKwAAzCsA
+AMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAABMVAAAzCsAAMwrAADMKwAAzCsAAMwrAADAEwIA
+EBQCAHhIAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADM
+KwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwr
+AADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAAzCsAAMwrAADMKwAA+EkAAIBKAAAUSwAAyEsA
+AMCBAACgSwAAzCsAAMwrAADMKwAAzCsAAMwrAADwSQAA9EkAAMwrAADMKwAAmFIAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMwMAADMDAAAzAwAAMwMAADMDAAA
+zAwAAMwMAADMDAAAzAwAAMwMAADMDAAAzAwAAMwMAADMDAAAzAwAAMwMAADMDAAAzAwAAMwMAADM
+DAAAzAwAAMwMAADMDAAAzAwAAMwMAADMDAAAzAwAAMwMAADMDAAAzAwAAMwMAAD8DQAAAAAAAChe
+AQDMDAAA3AkAAMwMAADMDAAAzAwAAAwKAAAgQAEAAIQAAMwMAADMDAAARAoAAEQKAABECgAARAoA
+AEQKAABECgAARAoAAMwMAADMDAAAzAwAAMwMAAA8DAAAzAwAAMwMAADMDAAAzAwAAMwMAAAADgAA
+zAwAAMwMAADACQAAAwAAAIQRAgACAAAAcGwBAAQAAAAkbQEABQAAABwOAAAGAAAAtDQAAAgAAADs
+EwIAEwAAAJz8AQAJAAAAZAgCAAoAAACIFAIADgAAAAChAQAPAAAATI4BABAAAACEjgEAGQAAAJBd
+AQANAAAA/IUBABcAAADkcgAAEQAAAECCAAASAAAA0E8BAAEAAAAYAgIAFAAAAKy0AQAVAAAALKQB
+AAcAAAAscAAAFgAAAMAuAgAYAAAA+JwAABoAAAD8DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAQAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ
+AAAAAQEAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////8AAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADhAw4e4eEDDh7h
+4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e4eEDDh7h4QMOHuEAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8PDw8
+FRUVFTw8PDwAAAAAAAAAAAAAAAAAAAAAPDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDwV
+FRUVPDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAAADw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8
+PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAAAAAAAAAAAAAAAACQBgAAMfqvAJAGAAAx+q8AkAYA
+ADH6rwCQBgAAMfqvAJAGAAAx+q8AkAYAADH6rwCQBgAAMfqvAJAGAAAx+q8AQwUAADH6rwBDBQAA
+MfqvAEMFAAAx+q8AQwUAADH6rwBDBQAAMfqvAEMFAAAx+q8AQwUAADH6rwBDBQAAMfqvAAAAAADe
+wwkAAAAAAAAAAAAAAAAAvC0BAAEAAACsRYAAAAAAAAAAAAAAAAAAXC4BABUAAADsRYAAAAAAAAAA
+AAACAAAAAwAAAAAAAAAIAAAAAAAAADCMEQAgvwIAAAAAANAuAQB4LwEAhDABADAyAQCEMAEAMDIB
+AAQ0AQCMNAEA8DQBAICAgICAgICAAYACgICAgIAAAAAA8DoBAPA6AQAAAAAAAAAAAAAAAAAAAAAA
+8DoBAPA6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArEWAAKxFgACkIKAAOCCgAAEAAAD8
+////AAAAAAAAAADMRYAAzEWAAKggoAA8IKAACAAAAPP///8AAAAAAAAAAOxFgADsRYAArCCgAGwg
+oAAwAAAAz////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAA
+AAAAAADkUAEABQAAAOxFgAAsVgEAAP8DAExWAQAA/wUAOFcBAAD/LQBcVwEAAP89ABRXAQAA/wQA
++FYBAAD/JQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxcAQAGAAAArEWAAAAA
+AAAsAQAAXgEAAAEAAAABAAAAAQAAAAEAAAADAAAAAAAAAAAAAAAYZAEAIGUBAJxlAQCsYAEA1F8B
+APBmAQB4ZwEAvGcBABBoAQAAAAAAAwAAAAIAAAADAAAAAwAAAAMAAAABAAAAAAAAAAEAAAAAAAAA
+AAAAAAAAAAD0bQEACgAAAKxFgAAAAAAAAAAAAAAAAACAbgEACgAAAKxFgAAAAAAAAAAAAAAAAAA0
+bwEACgAAAKxFgAAAAAAAAAAAAAAAAABUcAEACgAAAKxFgAAAAAAAAAAAAAAAAAC4bgEACgAAAKxF
+gAAAAAAAAAAAAAAAAADMbwEACgAAAKxFgAAAAAAAEAAAAACAAAAAAKAAECcAAOgDAADoAwAAAAAA
+AAAAAAAAAAAAMEIBAAoAAACsRYAAAAAAAAAAAAAAAAAAMEIBAAoAAACsRYAAAAAAAAAAAAAAAAAA
+MEIBAAoAAACsRYAAAAAAAAAAAAAAAAAAMEIBAAoAAACsRYAAAAAAAAAAAAAAAAAAMEIBAAoAAACs
+RYAAAAAAAAAAAAAAAAAAMEIBAAoAAACsRYAAAAAAAAAAAAAAAAAAMEIBAAoAAACsRYAAAAAAAAAA
+AAAAAAAAMEIBAAoAAACsRYAAAAAAAAAAAAAAAAAAMEIBAAoAAACsRYAAAAAAAAAAAAAAAAAAMEIB
+AAoAAACsRYAAAAAAAAAAAAAAAAAAMEIBAAoAAACsRYAAAAAAAAAAAAAAAAAAMEIBAAoAAACsRYAA
+AAAAAAAAAAAAAAAA8IkBAAoAAACsRYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAGSRAQBwkgEAXJUBABCYAQCQmgEAFJ4BACCUAQA0BYAAMKuAABgAAADwqoAAAAAAAAAAAAAA
+AAAAAAAAAAAAAACooAEABgAAAKxFgAD/////AAAAAP//////////AAAAAAAAAAAAAAAAiKMBAAUA
+AADsRYAAbgBuAGkAwACgAFAAgAC+AFABfQA+AG4AbgBpAMAAoABQAIAAvgBQAX0APgAAAAAAAQEA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgEBAAIBAAECAgIAAQEAAgECAQIAAgABAgP//wAAuQHf
+ALEAGwAWARsAfAEbAK8AGwAUARsAegEbAGwAoADRAKAANwGgAG8AgwBxAIMAdgCDAHMAMwBuADMA
+cAAzAHIAMwDXADMAPQEzANQBBgDQAQAAfgA8AOMAPABJATwAeABJAN0ASQBDAUkAfwBaAOQAWgBK
+AVoAqgA/AKsAAQAPAT8AEAEBAHUBPwB2AQEAeQBqAN4AagBEAWoAqAAAAA0BAABzAQAApgA3AKcA
+AQALATcADAEBAHEBNwByAQEABAAIAJwBzACdAcwAngHMAJ8BzADVAcwA1gHMANcBzAC0AEcAGQFH
+AIABRwCQACIA9QAiAFsBIgChAIgABgGIAGwBiACUAAAAlQAAAJgAwACZAKAAlgCQAJcAAACUAAEA
+lQABAJgAwACZAKAAlgCQAJcAAACUAAIAlQADAJgAwACZAKAAlgCQAJcAAACUAAMAlQAHAJgAwACZ
+AKAAlgCQAJcAAAD6AAAA+QAAAAIBkAADAdMAAAGDAP4AEwD8ADMA/QB3APoAAQD5AAEAAgGQAAMB
+0wAAAYMA/gATAPwAMwD9AHcA+gACAPkAAwACAZAAAwHTAAABgwD+ABMA/AAzAP0AdwD6AAMA+QAH
+AAIBkgADAdMAAAGDAP4AEwD8ADMA/QB3AF8BAABhAQAAaAGQAGkB0wBmAYMAZAETAGIBMwBjAXcA
+XwEBAGEBAQBoAZAAaQHTAGYBgwBkARMAYgEzAGMBdwBfAQIAYQEDAGgBkABpAdMAZgGDAGQBEwBi
+ATMAYwF3AF8BAwBhAQcAaAGQAGkB0wBmAYMAZAETAGIBMwBjAXcAhQAAAIYAAACHAFAAiAAAAIkA
+oACKAAAAiwDQAIwAAACFAAEAhgABAIcAUACIAAAAiQCgAIoAAACLANAAjAAAAIUAAgCGAAMAhwBQ
+AIgAAACJAKAAigAAAIsA0ACMAAAAhQADAIYABwCHAFAAiAAAAIkAoACKAAAAiwDQAIwAAADrAAAA
+6gAAAOwAUADtAAAA7gCgAO8AAADwANAA8QAAAOsAAQDqAAEA7ABQAO0AAADuAKAA7wAAAPAA0ADx
+AAAA6wACAOoAAwDsAFAA7QAAAO4AoADvAAAA8ADQAPEAAADrAAMA6gAHAOwAUADtAAAA7gCgAO8A
+AADwANAA8QAAAFEBAABQAQAAUgFQAFMBAABUAaAAVQEAAFYB0ABXAQAAUQEBAFABAQBSAVAAUwEA
+AFQBoABVAQAAVgHQAFcBAABRAQIAUAEDAFIBUABTAQAAVAGgAFUBAABWAdAAVwEAAFEBAwBQAQcA
+UgFQAFMBAABUAaAAVQEAAFYB0ABXAQAA+/8AAP//AAC5Ad8AsQAbABYBGwB8ARsArwAbABQBGwB6
+ARsAbACgANEAoAA3AaAAbwCDAHEAgwB2AIMAcwAzAG4AMwBwADMAcgAzANcAMwA9ATMA1AEGANAB
+AAB+ADwA4wA8AEkBPAB4AEkA3QBJAEMBSQB/AFoA5ABaAEoBWgCqAD8AqwABAA8BPwAQAQEAdQE/
+AHYBAQB5AGoA3gBqAEQBagCoAAAADQEAAHMBAACmADcApwABAAsBNwAMAQEAcQE3AHIBAQAEAAgA
+nAHMAJ0BzACeAcwAnwGIANUBzADWAcwA1wHMALQARwAZAUcAgAFHAJAAIgD1ACIAWwEiAKEAiAAG
+AYgAbAGIAPoAAAD5AAAAAgGXAAMB0AAAAY0A/gARAPwAMwD9AHcA+gABAPkAAQACAZcAAwHQAAAB
+jQD+ABEA/AAzAP0AdwD6AAIA+QADAAIBlwADAdAAAAGNAP4AEQD8ADMA/QB3APoAAwD5AAcAAgGX
+AAMB0AAAAY0A/gARAPwAMwD9AHcAXwEAAGEBAABoAZcAaQHQAGYBjQBkAREAYgEzAGMBdwBfAQEA
+YQEBAGgBlwBpAdAAZgGNAGQBEQBiATMAYwF3AF8BAgBhAQMAaAGXAGkB0ABmAY0AZAERAGIBMwBj
+AXcAXwEDAGEBBwBoAZcAaQHQAGYBjQBkAREAYgEzAGMBdwDrAAAA6gAAAOwAVQDtAAAA7gCqAO8A
+AADwAN0A8QAAAOsAAQDqAAEA7ABVAO0AAADuAKoA7wAAAPAA3QDxAAAA6wACAOoAAwDsAFUA7QAA
+AO4AqgDvAAAA8ADdAPEAAADrAAMA6gAHAOwAVQDtAAAA7gCqAO8AAADwAN0A8QAAAFEBAABQAQAA
+UgFVAFMBAABUAaoAVQEAAFYB3QBXAQAAUQEBAFABAQBSAVUAUwEAAFQBqgBVAQAAVgHdAFcBAABR
+AQIAUAEDAFIBVQBTAQAAVAGqAFUBAABWAd0AVwEAAFEBAwBQAQcAUgFVAFMBAABUAaoAVQEAAFYB
+3QBXAQAA+/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAi3AQCU2AEA
+9LSAAEAFAAAAAAAACLcBADS4AQA0uoAA+AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGzdAQBw
+2wEALLyAAFQAAAAAAAAACLcBAKDbAQCsvIAAUAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAi3
+AQC01wEAWFeAAFABAAAAAAAACLcBAMzZAQDgBoAAAgAAAAAAAAAItwEAJNoBAOQGgAAEAAAAAAAA
+AGjdAQA0uAEAgLyAACoAAAAAAAAACLcBAMDaAQAAAAAAAAAAAAAAAAAItwEAgNoBAOgGgAAEAAAA
+AAAAAAAAAAAAAAAAAQACAAIAAwAEAAQABQAGAAYABwAIAAgACQAKAAoACwAMAAwADQAOAA4ADwAm
+ACcAKAAoACkAKgBGAEYARwBIAEgASQBKAEoASwBMAGgAaQBqAGoAawBsAGwAbQBuAG4AbwBwAHAA
+cQByAHIAcwB0AHQAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQAPAD8AAAAA
+AAAAAAAAAAAAAAABAAIAAgADAAQABAAFAAYABgAHAAgACAAJAAoACgALACQAJAAlACYAJgAnAEQA
+RABFAEYARgBHAEgASABJAEoASgBLAEwATABNAGoAagBrAGwAbABtAG4AbgBvAHAAcABxAHIAcgBz
+AHQAdAB1AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgAOAD8AMKoBABLS
+AAAAAAAA//8PAPDFAQC2AAAAAAAAAP8AAADwxQEAtwAAAAAAAAD/AAAA8MUBALgAAAAAAAAA/wAA
+APDFAQC5AAAAAAAAAP8AAADwxQEAugAAAAAAAAD/AAAA8MUBALsAAAAAAAAA/wAAAPDFAQC9AAAA
+AAAAAP8AAADwxQEAvgAAAAAAAAD/AAAA8MUBAL8AAAAAAAAA/wAAAPDFAQDAAAAAAAAAAP8AAADw
+xQEAwQAAAAAAAAD/AAAA8MUBAMIAAAAAAAAA/wAAADCqAQAT0gAAAAAAAP//DwDwxQEAGwEAAAAA
+AAD/AAAA8MUBABwBAAAAAAAA/wAAAPDFAQAdAQAAAAAAAP8AAADwxQEAHgEAAAAAAAD/AAAA8MUB
+AB8BAAAAAAAA/wAAAPDFAQAgAQAAAAAAAP8AAADwxQEAIgEAAAAAAAD/AAAA8MUBACMBAAAAAAAA
+/wAAAPDFAQAkAQAAAAAAAP8AAADwxQEAJQEAAAAAAAD/AAAA8MUBACYBAAAAAAAA/wAAAPDFAQAn
+AQAAAAAAAP8AAAAwqgEAFNIAAAAAAAD//w8A8MUBAIIBAAAAAAAA/wAAAPDFAQCDAQAAAAAAAP8A
+AADwxQEAhAEAAAAAAAD/AAAA8MUBAIUBAAAAAAAA/wAAAPDFAQCGAQAAAAAAAP8AAADwxQEAhwEA
+AAAAAAD/AAAA8MUBAIkBAAAAAAAA/wAAAPDFAQCKAQAAAAAAAP8AAADwxQEAiwEAAAAAAAD/AAAA
+8MUBAIwBAAAAAAAA/wAAAPDFAQCNAQAAAAAAAP8AAADwxQEAjgEAAAAAAAD/AAAAMKoBAAjSAAAA
+AAAA//8DAHCqAQAAggAAAAAAAP8BAABwqgEAAYIAAAAAAAD/AQAAMKoBAAnSAAAAAAAA//8DAHCq
+AQACggAAAAAAAP8BAABwqgEAA4IAAAAAAAD/AQAAMKoBAArSAAAAAAAA//8DAHCqAQAEggAAAAAA
+AP8BAABwqgEABYIAAAAAAAD/AQAAMKoBAAbSAAAAAAAA/wEAADCqAQAH0gAAAAAAAP8DAAAwqgEA
+BtIAAAkAAAAA/gMAMKoBAAfSAAAKAAAAAPwPADCqAQAG0gAAEgAAAAAA/AcwqgEAB9IAABQAAAAA
+APA/MKoBABXSAAAAAAAA/wMAADCqAQAM0gAAAAAAAP8BAAAwqgEAFdIAAAoAAAAA/A8AMKoBAAzS
+AAAJAAAAAP4DADCqAQAV0gAAFAAAAAAA8D8wqgEADNIAABIAAAAAAPwHMIAAAKqqqqoxgAAAqqqq
+qjKAAAAAqqqqM4AAAAAAAAA0gAAAAAAAADWAAAAAAAAANoAAAAAAAAA3gAAAAAAAADiAAAAAAAAA
+OYAAAAAAAAA6gAAAAAAAADuAAAAAAAAAPIAAAAAAAAA9gAAAqqoKAD6AAACqqqqqP4AAAKqqqqpA
+gAAAAAAAADCAAACqqqqqMYAAAKqqqqoygAAAAKqqqjOAAAAAAAAANIAAAAAAAAA1gAAAAAAAADaA
+AAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAAAAAAA7gAAAAAAAADyAAAAAAAAAPYAA
+AKqqCgA+gAAAqqqqqj+AAACqqqqqQIAAAAAAAAAwgAAAAAAAADGAAAAAAAAAMoAAAAAAAAAzgAAA
+AAAAADSAAACqqqqqNYAAAKqqqqo2gAAAAAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAAADqAAACq
+qqoKO4AAAKqqqqo8gAAAAAAAAD2AAAAAAAAAPoAAAAAAAAA/gAAAAAAAAECAAAAAAAAAMIAAAAAA
+AAAxgAAAAAAAADKAAAAAAAAAM4AAAAAAAAA0gAAAqqqqqjWAAACqqqqqNoAAAAAAAAA3gAAAAAAA
+ADiAAAAAAAAAOYAAAAAAAAA6gAAAqqqqCjuAAACqqqqqPIAAAAAAAAA9gAAAAAAAAD6AAAAAAAAA
+P4AAAAAAAABAgAAAAAAAADQFgAAwq4AAGAAAAPCqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg+AEABgAAAKxF
+gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ADQFgAAwq4AAGAAAAPCqgAAAAAAAAAAAAAAAAAAAAAAAAAAAABQEAgAGAAAArEWAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAWAADCrgAAY
+AAAA8KqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiBACAAQAAACsRYAAAAAAAAAAAAAAAAAAWA8CAAQA
+AACsRYAAAAAAAAAAAAAAAAAAUBECAAYAAACsRYAAAAAAAAAAAAAAAAAAWA8CAAQAAACsRYAAAAAA
+AAAAAAAAAAAAiBACAAQAAACsRYAAAAAAAAAAAAAAAAAAWA8CAAQAAACsRYAAAAAAAAAAAAAAAAAA
+iBACAAQAAACsRYAAAAAAAAAAAAAAAAAAWA8CAAQAAACsRYAAAAAAAAAAAAAAAAAAUBECAAYAAACs
+RYAAAAAAAAAAAAAAAAAAWA8CAAQAAACsRYAAAAAAAAAAAAAAAAAAiBACAAQAAACsRYAAAAAAAAAA
+AAAAAAAAUBECAAYAAACsRYAAAAAAAAAAAAAAAAAAiBACAAQAAACsRYAAAAAAAAAAAAAAAAAAiBAC
+AAQAAACsRYAAAAAAAAAAAAAAAAAAUBECAAYAAACsRYAANAWAADCrgAAYAAAA8KqAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU
+BQAAAAAAAAAAAAAAAAAAAAAA/wD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIDBAQEBAQFBgcICAgICAkKCwwNAAAABQYHCA0O
+DxAVFhcYGQAACg0RFAoNERQZGRkZCgoAAAAAAAAGBgYGCQkJCQAGAABuO2g7YjtcO246aDpiOlw6
+bjloOWI5XDluK2grYitcK24qaCpiKlwqbiloKWIpXCluG2gbYhtcG24aaBpiGlwabhloGWIZXBlu
+GGgYYhhcGG4XaBdiF1wXbhZoFmIWXBZuFWgVYhVcFW4UaBRiFFwUbhNoE2ITXBNuEmgSYhJcEm4R
+aBFiEVwRbhBoEGIQXBBXEFIQTRBJEG4BaAFiAVwBbgBoAGIAXABuO2g7YjtcO246aDpiOlw6bjlo
+OWI5XDluOGg4YjhcOG43aDdiN1w3biloKWIpXCluKGgoYihcKG4naCdiJ1wnbhloGWIZXBluGGgY
+YhhcGG4XaBdiF1wXbgloCWIJXAluCGgIYghcCG4HaAdiB1wHbgZoBmIGXAZuBWgFYgVcBW4EaARi
+BFwEbgNoA2IDXANuAmgCYgJcAm4BaAFiAVwBbgBoAGIAXAAAAAAAAAAAAAAAAAAAMQIACAAAAOxF
+gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////////AAH/
+/wID////BP//////////////////////Bf8G/wf/CP8J/wr/C/8M////Df///w7///8P////EP//
+////////////////////////////////////////////Ef///xL///8T////FP///xX///8W////
+F////xj///8Z////Gv///xv/////HP///x3///8e////H////yD///8h////////////////////
+//8iIyT/JSYn//8o////Kf//////////////////////////////////////////////////////
+////////////////////////AQQAAAIFAQADBgIABAcDAAUIBAAGCQUABwoGAAgLBwAJDAgACg0J
+AAsOCgAMDwsADRAMAA4RDQABQAAEAkEBBANCAgQEQwMEBUQEBAZFBQQHRgYECEcHBAlICAS3EyIA
+uBQjALkVJAC7FiUAvBcmAL0YJwDAGSgAxBopAAcbAAAIHAEACx0CAAweAwAQHwQAIiEFACQiBgAm
+IwcAKCQIAColCQAsJgoALicLADAoDAA0KQ0AOCoOADwrDwBALBAAZC4RAGgvEgBsMBMAcDEUAHQy
+FQB4MxYAfDQXAIA1GACENhkAiDcaAIw4GwCROhwAlTsdAJk8HgCdPR8AoT4gAKU/IQAkSQYCLEoK
+AjRLDQE8TA8BZE0RAWxOEwF0TxUBfFAXAYRRGQGVUh0BnVMfAQAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwA/AAEAAAAP
+AD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAIAAAAPAD8AAQAAAAAA
+AAABAAAAAgAAAAMAAAAAAAAABAAAAAIAAAAFAAAADxQZHigKBQDBCQGlADw4NDAsKCQgHBgUEAwI
+BAAMCAQAPDg0MCwoJCAcGBQQDAgEAggADgAAAA4BAQABAgEBAQAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+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/KjWbTosAQEBAQEBAQECAgICAgIC
+AgMDAwMDAwMDBAQEBAQEBAQBAgICAgICAwMDAwMDAwMDAwMDAwMEBAQEBAQEBAQEBAQEBAQEBAQE
+BAQEBAQAAAAAAQECAQICA3//Bw8fPwEDAQMPBwEHDx8/f///BQAHAgMEBgZ00UUX6KKLLg0PBQcJ
+CwEDChQ3blVVVQFLaC8BVVVVBeM4jgOqqqoCcRzHAaqqqgrHcRwHDw8PBwYHAgMEBQABCAkLCigA
+KAAwACwALAAoADwANAAoACgANAAwACwALABEADwAQAA8AIwAbABYAEgA9ACwACwALAA8ADQAMAAs
+AFQARABUAFQAbABgAFwAVACMAHgAOgECAdUA3wDaAKIAdQB/AGoBGgHZAOgACgG6AHkAiACKBSoD
+OQGoAYoFygLZAEgBygFKAeIA+QDKAeoAggCZAPQCRAK1AdUBlAKEAfUAQQKsAJAAhACAAHgAeAB4
+AHQAZuYAAJ3YiZ1O7MRONEiDNCd2YicapEEaEzuxExEYgREP/MAPTuzETid2YicapEEaEzuxEw3S
+IA2JndgJCIzACAd+4Ac0SIM0GqRBGhEYgREN0iANCIzACAZpkAawstUFBVRABSd2YicTO7ETDdIg
+DYmd2AkGaZAGxE7sBARGYAQDP/ADqqqqqhqkQRoTO7ETD/zADxEYgREN0iANCqiAChM7sRMP/MAP
+D/zADw3SIA0LtEALC7RAC4md2AkN0iANCqiACgqogAoIjMAIB3iABwd4gAcGaZAGD/zADw3SIA0L
+tEALDdIgDQu0QAuJndgJCIzACImd2AkIjMAIB37gBwd+4AfBLCkHCqiACgiMwAgHeIAHCIzACAd4
+gAcGaZAGsLLVBQZpkAawstUFBVRABQVUQAXWHcYEQAOABsAJAA2AEwAaQB2AIIAGAA2AEwAaACcA
+NIA6AEHACYATQB0AJ4A6AE7AV4BhmQMzB9kKcw6mFeYcgCAZJDMHcw6mFeYcWSvMOQBBM0jZCqYV
+gCBZKwBBplaAYVlsMAAAADYAAAAMAAAAEgAAABgAAAAkAAAABgAAAAkAAAAAAAAAAAAAABggFBQO
+DhQUBQYBAgMEAAAAAQECAQICAwQMDAgEDAQEQAAAAIAAAAAAAQAAAAIAAEAAAAAABAAAQAAAAEAA
+AAAQERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uL0BBQkNERUZHSElKS0xNTk9QUVJTVFVW
+V1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8zEwAAAAcHDwcPDxctAA8g
+APBhAAAAAAAAAAAAAAECBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTM6MDE6MDkAAAAATy6wAGqworCSsGMAAaiodgCojpeo
+qFsACQAAAAIAAAAAAAAAAAAAAAkAAAACAAAAAAAAAAAAAAAJAAAAAwAAAAEAAAAJAAAACQAAAAIA
+AAACAAAACQAAAAECAQIDBAAABQYHCAkKAAAABQYAAgQABQAAAAAABQcBAwQABQEAAABAI0AlISEh
+IUBAQEBABQQEAQFAQEBABQVAQAwMQA0MDAEBAQVAQAUFAAQABEBAAARAQEAFQEBAQEAFQEBABQUF
+AQEBAUAFBQUBBQEBQAUFBUAFQAUFBQUFBAAAABwRAAAcMgAAHDMAAAQAAAAcFQAAAgAXAGwAcAR0
+CHQMAAQEBgAAAAAAAAAAZAAAAACQAQAKAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAA
+AAABAAAAEAAAAAAAAAABAAAAAQAAAAAAAAD/AAAA/wAAAAAAAAAAAAAAoIABAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAAABAAAZAAAADyHAQBEhwEATIcBAKSHAQCs
+hwEAtIcBAAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH
+BwcHBwcHBwYGBgYGBQUFBQUEBAQEBAMDAwMDAgICAgIBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiVDwE58mAAHFy1gNAAAAAQOCR0t
+NwAABA4JHSw7AAEQAAEAAAACgAABQgYCEAACIAAAA8AAAUMGAxAAAsAAAAPAAAFDBgQQAAJAAAAC
+gAABRAYFEQAAQAAAA8AAAUUGBhEAAOAAAAPAAAFFBgcRAAEAAAACgAABRgYIEQACIAAAA8AAAUcG
+CREAAsAAAAPAAAFHBgoRAAJAAAACgAABSAYLEgAAQAAAA8AAAUkGDBIAAOAAAAPAAAFJBg0SAAEA
+AAACgAABSgYOEgACAAAAAoAAAUwGAAAiFgAAgAAAAwAAAVkAJBYAAQAAAAMAAAFaACYWAAIAAAAE
+AAABWgAoFgACAAAAAwAAAVsAKhYAAoAAAAMAAAFcACwXAAAAAAAEAAABXAAuFwAAgAAAAwAAAV0A
+MBcAAQAAAAMAAAFeADQXAAIAAAADAAABXwA2FwACgAAAAwAAAWAAOBgAAAAAAAQAAAFgADwYAAEA
+AAADAAABYgA+GAACAAAABAAAAWIAQBgAAgAAAAMAAAFjAGQbAAIAAAADAAABbwFmGwACgAAAAwAA
+AXABaBwAAAAAAAQAAAFwAWwcAAEAAAADAAABcgFuHAACAAAABAAAAXIBcBwAAgAAAAMAAAFzAnQd
+AAAAAAAEAAABdAJ2HQAAgAAAAwAAAXUCeB0AAQAAAAMAAAF2AnwdAAIAAAADAAABdwN+HQACgAAA
+AwAAAXgDgB4AAAAAAAQAAAF4A4QeAAEAAAADAAABegOGHgACAAAABAAAAXoEiB4AAgAAAAMAAAF7
+BIwfAAAAAAAEAAABfASRHwABQAAAAwAAAX4ElR8AAwAAAAQAAAF/BZcfAALAAAADAAABgAWZIAAA
+QAAAAwAAAYEFnSAAAUAAAAMAAAGCBZ8gAAHAAAADAAABgwWhIAADAAAABAAAAYMFpSEAAEAAAAMA
+AAGFBQAAIPUBACDlAQAE5wEAhOgBAJTqAQAU7QEAJPEBAOjyAQBA9AEACxoWGhgAAAA4CQIATAkC
+ALgJAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAABAQEBAQEBAQICAgICAgICAwMDAwMDAwMBAgAADgAAACoAAAAJAAAACwAAABX2Y/aw
+9vz2RveQ99j3H/hl+Kn47fgv+XD5sPnu+Sv6Z/qi+tz6FPtL+4H7tvvq+xz8Tfx9/Kv82fwF/TD9
+Wf2C/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+u75sPlw
++S/57fip+GX4H/jY95D3Rvf89rD2Y/ZwuYO6lruqvL690r7nv/zAEcInwz3EU8VqxoDHl8ivycbK
+3sv2zA/OJ89A0FnRctKM06bUv9Xa1vTXDtkp2kTbX9x63Zbesd/N4OnhBeMh5D7lWuZ355PosOnN
+6urrB+0k7kLvX/B98ZryuPPV9PP1Efcv+Ez5avqI+6b8xP3i/gAAHgE8AloDeASWBbQG0QfvCA0K
+KwtIDGYNgw6hD74Q3BH5EhYUMxVQFm0XiRimGcIa3xv7HBceMx9PIGohhiKhI7wk1yXyJgwoJilB
+KlordCyOLacuwC/ZMPExCjMiNDo1UTZpN4A4ljmtOsM72TzvPQQ/GUAuQUJCVkNqRH1FxQtkElCd
+GxK/YNUR6jyRESMaTxEb4g4Ryn/QEFjfkxAF7lgQGpofENTS5w9WiLEPmat8D1suSQ8YAxcP+hzm
+DtFvtg4E8IcOjZJaDu5MLg4oFQMOtuHYDYGprw3gY4cNjwhgDaiPOQ2d8RMNOSfvDJQpywwU8qcM
+ZnqFDHq8YwyDskIM8VYiDGykAgzVleMLQSbFC/dQpwttEYoLRmNtC1JCUQuHqjULA5gaCwoHAAsD
+9OUKdlvMCgw6swqNjJoK3k+CCgGBagoQHVMKQyE8CuiKJQplVw8KN4T5Ce8O5Ak29c4JxTS6CWzL
+pQkJt5EJj/V9CQGFaglwY1cJAY9ECblbGQBqERkA9McYAFZ/GACMNxgAlfAXAG6qFwAUZRcAhSAX
+AMDcFgDBmRYAhlcWAA4WFgBV1RUAWpUVABtWFQCUFxUAxdkUAKycFABFYBQAjyQUAIjpEwAurxMA
+f3UTAHo8EwAbBBMAYcwSAEuVEgDWXhIAASkSAMrzEQAuvxEALYsRAMRXEQDxJBEAtPIQAArBEADx
+jxAAaF8QAG4vEAAAABAAHdEPAMOiDwDydA8ApkcPAOAaDwCc7g4A2sIOAJmXDgDWbA4AkEIOAMcY
+DgB47w0AocYNAEOeDQBbdg0A6E4NAOgnDQBbAQ0APtsMAJK1DABTkAwAgmsMAB1HDAAiIwwAkf8L
+AGjcCwCmuQsASpcLAFN1CwC/UwsAjjILAL0RCwBN8QoAPNEKAImxCgAzkgoAOXMKAJpUCgBUNgoA
+ZxgKANH6CQCT3QkAqsAJABakCQDVhwkA52sJAEtQCQABNQkABhoJAFr/CAD85AgA68oIACexCACv
+lwgAgX4IAJ1lCAABTQgArjQIAKIcCADdBAgAXe0HACLWBwAsvwcAeKgHAAeSBwDYewcA6mUHADxQ
+BwDNOgcAniUHAKwQBwD4+wYAgecGAEXTBgBFvwYAf6sGAPSXBgChhAYAh3EGAKZeBgD7SwYAhzkG
+AEonBgBBFQYAbgMGAM/xBQBj4AUAK88FACW+BQBRrQUArpwFADyMBQD6ewUA6GsFAAVcBQBQTAUA
+yjwFAHEtBQBEHgUARQ8FAHEABQDJ8QQATOMEAPnUBADQxgQA0bgEAPqqBABNnQQAx48EAGmCBAAy
+dQQAImgEADhbBAB0TgQA1UEEAFw1BAAGKQQA1hwEAMgQBADeBAQAF/kDAHPtAwDx4QMAkNYDAFHL
+AwAywAMANLUDAFeqAwCZnwMA+5QDAHyKAwAbgAMA2XUDALZrAwCvYQMAx1cDAPtNAwBMRAMAuToD
+AEIxAwDoJwMAqB4DAIQVAwB6DAMAiwMDALb6AgD78QIAWekCANHgAgBi2AIADNACAM7HAgCovwIA
+mrcCAKOvAgDEpwIA/J8CAEuYAgCwkAIALIkCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOf////O
+////tf///5z///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn////zv///7X///+c////AAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAA5////87///+1////nP///xMBAADhAAAArwAAAH0AAAB9AAAArwAA
+AMgAAADIAAAAyAAAAMgAAAATAQAA4QAAAK8AAAB9AAAAfQAAAK8AAADIAAAAyAAAAMgAAADIAAAA
+EwEAAOEAAACvAAAAfQAAAH0AAACvAAAAyAAAAMgAAADIAAAAyAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACWAAAAlgAAAJYAAACWAAAAlgAAAH0AAAB9AAAAfQAAAH0A
+AAB9AAAAlgAAAJYAAACWAAAAlgAAAJYAAAB9AAAAfQAAAH0AAAB9AAAAfQAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeAQAALAEAABMBAAD6AAAA4QAAAMgAAACvAAAA
+fQAAAGQAAABkAAAAXgEAACwBAAATAQAA+gAAAOEAAADIAAAArwAAAH0AAABkAAAAZAAAAAAAAAD/
+////AAAAAAAAAAABAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAFBQUFBQUFBQAAAACADQAAACAA
+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
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAggA8A
+AEAAaSAAAGkgQABpIAAAaSBAACAggA8AAOgAaSAAAGkgQABpIAAAaSBAACAggA8AAGQGaSAAAGkg
+QABpIAAASiAAAEohAABKIgAASiMAAEokAABKJQAASiYAAEonAABKIAAQSiEAEEoiABBKIwAQSiQA
+EEolABBKJgAQSicAEEogACBKIQAgSiIAIEojACBKJAAgSiUAIEomACBKJwAgSiAAMEohADAKJIA/
+gQAAQEEsnDBALJwwQiQcNAoigD+AADiJCiMANxoIQABKJgBwaSBAAEomAHBKJgBwSiYAcEomAHAA
+FgBwgABkBEB4ICBAhwAAAAAAAAAAAADhwOHB4cLPcKAAyB8WEAGGz3KAAJidIKISEAGGIaITEAGG
+IqIUEAGGI6IVEAGGJKIkEAGGJqLPcZ8AuP9WoYoh/w8SGFiAExhYgBQYWIAVGFiAJBhYgMHCwcHB
+wCAgQIcMyM9yoADIHw4aGIANyA8aGIAOyBAaGIAPEgE2AcgkeBEaGIAQyC0aGIDgfuHE/BzIvvwc
+SL7hwOHB4cLhw/wcCLH8HEix/ByIsfwcyLH8HAiy/BxIsvwciLL8HMiy/BwIv2okgBDhxGokwBDh
+xPHAz3CgANAbFIDPcYAAYAQEIICPz1EE4QChCvIvKQEAz3CAAAwP8CBAAEB42v/RwMHEayTAEMHE
+aySAEMHEn3QEFAs0BBQKNAQUCTQEFAg0BBQHNAQUBjQEFAU0BBQENMHDwcLBwcHAwcRFLH4QCiZA
+fsHEaySAFMHEICBAhwzIh7gMGhgwDcibuA0aGDAOyA4aGDAPyIe4DxoYMBDIEBoYMOB+4HjxwAzI
+lbgMGhgwDcibuA0aGDAPyIq4jbiQuA8aGDDPcIAATBAYiBsIUQAPyM9xAAC8DKy4DxoYMHIOIAAP
+2GfYtgogAYohRwbRwOB+8cDPcIAAfMcAgIYg/oEJ9A/IBSCADwAAANQPGhgwof+KIFUFhgogAYoh
+hwro8eB4z3EDAEANz3CgAKggLaDPcYAAjARAgQFqAKHPcKAAOC4FgAQggA/AAAAAHQiAD8AAAABI
+2M9xnwC4/xqhW6Fp2Bi4GaHPcIAAmAklgCOBIIHHcQAAiBMBBsAJ4HjPcIAAmAmVBcAJ4HjxwPIL
+AAHPd4AAYASIdQboDQhRAAHYA/AA2AuvBekPCVEAAdgC8ADYCq8G6g0KUQAB2APwANgMrwDYz3ag
+AMgfGB4YkAuPiiEQAA7oCI8M6M9wAwBADUUeGBAwpgLYGB4YkAPwMaYKjxjoCY8W6M9wAgCYRSAe
+GJDPcIAAKAAhHhiQz3CAAFwEIh4YkBgWAJZFIAADGB4YkAyPCOgYFgCWhSABBBgeGJAPC1EAGBYA
+loi4GB4YkM9wgAAwkgCQjuDMIKKCBvQYFgCWgLgYHhiQGO0A2JS4z3WAAIAEAKVx2Aa4Sg0gAfzZ
+IIXPcAAATBw6DSABn7kYFgCWhbgYHhiQWQMAAc9xqqq7u89wnwC4/zagNqA2oDagz3GgAMg7DoGI
+uA6haSBAAP7x4HjxwKXBQcBCwQwcADEQHEAxz3GAAHyKNBnADzAZAA8sGcAOKBmADiQZQA7PcIAA
+fIogGEALz3CAAHyKHBgAC89wgAB8ihgYwArPcIAAfIoUGIAKz3CAAHyKEBjACM9wgAB8igwYgAjP
+cIAAfIoIGEAIz3GAAACKgBkACHwZwAd4GYAHdBlAB3AZAAdsGQAHaBmABmQZQAZgGQAGXBnABVgZ
+gAVUGUAFUBkABUwZwARIGYAERBlABEAZAATvoc6hraGMoSwZwAIoGYACJBlAAiAZAAIcGcABGBmA
+ARQZQAEQGQABY6FqIAAD2BkAAGogwALUGQAAaiCAAtAZAABqIEAByBkAAGogAAHEGQAAaiDAAMAZ
+AABqIIAAvBkAAGogQAC4GQAAaiAAALQZAABqIIABzBkAANDYn7jPcZ8AuP8doc9wgAAAAMSAUyXE
+NVMmxTXXugHm077EoFMjwAQFJo4f0P4AANahBSCAD7D+AAAWoRiBUyfONQDdlLgYoUDDAcACwclz
+DBQGMK4P4AAQFAcwz3CgALQPvKDPcaAAyDsugUYP4AB92IYPQAGaCyABqXAI2ADZSgsgAZm5z3CA
+ADCSAJCO4MwgooLKIIEP4ADEMcohIQBkCGEBzyGhBf0Fz//xwL4IIAF72P4O4ADw2c9xgAB8ijQZ
+wA8wGQAPLBnADigZgA4kGUAOz3CAAHyKIBhAC89wgAB8ihwYAAvPcIAAfIoYGMAKz3CAAHyKFBiA
+Cs9wgAB8ihAYwAjPcIAAfIoMGIAIz3CAAHyKCBhACM9xgAAAioAZAAh8GcAHeBmAB3QZQAdwGQAH
+bBkAB2gZgAZkGUAGYBkABlwZwAVYGYAFVBlABVAZAAVMGcAESBmABEQZQARAGQAE76HOoa2hjKEs
+GcACKBmAAiQZQAIgGQACHBnAARgZgAEUGUABEBkAAWOhaiAAA9gZAABqIMAC1BkAAGoggALQGQAA
+aiBAAcgZAABqIAABxBkAAGogwADAGQAAaiCAALwZAABqIEAAuBkAAGogAAC0GQAAaiCAAcwZAAAK
+IMAnz3WgAMgfGRUSls9wAABEHPYPIAEKIcAvenDPcIAATEIjgM92nwC4/89wgAAAAESAAeJTIsME
+IukZFQKWQQreAF2GQN+fv/2mZKAFI4MP0P4AAHamWB6AFyEVAJYiFQCWBCGBD/8A/P8AgRamCNgZ
+HRiQVqZdplEHwADQ2Z+5PaZkoAUjgw/Q/gAAdqYH2HYPIAEKuFMgQQcH2E4JIAEKuM9woADUCxiA
+QiAACEggAADPd4AAsA3PcYAAgAQggdQfABALIcCEyiUiE8ogYgAs9B0KkSAVC54liOhBK00lwL0c
+5QHYIvAE3R/wjCIEoBjyTCIAohLyB/YdClAgKQoRIRPdEfAZChAkjCIBoAz0Ft0L8A3dCfAU3Qfw
+Fd0F8BfdA/AP3QDYDQhRAFgewBRCCUACcYepcCpxCnIKJIAErQPv/wolwAQRAs//8cDCDMAAddh+
+DOAAiiFKD64MAAAmDoACVP6iCAAACiHAD+tyBtiKI4sDSiQAAHUD7/8KJQAB4HjxwATpGQgSCAoh
+wA/rcgXY9NtKJEAAVQPv/7hzz3KAAAwPFXogotHA4H7geADZnrkZec9ygAAEDwGCJXjgfwGiANme
+uRl5z3KAAAQPAYImeOB/AaIA2Z65GXnPcIAABA8BgCR4QiAAgOB/yiBiAOB4z3CAAAQPAYDgfy8o
+AQDgePHAxg+P/+B44HjgeOB4aSCAAW8hPwBpIAAA9/HxwGrYrgvgAIohBAYA2I24ngxgBQoaGDAU
+zIYg/4oJ8s9wgAAYBQCIgODkCYIFr/HxwAoKgAXPcYAAsAnwIQAAQHjPcKAA0BuA2lCgz3CAAAAA
+AIAA2Q8IHgLPcJ8AuP89oJXx8cAuDcAAz3GAAAAAAIE5CN4AAYFRIMCAQNjPIOIHyiCBDwAA0ADP
+IOEHz3KfALj/HaIEgQHg07gEoQUggA/Q/gAAFqLPcIAAYASggM9wgABMEAiABCWNHw8AAOAB3g0I
+3wIeCgAMjujPcaAAtEcA2EsZGIB3GZiDANieuFQZGIDPcoAAmAQgguGCBCWEHwEAAABALIAApHgE
+JYMfAAAAQAd5A7sgoqR7BHlnfwYlQBDhogQlgR8AAACALyICAUV5ArnkewQljR8CAAAAZnikeSZ4
+LygBAE4gQQTPcIAAfInwIEIAz3CAABjNhCoLDDAgQA5TIECAGxpYMCr0z3CfALj/OKAvCZEBz3KA
+AIicCZIL6BsamDPJcc9ygACwDRyCAeAcohTwDJIS6ATZGxpYMPTxhOHMIWKACvTPcIAAiJwOkAbo
+BtkbGlgw6PHPcqAAFAQqos9wgACUBwCIDQhRAAmCuOAA2IP3AdiI6M9woACIIDV4wKA48M9xgAAg
+BQDYAKEA2ZG5z3CgAMgfExhYgM9wgADQAhB4z3WgALRHSR0YkM9xgABkrM9wgAAkBSCgbydDEFQd
+2JOSCmAFChqYM74IAAyQ6ADYkbjPcaAAyB8TGRiAz3CAAAAEEHhJHRiQVB3Yk7EDwADxwEYLwADP
+cYAAiA6AEQAAz3WgAMgfLy4BEM9wAwBADUUdGBAA30MO0BfPcoAAAAAAgjcIngQBgvK4QNvPI+IH
+yiOBDwAA0ADPI+EHz3CfALj/faBkggHj07tkogUjgw/Q/gAAdqDwIYADQHgZDtAXz3CAAAAAAIAN
+CJ4Ez3CfALj//aCA2BUdGJAlA8AA4HjxwM9xgABgBHzYzgjgACCBCiHAD+tyBdiKI4QDSiQAANEH
+r/8KJQAB8cDhxc9wgABgBKCAa9gEJY0fDwAA4JoI4ACKIQgILyhBA4ILoA5OIEAECiUAgMohwg/K
+IsIHyiBiAcojgg8AACYCiAei/8okYgB/2Aq4z3GgANAbE6F/2BChrQLAAOB48cDhxc91gAAAAACF
+NQjeAwGF77hA2M8g4gfKIIEPAADQAM8g4QfPcZ8AuP8doQSFAeDTuASlBSCAD9D+AAAWoWvYDgjg
+AIohyAz6CqAOBNgKJQCAyiHCD8oiwgfKIGIByiOCDwAANQIAB6L/yiRiAACFEQjeAwDZz3CfALj/
+PaAlAsAASiQAdgDZqCDAA89wgACMDzZ4YYBAgM9wgACIDgHhVXhgoOB+4H7geA0JXkcNyL24DRoY
+MADZnbnPcKAA0BsxoOB+4HjgfuB48cCB4MwgooAF9M9ygABMEATwz3KAACzKz3GAALSdgeDMIOKA
+KfRogmChaYJhoXyKaKl9immpKhKDAGqpKxKDAGupLBKDAGypdJJ2qW2SZ7F3kmixaILAu3SpaIIE
+I4MPAAYAAIDjAdvAe3KphBICAFQZmAAc8GCBaKJhgWmiaIl8qmmJfapqiSoawgBriSsawgBsiSwa
+wgB2iXSyZ5FtsmiRd7JUEQMGhBrAAA0IkQAuDCABQCEABtHA4H7PcIAALMoggM9yoACAJSaiIpAn
+oiKAKqImkCuiz3GAAHzHIIFRIUCAIIAV9CiiIpApoiKAMaImkDKiIoA3oiaQOKIigDuiJpA8oiCA
+OaIikDqiIIA1oiKQNqKVB8AO4HjxwEYIwADPcIAAeLQA3tSoz3CAAHzHAIApCF4ACN/JdYDlzCWi
+kMwlIpHMJWKRAAziBcogQgNhv+kPdZAB5R3wiiQBcc9xgACInKgggAEEGZAD4HgA2UokAHLPcoAA
+4J6oIMACFiJAAHaQz3CAAACdNHgB4WCwz3WAACzKz3eAAPCwQCUAEiRvOg3gAAbaqXBAJ4ESLg3g
+AAbaQCUAEkAnARQiDeAABtoYjSEIEQGKIA8Ktg2gAIoh2gwoFYAQrgygDyiFgg2ADgmFFwheAYog
+hw6WDaAAiiGbAioPwAnPcIAAfMcAgFEgQIAUC8EDz3EAAP//z3CAAKStLKAroAUamDOo/6kHgADx
+wD4PoAAA2oQoCwwAIYN/gAAsyrUbmADPdoAAAHK0aLpmUoIChgAhgX+AACjMz3eAAASfuhuYAGGG
+3BnAAGWG4BkAAAaG5BnAAOgZAAAWJ4AQFiaBEAjgBOGuCCAGCNrdZRSFFn4Wf0AnABIkbpoIIAYI
+2jEHgADxwADY4f8uCiAGANjPcIAAxEY+CYAJz3CAAARHMgmACbYMAAYeCIAEAdgA2YIPIA6A2rYN
+QAxOC4AO9g3ACXYPwAraDEAKANiqD+AOCHGqCsAMng4ACskFz//gePHA4cUA3c9wgABMBaCgz3CA
+AFy0rLAaCSAKqXD2CY//GgigDKlw9g5ABhoPwAUyDkALegjgDKlwRgjADKUGgADxwC4OgACjwQ0I
+kQDPdYAATBAI8IQoCwwAIY1/gAAsyg0IkQDPdoAAaLsJ8M9xgAD0zIQoCwwAIU4OLZU8eihwhiHx
+D0e5wrqGIP4DJHpEuFBxyiHCD8oiwgfKIGIByiOCDwAAUATKJCIA/AKi/8olAgFIhTu6UyICgECu
+TZXAukGuDPJ3lYYj/wlDu2eud5WGI/4HRbtorhHqz3KAAFBPFSIDAACLNXoCrgGLA64CiwSuA4sF
+rgOKCvAB2SmuAtgCriOuANgErgPYBa4GrotwyXEiD+AFDNoAwAHBjgngDALCi3DJcQ4P4AUM2gDA
+AcH6CeAMAsLPcYAAyAYAoQ2VRLgA2S+lDQgeAIohCAAvpQkIXgCLuS+lCQieAI25L6V5BaAAo8Dg
+ePHAAg2gAJhwhCgLDAAhgH+AACzKVSBGCiiAVSDFC1EhwICKIQgAyiEhANgYRABKJAByANmoIEAP
+z3WAAFh2/IguZeR+LyqBA04igwfPcoAAfHZvYgAmQwDgq1QQjwDkfi8ugRNOJo8X7mLIq8iAIQ7e
+EF2IhuHTIqYALyqBAE4ijQfPcoAAhHaqYhHwz3aAAGx2LmbOZbyIxH1sEI4AxH0vLUETTiWOF8pi
+UKsB4UokAHIA2qggwA/ciM9zgABkdk9jz3WAAHx25H4vKYEDTiGPB+9lACaBAPypVBCPAOR+Ly6B
+E04mjxfuZSQZggPIgB8O3hB9iIDi0yOhAC8rwQBOI40Hz3OAAIR2q2MQ8ATqyWoD8Eh2zmN8iMR7
+bBCOAMR7LyvBAE4jjgfLZSwZwgAB4kokAHEA2qggAAXPcYAAYHZ9iElhACWMAAHiZHkvKUEATiGD
+B89xgACEdmlhIKxKCeAIiHAFBIAA4HjxwJYLgAAPCJEAz3GAAEwQB/CEKAsMACGBf4AALMrpgViJ
+QS/DEMC7F7vHcwAAgBzkv88jIgbgv07dzyOiAMolgh8AAE4BhuLPJWESUQ9fEc9ygAC0nRYShQDP
+coAAOM1Gks92gAAsysUWBBYZCkEBxBYCFlMiBQDPcoAAtJ1UihMKQAFBLEIBCwoeAEmGEwpfAQ0M
+XwFJhgcKXgGBu89ygAAgzVSKh+LPI+EAUScAks8jogWIGcAAjBlAAw0IkQDPcYAATBAI8IQoCwwA
+IYF/gAAsymkRgwBOEQ4BDiOCDwAAOgEJumJ+RX5akWJ6ErpFfluRYnpAKs0FxX0EJb6fAPAAAMoh
+wg/KIsIHyiBiAcojgg8AAOoAzyPiAsokwgCwB2L/yiVCA5AZQAMNCJEAz3WAAEwQCPCEKAsMACGN
+f4AALMrPcIAAMJIAkI7gzCCiginyB9iWCuAACrgEIIAPBwAAADC4ZwgVAjMmAHCAAGRyQCeBchR5
+AHmKIAQAlB0AEB/wiiAQAJQdABAZ8ADYi7iUHQAQFfAA2Iy4lB0AEA/wANiNuJQdABAL8APYDLiU
+HQAQBfAA2I64lB0AEIIgAQE9AqAAlB0AEAohwA/rcgXYz3MAAB8JSiQAAPUGb/8KJQAB8cCyCYAA
+CHUNCJEAz3aAAEwQCPCELQscACGOf4AALMoB2WgeQhAA34AewBNM2E4eBBAF2BCmCtgbthDYGrYU
+2EweBBAt2FAeBBAm2FIeBBBKJABy6XCoIIANz3KAALh29CIDAM9ygAC8rhR6YLLPcoAAyHb0IgMA
+z3KAAMyuFHpgss9ygADYdvQiAwDPcoAA3K4UemCyz3KAAOh29CIDAM9ygADsrhR6YLLPcoAA+Hb0
+IgMAz3KAAPyuFHoB4GCyCIYPCF4BBNpiHoIQA/BiHsITGQgeAQnZah5EEC7aXbYC2mkeghAK8BTa
+ah6EEDLaXbZpHkIQFNlZjllhMHlqHkQQGuE8thcIHgAK2GQeBBAG2GYeBBAH2AfwENhkHgQQZh7E
+EwXYEKapcJj+PI4ocFQeQhCGIAMA5rlsHgIQyiJBAAzyUCHDAW96VB7CEFAgwwFveGwewhARCV4B
+SHOGIwMAb3pUHsIQCwkeAaW4bB4CEA0J3gCkulQeghAxDZAQqXDM/s9wgAAAzYQtCxwwIEAOUSBA
+gPHYwCgiAcoggQ8AAJMAwCghAaAeABAY2I24F6YIhlEgwIDPcIAALMoG8r4QgACJuATwpRCAABam
+z3CgAKwvGYAwuMC4RgngDlUeAhAIhgQgvo8ABgAAC/I2uMC4G3gB4G4eBBAC2IAeABAD8G4exBMA
+2BymHaapcAT/KIYB2khzQSkABTW5UiAAAFIhAQDAuMC5mgtv/5hy7QdAAOB4z3CAAEwQCIDPcaQA
+HEDAuBN4wbgSoeB+8cDhxc91gABMEFeVz3GAAMwGV9gAoQsKHgBf2AChCwqeAIW4AKELCl4Ah7gA
+oc9xgABou0CJANmA4sogQQDPcaUA6A8Goc9xoACkMAGBgOLPIOIA0CDhAAGhagoADTCFz3CgAMgc
+KKDCC2AND4VxB0AA4Hjhxc9wgABMECmARCGDgADaI/SLChUEACKND4AAyEQAjaC4AK2AFYAQoLiA
+HQIQQBWAEKC4QB0CEBCNoLgQrZAVgBCguJAdAhBQFYAQoLhQHQIQAeLf8UcKFQQAIo0PgADIRACN
+gLgArYAVgBCAuIAdAhBAFYAQgLhAHQIQEI2AuBCtkBWAEIC4kB0CEFAVgBCAuFAdAhAB4t/xJQme
+Ac9ygADIRAiKgLgIqogSgACAuIgaAgBIEoAAgLgR8JHrz3KAAMhECIqguAiqiBKAAKC4iBoCAEgS
+gACguEgaAgAA2D0JHgBKJAB04HioIEAGLQieAAAggw+AAMhEIBOBAIC5IBtCAKATgQCAuaAbQgBg
+E4EAgLlgG0IAAeAd8EokAHTgeKggQAYtCJ4AACCDD4AAyEQgE4IAoLogG4IAoBOCAKC6oBuCAGAT
+ggCgumAbggAB4OB/wcXgePHAmg1gAAfaz3agAMgfSB6YkM91gABMEIAVABDPcasAoP9MHhiQANgZ
+oVqhGKGKIAQAD6ZqFQARz3eAADCSsB4AELQeABAf2Ai4DqYIhVEgAIAA2Iu4FfIQpmIOgA7PcaAA
+pDABgYS4AaEElzUIUQEA2ZS5z3CgAAREJaAS8BGmPg6ADs9xoACkMAGBpLgBoQSXEQhRAc9xoAAE
+RADYBaHPcIAAzAQAgBUIHgCGIP8OIrgUuM9xoAAERAWhWP+6D4AMXf95/89wAABVVVoeGJAB2Fke
+GJAIhc9xpgAoABEI3gQA2A+hrg6ADgTwAdgPoW4VARHPcKYA6AcmoI4LAAXGCKAMDZUHjwroiiDY
+Ca4KYAAB2fIOIAMC2AXwJgogBQHYiBUAEM9xoADEJw8ZGICMFQIQz3CgADAQRKDPcIAAtKcQeI8Z
+GIDPcoAAZKhQeJYiAgAQukV4kBkYgIogBACSGRiAkBUAEECXQBkAgM9wgADIRFMZGIAPEQCGjuKf
+uA8ZGIDMIqKCB/QIEQCAhSCEAAgZAIARCpECCBEAgIq4CBkAgA/YEBkAgJQVABAcGRiACIUdCF4H
+LgugDgDYNgugDgHYz3GmAPTPAdgSoQTwGguADi0EQADxwL4LQAAKJQCQz3CAACzKGnEF9MUQAQYC
+8CmAJblPCR4Az3KAALSdz3GAADjNJpF2ihMLQQDEEAEGVIrAuRUJgADFEAEGDQleASmAHwlfAQoh
+wA/rcgXYz3MAADYJSiQAAJ0Ab/8KJQABhC0LHC93z3aAAEwQ+GDJcX4IoAAp2s9xgABouwAngB+A
+APTMsgigAAzaz3CgALQPAN/8oEiGUyIAAA4PIAw0loINAANf/4DlbAihDMogYQAEyAsIngDKDEAD
+C/AA2Z65z3CgAPxEIaDPcKAAtA/8oEwgAKAADKIOyiBiAM91gACgBAyNhujGCEANAdgMrSkDQADx
+wLoKQAAKJQCQAdgQ8gTIGwifAAohwA/rcgXYiiMIA0okAADdBy//uHMA2IQtCxzPdoAALMoAJk8e
+hCgLDEAmARkwIUAOSYcluCW6UyARAFMiEgDpcP4OYAAN2QYJYA+pcAmHJbhTIBAAhu0D2D78hPwE
+8OYKgA49CBAgTCIAoMohwg/KIsIHyiOCDwAALwLKIGIBxvU2CYAIqgjgAAHYz3eAAHzHDwkRIEII
+wApGCMAKFvCOCOAAANjPd4AAfMeD7dD8CPCSCoAOAIdRIECAlAqCDkwhAKCEC4H/qXAO/r4KoAGp
+cATYBBoYMF0JESDPcYAAtJ3PcIAAOM0GkFaJEQoBAMQWABY0icC4GQhAAMUWABYRCF4BCYYNCF4B
+AIcpCF8AqXAKcXf/f9kRuc9woACwHzSg/gpACA/IBSCADwEAAPwPGhgwAIdFCF4Az3GAALSdz3CA
+ADjNBpBWiRMKAQDEFgAWNInAuBcIQADFFgAWUSBAgQmG0SBigQj0GI7PcYAATBAYqQmGCaEB3goL
+IAzJcM9wgAChBjIJIAzAqBkNURDPcIAAIM0UiA0I0QFMIACgEAqCDuYJgA5SDUAAKgngAgDYUQFA
+AOB48cAA2Iz/IgwP/89xgAC0nRaJvgkgDzSJOQCP//HA2ghAAM92gAAsyhpwCwhRAKmGA/DFFg0W
+Jb2EKAssACZPHgmHwL1RIECByiHBD8oiwQfKIGEByiOBDwAAwQLKJCEA1AUh/8olAQTPcIAAoBAB
+iMxxawgRIECBz3GAALSdQKEAFgNAgOBhoQAWg0BoqQAWg0BpqQAWAEEC8g+2ABaAQAQigg8ABgAA
+CqkAFoBAgOILqQAWgEAB2gypABaAQAAWAEHAegexABYAQQixABYAQFKpyg5v/wTYOPAggc9ygAAk
+zsQeWBAAFgFAgODFHlgQABaBQBQaQoAAFoFAFRpCgMxwCPIgkM9wgAA4zSGwA/AAkAAWgEDPcYAA
+KM4iGgKAABaAQCMaAoAAFoBAJBoCgAAWgEAAFgBBDhkEgAAWAEEiGQSAABYAQC8gBwR//YYIoAEK
+cM9xgAC0nRaJz3KAADjNRpKb7RMIgQDEFgAWNInAuCEIQADFFgAWGQheAQmGEQheAc9wgAB8xwCA
+DwhfACmHCnAlucC56P46CIAOpgtAALkHAADgePHAANic/89xgAC0nRaJGgggDzSJlQZP//HAANnP
+cKAAtA88oIoKwAzeD8AMlgwADOYLIA0A2P/Zz3CrAKD/OaAC2FoLYAAEGhgwYQZP/+B4hCgLDAAh
+gH+AACjM4BACAM9xgACwn9wQAwBgGYCA5BACAOgQAABcGcCAbBmAgOB/cBkAgPHAxg4gABLZqcEI
+diYNYACLcEokAHEA2qgggAIWJIAwKIgLCZIAYbkoqAHiAcICwYQuCxwAIYB/gAAozNwYgAAFwuAY
+QAAGwbRu5BiAAMd1gAAAckgVERDoGEAAz3CAAASfCiBALhYgQAQI4IPBKgigBQja9IXPcIAABJ+H
+wfZ4COAWCKAFCNoAwAAgjS+AACzKtR0YEBMIHgC6HdgTuxUAFoC4BvC6HVgUuxUAFqC4ux0YEM9w
+gAAAylSINohEKj4LACGAf4AAXMg1eAaIEHb8DuH/yiCBA7UVABZRIECA8djAKCIByiCBDwAAkwDA
+KCEBJgpgAKAdABAtBiAAqcAA2IDx8cClwYtwUgpgAAXZAMIrCh4Az3CAAEwQGIgfCFEAANiauM9x
+oADIHw+hAcCkGQAAw9gauA6hKwqeAAYSAjYA2UokAHKoIEADuHGDcSiJACJAMWQYQgAVCk4AQCVB
+ALYJQAClwNHA4H4KIcAP63IF2IojjwiRAi//SiRAAPHAz3CAAEwQCYBRIECByiHCD8oiwgfKIGIB
+yiOCDwAAKQfKJGIAZAIi/8olwgBSCUAM4g9gCQHYz3CAACDNFIhFCNEBz3CAABTNC4A5CF4Bz3CA
+AKjICpDPcYAAqLQlgQq4MHDKIcIPyiLCB8ogYgHKI4IPAAAzB8okIgAMAiL/yiXCAHIID/+WDuAL
+ANiCDMALBglAABEET//gePHAAti//MX9AQRP//HApgwAAADez3WgALQP3KWGCCAMaHf4/+oJYAzp
+cATICwieAEoOAAMI8ADZnrnPcKAA/EQhoNyl1QQAAIQoCwzPcYAAFM0wIUIOz3CAAOCeVnh2kM9x
+gAC0ncQZ3AAXkM9zgACwn8UZHADPcIAABJ9WeAyIkBsCgADY4H/HGRwA8cBiDU//sgxADrYNT/9x
+A0//4HjxwBYMIABE2s91gAAAcsRtz3GAAAifeglgAKlwSiSAcADZqCCACBRp2GBxgIQpCwwAIYJ/
+gAAsygAhgH+AACjMuhrYAADbtRrYAGGFQoUB4dwYwABlheAYgABGheQYwADoGIAAHQQAAM9wgAC0
+nekEIACKIQUF4HjxwJYLIAAA2qHBQMIAFo5AABaNQAAWg0AAFpBAHO2pd89xgACQuyOJhif8F0W/
+w73meeC5yiJCA2DC4bnKIkIDyiIhAAEcgjBRIYCAyiUhEAIcQjOk6M9wgAC0nbaI9Iixc8wmwZMR
+8gohwA/rckArBAQQvgXYiiPeAgUkRANZAC//BSbFEwDFQCAOBs93gAAsylQYWAOEH0ATIfDPcIAA
+OM0GkBULAQDPd4AALMrEFwAWwLgbDgAQCiHAD+tyBdiKIx4FmHMRAC//SiUAAADFz3aAAMjI3R9Y
+E0AgQSBJIQEGNHlCDyAAyXBCIMAlSCAAABsIdAAA2wDaABYBQAHi+wrUgAHj9QsEgFYmABkaDyAA
+BtnPcIAAfMcAgDMIXgDPcYAAtJ3PcIAAOM0GkFaJEQoBAMQXABY0icC4EwkAAMUXABYLCF4BCYcf
+CF8Byg1gAMlwz3CAAMgQoqCKIBINWgggAKlxfg4AAJECIAChwADYSPHxwKHBi3CuDiAAAdkAFAUw
+TCUAgMohwQ/KIsEHyiBhAcojgQ8AAMwHOAfh/sokYQDPcIAAkLs6DiAAAxhCAaHA0cDgfvHA4gkA
+AM9zgACEEUODAN/PdaAALCCwhdJq1H5+ZqWmBKYB4owiEIAmpkOjhfcCg+OjAeACoxUCAADgeADY
+z3GgAMgfGKEZoQHYDqHgfuB48cBqCQAACHe6cdpy+nMKIgAhCiNAIQohgCHPcAAAyBvGCWAACiDA
+IRtwz3AAAMwbtglAADtwz3AAAAQcqglAAM92oADIH5pwAdgTpgXYz3WAAPAQAKXhpQ7AIB0AFAml
+FYYcHUAUCqUYhhgdwBQLpRmGFB2AFAyloBYAEBAdwBUNpaQWABAMHYAVDqWoFgAQCB1AFQ+lz3AB
+AMEJEKVKCWAAKNgRpUIJYAAA2BKlUyfAdROlAshUHQAXFqUSFgCWUB0AFxelExYAls9ygADwEBil
+FBYAllMkASMZpRUWAJYQuRqlJBYAlkokQHkbpRYWAJYcpc9wgACwDRGAHaXPcIAA8BB4GIAKz3CA
+APAQfBjACs9wgABsEQQYAAuEGkALz3CgAMgcCICIGgAAz3CAAHAFAICMGgAALyAHBgi4BXkvIEcG
+JXiQGgAAANioIEAC8CIDAM9xnwC4/wHgdqFNAAAA4Hj8HIi2/BxItvwcCLb8HMi1/ByItfwcSLX8
+HAi1/BzItPwciLT8HEi0/BwItPwcyLP8HIiz/BxIs+B+4HgE3DjdNfDgeATcNN0z8OB4BNww3THw
+4HgE3CzdL/DgeATcKN0t8OB4BNwk3Svw4HgE3CDdKfDgeATcHN0n8OB4BNwY3SXw4HgE3BTdI/Dg
+eATcEN0h8OB4BNwM3R/w4HgE3AjdHPDgeATcBN0Z8DQUGjAwFBkwLBQYMCgUFzAkFBYwIBQVMBwU
+FDAYFBMwFBQSMBAUETAMFBAwAscBxrAkTTOwJB8z4H7xwM9xgACwDRGh4HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB40cDgfuB44cXhxkApDQIlfUAtAxSleyUK
+NAIIdVMlfpAG8gEdUhBhuvvxQSqOAMG6QiZOkAQd0BD99QnqLySJcOB4qCBAAQEdUhDgeMHG4H/B
+xShyANnY8eB48cCyDs//ocEId892oACsLxmGBCCAD3AAAADXcCAAAAAB2MB4LyYH8Ch1GnIT9Iog
+SQamDO//iiFNCDmGmgzv/4ogCQaKIAkGjgzv/6lxANgk8BHMABxEM08gwQMB4BB4BCCADwAA/7+P
+uAIcRDARGhwwAghgDkAnABIH5wQnjx8AAPz/BScAFJ24n7jscQChAMHscCCgAdh9Bu//ocDgeCK5
+BvDscmCiBOBhufkJtYBggADZz3CgANQLbaDPcKAARB01oOB+4HjxwPINz/8Idih1KHBIcWhyyv+B
+4MoggQPAD+H/yiFBAz0Gz//hxc9ygACwBKSKz3KfALj/Be3Pc9C6/sp+ohqiO6IO7c9woAA4LgWA
+BCCAD8AAAADxCICPwAAAAGnYGLgZouB/wcXgePHAhg3P/wh3z3GAALAEBYkA3qnBQMaLCBEAAd2l
+qc9xgACAlM9woADMKy2gANiPuBEaHDAhGoIzHgrgDItwggwACM9wAQDBCUHAiiBQAELAz3CAANiA
+AIhkxQLdERwCMADAEhxCMxMcAjDPcIAAhBFFwM9wgADwEEbAz3CAAHAFAIBDxiDZAdpHwEjHgcA9
+2xe7wv8I2AHZyf8EGlgzUQXv/6nAA9rPcaAAFARFoc9xoADUCw2h4H7xwOHFz3KgANQLA92xogDb
+cKIFEgI313IAAABAAdrCIooAF7rHcgAOAABFIgIGnbqfuux1QKUC2iAagjAIEg027HKgohESAjcB
+4hEanDDscgCiAhICNuxwQKDscCCgAdjPdaAAyB8TpTiF7HAgoBmF3/90HdiQz3GgAMg7DoGIuA6h
+xQTP/+B48cAA2AgSgTDc/wgShTAKIcAP63IH2Ioj0QhpAe/+SiQAAOB4ANoD8AHiQSiBAP0KRIDg
+fs9xgACwDUQZwAfPcaAAyB9cgZ24nrhNGRiA4HjgeOB44HjgeOB44HjgeByB4H7geAPaz3GgABQE
+RaHPcaAA/AsMqeB+A9rPcaAAFARFoc9xoAAIDACx4H4FzADa13AAAABAAdjCIAoAF7jHcAAOAABP
+IIEAnbmfuexwIKDPcKAAFAQD2SWgAhIBNs9woADUCy2gz3CgAEQdVaDgfqcJEABAIcIDw7mfCTUE
+JLozJkFwgABwckAnA3I0ewB7ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQ
+AAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQAQYUAAAFgFABBhQAAAWAUAEGFAA
+ABYBQAQYUAAAFgFABBhQAAAWAUAEGFAAABYBQEIiQoAEGFAAvvXgfuHFIupjasG6PQo1ASK7MyaC
+cIAAgHJAJ41yVH0AfQQQAgQEGZAABBACBAQZkAAEEAIEBBmQAEIjQ4AEEAIEBBmQAO/1/wTP/+HF
+qQoQAEAiwwPDup0KNQQkuzMmgnCAAIRyQCeNclR9AH0BEIIEARmSAAEQggQBGZIAARCCBAEZkgAB
+EIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgABEIIEARmSAAEQ
+ggQBGZIAARCCBAEZkgABEIIEARmSAAEQggQBGZIAARCCBAEZkgBCI0OAARCCBAEZkgC/9VMEz//x
+wN4Jz/8odkYhzQAdZSK5lf/Bvh0OUBARDpAQGw7REAAWgEABHRIQABaAQAEdEhAAFoBAAK0VAs//
+4HiA4cokTXDgeOggrQEAFgFBAhhUAOB+4HiA4cokTXDgeOggrQEAFoFAARhSAOB+4HjxwHIJ7/9T
+IUIATiINAc9yoAAUBMmCANsOJoIfAAAABlBxyiHGD8oixgfKIGYByiOGDwAADALKJGYAcAam/sol
+xgCA4cokTXDKIs0A6CAtAk5gz3GgADgEAeLIqR0NUBARDZAQHQ3REM9woAA4BGioz3CgADgEaKjP
+cKAAOARoqF0Bz//hxQDaD/CggA1zoKOhgA1zoKOigA1zoKOjgA1zoKMQ4AHiQSkDAeMKxIAA2wbw
+BBANBA1yoKIB41MhwgAiuvMLhIAA2wbwARCNBA1yoKoB41MhQgDzC4SABwPP/wDbz3KfALj/GqJ7
+oj6iz3AAbAQAGaLgfvHAcgjv/wDaocEacM9w1Lr+ykDAz3GfALj/aBkABATYG6GLcB6hnbrPcKAA
+0BtRoM9wAG0AEBmhBfD2CO//iiBJBfsJXscAFAUwew2BD9S6/sog3c9zoADIH7CjAdhDGxgAANiN
+uAD/saPPcZ8AuP9oGQAEBNgboYtwHqEA2J24ExsYgM9wAG0AEBmhBfCiCO//iiAJCvsJXscAFAUw
+DCWAj9S6/srKIcEPyiLBB8ogYQHKI4EPAABsAvgEof7KJAEEmQHv/6hwz3GAALAEZInPcp8AuP8G
+689x0Lr+yj6iGqIO689woAA4LgWABCCAD8AAAADxCICPwAAAAGrYGLgZohyC4H7gePHAcg+v/5hw
+KHZIde3/BiCBA4hwpXlk/sUHj//PcaAANB8EoQHYB6EIgYDoBYHgfvHAPg+v/0okAAIA3c93AAAE
+Hal2FSKAMxwQAQYA2M9yoAAUBMqiqKInogSiPWWI4Wi5yiEOAOlwT/5CJEQAIOfVDHWAAeZhB4//
+4HhBKYGACfIvJElwqCDAAQQQAgTscUCh4H7xwN4Oj/8IdSh2jgggDkAhAAIFzNdwAAAAQAHYwiAK
+ABe4ACCBDwAOAAAHbgQggA8AAPz/JXiduJ+47HEAoQISATbscCCgIr4F8OxxAKEE5WG++w61kACF
+aP7xBo//4HgH2c9yoADUBxoaWIAN6BkSAYYJIEMADxIBhgIgwIB5YQ8aWID19eB+ocHxwAUSAjfX
+cgAAAEAB2sIiigAXusdyAA4AAIO67HNAo+xyAKIocFL+0cDgf6HA8cDhxc9wgAAwkiaILukniCzp
+oJBPbRcKFQIzJoJwgACUckAngXJUeQB5ANkR8CSQB92A4QHZwHkL8CSQCN2F4QHZwHkF8CSQhOEB
+2cB5HQlQAAgQBQEKIcAP63IQ2Iojzwn9Aq/+mHUxBo//ocHxwLINj//PcoAArQdAioDiRMCL8o3p
+CiHAD+tyBdiKI08NSiRAAMkCr/64c2CBA+tBgYjqz3KAAKyecIJgoVGCQaEkxoDmyiHBD8oiwQfK
+I4EPAAD/A8ogYQHk84DiyiHBD8oiwQfKI4EPAAAABMogYQHY8zEIXgIEIIAPAQAAwC64z3KAAFB2
+CGJJIIAAYbgCuBR4x3CAAASwaqAhgSugRfA5CB4CoObKJYITyiUhEAQggg8BAADAz3eAAAB2zmcE
+IIAPBgAAADG4LroeZs9wgABQdkhgwngT8FMgwgBdes91gAAweU1lBCCADwEAAMAuuM9ygABQdghi
+YbgWfRJtFHjHcIAADK9goCGBHw00FiGgCiHAD+tyBdiKI5AHiiSDD80Br/64dQjc8wSP/+HF4cbP
+cYAArQcgiSXpANtKJAB2z3KAAAyvqCDAAzJrNHklYD5ioKY9YKGFGWGhpiKBAeMipkgQAQZIGlgA
+SRABBkkaWABLEAEGSxpYAEwQAAZMGhgAbwWP/+B48cAuDK//uHHPcoAAKIsEuTAiRACiwQ8MXgPP
+c4AAwM0E8M9zgADQykAjAgZAIwEHUSRAgsohwg/KIsIHyiOCDwAARQQgAaL+yiBiAc92gAAwjkAt
+jQGmZkDGIMULDh4Swr2qYQ3wEw5eEkQlARxEuSpiiboF8FMlwRA8eSpjz3GAADCNFiFBASKJDrlF
+eSCgCQSv/6LA4Hj9AuAHCNjgePHAiguv/4ogVw7PdYAApEGaCa//IIWKIBcHz3GAAFxCigmv/yGB
+AN7ApRDfSiSAc8lxqCAAAhYlQBDhoMKgAeHPcIAAGEKKDK//ENnPcIAAKEJ+DK//JNnPcIAAXEJy
+DK//INnPcYAAlEHAoeGhAdgIqQmpxbHDoYoglwcuCa//iiFOBs9xgAAoRsChwaEI2AWhxqEC2AKh
+A9gDocShz3ARADCMB6HPcAIAIL9FA6//CKHgePHA2gqv/wHZz3CAAJRBIKAA3c92gAC4BBYmQBMD
+gIDg4iACAEAlTZD488IMr/4G2BUDj//xwKYKj/8Idc9wgACUQaCgz3aAAChGiiBXC6oIr/8ghoog
+VwueCK//JYZ6DK/+BtgfDZAQAN3PdoAAuAQWJkATBICA4OIgAgBAJU2Q+PPFAo//4HjxwFIKj/8I
+doog1wxiCK//yXHPdYAAlEHKC6ACw6UDhSvoMQhQAHEIkQC2C4ACz3AAABw5z3GAALgEAKHPcAAA
+8DoBoQDY2v9yCeAHBdgk8M9wAAAMOc9xgAC4BAChz3AAALA7AaHF/3ILgAJeC4ACANgJrRDwVguA
+As9wAAAMOc9xgAC4BAChz3AAALA7AaEA2Mf/KQKP//HAiiBXB9IPb/+A2Yj/ANjW/9HA4H7gePHA
+z3CAAJRBA4CC4PwI4QfKIKEC8/HgePHA4cUIdYogFwqeD2//qXHPcYAAlEEDgT8IkQDPcIAAXEIA
+gI3tIrjAuAmpAtjPcYAAKEYCoQPYA6EA2AzwI7jAuAmpBNjPcYAAKEYCoQXYA6EG2AShqQGP/+B4
+8cAuCY//z3WAAJRBA4UfCJAAEBIENgohwA/rcgXYiiNFCUUGb/5KJQAAXgqAAl4KoAIIdgHYCK0t
+DlEQz3CAALxEWgqAAqIOwAcIdYog1wr6Dm//qXGJ5cwlopA4COIHyiBCAzUBj//xwEoKgALPcIAA
+TJ8giM9wgACwRM9ygACUQSGoKIrAuSKoANkjqBIKoAIhoiIKgAIA2Zu5z3CgANAbMaBx8eB48cDP
+cIAAlEEDgB8IkQCKIFcHkg5v/4ohRgkA2Lj/ANhw/+j/Nf9d8fHAz3GAAJRBI4GC4cwgIYC0D6EH
+yiChAU/x4HjxwM9xgACUQSOBguHMICGAmA+hB8og4QFB8eB48cAKJACAyiHCD8oiwgfKIGIByiOC
+DwAA2QNEBWL+yiXCAM9wgAC4BBYgAAEjoESgJ/HgePHA7g9P/wh2iiCYAAIOb//Jcc91gACUQYog
+Fw7yDW//IYUhhQDfkOEE9AHfwaXJcSUPUBDPcIAATJ8VIIIDNXggiGCKEQnCAAGIIYoJCEIAAIWO
+6IogVwe2DW//iiHJDsGl+g6gBwPYAdgD8ADY6QdP/+B48cDhxQhxENgA20okgHPPdYAATJ+Yc6gg
+gAYpCQ4Bz3KAAKRBFiICAQQSBQAhDRUEFSVCEUCKUHPKIEsByiOLAEAkRAAvJAcBqQdP/wohwA/r
+cgXYYQRv/oojxw3xwB4Pb/8Icc92gACUQQQWBRAbDRQECiHAD+tyBdiKI4oGOQRv/ookgw8WDW//
+iiBYAIogFw4KDW//IYYBhs91gAAYQgll+gxv/4ogFwchhihliwhTAM9wgABMnzV44YgQ2AGmz3WA
+AKRBiiBXDtIMb/8ghYogFwfGDG//6XEAhYDgyiAhASnyx/8IcQGmkODKIcEPyiLBB8ogYQHKI4EP
+AAC7AsokwQCwA2H+yiUhAI4Mb/+KIBcOIYbPcIAATJ81eAGIFwjDA4ogVwdyDG//iiGLAAPYtg2A
+B60GT//geM9wgACUQQOAgODgf8ogYgDxwCIOT/9acCh3OnJAKAEEiiAYADoMb/9FeUwigKPKIcoP
+yiLKB8ogagHKI4oPAAD8AsokigQ0A2r+yiXKAEwhAKTKIcoPyiLKB8ogagHKI4oPAAD9AsokSgQQ
+A2r+yiXKAM92gACkQRYmjRQEFZAQiiDXDtoLb/8KcREJASTPcIAAlEEAgF7wTCAApMogYQBA8kwg
+AKTKIcoPyiLKB8ogagHKI4oPAAARA8okCgS8Amr+yiWKBM9wgABMnxUgAQQVIEAEYIhAiREKwgAB
+iCGJEHFAACoAANiKIFcHcgtv/4ohjAUAIIIvgAAYQgCKAdmN6AAWBRAKIcAP63IF2IojzAZpAm/+
+CiQABGG4AKoocBkIUQAAIYEvgAAYQgCJBB1AFOKlAeAAqQCGDyCABACmKnBE/89xgACUQSCBA7gl
+eD0FT//xwOoMT/8IdSh3SHZAKAEEiiDYAPYKb/9Fec9xgAAoQiARBABMJACByiHGD8oixgfKIGYB
+yiOGDwAAQgPoAWb+yiUmABYhAAGkqOCgxahAJEAACKH9BG//AtjgePHA4cXPcoAAKEIIghHoz3WA
+ALgEYbgIohZ6YIUEiiCCYHtFis9ygAAoQgiC9OjZBE//4HjxwFIMT/86cI7gyiHKD8oiygfKIGoB
+yiOKDwAAsgPKJEoEdAFq/solygDPdoAApEEWJk0UBBWQEIog1w8+Cm//KnGKINcONgpv/wpxANgC
+pRDYAaUA2A8gQASghgZ9oKZdCBAkTCAApMohyg/KIsoHyiBqAcojig8AAMMDyiQKBBQBav7KJUoE
+ACCBL4AAGEIAiYDgyiHBD8oiwQfKIGEByiOBDwAAxAPKJAEE6ABh/solQQNhuACpCnAh//UDT//g
+fuB44cXhxhDZAN7PdYAATJ+fcclzqCDAAxcIjgMVJYITQIpQc8ohiwPKI4sAAebPfihwwcbgf8HF
+4HjxwFoLb/+KIJcPSiAAIM93gACkQWoJb/8ghw7eCnUAhxcITgMWJ0ATAoAH6EB4BSAABC8gByBh
+vgHl5w51kK99ANgAp0wgAKAB2HUDb//CIAwA4HjxwAYLT/8Ids9woABkLvAgjwMbEhA2GxqYM/XY
+BbgmDW//yXEbyM91oAAUBAqlCYWA4HAMQgfPcKAAwC9REACGCyDAg/X1z3AAAGQeEguP/98IjoMJ
+he3oGxoYNPXYBbjiDG//CnEbyAqlAQNP/+B48cDiDk//qQcP/uB4ABYBQSCwABaCQFMiQQAhoEEq
+wQBSIQEAwLkoqEEqgQDAuSmoQSoBAcC5MKgAFoFAz3GgAMgcKIHgfyOg8cABgBHoNQhQADUIkAAK
+IcAP63IF2IojxANKJAAAcQcv/golAAEB2c9woADIHCmgAg5v/xTYCfAC2fjxAdnPcKAAyBwpoNHA
+4H7gePHAEugnCFAAKQiQAAohwA/rcgXYiiMFC0okAAAlBy/+CiUAASnYErgH8BXYE7gF8E96K9gS
+uDV4QKDh8fHA4cUIdaYNb/8U2COFz3CgAMgcKKAtAk//4HjxwK4JT/+lwYt36XDF/+lw0/8iwBbo
+ABYOQSTAA+gAFgBBAN0J8AHAABYCQMlx3/8B5tB+AeUAFAEx7w1EkBPwAN0M8AAWAUED6gAWAEEB
+wAAWAkAB5dX/ABQBMekNZJAkwiTAhegLCR4AABYAQQXM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24
+n7jscQChAhIBNuxwIKDpcNP/Ngxv/wHYANnPcKAARB01oG0Bb/+lwPHAAYAT6CMIUAAjCJAACiHA
+D+tyBdiKIwQNSiQAAB0GL/4KJQABAtgC8AHYz3GgAMgcCaGqDG//FNhd8fHAEugtCFAALwiQAAoh
+wA/rcgXYiiOGB0okAADhBS/+CiUAASnYErjwIEAAAKJF8RXYE7j68SvYErj48fHAhghP/6XBi3fp
+cHv/6XDe/wAUATEFzAK513AAAABAAdjCIAoAF7jHcAAOAAAL4QQhgQ8AAPz/JXiduJ+47HEAoQIS
+ATbscCCgABQBMexwILAJFIAwCOjPcKYAnD8ZgPkIUYAiwBboABYNQSTABOgAFgBBAN4J8OxyAcCp
+cdL/AeWwfQHmABQBMfEORJAS8ADdC/AAFgFBA+oAFgBB7HIBwMn/AeUAFAEx7Q1kkCTCJMCG6AkJ
+HgAAFgBB6XCA//oLb/8B2ADZz3CgAEQdNaBZ8eB48cCyDy//AdgAFoJAABaKQAAWiUAAFoZARCa+
+g0QigxPAeAohQILKIWIAAeGA48ojgQDKIyIAgODKIEICyiAhAEDcBCILkxtjb3sk9AXMAd3XcAAA
+AEASa8IlShMM4Be9BCCADwAA/P/HdQAOAACleJ24n7jsdQClAhINNuxwoKDsdQAdghLscGCoANvs
+cGCw5Ql0AADY+HAZcYHgyiOBAcoiQQLKI4ICRCOBA4LhSiVAAMIlQgFSIw4AwL5EIwAMkOAB28B7
+oOAB2MB4BSDEAAAWDUBhuk96lukjCnQAAN8ghYDmBOUE9AAWDUAJCxEQ7HAgoAHn7Q+EkCCFCQsR
+EOxwIKAGJT6BEvIfCnQAANgAFgFAgOYgpQTlBPQAFg1AAeDxCISAABYAQAClCyRAgRzyKQp0AADY
+ABYBQOCFBOvneQPw5XkgpYDmBOUD9AAWDUAB4OUIhIAAFgBAIIUE6yd4A/AleAClQiBBECsJdYBA
+J0AADQsREFoKb/8B2AfwA9nPcKAAFAQloADZz3CgAEQdNaCFBg//YQJP//HAFg4v/wDZz3CgANAP
+NaAAFgNBABYCQQXMMQteAtdwAAAAQAHYwiAKABe4ACCNDwAOAABAIgEDz3AAAPz/JHileJ24n7gT
+8NdwAAAAQAHdwiVKExe9x3UADgAAQCIBA89wAAD8/yR4pXjscQChAsjscQCh7HBAsOxxANgAsYUL
+HgIjagQhgQ8AAPz/EwveAM91oAA4BAitAdhhuTB5HQseAaFoCL0Ffc92oAAQBLi2AuAPeGK5MHkA
+3RTww2gYvuJo738Qv+V+4Wjvfwi/5X4Ffs93oAAUBMunBOAPeAHl2mndDYSTAN4I8M91oAA4BAit
+AeAPeAHmUyFNAO8ORJMRC14BAdnPcKAA0A8RGFiAEwueAQPYz3GgABQEEKEB2AShEQveAAAWgUDs
+cCCoYboTCx4BDwqUAAAWAUHscCCwYrpEI4GBQSqAABX0AN4L8M91oAAABOyNABaNQOx14K0B5rJo
+Dw5FE+kL34EAFo9A9vEtCZEAANkK8M91oADUA9yVABYNQex1wLUB4Rt9EQlFA+sL34EAFg5B9/Er
+C54AgODKJA1w4HjoIO0DEwveAc9woACYAz2AABYAQAPwABYBQOxwIKAA2QbwABaDQOxwYKgB4VMi
+QADzCQSAWghv/wHYANjPcaAA0A8RGRiAz3GgABQEBKEEyM9xoADQDyK4wLgVoXkED//xwBIML/8A
+2UokAHKoIEACABYCQBUiQDAcGJgAAeEAFg1AABYOQK4MT//PcKAAFASsoM9woADUC9ygHghP/0EE
+D//geOHF4cYkiM9ygACccqaIwrkuYgDZDyGBA89zgACMn3YTAgaG7SZ6dhuYAB3wRXl2G1gAJYgV
+I40DeR1YECaIRYhZYXwdWBAggIwhEIBE94ohEAAgoCO5dxtYAACAKrh4GxgAANnPcKAA8DYsoHkT
+AQYloHwTAQYmoHoTAQYnoH0TAQYooHsTAQYpoH4TAQYqoHcTAQYroHgTAQYtoHYTAQYkoMHG4H/B
+xfHA4cWiwYt1qXCmDy//AtmpcNL/Vg8P/4EDL/+iwOB48cCI6M9wgABkoT4ML/8k2ecAz//xwO4K
+L/+YcJDgyiHGD8oixgfKIGYByiOGDwAAawMMACb+yiUmBADaSiQAdM92gADMBKggQA9ALIMBVXvH
+c4AAMI4gg891gAAoi0AsAAHduQBlIKPxuNEhIoIJ8qCLz3eAAAB2rWcXDZMQz3WAADCNFiUNEaCN
+Cw0eEJ65FfAtuMC4FSYPEOOHUiFNAgsnQJMM8s91gABMyoQoCwwwJUAe2wieh5+5IKMB4q0CD//g
+ePHAMgoP/6LBABYRQQAWAEFAKQ4hx3aAACiLAIYtuCMJNCRTIBIACiHAD+tyBdiKI1QDSiRAAEUH
+7/0KJUAEz3CAADCNFiBABBpwgg4v/wLZz3CAALCNFiBABHIOL/8C2UApjSEAJYAfgAAwjl4OL/8Q
+2YtwVg4v/wHZAIYPCF4CBg4P/wkCL/+iwAAlgB+AADCOIgxgCxDZARCAIJDgyiHKD8oiygfKI4oP
+AAA6BYYH6v/KIGoBSiQAdADZqCCBCBUlQhDPcIAAMI4wIIUABCWDjwAAAAEEHEAxQPIhxs9wgAAA
+dgQlhA8GAAAAQSxCBM9goOb4YtEl4YIr8gPrFw+TEAQlhA8AAAAkRwyADwAAACQ/CtUADQqRABvr
+Mw+REAPrzOYV9s9ygAAwkkaSIwrCAyMN3gLPc4AATMqEKgssMCNCDgQivo8ABgAAA/QA2wLwAdtv
+ewTwAdgIcwQlgg8BAADALrrPdoAAOHlKZlBwAdjCIA0AgOPMICKAEfIB4QIQgCDPcYAAUHYIYT0I
+UAAKIcAP63IF2IojVQQQ8M9zgABMyoQqCywwI0QOCiHAD+tyBdjFBe/9iiOVA0okQAC5Be/9SiUA
+AAMQgCAIYYLgyiHCD8oiwgfKI4IPAABTBQXY7vUqcFv/z3CAALCNFiBABECQz3EAABgVCSJBACCw
+QPHgePHAOggv/wLZz3CAAMwEkg4P/89wgADMBECAz3agAOwnz3egAAREz3WAADCSeQoeACuGRCKA
+AIYi/w4iuqG5FLq0uQV6BSGDAAQhgQ8QAAIABCKCDxAAAgBrpiV6RacolYfhzCGigQ/0z3GgAMgc
+B+gB2B6hEg6ACwXwANgeoXoOgAsElV0IUQHPcIAAzAQAgFEI3gAE2c9woABEHSWgI6AkoCDwz3Cg
+AMgcAdk+oAuGgbgLptINgAsElR8IUQHPcIAATBAIgBMIHgAA2JS4BacLhpS4BfAA2AWnC4a0uAum
+ogsP/70Hz/7hxTRoz3KAACiLIWItucC5hCkLDAAhgX+AACzKSIFRIgCAz3KAAJC7QYIJ8jyJgOHF
+IoEPAAAKAgPyRSJCA0okAHQA26gggAI2aHV5ACGND4AAMI5ApQHjAN3Pc4AAMI0WIwIAoKqhqgHZ
+IqoD2SOqSiQAcalxqCDAAXphFnqkqgHh4H/BxeB4MQSP/y0Ej//xwAAWAEDPcYAATEIAoR8IUQAA
+FgBADLgEIIAPAQAA8AGhABYAQAKhEfCC4AAWAEAL9EYgwgBDoQAWAEDPcKAA0BteoAPwABYAQAXM
+13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChAhIBNuxwIKByCS//AdgA2c9woABEHTWgNwSP
+/+B48cAAFgJAocFAwgEUgDAPCB4Az3GAAFCuBPDPcYAAaK5AoWCJAdoI8AAWAEAVIYwAAKQB4n14
+9QiFgBcLHgAAFgBBA/AA2BUhjAAApAHi+QqUgQXM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7js
+cgCiAhICNuxwQKDiCS//AokA2c9woABEHTWgocDRwOB+8cDhxQAWA0DPcYAAAABgoQAWAkAA3UGh
+ABYAQAKhABYAQAOhpKElC94H/7pA2M8g4gfKIIEPAADQAM8g4QfPcZ8AuP8doQbwz3CfALj/vaAF
+zNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQISATbscCCgUggv/wHYz3CgAEQdtaCdBc/+
+4HjxwOHFz3WAAMwEBG06Cy//CNkBhc9xoAC4HgKhAoUDoUYJD/9xBc/+8cDhxaHBAN1AxQAWAUAA
+FgBAOQlQAAXM13AAAABAAdjCIAoAF7jHcAAOAABFIAADnbifuOxxAKECEgE27HAgoOxwoKCpcCDw
+fgngC4twBcwB2ddwAAAAQAHYwiAKABe4x3AADgAAhLiduJ+47HIAogISAjbscECg7HAgoADB7HAg
+oAHYkg/P/s9woABEHbWg3QTv/qHA4HjxwFYMz/4KJgCQOnFP8i8ogQNOII0H2thmCu/+qXEbGlgz
+QCUAFEogACAPIBAg9dgFuGYO7/6pcRvIz3egABQECqfPcaAAZC7wIQEACYeS6M9woADAL1EQAIYL
+IECACvTPcAAAsB5ODA//CyAAhBb02tgOCu/+iiHaBymHAgrv/trYz3GgAMAvUREBhvIJ7/7a2PYO
+4AYqcK4P4AOpcADYDyBAAwYmDpCz9c9xgABQBQCBB9obGpgwPQjQAc9woAA4LgWABCCAD8AAAAAh
+CIAPwAAAAPXYBbjPc58AuP8ao1ujadgYuBmjAdgD8ADYCQhRAEChz3CgABQESqC5A8/+8cDhxQIS
+DTYAFgBBABYBQcW4grm7/5IP7/4CGlgzuQPP/uB48cAuC+/+gNjPd6AAwC+lFxKWFBcRlgDepR+Y
+k89yoABkLhQfmJMvKwEATiOBB/AiQwBlfgDbDyNDAAYgwID19U8mwBakHxiQpBcAlv0I3oejFwCW
+BCCADwAAAA+MIBCA+PPz2AW4gNkKDe/+n7kbEhA29dgFuAfd+gzv/qlxz3CgABQEqqAbGlgzB/AD
+2c9woAAUBCWgz3CgABQEqYAe7XbtQS2AkAryLyQJcOB4qCCAAQAWAEDgeFMlTZAJ8i8kSXPgeKgg
+QAEAFoBA4HjPcKAAFASpgObx89i2Ci//BbjBCN+H9dgFuIoM7/4Kcc9xoAAUBCgZAAQbGhg0I+4v
+KIEDTiCBB5ThyiJFAIT3KHKAIsIBz3CgABgs8CCDAJThyiJFAIT3KHKAIsIEz3CgAGgsVXhgoADY
+DyBAAAYmDpDf9YDZz3CgANAbMKClH5iUFB9YlDUCz/7xwNYJ7/4X2bfBi3diDu/+6XAjwEohQCBT
+INIAhiD+A0IoEAEhCjIkDByCNAohwA/rcgXYiiPPAQokQAThBq/9CiWABBLGLb4gwMC+QCoNIcd1
+gAAoi1EgAIAAhYYg9w819IDgyiHBD8oiwQfKI4EPAADOAwXY4vMBwALBSnKWDSAEZm0f6Mlwmgng
+AEpxDRSAMIUgwQANHAIwiiD/D1PAAIWpuAClSnBaCeAA6XHPcIAAhATVeCCADyGBBCCgKnYC8ALe
+SnBz/gbwgODKJkEUyiYiEq8OURATwQCFEsImeER5JXgApQwdAhTPcIAASIwA2RYggARAhSCgIaAL
+Cl8FANmLuSGgDwqeBSGAhSEBDiGgeg+gAOlwDRSBMAsJXgFYFAAxBbUNCV4AUBQAMQK1DwkeAUpw
+Cg8gBFUUgTANFIAwPwjeADXBVhQCMUpwZg8gBBLDuHCMIAKAyiHBD8oiwQfKIGEByiOBDwAAOwSw
+BaH9yiRhAFElwIHKJiIRSnBd/QXM13AAAABAAdjCIAoAF7jHcAAOAACDuJ24n7jscQChAhIBNuxw
+IKBaC+/+yXAA2c9woABEHTWgeQDv/rfA8cAaCM/+pMEB3YHAogzv/qlxAN5N8ILAlgzv/gLZAsCL
+cuIKIAQDwaR4LyUHkEDyAMEA2M93gAAoiw8gQAAEuSFnLyEKIC25UyEQAM9xgABMBUCBBCGAoACh
+B/SA4hALIgnKICIIIMAWDiAEENkAwQDYiiMIAFRp+mICsmCigNtoqmmqz3KAAIQEFSICBGCCBCND
+BGCiz3KAAEiMNnoAogGiz3KAACiMNHoAsgHmIcBnDgSQBczXcAAAAEAB2MIgCgAXuMdwAA4AAIO4
+nbifuOxxAKECEgE27HAgoGYL7/6pcJkHr/6kwPHAsgkABH4Lz/4nBU//4HjxwCoPj/6EKAsMz3KA
+AIQE8CINAAAhgX+AACzKaIEEI4IPgAAAAEQjDwIvuga/RX8EI4IPAAEAAEEqTgMsuuV+RX7PcoAA
+zAQVegOCZQ4AEAQjvo+AAQAAIvLPcIAAIM0UiD0I0QHPcIAAfMcAgDEIXgC+u2ihRCMAAga4BCOB
+D4AAAAAvuSV4BCODDwABAABBK0EDJXgsuwUjDgDDogrtLylBA04hgAcQJQ0Q5Pz67eEGj/7xwKLB
+i3CaDO/+CNkAwM9xgAB4BAChCOgGFAAxA7EEFAAxArGaCs/+osDRwOB+4HjxwKTBi3BqDO/+ENkF
+zNdwAAAAQAHYwiAKABe4x3AADgAAg7iduJ+47HEAoQISATbscCCgAMBRIACAA8AG9ALBbgmgBADa
+BfB+DCAFAcEaCc/+ANnPcKAARB01oKTA0cDgfuB4wdnPcKAABCUgoOB+8cDaDY/+z3AAAEQcHg7v
+/gDecdgWDu/+BrjPcAAATBwKDu/+CN3PcAAAyBv+Dc/+z3AAAMwb9g3P/s9wAAAIHOoNz/7PcAAA
+BBziDc/+z3CgANQLOIAcgM9wnwC4/1gYAAgAJoAfAADAG8IN7/4E5mG98w1VkADeBd0AJoAfAAAA
+HKoN7/4E5mG98w1VkLkFj/7geM9xoADQDxkRAIYcEQCGz3CgAMgfFRAChh6Az3CgAMQnGRAChpwR
+AgAVEAKGLRAChi4QAoYvEAKGMBAChoARAgCEEQIAoRAChpARAgCiEACGlBEAAJgRAACMEQAAiBEA
+ABiBz3GfALj/WBkACM9xnwC4/1gZQAjPcKAA0A87gDmAz3GmANQEFxAAhiwRAIAwEQCAOBEAgM9x
+oACIJACBAYECgQOBBIEFgQaBB4Fg8eB48cDhxc91gACIoalwEgnv/gPZAYXPcaAAgCUMoQKFDaEA
+jVEgAIAA2I64BPIPoQPwEKGqCM/+1QSP/uB48cBSDI/+z3WAAOAEAIXPdoAAtKfkkOlxFgjgAoYh
+/AMacA0I3gAfhoC4H6YghQCROGAApVQWgBCS6OlwfgogB4Yg/AMJ6BkIHiDPcIAATBAJgA0IXwAf
+hoK4H6ZZBI/+8cD2C4/+osHPcIAAtKc+gAQhgQ///w/QBCWAXwAA8C8leM91gAC0p5IKIAcepYDg
+VAMhAJgdABDPcYAAAAAAgTUI3gIBgeu4QNjPIOIHyiCBDwAA0ADPIOEHz3KfALj/HaIEgQHg07gE
+oQUggA/Q/gAAFqIPDd5Rz3CAAKAQAogF8AOFSgggBCSFXoVEIgEMlB0CEAsJEQiA2JQdAhBAKAEG
+xwjfAYK5IwqeU0QiPtMK9M9wgAC0pwGADQgeAHYLAAcV8G4MAAcR8EUhAAbPcYAAQKgoiYYh/Q9S
+IcEBRbkleM9xoACIJBChz3CAAAioAIiE6BMKn1LPcKAADCQTgFMgwIBJ8kQiAFNBKIEATXCGIPwD
+QSgCAc9wgAC0pxMNnlEEuVlhx3GAAMhEEvAVDV5TdGlbYwAjgQ+AAAhFCvAVDV5SBLk6YgAigQ+A
+AEhFrBhAAKwQAgAf6iCKlxhCADzYAKoZ8LO6XqVRIoDTxSGCDwAAAAdFIQAGz3GAAECoKImGIf0P
+UiHBAUW5JXjPcaAAiCQQoYoh1gDPcKAAgCUvoM9xoADEJ0ERAIZRIsDTzyDiAtAg4QJBGRiAz3WA
+ALSnAJUEIIAPAADMgBUIgQ8AAMiAC4UNCB4A4gvAAk3wHoVUFYIQywjeBBoRAIYFIIAPAAAAmhoZ
+GIAH6gHaz3CgANQLUqAE2BAZGIBNcQoIr/6KIEQOBvCWCq/+iiAGAgkIn0T1CR7Gz3WAALSnz3ag
+AMQnLhYBlhaFInhkuBB4hh0EEM9xgABMECYKoAcvkRoWAJYEIIAP////ABoeGJARFgCWEwjeAgDY
+i7gTHhiQGtgZHhiQHoVRIICBANmP8hSVUSBAgYv0z3CgACwgD4CA4IX0ENhBwM9wgAB8xwCAIwhe
+AB8NXlMB2EDADPAH6gHaz3CgANQLUqAE2BAZGIDb8UDBK4XPcIAAuMaLcwQhgQ/AAAAAwoA2uYHC
+QCAEC1cOThDhlceAcL/0JEEACCbOE0cJgwOUFYEQPwnfAc92oAAsIC+GmenGhjyVEwmFA89xgABk
+sMKBJYAfDkEQBOsC2SCjI4CDuSOgBeoggqa5IKIBwg3wI4ABwhcJ3gAA3p6+z3OgAPxEwaOjuSOg
+K4UkoCOFJaBUFYAQB+gAwILgzyJiAQL0h7oAwUHCVSVAGmYPYAMA2x+FlLgfpR6FkLgepQ3wz3GA
+AMiSDYEB4A2hENnPcKAAkCM9oMUAr/6iwM9wpACQQU2Az3GAAIimQrEagAOxBCCAD/8AAAAwuASx
+z3CAAIimANoRCF5Gz3GAALSnMYELCZ4CQrBDsESw4H9ZsOB48cASCK/+mHDPcYAAtKcOkc92gACI
+pgC2z3CmAOj/C4DPdaQAtEUDpgwVA5YNFQKWRBGJAC8nxwD/2BC4KXSEJAOcBCMIAAT0WwkfEDIV
+AJZTII8A/2cBtv/Y9H8IuO9/ZHhALwUSACUGAAAnxwMFJsYBQC8AFgQjgw8A/wAAQC8HFBtjACDI
+Ef/YBSYGAgi4BSODAQQiBgD6YgAmQAEFeuW2b3gEI4MP/wAAACi7ZXhPegO2RLYEFQCWArYRgR8I
+HgLPcIAAAHYyIEACDwiSAM9wpgDo/w2AA/AA2AamBaYA2EokgHAG2o26qCBAAynbErvwI48AQCYD
+HxV7AeLgowHgAJE4HgARVSZBFBq2z3CAAACuMgyv/gjaGxUAls9xpQDYyxmmHBUAlhqmHRUAlhum
+DoEcpg+BHaYmFQCWHqbPcKQAkH8cgDEHb/4fpuB48cCyDm/+ANvPcaAAyB9AEQAGz3egANAPGRcA
+ls9yoADEJ08SDoa4gc9wgAC4xqigEczPdYAAtKcLDgAQH4ULCJ4AAd4E8BEanDNodlISEIYVEhOG
+G9gWGhiAEQvfIFEgQKBKIgAgB/QdhQHeWnaEuB2lDQseIVQVgBAE6ADYBvAdhYW4HaUB2DpwTCIA
+oMwhIaBY8s9ynwC4/1gaAAgQh89wgACgEA+IFqIA2s9woAD8RJ66QaBloB6FsLgepagVABBk4B6h
+ENgOoQHYFRkYgOIJr/4J2BcIX0fPcYAAsA0LgQHgwg2gAQuhLgmAARsJECDPcYAARJMFgQHg6gmg
+AQWhOQIAAM91gAC0p8cKECAdhYS4HaXPcIAARJMRC94gIoAB4SKgiiCFCQfwIYAB4SGgiiDFCK4L
+T/5KDYABS/BCEgCGBCC+jwDAAABD8gG1HoV7CN4EiiCEDooLb/6KIZAHJguABwCVhiD8AIwgAoAx
+9IoJgAev6APYEh8YkOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HgSHxiQE8wRGhwwBfAAlboOoAg0lawVARAI6ZcVgBAAqQDYrB0A
+EFQVgBAh6M92oAD8JTSGAdrPc4AARJMGgzhgBqMF6c9xgADpB0CpU4Yng1lhJ6M+hQHenwgQAJsJ
+3gEB2c9wgAB0BSCgRfAhCB4gAdnPcIAA6QcgqM9xgABEkwOBAeADoT6F6/ED2c9woADUCzGg4Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeDGgE8wRGhwwGQoRIB2Fz3GAAESTgrgdpQSBAeAEoQHeHoUXCB4ElRWAEKQVARCpcroNIAIB
+2wPwVgmAAh+FDwgeAM9wgACArhoIwATPd4AACLMZhwbo/gsABADYGaf2D0ABz3CAAEwQCIAjCN4C
+j+4EIIAv/wBf/+r+z3CAAIimoNnE2j3bvg1v/he7HoXwuNQMAgTPcIAAuMYAgIDg6AqiDMogYgDR
+A0/+8cB2C0/+z3GAAGSoz3CAAOAEIKAA2c9ygAAwqCmiz3CAALjGJKAloCyiz3AAAP9/z3GgAAwk
+AaEb2AShz3aAALSnLQgeRB2GhLgdps9wgACQBCCABYEB4AWhiiCFCUoJb/4kgXYOQAFTAgAARBaA
+EPGGwrgEJ48fAAAACFQWghD7f891oADEJwDZFerg2r8dmJCU2pUeghAE289ygABIBWCiAto8HYCQ
+z3KAAGSwIaIH8EDZvx1YkNTZlR5CEAAgkQ+AACzKwBGBIAAgkg+AACTOuBKAoAUh0wPuDqABBSDQ
+A4Dg6/IB2BAdGJDIEYAgz3GAALyu5XgbpmwWgBDDuBx49CEAAGQewBReHgQQwBKAoOV4HKZwFoAQ
+w7gcePQhAADPcoAA3K5gHgQQZBaAEMO4HHj0IgEAaB4AFIoeRBDPcYAA7K70IQAAjh4EEGgWgBDD
+uBx49CICAPQhAACMHoQQkB4EEBTMhiD/hWwJwQHPcIAATBAIgOu4uAnC/x3wz3GAAHCwAIFjgUOh
+ZngAoQSBDBUBkBJ4JXgMHQCQANiPuBMdGJAIFQCQoLgIHQCQGtgZHRiQYgqAAc92gAC0px2GUSDA
+gXv0z3WgAMQnERUQlgDarQjfozUIXyJfCJ8j1wgfo7MIHyDXCN4gCNgTHRiQugyAAcMIEQAC2Dwd
+AJAjhs9wgABksCGg1/FJ/aAWABCRFQGWAeDDuaAeABCbCEGAiiIIABMdmJCRFQCWw7iHCQCAEh2Y
+kL/xOhUAlkMIngDPcYAAcLAAgTcIHwCAuAChAdgDoYog/wAEoToVAJaGIP8BA7gBoQwVAJBGIAAP
+DB0AkAgVAJCAuAgdAJAA2I64Ex0YkDMNHtAE2c9woACQIz2gkfE//QLYPB0AkCOGz3CAAGSwIaAe
+hvO4hfMTHRiUhf4D8BMdGJQVAU/+VBaAEInoQhUAlgQgvo8AwAAAA/QlCB4ivxUAlqW4vx0YkIog
+BAATHRiQEgiADFQWgBCA4GP1HQifIAohwA/rcgXYiiONBookgw+5BS/9CiUABM9wgAC4xiqAz3Cg
+AAREJqDH8eB44cXPdYAAiKYJpSqleLVLpQHYGbXgf8HFSiQAegDZqCCAAgDaz3CAAIimNXhAoAHh
+4H7gePHALghP/gDez3GAAAAAwKHPcqAAyDsdgsKhwaHDoYToANgL8ASB/QiBj2WHIUOKIIQAAKEB
+ocShDejQ2Z+5z3CfALj/PaCC2BSiz3AAgBEUDqKKIMUPz3WgAMgfGR0YkAHYCHEIcghz1gsv/Zhw
+z3CAABQAHQiAD4AAFAAKIcAP63IF2GrbiiSDD+EEL/24c893oADQD9WnhdgJuM92oADAL3oeGJAq
+DsAHeg/ACFoMAAtA2c9wnwC4/zKgNgiP/oDZz3CgABQELKAdH1iQAguAB7oPwAYeCqAHANi+CsAK
+B9hIHRiQogsP/kIPAArPcIAAMJIAkIfgcA4CCpIJgArmCUANkgmADBWGUiAAAA8IHwACDmAKAd8P
+8APfE4aauBOmIN4F2NClQx0YEADY8gpv/o240aXPcIAAMJIAkIfgKA4BCtoKD/5eCYADlg3AA+IL
+AADqDIADhg/AA9INwAm6D0AIggvACwoOQAxaD0AMeg5P/Yogxg3PcYAATBANsQPYbRkCABvZz3CA
+AKy6HgggAjCougiP/+oNQAzeDI/+Ng5ADY4IgAwCCW/+6XDpBg/+4HjxwGYOL/4B2aXBGnAKIoAv
+gADsBPIKb/6LcAAUhTABFJEwDwhRIAoigC+AAPAECw1SABkNUgEKIcAP63IF2KzbdQMv/UokQABM
+JQCAGAEOAKhwABaOQAAWlEAPDDIkenCMJMOvJfQAFgBBABaPQAAWgEAAFgBBfQwTJCbvz3CAAOQE
+AIBALM0gtX0Q4Lhgegpv/gTZz3CAAOQEAIBMIUCgHWXMJ2GTFvQA2Iy4E/AKIcAP63IF2LfbSiRA
+APkCL/0KJQAFCiHAD+tyBdjA2/bxANgAtc9wgADkBCCAQCzAIBV4EmEZYQUiQAQAsQTdB/CBwATd
+Egpv/qlxACKMIwAcAhXPcIAAhATwIAIEHt8vKYEAAidAECPqz3OAAC+LNGgrYxULjgMAJoEfgACU
+oRZ5ABkCBQAtgRMLIcCACPIAJoEfgACUoRZ5BBkCBRAiAoAvKYEAAidAEOD1QiNAIIDg8gbN/14J
+T/5RBS/+pcDgeADYSPHxwOHFrcGLdalwiglv/g3ZAMAdeFMgAQBEKT4NqXAAIYF/gADIjBYKb/4N
+2iIJT/5NBS/+rcDgePHACiHAD+tyBdiKI4wIiiSDD/kBL/1KJQAA4HjxwOHFINvPcaAAyBxpoQAW
+AEDPcqAAEBQMogAWBUAB3UwlAIDKIcEPyiLBB8ogYQHKI4EPAAAJAbQBIf3KJEEDGBpAAWgZQAED
+2A+iuaFqoaoIT/7VBA/+8cBaDA/+pBABAKLB2wlfBiDZz3OgAMgcKaOkEAEAXQneATGIz3WgABAU
+I7nAuQO5BeED2k+lRoVBwo3hEN7KJuIRBhQPMYwnw58J9AQUDzHxdswn6pAB3kL2AN7r7sWARX7H
+pbGIhiX8Hxi9pXrPdaAAzBdaoBbwRYDPcaAAEBRHoaQQAQAVCZ4CMYjXuoYh/A8YuUV5OqDPdaAA
+zBcN2QHaA+ENHZiQDh1YkCaAGR1YkCeAGh1YkCiAGx1YkAPZFB1YkHAQAQEQHViQcBABAc91oAD0
+BwThJ6VHo6QQAQCZuaQYQADdAy/+osDxwAPIpBABAPm5DA/B/wPZz3CgABAUJaDRwOB+ANqA4cok
+TXDoIK0B/9lcYCCsAeLgfuB48cDPc4AA7ARocATZ9/8EawTZ9v/o8eB48cCiCCAKENhv2Qe5z3Kg
+APAXMaLPcQAA8P84ogYKAArW8eB48cDx//b/0vHPcYAA7AQLCFEABGkC8ChwBNnK8Q97SLgPeM9y
+gAAAdPQiAABAKAECSLgFefQiwAAweeB/J3jgePHAvgoP/qXBCHYCiyh1mHBkwACLABIGAREcAjB5
+cAISBwEEEggBEBQAMeSSBhIFAQAgyQMAkS8hSBIHIEACEHjn/wAgigEBlS8iiBIHIIACEHjj/wAg
+xgEClS8miAEHIIABEHje/wAgBwIDlS8nyAEHIMABEHja/wAlBQAElS8lSAEHIEABEHjV/x9nBZXw
+f+d4EHjS/yaVIXAQeAd5PHoPuSV6UHoAIoECMHkAHEQwR5Unelx5D7pFeTB5ACGCAVB6XHkCHIQw
+D7pFeTB5ACHCAVB6XHkEHIQwD7pFeTB5ACFCAVB6XHkGHIQwD7pFeTB5P2fwf/x5CBzEMw+/5Xkw
+eThgaXHGuYW5CLkFIcECILYQeCCVChwEMCd4HHgIuAUgAAEBtgDAAaYBwAKmAsADpvUBL/6lwOB+
+4HjxwOHFCHU+iM9wgADkBECAQCUAFAO5NXlZYZ4OL/4K2qlw9//VAQ/+8cBSCQ/+CHbsiAiQz3KA
+AOwEtG8Ic4Yj8w9CKxECx3WAACiLYIVIcQcLXgMkauu4iiDDLwP0HhaQEE2OUSIAgJryeQjfAC0L
+3gL/2AetSiQAcQDYqCBAAwphACCDD4AAlKH2e0SrCmEB4A94QKtY8B0JEiEKIcAP63IF2IojCwVK
+JEAAEQbv/AolQATuuEeNMiFABAAhgS+AAJSh9nkJ8gSpBNgAKEAERXgHrTrwAKkPIkIER61e8CkI
+EiSMIMOvyiHCD8oiwgfKIGIByiOCDwAA6ALKJGIAvAXi/MolAgTJcL7/CJYNCJ4DAo4JrQTwAY4I
+rQCFMwjeAgDZSiQAcSetqCCAAwAhgA+AAJSh9ngEGAIEABgCBAHhL3kBjgitAo4JrSjwTCEAocoh
+yg/KIsoHyiOKDwAABQNIB+r/BdgIlgAhgS+AAJSh7rgHjfZ5CfIEGQIEBNkAKUEEJngHreDxABkC
+BADZDyFBBCZ4B60BjgitPQAP/kGJBLjHcIAAKItIqCKJ4H8pqOB4EYjgf8K44HjgfuB44cXPcoAA
+7ASA4MAiIgH/3RRpACCDD4AAL4ugq0okAHEA26gggANtYgAjgA+AAJShNnikqG1iAeNve6Co4H/B
+xfHAgg/v/ZhwpcEod7hzAN4EI4AP/wAAABi6BXpveQi5/9gIuGR4KLgFeUV5CN30JIADJ3hEwBAU
+ADEa/xIUAjFhvUAoAQQFeUd5RMEQFAIxFCSAM0Cw2w11kAHmUyXCBUCnABQNAQfZBvAQfRQnTBAA
+tGG5FCRAMLt7T70AkKV7cHvrCbWAeGAEIIAPAAAA/xC4BXpjBe//QKfgePHA5g7v/SDZANrPdaAA
+yBwppc9xoACUE1uhz3OAAOQEYIPzaM92gAC0pwyG9X9TIMQF8GP7Y1MgjwCkwYtxOQ/REB6Gm7ge
+pjQWgBDiixkIwQMocEAjAQREa0AmAxzz/g3aKvAdhpG4krgdps9woADMFyvwHQ9REUEqAlJAIwAE
+wbqIc7j/HoacuB6mDdoU8Cy4UyACAB6GA7qZuB6m5IMF4gUnABEAoQWDAaEGgwKhB4MDoQPiz3Cg
+AMwXz3GgAJQTXKEB2ojqHoaXuB6mINgKpRnwAMED2hgYWIABwRkYWIACwRoYWIADwRsYWIAUGJiA
+hhYBERAYWIAE2SelFhiYgE0G7/2kwOB+4HjxwNoN7/0B2aHBXgov/otwIMDPdYAAXEIApYogVwre
+C+/9AhIBNoogVwrSC+/9IIUAhUDZQMEPCB8AKg8v/ihwK/DPcIAATJ+6Cw/+ANvEhUokAHTmhagg
+wAcA2M9xgABMn3V5Q4kPIMAA4brKIQIAyiEhACV+4LrKIQIAyiEhACV/USKAgMogIQAnhQHjJXgH
+pealxKWOCQ/+AIUnuMC4QCBEAM9wgACUQQwQBQAPDREA3gpv/ohwFvBMJICAzCWhgBLyTCRAgMwl
+YYDKIcIPyiLCB8ojgg8AAHcAOALi/MogYgFdBe/9ocDgePHA4cWiwYHgAdjAeEDAiiCXCv4K7/0R
+EgE3iiCXCvIK7/0AwQDBz3KAAFxCZYKhggOCi+kmgmR9pHkme0HBZaIleAOiCfAkggR9pHkmeCV7
+QcEDomWiDem2Cu/9iiCXCotwCNlb2h7bmg7v/Ri7+QTv/aLA8cDhxaHBz3WAAMAEqXD6CC/+AdmK
+IFcKggrv/QISATZAjYogVwohjRC6cgrv/UV5z3CAAJRBAICB4AHYwHhAwItwYg0v/gTZAI1RIACA
+AY0E9CIIgAYE8LoIgAaVBO/9ocDgeOHF4caYcM9ygAB8QgWCIIJmgsi4ELjIuQUhAYABgsi7ELvI
+uAUjBQBnggKCyLsQu8i4BSMHAGiCA4LIu8i4ELsFIwYAJPIAFA4ALyhBAE4ggwcA2A8gwAASfQQg
+QwGkfmV+AByAA9qCpH7Fe3qieYIEII4BBCDAAaR7xXt5oniCpHsEIUGDZXgYot/1wcbgf8HF4Hjx
+wHoLz/06cAWBoIHIuBC4yL0FJQ2QAYEmgci4yLkQuQUhEAAB3hnyBCWAkxPyLygBAE4gggfwIYEg
+AN8PJ48QCOkEJwAUQiAAgGB5yiBiAOZ9237q7YUDz/3gePHAocEB2H4MIAxAwM9wgAB8QgqAUSAA
+gMogAgfKISIByiKCDwAAZwDKI2IPDA3i/cAr4gWhwNHA4H7geKHB8cDiCs/9o8EIdUjAz3aAAHxC
+Gob7hjyGBH8kf6d/QcfqCO/9iiDYBIog2ATeCO/9qXGU78sNERDaDO/8B9i/CBAACiHAD+tyBdiK
+I0YPSiQAANEHr/wKJQABBBQBMRjpIBQAMQsgQIAN8s9wgAC4BGCAz3EAADxvDNhgewPaCPCI6M9w
+gAC8BCCAYHkM2AYUATEY6SIUADELIECADfLPcIAAuARggM9xAAA8bw3YYHsE2gjwiOjPcIAAvAQg
+gGB5DdgEJ1CTCvIiDO/8B9iKIBgINgjv/QpxEvCQ7Yog2AQqCO/9iiFHChYM7/wH2IogGAQWCO/9
+6XGz/7ymCNxLAu/9o8DgePHA4cWjwQHYQMDPdYAAfEKpcPoP7/1c2TqFG4UkeDyFBHmBwEHBav8B
+wDuFBHlBwdIPr/2KIFgEVSVAH6lxif/PcIAA9ENAJQEbhv+LcL4KL/4E2QHAqf/SCgAMAIWG6AWF
+gOBYDsH/8QHv/aPA4HjxwGoJz/2iwQHdz3aAAHxCOoYbhiR4PIYEIRAAdg+v/YogmANVJk8XVwgQ
+IALwu30EIECj/fMvKAEATiCRB/AnQBRcHkAUgODKIcEPyiLBB8ogYQHKI4EPAAAYAsokAQRMBqH8
+yiVBBEB4iiCYAyYPr/0qcQDYDyBABAYgECAKcIL/iiCYAw4Pr/08hj0B7/2iwOB48cDWCM/9psE6
+cRpyYMAA2AEcAjAB2AIcAjADHAIwi3DmDeAKgcEEwQpwIyBABAXCA8CM6AohwA/rcgXY7NuKJMMP
+2QWv/LhzQHjtAO/9psDxwIoIz/0acCh1SHdodjhjZtk92sYJ7/0XuhcIUQAKcH4JL/6pcelwUgrv
+/clxwQDP/eB48cBaCM/9CHYA3Yog2ANuDq/9yXHPcIAAfEJagDuARHkA2g8iggMEIkMAQiMDgMoj
+YgAvJsfwAd/KIEEDBvIcgCR4RXhL/+lweQDP/eB/ANjhxVIggADPcaAAfB0EqQLdEfDgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG9jCX/n+314H/BxeB4z3CgAHwdBIjgfuB48cCuD4/9
+OnB6cVpyGnMA2On/BNjo/ysJVCAqdQDfQiFAIOJ4ASsOIMC+TyaAEOL/RSaAEeD/Yb3nDXWQAecE
+2N3/ANkzCnQgABhAIEp1KHYG2Nn/Yb3o/0IiQSDCecC4OHgAEAEgBXkAGEAgBNjS/+ENdZAB5gDY
+z/+NB4/94HjxwKHBi3MI2AXZCHLd/yDAocDRwOB+4HjxwA4Pj/1acDpxCiOAoBpzCiUAIcwgIaAQ
+8kwjAKDMICKgDPQKIcAP63IF2FbbiiSDDzEEr/y4cwDYmnC4/wTYt/8rClQgSnaKdUIiQCCieAEp
+DyDAv08ngBCx/0UngBGv/2G+5w51kAHlAN0S8EEtwBAyIw4gUyWBEE4hwAEZfsC+TyaAEKb/RSaA
+EaT/AeVAKMAg2w0EkADYof8zDRAgE/DS/zEIHgAg3s91oADIH9ClZNhDHRgQANheCu/9jbjRpYAk
+ASnfDISvAACIE4og/w8D8ADYiQaP/eB4CNgG2QDaSHOYco7x8cA+Do/9CHUod0h2+v9PJUEUGNjp
+cslzSiRAAL//iQaP/eB48cAWDo/9qcHPd6AALCBAFxAQsgmv/ADdz3GAALANEoEB4BKhi3AeDO/9
+BNkX8IHGyXASDO/9INkAFAAxyXEg2uf/BX0AFAAxIOAAHAQwAhQAMUIgAAgCHAQwAhQBMdMJE4gN
+6YHG3gvv/clwABQAMclxAhQCMdr/BX3QhzzYAiYOFLoLr/3JcYDlyiWBEwLIOg/v/alx5QWv/anA
+HXjPcaAAYB0SsRSR4H7gePHA4cUIdShzB/CpcPn/AhsUAALlsH1huowi/4/39ckFj/3gePHA4cUI
+dShzCfCpcPD/AKtIuAGrAuWwfQLjYbqMIv+P9fWhBY/94HjxwOHFocEIcyh1AeJdehDwaHDl/wAc
+BDACaxB44v8CHAQwAMAE43B7BB0QEGG6jCL/j/D1ZQWv/aHA4HjxwOYMj/0IdjIN7/0k2FEgAIDK
+IcEPyiLBB8ogYQHKI4EPAAAqAsokIQD4AaH8yiXBAM91oADALxOFpw4RECkIngYThSDes7i6uBOl
+z3WgAMgfZNjQpUMdGBAA2HoI7/2NuNGl9NgA2RIN7/0B2jTYANmRuQYN7/0A2jDYiiEGAPoM7/0A
+2jTYANkD2u4M7/0UuqoM7/0w2MK4CwhRAADYB/AE3T/YYgqv/alxqXDPcgEAxgPPcaAA7CdGoc9x
+oAC0DzyBkwkQAAISBDYKIcAP63IF2IojyQRJAa/8uHOauBOlIN/PdqAAyB/wpoogDwpDHhgQANji
+D6/9jbjxphOFs7i6uBOlZNjwpkMeGBAA2MYPr/2NuPGm8KYB2EMeGBAA2LYPr/2NuPGmE4ULCJ8G
+EIUfCB8A/BUFEAohwA/rcgXYiiNHAd0Ar/yKJAkDRNhJHhiQpfH5A4/94HjxwIYLj/2hwSh2z3eg
+ACwgQBcQEADdABxEM7DqMmgEIYEPAAD8/54Nr/0s2BCHAiAABIwgD4oJ96YL7/0s2Ah17QgegAfw
+IIaAuSCmXgmv/T/Yjgvv/TTYHQheBSCGgbkgpkoJr/0/2DTYANkA2rIL7/2VujC9U/APeRC5BSGB
+DwAAgv3PdaAA7CcmpQQggA8AAAAfSLiGuBC4BSCADwAAQv0GpRCHAiAABIwgD4oO989wAAAD/Qal
+CoWLcQCxABQAMeUIHoAI8CCGgLkgpt4Ir/0/2M9wAABD/AalCoVAJIEwALECFAAxEQieACCGgbkg
+proIr/0/2M9wAACD/walCoWLcQCxIMDPcgAAw/9GpUqFCLhAsSDFBX1A2I4Ir/2pcalwxQKv/aHA
+4HjPcQEAxwPPcKAA7CcmoOB+8cBOCq/9AtmiwQDeQcamCO/9i3A+2FoIr/0CEgE2PthOCK/9ABQB
+MT7YRgiv/QIUATEFzNdwAAAAQAHYwiAKABe4ACCBDwAOAAACFAAxG3gP4AQggA8AAPz/JXiduJ+4
+7HEAoQISATbscCCgABQBMexwILACFAEx7HAgsAIUBTFRJQCAyiHCD8oiwgfKIGIByiOCDwAArQHw
+BmL8yiSCA89xAAAiIsoPb/0+2AHYL/8Bwc91oAAsIPCFJXhBwA/wABQAMYHBAdp//+xxALEAFAAx
+AeYB4AAcBDACFAAx5Q4CkMT/MIU+2IYPb/3ieT/Yfg9v/QHBegyv/QHAuQGv/aLA4HjxwKHBEHhP
+IAEEkbmLcxjYENpf/gkC7/8AFAAx8cAuCY/9CHYod3oJ7/0w2AhxhiEGAFILr/0w2GYJ7/0w2P0I
+X4LbfoG+QC8NFCzYNguv/QUlgRNKCe/9MNj9CF+CiiDRDwoPb/0FJYETSQGP/eB48cDSCI/9GnAo
+dzpyz3aAAEwQFJbPdYAATJIQuEYMoAgApYDgyiciEIUhBylPIUAnn7jscQCh7HEAGQAECIYNCB4A
+AIWBuAClz3CAALwGAIiE6ACFg7gApc9woAAsIBCAAN5tHRgQSiTAcMlxqCAABs9wgACuBwCIgOAM
+2MogIQBEKb4Dz3KAACTQJ3AzIgAAACGCD4AAzJMB4QCqHe8AhWIVDxapcWMVBBaAuAClANgG8Oxz
+QKMEGZADAeD34ECBuffPcKAA1AtNoMChYh3YE2MdGBEP8ADZqXIG8OxzAKME4gHh9+EAgrr3z3Gg
+ANQLDaFBAK/91B2AE+B48cDhxaHBCHXqCa/8F9jPcIAA9AQAgJbondgAHAQwEcypcR7aAhwEMAHg
+EHgEIIAPAAD/v4+4ERocMADAGLqy/6IOgAURAK/9ocDgeADY2vHxwOHFABYNQAXMAdrXcAAAAEAC
+yMIiigAXusdyAA4AAFMlARCk/1ElQJDPcYAA9AQB2MogIQDRB2/9AKHxwE4Pb/0A2M9xpwAUSAih
+R4HPdoAAlKRfplCBz3OnADREgB6AEAehz3LzD//8UKEWoaDZmrn1G1gAz3GlAAgMCBEFAEwlAIDK
+IcIPyiLCB8ogYgHKI4IPAAAbAzAEYvzKJCIAz3KkALg9mxIDBs91oADIH3umphIDBiDffKaSEgMG
+faajEgMGfqZQ22KhmxoYAP/ZphpYAJIaWACjGlgAz3GkAOz/B6HPcAAA//8GoVEVEJYB2FEdGJDw
+pUMdGBAA2IIKr/2NuPGliiDEAM9xoADsJwahCoFoHgQQiiDNAAahCoFqHgQQz3AoAAIBBqGKII0A
+BqFRHRiUuQZP/eB48cDhxQhyAd2A4cohwQ/KIsEHyiBhAcojgQ8AAKIAyiQhAGwDYfzKJQEBgOJE
+9lN6iiX/HwkJEwAzebN9FCGAAB4LIAY7eax4gQZv/S9w4HjxwOoNT/16cJpxSHcacwolACEA2s9x
+qwCg/1mhB9gaoVihIN7PdaAAyB/QpQHYQx0YEADYvgmv/Y240aUZ2c9wpwCYRzqgOgygCR7Yz3Kn
+ABRIHYK+gmwSEQBwEhIAAKcAGEAj97jFIIIPAP8AANMg4QX3vcUlgh8A/wAA0yXhFYohEADL/wh2
+qXCKIRAAyf8IdUApACKKIQgAxv8Id0AqACKKIQgAw//ReRnhLHkvcbF6GeJMei9yABuAIw0PYhAA
+HEAjANgF8P0Ig4AB2G0Fb/0AHQIg4HjxwCoNb/0A2c9zoAC0D7yDPKPPcIAAlKRoEAIBELpPIk4A
+iL7PcqAA7CfGomoQDgEQvoUmjRDGot+Az3enABRIx6eAEA4A0KfPdqUACAwipvuAz3akALg9mx7Y
+E/yAph7YE/2Akh7YEx6Aox4YEM9wpADs/yagiiCKAAaivKNWCiACAdgNBU/98cB6DE/9z3CAADCS
+B4iA4OYEIQCswc9wqwCg/2QQGQBoEBcAYBAYAAfdSv8A2c9wqwCg/zmguqA4oIoMYAkB2M93oADI
+H1EXAJbPdqAA7CdAwAHYUR8YkCDYEKcB2EMfGBAA2C4Ir/2NuCDYEafPcacAFEisoQDYDaEOoQ+h
+z3AAAAEqBqbPcKUA6A+noCDYEKcF2EMfGBAA2PoPb/2NuCDYEacB2M9xoAC0Dxyhz3AAAAIvBqbP
+cAAAwjAGps9wAABCSAamz3AAAAJKBqbPcAAAAmIGps9wAADCYwamSiAAIM9wgAAwkiSQC4hEKb4H
+GGAVeGq4ACBBDhUgACQ4YMdwgAB0RAMQlAAEEJUAARCSAAIQlgAgiBC5BSGBDwAAQi0mpiCIELkF
+IYEPAACCRiamAIgQuAUggA8AAEJgBqYg2BCnBdhDHxgQANhGD2/9jbgg2BGnSiEAIBDwz3CAAAig
+FiBABEQYgAFBhUgYQAFAIVEgV6A4oM9wgAAwkgaQMnDaAg4Az3GnABRIXBlABEAqACRPIEEAh7mJ
+uSamCHGFIYsAJqaFIIwABqYlCRAgOQlQIE0JkSBALAAkBSCBDwAAgmAmpgUggA8AAEJiGfBALAAk
+BSCBDwAAgi0mpgUggA8AAEIvDfBALAAkBSCBDwAAwkYmpgUggA8AAIJIBqYg2BCnBdhDHxgQANiG
+Dm/9jbgg2BGngcCCwUAkEzuJworDCiTABB//K8CHCBAACcBAKU0hx3WAAIyfAKUKwAGlAcAYpQLA
+GaVALgAkhSCKAAamINgQpwXYQx8YEADYNg5v/Y24INgRp4PAhMGJworDCiTABAv/K8Ai6AnAAqUK
+wAOlA8AapQTAG6VDCRAgVwlQIGsJkSBALQAkBSCBDwAAgmAmpgUggA8AAEJiJvAKIcAP63IF2Ioj
+RAWn8AohwA/rcgXYiiMECJ/wQC0AJAUggQ8AAIItJqYFIIAPAABCLwzwQC0AJAUggQ8AAMJGJqYF
+IIAPAACCSAamINgQpwXYQx8YEADYjg1v/Y24INgRp4XAhsGJworDCiTABOH+K8DbCBAACcAGpQrA
+B6UFwB6lBsAfpSDYEKcF2EMfGBAA2FINb/2NuCDYEadAKgAkhSCKAAamh8CIwYnCisMKJMAE0P4r
+wK8IEAAJwAjBBKUKwAHDBaUHwBylPaUDwQIhwgAFw1hgAiDFgEzyYnlMeS9wqHGw/gPBQCiNILR9
+FSVNFAJ5x3WAAJSkAsAEwiGlCMMCIgEABsA7YwIjBYA88gJ6LHovcKhxo/4EwgXDAiIBAAPAJ6UC
+IwaANB2AETPyBsACIIWAeAXi/0wdQBEKIcAP63IF2IojxQUa8AohwA/rcgXYiiNEDkokAADVBS/8
+CiUAAQohwA/rcgXYiiMFAfXxCiHAD+tyBdiKIwUDsQUv/Iokgw8KIcAP63IF2IojBQT28QohwA/r
+cgXYiiMFBYokgw+NBS/8CiWAAUAgUCBMIICgggTF/wDYz3GgALQPHKHC/s9xqwCg/2QZQAZoGcAF
+YBkABkokAHEA2aggAA0ocIAggg0QeAa4gbiXuAamKHCAIEIPEHgGuIG4l7gGpihwgCDEBhB4BriB
+uJe4BqYocIAghAgQeAa4gbiXuAamKHCAIIYAEHgGuIG4l7gGpihwgCBGAhB4BriBuJe4BqYB4QDA
+UR8YkMUHL/2swPHAlg8v/ZhwocHPcoAA+AQgis9zgACUpAGChBMDAJBxzCDBgOnyEQjAAM9wgACs
+pSGIIKpKJMBwSiAAEKggwALPcIAArKUyIAACCwgAAUAgSBBMIMCQogEGAM9wgACspQGIEQgBAQQh
+AQEvJUcABvAHIAABLyUHAGGiANvPcKAAtA9wEBIAfKAAGgIBFPBAIIAhEHgGuIG4QCkBJCV4BqZA
+I4ERMHkGuYG5QCoAFCV4BqYB489wgAAwkgaQEHMwAQYAANkPIcEACyFAgQHYyicCAA30CyEAge3z
+z3CAAKylAYjTCACBCicAAhLr0QtQAA8LkQCKIIYgiiFGAgvwCiHAD+tyBdiKIw8CZfC22r3ZGnJ5
+cc92oADsJ0ohACBKJABxCiJAFCp1qCBBAgAgQSNUa0AvAAEUeBpitXrHcoAADKUIkjB5QCmJAU8h
+QRAcfxC/5XkmpsC4uHgFIEAELyEIIAAjTxMJkvB/Br9PJ0YQHHlAKRMEBSOBISamwLi4eAUggQIv
+IkgQRSHAEAamCoaLcQCxCJIvJgEAABQAMSsIgQFFJ88Q5qYKhgCxCZIAFAExHHgrCEEAAeVr8Yoi
+xAaKIYQIpvEKIcAP63IF2IojDwdKJAAADQMv/AolAAEKIcAP63IF2Iojjwf18c9xoAC0D3AZgAT5
+BS/9ocAA2c9wgACspSCoIajgfyKo4H7gePHAbg0P/a/Bz3CAAEwQCIDPdYAAdETAuEDAz3CAADCS
+JJALiEQpvgcYYBV4argAIEEOAMAVeDhgGWUjiUHBGWUkibhgAohCwUPAz3CAAJSkAIAiuMC4RMDP
+cIAAlKRkEAEBz3CAALgGAJBKIQAgUwkBAM9ygACsui2Kz3aAAKylhiH/AWCOQ7nuik+KAiHBgGGO
+hif/EcohYgBDvw4jw4OGIv8ByiNiAHt7ZXl7akKODiLCgMoiYgACukV5AvAH2YDh9gMhAEXBz3Gg
+ALRHRxEBhoDh4gMBAM9ygACsui2Kz3OAAKylhiH/AUO5IKsuioYh/wFDuSGrL4qGIf8BQ7kiq89x
+gACUpGQZBAAA2Z65z3CgALRHUxhYgEv9z3agAMgfURYPlgHYUR4YkCDYEKYB2EMeGBAA2E4Ib/2N
+uCDYEabPcYAAMJIEkSuJz3KgAOwnRCi+BzlhNXlquQAhQA4AwTV5OGAJZRC5BSGBDwAAQi0mogll
+ELkFIYEPAACCRiaiCGUQuAUggA8AAEJgBqJRHtiTz3CnABRIDIDPcg8AAPzPd4AAlKRGwADAArgU
+eBtnHWcZZwAnBBAAJwUQH2cJh2GDp4UGxyAUBAAigQwVBQCc7wq7RHvJvaV7z3WnABRIbaUKuSR6
+iHHJuUV5z3KnABRILqJALYECBCGBDw8AAPzJuCV4G/AKvUR9ybule891pwAUSG2lQCyDAmR6yblF
+ec9ypwAUSC6iCrgEIIAPDwAA/KhxybkleM9xpwAUSA+hSiIAIAPYR8AKI0AkBcARIICELgIBAM9x
+gACspTIhgARCcUjBz3GgALRHYBkYgBC4m7jPcYAAaLsgiZ+4gOEB2cB5D7kleM9xoAC0R18ZGIAG
+8LoLL/2KIIgDz3CgALRHcRAAhgQggA8OAAAAQSh+hPL1AN8D8AHnz3CAADCSBpAQd74BBgAIwACI
+7QjOgwDAArgUeEnAAcECwAIgWQDPcKcAFEj3oArv9Q9QEBkPkRCKIYYgiiNGIgbwtti92TpwenFK
+JAAhinVAL1gRYb1RFhCWAdhRHhiQINgQpgHYQx4YEADYYg4v/Y24INgRpgPANW0leBB4ELiFIIoA
+z3GgAOwnBqEAJUAUEHgGuIG4l7gGoQAlwBQQeAa4gbiXuAahQCGAIRB4BriBuAahQCOAIRB4BriB
+uAahUR4YlEAkBD6KwIvBjMKNwwP9LsCN6M9wgACUpHwQAAbPcYAAlKQB4HwZGAAJwAbB9XjHcIAA
+lKSb6YvCYIKKwSCBisJgoovCIKKNwmCCjMEggYzCYKKNwiCiM4A0EBAACvCKIMQGiiGECI7xLYBM
+EBAAFiBAMwrCACCVD4AAjJ8LwPAdgCD0HQAgCCKAD///Af8vJkAmBC4+IC9wzPwOIJcPAAAAAQvA
+iCB8AAQovgUvcApxxvwOIIEPAAAAAQkngC8AAP8BiSHHD0ggAABIIQEALsJUHRggVR1YIAsKUAAE
+wozqVG9AKgMhdHt6YrV6x3KAAAylCLIpskIkVCBMJACgkgbN/xzxB8BhuIDgQCJSIMIF7f9HwPf8
+BfC6CS/9iiCIA89woAC0R3EQAIYEIIAPDgAAAEEofoTx9fkAL/2vwPHAocGLcP4OL/0E2QDAUSAA
+gCgMgv8AwFEgQIAoC+L/yiCiAADAUSCAgKQOwgkAwFEgwIBMCQIKSg6gAQHYz3GAruAB7HAgoALI
+7HEAoc9ygACMn4okgX0A2aggAALwIkMA7HBgoAHhkgsv/QDYocDRwOB+8cBmCA/9z3CAAIQFAIC7
+CFQBz3agAKwvGoZSIAAAqwgfAM9xgACMpQmBAeAJoc9wgAB0u0CAA4AVeQbqCoEB4AqhBfAYgQHg
+GKEYhs91oADIHyDfmrgYpgXY8KVDHRgQANj2Cy/9jbjxpZX+GIazuLq4GKZk2PClQx0YEADY2gsv
+/Y248aWeDwAJTg3ACMoOgAEG8IoIL/2KIIgDz3CgAHhFAIAEIIAPDgAAAEEofoTy9c9xgABMEEiB
+NJFTIgAAAgvv/AHbtgkv/BHYAQAP/fHAlg/P/M9wpQDoDweAz3KkAAxCUyAEgEQgjQBEIAMBAoLP
+dg8AAPwIccm5xHjjgiq42HfEf0EvhRLkglMmRgLpcsm65H4qvgbyDQmUB4whT4jE9wDZA/AB2QsM
+EAALCJUHANgF8IwgT4g99wHYG3gleATtCQ6VBwDZBvCMJk+IPPcB2QK5BXkD7QsNlQcA2AXwjCVP
+iD33AdgDuAV5BOsJCpUHANgG8IwiT4g89wHYBLgFeQPrCw6VFwDYBfCMJk+YPfcB2AW4JXhCIACA
+MQfv/MogYgDgeOB/ANjgfuB4z3CgACwgEIDgfwng4H7geOB/AdgA2Za5z3CgAKwvPKDgfuB44H7g
+eOB+4HjgfuB44H7geOB/ANjgfuB44H7geOB+4HjgfuB44H7geM9ygACgEFSKWWEweUFpDQoDACJ4
+EHgD8ALYz3GgAMgfHqEQ2A6hAdgVGRiA4H7gePHAOg7P/ADfz3WgANAP9aUD3hLw4HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44Hhhvowm/5/u9QPYGqXPcIAAoBDvqAHYFaVVBs/88cDqDe/8
+BdgA3Qu4qXHd/89xgAC0px6BsQieAx2BrQgeAHIJz/sA2Zy5z3CgANAbMKAB2c9wpACYQDygBCC+
+zzAAAAAB5colIhBJCx9ACwheRU8JnkMdCN5FGQmeQ89wqgAABAGAhiA/CzcI0ADR/yDfz3agAMgf
+8KYB2EMeGBAA2FoJL/2NuPGmtQ0UkQnwyP/PcYAAwJMJgQHgCaEA2R8IHkcA2s9woADQG5y6UKDP
+cIAAkARAgBCCAeAQos9wpACYQDygOvDKCM/7bQhfRVEgAMUB5colIhDPdqAAyB8g3x8LH0DwpgHY
+Qx4YEADY6ggv/Y248aZBDRUR6PHPdaAA0A8A2BWl8KYB2EMeGBAA2MoIL/2NuAPY8aYapQDYz3GA
+AKAQD6nPcYAAwJMJgQHgCaEB2BWlGQXP/PHArgzP/ADfz3agANAP9aYD3RLw4HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HhhvYwl/5/u9QPYGqbPcIAAoBDvqAHYFabPcYAAtKcdgYC4HaGb
+/xYNgAK5BM/84HjxwOHFz3KgANAPsILPcIAAoBAviADbDw1BEAPZOqJvqALw3/+dBM/8ANvPcqAA
+xCeKIBgIPBrAgM9xoADIHw6hgBEAAFEgQIDPcIAAZLAM8kISAoYEIr6PAMAAAATyQYAC6kKggBnA
+AOB/YaAUzAQgvo8AAChAQ/JBCN4AFRICN4DYz3GAAESTFBocMA0K3gIYgQHgGKEF8BCBAeAQoREK
+3wAA2c9woAAsIC+gFcxGIIAC4H8VGhwwLwheAYogBAAUGhwwz3GAAESTD4EB4A+hFcwA2UYggAIV
+Ghwwz3CgACwgL6DgfgTYFBocMM9xgACwDR+BAeDgfx+h4H7xwE4Lz/wA3SDYz3aAAOytQCYPFcIM
+IAYAps9zoADIHwHYE6NYgzmDVBMEAPgTAADPc6AAMBBhg89zoAAMJAIiAoBngwMhQQNBpiKmAiQD
+AM9ygABMEM9xgAC0p2OmTBlEAxSSUBlEA2iCCbbPcqUACAxTIwAACLYAEgQAThlEA1MkRQFTJEIA
+SBlCAYPiyiHBD8oiwQfKI4EPAABWDewHofvKIGEBBCSFDwAAAOBBLUIDlhmCAD6BFB4AERkJngME
+uoG6RXgItgfYB/AVJwwQoKQD8ATYAeD1CBSC67soCoL+qXdRIIDFtPKA57L0z3CAALSnPoAEIYEP
+AAAAQAQhgE8AAABAEHEB38onIhDKJWIQz3GAAKAQD4kB4A94D6nPcaAAtA83gQDeFQhBAM9woACo
+IAaAjCCDjsz3AN9Z/89wgACQBCCAAd0IgQHgCKGA54Dyz3GAAOytBYEEIIAPAAAA4EEoRAPPcKQA
+kEF1gFaAuHJIoc9ygAC0p2ehDQweAEwaxAAJ8EwahAMEI4MP//8AAGehDwxeADC7ThrEAAXwThqE
+A3B7Z6ENDJ4AUBpEAQnwUBqEAwQlgw///wAAaKENgAahBCCADwAAAP4puFIaBAAegkUIngPPcKoA
+AAQEgAmhz3CAAFCuQIhAIAQBMOpbCnQAAhCFAPQkgwMV2BO48CDDAM9wgAAortV4AebrDqSQYKAb
+8M9wgABorkCIQCAEARbqJwp0AAIQhQD0JIMDKdgSuPAgwwDPcIAAKK7VeAHm6w6kkGCgQakCGUIB
+l+8EIL7PYAAAABP0z3CAAJAEIIAB3QGBYbgBoQeBAeAHoYoghQf6Dq/8FBIBNysLHkAA3wf/iiDF
+B+YOr/zpcc9wgACQBCCAAd0BgWG4AaEHgQHgB6FiCe/8iiBEAgQgvs+AAQAAzCcikMwlIZAU889w
+oAAwEAOAANkL6M9wgACQBECAAd0odwyCAeAMohXtAtnPcKAAyBwqoCL/z3CAALSnQNk9oBTMhiD5
+jwX0ANiPuBQaHDCxAO/86XDhxTDbAN3PcKAAyBxpoAPaz3GgAMwXIRmYgE6hp6BqoOB/wcXxwOHF
+z3GAALANDoEB4A6hz3GgAMQnGREAhgDaBOgC2BAZGIDPdaAA1AtXpQX/z3GAALSnHYGHuB2h6f8Q
+hSvoA9gRpeB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HgRpRPMERocMLn+CQDP/AohwA/rcgXYz3MAALwJSiQAALUEr/sKJQAB8cCR
+CR9Gz3CgAAwkB4CFCBAAz3CAADCoC4DPcaAAyB9k4B6hENgOoQHYFRkYgDYL7/wL2F0JH0YA2kMI
+XkfPcaAA1AsWgTiBJOAZCEUACwkfRv8LHsAnCx9AIwifRBrwANnPcKAA/ESeuSGgRaDPcYAAsA0P
+gQHgD6HPcJ8AuP9cGMAIz3CfALj/XBgACLL/0cDgfvHA3g6P/Ah1z3aAALSnHYYvJgjwO/QlDR8Q
+grjPcYAAkARAgR2mA4IB4AOiIIGKIEUJzgyv/COBHYYlDV8QhLjPcoAAkAQggh2mBIEB4AShIIKK
+IIUJqgyv/CSBz3CgAAwkA4BRIMCAHYYR8oS4z3KAAJAEIIIdpgWBAeAFoSCCiiCFCXoMr/wlgT2G
+LyZI8ADfD/QKIcAP63IF2M9zAAARCYokgw91A6/7SiUAAM91oADQDxEVAJaA4IHyRCF+ghHyLwke
+AM9ygACQBCCCAoEB4AKhIIKKIEUIJgyv/CKBB/ApCR4Bov8dhs8I3wHPcKAAxCcZEACGBugC2c9w
+oACQIz2gS/4b8Jn/HYarCN8BOYXpcgXwABEAUAHiT3pBKYAA9woEgADaBfAAEYBQAeJPelMhQAD3
+CgSAA9gSHRiQ4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeBIdGJATzBEaHDBe/h6GFwjeBM9wgACctOuoz3CAAFy07LDPcAAA/3/P
+caAADCQBoRvYBKE6/5EFj/wKIcAP63LPcwAAWAkF2G3x4HjxwOHFUN0A2s9zoADIH6+jXqMCIEIA
+XqMB2hUbmIBA2k6jBCC+zwACABCADoH/XQWP/OB48cDeDI/8z3CAALSnMYAlCV4Cz3GAAKAQLolE
+EIIARHlRIYCASNrKIoEPAACQAAPwDtoA289xoACoICeBqBANAFlhsXHCJUUQyiXmErB4CtmJ/Sz+
+z3CAAPRHAJDPdqAAxCcNCB4BjCUDkgT3AN8U8M9woAC0D3ygz3CrAKD/eqAiCaAJANgZFgCWBegC
+2BAeGJAB3xkWAJZ9CBEAeQkfRgPZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaATzM9xgACwDWq9ERocMBSBAeAU
+oRWBuGAVocoPr/wB2HoJYAEB2Mj9MQSv/Olw4HjxwMILr/zA2M91gADsrUGNIBoCMBJqRODPcaAA
+1AvYgQDbQiYOGIDmyibMEEUOBRDPcZ8AuP8Ygc9ygACQBJC4GKEYgbC4GKEgggWBAeAFoc9xgAC0
+px2Bg7gdoSCCiiDFCIIJr/wlgQDYH/8A2D7wz3aAAEwQyYYD4AQggA8AAPz/Kr7Avhe+x3YADgAA
+xXjsdgCmCMjsdgCmEczPdqAAiCRKJMBzAeAQeAQggA8AAP+/j7gRGhwwHqYA3qggwAHwJY8T7HDg
+oAHmHQp0AADdz3CAACiu8CBOA+xwwKAB5fENhJBtoQHYQQOP/MHYIBoCMM9ygABMEBiKAdvPcYAA
+tKeG4BaBwiPBAAzgGCDAAGIZBABiEQABA+AEIIAPAAD8/524n7jscwCjCMjscwCjGIo2gYbgAdjC
+IAEAGCEBAOxwIKDgfwHY8cB+Cq/8G9jPdqAAxCcVFg2WFh4YkAPZz3CgANQLMaDgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaAT
+zBEaHDCKIAQMLgiv/ADZi/0lDR4Rz3CAAJAEIIARgQHgEaFS/RkWAJYE6ALYEB4YkGn+IvBSFgCW
+UyBBAIPh0SXhkATyvf4Y8M9wgADpBwHZIKjPcIAAkARAgAaCAeAGos9wgAC0px6ADQjeAc9wgAB0
+BSCgEQKP/PHAogmv/ADZz3AAAP9/z3WgAMQnEx0YkBvYFh0YkAHYEB0YkM92gAC0px6GCwheBKge
+QBAI8BGGNobODGACANqoHgAQev4dhgkI3gEA2CXwLRUBllaGEQpAAIC4HaYA2Jj+9vEEJYFfAADw
+Lx6GJXgephEVAZYPCV4Cz3AAAESvC/ANCR4EAtiIHgQQDwkeAM9wAADosXkBj/wzCd4ACNgTHRiQ
+B//U6ALYPB0AkCEVAZbPcIAAZLAhoBEVAJYPCJ8AW/4dhokI34ERFQWWGw2fAAohwA/rcgXYiiNG
+CP0Fb/uKJIMPBNgTHRiQjv+w8fHA4cXPcoAAtKcWgs9xgACEsA0IEAZUEoAABegZgrqCA/AbgryC
+UYLPc/7//z9keKR7BCKCDwAAABBFeAChANgBoWV6SaEO2kqhz3GAACzK+giAAc9wgAB8xwCAEQhe
+AM9xgAAczeYIoAEB2LkAj/zxwDIIj/zPcYAAAAAAgTkIHgABgVEgAIBA2M8g4gfKIIEPAADQAM8g
+4QfPcp8AuP8dogSBAeDTuAShBSCAD9D+AAAWogDez3WAALSn3aXepVQdghPfpYDYlB0CEM9wgAAI
+s9mgz3CAAHCwwKDPcIAAuMbCoBTMgB2AE4gdhBOoHYATIQjeABXMUyBAgAryz3CAAEwQCYBRIECA
+SiFAIATySiEAIM9woAAEJdSgMNnPcKAAUAwioBHMExocMNj8z3eAAEwQz3GAAEySPQmeQwDYjrge
+pc9wgACQBFThIKAblxy1HZeSHQQQiiCEDh61iiBEC24Nb/wA2QbZz3CgAMgcKaAU8M9wgACQBATh
+IKAalxy1HJeSHQQQThcAER61iiCECz4Nb/wA2c9xgACQBECBAIIB4ACiIIEBgQHgAaH62JYIr/8A
+2ev8gODIBwEAz3CgAAwkz3EAAP9/IaDPcKAA0A8REACGDegKIcAP63IF2IojTgyKJIMPAQRv+7hz
+AdnPcKAA0A8RGFiAaBeBEByVAiBQAB6F7rgYAiEALyAIJEAdhBPPcKoAAAQCgM9xpQAIDCCBBCCC
+DwAAAP8ougQhgQ8AAADgO3mJuiV6KIcEIb6PAAYAAFGlA/KMulGlz3OAAOytTaMMo89xqgAABCCB
+RBWCEJTiKqMZ8gb2MwqRAiO5DvAdCtAN7uIT9EUp/gJBKcFwUSDAgcIhYgAA2AvwRSn+AkEpAXH6
+8SK5+PEA2QHYNqXPcqoAAARBgjyzS6PkusogYgDhusogYQCGIv4PQSoEARATBQFJHQIRHaUFJQIB
+SLNVIcMGz3IAAHwPCSOCAAsIHgAA2DvwHQmUA6AXAxAVC0QAz3OgANAPgBMDABMJwACAuB2lxgtv
+/IogBQjr8c9woADQDxkQAIZCIAAISCAAADkIhQDPcZ8AuP8YgZC4GKEYgbC4GKHPcYAAkARAgQWC
+AeAFoh2FIIGDuB2liiDFCHoLb/wlgcfxAdiK6ADfz3WgANQLANia/RMGAAAKcADZCv5iF4AQRBWB
+EAQgRACGIf8DQikFAUQkAgGgcs9xgADoysG6SWGJuTulbBWDEEkVgRAEIw8AhiP/A0S7JH9/Z89z
+gAAId/QjzwNKHYITXh3EE893gADYzUpnibpcpXAVghBEeIYi/wMkeES6WGD0IwAABCEBAWAdBBAR
+haBxz3KAACh39CJDABmlz3KAADh39CJBAIodxBAapYwdxBCOHUQQkB1EEFECIAAA389wpgAIBAGA
+BCCADzAAAAA0uEAdBBBAFQERGwhfRs9woACoIAiAGWEwef4Nb/8KcAPwCnDS/QQggE+AAQAAAN8x
+CIEPAAEAAAHYlhWCEEodAhDPcIAA7K0okAS6ibpAHcQTSR3CE/al6aBFeSiw3/BJHcITz3CmAIwD
+XYAEIoEPOAAAAEEpwASWHQIQBCKADwAAAPAsuCW5JXgRpc91gAC0pw0I3kcRhYy4EaVTIsECRBWE
+EDalUSQAgNEi4ocA2AL0AdjPdoAA7K1JppYVghBolgS6ZXpItnGFPLZTJMIAXHrPd4AA2MpPZx2l
++6VsFY8Qw78vJcEDz3eAALyu9CdPEW2mXh3EE893gADIzU9neaX8pXAVjxDDvy8lwQPPd4AAvK70
+J08ReqVgHcQTz3eAANyu9CeFEM9zpgCMA893gADsrvQnghCKHUQRjB1EEY4dhBCQHYQQfYMEI48P
+AQAAADC/Sh3CE2mmShWDEADaFusXDFADgLgdpYogRQgyCW/8iiFRAB2FDwgeAHHwugtv/IogkQP7
+CB7GSPBVIc4Gz3MAAHwPCSbDEAsIHgAA2DvwIQmUA892gADIEMmGFQ5EEM93oADQD4AXDhATCYAD
+gLgdpdoIb/yKIAUI6fEZFwCWQiAACIDgyiCMADkIxQDPcZ8AuP8Ygc9ygACQBJC4GKEYgbC4GKEg
+ggWBAeAFoR2FIIKDuB2liiDFCJIIb/wlgcfxAdgl6ADfz3aAALSnEQkQIBaGDQiRAx6GkbgepkoW
+gBCa6Ml1z3CgAHgmQtkyoB6F8biwAgIAnf2A4KACAQDW/YDgoAICAJUCAAAA2ND8jQIgAADfiiDF
+ADIIb/yKIRELz3GmANQELBEAgDQREYA4EQ2AyxESBipxxrmpcoYi/Q8GukV5KnKGIv0PBLpFeQQg
+gg8CAAAAJ7pFeUQlAhwNukV5qXKGIvMPBCCADzgAAAAOukV5JbgleEQlgRAUuSV4iLhEJQESQSnB
+gFIgQAURplQeQhDKIYIPAAD//8ohgQ8AABAfGnE2hj+2BCGBL/8DAP8ouTam3gwgAgDaqB4AEHUN
+nhREFoIQMYag4tEh4YIy8gQhhI8AAAABCPLPc4AAAHZLYxULkwAEIYMPAAAAJEULgA8AAAAkBCGD
+DwYAAAAxuzUL1QAXC5EALQwQAM9zgAAAdktjIQuRAAsMEADM4gr2doYSc8ojjg8BAIgNzCDOgM73
+FQ4FcAEAiA3PcoAAsA02ggHhNqIB2Rvwz3OAAAB2SmPPc4AAMJJmkyELggAXCd4Cz3GAAEwQKIEE
+Ib6PAAYAAATySiAAIATwAtkacVQWgRDPcoAA7K0oGkAEB7lokoi5ZXkosjaGMBqABDyyMYarogQl
+jR8IAAIAHbItotd1CAAAAOAPYQrKIAEEFoZ0HgAUhOjCD0AKaPDPcaAA0A+AEQEAGQhAAE8gASA9
+ps9ygABEkyCCAeEgolQWgRBs4AzpCSCBDwAAagbPcKAA0A8iGFiAB/DPcQAAfA8JIEEAz3CgANAP
+GRAAhkIgAAhIIAAAQwhFAM9xnwC4/xiBkLgYoRiBsLgYoc9xgACQBECBBYIB4AWiHYYggYO4HaaK
+IMUI9g0v/CWBz3GAAESTAoEB4AKhHYZEIP6CFPKGIL+NCvKKIMUL0g0v/IohEgdfAs//z3GAAEST
+CYEB4Amhr/wE8BIMz/3PdaAA1Asv8Hv9CiYAkC70A9jPdaAA1AsRpeB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgRpRPMERocMPCl
+fQcP/B6FCwheBEB+yPEUzIYg/4UF8gPIAYAJCF4Hmf1KC0AI8/HgePHA4cUIdc9wgAAwqAuAz3Gg
+AMgfZOAeoRDYDqEB2BUZGIAF8JoPL/x72AGFg+j5Cx7AAYXBuCMI0QDPcIAA6QcB2SCoz3CAAJAE
+IIAGgQHgBqEA2BTwAYURCB8Az3GAALSnHYGCuB2hAYUTCF8Az3GAALSnHYGEuB2hAdgBBw/88cDP
+cIAAaK7CDy/8GNnPcIAAUK62Dy/8GNmNB0//4HgB2gDZz3CgALQPXKDPcIAAwJMpoGUAb/sY2OB4
+ocHxwCIOD/wId1pyz3KAAAAAAIKacaHBOnM5CN4BAYJRIMCBQNjPIOIHyiCBDwAA0ADPIOEHz3Gf
+ALj/HaEEggHg07gEogUggA/Q/gAAFqHPcYAA2LQmgQDYgeEB2cB5QCkTA38PEBDPc4AAtKeUE4EA
+FQnfAc9wgAAoiwS5IGAtuMC46XGGIfwAjCEChRR7D/TPcIAASAUAgA8IngAg3Y4TDgEI8JjdihMO
+AQTwXhMOAQ7diiCFALILL/ypcYoghQCqCy/8yXHPcIAAcLAAgOC4wCUiEbB6LyCII0onQCAJ8M9x
+gABwsACh+nAIdRpwCHLPc4AAuMYggw0J0QAjgxcJ3wBKIQAgCiZAJAogQDQKJUAkf/DAEwIAOBKD
+ADcSgQAIu2V5ORKDABC7ZXk6EoMAGLtleTQSgwBAIRAEMxKBAC8gCCQIu2V5NRKDABC7ZXk2EoMA
+z3KgAPxEGLtleUAhFQFdggDZUSKAgcwhIqAI8i8iSAU6cfpx2nEbcUvwTyPTI0EsQiPAugS6VHqK
+cca5SSHBBTR6z3GAAKB4UWENDN4iQSkCARQiQQAouQPhz3YAAPz/BCGDA89xgABAqEiJz3GAACiL
+BLpBYUAgECEvIAgkDwmeBHt7QCAQIS8gCCRAJcEhJH4II4IDAiKYA1EgAIDAJSERJ20EIYEPAAD8
+/wgjQAACIFYAGmJQeoohAiACEgEhQCAAJRUIQwACIQEESCEBADB5QMEE8ADYQMAvIEgEinEKcx4J
+IAJKJAAACiQAoDz0CtjPcaAAyB8eoRDYDqEB2BUZGIAG8KYML/yKIMoHGwgfQ89woAD8RB2ABCC+
+jzAAAAAD9OULHsBRIwDAyiHCD8oiwgfKIGIByiOCDwAApQLKJCIA7AAi+8olIgBRIADDANgJ9M9x
+gACwDQmBAeAJoQDYmLiacEwkAKDKJSIQyiBCA8P0z3aAAHCwMQkQIM9woAD0B62gz3CAADTHMYBb
+iRqJCLpFeAS2XYkciQi6RXgFtgCGgbgApgTwANgCpkwnAKCV8gCGdQgeAM9wgADsp0yIz3CAAAB2
+MiCEAB/ZOwx0AADaz3ADABQAVnjPc6MAsP9Q4GBgz3UDABgAVn1Q5WNlLygBAAHiLyvBAAJ7MHPK
+IcUA0woEgUAsQAFCIAAIGWHPcIAAaHkoYCGGTyPTIwm4BXkChiV4AqYFI8AjDXEAsQ1xAMAAsQwS
+ASANcCCgEBIBIQ1wILCKIIUAyggv/OlxjCcClRPyjCcDkRzyjCcDlSDyCiHAD+tyBdjPcwAACAyK
+JIMPuQfv+rhzz3CAAJAEIIAPgQHgD6G+D6ABSnAR8M9wgACQBCCADoEB4A6hCfDPcIAAkAQggA2B
+AeANoQCGBugihg1wIKAA2ACmz3GgAPQHANgnCRAgB6EB2AuhA9gIoUwZgAUB2ALwANiqcQtySnN2
+CWAKABQEMM9yoAD0BwDZJKIB3YDgAdhiCWAKwHgAwQAhAATPcaAAyB/4EQIAQnhIIAAAX4EQeEkI
+hAAMEgIgz3CAAGSwQqCg2A+hANgfoc9ygACgEM9wgAC0p1WKHJBCeADCWGAfoQLYFRkYgA0MECBR
+IEDGINgD8oDYDqGMJwOVBvTPcIAAtKcckAnwjCcDkQj0z3CAACyoDZBmDG//ANmSDQ//FMyGIPmP
+C/SMJwORANjPIKEDyiAiARQaHDDPcIAAAAAAgBEI3gHPcZ8AuP8A2B2hz3GAAHCwANgAoalwCNxP
+AS/8ocDxwCIJL/wA2Qh1AYDBuIPgyiBBIMogQQAF8qlwgf5KIEAgIwhQABCFhwieARCFz3aAALSn
+NQjeAc9wgACgEAKIGPAB2wDfN/AA31UmQBrpcZDatg/gAADbQCUAEpweABAA2AW1BNsn8AWFJoWS
+DUABlB4CEBEI3gEdhpW4HaYehpe4HqYfhgQgvo8QcAAAyiciEOr1nLgfps9wgAB8xwCAqQhegBCF
+pQhegwHfz/EA3+lzz3KAALSnVBKOAM9xoAD0Js9wgABksJDuz3aAABKo9CbOE1yS2mLPdoAAoBDV
+jsJ6ELqAugPwAtpDoSWFIaAdCBEgz3CAAOkHAdkgqM9wgACQBCCABoEB4AahPgwP/3UAL/xocOB4
+8cAKCC/8kNmiwQh2QcEhhsG5g+EA2MogASAG8slwO/5KIEAgz3GgACwgJoEA3zB5NQhQABCGaQie
+Ac91gAC0pxyVFQhDACWGz3CAAGSwAoAQcaT0EIYVCN4Bz3CAAKAQAogI8AHYQPAFhiaGegxAAT+F
+BCG+jxBwAACUHQIQEPTPcYAAfMcggVEhQIAB2UXyUIaHCl4DQMEod0HwAN8h8ItwBOgC22CgA4GD
+uAOhBeoAgqa4AKIsFgAABKEMFgAABaEAwQHCVSVAGiYO4AAB2x+FnrgfpUAmABKcHQAQVgsP/wDY
+z3WAALSnVBWCEM9xoAD0JsEKEQDPcoAAEqj0IsMDXJV6Ys9zgACgEHWLYnoQuoC6UfBAxwDfqwjf
+gW2GBYbPcYAAuMaBwgQjgw/AAAAAAoE2u0AmBhJAIQQLQwjOAAWWHBEHAEIgBQT0JMMACCdAASsL
+AwDPcKAALCAPgI/oz3CgACwgZoAclTUIxYDPcIAAZLBigAWBKQsAgAOBNwjegADaz3CgAPxEnrpB
+oAOBo7gDoZHxz3GAAJAEQIELggHgC6IggYogRQuCDO/7K4F28QLaQ6FFhs9xgABksEGhHwgRIM9x
+gADpBwHaQKnPcYAAkARAgSaCAeEmopEG7/uiwPHAKg7P+wh2FcxTIECACvIHEgE2ANiYEQEA4gng
+AAhyAYbBuIPgyichEMolwRMG8slwvf0IdQHfgeXKI2EAQfIQhg0InwEA22hwPPAUzF0I3gAVzFMg
+QIAbEgI2D/QAIoEPgAAQnQHYAKnPcYAArLoyiVEhAIBcC4IAENgUGhwwz3GAAESTEoEB4BKhA8gb
+EgE2hBACAc9wgAAEnTV4KYBZYSmgCN3R8c9wgADIkiuAAeEroJYL7/uKIMUJANsB2ALZz3KgAPQm
+I6JDhs9xgABksEGhje/PcYAA6QcB2kCpz3GAAJAEQIEmggHhJqIK6ADYnrjPcaAA/EQBoQDYBaFO
+CQ//jQXv+wUjQAPxwCINz/sIdgGAwbiD4ADdyiBBAwTyyXCA/QHdANlZCFAAEIZRCJ4BFMzPcoAA
+TJIzCF4BQNgUGhwwUBIABgHgUBoYABvIz3KAAIicFHogqgMSATYA2JgRAQCWCOAACHIK8KQSAQAB
+4aQaQADSCu/7iiAFCgLZz3CgAPQmI6Ajhs9wgABksCGgje3PcIAA6QcB2SCoz3CAAJAEIIAGgQHg
+BqGiCA//6QTv+wDY8cDPcoAAtKdUEoEAk+k8ks9ygACgEFSKQnkQuUUhQwHPcaAA9CZjoQDaz3GA
+AGSwQaFP/YHgyiBhAAXyWggP/wDYUQUP/+B48cAmDM/7CHUacUEpAAHPcYAAIHnDuAhhJJUEIYEP
+AAAAgNdxAAAAgAHZwHk1eCGVBOEfCEAAjCACpAn0z3CAALSnFoCMIAKGA/IQ2JTwJJX6Ce/7iiDE
+C4wgAqwi8g72jCACoEPyjCACpGTyjCACqIT0qXCk/oDwjCADpBXyCPaMIAOgevSpcKH/dvCMIAOo
+zCCCrwAA8ABw9Klwx/9s8Klw3/5o8M9xgAAAAACBOQgeAQGBUSAAgUDYzyDiB8oggQ8AANAAzyDh
+B89ynwC4/x2iBIEB4NO4BKEFIIAP0P4AABaiqXBH/0bwz3KAAAAAAII5CB4BAYJRIACBQNjPIOIH
+yiCBDwAA0ADPIOEHz3GfALj/HaEEggHg07gEogUggA/Q/gAAFqGCCmABqXAk8M9xgAAAAACBNwge
+AQGBUSAAgUDYzyDiB8oggQ8AANAAzyDhB89ynwC4/x2iBIEB4NO4BKEFIIAP0P4AABaiogxgAalw
+FQPP+01x0gjv+4oghQhl8fHApgrP+892gAC0px+GBCC+jwBwAABW8i8pAQDPcIAAAAX0IE0AnBYC
+EADfpBYBEE8lgBDpcwr9j+iMJQOQz3GAACwOBfQUgQHgFKE68BOBAeAToTbwH4ZdCJ4Hz3WAAKy6
+EI0ujVkJAAASjVEI3wAwrd4PYAAD2DUIH0MA2Z65z3CgAPxEIaAwjYYh/wFDuRC5TyHCBs9xgABo
+uyCJn7qA4QHZwHkPuUV5LaASjYS4Eq0G8M9wgABQtOCoHguAAU0Cz/vxwOHFbgov/wDdz3GAALSn
+HYFRIMCBXPTPcKAABCWigAQljR//AF//UyWAEIcI0QGDCp5THoF/CJ8GBCC+jwAeAAAO8gbwz3AA
+AA4KTgrP+/cKn8BRIgDAzyViEc9xgAC0px6B+bjPJSISzyXiEs8lohMh9CUI3gaIvYm9jb1PJcAS
+vYGOuAQljR8CAAAAUiVNFCq9BX0P8Py4xSWCHwAAAAXPJeISzyWiE8UlgR8AAAAHz3CAAECoCIjE
+uBi4USCAxAV9DA3i+8ogIgiNAe/7qXDgePHADgnv+whyz3GAALSnAJGIEQMBz3WgANAPRCAEAwom
+wJBA2xAd2JBCLIQAhiD8A8omYhCoEQ8AQC6FFc9zgADsrfB+/bP8kxC+5X4MHZiTYYsCu0jjEB3Y
+kGIRDgGIEQMB22PAkXB7RLhiGcQADw6fEi6RUyHBgA/yz3CAAEwQCYBRIACAPdjAKOIFyiChB8Ao
+IQYJ8EAsAQE4YM9xgADIRAhhF7gD4wUgQAEEI4MPAAD8/2V4nbifuAwdGJARzAHgEHgEIIAPAAD/
+v4+4ERocMA4dmJAgFQCWz3CAAEwQCIAjCN4CHwofARYIb/1IcM9wgACIpqDZxNo92yYK7/sXu3UA
+z/vgePHAAgjv+4ohCADPdYAAZKjPcKAADCQhoMSVz3CAALSnHoAadoYg/CONCF4EiQ2eUYwgA6RA
+9APZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB4MaCpcFb+EQjeAM9wgACArqYLAALPcaAAxCcZEQCGBegC2BAZGIAE
+2BMZGIAb2BYZGICK8LYNIAQKcAh3qXAKccf+CHYn/0QmfpQO8hEOHhHPcYAAtKcdgYC4HaEBhU4I
+D/9y8ArvUP/PcYAAtKc9gdUJ3wGB/yvwA9nPcKAA1AsxoOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HgxoBPMERocMBEO3hDPcIAA
+gK7iCgACz3WgAMQnERUAlgDeMQifAC4Pz/7PcIAAtKcdgFEI3wERFQWWGQ2fAAohwA/rcgXYiiNJ
+DbUDr/qKJIMPBNgTHRiQG9gWHRiQz3WAAAizGYUE6IIOQAHZpc9wgAAAAACADQgeAc9wnwC4/92g
+oQaP+/HAQg6v+03Yz3KgAMQnLRIOhgm4GhoYgM9wgAAIqCCIocEH6QHbz3GgANQLcqEE2RAaWIBN
+cYYh8w+MIQyAAdnAeTlhNHkAiB7hgODKJUEQA/JAIQ0DIn4G8M9wAADsD5YOj/sJCJ9E8wkexs9x
+oADQDxAZWIMlEQCGYMAlEQCGD3kBHAIwABQAMYwg2IHMIIKPAAAHCMogIgAI9IjhAdjAeP4M4Aku
+bs9yoADEJxoSAYYEIYEP////ABoaWIAREgGGFQneAgDZi7kTGliAGtkZGliA2QWv+6HA4HjxwF4N
+j/vPdoAAtKfPcKAADCQ8gFaGocECIkAAZLgQeIYeBBAQcsohzg/KIs4HyiBuAcojjg8AACQFyiQu
+AGACrvrKJQ4BA8gBgBcIXgcvIIcKjCAChgX0HoaeuB6mz3WgAMQnIRUQlr4LAASA4PoBIQCYHgAQ
+z3KAAAAAAII3CN4CAYLruEDYzyDiB8oggQ8AANAAzyDhB89xnwC4/x2hBIIB4NO4BKIFIIAP0P4A
+ABahz3WAAEwQCw3eUVYVgBAF8AOGdgkgASSGPoaUHgIQRCEADA8IEQgLDd9SgNiUHgIQlBaAEAsI
+3gGXuT6mSwmeARSWQwhfAWIPQAed6M9woAAsIA+ABugDyAGAKwheBx6GkLgeps9wgAB8xwCADwhe
+AFElQNMB2QL0ANmLcJDaEgugAADbz3CAALSnlBCBAEApAgaGIf0PUiHBAUW5RXnPcqAAiCQwoimF
+XoAJCd4ACQpeAgDYA/AB2FEhAIHRImKCANnKIWIAJXgPeCcK3wUjCp5Tj+hEIj7TC/TPcIAAtKcB
+gAsIHgAGDAAEA/ACDQAEz3WAALSnHoVFCN4EBNnPcKAAkCM9oE1xygmv+4ogRA4G8FYMr/uKIFYL
+CQifRPUJHsbPdYAAtKeGFQARz3GAAEwQ9gugBC+RFfAAlQQggA8AAMyAFQiBDwAAyIALhQkIHgBI
+/wfwBNnPcKAAkCM9oALYz3egAMQnPB8AkJQVgBDPcYAAZLAEGQAEFQjeAR2FlbgdpYogBQlKCa/7
+ANlQ/gh2HYVRIMCB/gECAFMmQBAPCNEAFRcAlrkI3gAqDO/+yXDx8M9xgADIkg2BAeANoQPZz3Cg
+ANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB4MaATzM9xgABksBEaHDAQ2BAdGJAC2DwdAJAeC+/+BBkABB2GUSDAgbH0ERUF
+lhsNnwAKIcAP63IF2Ioj1wilB2/6iiSDDwTYEx0YkBvYFh0YkJ3wFMw+hRkI3gAEIYAPAEBAAA0I
+gQ8AQEAAmLk+pSUJHgQAwdTYqXLmC2//AdsE6FoLQAEI8M9xgAAsDhOBAeAToc9wgADpBwHf4KjP
+cIAAkAQggAaBAeAGoR6F87i4D4IEHoXwuBAOgf4ehREI3gEB2c9wgAB0BSCgz3GgAMgcANgHoTDY
+CqHJcC/+iiCEDeYPb/vJcQPIAYAtCF4HHoUpCB4GENgUGhwwz3CAAICu1g3AARvIACCBD4AAEJ0e
+heCpuLgepQCVhiD8AIwgAoAu9LoNgASq6APZz3CgANQLMaDgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB4MaATzBEaHDAehQ8I3wQA
+leYK4AU0lX0Br/uhwM9ygACgEFSKWWEweUFpDQoDACJ4EHgD8ALYz3GgAMgfH6GKIBgIDqEC2BUZ
+GIDgfvHA3giP+89wgAAABgCAgOBQDoIGz3aAAAAAAIZKIAAgNwjeAAGGUSDAgEDYzyDiB8oggQ8A
+ANAAzyDhB89xnwC4/x2hBIYB4NO4BKYFIIAP0P4AABahFMwA34EIHgDPcaAAyB+wEQIAz3OAAEwQ
+ahMAAWO4CCIAAB6hENgOoQHaz3CAAGSsFRmYgAMaGDDPcIAAKK0HGhgwCIMVCN4Cz3CgALRHSxjY
+g3cYmIACDQACz3CAABAFAIgF6AoNAAhKDgAIBCCRTzAAAADPcqAALCDPdaAAyB8z8O24yiWBH6AA
+yB/KIoEPoAAsICfyvg/P/s9wgADAkwmAjCACjYj36gmv+hjYz3CgALQP/KDPcIAATBAIgBEI3gIA
+2Z65z3CgAPxEIqAUzM91oADIH89yoAAsIDkI3wMKIQAkz3GAALAN46HloQOCvwIgAAehmgmv+hjY
+AN/PcKAAtA/8oM91oADIH6MCIAAadgTYChoYMB+FgOCKIAwAyiCCDwAAAAIOpQPYFbgSHRiQz3CA
+AAAGAICA4OwMggYAhgQgvo8AAN94vAMBAM9wnwC4//2gsQMAAArIz3GfALj/FqHPcJ8AuP9YGAAI
+HoV3CF5FCsiGIPGPNfTPdYAAsA0DhQHgA6XODu/+Ad7PcIAAwJMJgGEIhY8AALQAz3CAAEwQCIAR
+CN4CANieuM9xoAD8RAKhz3CAALSnHYCGIL6PBPIFhQHgBaXPcIAAAAAAgA8I3gIA2c9wnwC4/z2g
+SiBAIBTMGQgfATUInwGGIP+FRvIVCx5AEQhfRR7wFcxTIECAB/TPdaAAyB8A38/wB8gDEgE2AxoY
+MAcaWDA6CwACz3CAABAFAIhu6EILAAiCDAAI6vEUzM91gABEk2sI3gCA2BQaHDAVzBEI3gIYhQHg
+GKVKIAAgBfAQhQHgEKXPcIAArLoSiFEgAIDMCyIAyiBiAA0JECAXhQHgF6UUzADfqQjeARXMBCCA
+DwAAABg/CIEPAAAACMoMIAEKcCsIHgAI2Ju4DvCKIAQAFBocMA+FAeAPpckJEKAWhQHgFqXg8Qoa
+GDBw8ATY/PE+DIAAFcxDCN4Az3GgACwgBYEmgQrg5wkEgAMSATYC2BQaHDBQ2NINIACYEQEAXgoA
+As9wgAAQBQCIoQgQAGIKAAiiCwAISvADyKAQAADwuOlwGfKyCYAAANiWuBXwLQgeArYKoACKIAQA
+0gugAOl1A8igEAAA8LipcAXyigmAAADYlbgSDIAAu/HPcqAAyB8TCF4CcgmgAAHYANiQuPPxFwie
+AxMLHkCKIAQADqIE2AoaGDAVEgE3JQneA0ASAgbPcIAALKgNkBUKBACvuRUaXDDPcIAAuMbgoM91
+oADIHwrIBCC+jwOA6EOkBcL/USBAxZwFwv8/haAVABAJIQAA5ODQ9s9wgAAInwCAGQheAP6lEN4S
+C6ADyXCE6AHYHqXOpYogCACgHcATDqUfhREIFQqE6IogBAAOpcIIgAcv2JW4Eh0YkM9wAQDA/BUd
+GJAyCYAAz3KAAFAFAIJDCNABz3CgADguBYAEIIAPwAAAACUIgA/AAAAA9dkFuc9wnwC4/zqgB9k7
+oGnZGLk5oAHYA/AA2AsIUQAH2ACiz3CAAAAGAICA4LQJggbPcYAAsA0DgUSBCCIAAAShBYFGgQgi
+AAAGoXyFB4FIgQJ7AMoIIsIASKEXCBECA9nPcKAAQC0woAAawjME8AHgABoCMM9wgAAAAACABCC+
+jwAA33gF8s9wnwC4//2gz3CAAEwQCIAtCN4Cz3CAANwDEHjPcaAAtEdJGRiAz3AARBQASxkYgEwZ
+2IMD2HcZGIDhA0/7z3CAABgFQIgRCh4Az3GgAKwvGYGKuBmhEQpeAM9xoACsLxmBjrgZoeB+4Hjx
+wOHFB9kbGlgwz3CgANQHGhhYgA4QDYbPcYAAAABAgQsaWDM3Ch4CQYFRIgCCQNrPIuIHyiKBDwAA
+0ADPIuEHz3OfALj/XaNEgQHi07pEoQUigg/Q/gAAVqPPcaAASCy+oR8QAIYCGhgwCMqc4Mwggo8A
+AJEABvIAFgBAABYAQAXMz3GfALj/GKGKIEYE7ghv+wISATY9A2/7CMrxwOHFz3GAAEwQSIFTCh4A
+hiD/Ac9ygABQdkO4CmIA24DiyiHBD8oiwQfKIGEByiOBDwAAbADKJMEAwAch+solIQDPcKoADFAR
+CrQAvoGAvb6hAdkloAXwoL2+oWWg2QJP++B48cBSCk/7GnDPd4AArLoQj4Yg/wFCKNEAz3agALRH
+KnUF8PIKb/uKIIgDcRYAlgQggA8OAAAAQSh+hPX1QxYAlkYgAA1DHhiQVxYAlry4v7hXHhiQXxYA
+lr+4Xx4YkADYnrhTHhiQEI9gHhiQzP/PcIAAMJIHiBXoEI+GIP8BOgov/kO4z3eAABwFFI8TDQAQ
+z3CAAMRWFoBAeBQfQhRKDwAIQxYAlkUgAA1DHhiQgwgVIQpwMyYAcIAA1HlAJwFyFHkAeRC9m73P
+cIAAaLsAiJ+9gOAB2MB4D7ileF8eGJAf8M9wgABouwCIEL2A4AHYwHgPuJi4n7ileEUgwAFfHhiQ
+D/AQvc9wgABouwCIn72A4AHYwHgPuKV4Xx4YkArIhOA4C2H6yiBhBIkBT/sKIcAP63IF2IojDgpK
+JAAAWQYv+golAAHgePHAEglv+wHZz3CAAEwQCIDAuBt4AN7PdaAAtEdLHZiTdx1YkM9xoACERNih
+Atl3HViQANmeuVMdWJBUHViQz3GAADgBRx1YkI64z3GAACgARSAGDUgdWJDPcIAATBBJHZiTGpAC
+uGy4RB0YkBzYRR0YkM9wgAAM0AGIRh0YkM9wgACsuhCIdP9KJMBwz3GAAISwyXKoIIADz3CAAJC7
+VnhhgPJq9n8/ZwKAYqcB4gOnz3eAABwFAIcD6GQdGJBDHZiRAdh9/89wgABMECiAJQneAs9wgADc
+AxB4SR0YkM9wAEQUAEsdGJBMHZiTA9gF8EsdmJMB2HcdGJBAhx0JHgBTIkEAErlEIgADDrgleIYi
+/wMKukV4EvBIcIYg8w8KuAQigQ8AAAAMBrkleAQigQ8AAAAwArkleM9xgADkYj0Ab/sCoaHB8cC2
+Dy/7mHCmwQQgg48AAAAET8EG8s9wgABYBSCAz3CAAJC7AIBAwQhyhiL+AyS6QCqNAw/CwrgOuKZ6
+BSCGADwcgDEEJoAPAQAAwC64QCgNBpy9z3KAAEwQSIKfvc93gAAcBVEiAIDPcoAAiEUWegby0ILE
+p1GCBfDAgkGCxKdRJICBQ6cI2gvyC9oEJr6PAAAAGMoigg8AAA8EUSQAgTpyzyXiFgX0USQAgs8l
+YheFDl4CgOPKIcIPyiLCB8ogYgHKI4IPAABuATwEIvrKJYIBBCGBDwEAAMAuuc9ygABQdi5iSSaO
+EGG+z3GAAEwQYhGBAC/DCLhSblR6ZHnHcoAADK9IEg8GSRISBkQhBAFALEECJXhleAQmgQ8AAAAQ
+BSETAJ69GObPfgPIuRiCA3LwFetRIQCCRMEkwRDyz3CAAAB2KGAVCJIACwiRAAbYYMAF8AfYYMAD
+8GDBAMA9CB4CRMAkwqDiyiGCAMohIQAEIIMPAQAAwM92gAAAdkpmBCCADwYAAAAxuC67GmLPcIAA
+UHZoYEJ4E/BTIMEAz3KAADB5PXkpYgQggA8BAADALrjPcoAAUHYIYmG4FiEFABsNFAYKIcAP63IF
+2IojRgM5Ay/6iiSDDwHYDw4eAi/Bz3CAAAB2KGBALYIAVHrHcoAADK/ggmG4BCaBD+8AAN0muSV4
+UiDTAwPIBBISALkYQgHPcYAAfEIagTuBJHgPCB4CIoLPcKcAiEkvoDwUEDBqcIYg4w/PdqAAtEdB
+KBQCBvBCDi/7iiCIA3EWAJYEIIAPDgAAAEEofoT09Yog/w9vHhiQax4YkAPZD7nPcKAAyB8TGFiA
+WR6YlFoe2JNbHtiUWB5YlPu9SiUAAAvyHoACuEIghQNIJQUAqHDJuAV9z3CAAJC7B4AA2Q8hAQUk
+eM9xgADMBIDgAdhAgcB4UyIBgK+9CPKGIn8PXXoPukV9BfCA4M8l4hNXHliTh+mA4AbYyiDhAQLw
+ANjPcYAATBAogScJHgBPIAECjbmXuRUeWJAFIIEPgABAOhoeWJAFIIAPgADAUxHwBSCBD4AAwCQV
+HliQBSCBD4AAAD4aHliQBSCAD4AAgFcXHhiQz3CAADCSBJAfCFEAhBYBllAhAAMEIYEPAAAADK24
+ArkleAPwhBYAlhYeGJCMJc+PyiHGD8oixgfKIGYByiOGDwAACgGIASb6yiTGAOlwNghgCApxCNx7
+BC/7psDgeKHB8cAaDC/7mHDPcIAAkLtggKTBaHCGIP4DJLgOuAZ5wrsOu2V5TcEEIYMPAQAAwC67
+geIB2MB4BrhWIEAIQCsNBpy9z3KAAEwQSIKfvc92gAAcBVEiAIDPcoAAiEV2egXy8ILkplGCBPDg
+gkGC5KZDpmEJXgIEIYIPAQAAwC66z3aAAFB2SmZJIoIAYbrPdoAATBBiFo4QLccCulR6x3KAAAyv
+5H5IEhEGSRISBoYm/x4Jvgi7xXtlfwQhgQ8AAAAQJX+evU8gFAFPJNQhXvBRJECCzyBiAc8gIQGa
+cEcJHgJDwSPDoOPKIMIAyiAhAM92gAAAdmtmBCGPDwYAAAAxvwQhgg8BAADA+2Muus93gABQdkpn
+YnoWIIUALcALZhXwUyHAAM9ygAAweR14CGIEIYIPAQAAwC66z3OAAFB2SmNhuhYghQAB2xsNFAYK
+IcAP63IF2IojiQkVAC/6iiSDD0AtggBUesdygAAMrwASEQAEEhIAYbsEIYEP7wAA3Sa5ZXlSIc8D
+z3GAAHxCGoE7gSR4DwgeAiKCz3CnAIhJL6A0FBAw6XCGIOMPz3agALRHQSgTAgbwMgsv+4ogiANx
+FgCWBCCADw4AAABBKH6E9PWKIP8Pbx4YkGseGJAD2Q+5z3CgAMgfExhYgFkemJRaHliUWx7Yk1ge
+GJX7vUolAAAL8h6AArhCIIUDSCUFAKhwybgFfQDZz3CAAJC7B4APIcEEBHnPcIAAzASA4QHZQIDA
+eVMiAICvvQjyhiJ/D116D7pFfQXwgOHPJeITVx5Yk4fogOEG2Mog4QEC8ADYz3GAAEwQKIEnCR4A
+TyABAo25l7kVHliQBSCBD4AAQDoaHliQBSCAD4AAwFMR8AUggQ+AAMAkFR5YkAUggQ+AAAA+Gh5Y
+kAUggA+AAIBXFx4YkM9wgAAwkgSQHwhRAIQWAZZQIQADBCGBDwAAAAytuAK5JXgD8IQWAJYWHhiQ
+jCXPj8ohxg/KIsYHyiBmAcojhg8AAAoBeAbm+cokxgAqcCYNIAgKcQjcawEv+6TA4HjxwAYJL/sC
+udpwz3CAAEwQH4A2eQAhjQ+AAISwgOChwUDDyPIIhQUgkwAgHcAUGBUVEBAVFBAUFREQ54WqcAAV
+EBCGIOMPz3agALRHQSgSAgXwigkv+4ogiANxFgCWBCCADw4AAABBKH6E9fWKIP8Pbx4YkGseGJAD
+2Q+5z3CgAMgfExhYgFkeGJVaHliUWx5YlVge2JT7v0olAAAK8h6AArhCIIUDSCUFAKhwybgFf89w
+gACQuweAANkPIYEEJHjPcYAAzASA4AHYQIHAeFMiAYCvvwfyhiJ/D116D7pFfwTwgODPJ+ITVx7Y
+k4bpgOAG2Mog4QED8ADYz3GAAEwQKIEpCR4ATyABAo25l7kVHliQBSCBD4AAQDoaHliQBSCAD4AA
+wFMS8AUggQ+AAMAkFR5YkAUggQ+AAAA+Gh5YkAUggA+AAIBXFx4YkM9wgAAwkgSQHQhRAIQWAZZQ
+IQADBCGBDwAAAAytuAK5JXgE8IQWAJYWHhiQjCXPj8ohxg/KIsYHyiBmAcojhg8AAAoBzATm+cok
+xgAqcH4LIAgKcaoIYAkAwADZz3CAAEwQP6AAhQAeACCdB+/6ocDxwGYP7/oA26XBC+lIgQQigg8A
+AAAwQiIDgMojYgBSaFZ6x3KAAISwwIJAxiUOHhIgwM91gAAAdjIlBBAAig1lBCaAHwYAAAAxuAAg
+RQMF8AHYmHC4cK6+r76wvkDGgOPMISKAhPTPcIAAkLvPc4AAtKeWE4EAA4gLIQCANPJIE4EAAN8A
+21MhTQAPI0MDRCENA0K9hiH/Aw8nTxO8aQQnD5AA2QR7DyFBAyR4yicBEIDjyiPBAycNUAApDZAA
+gQ3QAAohwA/rcgXYiiPLCUokAADRA+/5CiUAAQ67ZX4z8OV7/fEhgs91gAAoi3RpY2UXC14CLygB
+AE4ggQcA2I64OHgFfh/wHQ1QACUNkAAxDdAACiHAD+tyBdiKI4sP2fHPcIAAMI02eAKIB/DPcIAA
+MI02eAOIDrgFfgXwjr6PvpC+BCaAHwEAAMAuuM9xgAA4eQhhUwhlAUDGCiHAD+tyBdiKI4wBPQPv
++Zh2DZEogYYgfwwEIYEPAAAAMCy5qWkceEAlgRMPJk4QQMYbCE8DCiHAD+tyBdiKI8wDiiTDDwED
+7/m4dc9xgACQuwCBi3Ogg4Yg/gMkuA64Bn2gowCBwrgOuKV4AKMAwM9zgABMEAQggQ8BAADALrlA
+KQUGTyUFB6iDTyXFB892gAAcBVElAJDPdYAAiEU2fQby8IXkprGFBfDghaGF5KajplsIXgKmggi5
+JX2mogQggA8BAADALrjPdYAAUHYIZUkggABhuAK4FHjHcIAABLCqgMuAYhOAACDHBCDEA89wgADs
+pxEQhgBPJYUHBCYAAQm4BXnleYogBgZR8D8IHgJEwCTGoObKJYITyiUhEM93gAAAds5nBCCPDwYA
+AAAxvwQggQ8BAADA/mYuuc93gABQdilnwnkS8FMgwQA9ec91gAAweS1lBCCBDwEAAMAuuc92gABQ
+dilmYbk2fR0NFBYKIcAP63IF2IojjQGKJIMPyQHv+bh1Mm00ecdxgAAMr6CBwYFCJEEABCCAD+8A
+AN0muAV5UiHBA4ogBALEoqWiHBpAAQiiJqIB2B+juQTv+qXAANiQuM9xoADIHxUZGIDPcIAACJ9G
+kFt6TyIDAFoRAoY4EIAAZHpYYNgZAADgfuB44cUA289ygACInBQiDQBgtWi1GmIgGsIAwB3EECga
+wgDPcYAACJ8WeSKRMBrCANAdxBCAHdwQeB1EEAHZiBpCAM9xgAAonRV5YKHgHcQQ8B3EEOB/wcXg
+ePHA4cUIdRsSATbPcIAAiJw0eBGIEegDyAGAHwheA89wgAB8ifAgQADPcYAAoAQUeQCREOAAscIJ
+AAMbyNv/A8gB2aAYQACmDuACqXDPcIAAAAAAgCUIXgHPcaqqu7vPcJ8AuP82oDagNqA2oM9xoADI
+Ow6BiLgOocEDz/rxwEYL7/pKJAByz3CgAIggAN6oIEAPdQ7QEaCAz3GAAAifz3KAAKi01nloiUeC
+emLPc4AAAJ3Ue53tACaNH4AA+Jz4jRMPkRDgk/t/I5GAvyR/4LMF8AsPURAikSCzANk4rc91oADI
+HPqFIJPkeSyzBPAskwkJRQNZYQTwrLO5Yokhzw8EGFAAAeYA2c9wgACotB0D7/onoPHArgrP+hsS
+ATbPdYAAiJwDEgI2z3OAAKSuNH3xjRAVhBAnCN4BAefpcDIShQCnkwIbAgHPdkEAgwCms891gAAY
+DuOrEPBAJEAAMRKFAAKrwBUNEeOrz3YhAIIAprPPdYAAHA4RDQUAxKMAhQHgAKUEg1jwz3CAAKic
+KGAB4ASrAYKwin8IHgEvJMgDz3eAAPRiB4fSii95A+gFhyPwSSHAADRtz3eAACiLIWcRCZ4Fz3GA
+ADCNtnkhiQPwANnHcIAAMI22eASICCYOEAgmQRCAcUkhwQMWbTV4z3GAADCOAGHPcYAASIy2ec91
+gABMEL2FIYGleQQhgQ8AAAAIJngC8AOCAqOYEoAAKIsPCQAAANgEq2DYGLgD8ADYnbgEo/UBz/rh
+xeHGz3CgABQEA9kjoBvIz3KAAKSuYZLPcYAAiJzEihQhDQBotQAggw+AAKicOOHAq2KCFXkGkmCh
+AxIDNsAdBBAEgqATAQCGIcMPJXigGwAAwcbgf8HFGxICNgQgvo9gAAAAz3OAAIicVHvHcoAA+JwI
+cQXyA8gckBcIngIEIYEPYQAAABMJgQ8BAAAAANgAswHYHPAUzAMSATYbCN4BMhGBAAGLDQhBAADY
+Aavz8QHgAasL8DERgQAAiwsIQQAA2ACr5/EB4ACrAtjgfxiq8cC6CO/6BNkIdRsSDjYG2BsaGDDP
+d6AAFAQKp89wgADYeS4Pz/oAhSYP7/oE2QGFHg/v+jjZIoUF6QGFAJAbCEUACiHAD+tyBdiE20ok
+QAClBa/5uHP6Du/6A4UBhUKFIJAFheoO7/pCecqntQDv+hsamDPPcYAANAXgfwOh4HjxwDoIz/oh
+gAolAJAQicO4yiHBD8oiwQfKI4EPAAC9AMogYQEv8oDhyiHBD8oiwQfKI4EPAAC+AMogYQEj8gS4
+z3GAACiLB2EDhQCQhiD8AIwgAoAtv8C/CvSELwscACGAf4AAFM0hgIG5IaABhcKAAYYE6ACGjOgK
+IcAP63IF2MrbSiRAAPEEr/m4cwsIn0GiCoAGDOiKIM4Cwg2v+tHZAIaA2SigAYZAeBzwAYUgkCLI
+EHHKIc0PyiLNB8ojjQ8AANcAvgft/wXYqXCt/wGGyf/PcIAAfInmoPoKr/rpcMEHj/rPcYAANAUj
+geB/IKDxwOHFAxIBNqKBIIW6DO/6JNoBhYDg4iACAKkHj/rgePHAKg+v+gbYGxIPNhsaGDDPdaAA
+FAQKpQmFAN4R6IIJwAIJhQ3oJBUFEAohwA/rcgXYiiPEBjEEr/lKJEAA6qXPcaAA0BsQgc9ygACI
+nIa4EKETgZC4E6Edihsa2DMN6M9wgAB8iQaAz3GAAKAEFHkAkRDgALHGss6yJhqCA8wahAOKIE8L
+xgyv+oohBAsFB4/64HjxwOHFCHXPcIAAfIlGgM9wgADQyoQqCwwAIEIOz3CAALSdAIChwSkI3gAW
+ac9zgAAwjgBjGQhfAs9wgAAwjTZ4W4oCiIm6DrhFeAbwIgov+4twAMAApbkGr/qhwAokgPAFIEQA
+4CDBB0Qk/oBBKsQAhAACAC8kAvFCIQEBQiADAeggogQEEQQCBBEFAgQRBgIEEQcCBBsIAQQbSAEE
+G4gBBBvIASwAJQBEIj6BPAAiAEQi/IBAIcEA4CDBB0AjwwCoIIABARGEAgEbCgEgIMAHBBEEAgQR
+BQIEGwgB1Afh/wQbSAFEIvyABBEEAskH7/8EGwgBQiFBAEIgQwCoIIABARGEAgEbCgEgIMAH8cCO
+Da/6ANjPdYAAjLFKJAB0gN6oIEAFCHEB4E8gwgEWJUMQR6uKIggAQCkEAQAkgQ+AACiLQKEA2kKx
+xqnA2H8dAhDPdYAARAXArc9wgAAMsoDZLg6v+ihywa3PcIAAoBCZBa/6wqiiwfHAHg2v+phyRcFB
+KAECQSgDBAd5J3vGu8dzgAAMsiCLKQnfARQUDjHPcoAAjLEWIk0A4IUNCMED4pURD4ATJ41nbecJ
+3oEA2B/wxo2H7oDfz3CAAEQF4ajPcIAAoBDiiAsOwROA3sKoxo02egAcgAMHjYe5AKvPcIAARAVg
+iCCoAdhnqgzcAwWP+vHAjgyP+s9xgADceSGBo8FCwc9xgACEBBUhEQAAEQ0gLyhBA04gjgeVDRAQ
+9G7Hd4AAKIsGj89xgACMsRZ5AIEikY7mCBxEMMogYQAE8otyAsHJ/y3oANjPcYAATAVAgQ8ggAMv
+IAogBCCAoAChB/SA4nAP4gTKICIIz3h2CiAAENkA2IohCAAAEQIgArcgp89xgABIjNZ5AKEBoc9x
+gAAojAQiAgQAGYAg1HkAsRAljZMvKEEDTiCOB7r1MQSv+qPA4HiiwfHAzguP+kXBz3WAAEwQIoUV
+CEEAJpUUFA4xCQ5BEFYdghCL6s91gABEBcGNgOYA2cogQQAi8iGtCwqRAwHYHPBBKA0CB31BKAEE
+p3nPdoAARAWgjlMlRREbDTIExrkKIcAP63IF2LPbpQCv+Yokgw8LDZ4RANhf8c91gACMsRYlTRHn
+jQClFBQAMeCuRq0CtcdxgAAMsgCJB60AGUIBABtCAc3x4HiiwUHBQSgCAgd6QSgBBEd5z3KAAAyy
+xrkqYiUK3wEEFAMxz3GAAIyxVnlAgQsIgQBCkREKwABHiesK3oGA2APwBongf6LA4HjxwOYKr/q4
+cEokQACQ4Mohyg/KIsoHyiOKDwAAAwEAAKr5yiBqAUAtAwHHc4AAKIvGi4wmApAA2A3yz3CAAIyx
+FiCNA6CFoKEmizZ4ApAAsohwAQOP+uB48cDhxc91gACMss9xgABMEACBdBUCFkcKAQACkeoVAhc7
+CgEAdhUAFjoP7/93FQEWjCACgBPyz3KAAEgFIYIA2w8jAwAEuGZ5IaIAIIEPgAAoiwCBqriIuACh
+ANilAq/69B0cEM9wgABAqCiIz3KAAGy0jCECgAKSQSgDAwvyFwjfAgS5x3GAACiLApEPIMAAArEA
+2OB/BLIA2kokAHRIcagggAPPcIAAcLPPc4AA8LM0e0CzNnhAoEGgAeFKJMBzANmoIEACz3CAACiM
+NHhAsAHhz3CAAEgFQaDPcIAAbLTgf0Sw8cCmCa/6VGiGIvgDibpTIcMARXvPcoAAKIwUeo/hiiUP
+HMogKQAJ9gCSAN4PJk4QiiXPH8Z4ALJKJAB0ANqoIEAGz3eAAOizVH/El6R+z3CAAHCzGQuBAwDe
+xLdWeMCgwaDPcIAAELRVeMCgAeKhAY/64HjxwDIJr/qYcgh1z3aAAPCz9CZAEM93gABws1EgQILK
+IEEAyiQidMogIgDoICIC9CYCEAkKXgIB4EcIFQQtu8C7z3KAACiMtHpAK4UCYJIEvYYl+BOJvQ8j
+QwBgsgDaFn9Ap0Gnw7mleQUhQwEUfmC2z3GAABC0FXkAGQABAvCA2BkBj/oIccO4z3OAAPCz9CMC
+AMm6UHHKJCJ0yiAiAOggYgL0IwIAyboHCYAAAeDgfvHAggiv+gDZo8EIdQGAwbiD4MogQQBoCWL+
+yiBCAyMIUAAQhR8IngEQhc92gAC0pzUI3gHPcIAAoBACiBjwAd4C8ADeAtnPcKAA9CYjoCWFz3CA
+AGSwUgyv/SGgyXCNAK/6o8AFhSaF8gzP/5QeAhAfhgQgvo8QcAAAW/TPcIAAfMcAgA0IXgBRJUDT
+AdgD9ADYQMCUFoAQiQjfAW2FJYXPcYAAuMaLcAQjgw/AAAAA4oE2u0AlAhJAIQQLRw/OEOWVHBEG
+AEInBRT0JMMACCZPATMLwwPPd6AALCBvh5Pr5od8lhMLxQPPc4AAZLDig2WBEw/BEAToAttgoAOB
+g7gL8AOBFQjeAADfnr/Pc6AA/ETho6O4A6ELggShA4IFoQDBVSZAGpDaOg5v/wDbEYXPcYAASAUA
+oUEoDwPDv5QWgRBBKAUFFGkFIMQDDQneAR2GlbgdpnzwTyRAAp7/8QgVBM9xgAAQtJQWghDwIQMA
+QCoBBoYi/Q9SIsIBRbpFec9yoADEJ0EaWIACJcGAwCGEDwAAABAMv9dxAAAACJC/UfYFJ08RYhrY
+g4whAoDI9s9xgACwDQyBAeAMoQDZnblI8OV7YhrYgFUOQ3AAAMAPDiGCDwAAABDPcYAAcLMWeQCB
+Jwo1CAQRBQAA2w8jgwBhu04iDwgBKMEDWHhleAAtgwBleRXwQiICCADZDyGBAGG5WHgFeYog/w8L
+8M9zgACwDU2DiiD/DwhxAeJNowHbz3KAAEy0ZKrPcoAAjLLjGhwBchoYAHMaWAC68QDZnLkfhiV4
+H6ZAJQAS6wXv/5weABDgePHACg5P+hpwz3CAAAAAAICiwUUIngHPcIAAAAABgFEggIFA2M8g4gfK
+IIEPAADQAM8g4QfPcp8AuP8dos9xgAAAAASBAeDTuAShBSCAD9D+AAAWohXMVSBSJO240SBigAny
+BxIBNgDYmBEBAIIJb/8IcgQQACCL6M9woAD8JSOALyCIBDC57whFgAASACAB3UHABBQAMUEoEwNA
+EAAgBhQRMYMIngEVzIEI3gJAEAAgz3aAALSnEQjeAc9wgACgEAKICPAUEAAgGBABICoKz/9RIMCB
+lB4CEMokYSAL8h2GAN+VuB2miiAFCVYLb/rpcZp3lBaAEM9xgABUsAS4RpEFIMAEFQiAAM9ygACw
+DQCCSiQAIAHgAKIEkSkIgQ8AAP//SiQAIA7wz3CAAMiSK4AA3wHhK6AKC2/6iiAFDJp3AhAAIYwg
+AoVD9AQQACCM6M9woAD8JQOAQCIBITB5MLjrCQWAAN5KJAB0AdjJcaggAATwIg0gAeBTJQIQL72G
+JX8fRX07elh9pX4B4QQQASCL6c9xoAD8JSOBViICIlB6MLntCkWAAN9KJAB06XGoIAAE8CINIAHg
+UyUCEC+9hiV/H0V9O3pYfaV/AeEW8AIQACFjCBEHBBAAIIzoz3CgAPwlA4BAIgEhMHkwuOsJBYDw
+Ik4jCBIPIM9woAD0JgLZI6AMEAEgz3CAAGSwIaAODS/+CnA5CFEAz3CAAAAAAIAPCJ4Bz3GfALj/
+ANgdoQHYnPDPcIAAAAAAgBEIngEA2c9wnwC4/z2gENiQ8EcMECDPcKAAxCzHoM9xgABAqOigKIlA
+KwIjELmfuUV5QSkCIUV5JqAVzB8I3gIQ2au4FBpcMBUaHDDPcYAAwJMCgQHgAqGyD0/9FRIBNxEJ
+HgMI2Ky5FRpcMAPwANirDBAgz3OAAIyy4BMCABQQDSBEKj4HACNBDqChGBANIQHiorHPdYAAQKgI
+FYQQ4BuAAM91gABUsAgZAgEJGcIEChlEBMOhpJXkoUAsAwRAKwIjZXpBKQMhqrFles92oADAL0ce
+mJCU5cAlhh8AAJMAz3KgAGgs8CJCA0uxjxYDlgjwoxYClo8WA5YLCh8B9QvegQTw57vKIyEAQMMB
+FIIwxrvGulipeanPcYAAAAAggREJngHPcp8AuP8A2T2i9QJv+qLA4HjxwKYKT/oacM9wgABMtASI
+GujPcIAAjLJyEA4GcxANBs9xgACwDeMQEQfPcIAASAXggAKBNL8B4AKhNPAqC2/6iiAPCM9xoADE
+JxERAIYA3+0InoFkEQKGZBnYgwLYExkYgC8ogQBOIIEHE+rPcIAAcLM2eMCAoYDPcIAA8LP0IFEA
+z3CAABC08CBPAArwz3GAALANAYHpdel2OncB4AGhBBABIA1wIKAIEAEhDXAgsM9xgABwsACBBuhC
+gQ1wQKAA2AChz3CAAEwQCIDruMogggPKIUIDyiLCA3QJIvzKI0IEUyHAIM9xgABIBSCBFL8MuOV4
+FQmeAIK4DXEAoQ1wwKANcKCgHvANcQChSiQAdKggwAJEJoEQD7lTJgAQJXgNcQChIr5KJAB0qCAA
+A0QlgRAPuVMlABAleA1xAKEivcUBT/rPcoAAcLPPcaAABCVPoVYiAAQRoVYiAAUQoeB+SiQAdADZ
+qCCAAgDaz3CAAPCzNHhAsAHh5vHgePHAJglP+s91gAAAACCFOQmeASGFUSGAgUDZzyHiB8ohgQ8A
+ANAAzyHhB89ynwC4/z2iJIUB4dO5JKUFIYEP0P4AADaiz3aAAFSwRJaU4sAihg8AAJMAz3GgAGgs
+8CGSALkIEAAvjs9wgAAwjc9yoAAsIM93gABMEDZ4Iog8EhAADo44FxERgOCSACkAyiCpAIwgAaSG
+ACUABNgA2AWiUNhFIUECGNoKDqAAINv4uAjYNfQD2M9xoAD0BwWhhNoNcECwQiAAKA1yALJAhg1w
+QKBClg1wQLBAhw1wQKBClw1wQLAGlkAqAiXDuAy4grgFeg1wQKAA2AShDo4B4A6uVgmgACpwAIUR
+CJ4Bz3GfALj/ANgdoQHYHfAA2M9xoADELADaR6FIoeaWDL+fvwUngxRmoc9zgABEkzmDAeE5oyCF
+Tq4PCZ4Bz3GfALj/XaE1AE/64HjxwOHFAN0M8EQtPhcncBzZxdoe294Jb/oYuwHlz3CAAIyy4BAB
+AOUNRJAtAE/64HjhxeHGz3GAAKi0RYEl6M9zoADIH0ATDgZAKIECz3WAALSnQBUAEdB+2GDclT5m
+z3GAAEwQaRGNAKJ+CCYNEAJ9CSJCAwLYFRsYgF+jIoHPcIAAZLAioMHG4H/BxQDZz3CAAGSwIKAh
+oOB/IqAA2s9wgABksEGgz3CAALSnPJDPcIAAoBAViAJ5gOHKIYwAz3KgAMgfH4IweRB4CCEBADB5
+AtgVGhiAP6LgfuB48cDhxQh1iiAUDRoNL/qpcc9xpwCISQDYFw1REM9wgABMEAiAUSAAgAfYyiCh
+AQ6hSQcP+vHA4cXPdaAA9AdZCB5DJ4UZhTB5OGADuJYgQgXPcaAAyB8eoRDYDqEB2BUZGICSCm/6
+gdgtCB5Dz3CAAFAFAdkjoAPIpBABAJq5pBhAACoM7/4B2M9xgAAsDgWBAeAFoRmFBOgD2AqlGYUE
+6APYCqXVBg/68cBaDi/6mHBBgXCJgwoeAc92gAD0YgeGCBGFALKJbBKPMATopYYl8EknwBDUa893
+gAAoi8ZnEw6eFc92gAAwjXZ+wY4C8ADex3CAADCNdngEiAglDRAIJY0TACVAEUkgzQMWa7V4z3WA
+ADCOBWXPcIAASIx2eM9zgABMEH2DAYBleAQggA8AAAAIBn0C8KOB6L2YGUADANsJ8qQRAAAA25e7
+kbiUuKQZAABLDB4AG8jPdoAAfInAuvAmDhDPcIAATMqELgscMCBADgQggA8AQAAAPrge4Bh6RX2Y
+GUADHQ2eF6QRAACFIwEEjLiRuKQZAACcGcAAHvDPcoAATBASgiMN3hekEQ0AhSMBBJa7mLuNvZG9
+pBlAA5wZwACeuBKiCPCUu5a7nBnAAJ64n7gSopEFD/rhxeHGmBAOABsSAjYEJoEfAAAACDt5BCaN
+HwAAABAlfc9xgAB8ifAhggDPcYAA0MqEKgsMACFCDkAiAQaYEIMAEw5eEkQjAgxEuk5hib7JchXw
+OpIZDh4SHOLCu35iyI56YlCKpX7QfiV6CfDDu3x7fmJ6YlCKyI4leogYgAOleowYgADBxuB/wcXg
+eKHB8cCKDA/6CHVHwOi9KHDcACEASHYDuEAgkQUnwc9wgAAAdgQlkh8GAAAAQSpCJCtgBCWAH8AA
+AAA2uKl3emLPc4AA5HnGvwhjSmMaYkEtgBJSIAAAwLgDuBjgheLKII0PAQCJDdUgjgAvIAggBCWC
+HwAAABjPcIAAbHfXcgAAAAgeACIA8CDAA6DhEgABAM9xQnvQXgUofgAKIMAOKnEFKT4ACiDADiS4
+AeALChAgUyABADhgAiiBI89ygACIEFWSJQ1eE89zgABod2CTBSs+AAAhgH8AAP8/Lrg4YJEAIABY
+YBV5iQAgAFhhUSVAkk4AIQAnxbflIAALADNoUyUCEM9wgAB0dvAggAAFKT4ACiDADgHgB/CK5cAo
+4QDAKKIAz3GAAKAQLonA2qR5hiH/DiK5OnraejUAIABYYDNoUyXAEBx4z3KAAIh28CIAABbhBSk+
+AAogwA7PcoAAiBA1kgHgFXkIktp4OGAQeAjcewMP+gQogA8AAC+6QinCdFB6RCr+AgIgQA4QeAPo
+AeJQegsIMwFAsYPoANgC8IDY4H7geKHB8cDiCg/6osFKwTpwSHUacwoiACFjCV4CAtnPcKAAyBwp
+oCrBU23u4VB4BPSLcej/GfAPCdENG3gQeItx5f8Q8AsJEQUceAnwDQmRAgAchDAH8M9wAAD//wAc
+BDDgeADYz3KpAKT/uaIAFAExgrg3ohqiTvBlCR4CTCIAoNEh4qFI9M9wpQCs/89zgACIELigVZNo
+k1tjAiDCIAPiIrpbYnpiSCJCAAW6RSJCA1agQSnCIcC6KsMHugQhgQ8AAAAgJbllekV5ibmOuTmg
+z3CgAKggCIAe8CrAgODKIcEPyiLBB8ogYQHKI4EPAABWD8okIQA8B+H4yiXBAAW9pXjPcaUArP8W
+oc9woACoIAiAz3CgAPxEBYAA3UojQCAEIL6PACgAAM9woAAsIAOAwiPCJAbwP9h6Ci/6BrjPcKAA
+/EQdgAQghA+AAAAABCCODyAAAAAEIIMPEAAAAAkLECAJCF9GANoD8AHaz3egANAbMYcEIL6PADgA
+AAQhgQ8AAACAzCIhgMAlYRAFJgIRJXoFIv6AA/ShDZSSBumA5swjIYBk8s91oAC0R2sVAZYXCd4A
+z3GAAESTDIEB4AyhQt1N8FMhvoAJ8s9xgABEkwuBAeALoULwhQnfAQnuz3GAALANCYEB4AmhOPAk
+6xcIngbPcYAALA4HgQDdkb0B4AehLfAXCF4Gz3GAACwOCYFC3QHgCaEj8HEVBJZvFQWWCiHAD+ty
+z3MAAOkPCQbv+AXYUSGAgc9xgACwDQbyHYEB4B2hDPAA2J64Ux0YkADYVx0YkAqBAeAKoQDd3dgA
+2boO7/mYuZi9HvARh/C4yiAhAHQMIfrPIKEDz3CgAPxEOYAGgAsgQIAN8hYOr/4B2APZz3CgAPQH
+KqAF3Zi9AvAA3ZHtGQneIR8KESAB2M9xoAD0BwyhA9gG8APYz3GgAPQHBaHPcIAABAYAgAjoz3KA
+AEhKBYICcAWiz3GAAESTCoEB4AqhGQmeIgPIlBAAAAQggA8BAADAfghgBi64z3CAAHS7IYDPcIAA
+TBAUkB0JAQDPcIAAfEI6gBuAJHhRIACC1Aji/8ogYgCpcAjcEwAv+qLA4HjxwMIP7/kA2c9woAD8
+RJ65IaDPcKAA0BsRgADdFwjeA0oNr/4B2M9xgAAsDgGBAeABoQrIBCC+jwAAARADEg42HvKkFgAQ
+OQieBM9xgABQBQGBFuihoQbwIggv+oogRg75CZ7Fz3CgAMQsq4Dk2HYN7/mpcVMlgRQ/DZ8XAxIB
+NqARAADwuADdofKKIAgAFBocMPrYTg3v+aARAQADEgI2pBIDACELHga2EgEBz3CgAJgDPqCa8GTp
+mBYAEG4K7/8A2t7xABYBQTyyABYAQR2yABYAQA+iABYAQUAaBAAAFgBAEaIAFgBBSBoEAEQhAAM1
+CBABGN5yGoQDABYOQNOiABYOQVAahAMAFg5BVBqEAxEIEQIocIYg8w+MIAyADPIY3hTwEN5yGoQD
+z3CAAKSup7AM8B7echqEAwAWAEAWogAWAEFcGgQAKHCGIP0MjCACggv0AubQfnIahAMAFgBBYBoE
+AAPwYBpEAwsOXhAAFgBBaHSEJAyQANgJ8gAWAEAaogAWAEAbogjYdBINAb4SDwGifwInjRMCfbgS
+gACYu6QawAACfdhgEHhyGgQAuhIAAbB9cBpEAyV4HLLPcKAAmAMegLYaBAAQ8IogEAAKGhgw+9gO
+DO/5oBEBAAPIoBCAAMTgGA7B+wPZz3CgABQEI6A5Bs/54HjxwLoNz/miwRsSATbPd6AAvC3PcIAA
+TBAup2oQEAHPcIAAfInwIEIAz3CAANDKhCoLDAAgUQ4VEg03QCESJkYlwBEDEgI2FRocMKQSAACE
+uKQaAAABkkAhEyIA3oYahAMH6M9wgACInfQgQAAG6AGCCQifA6C9sH1TJX6QTgMBAM9wgADAkweA
+z3OAAMCTAeAHowcSAzakG4ADAZKVCBAAz3CAAIicNHiAEAEHhQkRANAQAQFTIcGAFPRyEgEB4JIi
+f7gSgQAif/B/4BjEA6QSAQCGIfOPBvJov/B/4BjEA3ASDwHgEAABIZLiePFwwicOEMIhzgN0EgAB
+GWG4EoAAdBuEA8CzOGAQeJAbBAC+GwQAEIoQqwGCAaMIigirEooA2hKrlroz8FoN7/mKIMQLD4f5
+CN6FT4dTIsACTwqeBRUIlQPPcYAALA4Egba6AeAEoR3wZLgHEgE2EHiQGQQABCKADwAAAPAsuHQZ
+hAPAsRCpwbEDyL4ZhANhgMiphiP/DYS7YaESiBKp9ro+AgEAANiWuAcSATakGQAAIwpeBdINr/8A
+2AcSATakEQAABCCCDwIAAAAtuqV6UH1E8AGBsQgeAc93gAD0YgeHcolQiWwShDAD6AWHI/AUas93
+gAAoiwBnSSTEABEIngXPcIAAMI1WeAGIA/AA2AAkjw+AADCNVn/kjwgjwwMIIwMASSPDAxZqdXjP
+c4AAMI4AY89zgABIjFZ7QYPPc4AATBB9g2V6BCKCDwAAAAhGeJgZAAAA2Ja4QYGGIv8NQwgeBaEK
+EACYEYIAQCEAKUhgz3OAAOyuQMAgwsO6XHr0I4IAUvAKIcAP63IF2M9zAABFC4okgw+FAO/4SiUA
+AJgRAwCcGYADSQteAoC4pBkAACjqmBGAAM9ygABMEGISggCGIP8DRLgyIgAgibhAwCDDZHqGI/8D
+hiL/DkS7emJPes9zgAAId/QjggAe8BMLHgII6pgRggBAIQApSGAL8IXqANpIcBDwmBGAAMO4HHgy
+IwAgQMAgws9zgAC8rsO6XHr0I4IAiBkAAJgRAACEGYQAkBEBARIOr/8A2gcSAjYDEgM2hBIBAYIa
+BADPdqAAyB84YBB4sBoEAPgWARCwEw8BIn/PcYAATBBkEQEBAnc/Zx9noBYOEPB/QQ7EE892gABM
+ENKGmBMPAAsmwJMW9FCK0ItQdtEnIpIX8pgTjwDPcoAAAHbqYiMKkgDPcoAAKIsEvsJiEwpeBM9x
+gAAsDhKBAeASoQ3wOGAQeIYbBADPcYAAwJMIgRUaXDMB4AihSQLv+aLA8cD6Cc/5z3agAMgfoBYE
+EPgWAxBLCBEBAxICNqQSAAB2EgEBDwgeBc9wgABEsKGAA/CCEg0BFcxRIACBhBIAAQjyAiXCEAIk
+gwAIIwMABfCGEgMBG2PPd4AATBBr8JMIUQAVEgI3A8h4EAEBQwoeAVEiQIDPd4AATBBkFwIRCfJ+
+EA0BQn1ifQIkQwMq8IAQAwHPdYAAsI0AI4QAcIh2fWCVACMNAYQQAwG7YxrwpBACABUKHgVwiM9y
+gACwjXZ6YJIE8IIQAwGAEA0Bz3eAAEwQZBcCEV1lu2OEEA0Bu2OAEA0BumJ+EA0BIn0k8M93gABM
+EDkIkQADEg02Fcx4FQERZBcCERUIHgGAFQARQnhieAIkAwAI8IIVAxGEFQARW2MbY4AVDREifQbw
+ANtocWh1aHIVzGkXhBAVCF4AA8h2EAEBAiEBAVlhCfAPC3IAAiEBAWoXABEZYfgWABA9ZQJ9H4YZ
+DQQQoNgPpgDYH6Y/pgLYFR4YkIDYDqblAO/5cHjgeBvIx3CAAKScNIgB4S95NKgdCTIBAxICNs9w
+AwCEAKAaAACKIAgAChoYMAvwiiAQAAoaGDDPcAIBhACgGgAAiiAEAFUGr/kA2c9xgABEkw2BAeAN
+oRvIx3CAAKScLIgB4S95LKjPcIAADNACiBMIQwCKIAgAChoYMIrYkLgM8APZz3CgABQEI6CKIBAA
+ChoYMELYmLjgfuB48cDeD6/5ANnPcKAA/ETdgAQmvp8ABgAABvQDyKQQAADXCJ4GA9/PdaAA1Afy
+pUcOnhYDEgI2khIAAS8IngLPcIAAyBAioM9wgACsnjagz3CAACzKhBhAAN0YWACSEgABqriSGgQA
+wf+KIAQAkg2v+QDZGQ5eFs//AxICNghxoBoAAH4Nr/n82APIIw7eFG8hQwCgGEAAiiAIAAoaGDCK
+IEQCXg2v+QDZA8gjDp4UANmXuaAYQACKIAgAChoYMIoghAI+Da/5ANkDyKQQAQAXCZ4GBdkQuaAY
+QACKIQgAChpYMM9xnwC4/1gZAAgTHdiToBAAAALwKHBNB4/58cDmDo/5Egiv/wh2vv/PcaAAyB8I
+dUDYD6FAEQEGMHlaCO/8yXAtB6/5qXDxwAPIpBAAAFEgAIDPcIAATBAE8h2QA/AckO//tujPcKAA
+FAQD2SOgINgUGhwwz3GAAESTEYEB4BGhA8gA2pgQAQCAEAMBlBhAAJ4QAQGAGIQAkhhEAL4QAQGQ
+GEQApBABAKy5rbmkGEAAfhABAX4YhAA7Y7AQAQFieTB5sBhEAIIQAQGyGEQA0cDgfs9wgADYtAaA
+A9qB4AHYwHgMuIUgAwHPcaAA9AdFoQ1yALIDyADbXZANcECwA8hRgA1wQKADyEgQAgENcECwZKHg
+fuB48cDmDa/5CHMQiTMRjQAB2kCrGxIPNs92gACwnO5mz3KAAOCcSNzBqxsSDzYCIg4D9CbOE8Gz
+GxIONvAiggNBo0GBIwoeAdKJz3KAADCNFnrcq0CKhiJ/DFx6BLpFftyrA/CA2lyrBLgFfb2rHJHP
+coAAKJ0PsxvI8CIAAASzC8gFo1QRAAEMswCRDbOgEYIASKMKyAQggA8CAEEADQiBDwIAAACIukij
+CsgEIL6PAABBEATyibpIo5wRAAHPc4AAUAUmuMC4QCgCAw+BwLgNuEV4fQWv+Qej8cAODY/5CHUG
+8M9wAADMDbYNj/nPdqAAwC+jFgCW7wgegQvIQB4YkBvIDwiRAZoN7/6pcILwz3eAAICuCo8J6EAn
+gBJAJYESQgrv+QraA8gHiBsI3gAA2KYI7/mQuADZkrnPcKAA0BsxoM9wgACgEAGIgeBUDuEHyiAh
+DAPIA5AluMC4F7jHcAAOAABFIAEL7HAgoAISATbscCCgIIXscCCgIYXscCCgIoXscCCgI4XscCCg
+JIXscCCgJYXscCCgJoXscCCgJ4XscCCgKIXscCCgB/DPcAAArg3uDI/5oxYAlvUIHoELyAQggA8B
+AADwLLiU4MAghg8AAJMAz3GgAGgs8CENAM9wgABQBceA2dgeCq/5BSZBExYPr/kFJkATKo+A4cog
+gg8AALUEAAqi+c8h4gEA2AqvPQSP+fHA0guv+ZhwG8jPdoAAKJ3wJgEQz3OAAIicAxINNggcRAAb
+EgE2QZWA4jR7yiIhAAzygBMAB58IEAAA2oAbnADwG4QA4BuEAECzAYUfCJ8DSLPQG4QAEI0EuMdw
+gAAoi+WQCw9SEGG/5bAAIYAPgACknESoTKhUqM9wgAAInzZ4ApDAG4QANX5ApngbBAABhQQggA8A
+AABgIQiBDwAAACDPcIAAfInwIEAAz3GAAKAEFHkAkRDgALED2c9woAAUBDCgiHCA/9nYKgmv+QIS
+ATY78HAVABHgEwEBAiEOABEIhAPCeAJ6UHqAG5wAz3KgANQHDxIOhgDY8BuEA3AVDRHAGwQAonkw
+eeAbRADQEwEBAeEwefATBQHQG0QAUyV+gMohwg/KIsIHyiOCDwAATw3KJIIPAAD+ANQHYvjKIGIB
+A9gTGhiA9QKP+eB4ocHxwHYKj/mhwSh1GnBacgQhvo8BAADAOnMs9EDFHw0eEiDBz3CAAAB2KWAE
+JYAfBgAAADG4OGAC8AHYBCWBHwIAAAHXcQIAAAHKIKEAHwhQABUIkACD4ADYyiDhAcAooQMH8APY
+DrgD8ADYjrgFfQpwSgpv/qlxCnCpcUpyKnMB3RIPb/+YdbroCtjPcaAAyB8eoRDYDqEVGViDBfCi
+Cq/5iiDKBx0IH0PPcKAA/EQdgAQgvo8wAAAABPTjCx7AUSMAwMohwg/KIsIHyiBiAcojgg8AAKUC
+yiQiAOQGYvjKJSIAUSAAwwDYCvTPcYAAsA0JgQHgCaEA2Ji4CNzbAa/5ocChwfHA4cVRIACCCHWo
+ACEAQsAiw89wgAAAdgQlgh8GAAAAMbprYAQlgB/AAAAANrh6Ys9zgADkeQhjSmNBLYMSUiMDAMC7
+A7saYhjjheLKI40PAQCJDdUjjgBwcVIAJQAA2O29GAAhAAIhwADPcRxHx3EFKH4ACiDADgPwIrhB
+LUETwLkEuTR5qXLGukkiwgVUec9ygACgeDJiDw3eEkEqAQEUIYIABSo+AEEpAHII3EsBj/kKIcAP
+63IF2M9zAAB8EUokAAD5BW/4CiUAAeB44cUDEgI2IJJBgkDh9LrAIaIAA+HPc6AA1AcPEw2GBCGB
+DwAA/P8VDSUQGmEbyBUiATAcEQAGHWUCIkEDGRMAhv0IRIAPG5iA4H/BxfHA4cUDyKQQAQCYEAIA
+USEAgHIQAQFIcAbytgtv/wDaCHUH8AHhqgtv/wDarGjCCcACz3KgAMgf+BIBAAPIz3OAACiLEIgE
+uABjEQhfAwHYE6J4glmCBvAC2BOieoJbggIlQBB4YBBzwCJtAA1xAKENcECgABYAQAAWAEADyM9y
+oAD0B3AQAQFouSeicBABAWi5MHlJAK/5cBhEAPHAug9P+aQRAACiwVEgAIDPcIAATBAodgPyG5AC
+8BqQmBYBEAQhvo8BAADAdh4EEC30QcEdCR4CIcLPcIAAAHZKYAQhgA8GAAAAMbhYYAPwAdgEIYIP
+AgAAAddyAgAAAcogoQAdCFAAEwiQAIPgANjKIOEBwCihAwbwA9gOuATwANiOuAV5mB5AEJ4WABGU
+HkAQkh4EEBCOz3WgANQHQMCCFgARsh4EEADYgB4EEH4eBBADyEGQkBYQEQnqG8jPcYAAiJ30IQAA
+EugZFQCWIQgVDhXMz3GAAESThiCIAhUaHDAVgQHgpwMgABWhDxURlgjqG8jPcYAAiJ30IQAABehK
+I0AgBvAD2BMdGJBKIwAgAhISNgHZz3CAACAFIKAA2JG4z3GgANAbEaHPcIAA0AIQeM9yoAC0R0ka
+GIDPcIAAJAXAoG8gQwBUGhiAEYELEg828bjKICEAYAqh+c8g4QMfC1EgB8gBkCDoz3GAACwOD4EB
+4A+hEYEB4BGhFvADyAGQFOgbyM9xgABYnfQhAABTIMCACvTPcYAALA4PgQHgD6EQgQHgEKEDEgE2
+AYEdCJ4DVBEAAVMgwIAI9M9xgAAsDg6BAeAOoQIWBRElDRAAAYbuuMohwg/KIsIHyiBiAcojgg8A
+AGEHHANi+MokYgAAlrBwyiHMD8oizAfKIGwByiOMDwAAYwf8Amz4yiRsADCOUyHAABCuhiH+A6QW
+ABBEucAeQhBJCJ8FCxIBNgIhwgMA2A8KUAACJ0IQjCLDjwL0AdiU6BXMz3GAAESThiCIAhUaHDAU
+gQHgFKEPHViUCxrYMycCIAACGpg0CxrYMwIamDQA2HQeBBCGDW/7yXDPcYAAQHl0FgIRCWFZYc9y
+gABIefAiAAAweaQWAhB0HkQQBSCGAKQegBEHyAGQFOgfC1EgAZa4FoIQOGBgllhgEHi+HgQQO2MA
+I4UADfC+FgARCvBAlrgWgBA6YlhgEHi+HgQQuHCQHgQQDCBAocohwg/KIsIHyiBiAcojgg8AAJsH
+BAJi+MokAgQAwhAWhBAZCgABCiHAD+tyBdiKIx4H5QFv+AAUBTAPFQKWtB6EEA8OHga2FgARDx0Y
+kH/wABYDQXy2ABYCQV22ABYCQE+mABYCQUAehBAAFgJAUaYAFgJBSB6EEEQjAgM3ChABGN9yHsQT
+ABYPQPOmABYPQVAexBMAFg9BVB7EExMKEQJocoYi8w+MIgyADfIY3xXwENpyHoQQAN/PcoAApK7n
+shDfC/Ae33IexBMAFgJAVqYAFgJBXB6EEGhyhiL9DIwiAoII9ALn8H9yHsQTABYCQQPwANpgHoQQ
+Cw9eEAAWAkHIdIQkDJAA2gnyABYCQFqmABYCQFumCNoieOJ4AiCBALgWgBACeR9nuhYAETB58H9w
+HkQQZXgctk8mAAZyHsQTpB4AEA8VAJa2HgQQpBYAEAh0hCQakCHyPQheAgPIAZAa6BvIz3GAAIic
+FHmAEQAHkujQEQABahaPEAHgw7j4YA94ah4CEP4OL/vJcGoewhMF8PIOL/vJcA8dWJRDAY//4Hjx
+wBILT/kbEgE2z3CAAHyJ8CBCAM9wgAAsykAgEAiEKgsMACBTDrUTAibPcIAACJ9AoM9ygAAAAACC
+q8E3CF4AAYJRIECAQNjPIOIHyiCBDwAA0ADPIOEHz3OfALj/HaMEggHg07gEogUggA/Q/gAAFqMU
+zFEgAIBQBgEAz3CgANAbEYDxuMogIQCgDmH5zyDhA89woADUBw8QAIYDEg02z3aAAEwQtB0EEBCN
+UyDBAIYg/gNEuMAdAhAwrQoSEjYA2KQdABASpgvIBCCADwDAAADwjTEIgQ8AwAAAG8jPcYAAiJwU
+eRGJjujPcIAAsI32eCKICI0RCEMASnDmCy//qXHa8FEiAKCC8gQVBBCFDB4BG8jPcoAAiJzPc4AA
+9GIUehEShQBHgzKND3gD6iWDI/BUb89zgAAoi0JjSSDAABEKngXPcoAAMI32ekGKA/AA2sdwgAAw
+jfZ4BIgIIQEACCGBAKBxSSHBAxZvNXjPcYAAMI4BYc9wgABIjPZ4QYAdhkV4BCCADwAAAAgGeQPw
+I4UbyM9ygAB8ifAiAACYHUAQhCgLDDAgQC4EIIAPAEAAAEEoggdTJAAAHuJYeAV5mB1AEBUJngcA
+2Iy4pB0AEFDYnB0AEHDwHwneBwDYjbikHQAQz3BAAVAAnB0AEADYnrgSpmDwANikHQAQBdgUuJwd
+ABDA2Bi4EqZW8I8KXicBhXUIHgHPc4AA9GIng1KNbMoE6SWDI/BJIMAANG/Pc4AAKIshYxMJngXP
+cYAAMI32eSGJAvAA2cdwgAAwjfZ4BIgIIgIACCJBAEkhwQMWbzV4z3GAADCOAWHPcIAASIz2eF2G
+AYBFeAQggA8AAAAIBnkD8COFmB1AEBvIz3KAAMCcFXogogDYA/AF2BS4nB0AEFEiAKUA2M8gYgTK
+ICEApB0AEADYdB0EELYIb/upcM9xgABAeQphdBUBEVlhMHl0HUQQz3GAAEh58CEBAKQVABAleJgV
+ARCkHQAQFwleAjuWgLh2HUQQeB1EEKQdABAQ8CiGWpZ2HYQQFQneADuWg7h4HUQQpB0AEATweB2E
+EPYKL/+pcKQVARBEIX6CjBWCEBbyYhaAEER4hiL/A0S6hiD/Dlhgz3KAABh39CIRAM9ygAAId/Qi
+EAAO8MO6z3CAAMyuXHr0IJEAz3CAALyu9CCQAOC5yiACBBn0mBUAEFEgAIKIFYAQw7jRISKFCfIc
+eM9ygADsrvQiAAAH8Bx4z3KAALyu9CIAAEGFUSLAgMogIQCYFQUQhB0EEKkNHgKYFYIQz3CAAAB2
+QC8EEQAkhA+AACiLSmAEJYAPBgAAADG4GmIAFAAABCC+jwAoAAA78gTYuB0CEADYj7iXuaQdQBC6
+HQQQABQAAAQgvo8AMAAAJfLPcIAA9GJhgHmlZoBCexa7BSNDAa67r7uwu5gdwBAFgAQggA8BAADA
+BXuYHcAQABQAAAQggA8AIAAAKLgFIMUAmB1AEQfwz3AMQKj+GaUD8AHaAxIGNgIWAAEq6BvIz3OA
+AIid9CMAAILoAZW4FYQQdBUHEQQlvo8BAADAACTDAQAjBAAvJAgBoALhAL4dBBEtClAAguLMIuKA
+DPIKIcAP63IF2N0AYACKIxkGAJXg8c9wgAAwjfZ4A4gH8M9wgAAwjfZ4AoiMFQIQDrhFeIwdABCE
+FgAQiOjPcIAArAcAiLkIEAAbEgI2sQqQAQCVrQjSDc9wgACInFR4EYidCBEApBYAAOy40SEhgEj0
+jQoeIJ4VAxFQJY8Dr7+wv08jgAKeHQQQmB3AE4QWAhC0uae7irsvKoEATiKAByO4QCCCAwDYpB1A
+EA8ggADPcYAAUAWeHcQQBScCEEKh6XMIcYYj+w+GIfsPBSN+gJgdgBAR8gQnjx8AAAAIBCCADwAA
+AAgFJz6QB/Kouqu6mB2AEA3YAvAA2JgdAhCYFQAQiHHyCC//ANqkFQIQBCK+jwAAADCCHQQQUPKM
+FQQQnBUBEZQdABGSHUQQgB0EFAMSAzYhCh4DFNmQHUQQfh1EFHgTDwECIcEjMHmyHUQQEfAO2ZAd
+RBAA2X4dRBB4Ew8BSiEAIAIgwSMwebIdRBDPcYAACJ8ggYYhf48M9JgVDxARD18SYZOG65G6krqk
+HYAQELkleqQdgBAyhgQkgw8AAAAQUiMDA2V5BCGDDwAAABB9e2V5MqYZ8JgVARCyHQQQlB1AEJ4V
+ARFKIAAgkh1EEL4VAREKIQAkkB1EEADZgB1EEH4dRBAAIQMkhBUBEXhgOGAQeLAdBBDPcZ8AuP9W
+oZwVABAWoQMSATaSEQABsgzv/ZQRAQAb8APYz3KgANQHIBoYgAHYFBoYgAAWAEALGhgwABYAQAIa
+GDADyLQQAAEPGhiAZgov+cvYGxIDNs9wgACInBQgwgCokgMSATae7ZgRDQB1eK6gtqDPcIAAfInw
+IMMAz3CAAKAE9CDAALwZBADQEgMBBCCADwAA8P/Du2V40BoEAAbw0BIAAbwZBAAB2KAZAABuDCAI
+sImA4F4CIQADEgM2CshRIICBTgICACGDEwmeBpDYkLhDAiAAoBsAAM9wgAAoi0AgAgMEva1iwBOC
+ABEKQAOR2JC4HwIgAKAbAADKg891oADIH6QVAhCMJv+fDPLCehUKhQ8AgAAAh9iQuPcBIACgGwAA
+0Iv0buJgBCK+jwAAABP4YCfyEQpeAovYkLigGwAA6fAPCh8DBZCJ6IjYkLgD8IXYkLigGwAAz3CA
+AEwQGIiE4Nf0z3GAABRhDIEPIIADDKHPcYAAWAcAgQHgAKHJ8EKQMxOAAEsKDgALyAQggA8AwAAA
+MQiBDwDAAAAIiykIUwCkEwAAtLikGwAAkhMAAae4khsEAJ4TAAGnuJ4bBAAJ8A8JngGN2JC4oBsA
+AKHwCsgEIL6PAAABEHTy/g1AAgMSAzYIcrATDgGoGwAAFYVVJkEW1bjPdYAAqLQLCEUABdknpSWF
+Annk4cogJQAJIIAArBsAAKQTAACxCJ4EmBOBAMO5C8g8eQQghg8BAADwGxINNs9wgAAIn7Z45ZCs
+EwAAQS4GAwkgxAPPcIAAfInwIEUDgBMPAX4TAAH4YM93gACIEPeXFL34YAgkDwACfwNvz3eAAAB5
+8CdPECK4BS8+EFMhD3AAJ0AeLyQCAEAtQAE1eMdwgAB0p+CQz3GgAMQs76EBkA6hQC4ABp64pXgF
+IAABCqHPcYAAUAUB2AGhBvCgFQIQsBMOAQ0KhQMF2Bi4oBsAAM9wgACUB0GAIJMJIYEAAIgTCFEA
+z3CgABQECYAQcQDYAvcB2IvoA9gYuKAbAADPcYAARJMOgQHgDqGgEwAABCC+jwEBAAAa9JITAAGU
+EwEAkBMCAbITAwFuDu/+SiRAAAMSAjagEgEAJXigGgAAzthqD+/4AhIBNgMSDTagFQAQBCC+jwEB
+AAAF8nIJD/+TAgABBczPc58AuP8Yo89ygABQBRsSATYAgjcJAADPcKAAOC4FgAQggA/AAAAAGwiA
+D8AAAAD12AW4GqM7o2nYGLgZowHYAvAA2AcIUQAgogrIBCC+jwAAARDKJiEQefKkFQAQcwieBAGC
+gOAA3zjyANgBooAVABF+FQ8RH2fPcIAAiBAXkB9nBvBaCS/5iiBGDvkJnsXPcKAAxCzLgOTYrg7v
++MlxUyaBFP6+zCEigA7ymBUAEN4L7/4A2s9xgACIECiRIngfZwPwAN8DEgI2AN4I8M9wgAAInzZ4
+5ZAA3qlyz3GgAMgfrBUAEIjvpBUDELG7pB3AEATwCSDAAwPbGLtvofgRAwChawggQANieKAZAAAA
+2Ji4DqEL76QSAADxuBXMxSCiBM8gYQAVGhwwAZII6BvIz3GAAIid9CEAAAXoAYIPCJ4DFcyAuBUa
+HDDM2PoN7/gKEgE2AxICNqQSAQATCR4GthIBAc9woACYAz6ghfAAFgNBfLIAFgBBHbIAFgBAD6IA
+FgBBQBoEAAAWAEARogAWAEFIGgQARCMAAzcIEAEY3XIaRAMAFg1As6IAFg1BUBpEAwAWDUFUGkQD
+EwgRAmhwhiDzD4wgDIAL8hjdE/AQ3XIaRAPPcIAApK7HsAvwHt1yGkQDABYAQBaiABYAQVwaBABo
+cIYg/QyMIAKCCvQC5bB9chpEAwAWAEFgGgQABPBgGoQDCQ1eEAAWAEEodIQkDJBKJAAACvIAFgBA
+SiQAAhqiABYAQBuidBIAAb4SDwECf6J/uBKAAAInDxGYuaQaQAACf7hgEHhyGgQAuhIAAfB/cBrE
+A2V4HLLPcKAAmAMegLYaBAB8kkQjAAOXCBABG8jPdYAAiJwUfcAVABHPcYAApK4FewGCfLIXCF4D
+VBIAAbwSDwHDuOV4VBoEAAGSI+jQFQ8RVBIAAcO/5XhUGgQAgBUNF4Ttirt8sqQSAwAVCx4CaBIP
+AVMgzQD9ZbB9aBpEAxMLXgJqEoMAw7h4YA94ahoCAAvIBCCADwDAAAANCIEPAMAAAMexBfAA2Iu4
+B7EckoYg/QyMIAKCDvQQis9xgAAyiwS4EGERCFEAYBIAAYS4YBoEAArYz3GgAMgfHqEQ2A6hAdgV
+GRiABfCSDu/4iiDKBx0IH0PPcKAA/EQdgAQgvo8wAAAABPTjCx7AHQseQAohwA/rcgXYiiNKCUok
+AADdAu/3CiUAAVEgAMMA2Ar0z3GAALANCYEB4AmhANiYuAzoA9nPcKAAFAQjoIogEADXBuAAChoY
+MAPIpBAAAAQgvo8AAAAwu/ITCB8Fjg/P/tbYcgvv+AoSATYDyKQQAQCJCR4DXgvv+M3YQgsv/wHY
+AxIBNgPbHbHPcIAA2LQGgM9xoAD0B4HgAdjAeAy4ZaGFIAINDXMAswPIfZANcGCwA8hvgADaFQse
+AAgTAyANcGCgDBMDIQfwDXBgoAPIQBADAQ1wYLADyHGADXBgoAPISBADAQ1wYLBEoRYOD/8KEgE2
+IwbgANDY2grv+NHYAxIBNgGBHwgeBs9wgAB0BwCQHbHPcIAAeAdAgAGAUaESoQfwmgov/wLYAxIB
+Nh2xXg4P/wPIng0v/3gQAAGA4NoFwgDS2I4K7/gA2QMSAzaYEwAAlBsAAAGDKwgeBs91gACArqlw
+ag4v/2hxENgUGhwwFcyjuBUaHDBqCG//qXCbBcAAnhMAAZIbBAC+EwIBkBuEAJITAAGUEwEAlglv
+/4ITAwEIdc/YLgrv+KlxHw0eFgPZz3CgABQEI6CKIBAAChoYMP3YTwXgAKlxAxIONqQWABD0uDwC
+gQAwjs9ygACwjc9wgAAAAKCANnpgkjcNnhGhgFElgJFA3c8l4hfKJYEfAADQAM8l4RfPd58AuP+9
+p6SAAeXTvaSgBSWNH9D+AAC2pxXMGQheAM9woAAsIA+AhBYNEQggQAOieAPwaHCwFg0RZOUrDQQQ
+z3GAAESTG4EB4Buhz3CAAAAAAIAA3Q8IngHPcJ8AuP+9oADYuvDPdYAAKIsEuSFlAN8EIY0PgAMA
+ADe9Zb1IJQ0QBCGBDxgAAAAzuQ3hDydPEAkgwQADEpAAkglv/5gWABCYFgMQCSDBA0ErQgPAugS6
+VHpocMa4SSDABRR6z3CAAKB4UmAPC94CQSoAARQgggAourh6A2oEIIAPAAD8/89ygABEsAOiz3Kg
+AMQsDaIwGgAEC8gbEgM2BCCADwEAAPBBKA0DQC0AFp24FLtleAV5KqLPcoAAsA0eggHgHqKqCO/4
+49iU5cohRQOE96lxgCHCAc9woAAYLPAgQACU5cAlhh8AAJMAz3CgAGgs8CBAAwfwz3AAABURCgvP
++PkJnsXPcKAAxCyrgOTYXgjv+KlxBCWPH/AHAAA0v1MlgRQRDZ4XDQ+UEACWEOALCEQAAxIONlbx
+EI7PcoAAKIsEuABi+7jVIcIDz3WAAESwIKXipZgWABBeDa/+ANoBpc9xgABEkxyBAxIONgDdAeAc
+oRqB+GAaoQHYgOCuB0EAz3egAMgflBYFEJIWBxHPcIAARLAgHEAxIYAAEBUAz3KlAKz/z3CAAEwQ
+YBpABUwQBgFmEAQBMHsAJIABAnsD4yK7eGN4YEggQAAFuEUgQAMWolEnwIGA2MogQQMow2V4BCWD
+DwAAACAlu2V4ibiOuBmiQBcAFhXMIQheAKAXABD4FwIQQnkCIFkAdhYBES8hSDYZYQXwhBYZESNx
+Oh5EFh+HFQhFADB4z3GAAEwQCghv/WkRgQDPcKAA1AcB2TSgM6AD2M9xoADUBw2hEREAhkDAQOAP
+GRiAFBlYgwPIpBAAAAsIHgJmC0ABA/BHH1iTz3CgANQHDRABhkApADQweQV5A8hBgAAQEwFBwrgQ
+mAByEAIBAiIUBroQAgF5gELCz3KgANQHiBrAAKQQAgC3uqQYgAC5oLgYQgO6GEQDAcATCJ4Fz3Og
+AEgIQCMAIwbwQCMAIc9zoABMCALCA3AFIZIAJ2jPcgAA/P9Eec9ygABEsEOCCCGCAM92oADUBxWm
+ABuABAIjACUPpgIiQwB7pgPZMKYLyM9xgABUsAQggA8BAADwLLgDEgM2BLEPgwIllSAAoUATAAGu
+qQKxEIvPdoAABJ1gEwMBVGgPqcO7ZXpGsc9wgABEsEGAGxIDNkAmBRnPcYAAiJxQeHV+aYZWIcQC
+eGAJpqQXABBYYPgXAhDPcwAA/P9CeEPAz3KgANQLAdgQogHAz3KAAESwQoI1uMC4Aror4he4ZHrH
+cAAOAABFeOxyAKICEgI27HBAoM9wgABEsEKA7HBAqBsSAjYUIYAAUIjscECo7HCgsBvI8CQCAOxw
+QKAbyPAlAgDscECw7HCgsOxwoKDscKCgCxICNuxwQKADEgI2AJJUEgIBELhFeOxyAKIDEgI2AYIh
+CB4BEopwis9ygAAwjXZ6QIqGIn8MXHoEukV4A/CA2OxyAKoDyFCIMxCAAAS6BXrscECoA8hckOxw
+QLADEgI2nBIAAVEggIEA2M8gIgPKIEEDT4LAug26RXjPcoAAUAUHohvIqXYAIIIPgACwnKCqz3KA
+AAifFnoUeaCxQpLAGUQDFSUAAKCgz3CAAEwQeBmEAByQ0BlEA0TAz3CAAESwIoD6dYDhpgMuAMon
+ThM6dRp1qXdMIQCgtfIBgM9xoADIH5YgQQ8eoRDYDqEB2BUZGIAS8M9woAD8RB2ABCC+jwAWAAAI
+8icInwYdCF8GHwgfByELH0DPcaAA9AcngQDY1wnehxjwiiCIABTwiiBIABLwAdnPcIAAUAUjoL4L
+b/0ocM9xgAAsDgWBAeAFoYogCAIFJw+QFAMiAADez3GgANQHD4EQeBkRAoZY4CsKBQAPgRB4GREC
+hljgDQoFAIQRAADvCNWMD4EQeBkRAoZY4I8KBAAeGRiEHREAhgcSAjYLGhgwHREAhkApAzRJwB0R
+AIbPdoAAIAUAsh0RAIYBolYgACIeGRiAHREBhgASEwEweAUg0gABggDbkbuGIfMPQcDPcKAA0Btx
+oM9wgABIAxB4z3OgALRHSRsYgEAgACIAps9wgAAkBUCgbyBDAFQbGICMIQyADvIa2A3wz3GAAEST
+HoGKJRARAeAeoUMCIAAA3iDYmnADcBB4choEAADeDQkRIAMSAjas8AHAEwieBc9xoABICEAjACMG
+8EAjACHPcaAATAgDcEbAAsBFwQUiEiAGwAfgz3GAAESwI4EEIIAPAAD8/wggVgBVDaQlR8BjCF5D
+z3CAAESwAYDPcaAAyB+WIEEPHqEQ2A6hAdgVGRiAjgjv+EHYOwheQwHZz3CAAFAFI6AyCm/9AdjP
+cYAALA4FgQHgBaGKIAgCJPDPcYAARJMdgYolEhAB4B2hv/DPcKAA/EQdgAQgvo8ABgAADPL6uMog
+gg8AAAECDPT5uIogiAAI9APZz3CgABQEJaAA2AUnD5AA3qL0AdjPcaAA1AcUGRiAVSBAJA8ZGIAB
+Ch9CBsDPcaAA1AcVoQXCAN4CIwAlABqABA+hB8ICJZUlAiaAIBuhA9gQoQPI6XHIuQiIDLgleAUS
+ATcQuSV47HEAoQnAQCdXIAIaGDAHEgI2A8gAHAA0AxqYMAcaGDABgkCSAME0uMC4FHoDakDhBCCA
+DwAA/P8AIFAAGxIBNgfwFSJAMBwQAAYCIBAgFSJAMBwQAAbvCAWgBczPcZ8AuP8Yoc9woAD8RD2A
+BCG+jwAGAABn9A0JESAUzCcIHgDPcKAA0BsRgPG4yiAhADQPofjPIOEDANmRuc9woADQGzGgGwkQ
+IAfIUIhTIsEAhiL+A0S6wBiCADCoz3CgANQHFBiYgwPIQCFRICiIAeEoqAsSATbPcKAASCw9oM9w
+gABEsCKAMnFyBM3/A/DpdVMlfpBe9IUIXkPPcIAARLABgM9xoADIH5YgQQ8eoRDYDqEB2BUZGICu
+Dq/4QdhdCF5DAdnPcIAAUAUjoFIIb/0B2M9xgAAsDgWBAeAFoYogCAI18EwhAKCKJxAQCfQLyM9y
+oABILIonCBAdovq5z3GAAMCTB/IAgYC/AeAAocDxAYGBvwHgAaG88c9woAD8RB2ABCC+jwAGAAAL
+8vq4yiCCDwAAAQIL9Pm4iiCIAAf0A9nPcKAAFAQloMlwBX8X7x0PXhADyCmIAeEpqM9xgADAkwGB
+AeABoQrwEQ8eEM9xgADAkwCBAeAAoel1A8jpcci5CIgMuCV4BRIBNxC5JXjscal0hCQCkQChQCdX
+IBXyz3GgANQHgBlABQXMqXLIuhC4RXjscgCizKEB2BQZGIDqCm/+QCdXIAMSAjaSEgABBxIBNg8I
+nwKSEQMBbwueAqq4khoEAJIRAAGquC4L4ASSGQQAENnPcKAA0A8QGFiAJBABhs9ygACArkWSMHkC
+ukV5DBhYgBTZEBhYgM9xgACArmeRRpEY2RC7ZXoMGJiAEBhYgM9xgACArmmRSJEQu2V6DBiYgAXw
+z3CAAICuyqjPcaAA1AvQoesNEBDPcIAARLACgBMPBSAI2uxwQKBAJ1cg9fELyAQggA8BAADwLLiU
+4MAghg8AAJMAz3KgAGgs8CIAAM9ygABQBUeCRXgNoQPaz3GgANQHUqHPcKAA8BdFoA0PXhIOCC//
+AMAG8BMZmIAUGZiD57/KIIIPAAAGARX04L/KIIIPAAADAQ/04b/KIIIPAAAEAQn04r+KIEQByiCB
+DwAABwGeDm/46XHPcqAALCAwggPAMHAB2MoghgNEIINAL4Lk4QHZyiGGA4DgzCMhgMwhIYDs889w
+ACgIAAoaGDAEwNYJr/sA2ccFAADPcIAArLoSiDEIHgAtCB5Dz3CAAKy6D4jPcYAAaLsQuCCJn7iA
+4QHZwHkPuSV4z3GgAPxEDaEbDRAgz3CgAPQHYBhABc9xgABEkx2BAeAdoQvIBCCADwEAAPAsuJTg
+wCCGDwAAkwDPcaAAaCzwIQAAz3GAAFAFJ4EleM9xoADUCw2hz3CgANQHzKCKIAQCxg1v+Olxwgjv
+/gTAz3CgANQHGRAAhsDgEAUOABXMUSBAgAgFAQAD2M9xoADUByAZGIDPcKAA1AcB2RQYWIDPcIAA
+IAXAoADZz3CgAMgfkbkTGFiAz3CAANACEHjPcqAAtEdJGhiAB8jPcYAAJAUAoW8gQwBUGhiAz3Cg
+AMgfExAAhs93gABMEPG4yiAhAAgLofjPIOEDz3CgANQHDxAAhgcSDTYD2bQdBBDPcKAA1AcTGFiA
+EI1TIMEAhiD+A0S4wB0CEDCtEBWREKQdgBMLyAQggA8AwAAA0qc5CIEPAMAAABvIz3GAAIicFHkR
+iZLoz3CAALCNFiBABCKICI0VCEMAz3ASIAAARghv/qlxUfABhYEIHgHPc4AA9GIngxKNbBKCMAPp
+JYMm8EkiwgBAKQEhz3OAACiLIWMVCZ4Fz3GAADCNFiFBBCGJA/AA2cdygAAwjRYiQgREiggggAAI
+IEAASSDBA0ApgCE1eM9xgAAwjgFhz3CAAEiMFiBABEGAHYdFeAQggA8AAAAIBnkD8COFmB1AEBvI
+z3KAAMCcFXogogDYnB2AE5G4pB0AEHQdhBMqDm/6qXDPcYAAQHl0FQIRCWFZYTB5dB1EEM9xgABI
+efAhAQCkFQAQJXikHQAQmBUAEBsIXgIbl3YdBBB4HQQQpBUAEIC4pB0AEBLwCIc6l3YdRBAZCN4A
+G5d4HQQQpBUAEIO4pB0AEATweB1EEGIIb/6pcKQVARBEIX6CjBWCEBbyYheAEER4hiL/A0S6hiD/
+Dlhgz3KAABh39CISAM9ygAAId/QiEAAP8FMiwADPcoAAzK4cePQiEgDPcoAAvK70IhAA4LnKIAIE
+GPSYFQAQUSAAgogVgBDDuNEhIoUI8hx4z3GAAOyu9CEAAAjwHHjPcYAAvK70IQAAIYUNCd4AhB0E
+EATwhB2EE5gVABCtCB4CmBWCEM9xgAAAdgQggA8GAAAAMbhJYRlhQCkAIQAghA+AACiLABQAAAQg
+vo8AKAAAPfKkFQAQl7ikHQAQBNi4HQIQANiPuLodBBAAFAAABCC+jwAwAAAl8s9ygAD0YgGCGaUG
+giJ4mBUDEBa4ZXiuuK+4sLiYHQAQRYIEIoIPAQAAwEV4mB0AEAAUAgAEIoIPACAAACi6RXiYHQAQ
+B/DPcAxAqP4ZpQPwAdkDyAGQJugbyM9ygACInfQiAACC6AGVvh0EELgVgxB0FQIRemJYYBB4vh0E
+EJgVBRAEJb6PAQAAwA70CiHAD+tyBdiKIxkDLQFv94okgw8AleTxHQlQAILhzCHigFQFAv/PcIAA
+MI0WIEAEI4gI8M9wgAAwjRYgQAQiiIwVABAOuSV4jB0AEJgVABC+FQEREg8v/gDagh0EEKQVABAE
+IL6PAAAAMFLyjBUAEM9xgAAIn5QdABCcFQARkh0EEIAdBBSkFQAQAxICNh0IHgMU2JAdBBB+HYQU
+eBIDAQIiwCAQeAzwDtiQHQQQfh2EE3gSAwECIMAgEHiyHQQQAIGGIH+PpBUBEAz0mBUDEBELXwJB
+kobqkbmSuaQdQBAQuCV4pB0AEIwVABAEIIAPAAAAEFIgAQMShyV4BCCBDwAAABA9eSV4EqcW8JgV
+ABCUHQAQnhUAEZIdBBC+FQARkB0EEIAdhBN+HYQTghUAEbIdBBCAFQARfhUCEYIVAREaYoQVABFZ
+YThgEHiwHQQQpBUAEM9xnwC4/xahnBUAEBahB8jPcaAAyB+wEAABoBEBAGTgMHDKIIUPEigIAIX3
+z3AAKAgAChoYMBXMBCCADwAAAggVCJEABxIBNoogBACSCi/9mBEBABsSATbPcIAAmJw0eMCwA8hu
+C6ACGpDPcIAAAAAAgFEggIGaA0EAz3CfALj/3aCPA0AApBYAELS4pB4AEJIWABGnuJIeBBCUFgAQ
+kBYDEc9xpQCs/7AWAhHPdYAAiBB4oXWVqJVIwLtjYnoD4iK6W2J6YkgiQgAFukUiQgNWoSjCBCCA
+DwAAACAluEV4ibiOuBmhz3CgAKggCIAD2c9woAD0ByWgG8iYFgIQz3GAAMCcFXlAoQGWFOgbyM9x
+gACInBR50BEAAVMgwIAK8vARAQHPcKAAmAM+oLYeRBCkFgAQCwheAgYOD/oi8Ah0hCQSkAzy+bgI
+DSH6yiCBAwPZz3CgABAUJaAU8A8IHgLKC8AAQgzAAAzwcBYCEc9woAD0BwDZR6DPcKAAyBwnoAPI
+pBAAABUIHwFaC0/+29g6Dy/4ChIBNgMSATbT2C4PL/ikEQEAAxIDNgGDEQhfBgIPb/4E2AMSAzYd
+s89wgADYtAaAAdmB4MB5DLnPdaAA9AcZhQDagODKIcIPyiLCB8ojgg8AAAEKHANi/wXYHJMleA1x
+ALEDyD2QDXAgsAPIL4ANcCCgA8hAEAEBDXAgsAPIMYANcCCgA8hIEAEBDXAgsAMSATYckYYg/ww/
+CBABM4ENcCCgA8hQEAEBDXAgsAPIVBABAQ1wILADEgE2HJGGIPMPjCAMgAn0NoENcCCgA8hcEAEB
+DXAgsAMSATYckYYg/QyMIAKCGvRgEQEBDXAgsAMSATakEQAAJQjeBTmBDXAgoAMSATakEQAAt7ik
+GQAAWaG4GYIAuhmEAKQRAAAPCJ4BAYHwuIwPgv4O8DqBDXAgoAMSATakEQAAhiDzjwTyO4ENcCCg
+AdgLpQPYCKXPcKAA/EQdgAQgvo8ABgAALfTgeOB44HhTCF5DA8jPcaAAyB+wEAABliBBDx6hENgO
+oQHYFRkYgIILb/hB2C8IXkPPcIAAUAUB2SOgA8ikEAEAmrmkGEAAGg3v/AHYz3GAACwOBYEB4AWh
+hg9P/hpwz3CAABAFAIhnCFEAz3WAABQFIIUeDuAAQCGAD08IUQDPcKAALCAwgAAVBRANDUUAsIAC
+JU0RCPAQgA4ljQ//////HWW+5cohzQ/KIs0HyiBtAcojjQ8AAOYDPAQt98okTQPqCm/4TiWAHxIN
+wATU2AoNL/gKcQQgvq8GAMoACvLPcYAALA4IgQHgNwBgAAihA9nPcKAAFAQloAMSATYBgUkI3gCk
+EQAAUSAAgM9wgABMEATyvZAD8LyQz3GAAKy6EoktCB4AD4nPcYAAaLsQuCCJn7iA4QHZwHkPuSV4
+z3GgAPxEDaEE8HYRDQEVzFMgQIAO8tXYhgwv+AoSATYKyAcSATaODq/+GxICNs92gACArslwYgiv
+/gMSATZyD8/9Xg5P/oDgmgcCAAMSATaSEQABEQieAqq4xg9gBJIZBAADEgI2CiGAL4AAwJx+EgEB
+ghIAAYASAwE4YM9xgAAEnRtjG8gVeQmBcHsbY2mhAYK3CN4A19gGDC/4ANkyC2/9gNgKEgE2BCGB
+DwIAAQAVEgI3GQmBDwIAAAARCF4HTyLAABUaHDAG8KO6UHgVGpwwAxICNiGCXwmeAYu4jLgVGhww
+EIozEoEABLgleM9zgABUsM9xoAA4LiSBBrMQ8C8uQRBOJoIXAN4PJo4QxnnPdoAAYJz0Jo4QEQiA
+A/Hpz3AAAP//BLMH8ESzz3CfALj/VqAI2BQaHDDPcYAARJMRgQHgEaEx8BDYFBocMBXMo7gVGhww
+Vgmv/slw2Ng+Cy/4AhIBNgMSAjYBkgnoG8jPcYAAiJ30IQAAC+gBghMInwMbyAHaACCBD4AAEJ1A
+qRXMUyBAgAnyBxIBNoogBAASDe/8mBEBAPYNb/6pcAPIGpDyDWACGxIBNhXMUSDAgBgGIQAKEgE2
+1gov+NfYz3CAAKSuAxIONgKAz3eAAEwQmB4AELCOChIQNgDYpB4AEBKnC8gEIIAPAMAAADMIgQ8A
+wAAAG8jPcYAAiJwUeRGJj+jPcIAAsI22eCKICI4PCEMACnACDu/9yXHc8FEgAKCH8gGGhQgeARvI
+z3KAAIicz3OAAPRiFHoREoQAR4Myjg94A+olgyPwSSDAAFRtz3OAACiLQmMRCp4Fz3KAADCNtnpB
+igPwANrHcIAAMI22eASICCEBAAghgQCAcUkhwQMWbTV4z3GAADCOAWHPcIAASIy2eEGAHYdFeAQg
+gA8AAAAIBnkD8COGmB5AEBvIz3KAAHyJ8CICAM9wgABMyoQqCwwwIEAOBCCADwBAAABBKIIHAYbA
+uB7iWHgFeZgeQBAZCZ4HpBYAEIy4pB4AEFDYnB4AEHDwIQneB6QWABCNuKQeABDPcEABUACcHgAQ
+ANieuBKnYPAA2KQeABAF2BS4nB4AEMDYGLgSp1TwjwheJwGGdQgeAc9zgAD0YgeDMo5sEoIwBOgl
+gyPwSSLCABRtz3OAACiLAGMTCJ4Fz3CAADCNtngBiALwANjHcoAAMI22ekSKCCGBAAghAABJIMED
+Fm01eM9xgAAwjgFhz3CAAEiMtnhdhwGARXgEIIAPAAAACAZ5A/AjhpgeQBAbyBUhACAgoADYA/AF
+2BS4nB4AEFEgAKUA2M8gYgTKICEApB4AEADYdB4EEMoKL/rJcM9xgABAeQphdBYBEVlhMHl0HkQQ
+z3GAAEh58CEBAKQWABAleKQeABCYFgAQGwheAhuXdh4EEHgeBBCkFgAQgLikHgAQEvAIhzqXdh5E
+EBkI3gAbl3geBBCkFgAQg7ikHgAQBPB4HkQQAg3v/clwpBYAEEQgfoKMFoIQFvJiF4EQRHmGIv8D
+RLqGIf8OWWHPcoAAGHf0IlEAz3KAAAh39CJSAA/wUyLBAM9ygADMrjx59CJRAM9ygAC8rvQiUgDg
+uMogggQY9JgWARBRIQCCiBaBEMO50SAihQjyPHnPcIAA7K70IEAACPDPcIAAvK48efQgQAAhhlEh
+wIDKICEAhB4EEJgWABCpCB4CmBaCEM9xgAAAdgQggA8GAAAAMbhJYRlhFG3HcIAAKItAgAQivo8A
+KAAAPfKkFgIQl7qkHoAQBNq4HoIQANqPuroehBBAgAQivo8AMAAAJfLPcoAA9GJhgnmmZoIie5gW
+BRBAK4QFBSRDAa67r7uwu5gewBBFggQigg8BAADARXuYHsAQAIAEIIAPACAAACi4ZXiYHgAQB/DP
+cAxAqP4ZpgPwAdkDEgI2AZIq6BvIz3OAAIid9CMAAIPoAZa+HgQQuBaFEHQWBBEAJQMBeGAQeL4e
+BBCYFgUQBCW+jwEAAMCoBIH/IQlQAILhzCHigAwCwv7PcIAAMI22eAOICfAAlt/xz3CAADCNtngC
+iIwWARAOuCV4jB4AEIQXABCI6M9wgACsBwCInwgQABsSATaXCZABAJaTCNINz3CAAIicNHgRiIMI
+EQCkEgAAewgfA6QWABBzCB8AbwgeIJ4WABGKuJ4eBBCYFgAQrrivuLC4mB4AEIQXAhAvKoEATiKB
+ByO5DuEPIEAAmB4AEKQWABC0uKQeABCeFgARp7ieHgQQmBYAEM9xgABQBQKhEQgeAhEI3gKouKu4
+mB4AEA3YA/AA2JgeAhCYFgAQvhYBESIL7/0A2oIeBBCkFgAQBCC+jwAAADBS8owWABCUHgAQnBYA
+EZIeBBCAHoQUpBYAEAMSAjYdCB4DFNiQHgQQfh5EFHgSAQECIUAgEHgN8A7YkB4EEADYfh4EEHgS
+AQECIkAgEHiyHgQQz3CAAAifAIBEIIGApBYAEAz0mBYDEBELXwJBkobqkbiSuKQeABAQuSV4pB4A
+EIwWABAEIIAPAAAAEFIgAQMShyV4BCCBDwAAABA9eSV4EqcX8JgWABCUHgAQnhYAEZIeBBC+FgAR
+kB4EEADYgB4EEH4eBBCCFgARsh4EEIAWABF+FgIRghYBERpihBYAEVlhOGAQeLAeBBCkFgAQz3Gf
+ALj/FqGcFgAQFqEKEgE23NjCDM/3tQbv96vA8cDhxW/YlbjPdaAAyB8SHRiQz3ABAEA8FR0YkDYL
+D/2KIAQADqXpBs/34HjxwF4O7/cD2K7Bz3agANQHEx4YkA8WEJYZFgCWwOC+9wAWAUAAFg9A07nP
+cLD+AAAFec91nwC4/zalUyfBFCV4FqXveJzgyiHCD8oiwgfKIGIByiOCDwAA7wvKJMIASAPi9sol
+IgCLcI4KL/gO2QYUATEAFAAxUSEAgcAgogAD4AQgkg8AAPz/C8BWIhEiEegapSzAG6UCwB6lz3AA
+bAQAGaUH8M9wAAARDHoOz/cZFgCW9QiEhAAhACQPHhiQA9ggHhiQ5djGC+/36XEBwAQggA8AAABA
+5QXv967A8cCGDe/3A9jPdqAA1AcTHhiQDxYRlgAWAUAAFg1A07nPcLD+AAAFec9ynwC4/zaiUyXB
+FCV4FqKveJzgyiHCD8oiwgfKIGIByiOCDwAARQzKJMIAdALi9solIgAAFg9A8H8AFhBAQOdRIACl
+wCeiEAPnBCePHwAA/P8H8M9wAABZDMYNz/cZFgCWQicBFPEIRIAAIcAjDx4YkAPYIB4YkNrYDgvv
+96lxBCCALwAAAEA1Bc/38cDSDM/3CHXPcYAAAAAAgYIkAzE1CF4DAYHtuEDYzyDiB8oggQ8AANAA
+zyDhB89ynwC4/x2iBIEB4NO4BKEFIIAP0P4AABaii3DPcYAA7HlSDi/9xNrPcKAAFAQB2SSgz3GA
+AESTE4EB4BOh07gFIIAPsP4AAM9xnwC4/xahOw2eEBvIz3GgAGQu8CEQABDgSiEAIA8hESAB3yjw
+rP/PdoAAgK4Id8lwTg4v/otxIg8v/slwGvCm/wh3ANgacDpwFPCO2JC4oBwAMA8OHhGG2JC4oBwA
+MIDnzCUhkOD1A9nPcKAAFAQjoIDnqXar8gDYz3GAACAFAKEA2c9woADIH5G5ExhYgM9wgADQAhB4
+z3GgALRHSRkYgItwz3KAACQFAKJvIEMAVBkYgM9woADIHxMQAIbxuMogIQCQD+H3zyDhAyTBUyHA
+AIYh/gNEucAcQjBkwEQmjRZrDl+QBu+M2JC4oBwAMLnxBLjHcIAAKItAgEh0hCQMkA3yUSJAgovY
+zyAiBMoggQ8AAIgAzyAhBFXwTIhQccoggg8AAJEAzyAiBE30AcETCZ4GAd2Q2JC4oBwAMJHxIpAz
+FIAwXQkOAAvIBCCBDwDAAABRCYEPAMAAACLBRQlSAI3ZkLkEIIAPAQAA8Cy4lOCgHEAwyiIFAIT3
+CHKAIsIEz3GgAGgs8CGBAJTgwCCGDwAAhwDPcaAAGCzwIQAAFfAKwYwh/49d889woADIH6QQAAAi
+eNdwAIAAAKYGxv+H2JC4oBwAMAHdS/FEJv6SCPLPcKAAFAQJgIDgT/UjDl4Qz3CgAMQsEIALIACE
+RfXPcAAAsB7CCg/4CyBAhD3zvQLv94AkAzHgeOHF4cahwUokAHIA2aggAA8AIYIPgADUyoQoCwwE
+4jIiQg7Pc4AAvK7PdYAATBBAwiDCw7pcevQjggBMFQMRemJ6lWK6W2MD4s91gAAAefAlTRAiugUt
+vhBTIQ5wACZCHl161Wg1fsd2gAB0p0C2A+MiuwUt/hBTIQNwACNCDl16QbYB4aHAwcbgf8HF8cDh
+xanBi3WpcM9xgACweoYLL/0k2qlw0gsv/gMSATaiDC/+qXAhAu/3qcDxwJ4Jz/ehwc9xgADgrCSB
+z3WAAEwQNBUQEc9zgADMrgQhgQ8AAAAQRSFBA0DBIMLPd6AAyB/Dulx69CODAKAXAhACIwMEFwrk
+AADeEHhwe84OL/4U2gsIHgYA2CHwA9jPcaAA9AcFoeTaDXBAsA1wwLBChQ1wQKBGlQ1wQLBAhQ1w
+QKBClQ1wQLDEoUoKj/1AFwEWMHn6Dy/8CnAB2GUB7/ehwPHAz3CAAEwQGIghCFEBz3ABAKCGQg9A
+ADoKAAEIcc9wgAAQRtYKgADRwOB+0QLv9hfY4HjxwOHF1g9gADDYtGjOD2AANtgFfRi9z3CAANR6
+6g9gAJC9KLileM9xgABwBRUB7/cAoeB48cDPcYAAKEYAEQUAFw1UAgohwA/rcgXYVtu5Ba/2iiSD
+DwWhz3CAAFBG8CBAAUB40cDgfvHAZgjP9892gAAoRgWGFwiRAooglwluDq/3atkI2ACmQPCF4Mwg
+4oE89M9woACsLxqAUiAAAG0IHwCKIBcMRg6v93XZEBYFEBcNFAQKIcAP63IF2HfbSQWv9ookgw/P
+cIAATJ8VIEABIIjPcIAAsETPcoAAlEEB3SGoKIqjqMC5IqhmCe/6BBpAAQKGIgnv+gGmB6aKINcH
+6g2v94HZoKYxAM/38cC+D4/3z3aAAChGJYYA3RsJkQAKIcAP63IF2IojhACYc9kEr/ZKJQAADQnR
+AAHYBqZr8AkJEQGmpmfwOwmRAs9wgABMnyCIz3CAALBEz3KAAJRBo6ghqCiKwLkiqNYI7/qhooog
+lwl2Da/3iiEEBwjYAKZJ8M9woAAsIBCAR4YA31BwEAAvAMonbxCB4cwhIoA79Ioglw1GDa/36XEF
+hhMIEQKA5wHZwHnPcIAAlEEoqAGGAKaAIJcHJg2v94ohhA8mhs9wgACkQQCAIQlRAIDgyiHBD8oi
+wQfKI4EPAABGAQXYnvOmpgPYDvCA4MogIQEK8gsPUBAFhgsIUQAB2ALwANiJ/yEHj/fgePHAtg6P
+9891gAAoRiWFguHKIcEPyiLBB8ogYQHKI4EPAACNAMokwQDEA6H2yiUhAIrhcgENADImQXCAAOB6
+QCeAcjR4AHgChbYPr/oBpc9xgACUQQQRBQAZDTQEB6UKIcAP63IF2JzbhQOv9ookgw/PcIAATJ8V
+IEABQIgoic9wgACwRAHeQajAuSKomg+v+sOoiiDXBz4Mr/eg2cClg/ADhYAglwcuDK/3qdkDhTIL
+L/gApRIJ7/kB2M9wgACUQSGAz3CAAEyfNXghiM9wgACwRCGoANkiqAHZTg+v+iOoYfAA3uII7/kA
+2CSFz3CAAEyfNXghiM9wgACwRCGoANkiqCYPr/rDqE3wiiCXCcYLr/fF2QjYAKUA3voKL/jJcBAV
+BRAXDRQECiHAD+tyBdjS270Cr/aKJIMPz3CAAEyfFSBAASCIz3CAALBEz3KAAJRBw6ghqCiKwLki
+qMoOr/oEGkABH/CSD4/2OwiRAVoPr/YG2IIPj/aZ4IgKQQE2D6/2BtgP8IogVwxKC6/37NmaDo/6
+iiCXBzoLr/fy2QDYAKWBBY/34HjxwA4Nj/fPdoAAKEYlhgDdKQmRAM9wgACkQQAQBADPcIAAvEQE
+EAUACiHAD+tyBdgVAq/2iiPFCykJEQLPcIAApEEAEAQAz3CAALxEBBAFAAohwA/rcgXY7QGv9ooj
+hQzKCq/3iiDXDSWGiuFiAQ0AMiZBcIAA7HpAJwByNHgAeAfwng+v+alwJglP+Ah1iiCXDpoKr/ep
+cT0NURDPcYAA2LQAgYq4AKHCCS/4AtiKIBcJegqv94ohRgUG2ACmz3EAAGA6z3CAALgEjg2v+iCg
+B6YO8JYJL/gA2AKGgCCXB0oKr/eKIcYIAoYAphAWBRAZDRQECiHAD+tyBdiKI0YKRQGv9ookgw/P
+cIAATJ8VIEABIIjPcIAAsETPcoAAlEGjqCGoKIrAuSKoVg2v+gQaQAFP8M9wgABMnyCIz3CAALBE
+z3KAAJRBo6ghqCiKwLkiqC4Nr/qhoooglwnOCa/3iiEGDQjYAKYz8AHdsg6v+alwz3GAAJRBQYHP
+cIAATJ8oiVV4QYjPcIAAsETAuSKoQajuDK/6o6gb8IogVwyOCa/3iiEHAd4Mj/oT8M9wgACwRN4M
+j/rWDI/6FwhRAIogVw1qCa/3iiGHBalwqv6tA4/34HjxwDoLj/fPdoAAKEYFhncIEQEA3YIIL/ip
+cM9xgADYtACBqrgAoYogVwkuCa/3iiEHDBAWBRAH2BsNNAQApgohwA/rcgXYiiPHDCkAr/aKJIMP
+z3CAAEyfFSBAASCIz3CAALBEz3KAAJRBo6ghqCiKwLkiqDYMr/oEGkABBgyP+gemJQOP9+B48cCy
+Co/3z3CgACwgMIDPdYAAKEYHhQDeEHEFhcombxCA4MwmYpAe9AKFgCCXB6IIr/eKIQgDAoUApQWF
+EwgRAoDmAdnAec9wgACUQSioz3EAABw5z3CAALgEyg0v+CCgvQKP9+B+4HjxwEYKr/dA2rDBz3GA
+APh6/gvv/Itwz3CAAChGIIDPc4AAsEQJCVEAQYsR8M9wgACUQUGAz3CAAEyfVXhBiAOLQiAAgMog
+YgAaYs92gAC8RAGOAd8QcsInzhOA4cwhooAK9M9xgACkQSCBCiVAkMolYhAH8IHhAd3CJUETAuUY
+uhC4RXhALwESBXmKINcK2g9v96V5A44FvwS4+GC1eDAkADANAq/3sMDPcYAATBApgVEhQIDhIMIH
+yiCiAES4z3GAAHRGw7gJYQkJHgA1DZ9RNQleAM9wgABMEDiIIQlQAM9wgAB8xwCAEQheAM9wgAAg
+zRSICQjQAQ0JkQAJDZ5RAdjgfuB/ANjhxUQiAVNNcoYi/ANNcE1wBCWAXwAAACBBKH6DB/LPcIAA
+fMcAgAsIXwAA2ALwAdglCRECz3CAAEwQGIgLCFAAEQ1eUQTwhiX21wTyAdiU8ADYkvD+6c9xgAC0
+p1QRgwD4689zgAB8x2CDOQteAM9zgAAgzXSLLQvRAWGBjCP/jxD0pJHPcwAA//8ZDcEQZYGMI/+P
+BvRskbULgI8AAP//hCgLDAAhgH+AACzKaYDPdYAAOHsLC14BQCUDFwPwQCUDFBiIC2NBKgABCGUW
+e89wgABUe3y4eGAoEIMADQseAB6BhiD2jxbyCwteAB6BJQieAgsLngALDR5SAdgL8BUL3gDPcKAA
+DCQRgIwg/4/38wDYUSOAgcogIgDPcYAAfMcggRMJXgAEJb7fAAAAIsogYgAW6M9zgAC0pz6DOQke
+AowiAoDMIoKPAABQAMwigo8AANAAEPSTuT6jDvDPcYAATBApgQ8JXwCMIgKABPQJCZ4BAtjgf8HF
+8cDGD0/3z3CgAAwkGIBBKIQHQS0AVMG4FQgVATMmAHCAANB7QCcBchR5AHkA2Bjwz3WAALSnlBWA
+EEAoAQaGIP0PUiDAAUW4JXjPcaAAiCQQoT6Fs7k+pVLwAdhEKD4NACGAf4AAyIwhiM91gAC0p5QV
+ghDPdqAAiCRTIUUAPoVAKg8GhiL9D1IiwgFFug0MQAHlelCm4PHPc4AAuHtig5q55XtlelCmPqXP
+caAAyBwQ2kmhJIDPcqAA8BcmoiOAJqIigCaiIYAmooYVARFouTB5hh1EEFMhwYDAICEIwCAiDCCA
+M6IsaCCBM6L4EAGCM6L8EACAE6IA2AqiMQdP9/HAxg5v9wDbz3CgAAwkWIDPdYAAtKetcEEqhgeG
+IPcPlBWBECm4NnvAc8dzgACUoRV7AIvPc4AA5ARgg9No1X7XY9tjRCeFkFMnjhAEIo8PACAAAMwn
+IpAH9EwlAIDMJyGQAN8C9AHfuwgTBIDmzCcikFnyFw2UAQohwA/rcgXYoNuBA2/2iiSDD893gAC4
+e/AnhBNAKQUGhiH9D0AuhgNSIcEBBSSEAQUlDwFFuSV/z3GgAMQnQRnYgz8OkRAehRDZmrgepc9w
+oADIHCmgB4PPcaAA8BcGoQaDBqEFgwahBIMGoQDYCqGGFQARaLgQeIYdBBAm8EoVgxCk60ylhhUC
+EWS6UHqGHYQQFQ7RECsRAYZkulB6hh2EEC2lxg5P+RDwQCkABoYh/Q9SIcEBRbkleM9xoACIJBCh
+HoWzuB6l7QVP989woADIHBDZKaAB2M9xoADwFwqhAxIDNhyThiD/jCf0D4NLCB4Az3KAAMiMBIIG
+oQOCBqECggahAYIGoXATAAEe4FMgwIAF9EAiAAgD8EAiAAxAgFOhTGhAglOh+BACglOh/BAAgBOh
+CfAIgwahB4MGoQaDBqEFgwah4H7hxQMSDTbPc6AA8BcPhc9yoAD8FwijQBUAEQqyEYUIo0gVABEK
+shOFCKNQFQARCrIclYYg8w+MIAyAB/QWhQijXBUAEQqycBUBERyVCOEIsh2VCLJUFQARCLJgFQAR
+CLIZhQejGoUHoxuFB6NyFQAROGAQeAiyz3CgAPQHJ6AC2c9woADIHCeg4H/BxfHAiiBXB5YKb/dM
+2QHYANlSDeAEiiIEANHA4H7xwFoMT/fPd4AAXEIBh0ogACAQ3gp1AqcA2QGHDyFBAwsgQIAN8keH
+z3CAAIRGRHnwIEADBSBQIIDg4iACAGG+AeXZDnWQr31CIACgcQRv98ogYgDxwA4Mb/cIcQDeDyYO
+EM9wgACUQaCAFgpv94ogFw/Pc4AAXEIBgwQggQMwdsohwg/KIsIHyiBiAcojgg8AAJQAyiTCAAAB
+YvbKJSIA0nnDg0KDBCBAgCR+w6MBoyR6xYNCo8R5JaPMJaKQD/IKCA/4D3rPcIAAuARggM9xAQDs
+OmB7A9gM8AbogOLMJaGQCPTPcIAAvAQggGB5A9jdA0/38cDhxQh1ANsPIwMAz3KAAFxCA4IhgmV4
+A6IFgmV5IaJleAWiZglv94ogVw/PcIAAuARggM9xAQDsOgPYYHupchEI3wDPcIAAlEE2Dm/5AICR
+A0/3CiJAgADZ7gABAC8mAPBKJkAATgAGAE8AIACKJf8P4HgKIkCAANnOAAEAbAAkAC8mAPBcAAUA
+Kwg1CEomQAAIcQDYAiG+gOAgxQdCeQHgAiG+gOAgxQdCeesH7/8B4C8tAQBAJUUAAiZ88QAAIAAA
+KEAB6CBiAy8gAIAvIUsAAiG+gMAghgHCIYYA4H4RACAASiAAEEogQBAOIkIALyALEs4gRYCKJf8P
+CAAFAC8tAQBAJUUAAiZ88QAAIAAAKEABSiZAAOggIgMvIACALyFLAAIhvoDAIIYBwiGGAEomAABC
+IP6QziCCAUQgfpDOIYIB4H6dAQAA4HhGgQnqI4FggSKCYnkwcADYAvYB2OB+4HjxwM9xgADERphw
++P8H6M9xgADkRohw9f+D6ADYCPDPcYAABEeIcPH/eegB2NHA4H4Iczhg1bvVuQ0J5QA2uAIjQgAK
+8M9ygACotEWCAeDJuCJ6emIWuOB/RXjgePHArglP9wh113UlAACAANhK989xgACotCWBJQlFAyJ9
+AeD58c9wgACotMWAqXBqDu//yXEFLj4QAiVNHowgEIDKIcYPyiLGB8ogZgHKIyYNyiQmAJAGJvbK
+JQYBFri9AW/3pXgB2s9zoACwH1mjfoME6CJ7CQjEAADYA/BIcOB+z3KgACwgcIIJ6AIjQgATDoRw
+AIAAAA8IhAAA2ATw/wjFgAHY4H7geAhyA/AB4CCI/ungf0J44HjxwOHFCwgyDAh1GQ2SHgohwA/r
+cgXYItuYdRUGL/a4c0IlABxFAW/3D3jgePHAxghv99hwAN3v/8loKw4SEPhwqXcyJoADFQgSDBEI
+kw7t/zJvOHgFfQHnQidHAOcPdYBhvvkAb/epcAomAPCKIL8PyiBkAOB/LyADAOB/iiD/D/HAdghP
+94YKIAAIdc9xoADIH0WFDOj0EQ4AAoBkhcR6RXv0GcAAIoUAoQvw9BEAAER49BkAABzYGLgVGRiA
+pQBP9+B4D9mauc9woACwHzWg4H7gePHAIghP9wh1z3agAMgfpBYAELhgpB4AEAHYE6ZYhjmGANgA
+IkKDASEBAFimOaYC2TOmOoZbhgAhQYMBIIAAOqYbphWGIg2gAKlxFaYXhhoNoACpcRemD9iauA6m
+z3CAAARH0//PcIAAxEbR/89wgADkRs//GQBP989xoADIH/QRAAAA2kYgwA/0GQAAD8iauJu4nLgP
+GhgwHNgYuBUZGIBYoVmhWqFboc9wAAwPAKQZgAAOoQ/YDLgQoeB+8cBmDw/3z3WgANAb04URDp4W
+z3CAAMRGbgkAAA8O3hbPcIAA5EZiCQAAEQ4eF89wgAAER1IJAAAc2Bi4E6WVBw/34HjxwOHFJYBA
+gEIiAoDKImIAgOLKIcIPyiLCB8ogYgHKI4IPAABvAMokIgAwBCL2yiUCAWCBFQtAAEKAooNCfQ0N
+UxBgg/ULQYBBgwGjYKBBoACiRIClgEAlAxYXCl4ARoUG6qKCQoBCfQcNUhAAo0SApYBAJQMXFwre
+AEeFBuqigkKAQn0HDVIQAKNBgAsJgQAeDu//BYABBw/34HhAgBUKAABkggsjQIAF9ECC9woBgADa
+4H9IcOB48cBmDg/3CHYAgEIgAYDKIWIAANgk6SWGQYYB3zByIIZBhkGhIKIAps9wrd4CAAGmpYbA
+fwaFDw4BEKlwAtnq/walpYYHhQ8OARCpcAjZ5v8HpQXvog3v/wWGAdhxBg/38cAGDg/3CHUodub/
+CHfCpalwtv9ZBi/36XDgeCCAEHHKISEA4H8ocPHA3g0P9wh3HvAAhiGGIaAAoQDYAKbPcK3eAgAB
+pqWGBoUPDgEQqXAC2c3/BqWlhgeFDw4BEKlwCNnJ/welI4Zgeclw6XDs/womAJAH8gOHIIAChiJ4
+twhSgBYN7//pcOUFD/fxwOHFCHUD8MP/qXDh//7o4QUP9+B+4HiA4cokTXDoIG0Cz3GgAFAMJYEB
+GFIA4H7xwEoNL/e4cJhxz3OAAHQFAYMig892gAC0p891gADUewJ5HoY5uMG4FH0BFYcQz3CgANQL
+PBAGAM91oADQDw0JZQEA2gDYQ/CoFgAQz3GgAMgfZOAeoRDYDqEB2BUZGIAZcwbwz3WgANAPCXMX
+FQCWIoMCIMABAnlIIQEAAYMCeUghAQApDFEAJQpFAM9zgAAwRwKLJRUPlsG402gB4AKrA4PYf+d4
+A6MB4vDxIwsfQM9zoADUC7EJRIEEEAEQAdigcQQYQBA8G4AB6QQP92IMT/q68fHAdgwP989wgABA
+qAiIjCACgCryNGjHcYAAKIvAgc9ygABIjM93gAB4tPaXFnphglAmjRWGJ7sfoKGMJ0SQhiMBDmGi
+BPSRvaChDPCxvra+wKERD1EQlr7AoYUjAQ5hoioJD/gA2c9wgAB4tHEEL/cvGEIA4cXhxs9wgABA
+qAiIjCACgM9ygACUtBby0orPcYAASIy0aMd1gAAoixZ5AIVhgQbulbgApau7BfC1uACli7thoQDY
+E6rBxuB/wcXgePHAtgsP989wgABAqAiIjCACgC7yz3WAAHi0KoXPcoAASIzUaMd2gAAoi2CGRCEE
+gxZ64YIS8lAjgQUgpoYnAR7hog0MEQGRuSCmBfCxu7a7YKZ6CA/4B/CWu2CmhScBHuGiLxWAEKK4
+Lx0CELEDD/fxwEoLD/fPdoAAQKgIjowgAoAy8s9wgAAsykiAz3WAAHi0KYW3uri6BCGBDwMAAAAH
+uUV5KKDqC2/4ANgJhUiOz3GAAEiMUSCAghRqx3CAACiLYIBWeUGBBfKVu2Cgq7oE8LW7YKCLui8V
+gBBBoaO4Lx0CEEEDD/fxwLIKD/ehwQh1QMHPdoAAtKcAlkomQCCGIPwAjCACgMImgiUC2MpxV/+P
+6B6Gs7gepgDYz3GAAJS0E6nPcYAAXLQMsWTwQiWSEEx0hCQDkP3z4HjPdaAA0A8lFQ6WJRUPlkok
+QCAQFRWWAm8MIgCgwiQOJS8jACVKCKAAyXAacBQnERUjDhAgDw5QEYvmANjKIGEAAvAC2M9xgAAw
+RySBCyEAgAPyANkC8AHZKnA2/xHoSQiQIc9wgABcRxYgAARAgAaIHQ4BEAzq6XBgegDBFfDPcYAA
+tKcegbO4HqGr8QohwA/rcgXYiiPXDEokAAAZB+/1CiUAAQHYoncQHdiTAiJSJIDgzCMioKH18QEv
+96HA4Hjhxc9wgAAwRyCIAdthqCDpz3KgALAfeaJ+gkKAo4AA2TENgRDPcoAAdAVYioPqAdoK8EGA
+AiONAPcNhZ9MAEBLIagocgcKUQBhoCKo4H/BxaKg7/HxwF4JD/cacDpxiiBHDXoP7/aKIZYHz3aA
+ALSnz3WAAHi0EQg0JADfDNjpcfz+jOgehi8dwhOzuB6mz3CAAFy07LAf8KlwDNnv/s9ygAAwRwCK
+/NkK6ACWJHiMIAKABvQllQSVJ3gDokIgACMqcYv/AJaGIPwAjCACgDQPwf9BAQ/34HjxwOYID/eh
+wQh2iiBED/YO7/bJcSUO9RAA2c9ygAC0px6Cs7geos9wgACUtDOoz3CAAFy0LLCO8ALY2P6A4Iry
+z3GgAFAMBYHPdYAAeLQSrQWBE60JlYwgiIBivkzyEvY9CNABjCDEgW/0Yw6REMlwANnK/ivoQCUA
+G8lxwf4h8IwgyIBR8owgEIBf9AWBCW6F4IQN4f/KISEAV/CrDlEQyXAA2b3+owgQAEAlgBvJcbT+
+LxWAEIG4Lx0CEEXwLxWAEIC4Lx0CED/wfw5REMlwANmy/nMIEACLcMlxqf4gwFMgAQCGIH8PLB1C
+EBx4LR0CEOfxUw6RE89wgABMEBiIRwhQAMlwANmk/h/oz3KAAFy0SHAG2Zv+QCIAAgbZmf4MkoG4
+EPAjDhERyXAA2Zv+C+jPcoAAXLRAIgAFBNmR/gySgLgMsoogRA+6De/2KZUBAC/3ocDgePHAhg/P
+9gh1GnHPcIAAeLS+CC/3JNnPcIAAtKcegM9ygADsrTm4UyBBAM9wgADUezR4QYogiADbVXnPcqAA
+1Asvos9ygAB0BSGIYaICJUAQgODKIMwAAqJNcYYh/APQ4cwhgo8AAIAAD/KMIQOEEPIKIcAP63IF
+2IojWgdKJAAARQTv9bhzCnFn/wPwh/9dB8/24HjxwOoOz/bPcoAAtKc+ghpwqsEA2CEJngPPcYAA
+TBBiEYEARBKDAMDdZHmGIf8OIrk6fQjwz3CAAEwQTBANAQLYhhIBAQJ5EYIE4RYK7/wA2i4IYAAC
+IE8DA9jPdqAAyB8TphiGANlCwBmGQ8AahkTAG4ZFwLWGXBYREEAWABYfZ/wWABDPcIAAeLRAgAGA
+ACLCgwEgQABAwkHAi3AZCFEghMEOC2AAhsIId89wgACoyCqQC/CCwfoKYACGwgh3z3CAAKi0JJDP
+coAAqLRlggbCBLsXC6QAQCmAAhkIhQACev8IhIAF8LoLYACGwAhyRsItD5EQqXBKC2AASHEIdSpw
+PgtgAAbBBsM6cATCB8EFwAAiwoABIEAARMIW8JXvqXBKC2AASHEIdSpwQgtgAAbBBME6cAbDBcAH
+wgIhwYBEwQMggABFwBkPUBDPcIAATBAYiITgzCchkADYA/QB2C8iB6A49Klw2gpgAAPZCHUqcM4K
+YAAD2QDBCHcBwEAhwYBBIAAAQcAEwEDBBcFAIMCAQSEBAETA6g4gAEXBDwgRILWmAMAYpgHAGaYb
+CJEgtaYAwBimAcAZpvemBMAapgXAG6YRCFEg96YAwBqmAcAbpoogBw5CC+/2SnFMIgCgAdnAec9w
+gAAUYTSoXQXv9qrAz3GAACRHIIEA2IPhzCEigAL0Adjgfw94CiIAgPHAFPL4/4DgyiHBD8oiwQfK
+IGEByiOBDwAAwwbKJCEABALh9colAQHPcIAAJEdAoNHA4H7xwM9ygAAkRyCCgOHKIcEPyiLBB8og
+YQHKI4EPAADMBsokIQDMAeH1yiUBAQGiAdrPcaAAyB9QoUoZmABIGRgA3vHgePHAcgzP9s9xpAC0
+RSkRAIbPdoAAyJIRpisRAIYA3RKmz3ClAAgMA4AYpg4RAIYQejC4U6YUpg8RAIYVps9wgADwp1CI
+cohZpjSIeqYLkDumLOACII8AAiDCACJ4z3OAACRHIINdpvymNwk1AR6mMyZBcIAA3HtAJ4ByNHgA
+eAPYwf9A2M7/t6YL8M9yoACoIDGCAoOiozhgF6YB2BKiAdg5BO/2FqbgeM9wgAB0BRiIBujPcIAA
+MEcBiAPwAdjgfvHAtgvP9s91gAAsysUVABYRCF4Bz3CAACDNFIgNCBACCYVRIECBh/LPcYAAtKcD
+gVoIb/wkgSMIUQDPcYAAfMcggRcJXgDPcYAAIM00iYjhyiBhABDykejPcIAAfMcAgBMIXgDPcIAA
+IM0UiIfgAtgC8gDYEv/aDIACz3GAAKi0BoFFIEABBqHPcIAATBAYiM92gAB4tEkIEAHPcIAAtJ1W
+iHeOz3GAAMiSDQuAAACAHQgfAM9ygAB0BQWCAeAFogDYBKIPgQHgD6EF8A6BAeAOoQmFUSBAgXgL
+wgDPcYAAdAUDgQvoANgDoc9xgAC0BgCBorgaDqACAKEvFoAQUSDAgGwPgv8vFoAQUSCAgPAOgv+M
+/7X/gOCYDOL1yiDiBc9wgACsuhGIgOCIDOL1yiAiBfECz/bgePHAz3CAAFy0DJANCB4ASghP/Abw
+USBAgNgPAvzPcIAAlLQTiA8IUAARCJEAk/2VBc//df2NBc//iQXP//HAQgrP9s9woADEJ1IQAYZB
+EACGhiDjjwDdBvLrudEhooFJ8s9wgABMEAmAz3aAAHi0LwheAeYKwAWK6BSOgeDKICEBrAyhAsoh
+YQDPcIAAZLAAgAsIngA6Cq/8EJa0rs9wgABksKCgTXCGIPwDjCACgB30z3GAAHQFB4EB4Aehz3CA
+AEwQGIiE4KQOgQSKIEcNzg+v9oohCwUaCsAFfP/iDKAELyCICgXwjCADhBgPwf/9Ac/24HjPcYAA
+dAUJgQ8IUQDPcKAAsB8bgAuh4H42uDa5MHDWIIUPAACAAOB/InjgePHAz3KAAHQFCYIhCFEAz3Cg
+ALAfG4AMoiuC9f9GEgEBOGAQeEYaBAB5BM//8cDhxc91gAB0BQ+Fj+gJhRsIUQBeC8/1EwhQBs9w
+oACwHxuADaUB2A+lfQHP9uB48cDhxc91gAB0BQ+FF+gJhSsIUQAuC8/1IwhQBs9woACwHxuAANoO
+pS2F2v9EFQERT6U4YBB4RB0EED0Bz/bgeADZz3CAAHQFK6AsoC2gLqAvoCWgMKAkoEYYRABEGEQA
+4H8qoPHAANnPcIAAdAUpoPT/z3CAAERHIgqP/8kDz/8Icc9wgABER0WAQ4JhuWCCz3KAAHQFSILV
+unpiz3OAAKi0ZYMFK34AACGBcMdxAAAAEEkCj//gePHAz3GAAHQFCYGW6AHYCaEA2Aih3f+KIIcO
+Tg6v9oohzwvPcIAATBAYiIPgnA/h/8ogYQFZA8//8cASCO/2iiDHD6TBIg6v9ooh0gXeCEAEgOD4
+DsL/z3WAAHQFCIUqhZ7/RBUBEUYVAhFZYTBwAN7D9wIgTgAlhZHpEe4AhY/oBIXPcYAAyJLYYASl
+EIXYYBClEIHYYBChCPARCYUDAiZAEDCFOGAQpYogCAC6Da/2JIUEhULGQMAQhRDZQcAFhaLaHttD
+wItwkgnv9hi7CIUKpQDYBaVGHQQQRB0EEAClegnv9RLYBIUbCFQBAdi3//IOj/nPcYAAwJMYgQHg
+GKED8AXYsf+xB6/2pMCA4AHYwiAMAM9ygAAwRwCqAdgBqgDYAqoBogKiA6LgfySi4HgAFgBAWQPP
+9s9wgAAkR+B/AIDgePHAAgnv9RLYz3CgALAfO4DPcIAAdAU1Au//KKDPcaAAsB87gUEoggXVuEEp
+gwXVuQJ5z3CAAKi0YnoFgMm6BSi+ACdxz3CAAMRGA4AAgOB/OGDgeM9xoACwHzuBQSiDBdW4QSmC
+BdW5FwklAFtjz3KAAKi0RYJZYQJ5AeMC8AJ5QCuABSV4zPEA2Za5z3CgANAbM6DgeAMLnkXgfvHA
+Yg6v9gHaCHaKIAgAz3WgAMgfEKVBHZgQ9f/Pd4AAqLRjhwWHUyNBBRBxyiHND8oizQfKIG0ByiON
+DwAAnQDKJC0AXAOt9colDQGA5swmYpA89CCHz3aAAHzHOKUhhzmlFKV1pQCGuwheAM9wgAAgzRSI
+rwjRATeF94UVhQQhkA/A/wAA1b9SCyAAqhYBFtW4BSABBAIgw4M3pQLZM6VahTuFyiDDABIAIwBf
+u6AWAxcKu+J7eGAA2wIiAoADIcEAWqU7pS/wWw6REM9xgAB8x6ARAAcKuBalz3CAACzKCYA1CF4B
+z3CAACDNFIgpCNEBU6VYhRmFANuqEQEGAiJCgAMgwABapRulFYXOCgAAF6UJ8E4RAAYapU8RAAYb
+pXelpQWP9uB48cBCDY/2CiYAkM91gACotBH0z3CAAOB7qXGiCu/2FNrPcIAAxEaiD0//z3CAAORG
+FfAdDpEQz3CAALTIqXF+Cu/2FNrPcIAA5EYO8Klwfgnv9gXZz3CAAMRGbg9P/89wgAAER2IPT/8E
+lQq4BaUGhYYgww8GpclwmP9uCI/1MQWP9uB4z3CAAMRGJ4AG6QOAQIACgUJ4BfDPcP8P///gfs9x
+gADERkaBiiH/DyCgBuoigiCgAdgD8ALY4H7xwKHBCHOLcPf/guAA2AfyAMAQcwHYwiAOAKHA0cDg
+fuDYkLgA2s9xoADIHxChCdiwGQAAtBkAABXYbxkYAGrYQhkYAADYmrgPoaQZgADPcAAMABkOoeB+
+4cVTIEIFBCCND8D/AADPcIAAqLQFgAIggwAEIYIPwP8AANW5Inile0V4EHPKIK0ABfcQcwDYyiBm
+AOB/wcXgePHA4cXYcLhxmHLu/wh1yHCIcez/EHXKIK0ACvcQdQDYyiBGAZwP5v/KIQYBNQSP9ghz
+KHLPcKAAsB8bgAIggA8AAgAAaHHe8Yoh/w8goM9zgADERkaDEuokghsJXgDPcYAAlEgPCkAAz3GA
+AKxIEQpBAECC5QuBgALYBfAigiCgAdjgfs9xgAAER0aBiiH/DyCgBuoigiCgAdgD8ALY4H7xwEoL
+r/ZKJEAAwIGggAHf0XXCJAIB0XWhgWGAwifOEwHesXPAfrFzAdvCI84ATCQAgMwmIpDKI2IACvSF
+64DmzCcikAPyAtsC8ADbFOshC1AAOQuRAKCAwIEBgCGBAiWNk6CiAyBAAAGiEPAA2ACiAaIM8KCB
+wIAhgQGAAiWNk6CiAyEBACGiKQOv9mhw4HgF8EJ5x3BAAAAAz3KAAKi0RYLzCkSAUyBDBXBxwCCN
+D0AAAADAII0A4H8ieAbwYnkCIIAPQAAAAM9ygACotGWC7wtEgFMgQgU6YgsLhAA4YAfwAiCAD0AA
+AABieDhg4H7xwF4Kj/YIdSh2Pg8v/wGAoIUQuUEtABQ4YC4PL//JcRC5sHg4YCIPL/9ALoESnQKv
+9ihw1bjVuQ8JBQDPcoAAqLRFgllh4H8OIEAAKwhQD4XgEfIH9hsI0AAnCBEB4H8E2BsIUAkbCFEL
+4H8C2OB/ANjgfwHY4H8D2OB/BdgG2OB+4HjxwIHg4cUA2An0z3CAAI+0Ad1mDG//qXGpcDUCj/bg
+ePHAsgmP9gh3z3CAAEwQGIgacY8IEAGE5wDdiAAlAMogRQPPdoAAeLRAJgATKgxv/wTZLo6wrlMh
+AAARrkEowCCguV8IZAACIEIAY79TCsUDDurPcaAA0A8QEQCGYbpYYBAZGIAlEQCGD3gD8A+OANlT
+IIIgDyGBACR4LyYH8M9xnwC4/xCuGIHPIOIH0CDhBxihGIGeuBihGIG+uBihAdh1AY/2g+DxwADY
+CfTPcIAAjLSmC2//A9kB2NHA4H7geIbg8cAA2A/0z3CAAJS0igtv/wbZz3GAAGSwAIGCuAChAdjt
+8fHAmuDhxQDYjPfPdYAAnLQEbWILb/8E2QuNgrgLrQHYKQGP9vHAluDhxQDYjPfPdYAAnLSpcD4L
+b/8E2QuNg7gLrQHYBQGP9vHAjgiv9gnZz3aAAPRHCg2v9slwAJbPdYAA2LQTCB4AAdhMHQIQZgqv
+9RnYCPBMFYAQDQhRAALYTB0CEACWIoYiuMC4TR0CEM9wgAD0SCCgz3GgACwgUIFyhQIiwAAJCN8H
+UqUQgQOlz3CAANxHAIBCIACAyiBiAIjoz3CAAIxHAICA4CwIAgAIhoboz3CAAKi0CJAVpQCWJbjA
+uLYI7/8D2TIMj/ZVAI/24HjgfuB4z3GAAIxHz3CAAPR7AQWv9hTa4HjxwOHFz3WAANxHWglv/6lw
+z3CAAIxHIIA9CV4AFBAEABgQBQBRIQCAzCQigMwlIoAI9AohwA/rcgXYyQRv9cTb3g0v/wAlAAHS
+CM//CHF2CW//qXDpB0/28cDhxc91gACMR6lw7guv9gfZCBUEEADYRiT+g8ohwg/KIsIHyiBiAcoj
+gg8AAHcAeARi9colIgBAhScKXgAPCh4AJYUD6SaFi+kKIcAP63IF2H/bSiQAAFEEb/W4c89xAQDY
+fjKlE6UjhR8KHgEOpQGFL6UZCNADz3ABAODsEqUB2BOlBPAupf/YD6XH/yoLj/ZVB0/24HjPcYAA
+jEcAgSKBf9vPcoAA2LRTIACAJnsD9C6CkekG6A6CCyDAgA30MIKF6QWCDwiQAAfpEYILCJEAAdgC
+8ADY4H7geOHF4cbPcIAAjEdAgAKAP9sGewxwz3aAAIxHoobPcYAA2LQLIECDAdgugcIgAQALIUCD
+wLoG8imGUSEAgc8gYQALIMDACfTPcYAA2LQugQshwIAA2QLyBNmE6g8JEAGF6ATqCQkRAQTYwcbg
+f8HF4HjxwCIOb/YA2c9ygADYtASChujPcIAAjEcHgAPoAdnPdYAAjEfPd4AATBAYj8CFUyYDEA0I
+EAEJhwkIXwEA3jLwB4WE6ADYEaWA48whIoAK8gmFEQgeARcOHhEBhQsI0QMA2Ah2FPAA2BHwEYUB
+4BGlDwg1AQjeAYWP4ADYCPLPdqAALCDQhgHYw6II3rCFie2C64fphehMEoAACQiRAATe6QVv9slw
+4HjxwHINT/akwTpwGnFId6b/nwgQAM92gADYtACGkwgRAM9wgADABQCAFwiRAIogCQhqC2/2iiFI
+BgYMIAAI2M9xgACMRwCBS4ELCB8BAYEXCNADXwrQAADdp6GsoQPYC6EI8E8K0AAA3amhp6ED2Aih
+pKaKIIoIJgtv9iqBz3CgACwg0IBAxwbYQcBCxUPFAdge2SpyCHNKJAAACiUAAQAmhx8HACChIyAA
+BAomAAElBW/2pMDxwOHFCHUhCBEB1gygAATdiiCJBtIKb/aKIQYNbgsgAADYXfBxCREBz3CAACzK
+GBCEAEwkAIHKIcEPyiLBB8ogYQHKI4EPAAC8AbgBYfXKJSEAJBAEAFEkQIHKIcEPyiLBB8ogYQHK
+I4EPAAC+AZQBYfXKJSEAiiBJCG4Kb/aKIQcACgsgAAfYQgxgAATdUgyAACXwUyV+kBPyz3CAAMAF
+AICC4MwgIoEZ9IogCQg6Cm/2iiGHBNYKIAAI2A/wHQkRAs9xgACMR89yAQBAXAHdqXAygZ7/A/AA
+3WUEb/apcPHA6gtP9s91gACMRwiFaQjQAAuFYQjQAAmFz3GgACwgGQgeAQyFFQhRADCB2glv9oog
+SggB2CHw0IEKhQImARAF2Ay4MQhFAIogyge6CW/2yXEQ2AmlDYUCJgEQGQ5FcAAAAFCKIMoHnglv
+9slxAdgMpQPwANjhA0/24HjxwGoLT/bPcKAALCDwgM92gACMRwqGpYYCJwEQDQ1EEAaGHWUifQnw
+z3IBAEBcAdgyhnD/6qYAhs92gADcRxsIXgCCCS//qXB2DI//CHEaDS//yXAE8LIML//JcHUDT/bP
+cYAAjEcAgVEgAIHPcIAAaLFIgFMiAwAE9AGBIQjQAwvrFwrfAc9woAAsIBCADaEB2OB/C6EC2OB/
+C6EK6xUK3wHPcKAALCAQgAqhAdgD8ALYCKHgfuB48cC2Cm/2ANmbuc9woADQGzGgz3CAAMAFAIAA
+3ongyiHGD8oixgfKIGYByiOGDwAA5gDKJIYDuAcm9colxgDPdYAAAAAghTcJXgQhhfG5QNrPIuIH
+yiKBDwAA0ADPIuEHz3GfALj/XaFEhQHi07pEpQUigg/Q/gAAVqHPcYAAHEjwIQAAQHgAhQ0IXgTP
+cJ8AuP/doI0CT/bxwOHFz3GgAKwvHIG9gQR9z3CAAJQEAIgTCFEAz3DA3wEAHKEo2Ri5G/CKIEkG
+Dghv9oohTgyKIAkGAghv9qlxFQ0eF4ogCgXyDy/2iiFPACoIAAT2vZwIwvYA2Zu5z3CgANAbMaAt
+Ak/24HjxwOHFz3WAAMi0z3CAAER8QCUBFBYPb/ZI2s9wgACkfM9xgADEBQYPb/YI2gDZz3CAAPRH
+KaDPcIAAwAUgoM9woAAsIBCA4QFv9hal8cDt/wDYz3GgAMAvgBkAABOBi7gToc9wyAA8AMAZAADR
+wOB+8cA+CU/2z3aAAEBI8CYBEM93gADABQCnrQnQAM91gADItBsIkQAqhRMJUQCKIAkILg8v9gDZ
+CNgApzkIkQAC2AqlANnPcKAA/ESeuSGgz3CgALQPANpcoA/IBCCAD/7//wMPGhgwD8iHuA8aGDAs
+8PAmARAXCVEAz3CAAIxHAIALCB8AANgKpQLwKqUEyA0IngB2Ck/5DfAA2p66ANnPcKAA/ERBoM9w
+oAC0Dzygz3CAAEwQGIgNCBEBXg0ABITo2gsAAuEAT/bxwOHFiiBJDI4OL/aKIcoK1g0AAs9xgAAs
+ykiBz3WAAMi0NJFTIgAAqgsv9gHbANgSpQ6FB+jPcIAATBAYiAsIEQEE2APwognP/2oL7/8A2ZTo
+C4UVCN4AiiCJBjoOL/aKIQsEANgJ8IogSQcqDi/2iiFLBQLYsf91AE/28cAA2c9woADQG5u5MaAE
+yBcIEAGKIIkGAg4v9oohCgUA2Kf/CvCKIAkJ8g0v9oohygYE2KL/1P9A8eB48cDPcIAAwAUAgA0I
+0QCCDsAA7f808eB48cBODm//4cXPdaAArC8YhRUIngYahVIgAAANCB4AHIUTCB4HiiBJBp4NL/Yk
+aEoOwAAchTMIHgDPcIAAZEgAgEIgAIDKIGIAj+jPcoAA9EcJghcIFQHPcYAAyLQugQsJUQAB4Ami
+PIVeDS/2iiCJDd4KD/XqDMADiOjPcIAAwAUAgIPgKA/B/5UHD/bxwA4PD/YIdzpxiiDJCS4NL/aK
+IUcMz3CAAMQFIIABgFYhQQsU4DhgMnDKIcYPyiLGB8ogZgHKI4YPAADyAcokJgAUBCb1yiUGAc9w
+gADItA6AHejPcIAATBAYiC8IEAHPcIAAyLQJgILgyiHCD8oiwgfKIGIByiOCDwAA8wHKJCIA1AMi
+9colwgDWDIAAWNjCCG/2AdnPdqAAyB8g2BCmMthDHhgQANhiCm/2jbgg2BGmz3CAAMi0pBYQENoM
+b//roDWGdgwv9oogyQnPdaAArC88hWYML/aKIMkJiiDJCVoML/YqcYcP3hDPcIAAMAcAgIYgfw+C
+4AHYwHhvCFEAGBYAlqG4GB4YkIogEAARphmF8LgZhQzyBCCADwgAAADXcAgAAAAB2MB4B/CGIH8P
+guAB2MB4buig3xLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhv4wn/5/u9RmFiLgZ
+pQoID/nPcIAAyLQLgMC4geAB2MB4Rg2v9lpwTgjgACpwAdjiD6AACnEchTcIXwYYhYi4GKWg3xHw
+4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44Hhhv4wn/5/t9VIKwACkFg8QDg2v9kpwZ/9c
+2HYPL/YB2SDYEKYy2EMeGBAA2B4Jb/aNuCDYEaYchR8IXgbPcIAA9EcAkFEggIHKICECRA8h9soh
+oQDPcACCAQAcpQDYTg+gAOlxRQUP9uB48cDyDC/2ANnPdp8AuP+9hj2mHNkV8M9zoADIOzaDRCEC
+BzaDhiH/CCV6NoOGIf8IRXnPcqAAqCBNguTiiPft6boIgAC9po/oANgr8DgTBABYEwUACiHAD+ty
+BdjNAS/1L9uOCS/3ANiKIIkHogov9oohhwED2M/+AtjPcYAAyLQJoc9wgAAsygmAJbjAuOILr/YO
+oQjYiiH/D0//AdjBBA/24HjxwEoMD/bPdYAAyLRcFYEQHwlzAKTBCiHAD+tyBdiKI0QASiQAAGEB
+L/UKJQABBMiB4MohwQ/KIsEHyiOBDwAAAgHKIGEB7/MTCZEAANhcHQIQDg4v9RnYU/C+DaAAiiDG
+C58IEAAOhQDe0qUH6M9wgABMEBiIKQgRAc9xgACMR9Ch0aEQ2Amhx6HJpYogSQfaCS/2iiEEBwLY
+MvCmDaAAiicEG89zgADEBUCDYYOVIkEA+mIU43piRwikAAHZKaXPcKAALCCwgM9wAQAIdkDAQcFC
+wUPGKHAG2QHayXOYdrh2ACWHHwcAIKHyCuAA2HaKIAkHdgkv9ulxAdiE/rUDL/akwPHASgsP9s9w
+gABMEBiIhODKIcEPyiLBB8ogYQHKI4EPAAA6AcokIQBYACH1yiXBAIYMj/8KDaAACHYIdZHu1gyg
+AIogxgsN6M9wgADEBSCAAYCWIYEBFOA4YB0IRAPiCuAAAdiKIIkG/ggv9oohxQQA2Gb+QQMP9vHA
+ygov9oog/w+hwUDAz3aAAMi0CIYA2Qfoz3CgACwgEIAopgemGgyP/4YMr/8acAhx2g2v/wpwgOCH
+9M9wgACMRwmAAN9RIACByiHBD8oiwQfKIGEByiOBDwAAdAHKJMEDqAfh9MolwQCKINAHgggv9ooh
+xQ2ODgACz3EAggEAz3CgAKwvPKDPdZ8AuP90FRAQ/aUc2Rbwz3CgAMg7NoBWgIYh/wiGIv8IRXlW
+gIYi/whFec9yoACoIE2C5OKZ9+zp2gugAIogxwt0HQAUewgQAAaGGOgKIcAP63IF2IojhgNKJAAA
+JQfv9AolAAE4EAQAWBAFAAohwA/rcgXYDQfv9C/bogmgAItwCiUAkB3yiiBJBtoP7/WKIYYFiiAJ
+Bs4P7/UAwYogCQbGD+/1qXGKIIkHug/v9YohhgYD2BX+qXAAwZz+6QEv9qHA8cCGCQ/27gqP/1oL
+r/8IdQhxrgyv/6lwEwgRAYogCQaCD+/1iiGLCizwz3CgAMgfpBABABWAz3aAAMi0RYZCeddxAACg
+DwDdy/fPcYAAqLQlgdW4QSmCAEJ5CwhEAAaGkOiKIAkGPg/v9YohSw2mpoogSQcuD+/1iiELDgLY
+8v1xAQ/28cDhxc9wgABMEBgQhABMJACByiHBD8oiwQfKIGEByiOBDwAACQMUBuH0yiUhAEIKj/+u
+Cq//CHUIcQIMr/+pcDUBD/bxwM9wgABMEBiIhODKIcEPyiLBB8ogYQHKI4EPAAAbA8okIQDQBeH0
+yiXBAP4Jj/8O6III4AAB2IogSQieDu/1iiEMCgfYzv3mDkAALQeP//HA4cXPcIAATBAYiITgyiHB
+D8oiwQfKIGEByiOBDwAAXgPKJCEAgAXh9MolwQCuCY//Ggqv/wh1CHFuC6//qXCGIL+OEvRCDI//
+IQhRAALdz3CAAMi0qqCKIEkHLg7v9YohzQupcLL9eQAP9vHA/g/P9abBz3CAAER8NoDPdYAAyLQX
+gETBKYVFwIPhzCEigDjyz3CAAEwQGIhpCBABAd8A3hkJUQC+D6AA6XDPcIAAiJwdiMmlJuiKIEkG
+zg3v9YohTQID2AmlEYXSpQzZFSQCMM9woAAsILCAz3ABALx1QMBBx0LHQ8ZEggDYCHOYcLhwACWH
+HwcAIKECD6AA2HDRB+/1psDgePHAYg/P9c9wgABMEBiIhODKIcEPyiLBB8ogYQHKI4EPAABRAMok
+IQB0BOH0yiXBAIogBw5ODe/1ANnPdoAAeLQtjgXpDI4bCEIAOg3v9Yoghw2KIIcNLg3v9SyOWPDP
+cKAAsB8bgM93gAAwtQKniiBJBhIN7/Vj2YogCQYGDe/1IodMjg2Oz3GAAKi0aJFAp891gADYtB0I
+4gABpwixANlNHUIQAdkspTWFCQkFABWlEI4EpRGOA+gD6gDYCPDPcIAATBAJgPcInoAB2AKliiBJ
+BrIM7/WD2YogCQamDO/1IocChUCHgODKIGIAGLgFegSFCiEAgIogCQbKIWIAELmCDO/1RXleCC/1
+Ati9Bs/18cBWDu/1iiBJBmoM7/WKIUQBIgiP/891gADYtAhxhODMISKCEfTPcKAALCAQgADaQqUD
+pc9wgAAwtQKA1bjHcAAAiBMJpQ2FgODKISIBAN4+Ca//yXALCBEBzaUT8AKFCeiKIIkJDgzv9Yoh
+RAoF2AfwiiBJB/4L7/UceQLYmgyP/0EGz/XgePHAyg3v9ZhxCiMAgMohwQ/KIsEHyiBhAcojgQ8A
+AFcByiQhAOAC4fTKJQEBz3CAAJRIJYAjgc93gACotECBz3GgALAf24FTJk0VNr5+Zl1lJYdhuwUp
+/gAndQIlgxCMIxeHSvfPcoAAMLVBggUqfgAndV5mEQwQAM9xgACMRzOBJQlRAEIPr/5YJUEWz3CA
+AKxIACWBHwAAiBMuD4/+iiDJDhrwz3CAAMRIHg+v/lglQRbPcIAA3EgAJYEfAACIEwYPj/7Jccm5
+z3CAADC1I6CKIIkPFgvv9clxBoeBuFUF7/UGp/HAz3CAAHxIeg6v/uHFz3CAABC1NYjPcIAAlEjP
+dYAAMLWL6SCAQiEBgMohYgAF6SCFlQkRAE4Oj/7PcIAArEhCDo/+QoXPcKAAsB8bgDa6NrgPCIUA
+CHGAIRAAAvAIcWCFemJhhXlhGwmFAAohwA/rcgXYsdtKJAAAqQHv9LhzemIBCYUAInpPenByyiHN
+D8oizQfKI40PAAC4AMogbQEr989xgADESCCBQiEBgMohYgAH6VhgI4XJuA0IQABIcADZl/+ZBM/1
+8cDhxYogSQY2Cu/1z9nPcIAATBAYiITgyiHBD8oiwQfKIGEByiOBDwAA0gDKJCEAKAHh9MolwQD6
+De/0AtjPdYAA2LQChQzoz3CAAPRHAYAJpc9woAAsIBCAAaXPcIAAqLQGgEUIHgDPcIAAwAUAgIbg
+zCBigcwgIoIE9FT/FPAEhQDZEOjPcKAALCAQgCKlA6XPcIAAMLUCgNW4x3AAAIgTCaUA2ASlpP/t
+A8/14HjgfuB48cBqC8/1z3GAAEwQOImE4cohwQ/KIsEHyiBhAcojgQ8AADwByiQhAHwA4fTKJcEA
+z3GAANi0KoGNCRAAz3aAAGRIIIZCIQGAyiFiALzpgODKIcEPyiLBB8ogYQHKI4EPAABCAcokIQA8
+AOH0yiUBASWGI4HPd6AAsB+ggTuH1bk9Zc9xgACotCWBYbgFKT4AJ3WKIAkO9gjv9alxO4eKIAkO
+6gjv9Ta5yXC+DK/+VyXBGM9wgAB8SAAlgR8AAIgTpgyP/g0Dz/XxwOHFCHXPcKAAsB87gIogSQ6y
+CO/1NrmKIEkOpgjv9SKFz3CAAEwQGIiE4MohwQ/KIsEHyiBhAcojgQ8AAI0ByiQhAJgHofTKJcEA
+z3GAAPRHCYEJCBUBAeAJoc9xgACotAaBRiBAAQahz3CAAMAFAIAZCJEAiiDJB0oI7/WKIQYH5giv
+/wbYkQLP9fHA4cUIdc9woACwHzuAiiCJDiYI7/U2uYogiQ4aCO/1IoXPcYAAqLQGgYK4BqHqC+/0
+AthZAs/18cDhxQh1z3CgALAfO4CKIMkP7g+v9Ta5iiDJD+IPr/Uihc9wgABMEBiIhODKIcEPyiLB
+B8ogYQHKI4EPAAD6AcokIQDUBqH0yiXBAIogyQeuD6/1iiFIAUoIr/8G2AHZz3CAANi0LaDPcYAA
+qLQGgUYgQAHhAe/1BqHgePHA4cUIdc9woACwHzuAiiAJD3IPr/U2uYogCQ9mD6/1IoXPcIAATBAY
+EIQATCQAgcohwQ/KIsEHyiBhAcojgQ8AAMABWAah9MolIQDPcYAA2LQMgQnoBYGA4MwgYoAF8gDY
+yf8X8M9xgACotAaBRiBAAQahz3CAAMAFAIAXCJEAiiDJB/4Or/WKIQcEmg9v/wbYSQHP9eB48cDO
+CM/1CHbPcKAAsB87gIogCgDWDq/1NrmKIAoAzg6v9SKGz3CAAEwQGIgA3YTgyiHBD8oiwQfKIGEB
+yiOBDwAAHALKJEEDvAWh9MolwQDPdoAAqLSmpoogSQiODq/1iiGICCoPb/8H2AaGgrhiCO//BqbP
+cIAA2LStoE4K7/QC2LkAz/XgePHA4cUIdc9woACwHzuAiiBJD1IOr/U2uYogSQ9GDq/1IoXPcYAA
+qLQGgYK4BqEWCu/0AtjPcYAA2LQMgQvoDYEJ6AWBgODMIGKAMA/i/8ogIgBpAM/14HjxwO4Pj/XP
+cIAALMoJgM9xgADYtCW4UyAAgAqhANgFoQ2hV/LPcIAATBAYiKMIEAGKIEkG1g2v9YohSQDPcKAA
+sB87gIogCQbCDa/1NrnPdYAAxEgAhUIgAIDKIGIAMwhRACYJr/6pcM92gACUSACGQiAAgMogYgCL
+6IogSgCODa/1iiEJA8lwXgmv/iKFz3WAANxIAIVCIACAyiBiADMIUQDmCK/+qXDPdoAArEgAhkIg
+AIDKIGIAi+iKIEoATg2v9YohSQbJcB4Jr/4ihY0Hj/XgePHA4cXPcAAA///PdYAAMLUDpc9wgABk
+SJoIj/7PcIAAfEiSCI/+ANkgpQXYAaUipfoI7/QC2FkHj/XgePHA3g6P9Sh1z3GgACwgMIHPc4AA
+MJJGiwDeBOpHi4PqBtiH4Mohyg/KIsoHyiBqAcojig8AAJ8CyiQqANgDqvTKJcoAz3OAANi0CQ2Q
+ETSjToMPIkIDTqPPcoAA9EjwIgAAUoM4YAIgjQAJDd8XEqPPdYAAjEcChUGFBHobyBsKDgAqpXYM
+r/WKIMoIAYXJpQcI0QPHpbUGj/XgePHAPg6P9Qh1z3aAAPRHAYbPcoAA2LQJos9wgAC0px6ABCWE
+HwAAACDmuCa4UyADAEEtQBPAuBYizwACpyTyz3OAAIxHCYMA3yV4w7kPJ08QL4MJowshwIMB2AXy
+DKMcGwABLw2fEQ6DMIPkeAUgQIAQow/yANgJps9woAAsIBCAA6IH8M9woAAsIBCAAaLPdoAATBAY
+joTg6AihA8ogQQMYjjcIUADPcIAAfMcAgE8IXgDPcIAAIM0UiEMI0QHPcIAAtKeUEIAAz3GAACiL
+BLgAYSsIXgMnDR4Tz3CAALSnlBCAAAS4x3CAACiLIICIuSCgbguv9YogCQatBY/14HjxwEINj/XP
+dYAA2LQghSV4AKUQhaHBhugB2BClBYURpcoN7/qLcADBz3ABAAh2GwhAAM9wAQC8dQ8JAADPcAEA
+QFwNCQEA8gxgAAHYAN4KDe//wqXPcIAAZEiCDk/+z3CAAHxIdg5P/s9wgADcR24OT/6KIIkG6gqv
+9YbZhgtv/8lwLQWv9aHA8cDhxQh1iiAJBs4Kr/Wpcc9xgADYtACBpngAoQDYEKEFgdIML/8RoQUF
+j/XhxeHGCHX/2c9wqwCg/zmgBNnPcKAAyBwooBbeEfDgeOB44HjgeOB44HjgeOB44HjgeOB44Hjg
+eOB44HjgeGG+jCb/n+31z3GgAMAvE4GA5c8g4gLQIOECE6GA5TzYyiCBDwAAsgyTuJa4l7jAGQAA
+wcbgf8HF4HjxwJIJoAFH2ADaz3GrAKD/WaEH2BqhWKHRwOB+8cDqC4/1CHXPdqAAwC8ahjm4UiAA
+AFMgEAAUhgDfFQjfACoM7/Uk2PK4yiLBIwTySiJAIFEWAJaK6KMWAJYEIIAPAAAAD4wgEIAE9ADe
+A/AB3gQhkU8ABAAAz3AAAAgc6gvP9T+4UiACAAQggE8CAAAA13ACAAAAAdnAeQxwhiA9AIDgSiRA
+AMIkAgETCJ5Bz3CAAMAFAICB4ADYAvQB2M9zgACUQWODEwuRAM93oACsL/yHANsJD58VAdvlvcog
+YSARCBAg5r3KImEgCQoRIADYIvDjvcohYSD5CRCg5L3KImEAdurivcomYRBy7uG9yiFhAG7p4L3K
+JGEA1QwQgOe9yiBhAGboUSUAksojYQBg6wHYMQOv9Q944HjxwOHFz3EDAEANz3CgAKggLaDPcaAA
+wC8UgfC4FIEM8gQggA8IAAAA13AIAAAAAdjAeAfwhiB/D4LgAdjAeL0IEQAVEQCGoLgVGRiAEfDP
+cKAAqCANgOTgz3WgAKwvjfcchY0IXwYMdIQkwp9A9FrYnf9v6ELwiiAJBoIIr/WKIUkMz3GgANQL
+O4FyCK/1iiAJBixxZgiv9YogCQY5hV4Ir/WKIAkGigrv9STYCHFOCK/1iiAJBnoK7/WKIAkDCHE6
+CK/1iiAJBut1Zgrv9STYuHDPcKAA1AtsEAQABdgKIcAPqXIxB2/0iiMJDs9xoADMKxKBgLgSoVkC
+j/XgfuB44H7gePHAiiCJBvIPb/WKIUwGjghv/wDYyQXP//HAz3AAAAgcCgrv9aHBHwjeB89woAAs
+IBCABNl82j3bQMCLcK4Lr/UXu6HA0cDgfvHA4cXPcIAAwAUAEAQAz3CAANi0TCTAgcwkIoAK8hQQ
+BQAKIcAP63IF2KEGb/T82wDdpaCKIIkGdg9v9YohRAASCG//qXDBAY/14HjxwEIJj/XPcIAAaLEI
+gM93gADYtADdLQjfAYogSQdGD2/16NkC3uIPL//JcMWnz3GAAIxHsKGxoRDYCaGnoQvwpaeKIIkG
+Hg9v9fHZug8v/6lwWQGP9eB48cDmCK/1AdvPcIAAjEcAgM9ygAAwtcG4g+DBgsB7Dw5REM9wgAD0
+R8eAz3CAAMRIAIBCIACAyiBiAIMIEQDPcYAA2LQMgYDgzCMhgDf0AoLPc6AAsB/7gza4Nr/xcNYn
+jR8AAIAAQIK1gQAiEAD9ZRsNBRQKIcAP63IF2IojBAoKJAAEoQVv9Lh1i+4KIcAP63IF2IojxAr0
+8QAgkCP/DQWU/maKIEkGYg5v9YohxAwCIIAjbgqv/wHZkQCP9eB48cAiCI/1CHaKIP8PAKbPcIAA
+2LQKgIDgyiUhEWnyz3CAAEwQGIgvCBEBfgoAAACmz3GAAMQFQIEhgVYiQgsU4VlhMHAB2MIgDgAT
+eFMgTQBP8Lz/z3CAAGRIAIDPd4AA9EdCIBGAvgkgAMohYiAAps9xoACwH7uBKYdAJxATz3KAAKi0
+8CBBIEWCYbkFKn4A1b0ndYIlgRFIJQ0QEHXKJQYQT/fPcIAAZEgeCW/+SiFAIM9wgAB8SA4JT/6g
+ps9xgADEBQCBIYFWIEALFOE4YBB1Ad3CJU4Ts31TJU2QCfIPCVEgCYfeC6//8CAAIJUHb/WpcPHA
+Ng9P9c9wgABMEBiIz3aAANi0KwgRAQqGAdqA4ACGwHoB2YDgz3CAAKi0BoDAeYDgzCIhgMwhIoBZ
+8l/wz3CgACwgsIAShgDaAiUBkOOGyiJvALF3CYYQAC8A+2ACJc8QgOcA38P2Ad8XDkVwAEAAAAfq
+AiWBH04AASAypgIlwRAXDkVwAEAAAAfvAiWBH04AASAjpiKGEukhhjhgEQhFABkIRQMRDUQQCPAJ
+DUQQCQhFAwDZA/AB2SKmAIbPdYAAqLSmhYDgAdjAeIDhAdnAeYYlfx4A2wkNkBGqhoPtAduA58wi
+IoAD9ADYCPCA48whIoDMICKA+fMB2KEGT/XxwJhwz3CAACzKCYDPcYAA2LQluMC4CqG6/wXoiHCJ
+/oPoANgC8AHYFQLP//HAocEA2M9ygADYtE0SgQBAwItwHwlRAM9xoAAsIDCBVIJCeQ8ORXBOAAAg
+PgrP/gPwPgnP/hEIkQCKIP8PocDRwOB+z3CAAMRGA4AggADAIniA4MogLADz8eB4z3KgACwgUIIi
+es9xgADEBRV5AIETCIUAz3CAACzKCYAHCF4BQKHgfuHFiiH/D89woACwHxuAz3WAAMRGY4Vgg6aF
+1biA5QDaBvIihWJ5gOHKIYwACSEAAIIggQFIIAAA4H/BxfHAPg1P9Tpwz3CAANi0B4BKIkAgwLiB
+4M9wgACUQSmIwiKCJAkJUAAA2Bzwz3GAAKRBIIF66QwQBABMJICAyiHCD8oiwgfKIGIByiOCDwAA
+7gA0AmL0yiXCADYOb/hKcBpwiiBJBgYLb/VU2YogyQn6Cm/1KnHPcKAAtA8A3tygD8gEIIAP/v//
+Aw8aGDAPyIe4DxoYMBIIIAIc3UTYz3egAMgfSR8YkBHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HhhvYwl/5/t9c91oADALxOFFwifBoogSQaKCm/1a9n2DSACSnDWD6//SnDPcZ8AuP9d
+gc9wgADMBUCg3aEc2hTwz3CgAMg7NoBEIQIHNoB2gIYh/wglekUXARaGI/8I5OFEACUAZXrt6kIJ
+z/9RFQCWhugMdIQkwp8h8heFPwhfBs9wgAAwBwCAMwhfAAohwA/rcgokAAhRFQWWBdghAW/0hts4
+EAQAWBAFAAohwA/rcgXYCQFv9C/bSQpRIIogSQbiCW/1jtkQhS0IHwDPcYAAMJIEkQ0IUQELiRkI
+kABAFQQQCiHAD+tyBdiU29EAb/S4c4ogEAERpRCF/wgfgBSFq7gUpU8gQCacuBmlz3CgAMgfGBAB
+hqG5GBhYgIohEAAxoAnZCLkvoBOFqbgTpc9wgADYtAeANQjRAM9wgADEBQCAViBACwIhAaAYAA8A
+CiHAD+tyBdi720okAABhAG/0uHMSaZ+4iB0AEOoKD/6AHYATz3CAAMwFWQNv9cGg8cD2Ck/1z3Wg
+AMAvgBUPEFwVEBDahYgVERDPcIAA2LQHgEoiQCDAuIHgz3CAAMwFAYDCIoIk4LjK9IC4z3GAAMwF
+AaGKIAkN2ghv9eXZiiAJDdIIb/VBL4EQiiAJDcYIb/UKcYogCQ26CG/1yXGKIAkNsghv9SpxMIWq
+CG/1iiAJDTOFnghv9YogCQ0LDh4XEIULCB8AANgC8AHYLyAHIH0KECCKIAkNeghv9frZMIVyCG/1
+iiAJDRCFHQifAkAVBBBMFQUQCiHAD+tyBdhxBy/0/dvPdqAAyB8g3ycIUSCKIBABEaXwpgrYQx4Y
+EADYAg5v9Y248aYwhSoIb/WKIAkNiiAQABKl8KYF2EMeGBAA2OINb/WNuPGmEfAQhR8IngJAFQQQ
+TBUFEAohwA/rcgXYDQcv9IojBAQThR8KECAxCJ4GCiHAD+tyBdil20okAADtBi/0CiUAAfq4yiHB
+D8oiwQfKI4EPAACpAAXY8fMH2M92oADIHxkeGJAB2AhxCHIIc44NL/SYcM4Jr/VU2BUIHwHPcIAA
+zAUggM9wnwC4/z2ggBUPECK/Pgkv/ulwz3GAAMCTDYH4YA2hANiAHQAQiB0AEAnYCLgOpoUBT/Xx
+wC4JT/XPcIAA2LQHgEogQCDAuIHgz3GAAMwFAYHCIAIkhQhfAIG4AaHPdqAAwC8Thg0IngYThrq4
+E6YC2BGmz3CAADCSAJDPdaAAyB8lCBECIN/wpQrYQx0YEADYxgxv9Y248aUJ8EUVABbk4J73EIb5
+CB6ArgyP/74JIAIKcBUWAJaAuBUeGJCKINAHxg4v9YohBQ7SDEABig/P+QnYCLgOpe0AT/VcFgQQ
+QBYFEAohwA/rcgXYtQUv9IojBQrxwF4IT/WhwTpwKHVIdppzCiMAIQoiQCHIdwogwCGKIBkCcg4v
+9QvBLMAoFAUwCugqcKlxyXIKc7YJIACYdxHwABxAMSpwqXHJcopzCiTABAolgATYdyoIIAAKJwAE
+VQBv9aHA4H7gePHACHEmDi/1iiBZAdYIj/rRwOB+8cDSDw/1OnD6cRpyWnMKIAAxCiRAIQojgCEK
+JcAhCiDAhM9xgAA0i8ogYgAIcgS4CGFMJwCgBLiGIP4DBSCWAMohzA/KIswHyiBsAcojjA8AAEQA
+yiRsANgELPTKJcwFz3WAAMxiAYUA3slxgghv9TjaIIUc2AChAYUY2SCwanGEKQsMACGPf4AALMo3
+hxAYggUzGIIDz3aAANQFIaDJcSKgCiHAhCgYQAUxGMIFMhjCBTQYBATKIWIAFguv9QzgIYUM2BKp
+A4EdCF8CDInPcoAAbHbDuBx4CmLPcIAA0MpIYAypDQsRIM9wgADwsAXwz3CAABCxA6XPcgAASBFA
+sBjaQqULCVAgiiIFAkCwDcKE6s9yAQBA7kGmtRcCFiMKHgAa2kCxQqVAkIe6QLATChAgz3CAAIxH
+BIAzGQIAKwgQMAGBmLgBoQOBn7gDoc9xgAB0BwAZBAUgh0GHz3CAAHgHIKBBoFoOb/qpcKkGD/Xx
+wHoOD/WhwQh2WnE6chpziHeiD6/+qHWA4MwmIpAK8s9wgADYtK+gXghv9APYDfBAxclwSnEqcgDb
+mHO4c9h3CicABJP/kQYv9aHA8cDhxc91gADcBRLpJoWN6QClKghv9A3Y5giv/4ogCAAB2AalDvAg
+hSV4C/AiCG/0DdhWCa//iiAIAADYBqUApXEGD/XxwPIND/UIdgDf6XDpcez/A9jpdRpwCe4TbRR4
+x3CAABBJcg/P/QnuE20UeMdwgABYSWIPz/1CIEAg3Qh1gAHlz3CAAEC16XSdsDC8nrDPcIAA3AX+
+CCAB4KD9BQ/14HjxwIYND/XPcYAAtAYAgaC4AKEB2OP/z3CAAEC1AIAbCBQBCiHAD+tyBdjs25hz
+pQIv9EolAADhCHQAAN7Pd4AA3AXPcIAArHzVeCCAs24DgCKnA6cUbgAggQ+AAEC1R5EGkRC6RXhF
+kRpwBJEQukV4Q5FacAKRELpFeDpwRgvv/QpxIod6cLR9ACWAH4AAHEkgoCIOb/4qcAhxACWAH4AA
+EEnyDs/9CwiEJFMKESAjh7NutH0AJYAfgABkSSCg9g1v/mpwCHEAJYAfgABYScYOz/2KIEwN4gov
+9YohhAKKIEwN1gov9WpxHw7UEAohwA/rcgXYiiMEA5rxiiBMDboKL/WKIQQEz3CAAEC1AIAB5jMO
+BJDJBA/18cDPcIAAQLUCCW/1Ddm6CE/1tv/RwOB+8cBiDA/1CHaKIEwLegov9clxg+bKIcYPyiLG
+B8ogZgHKI4YPAACdAcokxgB0ASb0yiUmABRuz3eAAEC1+GBFkCSQELpFeRpwhwkQAM9wgACsfNV4
+IIDPcoAA3AUDgCSis24ForR9ACWAH4AArEkGEAIhIKAEEAAhELoKDW/+RXgIcQAlgB+AAKBJ2g3P
+/c9wgADcBSWAACWAH4AA9EkGEAIhDhADISCgBBAAIQwQASEQuhC7RXjeCe/9ZXnGDE/+CHEAJYAf
+gADoSZoNz/1elx2XANkPIYEDELpFeAYgQIAB3R23MLgetxf0z3GAALQGAIGguM4O4AAAoc9woACw
+HxuAsqcM2ZbaEadWJwASHttqDS/1GLsQ2s9xgADcBQCB2HpGeKEDL/UAoeB48cA+Cw/1z3aAANwF
+AN0L8BDYuHgLIQCAvA7i/8ogQgMB5fEN9JAghoDhyiAhANQM4f/KIQEAdQMP9eB48cAA2c9ygABA
+tSCiz3CAALQGIKA9sjC5PrI+8fHA4cUA3c9wgADcBaCgz3CAALQGoKDPcIAAQLWpdJ2wMLyesKlw
+Mv+pcKlxH/8tAw/14HjxwK4KD/UA3891gABAtT6VDycPEB2VELkleAYg/oM/9M9xgAC0BgCBgLgA
+oc9wgAC4Bs9xgAC0nQCQVok3CgEAz3CAALoGAJBUiSsKAQDPcIAAvAYAiDKJGwkBAA/IBCCAD/7/
+/wMPGhgwD8iHuA8aGDDPcKAAsB8bgADeDNmW2hCl0qVWJQASHts6DC/1GLsB2MlxAgugAoDaPpUd
+lRC5JXjleB21MLhtAi/1HrXgeKjx4HgIcQDY/PHgeAhxAdj48eB4CHEC2PTx4HjxwOHFz3GAAEC1
+fpFdkRC7ZXoB3RcKDwADuBR4x3CAABBJXgvP/alwAvAA2C0CD/XxwOHFKHXz/4DgyiBBA2wL4f/K
+IWEAFQIP9eB4CHIA2BDZ8PEIcgHYINns8QhyAthA2ejx8cDhxc91gADctiCNjCHDjwnyB+jPcIAA
+MEoCC8/9/9gArc9wgACEtgDdtaDPcIAAgAWgoM9xgAC0BgCBorieDOAAAKGpcL4I4ACpcakBD/Xx
+wOHFz3GgALAfO4FCD+/0iiDMDc9wgAB0BgCABCC+jwDAAAAI9M9wgADctgCIjCDDjwTyAdjf/891
+gACMtalweg0v9VLZog7AA6OFiiBMDv4O7/SpcSIND/WKIIwO8g7v9HLZ5glv/qlwCHHPcIAAMEq6
+Cs/9/tnPcIAA3LYpAS/1IKj/2c9wgADctiCoANnPcIAAhLbgfzWg4HjPcoAAtJ12is9xgAD4BVSK
+YbEBoUCxKHAI2XPaHtuJAi/1GLvxwOHFz3GAAIy1QYnPdYAAgAXPc4AAtAYggwfqAdgApYK5IKMI
+8ADaQKWiuYDgIKOYC8IAANi+D6AACHEA2Oj/pQAP9fHAz3CAAEwQCYBRIECByiBiAEQJYgPKISIA
+z3GAALgGiiCMDCYO7/QgkQHY5P/RwOB+4HjxwPoP7/SKIgQOz3WAAIy1z3aAALSdQCUAFFoNL/VA
+JgEWAYUihSGmIZUApjauII0EIIAPAAYAAIDgAdjAeDSuEq4A2c9wgADqBxYPIAAgqIoIgAIE6ADY
+zP8i8M9xoACwHzuBsg3v9IogTAwqDi/0AtjPcYAATBBIgTSRUyIAANIK7/QB24ogjA6ODe/0utkA
+2Z65z3CAAHQGIKDJB8/08cDhxQh1/9nPcIAA3LYgqG8gQwDGDqAAAdnPcaAAsB87gVYN7/SKIMwN
+BYUDgEKFIICKIIgAQg3v9EJ5kQfP9IDg8cAP2AnyDgkP9M4Jb/+A2NHA4H4WCQ/0Sgpv/4DY6g8P
+/g0IkQACCi/+ANjz8fHx4HjxwMoO7/SKIMwOosH2DO/0iiHFBotwWgsv9QLZAxSPMILnyiHKD8oi
+ygfKIGoByiOKDwAAbAHKJCoA5APq88olygACFIAwz3aAAAAGhC8GHwAUEDEkHgIQz3CAAIS4ACBB
+DjSJCiVALkAgEgUAIFQOG+mKIEwNjgzv9IohRQ6KIEwNggzv9Olx4g8v9UIggCEB2BO2/9glHgIQ
+QCYAGW4PL/UE2WbwSiMAICYexBQlHsITz3WAAOC2QCUREqJ1i3CpcVYLL/UC2kAlABI+DC/1QiCB
+IQAlgS+AAOC2AoHPcYAAqLQlgdW4MHDKIcYPyiLGB8ogZgHKI4YPAACKAcokxgQcA+bzyiXGBOIL
+4APpcEokgHBqcaggwAOEKQYPL3AyIgIgBuowIQIgAoVLCgAAAeFAJgAZ1g4v9QTZAdkUHEIgbRUA
+FoC4bR0YEChwoP+KIEwNrgvv9IohhgiKIEwNogvv9CKFiiBMDZoL7/TpcakF7/SiwAohwA/rcgXY
+iiOGBUokAACZAu/zCiUAAeB48cDPcYAAAAYDoUoP7/MQ2AYIb/+KIAQAG/HgePHAMg3P9AAWDkCh
+wYLmyiHGD8oixgfKIGYByiOGDwAAfQXKJMYATALm88olJgBAxot36XAqDi/1BNmKIMwKGgvv9Mlx
+hC4GHwogQC4AIY1/gADcuGDcfg6v/QIlABPPcIAA4LbeEAAGIQ4AELwVgJAj6OlwBNmZ2h7b0g7v
+9Bi7ANi8HQKQGfAAIIEvgABUuBCBgbgQoc9wgAAABjSAAdoE6USgBNgI8ADZMKAqoEugJKAF2Mz/
+4QTv9KHAoQbv8xDY4HjxwOHFz3WAAAAGFYWf6FoND/6C4HAP4f3KICEAAdgVpWYO7/MQ2HYO7/MP
+2BalCOhWDu/zD9iKDy//gNjPcQEA+J0B2BYNYAKA2qEEz/TgePHAHgzP9M91gAAABjQVEBCMIMOv
+CPKKIAwNKgrv9IohRwIg8IDgyiHBD8oiwQfKIGEByiOBDwAAzgHKJCEAIAHh88olAQQIcYIhBgfP
+cIAA4LYOIEAA2giv/YohBg8acM9wgABEukWAjCLDj//ZBvI4GAAELaUI8BQYAAQA2ASlLaXM//0D
+z/TxwOHFCHWEKAYPz3KAAOC2ACJBDm0RAAbPc4AAAAaguG0ZGAACgwSIE+gDgYDgyiHBD8oiwQfK
+IGEByiOBDwAARAfKJCEAkADh88olwQACgZLo3hIABowgw48K8s9woACwHxuAAqHnGlgDEfCtowDY
+wv8N8EIMD/6ELQYfCHEAIYB/gAB8uBINj/2JA8/04HjxwA4L7/QC2ADdCHbPcIAAlLiELQYfMCBA
+DlEgAIBUD+L/yiBCAwlu4wh1gAHlANjx/kkDz/TgePHA4cXPdYAAAAYjhc9wgACoTvAgQABAeHno
+MQPP9OB4z3CgAAREB4CA4AHY4H/AeM9zoACoIDGDz3KAAEhKA4I4YAOiAdgSo+B+4HjPcqAALCBm
+gs9xgAAABhOBYngToRCCEqHm8eB44cXPcqAAyB+kEgMAz3GAAAAGEoEQc8IjBgBE92J4E3u/ghOB
+u2N4YBOhAdhKGhgA4H/BxfHANgrv9ADbz3CAAAAGY6D/2s9wgADgtt4YmABKJIBwaHWoIAAIhC0G
+HwAhgX+AANy4z3eAAMRGoBnAgAbesBmAg892AQAoi6wZgIO0GcCDvBnCgAAhgX+AAJS4YKEB5c9w
+gADgtucYmADPcYAAxE4AgRzaQKAY2NIIoAACoSECz/TgeAHaz3GAAEhKQ6kYoShwZNl12h7bsQPv
+9Bi74HjxwJIJz/TPd4AA4LbnFw0WjCXDny/y/9nnH1gQhC0GH6CgJ3cEjwogQC6R6AKHz3GAAHwG
+jg9v/SCBCHHPdqAAyB8VhpoND/6D6AHYFPDPcYAASEoCj6CpAakB2BOmHIYBoQHY4P8A2AAggS+A
+AJi4AKkA2IEBz/TxwCIJ7/QB2qHBz3GAALAGQKFPCFEAz3WAAES6BYWMIMOPCvIA2oQoBg8AIYF/
+gACYuECpz3aAAAAGEIYF6A+Gy/8A2BCm/9gFpYtwz/8J6CoMgAAAwA2mANgp/xHw1grv8xDYFgyA
+AAIML/+KIAQAogkP/oLgvAvh/cogIQARAe/0ocDxwJYI7/T/2s9wgADgtt4YmADnGJgAAN7PcYAA
+AAbDoU2hAdrPcIAAsAZAoNCh1aHWodShwKHBoQLdyXCEKAYPGnAAIYF/gABUuBCBACGPf4AA3Lhg
+3EYgwAAQodoJr/0CJwATYb28H4KT1Q11kEAgQCAB2ML/hQDP9OB4ANjPcYAASEoDqc9wgAAABkiA
+AoBCqRzgVnhEiEmpBYjgfwqp8cD6D6/0iiAMCc91gAAABiSFCg6P9ASFhQgRAM93gADgtt4XAhYA
+3oQqBg8AJ0AeAqUkiAHbz6VwpSLp6B+YEwwQBQDPcYAAqLQEJYQPwP8AABQRBgBBLAQGBS4+AQAh
+hH8/AP//BCRBAekfWBAgkIwhgoYB2cIhTgAupcilJIDPdoAAKLrAuTq2z3aAAEhKKK5ArgKIZKUB
+rh7wBIU5CFEAz/8A2ASlAoUkiJLpKIUc4DZ4JIjPcIAAtJ0WiBBxAdnAec9wgACwBiCgAtgD8AHY
+A6WNB6/0AdjgePHAz3KAAAAGAoIliAHYBukI2S+ie/8I8M9xgACwBjYKoAAAofcHj//xwPYOr/SK
+IEwJz3aAAAAGJIYGDa/0pMEEhoDgnvQChkiGJIBWeM9ygAC0nQQhgQ8ABgAAgOEB2XaKIBCNAMB5
+Ew3BEM93gAAouvqXtIoLDcATAN0F8LKK+wlBgwHdz3GAALAGoKGW7c9xgAC4BiCRIQtBAM9xgAC6
+BiCRdIoVC0EAz3GAALwGIIlSigkKQAAA2QPwAdm5CRAAJ4DPcIAARLotoM9wgAAwtUGAz3CAAKi0
+BYAFKL4AQCmAchBxyiHGD8oixgfKIGYByiOGDwAA/ALKJCYAXAOm88olJgDPcIAAhAYAgA4Mb/04
+YIPou/9G8A/IBCCAD////wMPGhgwaBaAEADdpaaJ6M9woAAsIBCAx3AHACChGaZkFgcQz3ABAHSd
+QMAF2EHAAd9Cx0PF6XAG2QTaANuYc7hzSg1v/9hzaB5CE+Sm6XAb8ADYAtkjpmgeAhAV8ASGAd0h
+CFEABYaa6M9wgABEui2Az3CAAIQGAIB+C2/9OGAG6AHY4QWv9KTAaB5CE2YNb/8F2ADYBKav8QXY
+D6apcBD/ANhoHgIQ7vHxwFINj/TPdoAAAAYEhqTBi+gkhl4Lr/SKIIwIAoYEiJLoAtgEpgSGjQhR
+AAWGuejPcKAAsB8bgGIJL/47hqzoANgw8ADf5abPdaAAyB8Vhc9xgACEBioLb/0ggRumpBUHEM9w
+AQDQnUDABdhBwAHdQsVDx+lwBtkE2ulzmHe4dwAnhw8HACChWgxv/9h3pKapcC7wtgxv/wXYBNgC
+8AXYAdqE6AHYJPArhiMJUABQpg+mDfAEhjcIkQAkhrYKr/SKIIwIC4YLCFEAAdgN8OzoAobWDe/9
+A4AIcc9wgADcTm4OT/0A2NT+3vEA2Hfx4HjPcoAAAAYigiWJE+nPcYAA4LbeEQMGz3GAAJS4hCsG
+DzAhQQ4LCV8ACNgPogHYC6IA2AqiBKIF2AOi4H7xwCoMr/SKIIwJz3WAAAAGJIU2Co/0BIV5CBEA
+IoVIhUAhAAdWeESIz3CAALgGAJAB3iEKAQDPcIAAugZAkM9wgAAouhqQDQoBAMSlANg98ASJHejP
+cIAAsAYAgJfoz3CAAES6LYDPcIAAhAYAgLYJb/04YIvoiiBMDc4Jr/SKIU0GANjQ/wHYH/DEpQHY
+HfAEhQDeNwhRACKFz3OAAEwQRIEFgRzhSKMJo2iFz3CAACi6GpB2eSSJyg5v9MlzxKUD2AOlAdjR
+A4/0CiHAD+tyBdiKI80OmHaJAK/zuHPgeM9wgADETiCAHNrPc4AAAAZAoUKDVSLBCSGgoBIBAK25
+oBpAAFUjwQWkGkAAnBIBAWiDJKBVIkENI6AA2eoaRABAIgEHdnkliRkJEQjPcYAAuAYgkUh0gCRE
+EyCsHtsD8BjbYqBVIkENeWGlAu/5JaDPcYAASEpAIQADVSHCBREIhQAA2QQYUAD7CISA4H7gePHA
+sgqP9M9wgADgtt4QAwZKIAAgguPKIcYPyiLGB8ogZgHKI4YPAADjB8okBgTEB2bzyiXGAM9ygAAA
+BkiChCsGDydwVningI8JEQDPcIAArEqqC6/0iiEPD89wgABkSpoLr/Qg2c9wpQAIDACAUyBAgBLy
+JQhQACcIkAAKIcAP63IF2AHbi7sKJAAEZQdv8wolAAT/2Qfw/9kIuQPw/9kQuc9yoAC0Rx4aWIAd
+GhiAGxpYgwDZkbnPcKAA0BsxoM9wgAAABBB4SRoYgG8gQwBUGhiAMvDPc6AAtEcbEwCGDegKIcAP
+63IbEwWGBdgQ24u7AQdv8wokAARLGxiEAdh3GxiAANieuFQbGICKJMN/z3OAAMR8CnCoIAAECmPP
+dYAASErPcYAArEpVfUeF8CEBAAHgWWEnpd0Bj/TxwHoJr/SKIAwKo8HPdYAAAAYkhYYPb/QA3gSF
+puiSDEAAAdgEpQKFBIiA4EICAQDPcIAAsAYAgIDgNgICAM9woAAsIAOAz3KAAES6LYIZYc9wgACA
+BgCAOGCiDO/9DKKA4A4CAQBy8ASFeQiRAA6FgODKIcEPyiLBB8ogYQHKI4EPAAClA8okgQMsBmHz
+yiXBAEKFKIVAIgAHNngmiGDBJogBHEIwJogCHEIwJ4hhwSeIBRxCMAeIi3EGHAIwCgvv9KgSAADP
+cKAALCAjgM9wgABISiGgxaVX/wPYBKXJ8ASFbwjRAEKFKIVAIgAHNngFiCcIXgEDks9xoAAsICOB
+z3OAAEhKYYMKuGJ5CwkEAAnYD6WF8AWFjOgEioDgqfLPcIAARLrWC+/9DICA4KHyBYUG6AXYD6UB
+2Anwz3CAALAGAICA4JX0ANj0/pHwBIXVCFEAVP8ihUiFQCEAB1Z4RYgzCh4Ag7pFqM9ygABMkseC
+z3OAAES6x6P3gsOC/mbIo/aCwoL+ZsmjwYJVgl5myqMFiFkIXgDeCo/9gODKIcEPyiLBB8ogYQHK
+I4EPAAD3A8okIQAABWHzyiUBAdIKr/0C2AILr/0I2CKFBIkXCJEAAdgApQDYE6XuCq/9WtgihQSJ
+CQhRAAHYAaUIhRzhFnkFiYYg/4zKIIIPAAAwQ8QM4v/KISIAAoUohRzgNngFiIYg/ocF8gLYBKUp
+8ATYBKUn8CSFAdhHCREBFKXPd6AAyB88h89wgABISiGgXg1v9IogDArPcIAASEoM2XXaHts+Ca/0
+GLsVh89xgACIBkYNL/0ggQelxKUE2AOlAdhxB2/0o8DgePHA/g5P9M91gAAABgSFzQgRAAKFBIgS
+6M9wgACwBgCAjOjPcIAARLpaCu/9DIAG6ADYnP4TAwAAz3agAMgfPIbPcIAASEoBgEiFAnkChVZ4
+B4APCQQAAdgEpe8CAAAAhQnoEwteQALYFR4YkOIJr/0e2BWGz3WAAAAG0grv/SeFgODGAgEAFYbP
+cYAAiAaiDC/9IIEHpQKFKIUc4DZ4BYiGIP+MCPLPcAAAMEPPcYAAZErn/gKFKIUc4DZ4BYhRIECA
+hgIBAACFBegfhoDgegICAOT8cwIAAASFgeCH9CSFQgxv9IogTArPcaAALCAjgTIMb/SKIEwKAoUo
+hRzgNngFEIYAAN7UpXkOHgDPcoAASErPcIAATJJ2gCKAeWHPc4AARLrpg9iqVBAEAAQQBQAAJQUB
+KBMEAOJ5AiUFAeeDHBAEAAIkxINogwOAYnjKJ4ETBPIB3/iqDelALIMADQnEAE8ngBAF8AXoTydA
+EA9/GKpBKcAAOGAJCEUBgr/4qk8OXgAAhQ7oz3GgACwgJoEThSJ4z3GAAEhKBaHApQXwAYUD6MGl
+r/xODo/9HQiQAAohwA/rcgXYiiOTCUokAAB9Am/zCiUAAU4Ir/0A2AKFKIUc4DZ4BYiGIP+MBPIC
+2ASls/AE2ASlr/AEhRcIkQDPcAAAMEPPcYAAZEqU/gTYBKUEhYTgpPQkhRoLb/SKIEwKz3CgACwg
+I4DPcIAASEpAIBAHN6D+Cm/0iiCMDSKFIBUEEEAhAAcWIAABBYgA3j0IHgBKJMBwyXLJc6gggAHw
+IMAgAeMaYgPfSiRAcQDbqCCAAfAgwCMB5xtjEQrFAM9ygABIShiKgrgYqs9wgABEus+gTJFAJEAA
+EQilAAilbREABg0IXgAB2BClAf5V8A+FrPwPyAQggA////8DDxoYMM+lDP2KIEwNagpv9Ioh1AoI
+hSKFFnmKIEwNVgpv9CeBAtgDpQKFz3KAALAGJIiO6SiFHOA2eCSIz3CAALSdFogQcQHYwHgAoibw
+IIIF6QHYA6Ug8CiFNngngM9wgABEui2gz3CAADC1QYDPcIAAqLQFgAUovgBAKYByEHHKIcYPyiLG
+B8ojhg8AAEEFgAbm/wXYxKUdBG/0AdgKIcAP63IF2IojFQNKJIAA4QBv87hz4HjxwJ4LT/TPdYAA
+AAYEhaHBgQgRACSFqglv9IogjAoB3s9wgACwBsCgANgUpSqFAaUApQLanenPcIAAtJ3Pd4AAuAbg
+l3aIJwvBA893gAC6BuCXdIgXC8EDcojPcIAAvAYAiAsLAQBEpQPwyqXJcSMJUQDOCa/zAtjPcoAA
+tJ0UijaKQIJ2Di/0AdvEpZrwRKUEhRUIUQAkhSYJb/SKIIwKAtgEpQSFZQiRACSFEglv9IogjArP
+cYAAuAaKIIwMAglv9CCRz3GAALoGiiDMDPIIb/QgkQKFBIgW6AuFlOjPcoAARLowgg+CDiGDDwcA
+IKERCwUAB9gPpQHYEKULpQTwOGAPogPYXfAEhSMI0QAkha4Ib/SKIIwKD8gEIIAP////Aw8aGDAE
+2EvwBIU9CBEBJIWOCG/0iiCMClMgwECWDSAAHKXPcIAA4LbeEAEGz3CAAJS4hCkGDzAgQA5RIECA
+BdjKIKEBLfAEhUMIUQHPdoAA4LbeFgAWBNmZ2h7bQMCLcDIMb/QYu94WABaEKAYPACGAf4AAVLgw
+gKG5MKAB2AulBtgEpQDYDfAEhRUIkQEG2AOlHIWA4MogYgAbeASlAdhFAm/0ocDPcIAAaLEogM9y
+gAAABi94FwhRAADbz3CgALQPfKAC2AOiZKID8AHYBaLNBy/0iiDMCOB4z3CAAES6OYDPcoAAAAYv
+eAsIUQAE2ASiA/AB2AWipQcv9IogzAjgeM9wgABosSiAz3KAAAAGL3gLCFEAAtgEogPwAdgFon0H
+L/SKIMwI4HjxwFYJb/SKIEwNag8v9IohmAEPyADeBCCAD////wMPGhgw4gtv/8lwz3WAAAAGFoWA
+4AwKYv/KIGIAiQFv9NWlAdnPcIAAAAYkoJkET//gePHAWghP/wIOD//GDk//0cDgfuB4OdnPcKUA
+CAw+oOB+8cDhxQDdyglv/6lwWg8v/6lwOgiP/+4ND//PcIAAgAU5AW/0oKDgePHAz3GAAHQGAIER
+CIEPAIAAALYIT//Z8QCBIQiBDwBAAADPcaAAsB87gbIOL/SKIEwMYghP/8nxx/HgePHAgghP9M91
+gAB0Bg3pAKUBhZToagpv8w7YKguv/gjYAdgBpQrwAN7ApWoKb/MO2JoLr/4I2MGltQBP9PHAz3AA
+ACBOkg7v/OHFz3WAAHwGAKXPcAAAuAsBpc9wAACIE3YOz/wCpc9wDwBAQmoOz/wDpQXYYg7v/Au4
+fQBv9ASl8cDPcIAAkAYDgJroGgpv8xXYlujPcIAAMJIHiBDoz3CAALgEYIDPcQEA2KEL2GB7BNrO
+CW/zFdjRwOB+z3GAACzKCYENCF8BxREABhMIXgFWD2/2E9hSD2/2Edju8e7x8cCaDy/0B9gWDQAA
+z3agALQP/IYacADYHKbPcaAALCAwgZ4NL/SKIJEFHghAAc91gACQBvoMIAEApUCFz3GAAMCTAaVF
+oQ4OIAMGofymUg4gAApwEY1LCFEAQIWKIEQEz3WAAPROI4UaYjhgEHIB2MIgDgAO6IogEQtGDS/0
+ANm2C+ABBNgAhZ4MIAEDpQfwtgvgAQTYAoUDpVoKwAFhBw/04HjxwP4OD/TW/891gACQBtoKYAEH
+hQh2B4UXDgAQRgrgAMlwQgkv98eleg5v9hHY+gsAAc9woAAsIBCAMQcv9AKl8cChwe//z3CAAJAG
+AIAE2WLaHttAwItwtghv9Bi7ocDRwOB+8cDhxc91gACQBhCNjCDDjw70z3CAAARPJYAjgSCBx3EP
+AACgbggP/f7YEK3hBg/08cDhxc91gACQBgaFG3gyDe/8IoUE6AHYEa2U/8EGD/TxwP/Zz3CAAJAG
+MKjp//X/OPHgePHAMg4P9Ah3fdgNuM9xgACotMWBCgvv/MlxjCACgM9xgACQBgDdh/cdeIwgAoAB
+5Xz3AChCAwUqvgMYGUAOFrgFoYTv/9gQqRCJjCDDj1APwf9JBg/04HjgfuB48cDaDQ/0z3WAAPRO
+AoUjhQHeEHHAfqlwSgpv9APZAgpP9ATuAoUD8ACFHQYv9AOl8cC6Dy/zFdip/89xgAAsygmBDwhf
+AcURAAYNCF4BMg1v9hPYz3CAALwEIIBgeQvYsQXP//HAhg8v8xXYpQXv/wDY4HiA4AHZwHnPcIAA
+kAbgfyOg4H7geM9ygACwBmGCZXgBohDpz3GAALSdBJJ2iSsLAQAFknSJIwsBAAyKMokbCQEAD8gE
+IIAP/v//Aw8aGDAPyIe4DxoYMOB+z3KAALSdz3GAALAGBJF2ihkLAQAFkXSKEQsBAAyJUooJCgEA
+AYED8ADY4H7PcoAAsAYhggZ54H8houB4z3GAALAGAIEJ6AGBi+gPyAUggA8BAAD8A/APyJC4DxoY
+MBkGD/zgePHAz3CAAHzHAIBXCF8Awg4v8xDYo+jPcoAAtJ3PcYAAsAYEkXaKJwsBAAWRdIofCwEA
+DIlSihcKAQABgYvoD8gFIIAPAQAA/APwD8iQuA8aGDDCDQ/80cDgfuD//fH98Q/IkLgPGhgwqQUP
+/PHAHg2AAQjoz3CAACgHAIAPCJEBz3CAALAGAICD6ADYAvAB2OPx4HjxwAIMD/QIdwQikw8ABgAA
+TCMAoAHdwH0EIoAPQAAAANdwQAAAAEoiQCDPdoAAdLsYjsIigiQacRENARCE7RmOCQiBBADYA/AB
+2C8hByDpcFIM4ACpcSCGANgRD0EQIYYSccwhIaAD8gHYLyYH8BquOfIA2c9woAC0Dzyghg9P/ulw
+CnGpcp4LoAFKc6YLIACpcNL/huiuDwAATgpP/QTwdgpP/S4KAAMBhs91gACwBgS1AIYFtRiODK1W
+CiADSnAElc9ygABMECWVFLIIgoDh0CAhAM8gIgC5uLq4BSDABAiieQMP9OB48cAmCw/0z3WgALQP
+cBUQEM9wgABMEAmAosEA3hkIXgEKIcAP63IF2KnbiiTDDzkAL/O4dot36XB+Dy/0Atncpc9xqwCg
+/9mhB9gaodihABQAMQIUATFEIAICQiICgkEowwDKImIAwLjSCqABwLsAFAAxhiD/DUIgAILSCiAA
+yiBiAHAdABRBxulwygtv9AjZ+QIv9KLA4HgA2c9wgAB0uyGg4QTv9iKg4cXhxs9xoADIHMiBCKEG
+3RHw4HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HhhvYwl/5/t9clwwcbgf8HF4HjPcqwA
+1AEA2a0aWICoGliAWNvPcIAAMJLoGsCAAJCH4MwgIoID8uwawICBGtgAgNuCGtgABduDGtgAc9u+
+GtiAdNsIGsCAGBpAgL8a2IB32wwawIAD2xwawIAH27wa2IAAGsCAf9sQGkCAvRrYgAQawIAUGkCA
+qhpYgKsaWIAB26waWICTGtiAKdvwGsCAqtt1GtgACtt2GtgAeNvUGkCAmBrYgCfbmRrYgCDbmhrY
+gIfgAdvAe4jgAdjAeAUg/oAE8gLYmxoYgH4aWAB/GlgAgBpYAOB+4HjPcAAAAT/PcaoA8EMFoc9w
+AAA+PQahz3IAAD09R6GKIMwPCKEJ2Iy4CaHPcAAAFhwKoc9wAAAfHwuhz3AAABwWDKGR2AS4DaHP
+cAAAAz8OoU+hz3AAAD0+EKGKIMQPEaHgfuB44cXPcaAAyBwIoQbdEfDgeOB44HjgeOB44HjgeOB4
+4HjgeOB44HjgeOB44HjgeGG9jCX/n+314H/BxeB48cDCCC/0B9gA34//GnCf/892pAC4PawWABbP
+daUA2MuiuKweGBAB2Oyl9h4YEM9wFQArK5oeGBDOCiAA6XCKIMQAnx4YEM9wgAAwkgCQAdmH4MB5
+iOAB2MB4BSB+gBPyGtjzHhgQ9B4YEGTYyB4YEKrYyR4YEGnYzB4YEMDYzR4YEDnZz3ClAAgMPqC1
+/wpwzf8Y2JUeGBDPcYAA9E7hocjYAqEAoQOhz3EBAOihz3CAAPhC1BhAAJTYC6VpAA/08cDPcIAA
+DK9CCS/0iiEEDs9wgAC0nTYJL/SKIQUF0cDgfuB4z3KAADCSJ4qD6SaKCenPcawAkAGA4APYyiCh
+AAWh4H7xwOHFCHUgkAKVQZUQuAV6KdgSuBUgQQBAoSCV8CBBAB0KQAC+De/ziiDRAwKVIZUQuAV5
+rg3v84og0QP9B8/z8cDhxQh1IJAClUGVELgFehXYE7gVIEEAQKEglfAgQQAdCkAAfg3v84og0QMC
+lSGVELgFeW4N7/OKINEDvQfP8/HA4cUIdSCQApVBlRC4BXor2BK4FSBBAEChIJXwIEEAHQpAAD4N
+7/OKINEDApUhlRC4BXkuDe/ziiDRA30Hz/PxwAYPz/ModoDgzCYikA30CiHAD+tyBdiKIwYFiiTD
+Dx0E7/K4c1MmfpDKIcIPyiLCB8ojgg8AAJYByiBiAfD1QYAghqKAWHlAgCR9KdkSuRUhggCgogCA
+8CEBABcNQBDCDO/ziiDRA4og0QO2DO/zqXEBB+/zBG7xwI4Oz/ModoDgzCYikA30CiHAD+tyBdiK
+I4YOiiTDD6UD7/K4c1MmfpDKIcIPyiLCB8ojgg8AALwByiBiAfD1QYAghqKAWHlAgCR9FdkTuRUh
+ggCgogCA8CEBABcNQBBKDO/ziiDRA4og0QM+DO/zqXGJBu/zBG7xwBYOz/MbCHQASHUIdkCFYb5g
+egRtCHH3DnWQEOVlBs/z4HjxwOHFiiBSDgYM7/OB2c91gAAcT6lwQCWBFVILL/QW2gHYRQbv8zEd
+AhDgePHAvg3P8wh2guDKIcYPyiLGB8ogZgHKI4YPAABcAMokJgDcAubyyiXGAM91gAAcTwuFACaP
+H4AAOE8LDgEQFI846AIL7/8F2BpwiiASDpYL7/PJcUQuvhUAJUAeQJAhkAi6RXnPcqQAuD2bGlgA
+IpDKGlgAI5DLGlgAJJDEGlgAJZDGGlgAJpDHGlgAJ5DCGlgAKJDDGlgAKZDFGlgACpCjGhgAHgzv
+/wpwy6UA2BSvcQXP8/HA4cWmwYogkg0mC+/zktmLcIoJL/QG2QAUADGT6EAkgDDPdYAAHE+pcWIK
+L/QW2gHYMB0CEAuFgOAUD+H/yiAhAAAUADEzCFEAiiDSDeIK7/Oj2UAkgDDPdYAAHE9AJYEVKgov
+9BbaAdgrhTEdAhCB4dwOwf/iCA/0DQXv86bA8cCODO/zCHMIdoYj/gNEuwh3hifxH0e/RCCBAzx5
+z3WAAKy6LK0EIIQPAAAADEIsgAIUrQQmhB8AAAAwQiwAAxWtBCaEHwAAAEBTIb6AQiyAA7EdAhAN
+9AohwA/rcgXYWtuKJMMPZQHv8kolAAARjYHgzCAigMwgIoEG9FNpJXpOrU2tgOPMICKBBfJTa2V6
+Ta2A58wgIoEE8hNv5XgOrRNpJXgPrQ2NEK2OCa/4ANhFBO/z37XgeKTx4HjgfuB44H7geOB+4Hjg
+fuB4o8HhxULBCRSBMEPCQcAZCTMBANgRCVIAChSBMAkJUgAHCRIBAdgHFIIwBhSDMBELgAAiwTBz
+zCJCgAP0AdghxSENURAKFIEwI8MZCcMACxSCMFBxzCOqgIT2gOLKIGkAGwhRAIohyQ/PcIAAwAYi
+oIHl/9nKISIAI6DBxeB/o8CjwUDAQcEFFIEwANiB4ULCDfKC4Qfyg+EN9CHBANgPIEAAAxSBMA8g
+QAACFIEwDyBAAAYUgTAhCVAAEwmQACMJ0QAhwQPhDyBAAAMUgTAD4Q8gQAACFIEwA+EPIEAACRSB
+MCEJUQACFIEwCrlPIQIEAxSBMAy5JXohwQ65RXkleCDBFQlRAAcUgTAiwga5CLpFeSV44H+jwNEA
+D/TxwKIKz/MacM9wgACsuhCIz3aAAHS7hiD/ATtoBYYOIECAz3GAADCSJ4nKIGIAIek6joDhzCAh
+gBvyAN0M3xJtFXjHcIAAxFYggAXpAoAW6EB4Yb/rD3WQAeUA2Bquz3CAAKy6EIiGIP8BQ7gFpnoM
+7/8KcJECz/MKIcAP63IF2DvbSiRAAF0Hr/K4c/HAABaFQKbBDQ0zBQAcQjEXDRMCCiHAD+tyBdiI
+2zkHr/JKJEAAABaAQAEcAjAAFoBAAhwCMAAWgEADHAIwi3ACD+AAgcECwovqCiHAD+tyBdiS24ok
+ww/9Bq/yuHMEwGB6BcEDwYDhyiHBD8oiwQfKI4EPAACWAAXY7vMBwIDg4iBCAN4Nz/OmwNHA4H7g
+eOB+4HjxwH4Jz/M6cBt9z3CmAJw/ZBAQAE8IHyAD3hLw4HjgeOB44HjgeOB44HjgeOB44HjgeOB4
+4HjgeOB44Hhhvowm/5/u9WG9jCX/n+H1CiHAD+tyEtha2wokQARpBq/yCiUABH0Bz/PgePHAIgnP
+8891gADQBgKFLwgfAI4Or/8H2E4IYAAIdvoJQAA2C0AAdgtAAC4JQADyD6//yXAChYC4AqVVAc/z
+4HjxwOHFz3WAANAGAoUbCF8Azg2AAKoKD/RaCgACKg7AAAKFgbgCpTEBz/PgePHAtgjP8891gADQ
+BgKFWwifAM9wgAAwkgeIJ+jPc6AAwC8TgwsInwYQgx8IHwD8EwUACiHAD+tyBdiKI0cBsQWv8ook
+wgTuDa//B9jGDeAACHZWDoAArg3AAFoPr//JcAKFgrgCpb0Az/PgePHAz3OgAMAvE4MNCJ8GEIMd
+CB8A/BMFAAohwA/rcgXYiiNHAV0Fr/KKJMIPv//P/89wgAAwkgeIBOgaCEAA1v/RwOB+z3GsANQB
+sREAhqO4sRkYgLIRAIajuLIZGICzEQCGo7izGRiAAtifGRiAoBkYgKEZGIAB2KIZGICjGRiApBkY
+gKUZGICmGRiApxkYgAXY+BkAgPwZAIAAoeB+4HjPcKsAoP84gM9ygADQBiCiOYAA2yGieKB5oD/Z
+OqDgfvHAfg+P8zpwAdjPdqcAFEgIpsoJoAAqcIDgAN8qcAb0SiBAI9j/CPAiCqAAGncKC6AAKnDr
+///Ym7jPdacAmEccpYogEg1iDa/zKnHPcYAAEAUAiYDgyiHCD8oiwgfKIGIByiOCDwAA7QLKJCIA
+VASi8solAgEB2ACp9qYvIAAEgLgapc9woAAsIDCAz3CAABQFTQev8yCg8cDhxaHBuHAA2EDAUyWA
+ACEIUAA7CJAARQgQAQohwA/rcgXYiiOKDgEEr/KKJIMPz3CAADCSBJAB2c91gACLroTgwHnPcAAA
+ItI0eA7wz3AAACPSz3WAAI6uCPDPcAAAJNLPdYAAka4p2RK58CEBAA4hgA8AAQAAZgrgAEDAQMCL
+cKlx5gvv8wPa3Qav86HA8cBaDo/zz3CmAJw/GYCnCB4Az3aAAEwQhBYAEC8oAQBOIJAHQSjQIBEI
+1SAAII0vgAC8EBSNjugKIcAP63IF2IojjAOKJIMPUQOv8golAATPd4AAgK5AJ8ASSg+v8wnZANhS
+CKAADyAABIDgANgPIAAEBPS//wTwVgmAAAPIANm5EIAAG3iAuAqvFI1huA94FK2KIFIN6guv8w8h
+AQSEFgEQz3CAAKyeNqDPcIAAqMoioIoKQAAJBo/z4HjPcQEAjLvPcgEAGLx1BS/0ANjgePHAuHGK
+6AohwA/rcgXY49u5Aq/yiiSDD89xgACQuyCBTCUAgAQhgQ8ABwAAQSkDBgDZyiRNceggrQPwIEUA
+BCWCDwEAAMAuumV6DQuBAAHhOQXP/wohwA/rcgXY7NttAq/ySiRAAOB4z3CAAEwQCIDPcYAAkLsL
+CB4AAYkC8AKJ4H8AqQhxWIkBgAKhiOpZiYDiwiCiAMAgoQACoeB+4HjxwO4Mj/OiwaKBYJDPdoAA
+0Aa4e6OBZH1jhqV7poEBkLh4p4FjpqR4pIZAIQ8EpXgEph3qAYECHMQwMLsEHMQwABwEMCCBi3Vg
+ealwAYckhgIcRDAwuQQcRDAghwAcBDBgealwANgDpgSm7QSv86LA8cBqDI/zocEAFo1AABaPQAAW
+AEHqCa//B9gacILlBtkD9Pt5B+EFzAPhBCGBDwAA/P/XcAAAAEAB2MIgCgAXuMdwAA4AACV4nbif
+uOxxAKECEgE27HAgoOxwoKjPdqAAyB9RFhGWAdlRHliQINgQpkMeWBAA2PoPr/ONuCDYEaaH5ZAB
+DQAyJk1zgADEfUAngHK0eAB4ABYBQAAWAECAuc9woADsJyagpvCA50gBDgAAFgBBABYBQQAcRDAA
+FgFAAgsgAGG/ABQBMQa4gbgQuSV4z3GgAOwnBqHZD1WQjPDscOCogOcQAQ4AABYAQAAWAUDSCiAA
+EHgGuEUgwgDPcKAA7CdGoAqAi3EAsQAUATHscCCwYb/XD1WQbvAAFgBAIg4AAM9xoADsJwuhABYA
+QGLwxQ9UEAAWAEAAFhRAQSgTBBB4fgogAFpwBrhFIMAAz3WgAOwnBqUKhYtxALEAFAAxBiDABAUg
+AAUAHAQwVgogAEpwABQBMQa4gbgQuSV4BqVhv7MPVZA28G0PVBAAFgBBABYBQQAcRDAAFgFAJgog
+AGG/ABQBMQa4RSCAARC5JXjPcaAA7CcGodcPVZAc8DUPVBAAFgBBABYBQQAcRDAAFgFA7gkgAGG/
+ABQBMQa4RSDAARC5JXjPcaAA7CcGodUPVZBRHliUhgmv/wpwog6v8wHYANh0HhiQtQKv86HACiHA
+D+tyBdiKI0YFSiQAAJkHb/IKJQAB8cBKCo/zABaNQAAWkEAAFgBBxg9v/wfYOnCC5QbZBPRAIMEh
+BcwD4QQhgQ8AAPz/13AAAABAAdjCIAoAF7jHcAAOAAAleJ24n7jscQChAhIBNuxwIKDscKCoz3ag
+AMgfURYSlgHYUR4YkCDf8KZDHhgQANjSDa/zjbjxpscNlREzJk1zgADMfUAnAHK0eAB4ABYBQM9w
+oADsJyagSfCTCFQgCiQAdKggQAIAFgFAz3CgAOwnJqA98OxwABgCBHMIVCAKJAB0qCAAAwAWAUDP
+cKAA7CcmoCqA7HAgqCnwABYBQM9woADsJyugI/BMIACgyiQNdOggbQcAFgNABCOBDwAAAP8ouVZp
+RSLNAM9xoADsJwQjgA//AAAApqGqgTC4OLuBugZ9pXsQu2V6RqFRHpiUJgiv/ypwPg2v8wHYaQGP
+8wohwA/rcgXYiiMIB0okAABBBm/yCiUAAeB4AtjPcawA1AGfGRiAoBkYgKEZGIAB2KIZGICjGRiA
+pBkYgKUZGICmGRiApxkYgAXY+BkAgPwZAIAAoeB+4H7geAHZz3CgAMgcMKBL2c9wpAAcQCSg4H7g
+ePHAjgiP8zpwGnFKI0AgwJAk8Ol2IvAVIcAk4JACEBIBQCNTINd3AAD7/y8jyCRz9j8OgB8AAP//
+TCAAoMwmgZ8AAP7/FfJMIECgzCaBnwAA/f8P8hMIkCDPcAAA+/+7DgGQgQCP8/UOgZ8AAPz/z3Wg
+AMgfURUUlgHZUR1YkCDYEKVDHVgQANgKDK/zjbgg2BGlBr+Bv0AqACTleM9xoADsJwahUR0Yldjx
+4HjxwM9wgAAwkkaAKpANCpEAz3CAAFxTBfDPcIAAcE/O/yIOAADSDgAA0cDgfvHA4cXPcYAAMJIE
+kc9ygACQuwDbYKIS6FEIUAB/CJAACiHAD+tyBdiKI8sKSiRAANUEb/JKJQAAB9gYuACiYapiqkok
+wHBocKggwAIA2467FiINAGGlA9sOu2KlAeAD2AaxB7EA2BjwANiZuACiUtgBqkokwHACqqggQAIA
+3Y+9FiLAAKGgoqAB41LYAttmsQHbZ7GtB2/zAKoA2Ji4SiTAcACiqCBAAgDdjr0WIsAAoaCioAHj
+YdgBqlLYAqro8fHACgxgAKHBz3CAADCSR4iA4gDZjvIAHEQwz3OgAMAvM4MNCZ8GMIMdCR8A/BMF
+AAohwA/rcgXYiiNHAQkEb/KKJEwAA9vPcqAA7CdmomqCi3FgsQAUBTGodIQkA5DKIcIPyiLCB8og
+YgHKI4IPAAAIA9QDYvLKJGIARCUDDES7ZLBEJQMDQrsvJsfwa6gE9AHba6hD22aiaoJgsQAUBTEU
+GEQBTCUAgMwlYoDMJaKAyiHCD8oiwgfKIGIByiOCDwAAHAOAA2LyyiRiAIPbZqJqgmCxABQFMVMl
+gwBosIfjzCMigMwjooHKIcIPyiLCB8ogYgHKI4IPAAAmA0gDYvLKJGIAiiPSAGaiSoJAsQAUBTFT
+JYEAKbAhCdABCiHAD+tyBdiKI0wLHQNv8kokQAAksAfZKLApsKHA0cDgfuB48cDPcIAAMJIGgBLo
+LwhQAC8IkAAKIcAP63IF2IojDQRKJAAA4QJv8golAAGA2c9wgACQu8kF7/8noADZ+fFA2ffx4Hjx
+wM9wgAAwkgSQEuiB4MwgooAS8gohwA/rcgXYiiPODEokQACdAm/ySiUAAM9xKhUVKgXwz3EqKhUV
+z3CAABwFeQXv/yCg4HjxwM9xgAAwkiSRiwkQACMJUABjCZAACiHAD+tyBdiKI08JSiRAAFUCb/JK
+JQAABCCBD/P//88EIYAPAwAAAAK4BSECAAQhgQ8AAAAMBCCADwAAAAwleM9xgABMECiBArhFeDMJ
+HwAHIIAPDwAAAAUFz//PcYAATBAogRsJHwAEIL6PDAAAANIgogToBOL/0iDiBOEEz//geADZz3Cg
+AOwnK6DgfuB+4HjxwJYMT/PPcaAArC8Ygc91oADIHyDemrgYoQXY0KVDHRgQANhiCK/zjbjRpQPf
+EvDgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeOB44HjgeGG/jCf/n+71z3GgAKwvGIGzuLq4GKFk
+2NClQx0YEADYFgiv84240aXQpQrYQx0YEADYBgiv84240aV1BE/z4HjxwAIMT/MId891oADIH1EV
+EJYB2FEdGJAg3tClQx0YEADY1g9v84240aUglwGXBrmBuRC4JXjPcaAA7CcGoVEdGJQlBE/z4Hjx
+wL4LT/PPdaAAwC8Thc92oADIHyDfs7i6uBOlZNjwpkMeGBAA2IoPb/ONuPGm8KYF2EMeGBAA2HYP
+b/ONuPGmE4UNCJ8GEIUdCB8A/BUFEAohwA/rcgXYiiNHAZ0Ab/KKJE0KFguP/54MD/8EyBsIEQHP
+cYAALMpIgTSRUyIAAJoOL/MB26EDT/PgeIogVwdNAW/ziiGNBuB+4HgA2M9xrADUAfgZAID8GQCA
+AKGlGRiAphkYgKcZGICiGRiAoxkYgKQZGICfGRiAoBkYgKEZGIDPcIAA0AYAgIsZGIDPcIAA1AYA
+gIwZGICxEQCGg7ixGRiAshEAhoO4shkYgLMRAIaDuLMZGIDgfuB48cCyCm/zAdjPdqAAyB9RFg+W
+UR4YkCDdsKZDHhgQANiCDm/zjbixps9wgADHIM9xoADsJwahz3CAAAc6BqHPcIAAh1MGoc9wgACH
+JAahz3CAAMc9BqHPcIAAR1cGoYogigAGoYogiwAGoYogjAAGoc9wJAAHAQahiiCFAAahz3ADAAch
+BqHPcAMAxyQGoc9wBABHSwahz3ADAEc6BqHPcAMABz4Goc9wBADHZAahz3ADAMdTBqHPcAMAh1cG
+oc9wBADHMQahUR7Yk1ECT/PgePHA5glP8892gAAQBQCODugA3c9wpwCYR7qgqv/F/89wpwAUSKig
+oK4pAk/z8cC2CW/zAdjPdqAAyB9RFg+WUR4YkCDdsKZDHhgQANiGDW/zjbixps9xgAAGIc9woADs
+Jyagz3GAAEY6JqDPcYAAxlMmoM9xgADGJCagz3GAAAY+JqDPcYAAhlcmoFEe2JPPcacAiEkA2BCh
+sQFP889wgAAHIc9xoADsJwahz3CAAEc6BqHPcIAAx1MGoc9wgADHJAahz3CAAAc+BqHPcIAAh1cG
+oUnZz3CnAIhJMKDgfuB48cD+CG/zAdjPdqAAyB9RFhCWUR4YkCDdsKZDHhgQANjSDG/zjbixpsfY
+lLjPd6AA7CcGp89wAwCCKwanz3ADAMJEBqfPcAMAQl4Gp89wAwACLAanz3ADAEJFBqfPcAMAwl4G
+p89xAADCdM9wAwDCdAanz3ADAIJvBqfPcAMAgmwGp8bYkLgGpyansKYK2EMeGBAA2F4Mb/ONuLGm
+z3AAAIJvBqewpgrYQx4YEADYRgxv8424sabPcAAAgmwGp7CmCthDHhgQANgqDG/zjbixps9wAAAC
+LAansKYK2EMeGBAA2BIMb/ONuLGmz3AAAEJFBqewpgrYQx4YEADY9gtv8424sabPcAAAwl4Gp7Cm
+CthDHhgQANjeC2/zjbixps9wAACCKwansKYK2EMeGBAA2MILb/ONuLGmz3AAAMJEBqewpgrYQx4Y
+EADYqgtv8424sabPcAAAQl4Gp7CmCthDHhgQANiOC2/zjbixps9wEwDGAAansKYy2EMeGBAA2HYL
+b/ONuLGmUR4YlNkHD/PgeM9ygADkBhkIHgCA4VHYwCgiBMogYQTAKCEEA/AA2OB/AKLgePHATg8v
+8wHYz3WgAMgfURUPllEdGJAg3tClQx0YEADYHgtv84240aXPcAAAwizPcaAA7CcGoc9wAAACRgah
+z3AAAMJfBqFRHdiTbQcP8+B48cD+Dg/zz3GgAKwvOoFSIQEAfQkfAB7oIN15/892oADIH1EWD5YB
+2FEeGJCwpkMeGBAA2LoKb/ONuLGmz3EGAAJ1z3CgAOwnJqBRHtiTBPBqDk//z3agAMgfURYPlgHY
+UR4YkCDdsKZDHhgQANiCCm/zjbixps9wgABMEA+Az3GgAOwngLgGoVEe2JPZBg/z8cBqDi/zAdnP
+daAA7Ccmpc9yoACsL5PoGILPdaAAyB8g3pq4GKIF2NClQx0YEADYLgpv84240aVB8BWCUSAAgMoh
+wQ/KIsEHyiBhAcojgQ8AAE0AyiTBAFADIfLKJcEAz3DAAEdoBqXPcBMAxwAGpc9wEAAGaQalIN/H
+2JW4BqXPdqAAyB9RFhCWUR5YkPCmQx5YEADYyglv84248abPcAAAQi0Gpc9wAACCRgalz3AAAEJg
+BqVRHhiUFQYP8+B48cDYcFMggQDPcIAAOHkoYB0IUAAKIcAP63IF2IojhwiKJIMPxQIv8golgAHP
+cYAAMJIIEQUBGw0QAAohwA/rcgXYiiMHCaUCL/KKJIMPz3CAAEwQCIAXCB8ACJEF6A8IkQELDh4A
+ANgC8AHY0cDgfrhwwrjxwCMIUABLCJAAcwgQAQohwA/rcgXYiiMEBF0CL/KKJIMPz3CAAEwQCIDP
+caAA7CdRIACAyiCCDwMABiHKIIEPAwDGJAahz3AEAEZLLPDPcIAATBAIgM9xoADsJ1EgAIDKIIIP
+AwBGOsoggQ8DAAY+BqHPcAQAxmQW8M9wgABMEAiAz3GgAOwnUSAAgMoggg8DAMZTyiCBDwMAhlcG
+oc9wBADGMQahqvHxwKHBz3GAAEwQKIEvKAEAwLkAIYMPAAAi0k4ggQcp2BK48CDAAM9ygACLrjR5
+WWFAwItw2glv8wPaocDRwOB+8cBKDA/zGnDPdaAAyB9RFRGWAd5RHZiTIN/wpUMdmBMA2CIIb/ON
+uPGlz3AsAAYBz3GgAOwnBqFTIIAgJQhQAFkIkACPCBABCiHAD+tyBdiKI8cFiiSDDzUBL/IKJQAE
+z3CAAEwQCIBRIACAyiCCD4AAxiDKIIEPgACGJAahz3ADAMICBqHPcEgAQgEGoc9wpwAUSNegO/DP
+cIAATBAIgFEgAIDKIIIPgAAGOsoggQ+AAMY9BqHPcAMAAgMGoc9wSgBCAQahAtnPcKcAFEg3oB3w
+z3CAAEwQCIBRIACAyiCCD4AAhlPKIIEPgABGVwahz3ADAIICBqHPcEwAQgEGoc9xpwAUSADYF6FR
+HViUnQMP8+B4gLjPcaAA7CcGoeB+CdngfyCg4HjxwH4Lb/Mo2AhxhiH8AyS5z3KAADCSILJEIAED
+IrkhssG4yQXv/wKy8cDhxVILb/MA2EEoAQLAuc91gAAwkiatKbjAuAetOgtv81DYwbhVAy/zBqXg
+fuB48cDSCi/zAdjPdqAAyB9RFg+WUR4YkCDdsKZDHhgQANiiDi/zjbixps9wIAAGAc9xoADsJwah
+z3BwAIICBqFRHtiT+QIP8+B4z3EgAAcBz3CgAOwnJqDgfuB+4HjgfuB4z3CAAGhW4H8TgOB48cBi
+Cg/zCHcacQHZz3CnAJhHOqAg3s91oADIH9ClCthDHRgQANgyDi/zjbjRpc9xpwAUSAyBhOg+gQPw
+PYEAGEAg97nFIYIPAP8AANMh4QV1Ai/zIKfgePHABgoP889wgAAwkgeIgOCcAiEAosHPcKAAyB9R
+EBCGAdlRGFiAINkwoAHZQxhYAADYzg0v8424INnPcKAAyB8xoE4P7/4F2M91gABoVg6lw9jPdqAA
+7CcGpgqGz3enABRIALWKIMQABqYKhgG1iiDFAAamCoYCtYogywAGpgqGA7WKIM8ABqYKhgS1z3AA
+AIMNBqYKhgW1z3AAAMMNBqYKhga1z3AAAAMOBqYKhge1CIcEpQ2HBaUOhwalz3CnAJhHPIAnpTeH
+KKU2hymlz3GlAAgMIoEqpc9xqwCg/ziBK6XPcasAoP85gSylz3GrAKD/OoEtpc9xBQDGAyamxtmQ
+uSamz3EsAAIBJqbPcVoAQgEmpoohiwAmps9xQACHDSamz3HRAMINJqbPccAABw4mpgHZKKcA2S2n
+LqfPcVAA/wA8oAHYF6cA2BanUNnPcKUACAwioPzZz3CrAKD/OKBz2TmgGoDPcasAoP+BuBqhz3Aq
+AAIOBqaLcIHBi/8Awc9wgAAAoTSlMqABwS+gz3AaAAIOBqaLcIHBhP8Awc9wgAAAoTWlM6ABwTCg
+z3AmAAIOBqaLcIHBfP8Awc9wgAAAoTSgNqUBwTGgz3CgAMgfURARhgHZURhYgCDZMKAB2UMYWAAA
+2BoML/ONuCDZz3CgAMgfMaABlRC4hSCEAAamApUQuIUghQAGpgOVELiFIIsABqYElRC4hSCPAAam
+BZUQuAUggA8AAIINBqYGlRC4BSCADwAAwg0GpgeVELgFIIAPAAACDgamz3CgAMgfURhYhASFKoUI
+pwWFDacGhQ6nCIUXpwmFFqfPcKUACAwioA3pBBIENgISBTYKIcAP63IF2MkE7/GKI0QCC4XPcasA
+oP8YoQyFGaENhRqhcg7v/g6Fz3CgAMgfURgYhLkH7/KiwOB48cBSD8/yz3CAADCSJojPdYAAaFai
+wQTpB4iG6CEDIABIFQQQA9gacIogkQUA304N7/LpcaYM7/4F2A6lw9jPdqAA7CcGpgqGALWKIMQA
+BqYKhgG1iiDFAAamCoYCtYogywAGpgqGA7WKIM8ABqYKhgS1z3AAAIMNBqYKhgW1z3AAAMMNBqYK
+hga1z3AAAAMOBqYKhge1z3CnABRIKIAkpS2ADoAlpQalz3CnAJhHPIAnpc9xpwAUSFeBNoFIpSml
+z3GlAAgMIoEB2iqlz3GrAKD/OIErpc9xqwCg/zmBLKXPcasAoP86gS2lz3EFAMYDJqbG2ZC5JqbP
+cSwAAgEmps9xWgBCASamiiGLACamz3FAAIcNJqbPcdEAwg0mps9xwAAHDiamz3GnABRISKHtoe6h
+z3FQAP8APKDPcKcAFEhXoPagUNnPcKUACAwioPzZz3CrAKD/OKBz2TmgGoDPcasAoP+BuBqhz3AR
+AAYOBqaLcIHB4P41hQDAIniEKIQDFIU2hQJ54gqv+y9wAcKCIMQCz3GAAAChEqUWoVWhz3egAMgf
+URcRlgHYUR8YkCDYEKcB2EMfGBAA2JIJL/ONuCDYEafPcEAAhg0Gps9wEAACDgamUR9YlItwgcHG
+/jWFAMAieAQogA8AAHQJFIU2hQJ5dgqv+y9wAcJP4M9xgAAAoROlGKFXoVEXEZYB2FEfGJAg2BCn
+AdhDHxgQANguCS/zjbgg2BGnAZUQuIUghAAGpgKVELiFIIUABqYDlRC4hSCLAAamBJUQuIUgjwAG
+pgWVELgFIIAPAACCDQamBpUQuAUggA8AAMINBqYHlRC4BSCADwAAAg4GplEfWJQkhc9wpwAUSCig
+JYUtoCaFLqAohTegKYU2oCqFz3ClAAgMIqCt6QuFz3GrAKD/GKEMhRmhDYUaoaYL7/4OhTKFjCGC
+gEb2Tw5CcP//4v8g2BCnCthDHxgQANhyCC/zjbgg2BGnm/6KINEFkgrv8jKFQiBAIIDgMgXN/xHw
+BBIENgISBTYKIcAP63IF2I0B7/GKI0QCagrv8oog0QVIFQQQjCSCgEX2jCS/iAr2CiHAD+tyBdiK
+I8QOYQHv8bhzvQTv/4hw4HjgfwHY4H7geKHB8cAKDO/ymHDPcIAAdLsQEAYAz3CAAMRWBYC4cYDg
+ocGGJfcPhPLPcoAA6AYFghEIgQEGgg0IAQEHgvEIQAEAHAAxIMMBFIAww7tTIMgAAhSAMEAuwQBT
+IMkAeGMUeDZ5OGDPc4AA8MAOY8l1hiX9H7t9eGDhiAUlhxPpcIYg/Q8beAV/ACAOEtR+PmbYYwKI
+fmYIdYYl/R+7fcOOBSUIEMlwhiD9Dxt4BX4AIUASFHgZYThjBIg7Ywh1hiX9H7t9ZYuleGhxhiH9
+Dzt5JXs1DRAAz3WqAOAHM4UXCR4A6KUkHcARyqUsHQASbKUNpRjwIB3AEemlKB0AEsulDKVtpRDw
+Cb8FJ8ERz3WnABRII6UJvgUmARIkpQm7ZXgFpRQagAEYGgABHBpAAQjcSwPv8qHAAIgB22ChaLgC
+uBV4x3CAAMRWQ4BDoUGAQaFCgEKhRIBEoeB/YKDgeM9xgAC0V89wgABAV+B/IqABBk/14H7gePHA
+VgoAAs9wAQCI0gnoz3GAAHxClBkAABuBiLgbodHA4H7gePHAdgrv8kokAADPc6UACAwIEwUATCUA
+gMohwg/KIsIHyiOCDwAASAKIB6LxyiBiAUDYAqPPcIAAdLuggM9ygAC0V4okgXSIcagggAOELQIa
+L3AeYvQmThDPd6YAAIA1fwHhwKfHcIAALFhWkM9xpACgP12hF5AeoQgbQAFhAs/y8cDyCc/ypcEI
+dyh2ag+v/gfYGnABhgzdBBwEMAQXARQGHEQwMLkIHEQwEBYBFGB5gcABhmG9DBwEMAEXgRQOHEQw
+MLkQHEQwEBYBFGB5g8DjDVWQogjv/gpw/QHv8qXA8cCWCc/yz3CAAMRWAICA4JHyz3agAMgfURYP
+lgHYUR4YkCDdsKZDHhgQANhaDe/yjbixps9w0QBCLc9xoADsJwahz3DRAIJGBqHPcNEAQmAGoc9w
+gACsulEe2JMQiIYg/wFDuClozwnVAc91gAB0uwSFMyZBcIAA1H1AJwJ1BrgUeDR6x3CAALC7AHrP
+cYAABFlQ8M9xgADUWRDgSvDPcYAApFog4Ebwz3GAAARZMOC8/wSFz3KAAPC7z3GAANRZBrgUeDXw
+z3aAADC8z3GAAARZcOCz/wSFz3GAAKRaBrgUeNhgJvDPcYAA1FlQ4K3/z3KAABC8BIUW8M92gABQ
+vM9xgAAEWYAgAgSm/wSFz3GAANRZBrgUeNhgov8Ehc9ygABgvAa4FHjPcYAApFpYYJz/zQDP8uB4
+8cBeCO/yAdjPdaAAyB9RFQ+WUR0YkCDe0KVDHRgQANguDO/yjbjRpc9ygADoBgCKz3GgAOwnELgF
+IIAPAADCaQahAYoQuAUggA8AAAJqBqFRHdiTcQDP8vHABgjv8gHYz3WgAMgfURUPllEdGJAg3tCl
+Qx0YEADY1gvv8o240aXPcIAA6AYikIa5ELkFIYIPAADCEs9xoADsJ0ahA5AQuAUggA8AAAITBqFR
+HdiTGQDP8uB48cCuD4/yz3WAAOgGyI0JjcK+wrgWfs9+1g4v/w3YBriBuBC+xXjPcaAA7CcGoQOF
+z3GlAOgPBqEEhQeh3QeP8vHAag+P8s92pQDoDyaGp4bPcIAA6AYA3yOgpKCSDi//DdgGuIG4z3Gg
+AOwnBqHmpkUlzR+npp0Hj/LgePHAGg+P8qLBOnAacQDdogyv/gfYmnAC2alwWnB6cQDbNGgCcSh1
+FCEAIGhywoUEEA8F2H/DhQHixH/le/EK9IAg5QGBAhzEMDC7ABwEMCCBBBzEMGB5i3BCI0Egvwl1
+gEAiQCDKDa/+inAFB6/yosDxwM9wgADEVg+AEOjPcIAAdLsEgM9xgAAEXM9ygADowgK4FHhYYNv/
+GwTP//HAgg6P8s9wgADEVhSAgOCF8gIMr/4H2Hpwz3CAAKy6EIiGIP8BQ7gpaIbh6AANAM92gAB0
+u0SGz3CAAGjDMyZBcIAA3H1AIBALBLpUekAgEQpAIBIGQCAPCEAgDQRYYEAnAnI0egB6z3GAAGRc
+UfDPcYAAhFwE4Evwz3GAAKRcCOBH8M9xgABkXAzgGgkv/wDaBIbPcYAAhFwEuBR4uGA38M9xgABk
+XBzg/ggv/wDaBIbPcYAApFwEuBR4+GAp8M9xgACEXBTg3ggv/wDaBIbPcYAApFwEuBR4QnAZ8M9x
+gABkXCTgwggv/wDaBIbPcYAAhFwEuBR4InCuCC//ANoEhs9xgACkXAS4FHgCcJoIL/8B2n4Mr/5q
+cMEFj/LgePHACiUAgM9xgADoBiARBAAi8s9ypAC4PQDbHwwRAJsSAAYJoaYSAAYKoZISAAYLoaMS
+AAYMoZsa2AD/2KYaGACSGhgAoxoYAAHaz3CgALQPXKAn8EwkAIDKIcEPyiLBB8ojgQ8AAEEERAKh
+8cogYQEJgc9ypAC4PZsaGAAKgaYaGAALgZIaGAAMgaMaGAAEyM9yoAC0D4Yg/w4iuByiWwLv/yAZ
+QAHgePECz/LtAs/y4H7gePHAugyP8qLBCHcodkh1Mgqv/gfYKQ90EBpwAYVhvwAcBDAEFgEUAhxE
+MDC5BBxEMBAVARRgeYtw4w9VkIILr/4KcN0Er/KiwM9wgAB0uyCAA4BEKH4DACGAf4AA5H0E6QyI
+BPDEEIAA4H7gePHA4cXPdYAAdLtCD+/+qXC4cACFEehKJIBzz3OAAOR9ANmoIIACRCl+AzIjQg5D
+CkABAeET8ADZSiSAec9ygACMfqggQANZIkMFRCl+AydzuBODABsLQAEB4QohwA/rcgXYiiMFCSkB
+r/FKJIACXQSv8ihw4cUG6c9ygADUXQXwz3KAAMRciesH6QHZz3CmAKQAN6AP8EokQHQA2aggwAIW
+IkAAoYBggCnYErgB4XV4oKDgf8HF4HjxwJYLj/KhwRpwKHZIdYogEQWqCa/yiiFJBoogEQWeCa/y
+CnGKIBEFkgmv8slxiiARBYoJr/Kpcc9woAAsIFCAz3GAABwHQqFQgGKBYnpBoUAogyFFI88Az3Og
+AOwn5qNqg4tyYLJBgRUKZQMAFA8xxH/ZDsGThQOv8qHAz3CAACwOq4DPcIAAdLsMEAQACiHADxC9
+63IQvwXYiiOJCAUkRAM1AK/xBSeFE+B48cDqCo/yocHPcYAALA4LgSDdAeALoc9woADIH1EQEIYB
+2VEYWICwoEMYWAAA2LIOr/KNuM9woADIH7Ggz3DAAEdoz3agAOwnBqbPcYAAQFcEgSkIUQAGgc93
+gAB0u0B4GBeFEC0NEQDPcAEABgEGps9wEgAGBBXwCiHAD+tyBdiKI0YHSiQAAKEHb/EKJQABz3AB
+AAcBBqbPcBIABwQGpgAXBBDPc4AA5H3PcgAAAjPPcQAAgkwDhzEMEABEKH4DACHNcMbYkrgGps9w
+OQACMwamz3A5AIJMBqbPcDkAAmYGpsfYlbgS8FYjzQVEKH4DJ3XH2JK4BqZGpiamz3AAAAJmBqbG
+2JW4BqYH2c9wpwAUSCugLKDPcaoA4AcB2BOhAYdZj6hxiHN6/89wEACHcgamAY0QuAUggA8AAEJy
+BqYFjRC4BSCADwAAQnAGpgSNELgFIIAPAACCcAamA40QuAUggA8AAMJwBqYCjRC4BSCADwAAAnEG
+pgmNELgFIIAPAABCcQamCI0QuAUggA8AAIJxBqYHjRC4BSCADwAAwnEGpgaNELgFIIAPAAACcgam
+C40QuAUggA8AAIJzBqYKjRC4BSCADwAAxnMGps9wAQBGagamz3CgAMgfpBANAM9wgAAGdAamz3CA
+AAd0BqbPcIAAxnMGps9wQABCdAamz3CAAMdzBqbPcAIARmoGps9wEADGagamWI8AjySPgOIB2sB6
+DgggAXmPJNgY2TPaSv/PcBAAx2oGps9wEACGcgamfgsAATYIQAEk2AHZM9pC/89woADIH6QQAADP
+cYAALA6ieAqhz3ACAEdqBqbPcGUAwm4Gps9wAADDCQamCoaLcQCxABQBMYDhzCHihzD0gg5v8oog
+kQTPcYAAHAcAkQHgALEBkSMIUQDPcIAALA4sEAQAABQFMQohwA/rcgXYbQVv8YojyQApCJEAz3CA
+ACwOLBAEABkMlAAAFAUxCiHAD+tyBdhFBW/xiiPJAc9woADIH1EYGITXBM//4HjxwPYPT/LPdaAA
+wC/ThQ0OnxbQhR0OHxD8FQUQCiHAD+tyBdiKI0cBBQVv8YokiQzPdYAAdLsApSGlWK15rdn+A6XP
+/gSlrghv+ADYz3CAADCSB4iA4LAMwv8JAI/y4HjxwKHBgNhgwAXMAhwEMM9woADUAxyQBgnP8gDA
+Jgnv8gLZcgggAALYocDRwOB+4HjgfwDY4H8A2OB/ANjgfwDY4H8A2OB/ANjgfwDY4H8A2OB/ANjx
+wKHBgdhgwAXMAhwEMADA3gjv8gLZocDRwOB+4H7geOB/ANjgfuB44H7geOB+4HjgfuB44H7geOB+
+4HjxwKPBANlgwQEcAjADHEIwAhxCMAHYz3GgAMgfE6EZgYTaQsAYgR7bDNlBwItw6giv8hi7o8DR
+wOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB/ANjxwAohwA/rcgXYHtuKJMMP2QNv8bhz4HjxwJoO
+b/KKIP8Pz3WgADgux4UHpT/YJgqv8xbZQguP88el5QZP8uB48cDhxYogygWGDG/yiiHFCF4Lb/MB
+2M9wpQAIDADdoqAEyITgdAlB8c9xAADoCRYIr/EG2A/IBSCADwEAAPwPGhgwBMgLCJ4A7g9P9Qvw
+ANmeuc9woAD8RCGgz3CgALQPvKDe/04OD/zWDy/+AdgWCK/xAdhxBk/y8cDhxet1iiCKBQ4Mb/KK
+IcQHiiCKBQIMb/Kpcc91gAAwBwCFLQhfAAOFUiCAAAOlCPDPcKAAqCANgOTg9AAFAAoOr/JU2EQg
+AQEDhecIQYCKIIoFwgtv8oohBAwEyD0IEQHPcYAAtJ0BgaW4AaHPcYAALMrFEQAGpbjFGRgACYGl
+uAmhJbjAuM9xgADYtFYO7/8KoT4JT/KKIIoFegtv8oohhA8A2s9woAD8RJ66QaDPcKAAtA8A2Tyg
+D8gEIIAP/v//Aw8aGDAPyIe4DxoYMH/YCrjPcaAA0BsToX/YEKEA2JW4EKHPcQEArN3eDm/xBtjP
+caAA8DYEgUYgwAEEoZTYLg9v8hjZiiCKBQoLb/IghQCFUSBAgPAPIvzKICIAiiCKBfIKb/KKIUUG
+QQVP8gohwA/rcgXYiiPECkokAADxAW/xCiUAAfHA4cWhwc91gAAwB0SVIpWKIEoFELq6Cm/yRXlC
+hSGFNwmAAATIQMELCBEBTyEAAUDAhemA4gwOwv+LcATZodo924IOb/IXuyGFBukChYTomv8hhSKl
+JukA2s9woAD8RJ66QaDPcKAAtA8A2TygD8gEIIAP/v//Aw8aGDAPyIe4DxoYMH/YCrjPcaAA0BsT
+oX/YEKEA2JW4EKEWDm/xAdiFBG/yocDgePHA4cUAFgBAz3WAADAHAKU9CJEAANnPcJ8AuP89oBzZ
+FfDPcKAAyDs2gEQhAgc2gIYh/wglejaAhiH/CEV5z3KgAKggTYLk4o/37ekCCI/yIIVJCVUBMyZB
+cIAAjIBAJ4ByNHgAeDgQBABYEAUACiHAD+tyBdjNAG/xL9veC6/yVNgZCF4AAYWBuAGls/8G8GD/
+BPCWC8/75QNP8s9ygAAwByGCJXjgfwGi4HjPcoAAMAchggZ54H8houB4ANmcuc9woACsLz2g4H7g
+ePHA4cXPc6AArC8Zg/C4GYMA3QzyBCCADwgAAADXcAgAAAAB2MB4B/CGIH8PguAB2MB4GOgZgwQg
+gA8OAAAAQiAAgMogYgAdCFAACiHAD+tyZBMEAAXYiNsdAG/xSiUAAC4Lr/JU2EQgAQI9CB4Bz3Kf
+ALj/vaIc2hXwz3OgAMg7VoO2g4Yi/wiGJf8YpXq2g4Yl/xiles91oACoIK2F5OWL9+3qUSBAgM9y
+gAAwBwGCDvKBuA3wOBMEAFgTBQAKIcAP63IF2LEHL/Ev26G4AaIbCJ4ABIIXCQAAJKIB2c9wgACh
+BroKL/4gqMkCT/LgePHAANicuM9xoACsLxyhGoFRIICCGoEK8qq4GqEagecIHoAB2LP/CfCKuBqh
+GoHXCB+AAdir/wDZm7nPcKAA0BsxoLT/Vv/PcIAAMAcBgEIgAIDKIGIA0cDgfuB48cDyCU/yz3EA
+ggEAz3CgAKwvPKDPcIAAMAcBgIPo4v8U8M7+3gwv/G/YkOgg3s91oADIH9ClCthDHRgQANiiDW/y
+jbjRpcX+FQJP8qzx4HjxwIogSga6Dy/yANm//pb/OP+A2c9woADQGzCgx/HgeM9wgADkYEEBj/fg
+ePHAlglAAc9wgAAsyhgQhAARDBEBCYANCF4Beg8AAA3wEwxQAM9wgAAgzRQQhQAPDdEB1ggAANHA
+4H4KIcAP63IF2G0GL/F12/HALglP8gAWAEDPcIAAjAcAgM91gAC4xIPgABYAQFUlThQV9M91gADk
+XgClBG2KDW/yD9lVJUAUGg9v8iKVAdnPcIAAAMokqCXwAKUEbWoNb/IP2clw/g5v8iKVHpXPcoAA
+SAfZYNhgARCFACCiJw0RAAKF8LjKIcEPyiLBB8ogYQHKI4EPAADxANwFIfHKJGEACQFP8uB4CHLP
+cIAA/GAlgCOBYIHPcaAAsB87gdW5eWEQ4XECL/tCeeB48cDhxdD/sgxP8s9wgABMEBiIWwhRAM9x
+gAC4xM9ygADkYACCYIFgoACCHNtgqARpAaLPcIAAUAcDoVUhQAQDohjYAqJVIcAFBaIBgQDdWhlE
+AwSiAoGtuE4PYAACoYfoqXDf/zYPYAAG2H0AT/LgePHA4cXPdaAAyB8Vhc9xnwC4/9W4FqFuDs//
+FRUAlpC4Hh0YkAYPYAAA2E0AT/LgePHA4cUB2M9xoADIHxOhGIGswUnAGYHPdYAAaLHPcYAAFM1K
+wAGBobgBoQiFEwgeAA8I3wEqC0/7lglv8RfYi3GpcAoNb/Ik2s9wgABIByCAAomS6ASJIQgeAA/I
+BCCAD/7//wMPGhgwD8iGuIy4j7iQuAvwD8gFIIAPAQAA/A8aGDAPyKy4DxoYMF4JD/GLcDDZkNoe
+204Jb/IYu89wnwC4/wLZNqAowIHgyiHCD8oiwgfKIGIByiOCDwAALQHKJCIASAQi8colIgA+DkAA
+h+gA2Jv/Jg5gAAbYbQcv8qzA8cDuDi/yMNrPcZ8AuP9WoRsaGDDPcaAA1AcaGRiAHxEAhgHfAhoY
+MAgShTBMJQCHyiHCD8oiwgfKIGIByiOCDwAAmQHkAyLxyiTCAxkRAoYD2CAZGIAUGdiDDxENhgAW
+AEAAFgBAABYDQQAWAEEAFg5ADxlYg1YjAAIQeAkOHhUC4BB4A+AEIIAPAAD8/7MIhAAPEQKGQOIe
+GZiAHREAhh4ZmICtuB0ZGICSDkAAfQgQAM92oAA4LgeGz3EAABwKqLgHpv4PL/EN2M91gAB8xyeG
+qxUAFiV4B6aKIBUMMgwv8oohxwKKIBUMJgwv8qsVARYA2KsdGBAAhYYg/oEPyAryBSCADwAAANQP
+GhgwD8iQuAbwBSCADwEAAPwPGhgwFg5gAALYDfAPyAUggA8BAAD8DxoYMA/IrLgPGhgwz3GAACAF
+ANgAoQDZkbnPcKAA0BsxoM9wgADQAhB4z3GgALRHSRkYgM9ygABkrM9wgAAkBUCgbyBDAFQZGICO
+DK/2ChrYM9EFL/IA2OB48cBmDQ/yABaFQAAWgEAAFoBAABaAQEwlAITKIckPyiLJB8ogaQHKI4kP
+AABbAHACKfHKJGkAANnPdoAAFGEpDXQAKaYocgAWg0AUa891gAAoiwBlGQhfAgHiDyHBAOsKZIEp
+pkYJT/JpBQ/yCiHAD+tyBdhp20okAAAlAi/xCiUAAeB4z3GAABRhCoGD6A2BA+gA2AXwBoH7CFCA
+Adjgfw944HjxwOHFagkgAAh1z3GAAKi0JZFhCVIALujPcIAAQKhIiADZz3OAABRhDIMPIYEACyBA
+gCD0jCICgBzyhiX8EIwlApAO8owlApQH8oogzw6SCi/yrNkO8A2DJXgNowuDBXkrozRqx3GAACiL
+AIGouAChxQQP8vHASgwv8gDYSiTAc6ggAAc0aMdxgAAoi+CBz3WAABRhAN4PJg4QQS8DElEjAIBs
+hQT0xntspQfwCyOAgwP0qL/goQHgbQQP8uHFSiTAcwDbqCAABgDdz3GAABRhDIEPJc0QCyBAgw30
+C4ELIECDCfQUa8dwgAAoiyCAiLkgoAHj4H/BxfHAz3CAABRhIBAFAEwlwIDKIcYPyiLGB8ogZgHK
+I4YPAABVANwAJvHKJKYAz3CAAJSA8CBAAUB40cDgfvHAjgsP8gh1z3aAABRhiiBPCpoJL/IohgiG
+Dw0FEIDlyiUCEAL0qKaKII8Kfgkv8qlxyQMP8uB4z3CAABRh4H8IgOB48cCKIE8LYgkv8oohhAJO
+DS/xCdgA2Or/0PHgePHA9v8A2YLgzCBigMogQgAC9AHYD3jE8fHAAdjPcYAAFGEDoc9woAAsIAOA
+BKECgYHg0AtB97Tx8cCKIE8MDgkv8o7Z+gwv8QnYqvHxwOIKD/Li/xkIUAAKIcAP63IF2KDbiiTD
+DwEAL/G4c891gAAUYSOFAoUhCVEAANkJCFAAFI0G6KoJIAAmpQzwI6UB2AalCPCG6AHeFgnv/8al
+wqXPcIAAqLQFkIDgOA7J/+0CD/LgePHAdgoP8s91gAAUYUmFMOoHhWEIUQAWjQDZaoXLhQ8hAQAk
+ekIiAoAke8oiYgCA4wHbJH7Ae4DmAd7shcB+5HmA4QHZwHmA4swjIoDMJiKQzCEigAbyFa0A2coJ
+IAAnpRaNAeAPeBatCQgRBADYFq1tAg/y8cDPcYAAFGHPcIAAoIByDy/yONoaCWAAANjRwOB+4Hjx
+wOIJD/IAFgBAz3CAALSdAYAbCF8BCiHAD+tyBdiU24okww/5Bu/wuHMAFgBAz3WAALjEAKXkbelw
+Ng4v8g/ZVSVOFMlwxg8v8iKV3g0P8ggVBRBRJQCEyiHBD8oiwQfKIGEByiOBDwAAnACwBuHwyiRh
+AM9wgADkYCCAQIVAoSCAHNpAqc9xgABcByOlGNkioFUlwRUloOGgIYXDoCSgANhaHQQQAoWtuHII
+YAACpZfoz3CAAKi0JZAXCXIAiiCPC0IP7/Gv2XILAAAG8DYP7/G02f4KAAA2CGAADdhtAQ/y4Hjx
+wP4ID/LPdoAAaLEIhqzBEwgeAA8I3wF2DA/74gov8RfYi3HJcFYOL/Ik2gHYz3GgAMgfE6EYgQDd
+ScAZgc93gAAUYUrABocw2ZDaHttLwItwwgov8hi7obaopqGmvK6jpxYN7/8C2M9wgACotAWQCwhS
+AKqnracE8KoLIACpcGaHAdnPcoAAZAcAgoHjwHmA4zhgAKIB2CGCwHg4YAGixQAv8qzA4HjxwFII
+L/I42qLBGnDPdYAATGEBhQDfOgkv8ulxIYUY2M9zgABMEACxF4NTIM4gz3KAADSLAaFAKAAhCGIz
+GcIDQCgEAYhwhiD+A8V4EKnPcKAALCAQgMdwBwAgoQqhBtgxGQIAMhkCABaD+rEDoUAhAANSCW/3
+CnEDhZDZgcIgsItx9gxv9wpwgeDKIcIPyiLCB8ogYgHKI4IPAAB3AMokYgDwBOLwyiUCBADAFwge
+AIogTw7CDe/xe9khhQGBo7gBoSOFi3AE4QoNL/IG2gGFz3GAAGwHIqBGDy/3qXDPcIAAFGEVGAIE
+zQfv8aLA4HjxwGoP7/GKIE8Ofg3v8ZXZAdjPdYAAFGEHpc92gABosYogTw5iDe/xKIYVjQDaLIUP
+IgIACyGAgCX0KoVFeciGKqVrhQS4x3CAACiLIIAbDh4QFw7fEWV6S6WouSCgiiAPDqbZCPBGe2ul
+iLkgoIogDw6t2RINz/GKIA8OCg3v8SuFVQfP8eB48cDeDs/xz3CAABRhwIAA35a//mbmDy/7yXAI
+cc9wgABkYboI7/r+Zs91gACotAWVJYUKuNlhxg8v+w4gQACYcM9wgAB8YZYI7/qIca4PL/vJcJhw
+z3CAAJRhggjv+ohxz3CAABRhwKAFhf5mHmYFlQq4ig8v+w4ggAMIcc9wgACsYVoIz/rBBs/x4Hjx
+wFIOz/HPdoAAFGGghgDflr/9ZVoPL/upcAhxz3CAAFRiLgjv+v1lRg8v+6lwCHHPcIAAbGIaCM/6
+gQbv8aCm8cASDs/xz3CgALAfu4AA3pa+BCWNH8D/AADdZRTlACWPH4AAAAAKDy/7qXAIcc9wgACE
+YtoPj/r2Di/72GUIcc9wgACcYsoPj/rmDi/76XAIcc9wgAC0YrYPj/rPcIAAFGEZBu/x4KDxwKYN
+z/HPcKAAsB/7gADdlr0EJ48fwP8AAL9nEOcAJ5AfgAAAAKIOL/vpcAhxz3CAAMRhcg+v+r9nz3aA
+AKi0BZYlhgq4+WF+Di/7DiBAAAhxz3CAANxhTg+P+moOL/vpcAhxz3CAAPRhPg+v+r9nBYYfZwWW
+CrhODi/7DiDAAwhxz3CAAAxiHg+v+gJ1Og4v+wpwCHHPcIAAJGIKD4/6z3GAABRhABkABAWWJYYK
+uLlhFg4v+w4gQAAIcc9wgAA8YuYOj/pFBc/x4HjxwN4Mz/GiwYDgyiGBD63erd4H8iWAI4EggQKA
+AnniCu/xiiBPDc92gAAUYQGGJQhRAIogTw3KCu/xiiFGCQDYAaayDu/wCdgOCe//ANhr8D4Jz/+B
+4AHYwHgvJQeQEfKKIA8Nmgrv8YohBg1KDQ/3AdhyC+//BqbeCO//AtgSCc//HQiQAAohwA/rcgXY
+iiMHAIokww+FAe/wuHMPyAUggA8BAAD8DxoYME4Or/AA36YI7//pcD4O7/AJ2M9wgACotAWQXwhS
+AAqGQcALhjYPr/9AwAjogOXKIIEPAABAAEgPAfyLcAjZlNoe2wYO7/EYu4ogjw4KCu/xiiFHB4og
+jw7+Ce/xK4aKII8O8gnv8SqGiO3KD4//ngwP9wHYB6brpiUE7/GiwPHAugvv8YogDwrOCe/xiiFF
+BW4Pj/3PdYAAFGGV6Iogzw62Ce/xiiHFBgHYAaXPcIAAqLQFkA0IUgA2D4//Q/AA2Kb/P/APyAQg
+gA/+//8DDxoYMA/Ih7gPGhgwD8iQuA8aGDBqDa/wAN4GD8/2Sg3v8AnYJIXPcKAALCADgMdxAAAA
+FCJ4GQiFDwCAAACKIA8KRgnv8YohxQ3DpcoPr//CpYDgiA+h/8ogYQDPcIAAqLQFkIDgyiCJDwAA
+QAC8DQn8ZQPP8eB48cDhxQh1BYADgEKFIICKIA8L/gjv8UJ5z3CAAKi0BZAJCFIA+/4D8B3/qXDD
+/zkDz/HgePHAtgrP8c91gADYtA+FSiAAIIDgyiHBD8oiwQfKIGEByiOBDwAAQgDKJAEEyAeh8Mol
+wQAB2s9xgABosWB4SKE8HQAUigzv8APY0QLP8eB48cBKCs/x2nCacfpyCiMAIQoiQCHIdwogwCEK
+IcCDz3CAADSLyiFiAChyBLkoYEwkAKAEuIYg/gMFIJEAyiHMD8oizAfKIGwByiOMDwAAhwDKJGwA
+UAes8MolDAXPdYAAzGIBhQDeyXH6Cu/xONoAhRzZIKABhRDZhC8LHAAhlX+AACzKILBcFQEgMxiC
+A892gAB0BxAYQgSZuSGgQCYBEyKgCiHAgygYAAQxGAIFMhgCBTQYxAXKIWIAig0v8gzgIYUI2BKp
+AYGNuAGhA4EfCF8CDInPcoAAbHbDuBx4CmLPcIAA0MpIYAyphu/PcoAA8LAF8M9ygAAQsUOlpNgA
+shDYAqULDlEgpNiMuACyDMCA4MohwQ/KIsEHyiBhAcojgQ8AALgAyiQhAHwGofDKJcEABKYhCxAg
+AYGYuAGhA4GfuAOhABUBIAQVACAAHoQUIaYCpt4IL/epcDkBz/HgeM9wgABosSiAz3CfALj/ANo2
+oAjZ7HAgoAPZz3CgABQEJaACyOxxAKHPcKAA1AtNoOB+4HjPcYAAiAfgfwCh4HjPcIAAiAfgfwCA
+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H8A2OB/ANjgfuB4ocHgf6HA4HjgfuB44H7g
+ePHA4cUCyM91gAAUYwClBG0CDe/xAtnPcYAOBADscCCghgvv8QCF2QDP8eB44H7geOB+4HjgfuB4
+4H7geOB+4HjgfuB44H7geOB+4HjgfuB48cAAFgBBz3KAABRjBrIAFgVBQCIBBA4aRAFMJYCEyiHC
+D8oiwgfKIGIByiOCDwAAggBABaLwyiQiAADaB/AAFgBBFCGMAAC0AeIvIEIB8woCgC4Mz/HRwOB+
+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjPcIAAjAfgfwCA4HjgfuB44H7g
+eOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB4
+4H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4Hjg
+fuB44H7geOB+4HjgfwHY4H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB+
+4HjgfuB44H7geOB+4HjgfuB44H7geOB+4HjgfuB44H7geOB/AdjxwM9wgAAM0FYL7/ED2Q4Lz/HR
+wOB+4HgC2M9xoADAHQ2hIdgGoQHYB6HgfgDZz3CgAMAdJ6AmoC2g4H7PcYAAlAcNCFEAAdgAqQGp
+AImB4MoggQ8AAMQJyiCCDwAAgADgfwGhANjPcoAAlAcBqgCqz3GAADCSBokI6AeJBugAkQkIkQMB
+2ACqANja8fHA4cUIdc9wgACgEAGIKwhRAAfw2gmP8OYOr/Fe2M9woADUCxiAANlCIAAIgODKIEwA
+5QhEg4kGj/HgeOB+4HjgfuB44H7geOB+4HjgfuB44H7gePHACiHAD+tyBdg220okAAAdA6/wCiUA
+AfHACiHAD+tyBdg720okAAAFA6/wCiUAAc9wAQDQ8c9xgACcBwChz3ABAMzxAaHPcAEA1PECoc9w
+AQDY8eB/A6HPcAEAUPHPcYAAnAcAoQGhAqHPcAEAVPHgfwOh4H7geOB+4HjgfuB44H7gePHAcg2v
+8WrYosGLcQHapgjgAEhzjegKIcAP63IF2IojjwyKJIEKhQKv8EolAACBwUTYAdp+COAASHOO6Aoh
+wA/rcgXYiiOPDYokAQFdAq/wSiUAAAQUADFfCIIPAAAyBEAkgTBr2AHaSgjgAEhzjugKIcAP63IF
+2IojkACKJMEKKQKv8EolAAACFAAxz3aAAKwHG3hBKMUATCUAigQeQBHR9gohwA/rcgXYiiOQAf0B
+r/CKJMEKHdjPdoAArAcBprhwABQAMc91gABQ0EAtggCpceIPoAAB243oABQEMQQWBRAKIcAP63IF
+2MEBr/CKIxAEQYYlCnIAANgWJQEQYImGI/8NI7sPC1EAYYkD62K7YakB4OcIgoAA2MUEr/GiwPHA
+Sgyv8YoiBAqhwc91gAD8BwCVz3aAAOzRyXFKIAAgABwENG4PoAAB24/oABUEEQohwA/rcgXYz3MA
+AAoMTQGv8IolBAoAjoTgyiHLD8oiywfKIGsByiOLDwAADwzKJAsEKAGr8MolywA6DO/xNNhtCB4E
+m/8P6AohwA/rcgXYz3MAABYMSiQAAAEBr/AKJQABi3FF2AHa+g6gAAHbgODKIcEPyiLBB8ogYQHK
+I4EPAAAZDMokgQ8AAEUAzACh8MolAQQAFAAxAdmGIP4PwODAec9wgACsByOoG/DPcIAA/gcAkM9x
+gAA81A7aVOAQeKIOoAAB24DgyiHBD8oiwQfKI4EPAAAhDMogYQG986EDr/GhwA54LHgpagDYDyBA
+ACdwWnjgfw4gwADgePHAIguP8c9wgACsBx2IBfBAJ0AAD3j4cM9wgACsBx6IiQjCAQDZB9hEKT4H
+WXAvcBlxhC8DASdwz3GAAOzRACEEAB8UxAAZYR4RxQA5cADeACGNH4AA7NHVfeeNiHEF2ulwBRXD
+EOH/QCiBEDR5hC8BBSdx1HnHcYAAWNTYcQCp6XCocQfaBhXDENj/AebPfsEOspEBHgIAQiJAEEAg
+QRCJCHWAL3m28eECj/GX6Iwhwo0B2lf2SiSAcaggQATPc4AAzdJEKj4HMiNDDhcLQwAH6xMKkAEB
+4k96ANoD8GG6T3rgf0hw4HjxwC4Kj/EacDpykQlyAADfWnEVIMAjoIgCiBsJECDPdoAAVGMVfgK4
+FHjHcIAA6GUK8M92gACMYxV+ArgUeMdwgACQZiGISwkeAAUQwQAirgYQwAADripwqXHb/wCugODM
+IGKAyiAhABLyRCg+BwAhgH+AAOzRxRCCAOEQgQACJYAQEHgHuMIOL/pCeQGuQiJBIIEJdYAB5/EB
+j/HxwM9wgAAwkgaAz3GAAKwHAtoTCFEAXKkA2B2pAdgeqQvwDQiRAFypAdgF8APYHKkA2B2pXqlH
+/5H/z3GAAPiAIIHPcIAAiGkB2sf/z3GAAPyAIIHPcIAA5GkA2sL/0cDgfuB48cC4cS0IUQAJDVIA
+Fw3SAwohwA/rcgXYiiNSBVkGb/CYc0AtgABkuMdwgABUYxvwz3CAAIhoMiBBAYwhw4/KIcEPyiLB
+B8ogYQHKI4EPAACbBCQGYfDKJMEAz3CAAIxjNXjN8QJ5LXlMeVYhAXJHuThg4H8PeOB48cC+CI/x
+CHYodUh3GnNPeRC5D3gIuAV5iiBHCMYOb/Glec9wgACsBwGIgODuAQIAgOfMICKgCfIsbS95z3CA
+AKwHP6gG8M9wgACsB7+oqXHPcoAArAcgGkIDwqohGsIDIhoCBMlwyf8AEIcA4YjPcIAArAfdiB6I
+EHaYAQkARC8+By9xhC4DEQokQA4AIU0Oz3CAAPDRHWVAL4IAVHqELgEVCiVADgAiQA4AIIgPgABY
+1AAmgx+AAMgHTCcAgMwnYoAm9BoVwBAA2QyrGxXAEEokgHEQqxiNFKuoIEAGFCBAEEGIc250ezV7
+x3OAADzVABDAAFirFSVCEBmrARLAAAHhGqsAii95G6t78AEVwBCX6ADaTKtQq1SrSiSAcQDZqCCA
+AxNuFHg1eMdwgAA81VioWahaqFuoAeEveWHwbLoAIkABfLkAJEQAACCGD4AAWNQAJIAPgADw0RqI
+Oo3pcqP/DKsAJIAPgADw0RuIO43pcp//EKvPcoAA8NEAJIAAGIg4jQAkhQDpcpn/FKsA20ohgBEU
+JssAFCDEEAETgBABFIEA6XKS/zNuNHl1eQAhig+AADzVGBoCEAATgBAAFIEA6XKK/xkaAhAVJcsA
+FSXEEAETgBABFIEA6XKE/xoaAhAAE4AQABSBAOlygP8bGgIQQiFJEAHjnQl1kG97AebPcIAArAce
+iM9+EHZyBsz/ANnPcIAArAcgqAkHT/HgePHAkg5P8afBGnBacUh1OnMKIwAhi3DPcYAA3IBOCO/2
+GtrPcYAArAcBgQDeqQh0AJhwAxGFAEwggKMB2s9xgABQ0BYhgwMAi8IijABEII8A/X9/CsEDDQtR
+IEGLDQoABG8LESBBi7XqRCACAiO6Yw2BEDMNUQBEIAIBQSqCgAf0RCAPBEEvPpEK8hEKUQBEIAIE
+JLoJClAAANoD8AHaT3oH8EQgAgQkuoDiAdrAeiMKUQBMIQCmAdrCIooAhiD/DiK4GwiAAIDizCVh
+kAfyAeZnDgSRiiD/DxHwMiRANBEIUQBCcdZ5AhHAAAnwCwiRAAYTwAAD8AcTwADxBW/xp8DxwJ4N
+b/FKJEAACHYacUh3aHW8/4wg/48R9MlwCnHpcqlzAN2Ydbf/jCD/jwf0iiAHCpILb/HJcalwyQVP
+8eB4+OCW9s9zgAA0ZAaLFwoAAAeLEwoAAA6LCwoAAA+LEQoBAIHhzCGigAHYA/IA2OB+8cAiDW/x
+iiCHCM92gACsB0ILb/E/jgGO4QgRAAKOP472/s9xgAC0nc9wgADIB0IgEAcgFoAQVokYFtIQGQoB
+AAKONIkRCEEAGRbAEAkggAQvIgUgHo79jqEIwgMA3UojgCMajg3oRC++EwAlQB4YFsIQACCBD4AA
+GNBMqTPwSCJAIC8hBSDPcIAAUGSrYB+O6XEhFoIQv/8JIEEELXkAIMAjz3KAAGBkqmIwEIAAQngJ
+IEEARC++EwAlRR4fjgAlhA+AABjQDBxCAOlxqXLB/wAlgg+AABjQDBLBAAJ5DBxCAEIjUyAB5XsL
+daCvfQHnHo7vf2kIw4OBBE/x4cXhxgARzQAJDRMQAN2gqRHo1OWD91PdoKnPcIAAKGUUIE4DoI6g
+qgARwQA0eAGIEPDU5YP3U92gqc9wgACAZBQgTgOgjqCqABHBADR4AYgAq8HG4H/BxfHA3gtv8bhy
+CHcodc9wgAC0nc92gACsByAWgxA2iKPBANrBCcEANIgCjrkJAQATFoYQDQ4QAITvRaYy8FMlgJAD
+8l0IUgELDRIUCw0SFgDaAvAB2g8OEAAhFoAQgOAA2ALyAdjPcYAANGSpYUQvvhMncQAhgw+AABjQ
+DBPEABQiwQPZYWyJAdlAwUHAQCYAFULAANgIcboK4AD4dwK9tH3HdYAADK9ChQ3vKw9QEEcPkRAF
+hlMiQQQSuAUgQgBCpRnwJYYEIoIP/wcA/iV6QqUR8AQigQ/8B/8BRYYJuvjxANkCvbR9ACWAH4AA
+FK8goChyiiCUDQoJb/FIcUkDb/GjwOB4ocHxwNYKT/GhwWXCCHYodc9wgAC6BoXBi3JAJEMwAIih
+/0QuvhYAJUAeFBTBMM93gACE0ZgnwRb4YJUgQQh5DTMWIKhTJYAQTQhTAUYlzRGvfR3wARSAMAAm
+gR+AAAyvUm1UellhIMIAqUQuvhYAJUAeRKkUFMEw+GCVIEEIIKjJcKlxnv8B5a99UyWAEMkIUoEg
+8AEUgjASbRR4ACaBH4AADK84YECoIMJEqMlwqXGT/xDwQiUAFg94ARSBMMd2gAAksAK4FHgeZiDA
+KK4MrgjccwJv8aHA8cDyCU/xocEacEohACAAHEA0iiAHCQ4Ib/EKcc9wgACsBwGIgOCw9M9wgAA0
+ZDIgEwTPcIAArAfdiB6IEHZIAQkAKncKIkAkAvA6dUQuvhMAI0AuACCBD4AAGNAMEc0Au30xCDMm
+rX3PcYAAfEIagTuBJHgdCB4Cz3CAAKwHE4iLc8lxrgjgAKlyAMACfa19z3CAAMgHfLjYYCwQwQDP
+coAAkAYAigXaqXOI/UokgHEA3aggQAVzbnR7tXvPcoAAPNV5YjmJemIK6SMJAAApCEIAMQ1TEQHl
+r30L8EIlkhAvIockYb2vfRDwGxLPAADZKnUN8IDlSiIAIMolYRAG8kIlUhAvIockAdkt6fNu9H8V
+J0ITz3GAADzVW2EAIYUAFSePFDpn+WE5iXmLNQnjAPuKGxWCAAS/AiNEAPB/BLovJAgBAieDECJ4
+bHgvIEYOvg3v+YhxDngCfwjn7n9Ev+1/CwgSJgrn7X/JcApx6XJu/wHmz3CAAKwHHojPfhB2ygbM
+/8UAb/GhwOB48cByCE/xz3CgALQPcBAQAIogxwjPcYAAkAZ+Di/xIIHPd4AArAcBjwDdr+jPcKAA
+tA+8oD6PHY8jCQIAz3OAAITRf9oUIA4AfmZMrq2uAeAPeAXa7wkjgE6uAN0O3s9wgABQZKhghP9h
+vgHl8w51kK99z3CAAJAGAIDPcaAAtA8Jp3AZAARRAE/x4HgIcQUhgQ+t3gAAAQYv8YoghwngePHA
+4cXPdYAAkAaKIMcJ6g0v8SCFz3GAAKwHAYmL6ACFKYFNaDBywCBsAcwhDIA0D8n/HQBP8eB4z3EA
+AK3euQUv8YoghwngePHAABaAQM9xgACsBxipABaEQAAWgEBQJL6BGakAFoBAyiHCD8oiwgfKIGIB
+yiOCDwAA+QqUBCLwyiXCAFEkgIEA2MogYQAbqc9wgAC4BgCQA+iD/rH/ggtP8fcFj//gePHALg8P
+8Qh1z3aAAKwHCY4odw0NARAIjkEPABCpcEAmgRTGCaAAQCbCFBKOr3ozjhi6CLgFeoogVA0WDS/x
+RXkyjkAmABMSDaAAU44SjkIMoAAzjqmu6K49Bw/x8cC4cS0IUQAJDVIAFQ3SAwohwA/rcgXYntv1
+Ay/wmHNALYAAFHhsuMdwgADoZRzwz3CAAIhoMiBAAYwgw4/KIcEPyiLBB8ogYQHKI4EPAACkALwD
+IfDKJMEAArgUeMdwgACQZtHA4H7xwGoOD/HPdoAAugYAjs93gAC4BiCP4f9BiM91gADoByCXEQre
+AAHYAK2KIMcDQ/ACgAboANgArZC5O/BfCh4Bz3KAALSdFopTCQEAAJZ0iksIwQDPcIAAvAYAiFKK
+PwoBAM9wgABMEAmAMwheAUGFANsO6s9woAAsIBCAQngRCIUPMQEALQHaQK0E8GCtANoQuoogRwNF
+eQ3wAY0G6AHYAK2KIAcDB/AA2ACtkbmKIAcE2gsP8R0GL/EAjfHAj+i2/89xoAAsIDCBx3FJawDS
+IqC6Cy/xiiCHBZLx8cDYcYnorv8A2SKgiiDHBZ4LL/HIcYbx8cDhxc91gADoB4ogRwaKCy/xKY0E
+2BYIL/0B2QiNKY3q/80FD/HgePHAz3GAAOgHiiDHBmILL/Epic9wgADQZdIOz/li8eB44cVTIA0A
+oKkEIIEPAAYAAEIhAYAEIIAPQAAAAMohYgAgqtdwQAAAAAHYwHgAq+B/wcXgePHA/gwv8dhxCiaA
+kIh1zCMigAbyQiYGAS8mhwHIcYP/z3GAAOgHA6Ef7iSIArk0eUOIA+ECEIUAGwofAAohwA/rcgXY
+iiMIBphz7QEv8AolgAEIYRcIXwAKIcAP63IF2IojCAfy8QEQhQBRJQCAyiHBD8oiwQfKI4EPAAAp
+AsogYQHk8+G90SUigcohwg/KIsIHyiBiAcojgg8AADACmAEi8MokggEnDR4QUSXAgMohwQ/KIsEH
+yiBhAcojgQ8AADcCdAEh8MokgQGhBA/x4HjxwCIMD/GhwQh2KHcacgDdz3CgALQPcBARAIogxwAu
+Ci/xyXHPcKAAtA+8oItxQCRCMEAkgzDpcLH/DQgRIEokAAAJ8M9wgACMtQGI+ehKJIAAIMABFIIw
+yXECFIMwtf/PcIAA6AcpiIDhzCZCkAXyI4CqqKKhMQ9eEc9xgAC0nVaJJQ6BEFSJUycDEBkLgQAE
+J48fAAYAAIDnAdoyicB6CwpAAKKooaCgqIogxwCeCS/xyXHPcaAAtA9wGUAExQMv8aHA8cBqCy/x
+iiAHBs92gADoB3YJL/EkhhXdBIYyaAHgNHnHcYAAkGYEpgKBEujPc6AALCBwg2J413BJawDSANrI
+90KhiiDHBUIJL/EgiQSGCwiUCgDYBKZhvcENVZB5Aw/x8cDPcYAAkAaKIIcBGgkv8SCB5P/PcIAA
+uAYAkIDggAzC/3kEz//gePHA2gov8dhxocEacItxQCRCMEAkgzDIcGb/ARSAMAnoAhSAMAXoQiAQ
+IS8gByQgwApx9/4BFIEwA+miiALwoYiKIMcBuggv8chxQCgAJkAtAhQFegEUgDACFIEwCLgFeoog
+xwGaCC/xRXnhvdEl4pAD8h0NHhEKIcAP63IF2IojDQOYc5UH7+8KJQAEsQIv8aHA4HjxwOHFPv/P
+cIAATBAYiM91gACMtRcIEQGKIA8KTggv8YohSgQCjSGF0f8CjSGFAdp8/5ECD/HgeBEIHgIEIL6P
+AAAAGAHYA/QA2OB/AKngePHA8gkP8aHBGnAA3s9woAC0D3AQEQDPcKAAtA/coIogRwH6D+/wCnGE
+KAYvACGNf4AA4LYh8EAlABcWIIQDBRSAAIYg/ocY8gSFi3FAJIMwQCRPMOlyHv+oFQAQ6XHj/yDA
+BBSBAAEUgjACFIMwSiTAACT/AeYMlb8OBJCKIEcBmg/v8Apxz3GgALQPcBlABP8Fz/+EKAsMACGB
+f4AALMooEYAAKIEtBe//ANrxwJL/dgnP/9kCz//PcYAAtJ3PcIAAuAYAkFaJKwoBAM9wgAC6BgCQ
+VIkfCgEAz3CAALwGAIgyiQ8JAQDPcYAA6AcBiQKp4H7xwAIJD/EacM9xgAC0nc92gAC4BgCWVonP
+dYAA6AcnCgEAz3CAALoGAJBUiRcKAQDPcIAAvAYAiDKJCwkBAAKNAvAA2AGtlv7PcIAAvAZAiM9x
+gAC6BgCJII6A4gHawHoKcwDfmHfq/gOFAYgglhEIHgEB2AOtiiBHAwXw462KIIcDpg7P8OEAD/Hg
+ePHAdggP8aHBCHUA3s9woAC0D3AQEADPcKAAtA/coOONiiAHAXYO7/DpcQSVi3FAJIMwgOAB2MB4
+LycAAAWFQCRCMMP+CoVAJEEwiP83D3QQlSVDHlYlABzwIIADqXGAIQgA1HnAuAUgwAEvJAcAIIkg
+wAEUgjACFIMwwv4B5tkOxJOKIAcBFg7v8Olxz3GgALQPcBkABJUFz//gePHA2g/P8M9wgABMECgQ
+kACogIogBwLqDe/wCnFTJQAQCnE7/gGIUSAAgcohwg/KIsIHyiBiAcojgg8AAGEDyiTCANgE4u/K
+JQIE9QfP8OB4z3CgACwgMIDPcIAA6AfgfyGg4HjxwOHFz3WAAOgHAI2P6EH+jeiKIEcEAN2CDe/w
+qXGQ2ZC5A8igGEAAE/ADjRDoz3CgAAAELIiMIQKAAN0I9F4N7/CKIIcEkdmQue3xAd2lB+/wqXDx
+wCYPz/DPdoAAeLQUjicIUQAE2MYJ7/wB2c9wgAC6BgCIz3GAALgGIIlU/gDYFK4t8PaOK+/PdYAA
+6AcKjWG4MQ8AEGX+z3CAANBlz3GAAKi0JYFBbwUpvgDKCO/5L3GKIIcGz3GAALgG3gzv8CCRz3CA
+ALoGAJDqrQitz3CAALgGAJAJrQDYFq41jgjpz3CAALoGAIhB/gDYFa7xBu/wAdjgeIDg8cD02Aj0
+zg4P8VAgAQD02Afwwg4P8Qhx9NiAuZ4ID/HRwOB+4HiA4PHANNgH9KYOD/FQIEEEBfCeDg/xTyBB
+BHoIL/E02O3x4HjxwDIOz/AacIIOL/Ew2JhwKbhRIACAyiHCD8oiwgfKIGIByiOCDwAAzQBIA+Lv
+yiUiACzYOggv8UAogSAB34ogDwoacEYOL/Ew2JhwKbgxCB4AjCcPmjXyIN3PdqAAyB+wpgHYQx4Y
+EADYvgkv8Y24saZCIEAgzwh1gAHnDg4v8TTYTyABBZW55g/v8DTY/g0v8SzYCHX2DS/xNNg1CF4F
+R9i2C+/wAtkKIcAP63IF2OnbSiQAAL0C7+8KJQABCiHAD+tyBdjZ26kC7+9KJQAA9LjKIIIPAABH
+AHwL4vDKIWIAtQXv8EEtABTgePHASg3v8DTYlg0P8c93gACc1ScIHgQA3slwrP8B2LX/iiUQEMlw
+vP8UJ4wTYb0AtPUNdZAB5n0Fz/DgePHADg3v8AHYocEA3kDGAN8aCG/zjL8D3Qq9+GYQeItxZglv
+8wHaz3GAAJzd1HlhvQCx6w11kAHmegpP8zkF7/ChwOB4z3GgAGAdErEUkeB+8cC6DM/wCHYodUh3
+GnMGDS/xNNgfCB8EGwgQIGG/jCf/nxfyyXD0/wIdFBAB5tB+9vEPCBAgz3GAAJzVBPDPcYAAnN37
+etR5Pg4v9qlw0QTv8AHY8cBeDM/wWnAacTpyaHBKCa/5CtmhaKoML/FKcAQgQAQEIQEkKwhAACDf
+z3agAMgf8KYK2EMeGBAA2CIIL/GNuPGmYb2MJf+fJ/YA2ALwAdhpBM/w8cDTuE8gAQaZuYILL/GK
+IBECkgsv8YogEQSfBc//4HjxwOHFSHVAKQIGUyDBBIogEQFaCy/xRXmKIBEDTgsv8alxTQTP8OB4
+8cDSC8/wCHYodez/CHLJcAPZpnrx/ykEz/DgePHAtgvP8Ah2KHXl/whyyXAD2aV66v8NBM/w4Hjx
+wMy4ELhPIIEAn7nCDe/w9Nj02ALZz3MBAKCGKHLE/4DgyiAhABMFz//gePHAbgvv8CTYmg3v8ATZ
+JNgB2c9zAACoYShyuv+A4MohwQ/KIsEHyiBhAcojgQ8AAAAByiQhAHAA4e/KJQEBz3AAAAwwANma
+udz/IN7PdaAAyB/QpQrYQx0YEADY/g7v8I240aXPcAAADDAA2Zq5zP+KIAkELg3v8G8hQwBdA8/w
+8cDiCu/wANkH2BpxOnAA3kAoACEUeMdwgABowxUgjQMAlYwgAo0A34T2jCCFgsn2/9gAtYogEQPS
+CO/w/9kBnQsIUw+MID+BR/bhtYogEQO6CO/wANkB5s9+uQ4Sk0IhQCBAIEEgpwh1gC951QLP8PHA
+4cXPcIAA/AcAkM9xgABow6jaAd2AIEQLEHiiDe//qXOA4MohwQ/KIsEHyiBhAcojgQ8AAMwAyiQh
+AHgHoe/KJQEB0//PcIAAxFalAu/wtKDgePHAKgrP8BYNz//PdoAA/Adm2CJuAdpWDe//SHOJ6Aoh
+wA/rcgXY29uKJIEJM/ACFgURTCUAgMwlgo8AAP//C/QKIcAP63IF2N7bGQev74okgQln2MlxAdoS
+De//SHOK6AohwA/rcgXY4duKJMEJE/ABliRuAdoB4BB48gzv/0hzoZaN6AohwA/rcgXY5NtAJUQQ
+0Qav70olAAACbRB4Jm4B2soM7/9Ic4roCiHAD+tyoZYF2OfbQCWEEO3x2QHP8PHATgnP8KHBGnA6
+cmh2uQlyAADYmnEVIA0gz3GAAPwHABWTEAIVkhC6cOONIZEBjQHaOGAQeItxcgzv/0hzEugAFAAx
+QCqCIAQggQ8AAAD/R7lUei8JECDHcoAA6GUW8M9wgAD8B8GQoY0KIcAP63IF2IojBAEAJkQTKQav
+7wolQAXHcoAAkGYAGsIEA+4CqgLwAaolCB4ADO4DioC4A6oSbxR4G2Jji1hggbtjqOSqA+4mqgLw
+JapCJEEgWQl1gEAlQCDZAO/wocDgePHAz3CAAIhpDtkB2gDbyv/PcIAAwGkJ2QHaSHPG/89wgADk
+aSrZANoA28P/z3CAAIxqC9kA2gHbv//RwOB+4HjxwI3/7/+6Dg//WggAAHX/9fHgeM9wAQDY0c9x
+gAB8QmEZGADPcAIAiBhVIUIHQCEDAwboHaMbgYO4G6HPcAIAjBkG6AKiG4GCuBuhz3ACALAZBugA
+ohuBgLgboeB+4HjxwO4Pj/CjwUohACCLcSpwSiAAIQpyKgvv/ypzgODKIcEPyiLBB8ogYQHKI4EP
+AAD3AMokQQQABaHvyiUBBAAUhTDPcYAABAgAGUIBTCUAgMohyw/KIssHyiBrAcojiw8AAP8A0ASr
+78okywAAwEEoAgJBKA4DUyLEAFMmxRACGQIBAxlCAUwkwIDMJeyAyiHJD8oiyQfKI4kPAAAFAZgE
+qe/KIGkBQSgCBFMixgAEGYIBQSgCBVMixQAFGUIBTCZAgMwl4YDKIcIPyiLCB8ogYgHKI4IPAAAL
+AVwEou/KJIIBQSgCBlMixAAGGQIBQSgFBwcZQgFMJECAzCVsgMohyQ/KIskHyiOJDwAAEQEoBKnv
+yiBpAQQUhTCMJQGErAAsAAEZQgEKIcAP63IF2IojhAUFBK/vmHPPdYAAnPUA3wPwAefvf0EoAQLD
+uWkPQxAA3hPwQCmBIDR5ChSAMBUhQQEB5s9+FHm5YQAZBASAIAIjLyAIJADAQSgBBsO5AeHDDkOQ
+gsEKcALatgnv/wDbCxSEMC8oAQFOIIUHLyVHAbUN0oAKIcAP63IF2IkDr++KI4QNQCFRIC8hRyRB
+KAEEw7l/CUKgBPBxDlOAQSgBBcO5CnWlCXIASiAAIEoiACAF8EAiUiAvIockQSgBA8O5dwpDIEoh
+ACAU8AK+1H4KFIAwFSZOEUAhUSAvIUckFH4AJoAfgACc9aCwgCUCE7B9AMBBKAEHAeG7CUOgMLjD
+uAAgDgSCwalwAtoGCe//ANsLFIQwLygBAU4ghQcvJUcBqw3ygM9+CiHAD+tyBdjZAq/viiPFA0Ag
+UCAvIAckQSgBBcO5aQhCoNPZCLkA2APez3OAAJz1ANqyaFR9fWU4tQHiT3pWIQEI8QqygDB5Yb4B
+4OcOdZAPeKEFr/CjwOB48cAVCHIAuHANDdMDANgAqQCqE/APDZIIjCUBgMogbAD39owlAYmL9owl
+AoMH9gLYAKkB2ACq0cDgfowlQoSG9owlQokD2Pb2CiHAD+tyBdiKIwYEMQKv75hz4HjhxeHGz3OA
+AAQIRpNTIk2AFvIxDZEQEasFkzCrxIMp3RK9FSUMEMCkKIsH6VYgAQgweTV9wKUB4AWzBPATqzKr
+AeJGs8HG4H/BxeB4uHBWIQAC8cANCHIAmHGMIAKAivYKIcAP63IF2MEBr++KI4cJz3CAAAiBFCAA
+AYAQAQEEKX4BL3LAEEAHQioDBMG7UroEKH4BL3FCKQAEwbhSuYHjwCJpAIHgwCFpAIgiPgB/3Aki
+AAOIIT4AiSHBD4Dg1iArCIDh1iErCM7/ifHxwAIMj/CiwUDAQcJAKBQFQCkXBQDdQCoTBUArEgUB
+3kolgCGpdwTwCnXKdwDAFbgTeBQgwAX6CG/5B9kCIFADAiBAI+oIb/kO2cx+CiFALgQpPnAvcKx+
+ACENdR1lAcAVuBN4FCCABMYIb/kH2QIg1gMCJsAjughv+Q7ZBCh+BC9x7H4AIcB0GWFCLQAVVLm8
+/0IlVSAB5pENdaDPfq0Dr/CiwPHAeguP8Ah2GnHPdYAABAjmlQrwzH92CG/5QClAcUW4CnGv/yaV
+jCEQgLb2sQOP8PHAPguP8KHBOnEA34DgyiHBD8oiwQfKIGEByiOBDwAAegLKJMEAZACh78olwQPP
+cYAABAhFseaxTCEAoMolzhNgAC4AyibOExp3WncE8Ml3GnVqcEAgUwCLcQHaNg6v/wDbABQNMS8j
+yCSpdim9yL6/5dklKRRMIgCgyiDCA8ohggPKIgIEqA7i/8ojQgPJcKlxh/9CIVEgtwl1oEAiUiDJ
+cKlxy//xAq/wocDxwI4Kj/CacBpxz3WAAAQIxY0EjR5mknbKIcwPyiLMB8ogbAHKI4wPAADbAsok
+DAWsB2zvyiWMAwDfAN4i8ADYCK1qcIrZKnLD/wiNUyfBEBi5w7gcuAV5z3gQuAV5iiBUDWIIr/AF
+IYEELyHIBBC5iiBUDU4Ir/AFIUEEAebPfgAlAhRGigFqNQ4DEEAsgCAUePV41HjPc4AAnPUQYwoi
+AKAyb+zzQCCTAC8jyCTUeTtjMBMRAcXqAdjE8QHn7397D9KQHQKP8PHAygmP8KHBCHV6cRpyz3GA
+AAQIxYkEiR5mcnbKIcwPyiLMB8ogbAHKI4wPAAAkA8okzATgBmzvyiWMAwDfAN4f8AEUgDABHRIQ
+BhGBIAEUgDCE6QEdEhAgwAMUgjABFIEwGLgUugV6AhSAMBC4BXqKIJQNhg9v8EV5AebPfs9xgAAE
+CAAhAAQGiAHgcw4jEAAhEQRAK4AgFHj1eNR4z3GAAJz1NCESAFMnwBAYuM95ELkFeYoglA1CD2/w
+BSGBBADZLwoQIItxSnAC2lIMr/8A23MIEYAKIcAP63IF2IojTA4KJIAEMQZv70olgAABHVIQBhGA
+IMPoAR1SEL/xAefvfz8P0pAX8fHA4cUA3aCjgeDMISGAF/ILChMIoKMA2AnwwOIG2Ab2QiIACEO4
+AuAAo1B5ELkQfYoglA2+Dm/wpXkRAY/w4HjxwIYIr/AA2KHBSHaIcgoiQCEKIYAhCsEKIMAhTCZA
+gAChzCZskMwgrKDO9gohwA/rcgXYiiOODQokQASRBW/vCiUABEwhQKDMICGgyiHBD8oiwQfKI4EP
+AAC8AwXY7vNocIYg/ANEuGTfhCgBCS91gCUPGsO7e2N1eyjARCq+DH1lAiVNHhsIUQBbek16i3Mq
+cApxy/8AwBV4FXgCfalw/gwv+WTZ7HgCJUQeieDKIGoCyiIKAEn2gODKICsAyiILAIP2QWhAKM8g
+9X/Pc4AABIkVJwEQVX95YftjGwkRIIbuqBEOhqgTAIYR8IoRDoaKEwCGC/CH7pARDoCQEwCABfAY
+EQ6AGBMAgCnBgeGKIf4AwCZBEMAgQQDCeIhxLHgvcH4ML/lk2bhg2GByDC/5Ctko4EggAQCMIUOC
+yiGKDwAAyADPcIAA8IOZIEEHNXjAEAAGjCJCoCW4EHhE9owiAaAO9gohwA/rcgXYiiORD4okQgBZ
+BG/vCiWABM9xgAAAglkhwQ8VIYEEgBEBBi25MHkseArAQimEdYwkx48AGAAByiHND8oizQfKIG0B
+yiONDwAAnQQYBG3vyiUNBIoglA3yDG/wiHEZB2/wocDgePHAtMGKIJgD2gxv8APZNgxgAItwiiCY
+A8oMb/AL2YogmAPCDG/wEdm0wNHA4H7gePHA4cWhwYtxvguv8AHaAMHPcIAA+PmA4cohgQ8AAEQA
+BfKB4YjZyiEiDIC5IKgA3aioydklsALZIaj/2SGwpagg2SSoA9mGDaAAKaipcL0Gb/ChwPHAPg5v
+8ADZz3aAAHxCF4bPdYAA4PYPIQEAGYYkeEIgAIDKIGIAocEB3xcIUQDPcQAAxCwJ2C4Nr/JWJYIU
+N4YA2A8gQAA4hiR4QiAAgMogYgAA2SUIUQAJ2GDAARxCMAIcwjMDHMIzi3AE2VYlghRCDa/yiiMH
+DgDYLQZv8KHA8cC0wYogmAPWC2/wAtkGDeAAi3CKIJgDxgtv8AnZtMDRwOB+8cC0wYogmAOyC2/w
+ANlKCSABi3CKIJgDogtv8BDZtMDRwOB+8cB2DW/wANnPdoAAfEIXhs91gABo+Q8hAQAZhiR4QiAA
+gMogYgChwQHfFwhRAM9xAADELBDYZgyv8lUlwhg3hgDYDyBAADiGJHhCIACAyiBiAADZIwhRABDY
+YMABHEIwAhzCMwMcwjOLcATZVSXCGHoMr/IocwDYZQVv8KHA4HjxwOHFocGLcSIKr/AB2gDAz3GA
+APj5gODKIIEPAABEAAXygeCI2MogIgyAuACpAN2oqcnYBbEC2AGp/9gBsaWpINgEqQPY6gugAAmp
+qXAhBW/wocDxwOHFocGLcc4Jr/AB2gAUBDDPdYAA2PXPcIAAuGqpcRPavgsgAQDbABQEMM9wgAAY
+CFUlwRQD2qYLIAEC289wgADgalYlwRIS2moMIAEAwwDYyQRv8KHA8cBODG/wANgIcWYIIAEC2gHY
+ANlaCCABAtoC2ArZUgggAQLaz3KAABgIGYLPdUsAS0vPcYAAJGsVIgMAAoMCoQSDz3ZoH/8Au6LE
+oQOhqqHPcIAABGsQ2gILIAEA210Eb/AA2PHA6gtP8KHBz3aAABgIWYaLdRUmjBBAFAARqXGL6noJ
+AAEZhgDBFSYAEEAQAAHGuQrwZgkAARmGAMEVJgAQQBAAAYe50ggAAc9wgABka89xgAB8a3oLIAEL
+2leGBdhI2bYIIAEPIYEAGYYVJgAQSBAAASYJIAGpcRmGAMEVJgAQSBAAAZIIIAHGuRmGFSYAEFAQ
+AAECCSABqXEZhgDBFSYAEFAQAAFyCCABxrkA2KkDb/ChwPHA4cWiwWh1WmJUehNpFngaYsdygABs
+94twJGreDK/1BtqpcItx1gyv9QbaANh9A2/wosDxwO4Kb/AB2hpwz3GAAAyJAIGlwULAApGEwQwc
+BDAWCK/wCnAEws9xgAAYCILDCnDDukTCNoHm/yLATg0gAQfZCHYJFIAwQg0gAQfZGnDJcADZCNoK
+c0okQAIqDiABSiVABAh3ChSAMB4NIAEH2VpwCxSAMBINIAEH2XpwSnAA2QjaanNKJEAC+g0gAUol
+QARAwCPA8gwgAQfZCHUNFIAw5gwgAQfZOnCpcADZCNoqc0okQALODSABSiVABEHAz3AAAAjS6XFe
+DuAAANpB2Am4yXFSDuAAAdrPcAAAAYIKcUIO4AAB2gDBz3AAAAnSNg7gAADaz3AAAAKCSnEmDuAA
+AdrPcAAAA4JqcRoO4AAB2gHBz3AAAArSCg7gAADaz3AAAASCqXH+DeAAAdrPcAAABYIqce4N4AAB
+2gDYCQJv8KXA4HjxwKPBi3HqDm/wA9rPcIAAMJIEkILgAdjAeLPoAMHPcAAAG9KP6QHZtg3gAADa
+z3AAABzSAdmqDeAAANoC2ArZL/AjCVEAAtmWDeAAANrPcAAAHNIC2YoN4AAA2gLYFNkf8ATZeg3g
+AADaz3AAABzSANluDeAAANoC2CHZEfDPcAAAG9IC2VoN4AAA2s9wAAAc0gDZSg3gAADaAtgR2UIN
+4AAC2gLBz3AAAAXSMg3gAADaAcHS2Ai4O3kB4SIN4AAA2gDYo8DRwOB+4HjxwO4IT/CpwUDAQcEA
+2EjAgsV6CyABqXCExnILIAHJcIbHagsgAelwAMCLcgoLIAEX2QHAgcICCyABF9kAwFYLIAGpcQHA
+TgsgAclxqXCpcU4LIAGpcslwyXFGCyAByXKpcMlxWgsgAelyBsAHwYjDmgkgAQHaCMDdAG/wqcDg
+ePHAaghP8Bpwz3aAABgIF4aA4IH0BtiKDeAAANkKcM9yrd7vvhYJIAEA2QpwUf+D4FACAQDPcAAA
+B9LPcQMP8MBSDOAAANrPcAAABtIA2UYM4AAocjeGCnAE2gokgA+t3u++2gggAf/bCnCT/4PgFAIB
+AM9wAAAg0lUmwRmaDOAABNrPcAAAIdJWJgEVigzgAATanBYAEKAWARC6/wh1z3AAAAfSz3HkEA45
+6gvgAADaz3AAAAbSANnaC+AAKHI3hgpwBNoKJIAPrd7vvm4IIAH/2wpweP+D4NTyz3AAACDSVSbB
+GTIM4AAE2s9wAAAh0lYmARUiDOAABNqcFgAQoBYBEKD/AiBQA4wgBK6I9wDfB/CB4AjYyiBiAn/x
+Ad9MIACgyiUqEFD2GIaO4AHYwiAOAAjoF4aA4AHfyiWhEQTyAN2pd3kIUiB1CIMvAAB8ks9wAABQ
+wyYM7/gKcYDgyiBsAMj2jCACiMoghg8AAJ8Az3GAANBs8CEAABV4/gvv+IohDwodZUPYG6bPcAAA
+C9LPcUMAQ0P+CuAAANohDdQSF4aM6BiGjuAB2MIgDgCB4AjdyiehEATyCN0B33MOA3QAACT0z3EA
+AFDDsgvv+ApwgODKIGwAyPaMIAKIyiCGDwAAnwDPcYAA0GzwIQAAFXiKC+/4iiEPCjeGm+k4ho7h
+AdnCIU4AKwlRAA8I1ABOII0DAN8N8E4gzQIA389wAAAL0s9xUgBSUmoK4ADpcheGBL/9ZYjoBthm
+C+AAqXEC2ArZG/AnCFEACNhWC+AAqXHPcIAAMJIEkAHZguDAeQLYgOEU2cohYgQH8AnYMgvgAKlx
+Atgh2R4K4AAC2rqmANhNBg/w8cDiDS/wBNqkwRpwEgtv8ItxAMHPdoAAGAh3hs9wgADIawQUETAA
+3fAgwgDPcIAA1GvwIM8Az3AAAAbSWHnSCeAAqXLPcAAAB9IAKcEjwgngAKlyCnDPcq3e775aDuAA
+OoYKcKL+UwjQADeGAsIKcAokgA+t3u++Pg7gAAPDCnDs/jcI0ADPcAAAINJVJsEZAgrgAATaz3AA
+ACHSViYBFfIJ4AAE2pwWABCgFgEQFP+IHgAQqXCNBS/wpMDxwC4ND/ChwQh1ACSOAGJ+AiZOEaBy
+YnoCIgKBANhAwA3yLH6Ldi9wSHEeD+AAyXLqDuAAyXAAwAJ9qXBZBS/wocDgePHA7gwv8Iokww8I
+ds91gAAYCIQVAxBfhQolgA+t3u++gBUBEHpikg3gAAPbyXC1/7cI0ACIFQAQhBUCEAolgA+t3u++
+f4WAFQEQjB0AEMlwemIE22IN4ACKJMMPyXCp/4cI0ACIFQAQhBUCEAolgA+t3u++f4WAFQEQkB0A
+EMlwYnoD2zIN4ACKJMMPyXCd/1cI0ACIFQAQhBUCEAolgA+t3u++f4WAFQEQlB0AEMlwYnoE2wIN
+4ACKJMMPyXCR/ycI0ACIFQUQlBUEEIQVABA/hZgdQBGMFQIQkBUDELj/hB0AEADYdQQP8OB48cD+
+Cy/wAdsId891gAAYCIAVAhA/hQolgA+t3u++AN5ZYYQVAhCmDOAAmHbpcHr/sQjQAIgVABCAFQEQ
+AttfhYwdABDpcAolgA+t3u++WWGEFQIQdgzgAJh26XBu/4UI0ACIFQAQgBUBEAHbX4WQHQAQ6XAK
+JYAPrd7vvkJ5hBUCEEoM4ACYdulwY/9VCNAAiBUAEIAVARAC21+FlB0AEOlwCiWAD63e775CeYQV
+AhAaDOAAmHbpcFf/KQjQAIgVBRCUFQQQgBUAED+FmB1AEYwVAhCQFQMQfv+AHQAQyXCFAw/w8cAW
+Cy/wAdqhwRpwQghv8Itxz3aAABgIFobPcYAA2PVWIU8EArgUeB9nAMBVIc0Nz3Gt3u++FqauC+AA
+CnAKcHz/UQjQAADYA/AehgHgPYYdCGUAHqbPca3e776KC+AACnAKcK7/5wjRgBTwF4aAFgEQFX8g
+t4QWARAhtzaGOWE0eRR5GoY9ZQCtG4YBrQDY6QIv8KHA4HjxwH4KL/AI2RpwAtjPdoAAGAgdpgrY
+H6bPcq3e774yC+AACnAKcG/9zwjQAADddgrgAKlwz3CAADCSBJAB37amguDAf6lwz3GAAJRr8CEA
+AAHZjuAYpsIhTgDCCuAAOaa3pgDYBe+A4MwgooAv8s9xrd7vvtoK4AAKcApwb/17CNAAz3Gt3u++
+xgrgAApwCnCD/WcI0ACAHkAT/9iEHgAQz3Gt3u++qgrgAApwCnBa/kcI0AAKcM9yrd7vvpIK4AA2
+hgpwqf8zCNAAF4YB4JkI9IAXphaGAeBvCPSBFqYKcM9yrd7vvmoK4AAQ2QpwPf2D4MogIgDtAQ/w
+4HjxwIYJL/CKIE8PAN3PdoAAvAiWD+/viiEICIogTw+KD+/vI4bPcYCuDADscCCgAsjscQChQCYP
+EgXwIInscCCoAeX7DfKRuWfPcKAAFAQD2kWgIInPcKAA/AssqJEBD/DxwOHFz3WAALwIqXCmDS/w
+AtmKIM8PMg/v733Z4f+KIM8PJg/v7yCNiiDPDxoP7+8hlQCNOQheABkIkAAKIcAP63IF2ITbSiRA
+ABkG7+64c89xoADIH7ARAAAeoRDYDqEmhc9wgADIECKgUvA1CJ4AhODKIcIPyiLCB8ojgg8AAJAA
+Bdjh9QDZz3CAAJwGIKAB2c9wgAChBpII7/sgqDjwJwjeAAHZiODKIcIPyiLCB8ojgg8AAJoABdjH
+9c9wgACcBiCgJPA1CB4AAhUFEQ0N0gOMJcOPy/YKIcAP63IF2KTbgQXv7kokQADPcYAAyBACgQal
+ANgCoc9xoADIH7ARAAAeoRDYDqEB2ASlkQAP8IoiBADPcaAAyB9PobAZAABOoRDYDqGpA8/u4Hjx
+wM9wgACIEBeQ9/8f2M9xoADIHwi4DqF/2JW4EhkYgM9wAQDA/BUZGIDRwOB+4HiKIBAA5QXv797Z
+4HjxwL4P7+8D2M91oADUByAdGJAB2BQdGJAZFQ+WDxUBls92gAC8CCemABYAQAAWAEDwfwimABYA
+QRK2Dx1YkEDgCqYF8BkVD5bwf4ogUACSDe/v6XEKhvEPBJDNB8/v4HjxwGIP7++KIFAAiib/H3IN
+7+/02fIKz+4Mcc91gABgBCClEQ5AEFoN7++KIFAAwIUzCN9Bz3CAAGAEAIBTIICB6vMvKAEATiCC
+B89xgAC8CALYBKHPcKAAFARKoEWh0f8c8KYLj/SMIEKByiHCD8oiwgfKIGIByiOCDwAAAgHKJGIA
+GATi7solwgBs/7b/ANnPcIAAvAgkoDUHz+8D2M9yoADUByAaGIAB2BQaGIAPEgGGABYAQAAWAEAA
+FgBAABYAQA8aWIAPEgCGDOAeGhiAHRIBhh4aGICDuR0aWIDgfvHAz3CAALwIBYDPcaAA1AcbGhgw
+GhkYgA4RAIYfEQWGCxoYMAIaWDEIypzgyiHCD8oiwgfKIGIByiOCDwAAwwF4A+LuyiRiAN3/L9iV
+uM9xoADQGxChz3ABAMD8E6Ep8fHAHg7P7893gABkrAMa2DPPcIAAKK0HGhgwAdgKGhgwev8A3c9w
+gAAgBaCgANmRuc9woADQGzGgz3CAANACEHjPdqAAtEdJHhiQz3CAACQF4KBvIEMAVB4YkI4Kj/bP
+cIAAEAUAiAbokgqP/NILj/wKEgU2MQ3eAAHYChoYMBvIz3GAAIicFHmxqbCpA9nPcKAAFAQjoM9x
+gAC8CAOBAeADoQ7wGQ2fAm8WBJYKIcAP63IF2KUC7+6KIwgByNiCC+/viiHIAcEFz+/gePHA4cWp
+wYt1qXDPcYAAFIkKDy/1JNoB2GDAAhwEMAvIRcAbyAy4hSBIAEjAGghv9qlwmQXv76nA8cAaDe/v
+iiCQADIL7++KIYQNz3WAALwIFBUFEAHeTCWAgcohwQ/KIsEHyiBhAcojgQ8AADcBIALh7sokgQOY
+/6//4v/PcKAA1AvQoBDYz3KgAMgfz3GgALAfD6IK8BDYz3KgAMgfz3GgALAfD6IB3hUamINAEgMG
+4ZVif/6iFKFCCM/unv/PcKAA1AvRoNMI3sHPcKAAFAQJgIDg8A7C9yIJj/SMIEKBzCCCjwAA/AAM
+8gohwA/rcgXYiiOFBkokQACVAe/uuHPPcqAA1AsA2TCijCBCgRD0x/7PcIAAvAgAiBkIHgAKIcAP
+63IF2IojxQfn8WINz/AK/89xgAC8CADYgQTv7wSh8cCKIBABLgrv74ohBgEq/89wgAC8CASAGuiC
+4Mwg4oAM8gohwA/rcgXYiiOGBIokww8dAe/uuHOw/4ogEAH2Ce/viiFGBToNz/cD8P/+9wPP/+B4
+8cCm/s9woADQG4DZMKDPcIAAvAgAiIYgf4yUD8H/0wPP/+B48cDhxc91gAD4+QCNMQhfAAYKL/wG
+2M9xpwAwTBQRAIYDpRURAIYEpRYRAIYFpRcRAIYGpRgRAIYHpQnwAY0H6ADZz3CnAJhHOqAJjQ8I
+0ABAJQATbgwv8BTZuQPP7+B48cAuC8/vz3aAAPj5AI6hwUQgDQcivTpwhiH8J54I7/sH2EEpTyEa
+cIztCiHAD+tyBdiKIwwEiiSDDz0A7+64cwsnQJPKIcIPyiLCB8ojgg8AABMDyiBiAe/1Dr2IvZW9
+jguv/EDFz3GAAJC7AIGLcoYg/gMkuEAogwMAgmZ4AKIggcK5DrkleACiAMEA3UEpgANBKcIDwLjA
+ugQhhA8BAADACLgKujC5RXjAuUApAgMFegCOQSyEA0EogwFBKEEBwLvAuQu7CblleUEowwENu2V5
+RXmAuc9yoADsJyaiQCzBAOV5z3KrAKD/OqLPcaAAtA+8oSGOz3KnADRE9hpYACWWYZbzafV/EL8F
+I9ID9RqYBGSO5Y5RIECA9xrYAPga2APPc6cAFEhBKYIhWBsAAVejz3KgAIBEcILPd6UArP9GIwMF
+cKIAwgQigg8hAADBJrpVp8oggg8BAP//BfQAwFoIb/YU4RinIMCJuI64GacAjhUIXgBAJgAT6gov
+8BTZAvAA3c92oAD0B6SmVg2P7s9xgAD4+QGJhOgAiREIXwAB2ZC5z3CnAJhHPKAD2ASmAQgeQ89x
+gAD4+QGJhOgAiRUIXwDPcqcAmEdwGoAECImAuBqiAIl3CF4Aqwgew/8I3sECDk/0jCACg8wggo8A
+APwADfIKIcAP63IF2IojzgVKJEAAcQav7rhzjCACgxn0z3WAAPj5qXCuDe/vA9kAjVEgAIDKIcIP
+yiLCB8ojgg8AAJwDyiBiAeT1Wv8D8DoKz/DqDO/vgNgF8OIM7++A2FT/ANrPcaAA9AdEoQPYCqEJ
+oUmh1g+v+wpwIQHv76HA8cDPcYAAMJIkkQDYguHMIWKAA/QB2C8mB/DPcYAA+PkAiQfyhiA/BUUg
+AAoAqQsIHgBY/wLwP//DAM//8cDPcIAA+PkSDe/vA9nu/68Az//xwOHFocGLcaYN7+8B2gAUBDDP
+dYAA4PbPcIAAeG+pcRXalg9gAADbABQEMM9wgADoCFUlQRUD2n4PYAAC289wgAD4b1YlARMS2kII
+oAAAwwDYoQDv76HA8cAeCO/vSiRAAih1GnIA3wfZgODKIGIAE3jCuM92gACkbwGmIqbPcGgf/wAD
+pgpw6XEI2gpzcgugAEolQAQOpgpw6XEI2gpzSiRAAloLoABKJUAED6YKcOlxCNoKc0okQAJGC6AA
+SiVABBCmhO0B2BGmCvALDVEQAtgRpgTwCQ2REPGm8qb/2ADZCdoIc0okgAIWC6AASiXABADZE9r/
+20okAAUCC6AASiVABxOmz3AgACAgzQev7wem4HiA4ADZyiBBAAXygeAB2MogogBI2Q8hAQDPcIAA
+HHDgfzGw4HjxwD4Pr+8E2qTBGnBqDO/vi3ECwAPDAN2pcQjaSiRAAqYKoABKJUAECHEBwDoLYACp
+cgpwz3Kt3u++1g9gAADBcghv/wpwbQjQAM92gADoCM9wAAAg0lYmQROSC2AABNrPcAAAIdJVJsEW
+ggtgAATaOob7hkEpwAXAuBi4E3gleEEvwRXAuRi5M3klfxqmz3EAAGgf+6a6C2/4CLgcps9xAABo
+H6oLb/hALwASHaapcPEGr++kwOB48cB2Dq/viiAPCoIkAjqacXpyWnOIdah3CiGAIQogwCEOCaAA
+nsGKcAYJoACLcYLGanD+CKAAyXFKcPYIoACEwalw7gigAIbBiMXpcOIIoACpcSpw2gigAIrBCnDS
+CKAAjMGpcIrBNgmgAJDCi3DJcSoJoACSwslwhMEiCaAAlMKGwKlxFgmgAJbCmMaQwJLBqgigAMly
+mseUwJbBngigAOlyyXDpcfYIoACcwpzAnsHKCKAAjsKfxW4IoAAEbY7AfgmgACRttwgQAIbAisGO
+CKAAQCUCE4twhMGCCKAAQCUCFZTAQCUBE1IIoADJcpDAQCUBFUYIoADpcslw6XGeCKAAnMKMwJzB
+MgigAMlyqgigAMlwyXCOwWIIoABAJQIXksBAJQETFgigAMlylsBAJQEVCgigAOlyyXDpcV4IoACc
+wozAnMH2D2AAyXLJcI7BKgigAEAlAhkeCKAAQCUAF89xgADoCBihDgigAEAlABnPcYAA6AgZoQfw
+ANnPcIAA6Ag4oDmgRQWv74AkAjrgePHA/gyv7wraqsEIdiIK7++LcQbYFgpgAAHBCNgOCmAAAcEJ
+2AYKYAABwRAUBDDJcADBAsIKJYAPrd7vvooNYAADw8lwXf9/CNAAz3WAAOgIHIUYFAQwEqUdhQDB
+CiWAD63e774CwhWlyXBeDWAABcPJcFL/TwjQAByFIBQEMBOlHYUAwQolgA+t3u++AsIWpclwNg1g
+AAfDyXBI/ycI0AB8hXQVBhDJcFQVBBBYFQUQdKUkFAcwMoVcHYARU4Vt/wDYqQSv76rA8cAaDK/v
+DNi6cTpyz3eAAOgIhBcTEHwXEBAA3Zpwz3CAAEBw8CBSA2pwFglv+EpxAnATeAoJb/iKIQ8KCHaI
+FwAQ/ghv+EpxgBcBEDhgE3juCG/4iiEPCrplVHpALcEgNnlZYcdxgABs9w0JESDEqQWpCfALCVEg
+xqkHqQPwyKkJqUIkQCCZCHWAAeXdA6/vANjgePHAdguP76fBunAA30bHSifAIEokgCFKI8AkSiCA
+Nc92gADoCOum6XFad4DhyiKBLwAACNLKIyElyiDhNcon4STKJKElgeHKIoEvAAAJ0sojISXKIOE1
+yidhJcokISaC4coigS8AAArSE9nKI0EgyiChBcogATDKJAEgyidBIADZB9hFwM91gABQbzV9AIXa
+cQHZjuDCIU4AKqaA4cohwSXKIcIkgOHKIAElyiACJooLQADPcYAAbG/JcAPa8glgAALbCoYrhgra
+rf7PcIAAeG/PcYAApG8V2tYJYAAA2wuG1v7PcIAA+G/PcYAAHHCaCmAAEtoAhc9xIAAgIAimz3AA
+AAvSvg4gAADaiiW/HUDFQcUK2ELAz3Ct3u++Q8CqcCuGKnJKc0okgAJKJYACSiaAAjoLYABOJgcA
+qnBa/4Pg1fIYhs9xEAAQEAymGYYNps9wAAAL0m4OIAAA2kDFQcUK2ELAz3Ct3u++Q8CqcCuGCnJK
+c0okgAIKJQABCiYAAeoKYABOJAcAqnBH/4Pgr/I4hlmGhsUNhi6mT6YTeFR4TIYfphN4U3o0eoAe
+gBCKIQ8Kzg1gAKlygBYAEBgUEDCKIQ8KE3i6DWAAqXIGwIohDwpEwB+GE3imDWAAqXIGwIohDwpC
+IJkCgBYAEBN4kg1gAKlyBsXPcAAAC9LPcSAAICBqvb4NIAAA2gAcQDYK2EHFQsDPcK3e775DwBAU
+BTArhkAghCKqcCpySnNAJYUCCiYAATYKYAD4dapwGv+vCNAAGIYQphmGEaYLhoboBtj+DiAAVibB
+EwuGEQhRAAjY7g4gAFYmwRMLhhEIkQAJ2N4OIABWJsETHobDuAsIdAMepgvYHqbPcYAAQHDwIQIA
+EYYwhkx4hB5AHkx5TIaIHkAehOpNhgrqToaE6k+GBuqA4cwgIYAJ9P+mgB7AE4QewBOIHsATqnDK
+cUuGKP8FwGG4gOCuBe3/QCZBICuGAeGD4UoF5f8rpgDYzQCv76fA8cCyCK/vCNnPcq3e775uCWAA
+CHbJcAj+TwjQAADdsghgAKlwz3Gt3u++UglgAMlwyXA4/zMI0ADPca3e774+CWAAyXAuCi//yXAf
+CNAAyXDPcq3e774mCWAAENnJcPb9g+DKIEIDuQCP7+B48cBGCI/vocHPdoAA6AhKhot1FSaMEASU
+qXGL6tYNAAAKhgDBFSYAEASQxrkJ8MYNAAAKhgDBFSYAEASQh7k2DQAAS4YF2EjZKg0gAA8hgQAK
+hhUmABAIkJoNIACpcQqGAMEVJgAQCJAKDSAAxrkKhhUmABAMkH4NIACpcQqGAMEVJgAQDJDuDCAA
+xrkA2CUAr++hwPHA4cWhwYtx2gyv7wHaABQEMM91gABo+c9wgAB8cKlxF9rKDiAAANsAFAQwz3CA
+AHgJVSXBFQPasg4gAALbz3CAABRxViVBEwvadg8gAADDANjVB2/vocDxwFoPb+8X2qbBz3ZAH/8A
+z3VQAFBQz3CAAHxwz3GAAKxwRg4gAADbz3AAAAvSABwEMM9wAAAC0gIcBDDPcAAAG9IEHAQwz3AA
+ABzSQsUGHAQwz3WAAHgJAoUA2UPGDyEBAAOFRMGCwQTaRcCLcPoNIAAA289xgAAIcalwA9rqDSAA
+AtsA2EEHb++mwPHA4cWhwc9wgAB4CSKAUNgPIE0Az3CAABRxz3GAACxxkg4gAAvaBdgAHAQwAhxE
+M4twQCSBMH4OIAAB2gDYmfHxwKLBi3G6C6/vAtoAwADZBNpIc0okQAH2CWAASiXAAQhxmgsgAEvY
+ANiiwNHA4H7xwEoOT++uwXpwWnE6chpzgsXmCGAAqXCExt4IYADJcNYIYACGwNIIYACIwMoIYACK
+wIzHwghgAOlwanAX2WYIYACLckpwF9laCGAAgcIAwK4IYACpcQHApghgAMlxqXCpcaoIYACpcslw
+yXGeCGAAyXKpcMlxtghgAIbCKnAX2SIIYACLcgpwF9kaCGAAgcIAwG4IYACpcQHAZghgAMlxqXCp
+cWYIYACpcslwyXFeCGAAyXKpcMlxcghgAIjCz3AAAE0ZOghgAIrBiMCKwT4IYADpculwC9nCCGAA
+6XKGwC4JYADpcYDgAdga9s9wAACMFg4IYACKwYjAisEOCGAA6XLpcAvZlghgAOlyhsACCWAA6XGA
+4ALYyiAqAIUFb++uwOB48cAiDW/vAdqhwZpwXgqv74txAMHPcIAAcHDPdoAAeAnwIEAAIqbPca3e
+774DptYNIACKcIpwa/+nCNAAz3Gt3u++wg0gAIpwinCJ/5MI0ACKcA/Zz3Ot3u++qg0gAALainCT
+/0oiACAf33cI0AAQFhAQFBYREAojgCQD8Fp1SnUe8Kl3HPAAJ40UvX2wfYpwqXHPc63e775qDSAA
+CtqKcIP/PwjQAESGCnAqcWWGjP/TCFCAyQiQgEojQCACJ4AUCQiUAMMLEKCB4MolzhPPcIAARHH0
+IEADpqYHpgDYmQRv76HAz3CAAOT5KLDgf0mw8cBKDG/vCNnPcq3e774GDSAACHbJcCH/TQjQAAHZ
+z3WAAHgJIqXPcq3e777mDCAAyXDJcLf/MQjQACKFAeHrCbSAIqUslclwTpXr/8lwz3Kt3u++vgwg
+ABDZyXAP/4PgyiAiAFEET+/xwNILT+86cCh1GnJSCW/7B9hMIICgWnAb8gz2JwgQIE0IUSAV2BO4
+FSBABKCgG/ArCBAkOQgRKCpwGguv76lxEfAp2BK4FSBABKCgC/Ar2BK4FSBABKCgBfDPcKAA7Ce5
+oH4Kb/tKcMUDT+8KIcAP63IF2EnbCiRABKEAb+4KJQAE4HjxwE4LT+86cCh1GnLOCG/7B9hacA8I
+niC+Ca/7yNhQIJAgTCCAoBnyCPYjCBAgRQhRIBXYE7gN8CUIECQ1CBEopgqv7ypwAKUP8CnYErjw
+IEAEAKUJ8CvYErj78c9woADsJxmAAKX2CW/7SnA9A0/vCiHAD+tyBdh62wokQAQZAG/uCiUABOB4
+8cDKCk/vOnAacc91oADIH1EVD5YB2FEdGJAg3tClQx0YEADYng5v74240aUmCG/7B9jPc6AAwC8z
+gw0JnwYwgx0JHwD8EwUACiHAD+tyBdiKI0cBuQcv7ookggQvIggEQCmBIYG5ELpFec9yoADsJyai
+UR3Yk14JT/uxAk/v4HjxwEoKT++hwRpwKHfPdqAAyB9RFhGWAdhRHhiQIN2wpkMeGBAA2B4Ob++N
+uLGmpg8v+wfYz3OgAMAvM4MLCZ8GMIMfCR8A/BMFAAohwA/rcgXYiiNHATkHL+6KJMILQCiQIUUg
+wyDPcqAA7CdmokqCi3FAsQAUATEgp1EeWJTWCE/7KQJv76HA8cC6CU/vWnA6cUh3GnPPdaAAyB9R
+FROWAdhRHRiQIN7QpUMdGBAA2JINb++NuNGlGg8v+wfYz3OgAMAvM4MNCZ8GMIMdCR8A/BMFAAoh
+wA/rcgXYiiNHAa0GL+6KJMMDANkPIQEESWlFeQDaDyLCA2lqRXtGe2Z5MHtAKpIhRSLCIRC7ZXrP
+c6AA7CdGowApwiMkelB6RSKBIRC6RXkmo1Ed2JQmCE/7aQFP7/HAFglP7wh3OnEacx0KdAAA3kh1
+9CeAExUhgSMKcmr/Yb31DXWQAeZNAU/v8cDqCE/vCHc6cRpzHQp0AADeSHX0J4AT8CGBIwpyPv9h
+vfUNdZAB5iEBT+/xwAsM3gDp/wLw8//RwOB+8cCuCE/vCHc6cRpzHQp0AADeSHXwJ4ATFSGBIwpy
+UP9hvfUNdZAB5uUAT+/xwIIIT+8IdzpxGnMdCnQAAN5IdfAngBPwIYEjCnIk/2G99Q11kAHmuQBP
+7/HACwzeAOn/AvDz/8zx4HjxwEoIT++hwQh3GnEhCnQAAN5IdfQngBOLcXn/AMAUIIwjYb0AtPEN
+dZAB5oEAb++hwOB48cAWCE/vCHcacR0KdAAA3kh19CeAE/QggSNM/2G99w11kAHmVQBP7/HACwve
+AOj/AvD0/5bx4HjxwNYPD+9acM92oADIH1EWEJYB2FEeGJAg3bCmQx4YEADYsgtv7424saY6DS/7
+B9g6cM91oADsJ+uFbgrv+0pwC6VRHhiUng4v+ypw5Qcv7+lw4HjxwJIPD+8IdgYNL/sH2M9xoADs
+J7mB2aF2Dg/74Qcv76lw4HjxwOHFCHGO4AHYwiANAADdz3OrAKD/uaMH2lqjuKMB2loPr/xIc2YP
+L/sB2LUHD+99AE/v8cBKCwAALg8v71DZRcBKIAAghsX6/yUINSUEFQEUBcAVIAAEIKBAIFAg7wmB
+j63e774k3GMHD+8KIcAP63IF2IojhweYcy0EL+4KJQAE4HjxwL4OD+9acBpx2nD6cTpyenMA2Jpw
+byVDEAh2SiDANztwCHe6cOlwqnHyCiAAAdoAIECDASGBA+IKIAALckIgWLDKc0MhGTDyccwgwYAK
+9wAnT5MBJZUjAiYWoAMnVyCpcMlx4gogAAHaBSB+gAh1KHbb9elwqnHpcvoKIACqcwIiEqDpcAMg
+UCCqcY4KIAAB2gUiPqQIdSh2EPIFJb6TDPIqcADZSnLKCiAACnOpcuIKIADJc5pwKnAA2elytgog
+AKpzACQCIDUGL+8AG4AgIIAA2oDhRfYB2jN5IKCAIQGAf9zAIQQDR7kgoAPqM3kgoOB+IIAHueB/
+IKChwfHA4cVCwJhxSHWA4ADaRPYB2hN4QsCCwPj/AsAD6hN41grv94hxAKUI3DcGD+/hxeHGAN0z
+CdAHCwnTBwsJEwAA2BPwGQnzBx/eTiH8B+B4qCCAAQ8ljRNhvgkITgCleAPwpngAogHYwcbgf8HF
+8cChwQDaQMKLcu7/AMChwNHA4H4A2SCg4H8hoAhyX7hAoeB/AaHgePHAVg0P70h1QIBhgMGBAIHO
+CSAAyXEApakFL+8hpeB44cXhxsCAYYCggQGBACWNkwEgwACgogGizfHgeOB/AIDxwBYND+9IdcGA
+QIFhgQCAtgkgAMlxAKVpBS/vIaXgeOHFYICggQGAIYECI0ODYKIDIEAAAaLgf8HF4HhAgCGATiID
+gADaAyJCAGCg4H9BoPHAxgwP70h1wYAAgChy2gogAMlxAKUdBS/vIaWf4cwg7ofMIE6ABvcCeUFp
+CwoRCIoh/w8G8ADZDyGBAGG5GHngfyhw8cB+DC/v2HAodkhxiHXJcPL/CHepcKhx8P8IcQAugAME
+fyZ/ACtAAyR4vQQv7+V4YIBAgQGAIYFQc8wgQYDhIMEHyiAhADBwhvYE9gkKxQDgfwHYiiD/D+B+
+4HjxwCYMD+9IdoDgAd1E9ool/x8TeAkJEwCzfTN5FCEAAA4J7/c7eax4AB5AHmUEL+8B2OB4/ByI
+sfwcSLH8HAix4cPhwuHB4cAHwBwcwDHhwOB/AcBTIkKB4HxOIgOIFgAMAAEozAAAKYEAACiAAOB/
+hXlOIwMAACjBAOB/AnjgeFMiQoHgfE4iA4gWAAwAACnMAAEpgQABKIAA4H+FeE4jAwABKcAA4H8i
+eeB4CHQA2AUqfgAvcQUqPgMAIECOASHBDgUrPgPgfydx4HgzACAASiQAAAchxAAvJkDwSiUAABAA
+JgAvJAQBDiBAgQMlQQCA4w4AAwAOIkKBAyXDAAUjhYAwAQEAeXNIdAhyKHMKJcCCSiIAEBoABADA
+IiEYyiUBgy8vQQHAImMQwCLDEUonAAAKJcCAwCchCBYABADKJYGALyhBAcAnYwDAJwMADieHgson
+JABAJ0cACiXAAUwnAIgA2RAAJAAA2EhxaHIA20InB4gKJEBxKAABAE4nCoh+AAEAACmAAgEpwQEA
+KoUCoHEBKsIBACuFAgErwwGgckwiAJhqAAkAqCCABQAgAIABIUGAASKCgAEjwwACIgKDAyPDggwA
+BgAAIgKDASPDgsAgZgBCJD6ASiUAACAAAQAMAAoADiJCgQMlwwAvJACBDAADAA4gQIEDJUEA4H4o
+cEhxaHIA2yAggA8CAMhEqCCAAwAgAIABIUGAASKCgJFywiIGA8UgZgAgIIAPAgD8RADaCWoA2y8h
+AgAgIIAPAgAkReB4UyJCgeB8TiIDiBYADAAAKcwAAimBAAEogADgf4V4TiMDAAIpwADgf0IpwQcA
+AAAAAAAAAAAAAAABAAAAAAAAAPAQgACEEYAAAIqAABAAgACMBIAABAjAEAoAE2RcBYCBAADAFgQB
+E2IPXAAiCgAAQAAGAHAaAABhAAATJAAAEyUAAMAXyCDAEHBFwBAQCMAQAAATJAAAEyUECMARDxQV
+IgQAFSb7/zAyAwATJBgIwBEcCMARDxQVIgEAFSYEADAwMAATJOwcwBEDABMkUBTAEQQYwBEAABMk
+EEXAERgIwBEPfBMiCADMEQAAEyUAABMkNEjHEQ97EyIBABMwBCjAEQ8UFSIEABUm5AaAgQAAwBbC
+LBMkBCjAEQJGEyQEKMARwl8TJAQowBEPTRMiBBDFEQIAEyTwHMARAQATJOwcwBEAABMkcAATJRAc
+wBEAABMlAAATJOAcwBEBABMkJBDAEQAAACEAABMlAAATJA9FACIAXAA5AwAAYgJgAGIAAFg4XQAA
+YSQQwBEAgBMkOBzAEQ9zEyKCARMwBCjAEQ90EyICAhMwBCjAEQ91EyJCAhMwBCjAEQ8UFSIBABUm
+D3ITIggAzBEPRAAiCgAAQABAAHAOAABhAAATJQIAEyTsHMARD3YTIhgIyhEJABNAHAjKEQkAE0Ag
+CMoRD3gTIgQAyhEAAAEkAAABJQYAAGEPdhMiLEjHEQ94EyIAAMYRAwABJAAAASUAABMlwiwTJAQo
+wBECRhMkBCjAEcJfEyQEKMARD0UAIgBcADknAABkAAATJAEAEyU4HMARD3cTIuAcwBEPARMiBAjA
+EQ8CEyIEKMARDwcTIgQowBEPBBMiBCjAEQIAcXAHAABh/wATJQIQEyQEKMARAAATJQAAEyTISccR
+BgAAYQAAEyUCEBMkBCjAEQAAEyVJABMkyEnHEQ9wEyIBABMwBCjAEQMAEyQAABMlBAjAEQAAEyQ4
+RcARDwMTIhgowBEEAABhAABYOAAAEyQBABMlOBzAEQAAACGkiYCBAADAFjwEwBEgBYCBAADAFgQB
+G2IQBMAQAwAbJFQEwBEkBMARCATAEGSJgIEAAMAXCATAEECJgIEAAMAXAAAbJQMcG2JAABskMBzA
+EQUAAGEkBYCBAADAFg8bGSIIBKCBOPDEgAAAGyQCABslOBzAEQAAACEgBYCBAADAFkwEwBEkBYCB
+AADAFg8bGSJIBKCBOPDEgAAAGyQCABslOBzAEQAAACEAAACFIAWAgQAAwBYPGwQiEAQbZg8BG2gU
+HMAQCgAbQAQAG24DAABhDxwdIgEAHSb5DwBhZAwAEADABhEBAAQn/AAEZAAAGyQCABslOBzAEQAA
+ACEAABslQAAbJDAcwBEAAAAhDxwdIhgBHSYYAMcQmKaAgQAAwBcgAMcQoKaAgQAAwBcAAAAhrEqA
+gQIAXG4RAABh+EHEEA8bCSIACwk5AgAKYgMBCmIEAgpiAAAJQAQAAGEJAAlAAgAAYQoACUAAAABh
+AgAJQQAJGigAAMAWAQAbJgAAwBcEAB0mAQAIJ+kACGQAAAAhAAAAAIwBAAABAQEBAQAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAABw5AADwOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKKA
+AAAAAAAAAAAAAAAAAAEAAAAHAAAAAAAAAMAAkADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAADAAAAaLGAAAAAAAAAAAAAQLWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAA/wAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIi6gAConQEAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wEAAAAAAAAAAAAAAQAA
+AAEAAAAAAAAAAAAAAAAAAAABAQECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABosYAAfN8BAAAA
+AABosYAATOYBAAAAAAAAAAAAaLGAAOTnAQAAAAAAAAAAAAAAAABosYAAAAAAAAAAAAAAAAAA/wAA
+AAAAAAAAAAAAUPEBAFDxAQBQ8QEAVPEBAAAAAAAdAAAAAAAAAAAAAAAAAAAAAAAAAH9/AAEAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAABAgQIAAgQIAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAAAAAAAAAAcAAAAHAAAABwAAAAIAAAACAAAAgwAAAJIA
+AADoAAAA9wAAAE4BAABdAQAAAAABAAIAAACDAAAAkgAAAOgAAAD3AAAATgEAAF0BAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAQAPAGQAAQDICIAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAEAAgAAAIMAAACSAAAA6AAAAPcAAABOAQAAXQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAOAIAAAVAAAABEeAAAQrAAAEKwAABCsAADBBAAAEKwAABCsAALA8AAAE
+KwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAABQHgAA+B8AABAgAAB8IQAA/CEAAIAh
+AAAEKwAABCsAAGhNAAAoTwAAEFAAAAQrAAAEKwAABCsAAOxLAABEYgAAQGIAAJhiAAAEKwAABCsA
+AAQrAAA8QwAABCsAAHxiAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAADRBAAAEKwAA
+BCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAE
+KwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAChEAAAEKwAABCsAAAQrAAAEKwAABCsAAAxF
+AAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAHBpAAAEKwAA0GoA
+AAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAAaG0AAAQrAAAEKwAABCsAAAQrAAAEKwAA
+BCsAAAQrAAAEKwAABCsAAAQrAAAEKwAAzIIBAByGAQAEKwAAaIgBAAQrAAAUigEAwFYBAAQrAAAE
+KwAA1FAAAAQrAAAEKwAABCsAAAQrAAAEKwAAuNcBAAzYAQAEKwAABCsAAAQrAAAEKwAABCsAAAQr
+AAAEKwAABCsAAAQrAAAEKwAABCsAAPx0AAAEKwAABCsAAAQrAADY3QEABCsAAOjhAQAEKwAAvP8B
+AAQrAAAgJQAAJCUAAAQrAAAEKwAAePABALx3AAAEKwAABCsAAAQrAABE2wEABCsAAAQrAAA0UAEA
+dKEBAAQrAAAEKwAABCsAADyqAQDcVwEABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAAMK0BAAQrAABw
+7wEAdO8BAIDvAQCE7wEAeO8BAHzvAQCI7wEABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQr
+AAAEKwAAuFIAAAQrAAAEKwAABCsAAAQrAAAEKwAAxO4BABTvAQAQRwAABCsAAAQrAAAEKwAABCsA
+AAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAA
+BCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAEKwAABCsAAAQrAAAE
+KwAABCsAAAQrAAAEKwAABCsAAIhIAAAQSQAAoEkAAFRKAABwhgAALEoAAAQrAAAEKwAABCsAAAQr
+AAAEKwAAgEgAAIRIAAAEKwAABCsAAARRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAACUDAAAlAwAAJQMAACUDAAAlAwAAJQMAACUDAAAlAwAAJQMAACUDAAAlAwA
+AJQMAACUDAAAlAwAAJQMAACUDAAAlAwAAJQMAACUDAAAlAwAAJQMAACUDAAAlAwAAJQMAACUDAAA
+lAwAAJQMAACUDAAAlAwAAJQMAACUDAAAxA0AAAAAAAAwXQEAlAwAALgJAACUDAAAlAwAAJQMAADo
+CQAA6D8BAJCIAACUDAAAlAwAABwKAAAcCgAAHAoAABwKAAAcCgAAHAoAABwKAACUDAAAlAwAAJQM
+AACUDAAABAwAAJQMAACUDAAAlAwAAJQMAACUDAAAyA0AAJQMAACUDAAAnAkAAAMAAACQ7AEAAgAA
+ACxrAQAEAAAA3GsBAAUAAADkDQAABgAAALgzAAAIAAAA8O4BABMAAACc2AEACQAAAITjAQAKAAAA
+jO8BAA4AAACQngEADwAAAECMAQAQAAAAeIwBABkAAACYXAEADQAAABCEAQAXAAAAuHcAABEAAADk
+hgAAEgAAADxPAQABAAAAXN0BABQAAAB8qwEAFQAAAKShAQAHAAAA2G0AABYAAACs/wEAGAAAAOSg
+AAAaAAAAxA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAABAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEBAAAAAAAAAAAAABAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAP//////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4QMOHuHhAw4e4eEDDh7h4QMOHuHhAw4e4eEDDh7h4QMO
+HuHhAw4e4eEDDh7h4QMOHuHhAw4e4eEDDh7hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDw8PDw8
+PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDwVFRUVPDw8PBUVFRU8PDw8AAAAAAAAAAAAAAAAAAAA
+ADw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8FRUVFTw8PDwVFRUVPDw8PAAAAAAAAAAA
+AAAAAAAAAAA8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PDw8PBUVFRU8PDw8FRUVFTw8PDwA
+AAAAAAAAAAAAAAAAAAAAkAYAADH6rwCQBgAAMfqvAJAGAAAx+q8AkAYAADH6rwCQBgAAMfqvAJAG
+AAAx+q8AkAYAADH6rwCQBgAAMfqvAEMFAAAx+q8AQwUAADH6rwBDBQAAMfqvAEMFAAAx+q8AQwUA
+ADH6rwBDBQAAMfqvAEMFAAAx+q8AQwUAADH6rwAAAAAA3sMJAAAAAAAAAAAAAAAAAHguAQABAAAA
+xEaAAAAAAAAAAAAAAgAAAAMAAAAAAAAACAAAAAAAAAAwjBEAIL8CAAAAAADoLgEAjC8BAJgwAQBA
+MgEAmDABAEAyAQAUNAEAnDQBAAA1AQCAgICAgICAgAGAAoCAgICAAAAAANA6AQDQOgEAAAAAAAAA
+AAAAAAAAAAAAANA6AQDQOgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRGgADERoAApCCg
+ADggoAABAAAA/P///wAAAAAAAAAA5EaAAORGgACoIKAAPCCgAAgAAADz////AAAAAAAAAAAER4AA
+BEeAAKwgoABsIKAAMAAAAM////8AAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAD
+AAAAAAAAAAAAAAAAAAAASFABAAUAAAAER4AAdFUBAAD/AwCUVQEAAP8FAHhWAQAA/y0AnFYBAAD/
+PQBUVgEAAP8EADhWAQAA/yUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgWwEA
+BgAAAMRGgAAAAAAALAEAAF4BAAABAAAAAQAAAAEAAAABAAAAAwAAAAAAAAAAAAAAAGMBAARkAQB8
+ZAEApF8BANReAQDIZQEATGYBAJBmAQDgZgEAAAAAAAMAAAACAAAAAwAAAAMAAAADAAAAAQAAAAAA
+AAABAAAAAAAAAAAAAAAAAAAAqGwBAAoAAADERoAAAAAAAAAAAAAAAAAANG0BAAoAAADERoAAAAAA
+AAAAAAAAAAAA6G0BAAoAAADERoAAAAAAAAAAAAAAAAAACG8BAAoAAADERoAAAAAAAAAAAAAAAAAA
+bG0BAAoAAADERoAAAAAAAAAAAAAAAAAAgG4BAAoAAADERoAAAAAAABAAAAAAgAAAAACgABAnAADo
+AwAA6AMAAAAAAAAAAAAAAAAAAORBAQAKAAAAxEaAAAAAAAAAAAAAAAAAAORBAQAKAAAAxEaAAAAA
+AAAAAAAAAAAAAORBAQAKAAAAxEaAAAAAAAAAAAAAAAAAAORBAQAKAAAAxEaAAAAAAAAAAAAAAAAA
+AORBAQAKAAAAxEaAAAAAAAAAAAAAAAAAAORBAQAKAAAAxEaAAAAAAAAAAAAAAAAAAORBAQAKAAAA
+xEaAAAAAAAAAAAAAAAAAAORBAQAKAAAAxEaAAAAAAAAAAAAAAAAAAORBAQAKAAAAxEaAAAAAAAAA
+AAAAAAAAAORBAQAKAAAAxEaAAAAAAAAAAAAAAAAAAORBAQAKAAAAxEaAAAAAAAAAAAAAAAAAAORB
+AQAKAAAAxEaAAAAAAAAAAAAAAAAAAPSHAQAKAAAAxEaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAABQjwEAVJABACSTAQDQlQEASJgBAKybAQD4kQEANAWAADCxgAAYAAAA8LCA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAOJ4BAAYAAADERoAA/////wAAAAD//////////wAAAAAAAAAA
+AAAAAAShAQAFAAAABEeAAG4AbgBpAMAAoABQAIAAvgBQAX0APgBuAG4AaQDAAKAAUACAAL4AUAF9
+AD4AAAAAAAEBAAAAAAAAAAECAQEAAgEAAQICAgABAQACAQIBAgACAAECA///AAC5Ad8AsQAbABYB
+GwB8ARsArwAbABQBGwB6ARsAbACgANEAoAA3AaAAbwCDAHEAgwB2AIMAcwAzAG4AMwBwADMAcgAz
+ANcAMwA9ATMA1AEGANABAAB+ADwA4wA8AEkBPAB4AEkA3QBJAEMBSQB/AFoA5ABaAEoBWgCqAD8A
+qwABAA8BPwAQAQEAdQE/AHYBAQB5AGoA3gBqAEQBagCoAAAADQEAAHMBAACmADcApwABAAsBNwAM
+AQEAcQE3AHIBAQAEAAgAnAHMAJ0BzACeAcwAnwHMANUBzADWAcwA1wHMALQARwAZAUcAgAFHAJAA
+IgD1ACIAWwEiAKEAiAAGAYgAbAGIAJQAAACVAAAAmADAAJkAoACWAJAAlwAAAJQAAQCVAAEAmADA
+AJkAoACWAJAAlwAAAJQAAgCVAAMAmADAAJkAoACWAJAAlwAAAJQAAwCVAAcAmADAAJkAoACWAJAA
+lwAAAPoAAAD5AAAAAgGQAAMB0wAAAYMA/gATAPwAMwD9AHcA+gABAPkAAQACAZAAAwHTAAABgwD+
+ABMA/AAzAP0AdwD6AAIA+QADAAIBkAADAdMAAAGDAP4AEwD8ADMA/QB3APoAAwD5AAcAAgGSAAMB
+0wAAAYMA/gATAPwAMwD9AHcAXwEAAGEBAABoAZAAaQHTAGYBgwBkARMAYgEzAGMBdwBfAQEAYQEB
+AGgBkABpAdMAZgGDAGQBEwBiATMAYwF3AF8BAgBhAQMAaAGQAGkB0wBmAYMAZAETAGIBMwBjAXcA
+XwEDAGEBBwBoAZAAaQHTAGYBgwBkARMAYgEzAGMBdwCFAAAAhgAAAIcAUACIAAAAiQCgAIoAAACL
+ANAAjAAAAIUAAQCGAAEAhwBQAIgAAACJAKAAigAAAIsA0ACMAAAAhQACAIYAAwCHAFAAiAAAAIkA
+oACKAAAAiwDQAIwAAACFAAMAhgAHAIcAUACIAAAAiQCgAIoAAACLANAAjAAAAOsAAADqAAAA7ABQ
+AO0AAADuAKAA7wAAAPAA0ADxAAAA6wABAOoAAQDsAFAA7QAAAO4AoADvAAAA8ADQAPEAAADrAAIA
+6gADAOwAUADtAAAA7gCgAO8AAADwANAA8QAAAOsAAwDqAAcA7ABQAO0AAADuAKAA7wAAAPAA0ADx
+AAAAUQEAAFABAABSAVAAUwEAAFQBoABVAQAAVgHQAFcBAABRAQEAUAEBAFIBUABTAQAAVAGgAFUB
+AABWAdAAVwEAAFEBAgBQAQMAUgFQAFMBAABUAaAAVQEAAFYB0ABXAQAAUQEDAFABBwBSAVAAUwEA
+AFQBoABVAQAAVgHQAFcBAAD7/wAA//8AALkB3wCxABsAFgEbAHwBGwCvABsAFAEbAHoBGwBsAKAA
+0QCgADcBoABvAIMAcQCDAHYAgwBzADMAbgAzAHAAMwByADMA1wAzAD0BMwDUAQYA0AEAAH4APADj
+ADwASQE8AHgASQDdAEkAQwFJAH8AWgDkAFoASgFaAKoAPwCrAAEADwE/ABABAQB1AT8AdgEBAHkA
+agDeAGoARAFqAKgAAAANAQAAcwEAAKYANwCnAAEACwE3AAwBAQBxATcAcgEBAAQACACcAcwAnQHM
+AJ4BzACfAYgA1QHMANYBzADXAcwAtABHABkBRwCAAUcAkAAiAPUAIgBbASIAoQCIAAYBiABsAYgA
++gAAAPkAAAACAZcAAwHQAAABjQD+ABEA/AAzAP0AdwD6AAEA+QABAAIBlwADAdAAAAGNAP4AEQD8
+ADMA/QB3APoAAgD5AAMAAgGXAAMB0AAAAY0A/gARAPwAMwD9AHcA+gADAPkABwACAZcAAwHQAAAB
+jQD+ABEA/AAzAP0AdwBfAQAAYQEAAGgBlwBpAdAAZgGNAGQBEQBiATMAYwF3AF8BAQBhAQEAaAGX
+AGkB0ABmAY0AZAERAGIBMwBjAXcAXwECAGEBAwBoAZcAaQHQAGYBjQBkAREAYgEzAGMBdwBfAQMA
+YQEHAGgBlwBpAdAAZgGNAGQBEQBiATMAYwF3AOsAAADqAAAA7ABVAO0AAADuAKoA7wAAAPAA3QDx
+AAAA6wABAOoAAQDsAFUA7QAAAO4AqgDvAAAA8ADdAPEAAADrAAIA6gADAOwAVQDtAAAA7gCqAO8A
+AADwAN0A8QAAAOsAAwDqAAcA7ABVAO0AAADuAKoA7wAAAPAA3QDxAAAAUQEAAFABAABSAVUAUwEA
+AFQBqgBVAQAAVgHdAFcBAABRAQEAUAEBAFIBVQBTAQAAVAGqAFUBAABWAd0AVwEAAFEBAgBQAQMA
+UgFVAFMBAABUAaoAVQEAAFYB3QBXAQAAUQEDAFABBwBSAVUAUwEAAFQBqgBVAQAAVgHdAFcBAAD7
+/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKwBALTNAQCwu4AAQAUA
+AAAAAACgrAEAwK0BAPDAgAD4AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhNIBAIzQAQDowoAA
+VAAAAAAAAACgrAEAuNABAGjDgABQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAoKwBANTMAQC0
+V4AAUAEAAAAAAACgrAEA7M4BAOgGgAACAAAAAAAAAKCsAQBEzwEA7AaAAAQAAAAAAAAAgNIBAMCt
+AQA8w4AAKgAAAAAAAACgrAEA4M8BAAAAAAAAAAAAAAAAAKCsAQCgzwEA8AaAAAQAAAAAAAAAAAAA
+AAAAAAABAAIAAgADAAQABAAFAAYABgAHAAgACAAJAAoACgALAAwADAANAA4ADgAPACYAJwAoACgA
+KQAqAEYARgBHAEgASABJAEoASgBLAEwAaABpAGoAagBrAGwAbABtAG4AbgBvAHAAcABxAHIAcgBz
+AHQAdAB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AHUAdQB1AA8APwAAAAAAAAAAAAAA
+AAAAAAEAAgACAAMABAAEAAUABgAGAAcACAAIAAkACgAKAAsAJAAkACUAJgAmACcARABEAEUARgBG
+AEcASABIAEkASgBKAEsATABMAE0AagBqAGsAbABsAG0AbgBuAG8AcABwAHEAcgByAHMAdAB0AHUA
+dgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AHYAdgB2AA4APwCIpwEAEtIAAAAAAAD/
+/w8ARLsBALYAAAAAAAAA/wAAAES7AQC3AAAAAAAAAP8AAABEuwEAuAAAAAAAAAD/AAAARLsBALkA
+AAAAAAAA/wAAAES7AQC6AAAAAAAAAP8AAABEuwEAuwAAAAAAAAD/AAAARLsBAL0AAAAAAAAA/wAA
+AES7AQC+AAAAAAAAAP8AAABEuwEAvwAAAAAAAAD/AAAARLsBAMAAAAAAAAAA/wAAAES7AQDBAAAA
+AAAAAP8AAABEuwEAwgAAAAAAAAD/AAAAiKcBABPSAAAAAAAA//8PAES7AQAbAQAAAAAAAP8AAABE
+uwEAHAEAAAAAAAD/AAAARLsBAB0BAAAAAAAA/wAAAES7AQAeAQAAAAAAAP8AAABEuwEAHwEAAAAA
+AAD/AAAARLsBACABAAAAAAAA/wAAAES7AQAiAQAAAAAAAP8AAABEuwEAIwEAAAAAAAD/AAAARLsB
+ACQBAAAAAAAA/wAAAES7AQAlAQAAAAAAAP8AAABEuwEAJgEAAAAAAAD/AAAARLsBACcBAAAAAAAA
+/wAAAIinAQAU0gAAAAAAAP//DwBEuwEAggEAAAAAAAD/AAAARLsBAIMBAAAAAAAA/wAAAES7AQCE
+AQAAAAAAAP8AAABEuwEAhQEAAAAAAAD/AAAARLsBAIYBAAAAAAAA/wAAAES7AQCHAQAAAAAAAP8A
+AABEuwEAiQEAAAAAAAD/AAAARLsBAIoBAAAAAAAA/wAAAES7AQCLAQAAAAAAAP8AAABEuwEAjAEA
+AAAAAAD/AAAARLsBAI0BAAAAAAAA/wAAAES7AQCOAQAAAAAAAP8AAACIpwEACNIAAAAAAAD//wMA
+yKcBAACCAAAAAAAA/wEAAMinAQABggAAAAAAAP8BAACIpwEACdIAAAAAAAD//wMAyKcBAAKCAAAA
+AAAA/wEAAMinAQADggAAAAAAAP8BAACIpwEACtIAAAAAAAD//wMAyKcBAASCAAAAAAAA/wEAAMin
+AQAFggAAAAAAAP8BAACIpwEABtIAAAAAAAD/AQAAiKcBAAfSAAAAAAAA/wMAAIinAQAG0gAACQAA
+AAD+AwCIpwEAB9IAAAoAAAAA/A8AiKcBAAbSAAASAAAAAAD8B4inAQAH0gAAFAAAAAAA8D+IpwEA
+FdIAAAAAAAD/AwAAiKcBAAzSAAAAAAAA/wEAAIinAQAV0gAACgAAAAD8DwCIpwEADNIAAAkAAAAA
+/gMAiKcBABXSAAAUAAAAAADwP4inAQAM0gAAEgAAAAAA/AcwgAAAqqqqqjGAAACqqqqqMoAAAACq
+qqozgAAAAAAAADSAAAAAAAAANYAAAAAAAAA2gAAAAAAAADeAAAAAAAAAOIAAAAAAAAA5gAAAAAAA
+ADqAAAAAAAAAO4AAAAAAAAA8gAAAAAAAAD2AAACqqgoAPoAAAKqqqqo/gAAAqqqqqkCAAAAAAAAA
+MIAAAKqqqqoxgAAAqqqqqjKAAAAAqqqqM4AAAAAAAAA0gAAAAAAAADWAAAAAAAAANoAAAAAAAAA3
+gAAAAAAAADiAAAAAAAAAOYAAAAAAAAA6gAAAAAAAADuAAAAAAAAAPIAAAAAAAAA9gAAAqqoKAD6A
+AACqqqqqP4AAAKqqqqpAgAAAAAAAADCAAAAAAAAAMYAAAAAAAAAygAAAAAAAADOAAAAAAAAANIAA
+AKqqqqo1gAAAqqqqqjaAAAAAAAAAN4AAAAAAAAA4gAAAAAAAADmAAAAAAAAAOoAAAKqqqgo7gAAA
+qqqqqjyAAAAAAAAAPYAAAAAAAAA+gAAAAAAAAD+AAAAAAAAAQIAAAAAAAAAwgAAAAAAAADGAAAAA
+AAAAMoAAAAAAAAAzgAAAAAAAADSAAACqqqqqNYAAAKqqqqo2gAAAAAAAADeAAAAAAAAAOIAAAAAA
+AAA5gAAAAAAAADqAAACqqqoKO4AAAKqqqqo8gAAAAAAAAD2AAAAAAAAAPoAAAAAAAAA/gAAAAAAA
+AECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAA0BYAAMLGAABgAAADwsIAAAAAAAAAAAAAAAAAAAAAAAAAAAABM3wEABgAAAMRGgAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQF
+gAAwsYAAGAAAAPCwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAJTrAQAEAAAAxEaAAAAAAAAAAAAAAAAA
+AGzqAQAEAAAAxEaAAAAAAAAAAAAAAAAAAFzsAQAGAAAAxEaAAAAAAAAAAAAAAAAAAGzqAQAEAAAA
+xEaAAAAAAAAAAAAAAAAAAJTrAQAEAAAAxEaAAAAAAAAAAAAAAAAAAGzqAQAEAAAAxEaAAAAAAAAA
+AAAAAAAAAJTrAQAEAAAAxEaAAAAAAAAAAAAAAAAAAGzqAQAEAAAAxEaAAAAAAAAAAAAAAAAAAFzs
+AQAGAAAAxEaAAAAAAAAAAAAAAAAAAGzqAQAEAAAAxEaAAAAAAAAAAAAAAAAAAJTrAQAEAAAAxEaA
+AAAAAAAAAAAAAAAAAFzsAQAGAAAAxEaAAAAAAAAAAAAAAAAAAJTrAQAEAAAAxEaAAAAAAAAAAAAA
+AAAAAJTrAQAEAAAAxEaAAAAAAAAAAAAAAAAAAFzsAQAGAAAAxEaAADQFgAAwsYAAGAAAAPCwgAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAQIDBAQEBAQFBgcICAgICAkKCwwNAAAABQYHCA0ODxAVFhcYGQAACg0RFAoNERQZGRkZ
+CgoAAAAAAAAGBgYGCQkJCQAGAABuO2g7YjtcO246aDpiOlw6bjloOWI5XDluK2grYitcK24qaCpi
+KlwqbiloKWIpXCluG2gbYhtcG24aaBpiGlwabhloGWIZXBluGGgYYhhcGG4XaBdiF1wXbhZoFmIW
+XBZuFWgVYhVcFW4UaBRiFFwUbhNoE2ITXBNuEmgSYhJcEm4RaBFiEVwRbhBoEGIQXBBXEFIQTRBJ
+EG4BaAFiAVwBbgBoAGIAXABuO2g7YjtcO246aDpiOlw6bjloOWI5XDluOGg4YjhcOG43aDdiN1w3
+biloKWIpXCluKGgoYihcKG4naCdiJ1wnbhloGWIZXBluGGgYYhhcGG4XaBdiF1wXbgloCWIJXAlu
+CGgIYghcCG4HaAdiB1wHbgZoBmIGXAZuBWgFYgVcBW4EaARiBFwEbgNoA2IDXANuAmgCYgJcAm4B
+aAFiAVwBbgBoAGIAXAAAAAAAAAAAAAAAAADUAQIACAAAAARHgAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////////AAH//wID////BP//////////////////
+////Bf8G/wf/CP8J/wr/C/8M////Df///w7///8P////EP//////////////////////////////
+////////////////Ef///xL///8T////FP///xX///8W////F////xj///8Z////Gv///xv/////
+HP///x3///8e////H////yD///8h//////////////////////8iIyT/JSYn//8o////Kf//////
+////////////////////////////////////////////////////////////////////////AQQA
+AAIFAQADBgIABAcDAAUIBAAGCQUABwoGAAgLBwAJDAgACg0JAAsOCgAMDwsADRAMAA4RDQABQAAE
+AkEBBANCAgQEQwMEBUQEBAZFBQQHRgYECEcHBAlICAS3EyIAuBQjALkVJAC7FiUAvBcmAL0YJwDA
+GSgAxBopAAcbAAAIHAEACx0CAAweAwAQHwQAIiEFACQiBgAmIwcAKCQIAColCQAsJgoALicLADAo
+DAA0KQ0AOCoOADwrDwBALBAAZC4RAGgvEgBsMBMAcDEUAHQyFQB4MxYAfDQXAIA1GACENhkAiDca
+AIw4GwCROhwAlTsdAJk8HgCdPR8AoT4gAKU/IQAkSQYCLEoKAjRLDQE8TA8BZE0RAWxOEwF0TxUB
+fFAXAYRRGQGVUh0BnVMfARzSDdIR0hDSAtIB0gPSG9IL0gCABdIS0hPSFNIEQwbSB9IE0nDSAAC1
+ABoBgQEFAAQABgAIAAkACgALAAwAgwCSAOgA9wBOAV0BDwAE0g3SEdIQ0gLSAdID0hvSAIAF0gvS
+EtIT0hTSBENw0gAAAAABAAAA////////////////AwAAAAIAAAADAAAAAwAAAAAAAAD/////AAAA
+AAAAAAAAAAAA/wMAAAAAAAC1ABoBgQEEAA8ABgAIAAkACgALAAwAAAAAAAAAAAAsAAEAFQAVABUA
+AQABAAEAAAA4AAAAaAAAAHQAAACAAAAAjAAAAJ0AAAAHAAAABAAAAAgAAAAQAAAAQAAAAIAAAAAg
+AAAAAAAAAAkAAAASAAAAAAAAAAoAAAAUAAAAOAAAAGgAAAB0AAAAgAAAAIwAAACdAAAABwAAAAAA
+AAAAAAAACgAAAA3SEdIQ0gLSAdID0hvSC9IAgAXSEtIT0hTSBEMI0gnSCtIc0gbSB9Jw0gAAAQAA
+AAAAAAAAAAAAAAAAAAMAAAAEAAAAAwAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAP8DAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtQAaAYEBBAAPAIMA6ABOAZIA9wBdAQYACAAJAAoACwAM
+AAUAAAAAAAAALAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQABAAAA/////wAAAAAtAQAA3QEAAFoC
+AAC6AgAACgMAAE0DAACHAwAAugMAAOgDAAARBAAANwQAAFkEAAB6BAAAmAQAALQEAADOBAAA5wQA
+AP4EAAAVBQAAKgUAAD4FAABRBQAAZAUAAHUFAACGBQAAlwUAAKcFAAC2BQAAxQUAANMFAADhBQAA
+7gUAAPsFAAAIBgAAFAYAACAGAAArBgAANwYAAEIGAABMBgAAVwYAAGEGAABrBgAAdQYAAH4GAACI
+BgAAkQYAAJoGAACiBgAAqwYAALQGAAC8BgAAxAYAAMwGAADUBgAA2wYAAOMGAADqBgAA8gYAAPkG
+AAAABwAABwcAAA4HAAAUBwAAGwcAACIHAAAoBwAALgcAADUHAAA7BwAAQQcAAEcHAABNBwAAUwcA
+AFgHAABeBwAAZAcAAGkHAABvBwAAdAcAAHkHAAB/BwAAhAcAAIkHAACOBwAAkwcAAJgHAACdBwAA
+ogcAAKcHAACrBwAAsAcAALUHAAC5BwAAvgcAAMIHAADHBwAAywcAANAHAADUBwAA2AcAANwHAADh
+BwAA5QcAAOkHAADtBwAA8QcAAPUHAAD5BwAA/QcAAAEIAAAFCAAACAgAAAwIAAAQCAAAFAgAABcI
+AAAbCAAAHwgAACIIAAAmCAAAKQgAAC0IAAAwCAAANAgAADcIAAA7CAAAPggAAEEIAABFCAAASAgA
+AEsIAABPCAAAUggAAFUIAABYCAAAWwgAAF8IAABiCAAAZQgAAGgIAABrCAAAbggAAHEIAAB0CAAA
+dwgAAHoIAAB9CAAAgAgAAIIIAACFCAAAiAgAAIsIAACOCAAAkQgAAJMIAACWCAAAmQgAADgAAABo
+AAAAdAAAAIAAAACMAAAAnQAAAAcAAAAAAAAAAAAAAAoAAAAN0hHSENIC0gHSA9Ib0gvSAIAF0hLS
+E9IU0gRDCNIJ0grSHNIG0gfScNIAAAEAAAAAAAAAAAAAAAAAAAADAAAABAAAAAMAAAAAAAAAAwAA
+AAAAAAAAAAAAAAAAAAAAAAD/AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALUAGgGBAQQA
+DwCDAOgATgGSAPcAXQEGAAgACQAKAAsADAAFAAAAAAAAACwAAQAAAAAAAAAAAAAAAAAAAAAAAAAB
+AAEAAQAAAN8AAAAZAQAAYgEAAL4BAAAyAgAAwwIAAHsDAABiBAAAhAUAAPIGAAC+CAAAAgsAAAEA
+AAACAAAAAAAAAAvSDtIN0gjSCdIK0hLSE9IU0hHSENIC0gHSA9IAgAXSBEMb0hzSBNIARTDSMdIA
+AAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAHAAAAAAAAAAMAAAAEAAAA
+AwAAAAAAAAD/AwAAAwAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAtQAaAYEBBQAE
+AA8AEAAKAAsADABOAAAAAAAAAAAAAAAsAAEAAAABAAEAAQAAAAAAAAAAAAEAAQACAAIAAgADAAMA
+BAAEAAUABQAGAAYABwAHAAgACAAJAAkACgAKAAsACwAMAAwADQANAA4ADgAPAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAEAAAAPAD8AAQAAAA8APwABAAAADwA/AAIA
+AAAPAD8AAQAAAAAAAAABAAAAAgAAAAMAAAAAAAAABAAAAAIAAAAFAAAADxQZHigKBQDBCQGlADw4
+NDAsKCQgHBgUEAwIBAAMCAQAPDg0MCwoJCAcGBQQDAgEAggADgAAAA4BAQABAgEBAQAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXG
+hPiZ7o32Df+91rHeVJFQYAMCqc59VhnnYrXmTZrsRY+dH0CJh/oV7+uyyY4L++xBZ7P9X+pFvyP3
+U5bkW5vCdRzhrj1qTFpsQX4C9U+DXGj0UTTRCPmT4nOrU2I/KgwIUpVlRl6dKDChNw8KtS8JDjYk
+mxs93ybNaU7Nf5/qGxKeHXRYLjQtNrLc7rT7W/akTXZht859e1I+3XFelxP1pmi5AAAswWBAH+PI
+ee22vtRGjdlnS3LelNSY6LBKhWu7KsXlTxbtxYbXmlVmlBHPihDpBgSB/vCgRHi6JeNL86L+XcCA
+igWtP7whSHAE8d9jwXd1r2NCMCAa5Q79bb9MgRQYNSYvw+G+ojXMiDkuV5PyVYL8R3qsyOe6KzKV
+5qDAmBnRnn+jZkR+VKs7gwvKjCnH02s8KHmn4rwdFnatO9tWZE50HhTbkgoMbEjkuF2fbr3vQ6bE
+qDmkMTfTi/Iy1UOLWW632owBZLHSnOBJtNj6rAfzJc+vyo706UcYENVviPBvSnJcJDjxV8dzUZcj
+y3yhnOghPt2W3GGGDYUPkOBCfMRxqszYkAUGAfcSHKPCX2r5rtBpkRdYmSc6uSc42RPrsyszIrvS
+cKmJB6czti0iPJIVIMlJh/+qeFB6pY8D+FmACRca2mUx18aEuNDDgrApd1oRHst7/KjWbTosAQEB
+AQEBAQECAgICAgICAgMDAwMDAwMDBAQEBAQEBAQBAgICAgICAwMDAwMDAwMDAwMDAwMEBAQEBAQE
+BAQEBAQEBAQEBAQEBAQEBAQAAAAAAQECAQICA3//Bw8fPwEDAQMPBwEHDx8/f///BQAHAgMEBgZ0
+0UUX6KKLLg0PBQcJCwEDChQ3blVVVQFLaC8BVVVVBeM4jgOqqqoCcRzHAaqqqgrHcRwHDw8PBwYH
+AgMEBQABCAkLCigAKAAwACwALAAoADwANAAoACgANAAwACwALABEADwAQAA8AIwAbABYAEgA9ACw
+ACwALAA8ADQAMAAsAFQARABUAFQAbABgAFwAVACMAHgAOgECAdUA3wDaAKIAdQB/AGoBGgHZAOgA
+CgG6AHkAiACKBSoDOQGoAYoFygLZAEgBygFKAeIA+QDKAeoAggCZAPQCRAK1AdUBlAKEAfUAQQKs
+AJAAhACAAHgAeAB4AHQAZuYAAJ3YiZ1O7MRONEiDNCd2YicapEEaEzuxExEYgREP/MAPTuzETid2
+YicapEEaEzuxEw3SIA2JndgJCIzACAd+4Ac0SIM0GqRBGhEYgREN0iANCIzACAZpkAawstUFBVRA
+BSd2YicTO7ETDdIgDYmd2AkGaZAGxE7sBARGYAQDP/ADqqqqqhqkQRoTO7ETD/zADxEYgREN0iAN
+CqiAChM7sRMP/MAPD/zADw3SIA0LtEALC7RAC4md2AkN0iANCqiACgqogAoIjMAIB3iABwd4gAcG
+aZAGD/zADw3SIA0LtEALDdIgDQu0QAuJndgJCIzACImd2AkIjMAIB37gBwd+4AfBLCkHCqiACgiM
+wAgHeIAHCIzACAd4gAcGaZAGsLLVBQZpkAawstUFBVRABQVUQAXWHcYEQAOABsAJAA2AEwAaQB2A
+IIAGAA2AEwAaACcANIA6AEHACYATQB0AJ4A6AE7AV4BhmQMzB9kKcw6mFeYcgCAZJDMHcw6mFeYc
+WSvMOQBBM0jZCqYVgCBZKwBBplaAYVlsMAAAADYAAAAMAAAAEgAAABgAAAAkAAAABgAAAAkAAAAA
+AAAAAAAAABggFBQODhQUBQYBAgMEAAAAAQECAQICAwQMDAgEDAQEQAAAAIAAAAAAAQAAAAIAAEAA
+AAAABAAAQAAAAEAAAAAQERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uL0BBQkNERUZHSElK
+S0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8zEwAA
+AAcHDwcPDxctAA8gAPBhAAAAAAAAAAAAAAECBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTI6NTc6MDcAAAAATi2uAGmuoK6Q
+rmIAAaendQCnjZanp1oACQAAAAIAAAAAAAAAAAAAAAkAAAACAAAAAAAAAAAAAAAJAAAAAwAAAAEA
+AAAJAAAACQAAAAIAAAACAAAACQAAAAECAQIDBAAABQYHCAkKAAAABQYAAgQABQAAAAAABQcBAwQA
+BQEAAABAI0AlISEhIUBAQEBABQQEAQFAQEBABQVAQAwMQA0MDAEBAQVAQAUFAAQABEBAAARAQEAF
+QEBAQEAFQEBABQUFAQEBAUAFBQUBBQEBQAUFBUAFQAUFBQUFBAAAABwRAAAcMgAAHDMAAAQAAAAc
+FQAAAgAXAGwAcAR0CHQMAAQEBgAAAAAAAAAAZAAAAACQAQAKAAAAAAAAAAAAAAAAAAAA/wAAAAAA
+AAAAAAAAAAAAAAAAAAABAAAAEAAAAAAAAAABAAAAAQAAAAAAAAD/AAAA/wAAAAAAAAAAAAAA2H4B
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAAABAAAZAAAAFCFAQBY
+hQEAYIUBALSFAQC8hQEAxIUBAAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcH
+BwcHBwcHBwcHBwcHBwcHBwcHBwYGBgYGBQUFBQUEBAQEBAMDAwMDAgICAgIBAQEBAQAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiVDvU56lQAH
+FCdZLgAAAAQOCR0tNwAABA4JHSw7AAEQAAEAAAACgAABQgYCEAACIAAAA8AAAUMGAxAAAsAAAAPA
+AAFDBgQQAAJAAAACgAABRAYFEQAAQAAAA8AAAUUGBhEAAOAAAAPAAAFFBgcRAAEAAAACgAABRgYI
+EQACIAAAA8AAAUcGCREAAsAAAAPAAAFHBgoRAAJAAAACgAABSAYLEgAAQAAAA8AAAUkGDBIAAOAA
+AAPAAAFJBg0SAAEAAAACgAABSgYOEgACAAAAAoAAAUwGAAAiFgAAgAAAAwAAAVkAJBYAAQAAAAMA
+AAFaACYWAAIAAAAEAAABWgAoFgACAAAAAwAAAVsAKhYAAoAAAAMAAAFcACwXAAAAAAAEAAABXAAu
+FwAAgAAAAwAAAV0AMBcAAQAAAAMAAAFeADQXAAIAAAADAAABXwA2FwACgAAAAwAAAWAAOBgAAAAA
+AAQAAAFgADwYAAEAAAADAAABYgA+GAACAAAABAAAAWIAQBgAAgAAAAMAAAFjAGQbAAIAAAADAAAB
+bwFmGwACgAAAAwAAAXABaBwAAAAAAAQAAAFwAWwcAAEAAAADAAABcgFuHAACAAAABAAAAXIBcBwA
+AgAAAAMAAAFzAnQdAAAAAAAEAAABdAJ2HQAAgAAAAwAAAXUCeB0AAQAAAAMAAAF2AnwdAAIAAAAD
+AAABdwN+HQACgAAAAwAAAXgDgB4AAAAAAAQAAAF4A4QeAAEAAAADAAABegOGHgACAAAABAAAAXoE
+iB4AAgAAAAMAAAF7BIwfAAAAAAAEAAABfASRHwABQAAAAwAAAX4ElR8AAwAAAAQAAAF/BZcfAALA
+AAADAAABgAWZIAAAQAAAAwAAAYEFnSAAAUAAAAMAAAGCBZ8gAAHAAAADAAABgwWhIAADAAAABAAA
+AYMFpSEAAEAAAAMAAAGFBQAACxkVGRcAAABY5AEAbOQBANTkAQAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAABAQEBAQEBAQICAgICAgIC
+AwMDAwMDAwMBAgAADgAAACoAAAAJAAAACwAAABX2Y/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/QX9
+2fyr/H38Tfwc/Or7tvuB+0v7FPvc+qL6Z/or+u75sPlw+S/57fip+GX4H/jY95D3Rvf89rD2Y/Zw
+uYO6lruqvL690r7nv/zAEcInwz3EU8VqxoDHl8ivycbK3sv2zA/OJ89A0FnRctKM06bUv9Xa1vTX
+Dtkp2kTbX9x63Zbesd/N4OnhBeMh5D7lWuZ355PosOnN6urrB+0k7kLvX/B98ZryuPPV9PP1Efcv
++Ez5avqI+6b8xP3i/gAAHgE8AloDeASWBbQG0QfvCA0KKwtIDGYNgw6hD74Q3BH5EhYUMxVQFm0X
+iRimGcIa3xv7HBceMx9PIGohhiKhI7wk1yXyJgwoJilBKlordCyOLacuwC/ZMPExCjMiNDo1UTZp
+N4A4ljmtOsM72TzvPQQ/GUAuQUJCVkNqRH1FxQtkElCdGxK/YNUR6jyRESMaTxEb4g4Ryn/QEFjf
+kxAF7lgQGpofENTS5w9WiLEPmat8D1suSQ8YAxcP+hzmDtFvtg4E8IcOjZJaDu5MLg4oFQMOtuHY
+DYGprw3gY4cNjwhgDaiPOQ2d8RMNOSfvDJQpywwU8qcMZnqFDHq8YwyDskIM8VYiDGykAgzVleML
+QSbFC/dQpwttEYoLRmNtC1JCUQuHqjULA5gaCwoHAAsD9OUKdlvMCgw6swqNjJoK3k+CCgGBagoQ
+HVMKQyE8CuiKJQplVw8KN4T5Ce8O5Ak29c4JxTS6CWzLpQkJt5EJj/V9CQGFaglwY1cJAY9ECblb
+GQBqERkA9McYAFZ/GACMNxgAlfAXAG6qFwAUZRcAhSAXAMDcFgDBmRYAhlcWAA4WFgBV1RUAWpUV
+ABtWFQCUFxUAxdkUAKycFABFYBQAjyQUAIjpEwAurxMAf3UTAHo8EwAbBBMAYcwSAEuVEgDWXhIA
+ASkSAMrzEQAuvxEALYsRAMRXEQDxJBEAtPIQAArBEADxjxAAaF8QAG4vEAAAABAAHdEPAMOiDwDy
+dA8ApkcPAOAaDwCc7g4A2sIOAJmXDgDWbA4AkEIOAMcYDgB47w0AocYNAEOeDQBbdg0A6E4NAOgn
+DQBbAQ0APtsMAJK1DABTkAwAgmsMAB1HDAAiIwwAkf8LAGjcCwCmuQsASpcLAFN1CwC/UwsAjjIL
+AL0RCwBN8QoAPNEKAImxCgAzkgoAOXMKAJpUCgBUNgoAZxgKANH6CQCT3QkAqsAJABakCQDVhwkA
+52sJAEtQCQABNQkABhoJAFr/CAD85AgA68oIACexCACvlwgAgX4IAJ1lCAABTQgArjQIAKIcCADd
+BAgAXe0HACLWBwAsvwcAeKgHAAeSBwDYewcA6mUHADxQBwDNOgcAniUHAKwQBwD4+wYAgecGAEXT
+BgBFvwYAf6sGAPSXBgChhAYAh3EGAKZeBgD7SwYAhzkGAEonBgBBFQYAbgMGAM/xBQBj4AUAK88F
+ACW+BQBRrQUArpwFADyMBQD6ewUA6GsFAAVcBQBQTAUAyjwFAHEtBQBEHgUARQ8FAHEABQDJ8QQA
+TOMEAPnUBADQxgQA0bgEAPqqBABNnQQAx48EAGmCBAAydQQAImgEADhbBAB0TgQA1UEEAFw1BAAG
+KQQA1hwEAMgQBADeBAQAF/kDAHPtAwDx4QMAkNYDAFHLAwAywAMANLUDAFeqAwCZnwMA+5QDAHyK
+AwAbgAMA2XUDALZrAwCvYQMAx1cDAPtNAwBMRAMAuToDAEIxAwDoJwMAqB4DAIQVAwB6DAMAiwMD
+ALb6AgD78QIAWekCANHgAgBi2AIADNACAM7HAgCovwIAmrcCAKOvAgDEpwIA/J8CAEuYAgCwkAIA
+LIkCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOf////O////tf///5z///8AAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAADn////zv///7X///+c////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5////87/
+//+1////nP///xMBAADhAAAArwAAAH0AAAB9AAAArwAAAMgAAADIAAAAyAAAAMgAAAATAQAA4QAA
+AK8AAAB9AAAAfQAAAK8AAADIAAAAyAAAAMgAAADIAAAAEwEAAOEAAACvAAAAfQAAAH0AAACvAAAA
+yAAAAMgAAADIAAAAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACW
+AAAAlgAAAJYAAACWAAAAlgAAAH0AAAB9AAAAfQAAAH0AAAB9AAAAlgAAAJYAAACWAAAAlgAAAJYA
+AAB9AAAAfQAAAH0AAAB9AAAAfQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAABeAQAALAEAABMBAAD6AAAA4QAAAMgAAACvAAAAfQAAAGQAAABkAAAAXgEAACwBAAATAQAA
++gAAAOEAAADIAAAArwAAAH0AAABkAAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAAAAAAAAEAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAA
+AAUFBQUFBQUFAAAAAIANAAAAIAAAgA0AAIANAAAAIAAAgA0AAAAGAAAABAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAA==
+====
diff --git a/sys/dev/aac/aac.c b/sys/dev/aac/aac.c
index 642a2dbf7ae4..b928dba02990 100644
--- a/sys/dev/aac/aac.c
+++ b/sys/dev/aac/aac.c
@@ -1880,7 +1880,7 @@ aac_init(struct aac_softc *sc)
 
 	ip->InitFlags = 0;
 	if (sc->flags & AAC_FLAGS_NEW_COMM) {
-		ip->InitFlags = INITFLAGS_NEW_COMM_SUPPORTED;
+		ip->InitFlags |= AAC_INITFLAGS_NEW_COMM_SUPPORTED;
 		device_printf(sc->aac_dev, "New comm. interface enabled\n");
 	}
 
@@ -2004,7 +2004,7 @@ aac_setup_intr(struct aac_softc *sc)
 	}
 	if (sc->flags & AAC_FLAGS_NEW_COMM) {
 		if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
-				   INTR_MPSAFE|INTR_TYPE_BIO, NULL, 
+				   INTR_MPSAFE|INTR_TYPE_BIO, NULL,
 				   aac_new_intr, sc, &sc->aac_intr)) {
 			device_printf(sc->aac_dev, "can't set up interrupt\n");
 			return (EINVAL);
diff --git a/sys/dev/aac/aac_cam.c b/sys/dev/aac/aac_cam.c
index c1164aa2d3f9..4bfe0ed5747b 100644
--- a/sys/dev/aac/aac_cam.c
+++ b/sys/dev/aac/aac_cam.c
@@ -395,7 +395,7 @@ aac_cam_action(struct cam_sim *sim, union ccb *ccb)
 			    srb->cdb_len);
 
 		/* Set command */
-		fib->Header.Command = (sc->flags & AAC_FLAGS_SG_64BIT) ? 
+		fib->Header.Command = (sc->flags & AAC_FLAGS_SG_64BIT) ?
 			ScsiPortCommandU64 : ScsiPortCommand;
 
 		/* Map the s/g list. XXX 32bit addresses only! */
@@ -512,7 +512,7 @@ aac_cam_complete(struct aac_command *cm)
 
 				scsi_sense_len = sizeof(struct scsi_sense_data);
 				bzero(&ccb->csio.sense_data, scsi_sense_len);
-				sense_len = (srbr->sense_len > 
+				sense_len = (srbr->sense_len >
 				    scsi_sense_len) ? scsi_sense_len :
 				    srbr->sense_len;
 				bcopy(&srbr->sense[0], &ccb->csio.sense_data,
diff --git a/sys/dev/aac/aac_debug.c b/sys/dev/aac/aac_debug.c
index 9d79b0bca441..9cdfd3fb271a 100644
--- a/sys/dev/aac/aac_debug.c
+++ b/sys/dev/aac/aac_debug.c
@@ -62,62 +62,62 @@ aac_print_queues(struct aac_softc *sc)
 	device_printf(sc->aac_dev, "FIB queue header at %p  queues at %p\n",
 	    &sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][0],
 	    &sc->aac_queues->qt_HostNormCmdQueue[0]);
-	device_printf(sc->aac_dev, "HOST_NORM_CMD  %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "HOST_NORM_CMD  %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][
-				      AAC_CONSUMER_INDEX], 
+				      AAC_CONSUMER_INDEX],
 	    AAC_HOST_NORM_CMD_ENTRIES);
-	device_printf(sc->aac_dev, "HOST_HIGH_CMD  %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "HOST_HIGH_CMD  %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][
-				      AAC_CONSUMER_INDEX], 
+				      AAC_CONSUMER_INDEX],
 	    AAC_HOST_HIGH_CMD_ENTRIES);
-	device_printf(sc->aac_dev, "ADAP_NORM_CMD  %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "ADAP_NORM_CMD  %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][
-				      AAC_CONSUMER_INDEX], 
+				      AAC_CONSUMER_INDEX],
 	    AAC_ADAP_NORM_CMD_ENTRIES);
-	device_printf(sc->aac_dev, "ADAP_HIGH_CMD  %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "ADAP_HIGH_CMD  %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][
-				      AAC_CONSUMER_INDEX], 
+				      AAC_CONSUMER_INDEX],
 	    AAC_ADAP_HIGH_CMD_ENTRIES);
-	device_printf(sc->aac_dev, "HOST_NORM_RESP %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "HOST_NORM_RESP %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][
 				      AAC_CONSUMER_INDEX],
 	    AAC_HOST_NORM_RESP_ENTRIES);
-	device_printf(sc->aac_dev, "HOST_HIGH_RESP %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "HOST_HIGH_RESP %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][
 				      AAC_CONSUMER_INDEX],
 	    AAC_HOST_HIGH_RESP_ENTRIES);
-	device_printf(sc->aac_dev, "ADAP_NORM_RESP %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "ADAP_NORM_RESP %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][
 				      AAC_CONSUMER_INDEX],
 	    AAC_ADAP_NORM_RESP_ENTRIES);
-	device_printf(sc->aac_dev, "ADAP_HIGH_RESP %d/%d (%d)\n", 
+	device_printf(sc->aac_dev, "ADAP_HIGH_RESP %d/%d (%d)\n",
 	    sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][
 				      AAC_PRODUCER_INDEX],
 	    sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][
 				      AAC_CONSUMER_INDEX],
 	    AAC_ADAP_HIGH_RESP_ENTRIES);
-	device_printf(sc->aac_dev, "AACQ_FREE      %d/%d\n", 
+	device_printf(sc->aac_dev, "AACQ_FREE      %d/%d\n",
 	    sc->aac_qstat[AACQ_FREE].q_length, sc->aac_qstat[AACQ_FREE].q_max);
-	device_printf(sc->aac_dev, "AACQ_BIO       %d/%d\n", 
+	device_printf(sc->aac_dev, "AACQ_BIO       %d/%d\n",
 	    sc->aac_qstat[AACQ_BIO].q_length, sc->aac_qstat[AACQ_BIO].q_max);
-	device_printf(sc->aac_dev, "AACQ_READY     %d/%d\n", 
+	device_printf(sc->aac_dev, "AACQ_READY     %d/%d\n",
 	    sc->aac_qstat[AACQ_READY].q_length,
 	    sc->aac_qstat[AACQ_READY].q_max);
-	device_printf(sc->aac_dev, "AACQ_BUSY      %d/%d\n", 
+	device_printf(sc->aac_dev, "AACQ_BUSY      %d/%d\n",
 	    sc->aac_qstat[AACQ_BUSY].q_length, sc->aac_qstat[AACQ_BUSY].q_max);
 }
 
@@ -225,8 +225,8 @@ aac_print_fib(struct aac_softc *sc, struct aac_fib *fib, const char *caller)
 
 		if (br->Command == VM_CtBlockRead) {
 			device_printf(sc->aac_dev,
-				      "  BlockRead: container %d  0x%x/%d\n", 
-				      br->ContainerId, br->BlockNumber, 
+				      "  BlockRead: container %d  0x%x/%d\n",
+				      br->ContainerId, br->BlockNumber,
 				      br->ByteCount);
 			sg = &br->SgMap;
 		}
@@ -234,7 +234,7 @@ aac_print_fib(struct aac_softc *sc, struct aac_fib *fib, const char *caller)
 			device_printf(sc->aac_dev,
 				      "  BlockWrite: container %d  0x%x/%d "
 				      "(%s)\n", bw->ContainerId,
-				      bw->BlockNumber, bw->ByteCount, 
+				      bw->BlockNumber, bw->ByteCount,
 				      bw->Stable == CSTABLE ? "stable" :
 				      "unstable");
 			sg = &bw->SgMap;
@@ -267,7 +267,7 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 		device_printf(sc->aac_dev, "EventNotify(%d)\n", aif->seqNumber);
 		switch(aif->data.EN.type) {
 		case AifEnGeneric:		/* Generic notification */
-			device_printf(sc->aac_dev, "(Generic) %.*s\n", 
+			device_printf(sc->aac_dev, "(Generic) %.*s\n",
 				  (int)sizeof(aif->data.EN.data.EG),
 				  aif->data.EN.data.EG.text);
 			break;
@@ -281,21 +281,21 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 		case AifEnContainerChange:	/* Adapter specific container
 						 * configuration change */
 			device_printf(sc->aac_dev, "(ContainerChange) "
-				      "container %d,%d\n", 
-				      aif->data.EN.data.ECC.container[0], 
+				      "container %d,%d\n",
+				      aif->data.EN.data.ECC.container[0],
 				      aif->data.EN.data.ECC.container[1]);
 			break;
 		case AifEnDeviceFailure:	/* SCSI device failed */
 			device_printf(sc->aac_dev, "(DeviceFailure) "
-				      "handle %d\n", 
+				      "handle %d\n",
 				      aif->data.EN.data.EDF.deviceHandle);
 			break;
 		case AifEnMirrorFailover:	/* Mirror failover started */
 			device_printf(sc->aac_dev, "(MirrorFailover) "
 				      "container %d failed, "
 				      "migrating from slice %d to %d\n",
-				      aif->data.EN.data.EMF.container, 
-				      aif->data.EN.data.EMF.failedSlice, 
+				      aif->data.EN.data.EMF.container,
+				      aif->data.EN.data.EMF.failedSlice,
 				      aif->data.EN.data.EMF.creatingSlice);
 			break;
 		case AifEnContainerEvent:	/* Significant container
@@ -325,7 +325,7 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 			device_printf(sc->aac_dev, "(EnclosureManagement) "
 				      "EMPID %d unit %d "
 				      "event %d\n", aif->data.EN.data.EEE.empID,
-				      aif->data.EN.data.EEE.unitID, 
+				      aif->data.EN.data.EEE.unitID,
 				      aif->data.EN.data.EEE.eventType);
 			break;
 		case AifEnBatteryEvent:		/* Significant NV battery
@@ -348,14 +348,14 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 			device_printf(sc->aac_dev, "(BatteryNeedsRecond)\n");
 			break;
 		case AifEnClusterEvent:		/* Some cluster event */
-			device_printf(sc->aac_dev, "(ClusterEvent) event %d\n", 
+			device_printf(sc->aac_dev, "(ClusterEvent) event %d\n",
 				      aif->data.EN.data.ECLE.eventType);
 			break;
 		case AifEnDiskSetEvent:		/* A disk set event occured. */
 			device_printf(sc->aac_dev, "(DiskSetEvent) event %d "
 				      "diskset %jd creator %jd\n",
-				      aif->data.EN.data.EDS.eventType, 
-				      (intmax_t)aif->data.EN.data.EDS.DsNum, 
+				      aif->data.EN.data.EDS.eventType,
+				      (intmax_t)aif->data.EN.data.EDS.DsNum,
 				      (intmax_t)aif->data.EN.data.EDS.CreatorId);
 			break;
 		case AifDenMorphComplete: 	/* A morph operation
@@ -392,7 +392,7 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 		}		
 	
 		device_printf(sc->aac_dev, "JobProgress (%d) - %s (%d, %d)\n",
-			      aif->seqNumber, status, 
+			      aif->seqNumber, status,
 			      aif->data.PR[0].currentTick,
 			      aif->data.PR[0].finalTick);
 		switch(aif->data.PR[0].jd.type) {
@@ -418,12 +418,12 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 			break;
 		case AifJobCtrZero:		/* Container clear operation */
 			device_printf(sc->aac_dev,
-				      "(ContainerZero) container %d\n", 
+				      "(ContainerZero) container %d\n",
 				      aif->data.PR[0].jd.client.container.src);
 			break;
 		case AifJobCtrCopy:		/* Container copy operation */
 			device_printf(sc->aac_dev,
-				      "(ContainerCopy) container %d to %d\n", 
+				      "(ContainerCopy) container %d to %d\n",
 				      aif->data.PR[0].jd.client.container.src,
 				      aif->data.PR[0].jd.client.container.dst);
 			break;
@@ -456,12 +456,12 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 		case AifJobCtrScrubRaid5:	/* Container Scrub Raid5
 						 * operation */
 			device_printf(sc->aac_dev,
-				      "(ContainerScrubRaid5) container %d\n", 
+				      "(ContainerScrubRaid5) container %d\n",
 				      aif->data.PR[0].jd.client.container.src);
 			break;
 		case AifJobCtrMorph:		/* Container morph operation */
 			device_printf(sc->aac_dev,
-				      "(ContainerMorph) container %d\n", 
+				      "(ContainerMorph) container %d\n",
 				      aif->data.PR[0].jd.client.container.src);
 				      /* XXX two containers? */
 			break;
@@ -476,13 +476,13 @@ aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 		case AifJobCtrRebuildMirror:	/* Container Rebuild Mirror
 						 * operation */
 			device_printf(sc->aac_dev,
-				      "(ContainerRebuildMirror) container " 
+				      "(ContainerRebuildMirror) container "
 				      "%d\n",
 				      aif->data.PR[0].jd.client.container.src);
 			break;
 		case AifJobCtrCrazyCache:	/* crazy cache */
 			device_printf(sc->aac_dev,
-				      "(ContainerCrazyCache) container %d\n", 
+				      "(ContainerCrazyCache) container %d\n",
 				      aif->data.PR[0].jd.client.container.src);
 				      /* XXX two containers? */
 			break;
diff --git a/sys/dev/aac/aac_disk.c b/sys/dev/aac/aac_disk.c
index 4a1a82b148a5..fa3b66b87c15 100644
--- a/sys/dev/aac/aac_disk.c
+++ b/sys/dev/aac/aac_disk.c
@@ -87,7 +87,7 @@ DRIVER_MODULE(aacd, aac, aac_disk_driver, aac_disk_devclass, 0, 0);
 /*
  * Handle open from generic layer.
  *
- * This is called by the diskslice code on first open in order to get the 
+ * This is called by the diskslice code on first open in order to get the
  * basic device geometry paramters.
  */
 static int
diff --git a/sys/dev/aac/aac_pci.c b/sys/dev/aac/aac_pci.c
index bc993791f8ba..6f59e68053db 100644
--- a/sys/dev/aac/aac_pci.c
+++ b/sys/dev/aac/aac_pci.c
@@ -177,7 +177,7 @@ struct aac_ident
 	{0x9005, 0x0285, 0x1014, 0x0312, AAC_HWIF_I960RX, 0,
 	 "IBM ServeRAID 8i"},
 	{0x9005, 0x0285, 0x9005, 0x0298, AAC_HWIF_I960RX, 0,
-	 "Adaptec SAS RAID 4000SAS"},
+	 "Adaptec RAID 4000"},
 	{0x9005, 0x0285, 0x9005, 0x0299, AAC_HWIF_I960RX, 0,
 	 "Adaptec SAS RAID 4800SAS"},
 	{0x9005, 0x0285, 0x9005, 0x029a, AAC_HWIF_I960RX, 0,
@@ -353,7 +353,7 @@ aac_pci_attach(device_t dev)
 	/* assume failure is 'not configured' */
 	error = ENXIO;
 
-	/* 
+	/*
 	 * Verify that the adapter is correctly set up in PCI space.
 	 */
 	command = pci_read_config(sc->aac_dev, PCIR_COMMAND, 2);
@@ -401,7 +401,7 @@ aac_pci_attach(device_t dev)
 
 	/*
 	 * Allocate the parent bus DMA tag appropriate for our PCI interface.
-	 * 
+	 *
 	 * Note that some of these controllers are 64-bit capable.
 	 */
 	if (bus_dma_tag_create(NULL, 			/* parent */
@@ -419,7 +419,7 @@ aac_pci_attach(device_t dev)
 		goto out;
 	}
 
-	/* 
+	/*
 	 * Detect the hardware interface version, set up the bus interface
 	 * indirection.
 	 */
diff --git a/sys/dev/aac/aac_tables.h b/sys/dev/aac/aac_tables.h
index 4a0d0e3dddd4..fe687fb8477b 100644
--- a/sys/dev/aac/aac_tables.h
+++ b/sys/dev/aac/aac_tables.h
@@ -34,40 +34,42 @@
  * relevant only to FSA operations.
  */
 static struct aac_code_lookup aac_command_status_table[] = {
-	{"OK",					0},
-	{"operation not permitted",		1},
-	{"not found",				2},
-	{"I/O error",				5},
-	{"device not configured",		6},
-	{"too big",				7},
-	{"permission denied",			13},
-	{"file exists",				17},
-	{"cross-device link",			18},
-	{"operation not supported by device",	19},
-	{"not a directory",			20},
-	{"is a directory",			21},
-	{"invalid argument",			22},
-	{"file too large",			27},
-	{"no space on device",			28},
-	{"readonly filesystem",			30},
-	{"too many links",			31},
-	{"operation would block",		35},
-	{"file name too long",			63},
-	{"directory not empty",			66},
-	{"quota exceeded",			69},
-	{"stale file handle",			70},
-	{"too many levels of remote in path",	71},
-	{"bad file handle",			10001},
-	{"not sync",				10002},
-	{"bad cookie",				10003},
-	{"operation not supported",		10004},
-	{"too small",				10005},
-	{"server fault",			10006},
-	{"bad type",				10007},
-	{"jukebox",				10008},
-	{"not mounted",				10009},
-	{"in maintenance mode",			10010},
-	{"stale ACL",				10011},
+	{"OK",					ST_OK},
+	{"operation not permitted",		ST_PERM},
+	{"not found",				ST_NOENT},
+	{"I/O error",				ST_IO},
+	{"device not configured",		ST_NXIO},
+	{"too big",				ST_E2BIG},
+	{"permission denied",			ST_ACCES},
+	{"file exists",				ST_EXIST},
+	{"cross-device link",			ST_XDEV},
+	{"operation not supported by device",	ST_NODEV},
+	{"not a directory",			ST_NOTDIR},
+	{"is a directory",			ST_ISDIR},
+	{"invalid argument",			ST_INVAL},
+	{"file too large",			ST_FBIG},
+	{"no space on device",			ST_NOSPC},
+	{"readonly filesystem",			ST_ROFS},
+	{"too many links",			ST_MLINK},
+	{"operation would block",		ST_WOULDBLOCK},
+	{"file name too long",			ST_NAMETOOLONG},
+	{"directory not empty",			ST_NOTEMPTY},
+	{"quota exceeded",			ST_DQUOT},
+	{"stale file handle",			ST_STALE},
+	{"too many levels of remote in path",	ST_REMOTE},
+	{"device busy (spinning up)",		ST_NOT_READY},
+	{"bad file handle",			ST_BADHANDLE},
+	{"not sync",				ST_NOT_SYNC},
+	{"bad cookie",				ST_BAD_COOKIE},
+	{"operation not supported",		ST_NOTSUPP},
+	{"too small",				ST_TOOSMALL},
+	{"server fault",			ST_SERVERFAULT},
+	{"bad type",				ST_BADTYPE},
+	{"jukebox",				ST_JUKEBOX},
+	{"not mounted",				ST_NOTMOUNTED},
+	{"in maintenance mode",			ST_MAINTMODE},
+	{"stale ACL",				ST_STALEACL},
+	{"bus reset - command aborted",		ST_BUS_RESET},
 	{NULL, 					0},
 	{"unknown command status",		0}
 };
diff --git a/sys/dev/aac/aacreg.h b/sys/dev/aac/aacreg.h
index 5c849664a476..ccec8b214b71 100644
--- a/sys/dev/aac/aacreg.h
+++ b/sys/dev/aac/aacreg.h
@@ -220,20 +220,20 @@ typedef enum {
 	IsAdapterPaused =		704,
 	SendHostTime =			705,
 	RequestSupplementAdapterInfo =	706,	/* Supp. Info for set in UCC
-						 * use only if supported 
+						 * use only if supported
 						 * (RequestAdapterInfo first) */
 	LastMiscCommand =		707,
-  
-	OnLineDiagnostic =		800,      
-	FduAdapterTest =		801, 
+
+	OnLineDiagnostic =		800,
+	FduAdapterTest =		801,
 	RequestCompatibilityId =	802,
 	AdapterEnvironmentInfo =	803,	/* temp. sensors */
 	NvsramEventLog =		900,
 	ResetNvsramEventLogPointers =	901,
 	EnableEventLog =		902,
 	DisableEventLog =		903,
-	EncryptedKeyTransportFIB=	904,    
-	KeyableFeaturesFIB=		905     
+	EncryptedKeyTransportFIB=	904,
+	KeyableFeaturesFIB=		905
 } AAC_FibCommands;
 
 /*
@@ -283,7 +283,7 @@ typedef enum {
 #define AAC_ERROR_FIB_DEALLOCATION_FAILED	0x08
 
 /*
- * Adapter Init Structure: this is passed to the adapter with the 
+ * Adapter Init Structure: this is passed to the adapter with the
  * AAC_MONKER_INITSTRUCT command to point it at our control structures.
  */
 struct aac_adapter_init {
@@ -306,7 +306,7 @@ struct aac_adapter_init {
 	u_int32_t	HostElapsedSeconds;
 	/* ADAPTER_INIT_STRUCT_REVISION_4 begins here */
 	u_int32_t	InitFlags;			/* flags for supported features */
-#define INITFLAGS_NEW_COMM_SUPPORTED	1
+#define AAC_INITFLAGS_NEW_COMM_SUPPORTED	1
 	u_int32_t	MaxIoCommands;		/* max outstanding commands */
 	u_int32_t	MaxIoSize;			/* largest I/O command */
 	u_int32_t	MaxFibSize;			/* largest FIB to adapter */
@@ -329,14 +329,14 @@ typedef enum {
 	CT_MORPH,
 	CT_PASSTHRU,
 	CT_RAID4,
-	CT_RAID10,                  /* stripe of mirror */
-	CT_RAID00,                  /* stripe of stripe */
-	CT_VOLUME_OF_MIRRORS,       /* volume of mirror */
-	CT_PSEUDO_RAID3,            /* really raid4 */
-	CT_RAID50,		    /* stripe of raid5 */
-	CT_RAID5D,		    /* raid5 distributed hot-sparing */
+	CT_RAID10,		/* stripe of mirror */
+	CT_RAID00,		/* stripe of stripe */
+	CT_VOLUME_OF_MIRRORS,	/* volume of mirror */
+	CT_PSEUDO_RAID3,	/* really raid4 */
+	CT_RAID50,		/* stripe of raid5 */
+	CT_RAID5D,		/* raid5 distributed hot-sparing */
 	CT_RAID5D0,
-	CT_RAID1E,		    /* extended raid1 mirroring */
+	CT_RAID1E,		/* extended raid1 mirroring */
 	CT_RAID6,
 	CT_RAID60,
 } AAC_FSAVolType;
@@ -345,23 +345,23 @@ typedef enum {
  * Host-addressable object types
  */
 typedef enum {
-	FT_REG = 1,     /* regular file */
-	FT_DIR,         /* directory */
-	FT_BLK,         /* "block" device - reserved */
-	FT_CHR,         /* "character special" device - reserved */
-	FT_LNK,         /* symbolic link */
-	FT_SOCK,        /* socket */
-	FT_FIFO,        /* fifo */
-	FT_FILESYS,     /* ADAPTEC's "FSA"(tm) filesystem */
-	FT_DRIVE,       /* physical disk - addressable in scsi by b/t/l */
-	FT_SLICE,       /* virtual disk - raw volume - slice */
-	FT_PARTITION,   /* FSA partition - carved out of a slice - building
+	FT_REG = 1,	/* regular file */
+	FT_DIR,		/* directory */
+	FT_BLK,		/* "block" device - reserved */
+	FT_CHR,		/* "character special" device - reserved */
+	FT_LNK,		/* symbolic link */
+	FT_SOCK,	/* socket */
+	FT_FIFO,	/* fifo */
+	FT_FILESYS,	/* ADAPTEC's "FSA"(tm) filesystem */
+	FT_DRIVE,	/* physical disk - addressable in scsi by b/t/l */
+	FT_SLICE,	/* virtual disk - raw volume - slice */
+	FT_PARTITION,	/* FSA partition - carved out of a slice - building
 			 * block for containers */
-	FT_VOLUME,      /* Container - Volume Set */
-	FT_STRIPE,      /* Container - Stripe Set */
-	FT_MIRROR,      /* Container - Mirror Set */
-	FT_RAID5,       /* Container - Raid 5 Set */
-	FT_DATABASE     /* Storage object with "foreign" content manager */
+	FT_VOLUME,	/* Container - Volume Set */
+	FT_STRIPE,	/* Container - Stripe Set */
+	FT_MIRROR,	/* Container - Mirror Set */
+	FT_RAID5,	/* Container - Raid 5 Set */
+	FT_DATABASE	/* Storage object with "foreign" content manager */
 } AAC_FType;
 
 /*
@@ -467,7 +467,7 @@ typedef enum {
 	CPU_MIPS,
 	CPU_XSCALE,
 	CPU__last
-} AAC_CpuType;  
+} AAC_CpuType;
 
 typedef enum {
 	CPUI960_JX = 1,
@@ -544,7 +544,7 @@ typedef enum {
  * XXX the aac-2622 with no battery present reports PLATFORM_BAT_OPT_PRESENT
  */
 typedef enum
-{ 
+{
 	PLATFORM_BAT_REQ_PRESENT = 1,	/* BATTERY REQUIRED AND PRESENT */
 	PLATFORM_BAT_REQ_NOTPRESENT,	/* BATTERY REQUIRED AND NOT PRESENT */
 	PLATFORM_BAT_OPT_PRESENT,	/* BATTERY OPTIONAL AND PRESENT */
@@ -552,9 +552,9 @@ typedef enum
 	PLATFORM_BAT_NOT_SUPPORTED	/* BATTERY NOT SUPPORTED */
 } AAC_BatteryPlatform;
 
-/* 
+/*
  * options supported by this board
- * there has to be a one to one mapping of these defines and the ones in 
+ * there has to be a one to one mapping of these defines and the ones in
  * fsaapi.h, search for FSA_SUPPORT_SNAPSHOT
  */
 #define AAC_SUPPORTED_SNAPSHOT		0x01
@@ -577,24 +577,24 @@ typedef enum
 #define AAC_SUPPORTED_64BIT_ARRAYSIZE	0x40000
 #define AAC_SUPPORTED_HEAT_SENSOR	0x80000
 
-/* 
+/*
  * Structure used to respond to a RequestAdapterInfo fib.
  */
 struct aac_adapter_info {
-	AAC_Platform		PlatformBase;    /* adapter type */
+	AAC_Platform		PlatformBase;	 /* adapter type */
 	AAC_CpuType		CpuArchitecture; /* adapter CPU type */
-	AAC_CpuSubType		CpuVariant;      /* adapter CPU subtype */
-	u_int32_t		ClockSpeed;      /* adapter CPU clockspeed */
-	u_int32_t		ExecutionMem;    /* adapter Execution Memory
+	AAC_CpuSubType		CpuVariant;	 /* adapter CPU subtype */
+	u_int32_t		ClockSpeed;	 /* adapter CPU clockspeed */
+	u_int32_t		ExecutionMem;	 /* adapter Execution Memory
 						  * size */
-	u_int32_t		BufferMem;       /* adapter Data Memory */
-	u_int32_t		TotalMem;        /* adapter Total Memory */
+	u_int32_t		BufferMem;	 /* adapter Data Memory */
+	u_int32_t		TotalMem;	 /* adapter Total Memory */
 	struct FsaRevision	KernelRevision;  /* adapter Kernel Software
 						  * Revision */
 	struct FsaRevision	MonitorRevision; /* adapter Monitor/Diagnostic
 						  * Software Revision */
 	struct FsaRevision	HardwareRevision;/* TBD */
-	struct FsaRevision	BIOSRevision;    /* adapter BIOS Revision */
+	struct FsaRevision	BIOSRevision;	 /* adapter BIOS Revision */
 	u_int32_t		ClusteringEnabled;
 	u_int32_t		ClusterChannelMask;
 	u_int64_t		SerialNumber;
@@ -604,7 +604,7 @@ struct aac_adapter_info {
 	AAC_OemFlavor	OemVariant;
 } __packed;
 
-/* 
+/*
  * Structure used to respond to a RequestSupplementAdapterInfo fib.
  */
 struct vpd_info {
@@ -692,7 +692,7 @@ struct aac_supplement_adapter_info {
 #define AAC_KERNEL_PANIC	0x00000100
 
 /*
- * Data types relating to control and monitoring of the NVRAM/WriteCache 
+ * Data types relating to control and monitoring of the NVRAM/WriteCache
  * subsystem.
  */
 
@@ -867,7 +867,7 @@ typedef enum {
 	AifEnGeneric = 1,		/* Generic notification */
 	AifEnTaskComplete,		/* Task has completed */
 	AifEnConfigChange,		/* Adapter config change occurred */
-	AifEnContainerChange,		/* Adapter specific container 
+	AifEnContainerChange,		/* Adapter specific container
 					 * configuration change */
 	AifEnDeviceFailure,		/* SCSI device failed */
 	AifEnMirrorFailover,		/* Mirror failover started */
@@ -881,7 +881,7 @@ typedef enum {
 	AifEnBatteryEvent,		/* Significant NV battery event */
 	AifEnAddContainer,		/* A new container was created. */
 	AifEnDeleteContainer,		/* A container was deleted. */
-	AifEnSMARTEvent, 	       	/* SMART Event */
+	AifEnSMARTEvent,		/* SMART Event */
 	AifEnBatteryNeedsRecond,	/* The battery needs reconditioning */
 	AifEnClusterEvent,		/* Some cluster event */
 	AifEnDiskSetEvent,		/* A disk set event occured. */
@@ -967,7 +967,7 @@ struct aac_AifEventNotify {
 /*
  * Adapter Initiated FIB command structures. Start with the adapter
  * initiated FIBs that really come from the adapter, and get responded
- * to by the host. 
+ * to by the host.
  */
 #define AAC_AIF_REPORT_MAX_SIZE 64
 
@@ -1081,6 +1081,7 @@ typedef enum {
 	ST_DQUOT = 69,
 	ST_STALE = 70,
 	ST_REMOTE = 71,
+	ST_NOT_READY = 72,
 	ST_BADHANDLE = 10001,
 	ST_NOT_SYNC = 10002,
 	ST_BAD_COOKIE = 10003,
@@ -1091,7 +1092,8 @@ typedef enum {
 	ST_JUKEBOX = 10008,
 	ST_NOTMOUNTED = 10009,
 	ST_MAINTMODE = 10010,
-	ST_STALEACL = 10011
+	ST_STALEACL = 10011,
+	ST_BUS_RESET = 20001
 } AAC_FSAStatus;
 
 /*
@@ -1120,7 +1122,7 @@ typedef enum _VM_COMMANDS {
 	VM_CtHostRead64,
 	VM_CtHostWrite64,
 	VM_DrvErrTblLog,	/* drive error table/log type of command */
-	VM_NameServe64		 
+	VM_NameServe64
 } AAC_VMCommand;
 
 /*
@@ -1526,7 +1528,7 @@ enum {
 /*
  * The adapter can request the host print a message by setting the
  * DB_PRINTF flag in DOORBELL0.  The driver responds by collecting the
- * message from the printf buffer, clearing the DB_PRINTF flag in 
+ * message from the printf buffer, clearing the DB_PRINTF flag in
  * DOORBELL0 and setting it in DOORBELL1.
  * (ODBR and IDBR respectively for the i960Rx adapters)
  */
diff --git a/sys/dev/aac/aacvar.h b/sys/dev/aac/aacvar.h
index 3ecb262ca7eb..29eb8169e02d 100644
--- a/sys/dev/aac/aacvar.h
+++ b/sys/dev/aac/aacvar.h
@@ -56,7 +56,7 @@
  */
 
 /*
- * The firmware interface allows for a 16-bit s/g list length.  We limit 
+ * The firmware interface allows for a 16-bit s/g list length.  We limit
  * ourselves to a reasonable maximum and ensure alignment.
  */
 #define AAC_MAXSGENTRIES	64	/* max S/G entries, limit 65535 */		
@@ -78,7 +78,7 @@
 #define AAC_PRINTF_BUFSIZE	256
 
 /*
- * We wait this many seconds for the adapter to come ready if it is still 
+ * We wait this many seconds for the adapter to come ready if it is still
  * booting
  */
 #define AAC_BOOT_TIMEOUT	(3 * 60)
@@ -126,7 +126,7 @@ struct aac_sim
 /*
  * Per-disk structure
  */
-struct aac_disk 
+struct aac_disk
 {
 	device_t			ad_dev;
 	struct aac_softc		*ad_controller;
@@ -216,7 +216,7 @@ struct aac_common {
 				AAC_QUEUE_ALIGN];
 
 	/* buffer for text messages from the controller */
-	char		       	ac_printf[AAC_PRINTF_BUFSIZE];
+	char			ac_printf[AAC_PRINTF_BUFSIZE];
 	
 	/* fib for synchronous commands */
 	struct aac_fib		ac_sync_fib;
@@ -225,7 +225,7 @@ struct aac_common {
 /*
  * Interface operations
  */
-struct aac_interface 
+struct aac_interface
 {
 	int	(*aif_get_fwstatus)(struct aac_softc *sc);
 	void	(*aif_qnotify)(struct aac_softc *sc, int qbit);
@@ -300,7 +300,7 @@ struct aac_fib_context {
 /*
  * Per-controller structure.
  */
-struct aac_softc 
+struct aac_softc
 {
 	/* bus connections */
 	device_t		aac_dev;
@@ -347,7 +347,7 @@ struct aac_softc
 	struct aac_command	*aac_commands;
 
 	/* command management */
-	TAILQ_HEAD(,aac_command) aac_free;	/* command structures 
+	TAILQ_HEAD(,aac_command) aac_free;	/* command structures
 						 * available for reuse */
 	TAILQ_HEAD(,aac_command) aac_ready;	/* commands on hold for
 						 * controller resources */
@@ -416,7 +416,7 @@ struct aac_softc
 
 	struct callout	aac_daemontime;		/* clock daemon callout */
 
-	u_int32_t	aac_max_fibs;           /* max. FIB count */
+	u_int32_t	aac_max_fibs;		/* max. FIB count */
 	u_int32_t	aac_max_fibs_alloc;		/* max. alloc. per alloc_commands() */
 	u_int32_t	aac_max_fib_size;		/* max. FIB size */
 	u_int32_t	aac_sg_tablesize;		/* max. sg count from host */
@@ -447,7 +447,7 @@ extern void		aac_free(struct aac_softc *sc);
 extern int		aac_attach(struct aac_softc *sc);
 extern int		aac_detach(device_t dev);
 extern int		aac_shutdown(device_t dev);
-extern int		aac_suspend(device_t dev); 
+extern int		aac_suspend(device_t dev);
 extern int		aac_resume(device_t dev);
 extern void		aac_new_intr(void *arg);
 extern int		aac_filter(void *arg);
@@ -561,7 +561,7 @@ aac_dequeue_ ## name (struct aac_softc *sc)				\
 	if ((cm = TAILQ_FIRST(&sc->aac_ ## name)) != NULL) {		\
 		if ((cm->cm_flags & AAC_ON_ ## index) == 0) {		\
 			printf("command %p not in queue, flags = %#x, "	\
-		       	       "bit = %#x\n", cm, cm->cm_flags,		\
+			       "bit = %#x\n", cm, cm->cm_flags,		\
 			       AAC_ON_ ## index);			\
 			panic("command not in queue");			\
 		}							\
diff --git a/sys/dev/acpica/acpi.c b/sys/dev/acpica/acpi.c
index f99c525ae51d..64a331823825 100644
--- a/sys/dev/acpica/acpi.c
+++ b/sys/dev/acpica/acpi.c
@@ -2640,25 +2640,6 @@ acpi_resync_clock(struct acpi_softc *sc)
     inittodr(time_second + sc->acpi_sleep_delay);
 }
 
-/* Initialize a device's wake GPE. */
-int
-acpi_wake_init(device_t dev, int type)
-{
-    struct acpi_prw_data prw;
-
-    /* Evaluate _PRW to find the GPE. */
-    if (acpi_parse_prw(acpi_get_handle(dev), &prw) != 0)
-	return (ENXIO);
-
-    /* Set the requested type for the GPE (runtime, wake, or both). */
-    if (ACPI_FAILURE(AcpiSetGpeType(prw.gpe_handle, prw.gpe_bit, type))) {
-	device_printf(dev, "set GPE type failed\n");
-	return (ENXIO);
-    }
-
-    return (0);
-}
-
 /* Enable or disable the device's wake GPE. */
 int
 acpi_wake_set_enable(device_t dev, int enable)
@@ -2673,14 +2654,16 @@ acpi_wake_set_enable(device_t dev, int enable)
 
     flags = acpi_get_flags(dev);
     if (enable) {
-	status = AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR);
+	status = AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit,
+	    ACPI_GPE_TYPE_WAKE_RUN);
 	if (ACPI_FAILURE(status)) {
 	    device_printf(dev, "enable wake failed\n");
 	    return (ENXIO);
 	}
 	acpi_set_flags(dev, flags | ACPI_FLAG_WAKE_ENABLED);
     } else {
-	status = AcpiDisableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR);
+	status = AcpiDisableGpe(prw.gpe_handle, prw.gpe_bit,
+	    ACPI_GPE_TYPE_WAKE);
 	if (ACPI_FAILURE(status)) {
 	    device_printf(dev, "disable wake failed\n");
 	    return (ENXIO);
@@ -2710,7 +2693,7 @@ acpi_wake_sleep_prep(ACPI_HANDLE handle, int sstate)
      * and set _PSW.
      */
     if (sstate > prw.lowest_wake) {
-	AcpiDisableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR);
+	AcpiDisableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_GPE_TYPE_WAKE);
 	if (bootverbose)
 	    device_printf(dev, "wake_prep disabled wake for %s (S%d)\n",
 		acpi_name(handle), sstate);
@@ -2747,7 +2730,7 @@ acpi_wake_run_prep(ACPI_HANDLE handle, int sstate)
      * clear _PSW and turn off any power resources it used.
      */
     if (sstate > prw.lowest_wake) {
-	AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_NOT_ISR);
+	AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit, ACPI_GPE_TYPE_WAKE_RUN);
 	if (bootverbose)
 	    device_printf(dev, "run_prep re-enabled %s\n", acpi_name(handle));
     } else {
diff --git a/sys/dev/acpica/acpi_button.c b/sys/dev/acpica/acpi_button.c
index 7814c0e3fdf5..56a1d951f793 100644
--- a/sys/dev/acpica/acpi_button.c
+++ b/sys/dev/acpica/acpi_button.c
@@ -164,7 +164,6 @@ acpi_button_attach(device_t dev)
     }
 
     /* Enable the GPE for wake/runtime. */
-    acpi_wake_init(dev, ACPI_GPE_TYPE_WAKE_RUN);
     acpi_wake_set_enable(dev, 1);
     
     return_VALUE (0);
diff --git a/sys/dev/acpica/acpi_ec.c b/sys/dev/acpica/acpi_ec.c
index d4ef0191b887..000658c18484 100644
--- a/sys/dev/acpica/acpi_ec.c
+++ b/sys/dev/acpica/acpi_ec.c
@@ -518,14 +518,8 @@ acpi_ec_attach(device_t dev)
     }
 
     /* Enable runtime GPEs for the handler. */
-    Status = AcpiSetGpeType(sc->ec_gpehandle, sc->ec_gpebit,
-			    ACPI_GPE_TYPE_RUNTIME);
-    if (ACPI_FAILURE(Status)) {
-	device_printf(dev, "AcpiSetGpeType failed: %s\n",
-		      AcpiFormatException(Status));
-	goto error;
-    }
-    Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
+    Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit,
+	ACPI_GPE_TYPE_RUNTIME);
     if (ACPI_FAILURE(Status)) {
 	device_printf(dev, "AcpiEnableGpe failed: %s\n",
 		      AcpiFormatException(Status));
@@ -575,7 +569,7 @@ acpi_ec_shutdown(device_t dev)
 
     /* Disable the GPE so we don't get EC events during shutdown. */
     sc = device_get_softc(dev);
-    AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_NOT_ISR);
+    AcpiDisableGpe(sc->ec_gpehandle, sc->ec_gpebit, ACPI_GPE_TYPE_RUNTIME);
     return (0);
 }
 
diff --git a/sys/dev/acpica/acpi_lid.c b/sys/dev/acpica/acpi_lid.c
index 47d5b45c1f9d..ae29aca923cd 100644
--- a/sys/dev/acpica/acpi_lid.c
+++ b/sys/dev/acpica/acpi_lid.c
@@ -115,7 +115,6 @@ acpi_lid_attach(device_t dev)
 			     acpi_lid_notify_handler, sc);
 
     /* Enable the GPE for wake/runtime. */
-    acpi_wake_init(dev, ACPI_GPE_TYPE_WAKE_RUN);
     acpi_wake_set_enable(dev, 1);
 
     return (0);
diff --git a/sys/dev/acpica/acpivar.h b/sys/dev/acpica/acpivar.h
index f30ee6490d36..002c11c91a71 100644
--- a/sys/dev/acpica/acpivar.h
+++ b/sys/dev/acpica/acpivar.h
@@ -332,7 +332,6 @@ int		acpi_ReqSleepState(struct acpi_softc *sc, int state);
 int		acpi_AckSleepState(struct apm_clone_data *clone, int error);
 ACPI_STATUS	acpi_SetSleepState(struct acpi_softc *sc, int state);
 void		acpi_resync_clock(struct acpi_softc *sc);
-int		acpi_wake_init(device_t dev, int type);
 int		acpi_wake_set_enable(device_t dev, int enable);
 int		acpi_parse_prw(ACPI_HANDLE h, struct acpi_prw_data *prw);
 ACPI_STATUS	acpi_Startup(void);
diff --git a/sys/dev/ath/ath_hal/ar5416/ar9160.ini b/sys/dev/ath/ath_hal/ar5416/ar9160.ini
index 275aa48454b1..275aa48454b1 100755..100644
--- a/sys/dev/ath/ath_hal/ar5416/ar9160.ini
+++ b/sys/dev/ath/ath_hal/ar5416/ar9160.ini
diff --git a/sys/dev/ath/ath_hal/ar5416/ar9285_attach.c b/sys/dev/ath/ath_hal/ar5416/ar9285_attach.c
index 946133a396f0..ef8c955595db 100644
--- a/sys/dev/ath/ath_hal/ar5416/ar9285_attach.c
+++ b/sys/dev/ath/ath_hal/ar5416/ar9285_attach.c
@@ -378,8 +378,8 @@ ar9285SetAntennaSwitch(struct ath_hal *ah, HAL_ANT_SETTING settings)
 	case HAL_ANT_VARIABLE:
 		/* Restore original chainmask settings */
 		/* XXX */
-		ahp->ah_tx_chainmask = AR5416_DEFAULT_TXCHAINMASK;
-		ahp->ah_rx_chainmask = AR5416_DEFAULT_RXCHAINMASK;
+		ahp->ah_tx_chainmask = AR9285_DEFAULT_TXCHAINMASK;
+		ahp->ah_rx_chainmask = AR9285_DEFAULT_RXCHAINMASK;
 		break;
 	}
 	return AH_TRUE;
diff --git a/sys/dev/ath/if_ath.c b/sys/dev/ath/if_ath.c
index d1ddb2dff6f7..58474890e72d 100644
--- a/sys/dev/ath/if_ath.c
+++ b/sys/dev/ath/if_ath.c
@@ -3654,8 +3654,14 @@ ath_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m,
 	case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
 		if (vap->iv_opmode == IEEE80211_M_IBSS &&
 		    vap->iv_state == IEEE80211_S_RUN) {
-			uint32_t rstamp = sc->sc_lastrs->rs_tstamp;
-			u_int64_t tsf = ath_extend_tsf(rstamp,
+			uint32_t rstamp;
+			uint64_t tsf;
+
+			if (sc->sc_lastrs == NULL)
+				break;
+
+			rstamp = sc->sc_lastrs->rs_tstamp;
+			tsf = ath_extend_tsf(rstamp,
 				ath_hal_gettsf64(sc->sc_ah));
 			/*
 			 * Handle ibss merge as needed; check the tsf on the
diff --git a/sys/dev/bce/if_bce.c b/sys/dev/bce/if_bce.c
index 61f3af565af7..2ad5ab2d37f5 100644
--- a/sys/dev/bce/if_bce.c
+++ b/sys/dev/bce/if_bce.c
@@ -39,8 +39,8 @@ __FBSDID("$FreeBSD$");
  *   BCM5708S B1, B2
  *   BCM5709C A1, C0
  *   BCM5709S A1, C0
- * 	 BCM5716C C0
- * 	 BCM5716S C0
+ *   BCM5716C C0
+ *   BCM5716S C0
  *
  * The following controllers are not supported by this driver:
  *   BCM5706C A0, A1 (pre-production)
@@ -277,37 +277,41 @@ static struct flash_spec flash_5709 = {
 /****************************************************************************/
 /* FreeBSD device entry points.                                             */
 /****************************************************************************/
-static int  bce_probe				(device_t);
-static int  bce_attach				(device_t);
-static int  bce_detach				(device_t);
-static int  bce_shutdown			(device_t);
+static int  bce_probe			(device_t);
+static int  bce_attach			(device_t);
+static int  bce_detach			(device_t);
+static int  bce_shutdown		(device_t);
 
 
 /****************************************************************************/
 /* BCE Debug Data Structure Dump Routines                                   */
 /****************************************************************************/
 #ifdef BCE_DEBUG
-static u32	bce_reg_rd				(struct bce_softc *, u32);
-static void	bce_reg_wr				(struct bce_softc *, u32, u32);
-static void	bce_reg_wr16			(struct bce_softc *, u32, u16);
-static u32  bce_ctx_rd				(struct bce_softc *, u32, u32);
-static void bce_dump_enet           (struct bce_softc *, struct mbuf *);
-static void bce_dump_mbuf 			(struct bce_softc *, struct mbuf *);
+static u32  bce_reg_rd			(struct bce_softc *, u32);
+static void bce_reg_wr			(struct bce_softc *, u32, u32);
+static void bce_reg_wr16		(struct bce_softc *, u32, u16);
+static u32  bce_ctx_rd			(struct bce_softc *, u32, u32);
+static void bce_dump_enet		(struct bce_softc *, struct mbuf *);
+static void bce_dump_mbuf		(struct bce_softc *, struct mbuf *);
 static void bce_dump_tx_mbuf_chain	(struct bce_softc *, u16, int);
 static void bce_dump_rx_mbuf_chain	(struct bce_softc *, u16, int);
 #ifdef BCE_JUMBO_HDRSPLIT
 static void bce_dump_pg_mbuf_chain	(struct bce_softc *, u16, int);
 #endif
-static void bce_dump_txbd			(struct bce_softc *, int, struct tx_bd *);
-static void bce_dump_rxbd			(struct bce_softc *, int, struct rx_bd *);
+static void bce_dump_txbd		(struct bce_softc *,
+    int, struct tx_bd *);
+static void bce_dump_rxbd		(struct bce_softc *,
+    int, struct rx_bd *);
 #ifdef BCE_JUMBO_HDRSPLIT
-static void bce_dump_pgbd			(struct bce_softc *, int, struct rx_bd *);
+static void bce_dump_pgbd		(struct bce_softc *, 
+    int, struct rx_bd *);
 #endif
-static void bce_dump_l2fhdr			(struct bce_softc *, int, struct l2_fhdr *);
-static void bce_dump_ctx			(struct bce_softc *, u16);
-static void bce_dump_ftqs			(struct bce_softc *);
+static void bce_dump_l2fhdr		(struct bce_softc *,
+    int, struct l2_fhdr *);
+static void bce_dump_ctx		(struct bce_softc *, u16);
+static void bce_dump_ftqs		(struct bce_softc *);
 static void bce_dump_tx_chain		(struct bce_softc *, u16, int);
-static void bce_dump_rx_chain		(struct bce_softc *, u16, int);
+static void bce_dump_rx_bd_chain	(struct bce_softc *, u16, int);
 #ifdef BCE_JUMBO_HDRSPLIT
 static void bce_dump_pg_chain		(struct bce_softc *, u16, int);
 #endif
@@ -315,7 +319,7 @@ static void bce_dump_status_block	(struct bce_softc *);
 static void bce_dump_stats_block	(struct bce_softc *);
 static void bce_dump_driver_state	(struct bce_softc *);
 static void bce_dump_hw_state		(struct bce_softc *);
-static void bce_dump_mq_regs        (struct bce_softc *);
+static void bce_dump_mq_regs		(struct bce_softc *);
 static void bce_dump_bc_state		(struct bce_softc *);
 static void bce_dump_txp_state		(struct bce_softc *, int);
 static void bce_dump_rxp_state		(struct bce_softc *, int);
@@ -323,18 +327,18 @@ static void bce_dump_tpat_state		(struct bce_softc *, int);
 static void bce_dump_cp_state		(struct bce_softc *, int);
 static void bce_dump_com_state		(struct bce_softc *, int);
 static void bce_dump_rv2p_state		(struct bce_softc *);
-static void bce_breakpoint			(struct bce_softc *);
+static void bce_breakpoint		(struct bce_softc *);
 #endif
 
 
 /****************************************************************************/
 /* BCE Register/Memory Access Routines                                      */
 /****************************************************************************/
-static u32  bce_reg_rd_ind			(struct bce_softc *, u32);
-static void bce_reg_wr_ind			(struct bce_softc *, u32, u32);
-static void bce_shmem_wr            (struct bce_softc *, u32, u32);
-static u32  bce_shmem_rd            (struct bce_softc *, u32);
-static void bce_ctx_wr				(struct bce_softc *, u32, u32, u32);
+static u32  bce_reg_rd_ind		(struct bce_softc *, u32);
+static void bce_reg_wr_ind		(struct bce_softc *, u32, u32);
+static void bce_shmem_wr		(struct bce_softc *, u32, u32);
+static u32  bce_shmem_rd		(struct bce_softc *, u32);
+static void bce_ctx_wr			(struct bce_softc *, u32, u32, u32);
 static int  bce_miibus_read_reg		(device_t, int, int);
 static int  bce_miibus_write_reg	(device_t, int, int, int);
 static void bce_miibus_statchg		(device_t);
@@ -346,96 +350,101 @@ static void bce_miibus_statchg		(device_t);
 static int  bce_acquire_nvram_lock	(struct bce_softc *);
 static int  bce_release_nvram_lock	(struct bce_softc *);
 static void bce_enable_nvram_access	(struct bce_softc *);
-static void	bce_disable_nvram_access(struct bce_softc *);
+static void bce_disable_nvram_access	(struct bce_softc *);
 static int  bce_nvram_read_dword	(struct bce_softc *, u32, u8 *, u32);
-static int  bce_init_nvram			(struct bce_softc *);
-static int  bce_nvram_read			(struct bce_softc *, u32, u8 *, int);
-static int  bce_nvram_test			(struct bce_softc *);
+static int  bce_init_nvram		(struct bce_softc *);
+static int  bce_nvram_read		(struct bce_softc *, u32, u8 *, int);
+static int  bce_nvram_test		(struct bce_softc *);
 #ifdef BCE_NVRAM_WRITE_SUPPORT
 static int  bce_enable_nvram_write	(struct bce_softc *);
 static void bce_disable_nvram_write	(struct bce_softc *);
 static int  bce_nvram_erase_page	(struct bce_softc *, u32);
 static int  bce_nvram_write_dword	(struct bce_softc *, u32, u8 *, u32);
-static int  bce_nvram_write			(struct bce_softc *, u32, u8 *, int);
+static int  bce_nvram_write		(struct bce_softc *, u32, u8 *, int);
 #endif
 
 /****************************************************************************/
 /*                                                                          */
 /****************************************************************************/
-static void bce_get_media			(struct bce_softc *);
-static void bce_init_media			(struct bce_softc *);
-static void bce_dma_map_addr		(void *, bus_dma_segment_t *, int, int);
-static int  bce_dma_alloc			(device_t);
-static void bce_dma_free			(struct bce_softc *);
+static void bce_get_media		(struct bce_softc *);
+static void bce_init_media		(struct bce_softc *);
+static void bce_dma_map_addr		(void *, 
+    bus_dma_segment_t *, int, int);
+static int  bce_dma_alloc		(device_t);
+static void bce_dma_free		(struct bce_softc *);
 static void bce_release_resources	(struct bce_softc *);
 
 /****************************************************************************/
 /* BCE Firmware Synchronization and Load                                    */
 /****************************************************************************/
-static int  bce_fw_sync				(struct bce_softc *, u32);
+static int  bce_fw_sync			(struct bce_softc *, u32);
 static void bce_load_rv2p_fw		(struct bce_softc *, u32 *, u32, u32);
-static void bce_load_cpu_fw			(struct bce_softc *, struct cpu_reg *, struct fw_info *);
-static void bce_start_cpu           (struct bce_softc *, struct cpu_reg *);
-static void bce_halt_cpu            (struct bce_softc *, struct cpu_reg *);
-static void bce_start_rxp_cpu       (struct bce_softc *);
+static void bce_load_cpu_fw		(struct bce_softc *, 
+    struct cpu_reg *, struct fw_info *);
+static void bce_start_cpu		(struct bce_softc *, struct cpu_reg *);
+static void bce_halt_cpu		(struct bce_softc *, struct cpu_reg *);
+static void bce_start_rxp_cpu		(struct bce_softc *);
 static void bce_init_rxp_cpu		(struct bce_softc *);
 static void bce_init_txp_cpu 		(struct bce_softc *);
 static void bce_init_tpat_cpu		(struct bce_softc *);
-static void bce_init_cp_cpu		  	(struct bce_softc *);
+static void bce_init_cp_cpu	  	(struct bce_softc *);
 static void bce_init_com_cpu	  	(struct bce_softc *);
-static void bce_init_cpus			(struct bce_softc *);
+static void bce_init_cpus		(struct bce_softc *);
 
 static void	bce_print_adapter_info	(struct bce_softc *);
 static void bce_probe_pci_caps		(device_t, struct bce_softc *);
-static void bce_stop				(struct bce_softc *);
-static int  bce_reset				(struct bce_softc *, u32);
-static int  bce_chipinit 			(struct bce_softc *);
-static int  bce_blockinit 			(struct bce_softc *);
+static void bce_stop			(struct bce_softc *);
+static int  bce_reset			(struct bce_softc *, u32);
+static int  bce_chipinit 		(struct bce_softc *);
+static int  bce_blockinit 		(struct bce_softc *);
 
 static int  bce_init_tx_chain		(struct bce_softc *);
 static void bce_free_tx_chain		(struct bce_softc *);
 
-static int  bce_get_rx_buf			(struct bce_softc *, struct mbuf *, u16 *, u16 *, u32 *);
+static int  bce_get_rx_buf		(struct bce_softc *, 
+    struct mbuf *, u16 *, u16 *, u32 *);
 static int  bce_init_rx_chain		(struct bce_softc *);
 static void bce_fill_rx_chain		(struct bce_softc *);
 static void bce_free_rx_chain		(struct bce_softc *);
 
 #ifdef BCE_JUMBO_HDRSPLIT
-static int  bce_get_pg_buf			(struct bce_softc *, struct mbuf *, u16 *, u16 *);
+static int  bce_get_pg_buf		(struct bce_softc *, 
+    struct mbuf *, u16 *, u16 *);
 static int  bce_init_pg_chain		(struct bce_softc *);
 static void bce_fill_pg_chain		(struct bce_softc *);
 static void bce_free_pg_chain		(struct bce_softc *);
 #endif
 
-static struct mbuf *bce_tso_setup	(struct bce_softc *, struct mbuf **, u16 *);
-static int  bce_tx_encap			(struct bce_softc *, struct mbuf **);
+static struct mbuf *bce_tso_setup	(struct bce_softc *, 
+    struct mbuf **, u16 *);
+static int  bce_tx_encap		(struct bce_softc *, struct mbuf **);
 static void bce_start_locked		(struct ifnet *);
-static void bce_start				(struct ifnet *);
-static int  bce_ioctl				(struct ifnet *, u_long, caddr_t);
-static void bce_watchdog			(struct bce_softc *);
-static int  bce_ifmedia_upd			(struct ifnet *);
+static void bce_start			(struct ifnet *);
+static int  bce_ioctl			(struct ifnet *, u_long, caddr_t);
+static void bce_watchdog		(struct bce_softc *);
+static int  bce_ifmedia_upd		(struct ifnet *);
 static void bce_ifmedia_upd_locked	(struct ifnet *);
-static void bce_ifmedia_sts			(struct ifnet *, struct ifmediareq *);
-static void bce_init_locked			(struct bce_softc *);
-static void bce_init				(void *);
+static void bce_ifmedia_sts		(struct ifnet *, struct ifmediareq *);
+static void bce_init_locked		(struct bce_softc *);
+static void bce_init			(void *);
 static void bce_mgmt_init_locked	(struct bce_softc *sc);
 
-static void bce_init_ctx			(struct bce_softc *);
+static void bce_init_ctx		(struct bce_softc *);
 static void bce_get_mac_addr		(struct bce_softc *);
 static void bce_set_mac_addr		(struct bce_softc *);
-static void bce_phy_intr			(struct bce_softc *);
-static inline u16 bce_get_hw_rx_cons(struct bce_softc *);
-static void bce_rx_intr				(struct bce_softc *);
-static void bce_tx_intr				(struct bce_softc *);
+static void bce_phy_intr		(struct bce_softc *);
+static inline u16 bce_get_hw_rx_cons	(struct bce_softc *);
+static void bce_rx_intr			(struct bce_softc *);
+static void bce_tx_intr			(struct bce_softc *);
 static void bce_disable_intr		(struct bce_softc *);
-static void bce_enable_intr			(struct bce_softc *, int);
+static void bce_enable_intr		(struct bce_softc *, int);
 
-static void bce_intr				(void *);
-static void bce_set_rx_mode			(struct bce_softc *);
+static void bce_intr			(void *);
+static void bce_set_rx_mode		(struct bce_softc *);
 static void bce_stats_update		(struct bce_softc *);
-static void bce_tick				(void *);
-static void bce_pulse				(void *);
-static void bce_add_sysctls			(struct bce_softc *);
+static void bce_tick			(void *);
+static void bce_pulse			(void *);
+static void bce_add_sysctls		(struct bce_softc *);
 
 
 /****************************************************************************/
@@ -540,15 +549,15 @@ bce_probe(device_t dev)
 	sdid = pci_get_subdevice(dev);
 
 	DBPRINT(sc, BCE_EXTREME_LOAD,
-		"%s(); VID = 0x%04X, DID = 0x%04X, SVID = 0x%04X, "
-		"SDID = 0x%04X\n", __FUNCTION__, vid, did, svid, sdid);
+	    "%s(); VID = 0x%04X, DID = 0x%04X, SVID = 0x%04X, "
+	    "SDID = 0x%04X\n", __FUNCTION__, vid, did, svid, sdid);
 
 	/* Look through the list of known devices for a match. */
 	while(t->bce_name != NULL) {
 
 		if ((vid == t->bce_vid) && (did == t->bce_did) &&
-			((svid == t->bce_svid) || (t->bce_svid == PCI_ANY_ID)) &&
-			((sdid == t->bce_sdid) || (t->bce_sdid == PCI_ANY_ID))) {
+		    ((svid == t->bce_svid) || (t->bce_svid == PCI_ANY_ID)) &&
+		    ((sdid == t->bce_sdid) || (t->bce_sdid == PCI_ANY_ID))) {
 
 			descbuf = malloc(BCE_DEVDESC_MAX, M_TEMP, M_NOWAIT);
 
@@ -557,8 +566,8 @@ bce_probe(device_t dev)
 
 			/* Print out the device identity. */
 			snprintf(descbuf, BCE_DEVDESC_MAX, "%s (%c%d)",
-				t->bce_name,
-			    (((pci_read_config(dev, PCIR_REVID, 4) & 0xf0) >> 4) + 'A'),
+			    t->bce_name, (((pci_read_config(dev, 
+			    PCIR_REVID, 4) & 0xf0) >> 4) + 'A'),
 			    (pci_read_config(dev, PCIR_REVID, 4) & 0xf));
 
 			device_set_desc_copy(dev, descbuf);
@@ -590,21 +599,21 @@ bce_print_adapter_info(struct bce_softc *sc)
 
 	BCE_PRINTF("ASIC (0x%08X); ", sc->bce_chipid);
 	printf("Rev (%c%d); ", ((BCE_CHIP_ID(sc) & 0xf000) >> 12) + 'A',
-		((BCE_CHIP_ID(sc) & 0x0ff0) >> 4));
+	    ((BCE_CHIP_ID(sc) & 0x0ff0) >> 4));
 
 	/* Bus info. */
 	if (sc->bce_flags & BCE_PCIE_FLAG) {
 		printf("Bus (PCIe x%d, ", sc->link_width);
 		switch (sc->link_speed) {
-			case 1: printf("2.5Gbps); "); break;
-			case 2:	printf("5Gbps); "); break;
-			default: printf("Unknown link speed); ");
+		case 1: printf("2.5Gbps); "); break;
+		case 2:	printf("5Gbps); "); break;
+		default: printf("Unknown link speed); ");
 		}
 	} else {
 		printf("Bus (PCI%s, %s, %dMHz); ",
-			((sc->bce_flags & BCE_PCIX_FLAG) ? "-X" : ""),
-			((sc->bce_flags & BCE_PCI_32BIT_FLAG) ? "32-bit" : "64-bit"),
-			sc->bus_speed_mhz);
+		    ((sc->bce_flags & BCE_PCIX_FLAG) ? "-X" : ""),
+		    ((sc->bce_flags & BCE_PCI_32BIT_FLAG) ? 
+		    "32-bit" : "64-bit"), sc->bus_speed_mhz);
 	}
 
 	/* Firmware version and device features. */
@@ -612,30 +621,30 @@ bce_print_adapter_info(struct bce_softc *sc)
 
 #ifdef BCE_JUMBO_HDRSPLIT
 	printf("SPLT");
-    i++;
+	i++;
 #endif
 
-    if (sc->bce_flags & BCE_USING_MSI_FLAG) {
-        if (i > 0) printf("|");
+	if (sc->bce_flags & BCE_USING_MSI_FLAG) {
+		if (i > 0) printf("|");
 		printf("MSI"); i++;
-    }
+	}
 
-    if (sc->bce_flags & BCE_USING_MSIX_FLAG) {
-        if (i > 0) printf("|");
+	if (sc->bce_flags & BCE_USING_MSIX_FLAG) {
+		if (i > 0) printf("|");
 		printf("MSI-X"); i++;
-    }
+	}
 
-    if (sc->bce_phy_flags & BCE_PHY_2_5G_CAPABLE_FLAG) {
-        if (i > 0) printf("|");
+	if (sc->bce_phy_flags & BCE_PHY_2_5G_CAPABLE_FLAG) {
+		if (i > 0) printf("|");
 		printf("2.5G"); i++;
-    }
+	}
 
-    if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
-        if (i > 0) printf("|");
-        printf("MFW); MFW (%s)\n", sc->bce_mfw_ver);
-    } else {
-        printf(")\n");
-    }
+	if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
+		if (i > 0) printf("|");
+		printf("MFW); MFW (%s)\n", sc->bce_mfw_ver);
+	} else {
+		printf(")\n");
+	}
 
 	DBEXIT(BCE_VERBOSE_LOAD);
 }
@@ -667,8 +676,8 @@ bce_probe_pci_caps(device_t dev, struct bce_softc *sc)
 	if (pci_find_extcap(dev, PCIY_EXPRESS, &reg) == 0) {
 		if (reg != 0) {
 			u16 link_status = pci_read_config(dev, reg + 0x12, 2);
-			DBPRINT(sc, BCE_INFO_LOAD, "PCIe link_status = 0x%08X\n",
-				link_status);
+			DBPRINT(sc, BCE_INFO_LOAD, "PCIe link_status = "
+			    "0x%08X\n",	link_status);
 			sc->link_speed = link_status & 0xf;
 			sc->link_width = (link_status >> 4) & 0x3f;
 			sc->bce_cap_flags |= BCE_PCIE_CAPABLE_FLAG;
@@ -730,7 +739,7 @@ bce_attach(device_t dev)
 
 	if (sc->bce_res_mem == NULL) {
 		BCE_PRINTF("%s(%d): PCI memory allocation failed\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENXIO;
 		goto bce_attach_fail;
 	}
@@ -801,14 +810,14 @@ bce_attach(device_t dev)
 	}
 
 	sc->bce_res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
-		&rid, RF_SHAREABLE | RF_ACTIVE);
+	    &rid, RF_SHAREABLE | RF_ACTIVE);
 
 	sc->bce_irq_rid = rid;
 
 	/* Report any IRQ allocation errors. */
 	if (sc->bce_res_irq == NULL) {
 		BCE_PRINTF("%s(%d): PCI map interrupt failed!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENXIO;
 		goto bce_attach_fail;
 	}
@@ -823,28 +832,28 @@ bce_attach(device_t dev)
 	 * valid until this is done.
 	 */
 	pci_write_config(dev, BCE_PCICFG_MISC_CONFIG,
-			       BCE_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
-			       BCE_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP, 4);
+	    BCE_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
+	    BCE_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP, 4);
 
 	/* Save ASIC revsion info. */
 	sc->bce_chipid =  REG_RD(sc, BCE_MISC_ID);
 
 	/* Weed out any non-production controller revisions. */
 	switch(BCE_CHIP_ID(sc)) {
-		case BCE_CHIP_ID_5706_A0:
-		case BCE_CHIP_ID_5706_A1:
-		case BCE_CHIP_ID_5708_A0:
-		case BCE_CHIP_ID_5708_B0:
-		case BCE_CHIP_ID_5709_A0:
-		case BCE_CHIP_ID_5709_B0:
-		case BCE_CHIP_ID_5709_B1:
-		case BCE_CHIP_ID_5709_B2:
-			BCE_PRINTF("%s(%d): Unsupported controller revision (%c%d)!\n",
-				__FILE__, __LINE__,
-				(((pci_read_config(dev, PCIR_REVID, 4) & 0xf0) >> 4) + 'A'),
-			    (pci_read_config(dev, PCIR_REVID, 4) & 0xf));
-			rc = ENODEV;
-			goto bce_attach_fail;
+	case BCE_CHIP_ID_5706_A0:
+	case BCE_CHIP_ID_5706_A1:
+	case BCE_CHIP_ID_5708_A0:
+	case BCE_CHIP_ID_5708_B0:
+	case BCE_CHIP_ID_5709_A0:
+	case BCE_CHIP_ID_5709_B0:
+	case BCE_CHIP_ID_5709_B1:
+	case BCE_CHIP_ID_5709_B2:
+		BCE_PRINTF("%s(%d): Unsupported controller revision (%c%d)!\n",
+		    __FILE__, __LINE__,
+		    (((pci_read_config(dev, PCIR_REVID, 4) & 0xf0) >> 4) + 'A'),
+		    (pci_read_config(dev, PCIR_REVID, 4) & 0xf));
+		rc = ENODEV;
+		goto bce_attach_fail;
 	}
 
 	/*
@@ -866,58 +875,67 @@ bce_attach(device_t dev)
 	if ((val & BCE_SHM_HDR_SIGNATURE_SIG_MASK) == BCE_SHM_HDR_SIGNATURE_SIG)
 		/* Multi-port devices use different offsets in shared memory. */
 		sc->bce_shmem_base = REG_RD_IND(sc, BCE_SHM_HDR_ADDR_0 +
-			(pci_get_function(sc->bce_dev) << 2));
+		    (pci_get_function(sc->bce_dev) << 2));
 	else
 		sc->bce_shmem_base = HOST_VIEW_SHMEM_BASE;
 
 	DBPRINT(sc, BCE_VERBOSE_FIRMWARE, "%s(): bce_shmem_base = 0x%08X\n",
-		__FUNCTION__, sc->bce_shmem_base);
+	    __FUNCTION__, sc->bce_shmem_base);
 
 	/* Fetch the bootcode revision. */
-    val = bce_shmem_rd(sc, BCE_DEV_INFO_BC_REV);
-    for (int i = 0, j = 0; i < 3; i++) {
-        u8 num;
+	val = bce_shmem_rd(sc, BCE_DEV_INFO_BC_REV);
+	for (int i = 0, j = 0; i < 3; i++) {
+		u8 num;
 
-        num = (u8) (val >> (24 - (i * 8)));
-        for (int k = 100, skip0 = 1; k >= 1; num %= k, k /= 10) {
-            if (num >= k || !skip0 || k == 1) {
-                sc->bce_bc_ver[j++] = (num / k) + '0';
-                skip0 = 0;
-            }
-        }
-        if (i != 2)
-            sc->bce_bc_ver[j++] = '.';
-    }
+		num = (u8) (val >> (24 - (i * 8)));
+		for (int k = 100, skip0 = 1; k >= 1; num %= k, k /= 10) {
+			if (num >= k || !skip0 || k == 1) {
+				sc->bce_bc_ver[j++] = (num / k) + '0';
+				skip0 = 0;
+			}
+		}
 
-    /* Check if any management firwmare is running. */
-    val = bce_shmem_rd(sc, BCE_PORT_FEATURE);
-    if (val & BCE_PORT_FEATURE_ASF_ENABLED) {
-        sc->bce_flags |= BCE_MFW_ENABLE_FLAG;
+		if (i != 2)
+			sc->bce_bc_ver[j++] = '.';
+	}
 
-        /* Allow time for firmware to enter the running state. */
-        for (int i = 0; i < 30; i++) {
-            val = bce_shmem_rd(sc, BCE_BC_STATE_CONDITION);
-            if (val & BCE_CONDITION_MFW_RUN_MASK)
-                break;
-            DELAY(10000);
-        }
-    }
+	/* Check if any management firwmare is enabled. */
+	val = bce_shmem_rd(sc, BCE_PORT_FEATURE);
+	if (val & BCE_PORT_FEATURE_ASF_ENABLED) {
+		sc->bce_flags |= BCE_MFW_ENABLE_FLAG;
 
-    /* Check the current bootcode state. */
-    val = bce_shmem_rd(sc, BCE_BC_STATE_CONDITION);
-    val &= BCE_CONDITION_MFW_RUN_MASK;
-    if (val != BCE_CONDITION_MFW_RUN_UNKNOWN &&
-        val != BCE_CONDITION_MFW_RUN_NONE) {
-        u32 addr = bce_shmem_rd(sc, BCE_MFW_VER_PTR);
-        int i = 0;
+		/* Allow time for firmware to enter the running state. */
+		for (int i = 0; i < 30; i++) {
+			val = bce_shmem_rd(sc, BCE_BC_STATE_CONDITION);
+			if (val & BCE_CONDITION_MFW_RUN_MASK)
+				break;
+			DELAY(10000);
+		}
+
+		/* Check if management firmware is running. */
+		val = bce_shmem_rd(sc, BCE_BC_STATE_CONDITION);
+		val &= BCE_CONDITION_MFW_RUN_MASK;
+		if ((val != BCE_CONDITION_MFW_RUN_UNKNOWN) &&
+		    (val != BCE_CONDITION_MFW_RUN_NONE)) {
+			u32 addr = bce_shmem_rd(sc, BCE_MFW_VER_PTR);
+			int i = 0;
+
+			/* Read the management firmware version string. */
+			for (int j = 0; j < 3; j++) {
+				val = bce_reg_rd_ind(sc, addr + j * 4);
+				val = bswap32(val);
+				memcpy(&sc->bce_mfw_ver[i], &val, 4);
+				i += 4;
+			}
+		} else {
+			/* May cause firmware synchronization timeouts. */
+			BCE_PRINTF("%s(%d): Management firmware enabled "
+			    "but not running!\n", __FILE__, __LINE__);
+			strcpy(sc->bce_mfw_ver, "NOT RUNNING!");
 
-        for (int j = 0; j < 3; j++) {
-            val = bce_reg_rd_ind(sc, addr + j * 4);
-            val = bswap32(val);
-            memcpy(&sc->bce_mfw_ver[i], &val, 4);
-            i += 4;
-        }
-    }
+			/* ToDo: Any action the driver should take? */
+		}
+	}
 
 	/* Get PCI bus information (speed and type). */
 	val = REG_RD(sc, BCE_PCICFG_MISC_STATUS);
@@ -964,10 +982,10 @@ bce_attach(device_t dev)
 	if (val & BCE_PCICFG_MISC_STATUS_32BIT_DET)
 		sc->bce_flags |= BCE_PCI_32BIT_FLAG;
 
-	/* Reset the controller and announce to bootcode that driver is present. */
+	/* Reset controller and announce to bootcode that driver is present. */
 	if (bce_reset(sc, BCE_DRV_MSG_CODE_RESET)) {
 		BCE_PRINTF("%s(%d): Controller reset failed!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENXIO;
 		goto bce_attach_fail;
 	}
@@ -975,7 +993,7 @@ bce_attach(device_t dev)
 	/* Initialize the controller. */
 	if (bce_chipinit(sc)) {
 		BCE_PRINTF("%s(%d): Controller initialization failed!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENXIO;
 		goto bce_attach_fail;
 	}
@@ -983,7 +1001,7 @@ bce_attach(device_t dev)
 	/* Perform NVRAM test. */
 	if (bce_nvram_test(sc)) {
 		BCE_PRINTF("%s(%d): NVRAM test failed!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENXIO;
 		goto bce_attach_fail;
 	}
@@ -1024,6 +1042,14 @@ bce_attach(device_t dev)
 	sc->bce_rx_ticks               = 18;
 #endif
 
+	/* Not used for L2. */
+	sc->bce_comp_prod_trip_int = 0;
+	sc->bce_comp_prod_trip = 0;
+	sc->bce_com_ticks_int = 0;
+	sc->bce_com_ticks = 0;
+	sc->bce_cmd_ticks_int = 0;
+	sc->bce_cmd_ticks = 0;
+
 	/* Update statistics once every second. */
 	sc->bce_stats_ticks = 1000000 & 0xffff00;
 
@@ -1507,7 +1533,8 @@ bce_miibus_read_reg(device_t dev, int phy, int reg)
 
 	/* Make sure we are accessing the correct PHY address. */
 	if (phy != sc->bce_phy_addr) {
-		DBPRINT(sc, BCE_INSANE_PHY, "Invalid PHY address %d for PHY read!\n", phy);
+		DBPRINT(sc, BCE_INSANE_PHY, "Invalid PHY address %d "
+		    "for PHY read!\n", phy);
 		return(0);
 	}
 
@@ -1533,8 +1560,8 @@ bce_miibus_read_reg(device_t dev, int phy, int reg)
 
 
 	val = BCE_MIPHY(phy) | BCE_MIREG(reg) |
-		BCE_EMAC_MDIO_COMM_COMMAND_READ | BCE_EMAC_MDIO_COMM_DISEXT |
-		BCE_EMAC_MDIO_COMM_START_BUSY;
+	    BCE_EMAC_MDIO_COMM_COMMAND_READ | BCE_EMAC_MDIO_COMM_DISEXT |
+	    BCE_EMAC_MDIO_COMM_START_BUSY;
 	REG_WR(sc, BCE_EMAC_MDIO_COMM, val);
 
 	for (i = 0; i < BCE_PHY_TIMEOUT; i++) {
@@ -1552,8 +1579,8 @@ bce_miibus_read_reg(device_t dev, int phy, int reg)
 	}
 
 	if (val & BCE_EMAC_MDIO_COMM_START_BUSY) {
-		BCE_PRINTF("%s(%d): Error: PHY read timeout! phy = %d, reg = 0x%04X\n",
-			__FILE__, __LINE__, phy, reg);
+		BCE_PRINTF("%s(%d): Error: PHY read timeout! phy = %d, "
+		    "reg = 0x%04X\n", __FILE__, __LINE__, phy, reg);
 		val = 0x0;
 	} else {
 		val = REG_RD(sc, BCE_EMAC_MDIO_COMM);
@@ -1595,17 +1622,18 @@ bce_miibus_write_reg(device_t dev, int phy, int reg, int val)
 
 	/* Make sure we are accessing the correct PHY address. */
 	if (phy != sc->bce_phy_addr) {
-		DBPRINT(sc, BCE_INSANE_PHY, "Invalid PHY address %d for PHY write!\n", phy);
+		DBPRINT(sc, BCE_INSANE_PHY, "Invalid PHY address %d "
+		    "for PHY write!\n", phy);
 		return(0);
 	}
 
 	DB_PRINT_PHY_REG(reg, val);
 
-    /*
-     * The 5709S PHY is an IEEE Clause 45 PHY
-     * with special mappings to work with IEEE
-     * Clause 22 register accesses.
-     */
+	/*
+	 * The 5709S PHY is an IEEE Clause 45 PHY
+	 * with special mappings to work with IEEE
+	 * Clause 22 register accesses.
+	 */
 	if ((sc->bce_phy_flags & BCE_PHY_IEEE_CLAUSE_45_FLAG) != 0) {
 		if (reg >= MII_BMCR && reg <= MII_ANLPRNP)
 			reg += 0x10;
@@ -1622,8 +1650,8 @@ bce_miibus_write_reg(device_t dev, int phy, int reg, int val)
 	}
 
 	val1 = BCE_MIPHY(phy) | BCE_MIREG(reg) | val |
-		BCE_EMAC_MDIO_COMM_COMMAND_WRITE |
-		BCE_EMAC_MDIO_COMM_START_BUSY | BCE_EMAC_MDIO_COMM_DISEXT;
+	    BCE_EMAC_MDIO_COMM_COMMAND_WRITE |
+	    BCE_EMAC_MDIO_COMM_START_BUSY | BCE_EMAC_MDIO_COMM_DISEXT;
 	REG_WR(sc, BCE_EMAC_MDIO_COMM, val1);
 
 	for (i = 0; i < BCE_PHY_TIMEOUT; i++) {
@@ -1638,7 +1666,7 @@ bce_miibus_write_reg(device_t dev, int phy, int reg, int val)
 
 	if (val1 & BCE_EMAC_MDIO_COMM_START_BUSY)
 		BCE_PRINTF("%s(%d): PHY write timeout!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 
 	if (sc->bce_phy_flags & BCE_PHY_INT_MODE_AUTO_POLLING_FLAG) {
 		val1 = REG_RD(sc, BCE_EMAC_MDIO_MODE);
@@ -2653,18 +2681,22 @@ bce_get_media(struct bce_softc *sc)
 		 * for Copper or SerDes operation.
 		 */
 		if (bond_id == BCE_MISC_DUAL_MEDIA_CTRL_BOND_ID_C) {
-			DBPRINT(sc, BCE_INFO_LOAD, "5709 bonded for copper.\n");
+			DBPRINT(sc, BCE_INFO_LOAD, "5709 bonded "
+			    "for copper.\n");
 			goto bce_get_media_exit;
 		} else if (bond_id == BCE_MISC_DUAL_MEDIA_CTRL_BOND_ID_S) {
-			DBPRINT(sc, BCE_INFO_LOAD, "5709 bonded for dual media.\n");
+			DBPRINT(sc, BCE_INFO_LOAD, "5709 bonded "
+			    "for dual media.\n");
 			sc->bce_phy_flags |= BCE_PHY_SERDES_FLAG;
 			goto bce_get_media_exit;
 		}
 
 		if (val & BCE_MISC_DUAL_MEDIA_CTRL_STRAP_OVERRIDE)
-			strap = (val & BCE_MISC_DUAL_MEDIA_CTRL_PHY_CTRL) >> 21;
+			strap = (val & 
+			    BCE_MISC_DUAL_MEDIA_CTRL_PHY_CTRL) >> 21;
 		else
-			strap = (val & BCE_MISC_DUAL_MEDIA_CTRL_PHY_CTRL_STRAP) >> 8;
+			strap = (val & 
+			    BCE_MISC_DUAL_MEDIA_CTRL_PHY_CTRL_STRAP) >> 8;
 
 		if (pci_get_function(sc->bce_dev) == 0) {
 			switch (strap) {
@@ -2672,13 +2704,13 @@ bce_get_media(struct bce_softc *sc)
 			case 0x5:
 			case 0x6:
 				DBPRINT(sc, BCE_INFO_LOAD,
-					"BCM5709 s/w configured for SerDes.\n");
+				    "BCM5709 s/w configured for SerDes.\n");
 				sc->bce_phy_flags |= BCE_PHY_SERDES_FLAG;
-                break;
+				break;
 			default:
 				DBPRINT(sc, BCE_INFO_LOAD,
-					"BCM5709 s/w configured for Copper.\n");
-                break;
+				    "BCM5709 s/w configured for Copper.\n");
+				break;
 			}
 		} else {
 			switch (strap) {
@@ -2686,13 +2718,13 @@ bce_get_media(struct bce_softc *sc)
 			case 0x2:
 			case 0x4:
 				DBPRINT(sc, BCE_INFO_LOAD,
-					"BCM5709 s/w configured for SerDes.\n");
+				    "BCM5709 s/w configured for SerDes.\n");
 				sc->bce_phy_flags |= BCE_PHY_SERDES_FLAG;
-                break;
+				break;
 			default:
 				DBPRINT(sc, BCE_INFO_LOAD,
-					"BCM5709 s/w configured for Copper.\n");
-                break;
+				    "BCM5709 s/w configured for Copper.\n");
+				break;
 			}
 		}
 
@@ -2703,21 +2735,23 @@ bce_get_media(struct bce_softc *sc)
 
 		sc->bce_flags |= BCE_NO_WOL_FLAG;
 
-		/* 5708S, 5709S, and 5716S use a separate PHY for SerDes. */
-		if (BCE_CHIP_NUM(sc) != BCE_CHIP_NUM_5706) 
-			sc->bce_phy_addr = 2;
-
-		if (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) {
+		if (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709)
 			sc->bce_phy_flags |= BCE_PHY_IEEE_CLAUSE_45_FLAG;
 
+		if (BCE_CHIP_NUM(sc) != BCE_CHIP_NUM_5706) {
+			/* 5708S/09S/16S use a separate PHY for SerDes. */
+			sc->bce_phy_addr = 2;
+
 			val = bce_shmem_rd(sc, BCE_SHARED_HW_CFG_CONFIG);
 			if (val & BCE_SHARED_HW_CFG_PHY_2_5G) {
-				sc->bce_phy_flags |= BCE_PHY_2_5G_CAPABLE_FLAG;
-				DBPRINT(sc, BCE_INFO_LOAD, "Found 2.5Gb capable adapter\n");
+				sc->bce_phy_flags |= 
+				    BCE_PHY_2_5G_CAPABLE_FLAG;
+				DBPRINT(sc, BCE_INFO_LOAD, "Found 2.5Gb "
+				    "capable adapter\n");
 			}
-        }
+		}
 	} else if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5706) ||
-		   (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5708))
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5708))
 		sc->bce_phy_flags |= BCE_PHY_CRC_FIX_FLAG;
 
 bce_get_media_exit:
@@ -2746,13 +2780,13 @@ bce_init_media(struct bce_softc *sc)
 		 * is done in mii layer.
 		 */
 
-        /* Select auto-negotiation MMD of the PHY. */
-        bce_miibus_write_reg(sc->bce_dev, sc->bce_phy_addr,
+		/* Select auto-negotiation MMD of the PHY. */
+		bce_miibus_write_reg(sc->bce_dev, sc->bce_phy_addr,
 		    BRGPHY_BLOCK_ADDR, BRGPHY_BLOCK_ADDR_ADDR_EXT);
 		bce_miibus_write_reg(sc->bce_dev, sc->bce_phy_addr,
 		    BRGPHY_ADDR_EXT, BRGPHY_ADDR_EXT_AN_MMD);
 
-        /* Select IEEE0 block of AN MMD (assumed in all brgphy(4) code). */
+		/* Set IEEE0 block of AN MMD (assumed in brgphy(4) code). */
 		bce_miibus_write_reg(sc->bce_dev, sc->bce_phy_addr,
 		    BRGPHY_BLOCK_ADDR, BRGPHY_BLOCK_ADDR_COMBO_IEEE0);
 	}
@@ -2778,7 +2812,7 @@ bce_dma_free(struct bce_softc *sc)
 	/* Free, unmap, and destroy the status block. */
 	if (sc->status_block != NULL) {
 		bus_dmamem_free(
-			sc->status_tag,
+		   sc->status_tag,
 		    sc->status_block,
 		    sc->status_map);
 		sc->status_block = NULL;
@@ -2786,7 +2820,7 @@ bce_dma_free(struct bce_softc *sc)
 
 	if (sc->status_map != NULL) {
 		bus_dmamap_unload(
-			sc->status_tag,
+		    sc->status_tag,
 		    sc->status_map);
 		bus_dmamap_destroy(sc->status_tag,
 		    sc->status_map);
@@ -2802,7 +2836,7 @@ bce_dma_free(struct bce_softc *sc)
 	/* Free, unmap, and destroy the statistics block. */
 	if (sc->stats_block != NULL) {
 		bus_dmamem_free(
-			sc->stats_tag,
+		    sc->stats_tag,
 		    sc->stats_block,
 		    sc->stats_map);
 		sc->stats_block = NULL;
@@ -2810,7 +2844,7 @@ bce_dma_free(struct bce_softc *sc)
 
 	if (sc->stats_map != NULL) {
 		bus_dmamap_unload(
-			sc->stats_tag,
+		    sc->stats_tag,
 		    sc->stats_map);
 		bus_dmamap_destroy(sc->stats_tag,
 		    sc->stats_map);
@@ -2829,7 +2863,7 @@ bce_dma_free(struct bce_softc *sc)
 		for (i = 0; i < sc->ctx_pages; i++ ) {
 			if (sc->ctx_block[i] != NULL) {
 				bus_dmamem_free(
-					sc->ctx_tag,
+				    sc->ctx_tag,
 				    sc->ctx_block[i],
 				    sc->ctx_map[i]);
 				sc->ctx_block[i] = NULL;
@@ -2837,10 +2871,10 @@ bce_dma_free(struct bce_softc *sc)
 
 			if (sc->ctx_map[i] != NULL) {
 				bus_dmamap_unload(
-					sc->ctx_tag,
-		    		sc->ctx_map[i]);
+				    sc->ctx_tag,
+				    sc->ctx_map[i]);
 				bus_dmamap_destroy(
-					sc->ctx_tag,
+				    sc->ctx_tag,
 				    sc->ctx_map[i]);
 				sc->ctx_map[i] = NULL;
 			}
@@ -2858,7 +2892,7 @@ bce_dma_free(struct bce_softc *sc)
 	for (i = 0; i < TX_PAGES; i++ ) {
 		if (sc->tx_bd_chain[i] != NULL) {
 			bus_dmamem_free(
-				sc->tx_bd_chain_tag,
+			    sc->tx_bd_chain_tag,
 			    sc->tx_bd_chain[i],
 			    sc->tx_bd_chain_map[i]);
 			sc->tx_bd_chain[i] = NULL;
@@ -2866,10 +2900,10 @@ bce_dma_free(struct bce_softc *sc)
 
 		if (sc->tx_bd_chain_map[i] != NULL) {
 			bus_dmamap_unload(
-				sc->tx_bd_chain_tag,
-		    	sc->tx_bd_chain_map[i]);
+			    sc->tx_bd_chain_tag,
+			    sc->tx_bd_chain_map[i]);
 			bus_dmamap_destroy(
-				sc->tx_bd_chain_tag,
+			    sc->tx_bd_chain_tag,
 			    sc->tx_bd_chain_map[i]);
 			sc->tx_bd_chain_map[i] = NULL;
 		}
@@ -2886,7 +2920,7 @@ bce_dma_free(struct bce_softc *sc)
 	for (i = 0; i < RX_PAGES; i++ ) {
 		if (sc->rx_bd_chain[i] != NULL) {
 			bus_dmamem_free(
-				sc->rx_bd_chain_tag,
+			    sc->rx_bd_chain_tag,
 			    sc->rx_bd_chain[i],
 			    sc->rx_bd_chain_map[i]);
 			sc->rx_bd_chain[i] = NULL;
@@ -2894,10 +2928,10 @@ bce_dma_free(struct bce_softc *sc)
 
 		if (sc->rx_bd_chain_map[i] != NULL) {
 			bus_dmamap_unload(
-				sc->rx_bd_chain_tag,
-		    	sc->rx_bd_chain_map[i]);
+			    sc->rx_bd_chain_tag,
+			    sc->rx_bd_chain_map[i]);
 			bus_dmamap_destroy(
-				sc->rx_bd_chain_tag,
+			    sc->rx_bd_chain_tag,
 			    sc->rx_bd_chain_map[i]);
 			sc->rx_bd_chain_map[i] = NULL;
 		}
@@ -2915,7 +2949,7 @@ bce_dma_free(struct bce_softc *sc)
 	for (i = 0; i < PG_PAGES; i++ ) {
 		if (sc->pg_bd_chain[i] != NULL) {
 			bus_dmamem_free(
-				sc->pg_bd_chain_tag,
+			    sc->pg_bd_chain_tag,
 			    sc->pg_bd_chain[i],
 			    sc->pg_bd_chain_map[i]);
 			sc->pg_bd_chain[i] = NULL;
@@ -2923,10 +2957,10 @@ bce_dma_free(struct bce_softc *sc)
 
 		if (sc->pg_bd_chain_map[i] != NULL) {
 			bus_dmamap_unload(
-				sc->pg_bd_chain_tag,
-		    	sc->pg_bd_chain_map[i]);
+			    sc->pg_bd_chain_tag,
+			    sc->pg_bd_chain_map[i]);
 			bus_dmamap_destroy(
-				sc->pg_bd_chain_tag,
+			    sc->pg_bd_chain_tag,
 			    sc->pg_bd_chain_map[i]);
 			sc->pg_bd_chain_map[i] = NULL;
 		}
@@ -2944,9 +2978,9 @@ bce_dma_free(struct bce_softc *sc)
 	for (i = 0; i < TOTAL_TX_BD; i++) {
 		if (sc->tx_mbuf_map[i] != NULL) {
 			bus_dmamap_unload(sc->tx_mbuf_tag,
-				sc->tx_mbuf_map[i]);
+			    sc->tx_mbuf_map[i]);
 			bus_dmamap_destroy(sc->tx_mbuf_tag,
-	 			sc->tx_mbuf_map[i]);
+	 		    sc->tx_mbuf_map[i]);
 			sc->tx_mbuf_map[i] = NULL;
 		}
 	}
@@ -2961,9 +2995,9 @@ bce_dma_free(struct bce_softc *sc)
 	for (i = 0; i < TOTAL_RX_BD; i++) {
 		if (sc->rx_mbuf_map[i] != NULL) {
 			bus_dmamap_unload(sc->rx_mbuf_tag,
-				sc->rx_mbuf_map[i]);
+			    sc->rx_mbuf_map[i]);
 			bus_dmamap_destroy(sc->rx_mbuf_tag,
-	 			sc->rx_mbuf_map[i]);
+	 		    sc->rx_mbuf_map[i]);
 			sc->rx_mbuf_map[i] = NULL;
 		}
 	}
@@ -2979,9 +3013,9 @@ bce_dma_free(struct bce_softc *sc)
 	for (i = 0; i < TOTAL_PG_BD; i++) {
 		if (sc->pg_mbuf_map[i] != NULL) {
 			bus_dmamap_unload(sc->pg_mbuf_tag,
-				sc->pg_mbuf_map[i]);
+			    sc->pg_mbuf_map[i]);
 			bus_dmamap_destroy(sc->pg_mbuf_tag,
-	 			sc->pg_mbuf_map[i]);
+	 		    sc->pg_mbuf_map[i]);
 			sc->pg_mbuf_map[i] = NULL;
 		}
 	}
@@ -3074,20 +3108,12 @@ bce_dma_alloc(device_t dev)
 	/*
 	 * Allocate the parent bus DMA tag appropriate for PCI.
 	 */
-	if (bus_dma_tag_create(NULL,
-			1,
-			BCE_DMA_BOUNDARY,
-			sc->max_bus_addr,
-			BUS_SPACE_MAXADDR,
-			NULL, NULL,
-			MAXBSIZE,
-			BUS_SPACE_UNRESTRICTED,
-			BUS_SPACE_MAXSIZE_32BIT,
-			0,
-			NULL, NULL,
-			&sc->parent_tag)) {
+	if (bus_dma_tag_create(NULL, 1,	BCE_DMA_BOUNDARY,
+	    sc->max_bus_addr, BUS_SPACE_MAXADDR, NULL, NULL,
+	    MAXBSIZE, BUS_SPACE_UNRESTRICTED, BUS_SPACE_MAXSIZE_32BIT,
+	    0, NULL, NULL, &sc->parent_tag)) {
 		BCE_PRINTF("%s(%d): Could not allocate parent DMA tag!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
@@ -3097,117 +3123,89 @@ bce_dma_alloc(device_t dev)
 	 * memory, map the memory into DMA space, and fetch the physical
 	 * address of the block.
 	 */
-	if (bus_dma_tag_create(sc->parent_tag,
-	    	BCE_DMA_ALIGN,
-	    	BCE_DMA_BOUNDARY,
-	    	sc->max_bus_addr,
-	    	BUS_SPACE_MAXADDR,
-	    	NULL, NULL,
-	    	BCE_STATUS_BLK_SZ,
-	    	1,
-	    	BCE_STATUS_BLK_SZ,
-	    	0,
-	    	NULL, NULL,
-	    	&sc->status_tag)) {
-		BCE_PRINTF("%s(%d): Could not allocate status block DMA tag!\n",
-			__FILE__, __LINE__);
+	if (bus_dma_tag_create(sc->parent_tag, BCE_DMA_ALIGN,
+	    BCE_DMA_BOUNDARY, sc->max_bus_addr,	BUS_SPACE_MAXADDR,
+	    NULL, NULL,	BCE_STATUS_BLK_SZ, 1, BCE_STATUS_BLK_SZ,
+	    0, NULL, NULL, &sc->status_tag)) {
+		BCE_PRINTF("%s(%d): Could not allocate status block "
+		    "DMA tag!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
 
-	if(bus_dmamem_alloc(sc->status_tag,
-	    	(void **)&sc->status_block,
-	    	BUS_DMA_NOWAIT,
-	    	&sc->status_map)) {
-		BCE_PRINTF("%s(%d): Could not allocate status block DMA memory!\n",
-			__FILE__, __LINE__);
+	if(bus_dmamem_alloc(sc->status_tag, (void **)&sc->status_block,
+	    BUS_DMA_NOWAIT, &sc->status_map)) {
+		BCE_PRINTF("%s(%d): Could not allocate status block "
+		    "DMA memory!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
 
 	bzero((char *)sc->status_block, BCE_STATUS_BLK_SZ);
 
-	error = bus_dmamap_load(sc->status_tag,
-	    	sc->status_map,
-	    	sc->status_block,
-	    	BCE_STATUS_BLK_SZ,
-	    	bce_dma_map_addr,
-	    	&sc->status_block_paddr,
-	    	BUS_DMA_NOWAIT);
+	error = bus_dmamap_load(sc->status_tag,	sc->status_map,
+	    sc->status_block, BCE_STATUS_BLK_SZ, bce_dma_map_addr,
+	    &sc->status_block_paddr, BUS_DMA_NOWAIT);
 
 	if (error) {
-		BCE_PRINTF("%s(%d): Could not map status block DMA memory!\n",
-			__FILE__, __LINE__);
+		BCE_PRINTF("%s(%d): Could not map status block "
+		    "DMA memory!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
 
 	DBPRINT(sc, BCE_INFO, "%s(): status_block_paddr = 0x%jX\n",
-		__FUNCTION__, (uintmax_t) sc->status_block_paddr);
+	    __FUNCTION__, (uintmax_t) sc->status_block_paddr);
 
 	/*
 	 * Create a DMA tag for the statistics block, allocate and clear the
 	 * memory, map the memory into DMA space, and fetch the physical
 	 * address of the block.
 	 */
-	if (bus_dma_tag_create(sc->parent_tag,
-	    	BCE_DMA_ALIGN,
-	    	BCE_DMA_BOUNDARY,
-	    	sc->max_bus_addr,
-	    	BUS_SPACE_MAXADDR,
-	    	NULL, NULL,
-	    	BCE_STATS_BLK_SZ,
-	    	1,
-	    	BCE_STATS_BLK_SZ,
-	    	0,
-	    	NULL, NULL,
-	    	&sc->stats_tag)) {
-		BCE_PRINTF("%s(%d): Could not allocate statistics block DMA tag!\n",
-			__FILE__, __LINE__);
+	if (bus_dma_tag_create(sc->parent_tag, BCE_DMA_ALIGN,
+	    BCE_DMA_BOUNDARY, sc->max_bus_addr,	BUS_SPACE_MAXADDR,
+	    NULL, NULL,	BCE_STATS_BLK_SZ, 1, BCE_STATS_BLK_SZ,
+	    0, NULL, NULL, &sc->stats_tag)) {
+		BCE_PRINTF("%s(%d): Could not allocate statistics block "
+		    "DMA tag!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
 
-	if (bus_dmamem_alloc(sc->stats_tag,
-	    	(void **)&sc->stats_block,
-	    	BUS_DMA_NOWAIT,
-	    	&sc->stats_map)) {
-		BCE_PRINTF("%s(%d): Could not allocate statistics block DMA memory!\n",
-			__FILE__, __LINE__);
+	if (bus_dmamem_alloc(sc->stats_tag, (void **)&sc->stats_block,
+	    BUS_DMA_NOWAIT,	&sc->stats_map)) {
+		BCE_PRINTF("%s(%d): Could not allocate statistics block "
+		    "DMA memory!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
 
 	bzero((char *)sc->stats_block, BCE_STATS_BLK_SZ);
 
-	error = bus_dmamap_load(sc->stats_tag,
-	    	sc->stats_map,
-	    	sc->stats_block,
-	    	BCE_STATS_BLK_SZ,
-	    	bce_dma_map_addr,
-	    	&sc->stats_block_paddr,
-	    	BUS_DMA_NOWAIT);
+	error = bus_dmamap_load(sc->stats_tag, sc->stats_map,
+	    sc->stats_block, BCE_STATS_BLK_SZ, bce_dma_map_addr,
+	    &sc->stats_block_paddr, BUS_DMA_NOWAIT);
 
 	if(error) {
-		BCE_PRINTF("%s(%d): Could not map statistics block DMA memory!\n",
-			__FILE__, __LINE__);
+		BCE_PRINTF("%s(%d): Could not map statistics block "
+		    "DMA memory!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
 
 	DBPRINT(sc, BCE_INFO, "%s(): stats_block_paddr = 0x%jX\n",
-		__FUNCTION__, (uintmax_t) sc->stats_block_paddr);
+	    __FUNCTION__, (uintmax_t) sc->stats_block_paddr);
 
 	/* BCM5709 uses host memory as cache for context memory. */
 	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
 		sc->ctx_pages = 0x2000 / BCM_PAGE_SIZE;
 		if (sc->ctx_pages == 0)
 			sc->ctx_pages = 1;
 
 		DBRUNIF((sc->ctx_pages > 512),
-			BCE_PRINTF("%s(%d): Too many CTX pages! %d > 512\n",
-				__FILE__, __LINE__, sc->ctx_pages));
+		    BCE_PRINTF("%s(%d): Too many CTX pages! %d > 512\n",
+		    __FILE__, __LINE__, sc->ctx_pages));
 
 		/*
 		 * Create a DMA tag for the context pages,
@@ -3215,20 +3213,12 @@ bce_dma_alloc(device_t dev)
 		 * memory into DMA space, and fetch the
 		 * physical address of the block.
 		 */
-		if(bus_dma_tag_create(sc->parent_tag,
-			BCM_PAGE_SIZE,
-		    BCE_DMA_BOUNDARY,
-			sc->max_bus_addr,
-			BUS_SPACE_MAXADDR,
-			NULL, NULL,
-			BCM_PAGE_SIZE,
-			1,
-			BCM_PAGE_SIZE,
-			0,
-			NULL, NULL,
-			&sc->ctx_tag)) {
+		if(bus_dma_tag_create(sc->parent_tag, BCM_PAGE_SIZE,
+		    BCE_DMA_BOUNDARY, sc->max_bus_addr,	BUS_SPACE_MAXADDR,
+		    NULL, NULL,	BCM_PAGE_SIZE, 1, BCM_PAGE_SIZE,
+		    0, NULL, NULL, &sc->ctx_tag)) {
 			BCE_PRINTF("%s(%d): Could not allocate CTX DMA tag!\n",
-				__FILE__, __LINE__);
+			    __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
@@ -3236,34 +3226,30 @@ bce_dma_alloc(device_t dev)
 		for (i = 0; i < sc->ctx_pages; i++) {
 
 			if(bus_dmamem_alloc(sc->ctx_tag,
-		    		(void **)&sc->ctx_block[i],
-	    		BUS_DMA_NOWAIT,
-		    	&sc->ctx_map[i])) {
+			    (void **)&sc->ctx_block[i],
+			    BUS_DMA_NOWAIT,
+			    &sc->ctx_map[i])) {
 				BCE_PRINTF("%s(%d): Could not allocate CTX "
-					"DMA memory!\n", __FILE__, __LINE__);
+				    "DMA memory!\n", __FILE__, __LINE__);
 				rc = ENOMEM;
 				goto bce_dma_alloc_exit;
 			}
 
 			bzero((char *)sc->ctx_block[i], BCM_PAGE_SIZE);
 
-			error = bus_dmamap_load(sc->ctx_tag,
-	    		sc->ctx_map[i],
-	    		sc->ctx_block[i],
-		    	BCM_PAGE_SIZE,
-		    	bce_dma_map_addr,
-	    		&sc->ctx_paddr[i],
-	    		BUS_DMA_NOWAIT);
+			error = bus_dmamap_load(sc->ctx_tag, sc->ctx_map[i],
+			    sc->ctx_block[i], BCM_PAGE_SIZE, bce_dma_map_addr,
+			    &sc->ctx_paddr[i], BUS_DMA_NOWAIT);
 
 			if (error) {
-				BCE_PRINTF("%s(%d): Could not map CTX DMA memory!\n",
-					__FILE__, __LINE__);
+				BCE_PRINTF("%s(%d): Could not map CTX "
+				    "DMA memory!\n", __FILE__, __LINE__);
 				rc = ENOMEM;
 				goto bce_dma_alloc_exit;
 			}
 
 			DBPRINT(sc, BCE_INFO, "%s(): ctx_paddr[%d] = 0x%jX\n",
-				__FUNCTION__, i, (uintmax_t) sc->ctx_paddr[i]);
+			    __FUNCTION__, i, (uintmax_t) sc->ctx_paddr[i]);
 		}
 	}
 
@@ -3272,53 +3258,41 @@ bce_dma_alloc(device_t dev)
 	 * allocate and clear the  memory, and fetch the
 	 * physical address of the block.
 	 */
-	if(bus_dma_tag_create(sc->parent_tag,
-			BCM_PAGE_SIZE,
-		    BCE_DMA_BOUNDARY,
-			sc->max_bus_addr,
-			BUS_SPACE_MAXADDR,
-			NULL, NULL,
-			BCE_TX_CHAIN_PAGE_SZ,
-			1,
-			BCE_TX_CHAIN_PAGE_SZ,
-			0,
-			NULL, NULL,
-			&sc->tx_bd_chain_tag)) {
-		BCE_PRINTF("%s(%d): Could not allocate TX descriptor chain DMA tag!\n",
-			__FILE__, __LINE__);
+	if(bus_dma_tag_create(sc->parent_tag, BCM_PAGE_SIZE, BCE_DMA_BOUNDARY,
+	    sc->max_bus_addr, BUS_SPACE_MAXADDR, NULL, NULL,
+	    BCE_TX_CHAIN_PAGE_SZ, 1, BCE_TX_CHAIN_PAGE_SZ, 0,
+	    NULL, NULL,	&sc->tx_bd_chain_tag)) {
+		BCE_PRINTF("%s(%d): Could not allocate TX descriptor chain "
+		    "DMA tag!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
 
 	for (i = 0; i < TX_PAGES; i++) {
 
-		if(bus_dmamem_alloc(sc->tx_bd_chain_tag,
-	    		(void **)&sc->tx_bd_chain[i],
-	    		BUS_DMA_NOWAIT,
-		    	&sc->tx_bd_chain_map[i])) {
+		if(bus_dmamem_alloc(sc->tx_bd_chain_tag, 
+		    (void **)&sc->tx_bd_chain[i], BUS_DMA_NOWAIT,
+		    &sc->tx_bd_chain_map[i])) {
 			BCE_PRINTF("%s(%d): Could not allocate TX descriptor "
-				"chain DMA memory!\n", __FILE__, __LINE__);
+			    "chain DMA memory!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
 
 		error = bus_dmamap_load(sc->tx_bd_chain_tag,
-	    		sc->tx_bd_chain_map[i],
-	    		sc->tx_bd_chain[i],
-		    	BCE_TX_CHAIN_PAGE_SZ,
-		    	bce_dma_map_addr,
-	    		&sc->tx_bd_chain_paddr[i],
-	    		BUS_DMA_NOWAIT);
+		    sc->tx_bd_chain_map[i], sc->tx_bd_chain[i],
+		    BCE_TX_CHAIN_PAGE_SZ, bce_dma_map_addr,
+		    &sc->tx_bd_chain_paddr[i], BUS_DMA_NOWAIT);
 
 		if (error) {
-			BCE_PRINTF("%s(%d): Could not map TX descriptor chain DMA memory!\n",
-				__FILE__, __LINE__);
+			BCE_PRINTF("%s(%d): Could not map TX descriptor "
+			    "chain DMA memory!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
 
 		DBPRINT(sc, BCE_INFO, "%s(): tx_bd_chain_paddr[%d] = 0x%jX\n",
-			__FUNCTION__, i, (uintmax_t) sc->tx_bd_chain_paddr[i]);
+		    __FUNCTION__, i, (uintmax_t) sc->tx_bd_chain_paddr[i]);
 	}
 
 	/* Check the required size before mapping to conserve resources. */
@@ -3333,20 +3307,11 @@ bce_dma_alloc(device_t dev)
 	}
 
 	/* Create a DMA tag for TX mbufs. */
-	if (bus_dma_tag_create(sc->parent_tag,
-			1,
-			BCE_DMA_BOUNDARY,
-			sc->max_bus_addr,
-			BUS_SPACE_MAXADDR,
-			NULL, NULL,
-			max_size,
-			max_segments,
-			max_seg_size,
-			0,
-			NULL, NULL,
-			&sc->tx_mbuf_tag)) {
+	if (bus_dma_tag_create(sc->parent_tag, 1, BCE_DMA_BOUNDARY,
+	    sc->max_bus_addr, BUS_SPACE_MAXADDR, NULL, NULL, max_size,
+	    max_segments, max_seg_size,	0, NULL, NULL, &sc->tx_mbuf_tag)) {
 		BCE_PRINTF("%s(%d): Could not allocate TX mbuf DMA tag!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
@@ -3355,8 +3320,8 @@ bce_dma_alloc(device_t dev)
 	for (i = 0; i < TOTAL_TX_BD; i++) {
 		if (bus_dmamap_create(sc->tx_mbuf_tag, BUS_DMA_NOWAIT,
 			&sc->tx_mbuf_map[i])) {
-			BCE_PRINTF("%s(%d): Unable to create TX mbuf DMA map!\n",
-				__FILE__, __LINE__);
+			BCE_PRINTF("%s(%d): Unable to create TX mbuf DMA "
+			    "map!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
@@ -3367,20 +3332,13 @@ bce_dma_alloc(device_t dev)
 	 * allocate and clear the memory, and fetch the physical
 	 * address of the blocks.
 	 */
-	if (bus_dma_tag_create(sc->parent_tag,
-			BCM_PAGE_SIZE,
-			BCE_DMA_BOUNDARY,
-			BUS_SPACE_MAXADDR,
-			sc->max_bus_addr,
-			NULL, NULL,
-			BCE_RX_CHAIN_PAGE_SZ,
-			1,
-			BCE_RX_CHAIN_PAGE_SZ,
-			0,
-			NULL, NULL,
-			&sc->rx_bd_chain_tag)) {
-		BCE_PRINTF("%s(%d): Could not allocate RX descriptor chain DMA tag!\n",
-			__FILE__, __LINE__);
+	if (bus_dma_tag_create(sc->parent_tag, BCM_PAGE_SIZE,
+			BCE_DMA_BOUNDARY, BUS_SPACE_MAXADDR,
+			sc->max_bus_addr, NULL, NULL,
+			BCE_RX_CHAIN_PAGE_SZ, 1, BCE_RX_CHAIN_PAGE_SZ,
+			0, NULL, NULL, &sc->rx_bd_chain_tag)) {
+		BCE_PRINTF("%s(%d): Could not allocate RX descriptor chain "
+		    "DMA tag!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
@@ -3388,11 +3346,10 @@ bce_dma_alloc(device_t dev)
 	for (i = 0; i < RX_PAGES; i++) {
 
 		if (bus_dmamem_alloc(sc->rx_bd_chain_tag,
-	    		(void **)&sc->rx_bd_chain[i],
-	    		BUS_DMA_NOWAIT,
-		    	&sc->rx_bd_chain_map[i])) {
-			BCE_PRINTF("%s(%d): Could not allocate RX descriptor chain "
-				"DMA memory!\n", __FILE__, __LINE__);
+		    (void **)&sc->rx_bd_chain[i], BUS_DMA_NOWAIT,
+		    &sc->rx_bd_chain_map[i])) {
+			BCE_PRINTF("%s(%d): Could not allocate RX descriptor "
+			    "chain DMA memory!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
@@ -3400,22 +3357,19 @@ bce_dma_alloc(device_t dev)
 		bzero((char *)sc->rx_bd_chain[i], BCE_RX_CHAIN_PAGE_SZ);
 
 		error = bus_dmamap_load(sc->rx_bd_chain_tag,
-	    		sc->rx_bd_chain_map[i],
-	    		sc->rx_bd_chain[i],
-		    	BCE_RX_CHAIN_PAGE_SZ,
-		    	bce_dma_map_addr,
-	    		&sc->rx_bd_chain_paddr[i],
-	    		BUS_DMA_NOWAIT);
+		    sc->rx_bd_chain_map[i], sc->rx_bd_chain[i],
+		    BCE_RX_CHAIN_PAGE_SZ, bce_dma_map_addr,
+		    &sc->rx_bd_chain_paddr[i], BUS_DMA_NOWAIT);
 
 		if (error) {
-			BCE_PRINTF("%s(%d): Could not map RX descriptor chain DMA memory!\n",
-				__FILE__, __LINE__);
+			BCE_PRINTF("%s(%d): Could not map RX descriptor "
+			    "chain DMA memory!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
 
 		DBPRINT(sc, BCE_INFO, "%s(): rx_bd_chain_paddr[%d] = 0x%jX\n",
-			__FUNCTION__, i, (uintmax_t) sc->rx_bd_chain_paddr[i]);
+		    __FUNCTION__, i, (uintmax_t) sc->rx_bd_chain_paddr[i]);
 	}
 
 	/*
@@ -3430,23 +3384,14 @@ bce_dma_alloc(device_t dev)
 	max_segments = 1;
 
 	DBPRINT(sc, BCE_INFO, "%s(): Creating rx_mbuf_tag (max size = 0x%jX "
-		"max segments = %d, max segment size = 0x%jX)\n", __FUNCTION__,
-		(uintmax_t) max_size, max_segments, (uintmax_t) max_seg_size);
+	    "max segments = %d, max segment size = 0x%jX)\n", __FUNCTION__,
+	    (uintmax_t) max_size, max_segments, (uintmax_t) max_seg_size);
 
-	if (bus_dma_tag_create(sc->parent_tag,
-			1,
-			BCE_DMA_BOUNDARY,
-			sc->max_bus_addr,
-			BUS_SPACE_MAXADDR,
-			NULL, NULL,
-			max_size,
-			max_segments,
-			max_seg_size,
-			0,
-			NULL, NULL,
-	    	&sc->rx_mbuf_tag)) {
+	if (bus_dma_tag_create(sc->parent_tag, 1, BCE_DMA_BOUNDARY,
+	    sc->max_bus_addr, BUS_SPACE_MAXADDR, NULL, NULL, max_size,
+	   max_segments, max_seg_size, 0, NULL, NULL, &sc->rx_mbuf_tag)) {
 		BCE_PRINTF("%s(%d): Could not allocate RX mbuf DMA tag!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
@@ -3454,9 +3399,9 @@ bce_dma_alloc(device_t dev)
 	/* Create DMA maps for the RX mbuf clusters. */
 	for (i = 0; i < TOTAL_RX_BD; i++) {
 		if (bus_dmamap_create(sc->rx_mbuf_tag, BUS_DMA_NOWAIT,
-				&sc->rx_mbuf_map[i])) {
-			BCE_PRINTF("%s(%d): Unable to create RX mbuf DMA map!\n",
-				__FILE__, __LINE__);
+		    &sc->rx_mbuf_map[i])) {
+			BCE_PRINTF("%s(%d): Unable to create RX mbuf "
+			    "DMA map!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
@@ -3468,20 +3413,12 @@ bce_dma_alloc(device_t dev)
 	 * allocate and clear the memory, and fetch the physical
 	 * address of the blocks.
 	 */
-	if (bus_dma_tag_create(sc->parent_tag,
-			BCM_PAGE_SIZE,
-			BCE_DMA_BOUNDARY,
-			BUS_SPACE_MAXADDR,
-			sc->max_bus_addr,
-			NULL, NULL,
-			BCE_PG_CHAIN_PAGE_SZ,
-			1,
-			BCE_PG_CHAIN_PAGE_SZ,
-			0,
-			NULL, NULL,
-			&sc->pg_bd_chain_tag)) {
-		BCE_PRINTF("%s(%d): Could not allocate page descriptor chain DMA tag!\n",
-			__FILE__, __LINE__);
+	if (bus_dma_tag_create(sc->parent_tag, BCM_PAGE_SIZE,
+	    BCE_DMA_BOUNDARY, BUS_SPACE_MAXADDR, sc->max_bus_addr,
+	    NULL, NULL,	BCE_PG_CHAIN_PAGE_SZ, 1, BCE_PG_CHAIN_PAGE_SZ,
+	    0, NULL, NULL, &sc->pg_bd_chain_tag)) {
+		BCE_PRINTF("%s(%d): Could not allocate page descriptor "
+		    "chain DMA tag!\n",	__FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
@@ -3489,56 +3426,44 @@ bce_dma_alloc(device_t dev)
 	for (i = 0; i < PG_PAGES; i++) {
 
 		if (bus_dmamem_alloc(sc->pg_bd_chain_tag,
-	    		(void **)&sc->pg_bd_chain[i],
-	    		BUS_DMA_NOWAIT,
-		    	&sc->pg_bd_chain_map[i])) {
-			BCE_PRINTF("%s(%d): Could not allocate page descriptor chain "
-				"DMA memory!\n", __FILE__, __LINE__);
+		    (void **)&sc->pg_bd_chain[i], BUS_DMA_NOWAIT,
+		    &sc->pg_bd_chain_map[i])) {
+			BCE_PRINTF("%s(%d): Could not allocate page "
+			    "descriptor chain DMA memory!\n", 
+			    __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
 
 		bzero((char *)sc->pg_bd_chain[i], BCE_PG_CHAIN_PAGE_SZ);
 
-		error = bus_dmamap_load(sc->pg_bd_chain_tag,
-	    		sc->pg_bd_chain_map[i],
-	    		sc->pg_bd_chain[i],
-		    	BCE_PG_CHAIN_PAGE_SZ,
-		    	bce_dma_map_addr,
-	    		&sc->pg_bd_chain_paddr[i],
-	    		BUS_DMA_NOWAIT);
+		error = bus_dmamap_load(sc->pg_bd_chain_tag, 
+		    sc->pg_bd_chain_map[i], sc->pg_bd_chain[i],
+		    BCE_PG_CHAIN_PAGE_SZ, bce_dma_map_addr,
+		    &sc->pg_bd_chain_paddr[i], BUS_DMA_NOWAIT);
 
 		if (error) {
-			BCE_PRINTF("%s(%d): Could not map page descriptor chain DMA memory!\n",
-				__FILE__, __LINE__);
+			BCE_PRINTF("%s(%d): Could not map page descriptor "
+			    "chain DMA memory!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
 
 		DBPRINT(sc, BCE_INFO, "%s(): pg_bd_chain_paddr[%d] = 0x%jX\n",
-			__FUNCTION__, i, (uintmax_t) sc->pg_bd_chain_paddr[i]);
+		    __FUNCTION__, i, (uintmax_t) sc->pg_bd_chain_paddr[i]);
 	}
 
 	/*
 	 * Create a DMA tag for page mbufs.
 	 */
 	max_size = max_seg_size = ((sc->pg_bd_mbuf_alloc_size < MCLBYTES) ?
-		MCLBYTES : sc->pg_bd_mbuf_alloc_size);
+	    MCLBYTES : sc->pg_bd_mbuf_alloc_size);
 
-	if (bus_dma_tag_create(sc->parent_tag,
-			1,
-			BCE_DMA_BOUNDARY,
-			sc->max_bus_addr,
-			BUS_SPACE_MAXADDR,
-			NULL, NULL,
-			max_size,
-			1,
-			max_seg_size,
-			0,
-			NULL, NULL,
-	    	&sc->pg_mbuf_tag)) {
-		BCE_PRINTF("%s(%d): Could not allocate page mbuf DMA tag!\n",
-			__FILE__, __LINE__);
+	if (bus_dma_tag_create(sc->parent_tag, 1, BCE_DMA_BOUNDARY,
+	    sc->max_bus_addr, BUS_SPACE_MAXADDR, NULL, NULL,
+	    max_size, 1, max_seg_size, 0, NULL, NULL, &sc->pg_mbuf_tag)) {
+		BCE_PRINTF("%s(%d): Could not allocate page mbuf "
+		    "DMA tag!\n", __FILE__, __LINE__);
 		rc = ENOMEM;
 		goto bce_dma_alloc_exit;
 	}
@@ -3546,9 +3471,9 @@ bce_dma_alloc(device_t dev)
 	/* Create DMA maps for the page mbuf clusters. */
 	for (i = 0; i < TOTAL_PG_BD; i++) {
 		if (bus_dmamap_create(sc->pg_mbuf_tag, BUS_DMA_NOWAIT,
-				&sc->pg_mbuf_map[i])) {
-			BCE_PRINTF("%s(%d): Unable to create page mbuf DMA map!\n",
-				__FILE__, __LINE__);
+		    &sc->pg_mbuf_map[i])) {
+			BCE_PRINTF("%s(%d): Unable to create page mbuf "
+			    "DMA map!\n", __FILE__, __LINE__);
 			rc = ENOMEM;
 			goto bce_dma_alloc_exit;
 		}
@@ -3589,7 +3514,7 @@ bce_release_resources(struct bce_softc *sc)
 	if (sc->bce_res_irq != NULL) {
 		DBPRINT(sc, BCE_INFO_RESET, "Releasing IRQ.\n");
 		bus_release_resource(dev, SYS_RES_IRQ, sc->bce_irq_rid,
-			sc->bce_res_irq);
+		    sc->bce_res_irq);
 	}
 
 	if (sc->bce_flags & (BCE_USING_MSI_FLAG | BCE_USING_MSIX_FLAG)) {
@@ -3599,7 +3524,8 @@ bce_release_resources(struct bce_softc *sc)
 
 	if (sc->bce_res_mem != NULL) {
 		DBPRINT(sc, BCE_INFO_RESET, "Releasing PCI memory.\n");
-		bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0), sc->bce_res_mem);
+		    bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0), 
+		    sc->bce_res_mem);
 	}
 
 	if (sc->bce_ifp != NULL) {
@@ -3632,7 +3558,7 @@ bce_fw_sync(struct bce_softc *sc, u32 msg_data)
 	DBENTER(BCE_VERBOSE_RESET);
 
 	/* Don't waste any time if we've timed out before. */
-	if (sc->bce_fw_timed_out) {
+	if (sc->bce_fw_timed_out == TRUE) {
 		rc = EBUSY;
 		goto bce_fw_sync_exit;
 	}
@@ -3641,8 +3567,8 @@ bce_fw_sync(struct bce_softc *sc, u32 msg_data)
 	sc->bce_fw_wr_seq++;
 	msg_data |= sc->bce_fw_wr_seq;
 
- 	DBPRINT(sc, BCE_VERBOSE_FIRMWARE, "bce_fw_sync(): msg_data = 0x%08X\n",
- 		msg_data);
+ 	DBPRINT(sc, BCE_VERBOSE_FIRMWARE, "bce_fw_sync(): msg_data = "
+	    "0x%08X\n",	msg_data);
 
 	/* Send the message to the bootcode driver mailbox. */
 	bce_shmem_wr(sc, BCE_DRV_MB, msg_data);
@@ -3658,18 +3584,17 @@ bce_fw_sync(struct bce_softc *sc, u32 msg_data)
 
 	/* If we've timed out, tell the bootcode that we've stopped waiting. */
 	if (((val & BCE_FW_MSG_ACK) != (msg_data & BCE_DRV_MSG_SEQ)) &&
-		((msg_data & BCE_DRV_MSG_DATA) != BCE_DRV_MSG_DATA_WAIT0)) {
+	    ((msg_data & BCE_DRV_MSG_DATA) != BCE_DRV_MSG_DATA_WAIT0)) {
 
 		BCE_PRINTF("%s(%d): Firmware synchronization timeout! "
-			"msg_data = 0x%08X\n",
-			__FILE__, __LINE__, msg_data);
+		    "msg_data = 0x%08X\n", __FILE__, __LINE__, msg_data);
 
 		msg_data &= ~BCE_DRV_MSG_CODE;
 		msg_data |= BCE_DRV_MSG_CODE_FW_TIMEOUT;
 
 		bce_shmem_wr(sc, BCE_DRV_MB, msg_data);
 
-		sc->bce_fw_timed_out = 1;
+		sc->bce_fw_timed_out = TRUE;
 		rc = EBUSY;
 	}
 
@@ -3797,9 +3722,9 @@ bce_load_cpu_fw(struct bce_softc *sc, struct cpu_reg *cpu_reg,
 		}
 	}
 
-    /* Clear the pre-fetch instruction and set the FW start address. */
-    REG_WR_IND(sc, cpu_reg->inst, 0);
-    REG_WR_IND(sc, cpu_reg->pc, fw->start_addr);
+	/* Clear the pre-fetch instruction and set the FW start address. */
+	REG_WR_IND(sc, cpu_reg->inst, 0);
+	REG_WR_IND(sc, cpu_reg->pc, fw->start_addr);
 
 	DBEXIT(BCE_VERBOSE_RESET);
 }
@@ -3843,11 +3768,11 @@ bce_halt_cpu(struct bce_softc *sc, struct cpu_reg *cpu_reg)
 
 	DBENTER(BCE_VERBOSE_RESET);
 
-    /* Halt the CPU. */
-    val = REG_RD_IND(sc, cpu_reg->mode);
-    val |= cpu_reg->mode_value_halt;
-    REG_WR_IND(sc, cpu_reg->mode, val);
-    REG_WR_IND(sc, cpu_reg->state, cpu_reg->state_value_clear);
+	/* Halt the CPU. */
+	val = REG_RD_IND(sc, cpu_reg->mode);
+	val |= cpu_reg->mode_value_halt;
+	REG_WR_IND(sc, cpu_reg->mode, val);
+	REG_WR_IND(sc, cpu_reg->state, cpu_reg->state_value_clear);
 
 	DBEXIT(BCE_VERBOSE_RESET);
 }
@@ -4175,7 +4100,7 @@ bce_init_tpat_cpu(struct bce_softc *sc)
 
 	DBPRINT(sc, BCE_INFO_RESET, "Loading TPAT firmware.\n");
 	bce_load_cpu_fw(sc, &cpu_reg, &fw);
-    bce_start_cpu(sc, &cpu_reg);
+	bce_start_cpu(sc, &cpu_reg);
 
 	DBEXIT(BCE_VERBOSE_RESET);
 }
@@ -4273,7 +4198,7 @@ bce_init_cp_cpu(struct bce_softc *sc)
 
 	DBPRINT(sc, BCE_INFO_RESET, "Loading CP firmware.\n");
 	bce_load_cpu_fw(sc, &cpu_reg, &fw);
-    bce_start_cpu(sc, &cpu_reg);
+	bce_start_cpu(sc, &cpu_reg);
 
 	DBEXIT(BCE_VERBOSE_RESET);
 }
@@ -4371,7 +4296,7 @@ bce_init_com_cpu(struct bce_softc *sc)
 
 	DBPRINT(sc, BCE_INFO_RESET, "Loading COM firmware.\n");
 	bce_load_cpu_fw(sc, &cpu_reg, &fw);
-    bce_start_cpu(sc, &cpu_reg);
+	bce_start_cpu(sc, &cpu_reg);
 
 	DBEXIT(BCE_VERBOSE_RESET);
 }
@@ -4437,7 +4362,7 @@ bce_init_ctx(struct bce_softc *sc)
 	DBENTER(BCE_VERBOSE_RESET | BCE_VERBOSE_CTX);
 
 	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
 		int i, retry_cnt = CTX_INIT_RETRY_COUNT;
 		u32 val;
 
@@ -4448,7 +4373,8 @@ bce_init_ctx(struct bce_softc *sc)
 		 * in host memory so prepare the host memory
 		 * for access.
 		 */
-		val = BCE_CTX_COMMAND_ENABLED | BCE_CTX_COMMAND_MEM_INIT | (1 << 12);
+		val = BCE_CTX_COMMAND_ENABLED | 
+		    BCE_CTX_COMMAND_MEM_INIT | (1 << 12);
 		val |= (BCM_PAGE_BITS - 8) << 16;
 		REG_WR(sc, BCE_CTX_COMMAND, val);
 
@@ -4462,33 +4388,34 @@ bce_init_ctx(struct bce_softc *sc)
 
 		/* ToDo: Consider returning an error here. */
 		DBRUNIF((val & BCE_CTX_COMMAND_MEM_INIT),
-			BCE_PRINTF("%s(): Context memory initialization failed!\n",
-			__FUNCTION__));
+		    BCE_PRINTF("%s(): Context memory initialization "
+		    "failed!\n", __FUNCTION__));
 
 		for (i = 0; i < sc->ctx_pages; i++) {
 			int j;
 
-			/* Set the physical address of the context memory cache. */
+			/* Set the physical address of the context memory. */
 			REG_WR(sc, BCE_CTX_HOST_PAGE_TBL_DATA0,
-				BCE_ADDR_LO(sc->ctx_paddr[i] & 0xfffffff0) |
-				BCE_CTX_HOST_PAGE_TBL_DATA0_VALID);
+			    BCE_ADDR_LO(sc->ctx_paddr[i] & 0xfffffff0) |
+			    BCE_CTX_HOST_PAGE_TBL_DATA0_VALID);
 			REG_WR(sc, BCE_CTX_HOST_PAGE_TBL_DATA1,
-				BCE_ADDR_HI(sc->ctx_paddr[i]));
+			    BCE_ADDR_HI(sc->ctx_paddr[i]));
 			REG_WR(sc, BCE_CTX_HOST_PAGE_TBL_CTRL, i |
-				BCE_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ);
+			    BCE_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ);
 
-			/* Verify that the context memory write was successful. */
+			/* Verify the context memory write was successful. */
 			for (j = 0; j < retry_cnt; j++) {
 				val = REG_RD(sc, BCE_CTX_HOST_PAGE_TBL_CTRL);
-				if ((val & BCE_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ) == 0)
+				if ((val & 
+				    BCE_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ) == 0)
 					break;
 				DELAY(5);
 			}
 
 			/* ToDo: Consider returning an error here. */
 			DBRUNIF((val & BCE_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ),
-				BCE_PRINTF("%s(): Failed to initialize context page %d!\n",
-				__FUNCTION__, i));
+			    BCE_PRINTF("%s(): Failed to initialize "
+			    "context page %d!\n", __FUNCTION__, i));
 		}
 	} else {
 		u32 vcid_addr, offset;
@@ -4509,9 +4436,9 @@ bce_init_ctx(struct bce_softc *sc)
 			REG_WR(sc, BCE_CTX_VIRT_ADDR, 0);
 			REG_WR(sc, BCE_CTX_PAGE_TBL, vcid_addr);
 
-            for(offset = 0; offset < PHY_CTX_SIZE; offset += 4) {
-                CTX_WR(sc, 0x00, offset, 0);
-            }
+			for(offset = 0; offset < PHY_CTX_SIZE; offset += 4) {
+				CTX_WR(sc, 0x00, offset, 0);
+			}
 
 			REG_WR(sc, BCE_CTX_VIRT_ADDR, vcid_addr);
 			REG_WR(sc, BCE_CTX_PAGE_TBL, vcid_addr);
@@ -4654,7 +4581,7 @@ bce_stop(struct bce_softc *sc)
 	ifp->if_flags = itmp;
 	sc->watchdog_timer = 0;
 
-	sc->bce_link = 0;
+	sc->bce_link_up = FALSE;
 
 	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 
@@ -4691,7 +4618,8 @@ bce_reset(struct bce_softc *sc, u32 reset_code)
 	}
 
 	/* Assume bootcode is running. */
-	sc->bce_fw_timed_out = 0;
+	sc->bce_fw_timed_out = FALSE;
+	sc->bce_drv_cardiac_arrest = FALSE;
 
 	/* Give the firmware a chance to prepare for the reset. */
 	rc = bce_fw_sync(sc, BCE_DRV_MSG_DATA_WAIT0 | reset_code);
@@ -4751,7 +4679,8 @@ bce_reset(struct bce_softc *sc, u32 reset_code)
 	}
 
 	/* Just completed a reset, assume that firmware is running again. */
-	sc->bce_fw_timed_out = 0;
+	sc->bce_fw_timed_out = FALSE;
+	sc->bce_drv_cardiac_arrest = FALSE;
 
 	/* Wait for the firmware to finish its initialization. */
 	rc = bce_fw_sync(sc, BCE_DRV_MSG_DATA_WAIT1 | reset_code);
@@ -4807,9 +4736,9 @@ bce_chipinit(struct bce_softc *sc)
 
 	/* Enable the RX_V2P and Context state machines before access. */
 	REG_WR(sc, BCE_MISC_ENABLE_SET_BITS,
-	       BCE_MISC_ENABLE_SET_BITS_HOST_COALESCE_ENABLE |
-	       BCE_MISC_ENABLE_STATUS_BITS_RX_V2P_ENABLE |
-	       BCE_MISC_ENABLE_STATUS_BITS_CONTEXT_ENABLE);
+	    BCE_MISC_ENABLE_SET_BITS_HOST_COALESCE_ENABLE |
+	    BCE_MISC_ENABLE_STATUS_BITS_RX_V2P_ENABLE |
+	    BCE_MISC_ENABLE_STATUS_BITS_CONTEXT_ENABLE);
 
 	/* Initialize context mapping and zero out the quick contexts. */
 	bce_init_ctx(sc);
@@ -4817,11 +4746,11 @@ bce_chipinit(struct bce_softc *sc)
 	/* Initialize the on-boards CPUs */
 	bce_init_cpus(sc);
 
-    /* Enable management frames (NC-SI) to flow to the MCP. */
-    if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
-        val = REG_RD(sc, BCE_RPM_MGMT_PKT_CTRL) | BCE_RPM_MGMT_PKT_CTRL_MGMT_EN;
-        REG_WR(sc, BCE_RPM_MGMT_PKT_CTRL, val);
-    }
+	/* Enable management frames (NC-SI) to flow to the MCP. */
+	if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
+		val = REG_RD(sc, BCE_RPM_MGMT_PKT_CTRL) | BCE_RPM_MGMT_PKT_CTRL_MGMT_EN;
+		REG_WR(sc, BCE_RPM_MGMT_PKT_CTRL, val);
+	}
 
 	/* Prepare NVRAM for access. */
 	if (bce_init_nvram(sc)) {
@@ -4899,56 +4828,56 @@ bce_blockinit(struct bce_softc *sc)
 
 	/* Program the physical address of the status block. */
 	REG_WR(sc, BCE_HC_STATUS_ADDR_L,
-		BCE_ADDR_LO(sc->status_block_paddr));
+	    BCE_ADDR_LO(sc->status_block_paddr));
 	REG_WR(sc, BCE_HC_STATUS_ADDR_H,
-		BCE_ADDR_HI(sc->status_block_paddr));
+	    BCE_ADDR_HI(sc->status_block_paddr));
 
 	/* Program the physical address of the statistics block. */
 	REG_WR(sc, BCE_HC_STATISTICS_ADDR_L,
-		BCE_ADDR_LO(sc->stats_block_paddr));
+	    BCE_ADDR_LO(sc->stats_block_paddr));
 	REG_WR(sc, BCE_HC_STATISTICS_ADDR_H,
-		BCE_ADDR_HI(sc->stats_block_paddr));
+	    BCE_ADDR_HI(sc->stats_block_paddr));
 
 	/* Program various host coalescing parameters. */
 	REG_WR(sc, BCE_HC_TX_QUICK_CONS_TRIP,
-		(sc->bce_tx_quick_cons_trip_int << 16) | sc->bce_tx_quick_cons_trip);
+	    (sc->bce_tx_quick_cons_trip_int << 16) | sc->bce_tx_quick_cons_trip);
 	REG_WR(sc, BCE_HC_RX_QUICK_CONS_TRIP,
-		(sc->bce_rx_quick_cons_trip_int << 16) | sc->bce_rx_quick_cons_trip);
+	    (sc->bce_rx_quick_cons_trip_int << 16) | sc->bce_rx_quick_cons_trip);
 	REG_WR(sc, BCE_HC_COMP_PROD_TRIP,
-		(sc->bce_comp_prod_trip_int << 16) | sc->bce_comp_prod_trip);
+	    (sc->bce_comp_prod_trip_int << 16) | sc->bce_comp_prod_trip);
 	REG_WR(sc, BCE_HC_TX_TICKS,
-		(sc->bce_tx_ticks_int << 16) | sc->bce_tx_ticks);
+	    (sc->bce_tx_ticks_int << 16) | sc->bce_tx_ticks);
 	REG_WR(sc, BCE_HC_RX_TICKS,
-		(sc->bce_rx_ticks_int << 16) | sc->bce_rx_ticks);
+	    (sc->bce_rx_ticks_int << 16) | sc->bce_rx_ticks);
 	REG_WR(sc, BCE_HC_COM_TICKS,
-		(sc->bce_com_ticks_int << 16) | sc->bce_com_ticks);
+	    (sc->bce_com_ticks_int << 16) | sc->bce_com_ticks);
 	REG_WR(sc, BCE_HC_CMD_TICKS,
-		(sc->bce_cmd_ticks_int << 16) | sc->bce_cmd_ticks);
+	    (sc->bce_cmd_ticks_int << 16) | sc->bce_cmd_ticks);
 	REG_WR(sc, BCE_HC_STATS_TICKS,
-		(sc->bce_stats_ticks & 0xffff00));
+	    (sc->bce_stats_ticks & 0xffff00));
 	REG_WR(sc, BCE_HC_STAT_COLLECT_TICKS, 0xbb8);  /* 3ms */
 
 	/* Configure the Host Coalescing block. */
 	val = BCE_HC_CONFIG_RX_TMR_MODE | BCE_HC_CONFIG_TX_TMR_MODE |
-		      BCE_HC_CONFIG_COLLECT_STATS;
+	    BCE_HC_CONFIG_COLLECT_STATS;
 
 #if 0
 	/* ToDo: Add MSI-X support. */
 	if (sc->bce_flags & BCE_USING_MSIX_FLAG) {
 		u32 base = ((BCE_TX_VEC - 1) * BCE_HC_SB_CONFIG_SIZE) +
-			   BCE_HC_SB_CONFIG_1;
+		    BCE_HC_SB_CONFIG_1;
 
 		REG_WR(sc, BCE_HC_MSIX_BIT_VECTOR, BCE_HC_MSIX_BIT_VECTOR_VAL);
 
 		REG_WR(sc, base, BCE_HC_SB_CONFIG_1_TX_TMR_MODE |
-			BCE_HC_SB_CONFIG_1_ONE_SHOT);
+		    BCE_HC_SB_CONFIG_1_ONE_SHOT);
 
 		REG_WR(sc, base + BCE_HC_TX_QUICK_CONS_TRIP_OFF,
-			(sc->tx_quick_cons_trip_int << 16) |
-			 sc->tx_quick_cons_trip);
+		    (sc->tx_quick_cons_trip_int << 16) |
+		     sc->tx_quick_cons_trip);
 
 		REG_WR(sc, base + BCE_HC_TX_TICKS_OFF,
-			(sc->tx_ticks_int << 16) | sc->tx_ticks);
+		    (sc->tx_ticks_int << 16) | sc->tx_ticks);
 
 		val |= BCE_HC_CONFIG_SB_ADDR_INC_128B;
 	}
@@ -4975,49 +4904,53 @@ bce_blockinit(struct bce_softc *sc)
 	reg = bce_shmem_rd(sc, BCE_DEV_INFO_SIGNATURE);
 
 	DBRUNIF(DB_RANDOMTRUE(bootcode_running_failure_sim_control),
-		BCE_PRINTF("%s(%d): Simulating bootcode failure.\n",
-			__FILE__, __LINE__);
-		reg = 0);
+	    BCE_PRINTF("%s(%d): Simulating bootcode failure.\n",
+	    __FILE__, __LINE__);
+	    reg = 0);
 
 	if ((reg & BCE_DEV_INFO_SIGNATURE_MAGIC_MASK) !=
 	    BCE_DEV_INFO_SIGNATURE_MAGIC) {
 		BCE_PRINTF("%s(%d): Bootcode not running! Found: 0x%08X, "
-			"Expected: 08%08X\n", __FILE__, __LINE__,
-			(reg & BCE_DEV_INFO_SIGNATURE_MAGIC_MASK),
-			BCE_DEV_INFO_SIGNATURE_MAGIC);
+		    "Expected: 08%08X\n", __FILE__, __LINE__,
+		    (reg & BCE_DEV_INFO_SIGNATURE_MAGIC_MASK),
+		    BCE_DEV_INFO_SIGNATURE_MAGIC);
 		rc = ENODEV;
 		goto bce_blockinit_exit;
 	}
 
 	/* Enable DMA */
 	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
 		val = REG_RD(sc, BCE_MISC_NEW_CORE_CTL);
 		val |= BCE_MISC_NEW_CORE_CTL_DMA_ENABLE;
 		REG_WR(sc, BCE_MISC_NEW_CORE_CTL, val);
 	}
 
-	/* Allow bootcode to apply any additional fixes before enabling MAC. */
-	rc = bce_fw_sync(sc, BCE_DRV_MSG_DATA_WAIT2 | BCE_DRV_MSG_CODE_RESET);
+	/* Allow bootcode to apply additional fixes before enabling MAC. */
+	rc = bce_fw_sync(sc, BCE_DRV_MSG_DATA_WAIT2 | 
+	    BCE_DRV_MSG_CODE_RESET);
 
 	/* Enable link state change interrupt generation. */
 	REG_WR(sc, BCE_HC_ATTN_BITS_ENABLE, STATUS_ATTN_BITS_LINK_STATE);
 
-    /* Enable the RXP. */
-    bce_start_rxp_cpu(sc);
+	/* Enable the RXP. */
+	bce_start_rxp_cpu(sc);
 
-    /* Disable management frames (NC-SI) from flowing to the MCP. */
-    if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
-        val = REG_RD(sc, BCE_RPM_MGMT_PKT_CTRL) & ~BCE_RPM_MGMT_PKT_CTRL_MGMT_EN;
-        REG_WR(sc, BCE_RPM_MGMT_PKT_CTRL, val);
-    }
+	/* Disable management frames (NC-SI) from flowing to the MCP. */
+	if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
+		val = REG_RD(sc, BCE_RPM_MGMT_PKT_CTRL) & 
+		    ~BCE_RPM_MGMT_PKT_CTRL_MGMT_EN;
+		REG_WR(sc, BCE_RPM_MGMT_PKT_CTRL, val);
+	}
 
 	/* Enable all remaining blocks in the MAC. */
-	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709)	||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716))
-		REG_WR(sc, BCE_MISC_ENABLE_SET_BITS, BCE_MISC_ENABLE_DEFAULT_XI);
+	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716))
+		REG_WR(sc, BCE_MISC_ENABLE_SET_BITS, 
+		    BCE_MISC_ENABLE_DEFAULT_XI);
 	else
-		REG_WR(sc, BCE_MISC_ENABLE_SET_BITS, BCE_MISC_ENABLE_DEFAULT);
+		REG_WR(sc, BCE_MISC_ENABLE_SET_BITS, 
+		    BCE_MISC_ENABLE_DEFAULT);
 
 	REG_RD(sc, BCE_MISC_ENABLE_SET_BITS);
 	DELAY(20);
@@ -5040,7 +4973,7 @@ bce_blockinit_exit:
 /****************************************************************************/
 static int
 bce_get_rx_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
-	u16 *chain_prod, u32 *prod_bseq)
+    u16 *chain_prod, u32 *prod_bseq)
 {
 	bus_dmamap_t map;
 	bus_dma_segment_t segs[BCE_MAX_SEGMENTS];
@@ -5058,8 +4991,9 @@ bce_get_rx_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 		BCE_PRINTF("%s(%d): RX producer out of range: 0x%04X > 0x%04X\n",
 		__FILE__, __LINE__, *chain_prod, (u16) MAX_RX_BD));
 
-	DBPRINT(sc, BCE_EXTREME_RECV, "%s(enter): prod = 0x%04X, chain_prod = 0x%04X, "
-		"prod_bseq = 0x%08X\n", __FUNCTION__, *prod, *chain_prod, *prod_bseq);
+	DBPRINT(sc, BCE_EXTREME_RECV, "%s(enter): prod = 0x%04X, "
+	    "chain_prod = 0x%04X, prod_bseq = 0x%08X\n", __FUNCTION__,
+	    *prod, *chain_prod, *prod_bseq);
 
 	/* Update some debug statistic counters */
 	DBRUNIF((sc->free_rx_bd < sc->rx_low_watermark),
@@ -5071,10 +5005,10 @@ bce_get_rx_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 
 		/* Simulate an mbuf allocation failure. */
 		DBRUNIF(DB_RANDOMTRUE(mbuf_alloc_failed_sim_control),
-			sc->mbuf_alloc_failed_count++;
-			sc->mbuf_alloc_failed_sim_count++;
-			rc = ENOBUFS;
-			goto bce_get_rx_buf_exit);
+		    sc->mbuf_alloc_failed_count++;
+		    sc->mbuf_alloc_failed_sim_count++;
+		    rc = ENOBUFS;
+		    goto bce_get_rx_buf_exit);
 
 		/* This is a new mbuf allocation. */
 #ifdef BCE_JUMBO_HDRSPLIT
@@ -5083,7 +5017,8 @@ bce_get_rx_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 		if (sc->rx_bd_mbuf_alloc_size <= MCLBYTES)
 			m_new = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
 		else
-			m_new = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, sc->rx_bd_mbuf_alloc_size);
+			m_new = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, 
+			    sc->rx_bd_mbuf_alloc_size);
 #endif
 
 		if (m_new == NULL) {
@@ -5115,7 +5050,7 @@ bce_get_rx_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 	/* Handle any mapping errors. */
 	if (error) {
 		BCE_PRINTF("%s(%d): Error mapping mbuf into RX chain (%d)!\n",
-			__FILE__, __LINE__, error);
+		    __FILE__, __LINE__, error);
 
 		sc->dma_map_addr_rx_failed_count++;
 		m_freem(m_new);
@@ -5128,9 +5063,7 @@ bce_get_rx_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 
 	/* All mbufs must map to a single segment. */
 	KASSERT(nsegs == 1, ("%s(): Too many segments returned (%d)!",
-		 __FUNCTION__, nsegs));
-
-	/* ToDo: Do we need bus_dmamap_sync(,,BUS_DMASYNC_PREREAD) here? */
+	    __FUNCTION__, nsegs));
 
 	/* Setup the rx_bd for the segment. */
 	rxbd = &sc->rx_bd_chain[RX_PAGE(*chain_prod)][RX_IDX(*chain_prod)];
@@ -5145,11 +5078,12 @@ bce_get_rx_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 	sc->rx_mbuf_ptr[*chain_prod] = m_new;
 	sc->free_rx_bd -= nsegs;
 
-	DBRUNMSG(BCE_INSANE_RECV, bce_dump_rx_mbuf_chain(sc, debug_chain_prod,
-		nsegs));
+	DBRUNMSG(BCE_INSANE_RECV, 
+	    bce_dump_rx_mbuf_chain(sc, debug_chain_prod, nsegs));
 
-	DBPRINT(sc, BCE_EXTREME_RECV, "%s(exit): prod = 0x%04X, chain_prod = 0x%04X, "
-		"prod_bseq = 0x%08X\n", __FUNCTION__, *prod, *chain_prod, *prod_bseq);
+	DBPRINT(sc, BCE_EXTREME_RECV, "%s(exit): prod = 0x%04X, "
+	    "chain_prod = 0x%04X, prod_bseq = 0x%08X\n", 
+	    __FUNCTION__, *prod, *chain_prod, *prod_bseq);
 
 bce_get_rx_buf_exit:
 	DBEXIT(BCE_EXTREME_RESET | BCE_EXTREME_RECV | BCE_EXTREME_LOAD);
@@ -5160,7 +5094,7 @@ bce_get_rx_buf_exit:
 
 #ifdef BCE_JUMBO_HDRSPLIT
 /****************************************************************************/
-/* Encapsulate an mbuf cluster into the page chain.                        */
+/* Encapsulate an mbuf cluster into the page chain.                         */
 /*                                                                          */
 /* Returns:                                                                 */
 /*   0 for success, positive value for failure.                             */
@@ -5182,15 +5116,15 @@ bce_get_pg_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 
 	/* Make sure the inputs are valid. */
 	DBRUNIF((*prod_idx > MAX_PG_BD),
-		BCE_PRINTF("%s(%d): page producer out of range: 0x%04X > 0x%04X\n",
-		__FILE__, __LINE__, *prod_idx, (u16) MAX_PG_BD));
+	    BCE_PRINTF("%s(%d): page producer out of range: 0x%04X > 0x%04X\n",
+	    __FILE__, __LINE__, *prod_idx, (u16) MAX_PG_BD));
 
 	DBPRINT(sc, BCE_EXTREME_RECV, "%s(enter): prod = 0x%04X, "
-		"chain_prod = 0x%04X\n", __FUNCTION__, *prod, *prod_idx);
+	    "chain_prod = 0x%04X\n", __FUNCTION__, *prod, *prod_idx);
 
 	/* Update counters if we've hit a new low or run out of pages. */
 	DBRUNIF((sc->free_pg_bd < sc->pg_low_watermark),
-		sc->pg_low_watermark = sc->free_pg_bd);
+	    sc->pg_low_watermark = sc->free_pg_bd);
 	DBRUNIF((sc->free_pg_bd == sc->max_pg_bd), sc->pg_empty_count++);
 
 	/* Check whether this is a new mbuf allocation. */
@@ -5198,10 +5132,10 @@ bce_get_pg_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 
 		/* Simulate an mbuf allocation failure. */
 		DBRUNIF(DB_RANDOMTRUE(mbuf_alloc_failed_sim_control),
-			sc->mbuf_alloc_failed_count++;
-			sc->mbuf_alloc_failed_sim_count++;
-			rc = ENOBUFS;
-			goto bce_get_pg_buf_exit);
+		    sc->mbuf_alloc_failed_count++;
+		    sc->mbuf_alloc_failed_sim_count++;
+		    rc = ENOBUFS;
+		    goto bce_get_pg_buf_exit);
 
 		/* This is a new mbuf allocation. */
 		m_new = m_getcl(M_DONTWAIT, MT_DATA, 0);
@@ -5225,12 +5159,13 @@ bce_get_pg_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 	/* Map the mbuf cluster into device memory. */
 	map = sc->pg_mbuf_map[*prod_idx];
 	error = bus_dmamap_load(sc->pg_mbuf_tag, map, mtod(m_new, void *),
-	    sc->pg_bd_mbuf_alloc_size, bce_dma_map_addr, &busaddr, BUS_DMA_NOWAIT);
+	    sc->pg_bd_mbuf_alloc_size, bce_dma_map_addr, 
+	    &busaddr, BUS_DMA_NOWAIT);
 
 	/* Handle any mapping errors. */
 	if (error) {
 		BCE_PRINTF("%s(%d): Error mapping mbuf into page chain!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 
 		m_freem(m_new);
 		DBRUN(sc->debug_pg_mbuf_alloc--);
@@ -5256,11 +5191,11 @@ bce_get_pg_buf(struct bce_softc *sc, struct mbuf *m, u16 *prod,
 	sc->pg_mbuf_ptr[*prod_idx] = m_new;
 	sc->free_pg_bd--;
 
-	DBRUNMSG(BCE_INSANE_RECV, bce_dump_pg_mbuf_chain(sc, debug_prod_idx,
-		1));
+	DBRUNMSG(BCE_INSANE_RECV, 
+	    bce_dump_pg_mbuf_chain(sc, debug_prod_idx, 1));
 
 	DBPRINT(sc, BCE_EXTREME_RECV, "%s(exit): prod = 0x%04X, "
-		"prod_idx = 0x%04X\n", __FUNCTION__, *prod, *prod_idx);
+	    "prod_idx = 0x%04X\n", __FUNCTION__, *prod, *prod_idx);
 
 bce_get_pg_buf_exit:
 	DBEXIT(BCE_EXTREME_RESET | BCE_EXTREME_RECV | BCE_EXTREME_LOAD);
@@ -5269,6 +5204,7 @@ bce_get_pg_buf_exit:
 }
 #endif /* BCE_JUMBO_HDRSPLIT */
 
+
 /****************************************************************************/
 /* Initialize the TX context memory.                                        */
 /*                                                                          */
@@ -5286,16 +5222,20 @@ bce_init_tx_context(struct bce_softc *sc)
 	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
 		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
 		/* Set the CID type to support an L2 connection. */
-		val = BCE_L2CTX_TX_TYPE_TYPE_L2_XI | BCE_L2CTX_TX_TYPE_SIZE_L2_XI;
+		val = BCE_L2CTX_TX_TYPE_TYPE_L2_XI | 
+		    BCE_L2CTX_TX_TYPE_SIZE_L2_XI;
 		CTX_WR(sc, GET_CID_ADDR(TX_CID), BCE_L2CTX_TX_TYPE_XI, val);
 		val = BCE_L2CTX_TX_CMD_TYPE_TYPE_L2_XI | (8 << 16);
-		CTX_WR(sc, GET_CID_ADDR(TX_CID), BCE_L2CTX_TX_CMD_TYPE_XI, val);
+		CTX_WR(sc, GET_CID_ADDR(TX_CID), 
+		    BCE_L2CTX_TX_CMD_TYPE_XI, val);
 
 		/* Point the hardware to the first page in the chain. */
 		val = BCE_ADDR_HI(sc->tx_bd_chain_paddr[0]);
-		CTX_WR(sc, GET_CID_ADDR(TX_CID), BCE_L2CTX_TX_TBDR_BHADDR_HI_XI, val);
+		CTX_WR(sc, GET_CID_ADDR(TX_CID), 
+		    BCE_L2CTX_TX_TBDR_BHADDR_HI_XI, val);
 		val = BCE_ADDR_LO(sc->tx_bd_chain_paddr[0]);
-		CTX_WR(sc, GET_CID_ADDR(TX_CID), BCE_L2CTX_TX_TBDR_BHADDR_LO_XI, val);
+		CTX_WR(sc, GET_CID_ADDR(TX_CID), 
+		    BCE_L2CTX_TX_TBDR_BHADDR_LO_XI, val);
 	} else {
 		/* Set the CID type to support an L2 connection. */
 		val = BCE_L2CTX_TX_TYPE_TYPE_L2 | BCE_L2CTX_TX_TYPE_SIZE_L2;
@@ -5305,9 +5245,11 @@ bce_init_tx_context(struct bce_softc *sc)
 
 		/* Point the hardware to the first page in the chain. */
 		val = BCE_ADDR_HI(sc->tx_bd_chain_paddr[0]);
-		CTX_WR(sc, GET_CID_ADDR(TX_CID), BCE_L2CTX_TX_TBDR_BHADDR_HI, val);
+		CTX_WR(sc, GET_CID_ADDR(TX_CID), 
+		    BCE_L2CTX_TX_TBDR_BHADDR_HI, val);
 		val = BCE_ADDR_LO(sc->tx_bd_chain_paddr[0]);
-		CTX_WR(sc, GET_CID_ADDR(TX_CID), BCE_L2CTX_TX_TBDR_BHADDR_LO, val);
+		CTX_WR(sc, GET_CID_ADDR(TX_CID), 
+		    BCE_L2CTX_TX_TBDR_BHADDR_LO, val);
 	}
 
 	DBEXIT(BCE_VERBOSE_RESET | BCE_VERBOSE_SEND | BCE_VERBOSE_CTX);
@@ -5334,7 +5276,7 @@ bce_init_tx_chain(struct bce_softc *sc)
 	sc->tx_prod_bseq   = 0;
 	sc->used_tx_bd     = 0;
 	sc->max_tx_bd      = USABLE_TX_BD;
-	DBRUN(sc->tx_hi_watermark = USABLE_TX_BD);
+	DBRUN(sc->tx_hi_watermark = 0);
 	DBRUN(sc->tx_full_count = 0);
 
 	/*
@@ -5389,8 +5331,9 @@ bce_free_tx_chain(struct bce_softc *sc)
 	for (i = 0; i < TOTAL_TX_BD; i++) {
 		if (sc->tx_mbuf_ptr[i] != NULL) {
 			if (sc->tx_mbuf_map[i] != NULL)
-				bus_dmamap_sync(sc->tx_mbuf_tag, sc->tx_mbuf_map[i],
-					BUS_DMASYNC_POSTWRITE);
+				bus_dmamap_sync(sc->tx_mbuf_tag, 
+				    sc->tx_mbuf_map[i],
+				    BUS_DMASYNC_POSTWRITE);
 			m_freem(sc->tx_mbuf_ptr[i]);
 			sc->tx_mbuf_ptr[i] = NULL;
 			DBRUN(sc->debug_tx_mbuf_alloc--);
@@ -5401,13 +5344,13 @@ bce_free_tx_chain(struct bce_softc *sc)
 	for (i = 0; i < TX_PAGES; i++)
 		bzero((char *)sc->tx_bd_chain[i], BCE_TX_CHAIN_PAGE_SZ);
 
-	sc->used_tx_bd     = 0;
+	sc->used_tx_bd = 0;
 
 	/* Check if we lost any mbufs in the process. */
 	DBRUNIF((sc->debug_tx_mbuf_alloc),
-		BCE_PRINTF("%s(%d): Memory leak! Lost %d mbufs "
-			"from tx chain!\n",
-			__FILE__, __LINE__, sc->debug_tx_mbuf_alloc));
+	    BCE_PRINTF("%s(%d): Memory leak! Lost %d mbufs "
+	    "from tx chain!\n",	__FILE__, __LINE__, 
+	    sc->debug_tx_mbuf_alloc));
 
 	DBEXIT(BCE_VERBOSE_RESET | BCE_VERBOSE_SEND | BCE_VERBOSE_UNLOAD);
 }
@@ -5426,10 +5369,10 @@ bce_init_rx_context(struct bce_softc *sc)
 
 	DBENTER(BCE_VERBOSE_RESET | BCE_VERBOSE_RECV | BCE_VERBOSE_CTX);
 
-	/* Initialize the type, size, and BD cache levels for the RX context. */
+	/* Init the type, size, and BD cache levels for the RX context. */
 	val = BCE_L2CTX_RX_CTX_TYPE_CTX_BD_CHN_TYPE_VALUE |
-		BCE_L2CTX_RX_CTX_TYPE_SIZE_L2 |
-		(0x02 << BCE_L2CTX_RX_BD_PRE_READ_SHIFT);
+	    BCE_L2CTX_RX_CTX_TYPE_SIZE_L2 |
+	    (0x02 << BCE_L2CTX_RX_BD_PRE_READ_SHIFT);
 
 	/*
 	 * Set the level for generating pause frames
@@ -5439,7 +5382,7 @@ bce_init_rx_context(struct bce_softc *sc)
 	 * watermark).
 	 */
 	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
 		u32 lo_water, hi_water;
 
 		lo_water = BCE_L2CTX_RX_LO_WATER_MARK_DEFAULT;
@@ -5460,7 +5403,7 @@ bce_init_rx_context(struct bce_softc *sc)
 
 	/* Setup the MQ BIN mapping for l2_ctx_host_bseq. */
 	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
 		val = REG_RD(sc, BCE_MQ_MAP_L2_5);
 		REG_WR(sc, BCE_MQ_MAP_L2_5, val | BCE_MQ_MAP_L2_5_ARM);
 	}
@@ -5488,7 +5431,7 @@ bce_init_rx_chain(struct bce_softc *sc)
 	int i, rc = 0;
 
 	DBENTER(BCE_VERBOSE_RESET | BCE_VERBOSE_RECV | BCE_VERBOSE_LOAD |
-		BCE_VERBOSE_CTX);
+	    BCE_VERBOSE_CTX);
 
 	/* Initialize the RX producer and consumer indices. */
 	sc->rx_prod        = 0;
@@ -5496,8 +5439,6 @@ bce_init_rx_chain(struct bce_softc *sc)
 	sc->rx_prod_bseq   = 0;
 	sc->free_rx_bd     = USABLE_RX_BD;
 	sc->max_rx_bd      = USABLE_RX_BD;
-	DBRUN(sc->rx_low_watermark = sc->max_rx_bd);
-	DBRUN(sc->rx_empty_count = 0);
 
 	/* Initialize the RX next pointer chain entries. */
 	for (i = 0; i < RX_PAGES; i++) {
@@ -5512,13 +5453,17 @@ bce_init_rx_chain(struct bce_softc *sc)
 			j = i + 1;
 
 		/* Setup the chain page pointers. */
-		rxbd->rx_bd_haddr_hi = htole32(BCE_ADDR_HI(sc->rx_bd_chain_paddr[j]));
-		rxbd->rx_bd_haddr_lo = htole32(BCE_ADDR_LO(sc->rx_bd_chain_paddr[j]));
+		rxbd->rx_bd_haddr_hi = 
+		    htole32(BCE_ADDR_HI(sc->rx_bd_chain_paddr[j]));
+		rxbd->rx_bd_haddr_lo = 
+		    htole32(BCE_ADDR_LO(sc->rx_bd_chain_paddr[j]));
 	}
 
 	/* Fill up the RX chain. */
 	bce_fill_rx_chain(sc);
 
+	DBRUN(sc->rx_low_watermark = USABLE_RX_BD);
+	DBRUN(sc->rx_empty_count = 0);
 	for (i = 0; i < RX_PAGES; i++) {
 		bus_dmamap_sync(sc->rx_bd_chain_tag, sc->rx_bd_chain_map[i],
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
@@ -5526,10 +5471,12 @@ bce_init_rx_chain(struct bce_softc *sc)
 
 	bce_init_rx_context(sc);
 
-	DBRUNMSG(BCE_EXTREME_RECV, bce_dump_rx_chain(sc, 0, TOTAL_RX_BD));
+	DBRUNMSG(BCE_EXTREME_RECV, bce_dump_rx_bd_chain(sc, 0, TOTAL_RX_BD));
 	DBEXIT(BCE_VERBOSE_RESET | BCE_VERBOSE_RECV | BCE_VERBOSE_LOAD |
-		BCE_VERBOSE_CTX);
+	    BCE_VERBOSE_CTX);
+
 	/* ToDo: Are there possible failure modes here? */
+
 	return(rc);
 }
 
@@ -5548,7 +5495,7 @@ bce_fill_rx_chain(struct bce_softc *sc)
 	u32 prod_bseq;
 
 	DBENTER(BCE_VERBOSE_RESET | BCE_EXTREME_RECV | BCE_VERBOSE_LOAD |
-		BCE_VERBOSE_CTX);
+	    BCE_VERBOSE_CTX);
 
 	/* Get the RX chain producer indices. */
 	prod      = sc->rx_prod;
@@ -5568,6 +5515,7 @@ bce_fill_rx_chain(struct bce_softc *sc)
 	sc->rx_prod      = prod;
 	sc->rx_prod_bseq = prod_bseq;
 
+	/* We should never end up pointing to a next page pointer. */
 	DBRUNIF(((prod & USABLE_RX_BD_PER_PAGE) == USABLE_RX_BD_PER_PAGE),
 		BCE_PRINTF("%s(): Invalid rx_prod value: 0x%04X\n",
 		__FUNCTION__, sc->rx_prod));
@@ -5579,7 +5527,7 @@ bce_fill_rx_chain(struct bce_softc *sc)
 		sc->rx_prod_bseq);
 
 	DBEXIT(BCE_VERBOSE_RESET | BCE_EXTREME_RECV | BCE_VERBOSE_LOAD |
-		BCE_VERBOSE_CTX);
+	    BCE_VERBOSE_CTX);
 }
 
 
@@ -5600,8 +5548,9 @@ bce_free_rx_chain(struct bce_softc *sc)
 	for (i = 0; i < TOTAL_RX_BD; i++) {
 		if (sc->rx_mbuf_ptr[i] != NULL) {
 			if (sc->rx_mbuf_map[i] != NULL)
-				bus_dmamap_sync(sc->rx_mbuf_tag, sc->rx_mbuf_map[i],
-					BUS_DMASYNC_POSTREAD);
+				bus_dmamap_sync(sc->rx_mbuf_tag, 
+				    sc->rx_mbuf_map[i],
+				    BUS_DMASYNC_POSTREAD);
 			m_freem(sc->rx_mbuf_ptr[i]);
 			sc->rx_mbuf_ptr[i] = NULL;
 			DBRUN(sc->debug_rx_mbuf_alloc--);
@@ -5610,14 +5559,17 @@ bce_free_rx_chain(struct bce_softc *sc)
 
 	/* Clear each RX chain page. */
 	for (i = 0; i < RX_PAGES; i++)
-		bzero((char *)sc->rx_bd_chain[i], BCE_RX_CHAIN_PAGE_SZ);
+		if (sc->rx_bd_chain[i] != NULL) {
+			bzero((char *)sc->rx_bd_chain[i], 
+			    BCE_RX_CHAIN_PAGE_SZ);
+		}
 
 	sc->free_rx_bd = sc->max_rx_bd;
 
 	/* Check if we lost any mbufs in the process. */
 	DBRUNIF((sc->debug_rx_mbuf_alloc),
-		BCE_PRINTF("%s(): Memory leak! Lost %d mbufs from rx chain!\n",
-			__FUNCTION__, sc->debug_rx_mbuf_alloc));
+	    BCE_PRINTF("%s(): Memory leak! Lost %d mbufs from rx chain!\n",
+	    __FUNCTION__, sc->debug_rx_mbuf_alloc));
 
 	DBEXIT(BCE_VERBOSE_RESET | BCE_VERBOSE_RECV | BCE_VERBOSE_UNLOAD);
 }
@@ -5832,12 +5784,12 @@ bce_ifmedia_upd_locked(struct ifnet *ifp)
 
 	/* Make sure the MII bus has been enumerated. */
 	if (mii) {
-		sc->bce_link = 0;
+		sc->bce_link_up = FALSE;
 		if (mii->mii_instance) {
 			struct mii_softc *miisc;
 
 			LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
-				mii_phy_reset(miisc);
+			    mii_phy_reset(miisc);
 		}
 		mii_mediachg(mii);
 	}
@@ -5887,26 +5839,28 @@ bce_phy_intr(struct bce_softc *sc)
 
 	DBENTER(BCE_VERBOSE_PHY | BCE_VERBOSE_INTR);
 
+	DBRUN(sc->phy_interrupts++);
+
 	new_link_state = sc->status_block->status_attn_bits &
-		STATUS_ATTN_BITS_LINK_STATE;
+	    STATUS_ATTN_BITS_LINK_STATE;
 	old_link_state = sc->status_block->status_attn_bits_ack &
-		STATUS_ATTN_BITS_LINK_STATE;
+	    STATUS_ATTN_BITS_LINK_STATE;
 
 	/* Handle any changes if the link state has changed. */
 	if (new_link_state != old_link_state) {
 
-		/* Update the status_attn_bits_ack field in the status block. */
+		/* Update the status_attn_bits_ack field. */
 		if (new_link_state) {
 			REG_WR(sc, BCE_PCICFG_STATUS_BIT_SET_CMD,
-				STATUS_ATTN_BITS_LINK_STATE);
+			    STATUS_ATTN_BITS_LINK_STATE);
 			DBPRINT(sc, BCE_INFO_PHY, "%s(): Link is now UP.\n",
-				__FUNCTION__);
+			    __FUNCTION__);
 		}
 		else {
 			REG_WR(sc, BCE_PCICFG_STATUS_BIT_CLEAR_CMD,
-				STATUS_ATTN_BITS_LINK_STATE);
+			    STATUS_ATTN_BITS_LINK_STATE);
 			DBPRINT(sc, BCE_INFO_PHY, "%s(): Link is now DOWN.\n",
-				__FUNCTION__);
+			    __FUNCTION__);
 		}
 
 		/*
@@ -5914,7 +5868,7 @@ bce_phy_intr(struct bce_softc *sc)
 		 * tick routine to update the state
 		 * based on the actual media state.
 		 */
-		sc->bce_link = 0;
+		sc->bce_link_up = FALSE;
 		callout_stop(&sc->bce_tick_callout);
 		bce_tick(sc);
 	}
@@ -5969,8 +5923,8 @@ bce_rx_intr(struct bce_softc *sc)
 	DBENTER(BCE_VERBOSE_RECV | BCE_VERBOSE_INTR);
 	DBRUN(sc->rx_interrupts++);
 	DBPRINT(sc, BCE_EXTREME_RECV, "%s(enter): rx_prod = 0x%04X, "
-		"rx_cons = 0x%04X, rx_prod_bseq = 0x%08X\n",
-		__FUNCTION__, sc->rx_prod, sc->rx_cons, sc->rx_prod_bseq);
+	    "rx_cons = 0x%04X, rx_prod_bseq = 0x%08X\n",
+	    __FUNCTION__, sc->rx_prod, sc->rx_cons, sc->rx_prod_bseq);
 
 	/* Prepare the RX chain pages to be accessed by the host CPU. */
 	for (int i = 0; i < RX_PAGES; i++)
@@ -6008,7 +5962,8 @@ bce_rx_intr(struct bce_softc *sc)
 		sw_rx_cons_idx = RX_CHAIN_IDX(sw_rx_cons);
 
 		/* Unmap the mbuf from DMA space. */
-		bus_dmamap_sync(sc->rx_mbuf_tag, sc->rx_mbuf_map[sw_rx_cons_idx],
+		bus_dmamap_sync(sc->rx_mbuf_tag, 
+		    sc->rx_mbuf_map[sw_rx_cons_idx],
 		    BUS_DMASYNC_POSTREAD);
 		bus_dmamap_unload(sc->rx_mbuf_tag,
 		    sc->rx_mbuf_map[sw_rx_cons_idx]);
@@ -6019,29 +5974,30 @@ bce_rx_intr(struct bce_softc *sc)
 		DBRUN(sc->debug_rx_mbuf_alloc--);
 		sc->free_rx_bd++;
 
-        if(m0 == NULL) {
-            DBPRINT(sc, BCE_EXTREME_RECV, "%s(): Oops! Empty mbuf pointer "
-                "found in sc->rx_mbuf_ptr[0x%04X]!\n",
-                __FUNCTION__, sw_rx_cons_idx);
-            goto bce_rx_int_next_rx;
-        }
+		if(m0 == NULL) {
+			DBPRINT(sc, BCE_EXTREME_RECV, 
+			    "%s(): Oops! Empty mbuf pointer "
+			    "found in sc->rx_mbuf_ptr[0x%04X]!\n",
+			    __FUNCTION__, sw_rx_cons_idx);
+			goto bce_rx_int_next_rx;
+		}
 
-        /*
-         * Frames received on the NetXteme II are prepended	with an
-         * l2_fhdr structure which provides status information about
-         * the received frame (including VLAN tags and checksum info).
-         * The frames are also automatically adjusted to align the IP
-         * header (i.e. two null bytes are inserted before the Ethernet
-         * header).  As a result the data DMA'd by the controller into
-         * the mbuf is as follows:
-         * 
-         * +---------+-----+---------------------+-----+
-         * | l2_fhdr | pad | packet data         | FCS |
-         * +---------+-----+---------------------+-----+
-         * 
-         * The l2_fhdr needs to be checked and skipped and the FCS needs
-         * to be stripped before sending the packet up the stack.
-         */
+		/*
+		 * Frames received on the NetXteme II are prepended	with an
+		 * l2_fhdr structure which provides status information about
+		 * the received frame (including VLAN tags and checksum info).
+		 * The frames are also automatically adjusted to align the IP
+		 * header (i.e. two null bytes are inserted before the Ethernet
+		 * header).  As a result the data DMA'd by the controller into
+		 * the mbuf is as follows:
+		 * 
+		 * +---------+-----+---------------------+-----+
+		 * | l2_fhdr | pad | packet data         | FCS |
+		 * +---------+-----+---------------------+-----+
+		 * 
+		 * The l2_fhdr needs to be checked and skipped and the FCS needs
+		 * to be stripped before sending the packet up the stack.
+		 */
 		l2fhdr  = mtod(m0, struct l2_fhdr *);
 
 		/* Get the packet data + FCS length and the status. */
@@ -6076,8 +6032,8 @@ bce_rx_intr(struct bce_softc *sc)
 			 * in the page chain.
 			 */
 
-			DBPRINT(sc, BCE_INFO_RECV, "%s(): Found a large packet.\n",
-				__FUNCTION__);
+			DBPRINT(sc, BCE_INFO_RECV, "%s(): Found a large "
+			    "packet.\n", __FUNCTION__);
 
 			/*
 			 * When the page chain is enabled and the TCP
@@ -6105,10 +6061,10 @@ bce_rx_intr(struct bce_softc *sc)
 
 				/* Unmap the page chain mbuf from DMA space. */
 				bus_dmamap_sync(sc->pg_mbuf_tag,
-					sc->pg_mbuf_map[sw_pg_cons_idx],
-					BUS_DMASYNC_POSTREAD);
+				    sc->pg_mbuf_map[sw_pg_cons_idx],
+				    BUS_DMASYNC_POSTREAD);
 				bus_dmamap_unload(sc->pg_mbuf_tag,
-					sc->pg_mbuf_map[sw_pg_cons_idx]);
+				    sc->pg_mbuf_map[sw_pg_cons_idx]);
 
 				/* Adjust the mbuf length. */
 				if (rem_len < m_pg->m_len) {
@@ -6137,8 +6093,8 @@ bce_rx_intr(struct bce_softc *sc)
 			 * 154 bytes or less in size.
 			 */
 
-			DBPRINT(sc, BCE_INFO_RECV, "%s(): Found a small packet.\n",
-				__FUNCTION__);
+			DBPRINT(sc, BCE_INFO_RECV, "%s(): Found a small "
+			    "packet.\n", __FUNCTION__);
 
 			/* Set the total packet length. */
 			m0->m_pkthdr.len = m0->m_len = pkt_len;
@@ -6154,19 +6110,19 @@ bce_rx_intr(struct bce_softc *sc)
 		/* Check that the resulting mbuf chain is valid. */
 		DBRUN(m_sanity(m0, FALSE));
 		DBRUNIF(((m0->m_len < ETHER_HDR_LEN) |
-			(m0->m_pkthdr.len > BCE_MAX_JUMBO_ETHER_MTU_VLAN)),
-			BCE_PRINTF("Invalid Ethernet frame size!\n");
-			m_print(m0, 128));
+		    (m0->m_pkthdr.len > BCE_MAX_JUMBO_ETHER_MTU_VLAN)),
+		     BCE_PRINTF("Invalid Ethernet frame size!\n");
+		     m_print(m0, 128));
 
 		DBRUNIF(DB_RANDOMTRUE(l2fhdr_error_sim_control),
-			BCE_PRINTF("Simulating l2_fhdr status error.\n");
-			sc->l2fhdr_error_sim_count++;
-			status = status | L2_FHDR_ERRORS_PHY_DECODE);
+		    BCE_PRINTF("Simulating l2_fhdr status error.\n");
+		    sc->l2fhdr_error_sim_count++;
+		    status = status | L2_FHDR_ERRORS_PHY_DECODE);
 
 		/* Check the received frame for errors. */
-		if (status & (L2_FHDR_ERRORS_BAD_CRC |
-			L2_FHDR_ERRORS_PHY_DECODE | L2_FHDR_ERRORS_ALIGNMENT |
-			L2_FHDR_ERRORS_TOO_SHORT  | L2_FHDR_ERRORS_GIANT_FRAME)) {
+		if (status & (L2_FHDR_ERRORS_BAD_CRC | 
+		    L2_FHDR_ERRORS_PHY_DECODE | L2_FHDR_ERRORS_ALIGNMENT |
+		    L2_FHDR_ERRORS_TOO_SHORT  | L2_FHDR_ERRORS_GIANT_FRAME)) {
 
 			/* Log the error and release the mbuf. */
 			ifp->if_ierrors++;
@@ -6193,20 +6149,22 @@ bce_rx_intr(struct bce_softc *sc)
 
 				/* Check if the IP checksum is valid. */
 				if ((l2fhdr->l2_fhdr_ip_xsum ^ 0xffff) == 0)
-					m0->m_pkthdr.csum_flags |= CSUM_IP_VALID;
+					m0->m_pkthdr.csum_flags |= 
+					    CSUM_IP_VALID;
 			}
 
 			/* Check for a valid TCP/UDP frame. */
 			if (status & (L2_FHDR_STATUS_TCP_SEGMENT |
-				L2_FHDR_STATUS_UDP_DATAGRAM)) {
+			    L2_FHDR_STATUS_UDP_DATAGRAM)) {
 
 				/* Check for a good TCP/UDP checksum. */
 				if ((status & (L2_FHDR_ERRORS_TCP_XSUM |
-					      L2_FHDR_ERRORS_UDP_XSUM)) == 0) {
+				    L2_FHDR_ERRORS_UDP_XSUM)) == 0) {
 					m0->m_pkthdr.csum_data =
 					    l2fhdr->l2_fhdr_tcp_udp_xsum;
-					m0->m_pkthdr.csum_flags |= (CSUM_DATA_VALID
-						| CSUM_PSEUDO_HDR);
+					m0->m_pkthdr.csum_flags |= 
+					    (CSUM_DATA_VALID
+					    | CSUM_PSEUDO_HDR);
 				}
 			}
 		}
@@ -6297,8 +6255,8 @@ bce_rx_int_next_rx:
 #endif
 
 	DBPRINT(sc, BCE_EXTREME_RECV, "%s(exit): rx_prod = 0x%04X, "
-		"rx_cons = 0x%04X, rx_prod_bseq = 0x%08X\n",
-		__FUNCTION__, sc->rx_prod, sc->rx_cons, sc->rx_prod_bseq);
+	    "rx_cons = 0x%04X, rx_prod_bseq = 0x%08X\n",
+	    __FUNCTION__, sc->rx_prod, sc->rx_cons, sc->rx_prod_bseq);
 	DBEXIT(BCE_VERBOSE_RECV | BCE_VERBOSE_INTR);
 }
 
@@ -6339,8 +6297,8 @@ bce_tx_intr(struct bce_softc *sc)
 	DBENTER(BCE_VERBOSE_SEND | BCE_VERBOSE_INTR);
 	DBRUN(sc->tx_interrupts++);
 	DBPRINT(sc, BCE_EXTREME_SEND, "%s(enter): tx_prod = 0x%04X, "
-		"tx_cons = 0x%04X, tx_prod_bseq = 0x%08X\n",
-		__FUNCTION__, sc->tx_prod, sc->tx_cons, sc->tx_prod_bseq);
+	    "tx_cons = 0x%04X, tx_prod_bseq = 0x%08X\n",
+	    __FUNCTION__, sc->tx_prod, sc->tx_cons, sc->tx_prod_bseq);
 
 	BCE_LOCK_ASSERT(sc);
 
@@ -6350,7 +6308,7 @@ bce_tx_intr(struct bce_softc *sc)
 
 	/* Prevent speculative reads from getting ahead of the status block. */
 	bus_space_barrier(sc->bce_btag, sc->bce_bhandle, 0, 0,
-		BUS_SPACE_BARRIER_READ);
+	    BUS_SPACE_BARRIER_READ);
 
 	/* Cycle through any completed TX chain page entries. */
 	while (sw_tx_cons != hw_tx_cons) {
@@ -6360,26 +6318,26 @@ bce_tx_intr(struct bce_softc *sc)
 		sw_tx_chain_cons = TX_CHAIN_IDX(sw_tx_cons);
 
 		DBPRINT(sc, BCE_INFO_SEND,
-			"%s(): hw_tx_cons = 0x%04X, sw_tx_cons = 0x%04X, "
-			"sw_tx_chain_cons = 0x%04X\n",
-			__FUNCTION__, hw_tx_cons, sw_tx_cons, sw_tx_chain_cons);
+		    "%s(): hw_tx_cons = 0x%04X, sw_tx_cons = 0x%04X, "
+		    "sw_tx_chain_cons = 0x%04X\n",
+		    __FUNCTION__, hw_tx_cons, sw_tx_cons, sw_tx_chain_cons);
 
 		DBRUNIF((sw_tx_chain_cons > MAX_TX_BD),
-			BCE_PRINTF("%s(%d): TX chain consumer out of range! "
-				" 0x%04X > 0x%04X\n", __FILE__, __LINE__, sw_tx_chain_cons,
-				(int) MAX_TX_BD);
-			bce_breakpoint(sc));
+		    BCE_PRINTF("%s(%d): TX chain consumer out of range! "
+		    " 0x%04X > 0x%04X\n", __FILE__, __LINE__, sw_tx_chain_cons,
+		    (int) MAX_TX_BD);
+		    bce_breakpoint(sc));
 
 		DBRUN(txbd = &sc->tx_bd_chain[TX_PAGE(sw_tx_chain_cons)]
-				[TX_IDX(sw_tx_chain_cons)]);
+		    [TX_IDX(sw_tx_chain_cons)]);
 
 		DBRUNIF((txbd == NULL),
-			BCE_PRINTF("%s(%d): Unexpected NULL tx_bd[0x%04X]!\n",
-				__FILE__, __LINE__, sw_tx_chain_cons);
-			bce_breakpoint(sc));
+		    BCE_PRINTF("%s(%d): Unexpected NULL tx_bd[0x%04X]!\n",
+		    __FILE__, __LINE__, sw_tx_chain_cons);
+		    bce_breakpoint(sc));
 
 		DBRUNMSG(BCE_INFO_SEND, BCE_PRINTF("%s(): ", __FUNCTION__);
-			bce_dump_txbd(sc, sw_tx_chain_cons, txbd));
+		    bce_dump_txbd(sc, sw_tx_chain_cons, txbd));
 
 		/*
 		 * Free the associated mbuf. Remember
@@ -6390,13 +6348,14 @@ bce_tx_intr(struct bce_softc *sc)
 
 			/* Validate that this is the last tx_bd. */
 			DBRUNIF((!(txbd->tx_bd_flags & TX_BD_FLAGS_END)),
-				BCE_PRINTF("%s(%d): tx_bd END flag not set but "
-				"txmbuf == NULL!\n", __FILE__, __LINE__);
-				bce_breakpoint(sc));
+			    BCE_PRINTF("%s(%d): tx_bd END flag not set but "
+			    "txmbuf == NULL!\n", __FILE__, __LINE__);
+			    bce_breakpoint(sc));
 
 			DBRUNMSG(BCE_INFO_SEND,
-				BCE_PRINTF("%s(): Unloading map/freeing mbuf "
-					"from tx_bd[0x%04X]\n", __FUNCTION__, sw_tx_chain_cons));
+			    BCE_PRINTF("%s(): Unloading map/freeing mbuf "
+			    "from tx_bd[0x%04X]\n", __FUNCTION__, 
+			    sw_tx_chain_cons));
 
 			/* Unmap the mbuf. */
 			bus_dmamap_unload(sc->tx_mbuf_tag,
@@ -6416,9 +6375,9 @@ bce_tx_intr(struct bce_softc *sc)
 		/* Refresh hw_cons to see if there's new work. */
 		hw_tx_cons = sc->hw_tx_cons = bce_get_hw_tx_cons(sc);
 
-		/* Prevent speculative reads from getting ahead of the status block. */
+		/* Prevent speculative reads of the status block. */
 		bus_space_barrier(sc->bce_btag, sc->bce_bhandle, 0, 0,
-			BUS_SPACE_BARRIER_READ);
+		    BUS_SPACE_BARRIER_READ);
 	}
 
 	/* Clear the TX timeout timer. */
@@ -6427,17 +6386,17 @@ bce_tx_intr(struct bce_softc *sc)
 	/* Clear the tx hardware queue full flag. */
 	if (sc->used_tx_bd < sc->max_tx_bd) {
 		DBRUNIF((ifp->if_drv_flags & IFF_DRV_OACTIVE),
-			DBPRINT(sc, BCE_INFO_SEND,
-				"%s(): Open TX chain! %d/%d (used/total)\n",
-				__FUNCTION__, sc->used_tx_bd, sc->max_tx_bd));
+		    DBPRINT(sc, BCE_INFO_SEND,
+		    "%s(): Open TX chain! %d/%d (used/total)\n",
+		    __FUNCTION__, sc->used_tx_bd, sc->max_tx_bd));
 		ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 	}
 
 	sc->tx_cons = sw_tx_cons;
 
 	DBPRINT(sc, BCE_EXTREME_SEND, "%s(exit): tx_prod = 0x%04X, "
-		"tx_cons = 0x%04X, tx_prod_bseq = 0x%08X\n",
-		__FUNCTION__, sc->tx_prod, sc->tx_cons, sc->tx_prod_bseq);
+	    "tx_cons = 0x%04X, tx_prod_bseq = 0x%08X\n",
+	    __FUNCTION__, sc->tx_prod, sc->tx_cons, sc->tx_prod_bseq);
 	DBEXIT(BCE_VERBOSE_SEND | BCE_VERBOSE_INTR);
 }
 
@@ -6472,11 +6431,11 @@ bce_enable_intr(struct bce_softc *sc, int coal_now)
 	DBENTER(BCE_VERBOSE_INTR);
 
 	REG_WR(sc, BCE_PCICFG_INT_ACK_CMD,
-	       BCE_PCICFG_INT_ACK_CMD_INDEX_VALID |
-	       BCE_PCICFG_INT_ACK_CMD_MASK_INT | sc->last_status_idx);
+	    BCE_PCICFG_INT_ACK_CMD_INDEX_VALID |
+	    BCE_PCICFG_INT_ACK_CMD_MASK_INT | sc->last_status_idx);
 
 	REG_WR(sc, BCE_PCICFG_INT_ACK_CMD,
-	       BCE_PCICFG_INT_ACK_CMD_INDEX_VALID | sc->last_status_idx);
+	    BCE_PCICFG_INT_ACK_CMD_INDEX_VALID | sc->last_status_idx);
 
 	/* Force an immediate interrupt (whether there is new data or not). */
 	if (coal_now)
@@ -6512,19 +6471,19 @@ bce_init_locked(struct bce_softc *sc)
 
 	if (bce_reset(sc, BCE_DRV_MSG_CODE_RESET)) {
 		BCE_PRINTF("%s(%d): Controller reset failed!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		goto bce_init_locked_exit;
 	}
 
 	if (bce_chipinit(sc)) {
 		BCE_PRINTF("%s(%d): Controller initialization failed!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		goto bce_init_locked_exit;
 	}
 
 	if (bce_blockinit(sc)) {
 		BCE_PRINTF("%s(%d): Block initialization failed!\n",
-			__FILE__, __LINE__);
+		    __FILE__, __LINE__);
 		goto bce_init_locked_exit;
 	}
 
@@ -6537,8 +6496,10 @@ bce_init_locked(struct bce_softc *sc)
 	 * size. Be generous on the receive if we have room.
 	 */
 #ifdef BCE_JUMBO_HDRSPLIT
-	if (ifp->if_mtu <= (sc->rx_bd_mbuf_data_len + sc->pg_bd_mbuf_alloc_size))
-		ether_mtu = sc->rx_bd_mbuf_data_len + sc->pg_bd_mbuf_alloc_size;
+	if (ifp->if_mtu <= (sc->rx_bd_mbuf_data_len + 
+	    sc->pg_bd_mbuf_alloc_size))
+		ether_mtu = sc->rx_bd_mbuf_data_len + 
+		    sc->pg_bd_mbuf_alloc_size;
 #else
 	if (ifp->if_mtu <= sc->rx_bd_mbuf_data_len)
 		ether_mtu = sc->rx_bd_mbuf_data_len;
@@ -6548,29 +6509,29 @@ bce_init_locked(struct bce_softc *sc)
 
 	ether_mtu += ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN + ETHER_CRC_LEN;
 
-	DBPRINT(sc, BCE_INFO_MISC, "%s(): setting h/w mtu = %d\n", __FUNCTION__,
-		ether_mtu);
+	DBPRINT(sc, BCE_INFO_MISC, "%s(): setting h/w mtu = %d\n", 
+	    __FUNCTION__, ether_mtu);
 
 	/* Program the mtu, enabling jumbo frame support if necessary. */
 	if (ether_mtu > (ETHER_MAX_LEN + ETHER_VLAN_ENCAP_LEN))
 		REG_WR(sc, BCE_EMAC_RX_MTU_SIZE,
-			min(ether_mtu, BCE_MAX_JUMBO_ETHER_MTU) |
-			BCE_EMAC_RX_MTU_SIZE_JUMBO_ENA);
+		    min(ether_mtu, BCE_MAX_JUMBO_ETHER_MTU) |
+		    BCE_EMAC_RX_MTU_SIZE_JUMBO_ENA);
 	else
 		REG_WR(sc, BCE_EMAC_RX_MTU_SIZE, ether_mtu);
 
 	DBPRINT(sc, BCE_INFO_LOAD,
-		"%s(): rx_bd_mbuf_alloc_size = %d, rx_bce_mbuf_data_len = %d, "
-		"rx_bd_mbuf_align_pad = %d\n", __FUNCTION__, 
-		sc->rx_bd_mbuf_alloc_size, sc->rx_bd_mbuf_data_len,
-		sc->rx_bd_mbuf_align_pad);
+	    "%s(): rx_bd_mbuf_alloc_size = %d, rx_bce_mbuf_data_len = %d, "
+	    "rx_bd_mbuf_align_pad = %d\n", __FUNCTION__, 
+	    sc->rx_bd_mbuf_alloc_size, sc->rx_bd_mbuf_data_len,
+	    sc->rx_bd_mbuf_align_pad);
 
 	/* Program appropriate promiscuous/multicast filtering. */
 	bce_set_rx_mode(sc);
 
 #ifdef BCE_JUMBO_HDRSPLIT
 	DBPRINT(sc, BCE_INFO_LOAD, "%s(): pg_bd_mbuf_alloc_size = %d\n",
-		__FUNCTION__, sc->pg_bd_mbuf_alloc_size);
+	    __FUNCTION__, sc->pg_bd_mbuf_alloc_size);
 
 	/* Init page buffer descriptor chain. */
 	bce_init_pg_chain(sc);
@@ -6617,7 +6578,7 @@ bce_mgmt_init_locked(struct bce_softc *sc)
 	/* Bail out if management firmware is not running. */
 	if (!(sc->bce_flags & BCE_MFW_ENABLE_FLAG)) {
 		DBPRINT(sc, BCE_VERBOSE_SPECIAL,
-			"No management firmware running...\n");
+		    "No management firmware running...\n");
 		goto bce_mgmt_init_locked_exit;
 	}
 
@@ -6786,10 +6747,10 @@ bce_tx_encap(struct bce_softc *sc, struct mbuf **m_head)
 
 	DBENTER(BCE_VERBOSE_SEND);
 	DBPRINT(sc, BCE_INFO_SEND,
-		"%s(enter): tx_prod = 0x%04X, tx_chain_prod = %04X, "
-		"tx_prod_bseq = 0x%08X\n",
-		__FUNCTION__, sc->tx_prod, (u16) TX_CHAIN_IDX(sc->tx_prod),
-		sc->tx_prod_bseq);
+	    "%s(enter): tx_prod = 0x%04X, tx_chain_prod = %04X, "
+	    "tx_prod_bseq = 0x%08X\n",
+	    __FUNCTION__, sc->tx_prod, (u16) TX_CHAIN_IDX(sc->tx_prod),
+	    sc->tx_prod_bseq);
 
 	/* Transfer any checksum offload flags to the bd. */
 	m0 = *m_head;
@@ -6850,10 +6811,9 @@ bce_tx_encap(struct bce_softc *sc, struct mbuf **m_head)
 			rc = error;
 			goto bce_tx_encap_exit;
 		} else if (error != 0) {
-			/* Still can't map the mbuf, release it and return an error. */
-			BCE_PRINTF(
-			    "%s(%d): Unknown error mapping mbuf into TX chain!\n",
-			    __FILE__, __LINE__);
+			/* Release it and return an error. */
+			BCE_PRINTF("%s(%d): Unknown error mapping mbuf into "
+			    "TX chain!\n", __FILE__, __LINE__);
 			m_freem(m0);
 			*m_head = NULL;
 			sc->dma_map_addr_tx_failed_count++;
@@ -6888,9 +6848,9 @@ bce_tx_encap(struct bce_softc *sc, struct mbuf **m_head)
 #endif
 
 	DBPRINT(sc, BCE_INFO_SEND,
-		"%s(start): prod = 0x%04X, chain_prod = 0x%04X, "
-		"prod_bseq = 0x%08X\n",
-		__FUNCTION__, prod, chain_prod, prod_bseq);
+	    "%s(start): prod = 0x%04X, chain_prod = 0x%04X, "
+	    "prod_bseq = 0x%08X\n",
+	    __FUNCTION__, prod, chain_prod, prod_bseq);
 
 	/*
 	 * Cycle through each mbuf segment that makes up
@@ -6901,11 +6861,13 @@ bce_tx_encap(struct bce_softc *sc, struct mbuf **m_head)
 	for (i = 0; i < nsegs ; i++) {
 
 		chain_prod = TX_CHAIN_IDX(prod);
-		txbd= &sc->tx_bd_chain[TX_PAGE(chain_prod)][TX_IDX(chain_prod)];
+		txbd= &sc->tx_bd_chain[TX_PAGE(chain_prod)]
+		    [TX_IDX(chain_prod)];
 
 		txbd->tx_bd_haddr_lo = htole32(BCE_ADDR_LO(segs[i].ds_addr));
 		txbd->tx_bd_haddr_hi = htole32(BCE_ADDR_HI(segs[i].ds_addr));
-		txbd->tx_bd_mss_nbytes = htole32(mss << 16) | htole16(segs[i].ds_len);
+		txbd->tx_bd_mss_nbytes = htole32(mss << 16) | 
+		    htole16(segs[i].ds_len);
 		txbd->tx_bd_vlan_tag = htole16(vlan_tag);
 		txbd->tx_bd_flags = htole16(flags);
 		prod_bseq += segs[i].ds_len;
@@ -6920,9 +6882,9 @@ bce_tx_encap(struct bce_softc *sc, struct mbuf **m_head)
 	DBRUNMSG(BCE_EXTREME_SEND, bce_dump_tx_chain(sc, debug_prod, nsegs));
 
 	DBPRINT(sc, BCE_INFO_SEND,
-		"%s( end ): prod = 0x%04X, chain_prod = 0x%04X, "
-		"prod_bseq = 0x%08X\n",
-		__FUNCTION__, prod, chain_prod, prod_bseq);
+	    "%s( end ): prod = 0x%04X, chain_prod = 0x%04X, "
+	    "prod_bseq = 0x%08X\n",
+	    __FUNCTION__, prod, chain_prod, prod_bseq);
 
 	/*
 	 * Ensure that the mbuf pointer for this transmission
@@ -6938,7 +6900,7 @@ bce_tx_encap(struct bce_softc *sc, struct mbuf **m_head)
 
 	/* Update some debug statistic counters */
 	DBRUNIF((sc->used_tx_bd > sc->tx_hi_watermark),
-		sc->tx_hi_watermark = sc->used_tx_bd);
+	    sc->tx_hi_watermark = sc->used_tx_bd);
 	DBRUNIF((sc->used_tx_bd == sc->max_tx_bd), sc->tx_full_count++);
 	DBRUNIF(sc->debug_tx_mbuf_alloc++);
 
@@ -6949,10 +6911,10 @@ bce_tx_encap(struct bce_softc *sc, struct mbuf **m_head)
 	sc->tx_prod_bseq = prod_bseq;
 
 	DBPRINT(sc, BCE_INFO_SEND,
-		"%s(exit): prod = 0x%04X, chain_prod = %04X, "
-		"prod_bseq = 0x%08X\n",
-		__FUNCTION__, sc->tx_prod, (u16) TX_CHAIN_IDX(sc->tx_prod),
-		sc->tx_prod_bseq);
+	    "%s(exit): prod = 0x%04X, chain_prod = %04X, "
+	    "prod_bseq = 0x%08X\n", __FUNCTION__, 
+	    sc->tx_prod, (u16) TX_CHAIN_IDX(sc->tx_prod),
+	    sc->tx_prod_bseq);
 
 bce_tx_encap_exit:
 	DBEXIT(BCE_VERBOSE_SEND);
@@ -6983,20 +6945,20 @@ bce_start_locked(struct ifnet *ifp)
 	tx_chain_prod = TX_CHAIN_IDX(tx_prod);
 
 	DBPRINT(sc, BCE_INFO_SEND,
-		"%s(enter): tx_prod = 0x%04X, tx_chain_prod = 0x%04X, "
-		"tx_prod_bseq = 0x%08X\n",
-		__FUNCTION__, tx_prod, tx_chain_prod, sc->tx_prod_bseq);
+	    "%s(enter): tx_prod = 0x%04X, tx_chain_prod = 0x%04X, "
+	    "tx_prod_bseq = 0x%08X\n",
+	    __FUNCTION__, tx_prod, tx_chain_prod, sc->tx_prod_bseq);
 
 	/* If there's no link or the transmit queue is empty then just exit. */
-	if (!sc->bce_link) {
+	if (sc->bce_link_up == FALSE) {
 		DBPRINT(sc, BCE_INFO_SEND, "%s(): No link.\n",
-			__FUNCTION__);
+		    __FUNCTION__);
 		goto bce_start_locked_exit;
 	}
 
 	if (IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
 		DBPRINT(sc, BCE_INFO_SEND, "%s(): Transmit queue empty.\n",
-			__FUNCTION__);
+		    __FUNCTION__);
 		goto bce_start_locked_exit;
 	}
 
@@ -7019,13 +6981,12 @@ bce_start_locked(struct ifnet *ifp)
 		 * to wait for the NIC to drain the chain.
 		 */
 		if (bce_tx_encap(sc, &m_head)) {
-			/* No room, put the frame back on the transmit queue. */
 			if (m_head != NULL)
 				IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
 			ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 			DBPRINT(sc, BCE_INFO_SEND,
-				"TX chain is closed for business! Total tx_bd used = %d\n",
-				sc->used_tx_bd);
+			    "TX chain is closed for business! Total "
+			    "tx_bd used = %d\n", sc->used_tx_bd);
 			break;
 		}
 
@@ -7037,26 +6998,29 @@ bce_start_locked(struct ifnet *ifp)
 
 	/* Exit if no packets were dequeued. */
 	if (count == 0) {
-		DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): No packets were dequeued\n",
-			__FUNCTION__);
+		DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): No packets were "
+		    "dequeued\n", __FUNCTION__);
 		goto bce_start_locked_exit;
 	}
 
-	DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): Inserted %d frames into send queue.\n",
-		__FUNCTION__, count);
+	DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): Inserted %d frames into "
+	    "send queue.\n", __FUNCTION__, count);
 
-	REG_WR(sc, BCE_MQ_COMMAND, REG_RD(sc, BCE_MQ_COMMAND) | BCE_MQ_COMMAND_NO_MAP_ERROR);
+	REG_WR(sc, BCE_MQ_COMMAND, REG_RD(sc, BCE_MQ_COMMAND) | 
+	    BCE_MQ_COMMAND_NO_MAP_ERROR);
 
 	/* Write the mailbox and tell the chip about the waiting tx_bd's. */
-	DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): MB_GET_CID_ADDR(TX_CID) = 0x%08X; "
-		"BCE_L2MQ_TX_HOST_BIDX = 0x%08X, sc->tx_prod = 0x%04X\n",
-		__FUNCTION__,
-		MB_GET_CID_ADDR(TX_CID), BCE_L2MQ_TX_HOST_BIDX, sc->tx_prod);
-	REG_WR16(sc, MB_GET_CID_ADDR(TX_CID) + BCE_L2MQ_TX_HOST_BIDX, sc->tx_prod);
-	DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): MB_GET_CID_ADDR(TX_CID) = 0x%08X; "
-		"BCE_L2MQ_TX_HOST_BSEQ = 0x%08X, sc->tx_prod_bseq = 0x%04X\n",
-		__FUNCTION__,
-		MB_GET_CID_ADDR(TX_CID), BCE_L2MQ_TX_HOST_BSEQ, sc->tx_prod_bseq);
+	DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): MB_GET_CID_ADDR(TX_CID) = "
+	    "0x%08X; BCE_L2MQ_TX_HOST_BIDX = 0x%08X, sc->tx_prod = 0x%04X\n",
+	    __FUNCTION__, MB_GET_CID_ADDR(TX_CID), 
+	    BCE_L2MQ_TX_HOST_BIDX, sc->tx_prod);
+	REG_WR16(sc, MB_GET_CID_ADDR(TX_CID) + 
+	    BCE_L2MQ_TX_HOST_BIDX, sc->tx_prod);
+
+	DBPRINT(sc, BCE_VERBOSE_SEND, "%s(): MB_GET_CID_ADDR(TX_CID) = "
+	    "0x%08X; BCE_L2MQ_TX_HOST_BSEQ = 0x%08X, sc->tx_prod_bseq = "
+	    "0x%04X\n",	__FUNCTION__, MB_GET_CID_ADDR(TX_CID), 
+	    BCE_L2MQ_TX_HOST_BSEQ, sc->tx_prod_bseq);
 	REG_WR(sc, MB_GET_CID_ADDR(TX_CID) + BCE_L2MQ_TX_HOST_BSEQ, sc->tx_prod_bseq);
 
 	/* Set the tx timeout. */
@@ -7110,165 +7074,172 @@ bce_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 
 	switch(command) {
 
-		/* Set the interface MTU. */
-		case SIOCSIFMTU:
-			/* Check that the MTU setting is supported. */
-			if ((ifr->ifr_mtu < BCE_MIN_MTU) ||
-				(ifr->ifr_mtu > BCE_MAX_JUMBO_MTU)) {
-				error = EINVAL;
-				break;
-			}
+	/* Set the interface MTU. */
+	case SIOCSIFMTU:
+		/* Check that the MTU setting is supported. */
+		if ((ifr->ifr_mtu < BCE_MIN_MTU) ||
+			(ifr->ifr_mtu > BCE_MAX_JUMBO_MTU)) {
+			error = EINVAL;
+			break;
+		}
 
-			DBPRINT(sc, BCE_INFO_MISC,
-				"SIOCSIFMTU: Changing MTU from %d to %d\n",
-				(int) ifp->if_mtu, (int) ifr->ifr_mtu);
+		DBPRINT(sc, BCE_INFO_MISC,
+		    "SIOCSIFMTU: Changing MTU from %d to %d\n",
+		    (int) ifp->if_mtu, (int) ifr->ifr_mtu);
 
-			BCE_LOCK(sc);
-			ifp->if_mtu = ifr->ifr_mtu;
-			reinit = 0;
-			if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-				/*
-				 * Because allocation size is used in RX
-				 * buffer allocation, stop controller if
-				 * it is already running.
-				 */
-				bce_stop(sc);
-				reinit = 1;
-			}
+		BCE_LOCK(sc);
+		ifp->if_mtu = ifr->ifr_mtu;
+		reinit = 0;
+		if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
+			/*
+			 * Because allocation size is used in RX
+			 * buffer allocation, stop controller if
+			 * it is already running.
+			 */
+			bce_stop(sc);
+			reinit = 1;
+		}
 #ifdef BCE_JUMBO_HDRSPLIT
-			/* No buffer allocation size changes are necessary. */
+		/* No buffer allocation size changes are necessary. */
 #else
-			/* Recalculate our buffer allocation sizes. */
-			if ((ifp->if_mtu + ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN + ETHER_CRC_LEN) > MCLBYTES) {
-				sc->rx_bd_mbuf_alloc_size = MJUM9BYTES;
-				sc->rx_bd_mbuf_align_pad  = roundup2(MJUM9BYTES, 16) - MJUM9BYTES;
-				sc->rx_bd_mbuf_data_len   = sc->rx_bd_mbuf_alloc_size -
-					sc->rx_bd_mbuf_align_pad;
-			} else {
-				sc->rx_bd_mbuf_alloc_size = MCLBYTES;
-				sc->rx_bd_mbuf_align_pad  = roundup2(MCLBYTES, 16) - MCLBYTES;
-				sc->rx_bd_mbuf_data_len   = sc->rx_bd_mbuf_alloc_size -
-					sc->rx_bd_mbuf_align_pad;
-			}
+		/* Recalculate our buffer allocation sizes. */
+		if ((ifp->if_mtu + ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN + 
+		     ETHER_CRC_LEN) > MCLBYTES) {
+			sc->rx_bd_mbuf_alloc_size = MJUM9BYTES;
+			sc->rx_bd_mbuf_align_pad  = 
+			    roundup2(MJUM9BYTES, 16) - MJUM9BYTES;
+			sc->rx_bd_mbuf_data_len = 
+			    sc->rx_bd_mbuf_alloc_size -
+			    sc->rx_bd_mbuf_align_pad;
+		} else {
+			sc->rx_bd_mbuf_alloc_size = MCLBYTES;
+			sc->rx_bd_mbuf_align_pad  = 
+			    roundup2(MCLBYTES, 16) - MCLBYTES;
+			sc->rx_bd_mbuf_data_len = 
+			    sc->rx_bd_mbuf_alloc_size -
+			    sc->rx_bd_mbuf_align_pad;
+		}
 #endif
 
-			if (reinit != 0)
-				bce_init_locked(sc);
-			BCE_UNLOCK(sc);
-			break;
+		if (reinit != 0)
+			bce_init_locked(sc);
+		BCE_UNLOCK(sc);
+		break;
 
-		/* Set interface flags. */
-		case SIOCSIFFLAGS:
-			DBPRINT(sc, BCE_VERBOSE_SPECIAL, "Received SIOCSIFFLAGS\n");
+	/* Set interface flags. */
+	case SIOCSIFFLAGS:
+		DBPRINT(sc, BCE_VERBOSE_SPECIAL, "Received SIOCSIFFLAGS\n");
 
-			BCE_LOCK(sc);
+		BCE_LOCK(sc);
 
-			/* Check if the interface is up. */
-			if (ifp->if_flags & IFF_UP) {
-				if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-					/* Change promiscuous/multicast flags as necessary. */
-					bce_set_rx_mode(sc);
-				} else {
-					/* Start the HW */
-					bce_init_locked(sc);
-				}
+		/* Check if the interface is up. */
+		if (ifp->if_flags & IFF_UP) {
+			if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
+				/* Change promiscuous/multicast flags as necessary. */
+				bce_set_rx_mode(sc);
 			} else {
-				/* The interface is down, check if driver is running. */
-				if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-					bce_stop(sc);
+				/* Start the HW */
+				bce_init_locked(sc);
+			}
+		} else {
+			/* The interface is down, check if driver is running. */
+			if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
+				bce_stop(sc);
 
-					/* If MFW is running, restart the controller a bit. */
-					if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
-						bce_reset(sc, BCE_DRV_MSG_CODE_RESET);
-						bce_chipinit(sc);
-						bce_mgmt_init_locked(sc);
-					}
+				/* If MFW is running, restart the controller a bit. */
+				if (sc->bce_flags & BCE_MFW_ENABLE_FLAG) {
+					bce_reset(sc, BCE_DRV_MSG_CODE_RESET);
+					bce_chipinit(sc);
+					bce_mgmt_init_locked(sc);
 				}
 			}
+		}
 
-			BCE_UNLOCK(sc);
-
-			break;
+		BCE_UNLOCK(sc);
+		break;
 
-		/* Add/Delete multicast address */
-		case SIOCADDMULTI:
-		case SIOCDELMULTI:
-			DBPRINT(sc, BCE_VERBOSE_MISC, "Received SIOCADDMULTI/SIOCDELMULTI\n");
+	/* Add/Delete multicast address */
+	case SIOCADDMULTI:
+	case SIOCDELMULTI:
+		DBPRINT(sc, BCE_VERBOSE_MISC, 
+		    "Received SIOCADDMULTI/SIOCDELMULTI\n");
 
-			BCE_LOCK(sc);
-			if (ifp->if_drv_flags & IFF_DRV_RUNNING)
-				bce_set_rx_mode(sc);
-			BCE_UNLOCK(sc);
+		BCE_LOCK(sc);
+		if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+			bce_set_rx_mode(sc);
+		BCE_UNLOCK(sc);
 
-			break;
+		break;
 
-		/* Set/Get Interface media */
-		case SIOCSIFMEDIA:
-		case SIOCGIFMEDIA:
-			DBPRINT(sc, BCE_VERBOSE_MISC, "Received SIOCSIFMEDIA/SIOCGIFMEDIA\n");
+	/* Set/Get Interface media */
+	case SIOCSIFMEDIA:
+	case SIOCGIFMEDIA:
+		DBPRINT(sc, BCE_VERBOSE_MISC, 
+		    "Received SIOCSIFMEDIA/SIOCGIFMEDIA\n");
 
-			mii = device_get_softc(sc->bce_miibus);
-			error = ifmedia_ioctl(ifp, ifr,
-			    &mii->mii_media, command);
-			break;
+		mii = device_get_softc(sc->bce_miibus);
+		error = ifmedia_ioctl(ifp, ifr,
+		    &mii->mii_media, command);
+		break;
 
-		/* Set interface capability */
-		case SIOCSIFCAP:
-			mask = ifr->ifr_reqcap ^ ifp->if_capenable;
-			DBPRINT(sc, BCE_INFO_MISC, "Received SIOCSIFCAP = 0x%08X\n", (u32) mask);
+	/* Set interface capability */
+	case SIOCSIFCAP:
+		mask = ifr->ifr_reqcap ^ ifp->if_capenable;
+		DBPRINT(sc, BCE_INFO_MISC, 
+		    "Received SIOCSIFCAP = 0x%08X\n", (u32) mask);
 
-			/* Toggle the TX checksum capabilities enable flag. */
-			if (mask & IFCAP_TXCSUM &&
-			    ifp->if_capabilities & IFCAP_TXCSUM) {
-				ifp->if_capenable ^= IFCAP_TXCSUM;
-				if (IFCAP_TXCSUM & ifp->if_capenable)
-					ifp->if_hwassist |= BCE_IF_HWASSIST;
-				else
-					ifp->if_hwassist &= ~BCE_IF_HWASSIST;
-			}
+		/* Toggle the TX checksum capabilities enable flag. */
+		if (mask & IFCAP_TXCSUM &&
+		    ifp->if_capabilities & IFCAP_TXCSUM) {
+			ifp->if_capenable ^= IFCAP_TXCSUM;
+			if (IFCAP_TXCSUM & ifp->if_capenable)
+				ifp->if_hwassist |= BCE_IF_HWASSIST;
+			else
+				ifp->if_hwassist &= ~BCE_IF_HWASSIST;
+		}
 
-			/* Toggle the RX checksum capabilities enable flag. */
-			if (mask & IFCAP_RXCSUM &&
-			    ifp->if_capabilities & IFCAP_RXCSUM)
-				ifp->if_capenable ^= IFCAP_RXCSUM;
+		/* Toggle the RX checksum capabilities enable flag. */
+		if (mask & IFCAP_RXCSUM &&
+		    ifp->if_capabilities & IFCAP_RXCSUM)
+			ifp->if_capenable ^= IFCAP_RXCSUM;
 
-			/* Toggle the TSO capabilities enable flag. */
-			if (bce_tso_enable && (mask & IFCAP_TSO4) &&
-			    ifp->if_capabilities & IFCAP_TSO4) {
-				ifp->if_capenable ^= IFCAP_TSO4;
-				if (IFCAP_TSO4 & ifp->if_capenable)
-					ifp->if_hwassist |= CSUM_TSO;
-				else
-					ifp->if_hwassist &= ~CSUM_TSO;
-			}
+		/* Toggle the TSO capabilities enable flag. */
+		if (bce_tso_enable && (mask & IFCAP_TSO4) &&
+		    ifp->if_capabilities & IFCAP_TSO4) {
+			ifp->if_capenable ^= IFCAP_TSO4;
+			if (IFCAP_TSO4 & ifp->if_capenable)
+				ifp->if_hwassist |= CSUM_TSO;
+			else
+				ifp->if_hwassist &= ~CSUM_TSO;
+		}
 
-			if (mask & IFCAP_VLAN_HWCSUM &&
-			    ifp->if_capabilities & IFCAP_VLAN_HWCSUM)
-				ifp->if_capenable ^= IFCAP_VLAN_HWCSUM;
+		if (mask & IFCAP_VLAN_HWCSUM &&
+		    ifp->if_capabilities & IFCAP_VLAN_HWCSUM)
+			ifp->if_capenable ^= IFCAP_VLAN_HWCSUM;
 
-			if ((mask & IFCAP_VLAN_HWTSO) != 0 &&
-			    (ifp->if_capabilities & IFCAP_VLAN_HWTSO) != 0)
-				ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
-			/*
-			 * Don't actually disable VLAN tag stripping as
-			 * management firmware (ASF/IPMI/UMP) requires the
-			 * feature. If VLAN tag stripping is disabled driver
-			 * will manually reconstruct the VLAN frame by
-			 * appending stripped VLAN tag.
-			 */
-			if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
-			    (ifp->if_capabilities & IFCAP_VLAN_HWTAGGING)) {
-				ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
-				if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
-				    == 0)
-					ifp->if_capenable &= ~IFCAP_VLAN_HWTSO;
-			}
-			VLAN_CAPABILITIES(ifp);
-			break;
-		default:
-			/* We don't know how to handle the IOCTL, pass it on. */
-			error = ether_ioctl(ifp, command, data);
-			break;
+		if ((mask & IFCAP_VLAN_HWTSO) != 0 &&
+		    (ifp->if_capabilities & IFCAP_VLAN_HWTSO) != 0)
+			ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
+		/*
+		 * Don't actually disable VLAN tag stripping as
+		 * management firmware (ASF/IPMI/UMP) requires the
+		 * feature. If VLAN tag stripping is disabled driver
+		 * will manually reconstruct the VLAN frame by
+		 * appending stripped VLAN tag.
+		 */
+		if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
+		    (ifp->if_capabilities & IFCAP_VLAN_HWTAGGING)) {
+			ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
+			if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
+			    == 0)
+				ifp->if_capenable &= ~IFCAP_VLAN_HWTSO;
+		}
+		VLAN_CAPABILITIES(ifp);
+		break;
+	default:
+		/* We don't know how to handle the IOCTL, pass it on. */
+		error = ether_ioctl(ifp, command, data);
+		break;
 	}
 
 	DBEXIT(BCE_VERBOSE_MISC);
@@ -7302,15 +7273,15 @@ bce_watchdog(struct bce_softc *sc)
 		__FILE__, __LINE__);
 
 	DBRUNMSG(BCE_INFO,
-		bce_dump_driver_state(sc);
-		bce_dump_status_block(sc);
-		bce_dump_stats_block(sc);
-		bce_dump_ftqs(sc);
-		bce_dump_txp_state(sc, 0);
-		bce_dump_rxp_state(sc, 0);
-		bce_dump_tpat_state(sc, 0);
-		bce_dump_cp_state(sc, 0);
-		bce_dump_com_state(sc, 0));
+	    bce_dump_driver_state(sc);
+	    bce_dump_status_block(sc);
+	    bce_dump_stats_block(sc);
+	    bce_dump_ftqs(sc);
+	    bce_dump_txp_state(sc, 0);
+	    bce_dump_rxp_state(sc, 0);
+	    bce_dump_tpat_state(sc, 0);
+	    bce_dump_cp_state(sc, 0);
+	    bce_dump_com_state(sc, 0));
 
 	DBRUN(bce_breakpoint(sc));
 
@@ -7348,6 +7319,7 @@ bce_intr(void *xsc)
 
 	DBENTER(BCE_VERBOSE_SEND | BCE_VERBOSE_RECV | BCE_VERBOSE_INTR);
 	DBRUNMSG(BCE_VERBOSE_INTR, bce_dump_status_block(sc));
+	DBRUNMSG(BCE_VERBOSE_INTR, bce_dump_stats_block(sc));
 
 	BCE_LOCK(sc);
 
@@ -7364,16 +7336,17 @@ bce_intr(void *xsc)
 	 * interrupt then there's nothing to do.
 	 */
 	if ((sc->status_block->status_idx == sc->last_status_idx) &&
-		(REG_RD(sc, BCE_PCICFG_MISC_STATUS) & BCE_PCICFG_MISC_STATUS_INTA_VALUE)) {
-			DBPRINT(sc, BCE_VERBOSE_INTR, "%s(): Spurious interrupt.\n",
-				__FUNCTION__);
-			goto bce_intr_exit;
+	    (REG_RD(sc, BCE_PCICFG_MISC_STATUS) & 
+	     BCE_PCICFG_MISC_STATUS_INTA_VALUE)) {
+		DBPRINT(sc, BCE_VERBOSE_INTR, "%s(): Spurious interrupt.\n",
+		    __FUNCTION__);
+		goto bce_intr_exit;
 	}
 
 	/* Ack the interrupt and stop others from occuring. */
 	REG_WR(sc, BCE_PCICFG_INT_ACK_CMD,
-		BCE_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
-		BCE_PCICFG_INT_ACK_CMD_MASK_INT);
+	    BCE_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
+	    BCE_PCICFG_INT_ACK_CMD_MASK_INT);
 
 	/* Check if the hardware has finished any work. */
 	hw_rx_cons = bce_get_hw_rx_cons(sc);
@@ -7384,35 +7357,39 @@ bce_intr(void *xsc)
 
 		status_attn_bits = sc->status_block->status_attn_bits;
 
-	DBRUNIF(DB_RANDOMTRUE(unexpected_attention_sim_control),
-		BCE_PRINTF("Simulating unexpected status attention bit set.");
-		sc->unexpected_attention_sim_count++;
-		status_attn_bits = status_attn_bits | STATUS_ATTN_BITS_PARITY_ERROR);
+		DBRUNIF(DB_RANDOMTRUE(unexpected_attention_sim_control),
+		    BCE_PRINTF("Simulating unexpected status attention "
+		    "bit set.");
+		    sc->unexpected_attention_sim_count++;
+		    status_attn_bits = status_attn_bits | 
+		    STATUS_ATTN_BITS_PARITY_ERROR);
 
 		/* Was it a link change interrupt? */
 		if ((status_attn_bits & STATUS_ATTN_BITS_LINK_STATE) !=
-			(sc->status_block->status_attn_bits_ack & STATUS_ATTN_BITS_LINK_STATE)) {
+		    (sc->status_block->status_attn_bits_ack & 
+		     STATUS_ATTN_BITS_LINK_STATE)) {
 			bce_phy_intr(sc);
 
-			/* Clear any transient status updates during link state change. */
-			REG_WR(sc, BCE_HC_COMMAND,
-				sc->hc_command | BCE_HC_COMMAND_COAL_NOW_WO_INT);
+			/* Clear transient updates during link state change. */
+			REG_WR(sc, BCE_HC_COMMAND, sc->hc_command | 
+			    BCE_HC_COMMAND_COAL_NOW_WO_INT);
 			REG_RD(sc, BCE_HC_COMMAND);
 		}
 
-		/* If any other attention is asserted then the chip is toast. */
+		/* If any other attention is asserted, the chip is toast. */
 		if (((status_attn_bits & ~STATUS_ATTN_BITS_LINK_STATE) !=
-			(sc->status_block->status_attn_bits_ack &
-			~STATUS_ATTN_BITS_LINK_STATE))) {
+		    (sc->status_block->status_attn_bits_ack &
+		    ~STATUS_ATTN_BITS_LINK_STATE))) {
 
-		sc->unexpected_attention_count++;
+			sc->unexpected_attention_count++;
 
-			BCE_PRINTF("%s(%d): Fatal attention detected: 0x%08X\n",
-				__FILE__, __LINE__, sc->status_block->status_attn_bits);
+			BCE_PRINTF("%s(%d): Fatal attention detected: "
+			    "0x%08X\n",	__FILE__, __LINE__, 
+			    sc->status_block->status_attn_bits);
 
 			DBRUNMSG(BCE_FATAL,
-				if (unexpected_attention_sim_control == 0)
-					bce_breakpoint(sc));
+			    if (unexpected_attention_sim_control == 0)
+				bce_breakpoint(sc));
 
 			bce_init_locked(sc);
 			goto bce_intr_exit;
@@ -7426,18 +7403,25 @@ bce_intr(void *xsc)
 		if (hw_tx_cons != sc->hw_tx_cons)
 			bce_tx_intr(sc);
 
-		/* Save the status block index value for use during the next interrupt. */
+		/* Save status block index value for the next interrupt. */
 		sc->last_status_idx = sc->status_block->status_idx;
 
-		/* Prevent speculative reads from getting ahead of the status block. */
+ 		/*
+ 		 * Prevent speculative reads from getting
+ 		 * ahead of the status block.
+		 */
 		bus_space_barrier(sc->bce_btag, sc->bce_bhandle, 0, 0,
-			BUS_SPACE_BARRIER_READ);
+		    BUS_SPACE_BARRIER_READ);
 
-		/* If there's no work left then exit the interrupt service routine. */
+ 		/*
+ 		 * If there's no work left then exit the
+ 		 * interrupt service routine.
+		 */
 		hw_rx_cons = bce_get_hw_rx_cons(sc);
 		hw_tx_cons = bce_get_hw_tx_cons(sc);
 
-		if ((hw_rx_cons == sc->hw_rx_cons) && (hw_tx_cons == sc->hw_tx_cons))
+		if ((hw_rx_cons == sc->hw_rx_cons) && 
+		    (hw_tx_cons == sc->hw_tx_cons))
 			break;
 
 	}
@@ -7449,7 +7433,8 @@ bce_intr(void *xsc)
 	bce_enable_intr(sc, 0);
 
 	/* Handle any frames that arrived while handling the interrupt. */
-	if (ifp->if_drv_flags & IFF_DRV_RUNNING && !IFQ_DRV_IS_EMPTY(&ifp->if_snd))
+	if (ifp->if_drv_flags & IFF_DRV_RUNNING && 
+	    !IFQ_DRV_IS_EMPTY(&ifp->if_snd))
 		bce_start_locked(ifp);
 
 bce_intr_exit:
@@ -7482,7 +7467,7 @@ bce_set_rx_mode(struct bce_softc *sc)
 
 	/* Initialize receive mode default settings. */
 	rx_mode   = sc->rx_mode & ~(BCE_EMAC_RX_MODE_PROMISCUOUS |
-			    BCE_EMAC_RX_MODE_KEEP_VLAN_TAG);
+	    BCE_EMAC_RX_MODE_KEEP_VLAN_TAG);
 	sort_mode = 1 | BCE_RPM_SORT_USER0_BC_EN;
 
 	/*
@@ -7490,7 +7475,7 @@ bce_set_rx_mode(struct bce_softc *sc)
 	 * be enbled.
 	 */
 	if (!(BCE_IF_CAPABILITIES & IFCAP_VLAN_HWTAGGING) &&
-		(!(sc->bce_flags & BCE_MFW_ENABLE_FLAG)))
+	    (!(sc->bce_flags & BCE_MFW_ENABLE_FLAG)))
 		rx_mode |= BCE_EMAC_RX_MODE_KEEP_VLAN_TAG;
 
 	/*
@@ -7533,8 +7518,8 @@ bce_set_rx_mode(struct bce_softc *sc)
 
 	/* Only make changes if the recive mode has actually changed. */
 	if (rx_mode != sc->rx_mode) {
-		DBPRINT(sc, BCE_VERBOSE_MISC, "Enabling new receive mode: 0x%08X\n",
-			rx_mode);
+		DBPRINT(sc, BCE_VERBOSE_MISC, "Enabling new receive mode: "
+		    "0x%08X\n", rx_mode);
 
 		sc->rx_mode = rx_mode;
 		REG_WR(sc, BCE_EMAC_RX_MODE, rx_mode);
@@ -7575,183 +7560,187 @@ bce_stats_update(struct bce_softc *sc)
 	 */
 	if (!(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5706) &&
 	    !(BCE_CHIP_ID(sc) == BCE_CHIP_ID_5708_A0))
-		ifp->if_oerrors += (u_long) stats->stat_Dot3StatsCarrierSenseErrors;
+		ifp->if_oerrors += 
+		    (u_long) stats->stat_Dot3StatsCarrierSenseErrors;
 
 	/*
 	 * Update the sysctl statistics from the
 	 * hardware statistics.
 	 */
 	sc->stat_IfHCInOctets =
-		((u64) stats->stat_IfHCInOctets_hi << 32) +
-		 (u64) stats->stat_IfHCInOctets_lo;
+	    ((u64) stats->stat_IfHCInOctets_hi << 32) +
+	     (u64) stats->stat_IfHCInOctets_lo;
 
 	sc->stat_IfHCInBadOctets =
-		((u64) stats->stat_IfHCInBadOctets_hi << 32) +
-		 (u64) stats->stat_IfHCInBadOctets_lo;
+	    ((u64) stats->stat_IfHCInBadOctets_hi << 32) +
+	     (u64) stats->stat_IfHCInBadOctets_lo;
 
 	sc->stat_IfHCOutOctets =
-		((u64) stats->stat_IfHCOutOctets_hi << 32) +
-		 (u64) stats->stat_IfHCOutOctets_lo;
+	    ((u64) stats->stat_IfHCOutOctets_hi << 32) +
+	     (u64) stats->stat_IfHCOutOctets_lo;
 
 	sc->stat_IfHCOutBadOctets =
-		((u64) stats->stat_IfHCOutBadOctets_hi << 32) +
-		 (u64) stats->stat_IfHCOutBadOctets_lo;
+	    ((u64) stats->stat_IfHCOutBadOctets_hi << 32) +
+	     (u64) stats->stat_IfHCOutBadOctets_lo;
 
 	sc->stat_IfHCInUcastPkts =
-		((u64) stats->stat_IfHCInUcastPkts_hi << 32) +
-		 (u64) stats->stat_IfHCInUcastPkts_lo;
+	    ((u64) stats->stat_IfHCInUcastPkts_hi << 32) +
+	     (u64) stats->stat_IfHCInUcastPkts_lo;
 
 	sc->stat_IfHCInMulticastPkts =
-		((u64) stats->stat_IfHCInMulticastPkts_hi << 32) +
-		 (u64) stats->stat_IfHCInMulticastPkts_lo;
+	    ((u64) stats->stat_IfHCInMulticastPkts_hi << 32) +
+	     (u64) stats->stat_IfHCInMulticastPkts_lo;
 
 	sc->stat_IfHCInBroadcastPkts =
-		((u64) stats->stat_IfHCInBroadcastPkts_hi << 32) +
-		 (u64) stats->stat_IfHCInBroadcastPkts_lo;
+	    ((u64) stats->stat_IfHCInBroadcastPkts_hi << 32) +
+	     (u64) stats->stat_IfHCInBroadcastPkts_lo;
 
 	sc->stat_IfHCOutUcastPkts =
-		((u64) stats->stat_IfHCOutUcastPkts_hi << 32) +
-		 (u64) stats->stat_IfHCOutUcastPkts_lo;
+	    ((u64) stats->stat_IfHCOutUcastPkts_hi << 32) +
+	     (u64) stats->stat_IfHCOutUcastPkts_lo;
 
 	sc->stat_IfHCOutMulticastPkts =
-		((u64) stats->stat_IfHCOutMulticastPkts_hi << 32) +
-		 (u64) stats->stat_IfHCOutMulticastPkts_lo;
+	    ((u64) stats->stat_IfHCOutMulticastPkts_hi << 32) +
+	     (u64) stats->stat_IfHCOutMulticastPkts_lo;
 
 	sc->stat_IfHCOutBroadcastPkts =
-		((u64) stats->stat_IfHCOutBroadcastPkts_hi << 32) +
-		 (u64) stats->stat_IfHCOutBroadcastPkts_lo;
+	    ((u64) stats->stat_IfHCOutBroadcastPkts_hi << 32) +
+	     (u64) stats->stat_IfHCOutBroadcastPkts_lo;
+
+	/* ToDo: Preserve counters beyond 32 bits? */
+	/* ToDo: Read the statistics from auto-clear regs? */
 
 	sc->stat_emac_tx_stat_dot3statsinternalmactransmiterrors =
-		stats->stat_emac_tx_stat_dot3statsinternalmactransmiterrors;
+	    stats->stat_emac_tx_stat_dot3statsinternalmactransmiterrors;
 
 	sc->stat_Dot3StatsCarrierSenseErrors =
-		stats->stat_Dot3StatsCarrierSenseErrors;
+	    stats->stat_Dot3StatsCarrierSenseErrors;
 
 	sc->stat_Dot3StatsFCSErrors =
-		stats->stat_Dot3StatsFCSErrors;
+	    stats->stat_Dot3StatsFCSErrors;
 
 	sc->stat_Dot3StatsAlignmentErrors =
-		stats->stat_Dot3StatsAlignmentErrors;
+	    stats->stat_Dot3StatsAlignmentErrors;
 
 	sc->stat_Dot3StatsSingleCollisionFrames =
-		stats->stat_Dot3StatsSingleCollisionFrames;
+	    stats->stat_Dot3StatsSingleCollisionFrames;
 
 	sc->stat_Dot3StatsMultipleCollisionFrames =
-		stats->stat_Dot3StatsMultipleCollisionFrames;
+	    stats->stat_Dot3StatsMultipleCollisionFrames;
 
 	sc->stat_Dot3StatsDeferredTransmissions =
-		stats->stat_Dot3StatsDeferredTransmissions;
+	    stats->stat_Dot3StatsDeferredTransmissions;
 
 	sc->stat_Dot3StatsExcessiveCollisions =
-		stats->stat_Dot3StatsExcessiveCollisions;
+	    stats->stat_Dot3StatsExcessiveCollisions;
 
 	sc->stat_Dot3StatsLateCollisions =
-		stats->stat_Dot3StatsLateCollisions;
+	    stats->stat_Dot3StatsLateCollisions;
 
 	sc->stat_EtherStatsCollisions =
-		stats->stat_EtherStatsCollisions;
+	    stats->stat_EtherStatsCollisions;
 
 	sc->stat_EtherStatsFragments =
-		stats->stat_EtherStatsFragments;
+	    stats->stat_EtherStatsFragments;
 
 	sc->stat_EtherStatsJabbers =
-		stats->stat_EtherStatsJabbers;
+	    stats->stat_EtherStatsJabbers;
 
 	sc->stat_EtherStatsUndersizePkts =
-		stats->stat_EtherStatsUndersizePkts;
+	    stats->stat_EtherStatsUndersizePkts;
 
 	sc->stat_EtherStatsOversizePkts =
-		stats->stat_EtherStatsOversizePkts;
+	     stats->stat_EtherStatsOversizePkts;
 
 	sc->stat_EtherStatsPktsRx64Octets =
-		stats->stat_EtherStatsPktsRx64Octets;
+	    stats->stat_EtherStatsPktsRx64Octets;
 
 	sc->stat_EtherStatsPktsRx65Octetsto127Octets =
-		stats->stat_EtherStatsPktsRx65Octetsto127Octets;
+	    stats->stat_EtherStatsPktsRx65Octetsto127Octets;
 
 	sc->stat_EtherStatsPktsRx128Octetsto255Octets =
-		stats->stat_EtherStatsPktsRx128Octetsto255Octets;
+	    stats->stat_EtherStatsPktsRx128Octetsto255Octets;
 
 	sc->stat_EtherStatsPktsRx256Octetsto511Octets =
-		stats->stat_EtherStatsPktsRx256Octetsto511Octets;
+	    stats->stat_EtherStatsPktsRx256Octetsto511Octets;
 
 	sc->stat_EtherStatsPktsRx512Octetsto1023Octets =
-		stats->stat_EtherStatsPktsRx512Octetsto1023Octets;
+	    stats->stat_EtherStatsPktsRx512Octetsto1023Octets;
 
 	sc->stat_EtherStatsPktsRx1024Octetsto1522Octets =
-		stats->stat_EtherStatsPktsRx1024Octetsto1522Octets;
+	    stats->stat_EtherStatsPktsRx1024Octetsto1522Octets;
 
 	sc->stat_EtherStatsPktsRx1523Octetsto9022Octets =
-		stats->stat_EtherStatsPktsRx1523Octetsto9022Octets;
+	    stats->stat_EtherStatsPktsRx1523Octetsto9022Octets;
 
 	sc->stat_EtherStatsPktsTx64Octets =
-		stats->stat_EtherStatsPktsTx64Octets;
+	    stats->stat_EtherStatsPktsTx64Octets;
 
 	sc->stat_EtherStatsPktsTx65Octetsto127Octets =
-		stats->stat_EtherStatsPktsTx65Octetsto127Octets;
+	    stats->stat_EtherStatsPktsTx65Octetsto127Octets;
 
 	sc->stat_EtherStatsPktsTx128Octetsto255Octets =
-		stats->stat_EtherStatsPktsTx128Octetsto255Octets;
+	    stats->stat_EtherStatsPktsTx128Octetsto255Octets;
 
 	sc->stat_EtherStatsPktsTx256Octetsto511Octets =
-		stats->stat_EtherStatsPktsTx256Octetsto511Octets;
+	    stats->stat_EtherStatsPktsTx256Octetsto511Octets;
 
 	sc->stat_EtherStatsPktsTx512Octetsto1023Octets =
-		stats->stat_EtherStatsPktsTx512Octetsto1023Octets;
+	    stats->stat_EtherStatsPktsTx512Octetsto1023Octets;
 
 	sc->stat_EtherStatsPktsTx1024Octetsto1522Octets =
-		stats->stat_EtherStatsPktsTx1024Octetsto1522Octets;
+	    stats->stat_EtherStatsPktsTx1024Octetsto1522Octets;
 
 	sc->stat_EtherStatsPktsTx1523Octetsto9022Octets =
-		stats->stat_EtherStatsPktsTx1523Octetsto9022Octets;
+	    stats->stat_EtherStatsPktsTx1523Octetsto9022Octets;
 
 	sc->stat_XonPauseFramesReceived =
-		stats->stat_XonPauseFramesReceived;
+	    stats->stat_XonPauseFramesReceived;
 
 	sc->stat_XoffPauseFramesReceived =
-		stats->stat_XoffPauseFramesReceived;
+	    stats->stat_XoffPauseFramesReceived;
 
 	sc->stat_OutXonSent =
-		stats->stat_OutXonSent;
+	    stats->stat_OutXonSent;
 
 	sc->stat_OutXoffSent =
-		stats->stat_OutXoffSent;
+	    stats->stat_OutXoffSent;
 
 	sc->stat_FlowControlDone =
-		stats->stat_FlowControlDone;
+	    stats->stat_FlowControlDone;
 
 	sc->stat_MacControlFramesReceived =
-		stats->stat_MacControlFramesReceived;
+	    stats->stat_MacControlFramesReceived;
 
 	sc->stat_XoffStateEntered =
-		stats->stat_XoffStateEntered;
+	    stats->stat_XoffStateEntered;
 
 	sc->stat_IfInFramesL2FilterDiscards =
-		stats->stat_IfInFramesL2FilterDiscards;
+	    stats->stat_IfInFramesL2FilterDiscards;
 
 	sc->stat_IfInRuleCheckerDiscards =
-		stats->stat_IfInRuleCheckerDiscards;
+	    stats->stat_IfInRuleCheckerDiscards;
 
 	sc->stat_IfInFTQDiscards =
-		stats->stat_IfInFTQDiscards;
+	    stats->stat_IfInFTQDiscards;
 
 	sc->stat_IfInMBUFDiscards =
-		stats->stat_IfInMBUFDiscards;
+	    stats->stat_IfInMBUFDiscards;
 
 	sc->stat_IfInRuleCheckerP4Hit =
-		stats->stat_IfInRuleCheckerP4Hit;
+	    stats->stat_IfInRuleCheckerP4Hit;
 
 	sc->stat_CatchupInRuleCheckerDiscards =
-		stats->stat_CatchupInRuleCheckerDiscards;
+	    stats->stat_CatchupInRuleCheckerDiscards;
 
 	sc->stat_CatchupInFTQDiscards =
-		stats->stat_CatchupInFTQDiscards;
+	    stats->stat_CatchupInFTQDiscards;
 
 	sc->stat_CatchupInMBUFDiscards =
-		stats->stat_CatchupInMBUFDiscards;
+	    stats->stat_CatchupInMBUFDiscards;
 
 	sc->stat_CatchupInRuleCheckerP4Hit =
-		stats->stat_CatchupInRuleCheckerP4Hit;
+	    stats->stat_CatchupInRuleCheckerP4Hit;
 
 	sc->com_no_buffers = REG_RD_IND(sc, 0x120084);
 
@@ -7760,26 +7749,26 @@ bce_stats_update(struct bce_softc *sc)
 	 * hardware statistics.
 	 */
 	ifp->if_collisions =
-		(u_long) sc->stat_EtherStatsCollisions;
+	    (u_long) sc->stat_EtherStatsCollisions;
 
 	/* ToDo: This method loses soft errors. */
 	ifp->if_ierrors =
-		(u_long) sc->stat_EtherStatsUndersizePkts +
-		(u_long) sc->stat_EtherStatsOversizePkts +
-		(u_long) sc->stat_IfInMBUFDiscards +
-		(u_long) sc->stat_Dot3StatsAlignmentErrors +
-		(u_long) sc->stat_Dot3StatsFCSErrors +
-		(u_long) sc->stat_IfInRuleCheckerDiscards +
-		(u_long) sc->stat_IfInFTQDiscards +
-		(u_long) sc->com_no_buffers;
+	    (u_long) sc->stat_EtherStatsUndersizePkts +
+	    (u_long) sc->stat_EtherStatsOversizePkts +
+	    (u_long) sc->stat_IfInMBUFDiscards +
+	    (u_long) sc->stat_Dot3StatsAlignmentErrors +
+	    (u_long) sc->stat_Dot3StatsFCSErrors +
+	    (u_long) sc->stat_IfInRuleCheckerDiscards +
+	    (u_long) sc->stat_IfInFTQDiscards +
+	    (u_long) sc->com_no_buffers;
 
 	/* ToDo: This method loses soft errors. */
 	ifp->if_oerrors =
-		(u_long) sc->stat_emac_tx_stat_dot3statsinternalmactransmiterrors +
-		(u_long) sc->stat_Dot3StatsExcessiveCollisions +
-		(u_long) sc->stat_Dot3StatsLateCollisions;
+	    (u_long) sc->stat_emac_tx_stat_dot3statsinternalmactransmiterrors +
+	    (u_long) sc->stat_Dot3StatsExcessiveCollisions +
+	    (u_long) sc->stat_Dot3StatsLateCollisions;
 
-	/* ToDo: Add additional statistics. */
+	/* ToDo: Add additional statistics? */
 
 	DBEXIT(BCE_EXTREME_MISC);
 }
@@ -7806,6 +7795,33 @@ bce_pulse(void *xsc)
 	msg = (u32) ++sc->bce_fw_drv_pulse_wr_seq;
 	bce_shmem_wr(sc, BCE_DRV_PULSE_MB, msg);
 
+	/* Update the bootcode condition. */
+	sc->bc_state = bce_shmem_rd(sc, BCE_BC_STATE_CONDITION);
+
+	/* Report whether the bootcode still knows the driver is running. */
+	if (sc->bce_drv_cardiac_arrest == FALSE) {
+		if (!(sc->bc_state & BCE_CONDITION_DRV_PRESENT)) {
+			sc->bce_drv_cardiac_arrest = TRUE;
+			BCE_PRINTF("%s(): Bootcode lost the driver pulse! "
+			    "(bc_state = 0x%08X)\n", __FUNCTION__, 
+			    sc->bc_state);
+		}
+	} else {
+ 		/*
+ 		 * Not supported by all bootcode versions.
+ 		 * (v5.0.11+ and v5.2.1+)  Older bootcode
+ 		 * will require the driver to reset the
+ 		 * controller to clear this condition.
+		 */
+		if (sc->bc_state & BCE_CONDITION_DRV_PRESENT) {
+			sc->bce_drv_cardiac_arrest = FALSE;
+			BCE_PRINTF("%s(): Bootcode found the driver pulse! "
+			    "(bc_state = 0x%08X)\n", __FUNCTION__, 
+			    sc->bc_state);
+		}
+	}
+
+
 	/* Schedule the next pulse. */
 	callout_reset(&sc->bce_pulse_callout, hz, bce_pulse, sc);
 
@@ -7848,7 +7864,7 @@ bce_tick(void *xsc)
 	bce_watchdog(sc);
 
 	/* If link is up already up then we're done. */
-	if (sc->bce_link)
+	if (sc->bce_link_up == TRUE)
 		goto bce_tick_exit;
 
 	/* Link is down.  Check what the PHY's doing. */
@@ -7858,16 +7874,19 @@ bce_tick(void *xsc)
 	/* Check if the link has come up. */
 	if ((mii->mii_media_status & IFM_ACTIVE) &&
 	    (IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE)) {
-		DBPRINT(sc, BCE_VERBOSE_MISC, "%s(): Link up!\n", __FUNCTION__);
-		sc->bce_link++;
+		DBPRINT(sc, BCE_VERBOSE_MISC, 
+		    "%s(): Link up!\n", __FUNCTION__);
+		sc->bce_link_up = TRUE;
 		if ((IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T ||
-		    IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_SX) &&
+		    IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_SX ||
+		    IFM_SUBTYPE(mii->mii_media_active) == IFM_2500_SX) &&
 		    bootverbose)
 			BCE_PRINTF("Gigabit link up!\n");
+
 		/* Now that link is up, handle any outstanding TX traffic. */
 		if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
-			DBPRINT(sc, BCE_VERBOSE_MISC, "%s(): Found pending TX traffic.\n",
-				 __FUNCTION__);
+			DBPRINT(sc, BCE_VERBOSE_MISC, "%s(): Found "
+			    "pending TX traffic.\n", __FUNCTION__);
 			bce_start_locked(ifp);
 		}
 	}
@@ -7888,22 +7907,22 @@ bce_tick_exit:
 static int
 bce_sysctl_driver_state(SYSCTL_HANDLER_ARGS)
 {
-        int error;
-        int result;
-        struct bce_softc *sc;
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        result = -1;
-        error = sysctl_handle_int(oidp, &result, 0, req);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
 
-        if (error || !req->newptr)
-                return (error);
+	if (error || !req->newptr)
+		return (error);
 
-        if (result == 1) {
-                sc = (struct bce_softc *)arg1;
-                bce_dump_driver_state(sc);
-        }
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_driver_state(sc);
+	}
 
-        return error;
+	return error;
 }
 
 
@@ -7916,22 +7935,78 @@ bce_sysctl_driver_state(SYSCTL_HANDLER_ARGS)
 static int
 bce_sysctl_hw_state(SYSCTL_HANDLER_ARGS)
 {
-        int error;
-        int result;
-        struct bce_softc *sc;
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        result = -1;
-        error = sysctl_handle_int(oidp, &result, 0, req);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
 
-        if (error || !req->newptr)
-                return (error);
+	if (error || !req->newptr)
+		return (error);
 
-        if (result == 1) {
-                sc = (struct bce_softc *)arg1;
-                bce_dump_hw_state(sc);
-        }
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_hw_state(sc);
+	}
 
-        return error;
+	return error;
+}
+
+
+/****************************************************************************/
+/* Allows the status block to be dumped through the sysctl interface.       */
+/*                                                                          */
+/* Returns:                                                                 */
+/*   0 for success, positive value for failure.                             */
+/****************************************************************************/
+static int
+bce_sysctl_status_block(SYSCTL_HANDLER_ARGS)
+{
+	int error;
+	int result;
+	struct bce_softc *sc;
+
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
+
+	if (error || !req->newptr)
+		return (error);
+
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_status_block(sc);
+	}
+
+	return error;
+}
+
+
+/****************************************************************************/
+/* Allows the stats block to be dumped through the sysctl interface.        */
+/*                                                                          */
+/* Returns:                                                                 */
+/*   0 for success, positive value for failure.                             */
+/****************************************************************************/
+static int
+bce_sysctl_stats_block(SYSCTL_HANDLER_ARGS)
+{
+	int error;
+	int result;
+	struct bce_softc *sc;
+
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
+
+	if (error || !req->newptr)
+		return (error);
+
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_stats_block(sc);
+	}
+
+	return error;
 }
 
 
@@ -7944,50 +8019,78 @@ bce_sysctl_hw_state(SYSCTL_HANDLER_ARGS)
 static int
 bce_sysctl_bc_state(SYSCTL_HANDLER_ARGS)
 {
-        int error;
-        int result;
-        struct bce_softc *sc;
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        result = -1;
-        error = sysctl_handle_int(oidp, &result, 0, req);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
+
+	if (error || !req->newptr)
+		return (error);
+
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_bc_state(sc);
+	}
+
+	return error;
+}
+
+
+/****************************************************************************/
+/* Provides a sysctl interface to allow dumping the RX BD chain.            */
+/*                                                                          */
+/* Returns:                                                                 */
+/*   0 for success, positive value for failure.                             */
+/****************************************************************************/
+static int
+bce_sysctl_dump_rx_bd_chain(SYSCTL_HANDLER_ARGS)
+{
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        if (error || !req->newptr)
-                return (error);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
+
+	if (error || !req->newptr)
+		return (error);
 
-        if (result == 1) {
-                sc = (struct bce_softc *)arg1;
-                bce_dump_bc_state(sc);
-        }
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_rx_bd_chain(sc, 0, TOTAL_RX_BD);
+	}
 
-        return error;
+	return error;
 }
 
 
 /****************************************************************************/
-/* Provides a sysctl interface to allow dumping the RX chain.               */
+/* Provides a sysctl interface to allow dumping the RX MBUF chain.          */
 /*                                                                          */
 /* Returns:                                                                 */
 /*   0 for success, positive value for failure.                             */
 /****************************************************************************/
 static int
-bce_sysctl_dump_rx_chain(SYSCTL_HANDLER_ARGS)
+bce_sysctl_dump_rx_mbuf_chain(SYSCTL_HANDLER_ARGS)
 {
-        int error;
-        int result;
-        struct bce_softc *sc;
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        result = -1;
-        error = sysctl_handle_int(oidp, &result, 0, req);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
 
-        if (error || !req->newptr)
-                return (error);
+	if (error || !req->newptr)
+		return (error);
 
-        if (result == 1) {
-                sc = (struct bce_softc *)arg1;
-                bce_dump_rx_chain(sc, 0, TOTAL_RX_BD);
-        }
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_rx_mbuf_chain(sc, 0, USABLE_RX_BD);
+	}
 
-        return error;
+	return error;
 }
 
 
@@ -8000,22 +8103,22 @@ bce_sysctl_dump_rx_chain(SYSCTL_HANDLER_ARGS)
 static int
 bce_sysctl_dump_tx_chain(SYSCTL_HANDLER_ARGS)
 {
-        int error;
-        int result;
-        struct bce_softc *sc;
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        result = -1;
-        error = sysctl_handle_int(oidp, &result, 0, req);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
 
-        if (error || !req->newptr)
-                return (error);
+	if (error || !req->newptr)
+		return (error);
 
-        if (result == 1) {
-                sc = (struct bce_softc *)arg1;
-                bce_dump_tx_chain(sc, 0, TOTAL_TX_BD);
-        }
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_tx_chain(sc, 0, TOTAL_TX_BD);
+	}
 
-        return error;
+	return error;
 }
 
 
@@ -8029,22 +8132,22 @@ bce_sysctl_dump_tx_chain(SYSCTL_HANDLER_ARGS)
 static int
 bce_sysctl_dump_pg_chain(SYSCTL_HANDLER_ARGS)
 {
-        int error;
-        int result;
-        struct bce_softc *sc;
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        result = -1;
-        error = sysctl_handle_int(oidp, &result, 0, req);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
 
-        if (error || !req->newptr)
-                return (error);
+	if (error || !req->newptr)
+		return (error);
 
-        if (result == 1) {
-                sc = (struct bce_softc *)arg1;
-                bce_dump_pg_chain(sc, 0, TOTAL_PG_BD);
-        }
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_dump_pg_chain(sc, 0, TOTAL_PG_BD);
+	}
 
-        return error;
+	return error;
 }
 #endif
 
@@ -8177,22 +8280,22 @@ bce_sysctl_dump_ctx(SYSCTL_HANDLER_ARGS)
 static int
 bce_sysctl_breakpoint(SYSCTL_HANDLER_ARGS)
 {
-        int error;
-        int result;
-        struct bce_softc *sc;
+	int error;
+	int result;
+	struct bce_softc *sc;
 
-        result = -1;
-        error = sysctl_handle_int(oidp, &result, 0, req);
+	result = -1;
+	error = sysctl_handle_int(oidp, &result, 0, req);
 
-        if (error || !req->newptr)
-                return (error);
+	if (error || !req->newptr)
+		return (error);
 
-        if (result == 1) {
-                sc = (struct bce_softc *)arg1;
-                bce_breakpoint(sc);
-        }
+	if (result == 1) {
+		sc = (struct bce_softc *)arg1;
+		bce_breakpoint(sc);
+	}
 
-        return error;
+	return error;
 }
 #endif
 
@@ -8216,467 +8319,474 @@ bce_add_sysctls(struct bce_softc *sc)
 
 #ifdef BCE_DEBUG
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"l2fhdr_error_sim_control",
-		CTLFLAG_RW, &l2fhdr_error_sim_control,
-		0, "Debug control to force l2fhdr errors");
+	    "l2fhdr_error_sim_control",
+	    CTLFLAG_RW, &l2fhdr_error_sim_control,
+	    0, "Debug control to force l2fhdr errors");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"l2fhdr_error_sim_count",
-		CTLFLAG_RD, &sc->l2fhdr_error_sim_count,
-		0, "Number of simulated l2_fhdr errors");
+	    "l2fhdr_error_sim_count",
+	    CTLFLAG_RD, &sc->l2fhdr_error_sim_count,
+	    0, "Number of simulated l2_fhdr errors");
 #endif
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"l2fhdr_error_count",
-		CTLFLAG_RD, &sc->l2fhdr_error_count,
-		0, "Number of l2_fhdr errors");
+	    "l2fhdr_error_count",
+	    CTLFLAG_RD, &sc->l2fhdr_error_count,
+	    0, "Number of l2_fhdr errors");
 
 #ifdef BCE_DEBUG
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"mbuf_alloc_failed_sim_control",
-		CTLFLAG_RW, &mbuf_alloc_failed_sim_control,
-		0, "Debug control to force mbuf allocation failures");
+	    "mbuf_alloc_failed_sim_control",
+	    CTLFLAG_RW, &mbuf_alloc_failed_sim_control,
+	    0, "Debug control to force mbuf allocation failures");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"mbuf_alloc_failed_sim_count",
-		CTLFLAG_RD, &sc->mbuf_alloc_failed_sim_count,
-		0, "Number of simulated mbuf cluster allocation failures");
+	    "mbuf_alloc_failed_sim_count",
+	    CTLFLAG_RD, &sc->mbuf_alloc_failed_sim_count,
+	    0, "Number of simulated mbuf cluster allocation failures");
 #endif
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"mbuf_alloc_failed_count",
-		CTLFLAG_RD, &sc->mbuf_alloc_failed_count,
-		0, "Number of mbuf allocation failures");
+	    "mbuf_alloc_failed_count",
+	    CTLFLAG_RD, &sc->mbuf_alloc_failed_count,
+	    0, "Number of mbuf allocation failures");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"fragmented_mbuf_count",
-		CTLFLAG_RD, &sc->fragmented_mbuf_count,
-		0, "Number of fragmented mbufs");
+	    "fragmented_mbuf_count",
+	    CTLFLAG_RD, &sc->fragmented_mbuf_count,
+	    0, "Number of fragmented mbufs");
 
 #ifdef BCE_DEBUG
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"dma_map_addr_failed_sim_control",
-		CTLFLAG_RW, &dma_map_addr_failed_sim_control,
-		0, "Debug control to force DMA mapping failures");
+	    "dma_map_addr_failed_sim_control",
+	    CTLFLAG_RW, &dma_map_addr_failed_sim_control,
+	    0, "Debug control to force DMA mapping failures");
 
 	/* ToDo: Figure out how to update this value in bce_dma_map_addr(). */
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"dma_map_addr_failed_sim_count",
-		CTLFLAG_RD, &sc->dma_map_addr_failed_sim_count,
-		0, "Number of simulated DMA mapping failures");
+	    "dma_map_addr_failed_sim_count",
+	    CTLFLAG_RD, &sc->dma_map_addr_failed_sim_count,
+	    0, "Number of simulated DMA mapping failures");
 	
 #endif
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"dma_map_addr_rx_failed_count",
-		CTLFLAG_RD, &sc->dma_map_addr_rx_failed_count,
-		0, "Number of RX DMA mapping failures");
+	    "dma_map_addr_rx_failed_count",
+	    CTLFLAG_RD, &sc->dma_map_addr_rx_failed_count,
+	    0, "Number of RX DMA mapping failures");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"dma_map_addr_tx_failed_count",
-		CTLFLAG_RD, &sc->dma_map_addr_tx_failed_count,
-		0, "Number of TX DMA mapping failures");
+	    "dma_map_addr_tx_failed_count",
+	    CTLFLAG_RD, &sc->dma_map_addr_tx_failed_count,
+	    0, "Number of TX DMA mapping failures");
 
 #ifdef BCE_DEBUG
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"unexpected_attention_sim_control",
-		CTLFLAG_RW, &unexpected_attention_sim_control,
-		0, "Debug control to simulate unexpected attentions");
+	    "unexpected_attention_sim_control",
+	    CTLFLAG_RW, &unexpected_attention_sim_control,
+	    0, "Debug control to simulate unexpected attentions");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"unexpected_attention_sim_count",
-		CTLFLAG_RW, &sc->unexpected_attention_sim_count,
-		0, "Number of simulated unexpected attentions");
+	    "unexpected_attention_sim_count",
+	    CTLFLAG_RW, &sc->unexpected_attention_sim_count,
+	    0, "Number of simulated unexpected attentions");
 #endif
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"unexpected_attention_count",
-		CTLFLAG_RW, &sc->unexpected_attention_count,
-		0, "Number of unexpected attentions");
+	    "unexpected_attention_count",
+	    CTLFLAG_RW, &sc->unexpected_attention_count,
+	    0, "Number of unexpected attentions");
 
 #ifdef BCE_DEBUG
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"debug_bootcode_running_failure",
-		CTLFLAG_RW, &bootcode_running_failure_sim_control,
-		0, "Debug control to force bootcode running failures");
+	    "debug_bootcode_running_failure",
+	    CTLFLAG_RW, &bootcode_running_failure_sim_control,
+	    0, "Debug control to force bootcode running failures");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"rx_low_watermark",
-		CTLFLAG_RD, &sc->rx_low_watermark,
-		0, "Lowest level of free rx_bd's");
+	    "rx_low_watermark",
+	    CTLFLAG_RD, &sc->rx_low_watermark,
+	    0, "Lowest level of free rx_bd's");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"rx_empty_count",
-		CTLFLAG_RD, &sc->rx_empty_count,
-		0, "Number of times the RX chain was empty");
+	    "rx_empty_count",
+	    CTLFLAG_RD, &sc->rx_empty_count,
+	    0, "Number of times the RX chain was empty");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"tx_hi_watermark",
-		CTLFLAG_RD, &sc->tx_hi_watermark,
-		0, "Highest level of used tx_bd's");
+	    "tx_hi_watermark",
+	    CTLFLAG_RD, &sc->tx_hi_watermark,
+	    0, "Highest level of used tx_bd's");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"tx_full_count",
-		CTLFLAG_RD, &sc->tx_full_count,
-		0, "Number of times the TX chain was full");
+	    "tx_full_count",
+	    CTLFLAG_RD, &sc->tx_full_count,
+	    0, "Number of times the TX chain was full");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO,
-		"requested_tso_frames",
-		CTLFLAG_RD, &sc->requested_tso_frames,
-		0, "Number of TSO frames received");
+	    "requested_tso_frames",
+	    CTLFLAG_RD, &sc->requested_tso_frames,
+	    0, "Number of TSO frames received");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"rx_interrupts",
-		CTLFLAG_RD, &sc->rx_interrupts,
-		0, "Number of RX interrupts");
+	    "rx_interrupts",
+	    CTLFLAG_RD, &sc->rx_interrupts,
+	    0, "Number of RX interrupts");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"tx_interrupts",
-		CTLFLAG_RD, &sc->tx_interrupts,
-		0, "Number of TX interrupts");
-
-	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"rx_intr_time",
-		CTLFLAG_RD, &sc->rx_intr_time,
-		"RX interrupt time");
-
-	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"tx_intr_time",
-		CTLFLAG_RD, &sc->tx_intr_time,
-		"TX interrupt time");
+	    "tx_interrupts",
+	    CTLFLAG_RD, &sc->tx_interrupts,
+	    0, "Number of TX interrupts");
 #endif
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHcInOctets",
-		CTLFLAG_RD, &sc->stat_IfHCInOctets,
-		"Bytes received");
+	    "stat_IfHcInOctets",
+	    CTLFLAG_RD, &sc->stat_IfHCInOctets,
+	    "Bytes received");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCInBadOctets",
-		CTLFLAG_RD, &sc->stat_IfHCInBadOctets,
-		"Bad bytes received");
+	    "stat_IfHCInBadOctets",
+	    CTLFLAG_RD, &sc->stat_IfHCInBadOctets,
+	    "Bad bytes received");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCOutOctets",
-		CTLFLAG_RD, &sc->stat_IfHCOutOctets,
-		"Bytes sent");
+	    "stat_IfHCOutOctets",
+	    CTLFLAG_RD, &sc->stat_IfHCOutOctets,
+	    "Bytes sent");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCOutBadOctets",
-		CTLFLAG_RD, &sc->stat_IfHCOutBadOctets,
-		"Bad bytes sent");
+	    "stat_IfHCOutBadOctets",
+	    CTLFLAG_RD, &sc->stat_IfHCOutBadOctets,
+	    "Bad bytes sent");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCInUcastPkts",
-		CTLFLAG_RD, &sc->stat_IfHCInUcastPkts,
-		"Unicast packets received");
+	    "stat_IfHCInUcastPkts",
+	    CTLFLAG_RD, &sc->stat_IfHCInUcastPkts,
+	    "Unicast packets received");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCInMulticastPkts",
-		CTLFLAG_RD, &sc->stat_IfHCInMulticastPkts,
-		"Multicast packets received");
+	    "stat_IfHCInMulticastPkts",
+	    CTLFLAG_RD, &sc->stat_IfHCInMulticastPkts,
+	    "Multicast packets received");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCInBroadcastPkts",
-		CTLFLAG_RD, &sc->stat_IfHCInBroadcastPkts,
-		"Broadcast packets received");
+	    "stat_IfHCInBroadcastPkts",
+	    CTLFLAG_RD, &sc->stat_IfHCInBroadcastPkts,
+	    "Broadcast packets received");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCOutUcastPkts",
-		CTLFLAG_RD, &sc->stat_IfHCOutUcastPkts,
-		"Unicast packets sent");
+	    "stat_IfHCOutUcastPkts",
+	    CTLFLAG_RD, &sc->stat_IfHCOutUcastPkts,
+	    "Unicast packets sent");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCOutMulticastPkts",
-		CTLFLAG_RD, &sc->stat_IfHCOutMulticastPkts,
-		"Multicast packets sent");
+	    "stat_IfHCOutMulticastPkts",
+	    CTLFLAG_RD, &sc->stat_IfHCOutMulticastPkts,
+	    "Multicast packets sent");
 
 	SYSCTL_ADD_ULONG(ctx, children, OID_AUTO,
-		"stat_IfHCOutBroadcastPkts",
-		CTLFLAG_RD, &sc->stat_IfHCOutBroadcastPkts,
-		"Broadcast packets sent");
+	    "stat_IfHCOutBroadcastPkts",
+	    CTLFLAG_RD, &sc->stat_IfHCOutBroadcastPkts,
+	    "Broadcast packets sent");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_emac_tx_stat_dot3statsinternalmactransmiterrors",
-		CTLFLAG_RD, &sc->stat_emac_tx_stat_dot3statsinternalmactransmiterrors,
-		0, "Internal MAC transmit errors");
+	    "stat_emac_tx_stat_dot3statsinternalmactransmiterrors",
+	    CTLFLAG_RD, &sc->stat_emac_tx_stat_dot3statsinternalmactransmiterrors,
+	    0, "Internal MAC transmit errors");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsCarrierSenseErrors",
-		CTLFLAG_RD, &sc->stat_Dot3StatsCarrierSenseErrors,
-		0, "Carrier sense errors");
+	    "stat_Dot3StatsCarrierSenseErrors",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsCarrierSenseErrors,
+	    0, "Carrier sense errors");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsFCSErrors",
-		CTLFLAG_RD, &sc->stat_Dot3StatsFCSErrors,
-		0, "Frame check sequence errors");
+	    "stat_Dot3StatsFCSErrors",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsFCSErrors,
+	    0, "Frame check sequence errors");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsAlignmentErrors",
-		CTLFLAG_RD, &sc->stat_Dot3StatsAlignmentErrors,
-		0, "Alignment errors");
+	    "stat_Dot3StatsAlignmentErrors",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsAlignmentErrors,
+	    0, "Alignment errors");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsSingleCollisionFrames",
-		CTLFLAG_RD, &sc->stat_Dot3StatsSingleCollisionFrames,
-		0, "Single Collision Frames");
+	    "stat_Dot3StatsSingleCollisionFrames",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsSingleCollisionFrames,
+	    0, "Single Collision Frames");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsMultipleCollisionFrames",
-		CTLFLAG_RD, &sc->stat_Dot3StatsMultipleCollisionFrames,
-		0, "Multiple Collision Frames");
+	    "stat_Dot3StatsMultipleCollisionFrames",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsMultipleCollisionFrames,
+	    0, "Multiple Collision Frames");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsDeferredTransmissions",
-		CTLFLAG_RD, &sc->stat_Dot3StatsDeferredTransmissions,
-		0, "Deferred Transmissions");
+	    "stat_Dot3StatsDeferredTransmissions",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsDeferredTransmissions,
+	    0, "Deferred Transmissions");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsExcessiveCollisions",
-		CTLFLAG_RD, &sc->stat_Dot3StatsExcessiveCollisions,
-		0, "Excessive Collisions");
+	    "stat_Dot3StatsExcessiveCollisions",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsExcessiveCollisions,
+	    0, "Excessive Collisions");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_Dot3StatsLateCollisions",
-		CTLFLAG_RD, &sc->stat_Dot3StatsLateCollisions,
-		0, "Late Collisions");
+	    "stat_Dot3StatsLateCollisions",
+	    CTLFLAG_RD, &sc->stat_Dot3StatsLateCollisions,
+	    0, "Late Collisions");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsCollisions",
-		CTLFLAG_RD, &sc->stat_EtherStatsCollisions,
-		0, "Collisions");
+	    "stat_EtherStatsCollisions",
+	    CTLFLAG_RD, &sc->stat_EtherStatsCollisions,
+	    0, "Collisions");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsFragments",
-		CTLFLAG_RD, &sc->stat_EtherStatsFragments,
-		0, "Fragments");
+	    "stat_EtherStatsFragments",
+	    CTLFLAG_RD, &sc->stat_EtherStatsFragments,
+	    0, "Fragments");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsJabbers",
-		CTLFLAG_RD, &sc->stat_EtherStatsJabbers,
-		0, "Jabbers");
+	    "stat_EtherStatsJabbers",
+	    CTLFLAG_RD, &sc->stat_EtherStatsJabbers,
+	    0, "Jabbers");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsUndersizePkts",
-		CTLFLAG_RD, &sc->stat_EtherStatsUndersizePkts,
-		0, "Undersize packets");
+	    "stat_EtherStatsUndersizePkts",
+	    CTLFLAG_RD, &sc->stat_EtherStatsUndersizePkts,
+	    0, "Undersize packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsOversizePkts",
-		CTLFLAG_RD, &sc->stat_EtherStatsOversizePkts,
-		0, "stat_EtherStatsOversizePkts");
+	    "stat_EtherStatsOversizePkts",
+	    CTLFLAG_RD, &sc->stat_EtherStatsOversizePkts,
+	    0, "stat_EtherStatsOversizePkts");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsRx64Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsRx64Octets,
-		0, "Bytes received in 64 byte packets");
+	    "stat_EtherStatsPktsRx64Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsRx64Octets,
+	    0, "Bytes received in 64 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsRx65Octetsto127Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsRx65Octetsto127Octets,
-		0, "Bytes received in 65 to 127 byte packets");
+	    "stat_EtherStatsPktsRx65Octetsto127Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsRx65Octetsto127Octets,
+	    0, "Bytes received in 65 to 127 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsRx128Octetsto255Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsRx128Octetsto255Octets,
-		0, "Bytes received in 128 to 255 byte packets");
+	    "stat_EtherStatsPktsRx128Octetsto255Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsRx128Octetsto255Octets,
+	    0, "Bytes received in 128 to 255 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsRx256Octetsto511Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsRx256Octetsto511Octets,
-		0, "Bytes received in 256 to 511 byte packets");
+	    "stat_EtherStatsPktsRx256Octetsto511Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsRx256Octetsto511Octets,
+	    0, "Bytes received in 256 to 511 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsRx512Octetsto1023Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsRx512Octetsto1023Octets,
-		0, "Bytes received in 512 to 1023 byte packets");
+	    "stat_EtherStatsPktsRx512Octetsto1023Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsRx512Octetsto1023Octets,
+	    0, "Bytes received in 512 to 1023 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsRx1024Octetsto1522Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsRx1024Octetsto1522Octets,
-		0, "Bytes received in 1024 t0 1522 byte packets");
+	    "stat_EtherStatsPktsRx1024Octetsto1522Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsRx1024Octetsto1522Octets,
+	    0, "Bytes received in 1024 t0 1522 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsRx1523Octetsto9022Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsRx1523Octetsto9022Octets,
-		0, "Bytes received in 1523 to 9022 byte packets");
+	    "stat_EtherStatsPktsRx1523Octetsto9022Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsRx1523Octetsto9022Octets,
+	    0, "Bytes received in 1523 to 9022 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsTx64Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsTx64Octets,
-		0, "Bytes sent in 64 byte packets");
+	    "stat_EtherStatsPktsTx64Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsTx64Octets,
+	    0, "Bytes sent in 64 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsTx65Octetsto127Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsTx65Octetsto127Octets,
-		0, "Bytes sent in 65 to 127 byte packets");
+	    "stat_EtherStatsPktsTx65Octetsto127Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsTx65Octetsto127Octets,
+	    0, "Bytes sent in 65 to 127 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsTx128Octetsto255Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsTx128Octetsto255Octets,
-		0, "Bytes sent in 128 to 255 byte packets");
+	    "stat_EtherStatsPktsTx128Octetsto255Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsTx128Octetsto255Octets,
+	    0, "Bytes sent in 128 to 255 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsTx256Octetsto511Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsTx256Octetsto511Octets,
-		0, "Bytes sent in 256 to 511 byte packets");
+	    "stat_EtherStatsPktsTx256Octetsto511Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsTx256Octetsto511Octets,
+	    0, "Bytes sent in 256 to 511 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsTx512Octetsto1023Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsTx512Octetsto1023Octets,
-		0, "Bytes sent in 512 to 1023 byte packets");
+	    "stat_EtherStatsPktsTx512Octetsto1023Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsTx512Octetsto1023Octets,
+	    0, "Bytes sent in 512 to 1023 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsTx1024Octetsto1522Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsTx1024Octetsto1522Octets,
-		0, "Bytes sent in 1024 to 1522 byte packets");
+	    "stat_EtherStatsPktsTx1024Octetsto1522Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsTx1024Octetsto1522Octets,
+	    0, "Bytes sent in 1024 to 1522 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_EtherStatsPktsTx1523Octetsto9022Octets",
-		CTLFLAG_RD, &sc->stat_EtherStatsPktsTx1523Octetsto9022Octets,
-		0, "Bytes sent in 1523 to 9022 byte packets");
+	    "stat_EtherStatsPktsTx1523Octetsto9022Octets",
+	    CTLFLAG_RD, &sc->stat_EtherStatsPktsTx1523Octetsto9022Octets,
+	    0, "Bytes sent in 1523 to 9022 byte packets");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_XonPauseFramesReceived",
-		CTLFLAG_RD, &sc->stat_XonPauseFramesReceived,
-		0, "XON pause frames receved");
+	    "stat_XonPauseFramesReceived",
+	    CTLFLAG_RD, &sc->stat_XonPauseFramesReceived,
+	    0, "XON pause frames receved");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_XoffPauseFramesReceived",
-		CTLFLAG_RD, &sc->stat_XoffPauseFramesReceived,
-		0, "XOFF pause frames received");
+	    "stat_XoffPauseFramesReceived",
+	    CTLFLAG_RD, &sc->stat_XoffPauseFramesReceived,
+	    0, "XOFF pause frames received");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_OutXonSent",
-		CTLFLAG_RD, &sc->stat_OutXonSent,
-		0, "XON pause frames sent");
+	    "stat_OutXonSent",
+	    CTLFLAG_RD, &sc->stat_OutXonSent,
+	    0, "XON pause frames sent");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_OutXoffSent",
-		CTLFLAG_RD, &sc->stat_OutXoffSent,
-		0, "XOFF pause frames sent");
+	    "stat_OutXoffSent",
+	    CTLFLAG_RD, &sc->stat_OutXoffSent,
+	    0, "XOFF pause frames sent");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_FlowControlDone",
-		CTLFLAG_RD, &sc->stat_FlowControlDone,
-		0, "Flow control done");
+	    "stat_FlowControlDone",
+	    CTLFLAG_RD, &sc->stat_FlowControlDone,
+	    0, "Flow control done");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_MacControlFramesReceived",
-		CTLFLAG_RD, &sc->stat_MacControlFramesReceived,
-		0, "MAC control frames received");
+	    "stat_MacControlFramesReceived",
+	    CTLFLAG_RD, &sc->stat_MacControlFramesReceived,
+	    0, "MAC control frames received");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_XoffStateEntered",
-		CTLFLAG_RD, &sc->stat_XoffStateEntered,
-		0, "XOFF state entered");
+	    "stat_XoffStateEntered",
+	    CTLFLAG_RD, &sc->stat_XoffStateEntered,
+	    0, "XOFF state entered");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_IfInFramesL2FilterDiscards",
-		CTLFLAG_RD, &sc->stat_IfInFramesL2FilterDiscards,
-		0, "Received L2 packets discarded");
+	    "stat_IfInFramesL2FilterDiscards",
+	    CTLFLAG_RD, &sc->stat_IfInFramesL2FilterDiscards,
+	    0, "Received L2 packets discarded");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_IfInRuleCheckerDiscards",
-		CTLFLAG_RD, &sc->stat_IfInRuleCheckerDiscards,
-		0, "Received packets discarded by rule");
+	    "stat_IfInRuleCheckerDiscards",
+	    CTLFLAG_RD, &sc->stat_IfInRuleCheckerDiscards,
+	    0, "Received packets discarded by rule");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_IfInFTQDiscards",
-		CTLFLAG_RD, &sc->stat_IfInFTQDiscards,
-		0, "Received packet FTQ discards");
+	    "stat_IfInFTQDiscards",
+	    CTLFLAG_RD, &sc->stat_IfInFTQDiscards,
+	    0, "Received packet FTQ discards");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_IfInMBUFDiscards",
-		CTLFLAG_RD, &sc->stat_IfInMBUFDiscards,
-		0, "Received packets discarded due to lack of controller buffer memory");
+	    "stat_IfInMBUFDiscards",
+	    CTLFLAG_RD, &sc->stat_IfInMBUFDiscards,
+	    0, "Received packets discarded due to lack "
+	    "of controller buffer memory");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_IfInRuleCheckerP4Hit",
-		CTLFLAG_RD, &sc->stat_IfInRuleCheckerP4Hit,
-		0, "Received packets rule checker hits");
+	    "stat_IfInRuleCheckerP4Hit",
+	    CTLFLAG_RD, &sc->stat_IfInRuleCheckerP4Hit,
+	    0, "Received packets rule checker hits");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_CatchupInRuleCheckerDiscards",
-		CTLFLAG_RD, &sc->stat_CatchupInRuleCheckerDiscards,
-		0, "Received packets discarded in Catchup path");
+	    "stat_CatchupInRuleCheckerDiscards",
+	    CTLFLAG_RD, &sc->stat_CatchupInRuleCheckerDiscards,
+	    0, "Received packets discarded in Catchup path");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_CatchupInFTQDiscards",
-		CTLFLAG_RD, &sc->stat_CatchupInFTQDiscards,
-		0, "Received packets discarded in FTQ in Catchup path");
+	    "stat_CatchupInFTQDiscards",
+	    CTLFLAG_RD, &sc->stat_CatchupInFTQDiscards,
+	    0, "Received packets discarded in FTQ in Catchup path");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_CatchupInMBUFDiscards",
-		CTLFLAG_RD, &sc->stat_CatchupInMBUFDiscards,
-		0, "Received packets discarded in controller buffer memory in Catchup path");
+	    "stat_CatchupInMBUFDiscards",
+	    CTLFLAG_RD, &sc->stat_CatchupInMBUFDiscards,
+	    0, "Received packets discarded in controller "
+	    "buffer memory in Catchup path");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"stat_CatchupInRuleCheckerP4Hit",
-		CTLFLAG_RD, &sc->stat_CatchupInRuleCheckerP4Hit,
-		0, "Received packets rule checker hits in Catchup path");
+	    "stat_CatchupInRuleCheckerP4Hit",
+	    CTLFLAG_RD, &sc->stat_CatchupInRuleCheckerP4Hit,
+	    0, "Received packets rule checker hits in Catchup path");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO,
-		"com_no_buffers",
-		CTLFLAG_RD, &sc->com_no_buffers,
-		0, "Valid packets received but no RX buffers available");
+	    "com_no_buffers",
+	    CTLFLAG_RD, &sc->com_no_buffers,
+	    0, "Valid packets received but no RX buffers available");
 
 #ifdef BCE_DEBUG
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"driver_state", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_driver_state, "I", "Drive state information");
+	    "driver_state", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_driver_state, "I", "Drive state information");
+
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
+	    "hw_state", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_hw_state, "I", "Hardware state information");
+
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
+	    "status_block", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_status_block, "I", "Status block");
+
+	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
+	    "stats_block", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_stats_block, "I", "Stats block");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"hw_state", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_hw_state, "I", "Hardware state information");
+	    "bc_state", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_bc_state, "I", "Bootcode state information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"bc_state", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_bc_state, "I", "Bootcode state information");
+	    "dump_rx_bd_chain", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_dump_rx_bd_chain, "I", "Dump RX BD chain");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"dump_rx_chain", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_dump_rx_chain, "I", "Dump rx_bd chain");
+	    "dump_rx_mbuf_chain", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_dump_rx_mbuf_chain, "I", "Dump RX MBUF chain");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"dump_tx_chain", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_dump_tx_chain, "I", "Dump tx_bd chain");
+	    "dump_tx_chain", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_dump_tx_chain, "I", "Dump tx_bd chain");
 
 #ifdef BCE_JUMBO_HDRSPLIT
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"dump_pg_chain", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_dump_pg_chain, "I", "Dump page chain");
+	    "dump_pg_chain", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_dump_pg_chain, "I", "Dump page chain");
 #endif
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"dump_ctx", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_dump_ctx, "I", "Dump context memory");
+	    "dump_ctx", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_dump_ctx, "I", "Dump context memory");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"breakpoint", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_breakpoint, "I", "Driver breakpoint");
+	    "breakpoint", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_breakpoint, "I", "Driver breakpoint");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"reg_read", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_reg_read, "I", "Register read");
+	    "reg_read", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_reg_read, "I", "Register read");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"nvram_read", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_nvram_read, "I", "NVRAM read");
+	    "nvram_read", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_nvram_read, "I", "NVRAM read");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
-		"phy_read", CTLTYPE_INT | CTLFLAG_RW,
-		(void *)sc, 0,
-		bce_sysctl_phy_read, "I", "PHY register read");
+	    "phy_read", CTLTYPE_INT | CTLFLAG_RW,
+	    (void *)sc, 0,
+	    bce_sysctl_phy_read, "I", "PHY register read");
 
 #endif
 
@@ -8741,10 +8851,10 @@ bce_dump_enet(struct bce_softc *sc, struct mbuf *m)
 	struct udphdr *uh;
 	struct arphdr *ah;
 
-		BCE_PRINTF(
-			"-----------------------------"
-			" Frame Decode "
-			"-----------------------------\n");
+	BCE_PRINTF(
+	    "-----------------------------"
+	    " Frame Decode "
+	    "-----------------------------\n");
 
 	eh = mtod(m, struct ether_vlan_header *);
 
@@ -8759,63 +8869,65 @@ bce_dump_enet(struct bce_softc *sc, struct mbuf *m)
 
 	/* ToDo: Add VLAN output. */
 	BCE_PRINTF("enet: dest = %6D, src = %6D, type = 0x%04X, hlen = %d\n",
-		eh->evl_dhost, ":", eh->evl_shost, ":", etype, ehlen);
+	    eh->evl_dhost, ":", eh->evl_shost, ":", etype, ehlen);
 
 	switch (etype) {
-		case ETHERTYPE_IP:
-			ip = (struct ip *)(m->m_data + ehlen);
-			BCE_PRINTF("--ip: dest = 0x%08X , src = 0x%08X, len = %d bytes, "
-				"protocol = 0x%02X, xsum = 0x%04X\n",
-				ntohl(ip->ip_dst.s_addr), ntohl(ip->ip_src.s_addr),
-				ntohs(ip->ip_len), ip->ip_p, ntohs(ip->ip_sum));
+	case ETHERTYPE_IP:
+		ip = (struct ip *)(m->m_data + ehlen);
+		BCE_PRINTF("--ip: dest = 0x%08X , src = 0x%08X, "
+		    "len = %d bytes, protocol = 0x%02X, xsum = 0x%04X\n",
+		    ntohl(ip->ip_dst.s_addr), ntohl(ip->ip_src.s_addr),
+		    ntohs(ip->ip_len), ip->ip_p, ntohs(ip->ip_sum));
 
-			switch (ip->ip_p) {
-				case IPPROTO_TCP:
-					th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
-					BCE_PRINTF("-tcp: dest = %d, src = %d, hlen = %d bytes, "
-						"flags = 0x%b, csum = 0x%04X\n",
-						ntohs(th->th_dport), ntohs(th->th_sport), (th->th_off << 2),
-						th->th_flags, "\20\10CWR\07ECE\06URG\05ACK\04PSH\03RST\02SYN\01FIN",
-						ntohs(th->th_sum));
-					break;
-				case IPPROTO_UDP:
-        		    uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
-					BCE_PRINTF("-udp: dest = %d, src = %d, len = %d bytes, "
-						"csum = 0x%04X\n", ntohs(uh->uh_dport), ntohs(uh->uh_sport),
-						ntohs(uh->uh_ulen), ntohs(uh->uh_sum));
-					break;
-				case IPPROTO_ICMP:
-					BCE_PRINTF("icmp:\n");
-					break;
-				default:
-					BCE_PRINTF("----: Other IP protocol.\n");
-			}
+		switch (ip->ip_p) {
+		case IPPROTO_TCP:
+			th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
+			BCE_PRINTF("-tcp: dest = %d, src = %d, hlen = %d bytes, "
+			    "flags = 0x%b, csum = 0x%04X\n",
+			    ntohs(th->th_dport), ntohs(th->th_sport), 
+			    (th->th_off << 2), th->th_flags, 
+			    "\20\10CWR\07ECE\06URG\05ACK\04PSH\03RST"
+			    "\02SYN\01FIN", ntohs(th->th_sum));
 			break;
-		case ETHERTYPE_IPV6:
-			BCE_PRINTF("ipv6: No decode supported.\n");
+		case IPPROTO_UDP:
+			uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
+			BCE_PRINTF("-udp: dest = %d, src = %d, len = %d "
+			    "bytes, csum = 0x%04X\n", ntohs(uh->uh_dport), 
+			    ntohs(uh->uh_sport), ntohs(uh->uh_ulen), 
+			    ntohs(uh->uh_sum));
 			break;
-		case ETHERTYPE_ARP:
-			BCE_PRINTF("-arp: ");
-			ah = (struct arphdr *) (m->m_data + ehlen);
-			switch (ntohs(ah->ar_op)) {
-				case ARPOP_REVREQUEST:
-					printf("reverse ARP request\n");
-					break;
-				case ARPOP_REVREPLY:
-					printf("reverse ARP reply\n");
-					break;
-				case ARPOP_REQUEST:
-					printf("ARP request\n");
-					break;
-				case ARPOP_REPLY:
-					printf("ARP reply\n");
-					break;
-				default:
-					printf("other ARP operation\n");
+		case IPPROTO_ICMP:
+			BCE_PRINTF("icmp:\n");
+			break;
+		default:
+			BCE_PRINTF("----: Other IP protocol.\n");
 			}
+		break;
+	case ETHERTYPE_IPV6:
+		BCE_PRINTF("ipv6: No decode supported.\n");
+		break;
+	case ETHERTYPE_ARP:
+		BCE_PRINTF("-arp: ");
+		ah = (struct arphdr *) (m->m_data + ehlen);
+		switch (ntohs(ah->ar_op)) {
+		case ARPOP_REVREQUEST:
+			printf("reverse ARP request\n");
+			break;
+		case ARPOP_REVREPLY:
+			printf("reverse ARP reply\n");
+			break;
+		case ARPOP_REQUEST:
+			printf("ARP request\n");
+			break;
+		case ARPOP_REPLY:
+			printf("ARP reply\n");
 			break;
 		default:
-			BCE_PRINTF("----: Other protocol.\n");
+			printf("other ARP operation\n");
+		}
+		break;
+	default:
+		BCE_PRINTF("----: Other protocol.\n");
 	}
 
 	BCE_PRINTF(
@@ -8842,37 +8954,49 @@ bce_dump_mbuf(struct bce_softc *sc, struct mbuf *m)
 	}
 
 	while (mp) {
-		BCE_PRINTF("mbuf: %p, m_len = %d, m_flags = 0x%b, m_data = %p\n",
-			mp, mp->m_len, mp->m_flags,
-			"\20\1M_EXT\2M_PKTHDR\3M_EOR\4M_RDONLY",
-			mp->m_data);
+		BCE_PRINTF("mbuf: %p, m_len = %d, m_flags = 0x%b, "
+		    "m_data = %p\n", mp, mp->m_len, mp->m_flags,
+		    "\20\1M_EXT\2M_PKTHDR\3M_EOR\4M_RDONLY", mp->m_data);
 
 		if (mp->m_flags & M_PKTHDR) {
-			BCE_PRINTF("- m_pkthdr: len = %d, flags = 0x%b, csum_flags = %b\n",
-				mp->m_pkthdr.len, mp->m_flags,
-				"\20\12M_BCAST\13M_MCAST\14M_FRAG\15M_FIRSTFRAG"
-				"\16M_LASTFRAG\21M_VLANTAG\22M_PROMISC\23M_NOFREE",
-				mp->m_pkthdr.csum_flags,
-				"\20\1CSUM_IP\2CSUM_TCP\3CSUM_UDP\4CSUM_IP_FRAGS"
-				"\5CSUM_FRAGMENT\6CSUM_TSO\11CSUM_IP_CHECKED"
-				"\12CSUM_IP_VALID\13CSUM_DATA_VALID\14CSUM_PSEUDO_HDR");
+			BCE_PRINTF("- m_pkthdr: len = %d, flags = 0x%b, "
+			    "csum_flags = %b\n", mp->m_pkthdr.len, 
+			    mp->m_flags, "\20\12M_BCAST\13M_MCAST\14M_FRAG"
+			    "\15M_FIRSTFRAG\16M_LASTFRAG\21M_VLANTAG"
+			    "\22M_PROMISC\23M_NOFREE", 
+			    mp->m_pkthdr.csum_flags,
+			    "\20\1CSUM_IP\2CSUM_TCP\3CSUM_UDP\4CSUM_IP_FRAGS"
+			    "\5CSUM_FRAGMENT\6CSUM_TSO\11CSUM_IP_CHECKED"
+			    "\12CSUM_IP_VALID\13CSUM_DATA_VALID"
+			    "\14CSUM_PSEUDO_HDR");
 		}
 
 		if (mp->m_flags & M_EXT) {
 			BCE_PRINTF("- m_ext: %p, ext_size = %d, type = ",
-				mp->m_ext.ext_buf, mp->m_ext.ext_size);
+			    mp->m_ext.ext_buf, mp->m_ext.ext_size);
 			switch (mp->m_ext.ext_type) {
-				case EXT_CLUSTER:    printf("EXT_CLUSTER\n"); break;
-				case EXT_SFBUF:      printf("EXT_SFBUF\n"); break;
-				case EXT_JUMBO9:     printf("EXT_JUMBO9\n"); break;
-				case EXT_JUMBO16:    printf("EXT_JUMBO16\n"); break;
-				case EXT_PACKET:     printf("EXT_PACKET\n"); break;
-				case EXT_MBUF:       printf("EXT_MBUF\n"); break;
-				case EXT_NET_DRV:    printf("EXT_NET_DRV\n"); break;
-				case EXT_MOD_TYPE:   printf("EXT_MDD_TYPE\n"); break;
-				case EXT_DISPOSABLE: printf("EXT_DISPOSABLE\n"); break;
-				case EXT_EXTREF:     printf("EXT_EXTREF\n"); break;
-				default:             printf("UNKNOWN\n");
+			case EXT_CLUSTER:
+				printf("EXT_CLUSTER\n"); break;
+			case EXT_SFBUF:
+				printf("EXT_SFBUF\n"); break;
+			case EXT_JUMBO9:
+				printf("EXT_JUMBO9\n"); break;
+			case EXT_JUMBO16:
+				printf("EXT_JUMBO16\n"); break;
+			case EXT_PACKET:
+				printf("EXT_PACKET\n"); break;
+			case EXT_MBUF:
+				printf("EXT_MBUF\n"); break;
+			case EXT_NET_DRV:
+				printf("EXT_NET_DRV\n"); break;
+			case EXT_MOD_TYPE:
+				printf("EXT_MDD_TYPE\n"); break;
+			case EXT_DISPOSABLE:
+				printf("EXT_DISPOSABLE\n"); break;
+			case EXT_EXTREF:
+				printf("EXT_EXTREF\n"); break;
+			default:             
+				printf("UNKNOWN\n");
 			}
 		}
 
@@ -8984,75 +9108,109 @@ bce_dump_pg_mbuf_chain(struct bce_softc *sc, u16 chain_prod, int count)
 static __attribute__ ((noinline)) void
 bce_dump_txbd(struct bce_softc *sc, int idx, struct tx_bd *txbd)
 {
-    int i = 0;
+	int i = 0;
 
-    if (idx > MAX_TX_BD)
+	if (idx > MAX_TX_BD)
 		/* Index out of range. */
 		BCE_PRINTF("tx_bd[0x%04X]: Invalid tx_bd index!\n", idx);
 	else if ((idx & USABLE_TX_BD_PER_PAGE) == USABLE_TX_BD_PER_PAGE)
 		/* TX Chain page pointer. */
-		BCE_PRINTF("tx_bd[0x%04X]: haddr = 0x%08X:%08X, chain page pointer\n",
-			idx, txbd->tx_bd_haddr_hi, txbd->tx_bd_haddr_lo);
+		BCE_PRINTF("tx_bd[0x%04X]: haddr = 0x%08X:%08X, chain page "
+		    "pointer\n", idx, txbd->tx_bd_haddr_hi, 
+		    txbd->tx_bd_haddr_lo);
 	else {
 		/* Normal tx_bd entry. */
-		BCE_PRINTF("tx_bd[0x%04X]: haddr = 0x%08X:%08X, mss_nbytes = 0x%08X, "
-			"vlan tag = 0x%04X, flags = 0x%04X (", idx,
-			txbd->tx_bd_haddr_hi, txbd->tx_bd_haddr_lo,
-			txbd->tx_bd_mss_nbytes, txbd->tx_bd_vlan_tag,
-			txbd->tx_bd_flags);
+		BCE_PRINTF("tx_bd[0x%04X]: haddr = 0x%08X:%08X, "
+		    "mss_nbytes = 0x%08X, vlan tag = 0x%04X, flags = "
+		    "0x%04X (", idx, txbd->tx_bd_haddr_hi, 
+		    txbd->tx_bd_haddr_lo, txbd->tx_bd_mss_nbytes, 
+		    txbd->tx_bd_vlan_tag, txbd->tx_bd_flags);
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_CONN_FAULT) {
-			if (i>0) printf("|"); printf("CONN_FAULT"); i++;
-        }
+			if (i>0) 
+				printf("|"); 
+			printf("CONN_FAULT"); 
+			i++;
+		}
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_TCP_UDP_CKSUM) {
-            if (i>0) printf("|"); printf("TCP_UDP_CKSUM"); i++;
-        }
+			if (i>0) 
+				printf("|"); 
+			printf("TCP_UDP_CKSUM"); 
+			i++;
+		}
 
-        if (txbd->tx_bd_flags & TX_BD_FLAGS_IP_CKSUM) {
-            if (i>0) printf("|"); printf("IP_CKSUM"); i++;
-        }
+		if (txbd->tx_bd_flags & TX_BD_FLAGS_IP_CKSUM) {
+			if (i>0) 
+				printf("|"); 
+			printf("IP_CKSUM"); 
+			i++;
+		}
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_VLAN_TAG) {
-            if (i>0) printf("|"); printf("VLAN"); i++;
-        }
+			if (i>0) 
+				printf("|"); 
+			printf("VLAN"); 
+			i++;
+		}
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_COAL_NOW) {
-            if (i>0) printf("|"); printf("COAL_NOW"); i++;
-        }
+			if (i>0) 
+				printf("|"); 
+			printf("COAL_NOW"); 
+			i++;
+		}
 
-        if (txbd->tx_bd_flags & TX_BD_FLAGS_DONT_GEN_CRC) {
-            if (i>0) printf("|"); printf("DONT_GEN_CRC"); i++;
-        }
+		if (txbd->tx_bd_flags & TX_BD_FLAGS_DONT_GEN_CRC) {
+			if (i>0) 
+				printf("|"); 
+			printf("DONT_GEN_CRC"); 
+			i++;
+		}
 
-        if (txbd->tx_bd_flags & TX_BD_FLAGS_START) {
-            if (i>0) printf("|"); printf("START"); i++;
-        }
+		if (txbd->tx_bd_flags & TX_BD_FLAGS_START) {
+			if (i>0) 
+				printf("|"); 
+			printf("START"); 
+			i++;
+		}
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_END) {
-            if (i>0) printf("|"); printf("END"); i++;
-        }
+			if (i>0) 
+				printf("|"); 
+			printf("END"); 
+			i++;
+		}
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_SW_LSO) {
-            if (i>0) printf("|"); printf("LSO"); i++;
-        }
+			if (i>0) 
+				printf("|"); 
+			printf("LSO"); 
+			i++;
+		}
 
-        if (txbd->tx_bd_flags & TX_BD_FLAGS_SW_OPTION_WORD) {
-            if (i>0) printf("|"); 
-            printf("SW_OPTION=%d", ((txbd->tx_bd_flags & 
-                TX_BD_FLAGS_SW_OPTION_WORD) >> 8)); i++;
-        }
+		if (txbd->tx_bd_flags & TX_BD_FLAGS_SW_OPTION_WORD) {
+			if (i>0) 
+				printf("|"); 
+			printf("SW_OPTION=%d", ((txbd->tx_bd_flags & 
+			    TX_BD_FLAGS_SW_OPTION_WORD) >> 8)); i++;
+		}
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_SW_FLAGS) {
-            if (i>0) printf("|"); printf("SW_FLAGS"); i++;
-        }
+			if (i>0) 
+				printf("|"); 
+			printf("SW_FLAGS"); 
+			i++;
+		}
 
 		if (txbd->tx_bd_flags & TX_BD_FLAGS_SW_SNAP) {
-            if (i>0) printf("|"); printf("SNAP)");
-        } else {
-            printf(")\n");
-        }
-    }
+			if (i>0) 
+				printf("|"); 
+			printf("SNAP)");
+		} else {
+			printf(")\n");
+		}
+	}
 }
 
 
@@ -9070,14 +9228,15 @@ bce_dump_rxbd(struct bce_softc *sc, int idx, struct rx_bd *rxbd)
 		BCE_PRINTF("rx_bd[0x%04X]: Invalid rx_bd index!\n", idx);
 	else if ((idx & USABLE_RX_BD_PER_PAGE) == USABLE_RX_BD_PER_PAGE)
 		/* RX Chain page pointer. */
-		BCE_PRINTF("rx_bd[0x%04X]: haddr = 0x%08X:%08X, chain page pointer\n",
-			idx, rxbd->rx_bd_haddr_hi, rxbd->rx_bd_haddr_lo);
+		BCE_PRINTF("rx_bd[0x%04X]: haddr = 0x%08X:%08X, chain page "
+		    "pointer\n", idx, rxbd->rx_bd_haddr_hi, 
+		    rxbd->rx_bd_haddr_lo);
 	else
 		/* Normal rx_bd entry. */
-		BCE_PRINTF("rx_bd[0x%04X]: haddr = 0x%08X:%08X, nbytes = 0x%08X, "
-			"flags = 0x%08X\n", idx,
-			rxbd->rx_bd_haddr_hi, rxbd->rx_bd_haddr_lo,
-			rxbd->rx_bd_len, rxbd->rx_bd_flags);
+		BCE_PRINTF("rx_bd[0x%04X]: haddr = 0x%08X:%08X, nbytes = "
+		    "0x%08X, flags = 0x%08X\n", idx, rxbd->rx_bd_haddr_hi, 
+		    rxbd->rx_bd_haddr_lo, rxbd->rx_bd_len, 
+		    rxbd->rx_bd_flags);
 }
 
 
@@ -9135,104 +9294,117 @@ bce_dump_l2fhdr(struct bce_softc *sc, int idx, struct l2_fhdr *l2fhdr)
 static __attribute__ ((noinline)) void
 bce_dump_ctx(struct bce_softc *sc, u16 cid)
 {
-	if (cid <= TX_CID) {
-		BCE_PRINTF(
-			"----------------------------"
-			"    CTX Data    "
-			"----------------------------\n");
-
-		BCE_PRINTF("     0x%04X - (CID) Context ID\n", cid);
+	if (cid > TX_CID) {
+		BCE_PRINTF(" Unknown CID\n");
+		return;
+	}
 
-		if (cid == RX_CID) {
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_HOST_BDIDX) host rx "
-				"producer index\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_HOST_BDIDX));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_HOST_BSEQ) host byte sequence\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_HOST_BSEQ));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BSEQ) h/w byte sequence\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_BSEQ));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BDHADDR_HI) h/w buffer "
-				"descriptor address\n",
- 				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_BDHADDR_HI));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BDHADDR_LO) h/w buffer "
-				"descriptor address\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_BDHADDR_LO));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BDIDX) h/w rx consumer index\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_BDIDX));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_HOST_PG_BDIDX) host page "
-				"producer index\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_HOST_PG_BDIDX));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_PG_BUF_SIZE) host rx_bd/page "
-				"buffer size\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_PG_BUF_SIZE));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_PG_BDHADDR_HI) h/w page "
-				"chain address\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_PG_BDHADDR_HI));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_PG_BDHADDR_LO) h/w page "
-				"chain address\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_PG_BDHADDR_LO));
-			BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_PG_BDIDX) h/w page "
-				"consumer index\n",
-				CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_PG_BDIDX));
-		} else if (cid == TX_CID) {
-			if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
-				(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_TYPE_XI) ctx type\n",
-					CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_TX_TYPE_XI));
-				BCE_PRINTF(" 0x%08X - (L2CTX_CMD_TX_TYPE_XI) ctx cmd\n",
-					CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_TX_CMD_TYPE_XI));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BDHADDR_HI_XI) h/w buffer "
-					"descriptor address\n",	CTX_RD(sc,
-					GET_CID_ADDR(cid), BCE_L2CTX_TX_TBDR_BHADDR_HI_XI));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BHADDR_LO_XI) h/w buffer "
-					"descriptor address\n", CTX_RD(sc,
-					GET_CID_ADDR(cid), BCE_L2CTX_TX_TBDR_BHADDR_LO_XI));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BIDX_XI) host producer "
-					"index\n", CTX_RD(sc, GET_CID_ADDR(cid),
-					BCE_L2CTX_TX_HOST_BIDX_XI));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BSEQ_XI) host byte "
-					"sequence\n", CTX_RD(sc, GET_CID_ADDR(cid),
-					BCE_L2CTX_TX_HOST_BSEQ_XI));
-			} else {
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_TYPE) ctx type\n",
-					CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_TX_TYPE));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_CMD_TYPE) ctx cmd\n",
-					CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_TX_CMD_TYPE));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BDHADDR_HI) h/w buffer "
-					"descriptor address\n", CTX_RD(sc, GET_CID_ADDR(cid),
-					BCE_L2CTX_TX_TBDR_BHADDR_HI));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BHADDR_LO) h/w buffer "
-					"descriptor address\n", CTX_RD(sc, GET_CID_ADDR(cid),
-					BCE_L2CTX_TX_TBDR_BHADDR_LO));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BIDX) host producer "
-					"index\n", CTX_RD(sc, GET_CID_ADDR(cid),
-					BCE_L2CTX_TX_HOST_BIDX));
-				BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BSEQ) host byte "
-					"sequence\n", CTX_RD(sc, GET_CID_ADDR(cid),
-					BCE_L2CTX_TX_HOST_BSEQ));
-			}
-		} else
-			BCE_PRINTF(" Unknown CID\n");
+	BCE_PRINTF(
+	    "----------------------------"
+	    "    CTX Data    "
+	    "----------------------------\n");
 
-		BCE_PRINTF(
-			"----------------------------"
-			"    Raw CTX     "
-			"----------------------------\n");
+	BCE_PRINTF("     0x%04X - (CID) Context ID\n", cid);
 
-		for (int i = 0x0; i < 0x300; i += 0x10) {
-			BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n", i,
-				CTX_RD(sc, GET_CID_ADDR(cid), i),
-				CTX_RD(sc, GET_CID_ADDR(cid), i + 0x4),
-				CTX_RD(sc, GET_CID_ADDR(cid), i + 0x8),
-				CTX_RD(sc, GET_CID_ADDR(cid), i + 0xc));
+	if (cid == RX_CID) {
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_HOST_BDIDX) host rx "
+		   "producer index\n",
+		    CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_HOST_BDIDX));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_HOST_BSEQ) host "
+		    "byte sequence\n", CTX_RD(sc, GET_CID_ADDR(cid),
+		    BCE_L2CTX_RX_HOST_BSEQ));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BSEQ) h/w byte sequence\n",
+		    CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_BSEQ));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BDHADDR_HI) h/w buffer "
+		    "descriptor address\n",
+ 		    CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_BDHADDR_HI));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BDHADDR_LO) h/w buffer "
+		    "descriptor address\n",
+		    CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_RX_NX_BDHADDR_LO));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_BDIDX) h/w rx consumer "
+		    "index\n", CTX_RD(sc, GET_CID_ADDR(cid),
+		    BCE_L2CTX_RX_NX_BDIDX));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_HOST_PG_BDIDX) host page "
+		    "producer index\n", CTX_RD(sc, GET_CID_ADDR(cid), 
+		    BCE_L2CTX_RX_HOST_PG_BDIDX));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_PG_BUF_SIZE) host rx_bd/page "
+		    "buffer size\n", CTX_RD(sc, GET_CID_ADDR(cid), 
+		    BCE_L2CTX_RX_PG_BUF_SIZE));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_PG_BDHADDR_HI) h/w page "
+		    "chain address\n", CTX_RD(sc, GET_CID_ADDR(cid), 
+		    BCE_L2CTX_RX_NX_PG_BDHADDR_HI));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_PG_BDHADDR_LO) h/w page "
+		    "chain address\n", CTX_RD(sc, GET_CID_ADDR(cid), 
+		    BCE_L2CTX_RX_NX_PG_BDHADDR_LO));
+		BCE_PRINTF(" 0x%08X - (L2CTX_RX_NX_PG_BDIDX) h/w page "
+		    "consumer index\n",	CTX_RD(sc, GET_CID_ADDR(cid), 
+		    BCE_L2CTX_RX_NX_PG_BDIDX));
+	} else if (cid == TX_CID) {
+		if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
+		    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_TYPE_XI) ctx type\n",
+			    CTX_RD(sc, GET_CID_ADDR(cid), 
+			    BCE_L2CTX_TX_TYPE_XI));
+			BCE_PRINTF(" 0x%08X - (L2CTX_CMD_TX_TYPE_XI) ctx "
+			    "cmd\n", CTX_RD(sc, GET_CID_ADDR(cid), 
+			    BCE_L2CTX_TX_CMD_TYPE_XI));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BDHADDR_HI_XI) "
+			    "h/w buffer descriptor address\n",	
+			    CTX_RD(sc, GET_CID_ADDR(cid), 
+			    BCE_L2CTX_TX_TBDR_BHADDR_HI_XI));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BHADDR_LO_XI) "
+			    "h/w buffer	descriptor address\n", 
+			    CTX_RD(sc, GET_CID_ADDR(cid),
+			    BCE_L2CTX_TX_TBDR_BHADDR_LO_XI));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BIDX_XI) "
+			    "host producer index\n", 
+			    CTX_RD(sc, GET_CID_ADDR(cid),
+			    BCE_L2CTX_TX_HOST_BIDX_XI));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BSEQ_XI) "
+			    "host byte sequence\n", 
+			    CTX_RD(sc, GET_CID_ADDR(cid),
+			    BCE_L2CTX_TX_HOST_BSEQ_XI));
+		} else {
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_TYPE) ctx type\n",
+			    CTX_RD(sc, GET_CID_ADDR(cid), BCE_L2CTX_TX_TYPE));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_CMD_TYPE) ctx cmd\n",
+			    CTX_RD(sc, GET_CID_ADDR(cid), 
+			    BCE_L2CTX_TX_CMD_TYPE));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BDHADDR_HI) "
+			    "h/w buffer	descriptor address\n", 
+			    CTX_RD(sc, GET_CID_ADDR(cid),
+			    BCE_L2CTX_TX_TBDR_BHADDR_HI));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_TBDR_BHADDR_LO) "
+			    "h/w buffer	descriptor address\n", 
+			    CTX_RD(sc, GET_CID_ADDR(cid),
+			    BCE_L2CTX_TX_TBDR_BHADDR_LO));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BIDX) host "
+			    "producer index\n", CTX_RD(sc, GET_CID_ADDR(cid),
+			    BCE_L2CTX_TX_HOST_BIDX));
+			BCE_PRINTF(" 0x%08X - (L2CTX_TX_HOST_BSEQ) host byte "
+			    "sequence\n", CTX_RD(sc, GET_CID_ADDR(cid),
+			    BCE_L2CTX_TX_HOST_BSEQ));
 		}
+	}
 
+	BCE_PRINTF(
+	   "----------------------------"
+	   "    Raw CTX     "
+	   "----------------------------\n");
 
-		BCE_PRINTF(
-			"----------------------------"
-			"----------------"
-			"----------------------------\n");
+	for (int i = 0x0; i < 0x300; i += 0x10) {
+		BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n", i,
+		   CTX_RD(sc, GET_CID_ADDR(cid), i),
+		   CTX_RD(sc, GET_CID_ADDR(cid), i + 0x4),
+		   CTX_RD(sc, GET_CID_ADDR(cid), i + 0x8),
+		   CTX_RD(sc, GET_CID_ADDR(cid), i + 0xc));
 	}
+
+
+	BCE_PRINTF(
+	   "----------------------------"
+	   "----------------"
+	   "----------------------------\n");
 }
 
 
@@ -9248,36 +9420,38 @@ bce_dump_ftqs(struct bce_softc *sc)
 	u32 cmd, ctl, cur_depth, max_depth, valid_cnt, val;
 
 	BCE_PRINTF(
-		"----------------------------"
-		"    FTQ Data    "
-		"----------------------------\n");
+	    "----------------------------"
+	    "    FTQ Data    "
+	    "----------------------------\n");
 
-	BCE_PRINTF("   FTQ    Command    Control   Depth_Now  Max_Depth  Valid_Cnt \n");
-	BCE_PRINTF(" ------- ---------- ---------- ---------- ---------- ----------\n");
+	BCE_PRINTF("   FTQ    Command    Control   Depth_Now  "
+	    "Max_Depth  Valid_Cnt \n");
+	BCE_PRINTF(" ------- ---------- ---------- ---------- "
+	    "---------- ----------\n");
 
 	/* Setup the generic statistic counters for the FTQ valid count. */
 	val = (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RV2PPQ_VALID_CNT << 24) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RXPCQ_VALID_CNT  << 16) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RXPQ_VALID_CNT   <<  8) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RLUPQ_VALID_CNT);
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RXPCQ_VALID_CNT  << 16) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RXPQ_VALID_CNT   <<  8) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RLUPQ_VALID_CNT);
 	REG_WR(sc, BCE_HC_STAT_GEN_SEL_0, val);
 
 	val = (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TSCHQ_VALID_CNT  << 24) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RDMAQ_VALID_CNT  << 16) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RV2PTQ_VALID_CNT <<  8) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RV2PMQ_VALID_CNT);
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RDMAQ_VALID_CNT  << 16) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RV2PTQ_VALID_CNT <<  8) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RV2PMQ_VALID_CNT);
 	REG_WR(sc, BCE_HC_STAT_GEN_SEL_1, val);
 
 	val = (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TPATQ_VALID_CNT  << 24) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TDMAQ_VALID_CNT  << 16) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TXPQ_VALID_CNT   <<  8) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TBDRQ_VALID_CNT);
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TDMAQ_VALID_CNT  << 16) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TXPQ_VALID_CNT   <<  8) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TBDRQ_VALID_CNT);
 	REG_WR(sc, BCE_HC_STAT_GEN_SEL_2, val);
 
 	val = (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_COMQ_VALID_CNT   << 24) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_COMTQ_VALID_CNT  << 16) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_COMXQ_VALID_CNT  <<  8) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TASQ_VALID_CNT);
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_COMTQ_VALID_CNT  << 16) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_COMXQ_VALID_CNT  <<  8) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_TASQ_VALID_CNT);
 	REG_WR(sc, BCE_HC_STAT_GEN_SEL_3, val);
 
 	/* Input queue to the Receive Lookup state machine */
@@ -9287,7 +9461,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_RLUP_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT0);
 	BCE_PRINTF(" RLUP    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Receive Processor */
 	cmd = REG_RD_IND(sc, BCE_RXP_FTQ_CMD);
@@ -9296,7 +9470,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_RXP_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT1);
 	BCE_PRINTF(" RXP     0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Recevie Processor */
 	cmd = REG_RD_IND(sc, BCE_RXP_CFTQ_CMD);
@@ -9305,7 +9479,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_RXP_CFTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT2);
 	BCE_PRINTF(" RXPC    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Receive Virtual to Physical state machine */
 	cmd = REG_RD(sc, BCE_RV2P_PFTQ_CMD);
@@ -9314,7 +9488,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_RV2P_PFTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT3);
 	BCE_PRINTF(" RV2PP   0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Recevie Virtual to Physical state machine */
 	cmd = REG_RD(sc, BCE_RV2P_MFTQ_CMD);
@@ -9323,7 +9497,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_RV2P_MFTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT4);
 	BCE_PRINTF(" RV2PM   0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Receive Virtual to Physical state machine */
 	cmd = REG_RD(sc, BCE_RV2P_TFTQ_CMD);
@@ -9332,7 +9506,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_RV2P_TFTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT5);
 	BCE_PRINTF(" RV2PT   0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Receive DMA state machine */
 	cmd = REG_RD(sc, BCE_RDMA_FTQ_CMD);
@@ -9341,7 +9515,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_RDMA_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT6);
 	BCE_PRINTF(" RDMA    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Transmit Scheduler state machine */
 	cmd = REG_RD(sc, BCE_TSCH_FTQ_CMD);
@@ -9350,7 +9524,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_TSCH_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT7);
 	BCE_PRINTF(" TSCH    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Transmit Buffer Descriptor state machine */
 	cmd = REG_RD(sc, BCE_TBDR_FTQ_CMD);
@@ -9359,7 +9533,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_TBDR_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT8);
 	BCE_PRINTF(" TBDR    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Transmit Processor */
 	cmd = REG_RD_IND(sc, BCE_TXP_FTQ_CMD);
@@ -9368,7 +9542,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_TXP_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT9);
 	BCE_PRINTF(" TXP     0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Transmit DMA state machine */
 	cmd = REG_RD(sc, BCE_TDMA_FTQ_CMD);
@@ -9377,7 +9551,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_TDMA_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT10);
 	BCE_PRINTF(" TDMA    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Transmit Patch-Up Processor */
 	cmd = REG_RD_IND(sc, BCE_TPAT_FTQ_CMD);
@@ -9386,7 +9560,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_TPAT_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT11);
 	BCE_PRINTF(" TPAT    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Transmit Assembler state machine */
 	cmd = REG_RD_IND(sc, BCE_TAS_FTQ_CMD);
@@ -9395,7 +9569,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_TAS_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT12);
 	BCE_PRINTF(" TAS     0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Completion Processor */
 	cmd = REG_RD_IND(sc, BCE_COM_COMXQ_FTQ_CMD);
@@ -9404,7 +9578,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_COM_COMXQ_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT13);
 	BCE_PRINTF(" COMX    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Completion Processor */
 	cmd = REG_RD_IND(sc, BCE_COM_COMTQ_FTQ_CMD);
@@ -9413,7 +9587,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_COM_COMTQ_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT14);
 	BCE_PRINTF(" COMT    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Completion Processor */
 	cmd = REG_RD_IND(sc, BCE_COM_COMQ_FTQ_CMD);
@@ -9422,17 +9596,19 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_COM_COMQ_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT15);
 	BCE_PRINTF(" COMX    0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Setup the generic statistic counters for the FTQ valid count. */
 	val = (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_CSQ_VALID_CNT  << 16) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_CPQ_VALID_CNT  <<  8) |
-		(BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_MGMQ_VALID_CNT);
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_CPQ_VALID_CNT  <<  8) |
+	    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_MGMQ_VALID_CNT);
 
-	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709)	||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716))
-		val = val | (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RV2PCSQ_VALID_CNT_XI << 24);
-		REG_WR(sc, BCE_HC_STAT_GEN_SEL_0, val);
+	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716))
+		val = val | 
+		    (BCE_HC_STAT_GEN_SEL_0_GEN_SEL_0_RV2PCSQ_VALID_CNT_XI << 
+		     24);
+	REG_WR(sc, BCE_HC_STAT_GEN_SEL_0, val);
 
 	/* Input queue to the Management Control Processor */
 	cmd = REG_RD_IND(sc, BCE_MCP_MCPQ_FTQ_CMD);
@@ -9441,7 +9617,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_MCP_MCPQ_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT0);
 	BCE_PRINTF(" MCP     0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Command Processor */
 	cmd = REG_RD_IND(sc, BCE_CP_CPQ_FTQ_CMD);
@@ -9450,7 +9626,7 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_CP_CPQ_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT1);
 	BCE_PRINTF(" CP      0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	/* Input queue to the Completion Scheduler state machine */
 	cmd = REG_RD(sc, BCE_CSCH_CH_FTQ_CMD);
@@ -9459,24 +9635,24 @@ bce_dump_ftqs(struct bce_softc *sc)
 	max_depth = (ctl & BCE_CSCH_CH_FTQ_CTL_MAX_DEPTH) >> 12;
 	valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT2);
 	BCE_PRINTF(" CS      0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-		cmd, ctl, cur_depth, max_depth, valid_cnt);
+	    cmd, ctl, cur_depth, max_depth, valid_cnt);
 
 	if ((BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5709) ||
-		(BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
-		/* Input queue to the Receive Virtual to Physical Command Scheduler */
+	    (BCE_CHIP_NUM(sc) == BCE_CHIP_NUM_5716)) {
+		/* Input queue to the RV2P Command Scheduler */
 		cmd = REG_RD(sc, BCE_RV2PCSR_FTQ_CMD);
 		ctl = REG_RD(sc, BCE_RV2PCSR_FTQ_CTL);
 		cur_depth = (ctl & 0xFFC00000) >> 22;
 		max_depth = (ctl & 0x003FF000) >> 12;
 		valid_cnt = REG_RD(sc, BCE_HC_STAT_GEN_STAT3);
 		BCE_PRINTF(" RV2PCSR 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\n",
-			cmd, ctl, cur_depth, max_depth, valid_cnt);
+		    cmd, ctl, cur_depth, max_depth, valid_cnt);
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -9493,20 +9669,20 @@ bce_dump_tx_chain(struct bce_softc *sc, u16 tx_prod, int count)
 
 	/* First some info about the tx_bd chain structure. */
 	BCE_PRINTF(
-		"----------------------------"
-		"  tx_bd  chain  "
-		"----------------------------\n");
+	    "----------------------------"
+	    "  tx_bd  chain  "
+	    "----------------------------\n");
 
 	BCE_PRINTF("page size      = 0x%08X, tx chain pages        = 0x%08X\n",
-		(u32) BCM_PAGE_SIZE, (u32) TX_PAGES);
+	    (u32) BCM_PAGE_SIZE, (u32) TX_PAGES);
 	BCE_PRINTF("tx_bd per page = 0x%08X, usable tx_bd per page = 0x%08X\n",
-		(u32) TOTAL_TX_BD_PER_PAGE, (u32) USABLE_TX_BD_PER_PAGE);
+	    (u32) TOTAL_TX_BD_PER_PAGE, (u32) USABLE_TX_BD_PER_PAGE);
 	BCE_PRINTF("total tx_bd    = 0x%08X\n", (u32) TOTAL_TX_BD);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   tx_bd data   "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   tx_bd data   "
+	    "----------------------------\n");
 
 	/* Now print out a decoded list of TX buffer descriptors. */
 	for (int i = 0; i < count; i++) {
@@ -9516,9 +9692,9 @@ bce_dump_tx_chain(struct bce_softc *sc, u16 tx_prod, int count)
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -9529,28 +9705,28 @@ bce_dump_tx_chain(struct bce_softc *sc, u16 tx_prod, int count)
 /*   Nothing.                                                               */
 /****************************************************************************/
 static __attribute__ ((noinline)) void
-bce_dump_rx_chain(struct bce_softc *sc, u16 rx_prod, int count)
+bce_dump_rx_bd_chain(struct bce_softc *sc, u16 rx_prod, int count)
 {
 	struct rx_bd *rxbd;
 
 	/* First some info about the rx_bd chain structure. */
 	BCE_PRINTF(
-		"----------------------------"
-		"  rx_bd  chain  "
-		"----------------------------\n");
+	    "----------------------------"
+	    "  rx_bd  chain  "
+	    "----------------------------\n");
 
 	BCE_PRINTF("page size      = 0x%08X, rx chain pages        = 0x%08X\n",
-		(u32) BCM_PAGE_SIZE, (u32) RX_PAGES);
+	    (u32) BCM_PAGE_SIZE, (u32) RX_PAGES);
 
 	BCE_PRINTF("rx_bd per page = 0x%08X, usable rx_bd per page = 0x%08X\n",
-		(u32) TOTAL_RX_BD_PER_PAGE, (u32) USABLE_RX_BD_PER_PAGE);
+	    (u32) TOTAL_RX_BD_PER_PAGE, (u32) USABLE_RX_BD_PER_PAGE);
 
 	BCE_PRINTF("total rx_bd    = 0x%08X\n", (u32) TOTAL_RX_BD);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   rx_bd data   "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   rx_bd data   "
+	    "----------------------------\n");
 
 	/* Now print out the rx_bd's themselves. */
 	for (int i = 0; i < count; i++) {
@@ -9560,9 +9736,9 @@ bce_dump_rx_chain(struct bce_softc *sc, u16 rx_prod, int count)
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -9580,23 +9756,23 @@ bce_dump_pg_chain(struct bce_softc *sc, u16 pg_prod, int count)
 
 	/* First some info about the page chain structure. */
 	BCE_PRINTF(
-		"----------------------------"
-		"   page chain   "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   page chain   "
+	    "----------------------------\n");
 
 	BCE_PRINTF("page size      = 0x%08X, pg chain pages        = 0x%08X\n",
-		(u32) BCM_PAGE_SIZE, (u32) PG_PAGES);
+	    (u32) BCM_PAGE_SIZE, (u32) PG_PAGES);
 
 	BCE_PRINTF("rx_bd per page = 0x%08X, usable rx_bd per page = 0x%08X\n",
-		(u32) TOTAL_PG_BD_PER_PAGE, (u32) USABLE_PG_BD_PER_PAGE);
+	    (u32) TOTAL_PG_BD_PER_PAGE, (u32) USABLE_PG_BD_PER_PAGE);
 
 	BCE_PRINTF("total rx_bd    = 0x%08X, max_pg_bd             = 0x%08X\n",
-		(u32) TOTAL_PG_BD, (u32) MAX_PG_BD);
+	    (u32) TOTAL_PG_BD, (u32) MAX_PG_BD);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   page data    "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   page data    "
+	    "----------------------------\n");
 
 	/* Now print out the rx_bd's themselves. */
 	for (int i = 0; i < count; i++) {
@@ -9606,23 +9782,27 @@ bce_dump_pg_chain(struct bce_softc *sc, u16 pg_prod, int count)
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 #endif
 
-#define BCE_PRINT_RX_CONS(arg)                                          \
-if (sblk->status_rx_quick_consumer_index##arg)                          \
-    BCE_PRINTF("0x%04X(0x%04X) - rx_quick_consumer_index##arg\n",       \
-		sblk->status_rx_quick_consumer_index##arg,                      \
-		(u16) RX_CHAIN_IDX(sblk->status_rx_quick_consumer_index##arg));
 
-#define BCE_PRINT_TX_CONS(arg)                                          \
-if (sblk->status_tx_quick_consumer_index##arg)                          \
-    BCE_PRINTF("0x%04X(0x%04X) - tx_quick_consumer_index##arg\n",       \
-        sblk->status_tx_quick_consumer_index##arg,                      \
-        (u16) TX_CHAIN_IDX(sblk->status_tx_quick_consumer_index##arg));
+#define BCE_PRINT_RX_CONS(arg)						\
+if (sblk->status_rx_quick_consumer_index##arg)				\
+	BCE_PRINTF("0x%04X(0x%04X) - rx_quick_consumer_index%d\n",	\
+	    sblk->status_rx_quick_consumer_index##arg, (u16)		\
+	    RX_CHAIN_IDX(sblk->status_rx_quick_consumer_index##arg),	\
+	    arg);
+
+
+#define BCE_PRINT_TX_CONS(arg)						\
+if (sblk->status_tx_quick_consumer_index##arg)				\
+	BCE_PRINTF("0x%04X(0x%04X) - tx_quick_consumer_index%d\n",	\
+	    sblk->status_tx_quick_consumer_index##arg, (u16)		\
+	    TX_CHAIN_IDX(sblk->status_tx_quick_consumer_index##arg),	\
+	    arg);
 
 /****************************************************************************/
 /* Prints out the status block from host memory.                            */
@@ -9637,52 +9817,54 @@ bce_dump_status_block(struct bce_softc *sc)
 
 	sblk = sc->status_block;
 
-   	BCE_PRINTF(
-		"----------------------------"
-		"  Status Block  "
-		"----------------------------\n");
+	BCE_PRINTF(
+	    "----------------------------"
+	    "  Status Block  "
+	    "----------------------------\n");
 
-    /* Theses indices are used for normal L2 drivers. */
+	/* Theses indices are used for normal L2 drivers. */
 	BCE_PRINTF("    0x%08X - attn_bits\n",
-		sblk->status_attn_bits);
+	    sblk->status_attn_bits);
 
 	BCE_PRINTF("    0x%08X - attn_bits_ack\n",
-		sblk->status_attn_bits_ack);
+	    sblk->status_attn_bits_ack);
 
-    BCE_PRINT_RX_CONS(0);
-    BCE_PRINT_TX_CONS(0)
+	BCE_PRINT_RX_CONS(0);
+	BCE_PRINT_TX_CONS(0)
 
 	BCE_PRINTF("        0x%04X - status_idx\n", sblk->status_idx);
 
 	/* Theses indices are not used for normal L2 drivers. */
-    BCE_PRINT_RX_CONS(1);   BCE_PRINT_RX_CONS(2);   BCE_PRINT_RX_CONS(3);
-    BCE_PRINT_RX_CONS(4);   BCE_PRINT_RX_CONS(5);   BCE_PRINT_RX_CONS(6);
-    BCE_PRINT_RX_CONS(7);   BCE_PRINT_RX_CONS(8);   BCE_PRINT_RX_CONS(9);
-    BCE_PRINT_RX_CONS(10);  BCE_PRINT_RX_CONS(11);  BCE_PRINT_RX_CONS(12);
-    BCE_PRINT_RX_CONS(13);  BCE_PRINT_RX_CONS(14);  BCE_PRINT_RX_CONS(15);
+	BCE_PRINT_RX_CONS(1);   BCE_PRINT_RX_CONS(2);   BCE_PRINT_RX_CONS(3);
+	BCE_PRINT_RX_CONS(4);   BCE_PRINT_RX_CONS(5);   BCE_PRINT_RX_CONS(6);
+	BCE_PRINT_RX_CONS(7);   BCE_PRINT_RX_CONS(8);   BCE_PRINT_RX_CONS(9);
+	BCE_PRINT_RX_CONS(10);  BCE_PRINT_RX_CONS(11);  BCE_PRINT_RX_CONS(12);
+	BCE_PRINT_RX_CONS(13);  BCE_PRINT_RX_CONS(14);  BCE_PRINT_RX_CONS(15);
 
-    BCE_PRINT_TX_CONS(1);   BCE_PRINT_TX_CONS(2);   BCE_PRINT_TX_CONS(3);
+	BCE_PRINT_TX_CONS(1);   BCE_PRINT_TX_CONS(2);   BCE_PRINT_TX_CONS(3);
 
-    if (sblk->status_completion_producer_index ||
-		sblk->status_cmd_consumer_index)
+	if (sblk->status_completion_producer_index ||
+	    sblk->status_cmd_consumer_index)
 		BCE_PRINTF("com_prod  = 0x%08X, cmd_cons      = 0x%08X\n",
-			sblk->status_completion_producer_index,
-			sblk->status_cmd_consumer_index);
+		    sblk->status_completion_producer_index,
+		    sblk->status_cmd_consumer_index);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
-#define BCE_PRINT_64BIT_STAT(arg)                                       \
-if (sblk->arg##_lo || sblk->arg##_hi)                               \
-	BCE_PRINTF("0x%08X:%08X : arg\n", sblk->arg##_hi, sblk->arg##_lo);
+#define BCE_PRINT_64BIT_STAT(arg) 				\
+if (sblk->arg##_lo || sblk->arg##_hi)				\
+	BCE_PRINTF("0x%08X:%08X : %s\n", sblk->arg##_hi,	\
+	    sblk->arg##_lo, #arg);
 
-#define BCE_PRINT_32BIT_STAT(arg)                                       \
-if (sblk->arg)                                                        \
-	BCE_PRINTF("         0x%08X : arg\n", sblk->arg);
+#define BCE_PRINT_32BIT_STAT(arg)				\
+if (sblk->arg)							\
+	BCE_PRINTF("         0x%08X : %s\n", 			\
+	    sblk->arg, #arg);
 
 /****************************************************************************/
 /* Prints out the statistics block from host memory.                        */
@@ -9698,69 +9880,70 @@ bce_dump_stats_block(struct bce_softc *sc)
 	sblk = sc->stats_block;
 
 	BCE_PRINTF(
-		"---------------"
-		" Stats Block  (All Stats Not Shown Are 0) "
-		"---------------\n");
+	    "---------------"
+	    " Stats Block  (All Stats Not Shown Are 0) "
+	    "---------------\n");
 
-    BCE_PRINT_64BIT_STAT(stat_IfHCInOctets);
-    BCE_PRINT_64BIT_STAT(stat_IfHCInBadOctets);
-    BCE_PRINT_64BIT_STAT(stat_IfHCOutOctets);
-    BCE_PRINT_64BIT_STAT(stat_IfHCOutBadOctets);
-    BCE_PRINT_64BIT_STAT(stat_IfHCInUcastPkts);
-    BCE_PRINT_64BIT_STAT(stat_IfHCInBroadcastPkts);
-    BCE_PRINT_64BIT_STAT(stat_IfHCInMulticastPkts);
-    BCE_PRINT_64BIT_STAT(stat_IfHCOutUcastPkts);
-    BCE_PRINT_64BIT_STAT(stat_IfHCOutBroadcastPkts);
-    BCE_PRINT_64BIT_STAT(stat_IfHCOutMulticastPkts);
-    BCE_PRINT_32BIT_STAT(stat_emac_tx_stat_dot3statsinternalmactransmiterrors);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsCarrierSenseErrors);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsFCSErrors);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsAlignmentErrors);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsSingleCollisionFrames);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsMultipleCollisionFrames);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsDeferredTransmissions);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsExcessiveCollisions);
-    BCE_PRINT_32BIT_STAT(stat_Dot3StatsLateCollisions);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsCollisions);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsFragments);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsJabbers);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsUndersizePkts);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsOversizePkts);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx64Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx65Octetsto127Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx128Octetsto255Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx256Octetsto511Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx512Octetsto1023Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx1024Octetsto1522Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx1523Octetsto9022Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx64Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx65Octetsto127Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx128Octetsto255Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx256Octetsto511Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx512Octetsto1023Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx1024Octetsto1522Octets);
-    BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx1523Octetsto9022Octets);
-    BCE_PRINT_32BIT_STAT(stat_XonPauseFramesReceived);
-    BCE_PRINT_32BIT_STAT(stat_XoffPauseFramesReceived);
-    BCE_PRINT_32BIT_STAT(stat_OutXonSent);
-    BCE_PRINT_32BIT_STAT(stat_OutXoffSent);
-    BCE_PRINT_32BIT_STAT(stat_FlowControlDone);
-    BCE_PRINT_32BIT_STAT(stat_MacControlFramesReceived);
-    BCE_PRINT_32BIT_STAT(stat_XoffStateEntered);
-    BCE_PRINT_32BIT_STAT(stat_IfInFramesL2FilterDiscards);
-    BCE_PRINT_32BIT_STAT(stat_IfInRuleCheckerDiscards);
-    BCE_PRINT_32BIT_STAT(stat_IfInFTQDiscards);
-    BCE_PRINT_32BIT_STAT(stat_IfInMBUFDiscards);
-    BCE_PRINT_32BIT_STAT(stat_IfInRuleCheckerP4Hit);
-    BCE_PRINT_32BIT_STAT(stat_CatchupInRuleCheckerDiscards);
-    BCE_PRINT_32BIT_STAT(stat_CatchupInFTQDiscards);
-    BCE_PRINT_32BIT_STAT(stat_CatchupInMBUFDiscards);
-    BCE_PRINT_32BIT_STAT(stat_CatchupInRuleCheckerP4Hit);
+	BCE_PRINT_64BIT_STAT(stat_IfHCInOctets);
+	BCE_PRINT_64BIT_STAT(stat_IfHCInBadOctets);
+	BCE_PRINT_64BIT_STAT(stat_IfHCOutOctets);
+	BCE_PRINT_64BIT_STAT(stat_IfHCOutBadOctets);
+	BCE_PRINT_64BIT_STAT(stat_IfHCInUcastPkts);
+	BCE_PRINT_64BIT_STAT(stat_IfHCInBroadcastPkts);
+	BCE_PRINT_64BIT_STAT(stat_IfHCInMulticastPkts);
+	BCE_PRINT_64BIT_STAT(stat_IfHCOutUcastPkts);
+	BCE_PRINT_64BIT_STAT(stat_IfHCOutBroadcastPkts);
+	BCE_PRINT_64BIT_STAT(stat_IfHCOutMulticastPkts);
+	BCE_PRINT_32BIT_STAT(
+	    stat_emac_tx_stat_dot3statsinternalmactransmiterrors);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsCarrierSenseErrors);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsFCSErrors);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsAlignmentErrors);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsSingleCollisionFrames);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsMultipleCollisionFrames);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsDeferredTransmissions);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsExcessiveCollisions);
+	BCE_PRINT_32BIT_STAT(stat_Dot3StatsLateCollisions);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsCollisions);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsFragments);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsJabbers);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsUndersizePkts);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsOversizePkts);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx64Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx65Octetsto127Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx128Octetsto255Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx256Octetsto511Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx512Octetsto1023Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx1024Octetsto1522Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsRx1523Octetsto9022Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx64Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx65Octetsto127Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx128Octetsto255Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx256Octetsto511Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx512Octetsto1023Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx1024Octetsto1522Octets);
+	BCE_PRINT_32BIT_STAT(stat_EtherStatsPktsTx1523Octetsto9022Octets);
+	BCE_PRINT_32BIT_STAT(stat_XonPauseFramesReceived);
+	BCE_PRINT_32BIT_STAT(stat_XoffPauseFramesReceived);
+	BCE_PRINT_32BIT_STAT(stat_OutXonSent);
+	BCE_PRINT_32BIT_STAT(stat_OutXoffSent);
+	BCE_PRINT_32BIT_STAT(stat_FlowControlDone);
+	BCE_PRINT_32BIT_STAT(stat_MacControlFramesReceived);
+	BCE_PRINT_32BIT_STAT(stat_XoffStateEntered);
+	BCE_PRINT_32BIT_STAT(stat_IfInFramesL2FilterDiscards);
+	BCE_PRINT_32BIT_STAT(stat_IfInRuleCheckerDiscards);
+	BCE_PRINT_32BIT_STAT(stat_IfInFTQDiscards);
+	BCE_PRINT_32BIT_STAT(stat_IfInMBUFDiscards);
+	BCE_PRINT_32BIT_STAT(stat_IfInRuleCheckerP4Hit);
+	BCE_PRINT_32BIT_STAT(stat_CatchupInRuleCheckerDiscards);
+	BCE_PRINT_32BIT_STAT(stat_CatchupInFTQDiscards);
+	BCE_PRINT_32BIT_STAT(stat_CatchupInMBUFDiscards);
+	BCE_PRINT_32BIT_STAT(stat_CatchupInRuleCheckerP4Hit);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -9776,146 +9959,142 @@ bce_dump_driver_state(struct bce_softc *sc)
 	u32 val_hi, val_lo;
 
 	BCE_PRINTF(
-		"-----------------------------"
-		" Driver State "
-		"-----------------------------\n");
+	    "-----------------------------"
+	    " Driver State "
+	    "-----------------------------\n");
 
 	val_hi = BCE_ADDR_HI(sc);
 	val_lo = BCE_ADDR_LO(sc);
-	BCE_PRINTF("0x%08X:%08X - (sc) driver softc structure virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc) driver softc structure virtual "
+	    "address\n", val_hi, val_lo);
 
 	val_hi = BCE_ADDR_HI(sc->bce_vhandle);
 	val_lo = BCE_ADDR_LO(sc->bce_vhandle);
-	BCE_PRINTF("0x%08X:%08X - (sc->bce_vhandle) PCI BAR virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->bce_vhandle) PCI BAR virtual "
+	    "address\n", val_hi, val_lo);
 
 	val_hi = BCE_ADDR_HI(sc->status_block);
 	val_lo = BCE_ADDR_LO(sc->status_block);
-	BCE_PRINTF("0x%08X:%08X - (sc->status_block) status block virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->status_block) status block "
+	    "virtual address\n",	val_hi, val_lo);
 
 	val_hi = BCE_ADDR_HI(sc->stats_block);
 	val_lo = BCE_ADDR_LO(sc->stats_block);
-	BCE_PRINTF("0x%08X:%08X - (sc->stats_block) statistics block virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->stats_block) statistics block "
+	    "virtual address\n", val_hi, val_lo);
 
 	val_hi = BCE_ADDR_HI(sc->tx_bd_chain);
 	val_lo = BCE_ADDR_LO(sc->tx_bd_chain);
-	BCE_PRINTF(
-		"0x%08X:%08X - (sc->tx_bd_chain) tx_bd chain virtual adddress\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->tx_bd_chain) tx_bd chain "
+	    "virtual adddress\n", val_hi, val_lo);
 
 	val_hi = BCE_ADDR_HI(sc->rx_bd_chain);
 	val_lo = BCE_ADDR_LO(sc->rx_bd_chain);
-	BCE_PRINTF(
-		"0x%08X:%08X - (sc->rx_bd_chain) rx_bd chain virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->rx_bd_chain) rx_bd chain "
+	    "virtual address\n", val_hi, val_lo);
 
 #ifdef BCE_JUMBO_HDRSPLIT
 	val_hi = BCE_ADDR_HI(sc->pg_bd_chain);
 	val_lo = BCE_ADDR_LO(sc->pg_bd_chain);
-	BCE_PRINTF(
-		"0x%08X:%08X - (sc->pg_bd_chain) page chain virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->pg_bd_chain) page chain "
+	    "virtual address\n", val_hi, val_lo);
 #endif
 
 	val_hi = BCE_ADDR_HI(sc->tx_mbuf_ptr);
 	val_lo = BCE_ADDR_LO(sc->tx_mbuf_ptr);
-	BCE_PRINTF(
-		"0x%08X:%08X - (sc->tx_mbuf_ptr) tx mbuf chain virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->tx_mbuf_ptr) tx mbuf chain "
+	    "virtual address\n",	val_hi, val_lo);
 
 	val_hi = BCE_ADDR_HI(sc->rx_mbuf_ptr);
 	val_lo = BCE_ADDR_LO(sc->rx_mbuf_ptr);
-	BCE_PRINTF(
-		"0x%08X:%08X - (sc->rx_mbuf_ptr) rx mbuf chain virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->rx_mbuf_ptr) rx mbuf chain "
+	    "virtual address\n", val_hi, val_lo);
 
 #ifdef BCE_JUMBO_HDRSPLIT
 	val_hi = BCE_ADDR_HI(sc->pg_mbuf_ptr);
 	val_lo = BCE_ADDR_LO(sc->pg_mbuf_ptr);
-	BCE_PRINTF(
-		"0x%08X:%08X - (sc->pg_mbuf_ptr) page mbuf chain virtual address\n",
-		val_hi, val_lo);
+	BCE_PRINTF("0x%08X:%08X - (sc->pg_mbuf_ptr) page mbuf chain "
+	    "virtual address\n", val_hi, val_lo);
 #endif
 
-	BCE_PRINTF("         0x%08X - (sc->interrupts_generated) h/w intrs\n",
-		sc->interrupts_generated);
+	BCE_PRINTF("         0x%08X - (sc->interrupts_generated) "
+	    "h/w intrs\n", sc->interrupts_generated);
 
-	BCE_PRINTF("         0x%08X - (sc->rx_interrupts) rx interrupts handled\n",
-		sc->rx_interrupts);
+	BCE_PRINTF("         0x%08X - (sc->rx_interrupts) "
+	    "rx interrupts handled\n", sc->rx_interrupts);
 
-	BCE_PRINTF("         0x%08X - (sc->tx_interrupts) tx interrupts handled\n",
-		sc->tx_interrupts);
+	BCE_PRINTF("         0x%08X - (sc->tx_interrupts) "
+	    "tx interrupts handled\n", sc->tx_interrupts);
 
-	BCE_PRINTF("         0x%08X - (sc->last_status_idx) status block index\n",
-		sc->last_status_idx);
+	BCE_PRINTF("         0x%08X - (sc->phy_interrupts) "
+	    "phy interrupts handled\n", sc->phy_interrupts);
 
-	BCE_PRINTF("     0x%04X(0x%04X) - (sc->tx_prod) tx producer index\n",
-		sc->tx_prod, (u16) TX_CHAIN_IDX(sc->tx_prod));
+	BCE_PRINTF("         0x%08X - (sc->last_status_idx) "
+	    "status block index\n", sc->last_status_idx);
 
-	BCE_PRINTF("     0x%04X(0x%04X) - (sc->tx_cons) tx consumer index\n",
-		sc->tx_cons, (u16) TX_CHAIN_IDX(sc->tx_cons));
+	BCE_PRINTF("     0x%04X(0x%04X) - (sc->tx_prod) tx producer "
+	    "index\n", sc->tx_prod, (u16) TX_CHAIN_IDX(sc->tx_prod));
 
-	BCE_PRINTF("         0x%08X - (sc->tx_prod_bseq) tx producer bseq index\n",
-		sc->tx_prod_bseq);
+	BCE_PRINTF("     0x%04X(0x%04X) - (sc->tx_cons) tx consumer "
+	    "index\n", sc->tx_cons, (u16) TX_CHAIN_IDX(sc->tx_cons));
 
-	BCE_PRINTF("         0x%08X - (sc->debug_tx_mbuf_alloc) tx mbufs allocated\n",
-		sc->debug_tx_mbuf_alloc);
+	BCE_PRINTF("         0x%08X - (sc->tx_prod_bseq) tx producer "
+	    "byte seq index\n",	sc->tx_prod_bseq);
 
-	BCE_PRINTF("         0x%08X - (sc->used_tx_bd) used tx_bd's\n",
-		sc->used_tx_bd);
+	BCE_PRINTF("         0x%08X - (sc->debug_tx_mbuf_alloc) tx "
+	    "mbufs allocated\n", sc->debug_tx_mbuf_alloc);
 
-	BCE_PRINTF("0x%08X/%08X - (sc->tx_hi_watermark) tx hi watermark\n",
-		sc->tx_hi_watermark, sc->max_tx_bd);
+	BCE_PRINTF("         0x%08X - (sc->used_tx_bd) used "
+	    "tx_bd's\n", sc->used_tx_bd);
 
-	BCE_PRINTF("     0x%04X(0x%04X) - (sc->rx_prod) rx producer index\n",
-		sc->rx_prod, (u16) RX_CHAIN_IDX(sc->rx_prod));
+	BCE_PRINTF("0x%08X/%08X - (sc->tx_hi_watermark) tx hi "
+	    "watermark\n", sc->tx_hi_watermark, sc->max_tx_bd);
 
-	BCE_PRINTF("     0x%04X(0x%04X) - (sc->rx_cons) rx consumer index\n",
-		sc->rx_cons, (u16) RX_CHAIN_IDX(sc->rx_cons));
+	BCE_PRINTF("     0x%04X(0x%04X) - (sc->rx_prod) rx producer "
+	    "index\n", sc->rx_prod, (u16) RX_CHAIN_IDX(sc->rx_prod));
 
-	BCE_PRINTF("         0x%08X - (sc->rx_prod_bseq) rx producer bseq index\n",
-		sc->rx_prod_bseq);
+	BCE_PRINTF("     0x%04X(0x%04X) - (sc->rx_cons) rx consumer "
+	    "index\n", sc->rx_cons, (u16) RX_CHAIN_IDX(sc->rx_cons));
+
+	BCE_PRINTF("         0x%08X - (sc->rx_prod_bseq) rx producer "
+	    "byte seq index\n",	sc->rx_prod_bseq);
 
-	BCE_PRINTF("         0x%08X - (sc->debug_rx_mbuf_alloc) rx mbufs allocated\n",
-		sc->debug_rx_mbuf_alloc);
+	BCE_PRINTF("         0x%08X - (sc->debug_rx_mbuf_alloc) rx "
+	    "mbufs allocated\n", sc->debug_rx_mbuf_alloc);
 
-	BCE_PRINTF("         0x%08X - (sc->free_rx_bd) free rx_bd's\n",
-		sc->free_rx_bd);
+	BCE_PRINTF("         0x%08X - (sc->free_rx_bd) free "
+	    "rx_bd's\n", sc->free_rx_bd);
 
 #ifdef BCE_JUMBO_HDRSPLIT
-	BCE_PRINTF("     0x%04X(0x%04X) - (sc->pg_prod) page producer index\n",
-		sc->pg_prod, (u16) PG_CHAIN_IDX(sc->pg_prod));
+	BCE_PRINTF("     0x%04X(0x%04X) - (sc->pg_prod) page producer "
+	    "index\n", sc->pg_prod, (u16) PG_CHAIN_IDX(sc->pg_prod));
 
-	BCE_PRINTF("     0x%04X(0x%04X) - (sc->pg_cons) page consumer index\n",
-		sc->pg_cons, (u16) PG_CHAIN_IDX(sc->pg_cons));
+	BCE_PRINTF("     0x%04X(0x%04X) - (sc->pg_cons) page consumer "
+	    "index\n", sc->pg_cons, (u16) PG_CHAIN_IDX(sc->pg_cons));
 
-	BCE_PRINTF("         0x%08X - (sc->debug_pg_mbuf_alloc) page mbufs allocated\n",
-		sc->debug_pg_mbuf_alloc);
+	BCE_PRINTF("         0x%08X - (sc->debug_pg_mbuf_alloc) page "
+	    "mbufs allocated\n", sc->debug_pg_mbuf_alloc);
 
-	BCE_PRINTF("         0x%08X - (sc->free_pg_bd) free page rx_bd's\n",
-		sc->free_pg_bd);
+	BCE_PRINTF("         0x%08X - (sc->free_pg_bd) free page "
+	    "rx_bd's\n", sc->free_pg_bd);
 
-	BCE_PRINTF("0x%08X/%08X - (sc->pg_low_watermark) page low watermark\n",
-		sc->pg_low_watermark, sc->max_pg_bd);
+	BCE_PRINTF("0x%08X/%08X - (sc->pg_low_watermark) page low "
+	    "watermark\n", sc->pg_low_watermark, sc->max_pg_bd);
 #endif
 
 	BCE_PRINTF("         0x%08X - (sc->mbuf_alloc_failed_count) "
-		"mbuf alloc failures\n",
-		sc->mbuf_alloc_failed_count);
+	    "mbuf alloc failures\n", sc->mbuf_alloc_failed_count);
 
-	BCE_PRINTF("         0x%08X - (sc->bce_flags) bce mac flags\n",
-		sc->bce_flags);
+	BCE_PRINTF("         0x%08X - (sc->bce_flags) "
+	    "bce mac flags\n", sc->bce_flags);
 
-	BCE_PRINTF("         0x%08X - (sc->bce_phy_flags) bce phy flags\n",
-		sc->bce_phy_flags);
+	BCE_PRINTF("         0x%08X - (sc->bce_phy_flags) "
+	    "bce phy flags\n", sc->bce_phy_flags);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -9932,84 +10111,102 @@ bce_dump_hw_state(struct bce_softc *sc)
 	u32 val;
 
 	BCE_PRINTF(
-		"----------------------------"
-		" Hardware State "
-		"----------------------------\n");
+	    "----------------------------"
+	    " Hardware State "
+	    "----------------------------\n");
 
 	BCE_PRINTF("%s - bootcode version\n", sc->bce_bc_ver);
 
 	val = REG_RD(sc, BCE_MISC_ENABLE_STATUS_BITS);
 	BCE_PRINTF("0x%08X - (0x%06X) misc_enable_status_bits\n",
-		val, BCE_MISC_ENABLE_STATUS_BITS);
+	    val, BCE_MISC_ENABLE_STATUS_BITS);
 
 	val = REG_RD(sc, BCE_DMA_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) dma_status\n", val, BCE_DMA_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) dma_status\n", 
+	    val, BCE_DMA_STATUS);
 
 	val = REG_RD(sc, BCE_CTX_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) ctx_status\n", val, BCE_CTX_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) ctx_status\n", 
+	    val, BCE_CTX_STATUS);
 
 	val = REG_RD(sc, BCE_EMAC_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) emac_status\n", val, BCE_EMAC_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) emac_status\n", 
+	    val, BCE_EMAC_STATUS);
 
 	val = REG_RD(sc, BCE_RPM_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) rpm_status\n", val, BCE_RPM_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) rpm_status\n",
+	    val, BCE_RPM_STATUS);
 
+	/* ToDo: Create a #define for this constant. */
 	val = REG_RD(sc, 0x2004);
-	BCE_PRINTF("0x%08X - (0x%06X) rlup_status\n", val, 0x2004);
+	BCE_PRINTF("0x%08X - (0x%06X) rlup_status\n", 
+	    val, 0x2004);
 
 	val = REG_RD(sc, BCE_RV2P_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) rv2p_status\n", val, BCE_RV2P_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) rv2p_status\n", 
+	    val, BCE_RV2P_STATUS);
 
+	/* ToDo: Create a #define for this constant. */
 	val = REG_RD(sc, 0x2c04);
-	BCE_PRINTF("0x%08X - (0x%06X) rdma_status\n", val, 0x2c04);
+	BCE_PRINTF("0x%08X - (0x%06X) rdma_status\n", 
+	    val, 0x2c04);
 
 	val = REG_RD(sc, BCE_TBDR_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) tbdr_status\n", val, BCE_TBDR_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) tbdr_status\n",
+	    val, BCE_TBDR_STATUS);
 
 	val = REG_RD(sc, BCE_TDMA_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) tdma_status\n", val, BCE_TDMA_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) tdma_status\n", 
+	    val, BCE_TDMA_STATUS);
 
 	val = REG_RD(sc, BCE_HC_STATUS);
-	BCE_PRINTF("0x%08X - (0x%06X) hc_status\n", val, BCE_HC_STATUS);
+	BCE_PRINTF("0x%08X - (0x%06X) hc_status\n",
+	    val, BCE_HC_STATUS);
 
 	val = REG_RD_IND(sc, BCE_TXP_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_state\n", val, BCE_TXP_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_state\n", 
+	    val, BCE_TXP_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_TPAT_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_state\n", val, BCE_TPAT_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_state\n", 
+	    val, BCE_TPAT_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_RXP_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_state\n", val, BCE_RXP_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_state\n", 
+	    val, BCE_RXP_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_COM_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) com_cpu_state\n", val, BCE_COM_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) com_cpu_state\n", 
+	    val, BCE_COM_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_MCP_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) mcp_cpu_state\n", val, BCE_MCP_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) mcp_cpu_state\n", 
+	    val, BCE_MCP_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_CP_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) cp_cpu_state\n", val, BCE_CP_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) cp_cpu_state\n", 
+	    val, BCE_CP_CPU_STATE);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 
 	BCE_PRINTF(
-		"----------------------------"
-		" Register  Dump "
-		"----------------------------\n");
+	    "----------------------------"
+	    " Register  Dump "
+	    "----------------------------\n");
 
 	for (int i = 0x400; i < 0x8000; i += 0x10) {
 		BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n",
-			i, REG_RD(sc, i), REG_RD(sc, i + 0x4),
-			REG_RD(sc, i + 0x8), REG_RD(sc, i + 0xC));
+		    i, REG_RD(sc, i), REG_RD(sc, i + 0x4),
+		    REG_RD(sc, i + 0x8), REG_RD(sc, i + 0xC));
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -10023,25 +10220,25 @@ static __attribute__ ((noinline)) void
 bce_dump_mq_regs(struct bce_softc *sc)
 {
 	BCE_PRINTF(
-		"----------------------------"
-		"    MQ Regs     "
-		"----------------------------\n");
+	    "----------------------------"
+	    "    MQ Regs     "
+	    "----------------------------\n");
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 
 	for (int i = 0x3c00; i < 0x4000; i += 0x10) {
 		BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n",
-			i, REG_RD(sc, i), REG_RD(sc, i + 0x4),
-			REG_RD(sc, i + 0x8), REG_RD(sc, i + 0xC));
+		    i, REG_RD(sc, i), REG_RD(sc, i + 0x4),
+		    REG_RD(sc, i + 0x8), REG_RD(sc, i + 0xC));
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -10057,32 +10254,32 @@ bce_dump_bc_state(struct bce_softc *sc)
 	u32 val;
 
 	BCE_PRINTF(
-		"----------------------------"
-		" Bootcode State "
-		"----------------------------\n");
+	    "----------------------------"
+	    " Bootcode State "
+	    "----------------------------\n");
 
 	BCE_PRINTF("%s - bootcode version\n", sc->bce_bc_ver);
 
 	val = bce_shmem_rd(sc, BCE_BC_RESET_TYPE);
 	BCE_PRINTF("0x%08X - (0x%06X) reset_type\n",
-		val, BCE_BC_RESET_TYPE);
+	    val, BCE_BC_RESET_TYPE);
 
 	val = bce_shmem_rd(sc, BCE_BC_STATE);
 	BCE_PRINTF("0x%08X - (0x%06X) state\n",
-		val, BCE_BC_STATE);
+	    val, BCE_BC_STATE);
 
 	val = bce_shmem_rd(sc, BCE_BC_STATE_CONDITION);
 	BCE_PRINTF("0x%08X - (0x%06X) condition\n",
-		val, BCE_BC_STATE_CONDITION);
+	    val, BCE_BC_STATE_CONDITION);
 
 	val = bce_shmem_rd(sc, BCE_BC_STATE_DEBUG_CMD);
 	BCE_PRINTF("0x%08X - (0x%06X) debug_cmd\n",
-		val, BCE_BC_STATE_DEBUG_CMD);
+	    val, BCE_BC_STATE_DEBUG_CMD);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -10099,44 +10296,49 @@ bce_dump_txp_state(struct bce_softc *sc, int regs)
 	u32 fw_version[3];
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   TXP  State   "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   TXP  State   "
+	    "----------------------------\n");
 
 	for (int i = 0; i < 3; i++)
 		fw_version[i] = htonl(REG_RD_IND(sc,
-			(BCE_TXP_SCRATCH + 0x10 + i * 4)));
+		    (BCE_TXP_SCRATCH + 0x10 + i * 4)));
 	BCE_PRINTF("Firmware version - %s\n", (char *) fw_version);
 
 	val = REG_RD_IND(sc, BCE_TXP_CPU_MODE);
-	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_mode\n", val, BCE_TXP_CPU_MODE);
+	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_mode\n", 
+	    val, BCE_TXP_CPU_MODE);
 
 	val = REG_RD_IND(sc, BCE_TXP_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_state\n", val, BCE_TXP_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_state\n", 
+	    val, BCE_TXP_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_TXP_CPU_EVENT_MASK);
-	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_event_mask\n", val,
-		BCE_TXP_CPU_EVENT_MASK);
+	BCE_PRINTF("0x%08X - (0x%06X) txp_cpu_event_mask\n", 
+	    val, BCE_TXP_CPU_EVENT_MASK);
 
 	if (regs) {
 		BCE_PRINTF(
-			"----------------------------"
-			" Register  Dump "
-			"----------------------------\n");
+		    "----------------------------"
+		    " Register  Dump "
+		    "----------------------------\n");
 
 		for (int i = BCE_TXP_CPU_MODE; i < 0x68000; i += 0x10) {
 			/* Skip the big blank spaces */
 			if (i < 0x454000 && i > 0x5ffff)
-				BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n",
-					i, REG_RD_IND(sc, i), REG_RD_IND(sc, i + 0x4),
-					REG_RD_IND(sc, i + 0x8), REG_RD_IND(sc, i + 0xC));
+				BCE_PRINTF("0x%04X: 0x%08X 0x%08X "
+				    "0x%08X 0x%08X\n", i, 
+				    REG_RD_IND(sc, i), 
+				    REG_RD_IND(sc, i + 0x4),
+				    REG_RD_IND(sc, i + 0x8),
+				    REG_RD_IND(sc, i + 0xC));
 		}
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -10153,44 +10355,50 @@ bce_dump_rxp_state(struct bce_softc *sc, int regs)
 	u32 fw_version[3];
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   RXP  State   "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   RXP  State   "
+	    "----------------------------\n");
 
 	for (int i = 0; i < 3; i++)
 		fw_version[i] = htonl(REG_RD_IND(sc,
-			(BCE_RXP_SCRATCH + 0x10 + i * 4)));
+		    (BCE_RXP_SCRATCH + 0x10 + i * 4)));
+
 	BCE_PRINTF("Firmware version - %s\n", (char *) fw_version);
 
 	val = REG_RD_IND(sc, BCE_RXP_CPU_MODE);
-	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_mode\n", val, BCE_RXP_CPU_MODE);
+	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_mode\n", 
+	    val, BCE_RXP_CPU_MODE);
 
 	val = REG_RD_IND(sc, BCE_RXP_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_state\n", val, BCE_RXP_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_state\n", 
+	    val, BCE_RXP_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_RXP_CPU_EVENT_MASK);
-	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_event_mask\n", val,
-		BCE_RXP_CPU_EVENT_MASK);
+	BCE_PRINTF("0x%08X - (0x%06X) rxp_cpu_event_mask\n", 
+	    val, BCE_RXP_CPU_EVENT_MASK);
 
 	if (regs) {
 		BCE_PRINTF(
-			"----------------------------"
-			" Register  Dump "
-			"----------------------------\n");
+		    "----------------------------"
+		    " Register  Dump "
+		    "----------------------------\n");
 
 		for (int i = BCE_RXP_CPU_MODE; i < 0xe8fff; i += 0x10) {
 			/* Skip the big blank sapces */
 			if (i < 0xc5400 && i > 0xdffff)
-				BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n",
-	 				i, REG_RD_IND(sc, i), REG_RD_IND(sc, i + 0x4),
-					REG_RD_IND(sc, i + 0x8), REG_RD_IND(sc, i + 0xC));
+				BCE_PRINTF("0x%04X: 0x%08X 0x%08X "
+				    "0x%08X 0x%08X\n", i, 
+				    REG_RD_IND(sc, i), 
+				    REG_RD_IND(sc, i + 0x4),
+				    REG_RD_IND(sc, i + 0x8), 
+				    REG_RD_IND(sc, i + 0xC));
 		}
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -10207,37 +10415,43 @@ bce_dump_tpat_state(struct bce_softc *sc, int regs)
 	u32 fw_version[3];
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   TPAT State   "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   TPAT State   "
+	    "----------------------------\n");
 
 	for (int i = 0; i < 3; i++)
 		fw_version[i] = htonl(REG_RD_IND(sc,
-			(BCE_TPAT_SCRATCH + 0x410 + i * 4)));
+		    (BCE_TPAT_SCRATCH + 0x410 + i * 4)));
+
 	BCE_PRINTF("Firmware version - %s\n", (char *) fw_version);
 
 	val = REG_RD_IND(sc, BCE_TPAT_CPU_MODE);
-	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_mode\n", val, BCE_TPAT_CPU_MODE);
+	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_mode\n", 
+	    val, BCE_TPAT_CPU_MODE);
 
 	val = REG_RD_IND(sc, BCE_TPAT_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_state\n", val, BCE_TPAT_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_state\n", 
+	    val, BCE_TPAT_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_TPAT_CPU_EVENT_MASK);
-	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_event_mask\n", val,
-		BCE_TPAT_CPU_EVENT_MASK);
+	BCE_PRINTF("0x%08X - (0x%06X) tpat_cpu_event_mask\n", 
+	    val, BCE_TPAT_CPU_EVENT_MASK);
 
 	if (regs) {
 		BCE_PRINTF(
-			"----------------------------"
-			" Register  Dump "
-			"----------------------------\n");
+		    "----------------------------"
+		    " Register  Dump "
+		    "----------------------------\n");
 
 		for (int i = BCE_TPAT_CPU_MODE; i < 0xa3fff; i += 0x10) {
 			/* Skip the big blank spaces */
 			if (i < 0x854000 && i > 0x9ffff)
-				BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n",
-					i, REG_RD_IND(sc, i), REG_RD_IND(sc, i + 0x4),
-					REG_RD_IND(sc, i + 0x8), REG_RD_IND(sc, i + 0xC));
+				BCE_PRINTF("0x%04X: 0x%08X 0x%08X "
+				    "0x%08X 0x%08X\n", i,
+				    REG_RD_IND(sc, i), 
+				    REG_RD_IND(sc, i + 0x4),
+				    REG_RD_IND(sc, i + 0x8), 
+				    REG_RD_IND(sc, i + 0xC));
 		}
 	}
 
@@ -10261,44 +10475,50 @@ bce_dump_cp_state(struct bce_softc *sc, int regs)
 	u32 fw_version[3];
 
 	BCE_PRINTF(
-		"----------------------------"
-		"    CP State    "
-		"----------------------------\n");
+	    "----------------------------"
+	    "    CP State    "
+	    "----------------------------\n");
 
 	for (int i = 0; i < 3; i++)
 		fw_version[i] = htonl(REG_RD_IND(sc,
-			(BCE_CP_SCRATCH + 0x10 + i * 4)));
+		    (BCE_CP_SCRATCH + 0x10 + i * 4)));
+
 	BCE_PRINTF("Firmware version - %s\n", (char *) fw_version);
 
 	val = REG_RD_IND(sc, BCE_CP_CPU_MODE);
-	BCE_PRINTF("0x%08X - (0x%06X) cp_cpu_mode\n", val, BCE_CP_CPU_MODE);
+	BCE_PRINTF("0x%08X - (0x%06X) cp_cpu_mode\n", 
+	    val, BCE_CP_CPU_MODE);
 
 	val = REG_RD_IND(sc, BCE_CP_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) cp_cpu_state\n", val, BCE_CP_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) cp_cpu_state\n", 
+	    val, BCE_CP_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_CP_CPU_EVENT_MASK);
 	BCE_PRINTF("0x%08X - (0x%06X) cp_cpu_event_mask\n", val,
-		BCE_CP_CPU_EVENT_MASK);
+	    BCE_CP_CPU_EVENT_MASK);
 
 	if (regs) {
 		BCE_PRINTF(
-			"----------------------------"
-			" Register  Dump "
-			"----------------------------\n");
+		    "----------------------------"
+		    " Register  Dump "
+		    "----------------------------\n");
 
 		for (int i = BCE_CP_CPU_MODE; i < 0x1aa000; i += 0x10) {
 			/* Skip the big blank spaces */
 			if (i < 0x185400 && i > 0x19ffff)
-				BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n",
-					i, REG_RD_IND(sc, i), REG_RD_IND(sc, i + 0x4),
-					REG_RD_IND(sc, i + 0x8), REG_RD_IND(sc, i + 0xC));
+				BCE_PRINTF("0x%04X: 0x%08X 0x%08X "
+				    "0x%08X 0x%08X\n", i, 
+				    REG_RD_IND(sc, i), 
+				    REG_RD_IND(sc, i + 0x4),
+				    REG_RD_IND(sc, i + 0x8), 
+				    REG_RD_IND(sc, i + 0xC));
 		}
 	}
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -10315,35 +10535,41 @@ bce_dump_com_state(struct bce_softc *sc, int regs)
 	u32 fw_version[4];
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   COM State    "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   COM State    "
+	    "----------------------------\n");
 
 	for (int i = 0; i < 3; i++)
 		fw_version[i] = htonl(REG_RD_IND(sc,
-			(BCE_COM_SCRATCH + 0x10 + i * 4)));
+		    (BCE_COM_SCRATCH + 0x10 + i * 4)));
+
 	BCE_PRINTF("Firmware version - %s\n", (char *) fw_version);
 
 	val = REG_RD_IND(sc, BCE_COM_CPU_MODE);
-	BCE_PRINTF("0x%08X - (0x%06X) com_cpu_mode\n", val, BCE_COM_CPU_MODE);
+	BCE_PRINTF("0x%08X - (0x%06X) com_cpu_mode\n", 
+	    val, BCE_COM_CPU_MODE);
 
 	val = REG_RD_IND(sc, BCE_COM_CPU_STATE);
-	BCE_PRINTF("0x%08X - (0x%06X) com_cpu_state\n", val, BCE_COM_CPU_STATE);
+	BCE_PRINTF("0x%08X - (0x%06X) com_cpu_state\n", 
+	    val, BCE_COM_CPU_STATE);
 
 	val = REG_RD_IND(sc, BCE_COM_CPU_EVENT_MASK);
 	BCE_PRINTF("0x%08X - (0x%06X) com_cpu_event_mask\n", val,
-		BCE_COM_CPU_EVENT_MASK);
+	    BCE_COM_CPU_EVENT_MASK);
 
 	if (regs) {
 		BCE_PRINTF(
-			"----------------------------"
-			" Register  Dump "
-			"----------------------------\n");
+		    "----------------------------"
+		    " Register  Dump "
+		    "----------------------------\n");
 
 		for (int i = BCE_COM_CPU_MODE; i < 0x1053e8; i += 0x10) {
-			BCE_PRINTF("0x%04X: 0x%08X 0x%08X 0x%08X 0x%08X\n",
-				i, REG_RD_IND(sc, i), REG_RD_IND(sc, i + 0x4),
-				REG_RD_IND(sc, i + 0x8), REG_RD_IND(sc, i + 0xC));
+			BCE_PRINTF("0x%04X: 0x%08X 0x%08X "
+			    "0x%08X 0x%08X\n", i, 
+			    REG_RD_IND(sc, i), 
+			    REG_RD_IND(sc, i + 0x4),
+			    REG_RD_IND(sc, i + 0x8),
+			    REG_RD_IND(sc, i + 0xC));
 		}
 	}
 
@@ -10366,55 +10592,59 @@ bce_dump_rv2p_state(struct bce_softc *sc)
 	u32 val, pc1, pc2, fw_ver_high, fw_ver_low;
 
 	BCE_PRINTF(
-		"----------------------------"
-		"   RV2P State   "
-		"----------------------------\n");
+	    "----------------------------"
+	    "   RV2P State   "
+	    "----------------------------\n");
 
-    /* Stall the RV2P processors. */
-    val = REG_RD_IND(sc, BCE_RV2P_CONFIG);
-    val |= BCE_RV2P_CONFIG_STALL_PROC1 | BCE_RV2P_CONFIG_STALL_PROC2;
-    REG_WR_IND(sc, BCE_RV2P_CONFIG, val);
+	/* Stall the RV2P processors. */
+	val = REG_RD_IND(sc, BCE_RV2P_CONFIG);
+	val |= BCE_RV2P_CONFIG_STALL_PROC1 | BCE_RV2P_CONFIG_STALL_PROC2;
+	REG_WR_IND(sc, BCE_RV2P_CONFIG, val);
 
-    /* Read the firmware version. */
-    val = 0x00000001;
-    REG_WR_IND(sc, BCE_RV2P_PROC1_ADDR_CMD, val);
-    fw_ver_low = REG_RD_IND(sc, BCE_RV2P_INSTR_LOW);
-    fw_ver_high = REG_RD_IND(sc, BCE_RV2P_INSTR_HIGH) & BCE_RV2P_INSTR_HIGH_HIGH;
-	BCE_PRINTF("RV2P1 Firmware version - 0x%08X:0x%08X\n", fw_ver_high, fw_ver_low);
+	/* Read the firmware version. */
+	val = 0x00000001;
+	REG_WR_IND(sc, BCE_RV2P_PROC1_ADDR_CMD, val);
+	fw_ver_low = REG_RD_IND(sc, BCE_RV2P_INSTR_LOW);
+	fw_ver_high = REG_RD_IND(sc, BCE_RV2P_INSTR_HIGH) & 
+	    BCE_RV2P_INSTR_HIGH_HIGH;
+	BCE_PRINTF("RV2P1 Firmware version - 0x%08X:0x%08X\n", 
+	    fw_ver_high, fw_ver_low);
 
-    val = 0x00000001;
-    REG_WR_IND(sc, BCE_RV2P_PROC2_ADDR_CMD, val);
-    fw_ver_low = REG_RD_IND(sc, BCE_RV2P_INSTR_LOW);
-    fw_ver_high = REG_RD_IND(sc, BCE_RV2P_INSTR_HIGH) & BCE_RV2P_INSTR_HIGH_HIGH;
-    BCE_PRINTF("RV2P2 Firmware version - 0x%08X:0x%08X\n", fw_ver_high, fw_ver_low);
+	val = 0x00000001;
+	REG_WR_IND(sc, BCE_RV2P_PROC2_ADDR_CMD, val);
+	fw_ver_low = REG_RD_IND(sc, BCE_RV2P_INSTR_LOW);
+	fw_ver_high = REG_RD_IND(sc, BCE_RV2P_INSTR_HIGH) & 
+	    BCE_RV2P_INSTR_HIGH_HIGH;
+	BCE_PRINTF("RV2P2 Firmware version - 0x%08X:0x%08X\n", 
+	    fw_ver_high, fw_ver_low);
 
-    /* Resume the RV2P processors. */
-    val = REG_RD_IND(sc, BCE_RV2P_CONFIG);
-    val &= ~(BCE_RV2P_CONFIG_STALL_PROC1 | BCE_RV2P_CONFIG_STALL_PROC2);
-    REG_WR_IND(sc, BCE_RV2P_CONFIG, val);
+	/* Resume the RV2P processors. */
+	val = REG_RD_IND(sc, BCE_RV2P_CONFIG);
+	val &= ~(BCE_RV2P_CONFIG_STALL_PROC1 | BCE_RV2P_CONFIG_STALL_PROC2);
+	REG_WR_IND(sc, BCE_RV2P_CONFIG, val);
 
-    /* Fetch the program counter value. */
+	/* Fetch the program counter value. */
 	val = 0x68007800;
-    REG_WR_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK, val);
-    val = REG_RD_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK);
-    pc1 = (val & BCE_RV2P_DEBUG_VECT_PEEK_1_VALUE);
-    pc2 = (val & BCE_RV2P_DEBUG_VECT_PEEK_2_VALUE) >> 16;
-    BCE_PRINTF("0x%08X - RV2P1 program counter (1st read)\n", pc1);
-    BCE_PRINTF("0x%08X - RV2P2 program counter (1st read)\n", pc2);
+	REG_WR_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK, val);
+	val = REG_RD_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK);
+	pc1 = (val & BCE_RV2P_DEBUG_VECT_PEEK_1_VALUE);
+	pc2 = (val & BCE_RV2P_DEBUG_VECT_PEEK_2_VALUE) >> 16;
+	BCE_PRINTF("0x%08X - RV2P1 program counter (1st read)\n", pc1);
+	BCE_PRINTF("0x%08X - RV2P2 program counter (1st read)\n", pc2);
 
-    /* Fetch the program counter value again to see if it is advancing. */
-    val = 0x68007800;
-    REG_WR_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK, val);
-    val = REG_RD_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK);
-    pc1 = (val & BCE_RV2P_DEBUG_VECT_PEEK_1_VALUE);
-    pc2 = (val & BCE_RV2P_DEBUG_VECT_PEEK_2_VALUE) >> 16;
-    BCE_PRINTF("0x%08X - RV2P1 program counter (2nd read)\n", pc1);
-    BCE_PRINTF("0x%08X - RV2P2 program counter (2nd read)\n", pc2);
+	/* Fetch the program counter value again to see if it is advancing. */
+	val = 0x68007800;
+	REG_WR_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK, val);
+	val = REG_RD_IND(sc, BCE_RV2P_DEBUG_VECT_PEEK);
+	pc1 = (val & BCE_RV2P_DEBUG_VECT_PEEK_1_VALUE);
+	pc2 = (val & BCE_RV2P_DEBUG_VECT_PEEK_2_VALUE) >> 16;
+	BCE_PRINTF("0x%08X - RV2P1 program counter (2nd read)\n", pc1);
+	BCE_PRINTF("0x%08X - RV2P2 program counter (2nd read)\n", pc2);
 
 	BCE_PRINTF(
-		"----------------------------"
-		"----------------"
-		"----------------------------\n");
+	    "----------------------------"
+	    "----------------"
+	    "----------------------------\n");
 }
 
 
@@ -10436,7 +10666,7 @@ bce_breakpoint(struct bce_softc *sc)
 		bce_freeze_controller(sc);
 		bce_unfreeze_controller(sc);
 		bce_dump_enet(sc, NULL);
-   		bce_dump_txbd(sc, 0, NULL);
+		bce_dump_txbd(sc, 0, NULL);
 		bce_dump_rxbd(sc, 0, NULL);
 		bce_dump_tx_mbuf_chain(sc, 0, USABLE_TX_BD);
 		bce_dump_rx_mbuf_chain(sc, 0, USABLE_RX_BD);
@@ -10444,7 +10674,7 @@ bce_breakpoint(struct bce_softc *sc)
 		bce_dump_ctx(sc, RX_CID);
 		bce_dump_ftqs(sc);
 		bce_dump_tx_chain(sc, 0, USABLE_TX_BD);
-		bce_dump_rx_chain(sc, 0, USABLE_RX_BD);
+		bce_dump_rx_bd_chain(sc, 0, USABLE_RX_BD);
 		bce_dump_status_block(sc);
 		bce_dump_stats_block(sc);
 		bce_dump_driver_state(sc);
@@ -10455,7 +10685,8 @@ bce_breakpoint(struct bce_softc *sc)
 		bce_dump_tpat_state(sc, 0);
 		bce_dump_cp_state(sc, 0);
 		bce_dump_com_state(sc, 0);
-        bce_dump_rv2p_state(sc);
+		bce_dump_rv2p_state(sc);
+
 #ifdef BCE_JUMBO_HDRSPLIT
 		bce_dump_pgbd(sc, 0, NULL);
 		bce_dump_pg_mbuf_chain(sc, 0, USABLE_PG_BD);
diff --git a/sys/dev/bce/if_bcereg.h b/sys/dev/bce/if_bcereg.h
index 177378b3aab5..49bba6377f89 100644
--- a/sys/dev/bce/if_bcereg.h
+++ b/sys/dev/bce/if_bcereg.h
@@ -85,9 +85,9 @@
 /* Conversion to FreeBSD type definitions.                                  */
 /****************************************************************************/
 #define u64 uint64_t
-#define u32	uint32_t
-#define u16	uint16_t
-#define u8	uint8_t
+#define u32 uint32_t
+#define u16 uint16_t
+#define u8  uint8_t
 
 #if BYTE_ORDER == BIG_ENDIAN
 #define __BIG_ENDIAN 1
@@ -98,371 +98,369 @@
 #endif
 
 #define BCE_DWORD_PRINTFB	\
-	"\020"					\
-	"\40b31"				\
-	"\37b30"				\
-	"\36b29"				\
-	"\35b28"				\
-	"\34b27"				\
-	"\33b26"				\
-	"\32b25"				\
-	"\31b24"				\
-	"\30b23"				\
-	"\27b22"				\
-	"\26b21"				\
-	"\25b20"				\
-	"\24b19"				\
-	"\23b18"				\
-	"\22b17"				\
-	"\21b16"				\
-	"\20b15"				\
-	"\17b14"				\
-	"\16b13"				\
-	"\15b12"				\
-	"\14b11"				\
-	"\13b10"				\
-	"\12b9"					\
-	"\11b8"					\
-	"\10b7"					\
-	"\07b6"					\
-	"\06b5"					\
-	"\05b4"					\
-	"\04b3"					\
-	"\03b2"					\
-	"\02b1"					\
+	"\020"			\
+	"\40b31"		\
+	"\37b30"		\
+	"\36b29"		\
+	"\35b28"		\
+	"\34b27"		\
+	"\33b26"		\
+	"\32b25"		\
+	"\31b24"		\
+	"\30b23"		\
+	"\27b22"		\
+	"\26b21"		\
+	"\25b20"		\
+	"\24b19"		\
+	"\23b18"		\
+	"\22b17"		\
+	"\21b16"		\
+	"\20b15"		\
+	"\17b14"		\
+	"\16b13"		\
+	"\15b12"		\
+	"\14b11"		\
+	"\13b10"		\
+	"\12b9"			\
+	"\11b8"			\
+	"\10b7"			\
+	"\07b6"			\
+	"\06b5"			\
+	"\05b4"			\
+	"\04b3"			\
+	"\03b2"			\
+	"\02b1"			\
 	"\01b0"
 
 /* MII Control Register 0x0 */
 #define BCE_BMCR_PRINTFB	\
-	"\020"					\
-	"\20Reset"				\
-	"\17Loopback"			\
-	"\16Spd0"				\
-	"\15AnegEna"			\
-	"\14PwrDn"				\
-	"\13Isolate"			\
-	"\12RstrtAneg"			\
-	"\11FD"					\
-	"\10CollTst"			\
-	"\07Spd1"				\
-	"\06Rsrvd"				\
-	"\05Rsrvd"				\
-	"\04Rsrvd"				\
-	"\03Rsrvd"				\
-	"\02Rsrvd"				\
+	"\020"			\
+	"\20Reset"		\
+	"\17Loopback"		\
+	"\16Spd0"		\
+	"\15AnegEna"		\
+	"\14PwrDn"		\
+	"\13Isolate"		\
+	"\12RstrtAneg"		\
+	"\11FD"			\
+	"\10CollTst"		\
+	"\07Spd1"		\
+	"\06Rsrvd"		\
+	"\05Rsrvd"		\
+	"\04Rsrvd"		\
+	"\03Rsrvd"		\
+	"\02Rsrvd"		\
 	"\01Rsrvd"
 
 /* MII Status Register 0x1 */
 #define BCE_BMSR_PRINTFB	\
-	"\020"					\
-	"\20Cap100T4"			\
-	"\17Cap100XFD"			\
-	"\16Cap100XHD"			\
-	"\15Cap10FD"			\
-	"\14Cap10HD"			\
-	"\13Cap100T2FD"			\
-	"\12Cap100T2HD"			\
-	"\11ExtStsPrsnt"		\
-	"\10Rsrvd"				\
-	"\07PrmblSupp"			\
-	"\06AnegCmpl"			\
-	"\05RemFaultDet"		\
-	"\04AnegCap"			\
-	"\03LnkUp"				\
-	"\02JabberDet"			\
+	"\020"			\
+	"\20Cap100T4"		\
+	"\17Cap100XFD"		\
+	"\16Cap100XHD"		\
+	"\15Cap10FD"		\
+	"\14Cap10HD"		\
+	"\13Cap100T2FD"		\
+	"\12Cap100T2HD"		\
+	"\11ExtStsPrsnt"	\
+	"\10Rsrvd"		\
+	"\07PrmblSupp"		\
+	"\06AnegCmpl"		\
+	"\05RemFaultDet"	\
+	"\04AnegCap"		\
+	"\03LnkUp"		\
+	"\02JabberDet"		\
 	"\01ExtCapSupp"
 
 /* MII Autoneg Advertisement Register 0x4 */
 #define BCE_ANAR_PRINTFB	\
-	"\020"					\
-	"\20AdvNxtPg"			\
-	"\17Rsrvd"				\
-	"\16AdvRemFault"		\
-	"\15Rsrvd"				\
-	"\14AdvAsymPause"		\
-	"\13AdvPause"			\
-	"\12Adv100T4"			\
-	"\11Adv100FD"			\
-	"\10Adv100HD"			\
-	"\07Adv10FD"			\
-	"\06Adv10HD"			\
-	"\05Rsrvd"				\
-	"\04Rsrvd"				\
-	"\03Rsrvd"				\
-	"\02Rsrvd"				\
+	"\020"			\
+	"\20AdvNxtPg"		\
+	"\17Rsrvd"		\
+	"\16AdvRemFault"	\
+	"\15Rsrvd"		\
+	"\14AdvAsymPause"	\
+	"\13AdvPause"		\
+	"\12Adv100T4"		\
+	"\11Adv100FD"		\
+	"\10Adv100HD"		\
+	"\07Adv10FD"		\
+	"\06Adv10HD"		\
+	"\05Rsrvd"		\
+	"\04Rsrvd"		\
+	"\03Rsrvd"		\
+	"\02Rsrvd"		\
 	"\01Adv802.3"
 
 /* MII Autoneg Link Partner Ability Register 0x5 */
 #define BCE_ANLPAR_PRINTFB	\
-	"\020"					\
-	"\20CapNxtPg"			\
-	"\17Ack"				\
-	"\16CapRemFault"	 	\
-	"\15Rsrvd"				\
-	"\14CapAsymPause"		\
-	"\13CapPause"			\
-	"\12Cap100T4"			\
-	"\11Cap100FD"			\
-	"\10Cap100HD"			\
-	"\07Cap10FD"			\
-	"\06Cap10HD"			\
-	"\05Rsrvd"				\
-	"\04Rsrvd"				\
-	"\03Rsrvd"				\
-	"\02Rsrvd"				\
+	"\020"			\
+	"\20CapNxtPg"		\
+	"\17Ack"		\
+	"\16CapRemFault"	\
+	"\15Rsrvd"		\
+	"\14CapAsymPause"	\
+	"\13CapPause"		\
+	"\12Cap100T4"		\
+	"\11Cap100FD"		\
+	"\10Cap100HD"		\
+	"\07Cap10FD"		\
+	"\06Cap10HD"		\
+	"\05Rsrvd"		\
+	"\04Rsrvd"		\
+	"\03Rsrvd"		\
+	"\02Rsrvd"		\
 	"\01Cap802.3"
 
 /* 1000Base-T Control Register 0x09 */
 #define BCE_1000CTL_PRINTFB	\
-	"\020"					\
-	"\20Test3"				\
-	"\17Test2"				\
-	"\16Test1"				\
-	"\15MasterSlave"		\
-	"\14ForceMaster"		\
-	"\13SwitchDev" 			\
-	"\12Adv1000TFD"			\
-	"\11Adv1000THD"			\
-	"\10Rsrvd"				\
-	"\07Rsrvd"				\
-	"\06Rsrvd"				\
-	"\05Rsrvd"				\
-	"\04Rsrvd"				\
-	"\03Rsrvd"				\
-	"\02Rsrvd"				\
+	"\020"			\
+	"\20Test3"		\
+	"\17Test2"		\
+	"\16Test1"		\
+	"\15MasterSlave"	\
+	"\14ForceMaster"	\
+	"\13SwitchDev" 		\
+	"\12Adv1000TFD"		\
+	"\11Adv1000THD"		\
+	"\10Rsrvd"		\
+	"\07Rsrvd"		\
+	"\06Rsrvd"		\
+	"\05Rsrvd"		\
+	"\04Rsrvd"		\
+	"\03Rsrvd"		\
+	"\02Rsrvd"		\
 	"\01Rsrvd"
 
 /* MII 1000Base-T Status Register 0x0a */
 #define BCE_1000STS_PRINTFB	\
-	"\020"					\
-	"\20MstrSlvFault"		\
-	"\17Master"				\
-	"\16LclRcvrOk"			\
-	"\15RemRcvrOk"			\
-	"\14Cap1000FD"			\
-	"\13Cpa1000HD"			\
-	"\12Rsrvd"				\
+	"\020"			\
+	"\20MstrSlvFault"	\
+	"\17Master"		\
+	"\16LclRcvrOk"		\
+	"\15RemRcvrOk"		\
+	"\14Cap1000FD"		\
+	"\13Cpa1000HD"		\
+	"\12Rsrvd"		\
 	"\11Rsrvd"
 
 /* MII Extended Status Register 0x0f */
 #define BCE_EXTSTS_PRINTFB	\
-	"\020"					\
-	"\20b15"				\
-	"\17b14"				\
-	"\16b13"				\
-	"\15b12"				\
-	"\14Rsrvd"				\
-	"\13Rsrvd"				\
-	"\12Rsrvd"				\
-	"\11Rsrvd"				\
-	"\10Rsrvd"				\
-	"\07Rsrvd"				\
-	"\06Rsrvd" 				\
-	"\05Rsrvd"				\
-	"\04Rsrvd"				\
-	"\03Rsrvd"				\
-	"\02Rsrvd"				\
+	"\020"			\
+	"\20b15"		\
+	"\17b14"		\
+	"\16b13"		\
+	"\15b12"		\
+	"\14Rsrvd"		\
+	"\13Rsrvd"		\
+	"\12Rsrvd"		\
+	"\11Rsrvd"		\
+	"\10Rsrvd"		\
+	"\07Rsrvd"		\
+	"\06Rsrvd" 		\
+	"\05Rsrvd"		\
+	"\04Rsrvd"		\
+	"\03Rsrvd"		\
+	"\02Rsrvd"		\
 	"\01Rsrvd"
 
 /* MII Autoneg Link Partner Ability Register 0x19 */
 #define BCE_AUXSTS_PRINTFB	\
-	"\020"					\
-	"\20AnegCmpl"			\
-	"\17AnegCmplAck"		\
-	"\16AnegAckDet"			\
-	"\15AnegAblDet"			\
-	"\14AnegNextPgWait"		\
-	"\13HCD"				\
-	"\12HCD" 				\
-	"\11HCD" 				\
-	"\10PrlDetFault"		\
-	"\07RemFault"			\
-	"\06PgRcvd"				\
+	"\020"			\
+	"\20AnegCmpl"		\
+	"\17AnegCmplAck"	\
+	"\16AnegAckDet"		\
+	"\15AnegAblDet"		\
+	"\14AnegNextPgWait"	\
+	"\13HCD"		\
+	"\12HCD" 		\
+	"\11HCD" 		\
+	"\10PrlDetFault"	\
+	"\07RemFault"		\
+	"\06PgRcvd"		\
 	"\05LnkPrtnrAnegAbl"	\
-	"\04LnkPrtnrNPAbl"		\
-	"\03LnkUp"				\
-	"\02EnaPauseRcv"		\
+	"\04LnkPrtnrNPAbl"	\
+	"\03LnkUp"		\
+	"\02EnaPauseRcv"	\
 	"\01EnaPausXmit"
 
-/* Remove before release. */
-/* #define BCE_DEBUG 1 */
-/* #define BCE_NVRAM_WRITE_SUPPORT */
+/* 
+ * Remove before release: 
+ *
+ * #define BCE_DEBUG
+ * #define BCE_NVRAM_WRITE_SUPPORT
+ * #define BCE_JUMBO_HDRSPLIT
+ */
 
 /****************************************************************************/
 /* Debugging macros and definitions.                                        */
 /****************************************************************************/
 
-#define BCE_CP_LOAD 			0x00000001
-#define BCE_CP_SEND		 		0x00000002
-#define BCE_CP_RECV				0x00000004
-#define BCE_CP_INTR				0x00000008
-#define BCE_CP_UNLOAD			0x00000010
-#define BCE_CP_RESET			0x00000020
-#define BCE_CP_PHY				0x00000040
-#define BCE_CP_NVRAM			0x00000080
-#define BCE_CP_FIRMWARE			0x00000100
-#define BCE_CP_CTX				0x00000200
-#define BCE_CP_REG				0x00000400
-#define BCE_CP_MISC				0x00400000
-#define BCE_CP_SPECIAL			0x00800000
-#define BCE_CP_ALL				0x00FFFFFF
+#define BCE_CP_LOAD 		0x00000001
+#define BCE_CP_SEND		0x00000002
+#define BCE_CP_RECV		0x00000004
+#define BCE_CP_INTR		0x00000008
+#define BCE_CP_UNLOAD		0x00000010
+#define BCE_CP_RESET		0x00000020
+#define BCE_CP_PHY		0x00000040
+#define BCE_CP_NVRAM		0x00000080
+#define BCE_CP_FIRMWARE		0x00000100
+#define BCE_CP_CTX		0x00000200
+#define BCE_CP_REG		0x00000400
+#define BCE_CP_MISC		0x00400000
+#define BCE_CP_SPECIAL		0x00800000
+#define BCE_CP_ALL		0x00FFFFFF
 
-#define BCE_CP_MASK				0x00FFFFFF
+#define BCE_CP_MASK		0x00FFFFFF
 
-#define BCE_LEVEL_FATAL			0x00000000
-#define BCE_LEVEL_WARN			0x01000000
-#define BCE_LEVEL_INFO			0x02000000
-#define BCE_LEVEL_VERBOSE		0x03000000
-#define BCE_LEVEL_EXTREME		0x04000000
-#define BCE_LEVEL_INSANE		0x05000000
+#define BCE_LEVEL_FATAL		0x00000000
+#define BCE_LEVEL_WARN		0x01000000
+#define BCE_LEVEL_INFO		0x02000000
+#define BCE_LEVEL_VERBOSE	0x03000000
+#define BCE_LEVEL_EXTREME	0x04000000
+#define BCE_LEVEL_INSANE	0x05000000
 
-#define BCE_LEVEL_MASK			0xFF000000
+#define BCE_LEVEL_MASK		0xFF000000
 
-#define BCE_WARN_LOAD			(BCE_CP_LOAD | BCE_LEVEL_WARN)
-#define BCE_INFO_LOAD			(BCE_CP_LOAD | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_LOAD		(BCE_CP_LOAD | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_LOAD		(BCE_CP_LOAD | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_LOAD			(BCE_CP_LOAD | BCE_LEVEL_INSANE)
+#define BCE_WARN_LOAD		(BCE_CP_LOAD | BCE_LEVEL_WARN)
+#define BCE_INFO_LOAD		(BCE_CP_LOAD | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_LOAD	(BCE_CP_LOAD | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_LOAD	(BCE_CP_LOAD | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_LOAD		(BCE_CP_LOAD | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_SEND			(BCE_CP_SEND | BCE_LEVEL_WARN)
-#define BCE_INFO_SEND			(BCE_CP_SEND | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_SEND		(BCE_CP_SEND | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_SEND		(BCE_CP_SEND | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_SEND			(BCE_CP_SEND | BCE_LEVEL_INSANE)
+#define BCE_WARN_SEND		(BCE_CP_SEND | BCE_LEVEL_WARN)
+#define BCE_INFO_SEND		(BCE_CP_SEND | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_SEND	(BCE_CP_SEND | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_SEND	(BCE_CP_SEND | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_SEND		(BCE_CP_SEND | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_RECV			(BCE_CP_RECV | BCE_LEVEL_WARN)
-#define BCE_INFO_RECV			(BCE_CP_RECV | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_RECV		(BCE_CP_RECV | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_RECV		(BCE_CP_RECV | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_RECV			(BCE_CP_RECV | BCE_LEVEL_INSANE)
+#define BCE_WARN_RECV		(BCE_CP_RECV | BCE_LEVEL_WARN)
+#define BCE_INFO_RECV		(BCE_CP_RECV | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_RECV	(BCE_CP_RECV | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_RECV	(BCE_CP_RECV | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_RECV		(BCE_CP_RECV | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_INTR			(BCE_CP_INTR | BCE_LEVEL_WARN)
-#define BCE_INFO_INTR			(BCE_CP_INTR | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_INTR		(BCE_CP_INTR | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_INTR		(BCE_CP_INTR | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_INTR			(BCE_CP_INTR | BCE_LEVEL_INSANE)
+#define BCE_WARN_INTR		(BCE_CP_INTR | BCE_LEVEL_WARN)
+#define BCE_INFO_INTR		(BCE_CP_INTR | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_INTR	(BCE_CP_INTR | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_INTR	(BCE_CP_INTR | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_INTR		(BCE_CP_INTR | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_UNLOAD			(BCE_CP_UNLOAD | BCE_LEVEL_WARN)
-#define BCE_INFO_UNLOAD			(BCE_CP_UNLOAD | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_UNLOAD		(BCE_CP_UNLOAD | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_UNLOAD		(BCE_CP_UNLOAD | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_UNLOAD		(BCE_CP_UNLOAD | BCE_LEVEL_INSANE)
+#define BCE_WARN_UNLOAD		(BCE_CP_UNLOAD | BCE_LEVEL_WARN)
+#define BCE_INFO_UNLOAD		(BCE_CP_UNLOAD | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_UNLOAD	(BCE_CP_UNLOAD | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_UNLOAD	(BCE_CP_UNLOAD | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_UNLOAD	(BCE_CP_UNLOAD | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_RESET			(BCE_CP_RESET | BCE_LEVEL_WARN)
-#define BCE_INFO_RESET			(BCE_CP_RESET | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_RESET		(BCE_CP_RESET | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_RESET		(BCE_CP_RESET | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_RESET		(BCE_CP_RESET | BCE_LEVEL_INSANE)
+#define BCE_WARN_RESET		(BCE_CP_RESET | BCE_LEVEL_WARN)
+#define BCE_INFO_RESET		(BCE_CP_RESET | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_RESET	(BCE_CP_RESET | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_RESET	(BCE_CP_RESET | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_RESET	(BCE_CP_RESET | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_PHY			(BCE_CP_PHY | BCE_LEVEL_WARN)
-#define BCE_INFO_PHY			(BCE_CP_PHY | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_PHY			(BCE_CP_PHY | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_PHY			(BCE_CP_PHY | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_PHY			(BCE_CP_PHY | BCE_LEVEL_INSANE)
+#define BCE_WARN_PHY		(BCE_CP_PHY | BCE_LEVEL_WARN)
+#define BCE_INFO_PHY		(BCE_CP_PHY | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_PHY		(BCE_CP_PHY | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_PHY		(BCE_CP_PHY | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_PHY		(BCE_CP_PHY | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_NVRAM			(BCE_CP_NVRAM | BCE_LEVEL_WARN)
-#define BCE_INFO_NVRAM			(BCE_CP_NVRAM | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_NVRAM		(BCE_CP_NVRAM | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_NVRAM		(BCE_CP_NVRAM | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_NVRAM		(BCE_CP_NVRAM | BCE_LEVEL_INSANE)
+#define BCE_WARN_NVRAM		(BCE_CP_NVRAM | BCE_LEVEL_WARN)
+#define BCE_INFO_NVRAM		(BCE_CP_NVRAM | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_NVRAM	(BCE_CP_NVRAM | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_NVRAM	(BCE_CP_NVRAM | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_NVRAM	(BCE_CP_NVRAM | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_FIRMWARE		(BCE_CP_FIRMWARE | BCE_LEVEL_WARN)
-#define BCE_INFO_FIRMWARE		(BCE_CP_FIRMWARE | BCE_LEVEL_INFO)
+#define BCE_WARN_FIRMWARE	(BCE_CP_FIRMWARE | BCE_LEVEL_WARN)
+#define BCE_INFO_FIRMWARE	(BCE_CP_FIRMWARE | BCE_LEVEL_INFO)
 #define BCE_VERBOSE_FIRMWARE	(BCE_CP_FIRMWARE | BCE_LEVEL_VERBOSE)
 #define BCE_EXTREME_FIRMWARE	(BCE_CP_FIRMWARE | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_FIRMWARE		(BCE_CP_FIRMWARE | BCE_LEVEL_INSANE)
+#define BCE_INSANE_FIRMWARE	(BCE_CP_FIRMWARE | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_CTX			(BCE_CP_CTX | BCE_LEVEL_WARN)
-#define BCE_INFO_CTX			(BCE_CP_CTX | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_CTX			(BCE_CP_CTX | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_CTX			(BCE_CP_CTX | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_CTX			(BCE_CP_CTX | BCE_LEVEL_INSANE)
+#define BCE_WARN_CTX		(BCE_CP_CTX | BCE_LEVEL_WARN)
+#define BCE_INFO_CTX		(BCE_CP_CTX | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_CTX		(BCE_CP_CTX | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_CTX		(BCE_CP_CTX | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_CTX		(BCE_CP_CTX | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_REG			(BCE_CP_REG | BCE_LEVEL_WARN)
-#define BCE_INFO_REG			(BCE_CP_REG | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_REG			(BCE_CP_REG | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_REG			(BCE_CP_REG | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_REG			(BCE_CP_REG | BCE_LEVEL_INSANE)
+#define BCE_WARN_REG		(BCE_CP_REG | BCE_LEVEL_WARN)
+#define BCE_INFO_REG		(BCE_CP_REG | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_REG		(BCE_CP_REG | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_REG		(BCE_CP_REG | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_REG		(BCE_CP_REG | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_MISC			(BCE_CP_MISC | BCE_LEVEL_WARN)
-#define BCE_INFO_MISC			(BCE_CP_MISC | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_MISC		(BCE_CP_MISC | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_MISC		(BCE_CP_MISC | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_MISC			(BCE_CP_MISC | BCE_LEVEL_INSANE)
+#define BCE_WARN_MISC		(BCE_CP_MISC | BCE_LEVEL_WARN)
+#define BCE_INFO_MISC		(BCE_CP_MISC | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_MISC	(BCE_CP_MISC | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_MISC	(BCE_CP_MISC | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_MISC		(BCE_CP_MISC | BCE_LEVEL_INSANE)
 
-#define BCE_WARN_SPECIAL		(BCE_CP_SPECIAL | BCE_LEVEL_WARN)
-#define BCE_INFO_SPECIAL		(BCE_CP_SPECIAL | BCE_LEVEL_INFO)
-#define BCE_VERBOSE_SPECIAL		(BCE_CP_SPECIAL | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME_SPECIAL		(BCE_CP_SPECIAL | BCE_LEVEL_EXTREME)
-#define BCE_INSANE_SPECIAL		(BCE_CP_SPECIAL | BCE_LEVEL_INSANE)
+#define BCE_WARN_SPECIAL	(BCE_CP_SPECIAL | BCE_LEVEL_WARN)
+#define BCE_INFO_SPECIAL	(BCE_CP_SPECIAL | BCE_LEVEL_INFO)
+#define BCE_VERBOSE_SPECIAL	(BCE_CP_SPECIAL | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME_SPECIAL	(BCE_CP_SPECIAL | BCE_LEVEL_EXTREME)
+#define BCE_INSANE_SPECIAL	(BCE_CP_SPECIAL | BCE_LEVEL_INSANE)
 
-#define BCE_FATAL				(BCE_CP_ALL | BCE_LEVEL_FATAL)
-#define BCE_WARN				(BCE_CP_ALL | BCE_LEVEL_WARN)
-#define BCE_INFO				(BCE_CP_ALL | BCE_LEVEL_INFO)
-#define BCE_VERBOSE				(BCE_CP_ALL | BCE_LEVEL_VERBOSE)
-#define BCE_EXTREME				(BCE_CP_ALL | BCE_LEVEL_EXTREME)
-#define BCE_INSANE				(BCE_CP_ALL | BCE_LEVEL_INSANE)
+#define BCE_FATAL		(BCE_CP_ALL | BCE_LEVEL_FATAL)
+#define BCE_WARN		(BCE_CP_ALL | BCE_LEVEL_WARN)
+#define BCE_INFO		(BCE_CP_ALL | BCE_LEVEL_INFO)
+#define BCE_VERBOSE		(BCE_CP_ALL | BCE_LEVEL_VERBOSE)
+#define BCE_EXTREME		(BCE_CP_ALL | BCE_LEVEL_EXTREME)
+#define BCE_INSANE		(BCE_CP_ALL | BCE_LEVEL_INSANE)
 
-#define BCE_CODE_PATH(cp)		((cp & BCE_CP_MASK) & bce_debug)
-#define BCE_MSG_LEVEL(lv)		((lv & BCE_LEVEL_MASK) <= (bce_debug & BCE_LEVEL_MASK))
-#define BCE_LOG_MSG(m)			(BCE_CODE_PATH(m) && BCE_MSG_LEVEL(m))
+#define BCE_CODE_PATH(cp)	((cp & BCE_CP_MASK) & bce_debug)
+#define BCE_MSG_LEVEL(lv)	\
+    ((lv & BCE_LEVEL_MASK) <= (bce_debug & BCE_LEVEL_MASK))
+#define BCE_LOG_MSG(m)		(BCE_CODE_PATH(m) && BCE_MSG_LEVEL(m))
 
 #ifdef BCE_DEBUG
 
-/*
- * Calculate the time delta between two reads
- * of the 25MHz free running clock.
- */
-#define BCE_TIME_DELTA(start, end)	(start > end ? (start - end) : \
-	(~start + end + 1))
-
 /* Print a message based on the logging level and code path. */
-#define DBPRINT(sc, level, format, args...)					\
-	if (BCE_LOG_MSG(level)) {							\
-		device_printf(sc->bce_dev, format, ## args);						\
+#define DBPRINT(sc, level, format, args...)			\
+	if (BCE_LOG_MSG(level)) {				\
+		device_printf(sc->bce_dev, format, ## args);	\
 	}
 
 /* Runs a particular command when debugging is enabled. */
-#define DBRUN(args...)			\
-	do {						\
-		args;					\
+#define DBRUN(args...)						\
+	do {							\
+		args;						\
 	} while (0)
 
 /* Runs a particular command based on the logging level and code path. */
-#define DBRUNMSG(msg, args...)	\
-	if (BCE_LOG_MSG(msg)) {		\
-		args;					\
+#define DBRUNMSG(msg, args...)					\
+	if (BCE_LOG_MSG(msg)) {					\
+		args;						\
 	}
 
 /* Runs a particular command based on the logging level. */
-#define DBRUNLV(level, args...) \
-	if (BCE_MSG_LEVEL(level)) { \
-		args;					\
+#define DBRUNLV(level, args...) 				\
+	if (BCE_MSG_LEVEL(level)) { 				\
+		args;						\
 	}
 
 /* Runs a particular command based on the code path. */
-#define DBRUNCP(cp, args...) 	\
-	if (BCE_CODE_PATH(cp)) { 	\
-		args; 					\
+#define DBRUNCP(cp, args...) 					\
+	if (BCE_CODE_PATH(cp)) { 				\
+		args; 						\
 	}
 
 /* Runs a particular command based on a condition. */
-#define DBRUNIF(cond, args...)									\
-	if (cond) {													\
-		args;													\
+#define DBRUNIF(cond, args...)					\
+	if (cond) {						\
+		args;						\
 	}
 
 /* Announces function entry. */
-#define DBENTER(cond)									  		\
+#define DBENTER(cond)						\
 	DBPRINT(sc, (cond), "%s(enter)\n", __FUNCTION__)
 
 /* Announces function exit. */
-#define DBEXIT(cond)											\
+#define DBEXIT(cond)						\
 	DBPRINT(sc, (cond), "%s(exit)\n", __FUNCTION__)
 
 /* Temporarily override the debug level. */
-#define DBPUSH(cond)											\
-	u32 bce_debug_temp = bce_debug;								\
+#define DBPUSH(cond)						\
+	u32 bce_debug_temp = bce_debug;				\
 	bce_debug |= cond;
 
 /* Restore the previously overriden debug level. */
@@ -482,43 +480,43 @@
 #define DB_OR_RANDOMTRUE(defects)   || (random() < defects)
 #define DB_AND_RANDOMTRUE(defects)  && (random() < defects)
 
-#define DB_PRINT_PHY_REG(reg, val)											\
-	switch(reg) {															\
-		case 0x00: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (BMCR   ), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_BMCR_PRINTFB); break;										\
-		case 0x01: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (BMSR   ), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_BMSR_PRINTFB); break;										\
-		case 0x04: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (ANAR   ), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_ANAR_PRINTFB); break;										\
-		case 0x05: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (ANLPAR ), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_ANLPAR_PRINTFB); break;										\
-		case 0x09: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (1000CTL), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_1000CTL_PRINTFB); break;									\
-		case 0x0a: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (1000STS), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_1000STS_PRINTFB); break;									\
-		case 0x0f: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (EXTSTS ), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_EXTSTS_PRINTFB); break;										\
-		case 0x19: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X (AUXSTS ), val = 0x%b\n",			\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,		\
-			BCE_AUXSTS_PRINTFB); break;										\
-		default: DBPRINT(sc, BCE_INSANE_PHY,								\
-			"%s(): phy = %d, reg = 0x%04X, val = 0x%04X\n",					\
-			__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff);		\
+#define DB_PRINT_PHY_REG(reg, val)					\
+switch(reg) {								\
+case 0x00: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (BMCR   ), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_BMCR_PRINTFB); break;					\
+case 0x01: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (BMSR   ), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_BMSR_PRINTFB); break;					\
+case 0x04: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (ANAR   ), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_ANAR_PRINTFB); break;					\
+case 0x05: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (ANLPAR ), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_ANLPAR_PRINTFB); break;					\
+case 0x09: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (1000CTL), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_1000CTL_PRINTFB); break;					\
+case 0x0a: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (1000STS), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_1000STS_PRINTFB); break;					\
+case 0x0f: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (EXTSTS ), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_EXTSTS_PRINTFB); break;					\
+case 0x19: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X (AUXSTS ), val = 0x%b\n",		\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff,	\
+	BCE_AUXSTS_PRINTFB); break;					\
+default: DBPRINT(sc, BCE_INSANE_PHY,					\
+	"%s(): phy = %d, reg = 0x%04X, val = 0x%04X\n",			\
+	__FUNCTION__, phy, (u16) reg & 0xffff, (u16) val & 0xffff);	\
 	}
 
 #else
@@ -560,55 +558,55 @@
 /* Device identification definitions.                                       */
 /****************************************************************************/
 #define BRCM_VENDORID				0x14E4
-#define BRCM_DEVICEID_BCM5706		0x164A
-#define BRCM_DEVICEID_BCM5706S		0x16AA
-#define BRCM_DEVICEID_BCM5708		0x164C
-#define BRCM_DEVICEID_BCM5708S		0x16AC
-#define BRCM_DEVICEID_BCM5709		0x1639
-#define BRCM_DEVICEID_BCM5709S		0x163A
-#define BRCM_DEVICEID_BCM5716		0x163B
+#define BRCM_DEVICEID_BCM5706			0x164A
+#define BRCM_DEVICEID_BCM5706S			0x16AA
+#define BRCM_DEVICEID_BCM5708			0x164C
+#define BRCM_DEVICEID_BCM5708S			0x16AC
+#define BRCM_DEVICEID_BCM5709			0x1639
+#define BRCM_DEVICEID_BCM5709S			0x163A
+#define BRCM_DEVICEID_BCM5716			0x163B
 
-#define HP_VENDORID					0x103C
+#define HP_VENDORID				0x103C
 
-#define PCI_ANY_ID					(u_int16_t) (~0U)
+#define PCI_ANY_ID				(u_int16_t) (~0U)
 
 /* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
 
-#define BCE_CHIP_NUM(sc)			(((sc)->bce_chipid) & 0xffff0000)
-#define BCE_CHIP_NUM_5706			0x57060000
-#define BCE_CHIP_NUM_5708			0x57080000
-#define BCE_CHIP_NUM_5709			0x57090000
-#define BCE_CHIP_NUM_5716			0x57160000
+#define BCE_CHIP_NUM(sc)		(((sc)->bce_chipid) & 0xffff0000)
+#define BCE_CHIP_NUM_5706		0x57060000
+#define BCE_CHIP_NUM_5708		0x57080000
+#define BCE_CHIP_NUM_5709		0x57090000
+#define BCE_CHIP_NUM_5716		0x57160000
 
-#define BCE_CHIP_REV(sc)			(((sc)->bce_chipid) & 0x0000f000)
-#define BCE_CHIP_REV_Ax				0x00000000
-#define BCE_CHIP_REV_Bx				0x00001000
-#define BCE_CHIP_REV_Cx				0x00002000
+#define BCE_CHIP_REV(sc)		(((sc)->bce_chipid) & 0x0000f000)
+#define BCE_CHIP_REV_Ax			0x00000000
+#define BCE_CHIP_REV_Bx			0x00001000
+#define BCE_CHIP_REV_Cx			0x00002000
 
-#define BCE_CHIP_METAL(sc)			(((sc)->bce_chipid) & 0x00000ff0)
-#define BCE_CHIP_BOND(bp)			(((sc)->bce_chipid) & 0x0000000f)
+#define BCE_CHIP_METAL(sc)		(((sc)->bce_chipid) & 0x00000ff0)
+#define BCE_CHIP_BOND(bp)		(((sc)->bce_chipid) & 0x0000000f)
 
-#define BCE_CHIP_ID(sc)				(((sc)->bce_chipid) & 0xfffffff0)
-#define BCE_CHIP_ID_5706_A0			0x57060000
-#define BCE_CHIP_ID_5706_A1			0x57060010
-#define BCE_CHIP_ID_5706_A2			0x57060020
-#define BCE_CHIP_ID_5706_A3			0x57060030
-#define BCE_CHIP_ID_5708_A0			0x57080000
-#define BCE_CHIP_ID_5708_B0			0x57081000
-#define BCE_CHIP_ID_5708_B1			0x57081010
-#define BCE_CHIP_ID_5708_B2			0x57081020
-#define BCE_CHIP_ID_5709_A0			0x57090000
-#define BCE_CHIP_ID_5709_A1			0x57090010
-#define BCE_CHIP_ID_5709_B0			0x57091000
-#define BCE_CHIP_ID_5709_B1			0x57091010
-#define BCE_CHIP_ID_5709_B2			0x57091020
-#define BCE_CHIP_ID_5709_C0			0x57092000
-#define BCE_CHIP_ID_5716_C0			0x57162000
+#define BCE_CHIP_ID(sc)			(((sc)->bce_chipid) & 0xfffffff0)
+#define BCE_CHIP_ID_5706_A0		0x57060000
+#define BCE_CHIP_ID_5706_A1		0x57060010
+#define BCE_CHIP_ID_5706_A2		0x57060020
+#define BCE_CHIP_ID_5706_A3		0x57060030
+#define BCE_CHIP_ID_5708_A0		0x57080000
+#define BCE_CHIP_ID_5708_B0		0x57081000
+#define BCE_CHIP_ID_5708_B1		0x57081010
+#define BCE_CHIP_ID_5708_B2		0x57081020
+#define BCE_CHIP_ID_5709_A0		0x57090000
+#define BCE_CHIP_ID_5709_A1		0x57090010
+#define BCE_CHIP_ID_5709_B0		0x57091000
+#define BCE_CHIP_ID_5709_B1		0x57091010
+#define BCE_CHIP_ID_5709_B2		0x57091020
+#define BCE_CHIP_ID_5709_C0		0x57092000
+#define BCE_CHIP_ID_5716_C0		0x57162000
 
 #define BCE_CHIP_BOND_ID(sc)		(((sc)->bce_chipid) & 0xf)
 
 /* A serdes chip will have the first bit of the bond id set. */
-#define BCE_CHIP_BOND_ID_SERDES_BIT		0x01
+#define BCE_CHIP_BOND_ID_SERDES_BIT	0x01
 
 
 /* shorthand one */
@@ -623,11 +621,11 @@
 #define BCE_CHIPREV_5701_AX		0x00
 
 struct bce_type {
-	u_int16_t		bce_vid;
-	u_int16_t		bce_did;
-	u_int16_t		bce_svid;
-	u_int16_t		bce_sdid;
-	char			*bce_name;
+	u_int16_t bce_vid;
+	u_int16_t bce_did;
+	u_int16_t bce_svid;
+	u_int16_t bce_sdid;
+	char      *bce_name;
 };
 
 /****************************************************************************/
@@ -669,44 +667,43 @@ struct bce_type {
 /****************************************************************************/
 
 /* Buffered flash (Atmel: AT45DB011B) specific information */
-#define SEEPROM_PAGE_BITS				2
-#define SEEPROM_PHY_PAGE_SIZE			(1 << SEEPROM_PAGE_BITS)
-#define SEEPROM_BYTE_ADDR_MASK			(SEEPROM_PHY_PAGE_SIZE-1)
-#define SEEPROM_PAGE_SIZE				4
-#define SEEPROM_TOTAL_SIZE				65536
+#define SEEPROM_PAGE_BITS		2
+#define SEEPROM_PHY_PAGE_SIZE		(1 << SEEPROM_PAGE_BITS)
+#define SEEPROM_BYTE_ADDR_MASK		(SEEPROM_PHY_PAGE_SIZE-1)
+#define SEEPROM_PAGE_SIZE		4
+#define SEEPROM_TOTAL_SIZE		65536
 
-#define BUFFERED_FLASH_PAGE_BITS		9
+#define BUFFERED_FLASH_PAGE_BITS	9
 #define BUFFERED_FLASH_PHY_PAGE_SIZE	(1 << BUFFERED_FLASH_PAGE_BITS)
 #define BUFFERED_FLASH_BYTE_ADDR_MASK	(BUFFERED_FLASH_PHY_PAGE_SIZE-1)
-#define BUFFERED_FLASH_PAGE_SIZE		264
-#define BUFFERED_FLASH_TOTAL_SIZE		0x21000
+#define BUFFERED_FLASH_PAGE_SIZE	264
+#define BUFFERED_FLASH_TOTAL_SIZE	0x21000
 
-#define SAIFUN_FLASH_PAGE_BITS			8
-#define SAIFUN_FLASH_PHY_PAGE_SIZE		(1 << SAIFUN_FLASH_PAGE_BITS)
-#define SAIFUN_FLASH_BYTE_ADDR_MASK		(SAIFUN_FLASH_PHY_PAGE_SIZE-1)
-#define SAIFUN_FLASH_PAGE_SIZE			256
+#define SAIFUN_FLASH_PAGE_BITS		8
+#define SAIFUN_FLASH_PHY_PAGE_SIZE	(1 << SAIFUN_FLASH_PAGE_BITS)
+#define SAIFUN_FLASH_BYTE_ADDR_MASK	(SAIFUN_FLASH_PHY_PAGE_SIZE-1)
+#define SAIFUN_FLASH_PAGE_SIZE		256
 #define SAIFUN_FLASH_BASE_TOTAL_SIZE	65536
 
-#define ST_MICRO_FLASH_PAGE_BITS		8
+#define ST_MICRO_FLASH_PAGE_BITS	8
 #define ST_MICRO_FLASH_PHY_PAGE_SIZE	(1 << ST_MICRO_FLASH_PAGE_BITS)
 #define ST_MICRO_FLASH_BYTE_ADDR_MASK	(ST_MICRO_FLASH_PHY_PAGE_SIZE-1)
-#define ST_MICRO_FLASH_PAGE_SIZE		256
+#define ST_MICRO_FLASH_PAGE_SIZE	256
 #define ST_MICRO_FLASH_BASE_TOTAL_SIZE	65536
 
-#define BCM5709_FLASH_PAGE_BITS			8
-#define BCM5709_FLASH_PHY_PAGE_SIZE		(1 << BCM5709_FLASH_PAGE_BITS)
+#define BCM5709_FLASH_PAGE_BITS		8
+#define BCM5709_FLASH_PHY_PAGE_SIZE	(1 << BCM5709_FLASH_PAGE_BITS)
 #define BCM5709_FLASH_BYTE_ADDR_MASK	(BCM5709_FLASH_PHY_PAGE_SIZE-1)
-#define BCM5709_FLASH_PAGE_SIZE			256
+#define BCM5709_FLASH_PAGE_SIZE		256
 
-#define NVRAM_TIMEOUT_COUNT				30000
-#define BCE_FLASHDESC_MAX				64
+#define NVRAM_TIMEOUT_COUNT		30000
+#define BCE_FLASHDESC_MAX		64
 
-#define FLASH_STRAP_MASK				(BCE_NVM_CFG1_FLASH_MODE | \
-										 BCE_NVM_CFG1_BUFFER_MODE  | \
-										 BCE_NVM_CFG1_PROTECT_MODE | \
-										 BCE_NVM_CFG1_FLASH_SIZE)
+#define FLASH_STRAP_MASK	(BCE_NVM_CFG1_FLASH_MODE |	\
+    BCE_NVM_CFG1_BUFFER_MODE | BCE_NVM_CFG1_PROTECT_MODE |	\
+    BCE_NVM_CFG1_FLASH_SIZE)
 
-#define FLASH_BACKUP_STRAP_MASK			(0xf << 26)
+#define FLASH_BACKUP_STRAP_MASK		(0xf << 26)
 
 struct flash_spec {
 	u32 strapping;
@@ -716,7 +713,7 @@ struct flash_spec {
 	u32 write1;
 #define BCE_NV_BUFFERED		0x00000001
 #define BCE_NV_TRANSLATE	0x00000002
-#define BCE_NV_WREN			0x00000004
+#define BCE_NV_WREN		0x00000004
 	u32 flags;
 	u32 page_bits;
 	u32 page_size;
@@ -746,50 +743,52 @@ struct flash_spec {
  * running and there won't be any firmware-driver synchronization during a
  * driver reset.
  */
-#define FW_ACK_TIME_OUT_MS                  1000
+#define FW_ACK_TIME_OUT_MS			1000
 
 
-#define BCE_DRV_RESET_SIGNATURE				0x00000000
+#define BCE_DRV_RESET_SIGNATURE			0x00000000
 #define BCE_DRV_RESET_SIGNATURE_MAGIC		0x4841564b /* HAVK */
 
-#define BCE_DRV_MB							0x00000004
-#define BCE_DRV_MSG_CODE			 		0xff000000
-#define BCE_DRV_MSG_CODE_RESET			 	0x01000000
-#define BCE_DRV_MSG_CODE_UNLOAD		 		0x02000000
-#define BCE_DRV_MSG_CODE_SHUTDOWN		 	0x03000000
+#define BCE_DRV_MB				0x00000004
+#define BCE_DRV_MSG_CODE	 		0xff000000
+#define BCE_DRV_MSG_CODE_RESET		 	0x01000000
+#define BCE_DRV_MSG_CODE_UNLOAD			0x02000000
+#define BCE_DRV_MSG_CODE_SHUTDOWN	 	0x03000000
 #define BCE_DRV_MSG_CODE_SUSPEND_WOL		0x04000000
-#define BCE_DRV_MSG_CODE_FW_TIMEOUT		 	0x05000000
-#define BCE_DRV_MSG_CODE_PULSE			 	0x06000000
-#define BCE_DRV_MSG_CODE_DIAG			 	0x07000000
+#define BCE_DRV_MSG_CODE_FW_TIMEOUT	 	0x05000000
+#define BCE_DRV_MSG_CODE_PULSE		 	0x06000000
+#define BCE_DRV_MSG_CODE_DIAG		 	0x07000000
 #define BCE_DRV_MSG_CODE_SUSPEND_NO_WOL	 	0x09000000
 #define BCE_DRV_MSG_CODE_UNLOAD_LNK_DN		0x0b000000
 #define BCE_DRV_MSG_CODE_CMD_SET_LINK		0x10000000
 
-#define BCE_DRV_MSG_DATA			 		0x00ff0000
-#define BCE_DRV_MSG_DATA_WAIT0			 	0x00010000
-#define BCE_DRV_MSG_DATA_WAIT1				0x00020000
-#define BCE_DRV_MSG_DATA_WAIT2				0x00030000
-#define BCE_DRV_MSG_DATA_WAIT3				0x00040000
+#define BCE_DRV_MSG_DATA			0x00ff0000
+#define BCE_DRV_MSG_DATA_WAIT0		 	0x00010000
+#define BCE_DRV_MSG_DATA_WAIT1			0x00020000
+#define BCE_DRV_MSG_DATA_WAIT2			0x00030000
+#define BCE_DRV_MSG_DATA_WAIT3			0x00040000
 
-#define BCE_DRV_MSG_SEQ						0x0000ffff
+#define BCE_DRV_MSG_SEQ				0x0000ffff
 
 #define BCE_FW_MB				0x00000008
 #define BCE_FW_MSG_ACK				 0x0000ffff
 #define BCE_FW_MSG_STATUS_MASK			 0x00ff0000
 #define BCE_FW_MSG_STATUS_OK			 0x00000000
+#define BCE_FW_MSG_STATUS_INVALID_ARGS		 0x00010000
+#define BCE_FW_MSG_STATUS_DRV_PRSNT		 0x00020000
 #define BCE_FW_MSG_STATUS_FAILURE		 0x00ff0000
 
-#define BCE_LINK_STATUS			0x0000000c
+#define BCE_LINK_STATUS				0x0000000c
 #define BCE_LINK_STATUS_INIT_VALUE		 0xffffffff
-#define BCE_LINK_STATUS_LINK_UP		 0x1
+#define BCE_LINK_STATUS_LINK_UP		 	 0x1
 #define BCE_LINK_STATUS_LINK_DOWN		 0x0
 #define BCE_LINK_STATUS_SPEED_MASK		 0x1e
 #define BCE_LINK_STATUS_AN_INCOMPLETE		 (0<<1)
 #define BCE_LINK_STATUS_10HALF			 (1<<1)
 #define BCE_LINK_STATUS_10FULL			 (2<<1)
-#define BCE_LINK_STATUS_100HALF		 (3<<1)
+#define BCE_LINK_STATUS_100HALF			 (3<<1)
 #define BCE_LINK_STATUS_100BASE_T4		 (4<<1)
-#define BCE_LINK_STATUS_100FULL		 (5<<1)
+#define BCE_LINK_STATUS_100FULL			 (5<<1)
 #define BCE_LINK_STATUS_1000HALF		 (6<<1)
 #define BCE_LINK_STATUS_1000FULL		 (7<<1)
 #define BCE_LINK_STATUS_2500HALF		 (8<<1)
@@ -846,9 +845,9 @@ struct flash_spec {
 #define BCE_SHARED_HW_CFG_PHY_COPPER		 0
 #define BCE_SHARED_HW_CFG_PHY_FIBER		 0x2
 #define BCE_SHARED_HW_CFG_PHY_2_5G		 0x20
-#define BCE_SHARED_HW_CFG_PHY_BACKPLANE	 0x40
+#define BCE_SHARED_HW_CFG_PHY_BACKPLANE		 0x40
 #define BCE_SHARED_HW_CFG_LED_MODE_SHIFT_BITS	 8
-#define BCE_SHARED_HW_CFG_LED_MODE_MASK	 0x300
+#define BCE_SHARED_HW_CFG_LED_MODE_MASK		 0x300
 #define BCE_SHARED_HW_CFG_LED_MODE_MAC		 0
 #define BCE_SHARED_HW_CFG_LED_MODE_GPHY1	 0x100
 #define BCE_SHARED_HW_CFG_LED_MODE_GPHY2	 0x200
@@ -863,27 +862,27 @@ struct flash_spec {
 
 #define BCE_PORT_HW_CFG_MAC_LOWER		0x00000054
 #define BCE_PORT_HW_CFG_CONFIG			0x00000058
-#define BCE_PORT_HW_CFG_CFG_TXCTL3_MASK	 0x0000ffff
+#define BCE_PORT_HW_CFG_CFG_TXCTL3_MASK		 0x0000ffff
 #define BCE_PORT_HW_CFG_CFG_DFLT_LINK_MASK	 0x001f0000
 #define BCE_PORT_HW_CFG_CFG_DFLT_LINK_AN	 0x00000000
 #define BCE_PORT_HW_CFG_CFG_DFLT_LINK_1G	 0x00030000
 #define BCE_PORT_HW_CFG_CFG_DFLT_LINK_2_5G	 0x00040000
 
-#define BCE_PORT_HW_CFG_IMD_MAC_A_UPPER	0x00000068
-#define BCE_PORT_HW_CFG_IMD_MAC_A_LOWER	0x0000006c
-#define BCE_PORT_HW_CFG_IMD_MAC_B_UPPER	0x00000070
-#define BCE_PORT_HW_CFG_IMD_MAC_B_LOWER	0x00000074
-#define BCE_PORT_HW_CFG_ISCSI_MAC_UPPER	0x00000078
-#define BCE_PORT_HW_CFG_ISCSI_MAC_LOWER	0x0000007c
+#define BCE_PORT_HW_CFG_IMD_MAC_A_UPPER		0x00000068
+#define BCE_PORT_HW_CFG_IMD_MAC_A_LOWER		0x0000006c
+#define BCE_PORT_HW_CFG_IMD_MAC_B_UPPER		0x00000070
+#define BCE_PORT_HW_CFG_IMD_MAC_B_LOWER		0x00000074
+#define BCE_PORT_HW_CFG_ISCSI_MAC_UPPER		0x00000078
+#define BCE_PORT_HW_CFG_ISCSI_MAC_LOWER		0x0000007c
 
 #define BCE_DEV_INFO_PER_PORT_HW_CONFIG2	0x000000b4
 
-#define BCE_DEV_INFO_FORMAT_REV		0x000000c4
+#define BCE_DEV_INFO_FORMAT_REV			0x000000c4
 #define BCE_DEV_INFO_FORMAT_REV_MASK		 0xff000000
 #define BCE_DEV_INFO_FORMAT_REV_ID		 ('A' << 24)
 
 #define BCE_SHARED_FEATURE			0x000000c8
-#define BCE_SHARED_FEATURE_MASK		 0xffffffff
+#define BCE_SHARED_FEATURE_MASK			 0xffffffff
 
 #define BCE_PORT_FEATURE			0x000000d8
 #define BCE_PORT2_FEATURE			0x00000014c
@@ -891,12 +890,12 @@ struct flash_spec {
 #define BCE_PORT_FEATURE_MBA_ENABLED		 0x02000000
 #define BCE_PORT_FEATURE_ASF_ENABLED		 0x04000000
 #define BCE_PORT_FEATURE_IMD_ENABLED		 0x08000000
-#define BCE_PORT_FEATURE_BAR1_SIZE_MASK	 0xf
+#define BCE_PORT_FEATURE_BAR1_SIZE_MASK		 0xf
 #define BCE_PORT_FEATURE_BAR1_SIZE_DISABLED	 0x0
 #define BCE_PORT_FEATURE_BAR1_SIZE_64K		 0x1
-#define BCE_PORT_FEATURE_BAR1_SIZE_128K	 0x2
-#define BCE_PORT_FEATURE_BAR1_SIZE_256K	 0x3
-#define BCE_PORT_FEATURE_BAR1_SIZE_512K	 0x4
+#define BCE_PORT_FEATURE_BAR1_SIZE_128K		 0x2
+#define BCE_PORT_FEATURE_BAR1_SIZE_256K		 0x3
+#define BCE_PORT_FEATURE_BAR1_SIZE_512K		 0x4
 #define BCE_PORT_FEATURE_BAR1_SIZE_1M		 0x5
 #define BCE_PORT_FEATURE_BAR1_SIZE_2M		 0x6
 #define BCE_PORT_FEATURE_BAR1_SIZE_4M		 0x7
@@ -904,9 +903,9 @@ struct flash_spec {
 #define BCE_PORT_FEATURE_BAR1_SIZE_16M		 0x9
 #define BCE_PORT_FEATURE_BAR1_SIZE_32M		 0xa
 #define BCE_PORT_FEATURE_BAR1_SIZE_64M		 0xb
-#define BCE_PORT_FEATURE_BAR1_SIZE_128M	 0xc
-#define BCE_PORT_FEATURE_BAR1_SIZE_256M	 0xd
-#define BCE_PORT_FEATURE_BAR1_SIZE_512M	 0xe
+#define BCE_PORT_FEATURE_BAR1_SIZE_128M		 0xc
+#define BCE_PORT_FEATURE_BAR1_SIZE_256M		 0xd
+#define BCE_PORT_FEATURE_BAR1_SIZE_512M		 0xe
 #define BCE_PORT_FEATURE_BAR1_SIZE_1G		 0xf
 
 #define BCE_PORT_FEATURE_WOL			0xdc
@@ -921,12 +920,12 @@ struct flash_spec {
 #define BCE_PORT_FEATURE_WOL_LINK_SPEED_AUTONEG	 0
 #define BCE_PORT_FEATURE_WOL_LINK_SPEED_10HALF	 1
 #define BCE_PORT_FEATURE_WOL_LINK_SPEED_10FULL	 2
-#define BCE_PORT_FEATURE_WOL_LINK_SPEED_100HALF 3
-#define BCE_PORT_FEATURE_WOL_LINK_SPEED_100FULL 4
+#define BCE_PORT_FEATURE_WOL_LINK_SPEED_100HALF	 3
+#define BCE_PORT_FEATURE_WOL_LINK_SPEED_100FULL	 4
 #define BCE_PORT_FEATURE_WOL_LINK_SPEED_1000HALF	 5
 #define BCE_PORT_FEATURE_WOL_LINK_SPEED_1000FULL	 6
 #define BCE_PORT_FEATURE_WOL_AUTONEG_ADVERTISE_1000	 0x40
-#define BCE_PORT_FEATURE_WOL_RESERVED_PAUSE_CAP 0x400
+#define BCE_PORT_FEATURE_WOL_RESERVED_PAUSE_CAP	 0x400
 #define BCE_PORT_FEATURE_WOL_RESERVED_ASYM_PAUSE_CAP	 0x800
 
 #define BCE_PORT_FEATURE_MBA			0xe0
@@ -943,9 +942,9 @@ struct flash_spec {
 #define BCE_PORT_FEATURE_MBA_LINK_SPEED_10FULL	 0x8
 #define BCE_PORT_FEATURE_MBA_LINK_SPEED_100HALF	 0xc
 #define BCE_PORT_FEATURE_MBA_LINK_SPEED_100FULL	 0x10
-#define BCE_PORT_FEATURE_MBA_LINK_SPEED_1000HALF	 0x14
-#define BCE_PORT_FEATURE_MBA_LINK_SPEED_1000FULL	 0x18
-#define BCE_PORT_FEATURE_MBA_SETUP_PROMPT_ENABLE	 0x40
+#define BCE_PORT_FEATURE_MBA_LINK_SPEED_1000HALF 0x14
+#define BCE_PORT_FEATURE_MBA_LINK_SPEED_1000FULL 0x18
+#define BCE_PORT_FEATURE_MBA_SETUP_PROMPT_ENABLE 0x40
 #define BCE_PORT_FEATURE_MBA_HOTKEY_CTRL_S	 0
 #define BCE_PORT_FEATURE_MBA_HOTKEY_CTRL_B	 0x80
 #define BCE_PORT_FEATURE_MBA_EXP_ROM_SIZE_SHIFT_BITS	 8
@@ -985,36 +984,37 @@ struct flash_spec {
 #define BCE_PORT_FEATURE_MBA_VLAN_TAG_MASK	 0xffff
 #define BCE_PORT_FEATURE_MBA_VLAN_ENABLE	 0x10000
 
-#define BCE_MFW_VER_PTR			0x00000014c
+#define BCE_MFW_VER_PTR				0x00000014c
 
-#define BCE_BC_STATE_RESET_TYPE		0x000001c0
+#define BCE_BC_STATE_RESET_TYPE			0x000001c0
 #define BCE_BC_STATE_RESET_TYPE_SIG		 0x00005254
 #define BCE_BC_STATE_RESET_TYPE_SIG_MASK	 0x0000ffff
-#define BCE_BC_STATE_RESET_TYPE_NONE	 (BCE_BC_STATE_RESET_TYPE_SIG | \
-					  0x00010000)
-#define BCE_BC_STATE_RESET_TYPE_PCI	 (BCE_BC_STATE_RESET_TYPE_SIG | \
-					  0x00020000)
-#define BCE_BC_STATE_RESET_TYPE_VAUX	 (BCE_BC_STATE_RESET_TYPE_SIG | \
-					  0x00030000)
-#define BCE_BC_STATE_RESET_TYPE_DRV_MASK	 DRV_MSG_CODE
-#define BCE_BC_STATE_RESET_TYPE_DRV_RESET (BCE_BC_STATE_RESET_TYPE_SIG | \
-					    DRV_MSG_CODE_RESET)
-#define BCE_BC_STATE_RESET_TYPE_DRV_UNLOAD (BCE_BC_STATE_RESET_TYPE_SIG | \
-					     DRV_MSG_CODE_UNLOAD)
-#define BCE_BC_STATE_RESET_TYPE_DRV_SHUTDOWN (BCE_BC_STATE_RESET_TYPE_SIG | \
-					       DRV_MSG_CODE_SHUTDOWN)
-#define BCE_BC_STATE_RESET_TYPE_DRV_WOL (BCE_BC_STATE_RESET_TYPE_SIG | \
-					  DRV_MSG_CODE_WOL)
-#define BCE_BC_STATE_RESET_TYPE_DRV_DIAG (BCE_BC_STATE_RESET_TYPE_SIG | \
-					   DRV_MSG_CODE_DIAG)
-#define BCE_BC_STATE_RESET_TYPE_VALUE(msg) (BCE_BC_STATE_RESET_TYPE_SIG | \
-					     (msg))
 
-#define BCE_BC_RESET_TYPE				0x000001c0
+#define BCE_BC_STATE_RESET_TYPE_NONE 			\
+    (BCE_BC_STATE_RESET_TYPE_SIG | 0x00010000)
+#define BCE_BC_STATE_RESET_TYPE_PCI			\
+    (BCE_BC_STATE_RESET_TYPE_SIG | 0x00020000)
+#define BCE_BC_STATE_RESET_TYPE_VAUX			\
+    (BCE_BC_STATE_RESET_TYPE_SIG | 0x00030000)
+#define BCE_BC_STATE_RESET_TYPE_DRV_MASK DRV_MSG_CODE
+#define BCE_BC_STATE_RESET_TYPE_DRV_RESET		\
+    (BCE_BC_STATE_RESET_TYPE_SIG | DRV_MSG_CODE_RESET)
+#define BCE_BC_STATE_RESET_TYPE_DRV_UNLOAD		\
+    (BCE_BC_STATE_RESET_TYPE_SIG | DRV_MSG_CODE_UNLOAD)
+#define BCE_BC_STATE_RESET_TYPE_DRV_SHUTDOWN		\
+    (BCE_BC_STATE_RESET_TYPE_SIG | DRV_MSG_CODE_SHUTDOWN)
+#define BCE_BC_STATE_RESET_TYPE_DRV_WOL			\
+    (BCE_BC_STATE_RESET_TYPE_SIG | DRV_MSG_CODE_WOL)
+#define BCE_BC_STATE_RESET_TYPE_DRV_DIAG		\
+    (BCE_BC_STATE_RESET_TYPE_SIG | DRV_MSG_CODE_DIAG)
+#define BCE_BC_STATE_RESET_TYPE_VALUE(msg)		\
+    (BCE_BC_STATE_RESET_TYPE_SIG | (msg))
+
+#define BCE_BC_RESET_TYPE			0x000001c0
 
-#define BCE_BC_STATE					0x000001c4
+#define BCE_BC_STATE				0x000001c4
 #define BCE_BC_STATE_ERR_MASK			0x0000ff00
-#define BCE_BC_STATE_SIGN				0x42530000
+#define BCE_BC_STATE_SIGN			0x42530000
 #define BCE_BC_STATE_SIGN_MASK			0xffff0000
 #define BCE_BC_STATE_BC1_START			(BCE_BC_STATE_SIGN | 0x1)
 #define BCE_BC_STATE_GET_NVM_CFG1		(BCE_BC_STATE_SIGN | 0x2)
@@ -1034,24 +1034,49 @@ struct flash_spec {
 #define BCE_BC_STATE_RT_SET_WOL			(BCE_BC_STATE_SIGN | 0x87)
 #define BCE_BC_STATE_RT_OTHER_FW		(BCE_BC_STATE_SIGN | 0x88)
 #define BCE_BC_STATE_RT_GOING_D3		(BCE_BC_STATE_SIGN | 0x89)
-#define BCE_BC_STATE_ERR_BAD_VERSION	(BCE_BC_STATE_SIGN | 0x0100)
-#define BCE_BC_STATE_ERR_BAD_BC2_CRC	(BCE_BC_STATE_SIGN | 0x0200)
+#define BCE_BC_STATE_ERR_BAD_VERSION		(BCE_BC_STATE_SIGN | 0x0100)
+#define BCE_BC_STATE_ERR_BAD_BC2_CRC		(BCE_BC_STATE_SIGN | 0x0200)
 #define BCE_BC_STATE_ERR_BC1_LOOP		(BCE_BC_STATE_SIGN | 0x0300)
-#define BCE_BC_STATE_ERR_UNKNOWN_CMD	(BCE_BC_STATE_SIGN | 0x0400)
+#define BCE_BC_STATE_ERR_UNKNOWN_CMD		(BCE_BC_STATE_SIGN | 0x0400)
 #define BCE_BC_STATE_ERR_DRV_DEAD		(BCE_BC_STATE_SIGN | 0x0500)
 #define BCE_BC_STATE_ERR_NO_RXP			(BCE_BC_STATE_SIGN | 0x0600)
-#define BCE_BC_STATE_ERR_TOO_MANY_RBUF	(BCE_BC_STATE_SIGN | 0x0700)
+#define BCE_BC_STATE_ERR_TOO_MANY_RBUF		(BCE_BC_STATE_SIGN | 0x0700)
 
-#define BCE_BC_STATE_CONDITION	        0x000001c8
-#define BCE_CONDITION_MFW_RUN_UNKNOWN   0x00000000
-#define BCE_CONDITION_MFW_RUN_IPMI	    0x00002000
-#define BCE_CONDITION_MFW_RUN_UMP	    0x00004000
-#define BCE_CONDITION_MFW_RUN_NCSI	    0x00006000
+#define BCE_BC_STATE_CONDITION			0x000001c8
+#define BCE_CONDITION_INIT_POR			0x00000001
+#define BCE_CONDITION_INIT_VAUX_AVAIL		0x00000002
+#define BCE_CONDITION_INIT_PCI_AVAIL		0x00000004
+#define BCE_CONDITION_INIT_PCI_RESET		0x00000008
+#define BCE_CONDITION_INIT_HD_RESET		0x00000010 /* 5709/16 only */
+#define BCE_CONDITION_DRV_PRESENT		0x00000100
+#define BCE_CONDITION_LOW_POWER_LINK		0x00000200
+#define BCE_CONDITION_CORE_RST_OCCURRED		0x00000400 /* 5709/16 only */
+#define BCE_CONDITION_UNUSED			0x00000800
+#define BCE_CONDITION_BUSY_EXPROM		0x00001000 /* 5706/08 only */
+
+#define BCE_CONDITION_MFW_RUN_UNKNOWN		0x00000000
+#define BCE_CONDITION_MFW_RUN_IPMI		0x00002000
+#define BCE_CONDITION_MFW_RUN_UMP		0x00004000
+#define BCE_CONDITION_MFW_RUN_NCSI		0x00006000
 #define BCE_CONDITION_MFW_RUN_NONE		0x0000e000
 #define BCE_CONDITION_MFW_RUN_MASK		0x0000e000
 
-#define BCE_BC_STATE_DEBUG_CMD					0x1dc
-#define BCE_BC_STATE_BC_DBG_CMD_SIGNATURE		0x42440000
+/* 5709/16 only */
+#define BCE_CONDITION_PM_STATE_MASK		0x00030000
+#define BCE_CONDITION_PM_STATE_FULL		0x00030000
+#define BCE_CONDITION_PM_STATE_PREP		0x00020000
+#define BCE_CONDITION_PM_STATE_UNPREP		0x00010000
+#define BCE_CONDITION_PM_RESERVED		0x00000000
+
+/* 5709/16 only */
+#define BCE_CONDITION_RXMODE_KEEP_VLAN		0x00040000
+#define BCE_CONDITION_DRV_WOL_ENABLED		0x00080000
+#define BCE_CONDITION_PORT_DISABLED		0x00100000
+#define BCE_CONDITION_DRV_MAYBE_OUT		0x00200000
+#define BCE_CONDITION_DPFW_DEAD			0x00400000
+
+#define BCE_BC_STATE_DEBUG_CMD			0x000001dc
+#define BCE_BC_STATE_BC_DBG_CMD_SIGNATURE	0x42440000
 #define BCE_BC_STATE_BC_DBG_CMD_SIGNATURE_MASK	0xffff0000
 #define BCE_BC_STATE_BC_DBG_CMD_LOOP_CNT_MASK	0xffff
 #define BCE_BC_STATE_BC_DBG_CMD_LOOP_INFINITE	0xffff
@@ -1067,40 +1092,51 @@ struct flash_spec {
 /****************************************************************************/
 /* Convenience definitions.                                                 */
 /****************************************************************************/
-#define BCE_PRINTF(fmt, args...)	device_printf(sc->bce_dev, fmt, ##args)
+#define BCE_PRINTF(fmt, args...)			\
+    device_printf(sc->bce_dev, fmt, ##args)
 
-#define	BCE_LOCK_INIT(_sc, _name)	mtx_init(&(_sc)->bce_mtx, _name, MTX_NETWORK_LOCK, MTX_DEF)
-#define	BCE_LOCK(_sc)				mtx_lock(&(_sc)->bce_mtx)
+#define	BCE_LOCK_INIT(_sc, _name)			\
+    mtx_init(&(_sc)->bce_mtx, _name, MTX_NETWORK_LOCK, MTX_DEF)
+#define	BCE_LOCK(_sc)			mtx_lock(&(_sc)->bce_mtx)
 #define	BCE_LOCK_ASSERT(_sc)		mtx_assert(&(_sc)->bce_mtx, MA_OWNED)
-#define	BCE_UNLOCK(_sc)				mtx_unlock(&(_sc)->bce_mtx)
+#define	BCE_UNLOCK(_sc)			mtx_unlock(&(_sc)->bce_mtx)
 #define	BCE_LOCK_DESTROY(_sc)		mtx_destroy(&(_sc)->bce_mtx)
 
 #ifdef BCE_DEBUG
-#define REG_WR(sc, offset, val)		bce_reg_wr(sc, offset, val)
-#define REG_WR16(sc, offset, val)	bce_reg_wr16(sc, offset, val)
-#define REG_RD(sc, offset)			bce_reg_rd(sc, offset)
+#define	REG_WR(sc, offset, val)		bce_reg_wr(sc, offset, val)
+#define	REG_WR16(sc, offset, val)	bce_reg_wr16(sc, offset, val)
+#define	REG_RD(sc, offset)		bce_reg_rd(sc, offset)
 #else
-#define REG_WR(sc, offset, val)		bus_space_write_4(sc->bce_btag, sc->bce_bhandle, offset, val)
-#define REG_WR16(sc, offset, val)	bus_space_write_2(sc->bce_btag, sc->bce_bhandle, offset, val)
-#define REG_RD(sc, offset)		 	bus_space_read_4(sc->bce_btag, sc->bce_bhandle, offset)
+#define	REG_WR(sc, offset, val)				\
+    bus_space_write_4(sc->bce_btag, sc->bce_bhandle, offset, val)
+#define	REG_WR16(sc, offset, val)			\
+    bus_space_write_2(sc->bce_btag, sc->bce_bhandle, offset, val)
+#define	REG_RD(sc, offset)	 			\
+    bus_space_read_4(sc->bce_btag, sc->bce_bhandle, offset)
 #endif
 
-#define REG_RD_IND(sc, offset)		bce_reg_rd_ind(sc, offset)
-#define REG_WR_IND(sc, offset, val)	bce_reg_wr_ind(sc, offset, val)
-#define CTX_WR(sc, cid_addr, offset, val)	bce_ctx_wr(sc, cid_addr, offset, val)
-#define CTX_RD(sc, cid_addr, offset)		bce_ctx_rd(sc, cid_addr, offset)
-#define BCE_SETBIT(sc, reg, x)		REG_WR(sc, reg, (REG_RD(sc, reg) | (x)))
-#define BCE_CLRBIT(sc, reg, x)		REG_WR(sc, reg, (REG_RD(sc, reg) & ~(x)))
-#define PCI_SETBIT(dev, reg, x, s)	pci_write_config(dev, reg, (pci_read_config(dev, reg, s) | (x)), s)
-#define PCI_CLRBIT(dev, reg, x, s)	pci_write_config(dev, reg, (pci_read_config(dev, reg, s) & ~(x)), s)
+#define	REG_RD_IND(sc, offset)		bce_reg_rd_ind(sc, offset)
+#define	REG_WR_IND(sc, offset, val)	bce_reg_wr_ind(sc, offset, val)
+#define	CTX_WR(sc, cid_addr, offset, val)bce_ctx_wr(sc, cid_addr, offset, val)
+#define	CTX_RD(sc, cid_addr, offset)	bce_ctx_rd(sc, cid_addr, offset)
+
+#define	BCE_SETBIT(sc, reg, x)				\
+    REG_WR(sc, reg, (REG_RD(sc, reg) | (x)))
+#define	BCE_CLRBIT(sc, reg, x)				\
+    REG_WR(sc, reg, (REG_RD(sc, reg) & ~(x)))
+#define	PCI_SETBIT(dev, reg, x, s)			\
+    pci_write_config(dev, reg, (pci_read_config(dev, reg, s) | (x)), s)
+#define	PCI_CLRBIT(dev, reg, x, s)			\
+    pci_write_config(dev, reg, (pci_read_config(dev, reg, s) & ~(x)), s)
+
+#define	BCE_STATS(x)			(u_long) stats->stat_ ## x ## _lo
 
-#define BCE_STATS(x)			(u_long) stats->stat_ ## x ## _lo
 #if (BUS_SPACE_MAXADDR > 0xFFFFFFFF)
-#define BCE_ADDR_LO(y)			((u64) (y) & 0xFFFFFFFF)
-#define BCE_ADDR_HI(y)			((u64) (y) >> 32)
+#define	BCE_ADDR_LO(y)			((u64) (y) & 0xFFFFFFFF)
+#define	BCE_ADDR_HI(y)			((u64) (y) >> 32)
 #else
-#define BCE_ADDR_LO(y)			((u32)y)
-#define BCE_ADDR_HI(y)			(0)
+#define	BCE_ADDR_LO(y)			((u32)y)
+#define	BCE_ADDR_HI(y)			(0)
 #endif
 
 
@@ -1166,7 +1202,7 @@ struct status_block {
 		#define STATUS_ATTN_BITS_TX_PATCHUP_ABORT	(1L<<6)
 		#define STATUS_ATTN_BITS_TX_ASSEMBLER_ABORT	(1L<<7)
 		#define STATUS_ATTN_BITS_RX_PARSER_MAC_ABORT	(1L<<8)
-		#define STATUS_ATTN_BITS_RX_PARSER_CATCHUP_ABORT	(1L<<9)
+		#define STATUS_ATTN_BITS_RX_PARSER_CATCHUP_ABORT (1L<<9)
 		#define STATUS_ATTN_BITS_RX_MBUF_ABORT		(1L<<10)
 		#define STATUS_ATTN_BITS_RX_LOOKUP_ABORT	(1L<<11)
 		#define STATUS_ATTN_BITS_RX_PROCESSOR_ABORT	(1L<<12)
@@ -1369,90 +1405,90 @@ struct l2_fhdr {
 };
 
 #define BCE_L2FHDR_PRINTFB	\
-	"\20"					\
-	"\40UDP_XSUM_ERR"		\
-	"\37b30"				\
-	"\36b29"				\
-	"\35TCP_XSUM_ERR"		\
-	"\34b27"				\
-	"\33b26"				\
-	"\32b25"				\
-	"\31b24"				\
-	"\30b23"				\
-	"\27b22"				\
-	"\26GIANT_ERR"			\
-	"\25SHORT_ERR"			\
-	"\24ALIGN_ERR"			\
-	"\23PHY_ERR"			\
-	"\22CRC_ERR"			\
-	"\21SPLIT"				\
-	"\20UDP"				\
-	"\17TCP"				\
-	"\16IP"					\
-	"\15b12"				\
-	"\14b11"				\
-	"\13b10"				\
-	"\12b09"				\
-	"\11RSS"				\
-	"\10SNAP"				\
-	"\07VLAN"				\
-	"\06P4"					\
-	"\05P3"					\
+	"\20"			\
+	"\40UDP_XSUM_ERR"	\
+	"\37b30"		\
+	"\36b29"		\
+	"\35TCP_XSUM_ERR"	\
+	"\34b27"		\
+	"\33b26"		\
+	"\32b25"		\
+	"\31b24"		\
+	"\30b23"		\
+	"\27b22"		\
+	"\26GIANT_ERR"		\
+	"\25SHORT_ERR"		\
+	"\24ALIGN_ERR"		\
+	"\23PHY_ERR"		\
+	"\22CRC_ERR"		\
+	"\21SPLIT"		\
+	"\20UDP"		\
+	"\17TCP"		\
+	"\16IP"			\
+	"\15b12"		\
+	"\14b11"		\
+	"\13b10"		\
+	"\12b09"		\
+	"\11RSS"		\
+	"\10SNAP"		\
+	"\07VLAN"		\
+	"\06P4"			\
+	"\05P3"			\
 	"\04P2"
 
 
 /*
  *  l2_tx_context definition (5706 and 5708)
  */
-#define BCE_L2CTX_TX_TYPE			   		0x00000000
-#define BCE_L2CTX_TX_TYPE_SIZE_L2	   		((0xc0/0x20)<<16)
-#define BCE_L2CTX_TX_TYPE_TYPE		   		(0xf<<28)
-#define BCE_L2CTX_TX_TYPE_TYPE_EMPTY   		(0<<28)
-#define BCE_L2CTX_TX_TYPE_TYPE_L2	   		(1<<28)
+#define BCE_L2CTX_TX_TYPE			0x00000000
+#define BCE_L2CTX_TX_TYPE_SIZE_L2		((0xc0/0x20)<<16)
+#define BCE_L2CTX_TX_TYPE_TYPE			(0xf<<28)
+#define BCE_L2CTX_TX_TYPE_TYPE_EMPTY		(0<<28)
+#define BCE_L2CTX_TX_TYPE_TYPE_L2		(1<<28)
 
-#define BCE_L2CTX_TX_HOST_BIDX	 			0x00000088
-#define BCE_L2CTX_TX_EST_NBD		   		0x00000088
-#define BCE_L2CTX_TX_CMD_TYPE		   		0x00000088
-#define BCE_L2CTX_TX_CMD_TYPE_TYPE	   		(0xf<<24)
-#define BCE_L2CTX_TX_CMD_TYPE_TYPE_L2  		(0<<24)
-#define BCE_L2CTX_TX_CMD_TYPE_TYPE_TCP 		(1<<24)
+#define BCE_L2CTX_TX_HOST_BIDX			0x00000088
+#define BCE_L2CTX_TX_EST_NBD			0x00000088
+#define BCE_L2CTX_TX_CMD_TYPE			0x00000088
+#define BCE_L2CTX_TX_CMD_TYPE_TYPE		(0xf<<24)
+#define BCE_L2CTX_TX_CMD_TYPE_TYPE_L2		(0<<24)
+#define BCE_L2CTX_TX_CMD_TYPE_TYPE_TCP		(1<<24)
 
-#define BCE_L2CTX_TX_HOST_BSEQ				0x00000090
-#define BCE_L2CTX_TX_TSCH_BSEQ		   		0x00000094
-#define BCE_L2CTX_TX_TBDR_BSEQ		   		0x00000098
-#define BCE_L2CTX_TX_TBDR_BOFF		   		0x0000009c
-#define BCE_L2CTX_TX_TBDR_BIDX		   		0x0000009c
-#define BCE_L2CTX_TX_TBDR_BHADDR_HI			0x000000a0
-#define BCE_L2CTX_TX_TBDR_BHADDR_LO			0x000000a4
-#define BCE_L2CTX_TX_TXP_BOFF		   		0x000000a8
-#define BCE_L2CTX_TX_TXP_BIDX		   		0x000000a8
-#define BCE_L2CTX_TX_TXP_BSEQ		   		0x000000ac
+#define BCE_L2CTX_TX_HOST_BSEQ			0x00000090
+#define BCE_L2CTX_TX_TSCH_BSEQ			0x00000094
+#define BCE_L2CTX_TX_TBDR_BSEQ			0x00000098
+#define BCE_L2CTX_TX_TBDR_BOFF			0x0000009c
+#define BCE_L2CTX_TX_TBDR_BIDX			0x0000009c
+#define BCE_L2CTX_TX_TBDR_BHADDR_HI		0x000000a0
+#define BCE_L2CTX_TX_TBDR_BHADDR_LO		0x000000a4
+#define BCE_L2CTX_TX_TXP_BOFF			0x000000a8
+#define BCE_L2CTX_TX_TXP_BIDX			0x000000a8
+#define BCE_L2CTX_TX_TXP_BSEQ			0x000000ac
 
 /*
  *  l2_tx_context definition (5709 and 5716)
  */
-#define BCE_L2CTX_TX_TYPE_XI		   		0x00000080
-#define BCE_L2CTX_TX_TYPE_SIZE_L2_XI   		((0xc0/0x20)<<16)
-#define BCE_L2CTX_TX_TYPE_TYPE_XI	   		(0xf<<28)
+#define BCE_L2CTX_TX_TYPE_XI			0x00000080
+#define BCE_L2CTX_TX_TYPE_SIZE_L2_XI		((0xc0/0x20)<<16)
+#define BCE_L2CTX_TX_TYPE_TYPE_XI		(0xf<<28)
 #define BCE_L2CTX_TX_TYPE_TYPE_EMPTY_XI		(0<<28)
-#define BCE_L2CTX_TX_TYPE_TYPE_L2_XI   		(1<<28)
-										
-#define BCE_L2CTX_TX_CMD_TYPE_XI	   		0x00000240
-#define BCE_L2CTX_TX_CMD_TYPE_TYPE_XI  		(0xf<<24)
+#define BCE_L2CTX_TX_TYPE_TYPE_L2_XI		(1<<28)
+
+#define BCE_L2CTX_TX_CMD_TYPE_XI		0x00000240
+#define BCE_L2CTX_TX_CMD_TYPE_TYPE_XI		(0xf<<24)
 #define BCE_L2CTX_TX_CMD_TYPE_TYPE_L2_XI	(0<<24)
 #define BCE_L2CTX_TX_CMD_TYPE_TYPE_TCP_XI	(1<<24)
 
-#define BCE_L2CTX_TX_HOST_BIDX_XI	   		0x00000240
-#define BCE_L2CTX_TX_HOST_BSEQ_XI			0x00000248
-#define BCE_L2CTX_TX_TBDR_BHADDR_HI_XI 		0x00000258
-#define BCE_L2CTX_TX_TBDR_BHADDR_LO_XI	 	0x0000025c
+#define BCE_L2CTX_TX_HOST_BIDX_XI		0x00000240
+#define BCE_L2CTX_TX_HOST_BSEQ_XI		0x00000248
+#define BCE_L2CTX_TX_TBDR_BHADDR_HI_XI		0x00000258
+#define BCE_L2CTX_TX_TBDR_BHADDR_LO_XI		0x0000025c
 
 
 /*
  *  l2_rx_context definition (5706, 5708, 5709, and 5716)
  */
-#define BCE_L2CTX_RX_WATER_MARK				0x00000000
-#define BCE_L2CTX_RX_LO_WATER_MARK_SHIFT 	0
+#define BCE_L2CTX_RX_WATER_MARK			0x00000000
+#define BCE_L2CTX_RX_LO_WATER_MARK_SHIFT	0
 #define BCE_L2CTX_RX_LO_WATER_MARK_DEFAULT	32
 #define BCE_L2CTX_RX_LO_WATER_MARK_SCALE	4
 #define BCE_L2CTX_RX_LO_WATER_MARK_DIS		0
@@ -1460,52 +1496,53 @@ struct l2_fhdr {
 #define BCE_L2CTX_RX_HI_WATER_MARK_SCALE	16
 #define BCE_L2CTX_RX_WATER_MARKS_MSK		0x000000ff
 
-#define BCE_L2CTX_RX_BD_PRE_READ			0x00000000
+#define BCE_L2CTX_RX_BD_PRE_READ		0x00000000
 #define BCE_L2CTX_RX_BD_PRE_READ_SHIFT		8
 
-#define BCE_L2CTX_RX_CTX_SIZE				0x00000000
-#define BCE_L2CTX_RX_CTX_SIZE_SHIFT			16
-#define BCE_L2CTX_RX_CTX_TYPE_SIZE_L2		((0x20/20)<<BCE_L2CTX_RX_CTX_SIZE_SHIFT)
+#define BCE_L2CTX_RX_CTX_SIZE			0x00000000
+#define BCE_L2CTX_RX_CTX_SIZE_SHIFT		16
+#define BCE_L2CTX_RX_CTX_TYPE_SIZE_L2	\
+    ((0x20/20)<<BCE_L2CTX_RX_CTX_SIZE_SHIFT)
 
-#define BCE_L2CTX_RX_CTX_TYPE				0x00000000
-#define BCE_L2CTX_RX_CTX_TYPE_SHIFT			24
+#define BCE_L2CTX_RX_CTX_TYPE			0x00000000
+#define BCE_L2CTX_RX_CTX_TYPE_SHIFT		24
 
 #define BCE_L2CTX_RX_CTX_TYPE_CTX_BD_CHN_TYPE	(0xf<<28)
 #define BCE_L2CTX_RX_CTX_TYPE_CTX_BD_CHN_TYPE_UNDEFINED	(0<<28)
 #define BCE_L2CTX_RX_CTX_TYPE_CTX_BD_CHN_TYPE_VALUE	(1<<28)
 
-#define BCE_L2CTX_RX_HOST_BDIDX				0x00000004
-#define BCE_L2CTX_RX_HOST_BSEQ				0x00000008
-#define BCE_L2CTX_RX_NX_BSEQ				0x0000000c
-#define BCE_L2CTX_RX_NX_BDHADDR_HI			0x00000010
-#define BCE_L2CTX_RX_NX_BDHADDR_LO			0x00000014
-#define BCE_L2CTX_RX_NX_BDIDX				0x00000018
+#define BCE_L2CTX_RX_HOST_BDIDX			0x00000004
+#define BCE_L2CTX_RX_HOST_BSEQ			0x00000008
+#define BCE_L2CTX_RX_NX_BSEQ			0x0000000c
+#define BCE_L2CTX_RX_NX_BDHADDR_HI		0x00000010
+#define BCE_L2CTX_RX_NX_BDHADDR_LO		0x00000014
+#define BCE_L2CTX_RX_NX_BDIDX			0x00000018
 
-#define BCE_L2CTX_RX_HOST_PG_BDIDX			0x00000044
-#define BCE_L2CTX_RX_PG_BUF_SIZE			0x00000048
-#define BCE_L2CTX_RX_RBDC_KEY				0x0000004c
-#define BCE_L2CTX_RX_RBDC_JUMBO_KEY			0x3ffe
+#define BCE_L2CTX_RX_HOST_PG_BDIDX		0x00000044
+#define BCE_L2CTX_RX_PG_BUF_SIZE		0x00000048
+#define BCE_L2CTX_RX_RBDC_KEY			0x0000004c
+#define BCE_L2CTX_RX_RBDC_JUMBO_KEY		0x3ffe
 #define BCE_L2CTX_RX_NX_PG_BDHADDR_HI		0x00000050
 #define BCE_L2CTX_RX_NX_PG_BDHADDR_LO		0x00000054
-#define BCE_L2CTX_RX_NX_PG_BDIDX			0x00000058
+#define BCE_L2CTX_RX_NX_PG_BDIDX		0x00000058
 
 
 /*
  *  l2_mq definitions (5706, 5708, 5709, and 5716)
  */
 
-#define BCE_L2MQ_RX_HOST_BDIDX				0x00000004
-#define BCE_L2MQ_RX_HOST_BSEQ				0x00000008
-#define BCE_L2MQ_RX_HOST_PG_BDIDX			0x00000044
+#define BCE_L2MQ_RX_HOST_BDIDX			0x00000004
+#define BCE_L2MQ_RX_HOST_BSEQ			0x00000008
+#define BCE_L2MQ_RX_HOST_PG_BDIDX		0x00000044
 
-#define BCE_L2MQ_TX_HOST_BIDX				0x00000088
-#define BCE_L2MQ_TX_HOST_BSEQ				0x00000090
+#define BCE_L2MQ_TX_HOST_BIDX			0x00000088
+#define BCE_L2MQ_TX_HOST_BSEQ			0x00000090
 
 /*
  *  pci_config_l definition
  *  offset: 0000
  */
-#define BCE_PCICFG_MISC_CONFIG							0x00000068
+#define BCE_PCICFG_MISC_CONFIG				0x00000068
 #define BCE_PCICFG_MISC_CONFIG_TARGET_BYTE_SWAP	 		(1L<<2)
 #define BCE_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP	 (1L<<3)
 #define BCE_PCICFG_MISC_CONFIG_CLOCK_CTL_ENA		 (1L<<5)
@@ -6098,62 +6135,6 @@ struct l2_fhdr {
 
 #define NUM_MC_HASH_REGISTERS   8
 
-
-/* PHY_ID1: bits 31-16; PHY_ID2: bits 15-0.  */
-#define PHY_BCM5706_PHY_ID                          0x00206160
-
-#define PHY_ID(id)                                  ((id) & 0xfffffff0)
-#define PHY_REV_ID(id)                              ((id) & 0xf)
-
-/* 5708 Serdes PHY registers */
-
-#define BCM5708S_UP1				0xb
-
-#define BCM5708S_UP1_2G5			0x1
-
-#define BCM5708S_BLK_ADDR			0x1f
-
-#define BCM5708S_BLK_ADDR_DIG			0x0000
-#define BCM5708S_BLK_ADDR_DIG3			0x0002
-#define BCM5708S_BLK_ADDR_TX_MISC		0x0005
-
-/* Digital Block */
-#define BCM5708S_1000X_CTL1			0x10
-
-#define BCM5708S_1000X_CTL1_FIBER_MODE		0x0001
-#define BCM5708S_1000X_CTL1_AUTODET_EN		0x0010
-
-#define BCM5708S_1000X_CTL2			0x11
-
-#define BCM5708S_1000X_CTL2_PLLEL_DET_EN	0x0001
-
-#define BCM5708S_1000X_STAT1			0x14
-
-#define BCM5708S_1000X_STAT1_SGMII		0x0001
-#define BCM5708S_1000X_STAT1_LINK		0x0002
-#define BCM5708S_1000X_STAT1_FD			0x0004
-#define BCM5708S_1000X_STAT1_SPEED_MASK		0x0018
-#define BCM5708S_1000X_STAT1_SPEED_10		0x0000
-#define BCM5708S_1000X_STAT1_SPEED_100		0x0008
-#define BCM5708S_1000X_STAT1_SPEED_1G		0x0010
-#define BCM5708S_1000X_STAT1_SPEED_2G5		0x0018
-#define BCM5708S_1000X_STAT1_TX_PAUSE		0x0020
-#define BCM5708S_1000X_STAT1_RX_PAUSE		0x0040
-
-/* Digital3 Block */
-#define BCM5708S_DIG_3_0			0x10
-
-#define BCM5708S_DIG_3_0_USE_IEEE		0x0001
-
-/* Tx/Misc Block */
-#define BCM5708S_TX_ACTL1			0x15
-
-#define BCM5708S_TX_ACTL1_DRIVER_VCM		0x30
-
-#define BCM5708S_TX_ACTL3			0x17
-
-#define RX_COPY_THRESH			92
-
 #define DMA_READ_CHANS	5
 #define DMA_WRITE_CHANS	3
 
@@ -6162,7 +6143,8 @@ struct l2_fhdr {
 #define BCM_PAGE_BITS	PAGE_SHIFT
 #define BCM_PAGE_SIZE	PAGE_SIZE
 #define BCM_PAGE_MASK	(BCM_PAGE_SIZE - 1)
-#define BCM_PAGES(x)	((((x) + BCM_PAGE_SIZE - 1) & BCM_PAGE_MASK) >> BCM_PAGE_BITS)
+#define BCM_PAGES(x)	((((x) + BCM_PAGE_SIZE - 1) & \
+    BCM_PAGE_MASK) >> BCM_PAGE_BITS)
 
 /*
  * Page count must remain a power of 2 for all
@@ -6177,8 +6159,7 @@ struct l2_fhdr {
 
 /* Advance to the next tx_bd, skipping any next page pointers. */
 #define NEXT_TX_BD(x) (((x) & USABLE_TX_BD_PER_PAGE) ==	\
-		(USABLE_TX_BD_PER_PAGE - 1)) ?					  	\
-		(x) + 2 : (x) + 1
+    (USABLE_TX_BD_PER_PAGE - 1)) ? (x) + 2 : (x) + 1
 
 #define TX_CHAIN_IDX(x) ((x) & MAX_TX_BD)
 
@@ -6198,8 +6179,7 @@ struct l2_fhdr {
 
 /* Advance to the next rx_bd, skipping any next page pointers. */
 #define NEXT_RX_BD(x) (((x) & USABLE_RX_BD_PER_PAGE) ==	\
-		(USABLE_RX_BD_PER_PAGE - 1)) ?					\
-		(x) + 2 : (x) + 1
+    (USABLE_RX_BD_PER_PAGE - 1)) ? (x) + 2 : (x) + 1
 
 #define RX_CHAIN_IDX(x) ((x) & MAX_RX_BD)
 
@@ -6220,8 +6200,7 @@ struct l2_fhdr {
 
 /* Advance to the next pg_bd, skipping any next page pointers. */
 #define NEXT_PG_BD(x) (((x) & USABLE_PG_BD_PER_PAGE) ==	\
-		(USABLE_PG_BD_PER_PAGE - 1)) ?					\
-		(x) + 2 : (x) + 1
+    (USABLE_PG_BD_PER_PAGE - 1)) ? (x) + 2 : (x) + 1
 
 #define PG_CHAIN_IDX(x) ((x) & MAX_PG_BD)
 
@@ -6233,29 +6212,29 @@ struct l2_fhdr {
 #define CTX_INIT_RETRY_COUNT        10
 
 /* Context size. */
-#define CTX_SHIFT                   7
-#define CTX_SIZE                    (1 << CTX_SHIFT)
-#define CTX_MASK                    (CTX_SIZE - 1)
-#define GET_CID_ADDR(_cid)          ((_cid) << CTX_SHIFT)
-#define GET_CID(_cid_addr)          ((_cid_addr) >> CTX_SHIFT)
+#define CTX_SHIFT		7
+#define CTX_SIZE		(1 << CTX_SHIFT)
+#define CTX_MASK		(CTX_SIZE - 1)
+#define GET_CID_ADDR(_cid)	((_cid) << CTX_SHIFT)
+#define GET_CID(_cid_addr)	((_cid_addr) >> CTX_SHIFT)
 
-#define PHY_CTX_SHIFT               6
-#define PHY_CTX_SIZE                (1 << PHY_CTX_SHIFT)
-#define PHY_CTX_MASK                (PHY_CTX_SIZE - 1)
-#define GET_PCID_ADDR(_pcid)        ((_pcid) << PHY_CTX_SHIFT)
-#define GET_PCID(_pcid_addr)        ((_pcid_addr) >> PHY_CTX_SHIFT)
+#define PHY_CTX_SHIFT		6
+#define PHY_CTX_SIZE		(1 << PHY_CTX_SHIFT)
+#define PHY_CTX_MASK		(PHY_CTX_SIZE - 1)
+#define GET_PCID_ADDR(_pcid)	((_pcid) << PHY_CTX_SHIFT)
+#define GET_PCID(_pcid_addr)	((_pcid_addr) >> PHY_CTX_SHIFT)
 
-#define MB_KERNEL_CTX_SHIFT         8
-#define MB_KERNEL_CTX_SIZE          (1 << MB_KERNEL_CTX_SHIFT)
-#define MB_KERNEL_CTX_MASK          (MB_KERNEL_CTX_SIZE - 1)
-#define MB_GET_CID_ADDR(_cid)       (0x10000 + ((_cid) << MB_KERNEL_CTX_SHIFT))
+#define MB_KERNEL_CTX_SHIFT	8
+#define MB_KERNEL_CTX_SIZE	(1 << MB_KERNEL_CTX_SHIFT)
+#define MB_KERNEL_CTX_MASK	(MB_KERNEL_CTX_SIZE - 1)
+#define MB_GET_CID_ADDR(_cid)	(0x10000 + ((_cid) << MB_KERNEL_CTX_SHIFT))
 
-#define MAX_CID_CNT                 0x4000
-#define MAX_CID_ADDR                (GET_CID_ADDR(MAX_CID_CNT))
-#define INVALID_CID_ADDR            0xffffffff
+#define MAX_CID_CNT		0x4000
+#define MAX_CID_ADDR		(GET_CID_ADDR(MAX_CID_CNT))
+#define INVALID_CID_ADDR	0xffffffff
 
-#define TX_CID		16
-#define RX_CID		0
+#define TX_CID			16
+#define RX_CID			0
 
 /****************************************************************************/
 /* BCE Processor Firmwware Load Definitions                                 */
@@ -6318,25 +6297,27 @@ struct fw_info {
 	u32 *rodata;
 };
 
-#define RV2P_PROC1                              0
-#define RV2P_PROC2                              1
+#define RV2P_PROC1		0
+#define RV2P_PROC2		1
 
-#define BCE_MIREG(x)	((x & 0x1F) << 16)
-#define BCE_MIPHY(x)	((x & 0x1F) << 21)
-#define BCE_PHY_TIMEOUT	50
+#define BCE_MIREG(x)		((x & 0x1F) << 16)
+#define BCE_MIPHY(x)		((x & 0x1F) << 21)
+#define BCE_PHY_TIMEOUT		50
 
-#define BCE_NVRAM_SIZE 					0x200
-#define BCE_NVRAM_MAGIC					0x669955aa
-#define BCE_CRC32_RESIDUAL				0xdebb20e3
+#define BCE_NVRAM_SIZE		0x200
+#define BCE_NVRAM_MAGIC		0x669955aa
+#define BCE_CRC32_RESIDUAL	0xdebb20e3
 
-#define BCE_TX_TIMEOUT					5
+#define BCE_TX_TIMEOUT		5
 
-#define BCE_MAX_SEGMENTS				32
-#define BCE_TSO_MAX_SIZE				65536
-#define BCE_TSO_MAX_SEG_SIZE			4096
+#define BCE_MAX_SEGMENTS	32
+#define BCE_TSO_MAX_SIZE	65536
+#define BCE_TSO_MAX_SEG_SIZE	4096
 
-#define BCE_DMA_ALIGN		 			8
-#define BCE_DMA_BOUNDARY				0
+#define BCE_DMA_ALIGN		8
+#define BCE_DMA_BOUNDARY	0
+
+#define BCE_MAX_CONTEXT		4
 
 /* The BCM5708 has a problem with addresses greater that 40bits. */
 /* Handle the sizing issue in an architecture agnostic fashion.  */
@@ -6358,22 +6339,23 @@ struct fw_info {
 #endif
 
 #if __FreeBSD_version < 700000
-#define BCE_IF_CAPABILITIES (IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING | \
-							IFCAP_HWCSUM | IFCAP_JUMBO_MTU)
+#define BCE_IF_CAPABILITIES (IFCAP_VLAN_MTU | 			\
+    IFCAP_VLAN_HWTAGGING | IFCAP_HWCSUM | IFCAP_JUMBO_MTU)
 #else
-#define BCE_IF_CAPABILITIES (IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING | \
-							IFCAP_HWCSUM | IFCAP_JUMBO_MTU | IFCAP_VLAN_HWCSUM)
+#define BCE_IF_CAPABILITIES (IFCAP_VLAN_MTU |			\
+    IFCAP_VLAN_HWTAGGING | IFCAP_HWCSUM |			\
+    IFCAP_JUMBO_MTU | IFCAP_VLAN_HWCSUM)
 #endif
 
-#define BCE_MIN_MTU						60
-#define BCE_MIN_ETHER_MTU				64
+#define BCE_MIN_MTU			60
+#define BCE_MIN_ETHER_MTU		64
 
-#define BCE_MAX_STD_MTU					1500
-#define BCE_MAX_STD_ETHER_MTU			1518
-#define BCE_MAX_STD_ETHER_MTU_VLAN		1522
+#define BCE_MAX_STD_MTU			1500
+#define BCE_MAX_STD_ETHER_MTU		1518
+#define BCE_MAX_STD_ETHER_MTU_VLAN	1522
 
-#define BCE_MAX_JUMBO_MTU			 	9000
-#define BCE_MAX_JUMBO_ETHER_MTU			9018
+#define BCE_MAX_JUMBO_MTU		9000
+#define BCE_MAX_JUMBO_ETHER_MTU		9018
 #define BCE_MAX_JUMBO_ETHER_MTU_VLAN 	9022
 
 // #define BCE_MAX_MTU		ETHER_MAX_LEN_JUMBO + ETHER_VLAN_ENCAP_LEN	/* 9022 */
@@ -6382,155 +6364,206 @@ struct fw_info {
 /* BCE Device State Data Structure                                          */
 /****************************************************************************/
 
-#define BCE_STATUS_BLK_SZ		sizeof(struct status_block)
-#define BCE_STATS_BLK_SZ		sizeof(struct statistics_block)
+#define BCE_STATUS_BLK_SZ	sizeof(struct status_block)
+#define BCE_STATS_BLK_SZ	sizeof(struct statistics_block)
 #define BCE_TX_CHAIN_PAGE_SZ	BCM_PAGE_SIZE
 #define BCE_RX_CHAIN_PAGE_SZ	BCM_PAGE_SIZE
 #define BCE_PG_CHAIN_PAGE_SZ	BCM_PAGE_SIZE
 
 struct bce_softc
 {
-	/* MUST start with ifnet pointer (see definition of miibus_statchg()) */
-	struct ifnet		*bce_ifp;			/* Interface info */
-	device_t			bce_dev;			/* Parent device handle */
-	u_int8_t			bce_unit;			/* Interface number */
-	struct resource		*bce_res_mem;  		/* Device resource handle */
-	struct ifmedia		bce_ifmedia;		/* TBI media info */
-	bus_space_tag_t		bce_btag;			/* Device bus tag */
-	bus_space_handle_t	bce_bhandle;		/* Device bus handle */
-	vm_offset_t			bce_vhandle;		/* Device virtual memory handle */
-	struct resource		*bce_res_irq;		/* IRQ Resource Handle */
-	struct mtx			bce_mtx;			/* Mutex */
+	/* Interface info */
+	struct ifnet		*bce_ifp;
+
+	/* Parent device handle */
+	device_t		bce_dev;
+
+	/* Interface number */
+	u_int8_t		bce_unit;
+
+	/* Device resource handle */
+	struct resource		*bce_res_mem;
+
+	/* TBI media info */
+	struct ifmedia		bce_ifmedia;
+
+	/* Device bus tag */
+	bus_space_tag_t		bce_btag;
+
+	/* Device bus handle */
+	bus_space_handle_t	bce_bhandle;
+
+	/* Device virtual memory handle */
+	vm_offset_t		bce_vhandle;
+
+	/* IRQ Resource Handle */
+	struct resource		*bce_res_irq;
+
+	struct mtx		bce_mtx;
 
 	/* Interrupt handler. */
 	driver_intr_t		*bce_intr;
-	void				*bce_intrhand;
-	int					bce_irq_rid;
-	int					bce_msi_count;
+	void *bce_intrhand;
+	int  bce_irq_rid;
+	int  bce_msi_count;
 
 	/* ASIC Chip ID. */
-	u32					bce_chipid;
+	u32  bce_chipid;
 
 	/* General controller flags. */
-	u32					bce_flags;
-#define BCE_PCIX_FLAG				0x00000001
-#define BCE_PCI_32BIT_FLAG 			0x00000002
-#define BCE_ONE_TDMA_FLAG			0x00000004		/* Deprecated */
-#define BCE_NO_WOL_FLAG				0x00000008
-#define BCE_USING_DAC_FLAG			0x00000010
-#define BCE_USING_MSI_FLAG 			0x00000020
-#define BCE_MFW_ENABLE_FLAG			0x00000040
+	u32  bce_flags;
+#define BCE_PCIX_FLAG			0x00000001
+#define BCE_PCI_32BIT_FLAG 		0x00000002
+#define BCE_RESERVED_FLAG		0x00000004
+#define BCE_NO_WOL_FLAG			0x00000008
+#define BCE_USING_DAC_FLAG		0x00000010
+#define BCE_USING_MSI_FLAG 		0x00000020
+#define BCE_MFW_ENABLE_FLAG		0x00000040
 #define BCE_ONE_SHOT_MSI_FLAG		0x00000080
-#define BCE_USING_MSIX_FLAG			0x00000100
-#define BCE_PCIE_FLAG				0x00000200
+#define BCE_USING_MSIX_FLAG		0x00000100
+#define BCE_PCIE_FLAG			0x00000200
 
 	/* Controller capability flags. */
-	u32								bce_cap_flags;
+	u32  bce_cap_flags;
 #define BCE_MSI_CAPABLE_FLAG		0x00000001
 #define BCE_MSIX_CAPABLE_FLAG		0x00000002
 #define BCE_PCIE_CAPABLE_FLAG		0x00000004
 #define BCE_PCIX_CAPABLE_FLAG		0x00000008
 
 	/* PHY specific flags. */
-	u32					bce_phy_flags;
-#define BCE_PHY_SERDES_FLAG					0x00000001
-#define BCE_PHY_CRC_FIX_FLAG				0x00000002
-#define BCE_PHY_PARALLEL_DETECT_FLAG		0x00000004
-#define BCE_PHY_2_5G_CAPABLE_FLAG			0x00000008
-#define BCE_PHY_INT_MODE_MASK_FLAG			0x00000300
-#define BCE_PHY_INT_MODE_AUTO_POLLING_FLAG	0x00000100
-#define BCE_PHY_INT_MODE_LINK_READY_FLAG	0x00000200
-#define BCE_PHY_IEEE_CLAUSE_45_FLAG     	0x00000400
+	u32  bce_phy_flags;
+#define BCE_PHY_SERDES_FLAG		0x00000001
+#define BCE_PHY_CRC_FIX_FLAG		0x00000002
+#define BCE_PHY_PARALLEL_DETECT_FLAG	0x00000004
+#define BCE_PHY_2_5G_CAPABLE_FLAG	0x00000008
+#define BCE_PHY_INT_MODE_MASK_FLAG	0x00000300
+#define BCE_PHY_INT_MODE_AUTO_POLLING_FLAG 0x00000100
+#define BCE_PHY_INT_MODE_LINK_READY_FLAG 0x00000200
+#define BCE_PHY_IEEE_CLAUSE_45_FLAG	0x00000400
 
 	/* Values that need to be shared with the PHY driver. */
-	u32					bce_shared_hw_cfg;
-	u32					bce_port_hw_cfg;
+	u32  bce_shared_hw_cfg;
+	u32  bce_port_hw_cfg;
+
+	bus_addr_t max_bus_addr;
+
+	/* PCI bus speed */
+	u16  bus_speed_mhz;
+
+	/* PCIe link width */
+	u16  link_width;
+
+	/* PCIe link speed */
+	u16  link_speed;
+
+	/* Flash NVRAM settings */
+	struct flash_spec *bce_flash_info;
+
+	/* Flash NVRAM size */
+	u32  bce_flash_size;
 
-	bus_addr_t			max_bus_addr;
-	u16					bus_speed_mhz;		/* PCI bus speed */
-	u16					link_width;			/* PCIe link width */
-	u16					link_speed;			/* PCIe link speed */
-	struct flash_spec	*bce_flash_info;	/* Flash NVRAM settings */
-	u32					bce_flash_size;		/* Flash NVRAM size */
-	u32					bce_shmem_base;		/* Shared Memory base address */
-	char *				bce_name;			/* Name string */
+	/* Shared Memory base address */
+	u32  bce_shmem_base;		
+
+	/* Name string */
+	char * bce_name;
 
 	/* Tracks the version of bootcode firmware. */
-	char			    bce_bc_ver[32];
-    char                bce_mfw_ver[32];
+	char bce_bc_ver[32];
+
+	/* Tracks the version of management firmware. */
+	char bce_mfw_ver[32];
 
-	/* Tracks the state of the firmware.  0 = Running while any     */
-	/* other value indicates that the firmware is not responding.   */
-	u16					bce_fw_timed_out;
+	/* 
+	 * Tracks the state of the firmware.  0 = Running while any
+	 * other value indicates that the firmware is not responding.
+	 */
+	u16  bce_fw_timed_out;
 
-	/* An incrementing sequence used to coordinate messages passed   */
-	/* from the driver to the firmware.                              */
-	u16					bce_fw_wr_seq;
+	/* 
+	 * An incrementing sequence used to coordinate messages passed
+	 * from the driver to the firmware.
+	 */ 
+	u16  bce_fw_wr_seq;
 
-	/* An incrementing sequence used to let the firmware know that   */
-	/* the driver is still operating.  Without the pulse, management */
-	/* firmware such as IPMI or UMP will operate in OS absent state. */
-	u16					bce_fw_drv_pulse_wr_seq;
+	/* 
+	 * An incrementing sequence used to let the firmware know that
+	 * the driver is still operating.  Without the pulse, management
+	 * firmware such as IPMI or UMP will operate in OS absent state.
+	 */ 
+	u16  bce_fw_drv_pulse_wr_seq;
+
+	/* Tracks whether firmware has lost the driver's pulse. */
+	u16  bce_drv_cardiac_arrest;
 
 	/* Ethernet MAC address. */
-	u_char				eaddr[6];
+	u_char eaddr[6];
+
+	/* 
+	 * These setting are used by the host coalescing (HC) block to
+	 * to control how often the status block, statistics block and
+	 * interrupts are generated.
+	 */ 
+	u16  bce_tx_quick_cons_trip_int;
+	u16  bce_tx_quick_cons_trip;
+	u16  bce_rx_quick_cons_trip_int;
+	u16  bce_rx_quick_cons_trip;
+	u16  bce_tx_ticks_int;
+	u16  bce_tx_ticks;
+	u16  bce_rx_ticks_int;
+	u16  bce_rx_ticks;
+	u32  bce_stats_ticks;
 
-	/* These setting are used by the host coalescing (HC) block to   */
-	/* to control how often the status block, statistics block and   */
-	/* interrupts are generated.                                     */
-	u16					bce_tx_quick_cons_trip_int;
-	u16					bce_tx_quick_cons_trip;
-	u16					bce_rx_quick_cons_trip_int;
-	u16					bce_rx_quick_cons_trip;
-	u16					bce_comp_prod_trip_int;
-	u16					bce_comp_prod_trip;
-	u16					bce_tx_ticks_int;
-	u16					bce_tx_ticks;
-	u16					bce_rx_ticks_int;
-	u16					bce_rx_ticks;
-	u16					bce_com_ticks_int;
-	u16					bce_com_ticks;
-	u16					bce_cmd_ticks_int;
-	u16					bce_cmd_ticks;
-	u32					bce_stats_ticks;
+	/* ToDo: Can these be removed? */
+	u16  bce_comp_prod_trip_int;
+	u16  bce_comp_prod_trip;
+	u16  bce_com_ticks_int;
+	u16  bce_com_ticks;
+	u16  bce_cmd_ticks_int;
+	u16  bce_cmd_ticks;
 
 	/* The address of the integrated PHY on the MII bus. */
-	int					bce_phy_addr;
+	int  bce_phy_addr;
 
 	/* The device handle for the MII bus child device. */
-	device_t			bce_miibus;
+	device_t bce_miibus;
 
 	/* Driver maintained TX chain pointers and byte counter. */
-	u16					rx_prod;
-	u16					rx_cons;
-	u32					rx_prod_bseq;	/* Counts the bytes used.  */
-	u16					tx_prod;
-	u16					tx_cons;
-	u32					tx_prod_bseq;	/* Counts the bytes used.  */
+	u16  rx_prod;
+	u16  rx_cons;
+
+	/* Counts the bytes used in the RX chain. */
+	u32  rx_prod_bseq;
+	u16  tx_prod;
+	u16  tx_cons;
+
+	/* Counts the bytes used in the TX chain. */
+	u32  tx_prod_bseq;
 
 #ifdef BCE_JUMBO_HDRSPLIT
-	u16					pg_prod;
-	u16					pg_cons;
+	u16  pg_prod;
+	u16  pg_cons;
 #endif
 
-	int					bce_link;
-	struct callout		bce_tick_callout;
-	struct callout		bce_pulse_callout;
+	int  bce_link_up;
+	struct callout bce_tick_callout;
+	struct callout bce_pulse_callout;
 
-	int watchdog_timer;			/* ticks until chip reset */
+	/* Ticks until chip reset */
+	int watchdog_timer;
 
 	/* Frame size and mbuf allocation size for RX frames. */
-	u32					max_frame_size;
-	int					rx_bd_mbuf_alloc_size;
-	int					rx_bd_mbuf_data_len;
-	int					rx_bd_mbuf_align_pad;
+	u32  max_frame_size;
+	int  rx_bd_mbuf_alloc_size;
+	int  rx_bd_mbuf_data_len;
+	int  rx_bd_mbuf_align_pad;
 
 #ifdef BCE_JUMBO_HDRSPLIT
-	int					pg_bd_mbuf_alloc_size;
+	int  pg_bd_mbuf_alloc_size;
 #endif
 
 	/* Receive mode settings (i.e promiscuous, multicast, etc.). */
-	u32					rx_mode;
+	u32  rx_mode;
 
 	/* Bus tag for the bce controller. */
 	bus_dma_tag_t		parent_tag;
@@ -6539,46 +6572,47 @@ struct bce_softc
 	bus_dma_tag_t		tx_bd_chain_tag;
 	bus_dmamap_t		tx_bd_chain_map[TX_PAGES];
 	struct tx_bd		*tx_bd_chain[TX_PAGES];
-	bus_addr_t			tx_bd_chain_paddr[TX_PAGES];
+	bus_addr_t		tx_bd_chain_paddr[TX_PAGES];
 
 	/* H/W maintained RX buffer descriptor chain structure. */
 	bus_dma_tag_t		rx_bd_chain_tag;
 	bus_dmamap_t		rx_bd_chain_map[RX_PAGES];
 	struct rx_bd		*rx_bd_chain[RX_PAGES];
-	bus_addr_t			rx_bd_chain_paddr[RX_PAGES];
+	bus_addr_t		rx_bd_chain_paddr[RX_PAGES];
 
 #ifdef BCE_JUMBO_HDRSPLIT
 	/* H/W maintained page buffer descriptor chain structure. */
 	bus_dma_tag_t		pg_bd_chain_tag;
 	bus_dmamap_t		pg_bd_chain_map[PG_PAGES];
 	struct rx_bd		*pg_bd_chain[PG_PAGES];
-	bus_addr_t			pg_bd_chain_paddr[PG_PAGES];
+	bus_addr_t		pg_bd_chain_paddr[PG_PAGES];
 #endif
 
 	/* H/W maintained status block. */
 	bus_dma_tag_t		status_tag;
 	bus_dmamap_t		status_map;
-	struct status_block	*status_block;			/* Virtual address */
-	bus_addr_t			status_block_paddr;		/* Physical address */
+	struct status_block	*status_block;
+	bus_addr_t		status_block_paddr;
 
 	/* Driver maintained status block values. */
-	u16					last_status_idx;
-	u16					hw_rx_cons;
-	u16					hw_tx_cons;
+	u16  last_status_idx;
+	u16  hw_rx_cons;
+	u16  hw_tx_cons;
 
 	/* H/W maintained statistics block. */
 	bus_dma_tag_t		stats_tag;
 	bus_dmamap_t		stats_map;
-	struct statistics_block *stats_block;		/* Virtual address */
-	bus_addr_t			stats_block_paddr;		/* Physical address */
+	struct statistics_block *stats_block;
+	bus_addr_t		stats_block_paddr;
 
 	/* H/W maintained context block. */
-	int					ctx_pages;
+	int  ctx_pages;
 	bus_dma_tag_t		ctx_tag;
-	/* DRC - Fix hard coded value. */
-	bus_dmamap_t		ctx_map[4];
-	void				*ctx_block[4];			/* Virtual address */
-	bus_addr_t			ctx_paddr[4];			/* Physical address */
+
+	/* BCM5709/16 use host memory for context. */
+	bus_dmamap_t		ctx_map[BCE_MAX_CONTEXT];
+	void			*ctx_block[BCE_MAX_CONTEXT];
+	bus_addr_t		ctx_paddr[BCE_MAX_CONTEXT];
 
 	/* Bus tag for RX/TX mbufs. */
 	bus_dma_tag_t		rx_mbuf_tag;
@@ -6590,16 +6624,16 @@ struct bce_softc
 
 	/* S/W maintained mbuf TX chain structure. */
 	bus_dmamap_t		tx_mbuf_map[TOTAL_TX_BD];
-	struct mbuf			*tx_mbuf_ptr[TOTAL_TX_BD];
+	struct mbuf		*tx_mbuf_ptr[TOTAL_TX_BD];
 
 	/* S/W maintained mbuf RX chain structure. */
 	bus_dmamap_t		rx_mbuf_map[TOTAL_RX_BD];
-	struct mbuf			*rx_mbuf_ptr[TOTAL_RX_BD];
+	struct mbuf		*rx_mbuf_ptr[TOTAL_RX_BD];
 
 #ifdef BCE_JUMBO_HDRSPLIT
 	/* S/W maintained mbuf page chain structure. */
 	bus_dmamap_t		pg_mbuf_map[TOTAL_PG_BD];
-	struct mbuf			*pg_mbuf_ptr[TOTAL_PG_BD];
+	struct mbuf		*pg_mbuf_ptr[TOTAL_PG_BD];
 #endif
 
 	/* Track the number of buffer descriptors in use. */
@@ -6674,26 +6708,28 @@ struct bce_softc
 	u32 com_no_buffers;
 
 	/* Recoverable failure counters. */
-	u32	mbuf_alloc_failed_count;
+	u32 mbuf_alloc_failed_count;
 	u32 fragmented_mbuf_count;
-	u32	unexpected_attention_count;
+	u32 unexpected_attention_count;
 	u32 l2fhdr_error_count;
 	u32 dma_map_addr_tx_failed_count;
 	u32 dma_map_addr_rx_failed_count;
 
+	/* Host coalescing block command register */
+	u32 hc_command;
+
+	/* Bootcode state */
+	u32 bc_state;
+
 #ifdef BCE_DEBUG
 	/* Simulated recoverable failure counters. */
-	u32	mbuf_alloc_failed_sim_count;
+	u32 mbuf_alloc_failed_sim_count;
 	u32 unexpected_attention_sim_count;
 	u32 l2fhdr_error_sim_count;
-	u32	dma_map_addr_failed_sim_count;
-#endif
+	u32 dma_map_addr_failed_sim_count;
 
-	u32	hc_command;
-
-#ifdef BCE_DEBUG
 	/* Track the number of enqueued mbufs. */
-	int	debug_tx_mbuf_alloc;
+	int debug_tx_mbuf_alloc;
 	int debug_rx_mbuf_alloc;
 
 #ifdef BCE_JUMBO_HDRSPLIT
@@ -6705,23 +6741,35 @@ struct bce_softc
 	u32 interrupts_handled;
 	u32 rx_interrupts;
 	u32 tx_interrupts;
+	u32 phy_interrupts;
 
 	/* Track interrupt time (25MHz clock). */
 	u64 rx_intr_time;
 	u64 tx_intr_time;
 
-	u32	rx_low_watermark;			/* Lowest number of rx_bd's free. */
-	u32 rx_empty_count;				/* Number of times the RX chain was empty. */
+	/* Lowest number of rx_bd's free. */
+	u32 rx_low_watermark;
+
+	/* Number of times the RX chain was empty. */
+	u32 rx_empty_count;
 
 #ifdef BCE_JUMBO_HDRSPLIT
-	u32	pg_low_watermark;			/* Lowest number of pages free. */
-	u32 pg_empty_count; 			/* Number of times the page chain was empty. */
+
+	/* Lowest number of pages free. */
+	u32 pg_low_watermark;
+
+	/* Number of times the page chain was empty. */
+	u32 pg_empty_count;
 #endif
 
-	u32 tx_hi_watermark;			/* Greatest number of tx_bd's used. */
-	u32	tx_full_count;				/* Number of times the TX chain was full. */
+	/* Greatest number of tx_bd's used. */
+	u32 tx_hi_watermark;
+
+	/* Number of times the TX chain was full. */
+	u32 tx_full_count;
 
-	u32	requested_tso_frames;		/* Number of TSO frames enqueued. */
+	/* Number of TSO frames enqueued. */
+	u32 requested_tso_frames;
 #endif
 };
 
diff --git a/sys/dev/bwi/if_bwi.c b/sys/dev/bwi/if_bwi.c
index 2604d8389ed5..96c5cc6d3e51 100644
--- a/sys/dev/bwi/if_bwi.c
+++ b/sys/dev/bwi/if_bwi.c
@@ -64,8 +64,8 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_radiotap.h>
 #include <net80211/ieee80211_regdomain.h>
-#include <net80211/ieee80211_amrr.h>
 #include <net80211/ieee80211_phy.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <net/bpf.h>
 
@@ -112,9 +112,6 @@ static void	bwi_set_channel(struct ieee80211com *);
 static void	bwi_scan_end(struct ieee80211com *);
 static int	bwi_newstate(struct ieee80211vap *, enum ieee80211_state, int);
 static void	bwi_updateslot(struct ifnet *);
-static struct ieee80211_node *bwi_node_alloc(struct ieee80211vap *,
-		    const uint8_t [IEEE80211_ADDR_LEN]);
-static void	bwi_newassoc(struct ieee80211_node *, int);
 static int	bwi_media_change(struct ifnet *);
 
 static void	bwi_calibrate(void *);
@@ -525,7 +522,6 @@ bwi_attach(struct bwi_softc *sc)
 	ic->ic_vap_delete = bwi_vap_delete;
 	ic->ic_raw_xmit = bwi_raw_xmit;
 	ic->ic_updateslot = bwi_updateslot;
-	ic->ic_node_alloc = bwi_node_alloc;
 	ic->ic_scan_start = bwi_scan_start;
 	ic->ic_scan_end = bwi_scan_end;
 	ic->ic_set_channel = bwi_set_channel;
@@ -621,10 +617,7 @@ bwi_vap_create(struct ieee80211com *ic,
 #if 0
 	vap->iv_update_beacon = bwi_beacon_update;
 #endif
-	ieee80211_amrr_init(&bvp->bv_amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    500 /*ms*/);
+	ieee80211_ratectl_init(vap);
 
 	/* complete setup */
 	ieee80211_vap_attach(vap, bwi_media_change, ieee80211_media_status);
@@ -637,7 +630,7 @@ bwi_vap_delete(struct ieee80211vap *vap)
 {
 	struct bwi_vap *bvp = BWI_VAP(vap);
 
-	ieee80211_amrr_cleanup(&bvp->bv_amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(bvp, M_80211_VAP);
 }
@@ -1831,7 +1824,7 @@ bwi_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 #endif
 		if (vap->iv_opmode == IEEE80211_M_STA) {
 			/* fake a join to init the tx rate */
-			bwi_newassoc(ni, 1);
+			ic->ic_newassoc(ni, 1);
 		}
 
 		callout_reset(&sc->sc_calib_ch, hz, bwi_calibrate, sc);
@@ -1842,25 +1835,6 @@ back:
 	return error;
 }
 
-/* ARGUSED */
-static struct ieee80211_node *
-bwi_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
-{
-	struct bwi_node *bn;
-
-	bn = malloc(sizeof(struct bwi_node), M_80211_NODE, M_NOWAIT | M_ZERO);
-	return bn != NULL ? &bn->ni : NULL;
-}
-
-static void
-bwi_newassoc(struct ieee80211_node *ni, int isnew)
-{
-	struct ieee80211vap *vap = ni->ni_vap;
-
-	ieee80211_amrr_node_init(&BWI_VAP(vap)->bv_amrr,
-	    &BWI_NODE(ni)->amn, ni);
-}
-
 static int
 bwi_media_change(struct ifnet *ifp)
 {
@@ -3012,7 +2986,7 @@ bwi_encap(struct bwi_softc *sc, int idx, struct mbuf *m,
 	} else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) {
 		rate = rate_fb = tp->ucastrate;
 	} else {
-		rix = ieee80211_amrr_choose(ni, &BWI_NODE(ni)->amn);
+		rix = ieee80211_ratectl_rate(ni, NULL, pkt_len);
 		rate = ni->ni_txrate;
 
 		if (rix > 0) {
@@ -3369,6 +3343,7 @@ _bwi_txeof(struct bwi_softc *sc, uint16_t tx_id, int acked, int data_txcnt)
 	struct bwi_txbuf *tb;
 	int ring_idx, buf_idx;
 	struct ieee80211_node *ni;
+	struct ieee80211vap *vap;
 
 	if (tx_id == 0) {
 		if_printf(ifp, "%s: zero tx id\n", __func__);
@@ -3394,9 +3369,9 @@ _bwi_txeof(struct bwi_softc *sc, uint16_t tx_id, int acked, int data_txcnt)
 
 	ni = tb->tb_ni;
 	if (tb->tb_ni != NULL) {
-		struct bwi_node *bn = (struct bwi_node *) tb->tb_ni;
 		const struct bwi_txbuf_hdr *hdr =
 		    mtod(tb->tb_mbuf, const struct bwi_txbuf_hdr *);
+		vap = ni->ni_vap;
 
 		/* NB: update rate control only for unicast frames */
 		if (hdr->txh_mac_ctrl & htole32(BWI_TXH_MAC_C_ACK)) {
@@ -3407,8 +3382,9 @@ _bwi_txeof(struct bwi_softc *sc, uint16_t tx_id, int acked, int data_txcnt)
 			 * well so to avoid over-aggressive downshifting we
 			 * treat any number of retries as "1".
 			 */
-			ieee80211_amrr_tx_complete(&bn->amn, acked,
-			    data_txcnt > 1);
+			ieee80211_ratectl_tx_complete(vap, ni,
+			    (data_txcnt > 1) ? IEEE80211_RATECTL_TX_SUCCESS :
+			        IEEE80211_RATECTL_TX_FAILURE, &acked, NULL);
 		}
 
 		/*
diff --git a/sys/dev/bwi/if_bwivar.h b/sys/dev/bwi/if_bwivar.h
index 22a1b1ebb039..d5f09da6eb2f 100644
--- a/sys/dev/bwi/if_bwivar.h
+++ b/sys/dev/bwi/if_bwivar.h
@@ -533,15 +533,8 @@ struct bwi_rx_radiotap_hdr {
 	/* TODO: sq */
 };
 
-struct bwi_node {
-	struct ieee80211_node		ni;	/* must be the first */
-	struct ieee80211_amrr_node	amn;
-};
-#define	BWI_NODE(ni)	((struct bwi_node *)(ni))
-
 struct bwi_vap {
 	struct ieee80211vap	bv_vap;
-	struct ieee80211_amrr	bv_amrr;
 	int			(*bv_newstate)(struct ieee80211vap *,
 				    enum ieee80211_state, int);
 };
diff --git a/sys/dev/bwn/if_bwn.c b/sys/dev/bwn/if_bwn.c
index a48548b47681..983f9972d600 100644
--- a/sys/dev/bwn/if_bwn.c
+++ b/sys/dev/bwn/if_bwn.c
@@ -67,8 +67,8 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_radiotap.h>
 #include <net80211/ieee80211_regdomain.h>
-#include <net80211/ieee80211_amrr.h>
 #include <net80211/ieee80211_phy.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <dev/bwn/if_bwnreg.h>
 #include <dev/bwn/if_bwnvar.h>
@@ -180,18 +180,14 @@ static void	bwn_addchannels(struct ieee80211_channel [], int, int *,
 		    const struct bwn_channelinfo *, int);
 static int	bwn_raw_xmit(struct ieee80211_node *, struct mbuf *,
 		    const struct ieee80211_bpf_params *);
-static void	bwn_newassoc(struct ieee80211_node *, int);
 static void	bwn_updateslot(struct ifnet *);
 static void	bwn_update_promisc(struct ifnet *);
 static void	bwn_wme_init(struct bwn_mac *);
 static int	bwn_wme_update(struct ieee80211com *);
-static struct ieee80211_node *bwn_node_alloc(struct ieee80211vap *,
-		    const uint8_t [IEEE80211_ADDR_LEN]);
 static void	bwn_wme_clear(struct bwn_softc *);
 static void	bwn_wme_load(struct bwn_mac *);
 static void	bwn_wme_loadparams(struct bwn_mac *,
 		    const struct wmeParams *, uint16_t);
-static void	bwn_node_cleanup(struct ieee80211_node *);
 static void	bwn_scan_start(struct ieee80211com *);
 static void	bwn_scan_end(struct ieee80211com *);
 static void	bwn_set_channel(struct ieee80211com *);
@@ -1088,15 +1084,10 @@ bwn_attach_post(struct bwn_softc *sc)
 
 	/* override default methods */
 	ic->ic_raw_xmit = bwn_raw_xmit;
-	ic->ic_newassoc = bwn_newassoc;
 	ic->ic_updateslot = bwn_updateslot;
 	ic->ic_update_promisc = bwn_update_promisc;
 	ic->ic_wme.wme_update = bwn_wme_update;
 
-	ic->ic_node_alloc = bwn_node_alloc;
-	sc->sc_node_cleanup = ic->ic_node_cleanup;
-	ic->ic_node_cleanup = bwn_node_cleanup;
-
 	ic->ic_scan_start = bwn_scan_start;
 	ic->ic_scan_end = bwn_scan_end;
 	ic->ic_set_channel = bwn_set_channel;
@@ -2772,20 +2763,6 @@ bwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
 }
 
 /*
- * Setup driver-specific state for a newly associated node.
- * Note that we're called also on a re-associate, the isnew
- * param tells us if this is the first time or not.
- */
-static void
-bwn_newassoc(struct ieee80211_node *ni, int isnew)
-{
-	struct ieee80211vap *vap = ni->ni_vap;
-
-	ieee80211_amrr_node_init(&BWN_VAP(vap)->bv_amrr,
-	    &BWN_NODE(ni)->bn_amn, ni);
-}
-
-/*
  * Callback from the 802.11 layer to update the slot time
  * based on the current setting.  We use it to notify the
  * firmware of ERP changes and the f/w takes care of things
@@ -2857,32 +2834,6 @@ bwn_wme_update(struct ieee80211com *ic)
 	return (0);
 }
 
-static struct ieee80211_node *
-bwn_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
-{
-	struct ieee80211com *ic = vap->iv_ic;
-	struct bwn_softc *sc = ic->ic_ifp->if_softc;
-	const size_t space = sizeof(struct bwn_node);
-	struct bwn_node *bn;
-
-	bn = malloc(space, M_80211_NODE, M_NOWAIT|M_ZERO);
-	if (bn == NULL) {
-		/* XXX stat+msg */
-		return (NULL);
-	}
-	DPRINTF(sc, BWN_DEBUG_NODE, "%s: bn %p\n", __func__, bn);
-	return (&bn->bn_node);
-}
-
-static void
-bwn_node_cleanup(struct ieee80211_node *ni)
-{
-	struct ieee80211com *ic = ni->ni_ic;
-	struct bwn_softc *sc = ic->ic_ifp->if_softc;
-
-	sc->sc_node_cleanup(ni);
-}
-
 static void
 bwn_scan_start(struct ieee80211com *ic)
 {
@@ -3018,10 +2969,7 @@ bwn_vap_create(struct ieee80211com *ic,
 	/* override max aid so sta's cannot assoc when we're out of sta id's */
 	vap->iv_max_aid = BWN_STAID_MAX;
 
-	ieee80211_amrr_init(&bvp->bv_amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    500 /*ms*/);
+	ieee80211_ratectl_init(vap);
 
 	/* complete setup */
 	ieee80211_vap_attach(vap, ieee80211_media_change,
@@ -3034,7 +2982,7 @@ bwn_vap_delete(struct ieee80211vap *vap)
 {
 	struct bwn_vap *bvp = BWN_VAP(vap);
 
-	ieee80211_amrr_cleanup(&bvp->bv_amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(bvp, M_80211_VAP);
 }
@@ -9040,12 +8988,12 @@ bwn_handle_txeof(struct bwn_mac *mac, const struct bwn_txstatus *status)
 	struct bwn_dma_ring *dr;
 	struct bwn_dmadesc_generic *desc;
 	struct bwn_dmadesc_meta *meta;
-	struct bwn_node *bn;
 	struct bwn_pio_txqueue *tq;
 	struct bwn_pio_txpkt *tp = NULL;
 	struct bwn_softc *sc = mac->mac_sc;
 	struct bwn_stats *stats = &mac->mac_stats;
 	struct ieee80211_node *ni;
+	struct ieee80211vap *vap;
 	int slot;
 
 	BWN_ASSERT_LOCKED(mac->mac_sc);
@@ -9074,9 +9022,12 @@ bwn_handle_txeof(struct bwn_mac *mac, const struct bwn_txstatus *status)
 				dr->getdesc(dr, slot, &desc, &meta);
 				if (meta->mt_islast) {
 					ni = meta->mt_ni;
-					bn = (struct bwn_node *)ni;
-					ieee80211_amrr_tx_complete(&bn->bn_amn,
-					    status->ack, 0);
+					vap = ni->ni_vap;
+					ieee80211_ratectl_tx_complete(vap, ni,
+					    status->ack ?
+					      IEEE80211_RATECTL_TX_SUCCESS :
+					      IEEE80211_RATECTL_TX_FAILURE,
+					    NULL, 0);
 					break;
 				}
 				slot = bwn_dma_nextslot(dr, slot);
@@ -9092,8 +9043,12 @@ bwn_handle_txeof(struct bwn_mac *mac, const struct bwn_txstatus *status)
 				return;
 			}
 			ni = tp->tp_ni;
-			bn = (struct bwn_node *)ni;
-			ieee80211_amrr_tx_complete(&bn->bn_amn, status->ack, 0);
+			vap = ni->ni_vap;
+			ieee80211_ratectl_tx_complete(vap, ni,
+			    status->ack ?
+			      IEEE80211_RATECTL_TX_SUCCESS :
+			      IEEE80211_RATECTL_TX_FAILURE,
+			    NULL, 0);
 		}
 		bwn_pio_handle_txeof(mac, status);
 	}
@@ -9678,7 +9633,7 @@ bwn_set_txhdr(struct bwn_mac *mac, struct ieee80211_node *ni,
 	else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
 		rate = rate_fb = tp->ucastrate;
 	else {
-		rix = ieee80211_amrr_choose(ni, &BWN_NODE(ni)->bn_amn);
+		rix = ieee80211_ratectl_rate(ni, NULL, 0);
 		rate = ni->ni_txrate;
 
 		if (rix > 0)
diff --git a/sys/dev/bwn/if_bwnvar.h b/sys/dev/bwn/if_bwnvar.h
index 16934c3e39ea..461587dd6c37 100644
--- a/sys/dev/bwn/if_bwnvar.h
+++ b/sys/dev/bwn/if_bwnvar.h
@@ -883,18 +883,11 @@ struct bwn_mac {
 	TAILQ_ENTRY(bwn_mac)	mac_list;
 };
 
-struct bwn_node {
-	struct ieee80211_node		bn_node;	/* must be the first */
-	struct ieee80211_amrr_node	bn_amn;
-};
-#define	BWN_NODE(ni)			((struct bwn_node *)(ni))
-
 /*
  * Driver-specific vap state.
  */
 struct bwn_vap {
 	struct ieee80211vap		bv_vap;	/* base class */
-	struct ieee80211_amrr		bv_amrr;
 	int				(*bv_newstate)(struct ieee80211vap *,
 					    enum ieee80211_state, int);
 };
diff --git a/sys/dev/cxgb/cxgb_adapter.h b/sys/dev/cxgb/cxgb_adapter.h
index 3c5f9a6436f1..d1f5ef64c508 100644
--- a/sys/dev/cxgb/cxgb_adapter.h
+++ b/sys/dev/cxgb/cxgb_adapter.h
@@ -139,7 +139,7 @@ enum {
 
 #define FL_Q_SIZE	4096
 #define JUMBO_Q_SIZE	1024
-#define RSPQ_Q_SIZE	1024
+#define RSPQ_Q_SIZE	2048
 #define TX_ETH_Q_SIZE	1024
 #define TX_OFLD_Q_SIZE	1024
 #define TX_CTRL_Q_SIZE	256
@@ -179,6 +179,7 @@ struct sge_rspq {
 	uint32_t        offload_bundles;
 	uint32_t        pure_rsps;
 	uint32_t        unhandled_irqs;
+	uint32_t        starved;
 
 	bus_addr_t	phys_addr;
 	bus_dma_tag_t	desc_tag;
diff --git a/sys/dev/cxgb/cxgb_main.c b/sys/dev/cxgb/cxgb_main.c
index 34b3ef0ccc3b..a47284fe9aec 100644
--- a/sys/dev/cxgb/cxgb_main.c
+++ b/sys/dev/cxgb/cxgb_main.c
@@ -2398,25 +2398,33 @@ cxgb_tick_handler(void *arg, int count)
 	if (p->rev == T3_REV_B2 && p->nports < 4 && sc->open_device_map) 
 		check_t3b2_mac(sc);
 
-	cause = t3_read_reg(sc, A_SG_INT_CAUSE);
-	reset = 0;
-	if (cause & F_FLEMPTY) {
+	cause = t3_read_reg(sc, A_SG_INT_CAUSE) & (F_RSPQSTARVE | F_FLEMPTY);
+	if (cause) {
 		struct sge_qset *qs = &sc->sge.qs[0];
+		uint32_t mask, v;
 
-		i = 0;
-		reset |= F_FLEMPTY;
+		v = t3_read_reg(sc, A_SG_RSPQ_FL_STATUS) & ~0xff00;
 
-		cause = (t3_read_reg(sc, A_SG_RSPQ_FL_STATUS) >>
-			 S_FL0EMPTY) & 0xffff;
-		while (cause) {
-			qs->fl[i].empty += (cause & 1);
-			if (i)
-				qs++;
-			i ^= 1;
-			cause >>= 1;
+		mask = 1;
+		for (i = 0; i < SGE_QSETS; i++) {
+			if (v & mask)
+				qs[i].rspq.starved++;
+			mask <<= 1;
 		}
+
+		mask <<= SGE_QSETS; /* skip RSPQXDISABLED */
+
+		for (i = 0; i < SGE_QSETS * 2; i++) {
+			if (v & mask) {
+				qs[i / 2].fl[i % 2].empty++;
+			}
+			mask <<= 1;
+		}
+
+		/* clear */
+		t3_write_reg(sc, A_SG_RSPQ_FL_STATUS, v);
+		t3_write_reg(sc, A_SG_INT_CAUSE, cause);
 	}
-	t3_write_reg(sc, A_SG_INT_CAUSE, reset);
 
 	for (i = 0; i < sc->params.nports; i++) {
 		struct port_info *pi = &sc->port[i];
diff --git a/sys/dev/cxgb/cxgb_sge.c b/sys/dev/cxgb/cxgb_sge.c
index ce6eda54ee11..9bc36c94fa76 100644
--- a/sys/dev/cxgb/cxgb_sge.c
+++ b/sys/dev/cxgb/cxgb_sge.c
@@ -3586,6 +3586,9 @@ t3_add_configured_sysctls(adapter_t *sc)
 			SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "credits",
 			    CTLFLAG_RD, &qs->rspq.credits,
 			    0, "#credits");
+			SYSCTL_ADD_UINT(ctx, rspqpoidlist, OID_AUTO, "starved",
+			    CTLFLAG_RD, &qs->rspq.starved,
+			    0, "#times starved");
 			SYSCTL_ADD_XLONG(ctx, rspqpoidlist, OID_AUTO, "phys_addr",
 			    CTLFLAG_RD, &qs->rspq.phys_addr,
 			    "physical_address_of the queue");
diff --git a/sys/dev/e1000/if_em.c b/sys/dev/e1000/if_em.c
index f8329f89663c..834e676a6afb 100644
--- a/sys/dev/e1000/if_em.c
+++ b/sys/dev/e1000/if_em.c
@@ -93,7 +93,7 @@ int	em_display_debug_stats = 0;
 /*********************************************************************
  *  Driver version:
  *********************************************************************/
-char em_driver_version[] = "7.0.0";
+char em_driver_version[] = "7.0.4";
 
 
 /*********************************************************************
@@ -192,7 +192,7 @@ static int	em_suspend(device_t);
 static int	em_resume(device_t);
 static void	em_start(struct ifnet *);
 static void	em_start_locked(struct ifnet *, struct tx_ring *);
-#if __FreeBSD_version >= 800000
+#ifdef EM_MULTIQUEUE
 static int	em_mq_start(struct ifnet *, struct mbuf *);
 static int	em_mq_start_locked(struct ifnet *,
 		    struct tx_ring *, struct mbuf *);
@@ -797,7 +797,7 @@ em_resume(device_t dev)
  *  the packet is requeued.
  **********************************************************************/
 
-#if __FreeBSD_version >= 800000
+#ifdef EM_MULTIQUEUE
 static int
 em_mq_start_locked(struct ifnet *ifp, struct tx_ring *txr, struct mbuf *m)
 {
@@ -812,10 +812,18 @@ em_mq_start_locked(struct ifnet *ifp, struct tx_ring *txr, struct mbuf *m)
 		return (err);
 	}
 
+        /* Call cleanup if number of TX descriptors low */
+	if (txr->tx_avail <= EM_TX_CLEANUP_THRESHOLD)
+		em_txeof(txr);
+
 	enq = 0;
-	if (m == NULL)
+	if (m == NULL) {
 		next = drbr_dequeue(ifp, txr->br);
-	else
+	} else if (drbr_needs_enqueue(ifp, txr->br)) {
+		if ((err = drbr_enqueue(ifp, txr->br, m)) != 0)
+			return (err);
+		next = drbr_dequeue(ifp, txr->br);
+	} else
 		next = m;
 
 	/* Process the queue */
@@ -830,12 +838,17 @@ em_mq_start_locked(struct ifnet *ifp, struct tx_ring *txr, struct mbuf *m)
 		ETHER_BPF_MTAP(ifp, next);
 		if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
                         break;
+		if (txr->tx_avail < EM_MAX_SCATTER) {
+			ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+			break;
+		}
 		next = drbr_dequeue(ifp, txr->br);
 	}
 
 	if (enq > 0) {
                 /* Set the watchdog */
                 txr->watchdog_check = TRUE;
+		txr->watchdog_time = ticks;
 	}
 	return (err);
 }
@@ -860,8 +873,7 @@ em_mq_start(struct ifnet *ifp, struct mbuf *m)
 	txr = &adapter->tx_rings[i];
 
 	if (EM_TX_TRYLOCK(txr)) {
-		if (ifp->if_drv_flags & IFF_DRV_RUNNING)
-			error = em_mq_start_locked(ifp, txr, m);
+		error = em_mq_start_locked(ifp, txr, m);
 		EM_TX_UNLOCK(txr);
 	} else 
 		error = drbr_enqueue(ifp, txr->br, m);
@@ -888,7 +900,7 @@ em_qflush(struct ifnet *ifp)
 	if_qflush(ifp);
 }
 
-#endif /* FreeBSD_version */
+#endif /* EM_MULTIQUEUE */
 
 static void
 em_start_locked(struct ifnet *ifp, struct tx_ring *txr)
@@ -905,8 +917,15 @@ em_start_locked(struct ifnet *ifp, struct tx_ring *txr)
 	if (!adapter->link_active)
 		return;
 
-	while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
+        /* Call cleanup if number of TX descriptors low */
+	if (txr->tx_avail <= EM_TX_CLEANUP_THRESHOLD)
+		em_txeof(txr);
 
+	while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
+		if (txr->tx_avail < EM_MAX_SCATTER) {
+			ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+			break;
+		}
                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
 		if (m_head == NULL)
 			break;
@@ -926,6 +945,7 @@ em_start_locked(struct ifnet *ifp, struct tx_ring *txr)
 		ETHER_BPF_MTAP(ifp, m_head);
 
 		/* Set timeout in case hardware has problems transmitting. */
+		txr->watchdog_time = ticks;
 		txr->watchdog_check = TRUE;
 	}
 
@@ -1118,6 +1138,10 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 			ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
 			reinit = 1;
 		}
+		if (mask & IFCAP_VLAN_HWFILTER) {
+			ifp->if_capenable ^= IFCAP_VLAN_HWFILTER;
+			reinit = 1;
+		}
 		if ((mask & IFCAP_WOL) &&
 		    (ifp->if_capabilities & IFCAP_WOL) != 0) {
 			if (mask & IFCAP_WOL_MCAST)
@@ -1228,8 +1252,18 @@ em_init_locked(struct adapter *adapter)
 	/* Setup VLAN support, basic and offload if available */
 	E1000_WRITE_REG(&adapter->hw, E1000_VET, ETHERTYPE_VLAN);
 
-	/* Use real VLAN Filter support */
-	em_setup_vlan_hw_support(adapter);
+	/* Use real VLAN Filter support? */
+	if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) {
+		if (ifp->if_capenable & IFCAP_VLAN_HWFILTER)
+			/* Use real VLAN Filter support */
+			em_setup_vlan_hw_support(adapter);
+		else {
+			u32 ctrl;
+			ctrl = E1000_READ_REG(&adapter->hw, E1000_CTRL);
+			ctrl |= E1000_CTRL_VME;
+			E1000_WRITE_REG(&adapter->hw, E1000_CTRL, ctrl);
+		}
+	}
 
 	/* Set hardware offload abilities */
 	ifp->if_hwassist = 0;
@@ -1337,11 +1371,13 @@ em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
 	}
 	EM_CORE_UNLOCK(adapter);
 
+	EM_RX_LOCK(rxr);
 	rx_done = em_rxeof(rxr, count);
+	EM_RX_UNLOCK(rxr);
 
 	EM_TX_LOCK(txr);
 	em_txeof(txr);
-#if __FreeBSD_version >= 800000
+#ifdef EM_MULTIQUEUE
 	if (!drbr_empty(ifp, txr->br))
 		em_mq_start_locked(ifp, txr, NULL);
 #else
@@ -1409,28 +1445,28 @@ em_handle_que(void *context, int pending)
 	struct ifnet	*ifp = adapter->ifp;
 	struct tx_ring	*txr = adapter->tx_rings;
 	struct rx_ring	*rxr = adapter->rx_rings;
-	u32		loop = EM_MAX_LOOP;
-	bool		more_rx, more_tx;
+	bool		more_rx;
 
 
 	if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-		EM_TX_LOCK(txr);
-		do {
-			more_rx = em_rxeof(rxr, adapter->rx_process_limit);
-			more_tx = em_txeof(txr);
-		} while (loop-- && (more_rx || more_tx));
+		EM_RX_LOCK(rxr);
+		more_rx = em_rxeof(rxr, adapter->rx_process_limit);
+		EM_RX_UNLOCK(rxr);
 
-#if __FreeBSD_version >= 800000
+		EM_TX_LOCK(txr);
+		em_txeof(txr);
+#ifdef EM_MULTIQUEUE
 		if (!drbr_empty(ifp, txr->br))
 			em_mq_start_locked(ifp, txr, NULL);
 #else
 		if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
 			em_start_locked(ifp, txr);
 #endif
-		if (more_rx || more_tx)
-			taskqueue_enqueue(adapter->tq, &adapter->que_task);
-
 		EM_TX_UNLOCK(txr);
+		if (more_rx) {
+			taskqueue_enqueue(adapter->tq, &adapter->que_task);
+			return;
+		}
 	}
 
 	em_enable_intr(adapter);
@@ -1448,17 +1484,12 @@ em_msix_tx(void *arg)
 {
 	struct tx_ring *txr = arg;
 	struct adapter *adapter = txr->adapter;
-	bool		more;
 
 	++txr->tx_irq;
 	EM_TX_LOCK(txr);
-	more = em_txeof(txr);
+	em_txeof(txr);
 	EM_TX_UNLOCK(txr);
-	if (more)
-		taskqueue_enqueue(txr->tq, &txr->tx_task);
-	else
-		/* Reenable this interrupt */
-		E1000_WRITE_REG(&adapter->hw, E1000_IMS, txr->ims);
+	E1000_WRITE_REG(&adapter->hw, E1000_IMS, txr->ims);
 	return;
 }
 
@@ -1475,8 +1506,10 @@ em_msix_rx(void *arg)
 	struct adapter	*adapter = rxr->adapter;
 	bool		more;
 
+	EM_RX_LOCK(rxr);
 	++rxr->rx_irq;
 	more = em_rxeof(rxr, adapter->rx_process_limit);
+	EM_RX_UNLOCK(rxr);
 	if (more)
 		taskqueue_enqueue(rxr->tq, &rxr->rx_task);
 	else
@@ -1513,14 +1546,16 @@ em_handle_rx(void *context, int pending)
 {
 	struct rx_ring	*rxr = context;
 	struct adapter	*adapter = rxr->adapter;
-	u32		loop = EM_MAX_LOOP;
         bool            more;
 
-        do {
-		more = em_rxeof(rxr, adapter->rx_process_limit);
-        } while (loop-- && more);
-        /* Reenable this interrupt */
-	E1000_WRITE_REG(&adapter->hw, E1000_IMS, rxr->ims);
+	EM_RX_LOCK(rxr);
+	more = em_rxeof(rxr, adapter->rx_process_limit);
+	EM_RX_UNLOCK(rxr);
+	if (more)
+		taskqueue_enqueue(rxr->tq, &rxr->rx_task);
+	else
+		/* Reenable this interrupt */
+		E1000_WRITE_REG(&adapter->hw, E1000_IMS, rxr->ims);
 }
 
 static void
@@ -1529,16 +1564,13 @@ em_handle_tx(void *context, int pending)
 	struct tx_ring	*txr = context;
 	struct adapter	*adapter = txr->adapter;
 	struct ifnet	*ifp = adapter->ifp;
-	u32		loop = EM_MAX_LOOP;
-        bool            more;
 
 	if (!EM_TX_TRYLOCK(txr))
 		return;
-	do {
-		more = em_txeof(txr);
-	} while (loop-- && more);
 
-#if __FreeBSD_version >= 800000
+	em_txeof(txr);
+
+#ifdef EM_MULTIQUEUE
 	if (!drbr_empty(ifp, txr->br))
 		em_mq_start_locked(ifp, txr, NULL);
 #else
@@ -1706,13 +1738,6 @@ em_xmit(struct tx_ring *txr, struct mbuf **m_headp)
 	txd_upper = txd_lower = txd_used = txd_saved = 0;
 	do_tso = ((m_head->m_pkthdr.csum_flags & CSUM_TSO) != 0);
 
-        /*
-         * Force a cleanup if number of TX descriptors
-         * available hits the threshold
-         */
-	if (txr->tx_avail <= EM_TX_CLEANUP_THRESHOLD)
-		em_txeof(txr);
-
 	/*
 	 * TSO workaround: 
 	 *  If an mbuf is only header we need  
@@ -2642,7 +2667,7 @@ em_setup_interface(device_t dev, struct adapter *adapter)
 
 	ifp->if_capabilities = ifp->if_capenable = 0;
 
-#if __FreeBSD_version >= 800000
+#ifdef EM_MULTIQUEUE
 	/* Multiqueue tx functions */
 	ifp->if_transmit = em_mq_start;
 	ifp->if_qflush = em_qflush;
@@ -2656,12 +2681,23 @@ em_setup_interface(device_t dev, struct adapter *adapter)
 	ifp->if_capenable |= IFCAP_TSO4;
 
 	/*
-	 * Tell the upper layer(s) we support long frames.
+	 * Tell the upper layer(s) we
+	 * support full VLAN capability
 	 */
 	ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
 	ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
 	ifp->if_capenable |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
 
+	/*
+	** Dont turn this on by default, if vlans are
+	** created on another pseudo device (eg. lagg)
+	** then vlan events are not passed thru, breaking
+	** operation, but with HW FILTER off it works. If
+	** using vlans directly on the em driver you can
+	** enable this and get full hardware tag filtering.
+	*/
+	ifp->if_capabilities |= IFCAP_VLAN_HWFILTER;
+
 #ifdef DEVICE_POLLING
 	ifp->if_capabilities |= IFCAP_POLLING;
 #endif
@@ -3681,6 +3717,8 @@ em_refresh_mbufs(struct rx_ring *rxr, int limit)
 		rxr->next_to_refresh = i;
 	}
 update:
+	bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
+	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	if (cleaned != -1) /* Update tail index */
 		E1000_WRITE_REG(&adapter->hw,
 		    E1000_RDT(rxr->me), cleaned);
@@ -3972,7 +4010,7 @@ em_initialize_receive_unit(struct adapter *adapter)
 	** When using MSIX interrupts we need to throttle
 	** using the EITR register (82574 only)
 	*/
-	if (adapter->msix)
+	if (hw->mac.type == e1000_82574)
 		for (int i = 0; i < 4; i++)
 			E1000_WRITE_REG(hw, E1000_EITR_82574(i),
 			    DEFAULT_ITR);
@@ -4015,6 +4053,9 @@ em_initialize_receive_unit(struct adapter *adapter)
 	    E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
 	    (hw->mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
 
+        /* Strip the CRC */
+        rctl |= E1000_RCTL_SECRC;
+
         /* Make sure VLAN Filters are off */
         rctl &= ~E1000_RCTL_VFE;
 	rctl &= ~E1000_RCTL_SBP;
@@ -4046,15 +4087,15 @@ static int
 em_rxeof(struct rx_ring *rxr, int count)
 {
 	struct adapter		*adapter = rxr->adapter;
-	struct ifnet		*ifp = adapter->ifp;;
+	struct ifnet		*ifp = adapter->ifp;
 	struct mbuf		*mp, *sendmp;
-	u8			status;
+	u8			status = 0;
 	u16 			len;
 	int			i, processed, rxdone = 0;
 	bool			eop;
 	struct e1000_rx_desc	*cur;
 
-	EM_RX_LOCK(rxr);
+	EM_RX_LOCK_ASSERT(rxr);
 
 	for (i = rxr->next_to_check, processed = 0; count != 0;) {
 
@@ -4109,6 +4150,10 @@ em_rxeof(struct rx_ring *rxr, int count)
 					    E1000_RXD_SPC_VLAN_MASK);
 					rxr->fmp->m_flags |= M_VLANTAG;
 				}
+#ifdef EM_MULTIQUEUE
+				rxr->fmp->m_pkthdr.flowid = curcpu;
+				rxr->fmp->m_flags |= M_FLOWID;
+#endif
 #ifndef __NO_STRICT_ALIGNMENT
 skip:
 #endif
@@ -4162,8 +4207,11 @@ skip:
 
 	rxr->next_to_check = i;
 
-	EM_RX_UNLOCK(rxr);
+#ifdef DEVICE_POLLING
 	return (rxdone);
+#else
+	return ((status & E1000_RXD_STAT_DD) ? TRUE : FALSE);
+#endif
 }
 
 #ifndef __NO_STRICT_ALIGNMENT
@@ -4346,7 +4394,7 @@ em_enable_intr(struct adapter *adapter)
 	struct e1000_hw *hw = &adapter->hw;
 	u32 ims_mask = IMS_ENABLE_MASK;
 
-	if (adapter->msix) {
+	if (hw->mac.type == e1000_82574) {
 		E1000_WRITE_REG(hw, EM_EIAC, EM_MSIX_MASK);
 		ims_mask |= EM_MSIX_MASK;
 	} 
@@ -4358,7 +4406,7 @@ em_disable_intr(struct adapter *adapter)
 {
 	struct e1000_hw *hw = &adapter->hw;
 
-	if (adapter->msix)
+	if (hw->mac.type == e1000_82574)
 		E1000_WRITE_REG(hw, EM_EIAC, 0);
 	E1000_WRITE_REG(&adapter->hw, E1000_IMC, 0xffffffff);
 }
diff --git a/sys/dev/e1000/if_em.h b/sys/dev/e1000/if_em.h
index 96d217b420d3..225a8d08b8ee 100644
--- a/sys/dev/e1000/if_em.h
+++ b/sys/dev/e1000/if_em.h
@@ -223,7 +223,7 @@
 #define HW_DEBUGOUT1(S, A)          if (DEBUG_HW) printf(S "\n", A)
 #define HW_DEBUGOUT2(S, A, B)       if (DEBUG_HW) printf(S "\n", A, B)
 
-#define EM_MAX_SCATTER		64
+#define EM_MAX_SCATTER		32
 #define EM_VFTA_SIZE		128
 #define EM_TSO_SIZE		(65535 + sizeof(struct ether_vlan_header))
 #define EM_TSO_SEG_SIZE		4096	/* Max dma segment size */
@@ -453,5 +453,6 @@ struct em_buffer {
 #define	EM_RX_UNLOCK(_sc)		mtx_unlock(&(_sc)->rx_mtx)
 #define	EM_CORE_LOCK_ASSERT(_sc)	mtx_assert(&(_sc)->core_mtx, MA_OWNED)
 #define	EM_TX_LOCK_ASSERT(_sc)		mtx_assert(&(_sc)->tx_mtx, MA_OWNED)
+#define	EM_RX_LOCK_ASSERT(_sc)		mtx_assert(&(_sc)->rx_mtx, MA_OWNED)
 
 #endif /* _EM_H_DEFINED_ */
diff --git a/sys/dev/e1000/if_igb.c b/sys/dev/e1000/if_igb.c
index 5fdd52c163b6..267590faf0e2 100644
--- a/sys/dev/e1000/if_igb.c
+++ b/sys/dev/e1000/if_igb.c
@@ -99,7 +99,7 @@ int	igb_display_debug_stats = 0;
 /*********************************************************************
  *  Driver version:
  *********************************************************************/
-char igb_driver_version[] = "version - 1.9.3";
+char igb_driver_version[] = "version - 1.9.4";
 
 
 /*********************************************************************
@@ -1055,6 +1055,10 @@ igb_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 			ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
 			reinit = 1;
 		}
+		if (mask & IFCAP_VLAN_HWFILTER) {
+			ifp->if_capenable ^= IFCAP_VLAN_HWFILTER;
+			reinit = 1;
+		}
 		if (mask & IFCAP_LRO) {
 			ifp->if_capenable ^= IFCAP_LRO;
 			reinit = 1;
@@ -1110,6 +1114,19 @@ igb_init_locked(struct adapter *adapter)
 
 	E1000_WRITE_REG(&adapter->hw, E1000_VET, ETHERTYPE_VLAN);
 
+        /* Use real VLAN Filter support? */
+	if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) {
+		if (ifp->if_capenable & IFCAP_VLAN_HWFILTER)
+			/* Use real VLAN Filter support */
+			igb_setup_vlan_hw_support(adapter);
+		else {
+			u32 ctrl;
+			ctrl = E1000_READ_REG(&adapter->hw, E1000_CTRL);
+			ctrl |= E1000_CTRL_VME;
+			E1000_WRITE_REG(&adapter->hw, E1000_CTRL, ctrl);
+		}
+	}
+                                
 	/* Set hardware offload abilities */
 	ifp->if_hwassist = 0;
 	if (ifp->if_capenable & IFCAP_TXCSUM) {
@@ -1436,7 +1453,7 @@ igb_msix_que(void *arg)
         if (adapter->hw.mac.type == e1000_82575)
                 newitr |= newitr << 16;
         else
-                newitr |= 0x8000000;
+                newitr |= E1000_EITR_CNT_IGNR;
                  
         /* save for next interrupt */
         que->eitr_setting = newitr;
@@ -2340,7 +2357,7 @@ igb_configure_queues(struct adapter *adapter)
         if (hw->mac.type == e1000_82575)
                 newitr |= newitr << 16;
         else
-                newitr |= 0x8000000;
+                newitr |= E1000_EITR_CNT_IGNR;
 
 	for (int i = 0; i < adapter->num_queues; i++) {
 		que = &adapter->queues[i];
@@ -2669,13 +2686,24 @@ igb_setup_interface(device_t dev, struct adapter *adapter)
 #endif
 
 	/*
-	 * Tell the upper layer(s) we support long frames.
+	 * Tell the upper layer(s) we
+	 * support full VLAN capability.
 	 */
 	ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
 	ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
 	ifp->if_capenable |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
 
 	/*
+	** Dont turn this on by default, if vlans are
+	** created on another pseudo device (eg. lagg)
+	** then vlan events are not passed thru, breaking
+	** operation, but with HW FILTER off it works. If
+	** using vlans directly on the em driver you can
+	** enable this and get full hardware tag filtering.
+	*/
+	ifp->if_capabilities |= IFCAP_VLAN_HWFILTER;
+
+	/*
 	 * Specify the media types supported by this adapter and register
 	 * callbacks to update media and link information
 	 */
@@ -3779,6 +3807,9 @@ igb_setup_receive_ring(struct rx_ring *rxr)
 		/* Update descriptor */
 		rxr->rx_base[j].read.pkt_addr = htole64(pseg[0].ds_addr);
         }
+
+	/* Setup our descriptor indices */
+	rxr->next_to_check = 0;
 	rxr->next_to_refresh = 0;
 	rxr->lro_enabled = FALSE;
 
@@ -4672,10 +4703,12 @@ igb_update_stats_counters(struct adapter *adapter)
 {
 	struct ifnet   *ifp;
 
-	if(adapter->hw.phy.media_type == e1000_media_type_copper ||
+	if (adapter->hw.phy.media_type == e1000_media_type_copper ||
 	   (E1000_READ_REG(&adapter->hw, E1000_STATUS) & E1000_STATUS_LU)) {
-		adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, E1000_SYMERRS);
-		adapter->stats.sec += E1000_READ_REG(&adapter->hw, E1000_SEC);
+		adapter->stats.symerrs +=
+		    E1000_READ_REG(&adapter->hw, E1000_SYMERRS);
+		adapter->stats.sec +=
+		    E1000_READ_REG(&adapter->hw, E1000_SEC);
 	}
 	adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, E1000_CRCERRS);
 	adapter->stats.mpc += E1000_READ_REG(&adapter->hw, E1000_MPC);
diff --git a/sys/dev/fb/vesa.c b/sys/dev/fb/vesa.c
index e89ba4b39184..446046c918df 100644
--- a/sys/dev/fb/vesa.c
+++ b/sys/dev/fb/vesa.c
@@ -763,8 +763,8 @@ vesa_get_bpscanline(struct vesa_mode *vmode)
 static int
 vesa_bios_init(void)
 {
-	static struct vesa_info buf;
 	struct vesa_mode vmode;
+	struct vesa_info *buf;
 	video_info_t *p;
 	x86regs_t regs;
 	size_t bsize;
@@ -800,7 +800,7 @@ vesa_bios_init(void)
 	x86bios_init_regs(&regs);
 	regs.R_AX = 0x4f00;
 
-	vmbuf = x86bios_alloc(&offs, sizeof(buf));
+	vmbuf = x86bios_alloc(&offs, sizeof(*buf));
 	if (vmbuf == NULL)
 		return (1);
 
@@ -813,23 +813,23 @@ vesa_bios_init(void)
 	if (regs.R_AX != 0x004f || bcmp("VESA", vmbuf, 4) != 0)
 		goto fail;
 
-	bcopy(vmbuf, &buf, sizeof(buf));
+	vesa_adp_info = buf = malloc(sizeof(*buf), M_DEVBUF, M_WAITOK);
+	bcopy(vmbuf, buf, sizeof(*buf));
 
-	vesa_adp_info = &buf;
 	if (bootverbose) {
 		printf("VESA: information block\n");
-		hexdump(&buf, sizeof(buf), NULL, HD_OMIT_CHARS);
+		hexdump(buf, sizeof(*buf), NULL, HD_OMIT_CHARS);
 	}
 
-	vers = buf.v_version = le16toh(buf.v_version);
-	buf.v_oemstr = le32toh(buf.v_oemstr);
-	buf.v_flags = le32toh(buf.v_flags);
-	buf.v_modetable = le32toh(buf.v_modetable);
-	buf.v_memsize = le16toh(buf.v_memsize);
-	buf.v_revision = le16toh(buf.v_revision);
-	buf.v_venderstr = le32toh(buf.v_venderstr);
-	buf.v_prodstr = le32toh(buf.v_prodstr);
-	buf.v_revstr = le32toh(buf.v_revstr);
+	vers = buf->v_version = le16toh(buf->v_version);
+	buf->v_oemstr = le32toh(buf->v_oemstr);
+	buf->v_flags = le32toh(buf->v_flags);
+	buf->v_modetable = le32toh(buf->v_modetable);
+	buf->v_memsize = le16toh(buf->v_memsize);
+	buf->v_revision = le16toh(buf->v_revision);
+	buf->v_venderstr = le32toh(buf->v_venderstr);
+	buf->v_prodstr = le32toh(buf->v_prodstr);
+	buf->v_revstr = le32toh(buf->v_revstr);
 
 	if (vers < 0x0102) {
 		printf("VESA: VBE version %d.%d is not supported; "
@@ -839,21 +839,21 @@ vesa_bios_init(void)
 		return (1);
 	}
 
-	VESA_STRCPY(vesa_oemstr, buf.v_oemstr);
+	VESA_STRCPY(vesa_oemstr, buf->v_oemstr);
 	if (vers >= 0x0200) {
-		VESA_STRCPY(vesa_venderstr, buf.v_venderstr);
-		VESA_STRCPY(vesa_prodstr, buf.v_prodstr);
-		VESA_STRCPY(vesa_revstr, buf.v_revstr);
+		VESA_STRCPY(vesa_venderstr, buf->v_venderstr);
+		VESA_STRCPY(vesa_prodstr, buf->v_prodstr);
+		VESA_STRCPY(vesa_revstr, buf->v_revstr);
 	}
 	is_via_cle266 = strncmp(vesa_oemstr, VESA_VIA_CLE266,
 	    sizeof(VESA_VIA_CLE266)) == 0;
 
-	if (buf.v_modetable == 0)
+	if (buf->v_modetable == 0)
 		goto fail;
 
-	msize = (size_t)buf.v_memsize * 64 * 1024;
+	msize = (size_t)buf->v_memsize * 64 * 1024;
 
-	vesa_vmodetab = x86bios_offset(BIOS_SADDRTOLADDR(buf.v_modetable));
+	vesa_vmodetab = x86bios_offset(BIOS_SADDRTOLADDR(buf->v_modetable));
 
 	for (i = 0, modes = 0; (i < (M_VESA_MODE_MAX - M_VESA_BASE + 1)) &&
 	    (vesa_vmodetab[i] != 0xffff); ++i) {
@@ -1016,12 +1016,16 @@ vesa_bios_init(void)
 	if (!has_vesa_bios)
 		goto fail;
 
-	x86bios_free(vmbuf, sizeof(buf));
+	x86bios_free(vmbuf, sizeof(*buf));
 	return (0);
 
 fail:
 	if (vmbuf != NULL)
 		x86bios_free(vmbuf, sizeof(buf));
+	if (vesa_adp_info != NULL) {
+		free(vesa_adp_info, M_DEVBUF);
+		vesa_adp_info = NULL;
+	}
 	if (vesa_oemstr != NULL) {
 		free(vesa_oemstr, M_DEVBUF);
 		vesa_oemstr = NULL;
@@ -1875,6 +1879,8 @@ vesa_unload(void)
 	}
 	splx(s);
 
+	if (vesa_adp_info != NULL)
+		free(vesa_adp_info, M_DEVBUF);
 	if (vesa_oemstr != NULL)
 		free(vesa_oemstr, M_DEVBUF);
 	if (vesa_venderstr != NULL)
diff --git a/sys/dev/hwpmc/hwpmc_core.c b/sys/dev/hwpmc/hwpmc_core.c
index 43a49143fc34..90d7c8bc23f0 100644
--- a/sys/dev/hwpmc/hwpmc_core.c
+++ b/sys/dev/hwpmc/hwpmc_core.c
@@ -534,10 +534,12 @@ struct iap_event_descr {
 #define	IAP_F_CC2E	(1 << 2)	/* CPU: Core2 Extreme only */
 #define	IAP_F_CA	(1 << 3)	/* CPU: Atom */
 #define	IAP_F_I7	(1 << 4)	/* CPU: Core i7 */
-#define	IAP_F_FM	(1 << 5)	/* Fixed mask */
+#define	IAP_F_I7O	(1 << 4)	/* CPU: Core i7 (old) */
+#define	IAP_F_WM	(1 << 5)	/* CPU: Westmere */
+#define	IAP_F_FM	(1 << 6)	/* Fixed mask */
 
-#define	IAP_F_ALLCPUS						\
-    (IAP_F_CC | IAP_F_CC2 | IAP_F_CC2E | IAP_F_CA | IAP_F_I7)
+#define	IAP_F_ALLCPUSCORE2					\
+    (IAP_F_CC | IAP_F_CC2 | IAP_F_CC2E | IAP_F_CA)
 
 /* Sub fields of UMASK that this event supports. */
 #define	IAP_M_CORE		(1 << 0) /* Core specificity */
@@ -570,151 +572,319 @@ static struct iap_event_descr iap_events[] = {
 	.iap_flags = (FLAGS)						\
 	}
 
+    IAPDESCR(02H_01H, 0x02, 0x01, IAP_F_FM | IAP_F_I7O),
     IAPDESCR(02H_81H, 0x02, 0x81, IAP_F_FM | IAP_F_CA),
 
     IAPDESCR(03H_00H, 0x03, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(03H_02H, 0x03, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
-    IAPDESCR(03H_04H, 0x03, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(03H_01H, 0x03, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(03H_02H, 0x03, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_WM),
+    IAPDESCR(03H_04H, 0x03, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7O),
     IAPDESCR(03H_08H, 0x03, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(03H_10H, 0x03, 0x10, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(03H_20H, 0x03, 0x20, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(04H_00H, 0x04, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(04H_01H, 0x04, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(04H_01H, 0x04, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7O),
     IAPDESCR(04H_02H, 0x04, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
+    IAPDESCR(04H_07H, 0x04, 0x07, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
     IAPDESCR(04H_08H, 0x04, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(05H_00H, 0x05, 0x00, IAP_F_FM | IAP_F_CC),
+    IAPDESCR(05H_01H, 0x05, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(05H_02H, 0x05, 0x02, IAP_F_FM | IAP_F_I7O | IAP_F_WM),
+    IAPDESCR(05H_03H, 0x05, 0x03, IAP_F_FM | IAP_F_I7O),
 
-    IAPDESCR(06H_00H, 0x06, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(06H_00H, 0x06, 0x00, IAP_F_FM | IAP_F_CC | IAP_F_CC2 |
+	IAP_F_CC2E | IAP_F_CA),
+    IAPDESCR(06H_01H, 0x06, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(06H_02H, 0x06, 0x02, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(06H_04H, 0x06, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(06H_08H, 0x06, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(06H_0FH, 0x06, 0x0F, IAP_F_FM | IAP_F_I7O),
 
     IAPDESCR(07H_00H, 0x07, 0x00, IAP_F_FM | IAP_F_CC | IAP_F_CC2),
-    IAPDESCR(07H_01H, 0x07, 0x01, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(07H_02H, 0x07, 0x02, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(07H_03H, 0x07, 0x03, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(07H_01H, 0x07, 0x01, IAP_F_FM | IAP_F_ALLCPUSCORE2 | IAP_F_WM),
+    IAPDESCR(07H_02H, 0x07, 0x02, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(07H_03H, 0x07, 0x03, IAP_F_FM | IAP_F_ALLCPUSCORE2),
     IAPDESCR(07H_06H, 0x07, 0x06, IAP_F_FM | IAP_F_CA),
     IAPDESCR(07H_08H, 0x07, 0x08, IAP_F_FM | IAP_F_CA),
 
-    IAPDESCR(08H_01H, 0x08, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(08H_02H, 0x08, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(08H_04H, 0x08, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
+    IAPDESCR(08H_01H, 0x08, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(08H_02H, 0x08, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(08H_04H, 0x08, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_WM),
     IAPDESCR(08H_05H, 0x08, 0x05, IAP_F_FM | IAP_F_CA),
     IAPDESCR(08H_06H, 0x08, 0x06, IAP_F_FM | IAP_F_CA),
     IAPDESCR(08H_07H, 0x08, 0x07, IAP_F_FM | IAP_F_CA),
     IAPDESCR(08H_08H, 0x08, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(08H_09H, 0x08, 0x09, IAP_F_FM | IAP_F_CA),
+    IAPDESCR(08H_10H, 0x08, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(08H_20H, 0x08, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(08H_40H, 0x08, 0x40, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(08H_80H, 0x08, 0x80, IAP_F_FM | IAP_F_I7),
+
+    IAPDESCR(09H_01H, 0x09, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7O),
+    IAPDESCR(09H_02H, 0x09, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7O),
+    IAPDESCR(09H_04H, 0x09, 0x04, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(09H_08H, 0x09, 0x08, IAP_F_FM | IAP_F_I7O),
 
-    IAPDESCR(09H_01H, 0x09, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(09H_02H, 0x09, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(0BH_01H, 0x0B, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(0BH_02H, 0x0B, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(0BH_10H, 0x0B, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(0CH_01H, 0x0C, 0x01, IAP_F_FM | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(0CH_01H, 0x0C, 0x01, IAP_F_FM | IAP_F_CC2 | IAP_F_I7 |
+	IAP_F_WM),
     IAPDESCR(0CH_02H, 0x0C, 0x02, IAP_F_FM | IAP_F_CC2),
     IAPDESCR(0CH_03H, 0x0C, 0x03, IAP_F_FM | IAP_F_CA),
 
-    IAPDESCR(10H_00H, 0x10, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(10H_01H, 0x10, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(0EH_01H, 0x0E, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(0EH_02H, 0x0E, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(0FH_01H, 0x0F, 0x01, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(0FH_02H, 0x0F, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(0FH_08H, 0x0F, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(0FH_10H, 0x0F, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(0FH_20H, 0x0F, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(0FH_80H, 0x0F, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(10H_00H, 0x10, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(10H_01H, 0x10, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(10H_02H, 0x10, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(10H_04H, 0x10, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(10H_08H, 0x10, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(10H_10H, 0x10, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(10H_20H, 0x10, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(10H_40H, 0x10, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(10H_80H, 0x10, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
     IAPDESCR(10H_81H, 0x10, 0x81, IAP_F_FM | IAP_F_CA),
 
     IAPDESCR(11H_00H, 0x11, 0x00, IAP_F_FM | IAP_F_CC | IAP_F_CC2),
     IAPDESCR(11H_01H, 0x11, 0x01, IAP_F_FM | IAP_F_CA),
     IAPDESCR(11H_81H, 0x11, 0x81, IAP_F_FM | IAP_F_CA),
 
-    IAPDESCR(12H_00H, 0x12, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(12H_01H, 0x12, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(12H_00H, 0x12, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(12H_01H, 0x12, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(12H_02H, 0x12, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(12H_04H, 0x12, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(12H_08H, 0x12, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(12H_10H, 0x12, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(12H_20H, 0x12, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(12H_40H, 0x12, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
     IAPDESCR(12H_81H, 0x12, 0x81, IAP_F_FM | IAP_F_CA),
 
-    IAPDESCR(13H_00H, 0x13, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(13H_01H, 0x13, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(13H_00H, 0x13, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(13H_01H, 0x13, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(13H_02H, 0x13, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(13H_04H, 0x13, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(13H_07H, 0x13, 0x07, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
     IAPDESCR(13H_81H, 0x13, 0x81, IAP_F_FM | IAP_F_CA),
 
     IAPDESCR(14H_00H, 0x14, 0x00, IAP_F_FM | IAP_F_CC | IAP_F_CC2),
-    IAPDESCR(14H_01H, 0x14, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(14H_01H, 0x14, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(14H_02H, 0x14, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(17H_01H, 0x17, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
     IAPDESCR(18H_00H, 0x18, 0x00, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
+    IAPDESCR(18H_01H, 0x18, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
     IAPDESCR(19H_00H, 0x19, 0x00, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
-    IAPDESCR(19H_01H, 0x19, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(19H_01H, 0x19, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(19H_02H, 0x19, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(21H, 0x21, IAP_M_CORE, IAP_F_ALLCPUS),
+    IAPDESCR(1DH_01H, 0x1D, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(1DH_02H, 0x1D, 0x02, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(1DH_04H, 0x1D, 0x04, IAP_F_FM | IAP_F_I7O),
+
+    IAPDESCR(1EH_01H, 0x1E, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(20H_01H, 0x20, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(21H, 0x21, IAP_M_CORE, IAP_F_ALLCPUSCORE2),
     IAPDESCR(22H, 0x22, IAP_M_CORE, IAP_F_CC2),
-    IAPDESCR(23H, 0x23, IAP_M_CORE, IAP_F_ALLCPUS),
-    IAPDESCR(24H, 0x24, IAP_M_CORE | IAP_M_PREFETCH, IAP_F_ALLCPUS),
-    IAPDESCR(25H, 0x25, IAP_M_CORE, IAP_F_ALLCPUS),
-    IAPDESCR(26H, 0x26, IAP_M_CORE | IAP_M_PREFETCH, IAP_F_ALLCPUS),
-    IAPDESCR(27H, 0x27, IAP_M_CORE | IAP_M_PREFETCH, IAP_F_ALLCPUS),
-    IAPDESCR(28H, 0x28, IAP_M_CORE | IAP_M_MESI, IAP_F_ALLCPUS),
+    IAPDESCR(23H, 0x23, IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+
+    IAPDESCR(24H, 0x24, IAP_M_CORE | IAP_M_PREFETCH, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(24H_01H, 0x24, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_02H, 0x24, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_03H, 0x24, 0x03, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_04H, 0x24, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_08H, 0x24, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_0CH, 0x24, 0x0C, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_10H, 0x24, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_20H, 0x24, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_30H, 0x24, 0x30, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_40H, 0x24, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_80H, 0x24, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_C0H, 0x24, 0xC0, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_AAH, 0x24, 0xAA, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(24H_FFH, 0x24, 0xFF, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(25H, 0x25, IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+
+    IAPDESCR(26H, 0x26, IAP_M_CORE | IAP_M_PREFETCH, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(26H_01H, 0x26, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_02H, 0x26, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_04H, 0x26, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_08H, 0x26, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_0FH, 0x26, 0x0F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_10H, 0x26, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_20H, 0x26, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_40H, 0x26, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_80H, 0x26, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_F0H, 0x26, 0xF0, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(26H_FFH, 0x26, 0xFF, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(27H, 0x27, IAP_M_CORE | IAP_M_PREFETCH, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(27H_01H, 0x27, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_02H, 0x27, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_04H, 0x27, 0x04, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(27H_08H, 0x27, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_0EH, 0x27, 0x0E, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_0FH, 0x27, 0x0F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_10H, 0x27, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_20H, 0x27, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_40H, 0x27, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_80H, 0x27, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_E0H, 0x27, 0xE0, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(27H_F0H, 0x27, 0xF0, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(28H, 0x28, IAP_M_CORE | IAP_M_MESI, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(28H_01H, 0x28, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(28H_02H, 0x28, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(28H_04H, 0x28, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(28H_08H, 0x28, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(28H_0FH, 0x28, 0x0F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
     IAPDESCR(29H, 0x29, IAP_M_CORE | IAP_M_MESI, IAP_F_CC),
     IAPDESCR(29H, 0x29, IAP_M_CORE | IAP_M_MESI | IAP_M_PREFETCH,
 	IAP_F_CA | IAP_F_CC2),
-    IAPDESCR(2AH, 0x2A, IAP_M_CORE | IAP_M_MESI, IAP_F_ALLCPUS),
+    IAPDESCR(2AH, 0x2A, IAP_M_CORE | IAP_M_MESI, IAP_F_ALLCPUSCORE2),
     IAPDESCR(2BH, 0x2B, IAP_M_CORE | IAP_M_MESI, IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(2EH, 0x2E, IAP_M_CORE | IAP_M_MESI | IAP_M_PREFETCH,
-	IAP_F_ALLCPUS),
-    IAPDESCR(2EH_41H, 0x2E, 0x41, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(2EH_4FH, 0x2E, 0x4F, IAP_F_FM | IAP_F_ALLCPUS),
+	IAP_F_ALLCPUSCORE2),
+    IAPDESCR(2EH_01H, 0x2E, 0x01, IAP_F_FM | IAP_F_WM),
+    IAPDESCR(2EH_02H, 0x2E, 0x02, IAP_F_FM | IAP_F_WM),
+    IAPDESCR(2EH_41H, 0x2E, 0x41, IAP_F_FM | IAP_F_ALLCPUSCORE2 | IAP_F_I7),
+    IAPDESCR(2EH_4FH, 0x2E, 0x4F, IAP_F_FM | IAP_F_ALLCPUSCORE2 | IAP_F_I7),
 
     IAPDESCR(30H, 0x30, IAP_M_CORE | IAP_M_MESI | IAP_M_PREFETCH,
-	IAP_F_ALLCPUS),
+	IAP_F_ALLCPUSCORE2),
     IAPDESCR(32H, 0x32, IAP_M_CORE | IAP_M_MESI | IAP_M_PREFETCH, IAP_F_CC),
     IAPDESCR(32H, 0x32, IAP_M_CORE, IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(3AH, 0x3A, IAP_M_TRANSITION, IAP_F_CC),
     IAPDESCR(3AH_00H, 0x3A, 0x00, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(3BH_C0H, 0x3B, 0xC0, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(3BH_C0H, 0x3B, 0xC0, IAP_F_FM | IAP_F_ALLCPUSCORE2),
 
-    IAPDESCR(3CH_00H, 0x3C, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(3CH_01H, 0x3C, 0x01, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(3CH_02H, 0x3C, 0x02, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(3CH_00H, 0x3C, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+        IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(3CH_01H, 0x3C, 0x01, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+        IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(3CH_02H, 0x3C, 0x02, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+
+    IAPDESCR(3DH_01H, 0x3D, 0x01, IAP_F_FM | IAP_F_I7O),
 
     IAPDESCR(40H, 0x40, IAP_M_MESI, IAP_F_CC | IAP_F_CC2),
+    IAPDESCR(40H_01H, 0x40, 0x01, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(40H_02H, 0x40, 0x02, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(40H_04H, 0x40, 0x04, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(40H_08H, 0x40, 0x08, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(40H_0FH, 0x40, 0x0F, IAP_F_FM | IAP_F_I7),
     IAPDESCR(40H_21H, 0x40, 0x21, IAP_F_FM | IAP_F_CA),
 
     IAPDESCR(41H, 0x41, IAP_M_MESI, IAP_F_CC | IAP_F_CC2),
+    IAPDESCR(41H_01H, 0x41, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(41H_02H, 0x41, 0x02, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(41H_04H, 0x41, 0x04, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(41H_08H, 0x41, 0x08, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(41H_0FH, 0x41, 0x0F, IAP_F_FM | IAP_F_I7O),
     IAPDESCR(41H_22H, 0x41, 0x22, IAP_F_FM | IAP_F_CA),
 
-    IAPDESCR(42H, 0x42, IAP_M_MESI, IAP_F_ALLCPUS),
+    IAPDESCR(42H, 0x42, IAP_M_MESI, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(42H_01H, 0x42, 0x01, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(42H_02H, 0x42, 0x02, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(42H_04H, 0x42, 0x04, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(42H_08H, 0x42, 0x08, IAP_F_FM | IAP_F_I7),
     IAPDESCR(42H_10H, 0x42, 0x10, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(43H_01H, 0x43, 0x01, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(43H_02H, 0x43, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(43H_01H, 0x43, 0x01, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+	IAP_F_I7),
+    IAPDESCR(43H_02H, 0x43, 0x02, IAP_F_FM | IAP_F_CA |
+	IAP_F_CC2 | IAP_F_I7),
 
     IAPDESCR(44H_02H, 0x44, 0x02, IAP_F_FM | IAP_F_CC),
 
-    IAPDESCR(45H_0FH, 0x45, 0x0F, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(45H_0FH, 0x45, 0x0F, IAP_F_FM | IAP_F_ALLCPUSCORE2),
 
-    IAPDESCR(46H_00H, 0x46, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(47H_00H, 0x47, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(48H_00H, 0x48, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(46H_00H, 0x46, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(47H_00H, 0x47, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+
+    IAPDESCR(48H_00H, 0x48, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(48H_02H, 0x48, 0x02, IAP_F_FM | IAP_F_I7),
 
     IAPDESCR(49H_00H, 0x49, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(49H_01H, 0x49, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(49H_02H, 0x49, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(49H_01H, 0x49, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+        IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(49H_02H, 0x49, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+        IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(49H_04H, 0x49, 0x04, IAP_F_FM | IAP_F_WM),
+    IAPDESCR(49H_10H, 0x49, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(49H_20H, 0x49, 0x20, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(49H_40H, 0x49, 0x40, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(49H_80H, 0x49, 0x80, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
 
-    IAPDESCR(4BH_00H, 0x4B, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(4BH_01H, 0x4B, 0x01, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(4BH_02H, 0x4B, 0x02, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(4BH_00H, 0x4B, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(4BH_01H, 0x4B, 0x01, IAP_F_FM | IAP_F_ALLCPUSCORE2 | IAP_F_I7O),
+    IAPDESCR(4BH_02H, 0x4B, 0x02, IAP_F_FM | IAP_F_ALLCPUSCORE2),
     IAPDESCR(4BH_03H, 0x4B, 0x03, IAP_F_FM | IAP_F_CC),
+    IAPDESCR(4BH_08H, 0x4B, 0x08, IAP_F_FM | IAP_F_I7O),
 
     IAPDESCR(4CH_00H, 0x4C, 0x00, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
+    IAPDESCR(4CH_01H, 0x4C, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
+    IAPDESCR(4DH_01H, 0x4D, 0x01, IAP_F_FM | IAP_F_I7O),
+
+    IAPDESCR(4EH_01H, 0x4E, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(4EH_02H, 0x4E, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(4EH_04H, 0x4E, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
     IAPDESCR(4EH_10H, 0x4E, 0x10, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(4FH_00H, 0x4F, 0x00, IAP_F_FM | IAP_F_CC),
+    IAPDESCR(4FH_02H, 0x4F, 0x02, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(4FH_04H, 0x4F, 0x04, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(4FH_08H, 0x4F, 0x08, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(4FH_10H, 0x4F, 0x10, IAP_F_FM | IAP_F_WM),
+
+    IAPDESCR(51H_01H, 0x51, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(51H_02H, 0x51, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(51H_04H, 0x51, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(51H_08H, 0x51, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(60H, 0x60, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUS),
+    IAPDESCR(52H_01H, 0x52, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(53H_01H, 0x53, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(60H, 0x60, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(60H_01H, 0x60, 0x01, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(60H_02H, 0x60, 0x02, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(60H_04H, 0x60, 0x04, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(60H_08H, 0x60, 0x08, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
 
     IAPDESCR(61H, 0x61, IAP_M_AGENT, IAP_F_CA | IAP_F_CC2),
     IAPDESCR(61H_00H, 0x61, 0x00, IAP_F_FM | IAP_F_CC),
 
-    IAPDESCR(62H, 0x62, IAP_M_AGENT, IAP_F_ALLCPUS),
+    IAPDESCR(62H, 0x62, IAP_M_AGENT, IAP_F_ALLCPUSCORE2),
     IAPDESCR(62H_00H, 0x62, 0x00, IAP_F_FM | IAP_F_CC),
 
     IAPDESCR(63H, 0x63, IAP_M_AGENT | IAP_M_CORE,
 	IAP_F_CA | IAP_F_CC2),
     IAPDESCR(63H, 0x63, IAP_M_CORE, IAP_F_CC),
+    IAPDESCR(63H_01H, 0x63, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(63H_02H, 0x63, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
     IAPDESCR(64H, 0x64, IAP_M_CORE, IAP_F_CA | IAP_F_CC2),
     IAPDESCR(64H_40H, 0x64, 0x40, IAP_F_FM | IAP_F_CC),
@@ -723,16 +893,18 @@ static struct iap_event_descr iap_events[] = {
 	IAP_F_CA | IAP_F_CC2),
     IAPDESCR(65H, 0x65, IAP_M_CORE, IAP_F_CC),
 
-    IAPDESCR(66H, 0x66, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUS),
+    IAPDESCR(66H, 0x66, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUSCORE2),
 
     IAPDESCR(67H, 0x67, IAP_M_AGENT | IAP_M_CORE, IAP_F_CA | IAP_F_CC2),
     IAPDESCR(67H, 0x67, IAP_M_AGENT, IAP_F_CC),
 
-    IAPDESCR(68H, 0x68, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUS),
-    IAPDESCR(69H, 0x69, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUS),
-    IAPDESCR(6AH, 0x6A, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUS),
-    IAPDESCR(6BH, 0x6B, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUS),
-    IAPDESCR(6CH, 0x6C, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUS),
+    IAPDESCR(68H, 0x68, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(69H, 0x69, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(6AH, 0x6A, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(6BH, 0x6B, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+
+    IAPDESCR(6CH, 0x6C, IAP_M_AGENT | IAP_M_CORE, IAP_F_ALLCPUSCORE2),
+    IAPDESCR(6CH_01H, 0x6C, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
     IAPDESCR(6DH, 0x6D, IAP_M_AGENT | IAP_M_CORE, IAP_F_CA | IAP_F_CC2),
     IAPDESCR(6DH, 0x6D, IAP_M_CORE, IAP_F_CC),
@@ -757,47 +929,89 @@ static struct iap_event_descr iap_events[] = {
 
     IAPDESCR(7BH, 0x7B, IAP_M_AGENT, IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(7DH, 0x7D, IAP_M_CORE, IAP_F_ALLCPUS),
+    IAPDESCR(7DH, 0x7D, IAP_M_CORE, IAP_F_ALLCPUSCORE2),
 
     IAPDESCR(7EH, 0x7E, IAP_M_AGENT | IAP_M_CORE, IAP_F_CA | IAP_F_CC2),
     IAPDESCR(7EH_00H, 0x7E, 0x00, IAP_F_FM | IAP_F_CC),
 
     IAPDESCR(7FH, 0x7F, IAP_M_CORE, IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(80H_00H, 0x80, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(80H_02H, 0x80, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_I7),
-    IAPDESCR(80H_03H, 0x80, 0x03, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(80H_00H, 0x80, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(80H_01H, 0x80, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(80H_02H, 0x80, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_I7 |
+	IAP_F_WM),
+    IAPDESCR(80H_03H, 0x80, 0x03, IAP_F_FM | IAP_F_CA | IAP_F_I7 |
+	IAP_F_WM),
+    IAPDESCR(80H_04H, 0x80, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(81H_00H, 0x81, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(81H_00H, 0x81, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(81H_01H, 0x81, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(81H_02H, 0x81, 0x02, IAP_F_FM | IAP_F_I7O),
 
+    IAPDESCR(82H_01H, 0x82, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
     IAPDESCR(82H_02H, 0x82, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(82H_04H, 0x82, 0x04, IAP_F_FM | IAP_F_CA),
     IAPDESCR(82H_10H, 0x82, 0x10, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(82H_12H, 0x82, 0x12, IAP_F_FM | IAP_F_CC2),
     IAPDESCR(82H_40H, 0x82, 0x40, IAP_F_FM | IAP_F_CC2),
 
+    IAPDESCR(83H_01H, 0x83, 0x01, IAP_F_FM | IAP_F_I7O),
     IAPDESCR(83H_02H, 0x83, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(85H_00H, 0x85, 0x00, IAP_F_FM | IAP_F_CC),
+    IAPDESCR(85H_01H, 0x85, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(85H_02H, 0x85, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(85H_04H, 0x85, 0x04, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(85H_10H, 0x85, 0x10, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(85H_20H, 0x85, 0x20, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(85H_40H, 0x85, 0x40, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(85H_80H, 0x85, 0x80, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+
+    IAPDESCR(86H_00H, 0x86, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+
+    IAPDESCR(87H_00H, 0x87, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(87H_01H, 0x87, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(87H_02H, 0x87, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(87H_04H, 0x87, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(87H_08H, 0x87, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(87H_0FH, 0x87, 0x0F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(86H_00H, 0x86, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(88H_00H, 0x88, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(88H_01H, 0x88, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_02H, 0x88, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_04H, 0x88, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_07H, 0x88, 0x07, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_08H, 0x88, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_10H, 0x88, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_20H, 0x88, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_30H, 0x88, 0x30, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_40H, 0x88, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(88H_7FH, 0x88, 0x7F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(87H_00H, 0x87, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(89H_00H, 0x89, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(89H_01H, 0x89, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_02H, 0x89, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_04H, 0x89, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_07H, 0x89, 0x07, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_08H, 0x89, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_10H, 0x89, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_20H, 0x89, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_30H, 0x89, 0x30, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_40H, 0x89, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(89H_7FH, 0x89, 0x7F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(88H_00H, 0x88, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(89H_00H, 0x89, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(8AH_00H, 0x8A, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(8BH_00H, 0x8B, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(8CH_00H, 0x8C, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(8DH_00H, 0x8D, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(8EH_00H, 0x8E, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(8FH_00H, 0x8F, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(8AH_00H, 0x8A, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(8BH_00H, 0x8B, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(8CH_00H, 0x8C, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(8DH_00H, 0x8D, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(8EH_00H, 0x8E, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(8FH_00H, 0x8F, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
 
-    IAPDESCR(90H_00H, 0x90, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(91H_00H, 0x91, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(92H_00H, 0x92, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(93H_00H, 0x93, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(94H_00H, 0x94, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(90H_00H, 0x90, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(91H_00H, 0x91, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(92H_00H, 0x92, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(93H_00H, 0x93, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(94H_00H, 0x94, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
 
     IAPDESCR(97H_00H, 0x97, 0x00, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(98H_00H, 0x98, 0x00, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
@@ -811,6 +1025,18 @@ static struct iap_event_descr iap_events[] = {
     IAPDESCR(A1H_20H, 0xA1, 0x20, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(A2H_00H, 0xA2, 0x00, IAP_F_FM | IAP_F_CC),
+    IAPDESCR(A2H_01H, 0xA2, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A2H_02H, 0xA2, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A2H_04H, 0xA2, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A2H_08H, 0xA2, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A2H_10H, 0xA2, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A2H_20H, 0xA2, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A2H_40H, 0xA2, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A2H_80H, 0xA2, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(A6H_01H, 0xA6, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A7H_01H, 0xA7, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(A8H_01H, 0xA8, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
     IAPDESCR(AAH_01H, 0xAA, 0x01, IAP_F_FM | IAP_F_CC2),
     IAPDESCR(AAH_02H, 0xAA, 0x02, IAP_F_FM | IAP_F_CA),
@@ -820,18 +1046,41 @@ static struct iap_event_descr iap_events[] = {
     IAPDESCR(ABH_01H, 0xAB, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(ABH_02H, 0xAB, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(B0H_00H, 0xB0, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(B0H_80H, 0xB0, 0x80, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(AEH_01H, 0xAE, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(B0H_00H, 0xB0, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(B0H_01H, 0xB0, 0x01, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(B0H_02H, 0xB0, 0x02, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(B0H_04H, 0xB0, 0x04, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(B0H_08H, 0xB0, 0x08, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(B0H_20H, 0xB0, 0x20, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(B0H_40H, 0xB0, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B0H_80H, 0xB0, 0x80, IAP_F_FM | IAP_F_CA | IAP_F_WM | IAP_F_I7O),
+
+    IAPDESCR(B1H_00H, 0xB1, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(B1H_01H, 0xB1, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_02H, 0xB1, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_04H, 0xB1, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_08H, 0xB1, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_10H, 0xB1, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_1FH, 0xB1, 0x1F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_20H, 0xB1, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_3FH, 0xB1, 0x3F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_40H, 0xB1, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B1H_80H, 0xB1, 0x80, IAP_F_FM | IAP_F_CA | IAP_F_I7 |
+	IAP_F_WM),
 
-    IAPDESCR(B1H_00H, 0xB1, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(B1H_80H, 0xB1, 0x80, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(B2H_01H, 0xB2, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(B3H_01H, 0xB3, 0x01, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(B3H_02H, 0xB3, 0x02, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(B3H_04H, 0xB3, 0x04, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(B3H_08H, 0xB3, 0x08, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(B3H_10H, 0xB3, 0x10, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(B3H_20H, 0xB3, 0x20, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(B3H_01H, 0xB3, 0x01, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+	IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(B3H_02H, 0xB3, 0x02, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+	IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(B3H_04H, 0xB3, 0x04, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+	IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(B3H_08H, 0xB3, 0x08, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(B3H_10H, 0xB3, 0x10, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(B3H_20H, 0xB3, 0x20, IAP_F_FM | IAP_F_ALLCPUSCORE2),
     IAPDESCR(B3H_81H, 0xB3, 0x81, IAP_F_FM | IAP_F_CA),
     IAPDESCR(B3H_82H, 0xB3, 0x82, IAP_F_FM | IAP_F_CA),
     IAPDESCR(B3H_84H, 0xB3, 0x84, IAP_F_FM | IAP_F_CA),
@@ -839,10 +1088,28 @@ static struct iap_event_descr iap_events[] = {
     IAPDESCR(B3H_90H, 0xB3, 0x90, IAP_F_FM | IAP_F_CA),
     IAPDESCR(B3H_A0H, 0xB3, 0xA0, IAP_F_FM | IAP_F_CA),
 
-    IAPDESCR(C0H_00H, 0xC0, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(C0H_01H, 0xC0, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C0H_02H, 0xC0, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C0H_04H, 0xC0, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
+    IAPDESCR(B4H_01H, 0xB4, 0x01, IAP_F_FM | IAP_F_WM),
+    IAPDESCR(B4H_02H, 0xB4, 0x02, IAP_F_FM | IAP_F_WM),
+    IAPDESCR(B4H_04H, 0xB4, 0x04, IAP_F_FM | IAP_F_WM),
+
+    IAPDESCR(B7H_01H, 0xB7, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(B8H_01H, 0xB8, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B8H_02H, 0xB8, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(B8H_04H, 0xB8, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(BAH_01H, 0xBA, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(BAH_02H, 0xBA, 0x02, IAP_F_FM | IAP_F_I7O),
+
+    IAPDESCR(BBH_01H, 0xBB, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(C0H_00H, 0xC0, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(C0H_01H, 0xC0, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C0H_02H, 0xC0, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C0H_04H, 0xC0, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(C0H_08H, 0xC0, 0x08, IAP_F_FM | IAP_F_CC2E),
 
     IAPDESCR(C1H_00H, 0xC1, 0x00, IAP_F_FM | IAP_F_CC),
@@ -850,43 +1117,64 @@ static struct iap_event_descr iap_events[] = {
     IAPDESCR(C1H_FEH, 0xC1, 0xFE, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(C2H_00H, 0xC2, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(C2H_01H, 0xC2, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C2H_02H, 0xC2, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C2H_04H, 0xC2, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(C2H_01H, 0xC2, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C2H_02H, 0xC2, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C2H_04H, 0xC2, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(C2H_07H, 0xC2, 0x07, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(C2H_08H, 0xC2, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(C2H_0FH, 0xC2, 0x0F, IAP_F_FM | IAP_F_CC2),
     IAPDESCR(C2H_10H, 0xC2, 0x10, IAP_F_FM | IAP_F_CA),
 
     IAPDESCR(C3H_00H, 0xC3, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(C3H_01H, 0xC3, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C3H_04H, 0xC3, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(C3H_01H, 0xC3, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C3H_02H, 0xC3, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C3H_04H, 0xC3, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C3H_10H, 0xC3, 0x10, IAP_F_FM | IAP_F_I7O),
 
-    IAPDESCR(C4H_00H, 0xC4, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(C4H_01H, 0xC4, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C4H_02H, 0xC4, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C4H_04H, 0xC4, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(C4H_00H, 0xC4, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C4H_01H, 0xC4, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C4H_02H, 0xC4, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C4H_04H, 0xC4, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(C4H_08H, 0xC4, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(C4H_0CH, 0xC4, 0x0C, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(C4H_0FH, 0xC4, 0x0F, IAP_F_FM | IAP_F_CA),
 
-    IAPDESCR(C5H_00H, 0xC5, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(C5H_00H, 0xC5, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C5H_01H, 0xC5, 0x01, IAP_F_FM | IAP_F_WM),
+    IAPDESCR(C5H_02H, 0xC5, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C5H_04H, 0xC5, 0x04, IAP_F_FM | IAP_F_WM),
 
     IAPDESCR(C6H_00H, 0xC6, 0x00, IAP_F_FM | IAP_F_CC),
     IAPDESCR(C6H_01H, 0xC6, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(C6H_02H, 0xC6, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(C7H_00H, 0xC7, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(C7H_01H, 0xC7, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C7H_02H, 0xC7, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C7H_04H, 0xC7, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C7H_08H, 0xC7, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(C7H_10H, 0xC7, 0x10, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(C7H_01H, 0xC7, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C7H_02H, 0xC7, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C7H_04H, 0xC7, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C7H_08H, 0xC7, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(C7H_10H, 0xC7, 0x10, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(C7H_1FH, 0xC7, 0x1F, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(C8H_00H, 0xC8, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(C8H_00H, 0xC8, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(C8H_20H, 0xC8, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(C9H_00H, 0xC9, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(C9H_00H, 0xC9, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
 
     IAPDESCR(CAH_00H, 0xCA, 0x00, IAP_F_FM | IAP_F_CC),
     IAPDESCR(CAH_01H, 0xCA, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
@@ -894,36 +1182,59 @@ static struct iap_event_descr iap_events[] = {
     IAPDESCR(CAH_04H, 0xCA, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(CAH_08H, 0xCA, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(CBH_01H, 0xCB, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(CBH_02H, 0xCB, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(CBH_04H, 0xCB, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(CBH_08H, 0xCB, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(CBH_10H, 0xCB, 0x10, IAP_F_FM | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(CBH_01H, 0xCB, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(CBH_02H, 0xCB, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(CBH_04H, 0xCB, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(CBH_08H, 0xCB, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(CBH_10H, 0xCB, 0x10, IAP_F_FM | IAP_F_CC2 | IAP_F_I7 |
+	IAP_F_WM),
+    IAPDESCR(CBH_40H, 0xCB, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(CBH_80H, 0xCB, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
     IAPDESCR(CCH_00H, 0xCC, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(CCH_01H, 0xCC, 0x01, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(CCH_02H, 0xCC, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(CCH_01H, 0xCC, 0x01, IAP_F_FM | IAP_F_ALLCPUSCORE2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(CCH_02H, 0xCC, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(CCH_03H, 0xCC, 0x03, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(CDH_00H, 0xCD, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(CEH_00H, 0xCE, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(CDH_00H, 0xCD, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(CEH_00H, 0xCE, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
     IAPDESCR(CFH_00H, 0xCF, 0x00, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(D0H_00H, 0xD0, 0x00, IAP_F_FM | IAP_F_CC),
+    IAPDESCR(D0H_01H, 0xD0, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(D1H_01H, 0xD1, 0x01, IAP_F_FM | IAP_F_WM),
+    IAPDESCR(D1H_02H, 0xD1, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(D1H_04H, 0xD1, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(D1H_08H, 0xD1, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    IAPDESCR(D2H_01H, 0xD2, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(D2H_02H, 0xD2, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(D2H_04H, 0xD2, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(D2H_08H, 0xD2, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
-    IAPDESCR(D2H_0FH, 0xD2, 0x0F, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(D2H_01H, 0xD2, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(D2H_02H, 0xD2, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(D2H_04H, 0xD2, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(D2H_08H, 0xD2, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(D2H_0FH, 0xD2, 0x0F, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(D2H_10H, 0xD2, 0x10, IAP_F_FM | IAP_F_CC2E),
 
-    IAPDESCR(D4H_01H, 0xD4, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(D4H_01H, 0xD4, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(D4H_02H, 0xD4, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(D4H_04H, 0xD4, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(D4H_08H, 0xD4, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(D4H_0FH, 0xD4, 0x0F, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
-    IAPDESCR(D5H_01H, 0xD5, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 | IAP_F_I7),
+    IAPDESCR(D5H_01H, 0xD5, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2 |
+	IAP_F_I7 | IAP_F_WM),
     IAPDESCR(D5H_02H, 0xD5, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(D5H_04H, 0xD5, 0x04, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(D5H_08H, 0xD5, 0x08, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
@@ -947,6 +1258,7 @@ static struct iap_event_descr iap_events[] = {
     IAPDESCR(DAH_02H, 0xDA, 0x02, IAP_F_FM | IAP_F_CC),
 
     IAPDESCR(DBH_00H, 0xDB, 0x00, IAP_F_FM | IAP_F_CC),
+    IAPDESCR(DBH_01H, 0xDB, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
     IAPDESCR(DCH_01H, 0xDC, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
     IAPDESCR(DCH_02H, 0xDC, 0x02, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
@@ -956,276 +1268,76 @@ static struct iap_event_descr iap_events[] = {
     IAPDESCR(DCH_1FH, 0xDC, 0x1F, IAP_F_FM | IAP_F_CA | IAP_F_CC2),
 
     IAPDESCR(E0H_00H, 0xE0, 0x00, IAP_F_FM | IAP_F_CC | IAP_F_CC2),
-    IAPDESCR(E0H_01H, 0xE0, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7),
+    IAPDESCR(E0H_01H, 0xE0, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7 |
+	IAP_F_WM),
 
     IAPDESCR(E2H_00H, 0xE2, 0x00, IAP_F_FM | IAP_F_CC),
-    IAPDESCR(E4H_00H, 0xE4, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
 
-    IAPDESCR(E6H_00H, 0xE6, 0x00, IAP_F_FM | IAP_F_CC | IAP_F_CC2),
-    IAPDESCR(E6H_01H, 0xE6, 0x01, IAP_F_FM | IAP_F_CA),
+    IAPDESCR(E4H_00H, 0xE4, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(E4H_01H, 0xE4, 0x01, IAP_F_FM | IAP_F_I7O),
 
-    IAPDESCR(F0H_00H, 0xF0, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
-    IAPDESCR(F8H_00H, 0xF8, 0x00, IAP_F_FM | IAP_F_ALLCPUS),
+    IAPDESCR(E5H_01H, 0xE5, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
 
-    /* Added with nehalem. */
-    IAPDESCR(02H_01H, 0x02, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(03H_01H, 0x03, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(05H_01H, 0x05, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(05H_02H, 0x05, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(05H_03H, 0x05, 0x03, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(06H_01H, 0x06, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(06H_02H, 0x06, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(06H_04H, 0x06, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(06H_08H, 0x06, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(06H_0FH, 0x06, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(08H_10H, 0x08, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(08H_20H, 0x08, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(08H_40H, 0x08, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(08H_80H, 0x08, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(09H_04H, 0x09, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(09H_08H, 0x09, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0BH_01H, 0x0B, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0BH_02H, 0x0B, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0EH_01H, 0x0E, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0EH_02H, 0x0E, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0FH_02H, 0x0F, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0FH_08H, 0x0F, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0FH_10H, 0x0F, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(0FH_20H, 0x0F, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(10H_02H, 0x10, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(10H_04H, 0x10, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(10H_08H, 0x10, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(10H_10H, 0x10, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(10H_20H, 0x10, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(10H_40H, 0x10, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(10H_80H, 0x10, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(12H_02H, 0x12, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(12H_04H, 0x12, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(12H_08H, 0x12, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(12H_10H, 0x12, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(12H_20H, 0x12, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(12H_40H, 0x12, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(13H_02H, 0x13, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(13H_04H, 0x13, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(13H_07H, 0x13, 0x07, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(14H_02H, 0x14, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(17H_01H, 0x17, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(18H_01H, 0x18, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(1DH_01H, 0x1D, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(1DH_02H, 0x1D, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(1DH_04H, 0x1D, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(1EH_01H, 0x1E, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_01H, 0x24, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_02H, 0x24, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_03H, 0x24, 0x03, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_04H, 0x24, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_08H, 0x24, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_0CH, 0x24, 0x0C, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_10H, 0x24, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_20H, 0x24, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_30H, 0x24, 0x30, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_40H, 0x24, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_80H, 0x24, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_AAH, 0x24, 0xAA, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_C0H, 0x24, 0xC0, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(24H_FFH, 0x24, 0xFF, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_01H, 0x26, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_02H, 0x26, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_04H, 0x26, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_08H, 0x26, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_0FH, 0x26, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_10H, 0x26, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_20H, 0x26, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_40H, 0x26, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_80H, 0x26, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_F0H, 0x26, 0xF0, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(26H_FFH, 0x26, 0xFF, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_01H, 0x27, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_02H, 0x27, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_04H, 0x27, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_08H, 0x27, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_0EH, 0x27, 0x0E, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_0FH, 0x27, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_10H, 0x27, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_20H, 0x27, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_40H, 0x27, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_80H, 0x27, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_E0H, 0x27, 0xE0, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(27H_F0H, 0x27, 0xF0, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(28H_01H, 0x28, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(28H_02H, 0x28, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(28H_04H, 0x28, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(28H_08H, 0x28, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(28H_0FH, 0x28, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(3DH_01H, 0x3D, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(40H_01H, 0x40, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(40H_02H, 0x40, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(40H_04H, 0x40, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(40H_08H, 0x40, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(40H_0FH, 0x40, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(41H_01H, 0x41, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(41H_02H, 0x41, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(41H_04H, 0x41, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(41H_08H, 0x41, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(41H_0FH, 0x41, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(42H_01H, 0x42, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(42H_02H, 0x42, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(42H_04H, 0x42, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(42H_08H, 0x42, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(48H_02H, 0x48, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(49H_10H, 0x49, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(49H_20H, 0x49, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(49H_40H, 0x49, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(49H_80H, 0x49, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4BH_08H, 0x4B, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4CH_01H, 0x4C, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4DH_01H, 0x4D, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4EH_01H, 0x4E, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4EH_02H, 0x4E, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4EH_04H, 0x4E, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4FH_02H, 0x4F, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4FH_04H, 0x4F, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(4FH_08H, 0x4F, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(51H_01H, 0x51, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(51H_02H, 0x51, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(51H_04H, 0x51, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(51H_08H, 0x51, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(52H_01H, 0x52, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(53H_01H, 0x53, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(60H_01H, 0x60, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(60H_02H, 0x60, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(60H_04H, 0x60, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(60H_08H, 0x60, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(63H_01H, 0x63, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(63H_02H, 0x63, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(6CH_01H, 0x6C, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(80H_01H, 0x80, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(80H_04H, 0x80, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(80H_10H, 0x80, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(81H_01H, 0x81, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(81H_02H, 0x81, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(82H_01H, 0x82, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(83H_01H, 0x83, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(85H_01H, 0x85, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(85H_02H, 0x85, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(85H_04H, 0x85, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(85H_10H, 0x85, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(85H_20H, 0x85, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(85H_40H, 0x85, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(85H_80H, 0x85, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(87H_01H, 0x87, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(87H_02H, 0x87, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(87H_04H, 0x87, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(87H_08H, 0x87, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(87H_0FH, 0x87, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_01H, 0x88, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_02H, 0x88, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_04H, 0x88, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_07H, 0x88, 0x07, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_08H, 0x88, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_10H, 0x88, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_20H, 0x88, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_30H, 0x88, 0x30, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(88H_40H, 0x88, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_01H, 0x89, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_02H, 0x89, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_04H, 0x89, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_07H, 0x89, 0x07, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_08H, 0x89, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_10H, 0x89, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_20H, 0x89, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_30H, 0x89, 0x30, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_40H, 0x89, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(89H_7FH, 0x89, 0x7F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_01H, 0xA2, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_02H, 0xA2, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_04H, 0xA2, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_08H, 0xA2, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_10H, 0xA2, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_20H, 0xA2, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_40H, 0xA2, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A2H_80H, 0xA2, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A6H_01H, 0xA6, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A7H_01H, 0xA7, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(A8H_01H, 0xA8, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B0H_01H, 0xB0, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B0H_02H, 0xB0, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B0H_04H, 0xB0, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B0H_08H, 0xB0, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B0H_20H, 0xB0, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B0H_40H, 0xB0, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B1H_01H, 0xB1, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B1H_02H, 0xB1, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B1H_04H, 0xB1, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B1H_08H, 0xB1, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B1H_10H, 0xB1, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B1H_20H, 0xB1, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B1H_40H, 0xB1, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B2H_01H, 0xB2, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B7H_01H, 0xB7, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B8H_01H, 0xB8, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B8H_02H, 0xB8, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(B8H_04H, 0xB8, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(BAH_01H, 0xBA, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(BAH_02H, 0xBA, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(C3H_02H, 0xC3, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(C3H_10H, 0xC3, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(C5H_02H, 0xC5, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(C8H_20H, 0xC8, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(CBH_40H, 0xCB, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(CBH_80H, 0xCB, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(CCH_03H, 0xCC, 0x03, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(D0H_01H, 0xD0, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(D1H_02H, 0xD1, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(D1H_04H, 0xD1, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(D1H_08H, 0xD1, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(DBH_01H, 0xDB, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(E4H_01H, 0xE4, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(E5H_01H, 0xE5, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(E6H_01H, 0xE6, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(E6H_02H, 0xE6, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(E8H_01H, 0xE8, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(E8H_02H, 0xE8, 0x02, IAP_F_FM | IAP_F_I7),
+    IAPDESCR(E6H_00H, 0xE6, 0x00, IAP_F_FM | IAP_F_CC | IAP_F_CC2),
+    IAPDESCR(E6H_01H, 0xE6, 0x01, IAP_F_FM | IAP_F_CA | IAP_F_I7 |
+	IAP_F_WM),
+    IAPDESCR(E6H_02H, 0xE6, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(E8H_01H, 0xE8, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(E8H_02H, 0xE8, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
     IAPDESCR(E8H_03H, 0xE8, 0x03, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_01H, 0xF0, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_02H, 0xF0, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_04H, 0xF0, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_08H, 0xF0, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_10H, 0xF0, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_20H, 0xF0, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_40H, 0xF0, 0x40, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F0H_80H, 0xF0, 0x80, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F1H_02H, 0xF1, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F1H_04H, 0xF1, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F1H_07H, 0xF1, 0x07, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F2H_01H, 0xF2, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F2H_02H, 0xF2, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F2H_04H, 0xF2, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F2H_08H, 0xF2, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F2H_0FH, 0xF2, 0x0F, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F3H_01H, 0xF3, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F3H_02H, 0xF3, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F3H_04H, 0xF3, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F3H_08H, 0xF3, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F3H_10H, 0xF3, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F3H_20H, 0xF3, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F4H_01H, 0xF4, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F4H_02H, 0xF4, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F4H_04H, 0xF4, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F4H_08H, 0xF4, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F4H_10H, 0xF4, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F6H_01H, 0xF6, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F7H_01H, 0xF7, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F7H_02H, 0xF7, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F7H_04H, 0xF7, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(F8H_01H, 0xF8, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(FDH_01H, 0xFD, 0x01, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(FDH_02H, 0xFD, 0x02, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(FDH_04H, 0xFD, 0x04, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(FDH_08H, 0xFD, 0x08, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(FDH_10H, 0xFD, 0x10, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(FDH_20H, 0xFD, 0x20, IAP_F_FM | IAP_F_I7),
-    IAPDESCR(FDH_40H, 0xFD, 0x40, IAP_F_FM | IAP_F_I7),
+
+    IAPDESCR(ECH_01H, 0xEC, 0x01, IAP_F_FM | IAP_F_WM),
+
+    IAPDESCR(F0H_00H, 0xF0, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(F0H_01H, 0xF0, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F0H_02H, 0xF0, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F0H_04H, 0xF0, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F0H_08H, 0xF0, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F0H_10H, 0xF0, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F0H_20H, 0xF0, 0x20, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F0H_40H, 0xF0, 0x40, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F0H_80H, 0xF0, 0x80, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(F1H_02H, 0xF1, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F1H_04H, 0xF1, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F1H_07H, 0xF1, 0x07, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(F2H_01H, 0xF2, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F2H_02H, 0xF2, 0x02, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F2H_04H, 0xF2, 0x04, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F2H_08H, 0xF2, 0x08, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+    IAPDESCR(F2H_0FH, 0xF2, 0x0F, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(F3H_01H, 0xF3, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F3H_02H, 0xF3, 0x02, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F3H_04H, 0xF3, 0x04, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F3H_08H, 0xF3, 0x08, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F3H_10H, 0xF3, 0x10, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F3H_20H, 0xF3, 0x20, IAP_F_FM | IAP_F_I7O),
+
+    IAPDESCR(F4H_01H, 0xF4, 0x01, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F4H_02H, 0xF4, 0x02, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F4H_04H, 0xF4, 0x04, IAP_F_FM | IAP_F_WM | IAP_F_I7O),
+    IAPDESCR(F4H_08H, 0xF4, 0x08, IAP_F_FM | IAP_F_I7O),
+    IAPDESCR(F4H_10H, 0xF4, 0x10, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(F6H_01H, 0xF6, 0x01, IAP_F_FM | IAP_F_I7 | IAP_F_WM),
+
+    IAPDESCR(F7H_01H, 0xF7, 0x01, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(F7H_02H, 0xF7, 0x02, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(F7H_04H, 0xF7, 0x04, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+
+    IAPDESCR(F8H_00H, 0xF8, 0x00, IAP_F_FM | IAP_F_ALLCPUSCORE2),
+    IAPDESCR(F8H_01H, 0xF8, 0x01, IAP_F_FM | IAP_F_I7O),
+
+    IAPDESCR(FDH_01H, 0xFD, 0x01, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(FDH_02H, 0xFD, 0x02, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(FDH_04H, 0xFD, 0x04, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(FDH_08H, 0xFD, 0x08, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(FDH_10H, 0xFD, 0x10, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(FDH_20H, 0xFD, 0x20, IAP_F_FM | IAP_F_WM | IAP_F_I7),
+    IAPDESCR(FDH_40H, 0xFD, 0x40, IAP_F_FM | IAP_F_WM | IAP_F_I7),
 };
 
 static const int niap_events = sizeof(iap_events) / sizeof(iap_events[0]);
@@ -1299,6 +1411,80 @@ iap_architectural_event_is_unsupported(enum pmc_event pe)
 }
 
 static int
+iap_event_corei7_ok_on_counter(enum pmc_event pe, int ri)
+{
+	uint32_t mask;
+
+	switch (pe) {
+		/*
+		 * Events valid only on counter 0, 1.
+		 */
+	case PMC_EV_IAP_EVENT_40H_01H:
+	case PMC_EV_IAP_EVENT_40H_02H:
+	case PMC_EV_IAP_EVENT_40H_04H:
+	case PMC_EV_IAP_EVENT_40H_08H:
+	case PMC_EV_IAP_EVENT_40H_0FH:
+	case PMC_EV_IAP_EVENT_41H_02H:
+	case PMC_EV_IAP_EVENT_41H_04H:
+	case PMC_EV_IAP_EVENT_41H_08H:
+	case PMC_EV_IAP_EVENT_42H_01H:
+	case PMC_EV_IAP_EVENT_42H_02H:
+	case PMC_EV_IAP_EVENT_42H_04H:
+	case PMC_EV_IAP_EVENT_42H_08H:
+	case PMC_EV_IAP_EVENT_43H_01H:
+	case PMC_EV_IAP_EVENT_43H_02H:
+	case PMC_EV_IAP_EVENT_48H_02H:
+	case PMC_EV_IAP_EVENT_51H_01H:
+	case PMC_EV_IAP_EVENT_51H_02H:
+	case PMC_EV_IAP_EVENT_51H_04H:
+	case PMC_EV_IAP_EVENT_51H_08H:
+	case PMC_EV_IAP_EVENT_63H_01H:
+	case PMC_EV_IAP_EVENT_63H_02H:
+		mask = 0x3;
+		break;
+
+	default:
+		mask = ~0;	/* Any row index is ok. */
+	}
+
+	return (mask & (1 << ri));
+}
+
+static int
+iap_event_westmere_ok_on_counter(enum pmc_event pe, int ri)
+{
+	uint32_t mask;
+
+	switch (pe) {
+		/*
+		 * Events valid only on counter 0.
+		 */
+	case PMC_EV_IAP_EVENT_B3H_01H:
+	case PMC_EV_IAP_EVENT_B3H_02H:
+	case PMC_EV_IAP_EVENT_B3H_04H:
+		mask = 0x1;
+		break;
+
+		/*
+		 * Events valid only on counter 0, 1.
+		 */
+	case PMC_EV_IAP_EVENT_51H_01H:
+	case PMC_EV_IAP_EVENT_51H_02H:
+	case PMC_EV_IAP_EVENT_51H_04H:
+	case PMC_EV_IAP_EVENT_51H_08H:
+	case PMC_EV_IAP_EVENT_63H_01H:
+	case PMC_EV_IAP_EVENT_63H_02H:
+		mask = 0x3;
+		break;
+
+	default:
+		mask = ~0;	/* Any row index is ok. */
+	}
+
+	return (mask & (1 << ri));
+}
+
+static int
 iap_event_ok_on_counter(enum pmc_event pe, int ri)
 {
 	uint32_t mask;
@@ -1310,6 +1496,9 @@ iap_event_ok_on_counter(enum pmc_event pe, int ri)
 	case PMC_EV_IAP_EVENT_10H_00H:
 	case PMC_EV_IAP_EVENT_14H_00H:
 	case PMC_EV_IAP_EVENT_18H_00H:
+	case PMC_EV_IAP_EVENT_B3H_01H:
+	case PMC_EV_IAP_EVENT_B3H_02H:
+	case PMC_EV_IAP_EVENT_B3H_04H:
 	case PMC_EV_IAP_EVENT_C1H_00H:
 	case PMC_EV_IAP_EVENT_CBH_01H:
 	case PMC_EV_IAP_EVENT_CBH_02H:
@@ -1356,8 +1545,19 @@ iap_allocate_pmc(int cpu, int ri, struct pmc *pm,
 	if (iap_architectural_event_is_unsupported(ev))
 		return (EOPNOTSUPP);
 
-	if (iap_event_ok_on_counter(ev, ri) == 0)
-		return (EINVAL);
+	switch (core_cputype) {
+	case PMC_CPU_INTEL_COREI7:
+		if (iap_event_corei7_ok_on_counter(ev, ri) == 0)
+			return (EINVAL);
+		break;
+	case PMC_CPU_INTEL_WESTMERE:
+		if (iap_event_westmere_ok_on_counter(ev, ri) == 0)
+			return (EINVAL);
+		break;
+	default:
+		if (iap_event_ok_on_counter(ev, ri) == 0)
+			return (EINVAL);
+	}
 
 	/*
 	 * Look for an event descriptor with matching CPU and event id
@@ -1381,6 +1581,9 @@ iap_allocate_pmc(int cpu, int ri, struct pmc *pm,
 	case PMC_CPU_INTEL_COREI7:
 		cpuflag = IAP_F_I7;
 		break;
+	case PMC_CPU_INTEL_WESTMERE:
+		cpuflag = IAP_F_WM;
+		break;
 	}
 
 	for (n = 0, ie = iap_events; n < niap_events; n++, ie++)
@@ -1469,6 +1672,22 @@ iap_allocate_pmc(int cpu, int ri, struct pmc *pm,
 	else if (config & IAP_ANY)
 		return (EINVAL);
 
+	/*
+	 * Check offcore response configuration.
+	 */
+	if (a->pm_md.pm_iap.pm_iap_rsp != 0) {
+		if (ev != PMC_EV_IAP_EVENT_B7H_01H &&
+		    ev != PMC_EV_IAP_EVENT_BBH_01H)
+			return (EINVAL);
+		if (core_cputype == PMC_CPU_INTEL_COREI7 &&
+		    ev == PMC_EV_IAP_EVENT_BBH_01H)
+			return (EINVAL);
+		if ( a->pm_md.pm_iap.pm_iap_rsp & ~IA_OFFCORE_RSP_MASK)
+			return (EINVAL);
+		pm->pm_md.pm_iap.pm_iap_rsp =
+		    a->pm_md.pm_iap.pm_iap_rsp & IA_OFFCORE_RSP_MASK;
+	}
+
 	if (caps & PMC_CAP_THRESHOLD)
 		evsel |= (a->pm_md.pm_iap.pm_iap_config & IAP_F_CMASK);
 	if (caps & PMC_CAP_USER)
@@ -1628,6 +1847,18 @@ iap_start_pmc(int cpu, int ri)
 	PMCDBG(MDP,STA,2, "iap-start/2 cpu=%d ri=%d evselmsr=0x%x evsel=0x%x",
 	    cpu, ri, IAP_EVSEL0 + ri, evsel);
 
+	/* Event specific configuration. */
+	switch (pm->pm_event) {
+	case PMC_EV_IAP_EVENT_B7H_01H:
+		wrmsr(IA_OFFCORE_RSP0, pm->pm_md.pm_iap.pm_iap_rsp);
+		break;
+	case PMC_EV_IAP_EVENT_BBH_01H:
+		wrmsr(IA_OFFCORE_RSP1, pm->pm_md.pm_iap.pm_iap_rsp);
+		break;
+	default:
+		break;
+	}
+
 	wrmsr(IAP_EVSEL0 + ri, evsel | IAP_EN);
 
 	if (core_cputype == PMC_CPU_INTEL_CORE)
@@ -1863,6 +2094,8 @@ core2_intr(int cpu, struct trapframe *tf)
 
 		error = pmc_process_interrupt(cpu, pm, tf,
 		    TRAPF_USERMODE(tf));
+		if (error)
+			intrenable &= ~flag;
 
 		v = iaf_reload_count_to_perfctr_value(pm->pm_sc.pm_reloadcount);
 
@@ -1871,9 +2104,6 @@ core2_intr(int cpu, struct trapframe *tf)
 
 		PMCDBG(MDP,INT, 1, "iaf-intr cpu=%d error=%d v=%jx(%jx)", cpu, error,
 		    (uintmax_t) v, (uintmax_t) rdpmc(IAF_RI_TO_MSR(n)));
-
-		if (error)
-			intrenable &= ~flag;
 	}
 
 	/*
diff --git a/sys/dev/hwpmc/hwpmc_core.h b/sys/dev/hwpmc/hwpmc_core.h
index 0c4ee5b38895..e88ecb0b3434 100644
--- a/sys/dev/hwpmc/hwpmc_core.h
+++ b/sys/dev/hwpmc/hwpmc_core.h
@@ -46,6 +46,7 @@ struct pmc_md_iaf_op_pmcallocate {
  */
 struct pmc_md_iap_op_pmcallocate {
 	uint32_t	pm_iap_config;
+	uint32_t	pm_iap_rsp;
 };
 
 #define	IAP_EVSEL(C)	((C) & 0xFF)
@@ -59,6 +60,8 @@ struct pmc_md_iap_op_pmcallocate {
 #define	IAP_INV		(1 << 23)
 #define	IAP_CMASK(C)	(((C) & 0xFF) << 24)
 
+#define	IA_OFFCORE_RSP_MASK	0xF7FF
+
 #ifdef	_KERNEL
 
 /*
@@ -76,16 +79,15 @@ struct pmc_md_iap_op_pmcallocate {
 /*
  * Programmable counters.
  */
-#define	IAP_PMC0				0x0C1
-#define	IAP_PMC1				0x0C2
 
+#define	IAP_PMC0				0x0C1
 #define	IAP_EVSEL0				0x186
-#define	IAP_EVSEL1				0x187
 
 /*
  * Simplified programming interface in Intel Performance Architecture
  * v2 and later.
  */
+
 #define	IA_GLOBAL_STATUS			0x38E
 #define	IA_GLOBAL_CTRL				0x38F
 #define	IA_GLOBAL_OVF_CTRL			0x390
@@ -93,12 +95,19 @@ struct pmc_md_iap_op_pmcallocate {
 #define	IA_GLOBAL_STATUS_FLAG_CONDCHG		(1ULL << 63)
 #define	IA_GLOBAL_STATUS_FLAG_OVFBUF		(1ULL << 62)
 
+/*
+ * Offcore response configuration.
+ */
+#define	IA_OFFCORE_RSP0				0x1A6
+#define	IA_OFFCORE_RSP1				0x1A7
+
 struct pmc_md_iaf_pmc {
 	uint64_t	pm_iaf_ctrl;
 };
 
 struct pmc_md_iap_pmc {
 	uint32_t	pm_iap_evsel;
+	uint32_t	pm_iap_rsp;
 };
 
 /*
diff --git a/sys/dev/hwpmc/hwpmc_intel.c b/sys/dev/hwpmc/hwpmc_intel.c
index e953f689f8b9..82d50794df16 100644
--- a/sys/dev/hwpmc/hwpmc_intel.c
+++ b/sys/dev/hwpmc/hwpmc_intel.c
@@ -133,8 +133,14 @@ pmc_intel_initialize(void)
 		case 0x1A:
 		case 0x1E:	/* Per Intel document 253669-032 9/2009, pages A-2 and A-57 */
 		case 0x1F:	/* Per Intel document 253669-032 9/2009, pages A-2 and A-57 */
+		case 0x2E:
 			cputype = PMC_CPU_INTEL_COREI7;
-			nclasses = 3;
+			nclasses = 5;
+			break;
+		case 0x25:	/* Per Intel document 253669-033US 12/2009. */
+		case 0x2C:	/* Per Intel document 253669-033US 12/2009. */
+			cputype = PMC_CPU_INTEL_WESTMERE;
+			nclasses = 5;
 			break;
 		}
 		break;
@@ -176,6 +182,7 @@ pmc_intel_initialize(void)
 	case PMC_CPU_INTEL_CORE2:
 	case PMC_CPU_INTEL_CORE2EXTREME:
 	case PMC_CPU_INTEL_COREI7:
+	case PMC_CPU_INTEL_WESTMERE:
 		error = pmc_core_initialize(pmc_mdep, ncpus);
 		break;
 
@@ -226,6 +233,22 @@ pmc_intel_initialize(void)
 		KASSERT(0, ("[intel,%d] Unknown CPU type", __LINE__));
 	}
 
+	/*
+	 * Init the uncore class.
+	 */
+#if	defined(__i386__) || defined(__amd64__)
+	switch (cputype) {
+		/*
+		 * Intel Corei7 and Westmere processors.
+		 */
+	case PMC_CPU_INTEL_COREI7:
+	case PMC_CPU_INTEL_WESTMERE:
+		error = pmc_uncore_initialize(pmc_mdep, ncpus);
+		break;
+	default:
+		break;
+	}
+#endif
 
   error:
 	if (error) {
@@ -247,6 +270,8 @@ pmc_intel_finalize(struct pmc_mdep *md)
 	case PMC_CPU_INTEL_CORE:
 	case PMC_CPU_INTEL_CORE2:
 	case PMC_CPU_INTEL_CORE2EXTREME:
+	case PMC_CPU_INTEL_COREI7:
+	case PMC_CPU_INTEL_WESTMERE:
 		pmc_core_finalize(md);
 		break;
 
@@ -269,4 +294,18 @@ pmc_intel_finalize(struct pmc_mdep *md)
 	default:
 		KASSERT(0, ("[intel,%d] unknown CPU type", __LINE__));
 	}
+
+	/*
+	 * Uncore.
+	 */
+#if	defined(__i386__) || defined(__amd64__)
+	switch (md->pmd_cputype) {
+	case PMC_CPU_INTEL_COREI7:
+	case PMC_CPU_INTEL_WESTMERE:
+		pmc_uncore_finalize(md);
+		break;
+	default:
+		break;
+	}
+#endif
 }
diff --git a/sys/dev/hwpmc/hwpmc_uncore.c b/sys/dev/hwpmc/hwpmc_uncore.c
new file mode 100644
index 000000000000..36cd95c09c46
--- /dev/null
+++ b/sys/dev/hwpmc/hwpmc_uncore.c
@@ -0,0 +1,1121 @@
+/*-
+ * Copyright (c) 2010 Fabien Thomas
+ * 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.
+ */
+
+/*
+ * Intel Uncore PMCs.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/pmc.h>
+#include <sys/pmckern.h>
+#include <sys/systm.h>
+
+#include <machine/intr_machdep.h>
+#include <machine/apicvar.h>
+#include <machine/cpu.h>
+#include <machine/cpufunc.h>
+#include <machine/specialreg.h>
+
+#define	UCF_PMC_CAPS \
+	(PMC_CAP_READ | PMC_CAP_WRITE)
+
+#define	UCP_PMC_CAPS \
+    (PMC_CAP_EDGE | PMC_CAP_THRESHOLD | PMC_CAP_READ | PMC_CAP_WRITE | \
+    PMC_CAP_INVERT | PMC_CAP_QUALIFIER | PMC_CAP_PRECISE)
+
+static enum pmc_cputype	uncore_cputype;
+
+struct uncore_cpu {
+	volatile uint32_t	pc_resync;
+	volatile uint32_t	pc_ucfctrl;	/* Fixed function control. */
+	volatile uint64_t	pc_globalctrl;	/* Global control register. */
+	struct pmc_hw		pc_uncorepmcs[];
+};
+
+static struct uncore_cpu **uncore_pcpu;
+
+static uint64_t uncore_pmcmask;
+
+static int uncore_ucf_ri;		/* relative index of fixed counters */
+static int uncore_ucf_width;
+static int uncore_ucf_npmc;
+
+static int uncore_ucp_width;
+static int uncore_ucp_npmc;
+
+static int
+uncore_pcpu_noop(struct pmc_mdep *md, int cpu)
+{
+	(void) md;
+	(void) cpu;
+	return (0);
+}
+
+static int
+uncore_pcpu_init(struct pmc_mdep *md, int cpu)
+{
+	struct pmc_cpu *pc;
+	struct uncore_cpu *cc;
+	struct pmc_hw *phw;
+	int uncore_ri, n, npmc;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[ucf,%d] insane cpu number %d", __LINE__, cpu));
+
+	PMCDBG(MDP,INI,1,"uncore-init cpu=%d", cpu);
+
+	uncore_ri = md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCP].pcd_ri;
+	npmc = md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCP].pcd_num;
+	npmc += md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCF].pcd_num;
+
+	cc = malloc(sizeof(struct uncore_cpu) + npmc * sizeof(struct pmc_hw),
+	    M_PMC, M_WAITOK | M_ZERO);
+
+	uncore_pcpu[cpu] = cc;
+	pc = pmc_pcpu[cpu];
+
+	KASSERT(pc != NULL && cc != NULL,
+	    ("[uncore,%d] NULL per-cpu structures cpu=%d", __LINE__, cpu));
+
+	for (n = 0, phw = cc->pc_uncorepmcs; n < npmc; n++, phw++) {
+		phw->phw_state 	  = PMC_PHW_FLAG_IS_ENABLED |
+		    PMC_PHW_CPU_TO_STATE(cpu) |
+		    PMC_PHW_INDEX_TO_STATE(n + uncore_ri);
+		phw->phw_pmc	  = NULL;
+		pc->pc_hwpmcs[n + uncore_ri]  = phw;
+	}
+
+	return (0);
+}
+
+static int
+uncore_pcpu_fini(struct pmc_mdep *md, int cpu)
+{
+	int uncore_ri, n, npmc;
+	struct pmc_cpu *pc;
+	struct uncore_cpu *cc;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] insane cpu number (%d)", __LINE__, cpu));
+
+	PMCDBG(MDP,INI,1,"uncore-pcpu-fini cpu=%d", cpu);
+
+	if ((cc = uncore_pcpu[cpu]) == NULL)
+		return (0);
+
+	uncore_pcpu[cpu] = NULL;
+
+	pc = pmc_pcpu[cpu];
+
+	KASSERT(pc != NULL, ("[uncore,%d] NULL per-cpu %d state", __LINE__,
+		cpu));
+
+	npmc = md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCP].pcd_num;
+	uncore_ri = md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCP].pcd_ri;
+
+	for (n = 0; n < npmc; n++)
+		wrmsr(UCP_EVSEL0 + n, 0);
+
+	wrmsr(UCF_CTRL, 0);
+	npmc += md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCF].pcd_num;
+
+	for (n = 0; n < npmc; n++)
+		pc->pc_hwpmcs[n + uncore_ri] = NULL;
+
+	free(cc, M_PMC);
+
+	return (0);
+}
+
+/*
+ * Fixed function counters.
+ */
+
+static pmc_value_t
+ucf_perfctr_value_to_reload_count(pmc_value_t v)
+{
+	v &= (1ULL << uncore_ucf_width) - 1;
+	return (1ULL << uncore_ucf_width) - v;
+}
+
+static pmc_value_t
+ucf_reload_count_to_perfctr_value(pmc_value_t rlc)
+{
+	return (1ULL << uncore_ucf_width) - rlc;
+}
+
+static int
+ucf_allocate_pmc(int cpu, int ri, struct pmc *pm,
+    const struct pmc_op_pmcallocate *a)
+{
+	enum pmc_event ev;
+	uint32_t caps, flags;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU %d", __LINE__, cpu));
+
+	PMCDBG(MDP,ALL,1, "ucf-allocate ri=%d reqcaps=0x%x", ri, pm->pm_caps);
+
+	if (ri < 0 || ri > uncore_ucf_npmc)
+		return (EINVAL);
+
+	caps = a->pm_caps;
+
+	if (a->pm_class != PMC_CLASS_UCF ||
+	    (caps & UCF_PMC_CAPS) != caps)
+		return (EINVAL);
+
+	ev = pm->pm_event;
+	if (ev < PMC_EV_UCF_FIRST || ev > PMC_EV_UCF_LAST)
+		return (EINVAL);
+
+	flags = UCF_EN;
+
+	pm->pm_md.pm_ucf.pm_ucf_ctrl = (flags << (ri * 4));
+
+	PMCDBG(MDP,ALL,2, "ucf-allocate config=0x%jx",
+	    (uintmax_t) pm->pm_md.pm_ucf.pm_ucf_ctrl);
+
+	return (0);
+}
+
+static int
+ucf_config_pmc(int cpu, int ri, struct pmc *pm)
+{
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU %d", __LINE__, cpu));
+
+	KASSERT(ri >= 0 && ri < uncore_ucf_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	PMCDBG(MDP,CFG,1, "ucf-config cpu=%d ri=%d pm=%p", cpu, ri, pm);
+
+	KASSERT(uncore_pcpu[cpu] != NULL, ("[uncore,%d] null per-cpu %d", __LINE__,
+	    cpu));
+
+	uncore_pcpu[cpu]->pc_uncorepmcs[ri + uncore_ucf_ri].phw_pmc = pm;
+
+	return (0);
+}
+
+static int
+ucf_describe(int cpu, int ri, struct pmc_info *pi, struct pmc **ppmc)
+{
+	int error;
+	struct pmc_hw *phw;
+	char ucf_name[PMC_NAME_MAX];
+
+	phw = &uncore_pcpu[cpu]->pc_uncorepmcs[ri + uncore_ucf_ri];
+
+	(void) snprintf(ucf_name, sizeof(ucf_name), "UCF-%d", ri);
+	if ((error = copystr(ucf_name, pi->pm_name, PMC_NAME_MAX,
+	    NULL)) != 0)
+		return (error);
+
+	pi->pm_class = PMC_CLASS_UCF;
+
+	if (phw->phw_state & PMC_PHW_FLAG_IS_ENABLED) {
+		pi->pm_enabled = TRUE;
+		*ppmc          = phw->phw_pmc;
+	} else {
+		pi->pm_enabled = FALSE;
+		*ppmc          = NULL;
+	}
+
+	return (0);
+}
+
+static int
+ucf_get_config(int cpu, int ri, struct pmc **ppm)
+{
+	*ppm = uncore_pcpu[cpu]->pc_uncorepmcs[ri + uncore_ucf_ri].phw_pmc;
+
+	return (0);
+}
+
+static int
+ucf_read_pmc(int cpu, int ri, pmc_value_t *v)
+{
+	struct pmc *pm;
+	pmc_value_t tmp;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal cpu value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucf_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	pm = uncore_pcpu[cpu]->pc_uncorepmcs[ri + uncore_ucf_ri].phw_pmc;
+
+	KASSERT(pm,
+	    ("[uncore,%d] cpu %d ri %d(%d) pmc not configured", __LINE__, cpu,
+		ri, ri + uncore_ucf_ri));
+
+	tmp = rdmsr(UCF_CTR0 + ri);
+
+	if (PMC_IS_SAMPLING_MODE(PMC_TO_MODE(pm)))
+		*v = ucf_perfctr_value_to_reload_count(tmp);
+	else
+		*v = tmp;
+
+	PMCDBG(MDP,REA,1, "ucf-read cpu=%d ri=%d -> v=%jx", cpu, ri, *v);
+
+	return (0);
+}
+
+static int
+ucf_release_pmc(int cpu, int ri, struct pmc *pmc)
+{
+	PMCDBG(MDP,REL,1, "ucf-release cpu=%d ri=%d pm=%p", cpu, ri, pmc);
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucf_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	KASSERT(uncore_pcpu[cpu]->pc_uncorepmcs[ri + uncore_ucf_ri].phw_pmc == NULL,
+	    ("[uncore,%d] PHW pmc non-NULL", __LINE__));
+
+	return (0);
+}
+
+static int
+ucf_start_pmc(int cpu, int ri)
+{
+	struct pmc *pm;
+	struct uncore_cpu *ucfc;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucf_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	PMCDBG(MDP,STA,1,"ucf-start cpu=%d ri=%d", cpu, ri);
+
+	ucfc = uncore_pcpu[cpu];
+	pm = ucfc->pc_uncorepmcs[ri + uncore_ucf_ri].phw_pmc;
+
+	ucfc->pc_ucfctrl |= pm->pm_md.pm_ucf.pm_ucf_ctrl;
+
+	wrmsr(UCF_CTRL, ucfc->pc_ucfctrl);
+
+	do {
+		ucfc->pc_resync = 0;
+		ucfc->pc_globalctrl |= (1ULL << (ri + UCF_OFFSET));
+		wrmsr(UC_GLOBAL_CTRL, ucfc->pc_globalctrl);
+	} while (ucfc->pc_resync != 0);
+
+	PMCDBG(MDP,STA,1,"ucfctrl=%x(%x) globalctrl=%jx(%jx)",
+	    ucfc->pc_ucfctrl, (uint32_t) rdmsr(UCF_CTRL),
+	    ucfc->pc_globalctrl, rdmsr(UC_GLOBAL_CTRL));
+
+	return (0);
+}
+
+static int
+ucf_stop_pmc(int cpu, int ri)
+{
+	uint32_t fc;
+	struct uncore_cpu *ucfc;
+
+	PMCDBG(MDP,STO,1,"ucf-stop cpu=%d ri=%d", cpu, ri);
+
+	ucfc = uncore_pcpu[cpu];
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucf_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	fc = (UCF_MASK << (ri * 4));
+
+	ucfc->pc_ucfctrl &= ~fc;
+
+	PMCDBG(MDP,STO,1,"ucf-stop ucfctrl=%x", ucfc->pc_ucfctrl);
+	wrmsr(UCF_CTRL, ucfc->pc_ucfctrl);
+
+	do {
+		ucfc->pc_resync = 0;
+		ucfc->pc_globalctrl &= ~(1ULL << (ri + UCF_OFFSET));
+		wrmsr(UC_GLOBAL_CTRL, ucfc->pc_globalctrl);
+	} while (ucfc->pc_resync != 0);
+
+	PMCDBG(MDP,STO,1,"ucfctrl=%x(%x) globalctrl=%jx(%jx)",
+	    ucfc->pc_ucfctrl, (uint32_t) rdmsr(UCF_CTRL),
+	    ucfc->pc_globalctrl, rdmsr(UC_GLOBAL_CTRL));
+
+	return (0);
+}
+
+static int
+ucf_write_pmc(int cpu, int ri, pmc_value_t v)
+{
+	struct uncore_cpu *cc;
+	struct pmc *pm;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal cpu value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucf_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	cc = uncore_pcpu[cpu];
+	pm = cc->pc_uncorepmcs[ri + uncore_ucf_ri].phw_pmc;
+
+	KASSERT(pm,
+	    ("[uncore,%d] cpu %d ri %d pmc not configured", __LINE__, cpu, ri));
+
+	if (PMC_IS_SAMPLING_MODE(PMC_TO_MODE(pm)))
+		v = ucf_reload_count_to_perfctr_value(v);
+
+	wrmsr(UCF_CTRL, 0);	/* Turn off fixed counters */
+	wrmsr(UCF_CTR0 + ri, v);
+	wrmsr(UCF_CTRL, cc->pc_ucfctrl);
+
+	PMCDBG(MDP,WRI,1, "ucf-write cpu=%d ri=%d v=%jx ucfctrl=%jx ",
+	    cpu, ri, v, (uintmax_t) rdmsr(UCF_CTRL));
+
+	return (0);
+}
+
+
+static void
+ucf_initialize(struct pmc_mdep *md, int maxcpu, int npmc, int pmcwidth)
+{
+	struct pmc_classdep *pcd;
+
+	KASSERT(md != NULL, ("[ucf,%d] md is NULL", __LINE__));
+
+	PMCDBG(MDP,INI,1, "%s", "ucf-initialize");
+
+	pcd = &md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCF];
+
+	pcd->pcd_caps	= UCF_PMC_CAPS;
+	pcd->pcd_class	= PMC_CLASS_UCF;
+	pcd->pcd_num	= npmc;
+	pcd->pcd_ri	= md->pmd_npmc;
+	pcd->pcd_width	= pmcwidth;
+
+	pcd->pcd_allocate_pmc	= ucf_allocate_pmc;
+	pcd->pcd_config_pmc	= ucf_config_pmc;
+	pcd->pcd_describe	= ucf_describe;
+	pcd->pcd_get_config	= ucf_get_config;
+	pcd->pcd_get_msr	= NULL;
+	pcd->pcd_pcpu_fini	= uncore_pcpu_noop;
+	pcd->pcd_pcpu_init	= uncore_pcpu_noop;
+	pcd->pcd_read_pmc	= ucf_read_pmc;
+	pcd->pcd_release_pmc	= ucf_release_pmc;
+	pcd->pcd_start_pmc	= ucf_start_pmc;
+	pcd->pcd_stop_pmc	= ucf_stop_pmc;
+	pcd->pcd_write_pmc	= ucf_write_pmc;
+
+	md->pmd_npmc	       += npmc;
+}
+
+/*
+ * Intel programmable PMCs.
+ */
+
+/*
+ * Event descriptor tables.
+ *
+ * For each event id, we track:
+ *
+ * 1. The CPUs that the event is valid for.
+ *
+ * 2. If the event uses a fixed UMASK, the value of the umask field.
+ *    If the event doesn't use a fixed UMASK, a mask of legal bits
+ *    to check against.
+ */
+
+struct ucp_event_descr {
+	enum pmc_event	ucp_ev;
+	unsigned char	ucp_evcode;
+	unsigned char	ucp_umask;
+	unsigned char	ucp_flags;
+};
+
+#define	UCP_F_I7	(1 << 0)	/* CPU: Core i7 */
+#define	UCP_F_WM	(1 << 1)	/* CPU: Westmere */
+#define	UCP_F_FM	(1 << 2)	/* Fixed mask */
+
+#define	UCP_F_ALLCPUS					\
+    (UCP_F_I7 | UCP_F_WM)
+
+#define	UCP_F_CMASK		0xFF000000
+
+static struct ucp_event_descr ucp_events[] = {
+#undef UCPDESCR
+#define	UCPDESCR(N,EV,UM,FLAGS) {					\
+	.ucp_ev = PMC_EV_UCP_EVENT_##N,					\
+	.ucp_evcode = (EV),						\
+	.ucp_umask = (UM),						\
+	.ucp_flags = (FLAGS)						\
+	}
+
+    UCPDESCR(00H_01H, 0x00, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(00H_02H, 0x00, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(00H_04H, 0x00, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(01H_01H, 0x01, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(01H_02H, 0x01, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(01H_04H, 0x01, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(02H_01H, 0x02, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(03H_01H, 0x03, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(03H_02H, 0x03, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(03H_04H, 0x03, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(03H_08H, 0x03, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(03H_10H, 0x03, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(03H_20H, 0x03, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(03H_40H, 0x03, 0x40, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(04H_01H, 0x04, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(04H_02H, 0x04, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(04H_04H, 0x04, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(04H_08H, 0x04, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(04H_10H, 0x04, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(05H_01H, 0x05, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(05H_02H, 0x05, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(05H_04H, 0x05, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(06H_01H, 0x06, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(06H_02H, 0x06, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(06H_04H, 0x06, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(06H_08H, 0x06, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(06H_10H, 0x06, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(06H_20H, 0x06, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(07H_01H, 0x07, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(07H_02H, 0x07, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(07H_04H, 0x07, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(07H_08H, 0x07, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(07H_10H, 0x07, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(07H_20H, 0x07, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(07H_24H, 0x07, 0x24, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(08H_01H, 0x08, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(08H_02H, 0x08, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(08H_04H, 0x08, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(08H_03H, 0x08, 0x03, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(09H_01H, 0x09, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(09H_02H, 0x09, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(09H_04H, 0x09, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(09H_03H, 0x09, 0x03, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(0AH_01H, 0x0A, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0AH_02H, 0x0A, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0AH_04H, 0x0A, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0AH_08H, 0x0A, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0AH_0FH, 0x0A, 0x0F, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(0BH_01H, 0x0B, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0BH_02H, 0x0B, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0BH_04H, 0x0B, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0BH_08H, 0x0B, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0BH_10H, 0x0B, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(0BH_1FH, 0x0B, 0x1F, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(0CH_01H, 0x0C, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(0CH_02H, 0x0C, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(0CH_04H, 0x0C, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(0CH_08H, 0x0C, 0x08, UCP_F_FM | UCP_F_WM),
+
+    UCPDESCR(20H_01H, 0x20, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(20H_02H, 0x20, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(20H_04H, 0x20, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(20H_08H, 0x20, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(20H_10H, 0x20, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(20H_20H, 0x20, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(21H_01H, 0x21, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(21H_02H, 0x21, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(21H_04H, 0x21, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(22H_01H, 0x22, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(22H_02H, 0x22, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(22H_04H, 0x22, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(23H_01H, 0x23, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(23H_02H, 0x23, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(23H_04H, 0x23, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(24H_02H, 0x24, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(24H_04H, 0x24, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(25H_01H, 0x25, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(25H_02H, 0x25, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(25H_04H, 0x25, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(26H_01H, 0x26, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(27H_01H, 0x27, 0x01, UCP_F_FM | UCP_F_I7),
+    UCPDESCR(27H_02H, 0x27, 0x02, UCP_F_FM | UCP_F_I7),
+    UCPDESCR(27H_04H, 0x27, 0x04, UCP_F_FM | UCP_F_I7),
+    UCPDESCR(27H_08H, 0x27, 0x08, UCP_F_FM | UCP_F_I7),
+    UCPDESCR(27H_10H, 0x27, 0x10, UCP_F_FM | UCP_F_I7),
+    UCPDESCR(27H_20H, 0x27, 0x20, UCP_F_FM | UCP_F_I7),
+
+    UCPDESCR(28H_01H, 0x28, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(28H_02H, 0x28, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(28H_04H, 0x28, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(28H_08H, 0x28, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(28H_10H, 0x28, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(28H_20H, 0x28, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(29H_01H, 0x29, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(29H_02H, 0x29, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(29H_04H, 0x29, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(29H_08H, 0x29, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(29H_10H, 0x29, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(29H_20H, 0x29, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(2AH_01H, 0x2A, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2AH_02H, 0x2A, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2AH_04H, 0x2A, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2AH_07H, 0x2A, 0x07, UCP_F_FM | UCP_F_WM),
+
+    UCPDESCR(2BH_01H, 0x2B, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2BH_02H, 0x2B, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2BH_04H, 0x2B, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2BH_07H, 0x2B, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(2CH_01H, 0x2C, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2CH_02H, 0x2C, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2CH_04H, 0x2C, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2CH_07H, 0x2C, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(2DH_01H, 0x2D, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2DH_02H, 0x2D, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2DH_04H, 0x2D, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2DH_07H, 0x2D, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(2EH_01H, 0x2E, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2EH_02H, 0x2E, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2EH_04H, 0x2E, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2EH_07H, 0x2E, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(2FH_01H, 0x2F, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2FH_02H, 0x2F, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2FH_04H, 0x2F, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2FH_07H, 0x2F, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2FH_08H, 0x2F, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2FH_10H, 0x2F, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2FH_20H, 0x2F, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(2FH_38H, 0x2F, 0x38, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(30H_01H, 0x30, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(30H_02H, 0x30, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(30H_04H, 0x30, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(30H_07H, 0x30, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(31H_01H, 0x31, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(31H_02H, 0x31, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(31H_04H, 0x31, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(31H_07H, 0x31, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(32H_01H, 0x32, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(32H_02H, 0x32, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(32H_04H, 0x32, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(32H_07H, 0x32, 0x07, UCP_F_FM | UCP_F_WM),
+
+    UCPDESCR(33H_01H, 0x33, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(33H_02H, 0x33, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(33H_04H, 0x33, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(33H_07H, 0x33, 0x07, UCP_F_FM | UCP_F_WM),
+
+    UCPDESCR(34H_01H, 0x34, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(34H_02H, 0x34, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(34H_04H, 0x34, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(34H_08H, 0x34, 0x08, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(34H_10H, 0x34, 0x10, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(34H_20H, 0x34, 0x20, UCP_F_FM | UCP_F_WM),
+
+    UCPDESCR(35H_01H, 0x35, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(35H_02H, 0x35, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(35H_04H, 0x35, 0x04, UCP_F_FM | UCP_F_WM),
+
+    UCPDESCR(40H_01H, 0x40, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(40H_02H, 0x40, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(40H_04H, 0x40, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(40H_08H, 0x40, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(40H_10H, 0x40, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(40H_20H, 0x40, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(40H_07H, 0x40, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(40H_38H, 0x40, 0x38, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(41H_01H, 0x41, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(41H_02H, 0x41, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(41H_04H, 0x41, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(41H_08H, 0x41, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(41H_10H, 0x41, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(41H_20H, 0x41, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(41H_07H, 0x41, 0x07, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(41H_38H, 0x41, 0x38, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(42H_01H, 0x42, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(42H_02H, 0x42, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(42H_04H, 0x42, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(42H_08H, 0x42, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(43H_01H, 0x43, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(43H_02H, 0x43, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(60H_01H, 0x60, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(60H_02H, 0x60, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(60H_04H, 0x60, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(61H_01H, 0x61, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(61H_02H, 0x61, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(61H_04H, 0x61, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(62H_01H, 0x62, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(62H_02H, 0x62, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(62H_04H, 0x62, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(63H_01H, 0x63, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(63H_02H, 0x63, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(63H_04H, 0x63, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(63H_08H, 0x63, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(63H_10H, 0x63, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(63H_20H, 0x63, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(64H_01H, 0x64, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(64H_02H, 0x64, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(64H_04H, 0x64, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(64H_08H, 0x64, 0x08, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(64H_10H, 0x64, 0x10, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(64H_20H, 0x64, 0x20, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(65H_01H, 0x65, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(65H_02H, 0x65, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(65H_04H, 0x65, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(66H_01H, 0x66, 0x01, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(66H_02H, 0x66, 0x02, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+    UCPDESCR(66H_04H, 0x66, 0x04, UCP_F_FM | UCP_F_I7 | UCP_F_WM),
+
+    UCPDESCR(67H_01H, 0x67, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(80H_01H, 0x80, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(80H_02H, 0x80, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(80H_04H, 0x80, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(80H_08H, 0x80, 0x08, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(81H_01H, 0x81, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(81H_02H, 0x81, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(81H_04H, 0x81, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(81H_08H, 0x81, 0x08, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(82H_01H, 0x82, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(83H_01H, 0x83, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(83H_02H, 0x83, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(83H_04H, 0x83, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(83H_08H, 0x83, 0x08, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(84H_01H, 0x84, 0x01, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(84H_02H, 0x84, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(84H_04H, 0x84, 0x04, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(84H_08H, 0x84, 0x08, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(85H_02H, 0x85, 0x02, UCP_F_FM | UCP_F_WM),
+    UCPDESCR(86H_01H, 0x86, 0x01, UCP_F_FM | UCP_F_WM)
+};
+
+static const int nucp_events = sizeof(ucp_events) / sizeof(ucp_events[0]);
+
+static pmc_value_t
+ucp_perfctr_value_to_reload_count(pmc_value_t v)
+{
+	v &= (1ULL << uncore_ucp_width) - 1;
+	return (1ULL << uncore_ucp_width) - v;
+}
+
+static pmc_value_t
+ucp_reload_count_to_perfctr_value(pmc_value_t rlc)
+{
+	return (1ULL << uncore_ucp_width) - rlc;
+}
+
+static int
+ucp_allocate_pmc(int cpu, int ri, struct pmc *pm,
+    const struct pmc_op_pmcallocate *a)
+{
+	int n;
+	enum pmc_event ev;
+	struct ucp_event_descr *ie;
+	uint32_t caps, config, cpuflag, evsel;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucp_npmc,
+	    ("[uncore,%d] illegal row-index value %d", __LINE__, ri));
+
+	/* check requested capabilities */
+	caps = a->pm_caps;
+	if ((UCP_PMC_CAPS & caps) != caps)
+		return (EPERM);
+
+	ev = pm->pm_event;
+
+	/*
+	 * Look for an event descriptor with matching CPU and event id
+	 * fields.
+	 */
+
+	switch (uncore_cputype) {
+	case PMC_CPU_INTEL_COREI7:
+		cpuflag = UCP_F_I7;
+		break;
+	case PMC_CPU_INTEL_WESTMERE:
+		cpuflag = UCP_F_WM;
+		break;
+	default:
+		return (EINVAL);
+	}
+
+	for (n = 0, ie = ucp_events; n < nucp_events; n++, ie++)
+		if (ie->ucp_ev == ev && ie->ucp_flags & cpuflag)
+			break;
+
+	if (n == nucp_events)
+		return (EINVAL);
+
+	/*
+	 * A matching event descriptor has been found, so start
+	 * assembling the contents of the event select register.
+	 */
+	evsel = ie->ucp_evcode | UCP_EN;
+
+	config = a->pm_md.pm_ucp.pm_ucp_config & ~UCP_F_CMASK;
+
+	/*
+	 * If the event uses a fixed umask value, reject any umask
+	 * bits set by the user.
+	 */
+	if (ie->ucp_flags & UCP_F_FM) {
+
+		if (UCP_UMASK(config) != 0)
+			return (EINVAL);
+
+		evsel |= (ie->ucp_umask << 8);
+
+	} else
+		return (EINVAL);
+
+	if (caps & PMC_CAP_THRESHOLD)
+		evsel |= (a->pm_md.pm_ucp.pm_ucp_config & UCP_F_CMASK);
+	if (caps & PMC_CAP_EDGE)
+		evsel |= UCP_EDGE;
+	if (caps & PMC_CAP_INVERT)
+		evsel |= UCP_INV;
+
+	pm->pm_md.pm_ucp.pm_ucp_evsel = evsel;
+
+	return (0);
+}
+
+static int
+ucp_config_pmc(int cpu, int ri, struct pmc *pm)
+{
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU %d", __LINE__, cpu));
+
+	KASSERT(ri >= 0 && ri < uncore_ucp_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	PMCDBG(MDP,CFG,1, "ucp-config cpu=%d ri=%d pm=%p", cpu, ri, pm);
+
+	KASSERT(uncore_pcpu[cpu] != NULL, ("[uncore,%d] null per-cpu %d", __LINE__,
+	    cpu));
+
+	uncore_pcpu[cpu]->pc_uncorepmcs[ri].phw_pmc = pm;
+
+	return (0);
+}
+
+static int
+ucp_describe(int cpu, int ri, struct pmc_info *pi, struct pmc **ppmc)
+{
+	int error;
+	struct pmc_hw *phw;
+	char ucp_name[PMC_NAME_MAX];
+
+	phw = &uncore_pcpu[cpu]->pc_uncorepmcs[ri];
+
+	(void) snprintf(ucp_name, sizeof(ucp_name), "UCP-%d", ri);
+	if ((error = copystr(ucp_name, pi->pm_name, PMC_NAME_MAX,
+	    NULL)) != 0)
+		return (error);
+
+	pi->pm_class = PMC_CLASS_UCP;
+
+	if (phw->phw_state & PMC_PHW_FLAG_IS_ENABLED) {
+		pi->pm_enabled = TRUE;
+		*ppmc          = phw->phw_pmc;
+	} else {
+		pi->pm_enabled = FALSE;
+		*ppmc          = NULL;
+	}
+
+	return (0);
+}
+
+static int
+ucp_get_config(int cpu, int ri, struct pmc **ppm)
+{
+	*ppm = uncore_pcpu[cpu]->pc_uncorepmcs[ri].phw_pmc;
+
+	return (0);
+}
+
+static int
+ucp_read_pmc(int cpu, int ri, pmc_value_t *v)
+{
+	struct pmc *pm;
+	pmc_value_t tmp;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal cpu value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucp_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	pm = uncore_pcpu[cpu]->pc_uncorepmcs[ri].phw_pmc;
+
+	KASSERT(pm,
+	    ("[uncore,%d] cpu %d ri %d pmc not configured", __LINE__, cpu,
+		ri));
+
+	tmp = rdmsr(UCP_PMC0 + ri);
+	if (PMC_IS_SAMPLING_MODE(PMC_TO_MODE(pm)))
+		*v = ucp_perfctr_value_to_reload_count(tmp);
+	else
+		*v = tmp;
+
+	PMCDBG(MDP,REA,1, "ucp-read cpu=%d ri=%d msr=0x%x -> v=%jx", cpu, ri,
+	    ri, *v);
+
+	return (0);
+}
+
+static int
+ucp_release_pmc(int cpu, int ri, struct pmc *pm)
+{
+	(void) pm;
+
+	PMCDBG(MDP,REL,1, "ucp-release cpu=%d ri=%d pm=%p", cpu, ri,
+	    pm);
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucp_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	KASSERT(uncore_pcpu[cpu]->pc_uncorepmcs[ri].phw_pmc
+	    == NULL, ("[uncore,%d] PHW pmc non-NULL", __LINE__));
+
+	return (0);
+}
+
+static int
+ucp_start_pmc(int cpu, int ri)
+{
+	struct pmc *pm;
+	uint32_t evsel;
+	struct uncore_cpu *cc;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal CPU value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucp_npmc,
+	    ("[uncore,%d] illegal row-index %d", __LINE__, ri));
+
+	cc = uncore_pcpu[cpu];
+	pm = cc->pc_uncorepmcs[ri].phw_pmc;
+
+	KASSERT(pm,
+	    ("[uncore,%d] starting cpu%d,ri%d with no pmc configured",
+		__LINE__, cpu, ri));
+
+	PMCDBG(MDP,STA,1, "ucp-start cpu=%d ri=%d", cpu, ri);
+
+	evsel = pm->pm_md.pm_ucp.pm_ucp_evsel;
+
+	PMCDBG(MDP,STA,2, "ucp-start/2 cpu=%d ri=%d evselmsr=0x%x evsel=0x%x",
+	    cpu, ri, UCP_EVSEL0 + ri, evsel);
+
+	wrmsr(UCP_EVSEL0 + ri, evsel);
+
+	do {
+		cc->pc_resync = 0;
+		cc->pc_globalctrl |= (1ULL << ri);
+		wrmsr(UC_GLOBAL_CTRL, cc->pc_globalctrl);
+	} while (cc->pc_resync != 0);
+
+	return (0);
+}
+
+static int
+ucp_stop_pmc(int cpu, int ri)
+{
+	struct pmc *pm;
+	struct uncore_cpu *cc;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal cpu value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucp_npmc,
+	    ("[uncore,%d] illegal row index %d", __LINE__, ri));
+
+	cc = uncore_pcpu[cpu];
+	pm = cc->pc_uncorepmcs[ri].phw_pmc;
+
+	KASSERT(pm,
+	    ("[uncore,%d] cpu%d ri%d no configured PMC to stop", __LINE__,
+		cpu, ri));
+
+	PMCDBG(MDP,STO,1, "ucp-stop cpu=%d ri=%d", cpu, ri);
+
+	wrmsr(UCP_EVSEL0 + ri, 0);	/* stop hw */
+
+	do {
+		cc->pc_resync = 0;
+		cc->pc_globalctrl &= ~(1ULL << ri);
+		wrmsr(UC_GLOBAL_CTRL, cc->pc_globalctrl);
+	} while (cc->pc_resync != 0);
+
+	return (0);
+}
+
+static int
+ucp_write_pmc(int cpu, int ri, pmc_value_t v)
+{
+	struct pmc *pm;
+	struct uncore_cpu *cc;
+
+	KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
+	    ("[uncore,%d] illegal cpu value %d", __LINE__, cpu));
+	KASSERT(ri >= 0 && ri < uncore_ucp_npmc,
+	    ("[uncore,%d] illegal row index %d", __LINE__, ri));
+
+	cc = uncore_pcpu[cpu];
+	pm = cc->pc_uncorepmcs[ri].phw_pmc;
+
+	KASSERT(pm,
+	    ("[uncore,%d] cpu%d ri%d no configured PMC to stop", __LINE__,
+		cpu, ri));
+
+	PMCDBG(MDP,WRI,1, "ucp-write cpu=%d ri=%d msr=0x%x v=%jx", cpu, ri,
+	    UCP_PMC0 + ri, v);
+
+	if (PMC_IS_SAMPLING_MODE(PMC_TO_MODE(pm)))
+		v = ucp_reload_count_to_perfctr_value(v);
+
+	/*
+	 * Write the new value to the counter.  The counter will be in
+	 * a stopped state when the pcd_write() entry point is called.
+	 */
+
+	wrmsr(UCP_PMC0 + ri, v);
+
+	return (0);
+}
+
+
+static void
+ucp_initialize(struct pmc_mdep *md, int maxcpu, int npmc, int pmcwidth)
+{
+	struct pmc_classdep *pcd;
+
+	KASSERT(md != NULL, ("[ucp,%d] md is NULL", __LINE__));
+
+	PMCDBG(MDP,INI,1, "%s", "ucp-initialize");
+
+	pcd = &md->pmd_classdep[PMC_MDEP_CLASS_INDEX_UCP];
+
+	pcd->pcd_caps	= UCP_PMC_CAPS;
+	pcd->pcd_class	= PMC_CLASS_UCP;
+	pcd->pcd_num	= npmc;
+	pcd->pcd_ri	= md->pmd_npmc;
+	pcd->pcd_width	= pmcwidth;
+
+	pcd->pcd_allocate_pmc	= ucp_allocate_pmc;
+	pcd->pcd_config_pmc	= ucp_config_pmc;
+	pcd->pcd_describe	= ucp_describe;
+	pcd->pcd_get_config	= ucp_get_config;
+	pcd->pcd_get_msr	= NULL;
+	pcd->pcd_pcpu_fini	= uncore_pcpu_fini;
+	pcd->pcd_pcpu_init	= uncore_pcpu_init;
+	pcd->pcd_read_pmc	= ucp_read_pmc;
+	pcd->pcd_release_pmc	= ucp_release_pmc;
+	pcd->pcd_start_pmc	= ucp_start_pmc;
+	pcd->pcd_stop_pmc	= ucp_stop_pmc;
+	pcd->pcd_write_pmc	= ucp_write_pmc;
+
+	md->pmd_npmc	       += npmc;
+}
+
+int
+pmc_uncore_initialize(struct pmc_mdep *md, int maxcpu)
+{
+	uncore_cputype = md->pmd_cputype;
+	uncore_pmcmask = 0;
+
+	/*
+	 * Initialize programmable counters.
+	 */
+
+	uncore_ucp_npmc  = 8;
+	uncore_ucp_width = 48;
+
+	uncore_pmcmask |= ((1ULL << uncore_ucp_npmc) - 1);
+
+	ucp_initialize(md, maxcpu, uncore_ucp_npmc, uncore_ucp_width);
+
+	/*
+	 * Initialize fixed function counters, if present.
+	 */
+	uncore_ucf_ri = uncore_ucp_npmc;
+	uncore_ucf_npmc  = 1;
+	uncore_ucf_width = 48;
+
+	ucf_initialize(md, maxcpu, uncore_ucf_npmc, uncore_ucf_width);
+	uncore_pmcmask |= ((1ULL << uncore_ucf_npmc) - 1) << UCF_OFFSET;
+
+	PMCDBG(MDP,INI,1,"uncore-init pmcmask=0x%jx ucfri=%d", uncore_pmcmask,
+	    uncore_ucf_ri);
+
+	uncore_pcpu = malloc(sizeof(struct uncore_cpu **) * maxcpu, M_PMC,
+	    M_ZERO | M_WAITOK);
+
+	return (0);
+}
+
+void
+pmc_uncore_finalize(struct pmc_mdep *md)
+{
+	PMCDBG(MDP,INI,1, "%s", "uncore-finalize");
+
+	free(uncore_pcpu, M_PMC);
+	uncore_pcpu = NULL;
+}
diff --git a/sys/dev/hwpmc/hwpmc_uncore.h b/sys/dev/hwpmc/hwpmc_uncore.h
new file mode 100644
index 000000000000..2be34db3d345
--- /dev/null
+++ b/sys/dev/hwpmc/hwpmc_uncore.h
@@ -0,0 +1,120 @@
+/*-
+ * Copyright (c) 2010 Fabien Thomas
+ * 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 _DEV_HWPMC_UNCORE_H_
+#define	_DEV_HWPMC_UNCORE_H_ 1
+
+/*
+ * Fixed-function PMCs.
+ */
+struct pmc_md_ucf_op_pmcallocate {
+	uint16_t	pm_ucf_flags;	/* additional flags */
+};
+
+#define	UCF_EN		0x1
+#define	UCF_PMI		0x4
+
+/*
+ * Programmable PMCs.
+ */
+struct pmc_md_ucp_op_pmcallocate {
+	uint32_t	pm_ucp_config;
+};
+
+#define	UCP_EVSEL(C)	((C) & 0xFF)
+#define	UCP_UMASK(C)	((C) & 0xFF00)
+#define	UCP_CTRR	(1 << 17)
+#define	UCP_EDGE	(1 << 18)
+#define	UCP_INT		(1 << 20)
+#define	UCP_EN		(1 << 22)
+#define	UCP_INV		(1 << 23)
+#define	UCP_CMASK(C)	(((C) & 0xFF) << 24)
+
+#ifdef	_KERNEL
+
+#define	DCTL_FLAG_UNC_PMI	(1ULL << 13)
+
+/*
+ * Fixed-function counters.
+ */
+
+#define	UCF_MASK				0xF
+
+#define	UCF_CTR0				0x394
+
+#define	UCF_OFFSET				32
+#define	UCF_CTRL				0x395
+
+/*
+ * Programmable counters.
+ */
+
+#define	UCP_PMC0				0x3B0
+#define	UCP_EVSEL0				0x3C0
+#define UCP_OPCODE_MATCH			0x396
+
+/*
+ * Simplified programming interface in Intel Performance Architecture
+ * v2 and later.
+ */
+
+#define	UC_GLOBAL_STATUS			0x392
+#define	UC_GLOBAL_CTRL				0x391
+#define	UC_GLOBAL_OVF_CTRL			0x393
+
+#define	UC_GLOBAL_STATUS_FLAG_CLRCHG		(1ULL << 63)
+#define	UC_GLOBAL_STATUS_FLAG_OVFPMI		(1ULL << 61)
+#define	UC_GLOBAL_CTRL_FLAG_FRZ			(1ULL << 63)
+#define	UC_GLOBAL_CTRL_FLAG_ENPMICORE0		(1ULL << 48)
+
+struct pmc_md_ucf_pmc {
+	uint64_t	pm_ucf_ctrl;
+};
+
+struct pmc_md_ucp_pmc {
+	uint32_t	pm_ucp_evsel;
+};
+
+/*
+ * Prototypes.
+ */
+
+int	pmc_uncore_initialize(struct pmc_mdep *_md, int _maxcpu);
+void	pmc_uncore_finalize(struct pmc_mdep *_md);
+
+void	pmc_uncore_mark_started(int _cpu, int _pmc);
+
+int	pmc_ucf_initialize(struct pmc_mdep *_md, int _maxcpu, int _npmc, int _width);
+void	pmc_ucf_finalize(struct pmc_mdep *_md);
+
+int	pmc_ucp_initialize(struct pmc_mdep *_md, int _maxcpu, int _npmc, int _width,
+	    int _flags);
+void	pmc_ucp_finalize(struct pmc_mdep *_md);
+
+#endif	/* _KERNEL */
+#endif	/* _DEV_HWPMC_UNCORE_H */
diff --git a/sys/dev/hwpmc/pmc_events.h b/sys/dev/hwpmc/pmc_events.h
index 628a693417bc..e38772cd95dc 100644
--- a/sys/dev/hwpmc/pmc_events.h
+++ b/sys/dev/hwpmc/pmc_events.h
@@ -468,8 +468,10 @@ __PMC_EV_ALIAS("unhalted-reference-cycles", IAF_CPU_CLK_UNHALTED_REF)
  * the CPU model happens inside hwpmc(4).
  */
 #define	__PMC_EV_IAP()				\
+__PMC_EV(IAP, EVENT_02H_01H)			\
 __PMC_EV(IAP, EVENT_02H_81H)			\
 __PMC_EV(IAP, EVENT_03H_00H)			\
+__PMC_EV(IAP, EVENT_03H_01H)			\
 __PMC_EV(IAP, EVENT_03H_02H)			\
 __PMC_EV(IAP, EVENT_03H_04H)			\
 __PMC_EV(IAP, EVENT_03H_08H)			\
@@ -478,9 +480,18 @@ __PMC_EV(IAP, EVENT_03H_20H)			\
 __PMC_EV(IAP, EVENT_04H_00H)			\
 __PMC_EV(IAP, EVENT_04H_01H)			\
 __PMC_EV(IAP, EVENT_04H_02H)			\
+__PMC_EV(IAP, EVENT_04H_07H)			\
 __PMC_EV(IAP, EVENT_04H_08H)			\
 __PMC_EV(IAP, EVENT_05H_00H)			\
+__PMC_EV(IAP, EVENT_05H_01H)			\
+__PMC_EV(IAP, EVENT_05H_02H)			\
+__PMC_EV(IAP, EVENT_05H_03H)			\
 __PMC_EV(IAP, EVENT_06H_00H)			\
+__PMC_EV(IAP, EVENT_06H_01H)			\
+__PMC_EV(IAP, EVENT_06H_02H)			\
+__PMC_EV(IAP, EVENT_06H_04H)			\
+__PMC_EV(IAP, EVENT_06H_08H)			\
+__PMC_EV(IAP, EVENT_06H_0FH)			\
 __PMC_EV(IAP, EVENT_07H_00H)			\
 __PMC_EV(IAP, EVENT_07H_01H)			\
 __PMC_EV(IAP, EVENT_07H_02H)			\
@@ -495,41 +506,126 @@ __PMC_EV(IAP, EVENT_08H_06H)			\
 __PMC_EV(IAP, EVENT_08H_07H)			\
 __PMC_EV(IAP, EVENT_08H_08H)			\
 __PMC_EV(IAP, EVENT_08H_09H)			\
+__PMC_EV(IAP, EVENT_08H_10H)			\
+__PMC_EV(IAP, EVENT_08H_20H)			\
+__PMC_EV(IAP, EVENT_08H_40H)			\
+__PMC_EV(IAP, EVENT_08H_80H)			\
 __PMC_EV(IAP, EVENT_09H_01H)			\
 __PMC_EV(IAP, EVENT_09H_02H)			\
+__PMC_EV(IAP, EVENT_09H_04H)			\
+__PMC_EV(IAP, EVENT_09H_08H)			\
+__PMC_EV(IAP, EVENT_0BH_01H)			\
+__PMC_EV(IAP, EVENT_0BH_02H)			\
+__PMC_EV(IAP, EVENT_0BH_10H)			\
 __PMC_EV(IAP, EVENT_0CH_01H)			\
 __PMC_EV(IAP, EVENT_0CH_02H)			\
 __PMC_EV(IAP, EVENT_0CH_03H)			\
+__PMC_EV(IAP, EVENT_0EH_01H)			\
+__PMC_EV(IAP, EVENT_0EH_02H)			\
+__PMC_EV(IAP, EVENT_0FH_01H)			\
+__PMC_EV(IAP, EVENT_0FH_02H)			\
+__PMC_EV(IAP, EVENT_0FH_08H)			\
+__PMC_EV(IAP, EVENT_0FH_10H)			\
+__PMC_EV(IAP, EVENT_0FH_20H)			\
+__PMC_EV(IAP, EVENT_0FH_80H)			\
 __PMC_EV(IAP, EVENT_10H_00H)			\
 __PMC_EV(IAP, EVENT_10H_01H)			\
+__PMC_EV(IAP, EVENT_10H_02H)			\
+__PMC_EV(IAP, EVENT_10H_04H)			\
+__PMC_EV(IAP, EVENT_10H_08H)			\
+__PMC_EV(IAP, EVENT_10H_10H)			\
+__PMC_EV(IAP, EVENT_10H_20H)			\
+__PMC_EV(IAP, EVENT_10H_40H)			\
+__PMC_EV(IAP, EVENT_10H_80H)			\
 __PMC_EV(IAP, EVENT_10H_81H)			\
 __PMC_EV(IAP, EVENT_11H_00H)			\
 __PMC_EV(IAP, EVENT_11H_01H)			\
 __PMC_EV(IAP, EVENT_11H_81H)			\
 __PMC_EV(IAP, EVENT_12H_00H)			\
 __PMC_EV(IAP, EVENT_12H_01H)			\
+__PMC_EV(IAP, EVENT_12H_02H)			\
+__PMC_EV(IAP, EVENT_12H_04H)			\
+__PMC_EV(IAP, EVENT_12H_08H)			\
+__PMC_EV(IAP, EVENT_12H_10H)			\
+__PMC_EV(IAP, EVENT_12H_20H)			\
+__PMC_EV(IAP, EVENT_12H_40H)			\
 __PMC_EV(IAP, EVENT_12H_81H)			\
 __PMC_EV(IAP, EVENT_13H_00H)			\
 __PMC_EV(IAP, EVENT_13H_01H)			\
+__PMC_EV(IAP, EVENT_13H_02H)			\
+__PMC_EV(IAP, EVENT_13H_04H)			\
+__PMC_EV(IAP, EVENT_13H_07H)			\
 __PMC_EV(IAP, EVENT_13H_81H)			\
 __PMC_EV(IAP, EVENT_14H_00H)			\
 __PMC_EV(IAP, EVENT_14H_01H)			\
+__PMC_EV(IAP, EVENT_14H_02H)			\
+__PMC_EV(IAP, EVENT_17H_01H)			\
 __PMC_EV(IAP, EVENT_18H_00H)			\
+__PMC_EV(IAP, EVENT_18H_01H)			\
 __PMC_EV(IAP, EVENT_19H_00H)			\
 __PMC_EV(IAP, EVENT_19H_01H)			\
 __PMC_EV(IAP, EVENT_19H_02H)			\
+__PMC_EV(IAP, EVENT_1DH_01H)			\
+__PMC_EV(IAP, EVENT_1DH_02H)			\
+__PMC_EV(IAP, EVENT_1DH_04H)			\
+__PMC_EV(IAP, EVENT_1EH_01H)			\
+__PMC_EV(IAP, EVENT_20H_01H)			\
 __PMC_EV(IAP, EVENT_21H)			\
 __PMC_EV(IAP, EVENT_22H)			\
 __PMC_EV(IAP, EVENT_23H)			\
 __PMC_EV(IAP, EVENT_24H)			\
+__PMC_EV(IAP, EVENT_24H_01H)			\
+__PMC_EV(IAP, EVENT_24H_02H)			\
+__PMC_EV(IAP, EVENT_24H_03H)			\
+__PMC_EV(IAP, EVENT_24H_04H)			\
+__PMC_EV(IAP, EVENT_24H_08H)			\
+__PMC_EV(IAP, EVENT_24H_0CH)			\
+__PMC_EV(IAP, EVENT_24H_10H)			\
+__PMC_EV(IAP, EVENT_24H_20H)			\
+__PMC_EV(IAP, EVENT_24H_30H)			\
+__PMC_EV(IAP, EVENT_24H_40H)			\
+__PMC_EV(IAP, EVENT_24H_80H)			\
+__PMC_EV(IAP, EVENT_24H_AAH)			\
+__PMC_EV(IAP, EVENT_24H_C0H)			\
+__PMC_EV(IAP, EVENT_24H_FFH)			\
 __PMC_EV(IAP, EVENT_25H)			\
 __PMC_EV(IAP, EVENT_26H)			\
+__PMC_EV(IAP, EVENT_26H_01H)			\
+__PMC_EV(IAP, EVENT_26H_02H)			\
+__PMC_EV(IAP, EVENT_26H_04H)			\
+__PMC_EV(IAP, EVENT_26H_08H)			\
+__PMC_EV(IAP, EVENT_26H_0FH)			\
+__PMC_EV(IAP, EVENT_26H_10H)			\
+__PMC_EV(IAP, EVENT_26H_20H)			\
+__PMC_EV(IAP, EVENT_26H_40H)			\
+__PMC_EV(IAP, EVENT_26H_80H)			\
+__PMC_EV(IAP, EVENT_26H_F0H)			\
+__PMC_EV(IAP, EVENT_26H_FFH)			\
 __PMC_EV(IAP, EVENT_27H)			\
+__PMC_EV(IAP, EVENT_27H_01H)			\
+__PMC_EV(IAP, EVENT_27H_02H)			\
+__PMC_EV(IAP, EVENT_27H_04H)			\
+__PMC_EV(IAP, EVENT_27H_08H)			\
+__PMC_EV(IAP, EVENT_27H_0EH)			\
+__PMC_EV(IAP, EVENT_27H_0FH)			\
+__PMC_EV(IAP, EVENT_27H_10H)			\
+__PMC_EV(IAP, EVENT_27H_20H)			\
+__PMC_EV(IAP, EVENT_27H_40H)			\
+__PMC_EV(IAP, EVENT_27H_80H)			\
+__PMC_EV(IAP, EVENT_27H_E0H)			\
+__PMC_EV(IAP, EVENT_27H_F0H)			\
 __PMC_EV(IAP, EVENT_28H)			\
+__PMC_EV(IAP, EVENT_28H_01H)			\
+__PMC_EV(IAP, EVENT_28H_02H)			\
+__PMC_EV(IAP, EVENT_28H_04H)			\
+__PMC_EV(IAP, EVENT_28H_08H)			\
+__PMC_EV(IAP, EVENT_28H_0FH)			\
 __PMC_EV(IAP, EVENT_29H)			\
 __PMC_EV(IAP, EVENT_2AH)			\
 __PMC_EV(IAP, EVENT_2BH)			\
 __PMC_EV(IAP, EVENT_2EH)			\
+__PMC_EV(IAP, EVENT_2EH_01H)			\
+__PMC_EV(IAP, EVENT_2EH_02H)			\
 __PMC_EV(IAP, EVENT_2EH_41H)			\
 __PMC_EV(IAP, EVENT_2EH_4FH)			\
 __PMC_EV(IAP, EVENT_30H)			\
@@ -540,11 +636,26 @@ __PMC_EV(IAP, EVENT_3BH_C0H)			\
 __PMC_EV(IAP, EVENT_3CH_00H)			\
 __PMC_EV(IAP, EVENT_3CH_01H)			\
 __PMC_EV(IAP, EVENT_3CH_02H)			\
+__PMC_EV(IAP, EVENT_3DH_01H)			\
 __PMC_EV(IAP, EVENT_40H)			\
+__PMC_EV(IAP, EVENT_40H_01H)			\
+__PMC_EV(IAP, EVENT_40H_02H)			\
+__PMC_EV(IAP, EVENT_40H_04H)			\
+__PMC_EV(IAP, EVENT_40H_08H)			\
+__PMC_EV(IAP, EVENT_40H_0FH)			\
 __PMC_EV(IAP, EVENT_40H_21H)			\
 __PMC_EV(IAP, EVENT_41H)			\
+__PMC_EV(IAP, EVENT_41H_01H)			\
+__PMC_EV(IAP, EVENT_41H_02H)			\
+__PMC_EV(IAP, EVENT_41H_04H)			\
+__PMC_EV(IAP, EVENT_41H_08H)			\
+__PMC_EV(IAP, EVENT_41H_0FH)			\
 __PMC_EV(IAP, EVENT_41H_22H)			\
 __PMC_EV(IAP, EVENT_42H)			\
+__PMC_EV(IAP, EVENT_42H_01H)			\
+__PMC_EV(IAP, EVENT_42H_02H)			\
+__PMC_EV(IAP, EVENT_42H_04H)			\
+__PMC_EV(IAP, EVENT_42H_08H)			\
 __PMC_EV(IAP, EVENT_42H_10H)			\
 __PMC_EV(IAP, EVENT_43H_01H)			\
 __PMC_EV(IAP, EVENT_43H_02H)			\
@@ -553,22 +664,50 @@ __PMC_EV(IAP, EVENT_45H_0FH)			\
 __PMC_EV(IAP, EVENT_46H_00H)			\
 __PMC_EV(IAP, EVENT_47H_00H)			\
 __PMC_EV(IAP, EVENT_48H_00H)			\
+__PMC_EV(IAP, EVENT_48H_02H)			\
 __PMC_EV(IAP, EVENT_49H_00H)			\
 __PMC_EV(IAP, EVENT_49H_01H)			\
 __PMC_EV(IAP, EVENT_49H_02H)			\
+__PMC_EV(IAP, EVENT_49H_04H)			\
+__PMC_EV(IAP, EVENT_49H_10H)			\
+__PMC_EV(IAP, EVENT_49H_20H)			\
+__PMC_EV(IAP, EVENT_49H_40H)			\
+__PMC_EV(IAP, EVENT_49H_80H)			\
 __PMC_EV(IAP, EVENT_4BH_00H)			\
 __PMC_EV(IAP, EVENT_4BH_01H)			\
 __PMC_EV(IAP, EVENT_4BH_02H)			\
 __PMC_EV(IAP, EVENT_4BH_03H)			\
+__PMC_EV(IAP, EVENT_4BH_08H)			\
 __PMC_EV(IAP, EVENT_4CH_00H)			\
+__PMC_EV(IAP, EVENT_4CH_01H)			\
+__PMC_EV(IAP, EVENT_4DH_01H)			\
+__PMC_EV(IAP, EVENT_4EH_01H)			\
+__PMC_EV(IAP, EVENT_4EH_02H)			\
+__PMC_EV(IAP, EVENT_4EH_04H)			\
 __PMC_EV(IAP, EVENT_4EH_10H)			\
 __PMC_EV(IAP, EVENT_4FH_00H)			\
+__PMC_EV(IAP, EVENT_4FH_02H)			\
+__PMC_EV(IAP, EVENT_4FH_04H)			\
+__PMC_EV(IAP, EVENT_4FH_08H)			\
+__PMC_EV(IAP, EVENT_4FH_10H)			\
+__PMC_EV(IAP, EVENT_51H_01H)			\
+__PMC_EV(IAP, EVENT_51H_02H)			\
+__PMC_EV(IAP, EVENT_51H_04H)			\
+__PMC_EV(IAP, EVENT_51H_08H)			\
+__PMC_EV(IAP, EVENT_52H_01H)			\
+__PMC_EV(IAP, EVENT_53H_01H)			\
 __PMC_EV(IAP, EVENT_60H)			\
+__PMC_EV(IAP, EVENT_60H_01H)			\
+__PMC_EV(IAP, EVENT_60H_02H)			\
+__PMC_EV(IAP, EVENT_60H_04H)			\
+__PMC_EV(IAP, EVENT_60H_08H)			\
 __PMC_EV(IAP, EVENT_61H)			\
 __PMC_EV(IAP, EVENT_61H_00H)			\
 __PMC_EV(IAP, EVENT_62H)			\
 __PMC_EV(IAP, EVENT_62H_00H)			\
 __PMC_EV(IAP, EVENT_63H)			\
+__PMC_EV(IAP, EVENT_63H_01H)			\
+__PMC_EV(IAP, EVENT_63H_02H)			\
 __PMC_EV(IAP, EVENT_64H)			\
 __PMC_EV(IAP, EVENT_64H_40H)			\
 __PMC_EV(IAP, EVENT_65H)			\
@@ -579,6 +718,7 @@ __PMC_EV(IAP, EVENT_69H)			\
 __PMC_EV(IAP, EVENT_6AH)			\
 __PMC_EV(IAP, EVENT_6BH)			\
 __PMC_EV(IAP, EVENT_6CH)			\
+__PMC_EV(IAP, EVENT_6CH_01H)			\
 __PMC_EV(IAP, EVENT_6DH)			\
 __PMC_EV(IAP, EVENT_6EH)			\
 __PMC_EV(IAP, EVENT_6FH)			\
@@ -592,20 +732,59 @@ __PMC_EV(IAP, EVENT_7EH)			\
 __PMC_EV(IAP, EVENT_7EH_00H)			\
 __PMC_EV(IAP, EVENT_7FH)			\
 __PMC_EV(IAP, EVENT_80H_00H)			\
+__PMC_EV(IAP, EVENT_80H_01H)			\
 __PMC_EV(IAP, EVENT_80H_02H)			\
 __PMC_EV(IAP, EVENT_80H_03H)			\
+__PMC_EV(IAP, EVENT_80H_04H)			\
+__PMC_EV(IAP, EVENT_80H_10H)			\
 __PMC_EV(IAP, EVENT_81H_00H)			\
+__PMC_EV(IAP, EVENT_81H_01H)			\
+__PMC_EV(IAP, EVENT_81H_02H)			\
+__PMC_EV(IAP, EVENT_82H_01H)			\
 __PMC_EV(IAP, EVENT_82H_02H)			\
 __PMC_EV(IAP, EVENT_82H_04H)			\
 __PMC_EV(IAP, EVENT_82H_10H)			\
 __PMC_EV(IAP, EVENT_82H_12H)			\
 __PMC_EV(IAP, EVENT_82H_40H)			\
+__PMC_EV(IAP, EVENT_83H_01H)			\
 __PMC_EV(IAP, EVENT_83H_02H)			\
 __PMC_EV(IAP, EVENT_85H_00H)			\
+__PMC_EV(IAP, EVENT_85H_01H)			\
+__PMC_EV(IAP, EVENT_85H_02H)			\
+__PMC_EV(IAP, EVENT_85H_04H)			\
+__PMC_EV(IAP, EVENT_85H_10H)			\
+__PMC_EV(IAP, EVENT_85H_20H)			\
+__PMC_EV(IAP, EVENT_85H_40H)			\
+__PMC_EV(IAP, EVENT_85H_80H)			\
 __PMC_EV(IAP, EVENT_86H_00H)			\
 __PMC_EV(IAP, EVENT_87H_00H)			\
+__PMC_EV(IAP, EVENT_87H_01H)			\
+__PMC_EV(IAP, EVENT_87H_02H)			\
+__PMC_EV(IAP, EVENT_87H_04H)			\
+__PMC_EV(IAP, EVENT_87H_08H)			\
+__PMC_EV(IAP, EVENT_87H_0FH)			\
 __PMC_EV(IAP, EVENT_88H_00H)			\
+__PMC_EV(IAP, EVENT_88H_01H)			\
+__PMC_EV(IAP, EVENT_88H_02H)			\
+__PMC_EV(IAP, EVENT_88H_04H)			\
+__PMC_EV(IAP, EVENT_88H_07H)			\
+__PMC_EV(IAP, EVENT_88H_08H)			\
+__PMC_EV(IAP, EVENT_88H_10H)			\
+__PMC_EV(IAP, EVENT_88H_20H)			\
+__PMC_EV(IAP, EVENT_88H_30H)			\
+__PMC_EV(IAP, EVENT_88H_40H)			\
+__PMC_EV(IAP, EVENT_88H_7FH)			\
 __PMC_EV(IAP, EVENT_89H_00H)			\
+__PMC_EV(IAP, EVENT_89H_01H)			\
+__PMC_EV(IAP, EVENT_89H_02H)			\
+__PMC_EV(IAP, EVENT_89H_04H)			\
+__PMC_EV(IAP, EVENT_89H_07H)			\
+__PMC_EV(IAP, EVENT_89H_08H)			\
+__PMC_EV(IAP, EVENT_89H_10H)			\
+__PMC_EV(IAP, EVENT_89H_20H)			\
+__PMC_EV(IAP, EVENT_89H_30H)			\
+__PMC_EV(IAP, EVENT_89H_40H)			\
+__PMC_EV(IAP, EVENT_89H_7FH)			\
 __PMC_EV(IAP, EVENT_8AH_00H)			\
 __PMC_EV(IAP, EVENT_8BH_00H)			\
 __PMC_EV(IAP, EVENT_8CH_00H)			\
@@ -627,16 +806,45 @@ __PMC_EV(IAP, EVENT_A1H_08H)			\
 __PMC_EV(IAP, EVENT_A1H_10H)			\
 __PMC_EV(IAP, EVENT_A1H_20H)			\
 __PMC_EV(IAP, EVENT_A2H_00H)			\
+__PMC_EV(IAP, EVENT_A2H_01H)			\
+__PMC_EV(IAP, EVENT_A2H_02H)			\
+__PMC_EV(IAP, EVENT_A2H_04H)			\
+__PMC_EV(IAP, EVENT_A2H_08H)			\
+__PMC_EV(IAP, EVENT_A2H_10H)			\
+__PMC_EV(IAP, EVENT_A2H_20H)			\
+__PMC_EV(IAP, EVENT_A2H_40H)			\
+__PMC_EV(IAP, EVENT_A2H_80H)			\
+__PMC_EV(IAP, EVENT_A6H_01H)			\
+__PMC_EV(IAP, EVENT_A7H_01H)			\
+__PMC_EV(IAP, EVENT_A8H_01H)			\
 __PMC_EV(IAP, EVENT_AAH_01H)			\
 __PMC_EV(IAP, EVENT_AAH_02H)			\
 __PMC_EV(IAP, EVENT_AAH_03H)			\
 __PMC_EV(IAP, EVENT_AAH_08H)			\
 __PMC_EV(IAP, EVENT_ABH_01H)			\
 __PMC_EV(IAP, EVENT_ABH_02H)			\
+__PMC_EV(IAP, EVENT_AEH_01H)			\
 __PMC_EV(IAP, EVENT_B0H_00H)			\
+__PMC_EV(IAP, EVENT_B0H_01H)			\
+__PMC_EV(IAP, EVENT_B0H_02H)			\
+__PMC_EV(IAP, EVENT_B0H_04H)			\
+__PMC_EV(IAP, EVENT_B0H_08H)			\
+__PMC_EV(IAP, EVENT_B0H_10H)			\
+__PMC_EV(IAP, EVENT_B0H_20H)			\
+__PMC_EV(IAP, EVENT_B0H_40H)			\
 __PMC_EV(IAP, EVENT_B0H_80H)			\
 __PMC_EV(IAP, EVENT_B1H_00H)			\
+__PMC_EV(IAP, EVENT_B1H_01H)			\
+__PMC_EV(IAP, EVENT_B1H_02H)			\
+__PMC_EV(IAP, EVENT_B1H_04H)			\
+__PMC_EV(IAP, EVENT_B1H_08H)			\
+__PMC_EV(IAP, EVENT_B1H_10H)			\
+__PMC_EV(IAP, EVENT_B1H_1FH)			\
+__PMC_EV(IAP, EVENT_B1H_20H)			\
+__PMC_EV(IAP, EVENT_B1H_3FH)			\
+__PMC_EV(IAP, EVENT_B1H_40H)			\
 __PMC_EV(IAP, EVENT_B1H_80H)			\
+__PMC_EV(IAP, EVENT_B2H_01H)			\
 __PMC_EV(IAP, EVENT_B3H_01H)			\
 __PMC_EV(IAP, EVENT_B3H_02H)			\
 __PMC_EV(IAP, EVENT_B3H_04H)			\
@@ -649,6 +857,16 @@ __PMC_EV(IAP, EVENT_B3H_84H)			\
 __PMC_EV(IAP, EVENT_B3H_88H)			\
 __PMC_EV(IAP, EVENT_B3H_90H)			\
 __PMC_EV(IAP, EVENT_B3H_A0H)			\
+__PMC_EV(IAP, EVENT_B4H_01H)			\
+__PMC_EV(IAP, EVENT_B4H_02H)			\
+__PMC_EV(IAP, EVENT_B4H_04H)			\
+__PMC_EV(IAP, EVENT_B7H_01H)			\
+__PMC_EV(IAP, EVENT_B8H_01H)			\
+__PMC_EV(IAP, EVENT_B8H_02H)			\
+__PMC_EV(IAP, EVENT_B8H_04H)			\
+__PMC_EV(IAP, EVENT_BAH_01H)			\
+__PMC_EV(IAP, EVENT_BAH_02H)			\
+__PMC_EV(IAP, EVENT_BBH_01H)			\
 __PMC_EV(IAP, EVENT_C0H_00H)			\
 __PMC_EV(IAP, EVENT_C0H_01H)			\
 __PMC_EV(IAP, EVENT_C0H_02H)			\
@@ -662,12 +880,14 @@ __PMC_EV(IAP, EVENT_C2H_01H)			\
 __PMC_EV(IAP, EVENT_C2H_02H)			\
 __PMC_EV(IAP, EVENT_C2H_04H)			\
 __PMC_EV(IAP, EVENT_C2H_07H)			\
+__PMC_EV(IAP, EVENT_C2H_08H)			\
 __PMC_EV(IAP, EVENT_C2H_0FH)			\
 __PMC_EV(IAP, EVENT_C2H_10H)			\
-__PMC_EV(IAP, EVENT_C2H_08H)			\
 __PMC_EV(IAP, EVENT_C3H_00H)			\
 __PMC_EV(IAP, EVENT_C3H_01H)			\
+__PMC_EV(IAP, EVENT_C3H_02H)			\
 __PMC_EV(IAP, EVENT_C3H_04H)			\
+__PMC_EV(IAP, EVENT_C3H_10H)			\
 __PMC_EV(IAP, EVENT_C4H_00H)			\
 __PMC_EV(IAP, EVENT_C4H_01H)			\
 __PMC_EV(IAP, EVENT_C4H_02H)			\
@@ -676,6 +896,9 @@ __PMC_EV(IAP, EVENT_C4H_08H)			\
 __PMC_EV(IAP, EVENT_C4H_0CH)			\
 __PMC_EV(IAP, EVENT_C4H_0FH)			\
 __PMC_EV(IAP, EVENT_C5H_00H)			\
+__PMC_EV(IAP, EVENT_C5H_01H)			\
+__PMC_EV(IAP, EVENT_C5H_02H)			\
+__PMC_EV(IAP, EVENT_C5H_04H)			\
 __PMC_EV(IAP, EVENT_C6H_00H)			\
 __PMC_EV(IAP, EVENT_C6H_01H)			\
 __PMC_EV(IAP, EVENT_C6H_02H)			\
@@ -687,6 +910,7 @@ __PMC_EV(IAP, EVENT_C7H_08H)			\
 __PMC_EV(IAP, EVENT_C7H_10H)			\
 __PMC_EV(IAP, EVENT_C7H_1FH)			\
 __PMC_EV(IAP, EVENT_C8H_00H)			\
+__PMC_EV(IAP, EVENT_C8H_20H)			\
 __PMC_EV(IAP, EVENT_C9H_00H)			\
 __PMC_EV(IAP, EVENT_CAH_00H)			\
 __PMC_EV(IAP, EVENT_CAH_01H)			\
@@ -698,13 +922,21 @@ __PMC_EV(IAP, EVENT_CBH_02H)			\
 __PMC_EV(IAP, EVENT_CBH_04H)			\
 __PMC_EV(IAP, EVENT_CBH_08H)			\
 __PMC_EV(IAP, EVENT_CBH_10H)			\
+__PMC_EV(IAP, EVENT_CBH_40H)			\
+__PMC_EV(IAP, EVENT_CBH_80H)			\
 __PMC_EV(IAP, EVENT_CCH_00H)			\
 __PMC_EV(IAP, EVENT_CCH_01H)			\
 __PMC_EV(IAP, EVENT_CCH_02H)			\
+__PMC_EV(IAP, EVENT_CCH_03H)			\
 __PMC_EV(IAP, EVENT_CDH_00H)			\
 __PMC_EV(IAP, EVENT_CEH_00H)			\
 __PMC_EV(IAP, EVENT_CFH_00H)			\
 __PMC_EV(IAP, EVENT_D0H_00H)			\
+__PMC_EV(IAP, EVENT_D0H_01H)			\
+__PMC_EV(IAP, EVENT_D1H_01H)			\
+__PMC_EV(IAP, EVENT_D1H_02H)			\
+__PMC_EV(IAP, EVENT_D1H_04H)			\
+__PMC_EV(IAP, EVENT_D1H_08H)			\
 __PMC_EV(IAP, EVENT_D2H_01H)			\
 __PMC_EV(IAP, EVENT_D2H_02H)			\
 __PMC_EV(IAP, EVENT_D2H_04H)			\
@@ -735,6 +967,7 @@ __PMC_EV(IAP, EVENT_DAH_00H)			\
 __PMC_EV(IAP, EVENT_DAH_01H)			\
 __PMC_EV(IAP, EVENT_DAH_02H)			\
 __PMC_EV(IAP, EVENT_DBH_00H)			\
+__PMC_EV(IAP, EVENT_DBH_01H)			\
 __PMC_EV(IAP, EVENT_DCH_01H)			\
 __PMC_EV(IAP, EVENT_DCH_02H)			\
 __PMC_EV(IAP, EVENT_DCH_04H)			\
@@ -745,249 +978,16 @@ __PMC_EV(IAP, EVENT_E0H_00H)			\
 __PMC_EV(IAP, EVENT_E0H_01H)			\
 __PMC_EV(IAP, EVENT_E2H_00H)			\
 __PMC_EV(IAP, EVENT_E4H_00H)			\
-__PMC_EV(IAP, EVENT_E6H_00H)			\
-__PMC_EV(IAP, EVENT_E6H_01H)			\
-__PMC_EV(IAP, EVENT_F0H_00H)			\
-__PMC_EV(IAP, EVENT_F8H_00H)			\
-__PMC_EV(IAP, EVENT_02H_01H)			\
-__PMC_EV(IAP, EVENT_03H_01H)			\
-__PMC_EV(IAP, EVENT_05H_01H)			\
-__PMC_EV(IAP, EVENT_05H_02H)			\
-__PMC_EV(IAP, EVENT_05H_03H)			\
-__PMC_EV(IAP, EVENT_06H_01H)			\
-__PMC_EV(IAP, EVENT_06H_02H)			\
-__PMC_EV(IAP, EVENT_06H_04H)			\
-__PMC_EV(IAP, EVENT_06H_08H)			\
-__PMC_EV(IAP, EVENT_06H_0FH)			\
-__PMC_EV(IAP, EVENT_08H_10H)			\
-__PMC_EV(IAP, EVENT_08H_20H)			\
-__PMC_EV(IAP, EVENT_08H_40H)			\
-__PMC_EV(IAP, EVENT_08H_80H)			\
-__PMC_EV(IAP, EVENT_09H_04H)			\
-__PMC_EV(IAP, EVENT_09H_08H)			\
-__PMC_EV(IAP, EVENT_0BH_01H)			\
-__PMC_EV(IAP, EVENT_0BH_02H)			\
-__PMC_EV(IAP, EVENT_0EH_01H)			\
-__PMC_EV(IAP, EVENT_0EH_02H)			\
-__PMC_EV(IAP, EVENT_0FH_02H)			\
-__PMC_EV(IAP, EVENT_0FH_08H)			\
-__PMC_EV(IAP, EVENT_0FH_10H)			\
-__PMC_EV(IAP, EVENT_0FH_20H)			\
-__PMC_EV(IAP, EVENT_10H_02H)			\
-__PMC_EV(IAP, EVENT_10H_04H)			\
-__PMC_EV(IAP, EVENT_10H_08H)			\
-__PMC_EV(IAP, EVENT_10H_10H)			\
-__PMC_EV(IAP, EVENT_10H_20H)			\
-__PMC_EV(IAP, EVENT_10H_40H)			\
-__PMC_EV(IAP, EVENT_10H_80H)			\
-__PMC_EV(IAP, EVENT_12H_02H)			\
-__PMC_EV(IAP, EVENT_12H_04H)			\
-__PMC_EV(IAP, EVENT_12H_08H)			\
-__PMC_EV(IAP, EVENT_12H_10H)			\
-__PMC_EV(IAP, EVENT_12H_20H)			\
-__PMC_EV(IAP, EVENT_12H_40H)			\
-__PMC_EV(IAP, EVENT_13H_02H)			\
-__PMC_EV(IAP, EVENT_13H_04H)			\
-__PMC_EV(IAP, EVENT_13H_07H)			\
-__PMC_EV(IAP, EVENT_14H_02H)			\
-__PMC_EV(IAP, EVENT_17H_01H)			\
-__PMC_EV(IAP, EVENT_18H_01H)			\
-__PMC_EV(IAP, EVENT_1DH_01H)			\
-__PMC_EV(IAP, EVENT_1DH_02H)			\
-__PMC_EV(IAP, EVENT_1DH_04H)			\
-__PMC_EV(IAP, EVENT_1EH_01H)			\
-__PMC_EV(IAP, EVENT_24H_01H)			\
-__PMC_EV(IAP, EVENT_24H_02H)			\
-__PMC_EV(IAP, EVENT_24H_03H)			\
-__PMC_EV(IAP, EVENT_24H_04H)			\
-__PMC_EV(IAP, EVENT_24H_08H)			\
-__PMC_EV(IAP, EVENT_24H_0CH)			\
-__PMC_EV(IAP, EVENT_24H_10H)			\
-__PMC_EV(IAP, EVENT_24H_20H)			\
-__PMC_EV(IAP, EVENT_24H_30H)			\
-__PMC_EV(IAP, EVENT_24H_40H)			\
-__PMC_EV(IAP, EVENT_24H_80H)			\
-__PMC_EV(IAP, EVENT_24H_AAH)			\
-__PMC_EV(IAP, EVENT_24H_C0H)			\
-__PMC_EV(IAP, EVENT_24H_FFH)			\
-__PMC_EV(IAP, EVENT_26H_01H)			\
-__PMC_EV(IAP, EVENT_26H_02H)			\
-__PMC_EV(IAP, EVENT_26H_04H)			\
-__PMC_EV(IAP, EVENT_26H_08H)			\
-__PMC_EV(IAP, EVENT_26H_0FH)			\
-__PMC_EV(IAP, EVENT_26H_10H)			\
-__PMC_EV(IAP, EVENT_26H_20H)			\
-__PMC_EV(IAP, EVENT_26H_40H)			\
-__PMC_EV(IAP, EVENT_26H_80H)			\
-__PMC_EV(IAP, EVENT_26H_F0H)			\
-__PMC_EV(IAP, EVENT_26H_FFH)			\
-__PMC_EV(IAP, EVENT_27H_01H)			\
-__PMC_EV(IAP, EVENT_27H_02H)			\
-__PMC_EV(IAP, EVENT_27H_04H)			\
-__PMC_EV(IAP, EVENT_27H_08H)			\
-__PMC_EV(IAP, EVENT_27H_0EH)			\
-__PMC_EV(IAP, EVENT_27H_0FH)			\
-__PMC_EV(IAP, EVENT_27H_10H)			\
-__PMC_EV(IAP, EVENT_27H_20H)			\
-__PMC_EV(IAP, EVENT_27H_40H)			\
-__PMC_EV(IAP, EVENT_27H_80H)			\
-__PMC_EV(IAP, EVENT_27H_E0H)			\
-__PMC_EV(IAP, EVENT_27H_F0H)			\
-__PMC_EV(IAP, EVENT_28H_01H)			\
-__PMC_EV(IAP, EVENT_28H_02H)			\
-__PMC_EV(IAP, EVENT_28H_04H)			\
-__PMC_EV(IAP, EVENT_28H_08H)			\
-__PMC_EV(IAP, EVENT_28H_0FH)			\
-__PMC_EV(IAP, EVENT_3DH_01H)			\
-__PMC_EV(IAP, EVENT_40H_01H)			\
-__PMC_EV(IAP, EVENT_40H_02H)			\
-__PMC_EV(IAP, EVENT_40H_04H)			\
-__PMC_EV(IAP, EVENT_40H_08H)			\
-__PMC_EV(IAP, EVENT_40H_0FH)			\
-__PMC_EV(IAP, EVENT_41H_01H)			\
-__PMC_EV(IAP, EVENT_41H_02H)			\
-__PMC_EV(IAP, EVENT_41H_04H)			\
-__PMC_EV(IAP, EVENT_41H_08H)			\
-__PMC_EV(IAP, EVENT_41H_0FH)			\
-__PMC_EV(IAP, EVENT_42H_01H)			\
-__PMC_EV(IAP, EVENT_42H_02H)			\
-__PMC_EV(IAP, EVENT_42H_04H)			\
-__PMC_EV(IAP, EVENT_42H_08H)			\
-__PMC_EV(IAP, EVENT_48H_02H)			\
-__PMC_EV(IAP, EVENT_49H_10H)			\
-__PMC_EV(IAP, EVENT_49H_20H)			\
-__PMC_EV(IAP, EVENT_49H_40H)			\
-__PMC_EV(IAP, EVENT_49H_80H)			\
-__PMC_EV(IAP, EVENT_4BH_08H)			\
-__PMC_EV(IAP, EVENT_4CH_01H)			\
-__PMC_EV(IAP, EVENT_4DH_01H)			\
-__PMC_EV(IAP, EVENT_4EH_01H)			\
-__PMC_EV(IAP, EVENT_4EH_02H)			\
-__PMC_EV(IAP, EVENT_4EH_04H)			\
-__PMC_EV(IAP, EVENT_4FH_02H)			\
-__PMC_EV(IAP, EVENT_4FH_04H)			\
-__PMC_EV(IAP, EVENT_4FH_08H)			\
-__PMC_EV(IAP, EVENT_51H_01H)			\
-__PMC_EV(IAP, EVENT_51H_02H)			\
-__PMC_EV(IAP, EVENT_51H_04H)			\
-__PMC_EV(IAP, EVENT_51H_08H)			\
-__PMC_EV(IAP, EVENT_52H_01H)			\
-__PMC_EV(IAP, EVENT_53H_01H)			\
-__PMC_EV(IAP, EVENT_60H_01H)			\
-__PMC_EV(IAP, EVENT_60H_02H)			\
-__PMC_EV(IAP, EVENT_60H_04H)			\
-__PMC_EV(IAP, EVENT_60H_08H)			\
-__PMC_EV(IAP, EVENT_63H_01H)			\
-__PMC_EV(IAP, EVENT_63H_02H)			\
-__PMC_EV(IAP, EVENT_6CH_01H)			\
-__PMC_EV(IAP, EVENT_80H_01H)			\
-__PMC_EV(IAP, EVENT_80H_04H)			\
-__PMC_EV(IAP, EVENT_80H_10H)			\
-__PMC_EV(IAP, EVENT_81H_01H)			\
-__PMC_EV(IAP, EVENT_81H_02H)			\
-__PMC_EV(IAP, EVENT_82H_01H)			\
-__PMC_EV(IAP, EVENT_83H_01H)			\
-__PMC_EV(IAP, EVENT_85H_01H)			\
-__PMC_EV(IAP, EVENT_85H_02H)			\
-__PMC_EV(IAP, EVENT_85H_04H)			\
-__PMC_EV(IAP, EVENT_85H_10H)			\
-__PMC_EV(IAP, EVENT_85H_20H)			\
-__PMC_EV(IAP, EVENT_85H_40H)			\
-__PMC_EV(IAP, EVENT_85H_80H)			\
-__PMC_EV(IAP, EVENT_87H_01H)			\
-__PMC_EV(IAP, EVENT_87H_02H)			\
-__PMC_EV(IAP, EVENT_87H_04H)			\
-__PMC_EV(IAP, EVENT_87H_08H)			\
-__PMC_EV(IAP, EVENT_87H_0FH)			\
-__PMC_EV(IAP, EVENT_88H_01H)			\
-__PMC_EV(IAP, EVENT_88H_02H)			\
-__PMC_EV(IAP, EVENT_88H_04H)			\
-__PMC_EV(IAP, EVENT_88H_07H)			\
-__PMC_EV(IAP, EVENT_88H_08H)			\
-__PMC_EV(IAP, EVENT_88H_10H)			\
-__PMC_EV(IAP, EVENT_88H_20H)			\
-__PMC_EV(IAP, EVENT_88H_30H)			\
-__PMC_EV(IAP, EVENT_88H_40H)			\
-__PMC_EV(IAP, EVENT_89H_01H)			\
-__PMC_EV(IAP, EVENT_89H_02H)			\
-__PMC_EV(IAP, EVENT_89H_04H)			\
-__PMC_EV(IAP, EVENT_89H_07H)			\
-__PMC_EV(IAP, EVENT_89H_08H)			\
-__PMC_EV(IAP, EVENT_89H_10H)			\
-__PMC_EV(IAP, EVENT_89H_20H)			\
-__PMC_EV(IAP, EVENT_89H_30H)			\
-__PMC_EV(IAP, EVENT_89H_40H)			\
-__PMC_EV(IAP, EVENT_89H_7FH)			\
-__PMC_EV(IAP, EVENT_A2H_01H)			\
-__PMC_EV(IAP, EVENT_A2H_02H)			\
-__PMC_EV(IAP, EVENT_A2H_04H)			\
-__PMC_EV(IAP, EVENT_A2H_08H)			\
-__PMC_EV(IAP, EVENT_A2H_10H)			\
-__PMC_EV(IAP, EVENT_A2H_20H)			\
-__PMC_EV(IAP, EVENT_A2H_40H)			\
-__PMC_EV(IAP, EVENT_A2H_80H)			\
-__PMC_EV(IAP, EVENT_A6H_01H)			\
-__PMC_EV(IAP, EVENT_A7H_01H)			\
-__PMC_EV(IAP, EVENT_A8H_01H)			\
-__PMC_EV(IAP, EVENT_B0H_01H)			\
-__PMC_EV(IAP, EVENT_B0H_02H)			\
-__PMC_EV(IAP, EVENT_B0H_04H)			\
-__PMC_EV(IAP, EVENT_B0H_08H)			\
-__PMC_EV(IAP, EVENT_B0H_20H)			\
-__PMC_EV(IAP, EVENT_B0H_40H)			\
-__PMC_EV(IAP, EVENT_B1H_01H)			\
-__PMC_EV(IAP, EVENT_B1H_02H)			\
-__PMC_EV(IAP, EVENT_B1H_04H)			\
-__PMC_EV(IAP, EVENT_B1H_08H)			\
-__PMC_EV(IAP, EVENT_B1H_10H)			\
-__PMC_EV(IAP, EVENT_B1H_20H)			\
-__PMC_EV(IAP, EVENT_B1H_40H)			\
-__PMC_EV(IAP, EVENT_B2H_01H)			\
-__PMC_EV(IAP, EVENT_B7H_01H)			\
-__PMC_EV(IAP, EVENT_B8H_01H)			\
-__PMC_EV(IAP, EVENT_B8H_02H)			\
-__PMC_EV(IAP, EVENT_B8H_04H)			\
-__PMC_EV(IAP, EVENT_BAH_01H)			\
-__PMC_EV(IAP, EVENT_BAH_02H)			\
-__PMC_EV(IAP, EVENT_C3H_02H)			\
-__PMC_EV(IAP, EVENT_C3H_10H)			\
-__PMC_EV(IAP, EVENT_C5H_02H)			\
-__PMC_EV(IAP, EVENT_C8H_20H)			\
-__PMC_EV(IAP, EVENT_CBH_40H)			\
-__PMC_EV(IAP, EVENT_CBH_80H)			\
-__PMC_EV(IAP, EVENT_CCH_03H)			\
-__PMC_EV(IAP, EVENT_D0H_01H)			\
-__PMC_EV(IAP, EVENT_D1H_02H)			\
-__PMC_EV(IAP, EVENT_D1H_04H)			\
-__PMC_EV(IAP, EVENT_D1H_08H)			\
-__PMC_EV(IAP, EVENT_DBH_01H)			\
 __PMC_EV(IAP, EVENT_E4H_01H)			\
 __PMC_EV(IAP, EVENT_E5H_01H)			\
-__PMC_EV(IAP, EVENT_F3H_04H)			\
-__PMC_EV(IAP, EVENT_F3H_08H)			\
-__PMC_EV(IAP, EVENT_F3H_10H)			\
-__PMC_EV(IAP, EVENT_F3H_20H)			\
-__PMC_EV(IAP, EVENT_F4H_01H)			\
-__PMC_EV(IAP, EVENT_F4H_02H)			\
-__PMC_EV(IAP, EVENT_F4H_04H)			\
-__PMC_EV(IAP, EVENT_F4H_08H)			\
-__PMC_EV(IAP, EVENT_F4H_10H)			\
-__PMC_EV(IAP, EVENT_F6H_01H)			\
-__PMC_EV(IAP, EVENT_F7H_01H)			\
-__PMC_EV(IAP, EVENT_F7H_02H)			\
-__PMC_EV(IAP, EVENT_F7H_04H)			\
-__PMC_EV(IAP, EVENT_F8H_01H)			\
-__PMC_EV(IAP, EVENT_FDH_01H)			\
-__PMC_EV(IAP, EVENT_FDH_02H)			\
-__PMC_EV(IAP, EVENT_FDH_04H)			\
-__PMC_EV(IAP, EVENT_FDH_08H)			\
-__PMC_EV(IAP, EVENT_FDH_10H)			\
-__PMC_EV(IAP, EVENT_FDH_20H)			\
-__PMC_EV(IAP, EVENT_FDH_40H)			\
+__PMC_EV(IAP, EVENT_E6H_00H)			\
+__PMC_EV(IAP, EVENT_E6H_01H)			\
 __PMC_EV(IAP, EVENT_E6H_02H)			\
 __PMC_EV(IAP, EVENT_E8H_01H)			\
 __PMC_EV(IAP, EVENT_E8H_02H)			\
 __PMC_EV(IAP, EVENT_E8H_03H)			\
+__PMC_EV(IAP, EVENT_ECH_01H)			\
+__PMC_EV(IAP, EVENT_F0H_00H)			\
 __PMC_EV(IAP, EVENT_F0H_01H)			\
 __PMC_EV(IAP, EVENT_F0H_02H)			\
 __PMC_EV(IAP, EVENT_F0H_04H)			\
@@ -1005,10 +1005,31 @@ __PMC_EV(IAP, EVENT_F2H_04H)			\
 __PMC_EV(IAP, EVENT_F2H_08H)			\
 __PMC_EV(IAP, EVENT_F2H_0FH)			\
 __PMC_EV(IAP, EVENT_F3H_01H)			\
-__PMC_EV(IAP, EVENT_F3H_02H)			
-
+__PMC_EV(IAP, EVENT_F3H_02H)			\
+__PMC_EV(IAP, EVENT_F3H_04H)			\
+__PMC_EV(IAP, EVENT_F3H_08H)			\
+__PMC_EV(IAP, EVENT_F3H_10H)			\
+__PMC_EV(IAP, EVENT_F3H_20H)			\
+__PMC_EV(IAP, EVENT_F4H_01H)			\
+__PMC_EV(IAP, EVENT_F4H_02H)			\
+__PMC_EV(IAP, EVENT_F4H_04H)			\
+__PMC_EV(IAP, EVENT_F4H_08H)			\
+__PMC_EV(IAP, EVENT_F4H_10H)			\
+__PMC_EV(IAP, EVENT_F6H_01H)			\
+__PMC_EV(IAP, EVENT_F7H_01H)			\
+__PMC_EV(IAP, EVENT_F7H_02H)			\
+__PMC_EV(IAP, EVENT_F7H_04H)			\
+__PMC_EV(IAP, EVENT_F8H_00H)			\
+__PMC_EV(IAP, EVENT_F8H_01H)			\
+__PMC_EV(IAP, EVENT_FDH_01H)			\
+__PMC_EV(IAP, EVENT_FDH_02H)			\
+__PMC_EV(IAP, EVENT_FDH_04H)			\
+__PMC_EV(IAP, EVENT_FDH_08H)			\
+__PMC_EV(IAP, EVENT_FDH_10H)			\
+__PMC_EV(IAP, EVENT_FDH_20H)			\
+__PMC_EV(IAP, EVENT_FDH_40H)
 
-#define	PMC_EV_IAP_FIRST	PMC_EV_IAP_EVENT_02H_81H
+#define	PMC_EV_IAP_FIRST	PMC_EV_IAP_EVENT_02H_01H
 #define	PMC_EV_IAP_LAST		PMC_EV_IAP_EVENT_FDH_40H
 
 /*
@@ -1647,330 +1668,655 @@ __PMC_EV_ALIAS("X87_OPS_RETIRED.ANY",		IAP_EVENT_C1H_FEH)	\
 __PMC_EV_ALIAS("X87_OPS_RETIRED.FXCH",		IAP_EVENT_C1H_01H)
 
 /*
- * Aliases for Core i7 PMC events.
+ * Core i7 and Xeon 5500 events removed between 253669-031US June 2009
+ * and 253669-033US December 2009.
+ */
+#define	__PMC_EV_ALIAS_COREI7_OLD()					\
+__PMC_EV_ALIAS("SB_FORWARD.ANY", IAP_EVENT_02H_01H)			\
+__PMC_EV_ALIAS("LOAD_BLOCK.STD", IAP_EVENT_03H_01H)			\
+__PMC_EV_ALIAS("LOAD_BLOCK.ADDRESS_OFFSET", IAP_EVENT_03H_04H)		\
+__PMC_EV_ALIAS("SB_DRAIN.CYCLES", IAP_EVENT_04H_01H)			\
+__PMC_EV_ALIAS("MISALIGN_MEM_REF.LOAD", IAP_EVENT_05H_01H)		\
+__PMC_EV_ALIAS("MISALIGN_MEM_REF.STORE", IAP_EVENT_05H_02H)		\
+__PMC_EV_ALIAS("MISALIGN_MEM_REF.ANY", IAP_EVENT_05H_03H)		\
+__PMC_EV_ALIAS("STORE_BLOCKS.NOT_STA", IAP_EVENT_06H_01H)		\
+__PMC_EV_ALIAS("STORE_BLOCKS.STA", IAP_EVENT_06H_02H)			\
+__PMC_EV_ALIAS("STORE_BLOCKS.ANY", IAP_EVENT_06H_0FH)			\
+__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.RESET", IAP_EVENT_09H_01H)	\
+__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.SUCCESS", IAP_EVENT_09H_02H)	\
+__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.WATCHDOG", IAP_EVENT_09H_04H)	\
+__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.WATCH_CYCLES", IAP_EVENT_09H_08H)\
+__PMC_EV_ALIAS("HW_INT.RCV", IAP_EVENT_1DH_01H)				\
+__PMC_EV_ALIAS("HW_INT.CYCLES_MASKED", IAP_EVENT_1DH_02H)		\
+__PMC_EV_ALIAS("HW_INT.CYCLES_PENDING_AND_MASKED", IAP_EVENT_1DH_04H)	\
+__PMC_EV_ALIAS("L2_WRITE.RFO.E_STATE", IAP_EVENT_27H_04H)		\
+__PMC_EV_ALIAS("UOPS_DECODED.DEC0", IAP_EVENT_3DH_01H)			\
+__PMC_EV_ALIAS("L1D_CACHE_ST.I_STATE", IAP_EVENT_41H_01H)		\
+__PMC_EV_ALIAS("L1D_CACHE_ST.MESI", IAP_EVENT_41H_0FH)			\
+__PMC_EV_ALIAS("DTLB_MISSES.PDE_MISS", IAP_EVENT_49H_20H)		\
+__PMC_EV_ALIAS("DTLB_MISSES.PDP_MISS", IAP_EVENT_49H_40H)		\
+__PMC_EV_ALIAS("DTLB_MISSES.LARGE_WALK_COMPLETED", IAP_EVENT_49H_80H)	\
+__PMC_EV_ALIAS("SSE_MEM_EXEC.NTA", IAP_EVENT_4BH_01H)			\
+__PMC_EV_ALIAS("SSE_MEM_EXEC.STREAMING_STORES", IAP_EVENT_4BH_08H)	\
+__PMC_EV_ALIAS("SFENCE_CYCLES", IAP_EVENT_4DH_01H)			\
+__PMC_EV_ALIAS("EPT.EPDE_MISS", IAP_EVENT_4FH_02H)			\
+__PMC_EV_ALIAS("EPT.EPDPE_HIT", IAP_EVENT_4FH_04H)			\
+__PMC_EV_ALIAS("EPT.EPDPE_MISS", IAP_EVENT_4FH_08H)			\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.READ_DATA",		\
+    IAP_EVENT_60H_01H)							\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.READ_CODE",		\
+    IAP_EVENT_60H_02H)							\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.RFO",		\
+    IAP_EVENT_60H_04H)							\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.ANY.READ",			\
+    IAP_EVENT_60H_08H)							\
+__PMC_EV_ALIAS("IFU_IVC.FULL", IAP_EVENT_81H_01H)			\
+__PMC_EV_ALIAS("IFU_IVC.L1I_EVICTION", IAP_EVENT_81H_02H)		\
+__PMC_EV_ALIAS("L1I_OPPORTUNISTIC_HITS", IAP_EVENT_83H_01H)		\
+__PMC_EV_ALIAS("ITLB_MISSES.WALK_CYCLES", IAP_EVENT_85H_04H)		\
+__PMC_EV_ALIAS("ITLB_MISSES.PMH_BUSY_CYCLES", IAP_EVENT_85H_04H)	\
+__PMC_EV_ALIAS("ITLB_MISSES.STLB_HIT", IAP_EVENT_85H_10H)		\
+__PMC_EV_ALIAS("ITLB_MISSES.PDE_MISS", IAP_EVENT_85H_20H)		\
+__PMC_EV_ALIAS("ITLB_MISSES.PDP_MISS", IAP_EVENT_85H_40H)		\
+__PMC_EV_ALIAS("ITLB_MISSES.LARGE_WALK_COMPLETED", IAP_EVENT_85H_80H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.READ_DATA", IAP_EVENT_B0H_01H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.READ_CODE", IAP_EVENT_B0H_02H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.RFO", IAP_EVENT_B0H_04H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY.READ", IAP_EVENT_B0H_08H)		\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY.RFO", IAP_EVENT_B0H_10H)		\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.UNCACHED_MEM", IAP_EVENT_B0H_20H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY", IAP_EVENT_B0H_80H)		\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.DATA", IAP_EVENT_B3H_01H)	\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.INVALIDATE",		\
+    IAP_EVENT_B3H_02H)							\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.CODE", IAP_EVENT_B3H_04H)	\
+__PMC_EV_ALIAS("PIC_ACCESSES.TPR_READS", IAP_EVENT_BAH_01H)		\
+__PMC_EV_ALIAS("PIC_ACCESSES.TPR_WRITES", IAP_EVENT_BAH_02H)		\
+__PMC_EV_ALIAS("MACHINE_CLEARS.FUSION_ASSIST", IAP_EVENT_C3H_10H)	\
+__PMC_EV_ALIAS("BOGUS_BR", IAP_EVENT_E4H_01H)				\
+__PMC_EV_ALIAS("L2_HW_PREFETCH.HIT", IAP_EVENT_F3H_01H)			\
+__PMC_EV_ALIAS("L2_HW_PREFETCH.ALLOC", IAP_EVENT_F3H_02H)		\
+__PMC_EV_ALIAS("L2_HW_PREFETCH.DATA_TRIGGER", IAP_EVENT_F3H_04H)	\
+__PMC_EV_ALIAS("L2_HW_PREFETCH.CODE_TRIGGER", IAP_EVENT_F3H_08H)	\
+__PMC_EV_ALIAS("L2_HW_PREFETCH.DCA_TRIGGER", IAP_EVENT_F3H_10H)		\
+__PMC_EV_ALIAS("L2_HW_PREFETCH.KICK_START", IAP_EVENT_F3H_20H)		\
+__PMC_EV_ALIAS("SQ_MISC.PROMOTION", IAP_EVENT_F4H_01H)			\
+__PMC_EV_ALIAS("SQ_MISC.PROMOTION_POST_GO", IAP_EVENT_F4H_02H)		\
+__PMC_EV_ALIAS("SQ_MISC.LRU_HINTS", IAP_EVENT_F4H_04H)			\
+__PMC_EV_ALIAS("SQ_MISC.FILL_DROPPED", IAP_EVENT_F4H_08H)		\
+__PMC_EV_ALIAS("SEGMENT_REG_LOADS", IAP_EVENT_F8H_01H)
+
+/*
+ * Aliases for Core i7 and Xeon 5500 PMC events (253669-033US December 2009)
  */
 #define	__PMC_EV_ALIAS_COREI7()						\
 __PMC_EV_ALIAS_INTEL_ARCHITECTURAL()					\
-__PMC_EV_ALIAS("SB_FORWARD.ANY",			IAP_EVENT_02H_01H) \
-__PMC_EV_ALIAS("LOAD_BLOCK.STD",			IAP_EVENT_03H_01H) \
-__PMC_EV_ALIAS("LOAD_BLOCK.ADDRESS_OFFSET",		IAP_EVENT_03H_04H) \
-__PMC_EV_ALIAS("SB_DRAIN.CYCLES",			IAP_EVENT_04H_01H) \
-__PMC_EV_ALIAS("MISALIGN_MEM_REF.LOAD",			IAP_EVENT_05H_01H) \
-__PMC_EV_ALIAS("MISALIGN_MEM_REF.STORE",		IAP_EVENT_05H_02H) \
-__PMC_EV_ALIAS("MISALIGN_MEM_REF.ANY",			IAP_EVENT_05H_03H) \
-__PMC_EV_ALIAS("STORE_BLOCKS.NOT_STA",			IAP_EVENT_06H_01H) \
-__PMC_EV_ALIAS("STORE_BLOCKS.STA",			IAP_EVENT_06H_02H) \
-__PMC_EV_ALIAS("STORE_BLOCKS.AT_RET",			IAP_EVENT_06H_04H) \
-__PMC_EV_ALIAS("STORE_BLOCKS.L1D_BLOCK",		IAP_EVENT_06H_08H) \
-__PMC_EV_ALIAS("STORE_BLOCKS.ANY",			IAP_EVENT_06H_0FH) \
-__PMC_EV_ALIAS("PARTIAL_ADDRESS_ALIAS",			IAP_EVENT_07H_01H) \
-__PMC_EV_ALIAS("DTLB_LOAD_MISSES.ANY",			IAP_EVENT_08H_01H) \
-__PMC_EV_ALIAS("DTLB_LOAD_MISSES.WALK_COMPLETED",	IAP_EVENT_08H_02H) \
-__PMC_EV_ALIAS("DTLB_LOAD_MISSES.STLB_HIT",		IAP_EVENT_08H_10H) \
-__PMC_EV_ALIAS("DTLB_LOAD_MISSES.PDE_MISS",		IAP_EVENT_08H_20H) \
-__PMC_EV_ALIAS("DTLB_LOAD_MISSES.PDP_MISS",		IAP_EVENT_08H_40H) \
-__PMC_EV_ALIAS("DTLB_LOAD_MISSES.LARGE_WALK_COMPLETED",	IAP_EVENT_08H_80H) \
-__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.RESET",		IAP_EVENT_09H_01H) \
-__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.SUCCESS",	IAP_EVENT_09H_02H) \
-__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.WATCHDOG",	IAP_EVENT_09H_04H) \
-__PMC_EV_ALIAS("MEMORY_DISAMBIGURATION.WATCH_CYCLES",	IAP_EVENT_09H_08H) \
-__PMC_EV_ALIAS("MEM_INST_RETIRED.LOADS",		IAP_EVENT_0BH_01H) \
-__PMC_EV_ALIAS("MEM_INST_RETIRED.STORES",		IAP_EVENT_0BH_02H) \
-__PMC_EV_ALIAS("MEM_STORE_RETIRED.DTLB_MISS",		IAP_EVENT_0CH_01H) \
-__PMC_EV_ALIAS("UOPS_ISSUED.ANY",			IAP_EVENT_0EH_01H) \
-__PMC_EV_ALIAS("UOPS_ISSUED.FUSED",			IAP_EVENT_0EH_02H) \
-__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.OTHER_CORE_L2_HITM",	IAP_EVENT_0FH_02H) \
-__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.REMOTE_CACHE_LOCAL_HOME_HIT", IAP_EVENT_0FH_08H) \
-__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.REMOTE_DRAM",	IAP_EVENT_0FH_10H) \
-__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.LOCAL_DRAM",		IAP_EVENT_0FH_20H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.X87",			IAP_EVENT_10H_01H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.MMX",			IAP_EVENT_10H_02H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP",		IAP_EVENT_10H_04H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE2_INTEGER",		IAP_EVENT_10H_08H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP_PACKED",		IAP_EVENT_10H_10H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP_SCALAR",		IAP_EVENT_10H_20H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_SINGLE_PRECISION",	IAP_EVENT_10H_40H) \
-__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_DOUBLE_PRECISION",	IAP_EVENT_10H_80H) \
-__PMC_EV_ALIAS("SIMD_INT_128.PACKED_MPY",		IAP_EVENT_12H_01H) \
-__PMC_EV_ALIAS("SIMD_INT_128.PACKED_SHIFT",		IAP_EVENT_12H_02H) \
-__PMC_EV_ALIAS("SIMD_INT_128.PACK",			IAP_EVENT_12H_04H) \
-__PMC_EV_ALIAS("SIMD_INT_128.UNPACK",			IAP_EVENT_12H_08H) \
-__PMC_EV_ALIAS("SIMD_INT_128.PACKED_LOGICAL",		IAP_EVENT_12H_10H) \
-__PMC_EV_ALIAS("SIMD_INT_128.PACKED_ARITH",		IAP_EVENT_12H_20H) \
-__PMC_EV_ALIAS("SIMD_INT_128.SHUFFLE_MOVE",		IAP_EVENT_12H_40H) \
-__PMC_EV_ALIAS("LOAD_DISPATCH.RS",			IAP_EVENT_13H_01H) \
-__PMC_EV_ALIAS("LOAD_DISPATCH.RS_DELAYED",		IAP_EVENT_13H_02H) \
-__PMC_EV_ALIAS("LOAD_DISPATCH.MOB",			IAP_EVENT_13H_04H) \
-__PMC_EV_ALIAS("LOAD_DISPATCH.ANY",			IAP_EVENT_13H_07H) \
-__PMC_EV_ALIAS("ARITH.CYCLES_DIV_BUSY",			IAP_EVENT_14H_01H) \
-__PMC_EV_ALIAS("ARITH.MUL",				IAP_EVENT_14H_02H) \
-__PMC_EV_ALIAS("INST_QUEUE_WRITES",			IAP_EVENT_17H_01H) \
-__PMC_EV_ALIAS("INST_DECODED.DEC0",			IAP_EVENT_18H_01H) \
-__PMC_EV_ALIAS("TWO_UOP_INSTS_DECODED",			IAP_EVENT_19H_01H) \
-__PMC_EV_ALIAS("HW_INT.RCV",				IAP_EVENT_1DH_01H) \
-__PMC_EV_ALIAS("HW_INT.CYCLES_MASKED",			IAP_EVENT_1DH_02H) \
-__PMC_EV_ALIAS("HW_INT.CYCLES_PENDING_AND_MASKED",	IAP_EVENT_1DH_04H) \
-__PMC_EV_ALIAS("INST_QUEUE_WRITE_CYCLES",		IAP_EVENT_1EH_01H) \
-__PMC_EV_ALIAS("L2_RQSTS.LD_HIT",			IAP_EVENT_24H_01H) \
-__PMC_EV_ALIAS("L2_RQSTS.LD_MISS",			IAP_EVENT_24H_02H) \
-__PMC_EV_ALIAS("L2_RQSTS.LOADS",			IAP_EVENT_24H_03H) \
-__PMC_EV_ALIAS("L2_RQSTS.RFO_HIT",			IAP_EVENT_24H_04H) \
-__PMC_EV_ALIAS("L2_RQSTS.RFO_MISS",			IAP_EVENT_24H_08H) \
-__PMC_EV_ALIAS("L2_RQSTS.RFOS",				IAP_EVENT_24H_0CH) \
-__PMC_EV_ALIAS("L2_RQSTS.IFETCH_HIT",			IAP_EVENT_24H_10H) \
-__PMC_EV_ALIAS("L2_RQSTS.IFETCH_MISS",			IAP_EVENT_24H_20H) \
-__PMC_EV_ALIAS("L2_RQSTS.IFETCHES",			IAP_EVENT_24H_30H) \
-__PMC_EV_ALIAS("L2_RQSTS.PREFETCH_HIT",			IAP_EVENT_24H_40H) \
-__PMC_EV_ALIAS("L2_RQSTS.PREFETCH_MISS",		IAP_EVENT_24H_80H) \
-__PMC_EV_ALIAS("L2_RQSTS.PREFETCHES",			IAP_EVENT_24H_C0H) \
-__PMC_EV_ALIAS("L2_RQSTS.MISS",				IAP_EVENT_24H_AAH) \
-__PMC_EV_ALIAS("L2_RQSTS.REFERENCES",			IAP_EVENT_24H_FFH) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.I_STATE",		IAP_EVENT_26H_01H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.S_STATE",		IAP_EVENT_26H_02H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.E_STATE",		IAP_EVENT_26H_04H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.M_STATE",		IAP_EVENT_26H_08H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.MESI",		IAP_EVENT_26H_0FH) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.I_STATE",	IAP_EVENT_26H_10H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.S_STATE",	IAP_EVENT_26H_20H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.E_STATE",	IAP_EVENT_26H_40H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.M_STATE",	IAP_EVENT_26H_80H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.MESI",		IAP_EVENT_26H_F0H) \
-__PMC_EV_ALIAS("L2_DATA_RQSTS.ANY",			IAP_EVENT_26H_FFH) \
-__PMC_EV_ALIAS("L2_WRITE.RFO.I_STATE",			IAP_EVENT_27H_01H) \
-__PMC_EV_ALIAS("L2_WRITE.RFO.S_STATE",			IAP_EVENT_27H_02H) \
-__PMC_EV_ALIAS("L2_WRITE.RFO.E_STATE",			IAP_EVENT_27H_04H) \
-__PMC_EV_ALIAS("L2_WRITE.RFO.M_STATE",			IAP_EVENT_27H_08H) \
-__PMC_EV_ALIAS("L2_WRITE.RFO.HIT",			IAP_EVENT_27H_0EH) \
-__PMC_EV_ALIAS("L2_WRITE.RFO.MESI",			IAP_EVENT_27H_0FH) \
-__PMC_EV_ALIAS("L2_WRITE.LOCK.I_STATE",			IAP_EVENT_27H_10H) \
-__PMC_EV_ALIAS("L2_WRITE.LOCK.S_STATE",			IAP_EVENT_27H_20H) \
-__PMC_EV_ALIAS("L2_WRITE.LOCK.E_STATE",			IAP_EVENT_27H_40H) \
-__PMC_EV_ALIAS("L2_WRITE.LOCK.M_STATE",			IAP_EVENT_27H_80H) \
-__PMC_EV_ALIAS("L2_WRITE.LOCK.HIT",			IAP_EVENT_27H_E0H) \
-__PMC_EV_ALIAS("L2_WRITE.LOCK.MESI",			IAP_EVENT_27H_F0H) \
-__PMC_EV_ALIAS("L1D_WB_L2.I_STATE",			IAP_EVENT_28H_01H) \
-__PMC_EV_ALIAS("L1D_WB_L2.S_STATE",			IAP_EVENT_28H_02H) \
-__PMC_EV_ALIAS("L1D_WB_L2.E_STATE",			IAP_EVENT_28H_04H) \
-__PMC_EV_ALIAS("L1D_WB_L2.M_STATE",			IAP_EVENT_28H_08H) \
-__PMC_EV_ALIAS("L1D_WB_L2.MESI",			IAP_EVENT_28H_0FH) \
-__PMC_EV_ALIAS("LONGEST_LAT_CACHE.REFERENCE",		IAP_EVENT_2EH_4FH) \
-__PMC_EV_ALIAS("LONGEST_LAT_CACHE.MISS",		IAP_EVENT_2EH_41H) \
-__PMC_EV_ALIAS("CPU_CLK_UNHALTED.THREAD_P",		IAP_EVENT_3CH_00H) \
-__PMC_EV_ALIAS("CPU_CLK_UNHALTED.REF_P",		IAP_EVENT_3CH_01H) \
-__PMC_EV_ALIAS("UOPS_DECODED.DEC0",			IAP_EVENT_3DH_01H) \
-__PMC_EV_ALIAS("L1D_CACHE_LD.I_STATE",			IAP_EVENT_40H_01H) \
-__PMC_EV_ALIAS("L1D_CACHE_LD.S_STATE",			IAP_EVENT_40H_02H) \
-__PMC_EV_ALIAS("L1D_CACHE_LD.E_STATE",			IAP_EVENT_40H_04H) \
-__PMC_EV_ALIAS("L1D_CACHE_LD.M_STATE",			IAP_EVENT_40H_08H) \
-__PMC_EV_ALIAS("L1D_CACHE_LD.MESI",			IAP_EVENT_40H_0FH) \
-__PMC_EV_ALIAS("L1D_CACHE_ST.I_STATE",			IAP_EVENT_41H_01H) \
-__PMC_EV_ALIAS("L1D_CACHE_ST.S_STATE",			IAP_EVENT_41H_02H) \
-__PMC_EV_ALIAS("L1D_CACHE_ST.E_STATE",			IAP_EVENT_41H_04H) \
-__PMC_EV_ALIAS("L1D_CACHE_ST.M_STATE",			IAP_EVENT_41H_08H) \
-__PMC_EV_ALIAS("L1D_CACHE_ST.MESI",			IAP_EVENT_41H_0FH) \
-__PMC_EV_ALIAS("L1D_CACHE_LOCK.HIT",			IAP_EVENT_42H_01H) \
-__PMC_EV_ALIAS("L1D_CACHE_LOCK.S_STATE",		IAP_EVENT_42H_02H) \
-__PMC_EV_ALIAS("L1D_CACHE_LOCK.E_STATE",		IAP_EVENT_42H_04H) \
-__PMC_EV_ALIAS("L1D_CACHE_LOCK.M_STATE",		IAP_EVENT_42H_08H) \
-__PMC_EV_ALIAS("L1D_ALL_REF.ANY",			IAP_EVENT_43H_01H) \
-__PMC_EV_ALIAS("L1D_ALL_REF.CACHEABLE",			IAP_EVENT_43H_02H) \
-__PMC_EV_ALIAS("L1D_PEND_MISS.LOAD_BUFFERS_FULL",	IAP_EVENT_48H_02H) \
-__PMC_EV_ALIAS("DTLB_MISSES.ANY",			IAP_EVENT_49H_01H) \
-__PMC_EV_ALIAS("DTLB_MISSES.WALK_COMPLETED",		IAP_EVENT_49H_02H) \
-__PMC_EV_ALIAS("DTLB_MISSES.STLB_HIT",			IAP_EVENT_49H_10H) \
-__PMC_EV_ALIAS("DTLB_MISSES.PDE_MISS",			IAP_EVENT_49H_20H) \
-__PMC_EV_ALIAS("DTLB_MISSES.PDP_MISS",			IAP_EVENT_49H_40H) \
-__PMC_EV_ALIAS("DTLB_MISSES.LARGE_WALK_COMPLETED",	IAP_EVENT_49H_80H) \
-__PMC_EV_ALIAS("SSE_MEM_EXEC.NTA",			IAP_EVENT_4BH_01H) \
-__PMC_EV_ALIAS("SSE_MEM_EXEC.STREAMING_STORES",		IAP_EVENT_4BH_08H) \
-__PMC_EV_ALIAS("LOAD_HIT_PRE",				IAP_EVENT_4CH_01H) \
-__PMC_EV_ALIAS("SFENCE_CYCLES",				IAP_EVENT_4DH_01H) \
-__PMC_EV_ALIAS("L1D_PREFETCH.REQUESTS",			IAP_EVENT_4EH_01H) \
-__PMC_EV_ALIAS("L1D_PREFETCH.MISS",			IAP_EVENT_4EH_02H) \
-__PMC_EV_ALIAS("L1D_PREFETCH.TRIGGERS",			IAP_EVENT_4EH_04H) \
-__PMC_EV_ALIAS("EPT.EPDE_MISS",				IAP_EVENT_4FH_02H) \
-__PMC_EV_ALIAS("EPT.EPDPE_HIT",				IAP_EVENT_4FH_04H) \
-__PMC_EV_ALIAS("EPT.EPDPE_MISS",			IAP_EVENT_4FH_08H) \
-__PMC_EV_ALIAS("L1D.REPL",				IAP_EVENT_51H_01H) \
-__PMC_EV_ALIAS("L1D.M_REPL",				IAP_EVENT_51H_02H) \
-__PMC_EV_ALIAS("L1D.M_EVICT",				IAP_EVENT_51H_04H) \
-__PMC_EV_ALIAS("L1D.M_SNOOP_EVICT",			IAP_EVENT_51H_08H) \
-__PMC_EV_ALIAS("L1D_CACHE_PREFETCH_LOCK_FB_HIT",	IAP_EVENT_52H_01H) \
-__PMC_EV_ALIAS("L1D_CACHE_LOCK_FB_HIT",			IAP_EVENT_53H_01H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.READ_DATA", IAP_EVENT_60H_01H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.READ_CODE", IAP_EVENT_60H_02H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.RFO", IAP_EVENT_60H_04H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.ANY.READ",	IAP_EVENT_60H_08H) \
-__PMC_EV_ALIAS("CACHE_LOCK_CYCLES.L1D_L2",		IAP_EVENT_63H_01H) \
-__PMC_EV_ALIAS("CACHE_LOCK_CYCLES.L1D",			IAP_EVENT_63H_02H) \
-__PMC_EV_ALIAS("IO_TRANSACTIONS",			IAP_EVENT_6CH_01H) \
-__PMC_EV_ALIAS("L1I.HITS",				IAP_EVENT_80H_01H) \
-__PMC_EV_ALIAS("L1I.MISSES",				IAP_EVENT_80H_02H) \
-__PMC_EV_ALIAS("L1I.READS",				IAP_EVENT_80H_03H) \
-__PMC_EV_ALIAS("L1I.CYCLES_STALLED",			IAP_EVENT_80H_04H) \
-__PMC_EV_ALIAS("IFU_IVC.FULL",				IAP_EVENT_81H_01H) \
-__PMC_EV_ALIAS("IFU_IVC.L1I_EVICTION",			IAP_EVENT_81H_02H) \
-__PMC_EV_ALIAS("LARGE_ITLB.HIT",			IAP_EVENT_82H_01H) \
-__PMC_EV_ALIAS("L1I_OPPORTUNISTIC_HITS",		IAP_EVENT_83H_01H) \
-__PMC_EV_ALIAS("ITLB_MISSES.ANY",			IAP_EVENT_85H_01H) \
-__PMC_EV_ALIAS("ITLB_MISSES.WALK_COMPLETED",		IAP_EVENT_85H_02H) \
-__PMC_EV_ALIAS("ITLB_MISSES.WALK_CYCLES",		IAP_EVENT_85H_04H) \
-__PMC_EV_ALIAS("ITLB_MISSES.STLB_HIT",			IAP_EVENT_85H_10H) \
-__PMC_EV_ALIAS("ITLB_MISSES.PDE_MISS",			IAP_EVENT_85H_20H) \
-__PMC_EV_ALIAS("ITLB_MISSES.PDP_MISS",			IAP_EVENT_85H_40H) \
-__PMC_EV_ALIAS("ITLB_MISSES.LARGE_WALK_COMPLETED",	IAP_EVENT_85H_80H) \
-__PMC_EV_ALIAS("ILD_STALL.LCP",				IAP_EVENT_87H_01H) \
-__PMC_EV_ALIAS("ILD_STALL.MRU",				IAP_EVENT_87H_02H) \
-__PMC_EV_ALIAS("ILD_STALL.IQ_FULL",			IAP_EVENT_87H_04H) \
-__PMC_EV_ALIAS("ILD_STALL.REGEN",			IAP_EVENT_87H_08H) \
-__PMC_EV_ALIAS("ILD_STALL.ANY",				IAP_EVENT_87H_0FH) \
-__PMC_EV_ALIAS("BR_INST_EXEC.COND",			IAP_EVENT_88H_01H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.DIRECT",			IAP_EVENT_88H_02H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.INDIRECT_NON_CALL",	IAP_EVENT_88H_04H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.NON_CALLS",		IAP_EVENT_88H_07H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.RETURN_NEAR",		IAP_EVENT_88H_08H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.DIRECT_NEAR_CALL",		IAP_EVENT_88H_10H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.INDIRECT_NEAR_CALL",	IAP_EVENT_88H_20H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.NEAR_CALLS",		IAP_EVENT_88H_30H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.TAKEN",			IAP_EVENT_88H_40H) \
-__PMC_EV_ALIAS("BR_INST_EXEC.ANY",			IAP_EVENT_7FH)	\
-__PMC_EV_ALIAS("BR_MISP_EXEC.COND",			IAP_EVENT_89H_01H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.DIRECT",			IAP_EVENT_89H_02H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.INDIRECT_NON_CALL",	IAP_EVENT_89H_04H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.NON_CALLS",		IAP_EVENT_89H_07H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.RETURN_NEAR",		IAP_EVENT_89H_08H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.DIRECT_NEAR_CALL",		IAP_EVENT_89H_10H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.INDIRECT_NEAR_CALL",	IAP_EVENT_89H_20H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.NEAR_CALLS",		IAP_EVENT_89H_30H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.TAKEN",			IAP_EVENT_89H_40H) \
-__PMC_EV_ALIAS("BR_MISP_EXEC.ANY",			IAP_EVENT_89H_7FH) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.ANY",			IAP_EVENT_A2H_01H) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.LOAD",			IAP_EVENT_A2H_02H) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.RS_FULL",		IAP_EVENT_A2H_04H) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.STORE",			IAP_EVENT_A2H_08H) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.ROB_FULL",		IAP_EVENT_A2H_10H) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.FPCW",			IAP_EVENT_A2H_20H) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.MXCSR",			IAP_EVENT_A2H_40H) \
-__PMC_EV_ALIAS("RESOURCE_STALLS.OTHER",			IAP_EVENT_A2H_80H) \
-__PMC_EV_ALIAS("MACRO_INSTS.FUSIONS_DECODED",		IAP_EVENT_A6H_01H) \
-__PMC_EV_ALIAS("BACLEAR_FORCE_IQ",			IAP_EVENT_A7H_01H) \
-__PMC_EV_ALIAS("LSD.UOPS",				IAP_EVENT_A8H_01H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.READ_DATA",	IAP_EVENT_B0H_01H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.READ_CODE",	IAP_EVENT_B0H_02H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.RFO",		IAP_EVENT_B0H_04H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY.READ",		IAP_EVENT_B0H_08H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY.RFO",		IAP_EVENT_80H_10H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.UNCACHED_MEM",		IAP_EVENT_B0H_20H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.L1D_WRITEBACK",	IAP_EVENT_B0H_40H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY",			IAP_EVENT_B0H_80H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT0",			IAP_EVENT_B1H_01H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT1",			IAP_EVENT_B1H_02H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT2_CORE",		IAP_EVENT_B1H_04H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT3_CORE",		IAP_EVENT_B1H_08H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT4_CORE",		IAP_EVENT_B1H_10H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT5",			IAP_EVENT_B1H_20H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT015",			IAP_EVENT_B1H_40H) \
-__PMC_EV_ALIAS("UOPS_EXECUTED.PORT234",			IAP_EVENT_B1H_80H) \
-__PMC_EV_ALIAS("OFFCORE_REQUESTS_SQ_FULL",		IAP_EVENT_B2H_01H) \
-__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.DATA",	IAP_EVENT_B3H_01H) \
-__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.INVALIDATE", IAP_EVENT_B3H_02H) \
-__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.CODE",	IAP_EVENT_B3H_04H) \
-__PMC_EV_ALIAS("OOF_CORE_RESPONSE_0",			IAP_EVENT_B7H_01H) \
-__PMC_EV_ALIAS("SNOOP_RESPONSE.HIT",			IAP_EVENT_B8H_01H) \
-__PMC_EV_ALIAS("SNOOP_RESPONSE.HITE",			IAP_EVENT_B8H_02H) \
-__PMC_EV_ALIAS("SNOOP_RESPONSE.HITM",			IAP_EVENT_B8H_04H) \
-__PMC_EV_ALIAS("PIC_ACCESSES.TPR_READS",		IAP_EVENT_BAH_01H) \
-__PMC_EV_ALIAS("PIC_ACCESSES.TPR_WRITES",		IAP_EVENT_BAH_02H) \
-__PMC_EV_ALIAS("INST_RETIRED.ANY_P",			IAP_EVENT_C0H_01H) \
-__PMC_EV_ALIAS("INST_RETIRED.X87",			IAP_EVENT_C0H_02H) \
-__PMC_EV_ALIAS("UOPS_RETIRED.ANY",			IAP_EVENT_C2H_01H) \
-__PMC_EV_ALIAS("UOPS_RETIRED.RETIRE_SLOTS",		IAP_EVENT_C2H_02H) \
-__PMC_EV_ALIAS("UOPS_RETIRED.MACRO_FUSED",		IAP_EVENT_C2H_04H) \
-__PMC_EV_ALIAS("MACHINE_CLEARS.CYCLES",			IAP_EVENT_C3H_01H) \
-__PMC_EV_ALIAS("MACHINE_CLEARS.MEM_ORDER",		IAP_EVENT_C3H_02H) \
-__PMC_EV_ALIAS("MACHINE_CLEARS.SMC",			IAP_EVENT_C3H_04H) \
-__PMC_EV_ALIAS("MACHINE_CLEARS.FUSION_ASSIST",		IAP_EVENT_C3H_10H) \
-__PMC_EV_ALIAS("BR_INST_RETIRED.ALL_BRANCHES",		IAP_EVENT_C4H_00H) \
-__PMC_EV_ALIAS("BR_INST_RETIRED.CONDITIONAL",		IAP_EVENT_C4H_01H) \
-__PMC_EV_ALIAS("BR_INST_RETIRED.NEAR_CALL",		IAP_EVENT_C4H_02H) \
-__PMC_EV_ALIAS("BR_INST_RETIRED.ALL_BRANCHES",		IAP_EVENT_C4H_04H) \
-__PMC_EV_ALIAS("BR_MISP_RETIRED.ALL_BRANCHES",		IAP_EVENT_C5H_00H) \
-__PMC_EV_ALIAS("BR_MISP_RETIRED.NEAR_CALL",		IAP_EVENT_C5H_02H) \
-__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.PACKED_SINGLE",	IAP_EVENT_C7H_01H) \
-__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.SCALAR_SINGLE",	IAP_EVENT_C7H_02H) \
-__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.PACKED_DOUBLE",	IAP_EVENT_C7H_04H) \
-__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.SCALAR_DOUBLE",	IAP_EVENT_C7H_08H) \
-__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.VECTOR_INTEGER",	IAP_EVENT_C7H_10H) \
-__PMC_EV_ALIAS("ITLB_MISS_RETIRED",			IAP_EVENT_C8H_20H) \
-__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L1D_HIT",		IAP_EVENT_CBH_01H) \
-__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L2_HIT",		IAP_EVENT_CBH_02H) \
-__PMC_EV_ALIAS("MEM_LOAD_RETIRED.LLC_UNSHARED_HIT",	IAP_EVENT_CBH_04H) \
-__PMC_EV_ALIAS("MEM_LOAD_RETIRED.OTHER_CORE_L2_HIT_HITM", IAP_EVENT_CBH_08H) \
-__PMC_EV_ALIAS("MEM_LOAD_RETIRED.LLC_MISS",		IAP_EVENT_CBH_10H) \
-__PMC_EV_ALIAS("MEM_LOAD_RETIRED.HIT_LFB",		IAP_EVENT_CBH_40H) \
-__PMC_EV_ALIAS("MEM_LOAD_RETIRED.DTLB_MISS",		IAP_EVENT_CBH_80H) \
-__PMC_EV_ALIAS("FP_MMX_TRANS.TO_FP",			IAP_EVENT_CCH_01H) \
-__PMC_EV_ALIAS("FP_MMX_TRANS.TO_MMX",			IAP_EVENT_CCH_02H) \
-__PMC_EV_ALIAS("FP_MMX_TRANS.ANY",			IAP_EVENT_CCH_03H) \
-__PMC_EV_ALIAS("MACRO_INSTS.DECODED",			IAP_EVENT_D0H_01H) \
-__PMC_EV_ALIAS("UOPS_DECODED.MS",			IAP_EVENT_D1H_02H) \
-__PMC_EV_ALIAS("UOPS_DECODED.ESP_FOLDING",		IAP_EVENT_D1H_04H) \
-__PMC_EV_ALIAS("UOPS_DECODED.ESP_SYNC",			IAP_EVENT_D1H_08H) \
-__PMC_EV_ALIAS("RAT_STALLS.FLAGS",			IAP_EVENT_D2H_01H) \
-__PMC_EV_ALIAS("RAT_STALLS.REGISTERS",			IAP_EVENT_D2H_02H) \
-__PMC_EV_ALIAS("RAT_STALLS.ROB_READ_PORT",		IAP_EVENT_D2H_04H) \
-__PMC_EV_ALIAS("RAT_STALLS.SCOREBOARD",			IAP_EVENT_D2H_08H) \
-__PMC_EV_ALIAS("RAT_STALLS.ANY",			IAP_EVENT_D2H_0FH) \
-__PMC_EV_ALIAS("SEG_RENAME_STALLS",			IAP_EVENT_D4H_01H) \
-__PMC_EV_ALIAS("ES_REG_RENAMES",			IAP_EVENT_D5H_01H) \
-__PMC_EV_ALIAS("UOP_UNFUSION",				IAP_EVENT_DBH_01H) \
-__PMC_EV_ALIAS("BR_INST_DECODED",			IAP_EVENT_E0H_01H) \
-__PMC_EV_ALIAS("BOGUS_BR",				IAP_EVENT_E4H_01H) \
-__PMC_EV_ALIAS("BPU_MISSED_CALL_RET",			IAP_EVENT_E5H_01H) \
-__PMC_EV_ALIAS("BACLEAR.CLEAR",				IAP_EVENT_E6H_01H) \
-__PMC_EV_ALIAS("BACLEAR.BAD_TARGET",			IAP_EVENT_E6H_02H) \
-__PMC_EV_ALIAS("BPU_CLEARS.EARLY",			IAP_EVENT_E8H_01H) \
-__PMC_EV_ALIAS("BPU_CLEARS.LATE",			IAP_EVENT_E8H_02H) \
-__PMC_EV_ALIAS("BPU_CLEARS.ANY",			IAP_EVENT_E8H_03H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.LOAD",			IAP_EVENT_F0H_01H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.RFO",			IAP_EVENT_F0H_02H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.IFETCH",		IAP_EVENT_F0H_04H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.PREFETCH",		IAP_EVENT_F0H_08H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.L1D_WB",		IAP_EVENT_F0H_10H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.FILL",			IAP_EVENT_F0H_20H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.WB",			IAP_EVENT_F0H_40H) \
-__PMC_EV_ALIAS("L2_TRANSACTIONS.ANY",			IAP_EVENT_F0H_80H) \
-__PMC_EV_ALIAS("L2_LINES_IN.S_STATE",			IAP_EVENT_F1H_02H) \
-__PMC_EV_ALIAS("L2_LINES_IN.E_STATE",			IAP_EVENT_F1H_04H) \
-__PMC_EV_ALIAS("L2_LINES_IN.ANY",			IAP_EVENT_F1H_07H) \
-__PMC_EV_ALIAS("L2_LINES_OUT.DEMAND_CLEAN",		IAP_EVENT_F2H_01H) \
-__PMC_EV_ALIAS("L2_LINES_OUT.DEMAND_DIRTY",		IAP_EVENT_F2H_02H) \
-__PMC_EV_ALIAS("L2_LINES_OUT.PREFETCH_CLEAN",		IAP_EVENT_F2H_04H) \
-__PMC_EV_ALIAS("L2_LINES_OUT.PREFETCH_DIRTY",		IAP_EVENT_F2H_08H) \
-__PMC_EV_ALIAS("L2_LINES_OUT.ANY",			IAP_EVENT_F2H_0FH) \
-__PMC_EV_ALIAS("L2_HW_PREFETCH.HIT",			IAP_EVENT_F3H_01H) \
-__PMC_EV_ALIAS("L2_HW_PREFETCH.ALLOC",			IAP_EVENT_F3H_02H) \
-__PMC_EV_ALIAS("L2_HW_PREFETCH.DATA_TRIGGER",		IAP_EVENT_F3H_04H) \
-__PMC_EV_ALIAS("L2_HW_PREFETCH.CODE_TRIGGER",		IAP_EVENT_F3H_08H) \
-__PMC_EV_ALIAS("L2_HW_PREFETCH.DCA_TRIGGER",		IAP_EVENT_F3H_10H) \
-__PMC_EV_ALIAS("L2_HW_PREFETCH.KICK_START",		IAP_EVENT_F3H_20H) \
-__PMC_EV_ALIAS("SQ_MISC.PROMOTION",			IAP_EVENT_F4H_01H) \
-__PMC_EV_ALIAS("SQ_MISC.PROMOTION_POST_GO",		IAP_EVENT_F4H_02H) \
-__PMC_EV_ALIAS("SQ_MISC.LRU_HINTS",			IAP_EVENT_F4H_04H) \
-__PMC_EV_ALIAS("SQ_MISC.FILL_DROPPED",			IAP_EVENT_F4H_08H) \
-__PMC_EV_ALIAS("SQ_MISC.SPLIT_LOCK",			IAP_EVENT_F4H_10H) \
-__PMC_EV_ALIAS("SQ_FULL_STALL_CYCLES",			IAP_EVENT_F6H_01H) \
-__PMC_EV_ALIAS("FP_ASSIST.ALL",				IAP_EVENT_F7H_01H) \
-__PMC_EV_ALIAS("FP_ASSIST.OUTPUT",			IAP_EVENT_F7H_02H) \
-__PMC_EV_ALIAS("FP_ASSIST.INPUT",			IAP_EVENT_F7H_04H) \
-__PMC_EV_ALIAS("SEGMENT_REG_LOADS",			IAP_EVENT_F8H_01H) \
-__PMC_EV_ALIAS("SIMD_INT_64.PACKED_MPY",		IAP_EVENT_FDH_01H) \
-__PMC_EV_ALIAS("SIMD_INT_64.PACKED_SHIFT",		IAP_EVENT_FDH_02H) \
-__PMC_EV_ALIAS("SIMD_INT_64.PACK",			IAP_EVENT_FDH_04H) \
-__PMC_EV_ALIAS("SIMD_INT_64.UNPACK",			IAP_EVENT_FDH_08H) \
-__PMC_EV_ALIAS("SIMD_INT_64.PACKED_LOGICAL",		IAP_EVENT_FDH_10H) \
-__PMC_EV_ALIAS("SIMD_INT_64.PACKED_ARITH",		IAP_EVENT_FDH_20H) \
-__PMC_EV_ALIAS("SIMD_INT_64.SHUFFLE_MOVE",		IAP_EVENT_FDH_40H)
+__PMC_EV_ALIAS("SB_DRAIN.ANY", 	IAP_EVENT_04H_07H)			\
+__PMC_EV_ALIAS("STORE_BLOCKS.AT_RET", IAP_EVENT_06H_04H)		\
+__PMC_EV_ALIAS("STORE_BLOCKS.L1D_BLOCK", IAP_EVENT_06H_08H)		\
+__PMC_EV_ALIAS("PARTIAL_ADDRESS_ALIAS", IAP_EVENT_07H_01H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.ANY", IAP_EVENT_08H_01H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.WALK_COMPLETED", IAP_EVENT_08H_02H)	\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.STLB_HIT", IAP_EVENT_08H_10H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.PDE_MISS", IAP_EVENT_08H_20H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.PDP_MISS", IAP_EVENT_08H_40H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.LARGE_WALK_COMPLETED",			\
+    IAP_EVENT_08H_80H) 							\
+__PMC_EV_ALIAS("MEM_INST_RETIRED.LOADS", IAP_EVENT_0BH_01H)		\
+__PMC_EV_ALIAS("MEM_INST_RETIRED.STORES", IAP_EVENT_0BH_02H)		\
+__PMC_EV_ALIAS("MEM_INST_RETIRED.LATENCY_ABOVE_THRESHOLD",		\
+    IAP_EVENT_0BH_10H) 							\
+__PMC_EV_ALIAS("MEM_STORE_RETIRED.DTLB_MISS", IAP_EVENT_0CH_01H)	\
+__PMC_EV_ALIAS("UOPS_ISSUED.ANY", IAP_EVENT_0EH_01H)			\
+__PMC_EV_ALIAS("UOPS_ISSUED.STALLED_CYCLES", IAP_EVENT_0EH_01H)		\
+__PMC_EV_ALIAS("UOPS_ISSUED.FUSED", IAP_EVENT_0EH_02H)			\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.L3_DATA_MISS_UNKNOWN",		\
+    IAP_EVENT_0FH_01H)							\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.OTHER_CORE_L2_HITM",			\
+    IAP_EVENT_0FH_02H)							\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.REMOTE_CACHE_LOCAL_HOME_HIT",	\
+    IAP_EVENT_0FH_08H)							\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.REMOTE_DRAM",			\
+    IAP_EVENT_0FH_10H)							\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.LOCAL_DRAM", IAP_EVENT_0FH_20H)	\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.UNCACHEABLE", IAP_EVENT_0FH_80H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.X87", IAP_EVENT_10H_01H)		\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.MMX", IAP_EVENT_10H_02H)		\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP", IAP_EVENT_10H_04H)		\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE2_INTEGER", IAP_EVENT_10H_08H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP_PACKED", IAP_EVENT_10H_10H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP_SCALAR", IAP_EVENT_10H_20H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_SINGLE_PRECISION",			\
+    IAP_EVENT_10H_40H)							\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_DOUBLE_PRECISION",			\
+    IAP_EVENT_10H_80H)							\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_MPY", IAP_EVENT_12H_01H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_SHIFT", IAP_EVENT_12H_02H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.PACK", IAP_EVENT_12H_04H)			\
+__PMC_EV_ALIAS("SIMD_INT_128.UNPACK", IAP_EVENT_12H_08H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_LOGICAL", IAP_EVENT_12H_10H)	\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_ARITH", IAP_EVENT_12H_20H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.SHUFFLE_MOVE", IAP_EVENT_12H_40H)		\
+__PMC_EV_ALIAS("LOAD_DISPATCH.RS", IAP_EVENT_13H_01H)			\
+__PMC_EV_ALIAS("LOAD_DISPATCH.RS_DELAYED", IAP_EVENT_13H_02H)		\
+__PMC_EV_ALIAS("LOAD_DISPATCH.MOB", IAP_EVENT_13H_04H)			\
+__PMC_EV_ALIAS("LOAD_DISPATCH.ANY", IAP_EVENT_13H_07H)			\
+__PMC_EV_ALIAS("ARITH.CYCLES_DIV_BUSY", IAP_EVENT_14H_01H)		\
+__PMC_EV_ALIAS("ARITH.MUL", IAP_EVENT_14H_02H)				\
+__PMC_EV_ALIAS("INST_QUEUE_WRITES", IAP_EVENT_17H_01H)			\
+__PMC_EV_ALIAS("INST_DECODED.DEC0", IAP_EVENT_18H_01H)			\
+__PMC_EV_ALIAS("TWO_UOP_INSTS_DECODED", IAP_EVENT_19H_01H)		\
+__PMC_EV_ALIAS("INST_QUEUE_WRITE_CYCLES", IAP_EVENT_1EH_01H)		\
+__PMC_EV_ALIAS("LSD_OVERFLOW", IAP_EVENT_20H_01H)			\
+__PMC_EV_ALIAS("L2_RQSTS.LD_HIT", IAP_EVENT_24H_01H)			\
+__PMC_EV_ALIAS("L2_RQSTS.LD_MISS", IAP_EVENT_24H_02H)			\
+__PMC_EV_ALIAS("L2_RQSTS.LOADS", IAP_EVENT_24H_03H)			\
+__PMC_EV_ALIAS("L2_RQSTS.RFO_HIT", IAP_EVENT_24H_04H)			\
+__PMC_EV_ALIAS("L2_RQSTS.RFO_MISS", IAP_EVENT_24H_08H)			\
+__PMC_EV_ALIAS("L2_RQSTS.RFOS", IAP_EVENT_24H_0CH)			\
+__PMC_EV_ALIAS("L2_RQSTS.IFETCH_HIT", IAP_EVENT_24H_10H)		\
+__PMC_EV_ALIAS("L2_RQSTS.IFETCH_MISS", IAP_EVENT_24H_20H)		\
+__PMC_EV_ALIAS("L2_RQSTS.IFETCHES", IAP_EVENT_24H_30H)			\
+__PMC_EV_ALIAS("L2_RQSTS.PREFETCH_HIT", IAP_EVENT_24H_40H)		\
+__PMC_EV_ALIAS("L2_RQSTS.PREFETCH_MISS", IAP_EVENT_24H_80H)		\
+__PMC_EV_ALIAS("L2_RQSTS.PREFETCHES", IAP_EVENT_24H_C0H)		\
+__PMC_EV_ALIAS("L2_RQSTS.MISS", IAP_EVENT_24H_AAH)			\
+__PMC_EV_ALIAS("L2_RQSTS.REFERENCES", IAP_EVENT_24H_FFH)		\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.I_STATE", IAP_EVENT_26H_01H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.S_STATE", IAP_EVENT_26H_02H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.E_STATE", IAP_EVENT_26H_04H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.M_STATE", IAP_EVENT_26H_08H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.MESI", IAP_EVENT_26H_0FH)		\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.I_STATE", IAP_EVENT_26H_10H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.S_STATE", IAP_EVENT_26H_20H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.E_STATE", IAP_EVENT_26H_40H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.M_STATE", IAP_EVENT_26H_80H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.MESI", IAP_EVENT_26H_F0H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.ANY", IAP_EVENT_26H_FFH)			\
+__PMC_EV_ALIAS("L2_WRITE.RFO.I_STATE", IAP_EVENT_27H_01H)		\
+__PMC_EV_ALIAS("L2_WRITE.RFO.S_STATE", IAP_EVENT_27H_02H)		\
+__PMC_EV_ALIAS("L2_WRITE.RFO.M_STATE", IAP_EVENT_27H_08H)		\
+__PMC_EV_ALIAS("L2_WRITE.RFO.HIT", IAP_EVENT_27H_0EH)			\
+__PMC_EV_ALIAS("L2_WRITE.RFO.MESI", IAP_EVENT_27H_0FH)			\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.I_STATE", IAP_EVENT_27H_10H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.S_STATE", IAP_EVENT_27H_20H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.E_STATE", IAP_EVENT_27H_40H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.M_STATE", IAP_EVENT_27H_80H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.HIT", IAP_EVENT_27H_E0H)			\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.MESI", IAP_EVENT_27H_F0H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.I_STATE", IAP_EVENT_28H_01H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.S_STATE", IAP_EVENT_28H_02H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.E_STATE", IAP_EVENT_28H_04H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.M_STATE", IAP_EVENT_28H_08H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.MESI", IAP_EVENT_28H_0FH)			\
+__PMC_EV_ALIAS("L3_LAT_CACHE.REFERENCE", IAP_EVENT_2EH_4FH)		\
+__PMC_EV_ALIAS("L3_LAT_CACHE.MISS", IAP_EVENT_2EH_41H)			\
+__PMC_EV_ALIAS("CPU_CLK_UNHALTED.THREAD_P", IAP_EVENT_3CH_00H)		\
+__PMC_EV_ALIAS("CPU_CLK_UNHALTED.REF_P", IAP_EVENT_3CH_01H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LD.I_STATE", IAP_EVENT_40H_01H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LD.S_STATE", IAP_EVENT_40H_02H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LD.E_STATE", IAP_EVENT_40H_04H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LD.M_STATE", IAP_EVENT_40H_08H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LD.MESI", IAP_EVENT_40H_0FH)			\
+__PMC_EV_ALIAS("L1D_CACHE_ST.S_STATE", IAP_EVENT_41H_02H)		\
+__PMC_EV_ALIAS("L1D_CACHE_ST.E_STATE", IAP_EVENT_41H_04H)		\
+__PMC_EV_ALIAS("L1D_CACHE_ST.M_STATE", IAP_EVENT_41H_08H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LOCK.HIT", IAP_EVENT_42H_01H)			\
+__PMC_EV_ALIAS("L1D_CACHE_LOCK.S_STATE", IAP_EVENT_42H_02H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LOCK.E_STATE", IAP_EVENT_42H_04H)		\
+__PMC_EV_ALIAS("L1D_CACHE_LOCK.M_STATE", IAP_EVENT_42H_08H)		\
+__PMC_EV_ALIAS("L1D_ALL_REF.ANY", IAP_EVENT_43H_01H)			\
+__PMC_EV_ALIAS("L1D_ALL_REF.CACHEABLE", IAP_EVENT_43H_02H)		\
+__PMC_EV_ALIAS("L1D_PEND_MISS.LOAD_BUFFERS_FULL", IAP_EVENT_48H_02H)	\
+__PMC_EV_ALIAS("DTLB_MISSES.ANY", IAP_EVENT_49H_01H)			\
+__PMC_EV_ALIAS("DTLB_MISSES.WALK_COMPLETED", IAP_EVENT_49H_02H)		\
+__PMC_EV_ALIAS("DTLB_MISSES.STLB_HIT", IAP_EVENT_49H_10H)		\
+__PMC_EV_ALIAS("LOAD_HIT_PRE", IAP_EVENT_4CH_01H)			\
+__PMC_EV_ALIAS("L1D_PREFETCH.REQUESTS", IAP_EVENT_4EH_01H)		\
+__PMC_EV_ALIAS("L1D_PREFETCH.MISS", IAP_EVENT_4EH_02H)			\
+__PMC_EV_ALIAS("L1D_PREFETCH.TRIGGERS", IAP_EVENT_4EH_04H)		\
+__PMC_EV_ALIAS("L1D.REPL", IAP_EVENT_51H_01H)				\
+__PMC_EV_ALIAS("L1D.M_REPL", IAP_EVENT_51H_02H)				\
+__PMC_EV_ALIAS("L1D.M_EVICT", IAP_EVENT_51H_04H)			\
+__PMC_EV_ALIAS("L1D.M_SNOOP_EVICT", IAP_EVENT_51H_08H)			\
+__PMC_EV_ALIAS("L1D_CACHE_PREFETCH_LOCK_FB_HIT", IAP_EVENT_52H_01H)	\
+__PMC_EV_ALIAS("L1D_CACHE_LOCK_FB_HIT", IAP_EVENT_53H_01H)		\
+__PMC_EV_ALIAS("CACHE_LOCK_CYCLES.L1D_L2", IAP_EVENT_63H_01H)		\
+__PMC_EV_ALIAS("CACHE_LOCK_CYCLES.L1D", IAP_EVENT_63H_02H)		\
+__PMC_EV_ALIAS("IO_TRANSACTIONS", IAP_EVENT_6CH_01H)			\
+__PMC_EV_ALIAS("L1I.HITS", IAP_EVENT_80H_01H)				\
+__PMC_EV_ALIAS("L1I.MISSES", IAP_EVENT_80H_02H)				\
+__PMC_EV_ALIAS("L1I.READS", IAP_EVENT_80H_03H)				\
+__PMC_EV_ALIAS("L1I.CYCLES_STALLED", IAP_EVENT_80H_04H)			\
+__PMC_EV_ALIAS("LARGE_ITLB.HIT", IAP_EVENT_82H_01H)			\
+__PMC_EV_ALIAS("ITLB_MISSES.ANY", IAP_EVENT_85H_01H)			\
+__PMC_EV_ALIAS("ITLB_MISSES.WALK_COMPLETED", IAP_EVENT_85H_02H)		\
+__PMC_EV_ALIAS("ILD_STALL.LCP", IAP_EVENT_87H_01H)			\
+__PMC_EV_ALIAS("ILD_STALL.MRU", IAP_EVENT_87H_02H)			\
+__PMC_EV_ALIAS("ILD_STALL.IQ_FULL", IAP_EVENT_87H_04H)			\
+__PMC_EV_ALIAS("ILD_STALL.REGEN", IAP_EVENT_87H_08H)			\
+__PMC_EV_ALIAS("ILD_STALL.ANY", IAP_EVENT_87H_0FH)			\
+__PMC_EV_ALIAS("BR_INST_EXEC.COND", IAP_EVENT_88H_01H)			\
+__PMC_EV_ALIAS("BR_INST_EXEC.DIRECT", IAP_EVENT_88H_02H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.INDIRECT_NON_CALL", IAP_EVENT_88H_04H)	\
+__PMC_EV_ALIAS("BR_INST_EXEC.NON_CALLS", IAP_EVENT_88H_07H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.RETURN_NEAR", IAP_EVENT_88H_08H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.DIRECT_NEAR_CALL", IAP_EVENT_88H_10H)	\
+__PMC_EV_ALIAS("BR_INST_EXEC.INDIRECT_NEAR_CALL", IAP_EVENT_88H_20H)	\
+__PMC_EV_ALIAS("BR_INST_EXEC.NEAR_CALLS", IAP_EVENT_88H_30H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.TAKEN", IAP_EVENT_88H_40H)			\
+__PMC_EV_ALIAS("BR_INST_EXEC.ANY", IAP_EVENT_88H_7FH)			\
+__PMC_EV_ALIAS("BR_MISP_EXEC.COND", IAP_EVENT_89H_01H)			\
+__PMC_EV_ALIAS("BR_MISP_EXEC.DIRECT", IAP_EVENT_89H_02H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.INDIRECT_NON_CALL", IAP_EVENT_89H_04H)	\
+__PMC_EV_ALIAS("BR_MISP_EXEC.NON_CALLS", IAP_EVENT_89H_07H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.RETURN_NEAR", IAP_EVENT_89H_08H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.DIRECT_NEAR_CALL", IAP_EVENT_89H_10H)	\
+__PMC_EV_ALIAS("BR_MISP_EXEC.INDIRECT_NEAR_CALL", IAP_EVENT_89H_20H)	\
+__PMC_EV_ALIAS("BR_MISP_EXEC.NEAR_CALLS", IAP_EVENT_89H_30H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.TAKEN", IAP_EVENT_89H_40H)			\
+__PMC_EV_ALIAS("BR_MISP_EXEC.ANY", IAP_EVENT_89H_7FH)			\
+__PMC_EV_ALIAS("RESOURCE_STALLS.ANY", IAP_EVENT_A2H_01H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.LOAD", IAP_EVENT_A2H_02H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.RS_FULL", IAP_EVENT_A2H_04H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.STORE", IAP_EVENT_A2H_08H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.ROB_FULL", IAP_EVENT_A2H_10H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.FPCW", IAP_EVENT_A2H_20H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.MXCSR", IAP_EVENT_A2H_40H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.OTHER", IAP_EVENT_A2H_80H)		\
+__PMC_EV_ALIAS("MACRO_INSTS.FUSIONS_DECODED", IAP_EVENT_A6H_01H)	\
+__PMC_EV_ALIAS("BACLEAR_FORCE_IQ", IAP_EVENT_A7H_01H)			\
+__PMC_EV_ALIAS("LSD.UOPS", IAP_EVENT_A8H_01H)				\
+__PMC_EV_ALIAS("ITLB_FLUSH", IAP_EVENT_AEH_01H)				\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.L1D_WRITEBACK", IAP_EVENT_B0H_40H)	\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT0", IAP_EVENT_B1H_01H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT1", IAP_EVENT_B1H_02H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT2_CORE", IAP_EVENT_B1H_04H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT3_CORE", IAP_EVENT_B1H_08H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT4_CORE", IAP_EVENT_B1H_10H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.CORE_ACTIVE_CYCLES_NO_PORT5",		\
+    IAP_EVENT_B1H_1FH)							\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT5", IAP_EVENT_B1H_20H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.CORE_ACTIVE_CYCLES", IAP_EVENT_B1H_3FH)	\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT015", IAP_EVENT_B1H_40H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT234", IAP_EVENT_B1H_80H)		\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_SQ_FULL", IAP_EVENT_B2H_01H)		\
+__PMC_EV_ALIAS("OFF_CORE_RESPONSE_0", IAP_EVENT_B7H_01H)		\
+__PMC_EV_ALIAS("SNOOP_RESPONSE.HIT", IAP_EVENT_B8H_01H)			\
+__PMC_EV_ALIAS("SNOOP_RESPONSE.HITE", IAP_EVENT_B8H_02H)		\
+__PMC_EV_ALIAS("SNOOP_RESPONSE.HITM", IAP_EVENT_B8H_04H)		\
+__PMC_EV_ALIAS("OFF_CORE_RESPONSE_1", IAP_EVENT_BBH_01H)		\
+__PMC_EV_ALIAS("INST_RETIRED.ANY_P", IAP_EVENT_C0H_01H)			\
+__PMC_EV_ALIAS("INST_RETIRED.X87", IAP_EVENT_C0H_02H)			\
+__PMC_EV_ALIAS("INST_RETIRED.MMX", IAP_EVENT_C0H_04H)			\
+__PMC_EV_ALIAS("UOPS_RETIRED.ANY", IAP_EVENT_C2H_01H)			\
+__PMC_EV_ALIAS("UOPS_RETIRED.RETIRE_SLOTS", IAP_EVENT_C2H_02H)		\
+__PMC_EV_ALIAS("UOPS_RETIRED.MACRO_FUSED", IAP_EVENT_C2H_04H)		\
+__PMC_EV_ALIAS("MACHINE_CLEARS.CYCLES", IAP_EVENT_C3H_01H)		\
+__PMC_EV_ALIAS("MACHINE_CLEARS.MEM_ORDER", IAP_EVENT_C3H_02H)		\
+__PMC_EV_ALIAS("MACHINE_CLEARS.SMC", IAP_EVENT_C3H_04H)			\
+__PMC_EV_ALIAS("BR_INST_RETIRED.ALL_BRANCHES", IAP_EVENT_C4H_00H)	\
+__PMC_EV_ALIAS("BR_INST_RETIRED.CONDITIONAL", IAP_EVENT_C4H_01H)	\
+__PMC_EV_ALIAS("BR_INST_RETIRED.NEAR_CALL", IAP_EVENT_C4H_02H)		\
+__PMC_EV_ALIAS("BR_INST_RETIRED.ALL_BRANCHES", IAP_EVENT_C4H_04H)	\
+__PMC_EV_ALIAS("BR_MISP_RETIRED.ALL_BRANCHES", IAP_EVENT_C5H_00H)	\
+__PMC_EV_ALIAS("BR_MISP_RETIRED.NEAR_CALL", IAP_EVENT_C5H_02H)		\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.PACKED_SINGLE", IAP_EVENT_C7H_01H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.SCALAR_SINGLE", IAP_EVENT_C7H_02H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.PACKED_DOUBLE", IAP_EVENT_C7H_04H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.SCALAR_DOUBLE", IAP_EVENT_C7H_08H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.VECTOR_INTEGER", IAP_EVENT_C7H_10H)	\
+__PMC_EV_ALIAS("ITLB_MISS_RETIRED", IAP_EVENT_C8H_20H)			\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L1D_HIT", IAP_EVENT_CBH_01H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L2_HIT", IAP_EVENT_CBH_02H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L3_UNSHARED_HIT", IAP_EVENT_CBH_04H)	\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.OTHER_CORE_L2_HIT_HITM",		\
+    IAP_EVENT_CBH_08H)							\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L3_MISS", IAP_EVENT_CBH_10H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.HIT_LFB", IAP_EVENT_CBH_40H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.DTLB_MISS", IAP_EVENT_CBH_80H)		\
+__PMC_EV_ALIAS("FP_MMX_TRANS.TO_FP", IAP_EVENT_CCH_01H)			\
+__PMC_EV_ALIAS("FP_MMX_TRANS.TO_MMX", IAP_EVENT_CCH_02H)		\
+__PMC_EV_ALIAS("FP_MMX_TRANS.ANY", IAP_EVENT_CCH_03H)			\
+__PMC_EV_ALIAS("MACRO_INSTS.DECODED", IAP_EVENT_D0H_01H)		\
+__PMC_EV_ALIAS("UOPS_DECODED.MS", IAP_EVENT_D1H_02H)			\
+__PMC_EV_ALIAS("UOPS_DECODED.ESP_FOLDING", IAP_EVENT_D1H_04H)		\
+__PMC_EV_ALIAS("UOPS_DECODED.ESP_SYNC", IAP_EVENT_D1H_08H)		\
+__PMC_EV_ALIAS("RAT_STALLS.FLAGS", IAP_EVENT_D2H_01H)			\
+__PMC_EV_ALIAS("RAT_STALLS.REGISTERS", IAP_EVENT_D2H_02H)		\
+__PMC_EV_ALIAS("RAT_STALLS.ROB_READ_PORT", IAP_EVENT_D2H_04H)		\
+__PMC_EV_ALIAS("RAT_STALLS.SCOREBOARD", IAP_EVENT_D2H_08H)		\
+__PMC_EV_ALIAS("RAT_STALLS.ANY", IAP_EVENT_D2H_0FH)			\
+__PMC_EV_ALIAS("SEG_RENAME_STALLS", IAP_EVENT_D4H_01H)			\
+__PMC_EV_ALIAS("ES_REG_RENAMES", IAP_EVENT_D5H_01H)			\
+__PMC_EV_ALIAS("UOP_UNFUSION", IAP_EVENT_DBH_01H)			\
+__PMC_EV_ALIAS("BR_INST_DECODED", IAP_EVENT_E0H_01H)			\
+__PMC_EV_ALIAS("BPU_MISSED_CALL_RET", IAP_EVENT_E5H_01H)		\
+__PMC_EV_ALIAS("BACLEAR.CLEAR", IAP_EVENT_E6H_01H)			\
+__PMC_EV_ALIAS("BACLEAR.BAD_TARGET", IAP_EVENT_E6H_02H)			\
+__PMC_EV_ALIAS("BPU_CLEARS.EARLY", IAP_EVENT_E8H_01H)			\
+__PMC_EV_ALIAS("BPU_CLEARS.LATE", IAP_EVENT_E8H_02H)			\
+__PMC_EV_ALIAS("BPU_CLEARS.ANY", IAP_EVENT_E8H_03H)			\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.LOAD", IAP_EVENT_F0H_01H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.RFO", IAP_EVENT_F0H_02H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.IFETCH", IAP_EVENT_F0H_04H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.PREFETCH", IAP_EVENT_F0H_08H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.L1D_WB", IAP_EVENT_F0H_10H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.FILL", IAP_EVENT_F0H_20H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.WB", IAP_EVENT_F0H_40H)			\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.ANY", IAP_EVENT_F0H_80H)		\
+__PMC_EV_ALIAS("L2_LINES_IN.S_STATE", IAP_EVENT_F1H_02H)		\
+__PMC_EV_ALIAS("L2_LINES_IN.E_STATE", IAP_EVENT_F1H_04H)		\
+__PMC_EV_ALIAS("L2_LINES_IN.ANY", IAP_EVENT_F1H_07H)			\
+__PMC_EV_ALIAS("L2_LINES_OUT.DEMAND_CLEAN", IAP_EVENT_F2H_01H)		\
+__PMC_EV_ALIAS("L2_LINES_OUT.DEMAND_DIRTY", IAP_EVENT_F2H_02H)		\
+__PMC_EV_ALIAS("L2_LINES_OUT.PREFETCH_CLEAN", IAP_EVENT_F2H_04H)	\
+__PMC_EV_ALIAS("L2_LINES_OUT.PREFETCH_DIRTY", IAP_EVENT_F2H_08H)	\
+__PMC_EV_ALIAS("L2_LINES_OUT.ANY", IAP_EVENT_F2H_0FH)			\
+__PMC_EV_ALIAS("SQ_MISC.SPLIT_LOCK", IAP_EVENT_F4H_10H)			\
+__PMC_EV_ALIAS("SQ_FULL_STALL_CYCLES", IAP_EVENT_F6H_01H)		\
+__PMC_EV_ALIAS("FP_ASSIST.ALL", IAP_EVENT_F7H_01H)			\
+__PMC_EV_ALIAS("FP_ASSIST.OUTPUT", IAP_EVENT_F7H_02H)			\
+__PMC_EV_ALIAS("FP_ASSIST.INPUT", IAP_EVENT_F7H_04H)			\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_MPY", IAP_EVENT_FDH_01H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_SHIFT", IAP_EVENT_FDH_02H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.PACK", IAP_EVENT_FDH_04H)			\
+__PMC_EV_ALIAS("SIMD_INT_64.UNPACK", IAP_EVENT_FDH_08H)			\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_LOGICAL", IAP_EVENT_FDH_10H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_ARITH", IAP_EVENT_FDH_20H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.SHUFFLE_MOVE", IAP_EVENT_FDH_40H)		\
+__PMC_EV_ALIAS_COREI7_OLD()
+
+/*
+ * Aliases for Westmere PMC events (253669-033US December 2009)
+ */
+#define	__PMC_EV_ALIAS_WESTMERE()					\
+__PMC_EV_ALIAS_INTEL_ARCHITECTURAL()					\
+__PMC_EV_ALIAS("LOAD_BLOCK.OVERLAP_STORE", IAP_EVENT_03H_02H)		\
+__PMC_EV_ALIAS("SB_DRAIN.ANY", IAP_EVENT_04H_07H)			\
+__PMC_EV_ALIAS("MISALIGN_MEMORY.STORE", IAP_EVENT_05H_02H)		\
+__PMC_EV_ALIAS("STORE_BLOCKS.AT_RET", IAP_EVENT_06H_04H)		\
+__PMC_EV_ALIAS("STORE_BLOCKS.L1D_BLOCK", IAP_EVENT_06H_08H)		\
+__PMC_EV_ALIAS("PARTIAL_ADDRESS_ALIAS", IAP_EVENT_07H_01H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.ANY", IAP_EVENT_08H_01H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.WALK_COMPLETED", IAP_EVENT_08H_02H)	\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.WALK_CYCLES", IAP_EVENT_08H_04H)	\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.STLB_HIT", IAP_EVENT_08H_10H)		\
+__PMC_EV_ALIAS("DTLB_LOAD_MISSES.PDE_MISS", IAP_EVENT_08H_20H)		\
+__PMC_EV_ALIAS("MEM_INST_RETIRED.LOADS", IAP_EVENT_0BH_01H)		\
+__PMC_EV_ALIAS("MEM_INST_RETIRED.STORES", IAP_EVENT_0BH_02H)		\
+__PMC_EV_ALIAS("MEM_INST_RETIRED.LATENCY_ABOVE_THRESHOLD",		\
+    IAP_EVENT_0BH_10H)							\
+__PMC_EV_ALIAS("MEM_STORE_RETIRED.DTLB_MISS", IAP_EVENT_0CH_01H)	\
+__PMC_EV_ALIAS("UOPS_ISSUED.ANY", IAP_EVENT_0EH_01H)			\
+__PMC_EV_ALIAS("UOPS_ISSUED.STALLED_CYCLES", IAP_EVENT_0EH_01H)		\
+__PMC_EV_ALIAS("UOPS_ISSUED.FUSED", IAP_EVENT_0EH_02H)			\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.LOCAL_HITM", IAP_EVENT_0FH_02H)	\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.LOCAL_DRAM_AND_REMOTE_CACHE_HIT",	\
+    IAP_EVENT_0FH_08H)							\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.LOCAL_DRAM", IAP_EVENT_0FH_10H)	\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.REMOTE_DRAM", IAP_EVENT_0FH_20H)	\
+__PMC_EV_ALIAS("MEM_UNCORE_RETIRED.UNCACHEABLE", IAP_EVENT_0FH_80H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.X87", IAP_EVENT_10H_01H)		\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.MMX", IAP_EVENT_10H_02H)		\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP", IAP_EVENT_10H_04H)		\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE2_INTEGER", IAP_EVENT_10H_08H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP_PACKED", IAP_EVENT_10H_10H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_FP_SCALAR", IAP_EVENT_10H_20H)	\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_SINGLE_PRECISION",			\
+    IAP_EVENT_10H_40H) 							\
+__PMC_EV_ALIAS("FP_COMP_OPS_EXE.SSE_DOUBLE_PRECISION",			\
+    IAP_EVENT_10H_80H)							\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_MPY", IAP_EVENT_12H_01H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_SHIFT", IAP_EVENT_12H_02H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.PACK", IAP_EVENT_12H_04H)			\
+__PMC_EV_ALIAS("SIMD_INT_128.UNPACK", IAP_EVENT_12H_08H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_LOGICAL", IAP_EVENT_12H_10H)	\
+__PMC_EV_ALIAS("SIMD_INT_128.PACKED_ARITH", IAP_EVENT_12H_20H)		\
+__PMC_EV_ALIAS("SIMD_INT_128.SHUFFLE_MOVE", IAP_EVENT_12H_40H)		\
+__PMC_EV_ALIAS("LOAD_DISPATCH.RS", IAP_EVENT_13H_01H)			\
+__PMC_EV_ALIAS("LOAD_DISPATCH.RS_DELAYED", IAP_EVENT_13H_02H)		\
+__PMC_EV_ALIAS("LOAD_DISPATCH.MOB", IAP_EVENT_13H_04H)			\
+__PMC_EV_ALIAS("LOAD_DISPATCH.ANY", IAP_EVENT_13H_07H)			\
+__PMC_EV_ALIAS("ARITH.CYCLES_DIV_BUSY", IAP_EVENT_14H_01H)		\
+__PMC_EV_ALIAS("ARITH.MUL", IAP_EVENT_14H_02H)				\
+__PMC_EV_ALIAS("INST_QUEUE_WRITES", IAP_EVENT_17H_01H)			\
+__PMC_EV_ALIAS("INST_DECODED.DEC0", IAP_EVENT_18H_01H)			\
+__PMC_EV_ALIAS("TWO_UOP_INSTS_DECODED", IAP_EVENT_19H_01H)		\
+__PMC_EV_ALIAS("INST_QUEUE_WRITE_CYCLES", IAP_EVENT_1EH_01H)		\
+__PMC_EV_ALIAS("LSD_OVERFLOW", IAP_EVENT_20H_01H)			\
+__PMC_EV_ALIAS("L2_RQSTS.LD_HIT", IAP_EVENT_24H_01H)			\
+__PMC_EV_ALIAS("L2_RQSTS.LD_MISS", IAP_EVENT_24H_02H)			\
+__PMC_EV_ALIAS("L2_RQSTS.LOADS", IAP_EVENT_24H_03H)			\
+__PMC_EV_ALIAS("L2_RQSTS.RFO_HIT", IAP_EVENT_24H_04H)			\
+__PMC_EV_ALIAS("L2_RQSTS.RFO_MISS", IAP_EVENT_24H_08H)			\
+__PMC_EV_ALIAS("L2_RQSTS.RFOS", IAP_EVENT_24H_0CH)			\
+__PMC_EV_ALIAS("L2_RQSTS.IFETCH_HIT", IAP_EVENT_24H_10H)		\
+__PMC_EV_ALIAS("L2_RQSTS.IFETCH_MISS", IAP_EVENT_24H_20H)		\
+__PMC_EV_ALIAS("L2_RQSTS.IFETCHES", IAP_EVENT_24H_30H)			\
+__PMC_EV_ALIAS("L2_RQSTS.PREFETCH_HIT", IAP_EVENT_24H_40H)		\
+__PMC_EV_ALIAS("L2_RQSTS.PREFETCH_MISS", IAP_EVENT_24H_80H)		\
+__PMC_EV_ALIAS("L2_RQSTS.PREFETCHES", IAP_EVENT_24H_C0H)		\
+__PMC_EV_ALIAS("L2_RQSTS.MISS", IAP_EVENT_24H_AAH)			\
+__PMC_EV_ALIAS("L2_RQSTS.REFERENCES", IAP_EVENT_24H_FFH)		\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.I_STATE", IAP_EVENT_26H_01H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.S_STATE", IAP_EVENT_26H_02H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.E_STATE", IAP_EVENT_26H_04H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.M_STATE", IAP_EVENT_26H_08H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.DEMAND.MESI", IAP_EVENT_26H_0FH)		\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.I_STATE", IAP_EVENT_26H_10H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.S_STATE", IAP_EVENT_26H_20H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.E_STATE", IAP_EVENT_26H_40H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.M_STATE", IAP_EVENT_26H_80H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.PREFETCH.MESI", IAP_EVENT_26H_F0H)	\
+__PMC_EV_ALIAS("L2_DATA_RQSTS.ANY", IAP_EVENT_26H_FFH)			\
+__PMC_EV_ALIAS("L2_WRITE.RFO.I_STATE", IAP_EVENT_27H_01H)		\
+__PMC_EV_ALIAS("L2_WRITE.RFO.S_STATE", IAP_EVENT_27H_02H)		\
+__PMC_EV_ALIAS("L2_WRITE.RFO.M_STATE", IAP_EVENT_27H_08H)		\
+__PMC_EV_ALIAS("L2_WRITE.RFO.HIT", IAP_EVENT_27H_0EH)			\
+__PMC_EV_ALIAS("L2_WRITE.RFO.MESI", IAP_EVENT_27H_0FH)			\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.I_STATE", IAP_EVENT_27H_10H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.S_STATE", IAP_EVENT_27H_20H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.E_STATE", IAP_EVENT_27H_40H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.M_STATE", IAP_EVENT_27H_80H)		\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.HIT", IAP_EVENT_27H_E0H)			\
+__PMC_EV_ALIAS("L2_WRITE.LOCK.MESI", IAP_EVENT_27H_F0H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.I_STATE", IAP_EVENT_28H_01H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.S_STATE", IAP_EVENT_28H_02H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.E_STATE", IAP_EVENT_28H_04H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.M_STATE", IAP_EVENT_28H_08H)			\
+__PMC_EV_ALIAS("L1D_WB_L2.MESI", IAP_EVENT_28H_0FH)			\
+__PMC_EV_ALIAS("L3_LAT_CACHE.REFERENCE", IAP_EVENT_2EH_02H)		\
+__PMC_EV_ALIAS("L3_LAT_CACHE.MISS", IAP_EVENT_2EH_01H)			\
+__PMC_EV_ALIAS("CPU_CLK_UNHALTED.THREAD_P", IAP_EVENT_3CH_00H)		\
+__PMC_EV_ALIAS("CPU_CLK_UNHALTED.REF_P", IAP_EVENT_3CH_01H)		\
+__PMC_EV_ALIAS("DTLB_MISSES.ANY", IAP_EVENT_49H_01H)			\
+__PMC_EV_ALIAS("DTLB_MISSES.WALK_COMPLETED", IAP_EVENT_49H_02H)		\
+__PMC_EV_ALIAS("DTLB_MISSES.WALK_CYCLES", IAP_EVENT_49H_04H)		\
+__PMC_EV_ALIAS("DTLB_MISSES.STLB_HIT", IAP_EVENT_49H_10H)		\
+__PMC_EV_ALIAS("DTLB_MISSES.LARGE_WALK_COMPLETED", IAP_EVENT_49H_80H)	\
+__PMC_EV_ALIAS("LOAD_HIT_PRE", IAP_EVENT_4CH_01H)			\
+__PMC_EV_ALIAS("L1D_PREFETCH.REQUESTS", IAP_EVENT_4EH_01H)		\
+__PMC_EV_ALIAS("L1D_PREFETCH.MISS", IAP_EVENT_4EH_02H)			\
+__PMC_EV_ALIAS("L1D_PREFETCH.TRIGGERS", IAP_EVENT_4EH_04H)		\
+__PMC_EV_ALIAS("EPT.WALK_CYCLES", IAP_EVENT_4FH_10H)			\
+__PMC_EV_ALIAS("L1D.REPL", IAP_EVENT_51H_01H)				\
+__PMC_EV_ALIAS("L1D.M_REPL", IAP_EVENT_51H_02H)				\
+__PMC_EV_ALIAS("L1D.M_EVICT", IAP_EVENT_51H_04H)			\
+__PMC_EV_ALIAS("L1D.M_SNOOP_EVICT", IAP_EVENT_51H_08H)			\
+__PMC_EV_ALIAS("L1D_CACHE_PREFETCH_LOCK_FB_HIT", IAP_EVENT_52H_01H)	\
+__PMC_EV_ALIAS("L1D_CACHE_LOCK_FB_HIT", IAP_EVENT_53H_01H)		\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.READ_DATA",		\
+    IAP_EVENT_60H_01H)							\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.READ_CODE",		\
+    IAP_EVENT_60H_02H)							\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.DEMAND.RFO",		\
+    IAP_EVENT_60H_04H)							\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_OUTSTANDING.ANY.READ",			\
+    IAP_EVENT_60H_08H)							\
+__PMC_EV_ALIAS("CACHE_LOCK_CYCLES.L1D_L2", IAP_EVENT_63H_01H)		\
+__PMC_EV_ALIAS("CACHE_LOCK_CYCLES.L1D", IAP_EVENT_63H_02H)		\
+__PMC_EV_ALIAS("IO_TRANSACTIONS", IAP_EVENT_6CH_01H)			\
+__PMC_EV_ALIAS("L1I.HITS", IAP_EVENT_80H_01H)				\
+__PMC_EV_ALIAS("L1I.MISSES", IAP_EVENT_80H_02H)				\
+__PMC_EV_ALIAS("L1I.READS", IAP_EVENT_80H_03H)				\
+__PMC_EV_ALIAS("L1I.CYCLES_STALLED", IAP_EVENT_80H_04H)			\
+__PMC_EV_ALIAS("LARGE_ITLB.HIT", IAP_EVENT_82H_01H)			\
+__PMC_EV_ALIAS("ITLB_MISSES.ANY", IAP_EVENT_85H_01H)			\
+__PMC_EV_ALIAS("ITLB_MISSES.WALK_COMPLETED", IAP_EVENT_85H_02H)		\
+__PMC_EV_ALIAS("ITLB_MISSES.WALK_CYCLES", IAP_EVENT_85H_04H)		\
+__PMC_EV_ALIAS("ITLB_MISSES.LARGE_WALK_COMPLETED", IAP_EVENT_85H_80H)	\
+__PMC_EV_ALIAS("ILD_STALL.LCP", IAP_EVENT_87H_01H)			\
+__PMC_EV_ALIAS("ILD_STALL.MRU", IAP_EVENT_87H_02H)			\
+__PMC_EV_ALIAS("ILD_STALL.IQ_FULL", IAP_EVENT_87H_04H)			\
+__PMC_EV_ALIAS("ILD_STALL.REGEN", IAP_EVENT_87H_08H)			\
+__PMC_EV_ALIAS("ILD_STALL.ANY", IAP_EVENT_87H_0FH)			\
+__PMC_EV_ALIAS("BR_INST_EXEC.COND", IAP_EVENT_88H_01H)			\
+__PMC_EV_ALIAS("BR_INST_EXEC.DIRECT", IAP_EVENT_88H_02H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.INDIRECT_NON_CALL", IAP_EVENT_88H_04H)	\
+__PMC_EV_ALIAS("BR_INST_EXEC.NON_CALLS", IAP_EVENT_88H_07H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.RETURN_NEAR", IAP_EVENT_88H_08H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.DIRECT_NEAR_CALL", IAP_EVENT_88H_10H)	\
+__PMC_EV_ALIAS("BR_INST_EXEC.INDIRECT_NEAR_CALL", IAP_EVENT_88H_20H)	\
+__PMC_EV_ALIAS("BR_INST_EXEC.NEAR_CALLS", IAP_EVENT_88H_30H)		\
+__PMC_EV_ALIAS("BR_INST_EXEC.TAKEN", IAP_EVENT_88H_40H)			\
+__PMC_EV_ALIAS("BR_INST_EXEC.ANY", IAP_EVENT_88H_7FH)			\
+__PMC_EV_ALIAS("BR_MISP_EXEC.COND", IAP_EVENT_89H_01H)			\
+__PMC_EV_ALIAS("BR_MISP_EXEC.DIRECT", IAP_EVENT_89H_02H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.INDIRECT_NON_CALL", IAP_EVENT_89H_04H)	\
+__PMC_EV_ALIAS("BR_MISP_EXEC.NON_CALLS", IAP_EVENT_89H_07H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.RETURN_NEAR", IAP_EVENT_89H_08H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.DIRECT_NEAR_CALL", IAP_EVENT_89H_10H)	\
+__PMC_EV_ALIAS("BR_MISP_EXEC.INDIRECT_NEAR_CALL", IAP_EVENT_89H_20H)	\
+__PMC_EV_ALIAS("BR_MISP_EXEC.NEAR_CALLS", IAP_EVENT_89H_30H)		\
+__PMC_EV_ALIAS("BR_MISP_EXEC.TAKEN", IAP_EVENT_89H_40H)			\
+__PMC_EV_ALIAS("BR_MISP_EXEC.ANY", IAP_EVENT_89H_7FH)			\
+__PMC_EV_ALIAS("RESOURCE_STALLS.ANY", IAP_EVENT_A2H_01H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.LOAD", IAP_EVENT_A2H_02H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.RS_FULL", IAP_EVENT_A2H_04H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.STORE", IAP_EVENT_A2H_08H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.ROB_FULL", IAP_EVENT_A2H_10H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.FPCW", IAP_EVENT_A2H_20H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.MXCSR", IAP_EVENT_A2H_40H)		\
+__PMC_EV_ALIAS("RESOURCE_STALLS.OTHER", IAP_EVENT_A2H_80H)		\
+__PMC_EV_ALIAS("MACRO_INSTS.FUSIONS_DECODED", IAP_EVENT_A6H_01H)	\
+__PMC_EV_ALIAS("BACLEAR_FORCE_IQ", IAP_EVENT_A7H_01H)			\
+__PMC_EV_ALIAS("LSD.UOPS", IAP_EVENT_A8H_01H)				\
+__PMC_EV_ALIAS("ITLB_FLUSH", IAP_EVENT_AEH_01H)				\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.READ_DATA", IAP_EVENT_B0H_01H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.READ_CODE", IAP_EVENT_B0H_02H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.DEMAND.RFO", IAP_EVENT_B0H_04H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY.READ", IAP_EVENT_B0H_08H)		\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY.RFO", IAP_EVENT_80H_10H)		\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.L1D_WRITEBACK", IAP_EVENT_B0H_40H)	\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS.ANY", IAP_EVENT_B0H_80H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT0", IAP_EVENT_B1H_01H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT1", IAP_EVENT_B1H_02H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT2_CORE", IAP_EVENT_B1H_04H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT3_CORE", IAP_EVENT_B1H_08H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT4_CORE", IAP_EVENT_B1H_10H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.CORE_ACTIVE_CYCLES_NO_PORT5",		\
+    IAP_EVENT_B1H_1FH)							\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT5", IAP_EVENT_B1H_20H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.CORE_ACTIVE_CYCLES", IAP_EVENT_B1H_3FH)	\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT015", IAP_EVENT_B1H_40H)		\
+__PMC_EV_ALIAS("UOPS_EXECUTED.PORT234", IAP_EVENT_B1H_80H)		\
+__PMC_EV_ALIAS("OFFCORE_REQUESTS_SQ_FULL", IAP_EVENT_B2H_01H)		\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.DATA", IAP_EVENT_B3H_01H)	\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.INVALIDATE",		\
+    IAP_EVENT_B3H_02H)							\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS_OUTSTANDING.CODE", IAP_EVENT_B3H_04H)	\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS.CODE", IAP_EVENT_B4H_01H)		\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS.DATA", IAP_EVENT_B4H_02H)		\
+__PMC_EV_ALIAS("SNOOPQ_REQUESTS.INVALIDATE", IAP_EVENT_B4H_04H)		\
+__PMC_EV_ALIAS("OFF_CORE_RESPONSE_0", IAP_EVENT_B7H_01H)		\
+__PMC_EV_ALIAS("SNOOP_RESPONSE.HIT", IAP_EVENT_B8H_01H)			\
+__PMC_EV_ALIAS("SNOOP_RESPONSE.HITE", IAP_EVENT_B8H_02H)		\
+__PMC_EV_ALIAS("SNOOP_RESPONSE.HITM", IAP_EVENT_B8H_04H)		\
+__PMC_EV_ALIAS("OFF_CORE_RESPONSE_1", IAP_EVENT_BBH_01H)		\
+__PMC_EV_ALIAS("INST_RETIRED.ANY_P", IAP_EVENT_C0H_01H)			\
+__PMC_EV_ALIAS("INST_RETIRED.X87", IAP_EVENT_C0H_02H)			\
+__PMC_EV_ALIAS("INST_RETIRED.MMX", IAP_EVENT_C0H_04H)			\
+__PMC_EV_ALIAS("UOPS_RETIRED.ANY", IAP_EVENT_C2H_01H)			\
+__PMC_EV_ALIAS("UOPS_RETIRED.RETIRE_SLOTS", IAP_EVENT_C2H_02H)		\
+__PMC_EV_ALIAS("UOPS_RETIRED.MACRO_FUSED", IAP_EVENT_C2H_04H)		\
+__PMC_EV_ALIAS("MACHINE_CLEARS.CYCLES", IAP_EVENT_C3H_01H)		\
+__PMC_EV_ALIAS("MACHINE_CLEARS.MEM_ORDER", IAP_EVENT_C3H_02H)		\
+__PMC_EV_ALIAS("MACHINE_CLEARS.SMC", IAP_EVENT_C3H_04H)			\
+__PMC_EV_ALIAS("BR_INST_RETIRED.ALL_BRANCHES", IAP_EVENT_C4H_00H)	\
+__PMC_EV_ALIAS("BR_INST_RETIRED.CONDITIONAL", IAP_EVENT_C4H_01H)	\
+__PMC_EV_ALIAS("BR_INST_RETIRED.NEAR_CALL", IAP_EVENT_C4H_02H)		\
+__PMC_EV_ALIAS("BR_INST_RETIRED.ALL_BRANCHES", IAP_EVENT_C4H_04H)	\
+__PMC_EV_ALIAS("BR_MISP_RETIRED.ALL_BRANCHES", IAP_EVENT_C5H_00H)	\
+__PMC_EV_ALIAS("BR_MISP_RETIRED.CONDITIONAL", IAP_EVENT_C5H_01H)	\
+__PMC_EV_ALIAS("BR_MISP_RETIRED.NEAR_CALL", IAP_EVENT_C5H_02H)		\
+__PMC_EV_ALIAS("BR_MISP_RETIRED.ALL_BRANCHES", IAP_EVENT_C5H_04H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.PACKED_SINGLE", IAP_EVENT_C7H_01H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.SCALAR_SINGLE", IAP_EVENT_C7H_02H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.PACKED_DOUBLE", IAP_EVENT_C7H_04H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.SCALAR_DOUBLE", IAP_EVENT_C7H_08H)	\
+__PMC_EV_ALIAS("SSEX_UOPS_RETIRED.VECTOR_INTEGER", IAP_EVENT_C7H_10H)	\
+__PMC_EV_ALIAS("ITLB_MISS_RETIRED", IAP_EVENT_C8H_20H)			\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L1D_HIT", IAP_EVENT_CBH_01H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L2_HIT", IAP_EVENT_CBH_02H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L3_UNSHARED_HIT", IAP_EVENT_CBH_04H)	\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.OTHER_CORE_L2_HIT_HITM",		\
+    IAP_EVENT_CBH_08H)							\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.L3_MISS", IAP_EVENT_CBH_10H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.HIT_LFB", IAP_EVENT_CBH_40H)		\
+__PMC_EV_ALIAS("MEM_LOAD_RETIRED.DTLB_MISS", IAP_EVENT_CBH_80H)		\
+__PMC_EV_ALIAS("FP_MMX_TRANS.TO_FP", IAP_EVENT_CCH_01H)			\
+__PMC_EV_ALIAS("FP_MMX_TRANS.TO_MMX", IAP_EVENT_CCH_02H)		\
+__PMC_EV_ALIAS("FP_MMX_TRANS.ANY", IAP_EVENT_CCH_03H)			\
+__PMC_EV_ALIAS("MACRO_INSTS.DECODED", IAP_EVENT_D0H_01H)		\
+__PMC_EV_ALIAS("UOPS_DECODED.STALL_CYCLES", IAP_EVENT_D1H_01H)		\
+__PMC_EV_ALIAS("UOPS_DECODED.MS", IAP_EVENT_D1H_02H)			\
+__PMC_EV_ALIAS("UOPS_DECODED.ESP_FOLDING", IAP_EVENT_D1H_04H)		\
+__PMC_EV_ALIAS("UOPS_DECODED.ESP_SYNC", IAP_EVENT_D1H_08H)		\
+__PMC_EV_ALIAS("RAT_STALLS.FLAGS", IAP_EVENT_D2H_01H)			\
+__PMC_EV_ALIAS("RAT_STALLS.REGISTERS", IAP_EVENT_D2H_02H)		\
+__PMC_EV_ALIAS("RAT_STALLS.ROB_READ_PORT", IAP_EVENT_D2H_04H)		\
+__PMC_EV_ALIAS("RAT_STALLS.SCOREBOARD", IAP_EVENT_D2H_08H)		\
+__PMC_EV_ALIAS("RAT_STALLS.ANY", IAP_EVENT_D2H_0FH)			\
+__PMC_EV_ALIAS("SEG_RENAME_STALLS", IAP_EVENT_D4H_01H)			\
+__PMC_EV_ALIAS("ES_REG_RENAMES", IAP_EVENT_D5H_01H)			\
+__PMC_EV_ALIAS("UOP_UNFUSION", IAP_EVENT_DBH_01H)			\
+__PMC_EV_ALIAS("BR_INST_DECODED", IAP_EVENT_E0H_01H)			\
+__PMC_EV_ALIAS("BPU_MISSED_CALL_RET", IAP_EVENT_E5H_01H)		\
+__PMC_EV_ALIAS("BACLEAR.CLEAR", IAP_EVENT_E6H_01H)			\
+__PMC_EV_ALIAS("BACLEAR.BAD_TARGET", IAP_EVENT_E6H_02H)			\
+__PMC_EV_ALIAS("BPU_CLEARS.EARLY", IAP_EVENT_E8H_01H)			\
+__PMC_EV_ALIAS("BPU_CLEARS.LATE", IAP_EVENT_E8H_02H)			\
+__PMC_EV_ALIAS("THREAD_ACTIVE", IAP_EVENT_ECH_01H)			\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.LOAD", IAP_EVENT_F0H_01H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.RFO", IAP_EVENT_F0H_02H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.IFETCH", IAP_EVENT_F0H_04H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.PREFETCH", IAP_EVENT_F0H_08H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.L1D_WB", IAP_EVENT_F0H_10H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.FILL", IAP_EVENT_F0H_20H)		\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.WB", IAP_EVENT_F0H_40H)			\
+__PMC_EV_ALIAS("L2_TRANSACTIONS.ANY", IAP_EVENT_F0H_80H)		\
+__PMC_EV_ALIAS("L2_LINES_IN.S_STATE", IAP_EVENT_F1H_02H)		\
+__PMC_EV_ALIAS("L2_LINES_IN.E_STATE", IAP_EVENT_F1H_04H)		\
+__PMC_EV_ALIAS("L2_LINES_IN.ANY", IAP_EVENT_F1H_07H)			\
+__PMC_EV_ALIAS("L2_LINES_OUT.DEMAND_CLEAN", IAP_EVENT_F2H_01H)		\
+__PMC_EV_ALIAS("L2_LINES_OUT.DEMAND_DIRTY", IAP_EVENT_F2H_02H)		\
+__PMC_EV_ALIAS("L2_LINES_OUT.PREFETCH_CLEAN", IAP_EVENT_F2H_04H)	\
+__PMC_EV_ALIAS("L2_LINES_OUT.PREFETCH_DIRTY", IAP_EVENT_F2H_08H)	\
+__PMC_EV_ALIAS("L2_LINES_OUT.ANY", IAP_EVENT_F2H_0FH)			\
+__PMC_EV_ALIAS("SQ_MISC.LRU_HINTS", IAP_EVENT_F4H_04H)			\
+__PMC_EV_ALIAS("SQ_MISC.SPLIT_LOCK", IAP_EVENT_F4H_10H)			\
+__PMC_EV_ALIAS("SQ_FULL_STALL_CYCLES", IAP_EVENT_F6H_01H)		\
+__PMC_EV_ALIAS("FP_ASSIST.ALL", IAP_EVENT_F7H_01H)			\
+__PMC_EV_ALIAS("FP_ASSIST.OUTPUT", IAP_EVENT_F7H_02H)			\
+__PMC_EV_ALIAS("FP_ASSIST.INPUT", IAP_EVENT_F7H_04H)			\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_MPY", IAP_EVENT_FDH_01H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_SHIFT", IAP_EVENT_FDH_02H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.PACK", IAP_EVENT_FDH_04H)			\
+__PMC_EV_ALIAS("SIMD_INT_64.UNPACK", IAP_EVENT_FDH_08H)			\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_LOGICAL", IAP_EVENT_FDH_10H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.PACKED_ARITH", IAP_EVENT_FDH_20H)		\
+__PMC_EV_ALIAS("SIMD_INT_64.SHUFFLE_MOVE", IAP_EVENT_FDH_40H)
 
 /* timestamp counters. */
 #define	__PMC_EV_TSC()							\
@@ -1979,6 +2325,627 @@ __PMC_EV_ALIAS("SIMD_INT_64.SHUFFLE_MOVE",		IAP_EVENT_FDH_40H)
 #define	PMC_EV_TSC_FIRST	PMC_EV_TSC_TSC
 #define	PMC_EV_TSC_LAST		PMC_EV_TSC_TSC
 
+#define	__PMC_EV_UCF()				\
+__PMC_EV(UCF, UCLOCK)
+
+#define	PMC_EV_UCF_FIRST	PMC_EV_UCF_UCLOCK
+#define	PMC_EV_UCF_LAST		PMC_EV_UCF_UCLOCK
+
+#define	__PMC_EV_UCP()				\
+__PMC_EV(UCP, EVENT_00H_01H)			\
+__PMC_EV(UCP, EVENT_00H_02H)			\
+__PMC_EV(UCP, EVENT_00H_04H)			\
+__PMC_EV(UCP, EVENT_01H_01H)			\
+__PMC_EV(UCP, EVENT_01H_02H)			\
+__PMC_EV(UCP, EVENT_01H_04H)			\
+__PMC_EV(UCP, EVENT_02H_01H)			\
+__PMC_EV(UCP, EVENT_03H_01H)			\
+__PMC_EV(UCP, EVENT_03H_02H)			\
+__PMC_EV(UCP, EVENT_03H_04H)			\
+__PMC_EV(UCP, EVENT_03H_08H)			\
+__PMC_EV(UCP, EVENT_03H_10H)			\
+__PMC_EV(UCP, EVENT_03H_20H)			\
+__PMC_EV(UCP, EVENT_03H_40H)			\
+__PMC_EV(UCP, EVENT_04H_01H)			\
+__PMC_EV(UCP, EVENT_04H_02H)			\
+__PMC_EV(UCP, EVENT_04H_04H)			\
+__PMC_EV(UCP, EVENT_04H_08H)			\
+__PMC_EV(UCP, EVENT_04H_10H)			\
+__PMC_EV(UCP, EVENT_05H_01H)			\
+__PMC_EV(UCP, EVENT_05H_02H)			\
+__PMC_EV(UCP, EVENT_05H_04H)			\
+__PMC_EV(UCP, EVENT_06H_01H)			\
+__PMC_EV(UCP, EVENT_06H_02H)			\
+__PMC_EV(UCP, EVENT_06H_04H)			\
+__PMC_EV(UCP, EVENT_06H_08H)			\
+__PMC_EV(UCP, EVENT_06H_10H)			\
+__PMC_EV(UCP, EVENT_06H_20H)			\
+__PMC_EV(UCP, EVENT_07H_01H)			\
+__PMC_EV(UCP, EVENT_07H_02H)			\
+__PMC_EV(UCP, EVENT_07H_04H)			\
+__PMC_EV(UCP, EVENT_07H_08H)			\
+__PMC_EV(UCP, EVENT_07H_10H)			\
+__PMC_EV(UCP, EVENT_07H_20H)			\
+__PMC_EV(UCP, EVENT_07H_24H)			\
+__PMC_EV(UCP, EVENT_08H_01H)			\
+__PMC_EV(UCP, EVENT_08H_02H)			\
+__PMC_EV(UCP, EVENT_08H_04H)			\
+__PMC_EV(UCP, EVENT_08H_03H)			\
+__PMC_EV(UCP, EVENT_09H_01H)			\
+__PMC_EV(UCP, EVENT_09H_02H)			\
+__PMC_EV(UCP, EVENT_09H_04H)			\
+__PMC_EV(UCP, EVENT_09H_03H)			\
+__PMC_EV(UCP, EVENT_0AH_01H)			\
+__PMC_EV(UCP, EVENT_0AH_02H)			\
+__PMC_EV(UCP, EVENT_0AH_04H)			\
+__PMC_EV(UCP, EVENT_0AH_08H)			\
+__PMC_EV(UCP, EVENT_0AH_0FH)			\
+__PMC_EV(UCP, EVENT_0BH_01H)			\
+__PMC_EV(UCP, EVENT_0BH_02H)			\
+__PMC_EV(UCP, EVENT_0BH_04H)			\
+__PMC_EV(UCP, EVENT_0BH_08H)			\
+__PMC_EV(UCP, EVENT_0BH_10H)			\
+__PMC_EV(UCP, EVENT_0BH_1FH)			\
+__PMC_EV(UCP, EVENT_0CH_01H)			\
+__PMC_EV(UCP, EVENT_0CH_02H)			\
+__PMC_EV(UCP, EVENT_0CH_04H)			\
+__PMC_EV(UCP, EVENT_0CH_08H)			\
+__PMC_EV(UCP, EVENT_20H_01H)			\
+__PMC_EV(UCP, EVENT_20H_02H)			\
+__PMC_EV(UCP, EVENT_20H_04H)			\
+__PMC_EV(UCP, EVENT_20H_08H)			\
+__PMC_EV(UCP, EVENT_20H_10H)			\
+__PMC_EV(UCP, EVENT_20H_20H)			\
+__PMC_EV(UCP, EVENT_21H_01H)			\
+__PMC_EV(UCP, EVENT_21H_02H)			\
+__PMC_EV(UCP, EVENT_21H_04H)			\
+__PMC_EV(UCP, EVENT_22H_01H)			\
+__PMC_EV(UCP, EVENT_22H_02H)			\
+__PMC_EV(UCP, EVENT_22H_04H)			\
+__PMC_EV(UCP, EVENT_23H_01H)			\
+__PMC_EV(UCP, EVENT_23H_02H)			\
+__PMC_EV(UCP, EVENT_23H_04H)			\
+__PMC_EV(UCP, EVENT_24H_02H)			\
+__PMC_EV(UCP, EVENT_24H_04H)			\
+__PMC_EV(UCP, EVENT_25H_01H)			\
+__PMC_EV(UCP, EVENT_25H_02H)			\
+__PMC_EV(UCP, EVENT_25H_04H)			\
+__PMC_EV(UCP, EVENT_26H_01H)			\
+__PMC_EV(UCP, EVENT_27H_01H)			\
+__PMC_EV(UCP, EVENT_27H_02H)			\
+__PMC_EV(UCP, EVENT_27H_04H)			\
+__PMC_EV(UCP, EVENT_27H_08H)			\
+__PMC_EV(UCP, EVENT_27H_10H)			\
+__PMC_EV(UCP, EVENT_27H_20H)			\
+__PMC_EV(UCP, EVENT_28H_01H)			\
+__PMC_EV(UCP, EVENT_28H_02H)			\
+__PMC_EV(UCP, EVENT_28H_04H)			\
+__PMC_EV(UCP, EVENT_28H_08H)			\
+__PMC_EV(UCP, EVENT_28H_10H)			\
+__PMC_EV(UCP, EVENT_28H_20H)			\
+__PMC_EV(UCP, EVENT_29H_01H)			\
+__PMC_EV(UCP, EVENT_29H_02H)			\
+__PMC_EV(UCP, EVENT_29H_04H)			\
+__PMC_EV(UCP, EVENT_29H_08H)			\
+__PMC_EV(UCP, EVENT_29H_10H)			\
+__PMC_EV(UCP, EVENT_29H_20H)			\
+__PMC_EV(UCP, EVENT_2AH_01H)			\
+__PMC_EV(UCP, EVENT_2AH_02H)			\
+__PMC_EV(UCP, EVENT_2AH_04H)			\
+__PMC_EV(UCP, EVENT_2AH_07H)			\
+__PMC_EV(UCP, EVENT_2BH_01H)			\
+__PMC_EV(UCP, EVENT_2BH_02H)			\
+__PMC_EV(UCP, EVENT_2BH_04H)			\
+__PMC_EV(UCP, EVENT_2BH_07H)			\
+__PMC_EV(UCP, EVENT_2CH_01H)			\
+__PMC_EV(UCP, EVENT_2CH_02H)			\
+__PMC_EV(UCP, EVENT_2CH_04H)			\
+__PMC_EV(UCP, EVENT_2CH_07H)			\
+__PMC_EV(UCP, EVENT_2DH_01H)			\
+__PMC_EV(UCP, EVENT_2DH_02H)			\
+__PMC_EV(UCP, EVENT_2DH_04H)			\
+__PMC_EV(UCP, EVENT_2DH_07H)			\
+__PMC_EV(UCP, EVENT_2EH_01H)			\
+__PMC_EV(UCP, EVENT_2EH_02H)			\
+__PMC_EV(UCP, EVENT_2EH_04H)			\
+__PMC_EV(UCP, EVENT_2EH_07H)			\
+__PMC_EV(UCP, EVENT_2FH_01H)			\
+__PMC_EV(UCP, EVENT_2FH_02H)			\
+__PMC_EV(UCP, EVENT_2FH_04H)			\
+__PMC_EV(UCP, EVENT_2FH_07H)			\
+__PMC_EV(UCP, EVENT_2FH_08H)			\
+__PMC_EV(UCP, EVENT_2FH_10H)			\
+__PMC_EV(UCP, EVENT_2FH_20H)			\
+__PMC_EV(UCP, EVENT_2FH_38H)			\
+__PMC_EV(UCP, EVENT_30H_01H)			\
+__PMC_EV(UCP, EVENT_30H_02H)			\
+__PMC_EV(UCP, EVENT_30H_04H)			\
+__PMC_EV(UCP, EVENT_30H_07H)			\
+__PMC_EV(UCP, EVENT_31H_01H)			\
+__PMC_EV(UCP, EVENT_31H_02H)			\
+__PMC_EV(UCP, EVENT_31H_04H)			\
+__PMC_EV(UCP, EVENT_31H_07H)			\
+__PMC_EV(UCP, EVENT_32H_01H)			\
+__PMC_EV(UCP, EVENT_32H_02H)			\
+__PMC_EV(UCP, EVENT_32H_04H)			\
+__PMC_EV(UCP, EVENT_32H_07H)			\
+__PMC_EV(UCP, EVENT_33H_01H)			\
+__PMC_EV(UCP, EVENT_33H_02H)			\
+__PMC_EV(UCP, EVENT_33H_04H)			\
+__PMC_EV(UCP, EVENT_33H_07H)			\
+__PMC_EV(UCP, EVENT_34H_01H)			\
+__PMC_EV(UCP, EVENT_34H_02H)			\
+__PMC_EV(UCP, EVENT_34H_04H)			\
+__PMC_EV(UCP, EVENT_34H_08H)			\
+__PMC_EV(UCP, EVENT_34H_10H)			\
+__PMC_EV(UCP, EVENT_34H_20H)			\
+__PMC_EV(UCP, EVENT_35H_01H)			\
+__PMC_EV(UCP, EVENT_35H_02H)			\
+__PMC_EV(UCP, EVENT_35H_04H)			\
+__PMC_EV(UCP, EVENT_40H_01H)			\
+__PMC_EV(UCP, EVENT_40H_02H)			\
+__PMC_EV(UCP, EVENT_40H_04H)			\
+__PMC_EV(UCP, EVENT_40H_08H)			\
+__PMC_EV(UCP, EVENT_40H_10H)			\
+__PMC_EV(UCP, EVENT_40H_20H)			\
+__PMC_EV(UCP, EVENT_40H_07H)			\
+__PMC_EV(UCP, EVENT_40H_38H)			\
+__PMC_EV(UCP, EVENT_41H_01H)			\
+__PMC_EV(UCP, EVENT_41H_02H)			\
+__PMC_EV(UCP, EVENT_41H_04H)			\
+__PMC_EV(UCP, EVENT_41H_08H)			\
+__PMC_EV(UCP, EVENT_41H_10H)			\
+__PMC_EV(UCP, EVENT_41H_20H)			\
+__PMC_EV(UCP, EVENT_41H_07H)			\
+__PMC_EV(UCP, EVENT_41H_38H)			\
+__PMC_EV(UCP, EVENT_42H_01H)			\
+__PMC_EV(UCP, EVENT_42H_02H)			\
+__PMC_EV(UCP, EVENT_42H_04H)			\
+__PMC_EV(UCP, EVENT_42H_08H)			\
+__PMC_EV(UCP, EVENT_43H_01H)			\
+__PMC_EV(UCP, EVENT_43H_02H)			\
+__PMC_EV(UCP, EVENT_60H_01H)			\
+__PMC_EV(UCP, EVENT_60H_02H)			\
+__PMC_EV(UCP, EVENT_60H_04H)			\
+__PMC_EV(UCP, EVENT_61H_01H)			\
+__PMC_EV(UCP, EVENT_61H_02H)			\
+__PMC_EV(UCP, EVENT_61H_04H)			\
+__PMC_EV(UCP, EVENT_62H_01H)			\
+__PMC_EV(UCP, EVENT_62H_02H)			\
+__PMC_EV(UCP, EVENT_62H_04H)			\
+__PMC_EV(UCP, EVENT_63H_01H)			\
+__PMC_EV(UCP, EVENT_63H_02H)			\
+__PMC_EV(UCP, EVENT_63H_04H)			\
+__PMC_EV(UCP, EVENT_63H_08H)			\
+__PMC_EV(UCP, EVENT_63H_10H)			\
+__PMC_EV(UCP, EVENT_63H_20H)			\
+__PMC_EV(UCP, EVENT_64H_01H)			\
+__PMC_EV(UCP, EVENT_64H_02H)			\
+__PMC_EV(UCP, EVENT_64H_04H)			\
+__PMC_EV(UCP, EVENT_64H_08H)			\
+__PMC_EV(UCP, EVENT_64H_10H)			\
+__PMC_EV(UCP, EVENT_64H_20H)			\
+__PMC_EV(UCP, EVENT_65H_01H)			\
+__PMC_EV(UCP, EVENT_65H_02H)			\
+__PMC_EV(UCP, EVENT_65H_04H)			\
+__PMC_EV(UCP, EVENT_66H_01H)			\
+__PMC_EV(UCP, EVENT_66H_02H)			\
+__PMC_EV(UCP, EVENT_66H_04H)			\
+__PMC_EV(UCP, EVENT_67H_01H)			\
+__PMC_EV(UCP, EVENT_80H_01H)			\
+__PMC_EV(UCP, EVENT_80H_02H)			\
+__PMC_EV(UCP, EVENT_80H_04H)			\
+__PMC_EV(UCP, EVENT_80H_08H)			\
+__PMC_EV(UCP, EVENT_81H_01H)			\
+__PMC_EV(UCP, EVENT_81H_02H)			\
+__PMC_EV(UCP, EVENT_81H_04H)			\
+__PMC_EV(UCP, EVENT_81H_08H)			\
+__PMC_EV(UCP, EVENT_82H_01H)			\
+__PMC_EV(UCP, EVENT_83H_01H)			\
+__PMC_EV(UCP, EVENT_83H_02H)			\
+__PMC_EV(UCP, EVENT_83H_04H)			\
+__PMC_EV(UCP, EVENT_83H_08H)			\
+__PMC_EV(UCP, EVENT_84H_01H)			\
+__PMC_EV(UCP, EVENT_84H_02H)			\
+__PMC_EV(UCP, EVENT_84H_04H)			\
+__PMC_EV(UCP, EVENT_84H_08H)			\
+__PMC_EV(UCP, EVENT_85H_02H)			\
+__PMC_EV(UCP, EVENT_86H_01H)
+
+#define	PMC_EV_UCP_FIRST	PMC_EV_UCP_EVENT_00H_01H
+#define	PMC_EV_UCP_LAST		PMC_EV_UCP_EVENT_86H_01H
+
+#define	__PMC_EV_ALIAS_COREI7UC()					\
+__PMC_EV_ALIAS("GQ_CYCLES_FULL.READ_TRACKER", UCP_EVENT_00H_01H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_FULL.WRITE_TRACKER", UCP_EVENT_00H_02H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_FULL.PEER_PROBE_TRACKER", UCP_EVENT_00H_04H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_NOT_EMPTY.READ_TRACKER", UCP_EVENT_01H_01H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_NOT_EMPTY.WRITE_TRACKER", UCP_EVENT_01H_02H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_NOT_EMPTY.PEER_PROBE_TRACKER", UCP_EVENT_01H_04H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.READ_TRACKER", UCP_EVENT_03H_01H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.RT_L3_MISS", UCP_EVENT_03H_02H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.RT_TO_L3_RESP", UCP_EVENT_03H_04H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.RT_TO_RTID_ACQUIRED", UCP_EVENT_03H_08H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.WT_TO_RTID_ACQUIRED", UCP_EVENT_03H_10H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.WRITE_TRACKER", UCP_EVENT_03H_20H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.PEER_PROBE_TRACKER", UCP_EVENT_03H_40H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_QPI", UCP_EVENT_04H_01H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_QMC", UCP_EVENT_04H_02H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_L3", UCP_EVENT_04H_04H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_CORES_02", UCP_EVENT_04H_08H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_CORES_13", UCP_EVENT_04H_10H)	\
+__PMC_EV_ALIAS("GQ_DATA.TO_QPI_QMC", UCP_EVENT_05H_01H)	\
+__PMC_EV_ALIAS("GQ_DATA.TO_L3", UCP_EVENT_05H_02H)	\
+__PMC_EV_ALIAS("GQ_DATA.TO_CORES", UCP_EVENT_05H_04H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.I_STATE", UCP_EVENT_06H_01H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.S_STATE", UCP_EVENT_06H_02H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.FWD_S_STATE", UCP_EVENT_06H_04H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.FWD_I_STATE", UCP_EVENT_06H_08H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.CONFLICT", UCP_EVENT_06H_10H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.WB", UCP_EVENT_06H_20H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.I_STATE", UCP_EVENT_07H_01H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.S_STATE", UCP_EVENT_07H_02H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.FWD_S_STATE", UCP_EVENT_07H_04H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.FWD_I_STATE", UCP_EVENT_07H_08H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.CONFLICT", UCP_EVENT_07H_10H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.WB", UCP_EVENT_07H_20H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.HITM", UCP_EVENT_07H_24H)	\
+__PMC_EV_ALIAS("L3_HITS.READ", UCP_EVENT_08H_01H)	\
+__PMC_EV_ALIAS("L3_HITS.WRITE", UCP_EVENT_08H_02H)	\
+__PMC_EV_ALIAS("L3_HITS.PROBE", UCP_EVENT_08H_04H)	\
+__PMC_EV_ALIAS("L3_HITS.ANY", UCP_EVENT_08H_03H)	\
+__PMC_EV_ALIAS("L3_MISS.READ", UCP_EVENT_09H_01H)	\
+__PMC_EV_ALIAS("L3_MISS.WRITE", UCP_EVENT_09H_02H)	\
+__PMC_EV_ALIAS("L3_MISS.PROBE", UCP_EVENT_09H_04H)	\
+__PMC_EV_ALIAS("L3_MISS.ANY", UCP_EVENT_09H_03H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.M_STATE", UCP_EVENT_0AH_01H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.E_STATE", UCP_EVENT_0AH_02H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.S_STATE", UCP_EVENT_0AH_04H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.F_STATE", UCP_EVENT_0AH_08H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.ANY", UCP_EVENT_0AH_0FH)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.M_STATE", UCP_EVENT_0BH_01H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.E_STATE", UCP_EVENT_0BH_02H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.S_STATE", UCP_EVENT_0BH_04H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.I_STATE", UCP_EVENT_0BH_08H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.F_STATE", UCP_EVENT_0BH_10H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.ANY", UCP_EVENT_0BH_1FH)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.IOH_READS", UCP_EVENT_20H_01H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.IOH_WRITES", UCP_EVENT_20H_02H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.REMOTE_READS", UCP_EVENT_20H_04H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.REMOTE_WRITES", UCP_EVENT_20H_08H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.LOCAL_READS", UCP_EVENT_20H_10H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.LOCAL_WRITES", UCP_EVENT_20H_20H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_FULL.IOH", UCP_EVENT_21H_01H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_FULL.REMOTE", UCP_EVENT_21H_02H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_FULL.LOCAL", UCP_EVENT_21H_04H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_NOT_EMPTY.IOH", UCP_EVENT_22H_01H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_NOT_EMPTY.REMOTE", UCP_EVENT_22H_02H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_NOT_EMPTY.LOCAL", UCP_EVENT_22H_04H)	\
+__PMC_EV_ALIAS("QHL_OCCUPANCY.IOH", UCP_EVENT_23H_01H)	\
+__PMC_EV_ALIAS("QHL_OCCUPANCY.REMOTE", UCP_EVENT_23H_02H)	\
+__PMC_EV_ALIAS("QHL_OCCUPANCY.LOCAL", UCP_EVENT_23H_04H)	\
+__PMC_EV_ALIAS("QHL_ADDRESS_CONFLICTS.2WAY", UCP_EVENT_24H_02H)	\
+__PMC_EV_ALIAS("QHL_ADDRESS_CONFLICTS.3WAY", UCP_EVENT_24H_04H)	\
+__PMC_EV_ALIAS("QHL_CONFLICT_CYCLES.IOH", UCP_EVENT_25H_01H)	\
+__PMC_EV_ALIAS("QHL_CONFLICT_CYCLES.REMOTE", UCP_EVENT_25H_02H)	\
+__PMC_EV_ALIAS("QHL_CONFLICT_CYCLES.LOCAL", UCP_EVENT_25H_04H)	\
+__PMC_EV_ALIAS("QHL_TO_QMC_BYPASS", UCP_EVENT_26H_01H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_FULL.READ.CH0", UCP_EVENT_27H_01H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_FULL.READ.CH1", UCP_EVENT_27H_02H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_FULL.READ.CH2", UCP_EVENT_27H_04H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_FULL.WRITE.CH0", UCP_EVENT_27H_08H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_FULL.WRITE.CH1", UCP_EVENT_27H_10H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_FULL.WRITE.CH2", UCP_EVENT_27H_20H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.READ.CH0", UCP_EVENT_28H_01H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.READ.CH1", UCP_EVENT_28H_02H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.READ.CH2", UCP_EVENT_28H_04H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.WRITE.CH0", UCP_EVENT_28H_08H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.WRITE.CH1", UCP_EVENT_28H_10H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.WRITE.CH2", UCP_EVENT_28H_20H)	\
+__PMC_EV_ALIAS("QMC_BUSY.READ.CH0", UCP_EVENT_29H_01H)	\
+__PMC_EV_ALIAS("QMC_BUSY.READ.CH1", UCP_EVENT_29H_02H)	\
+__PMC_EV_ALIAS("QMC_BUSY.READ.CH2", UCP_EVENT_29H_04H)	\
+__PMC_EV_ALIAS("QMC_BUSY.WRITE.CH0", UCP_EVENT_29H_08H)	\
+__PMC_EV_ALIAS("QMC_BUSY.WRITE.CH1", UCP_EVENT_29H_10H)	\
+__PMC_EV_ALIAS("QMC_BUSY.WRITE.CH2", UCP_EVENT_29H_20H)	\
+__PMC_EV_ALIAS("QMC_OCCUPANCY.CH0", UCP_EVENT_2AH_01H)	\
+__PMC_EV_ALIAS("QMC_OCCUPANCY.CH1", UCP_EVENT_2AH_02H)	\
+__PMC_EV_ALIAS("QMC_OCCUPANCY.CH2", UCP_EVENT_2AH_04H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_OCCUPANCY.CH0", UCP_EVENT_2BH_01H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_OCCUPANCY.CH1", UCP_EVENT_2BH_02H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_OCCUPANCY.CH2", UCP_EVENT_2BH_04H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_READS.ANY", UCP_EVENT_2BH_07H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.CH0", UCP_EVENT_2CH_01H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.CH1", UCP_EVENT_2CH_02H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.CH2", UCP_EVENT_2CH_04H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.ANY", UCP_EVENT_2CH_07H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.CH0", UCP_EVENT_2DH_01H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.CH1", UCP_EVENT_2DH_02H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.CH2", UCP_EVENT_2DH_04H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.ANY", UCP_EVENT_2DH_07H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.CH0", UCP_EVENT_2EH_01H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.CH1", UCP_EVENT_2EH_02H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.CH2", UCP_EVENT_2EH_04H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.ANY", UCP_EVENT_2EH_07H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.CH0", UCP_EVENT_2FH_01H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.CH1", UCP_EVENT_2FH_02H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.CH2", UCP_EVENT_2FH_04H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.ANY", UCP_EVENT_2FH_07H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.CH0", UCP_EVENT_2FH_08H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.CH1", UCP_EVENT_2FH_10H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.CH2", UCP_EVENT_2FH_20H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.ANY", UCP_EVENT_2FH_38H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.CH0", UCP_EVENT_30H_01H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.CH1", UCP_EVENT_30H_02H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.CH2", UCP_EVENT_30H_04H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.ANY", UCP_EVENT_30H_07H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.CH0", UCP_EVENT_31H_01H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.CH1", UCP_EVENT_31H_02H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.CH2", UCP_EVENT_31H_04H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.ANY", UCP_EVENT_31H_07H)	\
+__PMC_EV_ALIAS("QHL_FRC_ACK_CNFLTS.LOCAL", UCP_EVENT_33H_04H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.HOME.LINK_0", UCP_EVENT_40H_01H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.SNOOP.LINK_0", UCP_EVENT_40H_02H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.NDR.LINK_0", UCP_EVENT_40H_04H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.HOME.LINK_1", UCP_EVENT_40H_08H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.SNOOP.LINK_1", UCP_EVENT_40H_10H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.NDR.LINK_1", UCP_EVENT_40H_20H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.LINK_0", UCP_EVENT_40H_07H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.LINK_1", UCP_EVENT_40H_38H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.DRS.LINK_0", UCP_EVENT_41H_01H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCB.LINK_0", UCP_EVENT_41H_02H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCS.LINK_0", UCP_EVENT_41H_04H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.DRS.LINK_1", UCP_EVENT_41H_08H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCB.LINK_1", UCP_EVENT_41H_10H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCS.LINK_1", UCP_EVENT_41H_20H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.LINK_0", UCP_EVENT_41H_07H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.LINK_1", UCP_EVENT_41H_38H)	\
+__PMC_EV_ALIAS("QPI_TX_HEADER.BUSY.LINK_0", UCP_EVENT_42H_02H)	\
+__PMC_EV_ALIAS("QPI_TX_HEADER.BUSY.LINK_1", UCP_EVENT_42H_08H)	\
+__PMC_EV_ALIAS("QPI_RX_NO_PPT_CREDIT.STALLS.LINK_0", UCP_EVENT_43H_01H)	\
+__PMC_EV_ALIAS("QPI_RX_NO_PPT_CREDIT.STALLS.LINK_1", UCP_EVENT_43H_02H)	\
+__PMC_EV_ALIAS("DRAM_OPEN.CH0", UCP_EVENT_60H_01H)	\
+__PMC_EV_ALIAS("DRAM_OPEN.CH1", UCP_EVENT_60H_02H)	\
+__PMC_EV_ALIAS("DRAM_OPEN.CH2", UCP_EVENT_60H_04H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_CLOSE.CH0", UCP_EVENT_61H_01H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_CLOSE.CH1", UCP_EVENT_61H_02H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_CLOSE.CH2", UCP_EVENT_61H_04H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_MISS.CH0", UCP_EVENT_62H_01H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_MISS.CH1", UCP_EVENT_62H_02H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_MISS.CH2", UCP_EVENT_62H_04H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.CH0", UCP_EVENT_63H_01H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.AUTOPRE_CH0", UCP_EVENT_63H_02H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.CH1", UCP_EVENT_63H_04H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.AUTOPRE_CH1", UCP_EVENT_63H_08H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.CH2", UCP_EVENT_63H_10H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.AUTOPRE_CH2", UCP_EVENT_63H_20H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.CH0", UCP_EVENT_64H_01H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.AUTOPRE_CH0", UCP_EVENT_64H_02H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.CH1", UCP_EVENT_64H_04H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.AUTOPRE_CH1", UCP_EVENT_64H_08H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.CH2", UCP_EVENT_64H_10H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.AUTOPRE_CH2", UCP_EVENT_64H_20H)	\
+__PMC_EV_ALIAS("DRAM_REFRESH.CH0", UCP_EVENT_65H_01H)	\
+__PMC_EV_ALIAS("DRAM_REFRESH.CH1", UCP_EVENT_65H_02H)	\
+__PMC_EV_ALIAS("DRAM_REFRESH.CH2", UCP_EVENT_65H_04H)	\
+__PMC_EV_ALIAS("DRAM_PRE_ALL.CH0", UCP_EVENT_66H_01H)	\
+__PMC_EV_ALIAS("DRAM_PRE_ALL.CH1", UCP_EVENT_66H_02H)	\
+__PMC_EV_ALIAS("DRAM_PRE_ALL.CH2", UCP_EVENT_66H_04H)
+
+#define	__PMC_EV_ALIAS_WESTMEREUC()					\
+__PMC_EV_ALIAS("GQ_CYCLES_FULL.READ_TRACKER", UCP_EVENT_00H_01H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_FULL.WRITE_TRACKER", UCP_EVENT_00H_02H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_FULL.PEER_PROBE_TRACKER", UCP_EVENT_00H_04H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_NOT_EMPTY.READ_TRACKER", UCP_EVENT_01H_01H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_NOT_EMPTY.WRITE_TRACKER", UCP_EVENT_01H_02H)	\
+__PMC_EV_ALIAS("GQ_CYCLES_NOT_EMPTY.PEER_PROBE_TRACKER", UCP_EVENT_01H_04H)	\
+__PMC_EV_ALIAS("GQ_OCCUPANCY.READ_TRACKER", UCP_EVENT_02H_01H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.READ_TRACKER", UCP_EVENT_03H_01H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.RT_L3_MISS", UCP_EVENT_03H_02H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.RT_TO_L3_RESP", UCP_EVENT_03H_04H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.RT_TO_RTID_ACQUIRED", UCP_EVENT_03H_08H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.WT_TO_RTID_ACQUIRED", UCP_EVENT_03H_10H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.WRITE_TRACKER", UCP_EVENT_03H_20H)	\
+__PMC_EV_ALIAS("GQ_ALLOC.PEER_PROBE_TRACKER", UCP_EVENT_03H_40H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_QPI", UCP_EVENT_04H_01H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_QMC", UCP_EVENT_04H_02H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_L3", UCP_EVENT_04H_04H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_CORES_02", UCP_EVENT_04H_08H)	\
+__PMC_EV_ALIAS("GQ_DATA.FROM_CORES_13", UCP_EVENT_04H_10H)	\
+__PMC_EV_ALIAS("GQ_DATA.TO_QPI_QMC", UCP_EVENT_05H_01H)	\
+__PMC_EV_ALIAS("GQ_DATA.TO_L3", UCP_EVENT_05H_02H)	\
+__PMC_EV_ALIAS("GQ_DATA.TO_CORES", UCP_EVENT_05H_04H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.I_STATE", UCP_EVENT_06H_01H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.S_STATE", UCP_EVENT_06H_02H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.FWD_S_STATE", UCP_EVENT_06H_04H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.FWD_I_STATE", UCP_EVENT_06H_08H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.CONFLICT", UCP_EVENT_06H_10H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_LOCAL_HOME.WB", UCP_EVENT_06H_20H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.I_STATE", UCP_EVENT_07H_01H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.S_STATE", UCP_EVENT_07H_02H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.FWD_S_STATE", UCP_EVENT_07H_04H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.FWD_I_STATE", UCP_EVENT_07H_08H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.CONFLICT", UCP_EVENT_07H_10H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.WB", UCP_EVENT_07H_20H)	\
+__PMC_EV_ALIAS("SNP_RESP_TO_REMOTE_HOME.HITM", UCP_EVENT_07H_24H)	\
+__PMC_EV_ALIAS("L3_HITS.READ", UCP_EVENT_08H_01H)	\
+__PMC_EV_ALIAS("L3_HITS.WRITE", UCP_EVENT_08H_02H)	\
+__PMC_EV_ALIAS("L3_HITS.PROBE", UCP_EVENT_08H_04H)	\
+__PMC_EV_ALIAS("L3_HITS.ANY", UCP_EVENT_08H_03H)	\
+__PMC_EV_ALIAS("L3_MISS.READ", UCP_EVENT_09H_01H)	\
+__PMC_EV_ALIAS("L3_MISS.WRITE", UCP_EVENT_09H_02H)	\
+__PMC_EV_ALIAS("L3_MISS.PROBE", UCP_EVENT_09H_04H)	\
+__PMC_EV_ALIAS("L3_MISS.ANY", UCP_EVENT_09H_03H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.M_STATE", UCP_EVENT_0AH_01H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.E_STATE", UCP_EVENT_0AH_02H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.S_STATE", UCP_EVENT_0AH_04H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.F_STATE", UCP_EVENT_0AH_08H)	\
+__PMC_EV_ALIAS("L3_LINES_IN.ANY", UCP_EVENT_0AH_0FH)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.M_STATE", UCP_EVENT_0BH_01H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.E_STATE", UCP_EVENT_0BH_02H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.S_STATE", UCP_EVENT_0BH_04H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.I_STATE", UCP_EVENT_0BH_08H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.F_STATE", UCP_EVENT_0BH_10H)	\
+__PMC_EV_ALIAS("L3_LINES_OUT.ANY", UCP_EVENT_0BH_1FH)	\
+__PMC_EV_ALIAS("GQ_SNOOP.GOTO_S", UCP_EVENT_0CH_01H)	\
+__PMC_EV_ALIAS("GQ_SNOOP.GOTO_I", UCP_EVENT_0CH_02H)	\
+__PMC_EV_ALIAS("GQ_SNOOP.GOTO_S_HIT", UCP_EVENT_0CH_04H)	\
+__PMC_EV_ALIAS("GQ_SNOOP.GOTO_I_HIT", UCP_EVENT_0CH_08H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.IOH_READS", UCP_EVENT_20H_01H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.IOH_WRITES", UCP_EVENT_20H_02H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.REMOTE_READS", UCP_EVENT_20H_04H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.REMOTE_WRITES", UCP_EVENT_20H_08H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.LOCAL_READS", UCP_EVENT_20H_10H)	\
+__PMC_EV_ALIAS("QHL_REQUESTS.LOCAL_WRITES", UCP_EVENT_20H_20H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_FULL.IOH", UCP_EVENT_21H_01H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_FULL.REMOTE", UCP_EVENT_21H_02H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_FULL.LOCAL", UCP_EVENT_21H_04H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_NOT_EMPTY.IOH", UCP_EVENT_22H_01H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_NOT_EMPTY.REMOTE", UCP_EVENT_22H_02H)	\
+__PMC_EV_ALIAS("QHL_CYCLES_NOT_EMPTY.LOCAL", UCP_EVENT_22H_04H)	\
+__PMC_EV_ALIAS("QHL_OCCUPANCY.IOH", UCP_EVENT_23H_01H)	\
+__PMC_EV_ALIAS("QHL_OCCUPANCY.REMOTE", UCP_EVENT_23H_02H)	\
+__PMC_EV_ALIAS("QHL_OCCUPANCY.LOCAL", UCP_EVENT_23H_04H)	\
+__PMC_EV_ALIAS("QHL_ADDRESS_CONFLICTS.2WAY", UCP_EVENT_24H_02H)	\
+__PMC_EV_ALIAS("QHL_ADDRESS_CONFLICTS.3WAY", UCP_EVENT_24H_04H)	\
+__PMC_EV_ALIAS("QHL_CONFLICT_CYCLES.IOH", UCP_EVENT_25H_01H)	\
+__PMC_EV_ALIAS("QHL_CONFLICT_CYCLES.REMOTE", UCP_EVENT_25H_02H)	\
+__PMC_EV_ALIAS("QHL_CONFLICT_CYCLES.LOCAL", UCP_EVENT_25H_04H)	\
+__PMC_EV_ALIAS("QHL_TO_QMC_BYPASS", UCP_EVENT_26H_01H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.READ.CH0", UCP_EVENT_28H_01H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.READ.CH1", UCP_EVENT_28H_02H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.READ.CH2", UCP_EVENT_28H_04H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.WRITE.CH0", UCP_EVENT_28H_08H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.WRITE.CH1", UCP_EVENT_28H_10H)	\
+__PMC_EV_ALIAS("QMC_ISOC_FULL.WRITE.CH2", UCP_EVENT_28H_20H)	\
+__PMC_EV_ALIAS("QMC_BUSY.READ.CH0", UCP_EVENT_29H_01H)	\
+__PMC_EV_ALIAS("QMC_BUSY.READ.CH1", UCP_EVENT_29H_02H)	\
+__PMC_EV_ALIAS("QMC_BUSY.READ.CH2", UCP_EVENT_29H_04H)	\
+__PMC_EV_ALIAS("QMC_BUSY.WRITE.CH0", UCP_EVENT_29H_08H)	\
+__PMC_EV_ALIAS("QMC_BUSY.WRITE.CH1", UCP_EVENT_29H_10H)	\
+__PMC_EV_ALIAS("QMC_BUSY.WRITE.CH2", UCP_EVENT_29H_20H)	\
+__PMC_EV_ALIAS("QMC_OCCUPANCY.CH0", UCP_EVENT_2AH_01H)	\
+__PMC_EV_ALIAS("QMC_OCCUPANCY.CH1", UCP_EVENT_2AH_02H)	\
+__PMC_EV_ALIAS("QMC_OCCUPANCY.CH2", UCP_EVENT_2AH_04H)	\
+__PMC_EV_ALIAS("QMC_OCCUPANCY.ANY", UCP_EVENT_2AH_07H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_OCCUPANCY.CH0", UCP_EVENT_2BH_01H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_OCCUPANCY.CH1", UCP_EVENT_2BH_02H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_OCCUPANCY.CH2", UCP_EVENT_2BH_04H)	\
+__PMC_EV_ALIAS("QMC_ISSOC_READS.ANY", UCP_EVENT_2BH_07H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.CH0", UCP_EVENT_2CH_01H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.CH1", UCP_EVENT_2CH_02H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.CH2", UCP_EVENT_2CH_04H)	\
+__PMC_EV_ALIAS("QMC_NORMAL_READS.ANY", UCP_EVENT_2CH_07H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.CH0", UCP_EVENT_2DH_01H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.CH1", UCP_EVENT_2DH_02H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.CH2", UCP_EVENT_2DH_04H)	\
+__PMC_EV_ALIAS("QMC_HIGH_PRIORITY_READS.ANY", UCP_EVENT_2DH_07H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.CH0", UCP_EVENT_2EH_01H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.CH1", UCP_EVENT_2EH_02H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.CH2", UCP_EVENT_2EH_04H)	\
+__PMC_EV_ALIAS("QMC_CRITICAL_PRIORITY_READS.ANY", UCP_EVENT_2EH_07H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.CH0", UCP_EVENT_2FH_01H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.CH1", UCP_EVENT_2FH_02H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.CH2", UCP_EVENT_2FH_04H)	\
+__PMC_EV_ALIAS("QMC_WRITES.FULL.ANY", UCP_EVENT_2FH_07H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.CH0", UCP_EVENT_2FH_08H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.CH1", UCP_EVENT_2FH_10H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.CH2", UCP_EVENT_2FH_20H)	\
+__PMC_EV_ALIAS("QMC_WRITES.PARTIAL.ANY", UCP_EVENT_2FH_38H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.CH0", UCP_EVENT_30H_01H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.CH1", UCP_EVENT_30H_02H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.CH2", UCP_EVENT_30H_04H)	\
+__PMC_EV_ALIAS("QMC_CANCEL.ANY", UCP_EVENT_30H_07H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.CH0", UCP_EVENT_31H_01H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.CH1", UCP_EVENT_31H_02H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.CH2", UCP_EVENT_31H_04H)	\
+__PMC_EV_ALIAS("QMC_PRIORITY_UPDATES.ANY", UCP_EVENT_31H_07H)	\
+__PMC_EV_ALIAS("IMC_RETRY.CH0", UCP_EVENT_32H_01H)	\
+__PMC_EV_ALIAS("IMC_RETRY.CH1", UCP_EVENT_32H_02H)	\
+__PMC_EV_ALIAS("IMC_RETRY.CH2", UCP_EVENT_32H_04H)	\
+__PMC_EV_ALIAS("IMC_RETRY.ANY", UCP_EVENT_32H_07H)	\
+__PMC_EV_ALIAS("QHL_FRC_ACK_CNFLTS.IOH", UCP_EVENT_33H_01H)	\
+__PMC_EV_ALIAS("QHL_FRC_ACK_CNFLTS.REMOTE", UCP_EVENT_33H_02H)	\
+__PMC_EV_ALIAS("QHL_FRC_ACK_CNFLTS.LOCAL", UCP_EVENT_33H_04H)	\
+__PMC_EV_ALIAS("QHL_FRC_ACK_CNFLTS.ANY", UCP_EVENT_33H_07H)	\
+__PMC_EV_ALIAS("QHL_SLEEPS.IOH_ORDER", UCP_EVENT_34H_01H)	\
+__PMC_EV_ALIAS("QHL_SLEEPS.REMOTE_ORDER", UCP_EVENT_34H_02H)	\
+__PMC_EV_ALIAS("QHL_SLEEPS.LOCAL_ORDER", UCP_EVENT_34H_04H)	\
+__PMC_EV_ALIAS("QHL_SLEEPS.IOH_CONFLICT", UCP_EVENT_34H_08H)	\
+__PMC_EV_ALIAS("QHL_SLEEPS.REMOTE_CONFLICT", UCP_EVENT_34H_10H)	\
+__PMC_EV_ALIAS("QHL_SLEEPS.LOCAL_CONFLICT", UCP_EVENT_34H_20H)	\
+__PMC_EV_ALIAS("ADDR_OPCODE_MATCH.IOH", UCP_EVENT_35H_01H)	\
+__PMC_EV_ALIAS("ADDR_OPCODE_MATCH.REMOTE", UCP_EVENT_35H_02H)	\
+__PMC_EV_ALIAS("ADDR_OPCODE_MATCH.LOCAL", UCP_EVENT_35H_04H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.HOME.LINK_0", UCP_EVENT_40H_01H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.SNOOP.LINK_0", UCP_EVENT_40H_02H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.NDR.LINK_0", UCP_EVENT_40H_04H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.HOME.LINK_1", UCP_EVENT_40H_08H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.SNOOP.LINK_1", UCP_EVENT_40H_10H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.NDR.LINK_1", UCP_EVENT_40H_20H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.LINK_0", UCP_EVENT_40H_07H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_SINGLE_FLIT.LINK_1", UCP_EVENT_40H_38H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.DRS.LINK_0", UCP_EVENT_41H_01H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCB.LINK_0", UCP_EVENT_41H_02H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCS.LINK_0", UCP_EVENT_41H_04H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.DRS.LINK_1", UCP_EVENT_41H_08H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCB.LINK_1", UCP_EVENT_41H_10H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.NCS.LINK_1", UCP_EVENT_41H_20H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.LINK_0", UCP_EVENT_41H_07H)	\
+__PMC_EV_ALIAS("QPI_TX_STALLED_MULTI_FLIT.LINK_1", UCP_EVENT_41H_38H)	\
+__PMC_EV_ALIAS("QPI_TX_HEADER.FULL.LINK_0", UCP_EVENT_42H_01H)	\
+__PMC_EV_ALIAS("QPI_TX_HEADER.BUSY.LINK_0", UCP_EVENT_42H_02H)	\
+__PMC_EV_ALIAS("QPI_TX_HEADER.FULL.LINK_1", UCP_EVENT_42H_04H)	\
+__PMC_EV_ALIAS("QPI_TX_HEADER.BUSY.LINK_1", UCP_EVENT_42H_08H)	\
+__PMC_EV_ALIAS("QPI_RX_NO_PPT_CREDIT.STALLS.LINK_0", UCP_EVENT_43H_01H)	\
+__PMC_EV_ALIAS("QPI_RX_NO_PPT_CREDIT.STALLS.LINK_1", UCP_EVENT_43H_02H)	\
+__PMC_EV_ALIAS("DRAM_OPEN.CH0", UCP_EVENT_60H_01H)	\
+__PMC_EV_ALIAS("DRAM_OPEN.CH1", UCP_EVENT_60H_02H)	\
+__PMC_EV_ALIAS("DRAM_OPEN.CH2", UCP_EVENT_60H_04H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_CLOSE.CH0", UCP_EVENT_61H_01H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_CLOSE.CH1", UCP_EVENT_61H_02H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_CLOSE.CH2", UCP_EVENT_61H_04H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_MISS.CH0", UCP_EVENT_62H_01H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_MISS.CH1", UCP_EVENT_62H_02H)	\
+__PMC_EV_ALIAS("DRAM_PAGE_MISS.CH2", UCP_EVENT_62H_04H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.CH0", UCP_EVENT_63H_01H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.AUTOPRE_CH0", UCP_EVENT_63H_02H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.CH1", UCP_EVENT_63H_04H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.AUTOPRE_CH1", UCP_EVENT_63H_08H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.CH2", UCP_EVENT_63H_10H)	\
+__PMC_EV_ALIAS("DRAM_READ_CAS.AUTOPRE_CH2", UCP_EVENT_63H_20H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.CH0", UCP_EVENT_64H_01H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.AUTOPRE_CH0", UCP_EVENT_64H_02H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.CH1", UCP_EVENT_64H_04H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.AUTOPRE_CH1", UCP_EVENT_64H_08H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.CH2", UCP_EVENT_64H_10H)	\
+__PMC_EV_ALIAS("DRAM_WRITE_CAS.AUTOPRE_CH2", UCP_EVENT_64H_20H)	\
+__PMC_EV_ALIAS("DRAM_REFRESH.CH0", UCP_EVENT_65H_01H)	\
+__PMC_EV_ALIAS("DRAM_REFRESH.CH1", UCP_EVENT_65H_02H)	\
+__PMC_EV_ALIAS("DRAM_REFRESH.CH2", UCP_EVENT_65H_04H)	\
+__PMC_EV_ALIAS("DRAM_PRE_ALL.CH0", UCP_EVENT_66H_01H)	\
+__PMC_EV_ALIAS("DRAM_PRE_ALL.CH1", UCP_EVENT_66H_02H)	\
+__PMC_EV_ALIAS("DRAM_PRE_ALL.CH2", UCP_EVENT_66H_04H)	\
+__PMC_EV_ALIAS("DRAM_THERMAL_THROTTLED", UCP_EVENT_67H_01H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_TEMP.CORE_0", UCP_EVENT_80H_01H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_TEMP.CORE_1", UCP_EVENT_80H_02H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_TEMP.CORE_2", UCP_EVENT_80H_04H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_TEMP.CORE_3", UCP_EVENT_80H_08H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLED_TEMP.CORE_0", UCP_EVENT_81H_01H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLED_TEMP.CORE_1", UCP_EVENT_81H_02H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLED_TEMP.CORE_2", UCP_EVENT_81H_04H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLED_TEMP.CORE_3", UCP_EVENT_81H_08H)	\
+__PMC_EV_ALIAS("PROCHOT_ASSERTION", UCP_EVENT_82H_01H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_PROCHOT.CORE_0", UCP_EVENT_83H_01H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_PROCHOT.CORE_1", UCP_EVENT_83H_02H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_PROCHOT.CORE_2", UCP_EVENT_83H_04H)	\
+__PMC_EV_ALIAS("THERMAL_THROTTLING_PROCHOT.CORE_3", UCP_EVENT_83H_08H)	\
+__PMC_EV_ALIAS("TURBO_MODE.CORE_0", UCP_EVENT_84H_01H)	\
+__PMC_EV_ALIAS("TURBO_MODE.CORE_1", UCP_EVENT_84H_02H)	\
+__PMC_EV_ALIAS("TURBO_MODE.CORE_2", UCP_EVENT_84H_04H)	\
+__PMC_EV_ALIAS("TURBO_MODE.CORE_3", UCP_EVENT_84H_08H)	\
+__PMC_EV_ALIAS("CYCLES_UNHALTED_L3_FLL_ENABLE", UCP_EVENT_85H_02H)	\
+__PMC_EV_ALIAS("CYCLES_UNHALTED_L3_FLL_DISABLE", UCP_EVENT_86H_01H)
 
 /*
  * Intel XScale events from:
@@ -2165,10 +3132,14 @@ __PMC_EV_ALIAS("SIMD_INT_64.SHUFFLE_MOVE",		IAP_EVENT_FDH_40H)
 	__PMC_EV_P6()				\
 	__PMC_EV_BLOCK(XSCALE,	0x11200)	\
 	__PMC_EV_XSCALE()                       \
-	__PMC_EV_BLOCK(MIPS24K,    0x11300)        \
-	__PMC_EV_MIPS24K()
+	__PMC_EV_BLOCK(MIPS24K,	0x11300)	\
+	__PMC_EV_MIPS24K()			\
+	__PMC_EV_BLOCK(UCF,	0x12000)	\
+	__PMC_EV_UCF()				\
+	__PMC_EV_BLOCK(UCP,	0x12080)	\
+	__PMC_EV_UCP()				\
 
 #define	PMC_EVENT_FIRST	PMC_EV_TSC_TSC
-#define	PMC_EVENT_LAST	PMC_EV_24K_LAST
+#define	PMC_EVENT_LAST	PMC_EV_UCP_LAST
 
 #endif /* _DEV_HWPMC_PMC_EVENTS_H_ */
diff --git a/sys/dev/iwn/if_iwn.c b/sys/dev/iwn/if_iwn.c
index b6af7b8896bf..2e60da3bf1bb 100644
--- a/sys/dev/iwn/if_iwn.c
+++ b/sys/dev/iwn/if_iwn.c
@@ -65,166 +65,193 @@ __FBSDID("$FreeBSD$");
 #include <netinet/ip.h>
 
 #include <net80211/ieee80211_var.h>
-#include <net80211/ieee80211_amrr.h>
 #include <net80211/ieee80211_radiotap.h>
 #include <net80211/ieee80211_regdomain.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <dev/iwn/if_iwnreg.h>
 #include <dev/iwn/if_iwnvar.h>
 
 static int	iwn_probe(device_t);
 static int	iwn_attach(device_t);
-const struct iwn_hal *iwn_hal_attach(struct iwn_softc *);
-void		iwn_radiotap_attach(struct iwn_softc *);
+static const struct iwn_hal *iwn_hal_attach(struct iwn_softc *);
+static void	iwn_radiotap_attach(struct iwn_softc *);
 static struct ieee80211vap *iwn_vap_create(struct ieee80211com *,
 		    const char name[IFNAMSIZ], int unit, int opmode,
 		    int flags, const uint8_t bssid[IEEE80211_ADDR_LEN],
 		    const uint8_t mac[IEEE80211_ADDR_LEN]);
 static void	iwn_vap_delete(struct ieee80211vap *);
 static int	iwn_cleanup(device_t);
-static int 	iwn_detach(device_t);
-int		iwn_nic_lock(struct iwn_softc *);
-int		iwn_eeprom_lock(struct iwn_softc *);
-int		iwn_init_otprom(struct iwn_softc *);
-int		iwn_read_prom_data(struct iwn_softc *, uint32_t, void *, int);
+static int	iwn_detach(device_t);
+static int	iwn_nic_lock(struct iwn_softc *);
+static int	iwn_eeprom_lock(struct iwn_softc *);
+static int	iwn_init_otprom(struct iwn_softc *);
+static int	iwn_read_prom_data(struct iwn_softc *, uint32_t, void *, int);
+static void	iwn_dma_map_addr(void *, bus_dma_segment_t *, int, int);
 static int	iwn_dma_contig_alloc(struct iwn_softc *, struct iwn_dma_info *,
 		    void **, bus_size_t, bus_size_t, int);
 static void	iwn_dma_contig_free(struct iwn_dma_info *);
-int		iwn_alloc_sched(struct iwn_softc *);
-void		iwn_free_sched(struct iwn_softc *);
-int		iwn_alloc_kw(struct iwn_softc *);
-void		iwn_free_kw(struct iwn_softc *);
-int		iwn_alloc_ict(struct iwn_softc *);
-void		iwn_free_ict(struct iwn_softc *);
-int		iwn_alloc_fwmem(struct iwn_softc *);
-void		iwn_free_fwmem(struct iwn_softc *);
-int		iwn_alloc_rx_ring(struct iwn_softc *, struct iwn_rx_ring *);
-void		iwn_reset_rx_ring(struct iwn_softc *, struct iwn_rx_ring *);
-void		iwn_free_rx_ring(struct iwn_softc *, struct iwn_rx_ring *);
-int		iwn_alloc_tx_ring(struct iwn_softc *, struct iwn_tx_ring *,
+static int	iwn_alloc_sched(struct iwn_softc *);
+static void	iwn_free_sched(struct iwn_softc *);
+static int	iwn_alloc_kw(struct iwn_softc *);
+static void	iwn_free_kw(struct iwn_softc *);
+static int	iwn_alloc_ict(struct iwn_softc *);
+static void	iwn_free_ict(struct iwn_softc *);
+static int	iwn_alloc_fwmem(struct iwn_softc *);
+static void	iwn_free_fwmem(struct iwn_softc *);
+static int	iwn_alloc_rx_ring(struct iwn_softc *, struct iwn_rx_ring *);
+static void	iwn_reset_rx_ring(struct iwn_softc *, struct iwn_rx_ring *);
+static void	iwn_free_rx_ring(struct iwn_softc *, struct iwn_rx_ring *);
+static int	iwn_alloc_tx_ring(struct iwn_softc *, struct iwn_tx_ring *,
 		    int);
-void		iwn_reset_tx_ring(struct iwn_softc *, struct iwn_tx_ring *);
-void		iwn_free_tx_ring(struct iwn_softc *, struct iwn_tx_ring *);
-void		iwn5000_ict_reset(struct iwn_softc *);
-int		iwn_read_eeprom(struct iwn_softc *,
+static void	iwn_reset_tx_ring(struct iwn_softc *, struct iwn_tx_ring *);
+static void	iwn_free_tx_ring(struct iwn_softc *, struct iwn_tx_ring *);
+static void	iwn5000_ict_reset(struct iwn_softc *);
+static int	iwn_read_eeprom(struct iwn_softc *,
 		    uint8_t macaddr[IEEE80211_ADDR_LEN]);
-void		iwn4965_read_eeprom(struct iwn_softc *);
-void		iwn4965_print_power_group(struct iwn_softc *, int);
-void		iwn5000_read_eeprom(struct iwn_softc *);
+static void	iwn4965_read_eeprom(struct iwn_softc *);
+static void	iwn4965_print_power_group(struct iwn_softc *, int);
+static void	iwn5000_read_eeprom(struct iwn_softc *);
+static uint32_t	iwn_eeprom_channel_flags(struct iwn_eeprom_chan *);
+static void	iwn_read_eeprom_band(struct iwn_softc *, int);
+#if 0	/* HT */
+static void	iwn_read_eeprom_ht40(struct iwn_softc *, int);
+#endif
 static void	iwn_read_eeprom_channels(struct iwn_softc *, int,
 		    uint32_t);
-void		iwn_read_eeprom_enhinfo(struct iwn_softc *);
-struct ieee80211_node *iwn_node_alloc(struct ieee80211vap *,
+static void	iwn_read_eeprom_enhinfo(struct iwn_softc *);
+static struct ieee80211_node *iwn_node_alloc(struct ieee80211vap *,
 		    const uint8_t mac[IEEE80211_ADDR_LEN]);
-void		iwn_newassoc(struct ieee80211_node *, int);
-int		iwn_media_change(struct ifnet *);
-int		iwn_newstate(struct ieee80211vap *, enum ieee80211_state, int);
-void		iwn_rx_phy(struct iwn_softc *, struct iwn_rx_desc *,
+static void	iwn_newassoc(struct ieee80211_node *, int);
+static int	iwn_media_change(struct ifnet *);
+static int	iwn_newstate(struct ieee80211vap *, enum ieee80211_state, int);
+static void	iwn_rx_phy(struct iwn_softc *, struct iwn_rx_desc *,
 		    struct iwn_rx_data *);
 static void	iwn_timer_timeout(void *);
 static void	iwn_calib_reset(struct iwn_softc *);
-void		iwn_rx_done(struct iwn_softc *, struct iwn_rx_desc *,
+static void	iwn_rx_done(struct iwn_softc *, struct iwn_rx_desc *,
 		    struct iwn_rx_data *);
 #if 0	/* HT */
-void		iwn_rx_compressed_ba(struct iwn_softc *, struct iwn_rx_desc *,
+static void	iwn_rx_compressed_ba(struct iwn_softc *, struct iwn_rx_desc *,
 		    struct iwn_rx_data *);
 #endif
-void		iwn5000_rx_calib_results(struct iwn_softc *,
+static void	iwn5000_rx_calib_results(struct iwn_softc *,
 		    struct iwn_rx_desc *, struct iwn_rx_data *);
-void		iwn_rx_statistics(struct iwn_softc *, struct iwn_rx_desc *,
+static void	iwn_rx_statistics(struct iwn_softc *, struct iwn_rx_desc *,
 		    struct iwn_rx_data *);
-void		iwn4965_tx_done(struct iwn_softc *, struct iwn_rx_desc *,
+static void	iwn4965_tx_done(struct iwn_softc *, struct iwn_rx_desc *,
 		    struct iwn_rx_data *);
-void		iwn5000_tx_done(struct iwn_softc *, struct iwn_rx_desc *,
+static void	iwn5000_tx_done(struct iwn_softc *, struct iwn_rx_desc *,
 		    struct iwn_rx_data *);
-void		iwn_tx_done(struct iwn_softc *, struct iwn_rx_desc *, int,
+static void	iwn_tx_done(struct iwn_softc *, struct iwn_rx_desc *, int,
 		    uint8_t);
-void		iwn_cmd_done(struct iwn_softc *, struct iwn_rx_desc *);
-void		iwn_notif_intr(struct iwn_softc *);
-void		iwn_wakeup_intr(struct iwn_softc *);
-void		iwn_rftoggle_intr(struct iwn_softc *);
-void		iwn_fatal_intr(struct iwn_softc *);
-void		iwn_intr(void *);
-void		iwn4965_update_sched(struct iwn_softc *, int, int, uint8_t,
+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 *);
+static void	iwn_rftoggle_intr(struct iwn_softc *);
+static void	iwn_fatal_intr(struct iwn_softc *);
+static void	iwn_intr(void *);
+static void	iwn4965_update_sched(struct iwn_softc *, int, int, uint8_t,
 		    uint16_t);
-void		iwn5000_update_sched(struct iwn_softc *, int, int, uint8_t,
+static void	iwn5000_update_sched(struct iwn_softc *, int, int, uint8_t,
 		    uint16_t);
-void		iwn5000_reset_sched(struct iwn_softc *, int, int);
-int		iwn_tx_data(struct iwn_softc *, struct mbuf *,
+#ifdef notyet
+static void	iwn5000_reset_sched(struct iwn_softc *, int, int);
+#endif
+static uint8_t	iwn_plcp_signal(int);
+static int	iwn_tx_data(struct iwn_softc *, struct mbuf *,
 		    struct ieee80211_node *, struct iwn_tx_ring *);
 static int	iwn_raw_xmit(struct ieee80211_node *, struct mbuf *,
 		    const struct ieee80211_bpf_params *);
-void		iwn_start(struct ifnet *);
-void		iwn_start_locked(struct ifnet *);
+static void	iwn_start(struct ifnet *);
+static void	iwn_start_locked(struct ifnet *);
 static void	iwn_watchdog(struct iwn_softc *sc);
-int		iwn_ioctl(struct ifnet *, u_long, caddr_t);
-int		iwn_cmd(struct iwn_softc *, int, const void *, int, int);
-int		iwn4965_add_node(struct iwn_softc *, struct iwn_node_info *,
+static int	iwn_ioctl(struct ifnet *, u_long, caddr_t);
+static int	iwn_cmd(struct iwn_softc *, int, const void *, int, int);
+static int	iwn4965_add_node(struct iwn_softc *, struct iwn_node_info *,
 		    int);
-int		iwn5000_add_node(struct iwn_softc *, struct iwn_node_info *,
+static int	iwn5000_add_node(struct iwn_softc *, struct iwn_node_info *,
 		    int);
-int		iwn_set_link_quality(struct iwn_softc *, uint8_t, int);
-int		iwn_add_broadcast_node(struct iwn_softc *, int);
-int		iwn_wme_update(struct ieee80211com *);
+static int	iwn_set_link_quality(struct iwn_softc *, uint8_t, int);
+static int	iwn_add_broadcast_node(struct iwn_softc *, int);
+static int	iwn_wme_update(struct ieee80211com *);
 static void	iwn_update_mcast(struct ifnet *);
-void		iwn_set_led(struct iwn_softc *, uint8_t, uint8_t, uint8_t);
-int		iwn_set_critical_temp(struct iwn_softc *);
-int		iwn_set_timing(struct iwn_softc *, struct ieee80211_node *);
-void		iwn4965_power_calibration(struct iwn_softc *, int);
-int		iwn4965_set_txpower(struct iwn_softc *,
+static void	iwn_set_led(struct iwn_softc *, uint8_t, uint8_t, uint8_t);
+static int	iwn_set_critical_temp(struct iwn_softc *);
+static int	iwn_set_timing(struct iwn_softc *, struct ieee80211_node *);
+static void	iwn4965_power_calibration(struct iwn_softc *, int);
+static int	iwn4965_set_txpower(struct iwn_softc *,
 		    struct ieee80211_channel *, int);
-int		iwn5000_set_txpower(struct iwn_softc *,
+static int	iwn5000_set_txpower(struct iwn_softc *,
 		    struct ieee80211_channel *, int);
-int		iwn4965_get_rssi(struct iwn_softc *, struct iwn_rx_stat *);
-int		iwn5000_get_rssi(struct iwn_softc *, struct iwn_rx_stat *);
-int		iwn_get_noise(const struct iwn_rx_general_stats *);
-int		iwn4965_get_temperature(struct iwn_softc *);
-int		iwn5000_get_temperature(struct iwn_softc *);
-int		iwn_init_sensitivity(struct iwn_softc *);
-void		iwn_collect_noise(struct iwn_softc *,
+static int	iwn4965_get_rssi(struct iwn_softc *, struct iwn_rx_stat *);
+static int	iwn5000_get_rssi(struct iwn_softc *, struct iwn_rx_stat *);
+static int	iwn_get_noise(const struct iwn_rx_general_stats *);
+static int	iwn4965_get_temperature(struct iwn_softc *);
+static int	iwn5000_get_temperature(struct iwn_softc *);
+static int	iwn_init_sensitivity(struct iwn_softc *);
+static void	iwn_collect_noise(struct iwn_softc *,
 		    const struct iwn_rx_general_stats *);
-int		iwn4965_init_gains(struct iwn_softc *);
-int		iwn5000_init_gains(struct iwn_softc *);
-int		iwn4965_set_gains(struct iwn_softc *);
-int		iwn5000_set_gains(struct iwn_softc *);
-void		iwn_tune_sensitivity(struct iwn_softc *,
+static int	iwn4965_init_gains(struct iwn_softc *);
+static int	iwn5000_init_gains(struct iwn_softc *);
+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 *);
-int		iwn_send_sensitivity(struct iwn_softc *);
-int		iwn_set_pslevel(struct iwn_softc *, int, int, int);
-int		iwn_config(struct iwn_softc *);
-int		iwn_scan(struct iwn_softc *);
-int		iwn_auth(struct iwn_softc *, struct ieee80211vap *vap);
-int		iwn_run(struct iwn_softc *, struct ieee80211vap *vap);
-int		iwn5000_query_calibration(struct iwn_softc *);
-int		iwn5000_send_calibration(struct iwn_softc *);
-int		iwn5000_send_wimax_coex(struct iwn_softc *);
-int		iwn4965_post_alive(struct iwn_softc *);
-int		iwn5000_post_alive(struct iwn_softc *);
-int		iwn4965_load_bootcode(struct iwn_softc *, const uint8_t *,
+static int	iwn_send_sensitivity(struct iwn_softc *);
+static int	iwn_set_pslevel(struct iwn_softc *, int, int, int);
+static int	iwn_config(struct iwn_softc *);
+static int	iwn_scan(struct iwn_softc *);
+static int	iwn_auth(struct iwn_softc *, struct ieee80211vap *vap);
+static int	iwn_run(struct iwn_softc *, struct ieee80211vap *vap);
+#if 0	/* HT */
+static int	iwn_ampdu_rx_start(struct ieee80211com *,
+		    struct ieee80211_node *, uint8_t);
+static void	iwn_ampdu_rx_stop(struct ieee80211com *,
+		    struct ieee80211_node *, uint8_t);
+static int	iwn_ampdu_tx_start(struct ieee80211com *,
+		    struct ieee80211_node *, uint8_t);
+static void	iwn_ampdu_tx_stop(struct ieee80211com *,
+		    struct ieee80211_node *, uint8_t);
+static void	iwn4965_ampdu_tx_start(struct iwn_softc *,
+		    struct ieee80211_node *, uint8_t, uint16_t);
+static void	iwn4965_ampdu_tx_stop(struct iwn_softc *, uint8_t, uint16_t);
+static void	iwn5000_ampdu_tx_start(struct iwn_softc *,
+		    struct ieee80211_node *, uint8_t, uint16_t);
+static void	iwn5000_ampdu_tx_stop(struct iwn_softc *, uint8_t, uint16_t);
+#endif
+static int	iwn5000_query_calibration(struct iwn_softc *);
+static int	iwn5000_send_calibration(struct iwn_softc *);
+static int	iwn5000_send_wimax_coex(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 *,
 		    int);
-int		iwn4965_load_firmware(struct iwn_softc *);
-int		iwn5000_load_firmware_section(struct iwn_softc *, uint32_t,
+static int	iwn4965_load_firmware(struct iwn_softc *);
+static int	iwn5000_load_firmware_section(struct iwn_softc *, uint32_t,
 		    const uint8_t *, int);
-int		iwn5000_load_firmware(struct iwn_softc *);
-int		iwn_read_firmware(struct iwn_softc *);
-int		iwn_clock_wait(struct iwn_softc *);
-int		iwn_apm_init(struct iwn_softc *);
-void		iwn_apm_stop_master(struct iwn_softc *);
-void		iwn_apm_stop(struct iwn_softc *);
-int		iwn4965_nic_config(struct iwn_softc *);
-int		iwn5000_nic_config(struct iwn_softc *);
-int		iwn_hw_prepare(struct iwn_softc *);
-int		iwn_hw_init(struct iwn_softc *);
-void		iwn_hw_stop(struct iwn_softc *);
-void		iwn_init_locked(struct iwn_softc *);
-void		iwn_init(void *);
-void		iwn_stop_locked(struct iwn_softc *);
-void		iwn_stop(struct iwn_softc *);
+static int	iwn5000_load_firmware(struct iwn_softc *);
+static int	iwn_read_firmware(struct iwn_softc *);
+static int	iwn_clock_wait(struct iwn_softc *);
+static int	iwn_apm_init(struct iwn_softc *);
+static void	iwn_apm_stop_master(struct iwn_softc *);
+static void	iwn_apm_stop(struct iwn_softc *);
+static int	iwn4965_nic_config(struct iwn_softc *);
+static int	iwn5000_nic_config(struct iwn_softc *);
+static int	iwn_hw_prepare(struct iwn_softc *);
+static int	iwn_hw_init(struct iwn_softc *);
+static void	iwn_hw_stop(struct iwn_softc *);
+static void	iwn_init_locked(struct iwn_softc *);
+static void	iwn_init(void *);
+static void	iwn_stop_locked(struct iwn_softc *);
+static void	iwn_stop(struct iwn_softc *);
 static void 	iwn_scan_start(struct ieee80211com *);
 static void 	iwn_scan_end(struct ieee80211com *);
 static void 	iwn_set_channel(struct ieee80211com *);
 static void 	iwn_scan_curchan(struct ieee80211_scan_state *, unsigned long);
 static void 	iwn_scan_mindwell(struct ieee80211_scan_state *);
+static struct iwn_eeprom_chan *iwn_find_eeprom_channel(struct iwn_softc *,
+		    struct ieee80211_channel *);
 static int	iwn_setregdomain(struct ieee80211com *,
 		    struct ieee80211_regdomain *, int,
 		    struct ieee80211_channel []);
@@ -562,12 +589,15 @@ iwn_attach(device_t dev)
 #if IWN_RBUF_SIZE == 8192
 	    IEEE80211_HTCAP_AMSDU7935 |
 #endif
-	    IEEE80211_HTCAP_SMPS_DIS |
 	    IEEE80211_HTCAP_CBW20_40 |
 	    IEEE80211_HTCAP_SGI20 |
 	    IEEE80211_HTCAP_SGI40;
 	if (sc->hw_type != IWN_HW_REV_TYPE_4965)
 		ic->ic_htcaps |= IEEE80211_HTCAP_GF;
+	if (sc->hw_type == IWN_HW_REV_TYPE_6050)
+		ic->ic_htcaps |= IEEE80211_HTCAP_SMPS_DYN;
+	else
+		ic->ic_htcaps |= IEEE80211_HTCAP_SMPS_DIS;
 #endif
 
 	/* Read MAC address, channels, etc from EEPROM. */
@@ -643,7 +673,7 @@ fail:
 	return error;
 }
 
-const struct iwn_hal *
+static const struct iwn_hal *
 iwn_hal_attach(struct iwn_softc *sc)
 {
 	sc->hw_type = (IWN_READ(sc, IWN_HW_REV) >> 4) & 0xf;
@@ -680,7 +710,7 @@ iwn_hal_attach(struct iwn_softc *sc)
 		break;
 	case IWN_HW_REV_TYPE_1000:
 		sc->sc_hal = &iwn5000_hal;
-		sc->limits = &iwn5000_sensitivity_limits;
+		sc->limits = &iwn1000_sensitivity_limits;
 		sc->fwname = "iwn1000fw";
 		sc->txchainmask = IWN_ANT_A;
 		sc->rxchainmask = IWN_ANT_AB;
@@ -720,7 +750,7 @@ iwn_hal_attach(struct iwn_softc *sc)
 /*
  * Attach the interface to 802.11 radiotap.
  */
-void
+static void
 iwn_radiotap_attach(struct iwn_softc *sc)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -755,14 +785,9 @@ iwn_vap_create(struct ieee80211com *ic,
 	ivp->iv_newstate = vap->iv_newstate;
 	vap->iv_newstate = iwn_newstate;
 
-	ieee80211_amrr_init(&ivp->iv_amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    500 /* ms */);
-
+	ieee80211_ratectl_init(vap);
 	/* Complete setup. */
-	ieee80211_vap_attach(vap, ieee80211_media_change,
-	    ieee80211_media_status);
+	ieee80211_vap_attach(vap, iwn_media_change, ieee80211_media_status);
 	ic->ic_opmode = opmode;
 	return vap;
 }
@@ -772,12 +797,12 @@ iwn_vap_delete(struct ieee80211vap *vap)
 {
 	struct iwn_vap *ivp = IWN_VAP(vap);
 
-	ieee80211_amrr_cleanup(&ivp->iv_amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(ivp, M_80211_VAP);
 }
 
-int
+static int
 iwn_cleanup(device_t dev)
 {
 	struct iwn_softc *sc = device_get_softc(dev);
@@ -832,7 +857,7 @@ iwn_detach(device_t dev)
 	return 0;
 }
 
-int
+static int
 iwn_nic_lock(struct iwn_softc *sc)
 {
 	int ntries;
@@ -843,7 +868,7 @@ iwn_nic_lock(struct iwn_softc *sc)
 	/* Spin until we actually get the lock. */
 	for (ntries = 0; ntries < 1000; ntries++) {
 		if ((IWN_READ(sc, IWN_GP_CNTRL) &
-		     (IWN_GP_CNTRL_MAC_ACCESS_ENA | IWN_GP_CNTRL_SLEEP)) ==
+		    (IWN_GP_CNTRL_MAC_ACCESS_ENA | IWN_GP_CNTRL_SLEEP)) ==
 		    IWN_GP_CNTRL_MAC_ACCESS_ENA)
 			return 0;
 		DELAY(10);
@@ -938,7 +963,7 @@ iwn_mem_set_region_4(struct iwn_softc *sc, uint32_t addr, uint32_t val,
 		iwn_mem_write(sc, addr, val);
 }
 
-int
+static int
 iwn_eeprom_lock(struct iwn_softc *sc)
 {
 	int i, ntries;
@@ -969,7 +994,7 @@ iwn_eeprom_unlock(struct iwn_softc *sc)
  * Initialize access by host to One Time Programmable ROM.
  * NB: This kind of ROM can be found on 1000 or 6000 Series only.
  */
-int
+static int
 iwn_init_otprom(struct iwn_softc *sc)
 {
 	uint16_t prev, base, next;
@@ -1023,7 +1048,7 @@ iwn_init_otprom(struct iwn_softc *sc)
 	return 0;
 }
 
-int
+static int
 iwn_read_prom_data(struct iwn_softc *sc, uint32_t addr, void *data, int count)
 {
 	uint32_t val, tmp;
@@ -1096,8 +1121,7 @@ iwn_dma_contig_alloc(struct iwn_softc *sc, struct iwn_dma_info *dma,
 	    flags | BUS_DMA_ZERO, &dma->map);
 	if (error != 0) {
 		device_printf(sc->sc_dev,
-		   "%s: bus_dmamem_alloc failed, error %d\n",
-		   __func__, error);
+		    "%s: bus_dmamem_alloc failed, error %d\n", __func__, error);
 		goto fail;
 	}
 	error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr,
@@ -1116,7 +1140,7 @@ fail:
 	return error;
 }
 
-void
+static void
 iwn_dma_contig_free(struct iwn_dma_info *dma)
 {
 	if (dma->tag != NULL) {
@@ -1132,7 +1156,7 @@ iwn_dma_contig_free(struct iwn_dma_info *dma)
 	}
 }
 
-int
+static int
 iwn_alloc_sched(struct iwn_softc *sc)
 {
 	/* TX scheduler rings must be aligned on a 1KB boundary. */
@@ -1140,13 +1164,13 @@ iwn_alloc_sched(struct iwn_softc *sc)
 	    (void **)&sc->sched, sc->sc_hal->schedsz, 1024, BUS_DMA_NOWAIT);
 }
 
-void
+static void
 iwn_free_sched(struct iwn_softc *sc)
 {
 	iwn_dma_contig_free(&sc->sched_dma);
 }
 
-int
+static int
 iwn_alloc_kw(struct iwn_softc *sc)
 {
 	/* "Keep Warm" page must be aligned on a 4KB boundary. */
@@ -1154,13 +1178,13 @@ iwn_alloc_kw(struct iwn_softc *sc)
 	    BUS_DMA_NOWAIT);
 }
 
-void
+static void
 iwn_free_kw(struct iwn_softc *sc)
 {
 	iwn_dma_contig_free(&sc->kw_dma);
 }
 
-int
+static int
 iwn_alloc_ict(struct iwn_softc *sc)
 {
 	/* ICT table must be aligned on a 4KB boundary. */
@@ -1168,13 +1192,13 @@ iwn_alloc_ict(struct iwn_softc *sc)
 	    (void **)&sc->ict, IWN_ICT_SIZE, 4096, BUS_DMA_NOWAIT);
 }
 
-void
+static void
 iwn_free_ict(struct iwn_softc *sc)
 {
 	iwn_dma_contig_free(&sc->ict_dma);
 }
 
-int
+static int
 iwn_alloc_fwmem(struct iwn_softc *sc)
 {
 	/* Must be aligned on a 16-byte boundary. */
@@ -1182,13 +1206,13 @@ iwn_alloc_fwmem(struct iwn_softc *sc)
 	    sc->sc_hal->fwsz, 16, BUS_DMA_NOWAIT);
 }
 
-void
+static void
 iwn_free_fwmem(struct iwn_softc *sc)
 {
 	iwn_dma_contig_free(&sc->fw_dma);
 }
 
-int
+static int
 iwn_alloc_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring)
 {
 	bus_size_t size;
@@ -1247,7 +1271,7 @@ iwn_alloc_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring)
 		data->m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
 		if (data->m == NULL) {
 			device_printf(sc->sc_dev,
-			   "%s: could not allocate rx mbuf\n", __func__);
+			    "%s: could not allocate rx mbuf\n", __func__);
 			error = ENOMEM;
 			goto fail;
 		}
@@ -1278,7 +1302,7 @@ fail:
 	return error;
 }
 
-void
+static void
 iwn_reset_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring)
 {
 	int ntries;
@@ -1302,7 +1326,7 @@ iwn_reset_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring)
 	sc->last_rx_valid = 0;
 }
 
-void
+static void
 iwn_free_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring)
 {
 	int i;
@@ -1324,7 +1348,7 @@ iwn_free_rx_ring(struct iwn_softc *sc, struct iwn_rx_ring *ring)
 	}
 }
 
-int
+static int
 iwn_alloc_tx_ring(struct iwn_softc *sc, struct iwn_tx_ring *ring, int qid)
 {
 	bus_size_t size;
@@ -1398,7 +1422,7 @@ fail:
 	return error;
 }
 
-void
+static void
 iwn_reset_tx_ring(struct iwn_softc *sc, struct iwn_tx_ring *ring)
 {
 	int i;
@@ -1421,7 +1445,7 @@ iwn_reset_tx_ring(struct iwn_softc *sc, struct iwn_tx_ring *ring)
 	ring->cur = 0;
 }
 
-void
+static void
 iwn_free_tx_ring(struct iwn_softc *sc, struct iwn_tx_ring *ring)
 {
 	int i;
@@ -1443,7 +1467,7 @@ iwn_free_tx_ring(struct iwn_softc *sc, struct iwn_tx_ring *ring)
 	}
 }
 
-void
+static void
 iwn5000_ict_reset(struct iwn_softc *sc)
 {
 	/* Disable interrupts. */
@@ -1468,7 +1492,7 @@ iwn5000_ict_reset(struct iwn_softc *sc)
 	IWN_WRITE(sc, IWN_INT_MASK, sc->int_mask);
 }
 
-int
+static int
 iwn_read_eeprom(struct iwn_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN])
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -1529,7 +1553,7 @@ iwn_read_eeprom(struct iwn_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN])
 	return 0;
 }
 
-void
+static void
 iwn4965_read_eeprom(struct iwn_softc *sc)
 {
 	uint32_t addr;
@@ -1577,7 +1601,7 @@ iwn4965_read_eeprom(struct iwn_softc *sc)
 }
 
 #ifdef IWN_DEBUG
-void
+static void
 iwn4965_print_power_group(struct iwn_softc *sc, int i)
 {
 	struct iwn4965_eeprom_band *band = &sc->bands[i];
@@ -1611,9 +1635,10 @@ iwn4965_print_power_group(struct iwn_softc *sc, int i)
 }
 #endif
 
-void
+static void
 iwn5000_read_eeprom(struct iwn_softc *sc)
 {
+	struct iwn5000_eeprom_calib_hdr hdr;
 	int32_t temp, volt;
 	uint32_t addr, base;
 	int i;
@@ -1637,6 +1662,12 @@ iwn5000_read_eeprom(struct iwn_softc *sc)
 
 	iwn_read_prom_data(sc, IWN5000_EEPROM_CAL, &val, 2);
 	base = le16toh(val);
+	iwn_read_prom_data(sc, base, &hdr, sizeof hdr);
+	DPRINTF(sc, IWN_DEBUG_CALIBRATE,
+	    "%s: calib version=%u pa type=%u voltage=%u\n",
+	    __func__, hdr.version, hdr.pa_type, le16toh(hdr.volt));
+	    sc->calib_ver = hdr.version;
+
 	if (sc->hw_type == IWN_HW_REV_TYPE_5150) {
 		/* Compute temperature offset. */
 		iwn_read_prom_data(sc, base + IWN5000_EEPROM_TEMP, &val, 2);
@@ -1706,6 +1737,10 @@ iwn_read_eeprom_band(struct iwn_softc *sc, int n)
 		c->ic_ieee = chan;
 		c->ic_maxregpower = channels[i].maxpwr;
 		c->ic_maxpower = 2*c->ic_maxregpower;
+
+		/* Save maximum allowed TX power for this channel. */
+		sc->maxpwr[chan] = channels[i].maxpwr;
+
 		if (n == 0) {	/* 2GHz band */
 			c->ic_freq = ieee80211_ieee2mhz(chan,
 			    IEEE80211_CHAN_G);
@@ -1812,7 +1847,7 @@ iwn_read_eeprom_channels(struct iwn_softc *sc, int n, uint32_t addr)
 
 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
 
-void
+static void
 iwn_read_eeprom_enhinfo(struct iwn_softc *sc)
 {
 	struct iwn_eeprom_enhinfo enhinfo[35];
@@ -1849,23 +1884,20 @@ iwn_read_eeprom_enhinfo(struct iwn_softc *sc)
 	}
 }
 
-struct ieee80211_node *
+static struct ieee80211_node *
 iwn_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
 {
 	return malloc(sizeof (struct iwn_node), M_80211_NODE,M_NOWAIT | M_ZERO);
 }
 
-void
+static void
 iwn_newassoc(struct ieee80211_node *ni, int isnew)
 {
-	struct ieee80211vap *vap = ni->ni_vap;
-	struct iwn_node *wn = (void *)ni;
-
-	ieee80211_amrr_node_init(&IWN_VAP(vap)->iv_amrr,
-	    &wn->amn, ni);
+	/* XXX move */
+	ieee80211_ratectl_node_init(ni);
 }
 
-int
+static int
 iwn_media_change(struct ifnet *ifp)
 {
 	int error = ieee80211_media_change(ifp);
@@ -1873,7 +1905,7 @@ iwn_media_change(struct ifnet *ifp)
 	return (error == ENETRESET ? 0 : error);
 }
 
-int
+static int
 iwn_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 {
 	struct iwn_vap *ivp = IWN_VAP(vap);
@@ -1920,7 +1952,7 @@ iwn_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
  * Process an RX_PHY firmware notification.  This is usually immediately
  * followed by an MPDU_RX_DONE notification.
  */
-void
+static void
 iwn_rx_phy(struct iwn_softc *sc, struct iwn_rx_desc *desc,
     struct iwn_rx_data *data)
 {
@@ -1964,7 +1996,7 @@ iwn_calib_reset(struct iwn_softc *sc)
  * Process an RX_DONE (4965AGN only) or MPDU_RX_DONE firmware notification.
  * Each MPDU_RX_DONE notification must be preceded by an RX_PHY one.
  */
-void
+static void
 iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
     struct iwn_rx_data *data)
 {
@@ -2114,7 +2146,7 @@ iwn_rx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
 
 #if 0	/* HT */
 /* Process an incoming Compressed BlockAck. */
-void
+static void
 iwn_rx_compressed_ba(struct iwn_softc *sc, struct iwn_rx_desc *desc,
     struct iwn_rx_data *data)
 {
@@ -2130,7 +2162,7 @@ iwn_rx_compressed_ba(struct iwn_softc *sc, struct iwn_rx_desc *desc,
  * Process a CALIBRATION_RESULT notification sent by the initialization
  * firmware on response to a CMD_CALIB_CONFIG command (5000 only.)
  */
-void
+static void
 iwn5000_rx_calib_results(struct iwn_softc *sc, struct iwn_rx_desc *desc,
     struct iwn_rx_data *data)
 {
@@ -2146,7 +2178,8 @@ iwn5000_rx_calib_results(struct iwn_softc *sc, struct iwn_rx_desc *desc,
 
 	switch (calib->code) {
 	case IWN5000_PHY_CALIB_DC:
-		if (sc->hw_type == IWN_HW_REV_TYPE_5150)
+		if (sc->hw_type == IWN_HW_REV_TYPE_5150 ||
+		    sc->hw_type == IWN_HW_REV_TYPE_6050)
 			idx = 0;
 		break;
 	case IWN5000_PHY_CALIB_LO:
@@ -2187,7 +2220,7 @@ iwn5000_rx_calib_results(struct iwn_softc *sc, struct iwn_rx_desc *desc,
  * Process an RX_STATISTICS or BEACON_STATISTICS firmware notification.
  * The latter is sent by the firmware after each received beacon.
  */
-void
+static void
 iwn_rx_statistics(struct iwn_softc *sc, struct iwn_rx_desc *desc,
     struct iwn_rx_data *data)
 {
@@ -2244,7 +2277,7 @@ iwn_rx_statistics(struct iwn_softc *sc, struct iwn_rx_desc *desc,
  * Process a TX_DONE firmware notification.  Unfortunately, the 4965AGN
  * and 5000 adapters have different incompatible TX status formats.
  */
-void
+static void
 iwn4965_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
     struct iwn_rx_data *data)
 {
@@ -2260,7 +2293,7 @@ iwn4965_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
 	iwn_tx_done(sc, desc, stat->ackfailcnt, le32toh(stat->status) & 0xff);
 }
 
-void
+static void
 iwn5000_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
     struct iwn_rx_data *data)
 {
@@ -2284,16 +2317,16 @@ iwn5000_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc,
 /*
  * Adapter-independent backend for TX_DONE firmware notifications.
  */
-void
+static void
 iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt,
     uint8_t status)
 {
 	struct ifnet *ifp = sc->sc_ifp;
 	struct iwn_tx_ring *ring = &sc->txq[desc->qid & 0xf];
 	struct iwn_tx_data *data = &ring->data[desc->idx];
-	struct iwn_node *wn = (void *)data->ni;
 	struct mbuf *m;
 	struct ieee80211_node *ni;
+	struct ieee80211vap *vap;
 
 	KASSERT(data->ni != NULL, ("no node"));
 
@@ -2302,6 +2335,7 @@ iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt,
 	bus_dmamap_unload(ring->data_dmat, data->map);
 	m = data->m, data->m = NULL;
 	ni = data->ni, data->ni = NULL;
+	vap = ni->ni_vap;
 
 	if (m->m_flags & M_TXCB) {
 		/*
@@ -2331,11 +2365,11 @@ iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt,
 	 */
 	if (status & 0x80) {
 		ifp->if_oerrors++;
-		ieee80211_amrr_tx_complete(&wn->amn,
-		    IEEE80211_AMRR_FAILURE, ackfailcnt);
+		ieee80211_ratectl_tx_complete(vap, ni,
+		    IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL);
 	} else {
-		ieee80211_amrr_tx_complete(&wn->amn,
-		    IEEE80211_AMRR_SUCCESS, ackfailcnt);
+		ieee80211_ratectl_tx_complete(vap, ni,
+		    IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL);
 	}
 	m_freem(m);
 	ieee80211_free_node(ni);
@@ -2355,7 +2389,7 @@ iwn_tx_done(struct iwn_softc *sc, struct iwn_rx_desc *desc, int ackfailcnt,
  * Process a "command done" firmware notification.  This is where we wakeup
  * processes waiting for a synchronous command completion.
  */
-void
+static void
 iwn_cmd_done(struct iwn_softc *sc, struct iwn_rx_desc *desc)
 {
 	struct iwn_tx_ring *ring = &sc->txq[4];
@@ -2378,7 +2412,7 @@ iwn_cmd_done(struct iwn_softc *sc, struct iwn_rx_desc *desc)
 /*
  * Process an INT_FH_RX or INT_SW_RX interrupt.
  */
-void
+static void
 iwn_notif_intr(struct iwn_softc *sc)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -2556,7 +2590,7 @@ iwn_notif_intr(struct iwn_softc *sc)
  * Process an INT_WAKEUP interrupt raised when the microcontroller wakes up
  * from power-down sleep mode.
  */
-void
+static void
 iwn_wakeup_intr(struct iwn_softc *sc)
 {
 	int qid;
@@ -2572,7 +2606,7 @@ iwn_wakeup_intr(struct iwn_softc *sc)
 	}
 }
 
-void
+static void
 iwn_rftoggle_intr(struct iwn_softc *sc)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -2594,7 +2628,7 @@ iwn_rftoggle_intr(struct iwn_softc *sc)
  * we can't debug the firmware because it is neither open source nor free, it
  * can help us to identify certain classes of problems.
  */
-void
+static void
 iwn_fatal_intr(struct iwn_softc *sc)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -2654,7 +2688,7 @@ iwn_fatal_intr(struct iwn_softc *sc)
 	printf("  rx ring: cur=%d\n", sc->rxq.cur);
 }
 
-void
+static void
 iwn_intr(void *arg)
 {
 	struct iwn_softc *sc = arg;
@@ -2675,8 +2709,10 @@ iwn_intr(void *arg)
 			sc->ict_cur = (sc->ict_cur + 1) % IWN_ICT_COUNT;
 		}
 		tmp = le32toh(tmp);
-		if (tmp == 0xffffffff)
-			tmp = 0;	/* Shouldn't happen. */
+		if (tmp == 0xffffffff)	/* Shouldn't happen. */
+			tmp = 0;
+		else if (tmp & 0xc0000)	/* Workaround a HW bug. */
+			tmp |= 0x8000;
 		r1 = (tmp & 0xff00) << 16 | (tmp & 0xff);
 		r2 = 0;	/* Unused. */
 	} else {
@@ -2750,7 +2786,7 @@ done:
  * Update TX scheduler ring when transmitting an 802.11 frame (4965AGN and
  * 5000 adapters use a slightly different format.)
  */
-void
+static void
 iwn4965_update_sched(struct iwn_softc *sc, int qid, int idx, uint8_t id,
     uint16_t len)
 {
@@ -2766,7 +2802,7 @@ iwn4965_update_sched(struct iwn_softc *sc, int qid, int idx, uint8_t id,
 	}
 }
 
-void
+static void
 iwn5000_update_sched(struct iwn_softc *sc, int qid, int idx, uint8_t id,
     uint16_t len)
 {
@@ -2783,7 +2819,8 @@ iwn5000_update_sched(struct iwn_softc *sc, int qid, int idx, uint8_t id,
 	}
 }
 
-void
+#ifdef notyet
+static void
 iwn5000_reset_sched(struct iwn_softc *sc, int qid, int idx)
 {
 	uint16_t *w = &sc->sched[qid * IWN5000_SCHED_COUNT + idx];
@@ -2794,9 +2831,10 @@ iwn5000_reset_sched(struct iwn_softc *sc, int qid, int idx)
 	if (idx < IWN_SCHED_WINSZ) {
 		*(w + IWN_TX_RING_COUNT) = *w;
 		bus_dmamap_sync(sc->sched_dma.tag, sc->sched_dma.map,
-		     BUS_DMASYNC_PREWRITE);
+		    BUS_DMASYNC_PREWRITE);
 	}
 }
+#endif
 
 static uint8_t
 iwn_plcp_signal(int rate) {
@@ -2810,7 +2848,7 @@ iwn_plcp_signal(int rate) {
 	return 0;
 }
 
-int
+static int
 iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni,
     struct iwn_tx_ring *ring)
 {
@@ -2851,7 +2889,8 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni,
 	else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
 		rate = tp->ucastrate;
 	else {
-		(void) ieee80211_amrr_choose(ni, &wn->amn);
+		/* XXX pass pktlen */
+		(void) ieee80211_ratectl_rate(ni, NULL, 0);
 		rate = ni->ni_txrate;
 	}
 	ridx = iwn_plcp_signal(rate);
@@ -3001,7 +3040,7 @@ iwn_tx_data(struct iwn_softc *sc, struct mbuf *m, struct ieee80211_node *ni,
 		if (error != 0) {
 			device_printf(sc->sc_dev,
 			    "%s: bus_dmamap_load_mbuf_sg failed, error %d\n",
-			     __func__, error);
+			    __func__, error);
 			m_freem(m);
 			return error;
 		}
@@ -3196,7 +3235,7 @@ iwn_tx_data_raw(struct iwn_softc *sc, struct mbuf *m,
 		if (error != 0) {
 			device_printf(sc->sc_dev,
 			    "%s: bus_dmamap_load_mbuf_sg failed, error %d\n",
-			     __func__, error);
+			    __func__, error);
 			m_freem(m);
 			return error;
 		}
@@ -3287,7 +3326,7 @@ iwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
 	return error;
 }
 
-void
+static void
 iwn_start(struct ifnet *ifp)
 {
 	struct iwn_softc *sc = ifp->if_softc;
@@ -3297,7 +3336,7 @@ iwn_start(struct ifnet *ifp)
 	IWN_UNLOCK(sc);
 }
 
-void
+static void
 iwn_start_locked(struct ifnet *ifp)
 {
 	struct iwn_softc *sc = ifp->if_softc;
@@ -3340,7 +3379,7 @@ iwn_watchdog(struct iwn_softc *sc)
 	}
 }
 
-int
+static int
 iwn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 {
 	struct iwn_softc *sc = ifp->if_softc;
@@ -3386,7 +3425,7 @@ iwn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 /*
  * Send a command to the firmware.
  */
-int
+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];
@@ -3459,7 +3498,7 @@ iwn_cmd(struct iwn_softc *sc, int code, const void *buf, int size, int async)
 	return async ? 0 : msleep(desc, &sc->sc_mtx, PCATCH, "iwncmd", hz);
 }
 
-int
+static int
 iwn4965_add_node(struct iwn_softc *sc, struct iwn_node_info *node, int async)
 {
 	struct iwn4965_node_info hnode;
@@ -3478,7 +3517,7 @@ iwn4965_add_node(struct iwn_softc *sc, struct iwn_node_info *node, int async)
 	return iwn_cmd(sc, IWN_CMD_ADD_NODE, &hnode, sizeof hnode, async);
 }
 
-int
+static int
 iwn5000_add_node(struct iwn_softc *sc, struct iwn_node_info *node, int async)
 {
 	/* Direct mapping. */
@@ -3509,7 +3548,7 @@ static const uint8_t iwn_prev_ridx[] = {
  * Configure hardware link parameters for the specified
  * node operating on the specified channel.
  */
-int
+static int
 iwn_set_link_quality(struct iwn_softc *sc, uint8_t id, int async)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -3582,7 +3621,7 @@ iwn_set_link_quality(struct iwn_softc *sc, uint8_t id, int async)
 /*
  * Broadcast node is used to send group-addressed and management frames.
  */
-int
+static int
 iwn_add_broadcast_node(struct iwn_softc *sc, int async)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -3602,7 +3641,7 @@ iwn_add_broadcast_node(struct iwn_softc *sc, int async)
 	return error;
 }
 
-int
+static int
 iwn_wme_update(struct ieee80211com *ic)
 {
 #define IWN_EXP2(x)	((1 << (x)) - 1)	/* CWmin = 2^ECWmin - 1 */
@@ -3638,7 +3677,7 @@ iwn_update_mcast(struct ifnet *ifp)
 	/* Ignore */
 }
 
-void
+static void
 iwn_set_led(struct iwn_softc *sc, uint8_t which, uint8_t off, uint8_t on)
 {
 	struct iwn_cmd_led led;
@@ -3657,7 +3696,7 @@ iwn_set_led(struct iwn_softc *sc, uint8_t which, uint8_t off, uint8_t on)
  * Set the critical temperature at which the firmware will stop the radio
  * and notify us.
  */
-int
+static int
 iwn_set_critical_temp(struct iwn_softc *sc)
 {
 	struct iwn_critical_temp crit;
@@ -3678,7 +3717,7 @@ iwn_set_critical_temp(struct iwn_softc *sc)
 	return iwn_cmd(sc, IWN_CMD_SET_CRITICAL_TEMP, &crit, sizeof crit, 0);
 }
 
-int
+static int
 iwn_set_timing(struct iwn_softc *sc, struct ieee80211_node *ni)
 {
 	struct iwn_cmd_timing cmd;
@@ -3700,7 +3739,7 @@ iwn_set_timing(struct iwn_softc *sc, struct ieee80211_node *ni)
 	return iwn_cmd(sc, IWN_CMD_TIMING, &cmd, sizeof cmd, 1);
 }
 
-void
+static void
 iwn4965_power_calibration(struct iwn_softc *sc, int temp)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -3721,7 +3760,7 @@ iwn4965_power_calibration(struct iwn_softc *sc, int temp)
  * This function takes into account the regulatory information from EEPROM,
  * the current temperature and the current voltage.
  */
-int
+static int
 iwn4965_set_txpower(struct iwn_softc *sc, struct ieee80211_channel *ch,
     int async)
 {
@@ -3873,7 +3912,7 @@ iwn4965_set_txpower(struct iwn_softc *sc, struct ieee80211_channel *ch,
 #undef fdivround
 }
 
-int
+static int
 iwn5000_set_txpower(struct iwn_softc *sc, struct ieee80211_channel *ch,
     int async)
 {
@@ -3894,7 +3933,7 @@ iwn5000_set_txpower(struct iwn_softc *sc, struct ieee80211_channel *ch,
 /*
  * Retrieve the maximum RSSI (in dBm) among receivers.
  */
-int
+static int
 iwn4965_get_rssi(struct iwn_softc *sc, struct iwn_rx_stat *stat)
 {
 	struct iwn4965_rx_phystat *phy = (void *)stat->phybuf;
@@ -3925,7 +3964,7 @@ iwn4965_get_rssi(struct iwn_softc *sc, struct iwn_rx_stat *stat)
 	return rssi - agc - IWN_RSSI_TO_DBM;
 }
 
-int
+static int
 iwn5000_get_rssi(struct iwn_softc *sc, struct iwn_rx_stat *stat)
 {
 	struct iwn5000_rx_phystat *phy = (void *)stat->phybuf;
@@ -3948,7 +3987,7 @@ iwn5000_get_rssi(struct iwn_softc *sc, struct iwn_rx_stat *stat)
 /*
  * Retrieve the average noise (in dBm) among receivers.
  */
-int
+static int
 iwn_get_noise(const struct iwn_rx_general_stats *stats)
 {
 	int i, total, nbant, noise;
@@ -3967,7 +4006,7 @@ iwn_get_noise(const struct iwn_rx_general_stats *stats)
 /*
  * Compute temperature (in degC) from last received statistics.
  */
-int
+static int
 iwn4965_get_temperature(struct iwn_softc *sc)
 {
 	struct iwn_ucode_info *uc = &sc->ucode_info;
@@ -3992,7 +4031,7 @@ iwn4965_get_temperature(struct iwn_softc *sc)
 	return IWN_KTOC(temp);
 }
 
-int
+static int
 iwn5000_get_temperature(struct iwn_softc *sc)
 {
 	int32_t temp;
@@ -4013,7 +4052,7 @@ iwn5000_get_temperature(struct iwn_softc *sc)
 /*
  * Initialize sensitivity calibration state machine.
  */
-int
+static int
 iwn_init_sensitivity(struct iwn_softc *sc)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -4028,7 +4067,7 @@ iwn_init_sensitivity(struct iwn_softc *sc)
 	/* Set initial correlation values. */
 	calib->ofdm_x1     = sc->limits->min_ofdm_x1;
 	calib->ofdm_mrc_x1 = sc->limits->min_ofdm_mrc_x1;
-	calib->ofdm_x4     = 90;
+	calib->ofdm_x4     = sc->limits->min_ofdm_x4;
 	calib->ofdm_mrc_x4 = sc->limits->min_ofdm_mrc_x4;
 	calib->cck_x4      = 125;
 	calib->cck_mrc_x4  = sc->limits->min_cck_mrc_x4;
@@ -4055,7 +4094,7 @@ iwn_init_sensitivity(struct iwn_softc *sc)
  * after association and use them to determine connected antennas and
  * to set differential gains.
  */
-void
+static void
 iwn_collect_noise(struct iwn_softc *sc,
     const struct iwn_rx_general_stats *stats)
 {
@@ -4103,7 +4142,7 @@ iwn_collect_noise(struct iwn_softc *sc,
 #endif
 }
 
-int
+static int
 iwn4965_init_gains(struct iwn_softc *sc)
 {
 	struct iwn_phy_calib_gain cmd;
@@ -4116,14 +4155,11 @@ iwn4965_init_gains(struct iwn_softc *sc)
 	return iwn_cmd(sc, IWN_CMD_PHY_CALIB, &cmd, sizeof cmd, 1);
 }
 
-int
+static int
 iwn5000_init_gains(struct iwn_softc *sc)
 {
 	struct iwn_phy_calib cmd;
 
-	if (sc->hw_type == IWN_HW_REV_TYPE_6050)
-		return 0;
-
 	memset(&cmd, 0, sizeof cmd);
 	cmd.code = IWN5000_PHY_CALIB_RESET_NOISE_GAIN;
 	cmd.ngroups = 1;
@@ -4133,7 +4169,7 @@ iwn5000_init_gains(struct iwn_softc *sc)
 	return iwn_cmd(sc, IWN_CMD_PHY_CALIB, &cmd, sizeof cmd, 1);
 }
 
-int
+static int
 iwn4965_set_gains(struct iwn_softc *sc)
 {
 	struct iwn_calib_state *calib = &sc->calib;
@@ -4166,15 +4202,15 @@ iwn4965_set_gains(struct iwn_softc *sc)
 	return iwn_cmd(sc, IWN_CMD_PHY_CALIB, &cmd, sizeof cmd, 1);
 }
 
-int
+static int
 iwn5000_set_gains(struct iwn_softc *sc)
 {
 	struct iwn_calib_state *calib = &sc->calib;
 	struct iwn_phy_calib_gain cmd;
-	int i, ant, delta;
+	int i, ant, delta, div;
 
-	if (sc->hw_type == IWN_HW_REV_TYPE_6050)
-		return 0;
+	/* We collected 20 beacons and !=6050 need a 1.5 factor. */
+	div = (sc->hw_type == IWN_HW_REV_TYPE_6050) ? 20 : 30;
 
 	memset(&cmd, 0, sizeof cmd);
 	cmd.code = IWN5000_PHY_CALIB_NOISE_GAIN;
@@ -4187,7 +4223,7 @@ iwn5000_set_gains(struct iwn_softc *sc)
 		if (sc->chainmask & (1 << i)) {
 			/* The delta is relative to antenna "ant". */
 			delta = ((int32_t)calib->noise[ant] -
-			    (int32_t)calib->noise[i]) / 30;
+			    (int32_t)calib->noise[i]) / div;
 			/* Limit to [-4.5dB,+4.5dB]. */
 			cmd.gain[i - 1] = MIN(abs(delta), 3);
 			if (delta < 0)
@@ -4204,7 +4240,7 @@ iwn5000_set_gains(struct iwn_softc *sc)
  * Tune RF RX sensitivity based on the number of false alarms detected
  * during the last beacon period.
  */
-void
+static void
 iwn_tune_sensitivity(struct iwn_softc *sc, const struct iwn_rx_stats *stats)
 {
 #define inc(val, inc, max)			\
@@ -4331,7 +4367,7 @@ iwn_tune_sensitivity(struct iwn_softc *sc, const struct iwn_rx_stats *stats)
 
 		if (calib->cck_state != IWN_CCK_STATE_INIT &&
 		    (((int32_t)calib->noise_ref - (int32_t)noise_ref) > 2 ||
-		     calib->low_fa > 100)) {
+		    calib->low_fa > 100)) {
 			inc(calib->energy_cck, 2, limits->min_energy_cck);
 			dec(calib->cck_x4,     3, limits->min_cck_x4);
 			dec(calib->cck_mrc_x4, 3, limits->min_cck_mrc_x4);
@@ -4356,7 +4392,7 @@ iwn_tune_sensitivity(struct iwn_softc *sc, const struct iwn_rx_stats *stats)
 #undef inc
 }
 
-int
+static int
 iwn_send_sensitivity(struct iwn_softc *sc)
 {
 	struct iwn_calib_state *calib = &sc->calib;
@@ -4391,7 +4427,7 @@ iwn_send_sensitivity(struct iwn_softc *sc)
  * Set STA mode power saving level (between 0 and 5).
  * Level 0 is CAM (Continuously Aware Mode), 5 is for maximum power saving.
  */
-int
+static int
 iwn_set_pslevel(struct iwn_softc *sc, int dtim, int level, int async)
 {
 	const struct iwn_pmgt *pmgt;
@@ -4442,7 +4478,7 @@ iwn_set_pslevel(struct iwn_softc *sc, int dtim, int level, int async)
 	return iwn_cmd(sc, IWN_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async);
 }
 
-int
+static int
 iwn_config(struct iwn_softc *sc)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -4470,7 +4506,7 @@ iwn_config(struct iwn_softc *sc)
 
 	/* Configure bluetooth coexistence. */
 	memset(&bluetooth, 0, sizeof bluetooth);
-	bluetooth.flags = IWN_BT_COEX_MODE_4WIRE;
+	bluetooth.flags = IWN_BT_COEX_CHAN_ANN | IWN_BT_COEX_BT_PRIO;
 	bluetooth.lead_time = IWN_BT_LEAD_TIME_DEF;
 	bluetooth.max_kill = IWN_BT_MAX_KILL_DEF;
 	DPRINTF(sc, IWN_DEBUG_RESET, "%s: config bluetooth coexistence\n",
@@ -4555,7 +4591,7 @@ iwn_config(struct iwn_softc *sc)
 	return 0;
 }
 
-int
+static int
 iwn_scan(struct iwn_softc *sc)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -4726,7 +4762,7 @@ iwn_scan(struct iwn_softc *sc)
 	return error;
 }
 
-int
+static int
 iwn_auth(struct iwn_softc *sc, struct ieee80211vap *vap)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -4800,7 +4836,7 @@ iwn_auth(struct iwn_softc *sc, struct ieee80211vap *vap)
 /*
  * Configure the adapter for associated state.
  */
-int
+static int
 iwn_run(struct iwn_softc *sc, struct ieee80211vap *vap)
 {
 #define	MS(v,x)	(((v) & x) >> x##_S)
@@ -4891,7 +4927,6 @@ iwn_run(struct iwn_softc *sc, struct ieee80211vap *vap)
 		    __func__, error);
 		return error;
 	}
-	
 
 	/* Configuration has changed, set TX power accordingly. */
 	error = hal->set_txpower(sc, ni->ni_chan, 1);
@@ -4950,7 +4985,7 @@ iwn_run(struct iwn_softc *sc, struct ieee80211vap *vap)
  * This function is called by upper layer when an ADDBA request is received
  * from another STA and before the ADDBA response is sent.
  */
-int
+static int
 iwn_ampdu_rx_start(struct ieee80211com *ic, struct ieee80211_node *ni,
     uint8_t tid)
 {
@@ -4974,7 +5009,7 @@ iwn_ampdu_rx_start(struct ieee80211com *ic, struct ieee80211_node *ni,
  * This function is called by upper layer on teardown of an HT-immediate
  * Block Ack agreement (eg. uppon receipt of a DELBA frame.)
  */
-void
+static void
 iwn_ampdu_rx_stop(struct ieee80211com *ic, struct ieee80211_node *ni,
     uint8_t tid)
 {
@@ -4995,7 +5030,7 @@ iwn_ampdu_rx_stop(struct ieee80211com *ic, struct ieee80211_node *ni,
  * This function is called by upper layer when an ADDBA response is received
  * from another STA.
  */
-int
+static int
 iwn_ampdu_tx_start(struct ieee80211com *ic, struct ieee80211_node *ni,
     uint8_t tid)
 {
@@ -5024,7 +5059,7 @@ iwn_ampdu_tx_start(struct ieee80211com *ic, struct ieee80211_node *ni,
 	return 0;
 }
 
-void
+static void
 iwn_ampdu_tx_stop(struct ieee80211com *ic, struct ieee80211_node *ni,
     uint8_t tid)
 {
@@ -5039,7 +5074,7 @@ iwn_ampdu_tx_stop(struct ieee80211com *ic, struct ieee80211_node *ni,
 	iwn_nic_unlock(sc);
 }
 
-void
+static void
 iwn4965_ampdu_tx_start(struct iwn_softc *sc, struct ieee80211_node *ni,
     uint8_t tid, uint16_t ssn)
 {
@@ -5077,7 +5112,7 @@ iwn4965_ampdu_tx_start(struct iwn_softc *sc, struct ieee80211_node *ni,
 	    iwn_tid2fifo[tid] << 1);
 }
 
-void
+static void
 iwn4965_ampdu_tx_stop(struct iwn_softc *sc, uint8_t tid, uint16_t ssn)
 {
 	int qid = 7 + tid;
@@ -5098,7 +5133,7 @@ iwn4965_ampdu_tx_stop(struct iwn_softc *sc, uint8_t tid, uint16_t ssn)
 	    IWN4965_TXQ_STATUS_INACTIVE | iwn_tid2fifo[tid] << 1);
 }
 
-void
+static void
 iwn5000_ampdu_tx_start(struct iwn_softc *sc, struct ieee80211_node *ni,
     uint8_t tid, uint16_t ssn)
 {
@@ -5135,7 +5170,7 @@ iwn5000_ampdu_tx_start(struct iwn_softc *sc, struct ieee80211_node *ni,
 	    IWN5000_TXQ_STATUS_ACTIVE | iwn_tid2fifo[tid]);
 }
 
-void
+static void
 iwn5000_ampdu_tx_stop(struct iwn_softc *sc, uint8_t tid, uint16_t ssn)
 {
 	int qid = 10 + tid;
@@ -5164,7 +5199,7 @@ iwn5000_ampdu_tx_stop(struct iwn_softc *sc, uint8_t tid, uint16_t ssn)
  * Query calibration tables from the initialization firmware.  We do this
  * only once at first boot.  Called from a process context.
  */
-int
+static int
 iwn5000_query_calibration(struct iwn_softc *sc)
 {
 	struct iwn5000_calib_config cmd;
@@ -5191,7 +5226,7 @@ iwn5000_query_calibration(struct iwn_softc *sc)
  * Send calibration results to the runtime firmware.  These results were
  * obtained on first boot from the initialization firmware.
  */
-int
+static int
 iwn5000_send_calibration(struct iwn_softc *sc)
 {
 	int idx, error;
@@ -5214,7 +5249,7 @@ iwn5000_send_calibration(struct iwn_softc *sc)
 	return 0;
 }
 
-int
+static int
 iwn5000_send_wimax_coex(struct iwn_softc *sc)
 {
 	struct iwn5000_wimax_coex wimax;
@@ -5245,7 +5280,7 @@ iwn5000_send_wimax_coex(struct iwn_softc *sc)
  * This function is called after the runtime firmware notifies us of its
  * readiness (called in a process context.)
  */
-int
+static int
 iwn4965_post_alive(struct iwn_softc *sc)
 {
 	int error, qid;
@@ -5298,7 +5333,7 @@ iwn4965_post_alive(struct iwn_softc *sc)
  * This function is called after the initialization or runtime firmware
  * notifies us of its readiness (called in a process context.)
  */
-int
+static int
 iwn5000_post_alive(struct iwn_softc *sc)
 {
 	int error, qid;
@@ -5404,7 +5439,7 @@ iwn5000_post_alive(struct iwn_softc *sc)
  * The firmware boot code is small and is intended to be copied directly into
  * the NIC internal memory (no DMA transfer.)
  */
-int
+static int
 iwn4965_load_bootcode(struct iwn_softc *sc, const uint8_t *ucode, int size)
 {
 	int error, ntries;
@@ -5447,7 +5482,7 @@ iwn4965_load_bootcode(struct iwn_softc *sc, const uint8_t *ucode, int size)
 	return 0;
 }
 
-int
+static int
 iwn4965_load_firmware(struct iwn_softc *sc)
 {
 	struct iwn_fw_info *fw = &sc->fw;
@@ -5518,7 +5553,7 @@ iwn4965_load_firmware(struct iwn_softc *sc)
 	return 0;
 }
 
-int
+static int
 iwn5000_load_firmware_section(struct iwn_softc *sc, uint32_t dst,
     const uint8_t *section, int size)
 {
@@ -5556,7 +5591,7 @@ iwn5000_load_firmware_section(struct iwn_softc *sc, uint32_t dst,
 	return msleep(sc, &sc->sc_mtx, PCATCH, "iwninit", hz);
 }
 
-int
+static int
 iwn5000_load_firmware(struct iwn_softc *sc)
 {
 	struct iwn_fw_part *fw;
@@ -5588,7 +5623,7 @@ iwn5000_load_firmware(struct iwn_softc *sc)
 	return 0;
 }
 
-int
+static int
 iwn_read_firmware(struct iwn_softc *sc)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -5604,7 +5639,7 @@ iwn_read_firmware(struct iwn_softc *sc)
 	if (sc->fw_fp == NULL) {
 		device_printf(sc->sc_dev,
 		    "%s: could not load firmare image \"%s\"\n", __func__,
-		     sc->fwname);
+		    sc->fwname);
 		IWN_LOCK(sc);
 		return EINVAL;
 	}
@@ -5670,7 +5705,7 @@ iwn_read_firmware(struct iwn_softc *sc)
 	return 0;
 }
 
-int
+static int
 iwn_clock_wait(struct iwn_softc *sc)
 {
 	int ntries;
@@ -5689,7 +5724,7 @@ iwn_clock_wait(struct iwn_softc *sc)
 	return ETIMEDOUT;
 }
 
-int
+static int
 iwn_apm_init(struct iwn_softc *sc)
 {
 	uint32_t tmp;
@@ -5747,7 +5782,7 @@ iwn_apm_init(struct iwn_softc *sc)
 	return 0;
 }
 
-void
+static void
 iwn_apm_stop_master(struct iwn_softc *sc)
 {
 	int ntries;
@@ -5763,7 +5798,7 @@ iwn_apm_stop_master(struct iwn_softc *sc)
 	    __func__);
 }
 
-void
+static void
 iwn_apm_stop(struct iwn_softc *sc)
 {
 	iwn_apm_stop_master(sc);
@@ -5775,7 +5810,7 @@ iwn_apm_stop(struct iwn_softc *sc)
 	IWN_CLRBITS(sc, IWN_GP_CNTRL, IWN_GP_CNTRL_INIT_DONE);
 }
 
-int
+static int
 iwn4965_nic_config(struct iwn_softc *sc)
 {
 	if (IWN_RFCFG_TYPE(sc->rfcfg) == 1) {
@@ -5794,7 +5829,7 @@ iwn4965_nic_config(struct iwn_softc *sc)
 	return 0;
 }
 
-int
+static int
 iwn5000_nic_config(struct iwn_softc *sc)
 {
 	uint32_t tmp;
@@ -5831,13 +5866,17 @@ 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->calib_ver >= 6) {
+		 /* Indicate that ROM calibration version is >=6. */
+		 IWN_SETBITS(sc, IWN_GP_DRIVER, IWN_GP_DRIVER_CALIB_VER6);
+	}
 	return 0;
 }
 
 /*
  * Take NIC ownership over Intel Active Management Technology (AMT).
  */
-int
+static int
 iwn_hw_prepare(struct iwn_softc *sc)
 {
 	int ntries;
@@ -5873,7 +5912,7 @@ iwn_hw_prepare(struct iwn_softc *sc)
 	return ETIMEDOUT;
 }
 
-int
+static int
 iwn_hw_init(struct iwn_softc *sc)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -5984,7 +6023,7 @@ iwn_hw_init(struct iwn_softc *sc)
 	return hal->post_alive(sc);
 }
 
-void
+static void
 iwn_hw_stop(struct iwn_softc *sc)
 {
 	const struct iwn_hal *hal = sc->sc_hal;
@@ -6038,7 +6077,7 @@ iwn_hw_stop(struct iwn_softc *sc)
 	iwn_apm_stop(sc);
 }
 
-void
+static void
 iwn_init_locked(struct iwn_softc *sc)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -6106,7 +6145,7 @@ fail:
 	iwn_stop_locked(sc);
 }
 
-void
+static void
 iwn_init(void *arg)
 {
 	struct iwn_softc *sc = arg;
@@ -6121,7 +6160,7 @@ iwn_init(void *arg)
 		ieee80211_start_all(ic);
 }
 
-void
+static void
 iwn_stop_locked(struct iwn_softc *sc)
 {
 	struct ifnet *ifp = sc->sc_ifp;
@@ -6136,7 +6175,7 @@ iwn_stop_locked(struct iwn_softc *sc)
 	iwn_hw_stop(sc);
 }
 
-void
+static void
 iwn_stop(struct iwn_softc *sc)
 {
 	IWN_LOCK(sc);
@@ -6434,4 +6473,3 @@ DRIVER_MODULE(iwn, pci, iwn_driver, iwn_devclass, 0, 0);
 MODULE_DEPEND(iwn, pci, 1, 1, 1);
 MODULE_DEPEND(iwn, firmware, 1, 1, 1);
 MODULE_DEPEND(iwn, wlan, 1, 1, 1);
-MODULE_DEPEND(iwn, wlan_amrr, 1, 1, 1);
diff --git a/sys/dev/iwn/if_iwnreg.h b/sys/dev/iwn/if_iwnreg.h
index 0aa766938236..06e03ec7449f 100644
--- a/sys/dev/iwn/if_iwnreg.h
+++ b/sys/dev/iwn/if_iwnreg.h
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$OpenBSD: if_iwnreg.h,v 1.34 2009/11/08 11:54:48 damien Exp $	*/
+/*	$OpenBSD: if_iwnreg.h,v 1.37 2010/02/17 18:23:00 damien Exp $	*/
 
 /*-
  * Copyright (c) 2007, 2008
@@ -216,6 +216,7 @@
 #define IWN_GP_DRIVER_RADIO_3X3_HYB	(0 << 0)
 #define IWN_GP_DRIVER_RADIO_2X2_HYB	(1 << 0)
 #define IWN_GP_DRIVER_RADIO_2X2_IPA	(2 << 0)
+#define IWN_GP_DRIVER_CALIB_VER6	(1 << 2)
 
 /* Possible flags for register IWN_UCODE_GP1_CLR. */
 #define IWN_UCODE_GP1_RFKILL		(1 << 1)
@@ -832,10 +833,9 @@ struct iwn5000_cmd_txpower {
 /* Structure for command IWN_CMD_BLUETOOTH. */
 struct iwn_bluetooth {
 	uint8_t		flags;
-#define IWN_BT_COEX_DISABLE	0
-#define IWN_BT_COEX_MODE_2WIRE	1
-#define IWN_BT_COEX_MODE_3WIRE	2
-#define IWN_BT_COEX_MODE_4WIRE	3
+#define IWN_BT_COEX_CHAN_ANN	(1 << 0)
+#define IWN_BT_COEX_BT_PRIO	(1 << 1)
+#define IWN_BT_COEX_2_WIRE	(1 << 2)
 
 	uint8_t		lead_time;
 #define IWN_BT_LEAD_TIME_DEF	30
@@ -1326,6 +1326,12 @@ struct iwn_eeprom_enhinfo {
 	int8_t		mimo3;		/* max power in half-dBm */
 } __packed;
 
+struct iwn5000_eeprom_calib_hdr {
+	uint8_t		version;
+	uint8_t		pa_type;
+	uint16_t	volt;
+} __packed;
+
 #define IWN_NSAMPLES	3
 struct iwn4965_eeprom_chan_samples {
 	uint8_t	num;
@@ -1552,8 +1558,8 @@ static const struct iwn_sensitivity_limits iwn4965_sensitivity_limits = {
 };
 
 static const struct iwn_sensitivity_limits iwn5000_sensitivity_limits = {
-	120, 155,
-	240, 290,
+	120, 120,	/* min = max for performance bug in DSP. */
+	240, 240,	/* min = max for performance bug in DSP. */
 	 90, 120,
 	170, 210,
 	125, 200,
@@ -1575,8 +1581,20 @@ static const struct iwn_sensitivity_limits iwn5150_sensitivity_limits = {
 	 95
 };
 
+static const struct iwn_sensitivity_limits iwn1000_sensitivity_limits = {
+	120, 155,
+	240, 290,
+	90, 120,
+	170, 210,
+	125, 200,
+	170, 400,
+	95,
+	95,
+	95
+};
+
 static const struct iwn_sensitivity_limits iwn6000_sensitivity_limits = {
-	105, 145,
+	105, 110,
 	192, 232,
 	 80, 145,
 	128, 232,
@@ -1642,7 +1660,7 @@ static const char * const iwn_fw_errmsg[] = {
 	"DEBUG_1",
 	"DEBUG_2",
 	"DEBUG_3",
-	"UNKNOWN"
+	"ADVANCED_SYSASSERT"
 };
 
 /* Find least significant bit that is set. */
diff --git a/sys/dev/iwn/if_iwnvar.h b/sys/dev/iwn/if_iwnvar.h
index 98c9c9485533..40ce30f80a56 100644
--- a/sys/dev/iwn/if_iwnvar.h
+++ b/sys/dev/iwn/if_iwnvar.h
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$OpenBSD: if_iwnvar.h,v 1.16 2009/11/04 17:46:52 damien Exp $	*/
+/*	$OpenBSD: if_iwnvar.h,v 1.17 2010/02/17 18:23:00 damien Exp $	*/
 
 /*-
  * Copyright (c) 2007, 2008
@@ -99,7 +99,6 @@ struct iwn_rx_ring {
 
 struct iwn_node {
 	struct	ieee80211_node		ni;	/* must be the first */
-	struct	ieee80211_amrr_node	amn;
 	uint16_t			disable_tid;
 	uint8_t				id;
 	uint8_t				ridx[IEEE80211_RATE_MAXSIZE];
@@ -193,8 +192,6 @@ struct iwn_hal {
 
 struct iwn_vap {
 	struct ieee80211vap	iv_vap;
-	struct ieee80211_amrr	iv_amrr;
-	struct callout		iv_amrr_to;
 	uint8_t			iv_ridx;
 
 	int			(*iv_newstate)(struct ieee80211vap *,
@@ -284,6 +281,7 @@ struct iwn_softc {
 				bands[IWN_NBANDS];
 	struct iwn_eeprom_chan	eeprom_channels[IWN_NBANDS][IWN_MAX_CHAN_PER_BAND];
 	uint16_t		rfcfg;
+	uint8_t			calib_ver;
 	char			eeprom_domain[4];
 	uint32_t		eeprom_crystal;
 	int16_t			eeprom_voltage;
diff --git a/sys/dev/mii/miidevs b/sys/dev/mii/miidevs
index 017a0f03695e..30cd09c40719 100644
--- a/sys/dev/mii/miidevs
+++ b/sys/dev/mii/miidevs
@@ -102,6 +102,7 @@ oui xxREALTEK			0x000732
  */
 
 /* Agere Systems PHYs */
+model AGERE ET1011		0x0001 ET1011 10/100/1000baseT PHY
 model AGERE ET1011C		0x0004 ET1011C 10/100/1000baseT PHY
 
 /* Altima Communications PHYs */
diff --git a/sys/dev/mii/truephy.c b/sys/dev/mii/truephy.c
index 4eba9d98aaec..069b2a0638bf 100644
--- a/sys/dev/mii/truephy.c
+++ b/sys/dev/mii/truephy.c
@@ -76,6 +76,7 @@ static device_method_t truephy_methods[] = {
 };
 
 static const struct mii_phydesc truephys[] = {
+	MII_PHY_DESC(AGERE,	ET1011),
 	MII_PHY_DESC(AGERE,	ET1011C),
 	MII_PHY_END
 };
@@ -161,7 +162,10 @@ truephy_attach(device_t dev)
 
 	mii->mii_instance++;
 
-	truephy_reset(sc);
+	if (MII_MODEL(ma->mii_id2) == MII_MODEL_AGERE_ET1011)
+		mii_phy_reset(sc);
+	else
+		truephy_reset(sc);
 
 	sc->mii_capabilities = PHY_READ(sc, MII_BMSR) & ma->mii_capmask;
 	if (sc->mii_capabilities & BMSR_EXTSTAT) {
diff --git a/sys/dev/msk/if_msk.c b/sys/dev/msk/if_msk.c
index 63a11ab6c691..61b131bf4513 100644
--- a/sys/dev/msk/if_msk.c
+++ b/sys/dev/msk/if_msk.c
@@ -3473,6 +3473,9 @@ msk_handle_events(struct msk_softc *sc)
 	uint32_t control, status;
 	int cons, len, port, rxprog;
 
+	if (sc->msk_stat_cons == CSR_READ_2(sc, STAT_PUT_IDX))
+		return (0);
+
 	/* Sync status LEs. */
 	bus_dmamap_sync(sc->msk_stat_tag, sc->msk_stat_map,
 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
@@ -3556,7 +3559,7 @@ msk_handle_events(struct msk_softc *sc)
 	if (rxput[MSK_PORT_B] > 0)
 		msk_rxput(sc->msk_if[MSK_PORT_B]);
 
-	return (rxprog > sc->msk_process_limit ? EAGAIN : 0);
+	return (sc->msk_stat_cons != CSR_READ_2(sc, STAT_PUT_IDX));
 }
 
 static void
diff --git a/sys/dev/ofw/ofw_standard.c b/sys/dev/ofw/ofw_standard.c
index 0fda7db8467c..e521fa059d34 100644
--- a/sys/dev/ofw/ofw_standard.c
+++ b/sys/dev/ofw/ofw_standard.c
@@ -589,6 +589,7 @@ ofw_std_close(ofw_t ofw, ihandle_t instance)
 	} args = {
 		(cell_t)"close",
 		1,
+		0,
 	};
 
 	args.instance = instance;
@@ -717,6 +718,7 @@ ofw_std_release(ofw_t ofw, void *virt, size_t size)
 	} args = {
 		(cell_t)"release",
 		2,
+		0,
 	};
 
 	args.virt = (cell_t)virt;
@@ -738,6 +740,8 @@ ofw_std_enter(ofw_t ofw)
 		cell_t nreturns;
 	} args = {
 		(cell_t)"enter",
+		0,
+		0,
 	};
 
 	openfirmware(&args);
@@ -754,6 +758,8 @@ ofw_std_exit(ofw_t ofw)
 		cell_t nreturns;
 	} args = {
 		(cell_t)"exit",
+		0,
+		0,
 	};
 
 	openfirmware(&args);
diff --git a/sys/dev/ral/rt2560.c b/sys/dev/ral/rt2560.c
index 455b5ad8e723..9549107005f3 100644
--- a/sys/dev/ral/rt2560.c
+++ b/sys/dev/ral/rt2560.c
@@ -54,7 +54,7 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_radiotap.h>
 #include <net80211/ieee80211_regdomain.h>
-#include <net80211/ieee80211_amrr.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
@@ -103,8 +103,6 @@ static void		rt2560_reset_rx_ring(struct rt2560_softc *,
 			    struct rt2560_rx_ring *);
 static void		rt2560_free_rx_ring(struct rt2560_softc *,
 			    struct rt2560_rx_ring *);
-static struct ieee80211_node *rt2560_node_alloc(struct ieee80211vap *,
-			    const uint8_t [IEEE80211_ADDR_LEN]);
 static void		rt2560_newassoc(struct ieee80211_node *, int);
 static int		rt2560_newstate(struct ieee80211vap *,
 			    enum ieee80211_state, int);
@@ -307,7 +305,6 @@ rt2560_attach(device_t dev, int id)
 	ic->ic_raw_xmit = rt2560_raw_xmit;
 	ic->ic_updateslot = rt2560_update_slot;
 	ic->ic_update_promisc = rt2560_update_promisc;
-	ic->ic_node_alloc = rt2560_node_alloc;
 	ic->ic_scan_start = rt2560_scan_start;
 	ic->ic_scan_end = rt2560_scan_end;
 	ic->ic_set_channel = rt2560_set_channel;
@@ -430,11 +427,7 @@ rt2560_vap_create(struct ieee80211com *ic,
 	vap->iv_newstate = rt2560_newstate;
 	vap->iv_update_beacon = rt2560_beacon_update;
 
-	ieee80211_amrr_init(&rvp->amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    500 /* ms */);
-
+	ieee80211_ratectl_init(vap);
 	/* complete setup */
 	ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
 	if (TAILQ_FIRST(&ic->ic_vaps) == vap)
@@ -447,7 +440,7 @@ rt2560_vap_delete(struct ieee80211vap *vap)
 {
 	struct rt2560_vap *rvp = RT2560_VAP(vap);
 
-	ieee80211_amrr_cleanup(&rvp->amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(rvp, M_80211_VAP);
 }
@@ -764,25 +757,11 @@ rt2560_free_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring)
 		bus_dma_tag_destroy(ring->data_dmat);
 }
 
-static struct ieee80211_node *
-rt2560_node_alloc(struct ieee80211vap *vap,
-	const uint8_t mac[IEEE80211_ADDR_LEN])
-{
-	struct rt2560_node *rn;
-
-	rn = malloc(sizeof (struct rt2560_node), M_80211_NODE,
-	    M_NOWAIT | M_ZERO);
-
-	return (rn != NULL) ? &rn->ni : NULL;
-}
-
 static void
 rt2560_newassoc(struct ieee80211_node *ni, int isnew)
 {
-	struct ieee80211vap *vap = ni->ni_vap;
-
-	ieee80211_amrr_node_init(&RT2560_VAP(vap)->amrr,
-	    &RT2560_NODE(ni)->amrr, ni);
+	/* XXX move */
+	ieee80211_ratectl_node_init(ni);
 }
 
 static int
@@ -955,10 +934,11 @@ rt2560_tx_intr(struct rt2560_softc *sc)
 	struct ifnet *ifp = sc->sc_ifp;
 	struct rt2560_tx_desc *desc;
 	struct rt2560_tx_data *data;
-	struct rt2560_node *rn;
 	struct mbuf *m;
 	uint32_t flags;
 	int retrycnt;
+	struct ieee80211vap *vap;
+	struct ieee80211_node *ni;
 
 	bus_dmamap_sync(sc->txq.desc_dmat, sc->txq.desc_map,
 	    BUS_DMASYNC_POSTREAD);
@@ -973,15 +953,19 @@ rt2560_tx_intr(struct rt2560_softc *sc)
 		    !(flags & RT2560_TX_VALID))
 			break;
 
-		rn = (struct rt2560_node *)data->ni;
 		m = data->m;
+		ni = data->ni;
+		vap = ni->ni_vap;
 
 		switch (flags & RT2560_TX_RESULT_MASK) {
 		case RT2560_TX_SUCCESS:
+			retrycnt = 0;
+
 			DPRINTFN(sc, 10, "%s\n", "data frame sent successfully");
 			if (data->rix != IEEE80211_FIXED_RATE_NONE)
-				ieee80211_amrr_tx_complete(&rn->amrr,
-				    IEEE80211_AMRR_SUCCESS, 0);
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_SUCCESS,
+				    &retrycnt, NULL);
 			ifp->if_opackets++;
 			break;
 
@@ -991,8 +975,9 @@ rt2560_tx_intr(struct rt2560_softc *sc)
 			DPRINTFN(sc, 9, "data frame sent after %u retries\n",
 			    retrycnt);
 			if (data->rix != IEEE80211_FIXED_RATE_NONE)
-				ieee80211_amrr_tx_complete(&rn->amrr,
-				    IEEE80211_AMRR_SUCCESS, retrycnt);
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_SUCCESS,
+				    &retrycnt, NULL);
 			ifp->if_opackets++;
 			break;
 
@@ -1002,8 +987,9 @@ rt2560_tx_intr(struct rt2560_softc *sc)
 			DPRINTFN(sc, 9, "data frame failed after %d retries\n",
 			    retrycnt);
 			if (data->rix != IEEE80211_FIXED_RATE_NONE)
-				ieee80211_amrr_tx_complete(&rn->amrr,
-				    IEEE80211_AMRR_FAILURE, retrycnt);
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_FAILURE,
+				    &retrycnt, NULL);
 			ifp->if_oerrors++;
 			break;
 
@@ -1821,7 +1807,7 @@ rt2560_tx_data(struct rt2560_softc *sc, struct mbuf *m0,
 	} else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) {
 		rate = tp->ucastrate;
 	} else {
-		(void) ieee80211_amrr_choose(ni, &RT2560_NODE(ni)->amrr);
+		(void) ieee80211_ratectl_rate(ni, NULL, 0);
 		rate = ni->ni_txrate;
 	}
 
diff --git a/sys/dev/ral/rt2560var.h b/sys/dev/ral/rt2560var.h
index 288577b62667..b6a8d68e9236 100644
--- a/sys/dev/ral/rt2560var.h
+++ b/sys/dev/ral/rt2560var.h
@@ -95,16 +95,9 @@ struct rt2560_rx_ring {
 	int			cur_decrypt;
 };
 
-struct rt2560_node {
-	struct ieee80211_node	ni;
-	struct ieee80211_amrr_node amrr;
-};
-#define	RT2560_NODE(ni)		((struct rt2560_node *)(ni))
-
 struct rt2560_vap {
 	struct ieee80211vap	ral_vap;
 	struct ieee80211_beacon_offsets	ral_bo;
-	struct ieee80211_amrr	amrr;
 
 	int			(*ral_newstate)(struct ieee80211vap *,
 				    enum ieee80211_state, int);
diff --git a/sys/dev/ral/rt2661.c b/sys/dev/ral/rt2661.c
index 9e6693f43d18..9bc88385768a 100644
--- a/sys/dev/ral/rt2661.c
+++ b/sys/dev/ral/rt2661.c
@@ -55,7 +55,7 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_radiotap.h>
 #include <net80211/ieee80211_regdomain.h>
-#include <net80211/ieee80211_amrr.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
@@ -100,8 +100,6 @@ static void		rt2661_reset_rx_ring(struct rt2661_softc *,
 			    struct rt2661_rx_ring *);
 static void		rt2661_free_rx_ring(struct rt2661_softc *,
 			    struct rt2661_rx_ring *);
-static struct ieee80211_node *rt2661_node_alloc(struct ieee80211vap *,
-			    const uint8_t [IEEE80211_ADDR_LEN]);
 static void		rt2661_newassoc(struct ieee80211_node *, int);
 static int		rt2661_newstate(struct ieee80211vap *,
 			    enum ieee80211_state, int);
@@ -307,7 +305,6 @@ rt2661_attach(device_t dev, int id)
 
 	ieee80211_ifattach(ic, macaddr);
 	ic->ic_newassoc = rt2661_newassoc;
-	ic->ic_node_alloc = rt2661_node_alloc;
 #if 0
 	ic->ic_wme.wme_update = rt2661_wme_update;
 #endif
@@ -428,11 +425,7 @@ rt2661_vap_create(struct ieee80211com *ic,
 	vap->iv_update_beacon = rt2661_beacon_update;
 #endif
 
-	ieee80211_amrr_init(&rvp->amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    500 /* ms */);
-
+	ieee80211_ratectl_init(vap);
 	/* complete setup */
 	ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
 	if (TAILQ_FIRST(&ic->ic_vaps) == vap)
@@ -445,7 +438,7 @@ rt2661_vap_delete(struct ieee80211vap *vap)
 {
 	struct rt2661_vap *rvp = RT2661_VAP(vap);
 
-	ieee80211_amrr_cleanup(&rvp->amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(rvp, M_80211_VAP);
 }
@@ -771,25 +764,11 @@ rt2661_free_rx_ring(struct rt2661_softc *sc, struct rt2661_rx_ring *ring)
 		bus_dma_tag_destroy(ring->data_dmat);
 }
 
-static struct ieee80211_node *
-rt2661_node_alloc(struct ieee80211vap *vap,
-	const uint8_t mac[IEEE80211_ADDR_LEN])
-{
-	struct rt2661_node *rn;
-
-	rn = malloc(sizeof (struct rt2661_node), M_80211_NODE,
-	    M_NOWAIT | M_ZERO);
-
-	return (rn != NULL) ? &rn->ni : NULL;
-}
-
 static void
 rt2661_newassoc(struct ieee80211_node *ni, int isnew)
 {
-	struct ieee80211vap *vap = ni->ni_vap;
-
-	ieee80211_amrr_node_init(&RT2661_VAP(vap)->amrr,
-	    &RT2661_NODE(ni)->amrr, ni);
+	/* XXX move */
+	ieee80211_ratectl_node_init(ni);
 }
 
 static int
@@ -899,9 +878,9 @@ rt2661_tx_intr(struct rt2661_softc *sc)
 	struct ifnet *ifp = sc->sc_ifp;
 	struct rt2661_tx_ring *txq;
 	struct rt2661_tx_data *data;
-	struct rt2661_node *rn;
 	uint32_t val;
 	int qid, retrycnt;
+	struct ieee80211vap *vap;
 
 	for (;;) {
 		struct ieee80211_node *ni;
@@ -925,8 +904,8 @@ rt2661_tx_intr(struct rt2661_softc *sc)
 		/* if no frame has been sent, ignore */
 		if (ni == NULL)
 			continue;
-
-		rn = RT2661_NODE(ni);
+		else
+			vap = ni->ni_vap;
 
 		switch (RT2661_TX_RESULT(val)) {
 		case RT2661_TX_SUCCESS:
@@ -935,8 +914,9 @@ rt2661_tx_intr(struct rt2661_softc *sc)
 			DPRINTFN(sc, 10, "data frame sent successfully after "
 			    "%d retries\n", retrycnt);
 			if (data->rix != IEEE80211_FIXED_RATE_NONE)
-				ieee80211_amrr_tx_complete(&rn->amrr,
-				    IEEE80211_AMRR_SUCCESS, retrycnt);
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_SUCCESS,
+				    &retrycnt, NULL);
 			ifp->if_opackets++;
 			break;
 
@@ -946,8 +926,9 @@ rt2661_tx_intr(struct rt2661_softc *sc)
 			DPRINTFN(sc, 9, "%s\n",
 			    "sending data frame failed (too much retries)");
 			if (data->rix != IEEE80211_FIXED_RATE_NONE)
-				ieee80211_amrr_tx_complete(&rn->amrr,
-				    IEEE80211_AMRR_FAILURE, retrycnt);
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_FAILURE,
+				    &retrycnt, NULL);
 			ifp->if_oerrors++;
 			break;
 
@@ -1511,7 +1492,7 @@ rt2661_tx_data(struct rt2661_softc *sc, struct mbuf *m0,
 	} else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) {
 		rate = tp->ucastrate;
 	} else {
-		(void) ieee80211_amrr_choose(ni, &RT2661_NODE(ni)->amrr);
+		(void) ieee80211_ratectl_rate(ni, NULL, 0);
 		rate = ni->ni_txrate;
 	}
 	rate &= IEEE80211_RATE_VAL;
diff --git a/sys/dev/ral/rt2661var.h b/sys/dev/ral/rt2661var.h
index db1d4de56f80..9927d138fa71 100644
--- a/sys/dev/ral/rt2661var.h
+++ b/sys/dev/ral/rt2661var.h
@@ -88,15 +88,8 @@ struct rt2661_rx_ring {
 	int			next;
 };
 
-struct rt2661_node {
-	struct ieee80211_node	ni;
-	struct ieee80211_amrr_node amrr;
-};
-#define	RT2661_NODE(ni)		((struct rt2661_node *)(ni))
-
 struct rt2661_vap {
 	struct ieee80211vap	ral_vap;
-	struct ieee80211_amrr	amrr;
 
 	int			(*ral_newstate)(struct ieee80211vap *,
 				    enum ieee80211_state, int);
diff --git a/sys/dev/re/if_re.c b/sys/dev/re/if_re.c
index 978580179d5d..80915061c7d3 100644
--- a/sys/dev/re/if_re.c
+++ b/sys/dev/re/if_re.c
@@ -174,8 +174,7 @@ static struct rl_type re_devs[] = {
 	{ RT_VENDORID, RT_DEVICEID_8101E, 0,
 	    "RealTek 8101E/8102E/8102EL/8103E PCIe 10/100baseTX" },
 	{ RT_VENDORID, RT_DEVICEID_8168, 0,
-	    "RealTek 8168/8168B/8168C/8168CP/8168D/8168DP/"
-	    "8111B/8111C/8111CP/8111DP PCIe Gigabit Ethernet" },
+	    "RealTek 8168/8111 B/C/CP/D/DP/E PCIe Gigabit Ethernet" },
 	{ RT_VENDORID, RT_DEVICEID_8169, 0,
 	    "RealTek 8169/8169S/8169SB(L)/8110S/8110SB(L) Gigabit Ethernet" },
 	{ RT_VENDORID, RT_DEVICEID_8169SC, 0,
@@ -220,6 +219,7 @@ static struct rl_hwrev re_hwrevs[] = {
 	{ RL_HWREV_8168CP, RL_8169, "8168CP/8111CP"},
 	{ RL_HWREV_8168D, RL_8169, "8168D/8111D"},
 	{ RL_HWREV_8168DP, RL_8169, "8168DP/8111DP"},
+	{ RL_HWREV_8168E, RL_8169, "8168E/8111E"},
 	{ 0, 0, NULL }
 };
 
@@ -1310,6 +1310,11 @@ re_attach(device_t dev)
 		 */
 		sc->rl_flags |= RL_FLAG_NOJUMBO;
 		break;
+	case RL_HWREV_8168E:
+		sc->rl_flags |= RL_FLAG_PHYWAKE | RL_FLAG_PHYWAKE_PM |
+		    RL_FLAG_PAR | RL_FLAG_DESCV2 | RL_FLAG_MACSTAT |
+		    RL_FLAG_CMDSTOP | RL_FLAG_AUTOPAD | RL_FLAG_NOJUMBO;
+		break;
 	case RL_HWREV_8169_8110SB:
 	case RL_HWREV_8169_8110SBL:
 	case RL_HWREV_8169_8110SC:
@@ -1393,6 +1398,8 @@ re_attach(device_t dev)
 	}
 
 	/* Take PHY out of power down mode. */
+	if ((sc->rl_flags & RL_FLAG_PHYWAKE_PM) != 0)
+		CSR_WRITE_1(sc, RL_PMCH, CSR_READ_1(sc, RL_PMCH) | 0x80);
 	if ((sc->rl_flags & RL_FLAG_PHYWAKE) != 0) {
 		re_gmii_writereg(dev, 1, 0x1f, 0);
 		re_gmii_writereg(dev, 1, 0x0e, 0);
@@ -3135,6 +3142,9 @@ re_setwol(struct rl_softc *sc)
 		v |= RL_CFG5_WOL_LANWAKE;
 	CSR_WRITE_1(sc, RL_CFG5, v);
 
+	if ((ifp->if_capenable & IFCAP_WOL) != 0 &&
+	    (sc->rl_flags & RL_FLAG_PHYWAKE_PM) != 0)
+		CSR_WRITE_1(sc, RL_PMCH, CSR_READ_1(sc, RL_PMCH) & ~0x80);
 	/*
 	 * It seems that hardware resets its link speed to 100Mbps in
 	 * power down mode so switching to 100Mbps in driver is not
diff --git a/sys/dev/syscons/logo/beastie.c b/sys/dev/syscons/logo/beastie.c
new file mode 100644
index 000000000000..ea3f46e5c3a7
--- /dev/null
+++ b/sys/dev/syscons/logo/beastie.c
@@ -0,0 +1,358 @@
+/* $FreeBSD$ */
+
+#define logo_width 88
+#define logo_height 88
+
+unsigned int logo_w = logo_width;
+unsigned int logo_h = logo_height;
+
+unsigned char logo_pal[768] = {
+    0x00, 0x00, 0x00,
+    0x33, 0x33, 0x33,
+    0x66, 0x66, 0x66,
+    0x99, 0x99, 0x99,
+    0xcc, 0xcc, 0xcc,
+    0xff, 0xff, 0xff,
+    0x90, 0x8f, 0x90,
+    0x56, 0x4b, 0x55,
+    0xa3, 0xa5, 0xab,
+    0xfd, 0xfd, 0xfd,
+    0x6d, 0x6e, 0x74,
+    0x41, 0x2b, 0x39,
+    0xcb, 0xc8, 0xcb,
+    0xcf, 0xbb, 0xba,
+    0x8e, 0x82, 0x87,
+    0x5c, 0x5d, 0x60,
+    0x52, 0x2a, 0x37,
+    0x7f, 0x76, 0x7d,
+    0x82, 0x82, 0x85,
+    0x7a, 0x3e, 0x45,
+    0x7f, 0x6e, 0x70,
+    0xef, 0xef, 0xed,
+    0x53, 0x41, 0x4b,
+    0x67, 0x2b, 0x35,
+    0x6a, 0x55, 0x62,
+    0xe7, 0xe2, 0xe3,
+    0x64, 0x35, 0x3f,
+    0xf7, 0xe0, 0xe7,
+    0xb1, 0xb2, 0xb2,
+    0x31, 0x2b, 0x35,
+    0x7a, 0x2d, 0x37,
+    0x69, 0x4c, 0x56,
+    0x95, 0x9d, 0xa4,
+    0x85, 0x61, 0x69,
+    0x40, 0x34, 0x41,
+    0x8f, 0x2e, 0x39,
+    0x7a, 0x50, 0x5a,
+    0xde, 0xe1, 0xe0,
+    0x32, 0x33, 0x3d,
+    0xa0, 0x9b, 0x9c,
+    0x68, 0x63, 0x67,
+    0x76, 0x60, 0x67,
+    0xba, 0xb6, 0xb8,
+    0x29, 0x24, 0x41,
+    0x38, 0x21, 0x29,
+    0x42, 0x21, 0x27,
+    0xa2, 0x2a, 0x32,
+    0x56, 0x55, 0x58,
+    0x55, 0x21, 0x2b,
+    0x7a, 0x20, 0x2a,
+    0x37, 0x16, 0x21,
+    0x4d, 0x18, 0x37,
+    0x8a, 0x3a, 0x3e,
+    0xc0, 0xc2, 0xc4,
+    0x64, 0x23, 0x2c,
+    0x37, 0x1a, 0x24,
+    0x42, 0x18, 0x20,
+    0x4c, 0x21, 0x2b,
+    0xa0, 0x23, 0x2e,
+    0x95, 0x6c, 0x76,
+    0x26, 0x16, 0x1c,
+    0xa5, 0x18, 0x23,
+    0x84, 0x20, 0x2b,
+    0x6d, 0x3f, 0x49,
+    0xae, 0xa7, 0xac,
+    0x2a, 0x1f, 0x24,
+    0x90, 0x21, 0x30,
+    0xa0, 0x39, 0x3e,
+    0x95, 0x0f, 0x1c,
+    0x84, 0x13, 0x1e,
+    0x4e, 0x17, 0x24,
+    0x8c, 0x56, 0x5f,
+    0xe0, 0xc4, 0xcb,
+    0xa5, 0x7f, 0x8e,
+    0xff, 0xff, 0xf1,
+    0x3d, 0x3d, 0x5d,
+    0x61, 0x19, 0x26,
+    0xd5, 0xd5, 0xd5,
+    0xff, 0xf1, 0xed,
+    0xb6, 0x9c, 0xa5,
+    0x87, 0x4c, 0x5a,
+    0xa0, 0x76, 0x76,
+    0xc8, 0xa0, 0xa0,
+    0xa2, 0xc1, 0xc8,
+    0x91, 0xae, 0xb6,
+    0x52, 0x8b, 0xae,
+    0xb3, 0xd2, 0xd4,
+    0x95, 0xb7, 0xc1,
+    0x54, 0x6e, 0x83,
+    0x67, 0x90, 0xa6,
+    0x44, 0x3e, 0x45,
+    0x23, 0x40, 0x6a,
+    0x41, 0x6e, 0x97,
+    0x7e, 0x8e, 0x91,
+    0x52, 0x33, 0x41,
+    0x39, 0x49, 0x68,
+    0x1d, 0x2a, 0x48,
+    0x17, 0x21, 0x45,
+    0x90, 0x17, 0x1f,
+    0x38, 0x54, 0x71,
+    0x1c, 0x33, 0x58,
+    0x1c, 0x1e, 0x23,
+    0x6c, 0x17, 0x21,
+    0xb0, 0xc5, 0xc1,
+    0x5d, 0x7f, 0x96,
+    0xe9, 0xbf, 0xc1,
+    0x96, 0x06, 0x0f,
+    0x78, 0x16, 0x1e,
+    0xab, 0x0e, 0x18,
+    0xa6, 0x06, 0x0e,
+    0x4c, 0x4c, 0x54,
+    0x61, 0x42, 0x4c,
+    0x48, 0x5f, 0x84,
+    0xa0, 0xb8, 0xbe,
+    0x5c, 0x66, 0x7f,
+    0x7b, 0x9e, 0xa9,
+    0x6f, 0x75, 0x7f,
+    0x45, 0x54, 0x74,
+    0x32, 0x3e, 0x63,
+    0xb1, 0xb4, 0xb3,
+    0x66, 0x9d, 0xb4,
+    0x7a, 0x9f, 0xbb,
+    0x82, 0xaa, 0xba,
+    0x13, 0x15, 0x17,
+    0x0b, 0x0b, 0x0a,
+    0x37, 0x66, 0x92,
+    0x4c, 0x7f, 0xa5,
+    0x24, 0x4c, 0x7b,
+    0x25, 0x5f, 0x91,
+    0x40, 0x7d, 0xa5,
+    0x1d, 0x56, 0x88,
+    0x2d, 0x6f, 0xa0,
+    0x70, 0x81, 0x8f,
+    0x58, 0x97, 0xbd,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00,
+};
+
+unsigned char logo_img[logo_width*logo_height] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x09, 0x0a, 0x0b, 0x07, 0x0c, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0d, 0x0e, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x09, 0x0f, 0x0b, 0x10, 0x11, 0x09, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x12, 0x13, 0x14, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x15, 0x16, 0x0b, 0x17, 0x18, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, 0x13, 0x1a, 0x1b, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x1c, 0x1d, 0x10, 0x1e, 0x1f, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x20, 0x0b, 0x1e, 0x21, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x19, 0x22, 0x0b, 0x17, 0x23, 0x24, 0x15, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x25, 0x26, 0x10, 0x23, 0x27, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x05, 0x05, 0x05, 0x25, 0x27, 0x11, 0x28, 0x29, 0x11, 0x06, 0x0d, 0x09, 0x05, 0x2a, 0x2b, 0x2c, 0x2d, 0x1e, 0x2e, 0x21, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2f, 0x0b, 0x30, 0x31, 0x0c, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x15, 0x06, 0x16, 0x22, 0x1d, 0x2c, 0x32, 0x33, 0x17, 0x17, 0x17, 0x22, 0x14, 0x16, 0x1d, 0x2c, 0x2d, 0x1e, 0x2e, 0x34, 0x0c, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x2b, 0x2c, 0x36, 0x36, 0x35, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x27, 0x0b, 0x2c, 0x2c, 0x37, 0x32, 0x38, 0x2c, 0x2d, 0x39, 0x36, 0x17, 0x30, 0x2c, 0x2c, 0x2d, 0x2c, 0x2c, 0x1a, 0x3a, 0x3a, 0x3b, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0a, 0x2d, 0x2b, 0x33, 0x31, 0x0e, 0x05, 0x05, 0x05, 0x05, 0x09, 0x28, 0x2c, 0x37, 0x3c, 0x32, 0x38, 0x38, 0x37, 0x2c, 0x30, 0x36, 0x36, 0x17, 0x31, 0x36, 0x23, 0x23, 0x17, 0x2c, 0x17, 0x3a, 0x3d, 0x13, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x22, 0x2c, 0x37, 0x33, 0x3e, 0x31, 0x3f, 0x40, 0x19, 0x05, 0x11, 0x2c, 0x2c, 0x32, 0x32, 0x32, 0x38, 0x37, 0x41, 0x30, 0x3a, 0x3a, 0x2e, 0x42, 0x43, 0x17, 0x1a, 0x13, 0x23, 0x31, 0x1a, 0x2e, 0x3d, 0x1a, 0x09, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0b, 0x37, 0x32, 0x37, 0x33, 0x44, 0x44, 0x45, 0x17, 0x1a, 0x10, 0x2d, 0x37, 0x38, 0x46, 0x33, 0x46, 0x32, 0x2c, 0x23, 0x23, 0x47, 0x21, 0x13, 0x43, 0x34, 0x48, 0x19, 0x49, 0x34, 0x17, 0x1e, 0x3a, 0x13, 0x4a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4b, 0x32, 0x32, 0x32, 0x32, 0x4c, 0x45, 0x44, 0x44, 0x42, 0x36, 0x30, 0x33, 0x46, 0x38, 0x33, 0x46, 0x38, 0x31, 0x23, 0x27, 0x09, 0x4a, 0x4d, 0x47, 0x43, 0x0d, 0x4e, 0x4a, 0x4f, 0x34, 0x1a, 0x2e, 0x29, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, 0x33, 0x32, 0x32, 0x32, 0x33, 0x4c, 0x31, 0x45, 0x3e, 0x31, 0x36, 0x46, 0x46, 0x33, 0x33, 0x39, 0x30, 0x23, 0x50, 0x4a, 0x4a, 0x4a, 0x4a, 0x4d, 0x47, 0x51, 0x4e, 0x4a, 0x4a, 0x0e, 0x13, 0x1a, 0x27, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x2b, 0x32, 0x32, 0x2b, 0x32, 0x33, 0x4c, 0x33, 0x4c, 0x4c, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x23, 0x3a, 0x49, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4f, 0x50, 0x1b, 0x4e, 0x4a, 0x19, 0x50, 0x16, 0x0c, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x32, 0x32, 0x32, 0x32, 0x2b, 0x33, 0x33, 0x30, 0x2d, 0x39, 0x30, 0x30, 0x30, 0x4c, 0x36, 0x42, 0x3a, 0x52, 0x05, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0x3b, 0x52, 0x4e, 0x4a, 0x4a, 0x4f, 0x1a, 0x2a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4d, 0x2b, 0x2b, 0x32, 0x32, 0x32, 0x37, 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x10, 0x30, 0x30, 0x3e, 0x23, 0x3a, 0x0d, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x40, 0x51, 0x4a, 0x4a, 0x25, 0x15, 0x1f, 0x27, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x22, 0x2c, 0x32, 0x32, 0x32, 0x38, 0x2d, 0x2c, 0x41, 0x32, 0x39, 0x46, 0x4c, 0x31, 0x2e, 0x2e, 0x0c, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x25, 0x53, 0x18, 0x4a, 0x54, 0x55, 0x56, 0x51, 0x11, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x22, 0x32, 0x32, 0x32, 0x38, 0x38, 0x32, 0x2c, 0x37, 0x38, 0x30, 0x30, 0x3e, 0x3a, 0x3a, 0x2a, 0x4a, 0x4a, 0x05, 0x4a, 0x57, 0x58, 0x59, 0x5a, 0x35, 0x58, 0x5b, 0x5c, 0x5d, 0x5e, 0x4a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4d, 0x07, 0x37, 0x32, 0x38, 0x38, 0x32, 0x32, 0x41, 0x38, 0x30, 0x30, 0x3e, 0x3a, 0x3d, 0x27, 0x05, 0x4a, 0x4a, 0x4a, 0x5c, 0x5f, 0x59, 0x1d, 0x29, 0x2f, 0x60, 0x61, 0x26, 0x0b, 0x1c, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4e, 0x0a, 0x2d, 0x38, 0x38, 0x32, 0x37, 0x32, 0x2d, 0x39, 0x36, 0x31, 0x62, 0x3d, 0x0e, 0x4a, 0x4a, 0x4a, 0x09, 0x63, 0x64, 0x64, 0x61, 0x2d, 0x1d, 0x65, 0x61, 0x2b, 0x17, 0x16, 0x4a, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x27, 0x2c, 0x38, 0x38, 0x37, 0x37, 0x38, 0x2d, 0x30, 0x31, 0x42, 0x3a, 0x18, 0x09, 0x05, 0x05, 0x4a, 0x63, 0x60, 0x60, 0x2b, 0x10, 0x2d, 0x41, 0x41, 0x30, 0x42, 0x3e, 0x29, 0x09, 0x05, 0x05, 0x04, 0x03, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x37, 0x32, 0x38, 0x32, 0x41, 0x38, 0x38, 0x30, 0x66, 0x31, 0x3a, 0x1e, 0x67, 0x4a, 0x4a, 0x05, 0x68, 0x64, 0x61, 0x2b, 0x17, 0x36, 0x10, 0x33, 0x31, 0x42, 0x3d, 0x45, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x1c, 0x2c, 0x32, 0x32, 0x37, 0x41, 0x2c, 0x46, 0x30, 0x36, 0x36, 0x42, 0x42, 0x29, 0x1b, 0x4a, 0x4a, 0x4d, 0x26, 0x60, 0x0b, 0x17, 0x36, 0x44, 0x45, 0x66, 0x3e, 0x44, 0x44, 0x1a, 0x05, 0x05, 0x05, 0x05, 0x05, 0x15, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0c, 0x2c, 0x32, 0x32, 0x38, 0x37, 0x32, 0x37, 0x30, 0x36, 0x4c, 0x31, 0x1e, 0x10, 0x1f, 0x52, 0x69, 0x52, 0x07, 0x2c, 0x10, 0x36, 0x62, 0x6a, 0x44, 0x6b, 0x3e, 0x44, 0x6c, 0x30, 0x09, 0x05, 0x05, 0x25, 0x54, 0x19, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x25, 0x2c, 0x37, 0x38, 0x37, 0x2c, 0x32, 0x32, 0x46, 0x30, 0x46, 0x4c, 0x31, 0x66, 0x4c, 0x36, 0x1a, 0x1a, 0x17, 0x37, 0x37, 0x10, 0x31, 0x62, 0x45, 0x4c, 0x3e, 0x44, 0x62, 0x30, 0x09, 0x05, 0x0a, 0x70, 0x71, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x22, 0x32, 0x32, 0x38, 0x41, 0x41, 0x38, 0x2d, 0x46, 0x66, 0x44, 0x6c, 0x6c, 0x6c, 0x3d, 0x3a, 0x42, 0x31, 0x32, 0x32, 0x32, 0x33, 0x33, 0x30, 0x36, 0x3e, 0x3e, 0x31, 0x07, 0x05, 0x12, 0x6e, 0x72, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x2d, 0x2c, 0x38, 0x32, 0x41, 0x37, 0x2d, 0x46, 0x66, 0x6a, 0x6c, 0x6d, 0x6d, 0x6c, 0x3d, 0x3d, 0x31, 0x38, 0x38, 0x39, 0x33, 0x39, 0x36, 0x30, 0x30, 0x66, 0x30, 0x40, 0x4d, 0x5f, 0x4d, 0x4d, 0x05, 0x05, 0x05, 0x15, 0x04, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x5a, 0x2d, 0x32, 0x32, 0x37, 0x37, 0x32, 0x38, 0x46, 0x46, 0x66, 0x45, 0x44, 0x62, 0x44, 0x44, 0x3e, 0x31, 0x31, 0x31, 0x31, 0x31, 0x33, 0x37, 0x30, 0x10, 0x06, 0x05, 0x12, 0x0a, 0x05, 0x05, 0x05, 0x08, 0x68, 0x73, 0x05, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x22, 0x32, 0x32, 0x32, 0x3c, 0x37, 0x37, 0x2d, 0x39, 0x39, 0x39, 0x36, 0x36, 0x6b, 0x3e, 0x3e, 0x3e, 0x3e, 0x31, 0x4c, 0x39, 0x2d, 0x10, 0x16, 0x2a, 0x05, 0x05, 0x74, 0x74, 0x05, 0x05, 0x0c, 0x75, 0x5f, 0x1c, 0x05, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x2c, 0x32, 0x32, 0x32, 0x41, 0x37, 0x41, 0x2c, 0x2c, 0x41, 0x2c, 0x33, 0x36, 0x31, 0x36, 0x31, 0x31, 0x17, 0x46, 0x2c, 0x16, 0x40, 0x05, 0x05, 0x05, 0x05, 0x20, 0x5f, 0x4d, 0x72, 0x76, 0x06, 0x25, 0x4a, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x0b, 0x2d, 0x37, 0x2d, 0x2c, 0x2c, 0x37, 0x37, 0x38, 0x2c, 0x37, 0x2c, 0x10, 0x10, 0x39, 0x30, 0x0b, 0x2c, 0x11, 0x09, 0x05, 0x09, 0x4a, 0x05, 0x05, 0x19, 0x1d, 0x26, 0x76, 0x08, 0x05, 0x05, 0x05, 0x15, 0x25, 0x4d, 0x53, 0x77, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4d, 0x5a, 0x2c, 0x37, 0x2d, 0x2c, 0x37, 0x37, 0x39, 0x39, 0x33, 0x38, 0x2c, 0x2d, 0x2d, 0x2c, 0x5e, 0x2a, 0x05, 0x15, 0x3b, 0x17, 0x1f, 0x19, 0x05, 0x06, 0x26, 0x60, 0x5f, 0x0c, 0x05, 0x05, 0x05, 0x35, 0x68, 0x78, 0x56, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x2c, 0x2c, 0x2c, 0x37, 0x32, 0x37, 0x2c, 0x37, 0x32, 0x46, 0x33, 0x46, 0x39, 0x11, 0x15, 0x05, 0x05, 0x18, 0x31, 0x44, 0x6a, 0x30, 0x6e, 0x2b, 0x4b, 0x11, 0x5f, 0x63, 0x72, 0x54, 0x20, 0x74, 0x58, 0x25, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x15, 0x0b, 0x2c, 0x38, 0x2d, 0x39, 0x39, 0x2d, 0x37, 0x3c, 0x32, 0x37, 0x0b, 0x18, 0x05, 0x05, 0x05, 0x4e, 0x26, 0x32, 0x45, 0x6a, 0x46, 0x2b, 0x72, 0x4e, 0x05, 0x35, 0x0a, 0x75, 0x5f, 0x70, 0x08, 0x09, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x22, 0x2d, 0x30, 0x6b, 0x6b, 0x66, 0x36, 0x30, 0x36, 0x4c, 0x36, 0x30, 0x18, 0x05, 0x05, 0x05, 0x09, 0x4b, 0x32, 0x46, 0x66, 0x38, 0x0b, 0x09, 0x05, 0x05, 0x05, 0x05, 0x09, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0a, 0x2c, 0x2c, 0x31, 0x62, 0x62, 0x6b, 0x31, 0x45, 0x44, 0x44, 0x45, 0x31, 0x10, 0x0c, 0x4d, 0x0c, 0x08, 0x0b, 0x3c, 0x32, 0x33, 0x66, 0x17, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x22, 0x2c, 0x2d, 0x31, 0x45, 0x6b, 0x36, 0x31, 0x6b, 0x62, 0x45, 0x6a, 0x66, 0x30, 0x0b, 0x2c, 0x2c, 0x2c, 0x2c, 0x37, 0x46, 0x6b, 0x44, 0x62, 0x5e, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0c, 0x1d, 0x2c, 0x39, 0x36, 0x4c, 0x30, 0x30, 0x30, 0x36, 0x4c, 0x66, 0x4c, 0x36, 0x30, 0x37, 0x41, 0x2c, 0x2d, 0x2c, 0x3c, 0x33, 0x6b, 0x44, 0x44, 0x39, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x2d, 0x2d, 0x2d, 0x36, 0x39, 0x2d, 0x32, 0x38, 0x38, 0x46, 0x6a, 0x6d, 0x3d, 0x62, 0x46, 0x3c, 0x37, 0x2d, 0x32, 0x32, 0x32, 0x38, 0x4c, 0x30, 0x16, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0a, 0x37, 0x38, 0x38, 0x39, 0x37, 0x2c, 0x37, 0x37, 0x30, 0x45, 0x6d, 0x6d, 0x62, 0x62, 0x38, 0x3c, 0x3c, 0x32, 0x37, 0x32, 0x32, 0x32, 0x2c, 0x14, 0x15, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x6e, 0x37, 0x38, 0x38, 0x38, 0x37, 0x2c, 0x2d, 0x30, 0x31, 0x62, 0x6a, 0x6d, 0x6a, 0x6a, 0x46, 0x32, 0x32, 0x37, 0x37, 0x32, 0x30, 0x17, 0x29, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4a, 0x0b, 0x38, 0x38, 0x38, 0x2c, 0x2c, 0x0b, 0x2d, 0x39, 0x4c, 0x45, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x38, 0x37, 0x2c, 0x41, 0x18, 0x1c, 0x0c, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x15, 0x0b, 0x2d, 0x38, 0x38, 0x37, 0x2c, 0x2c, 0x2c, 0x37, 0x32, 0x4c, 0x6b, 0x44, 0x44, 0x45, 0x6a, 0x45, 0x38, 0x37, 0x1c, 0x09, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x1d, 0x38, 0x38, 0x38, 0x38, 0x2c, 0x3c, 0x37, 0x37, 0x32, 0x32, 0x46, 0x36, 0x1e, 0x6b, 0x4c, 0x46, 0x32, 0x22, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x37, 0x32, 0x37, 0x38, 0x38, 0x37, 0x32, 0x3c, 0x32, 0x32, 0x37, 0x38, 0x2d, 0x2d, 0x38, 0x2c, 0x2c, 0x4f, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x08, 0x3c, 0x37, 0x41, 0x38, 0x2d, 0x37, 0x37, 0x3c, 0x32, 0x3c, 0x32, 0x37, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0c, 0x41, 0x3c, 0x3c, 0x38, 0x32, 0x3c, 0x3c, 0x3c, 0x41, 0x32, 0x41, 0x37, 0x2c, 0x2c, 0x41, 0x38, 0x45, 0x18, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x2c, 0x3c, 0x37, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x37, 0x2c, 0x2c, 0x2c, 0x2c, 0x4c, 0x45, 0x6a, 0x1a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, 0x2c, 0x37, 0x41, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x41, 0x37, 0x37, 0x4c, 0x44, 0x6d, 0x6a, 0x1a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x5a, 0x2c, 0x41, 0x3c, 0x3c, 0x3c, 0x32, 0x2c, 0x32, 0x2c, 0x2c, 0x38, 0x38, 0x36, 0x45, 0x62, 0x44, 0x45, 0x29, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x2c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x37, 0x37, 0x32, 0x37, 0x39, 0x4c, 0x4c, 0x45, 0x62, 0x44, 0x62, 0x30, 0x2a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4a, 0x5a, 0x41, 0x3c, 0x3c, 0x3c, 0x3c, 0x32, 0x3c, 0x37, 0x37, 0x2d, 0x46, 0x4c, 0x6b, 0x6b, 0x45, 0x3e, 0x36, 0x29, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x27, 0x3c, 0x37, 0x3c, 0x3c, 0x37, 0x37, 0x32, 0x38, 0x37, 0x37, 0x37, 0x38, 0x39, 0x36, 0x4c, 0x30, 0x10, 0x16, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x04, 0x05, 0x05, 0x25, 0x1d, 0x37, 0x37, 0x41, 0x32, 0x3c, 0x32, 0x41, 0x37, 0x32, 0x2c, 0x41, 0x37, 0x2c, 0x32, 0x37, 0x2c, 0x2c, 0x5a, 0x0c, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x05, 0x05, 0x15, 0x5a, 0x37, 0x2c, 0x41, 0x2c, 0x2c, 0x41, 0x37, 0x41, 0x41, 0x3c, 0x2c, 0x41, 0x41, 0x3c, 0x37, 0x2c, 0x39, 0x0b, 0x0b, 0x25, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x2a, 0x22, 0x2d, 0x37, 0x2c, 0x3c, 0x1d, 0x2c, 0x38, 0x2c, 0x41, 0x2c, 0x2c, 0x2d, 0x39, 0x37, 0x3c, 0x37, 0x30, 0x1a, 0x5e, 0x6e, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x2a, 0x6e, 0x0b, 0x2d, 0x38, 0x41, 0x41, 0x6e, 0x5a, 0x2c, 0x41, 0x32, 0x38, 0x32, 0x39, 0x3f, 0x6f, 0x16, 0x37, 0x1a, 0x1f, 0x1f, 0x16, 0x1d, 0x0c, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x09, 0x40, 0x07, 0x2c, 0x37, 0x2c, 0x2d, 0x2c, 0x1d, 0x0e, 0x09, 0x0b, 0x4b, 0x07, 0x41, 0x38, 0x2d, 0x10, 0x2d, 0x10, 0x0b, 0x2b, 0x33, 0x3f, 0x21, 0x29, 0x07, 0x5e, 0x2f, 0x12, 0x08, 0x2a, 0x0c, 0x25, 0x09, 0x09, 0x09, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x19, 0x40, 0x28, 0x22, 0x2c, 0x38, 0x32, 0x32, 0x32, 0x1d, 0x0e, 0x19, 0x05, 0x35, 0x2c, 0x4b, 0x70, 0x0b, 0x32, 0x2c, 0x16, 0x16, 0x16, 0x0b, 0x22, 0x26, 0x0b, 0x10, 0x3f, 0x29, 0x1f, 0x47, 0x1f, 0x1f, 0x5e, 0x0b, 0x4b, 0x74, 0x84, 0x74, 0x84, 0x06, 0x35, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x09, 0x4d, 0x27, 0x0a, 0x22, 0x1d, 0x2c, 0x2c, 0x37, 0x32, 0x41, 0x41, 0x16, 0x27, 0x15, 0x09, 0x4a, 0x09, 0x28, 0x2d, 0x0b, 0x76, 0x2c, 0x37, 0x2d, 0x37, 0x32, 0x37, 0x0b, 0x0b, 0x5e, 0x5a, 0x4b, 0x0b, 0x0b, 0x07, 0x6e, 0x16, 0x5e, 0x10, 0x76, 0x5c, 0x68, 0x79, 0x7a, 0x53, 0x71, 0x54, 0x5d, 0x08, 0x4d, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x25, 0x27, 0x28, 0x0b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x41, 0x41, 0x41, 0x22, 0x11, 0x35, 0x4d, 0x4d, 0x35, 0x1c, 0x06, 0x0a, 0x22, 0x38, 0x38, 0x37, 0x38, 0x38, 0x38, 0x2d, 0x39, 0x39, 0x39, 0x10, 0x39, 0x10, 0x4b, 0x12, 0x08, 0x35, 0x67, 0x2a, 0x08, 0x74, 0x70, 0x81, 0x55, 0x78, 0x79, 0x57, 0x53, 0x71, 0x71, 0x73, 0x84, 0x25, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x05, 0x09, 0x27, 0x16, 0x0b, 0x2c, 0x2d, 0x2c, 0x41, 0x41, 0x1d, 0x22, 0x5a, 0x0f, 0x14, 0x0a, 0x28, 0x0a, 0x28, 0x28, 0x28, 0x6e, 0x5a, 0x65, 0x1d, 0x0b, 0x2d, 0x38, 0x46, 0x38, 0x38, 0x38, 0x39, 0x2d, 0x46, 0x39, 0x30, 0x39, 0x4b, 0x68, 0x79, 0x7a, 0x57, 0x67, 0x67, 0x56, 0x53, 0x71, 0x68, 0x7e, 0x85, 0x59, 0x73, 0x79, 0x54, 0x7a, 0x54, 0x06, 0x1c, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x4d, 0x16, 0x0b, 0x10, 0x39, 0x2d, 0x0b, 0x28, 0x06, 0x2a, 0x25, 0x35, 0x06, 0x11, 0x0a, 0x28, 0x07, 0x5a, 0x22, 0x26, 0x5a, 0x41, 0x7b, 0x7c, 0x60, 0x76, 0x22, 0x1d, 0x32, 0x38, 0x46, 0x46, 0x46, 0x38, 0x38, 0x38, 0x38, 0x2b, 0x75, 0x7d, 0x7e, 0x55, 0x78, 0x7a, 0x57, 0x57, 0x57, 0x71, 0x20, 0x68, 0x55, 0x85, 0x7a, 0x57, 0x53, 0x71, 0x57, 0x5d, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x0c, 0x16, 0x0b, 0x30, 0x39, 0x18, 0x2a, 0x09, 0x05, 0x4e, 0x19, 0x25, 0x0c, 0x27, 0x11, 0x0a, 0x0a, 0x2f, 0x5a, 0x5a, 0x26, 0x5a, 0x7b, 0x7c, 0x7c, 0x61, 0x7f, 0x7f, 0x7f, 0x76, 0x22, 0x22, 0x0b, 0x2d, 0x0b, 0x2d, 0x2d, 0x33, 0x0b, 0x5f, 0x80, 0x7d, 0x5c, 0x81, 0x55, 0x59, 0x59, 0x73, 0x73, 0x54, 0x5c, 0x5c, 0x7e, 0x55, 0x59, 0x73, 0x7a, 0x71, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x09, 0x25, 0x08, 0x07, 0x5e, 0x10, 0x22, 0x1c, 0x4a, 0x05, 0x09, 0x05, 0x15, 0x4d, 0x19, 0x19, 0x4d, 0x08, 0x12, 0x74, 0x0f, 0x6e, 0x5a, 0x26, 0x1d, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x61, 0x5b, 0x82, 0x82, 0x80, 0x80, 0x82, 0x7f, 0x7f, 0x7f, 0x7f, 0x5b, 0x7f, 0x82, 0x80, 0x7d, 0x5c, 0x7e, 0x79, 0x54, 0x54, 0x7a, 0x73, 0x0f, 0x2a, 0x25, 0x19, 0x09, 0x4a, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x4d, 0x2a, 0x06, 0x74, 0x28, 0x22, 0x22, 0x2d, 0x2c, 0x0e, 0x05, 0x05, 0x05, 0x05, 0x05, 0x3b, 0x07, 0x19, 0x09, 0x25, 0x0c, 0x27, 0x12, 0x0f, 0x2f, 0x26, 0x26, 0x1d, 0x65, 0x65, 0x7c, 0x7c, 0x7b, 0x7c, 0x7b, 0x7b, 0x60, 0x5b, 0x7f, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x80, 0x80, 0x83, 0x83, 0x81, 0x7e, 0x59, 0x73, 0x73, 0x84, 0x5d, 0x25, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x19, 0x08, 0x12, 0x0a, 0x0f, 0x6e, 0x5a, 0x26, 0x22, 0x2c, 0x2c, 0x0b, 0x27, 0x05, 0x05, 0x05, 0x15, 0x1e, 0x1e, 0x6f, 0x0c, 0x09, 0x15, 0x0c, 0x20, 0x12, 0x0f, 0x6e, 0x5a, 0x26, 0x26, 0x26, 0x65, 0x65, 0x65, 0x65, 0x7b, 0x7c, 0x7b, 0x65, 0x7b, 0x61, 0x61, 0x60, 0x64, 0x64, 0x64, 0x5b, 0x5b, 0x5f, 0x63, 0x70, 0x63, 0x58, 0x5d, 0x2a, 0x15, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x4a, 0x4d, 0x27, 0x11, 0x0a, 0x28, 0x6e, 0x5a, 0x26, 0x65, 0x41, 0x1d, 0x2c, 0x2c, 0x5e, 0x29, 0x0e, 0x14, 0x17, 0x31, 0x6b, 0x30, 0x14, 0x25, 0x09, 0x15, 0x4d, 0x08, 0x74, 0x0a, 0x0f, 0x2f, 0x5a, 0x26, 0x26, 0x1d, 0x1d, 0x1d, 0x2b, 0x65, 0x1d, 0x41, 0x65, 0x65, 0x7b, 0x65, 0x65, 0x1d, 0x6e, 0x74, 0x5d, 0x1c, 0x25, 0x15, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x09, 0x19, 0x4d, 0x08, 0x06, 0x0a, 0x2f, 0x6e, 0x2f, 0x6e, 0x26, 0x41, 0x7b, 0x65, 0x41, 0x37, 0x33, 0x30, 0x36, 0x36, 0x4c, 0x6b, 0x66, 0x30, 0x14, 0x35, 0x4a, 0x09, 0x15, 0x15, 0x25, 0x25, 0x0c, 0x1c, 0x08, 0x06, 0x5d, 0x5d, 0x5d, 0x0e, 0x06, 0x12, 0x06, 0x08, 0x1c, 0x2a, 0x0c, 0x19, 0x09, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x09, 0x09, 0x19, 0x35, 0x08, 0x12, 0x28, 0x2f, 0x2f, 0x6e, 0x5a, 0x41, 0x7c, 0x3c, 0x3c, 0x2c, 0x41, 0x2d, 0x2d, 0x39, 0x30, 0x4c, 0x4c, 0x66, 0x66, 0x31, 0x24, 0x20, 0x4a, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x4a, 0x09, 0x4a, 0x09, 0x09, 0x05, 0x09, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x15, 0x0c, 0x1c, 0x12, 0x28, 0x2f, 0x5a, 0x1d, 0x7c, 0x7b, 0x41, 0x7b, 0x3c, 0x7b, 0x3c, 0x41, 0x41, 0x5a, 0x16, 0x28, 0x14, 0x14, 0x14, 0x3b, 0x12, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x4a, 0x09, 0x15, 0x1c, 0x12, 0x12, 0x0a, 0x0f, 0x2f, 0x07, 0x2f, 0x0a, 0x12, 0x27, 0x0c, 0x4d, 0x15, 0x09, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x09, 0x15, 0x15, 0x15, 0x19, 0x4e, 0x4e, 0x05, 0x4a, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+unsigned int logo_img_size = sizeof(logo_img);
diff --git a/sys/dev/syscons/logo/logo.c b/sys/dev/syscons/logo/logo.c
index ea3f46e5c3a7..1c5aa228e3fc 100644
--- a/sys/dev/syscons/logo/logo.c
+++ b/sys/dev/syscons/logo/logo.c
@@ -1,358 +1,841 @@
 /* $FreeBSD$ */
 
-#define logo_width 88
-#define logo_height 88
+#define	LOGO_WIDTH	66
+#define	LOGO_HEIGHT	69
 
-unsigned int logo_w = logo_width;
-unsigned int logo_h = logo_height;
+unsigned int logo_w = LOGO_WIDTH;
+unsigned int logo_h = LOGO_HEIGHT;
 
-unsigned char logo_pal[768] = {
-    0x00, 0x00, 0x00,
-    0x33, 0x33, 0x33,
-    0x66, 0x66, 0x66,
-    0x99, 0x99, 0x99,
-    0xcc, 0xcc, 0xcc,
-    0xff, 0xff, 0xff,
-    0x90, 0x8f, 0x90,
-    0x56, 0x4b, 0x55,
-    0xa3, 0xa5, 0xab,
-    0xfd, 0xfd, 0xfd,
-    0x6d, 0x6e, 0x74,
-    0x41, 0x2b, 0x39,
-    0xcb, 0xc8, 0xcb,
-    0xcf, 0xbb, 0xba,
-    0x8e, 0x82, 0x87,
-    0x5c, 0x5d, 0x60,
-    0x52, 0x2a, 0x37,
-    0x7f, 0x76, 0x7d,
-    0x82, 0x82, 0x85,
-    0x7a, 0x3e, 0x45,
-    0x7f, 0x6e, 0x70,
-    0xef, 0xef, 0xed,
-    0x53, 0x41, 0x4b,
-    0x67, 0x2b, 0x35,
-    0x6a, 0x55, 0x62,
-    0xe7, 0xe2, 0xe3,
-    0x64, 0x35, 0x3f,
-    0xf7, 0xe0, 0xe7,
-    0xb1, 0xb2, 0xb2,
-    0x31, 0x2b, 0x35,
-    0x7a, 0x2d, 0x37,
-    0x69, 0x4c, 0x56,
-    0x95, 0x9d, 0xa4,
-    0x85, 0x61, 0x69,
-    0x40, 0x34, 0x41,
-    0x8f, 0x2e, 0x39,
-    0x7a, 0x50, 0x5a,
-    0xde, 0xe1, 0xe0,
-    0x32, 0x33, 0x3d,
-    0xa0, 0x9b, 0x9c,
-    0x68, 0x63, 0x67,
-    0x76, 0x60, 0x67,
-    0xba, 0xb6, 0xb8,
-    0x29, 0x24, 0x41,
-    0x38, 0x21, 0x29,
-    0x42, 0x21, 0x27,
-    0xa2, 0x2a, 0x32,
-    0x56, 0x55, 0x58,
-    0x55, 0x21, 0x2b,
-    0x7a, 0x20, 0x2a,
-    0x37, 0x16, 0x21,
-    0x4d, 0x18, 0x37,
-    0x8a, 0x3a, 0x3e,
-    0xc0, 0xc2, 0xc4,
-    0x64, 0x23, 0x2c,
-    0x37, 0x1a, 0x24,
-    0x42, 0x18, 0x20,
-    0x4c, 0x21, 0x2b,
-    0xa0, 0x23, 0x2e,
-    0x95, 0x6c, 0x76,
-    0x26, 0x16, 0x1c,
-    0xa5, 0x18, 0x23,
-    0x84, 0x20, 0x2b,
-    0x6d, 0x3f, 0x49,
-    0xae, 0xa7, 0xac,
-    0x2a, 0x1f, 0x24,
-    0x90, 0x21, 0x30,
-    0xa0, 0x39, 0x3e,
-    0x95, 0x0f, 0x1c,
-    0x84, 0x13, 0x1e,
-    0x4e, 0x17, 0x24,
-    0x8c, 0x56, 0x5f,
-    0xe0, 0xc4, 0xcb,
-    0xa5, 0x7f, 0x8e,
-    0xff, 0xff, 0xf1,
-    0x3d, 0x3d, 0x5d,
-    0x61, 0x19, 0x26,
-    0xd5, 0xd5, 0xd5,
-    0xff, 0xf1, 0xed,
-    0xb6, 0x9c, 0xa5,
-    0x87, 0x4c, 0x5a,
-    0xa0, 0x76, 0x76,
-    0xc8, 0xa0, 0xa0,
-    0xa2, 0xc1, 0xc8,
-    0x91, 0xae, 0xb6,
-    0x52, 0x8b, 0xae,
-    0xb3, 0xd2, 0xd4,
-    0x95, 0xb7, 0xc1,
-    0x54, 0x6e, 0x83,
-    0x67, 0x90, 0xa6,
-    0x44, 0x3e, 0x45,
-    0x23, 0x40, 0x6a,
-    0x41, 0x6e, 0x97,
-    0x7e, 0x8e, 0x91,
-    0x52, 0x33, 0x41,
-    0x39, 0x49, 0x68,
-    0x1d, 0x2a, 0x48,
-    0x17, 0x21, 0x45,
-    0x90, 0x17, 0x1f,
-    0x38, 0x54, 0x71,
-    0x1c, 0x33, 0x58,
-    0x1c, 0x1e, 0x23,
-    0x6c, 0x17, 0x21,
-    0xb0, 0xc5, 0xc1,
-    0x5d, 0x7f, 0x96,
-    0xe9, 0xbf, 0xc1,
-    0x96, 0x06, 0x0f,
-    0x78, 0x16, 0x1e,
-    0xab, 0x0e, 0x18,
-    0xa6, 0x06, 0x0e,
-    0x4c, 0x4c, 0x54,
-    0x61, 0x42, 0x4c,
-    0x48, 0x5f, 0x84,
-    0xa0, 0xb8, 0xbe,
-    0x5c, 0x66, 0x7f,
-    0x7b, 0x9e, 0xa9,
-    0x6f, 0x75, 0x7f,
-    0x45, 0x54, 0x74,
-    0x32, 0x3e, 0x63,
-    0xb1, 0xb4, 0xb3,
-    0x66, 0x9d, 0xb4,
-    0x7a, 0x9f, 0xbb,
-    0x82, 0xaa, 0xba,
-    0x13, 0x15, 0x17,
-    0x0b, 0x0b, 0x0a,
-    0x37, 0x66, 0x92,
-    0x4c, 0x7f, 0xa5,
-    0x24, 0x4c, 0x7b,
-    0x25, 0x5f, 0x91,
-    0x40, 0x7d, 0xa5,
-    0x1d, 0x56, 0x88,
-    0x2d, 0x6f, 0xa0,
-    0x70, 0x81, 0x8f,
-    0x58, 0x97, 0xbd,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
+unsigned char logo_pal[256 * 3] = {
+	0x00, 0x00, 0x00,
+	0x0b, 0x00, 0x00,
+	0x0b, 0x0b, 0x0b,
+	0x13, 0x01, 0x01,
+	0x1b, 0x05, 0x04,
+	0x13, 0x13, 0x13,
+	0x1b, 0x1b, 0x1b,
+	0x1c, 0x15, 0x14,
+	0x25, 0x03, 0x01,
+	0x33, 0x0e, 0x0c,
+	0x23, 0x21, 0x1a,
+	0x23, 0x23, 0x23,
+	0x2b, 0x2b, 0x2b,
+	0x3c, 0x3c, 0x3c,
+	0x34, 0x32, 0x32,
+	0x35, 0x30, 0x2a,
+	0x58, 0x00, 0x00,
+	0x4c, 0x0f, 0x0d,
+	0x47, 0x24, 0x15,
+	0x6c, 0x01, 0x01,
+	0x66, 0x09, 0x09,
+	0x66, 0x17, 0x15,
+	0x74, 0x01, 0x00,
+	0x7b, 0x00, 0x00,
+	0x77, 0x09, 0x08,
+	0x79, 0x19, 0x17,
+	0x6e, 0x3e, 0x3e,
+	0x76, 0x35, 0x35,
+	0x72, 0x2b, 0x26,
+	0x65, 0x2a, 0x20,
+	0x5a, 0x4f, 0x32,
+	0x44, 0x44, 0x44,
+	0x4b, 0x4a, 0x4a,
+	0x57, 0x56, 0x56,
+	0x56, 0x4d, 0x4c,
+	0x77, 0x45, 0x45,
+	0x6d, 0x5d, 0x4f,
+	0x6c, 0x6c, 0x6c,
+	0x62, 0x62, 0x62,
+	0x76, 0x75, 0x75,
+	0x72, 0x67, 0x55,
+	0x84, 0x00, 0x00,
+	0x8b, 0x00, 0x00,
+	0x88, 0x0c, 0x0b,
+	0x89, 0x18, 0x17,
+	0x93, 0x00, 0x00,
+	0x9b, 0x00, 0x00,
+	0x99, 0x0a, 0x06,
+	0x95, 0x17, 0x16,
+	0x95, 0x11, 0x0c,
+	0x87, 0x2a, 0x29,
+	0x99, 0x29, 0x27,
+	0x98, 0x37, 0x37,
+	0x86, 0x39, 0x34,
+	0xa4, 0x00, 0x00,
+	0xab, 0x00, 0x00,
+	0xab, 0x0c, 0x01,
+	0xa7, 0x0b, 0x06,
+	0xa8, 0x13, 0x0a,
+	0xa6, 0x16, 0x15,
+	0xb3, 0x00, 0x00,
+	0xbb, 0x00, 0x00,
+	0xb7, 0x0a, 0x03,
+	0xb3, 0x12, 0x00,
+	0xba, 0x15, 0x03,
+	0xb5, 0x18, 0x17,
+	0xb7, 0x27, 0x03,
+	0xb9, 0x27, 0x18,
+	0xa8, 0x2a, 0x16,
+	0xa8, 0x26, 0x25,
+	0xb9, 0x2a, 0x29,
+	0xb6, 0x39, 0x37,
+	0xab, 0x35, 0x2f,
+	0xae, 0x4c, 0x36,
+	0x93, 0x5d, 0x39,
+	0x90, 0x4e, 0x4b,
+	0x91, 0x67, 0x56,
+	0x8a, 0x75, 0x70,
+	0xa8, 0x49, 0x47,
+	0xb4, 0x5a, 0x58,
+	0xb2, 0x53, 0x4b,
+	0xac, 0x71, 0x53,
+	0xb8, 0x7a, 0x78,
+	0xb2, 0x65, 0x64,
+	0xc3, 0x01, 0x00,
+	0xc3, 0x0a, 0x00,
+	0xcb, 0x00, 0x00,
+	0xca, 0x0b, 0x00,
+	0xc7, 0x08, 0x08,
+	0xc5, 0x13, 0x00,
+	0xcb, 0x12, 0x00,
+	0xcb, 0x1a, 0x01,
+	0xc3, 0x18, 0x05,
+	0xc9, 0x17, 0x14,
+	0xd3, 0x00, 0x00,
+	0xd2, 0x0b, 0x00,
+	0xdb, 0x00, 0x00,
+	0xd8, 0x0c, 0x05,
+	0xd3, 0x14, 0x00,
+	0xd3, 0x1b, 0x01,
+	0xdb, 0x1c, 0x01,
+	0xd9, 0x14, 0x03,
+	0xd5, 0x18, 0x15,
+	0xc8, 0x25, 0x01,
+	0xd4, 0x23, 0x02,
+	0xd3, 0x2b, 0x01,
+	0xdb, 0x22, 0x01,
+	0xdb, 0x2a, 0x01,
+	0xd5, 0x27, 0x1c,
+	0xd6, 0x33, 0x02,
+	0xdb, 0x33, 0x02,
+	0xda, 0x3a, 0x03,
+	0xd4, 0x3c, 0x1a,
+	0xc8, 0x33, 0x17,
+	0xca, 0x29, 0x24,
+	0xc8, 0x32, 0x2b,
+	0xd3, 0x35, 0x2d,
+	0xe3, 0x00, 0x00,
+	0xeb, 0x00, 0x00,
+	0xea, 0x0b, 0x00,
+	0xe5, 0x18, 0x03,
+	0xf1, 0x03, 0x00,
+	0xf4, 0x0b, 0x00,
+	0xf4, 0x17, 0x01,
+	0xe2, 0x24, 0x01,
+	0xe3, 0x2a, 0x01,
+	0xe9, 0x2c, 0x02,
+	0xea, 0x28, 0x07,
+	0xe3, 0x33, 0x01,
+	0xe3, 0x3b, 0x02,
+	0xea, 0x33, 0x02,
+	0xeb, 0x3c, 0x02,
+	0xe9, 0x3c, 0x09,
+	0xf4, 0x25, 0x04,
+	0xf3, 0x34, 0x0e,
+	0xed, 0x35, 0x29,
+	0xd9, 0x45, 0x0b,
+	0xd7, 0x43, 0x14,
+	0xc8, 0x40, 0x19,
+	0xd7, 0x56, 0x3a,
+	0xcf, 0x46, 0x34,
+	0xec, 0x43, 0x03,
+	0xeb, 0x4c, 0x04,
+	0xe4, 0x47, 0x05,
+	0xe9, 0x58, 0x17,
+	0xf0, 0x47, 0x03,
+	0xf1, 0x4f, 0x11,
+	0xee, 0x4a, 0x2d,
+	0xee, 0x6d, 0x19,
+	0xee, 0x6c, 0x34,
+	0xcf, 0x66, 0x33,
+	0xc9, 0x4b, 0x49,
+	0xc6, 0x57, 0x57,
+	0xdb, 0x55, 0x4a,
+	0xd7, 0x58, 0x52,
+	0xcf, 0x4e, 0x49,
+	0xd3, 0x69, 0x54,
+	0xc9, 0x69, 0x67,
+	0xc9, 0x77, 0x76,
+	0xda, 0x7a, 0x77,
+	0xd3, 0x72, 0x6d,
+	0xf5, 0x59, 0x4c,
+	0xed, 0x71, 0x51,
+	0xe5, 0x74, 0x65,
+	0xef, 0x76, 0x6e,
+	0xb6, 0x8c, 0x6b,
+	0xa4, 0x8c, 0x63,
+	0xf2, 0x98, 0x28,
+	0xf2, 0x92, 0x36,
+	0xf3, 0xa8, 0x2b,
+	0xf6, 0xb4, 0x35,
+	0xed, 0xaa, 0x34,
+	0xdb, 0x95, 0x2c,
+	0xf1, 0x8f, 0x52,
+	0xfa, 0x87, 0x67,
+	0xfa, 0x97, 0x75,
+	0xef, 0x8e, 0x73,
+	0xf2, 0xb1, 0x4f,
+	0xf5, 0xa6, 0x79,
+	0xf0, 0xae, 0x71,
+	0xd1, 0x88, 0x76,
+	0xf6, 0xcc, 0x69,
+	0xfc, 0xe9, 0x76,
+	0x89, 0x89, 0x89,
+	0x98, 0x97, 0x97,
+	0x90, 0x8f, 0x8f,
+	0xb3, 0x94, 0x89,
+	0xa6, 0xa6, 0xa5,
+	0xb8, 0xb8, 0xb8,
+	0xb2, 0xa8, 0xa6,
+	0xc3, 0x8c, 0x8b,
+	0xd5, 0x88, 0x87,
+	0xd7, 0x99, 0x98,
+	0xcd, 0x9a, 0x9a,
+	0xd0, 0xa6, 0x93,
+	0xc6, 0xaa, 0xa4,
+	0xd5, 0xa7, 0xa7,
+	0xd9, 0xb8, 0xb6,
+	0xc6, 0xb9, 0xb5,
+	0xfa, 0x9a, 0x8a,
+	0xef, 0x94, 0x8d,
+	0xed, 0xa6, 0x93,
+	0xf7, 0xa7, 0x86,
+	0xf5, 0xa9, 0x98,
+	0xf6, 0xb7, 0x87,
+	0xf6, 0xb5, 0x97,
+	0xec, 0xab, 0x93,
+	0xe5, 0xa7, 0xa6,
+	0xe2, 0xb4, 0xb4,
+	0xfa, 0xac, 0xa3,
+	0xf3, 0xb6, 0xa6,
+	0xfa, 0xba, 0xb5,
+	0xe8, 0xb6, 0xac,
+	0xf5, 0xc2, 0x94,
+	0xfa, 0xc7, 0xa8,
+	0xf8, 0xc7, 0xba,
+	0xfa, 0xd4, 0xab,
+	0xf9, 0xd5, 0xb8,
+	0xeb, 0xc5, 0xb1,
+	0xfd, 0xea, 0x8b,
+	0xfd, 0xeb, 0xba,
+	0xfd, 0xef, 0xae,
+	0xd2, 0xc7, 0xbf,
+	0xca, 0xc8, 0xc7,
+	0xd5, 0xc7, 0xc7,
+	0xd7, 0xd6, 0xd6,
+	0xd3, 0xd1, 0xc4,
+	0xea, 0xc6, 0xc6,
+	0xec, 0xd3, 0xd3,
+	0xe8, 0xda, 0xd9,
+	0xf8, 0xca, 0xc8,
+	0xfa, 0xd8, 0xc7,
+	0xf1, 0xd5, 0xd4,
+	0xf3, 0xda, 0xda,
+	0xfb, 0xdb, 0xd3,
+	0xfb, 0xdd, 0xdb,
+	0xf8, 0xd7, 0xd5,
+	0xef, 0xde, 0xc8,
+	0xfb, 0xe4, 0xcd,
+	0xfc, 0xe8, 0xc9,
+	0xfc, 0xe4, 0xdc,
+	0xfb, 0xeb, 0xdb,
+	0xf8, 0xe6, 0xd6,
+	0xfd, 0xf7, 0xcb,
+	0xf1, 0xe9, 0xd9,
+	0xe9, 0xe6, 0xe6,
+	0xfa, 0xe4, 0xe3,
+	0xfb, 0xeb, 0xe3,
+	0xfa, 0xec, 0xea,
+	0xf4, 0xe7, 0xe4,
+	0xfc, 0xf1, 0xe3,
+	0xfc, 0xf2, 0xec,
+	0xf4, 0xf4, 0xf4,
+	0xfc, 0xf4, 0xf2,
+	0xfd, 0xf9, 0xf5,
+	0xfd, 0xfc, 0xfb
 };
 
-unsigned char logo_img[logo_width*logo_height] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x09, 0x0a, 0x0b, 0x07, 0x0c, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0d, 0x0e, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x09, 0x0f, 0x0b, 0x10, 0x11, 0x09, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x12, 0x13, 0x14, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x15, 0x16, 0x0b, 0x17, 0x18, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, 0x13, 0x1a, 0x1b, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x1c, 0x1d, 0x10, 0x1e, 0x1f, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x20, 0x0b, 0x1e, 0x21, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x19, 0x22, 0x0b, 0x17, 0x23, 0x24, 0x15, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x25, 0x26, 0x10, 0x23, 0x27, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x05, 0x05, 0x05, 0x25, 0x27, 0x11, 0x28, 0x29, 0x11, 0x06, 0x0d, 0x09, 0x05, 0x2a, 0x2b, 0x2c, 0x2d, 0x1e, 0x2e, 0x21, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2f, 0x0b, 0x30, 0x31, 0x0c, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x15, 0x06, 0x16, 0x22, 0x1d, 0x2c, 0x32, 0x33, 0x17, 0x17, 0x17, 0x22, 0x14, 0x16, 0x1d, 0x2c, 0x2d, 0x1e, 0x2e, 0x34, 0x0c, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x2b, 0x2c, 0x36, 0x36, 0x35, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x27, 0x0b, 0x2c, 0x2c, 0x37, 0x32, 0x38, 0x2c, 0x2d, 0x39, 0x36, 0x17, 0x30, 0x2c, 0x2c, 0x2d, 0x2c, 0x2c, 0x1a, 0x3a, 0x3a, 0x3b, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0a, 0x2d, 0x2b, 0x33, 0x31, 0x0e, 0x05, 0x05, 0x05, 0x05, 0x09, 0x28, 0x2c, 0x37, 0x3c, 0x32, 0x38, 0x38, 0x37, 0x2c, 0x30, 0x36, 0x36, 0x17, 0x31, 0x36, 0x23, 0x23, 0x17, 0x2c, 0x17, 0x3a, 0x3d, 0x13, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x22, 0x2c, 0x37, 0x33, 0x3e, 0x31, 0x3f, 0x40, 0x19, 0x05, 0x11, 0x2c, 0x2c, 0x32, 0x32, 0x32, 0x38, 0x37, 0x41, 0x30, 0x3a, 0x3a, 0x2e, 0x42, 0x43, 0x17, 0x1a, 0x13, 0x23, 0x31, 0x1a, 0x2e, 0x3d, 0x1a, 0x09, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0b, 0x37, 0x32, 0x37, 0x33, 0x44, 0x44, 0x45, 0x17, 0x1a, 0x10, 0x2d, 0x37, 0x38, 0x46, 0x33, 0x46, 0x32, 0x2c, 0x23, 0x23, 0x47, 0x21, 0x13, 0x43, 0x34, 0x48, 0x19, 0x49, 0x34, 0x17, 0x1e, 0x3a, 0x13, 0x4a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4b, 0x32, 0x32, 0x32, 0x32, 0x4c, 0x45, 0x44, 0x44, 0x42, 0x36, 0x30, 0x33, 0x46, 0x38, 0x33, 0x46, 0x38, 0x31, 0x23, 0x27, 0x09, 0x4a, 0x4d, 0x47, 0x43, 0x0d, 0x4e, 0x4a, 0x4f, 0x34, 0x1a, 0x2e, 0x29, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, 0x33, 0x32, 0x32, 0x32, 0x33, 0x4c, 0x31, 0x45, 0x3e, 0x31, 0x36, 0x46, 0x46, 0x33, 0x33, 0x39, 0x30, 0x23, 0x50, 0x4a, 0x4a, 0x4a, 0x4a, 0x4d, 0x47, 0x51, 0x4e, 0x4a, 0x4a, 0x0e, 0x13, 0x1a, 0x27, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x2b, 0x32, 0x32, 0x2b, 0x32, 0x33, 0x4c, 0x33, 0x4c, 0x4c, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x23, 0x3a, 0x49, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4f, 0x50, 0x1b, 0x4e, 0x4a, 0x19, 0x50, 0x16, 0x0c, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x32, 0x32, 0x32, 0x32, 0x2b, 0x33, 0x33, 0x30, 0x2d, 0x39, 0x30, 0x30, 0x30, 0x4c, 0x36, 0x42, 0x3a, 0x52, 0x05, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0x3b, 0x52, 0x4e, 0x4a, 0x4a, 0x4f, 0x1a, 0x2a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4d, 0x2b, 0x2b, 0x32, 0x32, 0x32, 0x37, 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x10, 0x30, 0x30, 0x3e, 0x23, 0x3a, 0x0d, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x40, 0x51, 0x4a, 0x4a, 0x25, 0x15, 0x1f, 0x27, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x22, 0x2c, 0x32, 0x32, 0x32, 0x38, 0x2d, 0x2c, 0x41, 0x32, 0x39, 0x46, 0x4c, 0x31, 0x2e, 0x2e, 0x0c, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x25, 0x53, 0x18, 0x4a, 0x54, 0x55, 0x56, 0x51, 0x11, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x22, 0x32, 0x32, 0x32, 0x38, 0x38, 0x32, 0x2c, 0x37, 0x38, 0x30, 0x30, 0x3e, 0x3a, 0x3a, 0x2a, 0x4a, 0x4a, 0x05, 0x4a, 0x57, 0x58, 0x59, 0x5a, 0x35, 0x58, 0x5b, 0x5c, 0x5d, 0x5e, 0x4a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4d, 0x07, 0x37, 0x32, 0x38, 0x38, 0x32, 0x32, 0x41, 0x38, 0x30, 0x30, 0x3e, 0x3a, 0x3d, 0x27, 0x05, 0x4a, 0x4a, 0x4a, 0x5c, 0x5f, 0x59, 0x1d, 0x29, 0x2f, 0x60, 0x61, 0x26, 0x0b, 0x1c, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4e, 0x0a, 0x2d, 0x38, 0x38, 0x32, 0x37, 0x32, 0x2d, 0x39, 0x36, 0x31, 0x62, 0x3d, 0x0e, 0x4a, 0x4a, 0x4a, 0x09, 0x63, 0x64, 0x64, 0x61, 0x2d, 0x1d, 0x65, 0x61, 0x2b, 0x17, 0x16, 0x4a, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x27, 0x2c, 0x38, 0x38, 0x37, 0x37, 0x38, 0x2d, 0x30, 0x31, 0x42, 0x3a, 0x18, 0x09, 0x05, 0x05, 0x4a, 0x63, 0x60, 0x60, 0x2b, 0x10, 0x2d, 0x41, 0x41, 0x30, 0x42, 0x3e, 0x29, 0x09, 0x05, 0x05, 0x04, 0x03, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x37, 0x32, 0x38, 0x32, 0x41, 0x38, 0x38, 0x30, 0x66, 0x31, 0x3a, 0x1e, 0x67, 0x4a, 0x4a, 0x05, 0x68, 0x64, 0x61, 0x2b, 0x17, 0x36, 0x10, 0x33, 0x31, 0x42, 0x3d, 0x45, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x1c, 0x2c, 0x32, 0x32, 0x37, 0x41, 0x2c, 0x46, 0x30, 0x36, 0x36, 0x42, 0x42, 0x29, 0x1b, 0x4a, 0x4a, 0x4d, 0x26, 0x60, 0x0b, 0x17, 0x36, 0x44, 0x45, 0x66, 0x3e, 0x44, 0x44, 0x1a, 0x05, 0x05, 0x05, 0x05, 0x05, 0x15, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0c, 0x2c, 0x32, 0x32, 0x38, 0x37, 0x32, 0x37, 0x30, 0x36, 0x4c, 0x31, 0x1e, 0x10, 0x1f, 0x52, 0x69, 0x52, 0x07, 0x2c, 0x10, 0x36, 0x62, 0x6a, 0x44, 0x6b, 0x3e, 0x44, 0x6c, 0x30, 0x09, 0x05, 0x05, 0x25, 0x54, 0x19, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x25, 0x2c, 0x37, 0x38, 0x37, 0x2c, 0x32, 0x32, 0x46, 0x30, 0x46, 0x4c, 0x31, 0x66, 0x4c, 0x36, 0x1a, 0x1a, 0x17, 0x37, 0x37, 0x10, 0x31, 0x62, 0x45, 0x4c, 0x3e, 0x44, 0x62, 0x30, 0x09, 0x05, 0x0a, 0x70, 0x71, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x22, 0x32, 0x32, 0x38, 0x41, 0x41, 0x38, 0x2d, 0x46, 0x66, 0x44, 0x6c, 0x6c, 0x6c, 0x3d, 0x3a, 0x42, 0x31, 0x32, 0x32, 0x32, 0x33, 0x33, 0x30, 0x36, 0x3e, 0x3e, 0x31, 0x07, 0x05, 0x12, 0x6e, 0x72, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x2d, 0x2c, 0x38, 0x32, 0x41, 0x37, 0x2d, 0x46, 0x66, 0x6a, 0x6c, 0x6d, 0x6d, 0x6c, 0x3d, 0x3d, 0x31, 0x38, 0x38, 0x39, 0x33, 0x39, 0x36, 0x30, 0x30, 0x66, 0x30, 0x40, 0x4d, 0x5f, 0x4d, 0x4d, 0x05, 0x05, 0x05, 0x15, 0x04, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x5a, 0x2d, 0x32, 0x32, 0x37, 0x37, 0x32, 0x38, 0x46, 0x46, 0x66, 0x45, 0x44, 0x62, 0x44, 0x44, 0x3e, 0x31, 0x31, 0x31, 0x31, 0x31, 0x33, 0x37, 0x30, 0x10, 0x06, 0x05, 0x12, 0x0a, 0x05, 0x05, 0x05, 0x08, 0x68, 0x73, 0x05, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x22, 0x32, 0x32, 0x32, 0x3c, 0x37, 0x37, 0x2d, 0x39, 0x39, 0x39, 0x36, 0x36, 0x6b, 0x3e, 0x3e, 0x3e, 0x3e, 0x31, 0x4c, 0x39, 0x2d, 0x10, 0x16, 0x2a, 0x05, 0x05, 0x74, 0x74, 0x05, 0x05, 0x0c, 0x75, 0x5f, 0x1c, 0x05, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x2c, 0x32, 0x32, 0x32, 0x41, 0x37, 0x41, 0x2c, 0x2c, 0x41, 0x2c, 0x33, 0x36, 0x31, 0x36, 0x31, 0x31, 0x17, 0x46, 0x2c, 0x16, 0x40, 0x05, 0x05, 0x05, 0x05, 0x20, 0x5f, 0x4d, 0x72, 0x76, 0x06, 0x25, 0x4a, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x40, 0x0b, 0x2d, 0x37, 0x2d, 0x2c, 0x2c, 0x37, 0x37, 0x38, 0x2c, 0x37, 0x2c, 0x10, 0x10, 0x39, 0x30, 0x0b, 0x2c, 0x11, 0x09, 0x05, 0x09, 0x4a, 0x05, 0x05, 0x19, 0x1d, 0x26, 0x76, 0x08, 0x05, 0x05, 0x05, 0x15, 0x25, 0x4d, 0x53, 0x77, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4d, 0x5a, 0x2c, 0x37, 0x2d, 0x2c, 0x37, 0x37, 0x39, 0x39, 0x33, 0x38, 0x2c, 0x2d, 0x2d, 0x2c, 0x5e, 0x2a, 0x05, 0x15, 0x3b, 0x17, 0x1f, 0x19, 0x05, 0x06, 0x26, 0x60, 0x5f, 0x0c, 0x05, 0x05, 0x05, 0x35, 0x68, 0x78, 0x56, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x2c, 0x2c, 0x2c, 0x37, 0x32, 0x37, 0x2c, 0x37, 0x32, 0x46, 0x33, 0x46, 0x39, 0x11, 0x15, 0x05, 0x05, 0x18, 0x31, 0x44, 0x6a, 0x30, 0x6e, 0x2b, 0x4b, 0x11, 0x5f, 0x63, 0x72, 0x54, 0x20, 0x74, 0x58, 0x25, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x15, 0x0b, 0x2c, 0x38, 0x2d, 0x39, 0x39, 0x2d, 0x37, 0x3c, 0x32, 0x37, 0x0b, 0x18, 0x05, 0x05, 0x05, 0x4e, 0x26, 0x32, 0x45, 0x6a, 0x46, 0x2b, 0x72, 0x4e, 0x05, 0x35, 0x0a, 0x75, 0x5f, 0x70, 0x08, 0x09, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x35, 0x22, 0x2d, 0x30, 0x6b, 0x6b, 0x66, 0x36, 0x30, 0x36, 0x4c, 0x36, 0x30, 0x18, 0x05, 0x05, 0x05, 0x09, 0x4b, 0x32, 0x46, 0x66, 0x38, 0x0b, 0x09, 0x05, 0x05, 0x05, 0x05, 0x09, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0a, 0x2c, 0x2c, 0x31, 0x62, 0x62, 0x6b, 0x31, 0x45, 0x44, 0x44, 0x45, 0x31, 0x10, 0x0c, 0x4d, 0x0c, 0x08, 0x0b, 0x3c, 0x32, 0x33, 0x66, 0x17, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x22, 0x2c, 0x2d, 0x31, 0x45, 0x6b, 0x36, 0x31, 0x6b, 0x62, 0x45, 0x6a, 0x66, 0x30, 0x0b, 0x2c, 0x2c, 0x2c, 0x2c, 0x37, 0x46, 0x6b, 0x44, 0x62, 0x5e, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0c, 0x1d, 0x2c, 0x39, 0x36, 0x4c, 0x30, 0x30, 0x30, 0x36, 0x4c, 0x66, 0x4c, 0x36, 0x30, 0x37, 0x41, 0x2c, 0x2d, 0x2c, 0x3c, 0x33, 0x6b, 0x44, 0x44, 0x39, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x2d, 0x2d, 0x2d, 0x36, 0x39, 0x2d, 0x32, 0x38, 0x38, 0x46, 0x6a, 0x6d, 0x3d, 0x62, 0x46, 0x3c, 0x37, 0x2d, 0x32, 0x32, 0x32, 0x38, 0x4c, 0x30, 0x16, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0a, 0x37, 0x38, 0x38, 0x39, 0x37, 0x2c, 0x37, 0x37, 0x30, 0x45, 0x6d, 0x6d, 0x62, 0x62, 0x38, 0x3c, 0x3c, 0x32, 0x37, 0x32, 0x32, 0x32, 0x2c, 0x14, 0x15, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x6e, 0x37, 0x38, 0x38, 0x38, 0x37, 0x2c, 0x2d, 0x30, 0x31, 0x62, 0x6a, 0x6d, 0x6a, 0x6a, 0x46, 0x32, 0x32, 0x37, 0x37, 0x32, 0x30, 0x17, 0x29, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4a, 0x0b, 0x38, 0x38, 0x38, 0x2c, 0x2c, 0x0b, 0x2d, 0x39, 0x4c, 0x45, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x38, 0x37, 0x2c, 0x41, 0x18, 0x1c, 0x0c, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x15, 0x0b, 0x2d, 0x38, 0x38, 0x37, 0x2c, 0x2c, 0x2c, 0x37, 0x32, 0x4c, 0x6b, 0x44, 0x44, 0x45, 0x6a, 0x45, 0x38, 0x37, 0x1c, 0x09, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x1d, 0x38, 0x38, 0x38, 0x38, 0x2c, 0x3c, 0x37, 0x37, 0x32, 0x32, 0x46, 0x36, 0x1e, 0x6b, 0x4c, 0x46, 0x32, 0x22, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x37, 0x32, 0x37, 0x38, 0x38, 0x37, 0x32, 0x3c, 0x32, 0x32, 0x37, 0x38, 0x2d, 0x2d, 0x38, 0x2c, 0x2c, 0x4f, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x08, 0x3c, 0x37, 0x41, 0x38, 0x2d, 0x37, 0x37, 0x3c, 0x32, 0x3c, 0x32, 0x37, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x0c, 0x41, 0x3c, 0x3c, 0x38, 0x32, 0x3c, 0x3c, 0x3c, 0x41, 0x32, 0x41, 0x37, 0x2c, 0x2c, 0x41, 0x38, 0x45, 0x18, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x2c, 0x3c, 0x37, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x37, 0x2c, 0x2c, 0x2c, 0x2c, 0x4c, 0x45, 0x6a, 0x1a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, 0x2c, 0x37, 0x41, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x41, 0x37, 0x37, 0x4c, 0x44, 0x6d, 0x6a, 0x1a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x5a, 0x2c, 0x41, 0x3c, 0x3c, 0x3c, 0x32, 0x2c, 0x32, 0x2c, 0x2c, 0x38, 0x38, 0x36, 0x45, 0x62, 0x44, 0x45, 0x29, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x2a, 0x2c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x37, 0x37, 0x32, 0x37, 0x39, 0x4c, 0x4c, 0x45, 0x62, 0x44, 0x62, 0x30, 0x2a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x4a, 0x5a, 0x41, 0x3c, 0x3c, 0x3c, 0x3c, 0x32, 0x3c, 0x37, 0x37, 0x2d, 0x46, 0x4c, 0x6b, 0x6b, 0x45, 0x3e, 0x36, 0x29, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x27, 0x3c, 0x37, 0x3c, 0x3c, 0x37, 0x37, 0x32, 0x38, 0x37, 0x37, 0x37, 0x38, 0x39, 0x36, 0x4c, 0x30, 0x10, 0x16, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x04, 0x05, 0x05, 0x25, 0x1d, 0x37, 0x37, 0x41, 0x32, 0x3c, 0x32, 0x41, 0x37, 0x32, 0x2c, 0x41, 0x37, 0x2c, 0x32, 0x37, 0x2c, 0x2c, 0x5a, 0x0c, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x05, 0x05, 0x15, 0x5a, 0x37, 0x2c, 0x41, 0x2c, 0x2c, 0x41, 0x37, 0x41, 0x41, 0x3c, 0x2c, 0x41, 0x41, 0x3c, 0x37, 0x2c, 0x39, 0x0b, 0x0b, 0x25, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x2a, 0x22, 0x2d, 0x37, 0x2c, 0x3c, 0x1d, 0x2c, 0x38, 0x2c, 0x41, 0x2c, 0x2c, 0x2d, 0x39, 0x37, 0x3c, 0x37, 0x30, 0x1a, 0x5e, 0x6e, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x2a, 0x6e, 0x0b, 0x2d, 0x38, 0x41, 0x41, 0x6e, 0x5a, 0x2c, 0x41, 0x32, 0x38, 0x32, 0x39, 0x3f, 0x6f, 0x16, 0x37, 0x1a, 0x1f, 0x1f, 0x16, 0x1d, 0x0c, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x09, 0x40, 0x07, 0x2c, 0x37, 0x2c, 0x2d, 0x2c, 0x1d, 0x0e, 0x09, 0x0b, 0x4b, 0x07, 0x41, 0x38, 0x2d, 0x10, 0x2d, 0x10, 0x0b, 0x2b, 0x33, 0x3f, 0x21, 0x29, 0x07, 0x5e, 0x2f, 0x12, 0x08, 0x2a, 0x0c, 0x25, 0x09, 0x09, 0x09, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x19, 0x40, 0x28, 0x22, 0x2c, 0x38, 0x32, 0x32, 0x32, 0x1d, 0x0e, 0x19, 0x05, 0x35, 0x2c, 0x4b, 0x70, 0x0b, 0x32, 0x2c, 0x16, 0x16, 0x16, 0x0b, 0x22, 0x26, 0x0b, 0x10, 0x3f, 0x29, 0x1f, 0x47, 0x1f, 0x1f, 0x5e, 0x0b, 0x4b, 0x74, 0x84, 0x74, 0x84, 0x06, 0x35, 0x09, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x09, 0x4d, 0x27, 0x0a, 0x22, 0x1d, 0x2c, 0x2c, 0x37, 0x32, 0x41, 0x41, 0x16, 0x27, 0x15, 0x09, 0x4a, 0x09, 0x28, 0x2d, 0x0b, 0x76, 0x2c, 0x37, 0x2d, 0x37, 0x32, 0x37, 0x0b, 0x0b, 0x5e, 0x5a, 0x4b, 0x0b, 0x0b, 0x07, 0x6e, 0x16, 0x5e, 0x10, 0x76, 0x5c, 0x68, 0x79, 0x7a, 0x53, 0x71, 0x54, 0x5d, 0x08, 0x4d, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x25, 0x27, 0x28, 0x0b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x41, 0x41, 0x41, 0x22, 0x11, 0x35, 0x4d, 0x4d, 0x35, 0x1c, 0x06, 0x0a, 0x22, 0x38, 0x38, 0x37, 0x38, 0x38, 0x38, 0x2d, 0x39, 0x39, 0x39, 0x10, 0x39, 0x10, 0x4b, 0x12, 0x08, 0x35, 0x67, 0x2a, 0x08, 0x74, 0x70, 0x81, 0x55, 0x78, 0x79, 0x57, 0x53, 0x71, 0x71, 0x73, 0x84, 0x25, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x05, 0x09, 0x27, 0x16, 0x0b, 0x2c, 0x2d, 0x2c, 0x41, 0x41, 0x1d, 0x22, 0x5a, 0x0f, 0x14, 0x0a, 0x28, 0x0a, 0x28, 0x28, 0x28, 0x6e, 0x5a, 0x65, 0x1d, 0x0b, 0x2d, 0x38, 0x46, 0x38, 0x38, 0x38, 0x39, 0x2d, 0x46, 0x39, 0x30, 0x39, 0x4b, 0x68, 0x79, 0x7a, 0x57, 0x67, 0x67, 0x56, 0x53, 0x71, 0x68, 0x7e, 0x85, 0x59, 0x73, 0x79, 0x54, 0x7a, 0x54, 0x06, 0x1c, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x4d, 0x16, 0x0b, 0x10, 0x39, 0x2d, 0x0b, 0x28, 0x06, 0x2a, 0x25, 0x35, 0x06, 0x11, 0x0a, 0x28, 0x07, 0x5a, 0x22, 0x26, 0x5a, 0x41, 0x7b, 0x7c, 0x60, 0x76, 0x22, 0x1d, 0x32, 0x38, 0x46, 0x46, 0x46, 0x38, 0x38, 0x38, 0x38, 0x2b, 0x75, 0x7d, 0x7e, 0x55, 0x78, 0x7a, 0x57, 0x57, 0x57, 0x71, 0x20, 0x68, 0x55, 0x85, 0x7a, 0x57, 0x53, 0x71, 0x57, 0x5d, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x0c, 0x16, 0x0b, 0x30, 0x39, 0x18, 0x2a, 0x09, 0x05, 0x4e, 0x19, 0x25, 0x0c, 0x27, 0x11, 0x0a, 0x0a, 0x2f, 0x5a, 0x5a, 0x26, 0x5a, 0x7b, 0x7c, 0x7c, 0x61, 0x7f, 0x7f, 0x7f, 0x76, 0x22, 0x22, 0x0b, 0x2d, 0x0b, 0x2d, 0x2d, 0x33, 0x0b, 0x5f, 0x80, 0x7d, 0x5c, 0x81, 0x55, 0x59, 0x59, 0x73, 0x73, 0x54, 0x5c, 0x5c, 0x7e, 0x55, 0x59, 0x73, 0x7a, 0x71, 0x19, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x05, 0x05, 0x09, 0x25, 0x08, 0x07, 0x5e, 0x10, 0x22, 0x1c, 0x4a, 0x05, 0x09, 0x05, 0x15, 0x4d, 0x19, 0x19, 0x4d, 0x08, 0x12, 0x74, 0x0f, 0x6e, 0x5a, 0x26, 0x1d, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x61, 0x5b, 0x82, 0x82, 0x80, 0x80, 0x82, 0x7f, 0x7f, 0x7f, 0x7f, 0x5b, 0x7f, 0x82, 0x80, 0x7d, 0x5c, 0x7e, 0x79, 0x54, 0x54, 0x7a, 0x73, 0x0f, 0x2a, 0x25, 0x19, 0x09, 0x4a, 0x05, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x4d, 0x2a, 0x06, 0x74, 0x28, 0x22, 0x22, 0x2d, 0x2c, 0x0e, 0x05, 0x05, 0x05, 0x05, 0x05, 0x3b, 0x07, 0x19, 0x09, 0x25, 0x0c, 0x27, 0x12, 0x0f, 0x2f, 0x26, 0x26, 0x1d, 0x65, 0x65, 0x7c, 0x7c, 0x7b, 0x7c, 0x7b, 0x7b, 0x60, 0x5b, 0x7f, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x80, 0x80, 0x83, 0x83, 0x81, 0x7e, 0x59, 0x73, 0x73, 0x84, 0x5d, 0x25, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x19, 0x08, 0x12, 0x0a, 0x0f, 0x6e, 0x5a, 0x26, 0x22, 0x2c, 0x2c, 0x0b, 0x27, 0x05, 0x05, 0x05, 0x15, 0x1e, 0x1e, 0x6f, 0x0c, 0x09, 0x15, 0x0c, 0x20, 0x12, 0x0f, 0x6e, 0x5a, 0x26, 0x26, 0x26, 0x65, 0x65, 0x65, 0x65, 0x7b, 0x7c, 0x7b, 0x65, 0x7b, 0x61, 0x61, 0x60, 0x64, 0x64, 0x64, 0x5b, 0x5b, 0x5f, 0x63, 0x70, 0x63, 0x58, 0x5d, 0x2a, 0x15, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x4a, 0x4d, 0x27, 0x11, 0x0a, 0x28, 0x6e, 0x5a, 0x26, 0x65, 0x41, 0x1d, 0x2c, 0x2c, 0x5e, 0x29, 0x0e, 0x14, 0x17, 0x31, 0x6b, 0x30, 0x14, 0x25, 0x09, 0x15, 0x4d, 0x08, 0x74, 0x0a, 0x0f, 0x2f, 0x5a, 0x26, 0x26, 0x1d, 0x1d, 0x1d, 0x2b, 0x65, 0x1d, 0x41, 0x65, 0x65, 0x7b, 0x65, 0x65, 0x1d, 0x6e, 0x74, 0x5d, 0x1c, 0x25, 0x15, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x09, 0x19, 0x4d, 0x08, 0x06, 0x0a, 0x2f, 0x6e, 0x2f, 0x6e, 0x26, 0x41, 0x7b, 0x65, 0x41, 0x37, 0x33, 0x30, 0x36, 0x36, 0x4c, 0x6b, 0x66, 0x30, 0x14, 0x35, 0x4a, 0x09, 0x15, 0x15, 0x25, 0x25, 0x0c, 0x1c, 0x08, 0x06, 0x5d, 0x5d, 0x5d, 0x0e, 0x06, 0x12, 0x06, 0x08, 0x1c, 0x2a, 0x0c, 0x19, 0x09, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x09, 0x09, 0x19, 0x35, 0x08, 0x12, 0x28, 0x2f, 0x2f, 0x6e, 0x5a, 0x41, 0x7c, 0x3c, 0x3c, 0x2c, 0x41, 0x2d, 0x2d, 0x39, 0x30, 0x4c, 0x4c, 0x66, 0x66, 0x31, 0x24, 0x20, 0x4a, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x4a, 0x09, 0x4a, 0x09, 0x09, 0x05, 0x09, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x09, 0x15, 0x0c, 0x1c, 0x12, 0x28, 0x2f, 0x5a, 0x1d, 0x7c, 0x7b, 0x41, 0x7b, 0x3c, 0x7b, 0x3c, 0x41, 0x41, 0x5a, 0x16, 0x28, 0x14, 0x14, 0x14, 0x3b, 0x12, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x4a, 0x09, 0x15, 0x1c, 0x12, 0x12, 0x0a, 0x0f, 0x2f, 0x07, 0x2f, 0x0a, 0x12, 0x27, 0x0c, 0x4d, 0x15, 0x09, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x09, 0x15, 0x15, 0x15, 0x19, 0x4e, 0x4e, 0x05, 0x4a, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+unsigned char logo_img[LOGO_WIDTH * LOGO_HEIGHT] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+	0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x02, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x02, 0x01, 0x03, 0x03, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x02, 0x02,
+	0x02, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0b,
+	0x0b, 0x06, 0x06, 0x06, 0x05, 0x05, 0x02, 0x02,
+	0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x01, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x04, 0x10, 0x2c, 0x48, 0x47, 0x33,
+	0x14, 0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x05, 0x05,
+	0x06, 0x0b, 0x0c, 0x1f, 0x21, 0x25, 0xb7, 0xb9,
+	0xb8, 0xb8, 0xb9, 0xb9, 0x27, 0x26, 0x20, 0x0d,
+	0x0c, 0x06, 0x06, 0x05, 0x02, 0x02, 0x02, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x08, 0x11, 0x2c, 0x45, 0x44, 0x31, 0x18, 0x09,
+	0x00, 0x00, 0x00, 0x00, 0x13, 0x2b, 0x45, 0x47,
+	0xa0, 0xc8, 0xc8, 0x9c, 0x47, 0x15, 0x08, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x05, 0x06,
+	0x0b, 0x0d, 0x26, 0xb8, 0xbc, 0xe1, 0xf5, 0xfc,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc,
+	0xf5, 0xdf, 0xbb, 0xb7, 0x21, 0x0e, 0x0b, 0x05,
+	0x05, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01,
+	0x11, 0x35, 0x9a, 0xa4, 0xa4, 0x9f, 0x97, 0x3a,
+	0x2a, 0x16, 0x08, 0x00, 0x00, 0x04, 0x2a, 0x29,
+	0x31, 0x45, 0x97, 0xc8, 0xe6, 0xd3, 0xc7, 0xb0,
+	0x9c, 0x1c, 0x08, 0x00, 0x02, 0x02, 0x05, 0x06,
+	0x0c, 0x21, 0xb8, 0xe1, 0xfc, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xf5, 0xbc,
+	0x27, 0x1f, 0x0c, 0x06, 0x02, 0x02, 0x00, 0x01,
+	0x12, 0x50, 0xb0, 0xd1, 0xd3, 0xd3, 0xd2, 0x9f,
+	0x46, 0x2f, 0x29, 0x2a, 0x10, 0x00, 0x00, 0x08,
+	0x2e, 0x29, 0x2a, 0x3a, 0x43, 0x9b, 0xd4, 0xf8,
+	0xec, 0xd3, 0xd1, 0xc7, 0xa3, 0x1c, 0x0a, 0x0a,
+	0x0c, 0x26, 0xbc, 0xf5, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xfd, 0xfe,
+	0xff, 0xff, 0xfc, 0xe1, 0xb7, 0x1f, 0x0c, 0x06,
+	0x12, 0x51, 0xd2, 0xed, 0xec, 0xec, 0xf6, 0xeb,
+	0xcf, 0x97, 0x41, 0x2d, 0x29, 0x2d, 0x13, 0x00,
+	0x00, 0x03, 0x2e, 0x2a, 0x2a, 0x2e, 0x3a, 0x72,
+	0x99, 0xd1, 0xe9, 0xec, 0xd7, 0xd7, 0xd6, 0xd5,
+	0xb4, 0x4c, 0xbb, 0xf5, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xfd, 0xe9, 0xe9, 0xe8, 0xe9, 0xe9,
+	0xe9, 0xeb, 0xf0, 0xf8, 0xfc, 0xfe, 0xfd, 0xe1,
+	0x4d, 0x51, 0xd2, 0xf0, 0xf6, 0xf7, 0xf6, 0xfd,
+	0xf6, 0xd1, 0x9a, 0x73, 0x3a, 0x2d, 0x29, 0x2d,
+	0x10, 0x00, 0x00, 0x01, 0x2d, 0x2d, 0x29, 0x2d,
+	0x39, 0x40, 0x6c, 0xa1, 0xa4, 0xcb, 0xd3, 0xe6,
+	0xe6, 0xe7, 0xeb, 0xf4, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xe9, 0xe9,
+	0xe8, 0xec, 0xec, 0xe4, 0xcf, 0xc0, 0xc0, 0xda,
+	0xe9, 0xd8, 0xd8, 0xfa, 0xfb, 0xfb, 0xf8, 0xfb,
+	0xf8, 0xec, 0xd1, 0xa3, 0x8c, 0x41, 0x2f, 0x2a,
+	0x29, 0x2e, 0x11, 0x00, 0x00, 0x00, 0x16, 0x36,
+	0x29, 0x2d, 0x2e, 0x3c, 0x5d, 0x6c, 0x87, 0xa1,
+	0xa4, 0xcb, 0xe7, 0xf8, 0xfc, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xfd, 0xe9, 0xe8, 0xe8, 0xe8, 0xbf, 0x41, 0x3e,
+	0x3b, 0x8c, 0xcd, 0xf1, 0xfe, 0xfd, 0xfd, 0xfb,
+	0xfb, 0xf0, 0xe6, 0xc7, 0xa4, 0x9a, 0x73, 0x39,
+	0x2d, 0x29, 0x2a, 0x3b, 0x08, 0x00, 0x00, 0x00,
+	0x11, 0x37, 0x2a, 0x2a, 0x2d, 0x37, 0x3e, 0x61,
+	0x87, 0x87, 0xa1, 0xc7, 0xf6, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
+	0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xf9, 0xe5, 0xe3, 0x46,
+	0x36, 0x3a, 0x8c, 0xd4, 0xfb, 0xff, 0xfe, 0xff,
+	0xfd, 0xf8, 0xf0, 0xe6, 0xd1, 0xc8, 0xa4, 0x74,
+	0x3e, 0x36, 0x2a, 0x29, 0x3b, 0x30, 0x01, 0x00,
+	0x00, 0x00, 0x08, 0x3b, 0x2f, 0x29, 0x2a, 0x36,
+	0x3e, 0x58, 0x6c, 0x87, 0xc7, 0xf9, 0xff, 0xff,
+	0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff,
+	0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfc,
+	0xff, 0xff, 0xfd, 0xff, 0xfc, 0xff, 0xfc, 0xf9,
+	0xe3, 0x45, 0x39, 0x8c, 0xe7, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xfb, 0xeb, 0xe6, 0xd3, 0xc7, 0xa4,
+	0x8c, 0x3e, 0x3c, 0x2f, 0x29, 0x31, 0x47, 0x11,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x41, 0x2a,
+	0x29, 0x2f, 0x38, 0x5d, 0x6c, 0xa4, 0xf6, 0xff,
+	0xff, 0xff, 0xff, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe,
+	0xff, 0xfe, 0xfd, 0xfb, 0xfb, 0xfd, 0xfd, 0xfc,
+	0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd,
+	0xfc, 0xff, 0xe9, 0x47, 0x3a, 0xb0, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xfd, 0xf6, 0xec, 0xd3, 0xd1,
+	0xc8, 0x8c, 0x58, 0x3e, 0x36, 0x2d, 0x29, 0x45,
+	0x47, 0x08, 0x00, 0x00, 0x00, 0x00, 0x02, 0x09,
+	0x47, 0x2f, 0x29, 0x2f, 0x3a, 0x41, 0x98, 0xe8,
+	0xff, 0xff, 0xff, 0xfd, 0xfd, 0xfd, 0xfb, 0xfe,
+	0xfd, 0xfe, 0xfe, 0xfb, 0xfb, 0xfb, 0xfa, 0xfb,
+	0xfb, 0xfb, 0xfd, 0xfd, 0xf8, 0xf8, 0xfd, 0xfd,
+	0xf8, 0xfd, 0xf8, 0xf8, 0xf8, 0xc0, 0x97, 0xcc,
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0xf8, 0xeb, 0xec,
+	0xd3, 0xc8, 0x87, 0x5f, 0x3d, 0x37, 0x2f, 0x2a,
+	0x30, 0x4f, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x01, 0x34, 0x46, 0x2b, 0x2b, 0x3b, 0x97,
+	0xe3, 0xfd, 0xff, 0xff, 0xfd, 0xf8, 0xfd, 0xfd,
+	0xfd, 0xfd, 0xfd, 0xfd, 0xf8, 0xf8, 0xf7, 0xf7,
+	0xfa, 0xfa, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8,
+	0xf8, 0xf8, 0xfa, 0xf7, 0xf7, 0xfa, 0xf1, 0xe3,
+	0xbf, 0xca, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xf6,
+	0xeb, 0xd7, 0xaf, 0x87, 0x60, 0x57, 0x3c, 0x36,
+	0x2d, 0x2b, 0x4e, 0x9d, 0x09, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x01, 0x12, 0x98, 0x30, 0x2b,
+	0x48, 0xc4, 0xfc, 0xff, 0xff, 0xfd, 0xf8, 0xf8,
+	0xfd, 0xfd, 0xfb, 0xfb, 0xfd, 0xfd, 0xf8, 0xf8,
+	0xf6, 0xf1, 0xf1, 0xf0, 0xf7, 0xf8, 0xf9, 0xf9,
+	0xf7, 0xf4, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf4,
+	0xf9, 0xf0, 0xd0, 0xce, 0xf0, 0xff, 0xff, 0xfd,
+	0xfb, 0xeb, 0xd3, 0xa4, 0x87, 0x61, 0x5e, 0x3e,
+	0x38, 0x2e, 0x2a, 0x33, 0x9e, 0x34, 0x01, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x4e,
+	0x50, 0x33, 0xbe, 0xf8, 0xfd, 0xff, 0xfd, 0xf8,
+	0xf8, 0xfb, 0xfb, 0xfe, 0xfb, 0xfb, 0xfb, 0xf8,
+	0xf6, 0xf6, 0xeb, 0xef, 0xef, 0xf0, 0xf6, 0xf6,
+	0xeb, 0xf2, 0xef, 0xee, 0xee, 0xef, 0xef, 0xee,
+	0xf2, 0xf6, 0xe9, 0xf4, 0xe8, 0xcf, 0xd1, 0xf7,
+	0xf0, 0xea, 0xd3, 0xc7, 0xa1, 0x87, 0x78, 0x5f,
+	0x55, 0x3c, 0x36, 0x2a, 0x2c, 0x4f, 0x9e, 0x11,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x1d, 0xa0, 0x53, 0xe4, 0xfc, 0xff, 0xfd,
+	0xf6, 0xf6, 0xfb, 0xfb, 0xfd, 0xfe, 0xfb, 0xfb,
+	0xf8, 0xf6, 0xf6, 0xf6, 0xeb, 0xef, 0xe7, 0xea,
+	0xea, 0xe7, 0xe7, 0xe7, 0xd9, 0xef, 0xe7, 0xe7,
+	0xe7, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe4, 0xbf,
+	0x97, 0xcb, 0xd2, 0xc7, 0xae, 0xa1, 0x87, 0x78,
+	0x61, 0x57, 0x3d, 0x36, 0x2d, 0x2b, 0x4e, 0xbf,
+	0x4e, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x04, 0x53, 0xe4, 0xf6, 0xfe,
+	0xfd, 0xf7, 0xf0, 0xf8, 0xfb, 0xfe, 0xff, 0xff,
+	0xfe, 0xfb, 0xf7, 0xf6, 0xeb, 0xec, 0xeb, 0xe7,
+	0xe7, 0xe7, 0xe7, 0xd9, 0xd9, 0xd9, 0xd9, 0xd7,
+	0xd9, 0xd7, 0xe6, 0xe4, 0xe4, 0xe6, 0xe4, 0xe4,
+	0xe4, 0xd0, 0x97, 0x99, 0xca, 0xaf, 0xa1, 0x93,
+	0x87, 0x61, 0x57, 0x3d, 0x37, 0x2f, 0x2b, 0x34,
+	0x9e, 0xbf, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x27, 0xe5,
+	0xf9, 0xff, 0xf7, 0xf2, 0xf7, 0xf7, 0xfb, 0xff,
+	0xff, 0xff, 0xfe, 0xfa, 0xf1, 0xf6, 0xec, 0xe6,
+	0xe6, 0xe6, 0xd7, 0xd6, 0xd8, 0xd6, 0xd6, 0xd6,
+	0xd6, 0xd2, 0xd3, 0xe3, 0xe3, 0xda, 0xe3, 0xd0,
+	0xe3, 0xe3, 0xe3, 0xe3, 0xc1, 0x49, 0xa1, 0xa1,
+	0xa1, 0x87, 0x77, 0x5f, 0x3e, 0x3e, 0x36, 0x2a,
+	0x2c, 0x53, 0xc0, 0x9d, 0x0f, 0x02, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0c,
+	0xdf, 0xe8, 0xfd, 0xfb, 0xe7, 0xea, 0xf1, 0xf8,
+	0xfe, 0xff, 0xff, 0xff, 0xfe, 0xf1, 0xf0, 0xec,
+	0xe6, 0xe6, 0xd7, 0xd6, 0xd6, 0xd2, 0xcd, 0xcd,
+	0xcd, 0xcd, 0xcd, 0xd1, 0xcf, 0xcf, 0xcf, 0xcf,
+	0xcf, 0xcf, 0xd0, 0xd0, 0xcf, 0xd0, 0xd0, 0xbe,
+	0x47, 0x87, 0x87, 0x77, 0x61, 0x3d, 0x3c, 0x2e,
+	0x2d, 0x2b, 0x4e, 0xc1, 0xc8, 0xc4, 0x27, 0x02,
+	0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x02, 0x25, 0xe5, 0xe9, 0xfe, 0xec, 0xe7, 0xea,
+	0xf0, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xee,
+	0xe7, 0xe6, 0xd3, 0xd1, 0xcd, 0xcd, 0xca, 0xca,
+	0xcb, 0xca, 0xae, 0xa2, 0xa2, 0xa1, 0x99, 0x9b,
+	0x9b, 0x9b, 0x97, 0x97, 0x98, 0x9d, 0x9e, 0xbe,
+	0xc0, 0xc0, 0x52, 0x48, 0x66, 0x5e, 0x3d, 0x3c,
+	0x36, 0x2d, 0x2b, 0x33, 0x9e, 0xcf, 0x9e, 0xe0,
+	0xbc, 0x0b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x06, 0xbc, 0xe4, 0xf8, 0xf6, 0xd7,
+	0xd9, 0xea, 0xf0, 0xfb, 0xff, 0xff, 0xff, 0xf7,
+	0xee, 0xd9, 0xd7, 0xd3, 0xcb, 0xcc, 0xca, 0xb2,
+	0xaf, 0xa2, 0x95, 0x93, 0x86, 0x86, 0x87, 0x72,
+	0x72, 0x72, 0x72, 0x72, 0x46, 0x46, 0x46, 0x46,
+	0x46, 0x47, 0x4e, 0x53, 0x52, 0x53, 0x48, 0x3e,
+	0x3c, 0x36, 0x2e, 0x2a, 0x2c, 0x4f, 0xcf, 0x9d,
+	0x52, 0xc6, 0xe1, 0x21, 0x02, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x20, 0xe5, 0xe3, 0xfd,
+	0xd7, 0xd4, 0xd9, 0xea, 0xf4, 0xf7, 0xfb, 0xfb,
+	0xfa, 0xee, 0xd9, 0xd6, 0xd2, 0xcb, 0xc7, 0xaf,
+	0xae, 0xa1, 0x92, 0x86, 0x85, 0x85, 0x7b, 0x66,
+	0x66, 0x66, 0x66, 0x5d, 0x5d, 0x5d, 0x41, 0x41,
+	0x41, 0x41, 0x41, 0x45, 0x45, 0x48, 0x34, 0x4e,
+	0x4b, 0x34, 0x30, 0x2f, 0x2b, 0x2b, 0x4e, 0xbf,
+	0x9f, 0x34, 0x53, 0xbd, 0xe1, 0xbb, 0x05, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xb9, 0xe4,
+	0xe4, 0xf7, 0xcd, 0xd2, 0xd7, 0xea, 0xf1, 0xfa,
+	0xfa, 0xf1, 0xef, 0xd9, 0xd6, 0xcc, 0xc7, 0xaf,
+	0xae, 0x93, 0x86, 0x85, 0x85, 0x7b, 0x7a, 0x7b,
+	0x77, 0x61, 0x61, 0x58, 0x58, 0x58, 0x58, 0x3e,
+	0x3e, 0x3e, 0x3e, 0x3b, 0x3b, 0x3b, 0x3b, 0x30,
+	0x33, 0x33, 0x33, 0x4b, 0x35, 0x32, 0x19, 0x2b,
+	0x45, 0x73, 0x34, 0x23, 0x4c, 0xba, 0xdf, 0xdf,
+	0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+	0xdf, 0xe3, 0xe9, 0xda, 0xc9, 0xcd, 0xd7, 0xf2,
+	0xfa, 0xfb, 0xfa, 0xf1, 0xdc, 0xd5, 0xca, 0xaf,
+	0xae, 0x95, 0x86, 0x85, 0x85, 0x7b, 0x7a, 0x7a,
+	0x7a, 0x79, 0x75, 0x61, 0x60, 0x5e, 0x56, 0x54,
+	0x58, 0x3d, 0x3e, 0x3c, 0x37, 0x39, 0x39, 0x36,
+	0x39, 0x2f, 0x30, 0x30, 0x2c, 0x32, 0x35, 0x35,
+	0x23, 0x1b, 0x1b, 0x1b, 0x1a, 0x1a, 0x4b, 0xa5,
+	0xc3, 0xe1, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x0d, 0xe5, 0xd0, 0xe9, 0xce, 0xb2, 0xce,
+	0xd9, 0xee, 0xfe, 0xff, 0xfa, 0xdc, 0xd8, 0xb2,
+	0xae, 0xa2, 0x86, 0x85, 0x7b, 0x7b, 0x7a, 0x7a,
+	0x79, 0x79, 0x79, 0x76, 0x60, 0x5e, 0x5e, 0x5e,
+	0x56, 0x54, 0x3d, 0x3d, 0x3c, 0x3c, 0x37, 0x37,
+	0x36, 0x2e, 0x2f, 0x2f, 0x2f, 0x2b, 0x2b, 0x2c,
+	0x19, 0x1c, 0x35, 0x23, 0x23, 0x1a, 0x1a, 0x23,
+	0x4b, 0x4c, 0xba, 0xe1, 0xb9, 0x05, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x25, 0xe9, 0xd0, 0xe6, 0xb4,
+	0xb0, 0xcc, 0xd8, 0xfa, 0xff, 0xff, 0xfa, 0xd8,
+	0xd5, 0xa2, 0x90, 0x82, 0x85, 0x7b, 0x7a, 0x7a,
+	0x79, 0x79, 0x79, 0x79, 0x79, 0x76, 0x60, 0x5e,
+	0x5e, 0x58, 0x56, 0x54, 0x3d, 0x3d, 0x3c, 0x37,
+	0x37, 0x36, 0x36, 0x2e, 0x2e, 0x2f, 0x2f, 0x2b,
+	0x2b, 0x2b, 0x2b, 0x19, 0x19, 0x1c, 0x23, 0x23,
+	0x23, 0x23, 0x4b, 0x4b, 0xa5, 0xdf, 0xbc, 0x0b,
+	0x00, 0x00, 0x00, 0x00, 0x02, 0xb8, 0xe4, 0xd0,
+	0xce, 0xa3, 0xad, 0xcc, 0xd8, 0xfa, 0xff, 0xfb,
+	0xe7, 0xd5, 0xad, 0x92, 0x85, 0x85, 0x78, 0x7a,
+	0x7a, 0x79, 0x79, 0x79, 0x79, 0x76, 0x76, 0x60,
+	0x5e, 0x5e, 0x56, 0x56, 0x54, 0x54, 0x3d, 0x3d,
+	0x3c, 0x37, 0x37, 0x36, 0x36, 0x2e, 0x2e, 0x2d,
+	0x2d, 0x2a, 0x2a, 0x2b, 0x18, 0x18, 0x19, 0x15,
+	0x1c, 0x1a, 0x1a, 0x23, 0x23, 0x4a, 0x51, 0xc5,
+	0xe2, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x05, 0xbc,
+	0xe3, 0xc4, 0xa3, 0x95, 0xb1, 0xb3, 0xd8, 0xee,
+	0xfa, 0xef, 0xd5, 0xad, 0x94, 0x86, 0x78, 0x77,
+	0x77, 0x7a, 0x76, 0x76, 0x79, 0x79, 0x76, 0x76,
+	0x76, 0x60, 0x5e, 0x56, 0x56, 0x54, 0x54, 0x3d,
+	0x3d, 0x3c, 0x3c, 0x37, 0x37, 0x36, 0x2e, 0x2e,
+	0x2d, 0x2d, 0x2a, 0x2a, 0x29, 0x29, 0x17, 0x16,
+	0x18, 0x14, 0x15, 0x15, 0x1c, 0x1b, 0x35, 0x35,
+	0x49, 0xc3, 0xe1, 0x21, 0x00, 0x00, 0x00, 0x00,
+	0x0b, 0xe1, 0xd0, 0xc4, 0x8b, 0x94, 0xad, 0xb3,
+	0xcd, 0xd6, 0xd8, 0xcd, 0xb1, 0x94, 0x91, 0x7c,
+	0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+	0x76, 0x76, 0x75, 0x5e, 0x56, 0x56, 0x56, 0x54,
+	0x54, 0x3d, 0x3d, 0x3c, 0x3c, 0x37, 0x37, 0x36,
+	0x2e, 0x2d, 0x2d, 0x2d, 0x2a, 0x2a, 0x29, 0x29,
+	0x17, 0x16, 0x18, 0x14, 0x14, 0x14, 0x15, 0x15,
+	0x1c, 0x19, 0x49, 0xc2, 0xf4, 0x25, 0x00, 0x00,
+	0x00, 0x00, 0x0e, 0xe1, 0xc5, 0xbf, 0x8a, 0x90,
+	0xa8, 0xad, 0xb2, 0xcc, 0xb2, 0xad, 0x95, 0x92,
+	0x91, 0x78, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76,
+	0x76, 0x75, 0x76, 0x75, 0x75, 0x5e, 0x56, 0x56,
+	0x54, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x37, 0x36,
+	0x36, 0x36, 0x2d, 0x2d, 0x2d, 0x2d, 0x2a, 0x29,
+	0x29, 0x17, 0x17, 0x16, 0x16, 0x17, 0x18, 0x14,
+	0x14, 0x14, 0x14, 0x18, 0x44, 0xc2, 0xf5, 0xb7,
+	0x02, 0x00, 0x00, 0x00, 0x1f, 0xf5, 0xc4, 0xa0,
+	0x6f, 0x8f, 0x90, 0x95, 0xad, 0xad, 0x95, 0x94,
+	0x92, 0x91, 0x91, 0x78, 0x75, 0x75, 0x75, 0x75,
+	0x75, 0x76, 0x75, 0x75, 0x75, 0x75, 0x60, 0x56,
+	0x56, 0x54, 0x54, 0x3d, 0x3d, 0x3c, 0x3c, 0x37,
+	0x37, 0x36, 0x36, 0x36, 0x2e, 0x2d, 0x2d, 0x2a,
+	0x2a, 0x29, 0x29, 0x17, 0x29, 0x2a, 0x2d, 0x2d,
+	0x13, 0x13, 0x14, 0x13, 0x14, 0x18, 0x44, 0xc2,
+	0xfa, 0xb8, 0x02, 0x00, 0x00, 0x00, 0x20, 0xf5,
+	0xc4, 0x9d, 0x6d, 0x80, 0x8f, 0x88, 0x90, 0x90,
+	0x92, 0x91, 0x86, 0x83, 0x83, 0x7c, 0x75, 0x75,
+	0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+	0x5e, 0x54, 0x54, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c,
+	0x3c, 0x37, 0x37, 0x36, 0x36, 0x2d, 0x2e, 0x2d,
+	0x2d, 0x2a, 0x2a, 0x29, 0x29, 0x2a, 0x36, 0x37,
+	0x36, 0x17, 0x13, 0x13, 0x13, 0x13, 0x13, 0x18,
+	0x44, 0xd5, 0xf5, 0xbb, 0x02, 0x00, 0x00, 0x00,
+	0x21, 0xf5, 0xc0, 0x50, 0x68, 0x6b, 0x80, 0x80,
+	0x80, 0x83, 0x80, 0x82, 0x82, 0x82, 0x83, 0x7e,
+	0x60, 0x75, 0x60, 0x75, 0x75, 0x75, 0x75, 0x75,
+	0x75, 0x60, 0x5e, 0x54, 0x3d, 0x3d, 0x3d, 0x3d,
+	0x3c, 0x3c, 0x37, 0x37, 0x36, 0x36, 0x2e, 0x2d,
+	0x2d, 0x2d, 0x2a, 0x2a, 0x2a, 0x2d, 0x37, 0x3c,
+	0x37, 0x37, 0x2a, 0x13, 0x13, 0x13, 0x16, 0x18,
+	0x17, 0x29, 0x44, 0xd8, 0xf4, 0xbb, 0x02, 0x00,
+	0x00, 0x00, 0x21, 0xf5, 0xc4, 0x49, 0x68, 0x6a,
+	0x7c, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x82, 0x82,
+	0x82, 0x82, 0x75, 0x60, 0x60, 0x60, 0x60, 0x60,
+	0x60, 0x60, 0x60, 0x60, 0x56, 0x3d, 0x3d, 0x3d,
+	0x3c, 0x3c, 0x37, 0x37, 0x37, 0x36, 0x36, 0x2e,
+	0x2e, 0x2d, 0x2d, 0x2d, 0x2d, 0x2e, 0x3c, 0x3c,
+	0x3c, 0x3c, 0x37, 0x2e, 0x16, 0x13, 0x16, 0x16,
+	0x17, 0x17, 0x29, 0x2a, 0x46, 0xd8, 0xfa, 0xbb,
+	0x02, 0x00, 0x00, 0x00, 0x1f, 0xf5, 0xc4, 0x50,
+	0x59, 0x6a, 0x6a, 0x7c, 0x7c, 0x7e, 0x7d, 0x7e,
+	0x7e, 0x7e, 0x82, 0x82, 0x65, 0x5e, 0x60, 0x60,
+	0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x56, 0x3d,
+	0x3c, 0x3c, 0x3c, 0x37, 0x37, 0x37, 0x36, 0x36,
+	0x2e, 0x2e, 0x2e, 0x2d, 0x2d, 0x36, 0x3c, 0x3d,
+	0x3c, 0x3c, 0x3c, 0x37, 0x37, 0x29, 0x13, 0x13,
+	0x16, 0x17, 0x17, 0x29, 0x2a, 0x2f, 0x8b, 0xdc,
+	0xf9, 0xb8, 0x02, 0x00, 0x00, 0x00, 0x0d, 0xf5,
+	0xc4, 0x47, 0x40, 0x63, 0x64, 0x64, 0x64, 0x7c,
+	0x7c, 0x7c, 0x7e, 0x85, 0x7e, 0x7e, 0x7c, 0x60,
+	0x60, 0x5e, 0x60, 0x5e, 0x60, 0x5e, 0x60, 0x5e,
+	0x54, 0x3c, 0x3c, 0x3c, 0x37, 0x37, 0x37, 0x36,
+	0x36, 0x36, 0x36, 0x2d, 0x2d, 0x36, 0x3d, 0x3d,
+	0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x37, 0x36, 0x16,
+	0x13, 0x13, 0x16, 0x17, 0x29, 0x2a, 0x2a, 0x2e,
+	0xad, 0xdc, 0xf1, 0xb8, 0x02, 0x00, 0x00, 0x00,
+	0x0c, 0xe5, 0xe0, 0x4e, 0x3f, 0x5b, 0x65, 0x6a,
+	0x64, 0x7c, 0x7c, 0x7c, 0x7d, 0x7c, 0x7e, 0x7e,
+	0x7e, 0x61, 0x5e, 0x5e, 0x5e, 0x60, 0x5e, 0x5e,
+	0x5e, 0x5e, 0x3d, 0x3c, 0x37, 0x37, 0x37, 0x36,
+	0x36, 0x36, 0x36, 0x2e, 0x2d, 0x36, 0x3c, 0x3d,
+	0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x37, 0x37, 0x37,
+	0x2a, 0x13, 0x13, 0x16, 0x17, 0x29, 0x29, 0x2a,
+	0x2d, 0x43, 0xd5, 0xdc, 0xf4, 0xb7, 0x00, 0x00,
+	0x00, 0x00, 0x06, 0xdf, 0xe4, 0x50, 0x38, 0x40,
+	0x62, 0x65, 0x64, 0x64, 0x7c, 0x7c, 0x7c, 0x7e,
+	0x7d, 0x7e, 0x7e, 0x64, 0x5e, 0x5e, 0x5e, 0x5e,
+	0x5e, 0x5e, 0x5e, 0x5e, 0x3d, 0x37, 0x37, 0x37,
+	0x36, 0x36, 0x36, 0x2e, 0x2e, 0x2d, 0x36, 0x3d,
+	0x3d, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c, 0x37,
+	0x37, 0x36, 0x17, 0x13, 0x16, 0x16, 0x17, 0x29,
+	0x2a, 0x2d, 0x36, 0x95, 0xdb, 0xdc, 0xf4, 0x25,
+	0x00, 0x00, 0x00, 0x00, 0x05, 0xbc, 0xf9, 0x4f,
+	0x2f, 0x3f, 0x5c, 0x64, 0x64, 0x64, 0x64, 0x64,
+	0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x5f, 0x5e,
+	0x56, 0x56, 0x5e, 0x5e, 0x5e, 0x56, 0x3c, 0x36,
+	0x36, 0x36, 0x36, 0x36, 0x2e, 0x2e, 0x2d, 0x36,
+	0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
+	0x3c, 0x37, 0x37, 0x2d, 0x16, 0x13, 0x16, 0x17,
+	0x29, 0x29, 0x2d, 0x2d, 0x44, 0xb5, 0xdd, 0xef,
+	0xe1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb9,
+	0xfc, 0x52, 0x31, 0x3f, 0x3f, 0x5c, 0x63, 0x65,
+	0x64, 0x64, 0x7c, 0x7c, 0x7c, 0x7e, 0x7d, 0x7d,
+	0x64, 0x56, 0x5e, 0x56, 0x56, 0x56, 0x56, 0x56,
+	0x3c, 0x36, 0x36, 0x2e, 0x2e, 0x2e, 0x2e, 0x2d,
+	0x36, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c,
+	0x3c, 0x37, 0x37, 0x37, 0x37, 0x2a, 0x13, 0x13,
+	0x16, 0x17, 0x29, 0x2a, 0x2d, 0x39, 0xad, 0xb6,
+	0xdd, 0xf3, 0xe2, 0x0e, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x26, 0xfc, 0xc4, 0x30, 0x2f, 0x3f, 0x3f,
+	0x59, 0x62, 0x64, 0x64, 0x6a, 0x64, 0x7c, 0x7c,
+	0x7c, 0x7d, 0x7d, 0x65, 0x56, 0x56, 0x56, 0x56,
+	0x56, 0x56, 0x37, 0x2e, 0x2e, 0x2e, 0x2e, 0x2d,
+	0x2d, 0x36, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3c,
+	0x3c, 0x3c, 0x3c, 0x37, 0x37, 0x37, 0x36, 0x29,
+	0x13, 0x16, 0x17, 0x29, 0x2a, 0x2a, 0x2e, 0x96,
+	0xb6, 0xdb, 0xdd, 0xf3, 0xbd, 0x06, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x0e, 0xe1, 0xe5, 0x32, 0x2d,
+	0x3f, 0x3f, 0x3f, 0x5a, 0x63, 0x65, 0x64, 0x64,
+	0x6a, 0x64, 0x7c, 0x7c, 0x7d, 0x7c, 0x57, 0x56,
+	0x54, 0x54, 0x56, 0x54, 0x37, 0x2e, 0x2e, 0x2d,
+	0x2d, 0x2d, 0x36, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
+	0x3c, 0x3c, 0x3c, 0x37, 0x3c, 0x37, 0x37, 0x36,
+	0x36, 0x17, 0x16, 0x17, 0x29, 0x29, 0x2d, 0x2d,
+	0x47, 0xb5, 0xdb, 0xdd, 0xf3, 0xf4, 0xb7, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xbc, 0xfd,
+	0x4f, 0x2a, 0x2f, 0x38, 0x3f, 0x59, 0x65, 0x63,
+	0x65, 0x64, 0x64, 0x64, 0x6a, 0x7c, 0x6b, 0x7c,
+	0x6a, 0x57, 0x54, 0x54, 0x54, 0x54, 0x37, 0x2d,
+	0x2d, 0x2d, 0x2d, 0x2d, 0x3c, 0x3d, 0x3d, 0x3d,
+	0x3d, 0x3c, 0x3c, 0x3c, 0x37, 0x37, 0x37, 0x37,
+	0x36, 0x36, 0x36, 0x17, 0x16, 0x17, 0x29, 0x2a,
+	0x2d, 0x43, 0xb1, 0xb6, 0xdb, 0xdd, 0xf3, 0xe5,
+	0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x25, 0xfe, 0xc3, 0x2b, 0x2d, 0x38, 0x38, 0x55,
+	0x62, 0x62, 0x63, 0x63, 0x64, 0x64, 0x64, 0x6a,
+	0x7c, 0x6b, 0x7d, 0x64, 0x57, 0x54, 0x3d, 0x3d,
+	0x37, 0x2d, 0x2d, 0x2a, 0x2a, 0x37, 0x3d, 0x3d,
+	0x3c, 0x3d, 0x3c, 0x3c, 0x3c, 0x37, 0x3c, 0x37,
+	0x37, 0x37, 0x36, 0x36, 0x36, 0x29, 0x17, 0x29,
+	0x2a, 0x2d, 0x5c, 0x95, 0xb1, 0xb5, 0xdb, 0xf3,
+	0xf3, 0xbc, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x0e, 0xe1, 0xf9, 0x34, 0x29, 0x36,
+	0x3f, 0x55, 0x5a, 0x62, 0x62, 0x63, 0x63, 0x64,
+	0x64, 0x6a, 0x6a, 0x6a, 0x6a, 0x6b, 0x6a, 0x57,
+	0x3d, 0x3d, 0x37, 0x2a, 0x2a, 0x2a, 0x2d, 0x3c,
+	0x3d, 0x3d, 0x3c, 0x3c, 0x3c, 0x3c, 0x37, 0x37,
+	0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x17,
+	0x29, 0x29, 0x2a, 0x39, 0x89, 0x96, 0xad, 0xb1,
+	0xd8, 0xf3, 0xf4, 0xb7, 0x02, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x02, 0xb8, 0xfe, 0xbe,
+	0x18, 0x2a, 0x2f, 0x3e, 0x57, 0x5a, 0x5f, 0x62,
+	0x62, 0x63, 0x63, 0x63, 0x6a, 0x6a, 0x6a, 0x6b,
+	0x69, 0x6b, 0x59, 0x3d, 0x37, 0x2a, 0x2a, 0x29,
+	0x2e, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x37,
+	0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x37, 0x37,
+	0x36, 0x29, 0x29, 0x2d, 0x3a, 0x71, 0x70, 0x93,
+	0x95, 0xb2, 0xd9, 0xef, 0xe2, 0x20, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+	0xf5, 0xf5, 0x32, 0x18, 0x2d, 0x3e, 0x57, 0x57,
+	0x5a, 0x62, 0x5f, 0x62, 0x63, 0x63, 0x63, 0x68,
+	0x6a, 0x6a, 0x6a, 0x6b, 0x69, 0x63, 0x38, 0x29,
+	0x29, 0x29, 0x37, 0x3c, 0x3c, 0x3c, 0x3c, 0x37,
+	0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x37,
+	0x37, 0x3c, 0x37, 0x29, 0x2f, 0x42, 0x71, 0x73,
+	0x70, 0x70, 0x8b, 0xce, 0xd9, 0xed, 0xb8, 0x05,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x05, 0xbb, 0xfc, 0xbe, 0x18, 0x29, 0x36,
+	0x57, 0x57, 0x57, 0x5a, 0x5a, 0x5a, 0x62, 0x63,
+	0x63, 0x63, 0x63, 0x68, 0x6a, 0x6a, 0x6a, 0x69,
+	0x68, 0x3a, 0x2a, 0x2a, 0x37, 0x3c, 0x3c, 0x37,
+	0x37, 0x37, 0x37, 0x37, 0x36, 0x37, 0x36, 0x36,
+	0x37, 0x37, 0x3c, 0x3c, 0x3e, 0x42, 0x71, 0x8a,
+	0x8a, 0x89, 0x70, 0x70, 0xa3, 0xda, 0xda, 0xde,
+	0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x1f, 0xe1, 0xf9, 0x34,
+	0x16, 0x2a, 0x55, 0x55, 0x57, 0x57, 0x5a, 0x5a,
+	0x5a, 0x5a, 0x63, 0x63, 0x63, 0x68, 0x68, 0x68,
+	0x68, 0x69, 0x69, 0x67, 0x42, 0x42, 0x40, 0x3c,
+	0x37, 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x37, 0x37, 0x3e, 0x59, 0x69, 0x6f, 0x89,
+	0x89, 0x89, 0x8a, 0x70, 0x70, 0x8b, 0xc9, 0xd2,
+	0xda, 0xb9, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xb9,
+	0xfe, 0xc4, 0x18, 0x17, 0x36, 0x55, 0x55, 0x55,
+	0x55, 0x57, 0x5a, 0x5a, 0x63, 0x63, 0x5b, 0x63,
+	0x68, 0x68, 0x68, 0x68, 0x68, 0x42, 0x42, 0x67,
+	0x6d, 0x67, 0x67, 0x5c, 0x40, 0x3e, 0x38, 0x38,
+	0x3c, 0x3f, 0x40, 0x67, 0x69, 0x6f, 0x8f, 0x8e,
+	0x8f, 0x88, 0x88, 0x88, 0x88, 0x89, 0x89, 0xb0,
+	0xd1, 0xd4, 0xc6, 0x1f, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x0c, 0xbc, 0xf5, 0x4f, 0x17, 0x29, 0x3c,
+	0x55, 0x55, 0x55, 0x57, 0x59, 0x59, 0x5a, 0x5a,
+	0x5b, 0x5b, 0x63, 0x5b, 0x68, 0x68, 0x68, 0x67,
+	0x42, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6f,
+	0x6f, 0x6f, 0x6f, 0x6f, 0x8f, 0x8f, 0x8f, 0x8e,
+	0x8e, 0x8e, 0x8e, 0x88, 0x88, 0x88, 0x88, 0x89,
+	0xa3, 0xcd, 0xd2, 0xc5, 0x25, 0x02, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x21, 0xe1, 0xe3, 0x33,
+	0x29, 0x2a, 0x3e, 0x54, 0x55, 0x55, 0x55, 0x55,
+	0x59, 0x5a, 0x5c, 0x5a, 0x5b, 0x5b, 0x68, 0x67,
+	0x68, 0x67, 0x42, 0x67, 0x69, 0x69, 0x6d, 0x6d,
+	0x6d, 0x6f, 0x6f, 0x81, 0x6f, 0x8d, 0x8f, 0x8f,
+	0x8f, 0x8e, 0x8e, 0x8e, 0x8e, 0x8f, 0x8f, 0x88,
+	0x90, 0xa2, 0xcd, 0xd2, 0xd4, 0xb8, 0x0b, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x27,
+	0xf5, 0xc0, 0x31, 0x29, 0x2d, 0x3e, 0x3d, 0x54,
+	0x55, 0x55, 0x59, 0x59, 0x59, 0x59, 0x5a, 0x5b,
+	0x67, 0x5b, 0x67, 0x67, 0x42, 0x67, 0x69, 0x69,
+	0x69, 0x6d, 0x6d, 0x6e, 0x80, 0x6f, 0x81, 0x8f,
+	0x81, 0x81, 0x8d, 0x91, 0x8e, 0x91, 0x8e, 0x8e,
+	0x88, 0x88, 0x95, 0xca, 0xce, 0xd2, 0xbd, 0x0d,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x06, 0xb9, 0xf5, 0x9e, 0x2f, 0x2a, 0x2d,
+	0x3e, 0x55, 0x3e, 0x55, 0x55, 0x55, 0x59, 0x5c,
+	0x5a, 0x5a, 0x5b, 0x5b, 0x5b, 0x67, 0x42, 0x67,
+	0x69, 0x69, 0x69, 0x69, 0x6d, 0x6e, 0x6e, 0x80,
+	0x81, 0x81, 0x81, 0x8f, 0x8d, 0x8e, 0x91, 0x8e,
+	0x8e, 0x8e, 0x8e, 0x95, 0xca, 0xce, 0xcd, 0xc3,
+	0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x0b, 0xb8, 0xe5, 0x9d,
+	0x2f, 0x2d, 0x2e, 0x3e, 0x55, 0x55, 0x55, 0x55,
+	0x59, 0x59, 0x59, 0x5a, 0x5b, 0x5b, 0x5b, 0x5b,
+	0x40, 0x67, 0x68, 0x69, 0x69, 0x6b, 0x6e, 0x6e,
+	0x6e, 0x80, 0x81, 0x81, 0x81, 0x83, 0x8d, 0x8d,
+	0x8d, 0x8d, 0x91, 0x8e, 0x95, 0xb2, 0xcd, 0xcd,
+	0xc3, 0x26, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+	0xb8, 0xe3, 0x9d, 0x39, 0x2e, 0x36, 0x37, 0x54,
+	0x55, 0x57, 0x57, 0x59, 0x5a, 0x5a, 0x5a, 0x5a,
+	0x63, 0x5b, 0x42, 0x67, 0x68, 0x6a, 0x6a, 0x6b,
+	0x6b, 0x80, 0x6b, 0x80, 0x80, 0x81, 0x83, 0x83,
+	0x83, 0x83, 0x8d, 0x8d, 0x8e, 0xad, 0xca, 0xce,
+	0xce, 0xc3, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x0b, 0xb7, 0xe3, 0x9d, 0x3a, 0x36,
+	0x36, 0x38, 0x3d, 0x57, 0x57, 0x57, 0x57, 0x5f,
+	0x5a, 0x62, 0x63, 0x63, 0x5c, 0x5c, 0x6a, 0x6a,
+	0x6a, 0x6b, 0x7d, 0x7d, 0x7d, 0x80, 0x80, 0x82,
+	0x82, 0x82, 0x83, 0x83, 0x91, 0x94, 0xa8, 0xb2,
+	0xca, 0xce, 0xc2, 0x21, 0x02, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x25, 0xc5,
+	0xbf, 0x43, 0x3c, 0x3c, 0x3c, 0x3d, 0x54, 0x57,
+	0x5f, 0x62, 0x5f, 0x62, 0x62, 0x63, 0x5b, 0x5c,
+	0x68, 0x6a, 0x6a, 0x7c, 0x6b, 0x7d, 0x7d, 0x7d,
+	0x80, 0x82, 0x82, 0x83, 0x82, 0x91, 0x94, 0xaa,
+	0xb1, 0xca, 0xce, 0xba, 0x1f, 0x02, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x02, 0x22, 0xbd, 0xc0, 0x97, 0x5d, 0x3e, 0x3e,
+	0x3d, 0x3d, 0x57, 0x57, 0x61, 0x62, 0x65, 0x63,
+	0x5b, 0x5c, 0x63, 0x64, 0x64, 0x64, 0x7c, 0x7c,
+	0x7c, 0x7e, 0x7e, 0x82, 0x82, 0x83, 0x94, 0xa9,
+	0xaa, 0xb1, 0xb2, 0xc2, 0x4d, 0x0c, 0x02, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x0c, 0x27, 0xc3, 0xa0,
+	0x73, 0x5d, 0x58, 0x55, 0x3d, 0x54, 0x57, 0x57,
+	0x5f, 0x5f, 0x59, 0x59, 0x63, 0x64, 0x7c, 0x78,
+	0x7c, 0x85, 0x7c, 0x7c, 0x7f, 0x84, 0x94, 0xa7,
+	0xaa, 0xaa, 0xb1, 0xb3, 0xa5, 0x21, 0x05, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+	0x1f, 0x4d, 0xbe, 0x9d, 0x74, 0x72, 0x66, 0x5d,
+	0x5d, 0x58, 0x57, 0x55, 0x55, 0x55, 0x5c, 0x62,
+	0x65, 0x64, 0x7c, 0x7d, 0x80, 0x8e, 0x94, 0xa9,
+	0xa9, 0xaa, 0xaa, 0xaa, 0xa6, 0x28, 0x0e, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x05, 0x1f, 0x4d, 0xa5, 0x9a,
+	0x9b, 0x74, 0x74, 0x74, 0x72, 0x72, 0x6c, 0x6c,
+	0x6c, 0x74, 0x89, 0x90, 0x94, 0xa7, 0xa7, 0xa9,
+	0xa9, 0xa9, 0xaa, 0xab, 0xa6, 0x28, 0x0f, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+	0x0c, 0x21, 0x4d, 0x53, 0x9a, 0x9a, 0x9b, 0x9b,
+	0x99, 0x99, 0x99, 0xa1, 0xa2, 0xa2, 0xa8, 0xa7,
+	0xab, 0xab, 0xac, 0xac, 0x4c, 0x1e, 0x0a, 0x02,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x0a, 0x0d, 0x22,
+	0x23, 0x4b, 0x4e, 0x50, 0x50, 0x4f, 0x50, 0x50,
+	0x4c, 0x4c, 0x4a, 0x1e, 0x0f, 0x0a, 0x02, 0x00,
+	0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x01, 0x02, 0x02, 0x05, 0x07, 0x07, 0x07,
+	0x07, 0x07, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00
 };
+
 unsigned int logo_img_size = sizeof(logo_img);
diff --git a/sys/dev/syscons/logo/logo_saver.c b/sys/dev/syscons/logo/logo_saver.c
index c77edfbbd0a4..16dd3334a5a4 100644
--- a/sys/dev/syscons/logo/logo_saver.c
+++ b/sys/dev/syscons/logo/logo_saver.c
@@ -171,4 +171,8 @@ static scrn_saver_t logo_module = {
 	NULL
 };
 
+#ifdef BEASTIE_LOGO
+SAVER_MODULE(beastie_saver, logo_module);
+#else
 SAVER_MODULE(logo_saver, logo_module);
+#endif
diff --git a/sys/dev/uart/uart.h b/sys/dev/uart/uart.h
index 8262c60885a6..3c477fd9be43 100644
--- a/sys/dev/uart/uart.h
+++ b/sys/dev/uart/uart.h
@@ -67,6 +67,7 @@ struct uart_class;
 extern struct uart_class uart_ns8250_class __attribute__((weak));
 extern struct uart_class uart_quicc_class __attribute__((weak));
 extern struct uart_class uart_sab82532_class __attribute__((weak));
+extern struct uart_class uart_sbbc_class __attribute__((weak));
 extern struct uart_class uart_sgisn_class __attribute__((weak));
 extern struct uart_class uart_z8530_class __attribute__((weak));
 
diff --git a/sys/dev/uart/uart_cpu_sparc64.c b/sys/dev/uart/uart_cpu_sparc64.c
index 0f40cb70bd73..c89b39fcc9eb 100644
--- a/sys/dev/uart/uart_cpu_sparc64.c
+++ b/sys/dev/uart/uart_cpu_sparc64.c
@@ -133,6 +133,14 @@ uart_cpu_getdev_console(phandle_t options, char *dev, size_t devsz)
 		return (-1);
 	if (strcmp(buf, "serial") != 0)
 		return (-1);
+	/* For a Serengeti console device point to the bootbus controller. */
+	if (OF_getprop(input, "name", buf, sizeof(buf)) > 0 &&
+	    !strcmp(buf, "sgcn")) {
+		if ((chosen = OF_finddevice("/chosen")) == -1)
+			return (-1);
+		if (OF_getprop(chosen, "iosram", &input, sizeof(input)) == -1)
+			return (-1);
+	}
 	return (input);
 }
 
@@ -258,6 +266,9 @@ uart_cpu_getdev(int devtype, struct uart_devinfo *di)
 	    !strcmp(compat, "su16552")) {
 		class = &uart_ns8250_class;
 		di->bas.chan = 0;
+	} else if (!strcmp(compat, "sgsbbc")) {
+		class = &uart_sbbc_class;
+		di->bas.chan = 0;
 	}
 	if (class == NULL)
 		return (ENXIO);
diff --git a/sys/dev/usb/serial/u3g.c b/sys/dev/usb/serial/u3g.c
index 0d218d548bf6..7ac1bd3310de 100644
--- a/sys/dev/usb/serial/u3g.c
+++ b/sys/dev/usb/serial/u3g.c
@@ -501,6 +501,7 @@ static const struct usb_device_id u3g_devs[] = {
 	U3G_DEV(OPTION, GTICON322, U3GINIT_REZERO),
 	U3G_DEV(QUALCOMMINC, ZTE_STOR, U3GINIT_ZTESTOR),
 	U3G_DEV(QUALCOMMINC, ZTE_STOR2, U3GINIT_SCSIEJECT),
+	U3G_DEV(QUANTA, Q101_STOR, U3GINIT_SCSIEJECT),
 	U3G_DEV(SIERRA, TRUINSTALL, U3GINIT_SIERRA),
 #undef	U3G_DEV
 };
diff --git a/sys/dev/usb/usbdevs b/sys/dev/usb/usbdevs
index e4128515567d..4cf2891af760 100644
--- a/sys/dev/usb/usbdevs
+++ b/sys/dev/usb/usbdevs
@@ -2519,6 +2519,7 @@ product QUALCOMMINC E2003	0x2003	3G modem
 /* Quanta products */
 product QUANTA RW6815_1		0x00ce	HP iPAQ rw6815
 product QUANTA RT3070		0x0304	RT3070
+product QUANTA Q101_STOR	0x1000	USB Q101 Storage
 product QUANTA Q101		0xea02	HSDPA modem
 product QUANTA Q111		0xea03	HSDPA modem
 product QUANTA GLX		0xea04	HSDPA modem
diff --git a/sys/dev/usb/wlan/if_rum.c b/sys/dev/usb/wlan/if_rum.c
index 0cd394d14446..5b3441b0118d 100644
--- a/sys/dev/usb/wlan/if_rum.c
+++ b/sys/dev/usb/wlan/if_rum.c
@@ -64,7 +64,7 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_regdomain.h>
 #include <net80211/ieee80211_radiotap.h>
-#include <net80211/ieee80211_amrr.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
@@ -140,7 +140,6 @@ static const struct usb_device_id rum_devs[] = {
 };
 
 MODULE_DEPEND(rum, wlan, 1, 1, 1);
-MODULE_DEPEND(rum, wlan_amrr, 1, 1, 1);
 MODULE_DEPEND(rum, usb, 1, 1, 1);
 
 static device_probe_t rum_match;
@@ -212,17 +211,14 @@ static int		rum_prepare_beacon(struct rum_softc *,
 			    struct ieee80211vap *);
 static int		rum_raw_xmit(struct ieee80211_node *, struct mbuf *,
 			    const struct ieee80211_bpf_params *);
-static struct ieee80211_node *rum_node_alloc(struct ieee80211vap *,
-			    const uint8_t mac[IEEE80211_ADDR_LEN]);
-static void		rum_newassoc(struct ieee80211_node *, int);
 static void		rum_scan_start(struct ieee80211com *);
 static void		rum_scan_end(struct ieee80211com *);
 static void		rum_set_channel(struct ieee80211com *);
 static int		rum_get_rssi(struct rum_softc *, uint8_t);
-static void		rum_amrr_start(struct rum_softc *,
+static void		rum_ratectl_start(struct rum_softc *,
 			    struct ieee80211_node *);
-static void		rum_amrr_timeout(void *);
-static void		rum_amrr_task(void *, int);
+static void		rum_ratectl_timeout(void *);
+static void		rum_ratectl_task(void *, int);
 static int		rum_pause(struct rum_softc *, int);
 
 static const struct {
@@ -511,9 +507,7 @@ rum_attach(device_t self)
 
 	ieee80211_ifattach(ic, sc->sc_bssid);
 	ic->ic_update_promisc = rum_update_promisc;
-	ic->ic_newassoc = rum_newassoc;
 	ic->ic_raw_xmit = rum_raw_xmit;
-	ic->ic_node_alloc = rum_node_alloc;
 	ic->ic_scan_start = rum_scan_start;
 	ic->ic_scan_end = rum_scan_end;
 	ic->ic_set_channel = rum_set_channel;
@@ -608,13 +602,10 @@ rum_vap_create(struct ieee80211com *ic,
 	rvp->newstate = vap->iv_newstate;
 	vap->iv_newstate = rum_newstate;
 
-	usb_callout_init_mtx(&rvp->amrr_ch, &sc->sc_mtx, 0);
-	TASK_INIT(&rvp->amrr_task, 0, rum_amrr_task, rvp);
-	ieee80211_amrr_init(&rvp->amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    1000 /* 1 sec */);
-
+	usb_callout_init_mtx(&rvp->ratectl_ch, &sc->sc_mtx, 0);
+	TASK_INIT(&rvp->ratectl_task, 0, rum_ratectl_task, rvp);
+	ieee80211_ratectl_init(vap);
+	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
 	/* complete setup */
 	ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
 	ic->ic_opmode = opmode;
@@ -627,9 +618,9 @@ rum_vap_delete(struct ieee80211vap *vap)
 	struct rum_vap *rvp = RUM_VAP(vap);
 	struct ieee80211com *ic = vap->iv_ic;
 
-	usb_callout_drain(&rvp->amrr_ch);
-	ieee80211_draintask(ic, &rvp->amrr_task);
-	ieee80211_amrr_cleanup(&rvp->amrr);
+	usb_callout_drain(&rvp->ratectl_ch);
+	ieee80211_draintask(ic, &rvp->ratectl_task);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(rvp, M_80211_VAP);
 }
@@ -716,7 +707,7 @@ rum_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 
 	IEEE80211_UNLOCK(ic);
 	RUM_LOCK(sc);
-	usb_callout_stop(&rvp->amrr_ch);
+	usb_callout_stop(&rvp->ratectl_ch);
 
 	switch (nstate) {
 	case IEEE80211_S_INIT:
@@ -751,7 +742,7 @@ rum_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 		/* enable automatic rate adaptation */
 		tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
 		if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
-			rum_amrr_start(sc, ni);
+			rum_ratectl_start(sc, ni);
 		break;
 	default:
 		break;
@@ -2194,7 +2185,7 @@ bad:
 }
 
 static void
-rum_amrr_start(struct rum_softc *sc, struct ieee80211_node *ni)
+rum_ratectl_start(struct rum_softc *sc, struct ieee80211_node *ni)
 {
 	struct ieee80211vap *vap = ni->ni_vap;
 	struct rum_vap *rvp = RUM_VAP(vap);
@@ -2202,23 +2193,23 @@ rum_amrr_start(struct rum_softc *sc, struct ieee80211_node *ni)
 	/* clear statistic registers (STA_CSR0 to STA_CSR5) */
 	rum_read_multi(sc, RT2573_STA_CSR0, sc->sta, sizeof sc->sta);
 
-	ieee80211_amrr_node_init(&rvp->amrr, &RUM_NODE(ni)->amn, ni);
+	ieee80211_ratectl_node_init(ni);
 
-	usb_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp);
+	usb_callout_reset(&rvp->ratectl_ch, hz, rum_ratectl_timeout, rvp);
 }
 
 static void
-rum_amrr_timeout(void *arg)
+rum_ratectl_timeout(void *arg)
 {
 	struct rum_vap *rvp = arg;
 	struct ieee80211vap *vap = &rvp->vap;
 	struct ieee80211com *ic = vap->iv_ic;
 
-	ieee80211_runtask(ic, &rvp->amrr_task);
+	ieee80211_runtask(ic, &rvp->ratectl_task);
 }
 
 static void
-rum_amrr_task(void *arg, int pending)
+rum_ratectl_task(void *arg, int pending)
 {
 	struct rum_vap *rvp = arg;
 	struct ieee80211vap *vap = &rvp->vap;
@@ -2227,6 +2218,7 @@ rum_amrr_task(void *arg, int pending)
 	struct rum_softc *sc = ifp->if_softc;
 	struct ieee80211_node *ni = vap->iv_bss;
 	int ok, fail;
+	int sum, retrycnt;
 
 	RUM_LOCK(sc);
 	/* read and clear statistic registers (STA_CSR0 to STA_CSR10) */
@@ -2235,36 +2227,18 @@ rum_amrr_task(void *arg, int pending)
 	ok = (le32toh(sc->sta[4]) >> 16) +	/* TX ok w/o retry */
 	    (le32toh(sc->sta[5]) & 0xffff);	/* TX ok w/ retry */
 	fail = (le32toh(sc->sta[5]) >> 16);	/* TX retry-fail count */
+	sum = ok+fail;
+	retrycnt = (le32toh(sc->sta[5]) & 0xffff) + fail;
 
-	ieee80211_amrr_tx_update(&RUM_NODE(ni)->amn,
-	    ok+fail, ok, (le32toh(sc->sta[5]) & 0xffff) + fail);
-	(void) ieee80211_amrr_choose(ni, &RUM_NODE(ni)->amn);
+	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 */
 
-	usb_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp);
+	usb_callout_reset(&rvp->ratectl_ch, hz, rum_ratectl_timeout, rvp);
 	RUM_UNLOCK(sc);
 }
 
-/* ARGUSED */
-static struct ieee80211_node *
-rum_node_alloc(struct ieee80211vap *vap __unused,
-	const uint8_t mac[IEEE80211_ADDR_LEN] __unused)
-{
-	struct rum_node *rn;
-
-	rn = malloc(sizeof(struct rum_node), M_80211_NODE, M_NOWAIT | M_ZERO);
-	return rn != NULL ? &rn->ni : NULL;
-}
-
-static void
-rum_newassoc(struct ieee80211_node *ni, int isnew)
-{
-	struct ieee80211vap *vap = ni->ni_vap;
-
-	ieee80211_amrr_node_init(&RUM_VAP(vap)->amrr, &RUM_NODE(ni)->amn, ni);
-}
-
 static void
 rum_scan_start(struct ieee80211com *ic)
 {
diff --git a/sys/dev/usb/wlan/if_rumvar.h b/sys/dev/usb/wlan/if_rumvar.h
index 82bb117b7ce7..f46634c268d0 100644
--- a/sys/dev/usb/wlan/if_rumvar.h
+++ b/sys/dev/usb/wlan/if_rumvar.h
@@ -67,18 +67,11 @@ struct rum_tx_data {
 };
 typedef STAILQ_HEAD(, rum_tx_data) rum_txdhead;
 
-struct rum_node {
-	struct ieee80211_node	ni;
-	struct ieee80211_amrr_node amn;
-};
-#define	RUM_NODE(ni)	((struct rum_node *)(ni))
-
 struct rum_vap {
 	struct ieee80211vap		vap;
 	struct ieee80211_beacon_offsets	bo;
-	struct ieee80211_amrr		amrr;
-	struct usb_callout		amrr_ch;
-	struct task			amrr_task;
+	struct usb_callout		ratectl_ch;
+	struct task			ratectl_task;
 
 	int				(*newstate)(struct ieee80211vap *,
 					    enum ieee80211_state, int);
diff --git a/sys/dev/usb/wlan/if_run.c b/sys/dev/usb/wlan/if_run.c
index 65f48e47be30..06d3764ab547 100644
--- a/sys/dev/usb/wlan/if_run.c
+++ b/sys/dev/usb/wlan/if_run.c
@@ -65,7 +65,7 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_regdomain.h>
 #include <net80211/ieee80211_radiotap.h>
-#include <net80211/ieee80211_amrr.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
@@ -290,7 +290,6 @@ static const struct usb_device_id run_devs[] = {
 };
 
 MODULE_DEPEND(run, wlan, 1, 1, 1);
-MODULE_DEPEND(run, wlan_amrr, 1, 1, 1);
 MODULE_DEPEND(run, usb, 1, 1, 1);
 MODULE_DEPEND(run, firmware, 1, 1, 1);
 
@@ -350,9 +349,9 @@ static int	run_key_set(struct ieee80211vap *, const struct ieee80211_key *,
 			    const uint8_t mac[IEEE80211_ADDR_LEN]);
 static int	run_key_delete(struct ieee80211vap *,
 		    const struct ieee80211_key *);
-static void	run_amrr_start(struct run_softc *, struct ieee80211_node *);
-static void	run_amrr_to(void *);
-static void	run_amrr_cb(void *, int);
+static void	run_ratectl_start(struct run_softc *, struct ieee80211_node *);
+static void	run_ratectl_to(void *);
+static void	run_ratectl_cb(void *, int);
 static void	run_iter_func(void *, struct ieee80211_node *);
 static void	run_newassoc(struct ieee80211_node *, int);
 static void	run_rx_frame(struct run_softc *, struct mbuf *, uint32_t);
@@ -754,14 +753,12 @@ run_vap_create(struct ieee80211com *ic,
 	rvp->newstate = vap->iv_newstate;
 	vap->iv_newstate = run_newstate;
 
-	TASK_INIT(&rvp->amrr_task, 0, run_amrr_cb, rvp);
+	TASK_INIT(&rvp->ratectl_task, 0, run_ratectl_cb, rvp);
 	TASK_INIT(&sc->wme_task, 0, run_wme_update_cb, ic);
 	TASK_INIT(&sc->usb_timeout_task, 0, run_usb_timeout_cb, sc);
-	callout_init((struct callout *)&rvp->amrr_ch, 1);
-	ieee80211_amrr_init(&rvp->amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    1000 /* 1 sec */);
+	callout_init((struct callout *)&rvp->ratectl_ch, 1);
+	ieee80211_ratectl_init(vap);
+	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
 
 	/* complete setup */
 	ieee80211_vap_attach(vap, run_media_change, ieee80211_media_status);
@@ -786,16 +783,16 @@ run_vap_delete(struct ieee80211vap *vap)
 	sc = ifp->if_softc;
 
 	RUN_LOCK(sc);
-	sc->sc_rvp->amrr_run = RUN_AMRR_OFF;
+	sc->sc_rvp->ratectl_run = RUN_RATECTL_OFF;
 	RUN_UNLOCK(sc);
 
 	/* drain them all */
-	usb_callout_drain(&sc->sc_rvp->amrr_ch);
-	ieee80211_draintask(ic, &sc->sc_rvp->amrr_task);
+	usb_callout_drain(&sc->sc_rvp->ratectl_ch);
+	ieee80211_draintask(ic, &sc->sc_rvp->ratectl_task);
 	ieee80211_draintask(ic, &sc->wme_task);
 	ieee80211_draintask(ic, &sc->usb_timeout_task);
 
-	ieee80211_amrr_cleanup(&rvp->amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(rvp, M_80211_VAP);
 	sc->sc_rvp = NULL;
@@ -1632,8 +1629,8 @@ run_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 	IEEE80211_UNLOCK(ic);
 	RUN_LOCK(sc);
 
-	sc->sc_rvp->amrr_run = RUN_AMRR_OFF;
-	usb_callout_stop(&rvp->amrr_ch);
+	sc->sc_rvp->ratectl_run = RUN_RATECTL_OFF;
+	usb_callout_stop(&rvp->ratectl_ch);
 
 	if (ostate == IEEE80211_S_RUN) {
 		/* turn link LED off */
@@ -1681,7 +1678,7 @@ run_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 		/* enable automatic rate adaptation */
 		tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
 		if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
-			run_amrr_start(sc, ni);
+			run_ratectl_start(sc, ni);
 
 		/* turn link LED on */
 		run_set_leds(sc, RT2860_LED_RADIO |
@@ -1961,12 +1958,11 @@ fail:
 }
 
 static void
-run_amrr_start(struct run_softc *sc, struct ieee80211_node *ni)
+run_ratectl_start(struct run_softc *sc, struct ieee80211_node *ni)
 {
 	struct ieee80211vap *vap = ni->ni_vap;
 	struct run_vap *rvp = RUN_VAP(vap);
 	uint32_t sta[3];
-	uint8_t wcid;
 
 	RUN_LOCK_ASSERT(sc, MA_OWNED);
 
@@ -1974,30 +1970,29 @@ run_amrr_start(struct run_softc *sc, struct ieee80211_node *ni)
 	run_read_region_1(sc, RT2860_TX_STA_CNT0,
 	    (uint8_t *)sta, sizeof sta);
 
-	wcid = RUN_AID2WCID(ni == NULL ? 0 : ni->ni_associd);
-	ieee80211_amrr_node_init(&rvp->amrr, &rvp->amn[wcid], ni);
+	ieee80211_ratectl_node_init(ni);
 
 	/* start at lowest available bit-rate, AMRR will raise */
 	ni->ni_txrate = 2;
 
 	/* start calibration timer */
-	rvp->amrr_run = RUN_AMRR_ON;
-	usb_callout_reset(&rvp->amrr_ch, hz, run_amrr_to, rvp);
+	rvp->ratectl_run = RUN_RATECTL_ON;
+	usb_callout_reset(&rvp->ratectl_ch, hz, run_ratectl_to, rvp);
 }
 
 static void
-run_amrr_to(void *arg)
+run_ratectl_to(void *arg)
 {
 	struct run_vap *rvp = arg;
 
 	/* do it in a process context, so it can go sleep */
-	ieee80211_runtask(rvp->vap.iv_ic, &rvp->amrr_task);
+	ieee80211_runtask(rvp->vap.iv_ic, &rvp->ratectl_task);
 	/* next timeout will be rescheduled in the callback task */
 }
 
 /* ARGSUSED */
 static void
-run_amrr_cb(void *arg, int pending)
+run_ratectl_cb(void *arg, int pending)
 {
 	struct run_vap *rvp = arg;
 	struct ieee80211vap *vap = &rvp->vap;
@@ -2020,8 +2015,8 @@ run_amrr_cb(void *arg, int pending)
 		ieee80211_iterate_nodes(&ic->ic_sta, run_iter_func, rvp);
 	}
 
-	if(rvp->amrr_run == RUN_AMRR_ON)
-		usb_callout_reset(&rvp->amrr_ch, hz, run_amrr_to, rvp);
+	if(rvp->ratectl_run == RUN_RATECTL_ON)
+		usb_callout_reset(&rvp->ratectl_ch, hz, run_ratectl_to, rvp);
 }
 
 
@@ -2033,10 +2028,11 @@ run_iter_func(void *arg, struct ieee80211_node *ni)
 	struct ifnet *ifp = ic->ic_ifp;
 	struct run_softc *sc = ifp->if_softc;
 	struct ieee80211_node_table *nt = &ic->ic_sta;
-	struct ieee80211_amrr_node *amn = &rvp->amn[0]; /* make compiler happy */
 	uint32_t sta[3], stat;
 	int error;
 	uint8_t wcid, mcs, pid;
+	struct ieee80211vap *vap = ni->ni_vap;
+	int txcnt = 0, success = 0, retrycnt = 0;
 
 	if(ic->ic_opmode != IEEE80211_M_STA)
 		IEEE80211_NODE_ITERATE_UNLOCK(nt);
@@ -2056,10 +2052,7 @@ run_iter_func(void *arg, struct ieee80211_node *ni)
 				continue;
 
 			/* update per-STA AMRR stats */
-			amn = &rvp->amn[wcid];
-			amn->amn_txcnt++;
 			if (stat & RT2860_TXQ_OK) {
-				amn->amn_success++;
 				/*
 				 * Check if there were retries, ie if the Tx
 				 * success rate is different from the requested
@@ -2069,16 +2062,20 @@ run_iter_func(void *arg, struct ieee80211_node *ni)
 				mcs = (stat >> RT2860_TXQ_MCS_SHIFT) & 0x7f;
 				pid = (stat >> RT2860_TXQ_PID_SHIFT) & 0xf;
 				if (mcs + 1 != pid)
-					amn->amn_retrycnt++;
+					retrycnt = 1;
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_SUCCESS,
+				    &retrycnt, NULL);
 			} else {
-				amn->amn_retrycnt++;
+				retrycnt = 1;
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_SUCCESS,
+				    &retrycnt, NULL);
 				ifp->if_oerrors++;
 			}
 			run_read_region_1(sc, RT2860_TX_STAT_FIFO,
 			    (uint8_t *)&stat, sizeof stat);
 		}
-		DPRINTFN(3, "retrycnt=%d txcnt=%d success=%d\n",
-		    amn->amn_retrycnt, amn->amn_txcnt, amn->amn_success);
 	} else {
 		/* read statistic counters (clear on read) and update AMRR state */
 		error = run_read_region_1(sc, RT2860_TX_STA_CNT0, (uint8_t *)sta,
@@ -2090,26 +2087,25 @@ run_iter_func(void *arg, struct ieee80211_node *ni)
 		    le32toh(sta[1]) >> 16, le32toh(sta[1]) & 0xffff,
 		    le32toh(sta[0]) & 0xffff);
 
-		wcid = RUN_AID2WCID(ni == NULL ? 0 : ni->ni_associd);
-		amn = &rvp->amn[wcid];
-
 		/* count failed TX as errors */
 		ifp->if_oerrors += le32toh(sta[0]) & 0xffff;
 
-		amn->amn_retrycnt =
+		retrycnt =
 		    (le32toh(sta[0]) & 0xffff) +	/* failed TX count */
 		    (le32toh(sta[1]) >> 16);		/* TX retransmission count */
 
-		amn->amn_txcnt =
-		    amn->amn_retrycnt +
+		txcnt =
+		    retrycnt +
 		    (le32toh(sta[1]) & 0xffff);		/* successful TX count */
 
-		amn->amn_success =
+		success =
 		    (le32toh(sta[1]) >> 16) +
 		    (le32toh(sta[1]) & 0xffff);
+		ieee80211_ratectl_tx_update(vap, ni, &txcnt, &success,
+		    &retrycnt);
 	}
 
-	ieee80211_amrr_choose(ni, amn);
+	ieee80211_ratectl_rate(ni, NULL, 0);
 
 skip:;
 	RUN_UNLOCK(sc);
@@ -4447,7 +4443,7 @@ run_stop(void *arg)
 	RUN_LOCK_ASSERT(sc, MA_OWNED);
 
 	if(sc->sc_rvp != NULL){
-		sc->sc_rvp->amrr_run = RUN_AMRR_OFF;
+		sc->sc_rvp->ratectl_run = RUN_RATECTL_OFF;
 		if (ic->ic_flags & IEEE80211_F_SCAN)
 			ieee80211_cancel_scan(&sc->sc_rvp->vap);
 	}
diff --git a/sys/dev/usb/wlan/if_runvar.h b/sys/dev/usb/wlan/if_runvar.h
index 87b15bc70340..a7f8f1f46e9d 100644
--- a/sys/dev/usb/wlan/if_runvar.h
+++ b/sys/dev/usb/wlan/if_runvar.h
@@ -107,13 +107,11 @@ struct run_node {
 struct run_vap {
 	struct ieee80211vap             vap;
 	struct ieee80211_beacon_offsets bo;
-	struct ieee80211_amrr           amrr;
-	struct ieee80211_amrr_node	amn[RT2870_WCID_MAX + 1];
-	struct usb_callout              amrr_ch;
-	struct task                     amrr_task;
-	uint8_t				amrr_run;
-#define RUN_AMRR_ON	1
-#define RUN_AMRR_OFF	0
+	struct usb_callout              ratectl_ch;
+	struct task                     ratectl_task;
+	uint8_t				ratectl_run;
+#define RUN_RATECTL_ON	1
+#define RUN_RATECTL_OFF	0
 
 	int                             (*newstate)(struct ieee80211vap *,
                                             enum ieee80211_state, int);
diff --git a/sys/dev/usb/wlan/if_ural.c b/sys/dev/usb/wlan/if_ural.c
index 25fb86fafa56..fc907bcb346d 100644
--- a/sys/dev/usb/wlan/if_ural.c
+++ b/sys/dev/usb/wlan/if_ural.c
@@ -66,7 +66,7 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_regdomain.h>
 #include <net80211/ieee80211_radiotap.h>
-#include <net80211/ieee80211_amrr.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
@@ -162,9 +162,6 @@ static void		ural_write_multi(struct ural_softc *, uint16_t, void *,
 static void		ural_bbp_write(struct ural_softc *, uint8_t, uint8_t);
 static uint8_t		ural_bbp_read(struct ural_softc *, uint8_t);
 static void		ural_rf_write(struct ural_softc *, uint8_t, uint32_t);
-static struct ieee80211_node *ural_node_alloc(struct ieee80211vap *,
-			    const uint8_t mac[IEEE80211_ADDR_LEN]);
-static void		ural_newassoc(struct ieee80211_node *, int);
 static void		ural_scan_start(struct ieee80211com *);
 static void		ural_scan_end(struct ieee80211com *);
 static void		ural_set_channel(struct ieee80211com *);
@@ -191,10 +188,10 @@ static void		ural_init(void *);
 static void		ural_stop(struct ural_softc *);
 static int		ural_raw_xmit(struct ieee80211_node *, struct mbuf *,
 			    const struct ieee80211_bpf_params *);
-static void		ural_amrr_start(struct ural_softc *,
+static void		ural_ratectl_start(struct ural_softc *,
 			    struct ieee80211_node *);
-static void		ural_amrr_timeout(void *);
-static void		ural_amrr_task(void *, int);
+static void		ural_ratectl_timeout(void *);
+static void		ural_ratectl_task(void *, int);
 static int		ural_pause(struct ural_softc *sc, int timeout);
 
 /*
@@ -403,7 +400,6 @@ static devclass_t ural_devclass;
 DRIVER_MODULE(ural, uhub, ural_driver, ural_devclass, NULL, 0);
 MODULE_DEPEND(ural, usb, 1, 1, 1);
 MODULE_DEPEND(ural, wlan, 1, 1, 1);
-MODULE_DEPEND(ural, wlan_amrr, 1, 1, 1);
 
 static int
 ural_match(device_t self)
@@ -500,9 +496,7 @@ ural_attach(device_t self)
 
 	ieee80211_ifattach(ic, sc->sc_bssid);
 	ic->ic_update_promisc = ural_update_promisc;
-	ic->ic_newassoc = ural_newassoc;
 	ic->ic_raw_xmit = ural_raw_xmit;
-	ic->ic_node_alloc = ural_node_alloc;
 	ic->ic_scan_start = ural_scan_start;
 	ic->ic_scan_end = ural_scan_end;
 	ic->ic_set_channel = ural_set_channel;
@@ -597,12 +591,10 @@ ural_vap_create(struct ieee80211com *ic,
 	uvp->newstate = vap->iv_newstate;
 	vap->iv_newstate = ural_newstate;
 
-	usb_callout_init_mtx(&uvp->amrr_ch, &sc->sc_mtx, 0);
-	TASK_INIT(&uvp->amrr_task, 0, ural_amrr_task, uvp);
-	ieee80211_amrr_init(&uvp->amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    1000 /* 1 sec */);
+	usb_callout_init_mtx(&uvp->ratectl_ch, &sc->sc_mtx, 0);
+	TASK_INIT(&uvp->ratectl_task, 0, ural_ratectl_task, uvp);
+	ieee80211_ratectl_init(vap);
+	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
 
 	/* complete setup */
 	ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
@@ -616,9 +608,9 @@ ural_vap_delete(struct ieee80211vap *vap)
 	struct ural_vap *uvp = URAL_VAP(vap);
 	struct ieee80211com *ic = vap->iv_ic;
 
-	usb_callout_drain(&uvp->amrr_ch);
-	ieee80211_draintask(ic, &uvp->amrr_task);
-	ieee80211_amrr_cleanup(&uvp->amrr);
+	usb_callout_drain(&uvp->ratectl_ch);
+	ieee80211_draintask(ic, &uvp->ratectl_task);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(uvp, M_80211_VAP);
 }
@@ -703,7 +695,7 @@ ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 
 	IEEE80211_UNLOCK(ic);
 	RAL_LOCK(sc);
-	usb_callout_stop(&uvp->amrr_ch);
+	usb_callout_stop(&uvp->ratectl_ch);
 
 	switch (nstate) {
 	case IEEE80211_S_INIT:
@@ -759,7 +751,7 @@ ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 		/* XXX should use ic_bsschan but not valid until after newstate call below */
 		tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
 		if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
-			ural_amrr_start(sc, ni);
+			ural_ratectl_start(sc, ni);
 
 		break;
 
@@ -1584,25 +1576,6 @@ ural_rf_write(struct ural_softc *sc, uint8_t reg, uint32_t val)
 	DPRINTFN(15, "RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff);
 }
 
-/* ARGUSED */
-static struct ieee80211_node *
-ural_node_alloc(struct ieee80211vap *vap __unused,
-	const uint8_t mac[IEEE80211_ADDR_LEN] __unused)
-{
-	struct ural_node *un;
-
-	un = malloc(sizeof(struct ural_node), M_80211_NODE, M_NOWAIT | M_ZERO);
-	return un != NULL ? &un->ni : NULL;
-}
-
-static void
-ural_newassoc(struct ieee80211_node *ni, int isnew)
-{
-	struct ieee80211vap *vap = ni->ni_vap;
-
-	ieee80211_amrr_node_init(&URAL_VAP(vap)->amrr, &URAL_NODE(ni)->amn, ni);
-}
-
 static void
 ural_scan_start(struct ieee80211com *ic)
 {
@@ -2231,7 +2204,7 @@ bad:
 }
 
 static void
-ural_amrr_start(struct ural_softc *sc, struct ieee80211_node *ni)
+ural_ratectl_start(struct ural_softc *sc, struct ieee80211_node *ni)
 {
 	struct ieee80211vap *vap = ni->ni_vap;
 	struct ural_vap *uvp = URAL_VAP(vap);
@@ -2239,23 +2212,23 @@ ural_amrr_start(struct ural_softc *sc, struct ieee80211_node *ni)
 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
 
-	ieee80211_amrr_node_init(&uvp->amrr, &URAL_NODE(ni)->amn, ni);
+	ieee80211_ratectl_node_init(ni);
 
-	usb_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp);
+	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
 }
 
 static void
-ural_amrr_timeout(void *arg)
+ural_ratectl_timeout(void *arg)
 {
 	struct ural_vap *uvp = arg;
 	struct ieee80211vap *vap = &uvp->vap;
 	struct ieee80211com *ic = vap->iv_ic;
 
-	ieee80211_runtask(ic, &uvp->amrr_task);
+	ieee80211_runtask(ic, &uvp->ratectl_task);
 }
 
 static void
-ural_amrr_task(void *arg, int pending)
+ural_ratectl_task(void *arg, int pending)
 {
 	struct ural_vap *uvp = arg;
 	struct ieee80211vap *vap = &uvp->vap;
@@ -2264,6 +2237,7 @@ ural_amrr_task(void *arg, int pending)
 	struct ural_softc *sc = ifp->if_softc;
 	struct ieee80211_node *ni = vap->iv_bss;
 	int ok, fail;
+	int sum, retrycnt;
 
 	RAL_LOCK(sc);
 	/* read and clear statistic registers (STA_CSR0 to STA_CSR10) */
@@ -2272,14 +2246,15 @@ ural_amrr_task(void *arg, int pending)
 	ok = sc->sta[7] +		/* TX ok w/o retry */
 	     sc->sta[8];		/* TX ok w/ retry */
 	fail = sc->sta[9];		/* TX retry-fail count */
+	sum = ok+fail;
+	retrycnt = sc->sta[8] + fail;
 
-	ieee80211_amrr_tx_update(&URAL_NODE(ni)->amn,
-	    ok+fail, ok, sc->sta[8] + fail);
-	(void) ieee80211_amrr_choose(ni, &URAL_NODE(ni)->amn);
+	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 */
 
-	usb_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp);
+	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
 	RAL_UNLOCK(sc);
 }
 
diff --git a/sys/dev/usb/wlan/if_uralvar.h b/sys/dev/usb/wlan/if_uralvar.h
index 5d9c5821a5a7..46dbfbddc8be 100644
--- a/sys/dev/usb/wlan/if_uralvar.h
+++ b/sys/dev/usb/wlan/if_uralvar.h
@@ -71,18 +71,11 @@ struct ural_tx_data {
 };
 typedef STAILQ_HEAD(, ural_tx_data) ural_txdhead;
 
-struct ural_node {
-	struct ieee80211_node		ni;
-	struct ieee80211_amrr_node	amn;
-};
-#define	URAL_NODE(ni)	((struct ural_node *)(ni))
-
 struct ural_vap {
 	struct ieee80211vap		vap;
 	struct ieee80211_beacon_offsets	bo;
-	struct ieee80211_amrr		amrr;
-	struct usb_callout		amrr_ch;
-	struct task			amrr_task;
+	struct usb_callout		ratectl_ch;
+	struct task			ratectl_task;
 
 	int				(*newstate)(struct ieee80211vap *,
 					    enum ieee80211_state, int);
diff --git a/sys/dev/usb/wlan/if_zyd.c b/sys/dev/usb/wlan/if_zyd.c
index 724bfaaf957d..ee143d632adc 100644
--- a/sys/dev/usb/wlan/if_zyd.c
+++ b/sys/dev/usb/wlan/if_zyd.c
@@ -65,7 +65,7 @@ __FBSDID("$FreeBSD$");
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_regdomain.h>
 #include <net80211/ieee80211_radiotap.h>
-#include <net80211/ieee80211_amrr.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
@@ -125,8 +125,6 @@ static void	zyd_vap_delete(struct ieee80211vap *);
 static void	zyd_tx_free(struct zyd_tx_data *, int);
 static void	zyd_setup_tx_list(struct zyd_softc *);
 static void	zyd_unsetup_tx_list(struct zyd_softc *);
-static struct ieee80211_node *zyd_node_alloc(struct ieee80211vap *,
-			    const uint8_t mac[IEEE80211_ADDR_LEN]);
 static int	zyd_newstate(struct ieee80211vap *, enum ieee80211_state, int);
 static int	zyd_cmd(struct zyd_softc *, uint16_t, const void *, int,
 		    void *, int, int);
@@ -163,7 +161,6 @@ static void	zyd_init_locked(struct zyd_softc *);
 static void	zyd_init(void *);
 static void	zyd_stop(struct zyd_softc *);
 static int	zyd_loadfirmware(struct zyd_softc *);
-static void	zyd_newassoc(struct ieee80211_node *, int);
 static void	zyd_scan_start(struct ieee80211com *);
 static void	zyd_scan_end(struct ieee80211com *);
 static void	zyd_set_channel(struct ieee80211com *);
@@ -408,9 +405,7 @@ zyd_attach(device_t dev)
 	ieee80211_init_channels(ic, NULL, &bands);
 
 	ieee80211_ifattach(ic, sc->sc_bssid);
-	ic->ic_newassoc = zyd_newassoc;
 	ic->ic_raw_xmit = zyd_raw_xmit;
-	ic->ic_node_alloc = zyd_node_alloc;
 	ic->ic_scan_start = zyd_scan_start;
 	ic->ic_scan_end = zyd_scan_end;
 	ic->ic_set_channel = zyd_set_channel;
@@ -483,10 +478,8 @@ zyd_vap_create(struct ieee80211com *ic,
 	zvp->newstate = vap->iv_newstate;
 	vap->iv_newstate = zyd_newstate;
 
-	ieee80211_amrr_init(&zvp->amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    1000 /* 1 sec */);
+	ieee80211_ratectl_init(vap);
+	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
 
 	/* complete setup */
 	ieee80211_vap_attach(vap, ieee80211_media_change,
@@ -500,7 +493,7 @@ zyd_vap_delete(struct ieee80211vap *vap)
 {
 	struct zyd_vap *zvp = ZYD_VAP(vap);
 
-	ieee80211_amrr_cleanup(&zvp->amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(zvp, M_80211_VAP);
 }
@@ -518,8 +511,8 @@ zyd_tx_free(struct zyd_tx_data *data, int txerr)
 		data->m = NULL;
 
 		if (txerr == 0)
-			ieee80211_amrr_tx_complete(&ZYD_NODE(data->ni)->amn,
-			    IEEE80211_AMRR_SUCCESS, 0);
+			ieee80211_ratectl_tx_complete(data->ni->ni_vap,
+			    data->ni, IEEE80211_RATECTL_TX_SUCCESS, NULL, NULL);
 		ieee80211_free_node(data->ni);
 		data->ni = NULL;
 	}
@@ -572,17 +565,6 @@ zyd_unsetup_tx_list(struct zyd_softc *sc)
 	}
 }
 
-/* ARGUSED */
-static struct ieee80211_node *
-zyd_node_alloc(struct ieee80211vap *vap __unused,
-	const uint8_t mac[IEEE80211_ADDR_LEN] __unused)
-{
-	struct zyd_node *zn;
-
-	zn = malloc(sizeof(struct zyd_node), M_80211_NODE, M_NOWAIT | M_ZERO);
-	return (zn != NULL) ? (&zn->ni) : (NULL);
-}
-
 static int
 zyd_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
 {
@@ -669,9 +651,12 @@ zyd_intr_read_callback(struct usb_xfer *xfer, usb_error_t error)
 			 */
 			ni = ieee80211_find_txnode(vap, retry->macaddr);
 			if (ni != NULL) {
-				ieee80211_amrr_tx_complete(&ZYD_NODE(ni)->amn,
-				    IEEE80211_AMRR_FAILURE,
-				    (int)(le16toh(retry->count) & 0xff));
+				int retrycnt =
+				    (int)(le16toh(retry->count) & 0xff);
+				
+				ieee80211_ratectl_tx_complete(vap, ni,
+				    IEEE80211_RATECTL_TX_FAILURE,
+				    &retrycnt, NULL);
 				ieee80211_free_node(ni);
 			}
 			if (le16toh(retry->count) & 0x100)
@@ -2498,7 +2483,7 @@ zyd_tx_start(struct zyd_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
 		else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
 			rate = tp->ucastrate;
 		else {
-			(void) ieee80211_amrr_choose(ni, &ZYD_NODE(ni)->amn);
+			(void) ieee80211_ratectl_rate(ni, NULL, 0);
 			rate = ni->ni_txrate;
 		}
 	}
@@ -2910,14 +2895,6 @@ zyd_loadfirmware(struct zyd_softc *sc)
 }
 
 static void
-zyd_newassoc(struct ieee80211_node *ni, int isnew)
-{
-	struct ieee80211vap *vap = ni->ni_vap;
-
-	ieee80211_amrr_node_init(&ZYD_VAP(vap)->amrr, &ZYD_NODE(ni)->amn, ni);
-}
-
-static void
 zyd_scan_start(struct ieee80211com *ic)
 {
 	struct ifnet *ifp = ic->ic_ifp;
@@ -2970,4 +2947,3 @@ static devclass_t zyd_devclass;
 DRIVER_MODULE(zyd, uhub, zyd_driver, zyd_devclass, NULL, 0);
 MODULE_DEPEND(zyd, usb, 1, 1, 1);
 MODULE_DEPEND(zyd, wlan, 1, 1, 1);
-MODULE_DEPEND(zyd, wlan_amrr, 1, 1, 1);
diff --git a/sys/dev/usb/wlan/if_zydreg.h b/sys/dev/usb/wlan/if_zydreg.h
index 57a5e879c6c0..dd11632bf2a5 100644
--- a/sys/dev/usb/wlan/if_zydreg.h
+++ b/sys/dev/usb/wlan/if_zydreg.h
@@ -1177,12 +1177,6 @@ struct zyd_rx_data {
 	int				rssi;
 };
 
-struct zyd_node {
-	struct ieee80211_node	ni;	/* must be the first */
-	struct ieee80211_amrr_node	amn;
-};
-#define	ZYD_NODE(ni)	((struct zyd_node *)(ni))
-
 struct zyd_rx_radiotap_header {
 	struct ieee80211_radiotap_header wr_ihdr;
 	uint8_t			wr_flags;
@@ -1243,7 +1237,6 @@ struct zyd_vap {
 	struct ieee80211vap	vap;
 	int			(*newstate)(struct ieee80211vap *,
 				    enum ieee80211_state, int);
-	struct ieee80211_amrr	amrr;
 };
 #define	ZYD_VAP(vap)	((struct zyd_vap *)(vap))
 
diff --git a/sys/dev/wpi/if_wpi.c b/sys/dev/wpi/if_wpi.c
index 1797c2d7271f..9bf9342140ab 100644
--- a/sys/dev/wpi/if_wpi.c
+++ b/sys/dev/wpi/if_wpi.c
@@ -93,6 +93,7 @@ __FBSDID("$FreeBSD$");
 #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>
@@ -173,8 +174,7 @@ static int	wpi_alloc_tx_ring(struct wpi_softc *, struct wpi_tx_ring *,
 		    int, int);
 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 struct ieee80211_node *wpi_node_alloc(struct ieee80211vap *,
-			    const uint8_t mac[IEEE80211_ADDR_LEN]);
+static void	wpi_newassoc(struct ieee80211_node *, int);
 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 *);
@@ -235,7 +235,6 @@ 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 void	wpi_newassoc(struct ieee80211_node *, int);
 static int	wpi_set_txpower(struct wpi_softc *, struct ieee80211_channel *,
 		    int);
 static void	wpi_calib_timeout(void *);
@@ -668,9 +667,8 @@ wpi_attach(device_t dev)
 
 	ieee80211_ifattach(ic, macaddr);
 	/* override default methods */
-	ic->ic_node_alloc = wpi_node_alloc;
-	ic->ic_newassoc = wpi_newassoc;
 	ic->ic_raw_xmit = wpi_raw_xmit;
+	ic->ic_newassoc = wpi_newassoc;
 	ic->ic_wme.wme_update = wpi_wme_update;
 	ic->ic_scan_start = wpi_scan_start;
 	ic->ic_scan_end = wpi_scan_end;
@@ -782,11 +780,7 @@ wpi_vap_create(struct ieee80211com *ic,
 	wvp->newstate = vap->iv_newstate;
 	vap->iv_newstate = wpi_newstate;
 
-	ieee80211_amrr_init(&wvp->amrr, vap,
-	    IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD,
-	    IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD,
-	    500 /*ms*/);
-
+	ieee80211_ratectl_init(vap);
 	/* complete setup */
 	ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
 	ic->ic_opmode = opmode;
@@ -798,7 +792,7 @@ wpi_vap_delete(struct ieee80211vap *vap)
 {
 	struct wpi_vap *wvp = WPI_VAP(vap);
 
-	ieee80211_amrr_cleanup(&wvp->amrr);
+	ieee80211_ratectl_deinit(vap);
 	ieee80211_vap_detach(vap);
 	free(wvp, M_80211_VAP);
 }
@@ -1236,18 +1230,6 @@ wpi_resume(device_t dev)
 	return 0;
 }
 
-/* ARGSUSED */
-static struct ieee80211_node *
-wpi_node_alloc(struct ieee80211vap *vap __unused,
-	const uint8_t mac[IEEE80211_ADDR_LEN] __unused)
-{
-	struct wpi_node *wn;
-
-	wn = malloc(sizeof (struct wpi_node), M_80211_NODE, M_NOWAIT | M_ZERO);
-
-	return &wn->ni;
-}
-
 /**
  * Called by net80211 when ever there is a change to 80211 state machine
  */
@@ -1567,7 +1549,9 @@ wpi_tx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc)
 	struct wpi_tx_ring *ring = &sc->txq[desc->qid & 0x3];
 	struct wpi_tx_data *txdata = &ring->data[desc->idx];
 	struct wpi_tx_stat *stat = (struct wpi_tx_stat *)(desc + 1);
-	struct wpi_node *wn = (struct wpi_node *)txdata->ni;
+	struct ieee80211_node *ni = txdata->ni;
+	struct ieee80211vap *vap = ni->ni_vap;
+	int retrycnt = 0;
 
 	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,
@@ -1580,11 +1564,12 @@ wpi_tx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc)
 	 * the lowest available bit-rate.
 	 * XXX frames w/o ACK shouldn't be used either
 	 */
-	wn->amn.amn_txcnt++;
 	if (stat->ntries > 0) {
 		DPRINTFN(WPI_DEBUG_TX, ("%d retries\n", stat->ntries));
-		wn->amn.amn_retrycnt++;
+		retrycnt = 1;
 	}
+	ieee80211_ratectl_tx_complete(vap, ni, IEEE80211_RATECTL_TX_SUCCESS,
+	    &retrycnt, NULL);
 
 	/* XXX oerrors should only count errors !maxtries */
 	if ((le32toh(stat->status) & 0xff) != 1)
@@ -1919,7 +1904,7 @@ wpi_tx_data(struct wpi_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
 	} else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) {
 		rate = tp->ucastrate;
 	} else {
-		(void) ieee80211_amrr_choose(ni, &WPI_NODE(ni)->amn);
+		(void) ieee80211_ratectl_rate(ni, NULL, 0);
 		rate = ni->ni_txrate;
 	}
 	tx->rate = wpi_plcp_signal(rate);
@@ -3214,10 +3199,9 @@ wpi_stop(struct wpi_softc *sc)
 static void
 wpi_newassoc(struct ieee80211_node *ni, int isnew)
 {
-	struct ieee80211vap *vap = ni->ni_vap;
-	struct wpi_vap *wvp = WPI_VAP(vap);
 
-	ieee80211_amrr_node_init(&wvp->amrr, &WPI_NODE(ni)->amn, ni);
+	/* XXX move */
+	ieee80211_ratectl_node_init(ni);
 }
 
 static void
@@ -3706,4 +3690,3 @@ static const char *wpi_cmd_str(int cmd)
 MODULE_DEPEND(wpi, pci,  1, 1, 1);
 MODULE_DEPEND(wpi, wlan, 1, 1, 1);
 MODULE_DEPEND(wpi, firmware, 1, 1, 1);
-MODULE_DEPEND(wpi, wlan_amrr, 1, 1, 1);
diff --git a/sys/dev/wpi/if_wpivar.h b/sys/dev/wpi/if_wpivar.h
index 811624b37ca7..00579b3eacd8 100644
--- a/sys/dev/wpi/if_wpivar.h
+++ b/sys/dev/wpi/if_wpivar.h
@@ -106,12 +106,6 @@ struct wpi_amrr {
 	int	recovery;
 };
 
-struct wpi_node {
-        struct  ieee80211_node ni;      /* must be the first */
-        struct  ieee80211_amrr_node     amn;
-};
-#define	WPI_NODE(ni)	((struct wpi_node *)(ni))
-
 struct wpi_power_sample {
 	uint8_t	index;
 	int8_t	power;
@@ -127,7 +121,6 @@ struct wpi_power_group {
 
 struct wpi_vap {
 	struct ieee80211vap	vap;
-	struct ieee80211_amrr	amrr;
 
 	int			(*newstate)(struct ieee80211vap *,
 				    enum ieee80211_state, int);
diff --git a/sys/fs/coda/cnode.h b/sys/fs/coda/cnode.h
index 8506404a2e6e..27531a4f6b29 100644
--- a/sys/fs/coda/cnode.h
+++ b/sys/fs/coda/cnode.h
@@ -94,7 +94,7 @@ extern int coda_vfsop_print_entry;
 struct cnode {
 	struct vnode	*c_vnode;
 	u_short		 c_flags;	/* flags (see below) */
-	CodaFid		 c_fid;		/* file handle */
+	struct CodaFid	 c_fid;		/* file handle */
 	struct vnode	*c_ovp;		/* open vnode pointer */
 	u_short		 c_ocount;	/* count of openers */
 	u_short		 c_owrite;	/* count of open for write */
@@ -196,7 +196,8 @@ void	coda_unmounting(struct mount *whoIam);
 int	coda_vmflush(struct cnode *cp);
 
 /* cfs_vnodeops.h */
-struct cnode	*make_coda_node(CodaFid *fid, struct mount *vfsp, short type);
+struct cnode	*make_coda_node(struct CodaFid *fid, struct mount *vfsp,
+		 short type);
 int		 coda_vnodeopstats_init(void);
 
 /* sigh */
diff --git a/sys/fs/coda/coda.h b/sys/fs/coda/coda.h
index 93547a4d7e80..ee1e7601f7be 100644
--- a/sys/fs/coda/coda.h
+++ b/sys/fs/coda/coda.h
@@ -103,6 +103,8 @@ struct timespec {
 };
 #endif
 
+typedef u_int32_t cuid_t;
+typedef u_int32_t cgid_t;
 
 /*
  * Cfs constants
@@ -132,14 +134,13 @@ struct timespec {
 #define C_A_F_OK    0               /* Test for existence.  */
 
 
-
 #ifndef _VENUS_DIRENT_T_
 #define _VENUS_DIRENT_T_ 1
 struct venus_dirent {
-        unsigned long	d_fileno;		/* file number of entry */
+        unsigned int	d_fileno;		/* file number of entry */
         unsigned short	d_reclen;		/* length of this record */
-        char 		d_type;			/* file type, see below */
-        char		d_namlen;		/* length of string in d_name */
+        unsigned char	d_type;			/* file type, see below */
+        unsigned char	d_namlen;		/* length of string in d_name */
         char		d_name[CODA_MAXNAMLEN + 1];/* name must be no longer than this */
 };
 #undef DIRSIZ
@@ -169,19 +170,19 @@ struct venus_dirent {
 
 #ifdef CODA_COMPAT_5
 
-typedef struct {
+struct CodaFid {
     u_long Volume;
     u_long Vnode;
     u_long Unique;      
-} CodaFid;
+};
 
-static __inline__ ino_t coda_f2i(CodaFid *fid)
+static __inline__ ino_t coda_f2i(struct CodaFid *fid)
 {
 	if (!fid) return 0;
 	return (fid->Unique + (fid->Vnode<<10) + (fid->Volume<<20));
 }
 
-static __inline__ char * coda_f2s(CodaFid *fid)
+static __inline__ char * coda_f2s(struct CodaFid *fid)
 {
   static char fid_str [35];
   snprintf (fid_str, 35, "[%lx.%lx.%lx]", fid->Volume,
@@ -189,7 +190,7 @@ static __inline__ char * coda_f2s(CodaFid *fid)
   return fid_str;
 }
  
-static __inline__ int coda_fid_eq (CodaFid *fid1, CodaFid *fid2)
+static __inline__ int coda_fid_eq (struct CodaFid *fid1, struct CodaFid *fid2)
 {
   return (fid1->Volume == fid2->Volume &&
 	  fid1->Vnode == fid2->Vnode &&
@@ -203,18 +204,18 @@ struct coda_cred {
 
 #else	/* CODA_COMPAT_5 */
 
-typedef struct  {
+struct CodaFid {
 	u_int32_t opaque[4];
-} CodaFid;
+};
 
-static __inline__ ino_t  coda_f2i(CodaFid *fid)
+static __inline__ ino_t  coda_f2i(struct CodaFid *fid)
 {
     if ( ! fid ) 
 	return 0; 
     return (fid->opaque[3] ^ (fid->opaque[2]<<10) ^ (fid->opaque[1]<<20) ^ fid->opaque[0]);
 }
 	
-static __inline__ char * coda_f2s(CodaFid *fid)
+static __inline__ char * coda_f2s(struct CodaFid *fid)
  {
      static char fid_str [35];
      snprintf (fid_str, 35, "[%x.%x.%x.%x]", fid->opaque[0],
@@ -222,7 +223,7 @@ static __inline__ char * coda_f2s(CodaFid *fid)
      return fid_str;
  }
 
-static __inline__ int coda_fid_eq (CodaFid *fid1, CodaFid *fid2)
+static __inline__ int coda_fid_eq (struct CodaFid *fid1, struct CodaFid *fid2)
 {
   return (fid1->opaque[0] == fid2->opaque[0] &&
 	  fid1->opaque[1] == fid2->opaque[1] &&
@@ -240,11 +241,11 @@ static __inline__ int coda_fid_eq (CodaFid *fid1, CodaFid *fid2)
 enum coda_vtype	{ C_VNON, C_VREG, C_VDIR, C_VBLK, C_VCHR, C_VLNK, C_VSOCK, C_VFIFO, C_VBAD };
 
 struct coda_vattr {
-	int     	va_type;	/* vnode type (for create) */
+	long     	va_type;	/* vnode type (for create) */
 	u_short		va_mode;	/* files access mode and type */
 	short		va_nlink;	/* number of references to file */
-	uid_t		va_uid;		/* owner user id */
-	gid_t		va_gid;		/* owner group id */
+	cuid_t		va_uid;		/* owner user id */
+	cgid_t		va_gid;		/* owner group id */
 	long		va_fileid;	/* file id */
 	u_quad_t	va_size;	/* file size in bytes */
 	long		va_blocksize;	/* blocksize preferred for i/o */
@@ -313,7 +314,7 @@ struct coda_statfs {
 #define VC_MAXMSGSIZE      sizeof(union inputArgs)+sizeof(union outputArgs) +\
                             VC_MAXDATASIZE  
 
-#define CIOC_KERNEL_VERSION _IOWR('c', 10, sizeof (int))
+#define CIOC_KERNEL_VERSION _IOWR('c', 10, int)
 #if	0
 	/* don't care about kernel version number */
 #define CODA_KERNEL_VERSION 0
@@ -344,23 +345,23 @@ struct coda_in_hdr {
 struct coda_in_hdr {
     u_int32_t opcode;
     u_int32_t unique;	    /* Keep multiple outstanding msgs distinct */
-    pid_t pid;		    /* Common to all */
-    pid_t pgid;		    /* Common to all */
-    uid_t uid;		    /* Common to all */
+    pid_t pid;
+    pid_t pgid;
+    cuid_t uid;
 };
 #endif
 
 /* Really important that opcode and unique are 1st two fields! */
 struct coda_out_hdr {
-    unsigned long opcode;
-    unsigned long unique;	
-    unsigned long result;
+    u_int32_t opcode;
+    u_int32_t unique;	
+    u_int32_t result;
 };
 
 /* coda_root: NO_IN */
 struct coda_root_out {
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 struct coda_root_in {
@@ -373,7 +374,7 @@ struct coda_root_in {
 /* coda_open: */
 struct coda_open_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int	flags;
 };
 
@@ -387,7 +388,7 @@ struct coda_open_out {
 /* coda_close: */
 struct coda_close_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int	flags;
 };
 
@@ -398,7 +399,7 @@ struct coda_close_out {
 /* coda_ioctl: */
 struct coda_ioctl_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
     int	cmd;
     int	len;
     int	rwflag;
@@ -415,7 +416,7 @@ struct coda_ioctl_out {
 /* coda_getattr: */
 struct coda_getattr_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 struct coda_getattr_out {
@@ -427,7 +428,7 @@ struct coda_getattr_out {
 /* coda_setattr: NO_OUT */
 struct coda_setattr_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
     struct coda_vattr attr;
 };
 
@@ -438,7 +439,7 @@ struct coda_setattr_out {
 /* coda_access: NO_OUT */
 struct coda_access_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int	flags;
 };
 
@@ -454,14 +455,14 @@ struct coda_access_out {
 /* coda_lookup: */
 struct  coda_lookup_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int         name;		/* Place holder for data. */
     int         flags;	
 };
 
 struct coda_lookup_out {
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
     int	vtype;
 };
 
@@ -469,7 +470,7 @@ struct coda_lookup_out {
 /* coda_create: */
 struct coda_create_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
     struct coda_vattr attr;
     int excl;
     int mode;
@@ -478,7 +479,7 @@ struct coda_create_in {
 
 struct coda_create_out {
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
     struct coda_vattr attr;
 };
 
@@ -486,7 +487,7 @@ struct coda_create_out {
 /* coda_remove: NO_OUT */
 struct coda_remove_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int name;		/* Place holder for data. */
 };
 
@@ -497,8 +498,8 @@ struct coda_remove_out {
 /* coda_link: NO_OUT */
 struct coda_link_in {
     struct coda_in_hdr ih;
-    CodaFid sourceFid;          /* cnode to link *to* */
-    CodaFid destFid;            /* Directory in which to place link */
+    struct CodaFid sourceFid;          /* cnode to link *to* */
+    struct CodaFid destFid;            /* Directory in which to place link */
     int tname;		/* Place holder for data. */
 };
 
@@ -510,9 +511,9 @@ struct coda_link_out {
 /* coda_rename: NO_OUT */
 struct coda_rename_in {
     struct coda_in_hdr ih;
-    CodaFid	sourceFid;
+    struct CodaFid	sourceFid;
     int 	srcname;
-    CodaFid destFid;
+    struct CodaFid destFid;
     int 	destname;
 };
 
@@ -523,14 +524,14 @@ struct coda_rename_out {
 /* coda_mkdir: */
 struct coda_mkdir_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     struct coda_vattr attr;
     int	   name;		/* Place holder for data. */
 };
 
 struct coda_mkdir_out {
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
     struct coda_vattr attr;
 };
 
@@ -538,7 +539,7 @@ struct coda_mkdir_out {
 /* coda_rmdir: NO_OUT */
 struct coda_rmdir_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int name;		/* Place holder for data. */
 };
 
@@ -549,7 +550,7 @@ struct coda_rmdir_out {
 /* coda_readdir: */
 struct coda_readdir_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int	count;
     int	offset;
 };
@@ -563,7 +564,7 @@ struct coda_readdir_out {
 /* coda_symlink: NO_OUT */
 struct coda_symlink_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;          /* Directory to put symlink in */
+    struct CodaFid	Fid;          /* Directory to put symlink in */
     int srcname;
     struct coda_vattr attr;
     int tname;
@@ -576,7 +577,7 @@ struct coda_symlink_out {
 /* coda_readlink: */
 struct coda_readlink_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 struct coda_readlink_out {
@@ -589,7 +590,7 @@ struct coda_readlink_out {
 /* coda_fsync: NO_OUT */
 struct coda_fsync_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 struct coda_fsync_out {
@@ -599,18 +600,18 @@ struct coda_fsync_out {
 /* coda_inactive: NO_OUT */
 struct coda_inactive_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 /* coda_vget: */
 struct coda_vget_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 struct coda_vget_out {
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
     int	vtype;
 };
 
@@ -626,7 +627,7 @@ struct coda_purgeuser_out {
 #ifdef CODA_COMPAT_5
     struct coda_cred cred;
 #else
-    uid_t uid;
+    cuid_t uid;
 #endif
 };
 
@@ -634,14 +635,14 @@ struct coda_purgeuser_out {
 /* CODA_ZAPFILE is a venus->kernel call */
 struct coda_zapfile_out {  
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 /* coda_zapdir: */
 /* CODA_ZAPDIR is a venus->kernel call */	
 struct coda_zapdir_out {	  
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 /* coda_zapnode: */
@@ -651,41 +652,44 @@ struct coda_zapvnode_out {
 #ifdef CODA_COMPAT_5
     struct coda_cred cred;
 #endif
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 /* coda_purgefid: */
 /* CODA_PURGEFID is a venus->kernel call */	
 struct coda_purgefid_out { 
     struct coda_out_hdr oh;
-    CodaFid Fid;
+    struct CodaFid Fid;
 };
 
 /* coda_replace: */
 /* CODA_REPLACE is a venus->kernel call */	
 struct coda_replace_out { /* coda_replace is a venus->kernel call */
      struct coda_out_hdr oh;
-    CodaFid NewFid;
-    CodaFid OldFid;
+    struct CodaFid NewFid;
+    struct CodaFid OldFid;
 };
 
 /* coda_open_by_fd: */
 struct coda_open_by_fd_in {
     struct coda_in_hdr ih;
-    CodaFid Fid;
+    struct CodaFid Fid;
     int	flags;
 };
 
 struct coda_open_by_fd_out {
     struct coda_out_hdr oh;
     int fd;
+#ifdef _KERNEL
+    /* not passed from userspace but used in-kernel only */
     struct vnode *vp;
+#endif
 };
 
 /* coda_open_by_path: */
 struct coda_open_by_path_in {
     struct coda_in_hdr ih;
-    CodaFid	Fid;
+    struct CodaFid	Fid;
     int	flags;
 };
 
@@ -799,6 +803,9 @@ struct PioctlData {
 
 #define	CODA_CONTROL		".CONTROL"
 #define CODA_CONTROLLEN           8
+#define	CTL_VOL			-1
+#define	CTL_VNO			-1
+#define	CTL_UNI			-1
 #define CTL_INO                 -1
 #define	CTL_FILE		"/coda/.CONTROL"
 
@@ -810,10 +817,9 @@ struct PioctlData {
 #define INVAL_FID		{ 0, 0, 0 }
 #else
 #define	CTL_FID			{ { -1, -1, -1, -1 } }
-#define	IS_CTL_FID(fidp)	((fidp)->opaque[0] == -1 &&\
-				 (fidp)->opaque[1] == -1 &&\
-				 (fidp)->opaque[2] == -1 &&\
-				 (fidp)->opaque[3] == -1)
+#define	IS_CTL_FID(fidp)	((fidp)->opaque[1] == CTL_VOL && \
+				(fidp)->opaque[2] == CTL_VNO && \
+				(fidp)->opaque[3] == CTL_UNI)
 #define	INVAL_FID		{ { 0, 0, 0, 0 } }
 #endif
 
diff --git a/sys/fs/coda/coda_subr.c b/sys/fs/coda/coda_subr.c
index e24950baefef..08c03cb00788 100644
--- a/sys/fs/coda/coda_subr.c
+++ b/sys/fs/coda/coda_subr.c
@@ -164,7 +164,7 @@ coda_unsave(struct cnode *cp)
  * NOTE: this allows multiple cnodes with same fid -- dcs 1/25/95
  */
 struct cnode *
-coda_find(CodaFid *fid)
+coda_find(struct CodaFid *fid)
 {
 	struct cnode *cp;
 
diff --git a/sys/fs/coda/coda_subr.h b/sys/fs/coda/coda_subr.h
index 0efc08169eb8..b8edfd3f0850 100644
--- a/sys/fs/coda/coda_subr.h
+++ b/sys/fs/coda/coda_subr.h
@@ -35,7 +35,7 @@
 
 struct cnode	*coda_alloc(void);
 void		 coda_free(struct cnode *cp);
-struct cnode	*coda_find(CodaFid *fid);
+struct cnode	*coda_find(struct CodaFid *fid);
 void		 coda_flush(struct coda_mntinfo *mnt, enum dc_status dcstat);
 void		 coda_testflush(void);
 void		 coda_checkunmounting(struct mount *mp);
diff --git a/sys/fs/coda/coda_venus.c b/sys/fs/coda/coda_venus.c
index b5e3b962a920..9999d3ae47b5 100644
--- a/sys/fs/coda/coda_venus.c
+++ b/sys/fs/coda/coda_venus.c
@@ -177,7 +177,7 @@ int coda_kernel_version = CODA_KERNEL_VERSION;
 
 int
 venus_root(void *mdp, struct ucred *cred, struct proc *p,
-    /*out*/ CodaFid *VFid)
+    /*out*/ struct CodaFid *VFid)
 {
 	DECL_NO_IN(coda_root);		/* sets Isize & Osize */
 	ALLOC_NO_IN(coda_root);		/* sets inp & outp */
@@ -194,7 +194,7 @@ venus_root(void *mdp, struct ucred *cred, struct proc *p,
 }
 
 int
-venus_open(void *mdp, CodaFid *fid, int flag, struct ucred *cred,
+venus_open(void *mdp, struct CodaFid *fid, int flag, struct ucred *cred,
     struct proc *p, /*out*/ struct vnode **vp)
 {
 	int cflag;
@@ -215,7 +215,7 @@ venus_open(void *mdp, CodaFid *fid, int flag, struct ucred *cred,
 }
 
 int
-venus_close(void *mdp, CodaFid *fid, int flag, struct ucred *cred,
+venus_close(void *mdp, struct CodaFid *fid, int flag, struct ucred *cred,
     struct proc *p)
 {
 	int cflag;
@@ -252,7 +252,7 @@ venus_write(void)
  * normal files.
  */
 int
-venus_ioctl(void *mdp, CodaFid *fid, int com, int flag, caddr_t data,
+venus_ioctl(void *mdp, struct CodaFid *fid, int com, int flag, caddr_t data,
     struct ucred *cred, struct proc *p)
 {
 	DECL(coda_ioctl);			/* sets Isize & Osize */
@@ -304,7 +304,8 @@ venus_ioctl(void *mdp, CodaFid *fid, int com, int flag, caddr_t data,
 }
 
 int
-venus_getattr(void *mdp, CodaFid *fid, struct ucred *cred, struct vattr *vap)
+venus_getattr(void *mdp, struct CodaFid *fid, struct ucred *cred,
+    struct vattr *vap)
 {
 	struct proc *p;
 	DECL(coda_getattr);			/* sets Isize & Osize */
@@ -326,7 +327,8 @@ venus_getattr(void *mdp, CodaFid *fid, struct ucred *cred, struct vattr *vap)
 }
 
 int
-venus_setattr(void *mdp, CodaFid *fid, struct vattr *vap, struct ucred *cred)
+venus_setattr(void *mdp, struct CodaFid *fid, struct vattr *vap,
+    struct ucred *cred)
 {
 	struct proc *p;
 	DECL_NO_OUT(coda_setattr);		/* sets Isize & Osize */
@@ -347,8 +349,8 @@ venus_setattr(void *mdp, CodaFid *fid, struct vattr *vap, struct ucred *cred)
 }
 
 int
-venus_access(void *mdp, CodaFid *fid, accmode_t accmode, struct ucred *cred,
-    struct proc *p)
+venus_access(void *mdp, struct CodaFid *fid, accmode_t accmode,
+    struct ucred *cred, struct proc *p)
 {
 	DECL_NO_OUT(coda_access);		/* sets Isize & Osize */
 	ALLOC_NO_OUT(coda_access);		/* sets inp & outp */
@@ -374,8 +376,8 @@ venus_access(void *mdp, CodaFid *fid, accmode_t accmode, struct ucred *cred,
 }
 
 int
-venus_readlink(void *mdp, CodaFid *fid, struct ucred *cred, struct proc *p,
-    /*out*/ char **str, int *len)
+venus_readlink(void *mdp, struct CodaFid *fid, struct ucred *cred,
+    struct proc *p, /*out*/ char **str, int *len)
 {
 	DECL(coda_readlink);			/* sets Isize & Osize */
 	coda_readlink_size += CODA_MAXPATHLEN;
@@ -400,7 +402,7 @@ venus_readlink(void *mdp, CodaFid *fid, struct ucred *cred, struct proc *p,
 }
 
 int
-venus_fsync(void *mdp, CodaFid *fid, struct proc *p)
+venus_fsync(void *mdp, struct CodaFid *fid, struct proc *p)
 {
 	DECL_NO_OUT(coda_fsync);		/* sets Isize & Osize */
 	ALLOC_NO_OUT(coda_fsync);		/* sets inp & outp */
@@ -420,8 +422,9 @@ venus_fsync(void *mdp, CodaFid *fid, struct proc *p)
 }
 
 int
-venus_lookup(void *mdp, CodaFid *fid, const char *nm, int len,
-    struct ucred *cred, struct proc *p, /*out*/	CodaFid *VFid, int *vtype)
+venus_lookup(void *mdp, struct CodaFid *fid, const char *nm, int len,
+    struct ucred *cred, struct proc *p, /*out*/	struct CodaFid *VFid,
+    int *vtype)
 {
 	DECL(coda_lookup);			/* sets Isize & Osize */
 	coda_lookup_size += len + 1;
@@ -457,9 +460,9 @@ venus_lookup(void *mdp, CodaFid *fid, const char *nm, int len,
 }
 
 int
-venus_create(void *mdp, CodaFid *fid, const char *nm, int len, int exclusive,
-    int mode, struct vattr *va, struct ucred *cred, struct proc *p,
-    /*out*/ CodaFid *VFid, struct vattr *attr)
+venus_create(void *mdp, struct CodaFid *fid, const char *nm, int len,
+    int exclusive, int mode, struct vattr *va, struct ucred *cred,
+    struct proc *p, /*out*/ struct CodaFid *VFid, struct vattr *attr)
 {
 	DECL(coda_create);			/* sets Isize & Osize */
 	coda_create_size += len + 1;
@@ -488,7 +491,7 @@ venus_create(void *mdp, CodaFid *fid, const char *nm, int len, int exclusive,
 }
 
 int
-venus_remove(void *mdp, CodaFid *fid, const char *nm, int len,
+venus_remove(void *mdp, struct CodaFid *fid, const char *nm, int len,
     struct ucred *cred, struct proc *p)
 {
 	DECL_NO_OUT(coda_remove);		/* sets Isize & Osize */
@@ -511,8 +514,8 @@ venus_remove(void *mdp, CodaFid *fid, const char *nm, int len,
 }
 
 int
-venus_link(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm, int len,
-    struct ucred *cred, struct proc *p)
+venus_link(void *mdp, struct CodaFid *fid, struct CodaFid *tfid,
+    const char *nm, int len, struct ucred *cred, struct proc *p)
 {
 	DECL_NO_OUT(coda_link);		/* sets Isize & Osize */
 	coda_link_size += len + 1;
@@ -535,8 +538,9 @@ venus_link(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm, int len,
 }
 
 int
-venus_rename(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm, int len,
-    const char *tnm, int tlen, struct ucred *cred, struct proc *p)
+venus_rename(void *mdp, struct CodaFid *fid, struct CodaFid *tfid,
+    const char *nm, int len, const char *tnm, int tlen, struct ucred *cred,
+    struct proc *p)
 {
 	DECL_NO_OUT(coda_rename);		/* sets Isize & Osize */
 	coda_rename_size += len + 1 + tlen + 1;
@@ -562,9 +566,9 @@ venus_rename(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm, int len,
 }
 
 int
-venus_mkdir(void *mdp, CodaFid *fid, const char *nm, int len,
+venus_mkdir(void *mdp, struct CodaFid *fid, const char *nm, int len,
     struct vattr *va, struct ucred *cred, struct proc *p,
-    /*out*/ CodaFid *VFid, struct vattr *ova)
+    /*out*/ struct CodaFid *VFid, struct vattr *ova)
 {
 	DECL(coda_mkdir);			/* sets Isize & Osize */
 	coda_mkdir_size += len + 1;
@@ -591,7 +595,7 @@ venus_mkdir(void *mdp, CodaFid *fid, const char *nm, int len,
 }
 
 int
-venus_rmdir(void *mdp, CodaFid *fid, const char *nm, int len,
+venus_rmdir(void *mdp, struct CodaFid *fid, const char *nm, int len,
     struct ucred *cred, struct proc *p)
 {
 	DECL_NO_OUT(coda_rmdir);		/* sets Isize & Osize */
@@ -614,7 +618,7 @@ venus_rmdir(void *mdp, CodaFid *fid, const char *nm, int len,
 }
 
 int
-venus_symlink(void *mdp, CodaFid *fid, const char *lnm, int llen,
+venus_symlink(void *mdp, struct CodaFid *fid, const char *lnm, int llen,
     const char *nm, int len, struct vattr *va, struct ucred *cred,
     struct proc *p)
 {
@@ -645,7 +649,7 @@ venus_symlink(void *mdp, CodaFid *fid, const char *lnm, int llen,
  * XXX: Unused.
  */
 int
-venus_readdir(void *mdp, CodaFid *fid, int count, int offset,
+venus_readdir(void *mdp, struct CodaFid *fid, int count, int offset,
     struct ucred *cred, struct proc *p, /*out*/	char *buffer, int *len)
 {
 	DECL(coda_readdir);			/* sets Isize & Osize */
@@ -672,8 +676,8 @@ venus_readdir(void *mdp, CodaFid *fid, int count, int offset,
 }
 
 int
-venus_fhtovp(void *mdp, CodaFid *fid, struct ucred *cred, struct proc *p,
-    /*out*/ CodaFid *VFid, int *vtype)
+venus_fhtovp(void *mdp, struct CodaFid *fid, struct ucred *cred,
+    struct proc *p, /*out*/ struct CodaFid *VFid, int *vtype)
 {
 	DECL(coda_vget);			/* sets Isize & Osize */
 	ALLOC(coda_vget);			/* sets inp & outp */
diff --git a/sys/fs/coda/coda_venus.h b/sys/fs/coda/coda_venus.h
index 0d4dac08631a..95f1c576438e 100644
--- a/sys/fs/coda/coda_venus.h
+++ b/sys/fs/coda/coda_venus.h
@@ -34,49 +34,50 @@
 #define	_CODA_VENUS_H_
 
 int	venus_root(void *mdp, struct ucred *cred, struct proc *p,
-	    /*out*/ CodaFid *VFid);
-int	venus_open(void *mdp, CodaFid *fid, int flag, struct ucred *cred,
-	    struct proc *p, /*out*/ struct vnode **vp);
-int	venus_close(void *mdp, CodaFid *fid, int flag, struct ucred *cred,
-	    struct proc *p);
+	    /*out*/ struct CodaFid *VFid);
+int	venus_open(void *mdp, struct CodaFid *fid, int flag,
+	    struct ucred *cred, struct proc *p, /*out*/ struct vnode **vp);
+int	venus_close(void *mdp, struct CodaFid *fid, int flag,
+	    struct ucred *cred, struct proc *p);
 void	venus_read(void);
 void	venus_write(void);
-int	venus_ioctl(void *mdp, CodaFid *fid, int com, int flag, caddr_t data,
-	    struct ucred *cred, struct proc *p);
-int	venus_getattr(void *mdp, CodaFid *fid, struct ucred *cred,
+int	venus_ioctl(void *mdp, struct CodaFid *fid, int com, int flag,
+	    caddr_t data, struct ucred *cred, struct proc *p);
+int	venus_getattr(void *mdp, struct CodaFid *fid, struct ucred *cred,
 	    struct vattr *vap);
-int	venus_setattr(void *mdp, CodaFid *fid, struct vattr *vap,
+int	venus_setattr(void *mdp, struct CodaFid *fid, struct vattr *vap,
 	    struct ucred *cred);
-int	venus_access(void *mdp, CodaFid *fid, int mode, struct ucred *cred,
-	    struct proc *p);
-int	venus_readlink(void *mdp, CodaFid *fid, struct ucred *cred,
+int	venus_access(void *mdp, struct CodaFid *fid, int mode,
+	    struct ucred *cred, struct proc *p);
+int	venus_readlink(void *mdp, struct CodaFid *fid, struct ucred *cred,
 	    struct proc *p, /*out*/ char **str, int *len);
-int	venus_fsync(void *mdp, CodaFid *fid, struct proc *p);
-int	venus_lookup(void *mdp, CodaFid *fid, const char *nm, int len,
-	    struct ucred *cred, struct proc *p, /*out*/ CodaFid *VFid,
+int	venus_fsync(void *mdp, struct CodaFid *fid, struct proc *p);
+int	venus_lookup(void *mdp, struct CodaFid *fid, const char *nm, int len,
+	    struct ucred *cred, struct proc *p, /*out*/ struct CodaFid *VFid,
 	    int *vtype);
-int	venus_create(void *mdp, CodaFid *fid, const char *nm, int len,
+int	venus_create(void *mdp, struct CodaFid *fid, const char *nm, int len,
 	    int exclusive, int mode, struct vattr *va, struct ucred *cred,
-	    struct proc *p, /*out*/ CodaFid *VFid, struct vattr *attr);
-int	venus_remove(void *mdp, CodaFid *fid, const char *nm, int len,
+	    struct proc *p, /*out*/ struct CodaFid *VFid,
+	    struct vattr *attr);
+int	venus_remove(void *mdp, struct CodaFid *fid, const char *nm, int len,
 	    struct ucred *cred, struct proc *p);
-int	venus_link(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm,
-	    int len, struct ucred *cred, struct proc *p);
-int	venus_rename(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm,
-	    int len, const char *tnm, int tlen, struct ucred *cred,
-	    struct proc *p);
-int	venus_mkdir(void *mdp, CodaFid *fid, const char *nm, int len,
+int	venus_link(void *mdp, struct CodaFid *fid, struct CodaFid *tfid,
+	    const char *nm, int len, struct ucred *cred, struct proc *p);
+int	venus_rename(void *mdp, struct CodaFid *fid, struct CodaFid *tfid,
+	    const char *nm, int len, const char *tnm, int tlen,
+	    struct ucred *cred, struct proc *p);
+int	venus_mkdir(void *mdp, struct CodaFid *fid, const char *nm, int len,
 	    struct vattr *va, struct ucred *cred, struct proc *p,
-	    /*out*/ CodaFid *VFid, struct vattr *ova);
-int	venus_rmdir(void *mdp, CodaFid *fid, const char *nm, int len,
+	    /*out*/ struct CodaFid *VFid, struct vattr *ova);
+int	venus_rmdir(void *mdp, struct CodaFid *fid, const char *nm, int len,
+	    struct ucred *cred, struct proc *p);
+int	venus_symlink(void *mdp, struct CodaFid *fid, const char *lnm,
+	    int llen, const char *nm, int len, struct vattr *va,
 	    struct ucred *cred, struct proc *p);
-int	venus_symlink(void *mdp, CodaFid *fid, const char *lnm, int llen,
-	    const char *nm, int len, struct vattr *va, struct ucred *cred,
-	    struct proc *p);
-int	venus_readdir(void *mdp, CodaFid *fid, int count, int offset,
+int	venus_readdir(void *mdp, struct CodaFid *fid, int count, int offset,
 	    struct ucred *cred, struct proc *p, /*out*/	char *buffer,
 	    int *len);
-int	venus_fhtovp(void *mdp, CodaFid *fid, struct ucred *cred,
-	    struct proc *p, /*out*/ CodaFid *VFid, int *vtype);
+int	venus_fhtovp(void *mdp, struct CodaFid *fid, struct ucred *cred,
+	    struct proc *p, /*out*/ struct CodaFid *VFid, int *vtype);
 
 #endif /* !_CODA_VENUS_H_ */
diff --git a/sys/fs/coda/coda_vfsops.c b/sys/fs/coda/coda_vfsops.c
index b12c43bc3626..90660c622a28 100644
--- a/sys/fs/coda/coda_vfsops.c
+++ b/sys/fs/coda/coda_vfsops.c
@@ -113,8 +113,8 @@ coda_mount(struct mount *vfsp)
 	struct cdev *dev;
 	struct coda_mntinfo *mi;
 	struct vnode *rootvp;
-	CodaFid rootfid = INVAL_FID;
-	CodaFid ctlfid = CTL_FID;
+	struct CodaFid rootfid = INVAL_FID;
+	struct CodaFid ctlfid = CTL_FID;
 	int error;
 	struct nameidata ndp;
 	ENTRY;
@@ -268,8 +268,8 @@ coda_root(struct mount *vfsp, int flags, struct vnode **vpp)
 	int error;
 	struct proc *p;
 	struct thread *td;
-	CodaFid VFid;
-	static const CodaFid invalfid = INVAL_FID;
+	struct CodaFid VFid;
+	static const struct CodaFid invalfid = INVAL_FID;
 
 	td = curthread;
 	p = td->td_proc;
@@ -288,7 +288,7 @@ coda_root(struct mount *vfsp, int flags, struct vnode **vpp)
 		 * but not in any released versions as of 6 Mar 2003.
 		 */
 		if (memcmp(&VTOC(mi->mi_rootvp)->c_fid, &invalfid,
-		    sizeof(CodaFid)) != 0 || mi->mi_started == 0) {
+		    sizeof(struct CodaFid)) != 0 || mi->mi_started == 0) {
 			/*
 			 * Found valid root.
 			 */
@@ -407,7 +407,7 @@ coda_fhtovp(struct mount *vfsp, struct fid *fhp, struct mbuf *nam,
 	int error;
 	struct thread *td = curthread; /* XXX -mach */
 	struct proc *p = td->td_proc;
-	CodaFid VFid;
+	struct CodaFid VFid;
 	int vtype;
 
 	ENTRY;
diff --git a/sys/fs/coda/coda_vfsops.h b/sys/fs/coda/coda_vfsops.h
index b51f4bc3d37c..e5b3a11b644a 100644
--- a/sys/fs/coda/coda_vfsops.h
+++ b/sys/fs/coda/coda_vfsops.h
@@ -42,7 +42,7 @@
 struct cfid {
 	u_short	cfid_len;
 	u_short	padding;
-	CodaFid	cfid_fid;
+	struct CodaFid	cfid_fid;
 };
 
 struct mbuf;
diff --git a/sys/fs/coda/coda_vnops.c b/sys/fs/coda/coda_vnops.c
index edaba652a0f6..79d53e53b10d 100644
--- a/sys/fs/coda/coda_vnops.c
+++ b/sys/fs/coda/coda_vnops.c
@@ -872,7 +872,7 @@ coda_lookup(struct vop_cachedlookup_args *ap)
 	struct cnode *cp;
 	const char *nm = cnp->cn_nameptr;
 	int len = cnp->cn_namelen;
-	CodaFid VFid;
+	struct CodaFid VFid;
 	int vtype;
 	int error = 0;
 
@@ -1009,7 +1009,7 @@ coda_create(struct vop_create_args *ap)
 	struct cnode *cp;
 	const char *nm = cnp->cn_nameptr;
 	int len = cnp->cn_namelen;
-	CodaFid VFid;
+	struct CodaFid VFid;
 	struct vattr attr;
 
 	MARK_ENTRY(CODA_CREATE_STATS);
@@ -1278,7 +1278,7 @@ coda_mkdir(struct vop_mkdir_args *ap)
 	const char *nm = cnp->cn_nameptr;
 	int len = cnp->cn_namelen;
 	struct cnode *cp;
-	CodaFid VFid;
+	struct CodaFid VFid;
 	struct vattr ova;
 
 	MARK_ENTRY(CODA_MKDIR_STATS);
@@ -1687,7 +1687,7 @@ coda_print_cred(struct ucred *cred)
  * coda_unsave.
  */
 struct cnode *
-make_coda_node(CodaFid *fid, struct mount *vfsp, short type)
+make_coda_node(struct CodaFid *fid, struct mount *vfsp, short type)
 {
 	struct cnode *cp;
 	struct vnode *vp;
diff --git a/sys/fs/deadfs/dead_vnops.c b/sys/fs/deadfs/dead_vnops.c
index 7a07b38542ec..e2556543fb60 100644
--- a/sys/fs/deadfs/dead_vnops.c
+++ b/sys/fs/deadfs/dead_vnops.c
@@ -225,13 +225,7 @@ dead_rename(ap)
 		struct componentname *a_tcnp;
 	} */ *ap;
 {
-	if (ap->a_tvp)
-		vput(ap->a_tvp);
-	if (ap->a_tdvp == ap->a_tvp)
-		vrele(ap->a_tdvp);
-	else
-		vput(ap->a_tdvp);
-	vrele(ap->a_fdvp);
-	vrele(ap->a_fvp);
+
+	vop_rename_fail(ap);
 	return (EXDEV);
 }
diff --git a/sys/fs/devfs/devfs_devs.c b/sys/fs/devfs/devfs_devs.c
index 81b2752583e0..79037ba63130 100644
--- a/sys/fs/devfs/devfs_devs.c
+++ b/sys/fs/devfs/devfs_devs.c
@@ -408,6 +408,9 @@ devfs_populate_loop(struct devfs_mount *dm, int cleanup)
 			continue;
 		KASSERT((cdp->cdp_flags & CDP_ACTIVE), ("Bogons, I tell ya'!"));
 
+		if (cdp->cdp_flags & CDP_INVALID)
+			continue;
+
 		if (dm->dm_idx <= cdp->cdp_maxdirent &&
 		    cdp->cdp_dirents[dm->dm_idx] != NULL) {
 			de = cdp->cdp_dirents[dm->dm_idx];
@@ -425,6 +428,8 @@ devfs_populate_loop(struct devfs_mount *dm, int cleanup)
 		dd = dm->dm_rootdir;
 		s = cdp->cdp_c.si_name;
 		for (;;) {
+			while (*s == '/')
+				s++;
 			for (q = s; *q != '/' && *q != '\0'; q++)
 				continue;
 			if (*q != '/')
@@ -434,6 +439,24 @@ devfs_populate_loop(struct devfs_mount *dm, int cleanup)
 				de = devfs_vmkdir(dm, s, q - s, dd, 0);
 			s = q + 1;
 			dd = de;
+			if (dd->de_flags & (DE_DOT | DE_DOTDOT))
+				break;
+		}
+
+		/*
+		 * XXX: Ignore duplicate and empty device names.
+		 * XXX: Currently there is no way to report the error to
+		 * XXX: the make_dev(9) caller.
+		 */
+		if (dd->de_dirent->d_type != DT_DIR ||
+		    dd->de_flags & (DE_DOT | DE_DOTDOT) || q - s < 1 ||
+		    devfs_find(dd, s, q - s) != NULL) {
+			dev_lock();
+			cdp->cdp_flags |= CDP_INVALID;
+			dev_unlock();
+			printf("%s: %s: invalid or duplicate device name\n",
+			    __func__, cdp->cdp_c.si_name);
+			return (1);
 		}
 
 		de = devfs_newdirent(s, q - s);
diff --git a/sys/fs/devfs/devfs_int.h b/sys/fs/devfs/devfs_int.h
index 5a61dd4a79b0..a998061513f2 100644
--- a/sys/fs/devfs/devfs_int.h
+++ b/sys/fs/devfs/devfs_int.h
@@ -55,6 +55,7 @@ struct cdev_priv {
 	u_int			cdp_flags;
 #define CDP_ACTIVE		(1 << 0)
 #define CDP_SCHED_DTR		(1 << 1)
+#define CDP_INVALID		(1 << 2)
 
 	u_int			cdp_inuse;
 	u_int			cdp_maxdirent;
diff --git a/sys/fs/msdosfs/msdosfs_vfsops.c b/sys/fs/msdosfs/msdosfs_vfsops.c
index 77583eecd391..a0801bde22a5 100644
--- a/sys/fs/msdosfs/msdosfs_vfsops.c
+++ b/sys/fs/msdosfs/msdosfs_vfsops.c
@@ -580,6 +580,7 @@ mountmsdosfs(struct vnode *devvp, struct mount *mp)
 	  || (pmp->pm_BytesPerSec & (pmp->pm_BytesPerSec - 1))
 	  || (pmp->pm_HugeSectors == 0)
 	  || (pmp->pm_FATsecs == 0)
+	  || (SecPerClust * pmp->pm_BlkPerSec > MAXBSIZE / DEV_BSIZE)
 	) {
 		error = EINVAL;
 		goto error_exit;
diff --git a/sys/fs/nfsserver/nfs_nfsdport.c b/sys/fs/nfsserver/nfs_nfsdport.c
index 724d46b70b43..ba367e300697 100644
--- a/sys/fs/nfsserver/nfs_nfsdport.c
+++ b/sys/fs/nfsserver/nfs_nfsdport.c
@@ -1397,24 +1397,16 @@ nfsvno_fillattr(struct nfsrv_descript *nd, struct vnode *vp,
  * nfs readdir service
  * - mallocs what it thinks is enough to read
  *	count rounded up to a multiple of DIRBLKSIZ <= NFS_MAXREADDIR
- * - calls nfsvno_readdir()
+ * - calls VOP_READDIR()
  * - loops around building the reply
  *	if the output generated exceeds count break out of loop
  *	The NFSM_CLGET macro is used here so that the reply will be packed
  *	tightly in mbuf clusters.
- * - it only knows that it has encountered eof when the nfsvno_readdir()
- *	reads nothing
- * - as such one readdir rpc will return eof false although you are there
- *	and then the next will return eof
  * - it trims out records with d_fileno == 0
  *	this doesn't matter for Unix clients, but they might confuse clients
  *	for other os'.
  * - it trims out records with d_type == DT_WHT
  *	these cannot be seen through NFS (unless we extend the protocol)
- * NB: It is tempting to set eof to true if the nfsvno_readdir() reads less
- *	than requested, but this may not apply to all filesystems. For
- *	example, client NFS does not { although it is never remote mounted
- *	anyhow }
  *     The alternate call nfsrvd_readdirplus() does lookups as well.
  * PS: The NFS protocol spec. does not clarify what the "count" byte
  *	argument is a count of.. just name strings and file id's or the
@@ -1456,7 +1448,7 @@ nfsrvd_readdir(struct nfsrv_descript *nd, int isdgram,
 	}
 	toff = off;
 	cnt = fxdr_unsigned(int, *tl);
-	if (cnt > NFS_SRVMAXDATA(nd))
+	if (cnt > NFS_SRVMAXDATA(nd) || cnt < 0)
 		cnt = NFS_SRVMAXDATA(nd);
 	siz = ((cnt + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
 	fullsiz = siz;
@@ -1474,6 +1466,13 @@ nfsrvd_readdir(struct nfsrv_descript *nd, int isdgram,
 			nd->nd_repstat = NFSERR_BAD_COOKIE;
 #endif
 	}
+	if (nd->nd_repstat == 0 && cnt == 0) {
+		if (nd->nd_flag & ND_NFSV2)
+			/* NFSv2 does not have NFSERR_TOOSMALL */
+			nd->nd_repstat = EPERM;
+		else
+			nd->nd_repstat = NFSERR_TOOSMALL;
+	}
 	if (!nd->nd_repstat)
 		nd->nd_repstat = nfsvno_accchk(vp, VEXEC,
 		    nd->nd_cred, exp, p, NFSACCCHK_NOOVERRIDE,
@@ -1696,7 +1695,7 @@ nfsrvd_readdirplus(struct nfsrv_descript *nd, int isdgram,
 	 * Use the server's maximum data transfer size as the upper bound
 	 * on reply datalen.
 	 */
-	if (cnt > NFS_SRVMAXDATA(nd))
+	if (cnt > NFS_SRVMAXDATA(nd) || cnt < 0)
 		cnt = NFS_SRVMAXDATA(nd);
 
 	/*
@@ -1705,7 +1704,7 @@ nfsrvd_readdirplus(struct nfsrv_descript *nd, int isdgram,
 	 * so I set it to cnt for that case. I also round it up to the
 	 * next multiple of DIRBLKSIZ.
 	 */
-	if (siz == 0)
+	if (siz <= 0)
 		siz = cnt;
 	siz = ((siz + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
 
diff --git a/sys/fs/nfsserver/nfs_nfsdserv.c b/sys/fs/nfsserver/nfs_nfsdserv.c
index 9a362873e727..50fa822b512a 100644
--- a/sys/fs/nfsserver/nfs_nfsdserv.c
+++ b/sys/fs/nfsserver/nfs_nfsdserv.c
@@ -2086,6 +2086,10 @@ nfsrvd_lock(struct nfsrv_descript *nd, __unused int isdgram,
 	if (flags & NFSLCK_OPENTOLOCK) {
 		NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED + NFSX_STATEID);
 		i = fxdr_unsigned(int, *(tl+4+(NFSX_STATEID / NFSX_UNSIGNED)));
+		if (i <= 0 || i > NFSV4_OPAQUELIMIT) {
+			nd->nd_repstat = NFSERR_BADXDR;
+			goto nfsmout;
+		}
 		MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i,
 			M_NFSDSTATE, M_WAITOK);
 		stp->ls_ownerlen = i;
@@ -2229,6 +2233,10 @@ nfsrvd_lockt(struct nfsrv_descript *nd, __unused int isdgram,
 
 	NFSM_DISSECT(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
 	i = fxdr_unsigned(int, *(tl + 7));
+	if (i <= 0 || i > NFSV4_OPAQUELIMIT) {
+		nd->nd_repstat = NFSERR_BADXDR;
+		goto nfsmout;
+	}
 	MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i,
 	    M_NFSDSTATE, M_WAITOK);
 	stp->ls_ownerlen = i;
@@ -2350,6 +2358,8 @@ nfsrvd_locku(struct nfsrv_descript *nd, __unused int isdgram,
 		break;
 	default:
 		nd->nd_repstat = NFSERR_BADXDR;
+		free(stp, M_NFSDSTATE);
+		free(lop, M_NFSDLOCK);
 		goto nfsmout;
 	};
 	stp->ls_ownerlen = 0;
@@ -2439,6 +2449,14 @@ nfsrvd_open(struct nfsrv_descript *nd, __unused int isdgram,
 	named.ni_cnd.cn_nameiop = 0;
 	NFSM_DISSECT(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
 	i = fxdr_unsigned(int, *(tl + 5));
+	if (i <= 0 || i > NFSV4_OPAQUELIMIT) {
+		nd->nd_repstat = NFSERR_BADXDR;
+		vrele(dp);
+#ifdef NFS4_ACL_EXTATTR_NAME
+		acl_free(aclp);
+#endif
+		return (0);
+	}
 	MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + i,
 	    M_NFSDSTATE, M_WAITOK);
 	stp->ls_ownerlen = i;
@@ -3391,6 +3409,10 @@ nfsrvd_releaselckown(struct nfsrv_descript *nd, __unused int isdgram,
 	}
 	NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
 	len = fxdr_unsigned(int, *(tl + 2));
+	if (len <= 0 || len > NFSV4_OPAQUELIMIT) {
+		nd->nd_repstat = NFSERR_BADXDR;
+		return (0);
+	}
 	MALLOC(stp, struct nfsstate *, sizeof (struct nfsstate) + len,
 	    M_NFSDSTATE, M_WAITOK);
 	stp->ls_ownerlen = len;
diff --git a/sys/fs/nwfs/nwfs.h b/sys/fs/nwfs/nwfs.h
index d7b2f6299e2f..af71724ffd43 100644
--- a/sys/fs/nwfs/nwfs.h
+++ b/sys/fs/nwfs/nwfs.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_io.c b/sys/fs/nwfs/nwfs_io.c
index 2f9ac0153466..75b1c188a18a 100644
--- a/sys/fs/nwfs/nwfs_io.c
+++ b/sys/fs/nwfs/nwfs_io.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_ioctl.c b/sys/fs/nwfs/nwfs_ioctl.c
index 0fd55319493d..35fe93e2bb91 100644
--- a/sys/fs/nwfs/nwfs_ioctl.c
+++ b/sys/fs/nwfs/nwfs_ioctl.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_mount.h b/sys/fs/nwfs/nwfs_mount.h
index a6f9568bb666..a1670942eafc 100644
--- a/sys/fs/nwfs/nwfs_mount.h
+++ b/sys/fs/nwfs/nwfs_mount.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_node.c b/sys/fs/nwfs/nwfs_node.c
index 1e044c66e26f..fc9b41bd8909 100644
--- a/sys/fs/nwfs/nwfs_node.c
+++ b/sys/fs/nwfs/nwfs_node.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_node.h b/sys/fs/nwfs/nwfs_node.h
index f2e0adae58ac..89545ebe375f 100644
--- a/sys/fs/nwfs/nwfs_node.h
+++ b/sys/fs/nwfs/nwfs_node.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_subr.c b/sys/fs/nwfs/nwfs_subr.c
index 732651fa7b80..cb85450ff34e 100644
--- a/sys/fs/nwfs/nwfs_subr.c
+++ b/sys/fs/nwfs/nwfs_subr.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_subr.h b/sys/fs/nwfs/nwfs_subr.h
index 683a94379d97..e571349cddd6 100644
--- a/sys/fs/nwfs/nwfs_subr.h
+++ b/sys/fs/nwfs/nwfs_subr.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_vfsops.c b/sys/fs/nwfs/nwfs_vfsops.c
index eed51c6b49c5..497414ed7146 100644
--- a/sys/fs/nwfs/nwfs_vfsops.c
+++ b/sys/fs/nwfs/nwfs_vfsops.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/nwfs/nwfs_vnops.c b/sys/fs/nwfs/nwfs_vnops.c
index e63df804572f..e4f42b1f0a39 100644
--- a/sys/fs/nwfs/nwfs_vnops.c
+++ b/sys/fs/nwfs/nwfs_vnops.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs.h b/sys/fs/smbfs/smbfs.h
index bdecd99d5a4b..4be0a55c76b3 100644
--- a/sys/fs/smbfs/smbfs.h
+++ b/sys/fs/smbfs/smbfs.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_io.c b/sys/fs/smbfs/smbfs_io.c
index 8ff8266f6853..df779a6151bf 100644
--- a/sys/fs/smbfs/smbfs_io.c
+++ b/sys/fs/smbfs/smbfs_io.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_node.c b/sys/fs/smbfs/smbfs_node.c
index 38464cd8a70b..a0543e28ffa1 100644
--- a/sys/fs/smbfs/smbfs_node.c
+++ b/sys/fs/smbfs/smbfs_node.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_node.h b/sys/fs/smbfs/smbfs_node.h
index f9c08cf76f64..ed1c17d7881b 100644
--- a/sys/fs/smbfs/smbfs_node.h
+++ b/sys/fs/smbfs/smbfs_node.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_smb.c b/sys/fs/smbfs/smbfs_smb.c
index 3a89a9ce7b44..f58f7de47f7c 100644
--- a/sys/fs/smbfs/smbfs_smb.c
+++ b/sys/fs/smbfs/smbfs_smb.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_subr.c b/sys/fs/smbfs/smbfs_subr.c
index 68ed0b191cfc..b775dff897ee 100644
--- a/sys/fs/smbfs/smbfs_subr.c
+++ b/sys/fs/smbfs/smbfs_subr.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_subr.h b/sys/fs/smbfs/smbfs_subr.h
index a72b9e657a5f..15112903bd35 100644
--- a/sys/fs/smbfs/smbfs_subr.h
+++ b/sys/fs/smbfs/smbfs_subr.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_vfsops.c b/sys/fs/smbfs/smbfs_vfsops.c
index 2a328b35a1ca..16352d7a31f1 100644
--- a/sys/fs/smbfs/smbfs_vfsops.c
+++ b/sys/fs/smbfs/smbfs_vfsops.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/fs/smbfs/smbfs_vnops.c b/sys/fs/smbfs/smbfs_vnops.c
index 0fd023374d5e..830c249e0067 100644
--- a/sys/fs/smbfs/smbfs_vnops.c
+++ b/sys/fs/smbfs/smbfs_vnops.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/geom/geom_vfs.c b/sys/geom/geom_vfs.c
index 9bfa74654e5d..e50e17b0e64d 100644
--- a/sys/geom/geom_vfs.c
+++ b/sys/geom/geom_vfs.c
@@ -161,6 +161,10 @@ g_vfs_open(struct vnode *vp, struct g_consumer **cpp, const char *fsname, int wr
 	g_topology_assert();
 
 	*cpp = NULL;
+	bo = &vp->v_bufobj;
+	if (bo->bo_private != vp)
+		return (EBUSY);
+
 	pp = g_dev_getprovider(vp->v_rdev);
 	if (pp == NULL)
 		return (ENOENT);
@@ -176,10 +180,10 @@ g_vfs_open(struct vnode *vp, struct g_consumer **cpp, const char *fsname, int wr
 	vnode_create_vobject(vp, pp->mediasize, curthread);
 	VFS_UNLOCK_GIANT(vfslocked);
 	*cpp = cp;
-	bo = &vp->v_bufobj;
+	cp->private = vp;
 	bo->bo_ops = g_vfs_bufops;
 	bo->bo_private = cp;
-	bo->bo_bsize = DEV_BSIZE;
+	bo->bo_bsize = pp->sectorsize;
 	gp->softc = bo;
 
 	return (error);
@@ -196,5 +200,6 @@ g_vfs_close(struct g_consumer *cp)
 	gp = cp->geom;
 	bo = gp->softc;
 	bufobj_invalbuf(bo, V_SAVE, 0, 0);
+	bo->bo_private = cp->private;
 	g_wither_geom_close(gp, ENXIO);
 }
diff --git a/sys/geom/sched/README b/sys/geom/sched/README
new file mode 100644
index 000000000000..1b52d901162b
--- /dev/null
+++ b/sys/geom/sched/README
@@ -0,0 +1,162 @@
+
+	--- GEOM BASED DISK SCHEDULERS FOR FREEBSD ---
+
+This code contains a framework for GEOM-based disk schedulers and a
+couple of sample scheduling algorithms that use the framework and
+implement two forms of "anticipatory scheduling" (see below for more
+details).
+
+As a quick example of what this code can give you, try to run "dd",
+"tar", or some other program with highly SEQUENTIAL access patterns,
+together with "cvs", "cvsup", "svn" or other highly RANDOM access patterns
+(this is not a made-up example: it is pretty common for developers
+to have one or more apps doing random accesses, and others that do
+sequential accesses e.g., loading large binaries from disk, checking
+the integrity of tarballs, watching media streams and so on).
+
+These are the results we get on a local machine (AMD BE2400 dual
+core CPU, SATA 250GB disk):
+
+    /mnt is a partition mounted on /dev/ad0s1f
+
+    cvs: 	cvs -d /mnt/home/ncvs-local update -Pd /mnt/ports
+    dd-read:	dd bs=128k of=/dev/null if=/dev/ad0 (or ad0-sched-)
+    dd-writew	dd bs=128k if=/dev/zero of=/mnt/largefile
+
+			NO SCHEDULER		RR SCHEDULER
+                	dd	cvs		dd	cvs
+
+    dd-read only        72 MB/s	----		72 MB/s	---
+    dd-write only	55 MB/s	---		55 MB/s	---
+    dd-read+cvs		 6 MB/s	ok    		30 MB/s	ok
+    dd-write+cvs	55 MB/s slooow		14 MB/s	ok
+
+As you can see, when a cvs is running concurrently with dd, the
+performance drops dramatically, and depending on read or write mode,
+one of the two is severely penalized.  The use of the RR scheduler
+in this example makes the dd-reader go much faster when competing
+with cvs, and lets cvs progress when competing with a writer.
+
+To try it out:
+
+1. USERS OF FREEBSD 7, PLEASE READ CAREFULLY THE FOLLOWING:
+
+    On loading, this module patches one kernel function (g_io_request())
+    so that I/O requests ("bio's") carry a classification tag, useful
+    for scheduling purposes.
+
+    ON FREEBSD 7, the tag is stored in an existing (though rarely used)
+    field of the "struct bio", a solution which makes this module
+    incompatible with other modules using it, such as ZFS and gjournal.
+    Additionally, g_io_request() is patched in-memory to add a call
+    to the function that initializes this field (i386/amd64 only;
+    for other architectures you need to manually patch sys/geom/geom_io.c).
+    See details in the file g_sched.c.
+
+    On FreeBSD 8.0 and above, the above trick is not necessary,
+    as the struct bio contains dedicated fields for the classifier,
+    and hooks for request classifiers.
+
+    If you don't like the above, don't run this code.
+
+2. PLEASE MAKE SURE THAT THE DISK THAT YOU WILL BE USING FOR TESTS
+   DOES NOT CONTAIN PRECIOUS DATA.
+    This is experimental code, so we make no guarantees, though
+    I am routinely using it on my desktop and laptop.
+
+3. EXTRACT AND BUILD THE PROGRAMS
+    A 'make install' in the directory should work (with root privs),
+    or you can even try the binary modules.
+    If you want to build the modules yourself, look at the Makefile.
+
+4. LOAD THE MODULE, CREATE A GEOM NODE, RUN TESTS
+
+    The scheduler's module must be loaded first:
+
+      # kldload gsched_rr
+
+    substitute with gsched_as to test AS.  Then, supposing that you are
+    using /dev/ad0 for testing, a scheduler can be attached to it with:
+
+      # geom sched insert ad0
+
+    The scheduler is inserted transparently in the geom chain, so
+    mounted partitions and filesystems will keep working, but
+    now requests will go through the scheduler.
+
+    To change scheduler on-the-fly, you can reconfigure the geom:
+
+      # geom sched configure -a as ad0.sched.
+
+    assuming that gsched_as was loaded previously.
+
+5. SCHEDULER REMOVAL
+
+    In principle it is possible to remove the scheduler module
+    even on an active chain by doing
+
+	# geom sched destroy ad0.sched.
+
+    However, there is some race in the geom subsystem which makes
+    the removal unsafe if there are active requests on a chain.
+    So, in order to reduce the risk of data losses, make sure
+    you don't remove a scheduler from a chain with ongoing transactions.
+
+--- NOTES ON THE SCHEDULERS ---
+
+The important contribution of this code is the framework to experiment
+with different scheduling algorithms.  'Anticipatory scheduling'
+is a very powerful technique based on the following reasoning:
+
+    The disk throughput is much better if it serves sequential requests.
+    If we have a mix of sequential and random requests, and we see a
+    non-sequential request, do not serve it immediately but instead wait
+    a little bit (2..5ms) to see if there is another one coming that
+    the disk can serve more efficiently.
+
+There are many details that should be added to make sure that the
+mechanism is effective with different workloads and systems, to
+gain a few extra percent in performance, to improve fairness,
+insulation among processes etc.  A discussion of the vast literature
+on the subject is beyond the purpose of this short note.
+
+--------------------------------------------------------------------------
+
+TRANSPARENT INSERT/DELETE
+
+geom_sched is an ordinary geom module, however it is convenient
+to plug it transparently into the geom graph, so that one can
+enable or disable scheduling on a mounted filesystem, and the
+names in /etc/fstab do not depend on the presence of the scheduler.
+
+To understand how this works in practice, remember that in GEOM
+we have "providers" and "geom" objects.
+Say that we want to hook a scheduler on provider "ad0",
+accessible through pointer 'pp'. Originally, pp is attached to
+geom "ad0" (same name, different object) accessible through pointer old_gp
+
+  BEFORE	---> [ pp    --> old_gp ...]
+
+A normal "geom sched create ad0" call would create a new geom node
+on top of provider ad0/pp, and export a newly created provider
+("ad0.sched." accessible through pointer newpp).
+
+  AFTER create  ---> [ newpp --> gp --> cp ] ---> [ pp    --> old_gp ... ]
+
+On top of newpp, a whole tree will be created automatically, and we
+can e.g. mount partitions on /dev/ad0.sched.s1d, and those requests
+will go through the scheduler, whereas any partition mounted on
+the pre-existing device entries will not go through the scheduler.
+
+With the transparent insert mechanism, the original provider "ad0"/pp
+is hooked to the newly created geom, as follows:
+
+  AFTER insert  ---> [ pp    --> gp --> cp ] ---> [ newpp --> old_gp ... ]
+
+so anything that was previously using provider pp will now have
+the requests routed through the scheduler node.
+
+A removal ("geom sched destroy ad0.sched.") will restore the original
+configuration.
+
+# $FreeBSD$
diff --git a/sys/geom/sched/g_sched.c b/sys/geom/sched/g_sched.c
new file mode 100644
index 000000000000..6f339b92d9e6
--- /dev/null
+++ b/sys/geom/sched/g_sched.c
@@ -0,0 +1,1895 @@
+/*-
+ * Copyright (c) 2009-2010 Fabio Checconi
+ * Copyright (c) 2009-2010 Luigi Rizzo, Universita` di Pisa
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * $Id$
+ * $FreeBSD$
+ *
+ * Main control module for geom-based disk schedulers ('sched').
+ *
+ * USER VIEW
+ * A 'sched' node is typically inserted transparently between
+ * an existing provider pp and its original geom gp
+ *
+ *	[pp --> gp  ..]
+ *
+ * using the command "geom sched insert <provider>" and
+ * resulting in the following topology
+ *
+ *	[pp --> sched_gp --> cp]   [new_pp --> gp ... ]
+ *
+ * Deletion "geom sched destroy <provider>.sched." restores the
+ * original chain. The normal "geom sched create <provide>"
+ * is also supported.
+ *
+ * INTERNALS
+ * Internally, the 'sched' uses the following data structures
+ *
+ *   geom{}         g_sched_softc{}      g_gsched{}
+ * +----------+    +---------------+   +-------------+
+ * |  softc *-|--->| sc_gsched   *-|-->|  gs_init    |
+ * |  ...     |    |               |   |  gs_fini    |
+ * |          |    | [ hash table] |   |  gs_start   |
+ * +----------+    |               |   |  ...        |
+ *                 |               |   +-------------+
+ *                 |               |
+ *                 |               |     g_*_softc{}
+ *                 |               |   +-------------+
+ *                 | sc_data     *-|-->|             |
+ *                 +---------------+   |  algorithm- |
+ *                                     |  specific   |
+ *                                     +-------------+
+ *
+ * A g_sched_softc{} is created with a "geom sched insert" call.
+ * In turn this instantiates a specific scheduling algorithm,
+ * which sets sc_gsched to point to the algorithm callbacks,
+ * and calls gs_init() to create the g_*_softc{} .
+ * The other callbacks (gs_start, gs_next, ...) are invoked
+ * as needed 
+ *
+ * g_sched_softc{} is defined in g_sched.h and mostly used here;
+ * g_gsched{}, and the gs_callbacks, are documented in gs_scheduler.h;
+ * g_*_softc{} is defined/implemented by each algorithm (gs_*.c)
+ *
+ * DATA MOVING
+ * When a bio is received on the provider, it goes to the
+ * g_sched_start() which calls gs_start() to initially queue it;
+ * then we call g_sched_dispatch() that loops around gs_next()
+ * to select zero or more bio's to be sent downstream.
+ *
+ * g_sched_dispatch() can also be called as a result of a timeout,
+ * e.g. when doing anticipation or pacing requests.
+ *
+ * When a bio comes back, it goes to g_sched_done() which in turn
+ * calls gs_done(). The latter does any necessary housekeeping in
+ * the scheduling algorithm, and may decide to call g_sched_dispatch()
+ * to send more bio's downstream.
+ *
+ * If an algorithm needs per-flow queues, these are created
+ * calling gs_init_class() and destroyed with gs_fini_class(),
+ * and they are also inserted in the hash table implemented in
+ * the g_sched_softc{}
+ *
+ * If an algorithm is replaced, or a transparently-inserted node is
+ * removed with "geom sched destroy", we need to remove all references
+ * to the g_*_softc{} and g_sched_softc from the bio's still in
+ * the scheduler. g_sched_forced_dispatch() helps doing this.
+ * XXX need to explain better.
+ */
+
+#include <sys/cdefs.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/bio.h>
+#include <sys/limits.h>
+#include <sys/hash.h>
+#include <sys/sysctl.h>
+#include <sys/malloc.h>
+#include <sys/proc.h>		/* we access curthread */
+#include <geom/geom.h>
+#include "gs_scheduler.h"
+#include "g_sched.h"		/* geom hooks */
+
+/*
+ * Size of the per-geom hash table storing traffic classes.
+ * We may decide to change it at a later time, it has no ABI
+ * implications as it is only used for run-time allocations.
+ */
+#define G_SCHED_HASH_SIZE	32
+
+static int g_sched_destroy(struct g_geom *gp, boolean_t force);
+static int g_sched_destroy_geom(struct gctl_req *req,
+    struct g_class *mp, struct g_geom *gp);
+static void g_sched_config(struct gctl_req *req, struct g_class *mp,
+    const char *verb);
+static struct g_geom *g_sched_taste(struct g_class *mp,
+    struct g_provider *pp, int flags __unused);
+static void g_sched_dumpconf(struct sbuf *sb, const char *indent,
+    struct g_geom *gp, struct g_consumer *cp, struct g_provider *pp);
+static void g_sched_init(struct g_class *mp);
+static void g_sched_fini(struct g_class *mp);
+
+struct g_class g_sched_class = {
+	.name = G_SCHED_CLASS_NAME,
+	.version = G_VERSION,
+	.ctlreq = g_sched_config,
+	.taste = g_sched_taste,
+	.destroy_geom = g_sched_destroy_geom,
+	.init = g_sched_init,
+	.fini = g_sched_fini
+};
+
+MALLOC_DEFINE(M_GEOM_SCHED, "GEOM_SCHED", "Geom schedulers data structures");
+
+/*
+ * Global variables describing the state of the geom_sched module.
+ * There is only one static instance of this structure.
+ */
+LIST_HEAD(gs_list, g_gsched);	/* type, link field */
+struct geom_sched_vars {
+	struct mtx	gs_mtx;
+	struct gs_list	gs_scheds;	/* list of algorithms */
+	u_int		gs_debug;
+	u_int		gs_sched_count;	/* how many algorithms ? */
+	u_int 		gs_patched;	/* g_io_request was patched */
+
+	u_int		gs_initialized;
+	u_int		gs_expire_secs;	/* expiration of hash entries */
+
+	struct bio_queue_head gs_pending;
+	u_int		gs_npending;
+
+	/* The following are for stats, usually protected by gs_mtx. */
+	u_long		gs_requests;	/* total requests */
+	u_long		gs_done;	/* total done */
+	u_int 		gs_in_flight;	/* requests in flight */
+	u_int 		gs_writes_in_flight;
+	u_int 		gs_bytes_in_flight;
+	u_int 		gs_write_bytes_in_flight;
+
+	char		gs_names[256];	/* names of schedulers */
+};
+
+static struct geom_sched_vars me = {
+	.gs_expire_secs = 10,
+};
+
+SYSCTL_DECL(_kern_geom);
+SYSCTL_NODE(_kern_geom, OID_AUTO, sched, CTLFLAG_RW, 0,
+    "GEOM_SCHED stuff");
+
+SYSCTL_INT(_kern_geom_sched, OID_AUTO, in_flight_wb, CTLFLAG_RD,
+    &me.gs_write_bytes_in_flight, 0, "Write bytes in flight");
+
+SYSCTL_INT(_kern_geom_sched, OID_AUTO, in_flight_b, CTLFLAG_RD,
+    &me.gs_bytes_in_flight, 0, "Bytes in flight");
+
+SYSCTL_UINT(_kern_geom_sched, OID_AUTO, in_flight_w, CTLFLAG_RD,
+    &me.gs_writes_in_flight, 0, "Write Requests in flight");
+
+SYSCTL_UINT(_kern_geom_sched, OID_AUTO, in_flight, CTLFLAG_RD,
+    &me.gs_in_flight, 0, "Requests in flight");
+
+SYSCTL_ULONG(_kern_geom_sched, OID_AUTO, done, CTLFLAG_RD,
+    &me.gs_done, 0, "Total done");
+
+SYSCTL_ULONG(_kern_geom_sched, OID_AUTO, requests, CTLFLAG_RD,
+    &me.gs_requests, 0, "Total requests");
+
+SYSCTL_STRING(_kern_geom_sched, OID_AUTO, algorithms, CTLFLAG_RD,
+    &me.gs_names, 0, "Algorithm names");
+
+SYSCTL_UINT(_kern_geom_sched, OID_AUTO, alg_count, CTLFLAG_RD,
+    &me.gs_sched_count, 0, "Number of algorithms");
+
+SYSCTL_UINT(_kern_geom_sched, OID_AUTO, debug, CTLFLAG_RW,
+    &me.gs_debug, 0, "Debug level");
+
+SYSCTL_UINT(_kern_geom_sched, OID_AUTO, expire_secs, CTLFLAG_RW,
+    &me.gs_expire_secs, 0, "Expire time in seconds");
+
+/*
+ * g_sched calls the scheduler algorithms with this lock held.
+ * The locking functions are exposed so the scheduler algorithms can also
+ * protect themselves e.g. when running a callout handler.
+ */
+void
+g_sched_lock(struct g_geom *gp)
+{
+	struct g_sched_softc *sc = gp->softc;
+
+	mtx_lock(&sc->sc_mtx);
+}
+
+void
+g_sched_unlock(struct g_geom *gp)
+{
+	struct g_sched_softc *sc = gp->softc;
+
+	mtx_unlock(&sc->sc_mtx);
+}
+
+/*
+ * Support functions to handle references to the module,
+ * which are coming from devices using this scheduler.
+ */
+static inline void
+g_gsched_ref(struct g_gsched *gsp)
+{
+
+	atomic_add_int(&gsp->gs_refs, 1);
+}
+
+static inline void
+g_gsched_unref(struct g_gsched *gsp)
+{
+
+	atomic_add_int(&gsp->gs_refs, -1);
+}
+
+/*
+ * Update the stats when this request is done.
+ */
+static void
+g_sched_update_stats(struct bio *bio)
+{
+
+	me.gs_done++;
+	me.gs_in_flight--;
+	me.gs_bytes_in_flight -= bio->bio_length;
+	if (bio->bio_cmd & BIO_WRITE) {
+		me.gs_writes_in_flight--;
+		me.gs_write_bytes_in_flight -= bio->bio_length;
+	}
+}
+
+/*
+ * Dispatch any pending request.
+ */
+static void
+g_sched_forced_dispatch(struct g_geom *gp)
+{
+	struct g_sched_softc *sc = gp->softc;
+	struct g_gsched *gsp = sc->sc_gsched;
+	struct bio *bp;
+
+	KASSERT(mtx_owned(&sc->sc_mtx),
+	    ("sc_mtx not owned during forced dispatch"));
+
+	while ((bp = gsp->gs_next(sc->sc_data, 1)) != NULL)
+		g_io_request(bp, LIST_FIRST(&gp->consumer));
+}
+
+/*
+ * The main dispatch loop, called either here after the start
+ * routine, or by scheduling algorithms when they receive a timeout
+ * or a 'done' notification.  Does not share code with the forced
+ * dispatch path, since the gs_done() callback can call us.
+ */
+void
+g_sched_dispatch(struct g_geom *gp)
+{
+	struct g_sched_softc *sc = gp->softc;
+	struct g_gsched *gsp = sc->sc_gsched;
+	struct bio *bp;
+
+	KASSERT(mtx_owned(&sc->sc_mtx), ("sc_mtx not owned during dispatch"));
+
+	if ((sc->sc_flags & G_SCHED_FLUSHING))
+		return;
+
+	while ((bp = gsp->gs_next(sc->sc_data, 0)) != NULL)
+		g_io_request(bp, LIST_FIRST(&gp->consumer));
+}
+
+/*
+ * Recent (8.0 and above) versions of FreeBSD have support to
+ * register classifiers of disk requests. The classifier is
+ * invoked by g_io_request(), and stores the information into
+ * bp->bio_classifier1.
+ *
+ * Support for older versions, which is left here only for
+ * documentation purposes, relies on two hacks:
+ * 1. classification info is written into the bio_caller1
+ *    field of the topmost node in the bio chain. This field
+ *    is rarely used, but this module is incompatible with
+ *    those that use bio_caller1 for other purposes,
+ *    such as ZFS and gjournal;
+ * 2. g_io_request() is patched in-memory when the module is
+ *    loaded, so that the function calls a classifier as its
+ *    first thing. g_io_request() is restored when the module
+ *    is unloaded. This functionality is only supported for
+ *    x86 and amd64, other architectures need source code changes.
+ */
+
+/*
+ * Lookup the identity of the issuer of the original request.
+ * In the current implementation we use the curthread of the
+ * issuer, but different mechanisms may be implemented later
+ * so we do not make assumptions on the return value which for
+ * us is just an opaque identifier.
+ */
+
+static inline u_long
+g_sched_classify(struct bio *bp)
+{
+
+#if __FreeBSD_version > 800098
+	/* we have classifier fields in the struct bio */
+#define HAVE_BIO_CLASSIFIER
+	return ((u_long)bp->bio_classifier1);
+#else
+#warning old version!!!
+	while (bp->bio_parent != NULL)
+		bp = bp->bio_parent;
+
+	return ((u_long)bp->bio_caller1);
+#endif
+}
+
+/* Return the hash chain for the given key. */
+static inline struct g_hash *
+g_sched_hash(struct g_sched_softc *sc, u_long key)
+{
+
+	return (&sc->sc_hash[key & sc->sc_mask]);
+}
+
+/*
+ * Helper function for the children classes, which takes
+ * a geom and a bio and returns the private descriptor
+ * associated to the request.  This involves fetching
+ * the classification field and [al]locating the
+ * corresponding entry in the hash table.
+ */
+void *
+g_sched_get_class(struct g_geom *gp, struct bio *bp)
+{
+	struct g_sched_softc *sc;
+	struct g_sched_class *gsc;
+	struct g_gsched *gsp;
+	struct g_hash *bucket;
+	u_long key;
+
+	sc = gp->softc;
+	key = g_sched_classify(bp);
+	bucket = g_sched_hash(sc, key);
+	LIST_FOREACH(gsc, bucket, gsc_clist) {
+		if (key == gsc->gsc_key) {
+			gsc->gsc_refs++;
+			return (gsc->gsc_priv);
+		}
+	}
+
+	gsp = sc->sc_gsched;
+	gsc = malloc(sizeof(*gsc) + gsp->gs_priv_size,
+	    M_GEOM_SCHED, M_NOWAIT | M_ZERO);
+	if (!gsc)
+		return (NULL);
+
+	if (gsp->gs_init_class(sc->sc_data, gsc->gsc_priv)) {
+		free(gsc, M_GEOM_SCHED);
+		return (NULL);
+	}
+
+	gsc->gsc_refs = 2;	/* 1 for the hash table, 1 for the caller. */
+	gsc->gsc_key = key;
+	LIST_INSERT_HEAD(bucket, gsc, gsc_clist);
+
+	gsc->gsc_expire = ticks + me.gs_expire_secs * hz;
+
+	return (gsc->gsc_priv);
+}
+
+/*
+ * Release a reference to the per-client descriptor,
+ */
+void
+g_sched_put_class(struct g_geom *gp, void *priv)
+{
+	struct g_sched_class *gsc;
+	struct g_sched_softc *sc;
+
+	gsc = g_sched_priv2class(priv);
+	gsc->gsc_expire = ticks + me.gs_expire_secs * hz;
+
+	if (--gsc->gsc_refs > 0)
+		return;
+
+	sc = gp->softc;
+	sc->sc_gsched->gs_fini_class(sc->sc_data, priv);
+
+	LIST_REMOVE(gsc, gsc_clist);
+	free(gsc, M_GEOM_SCHED);
+}
+
+static void
+g_sched_hash_fini(struct g_geom *gp, struct g_hash *hp, u_long mask,
+    struct g_gsched *gsp, void *data)
+{
+	struct g_sched_class *cp, *cp2;
+	int i;
+
+	if (!hp)
+		return;
+
+	if (data && gsp->gs_hash_unref)
+		gsp->gs_hash_unref(data);
+
+	for (i = 0; i < G_SCHED_HASH_SIZE; i++) {
+		LIST_FOREACH_SAFE(cp, &hp[i], gsc_clist, cp2)
+			g_sched_put_class(gp, cp->gsc_priv);
+	}
+
+	hashdestroy(hp, M_GEOM_SCHED, mask);
+}
+
+static struct g_hash *
+g_sched_hash_init(struct g_gsched *gsp, u_long *mask, int flags)
+{
+	struct g_hash *hash;
+
+	if (gsp->gs_priv_size == 0)
+		return (NULL);
+
+	hash = hashinit_flags(G_SCHED_HASH_SIZE, M_GEOM_SCHED, mask, flags);
+
+	return (hash);
+}
+
+static void
+g_sched_flush_classes(struct g_geom *gp)
+{
+	struct g_sched_softc *sc;
+	struct g_sched_class *cp, *cp2;
+	int i;
+
+	sc = gp->softc;
+
+	if (!sc->sc_hash || ticks - sc->sc_flush_ticks <= 0)
+		return;
+
+	for (i = 0; i < G_SCHED_HASH_SIZE; i++) {
+		LIST_FOREACH_SAFE(cp, &sc->sc_hash[i], gsc_clist, cp2) {
+			if (cp->gsc_refs == 1 && ticks - cp->gsc_expire > 0)
+				g_sched_put_class(gp, cp->gsc_priv);
+		}
+	}
+
+	sc->sc_flush_ticks = ticks + me.gs_expire_secs * hz;
+}
+
+/*
+ * Wait for the completion of any outstanding request.  To ensure
+ * that this does not take forever the caller has to make sure that
+ * no new request enter the scehduler before calling us.
+ *
+ * Must be called with the gp mutex held and topology locked.
+ */
+static int
+g_sched_wait_pending(struct g_geom *gp)
+{
+	struct g_sched_softc *sc = gp->softc;
+	int endticks = ticks + hz;
+
+	g_topology_assert();
+
+	while (sc->sc_pending && endticks - ticks >= 0)
+		msleep(gp, &sc->sc_mtx, 0, "sched_wait_pending", hz / 4);
+
+	return (sc->sc_pending ? ETIMEDOUT : 0);
+}
+
+static int
+g_sched_remove_locked(struct g_geom *gp, struct g_gsched *gsp)
+{
+	struct g_sched_softc *sc = gp->softc;
+	int error;
+
+	/* Set the flushing flag: new bios will not enter the scheduler. */
+	sc->sc_flags |= G_SCHED_FLUSHING;
+
+	g_sched_forced_dispatch(gp);
+	error = g_sched_wait_pending(gp);
+	if (error)
+		goto failed;
+	
+	/* No more requests pending or in flight from the old gsp. */
+
+	g_sched_hash_fini(gp, sc->sc_hash, sc->sc_mask, gsp, sc->sc_data);
+	sc->sc_hash = NULL;
+
+	/*
+	 * Avoid deadlock here by releasing the gp mutex and reacquiring
+	 * it once done.  It should be safe, since no reconfiguration or
+	 * destruction can take place due to the geom topology lock; no
+	 * new request can use the current sc_data since we flagged the
+	 * geom as being flushed.
+	 */
+	g_sched_unlock(gp);
+	gsp->gs_fini(sc->sc_data);
+	g_sched_lock(gp);
+
+	sc->sc_gsched = NULL;
+	sc->sc_data = NULL;
+	g_gsched_unref(gsp);
+
+failed:
+	sc->sc_flags &= ~G_SCHED_FLUSHING;
+
+	return (error);
+}
+
+static int
+g_sched_remove(struct g_geom *gp, struct g_gsched *gsp)
+{
+	int error;
+
+	g_sched_lock(gp);
+	error = g_sched_remove_locked(gp, gsp); /* gsp is surely non-null */
+	g_sched_unlock(gp);
+
+	return (error);
+}
+
+/*
+ * Support function for create/taste -- locate the desired
+ * algorithm and grab a reference to it.
+ */
+static struct g_gsched *
+g_gsched_find(const char *name)
+{
+	struct g_gsched *gsp = NULL;
+
+	mtx_lock(&me.gs_mtx);
+	LIST_FOREACH(gsp, &me.gs_scheds, glist) {
+		if (strcmp(name, gsp->gs_name) == 0) {
+			g_gsched_ref(gsp);
+			break;
+		}
+	}
+	mtx_unlock(&me.gs_mtx);
+
+	return (gsp);
+}
+
+/*
+ * Rebuild the list of scheduler names.
+ * To be called with me.gs_mtx lock held.
+ */
+static void
+g_gsched_build_names(struct g_gsched *gsp)
+{
+	int pos, l;
+	struct g_gsched *cur;
+
+	pos = 0;
+	LIST_FOREACH(cur, &me.gs_scheds, glist) {
+		l = strlen(cur->gs_name);
+		if (l + pos + 1 + 1 < sizeof(me.gs_names)) {
+			if (pos != 0)
+				me.gs_names[pos++] = ' ';
+			strcpy(me.gs_names + pos, cur->gs_name);
+			pos += l;
+		}
+	}
+	me.gs_names[pos] = '\0';
+}
+
+/*
+ * Register or unregister individual scheduling algorithms.
+ */
+static int
+g_gsched_register(struct g_gsched *gsp)
+{
+	struct g_gsched *cur;
+	int error = 0;
+
+	mtx_lock(&me.gs_mtx);
+	LIST_FOREACH(cur, &me.gs_scheds, glist) {
+		if (strcmp(gsp->gs_name, cur->gs_name) == 0)
+			break;
+	}
+	if (cur != NULL) {
+		G_SCHED_DEBUG(0, "A scheduler named %s already"
+		    "exists.", gsp->gs_name);
+		error = EEXIST;
+	} else {
+		LIST_INSERT_HEAD(&me.gs_scheds, gsp, glist);
+		gsp->gs_refs = 1;
+		me.gs_sched_count++;
+		g_gsched_build_names(gsp);
+	}
+	mtx_unlock(&me.gs_mtx);
+
+	return (error);
+}
+
+struct g_gsched_unregparm {
+	struct g_gsched *gup_gsp;
+	int		gup_error;
+};
+
+static void
+g_gsched_unregister(void *arg, int flag)
+{
+	struct g_gsched_unregparm *parm = arg;
+	struct g_gsched *gsp = parm->gup_gsp, *cur, *tmp;
+	struct g_sched_softc *sc;
+	struct g_geom *gp, *gp_tmp;
+	int error;
+
+	parm->gup_error = 0;
+
+	g_topology_assert();
+
+	if (flag == EV_CANCEL)
+		return;
+
+	mtx_lock(&me.gs_mtx);
+
+	LIST_FOREACH_SAFE(gp, &g_sched_class.geom, geom, gp_tmp) {
+		if (gp->class != &g_sched_class)
+			continue;	/* Should not happen. */
+
+		sc = gp->softc;
+		if (sc->sc_gsched == gsp) {
+			error = g_sched_remove(gp, gsp);
+			if (error)
+				goto failed;
+		}
+	}
+		
+	LIST_FOREACH_SAFE(cur, &me.gs_scheds, glist, tmp) {
+		if (cur != gsp)
+			continue;
+
+		if (gsp->gs_refs != 1) {
+			G_SCHED_DEBUG(0, "%s still in use.",
+			    gsp->gs_name);
+			parm->gup_error = EBUSY;
+		} else {
+			LIST_REMOVE(gsp, glist);
+			me.gs_sched_count--;
+			g_gsched_build_names(gsp);
+		}
+		break;
+	}
+
+	if (cur == NULL) {
+		G_SCHED_DEBUG(0, "%s not registered.", gsp->gs_name);
+		parm->gup_error = ENOENT;
+	}
+
+failed:
+	mtx_unlock(&me.gs_mtx);
+}
+
+static inline void
+g_gsched_global_init(void)
+{
+
+	if (!me.gs_initialized) {
+		G_SCHED_DEBUG(0, "Initializing global data.");
+		mtx_init(&me.gs_mtx, "gsched", NULL, MTX_DEF);
+		LIST_INIT(&me.gs_scheds);
+		gs_bioq_init(&me.gs_pending);
+		me.gs_initialized = 1;
+	}
+}
+
+/*
+ * Module event called when a scheduling algorithm module is loaded or
+ * unloaded.
+ */
+int
+g_gsched_modevent(module_t mod, int cmd, void *arg)
+{
+	struct g_gsched *gsp = arg;
+	struct g_gsched_unregparm parm;
+	int error;
+
+	G_SCHED_DEBUG(0, "Modevent %d.", cmd);
+
+	/*
+	 * If the module is loaded at boot, the geom thread that calls
+	 * g_sched_init() might actually run after g_gsched_modevent(),
+	 * so make sure that the module is properly initialized.
+	 */
+	g_gsched_global_init();
+
+	error = EOPNOTSUPP;
+	switch (cmd) {
+	case MOD_LOAD:
+		error = g_gsched_register(gsp);
+		G_SCHED_DEBUG(0, "Loaded module %s error %d.",
+		    gsp->gs_name, error);
+		if (error == 0)
+			g_retaste(&g_sched_class);
+		break;
+
+	case MOD_UNLOAD:
+		parm.gup_gsp = gsp;
+		parm.gup_error = 0;
+
+		error = g_waitfor_event(g_gsched_unregister,
+		    &parm, M_WAITOK, NULL);
+		if (error == 0)
+			error = parm.gup_error;
+		G_SCHED_DEBUG(0, "Unloaded module %s error %d.",
+		    gsp->gs_name, error);
+		break;
+	};
+
+	return (error);
+}
+
+#ifdef KTR
+#define	TRC_BIO_EVENT(e, bp)	g_sched_trace_bio_ ## e (bp)
+
+static inline char
+g_sched_type(struct bio *bp)
+{
+
+	if (0 != (bp->bio_cmd & BIO_READ))
+		return ('R');
+	else if (0 != (bp->bio_cmd & BIO_WRITE))
+		return ('W');
+	return ('U');
+}
+
+static inline void
+g_sched_trace_bio_START(struct bio *bp)
+{
+
+	CTR5(KTR_GSCHED, "S %lu %c %lu/%lu %lu", g_sched_classify(bp),
+	    g_sched_type(bp), bp->bio_offset / ULONG_MAX,
+	    bp->bio_offset, bp->bio_length);
+}
+
+static inline void
+g_sched_trace_bio_DONE(struct bio *bp)
+{
+
+	CTR5(KTR_GSCHED, "D %lu %c %lu/%lu %lu", g_sched_classify(bp),
+	    g_sched_type(bp), bp->bio_offset / ULONG_MAX,
+	    bp->bio_offset, bp->bio_length);
+}
+#else /* !KTR */
+#define	TRC_BIO_EVENT(e, bp)
+#endif /* !KTR */
+
+/*
+ * g_sched_done() and g_sched_start() dispatch the geom requests to
+ * the scheduling algorithm in use.
+ */
+static void
+g_sched_done(struct bio *bio)
+{
+	struct g_geom *gp = bio->bio_caller2;
+	struct g_sched_softc *sc = gp->softc;
+
+	TRC_BIO_EVENT(DONE, bio);
+
+	KASSERT(bio->bio_caller1, ("null bio_caller1 in g_sched_done"));
+
+	g_sched_lock(gp);
+
+	g_sched_update_stats(bio);
+	sc->sc_gsched->gs_done(sc->sc_data, bio);
+	if (!--sc->sc_pending)
+		wakeup(gp);
+
+	g_sched_flush_classes(gp);
+	g_sched_unlock(gp);
+
+	g_std_done(bio);
+}
+
+static void
+g_sched_start(struct bio *bp)
+{
+	struct g_geom *gp = bp->bio_to->geom;
+	struct g_sched_softc *sc = gp->softc;
+	struct bio *cbp;
+
+	TRC_BIO_EVENT(START, bp);
+	G_SCHED_LOGREQ(bp, "Request received.");
+
+	cbp = g_clone_bio(bp);
+	if (cbp == NULL) {
+		g_io_deliver(bp, ENOMEM);
+		return;
+	}
+	cbp->bio_done = g_sched_done;
+	cbp->bio_to = LIST_FIRST(&gp->provider);
+	KASSERT(cbp->bio_to != NULL, ("NULL provider"));
+
+	/* We only schedule reads and writes. */
+	if (0 == (bp->bio_cmd & (BIO_READ | BIO_WRITE)))
+		goto bypass;
+
+	G_SCHED_LOGREQ(cbp, "Sending request.");
+
+	g_sched_lock(gp);
+	/*
+	 * Call the algorithm's gs_start to queue the request in the
+	 * scheduler. If gs_start fails then pass the request down,
+	 * otherwise call g_sched_dispatch() which tries to push
+	 * one or more requests down.
+	 */
+	if (!sc->sc_gsched || (sc->sc_flags & G_SCHED_FLUSHING) ||
+	    sc->sc_gsched->gs_start(sc->sc_data, cbp)) {
+		g_sched_unlock(gp);
+		goto bypass;
+	}
+	/*
+	 * We use bio_caller1 to mark requests that are scheduled
+	 * so make sure it is not NULL.
+	 */
+	if (cbp->bio_caller1 == NULL)
+		cbp->bio_caller1 = &me;	/* anything not NULL */
+
+	cbp->bio_caller2 = gp;
+	sc->sc_pending++;
+
+	/* Update general stats. */
+	me.gs_in_flight++;
+	me.gs_requests++;
+	me.gs_bytes_in_flight += bp->bio_length;
+	if (bp->bio_cmd & BIO_WRITE) {
+		me.gs_writes_in_flight++;
+		me.gs_write_bytes_in_flight += bp->bio_length;
+	}
+	g_sched_dispatch(gp);
+	g_sched_unlock(gp);
+	return;
+
+bypass:
+	cbp->bio_done = g_std_done;
+	cbp->bio_caller1 = NULL; /* not scheduled */
+	g_io_request(cbp, LIST_FIRST(&gp->consumer));
+}
+
+/*
+ * The next few functions are the geom glue.
+ */
+static void
+g_sched_orphan(struct g_consumer *cp)
+{
+
+	g_topology_assert();
+	g_sched_destroy(cp->geom, 1);
+}
+
+static int
+g_sched_access(struct g_provider *pp, int dr, int dw, int de)
+{
+	struct g_geom *gp;
+	struct g_consumer *cp;
+	int error;
+
+	gp = pp->geom;
+	cp = LIST_FIRST(&gp->consumer);
+	error = g_access(cp, dr, dw, de);
+
+	return (error);
+}
+
+static void
+g_sched_temporary_start(struct bio *bio)
+{
+
+	mtx_lock(&me.gs_mtx);
+	me.gs_npending++;
+	gs_bioq_disksort(&me.gs_pending, bio);
+	mtx_unlock(&me.gs_mtx);
+}
+
+static void
+g_sched_flush_pending(g_start_t *start)
+{
+	struct bio *bp;
+
+	while ((bp = gs_bioq_takefirst(&me.gs_pending)))
+		start(bp);
+}
+
+static int
+g_insert_proxy(struct g_geom *gp, struct g_provider *newpp,
+    struct g_geom *dstgp, struct g_provider *pp, struct g_consumer *cp)
+{
+	struct g_sched_softc *sc = gp->softc;
+	g_start_t *saved_start, *flush = g_sched_start;
+	int error = 0, endticks = ticks + hz;
+
+	g_cancel_event(newpp);	/* prevent taste() */
+	/* copy private fields */
+	newpp->private = pp->private;
+	newpp->index = pp->index;
+
+	/* Queue all the early requests coming for us. */
+	me.gs_npending = 0;
+	saved_start = pp->geom->start;
+	dstgp->start = g_sched_temporary_start;
+
+	while (pp->nstart - pp->nend != me.gs_npending &&
+	    endticks - ticks >= 0)
+		tsleep(pp, PRIBIO, "-", hz/10);
+
+	if (pp->nstart - pp->nend != me.gs_npending) {
+		flush = saved_start;
+		error = ETIMEDOUT;
+		goto fail;
+	}
+
+	/* link pp to this geom */
+	LIST_REMOVE(pp, provider);
+	pp->geom = gp;
+	LIST_INSERT_HEAD(&gp->provider, pp, provider);
+
+	/*
+	 * replicate the counts from the parent in the
+	 * new provider and consumer nodes
+	 */
+	cp->acr = newpp->acr = pp->acr;
+	cp->acw = newpp->acw = pp->acw;
+	cp->ace = newpp->ace = pp->ace;
+	sc->sc_flags |= G_SCHED_PROXYING;
+
+fail:
+	dstgp->start = saved_start;
+
+	g_sched_flush_pending(flush);
+
+	return (error);
+}
+
+/*
+ * Create a geom node for the device passed as *pp.
+ * If successful, add a reference to this gsp.
+ */
+static int
+g_sched_create(struct gctl_req *req, struct g_class *mp,
+    struct g_provider *pp, struct g_gsched *gsp, int proxy)
+{
+	struct g_sched_softc *sc = NULL;
+	struct g_geom *gp, *dstgp;
+	struct g_provider *newpp = NULL;
+	struct g_consumer *cp = NULL;
+	char name[64];
+	int error;
+
+	g_topology_assert();
+
+	snprintf(name, sizeof(name), "%s%s", pp->name, G_SCHED_SUFFIX);
+	LIST_FOREACH(gp, &mp->geom, geom) {
+		if (strcmp(gp->name, name) == 0) {
+			gctl_error(req, "Geom %s already exists.",
+			    name);
+			return (EEXIST);
+		}
+	}
+
+	gp = g_new_geomf(mp, name);
+	dstgp = proxy ? pp->geom : gp; /* where do we link the provider */
+	if (gp == NULL) {
+		gctl_error(req, "Cannot create geom %s.", name);
+		error = ENOMEM;
+		goto fail;
+	}
+
+	sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
+	sc->sc_gsched = gsp;
+	sc->sc_data = gsp->gs_init(gp);
+	if (sc->sc_data == NULL) {
+		error = ENOMEM;
+		goto fail;
+	}
+
+	sc->sc_hash = g_sched_hash_init(gsp, &sc->sc_mask, HASH_WAITOK);
+
+	/*
+	 * Do not initialize the flush mechanism, will be initialized
+	 * on the first insertion on the hash table.
+	 */
+
+	mtx_init(&sc->sc_mtx, "g_sched_mtx", NULL, MTX_DEF);
+
+	gp->softc = sc;
+	gp->start = g_sched_start;
+	gp->orphan = g_sched_orphan;
+	gp->access = g_sched_access;
+	gp->dumpconf = g_sched_dumpconf;
+
+	newpp = g_new_providerf(dstgp, gp->name);
+	if (newpp == NULL) {
+		gctl_error(req, "Cannot create provider %s.", name);
+		error = ENOMEM;
+		goto fail;
+	}
+
+	newpp->mediasize = pp->mediasize;
+	newpp->sectorsize = pp->sectorsize;
+
+	cp = g_new_consumer(gp);
+	if (cp == NULL) {
+		gctl_error(req, "Cannot create consumer for %s.",
+		    gp->name);
+		error = ENOMEM;
+		goto fail;
+	}
+
+	error = g_attach(cp, proxy ? newpp : pp);
+	if (error != 0) {
+		gctl_error(req, "Cannot attach to provider %s.",
+		    pp->name);
+		goto fail;
+	}
+
+	g_error_provider(newpp, 0);
+	if (proxy) {
+		error = g_insert_proxy(gp, newpp, dstgp, pp, cp);
+		if (error)
+			goto fail;
+	}
+	G_SCHED_DEBUG(0, "Device %s created.", gp->name);
+
+	g_gsched_ref(gsp);
+
+	return (0);
+
+fail:
+	if (cp != NULL) {
+		if (cp->provider != NULL)
+			g_detach(cp);
+		g_destroy_consumer(cp);
+	}
+
+	if (newpp != NULL)
+		g_destroy_provider(newpp);
+
+	if (sc && sc->sc_hash) {
+		g_sched_hash_fini(gp, sc->sc_hash, sc->sc_mask,
+		    gsp, sc->sc_data);
+	}
+
+	if (sc && sc->sc_data)
+		gsp->gs_fini(sc->sc_data);
+
+	if (gp != NULL) {
+		if (gp->softc != NULL)
+			g_free(gp->softc);
+		g_destroy_geom(gp);
+	}
+
+	return (error);
+}
+
+/*
+ * Support for dynamic switching of scheduling algorithms.
+ * First initialize the data structures for the new algorithm,
+ * then call g_sched_remove_locked() to flush all references
+ * to the old one, finally link the new algorithm.
+ */
+static int
+g_sched_change_algo(struct gctl_req *req, struct g_class *mp,
+    struct g_provider *pp, struct g_gsched *gsp)
+{
+	struct g_sched_softc *sc;
+	struct g_geom *gp;
+	struct g_hash *newh;
+	void *data;
+	u_long mask;
+	int error = 0;
+
+	gp = pp->geom;
+	sc = gp->softc;
+
+	data = gsp->gs_init(gp);
+	if (data == NULL)
+		return (ENOMEM);
+
+	newh = g_sched_hash_init(gsp, &mask, HASH_WAITOK);
+	if (gsp->gs_priv_size && !newh) {
+		error = ENOMEM;
+		goto fail;
+	}
+
+	g_sched_lock(gp);
+	if (sc->sc_gsched) {	/* can be NULL in some cases */
+		error = g_sched_remove_locked(gp, sc->sc_gsched);
+		if (error)
+			goto fail;
+	}
+
+	g_gsched_ref(gsp);
+	sc->sc_gsched = gsp;
+	sc->sc_data = data;
+	sc->sc_hash = newh;
+	sc->sc_mask = mask;
+
+	g_sched_unlock(gp);
+
+	return (0);
+
+fail:
+	if (newh)
+		g_sched_hash_fini(gp, newh, mask, gsp, data);
+
+	if (data)
+		gsp->gs_fini(data);
+
+	g_sched_unlock(gp);
+
+	return (error);
+}
+
+/*
+ * Stop the request flow directed to the proxy, redirecting the new
+ * requests to the me.gs_pending queue.
+ */
+static struct g_provider *
+g_detach_proxy(struct g_geom *gp)
+{
+	struct g_consumer *cp;
+	struct g_provider *pp, *newpp;
+
+	do {
+		pp = LIST_FIRST(&gp->provider);
+		if (pp == NULL)
+			break;
+		cp = LIST_FIRST(&gp->consumer);
+		if (cp == NULL)
+			break;
+		newpp = cp->provider;
+		if (newpp == NULL)
+			break;
+
+		me.gs_npending = 0;
+		pp->geom->start = g_sched_temporary_start;
+
+		return (pp);
+	} while (0);
+	printf("%s error detaching proxy %s\n", __FUNCTION__, gp->name);
+
+	return (NULL);
+}
+
+static void
+g_sched_blackhole(struct bio *bp)
+{
+
+	g_io_deliver(bp, ENXIO);
+}
+
+static inline void
+g_reparent_provider(struct g_provider *pp, struct g_geom *gp,
+    struct g_provider *newpp)
+{
+
+	LIST_REMOVE(pp, provider);
+	if (newpp) {
+		pp->private = newpp->private;
+		pp->index = newpp->index;
+	}
+	pp->geom = gp;
+	LIST_INSERT_HEAD(&gp->provider, pp, provider);
+}
+
+static inline void
+g_unproxy_provider(struct g_provider *oldpp, struct g_provider *newpp)
+{
+	struct g_geom *gp = oldpp->geom;
+
+	g_reparent_provider(oldpp, newpp->geom, newpp);
+
+	/*
+	 * Hackish: let the system destroy the old provider for us, just
+	 * in case someone attached a consumer to it, in which case a
+	 * direct call to g_destroy_provider() would not work.
+	 */
+	g_reparent_provider(newpp, gp, NULL);
+}
+
+/*
+ * Complete the proxy destruction, linking the old provider to its
+ * original geom, and destroying the proxy provider.  Also take care
+ * of issuing the pending requests collected in me.gs_pending (if any).
+ */
+static int
+g_destroy_proxy(struct g_geom *gp, struct g_provider *oldpp)
+{
+	struct g_consumer *cp;
+	struct g_provider *newpp;
+
+	do {
+		cp = LIST_FIRST(&gp->consumer);
+		if (cp == NULL)
+			break;
+		newpp = cp->provider;
+		if (newpp == NULL)
+			break;
+
+		/* Relink the provider to its original geom. */
+		g_unproxy_provider(oldpp, newpp);
+
+		/* Detach consumer from provider, and destroy provider. */
+		cp->acr = newpp->acr = 0;
+		cp->acw = newpp->acw = 0;
+		cp->ace = newpp->ace = 0;
+		g_detach(cp);
+
+		/* Send the pending bios through the right start function. */
+		g_sched_flush_pending(oldpp->geom->start);
+
+		return (0);
+	} while (0);
+	printf("%s error destroying proxy %s\n", __FUNCTION__, gp->name);
+
+	/* We cannot send the pending bios anywhere... */
+	g_sched_flush_pending(g_sched_blackhole);
+
+	return (EINVAL);
+}
+
+static int
+g_sched_destroy(struct g_geom *gp, boolean_t force)
+{
+	struct g_provider *pp, *oldpp = NULL;
+	struct g_sched_softc *sc;
+	struct g_gsched *gsp;
+	int error;
+
+	g_topology_assert();
+	sc = gp->softc;
+	if (sc == NULL)
+		return (ENXIO);
+	if (!(sc->sc_flags & G_SCHED_PROXYING)) {
+		pp = LIST_FIRST(&gp->provider);
+		if (pp && (pp->acr != 0 || pp->acw != 0 || pp->ace != 0)) {
+			const char *msg = force ?
+				"but we force removal" : "cannot remove";
+
+			G_SCHED_DEBUG(!force,
+			    "Device %s is still open (r%dw%de%d), %s.",
+			    pp->name, pp->acr, pp->acw, pp->ace, msg);
+			if (!force)
+				return (EBUSY);
+		} else {
+			G_SCHED_DEBUG(0, "Device %s removed.", gp->name);
+		}
+	} else
+		oldpp = g_detach_proxy(gp);
+
+	gsp = sc->sc_gsched;
+	if (gsp) {
+		/*
+		 * XXX bad hack here: force a dispatch to release
+		 * any reference to the hash table still held by
+		 * the scheduler.
+		 */
+		g_sched_lock(gp);
+		/*
+		 * We are dying here, no new requests should enter
+		 * the scheduler.  This is granted by the topolgy,
+		 * either in case we were proxying (new bios are
+		 * being redirected) or not (see the access check
+		 * above).
+		 */
+		g_sched_forced_dispatch(gp);
+		error = g_sched_wait_pending(gp);
+
+		if (error) {
+			/*
+			 * Not all the requests came home: this might happen
+			 * under heavy load, or if we were waiting for any
+			 * bio which is served in the event path (see
+			 * geom_slice.c for an example of how this can
+			 * happen).  Try to restore a working configuration
+			 * if we can fail.
+			 */
+			if ((sc->sc_flags & G_SCHED_PROXYING) && oldpp) {
+				g_sched_flush_pending(force ?
+				    g_sched_blackhole : g_sched_start);
+			}
+
+			/*
+			 * In the forced destroy case there is not so much
+			 * we can do, we have pending bios that will call
+			 * g_sched_done() somehow, and we don't want them
+			 * to crash the system using freed memory.  We tell
+			 * the user that something went wrong, and leak some
+			 * memory here.
+			 * Note: the callers using force = 1 ignore the
+			 * return value.
+			 */
+			if (force) {
+				G_SCHED_DEBUG(0, "Pending requests while "
+				    " destroying geom, some memory leaked.");
+			}
+
+			return (error);
+		}
+
+		g_sched_unlock(gp);
+		g_sched_hash_fini(gp, sc->sc_hash, sc->sc_mask,
+		    gsp, sc->sc_data);
+		sc->sc_hash = NULL;
+		gsp->gs_fini(sc->sc_data);
+		g_gsched_unref(gsp);
+		sc->sc_gsched = NULL;
+	}
+
+	if ((sc->sc_flags & G_SCHED_PROXYING) && oldpp) {
+		error = g_destroy_proxy(gp, oldpp);
+
+		if (error) {
+			if (force) {
+				G_SCHED_DEBUG(0, "Unrecoverable error while "
+				    "destroying a proxy geom, leaking some "
+				    " memory.");
+			}
+
+			return (error);
+		}
+	}
+
+	mtx_destroy(&sc->sc_mtx);
+
+	g_free(gp->softc);
+	gp->softc = NULL;
+	g_wither_geom(gp, ENXIO);
+
+	return (error);
+}
+
+static int
+g_sched_destroy_geom(struct gctl_req *req, struct g_class *mp,
+    struct g_geom *gp)
+{
+
+	return (g_sched_destroy(gp, 0));
+}
+
+/*
+ * Functions related to the classification of requests.
+ *
+ * On recent FreeBSD versions (8.0 and above), we store a reference
+ * to the issuer of a request in bp->bio_classifier1 as soon
+ * as the bio is posted to the geom queue (and not later, because
+ * requests are managed by the g_down thread afterwards).
+ *
+ * On older versions of the system (but this code is not used
+ * in any existing release), we [ab]use the caller1 field in the
+ * root element of the bio tree to store the classification info.
+ * The marking is done at the beginning of g_io_request()
+ * and only if we find that the field is NULL.
+ *
+ * To avoid rebuilding the kernel, this module will patch the
+ * initial part of g_io_request() so it jumps to some hand-coded
+ * assembly that does the marking and then executes the original
+ * body of g_io_request().
+ *
+ * fake_ioreq[] is architecture-specific machine code
+ * that implements the above. CODE_SIZE, STORE_SIZE etc.
+ * are constants used in the patching routine. Look at the
+ * code in g_ioreq_patch() for the details.
+ */
+
+#ifndef HAVE_BIO_CLASSIFIER
+/*
+ * Support for old FreeBSD versions
+ */
+#if defined(__i386__)
+#define	CODE_SIZE	29
+#define	STORE_SIZE	5
+#define	EPILOGUE	5
+#define	SIZE		(CODE_SIZE + STORE_SIZE + EPILOGUE)
+
+static u_char fake_ioreq[SIZE] = {
+	0x8b, 0x44, 0x24, 0x04,		/* mov bp, %eax */
+	/* 1: */
+	0x89, 0xc2,			/* mov %eax, %edx # edx = bp */
+	0x8b, 0x40, 0x64,		/* mov bp->bio_parent, %eax */
+	0x85, 0xc0,			/* test %eax, %eax */
+	0x75, 0xf7,			/* jne 1b */
+	0x8b, 0x42, 0x30,		/* mov bp->bp_caller1, %eax */
+	0x85, 0xc0,			/* test %eax, %eax */
+	0x75, 0x09,			/* jne 2f */
+	0x64, 0xa1, 0x00, 0x00,		/* mov %fs:0, %eax */
+	0x00, 0x00,
+	0x89, 0x42, 0x30,		/* mov %eax, bp->bio_caller1 */
+	/* 2: */
+        0x55, 0x89, 0xe5, 0x57, 0x56,
+	0xe9, 0x00, 0x00, 0x00, 0x00,	/* jmp back... */
+};
+#elif defined(__amd64)
+#define	CODE_SIZE	38
+#define	STORE_SIZE	6
+#define	EPILOGUE	5
+#define	SIZE		(CODE_SIZE + STORE_SIZE + EPILOGUE)
+
+static u_char fake_ioreq[SIZE] = {
+	0x48, 0x89, 0xf8,		/* mov bp, %rax */
+	/* 1: */
+	0x48, 0x89, 0xc2,		/* mov %rax, %rdx # rdx = bp */
+	0x48, 0x8b, 0x82, 0xa8,		/* mov bp->bio_parent, %rax */
+	0x00, 0x00, 0x00,
+	0x48, 0x85, 0xc0,		/* test %rax, %rax */
+	0x75, 0xf1,			/* jne 1b */
+	0x48, 0x83, 0x7a, 0x58,		/* cmp $0, bp->bp_caller1 */
+	0x00,
+	0x75, 0x0d,			/* jne 2f */
+	0x65, 0x48, 0x8b, 0x04,		/* mov %gs:0, %rax */
+	0x25, 0x00, 0x00, 0x00,
+	0x00,
+	0x48, 0x89, 0x42, 0x58,		/* mov %rax, bp->bio_caller1 */
+	/* 2: */
+	0x55, 0x48, 0x89, 0xe5, 0x41, 0x56,
+	0xe9, 0x00, 0x00, 0x00, 0x00,	/* jmp back... */
+};
+#else /* neither x86 nor amd64 */
+static void
+g_new_io_request(struct bio *bp, struct g_consumer *cp)
+{
+	struct bio *top = bp;
+
+        /*
+         * bio classification: if bio_caller1 is available in the
+         * root of the 'struct bio' tree, store there the thread id
+         * of the thread that originated the request.
+         * More sophisticated classification schemes can be used.
+         */
+	while (top->bio_parent)
+		top = top->bio_parent;
+
+	if (top->bio_caller1 == NULL)
+		top->bio_caller1 = curthread;
+}
+
+#error please add the code above in g_new_io_request() to the beginning of \
+	/sys/geom/geom_io.c::g_io_request(), and remove this line.
+#endif /* end of arch-specific code */
+
+static int
+g_ioreq_patch(void)
+{
+	u_char *original;
+	u_long ofs;
+	int found;
+
+	if (me.gs_patched)
+		return (-1);
+
+	original = (u_char *)g_io_request;
+
+	found = !bcmp(original, fake_ioreq + CODE_SIZE, STORE_SIZE);
+	if (!found)
+		return (-1);
+
+	/* Jump back to the original + STORE_SIZE. */
+	ofs = (original + STORE_SIZE) - (fake_ioreq + SIZE);
+	bcopy(&ofs, fake_ioreq + CODE_SIZE + STORE_SIZE + 1, 4);
+
+	/* Patch the original address with a jump to the trampoline. */
+	*original = 0xe9;     /* jump opcode */
+	ofs = fake_ioreq - (original + 5);
+	bcopy(&ofs, original + 1, 4);
+
+	me.gs_patched = 1;
+
+	return (0);
+}
+
+/*
+ * Restore the original code, this is easy.
+ */
+static void
+g_ioreq_restore(void)
+{
+	u_char *original;
+
+	if (me.gs_patched) {
+		original = (u_char *)g_io_request;
+		bcopy(fake_ioreq + CODE_SIZE, original, STORE_SIZE);
+		me.gs_patched = 0;
+	}
+}
+
+static inline void
+g_classifier_ini(void)
+{
+
+	g_ioreq_patch();
+}
+
+static inline void
+g_classifier_fini(void)
+{
+
+	g_ioreq_restore();
+}
+
+/*--- end of support code for older FreeBSD versions */
+
+#else /* HAVE_BIO_CLASSIFIER */
+
+/*
+ * Classifier support for recent FreeBSD versions: we use
+ * a very simple classifier, only use curthread to tag a request.
+ * The classifier is registered at module load, and unregistered
+ * at module unload.
+ */
+static int
+g_sched_tag(void *arg, struct bio *bp)
+{
+
+	bp->bio_classifier1 = curthread;
+	return (1);
+}
+
+static struct g_classifier_hook g_sched_classifier = {
+	.func =	g_sched_tag,
+};
+
+static inline void
+g_classifier_ini(void)
+{
+
+	g_register_classifier(&g_sched_classifier);
+}
+
+static inline void
+g_classifier_fini(void)
+{
+
+	g_unregister_classifier(&g_sched_classifier);
+}
+#endif /* HAVE_BIO_CLASSIFIER */
+
+static void
+g_sched_init(struct g_class *mp)
+{
+
+	g_gsched_global_init();
+
+	G_SCHED_DEBUG(0, "Loading: mp = %p, g_sched_class = %p.",
+	    mp, &g_sched_class);
+
+	/* Patch g_io_request to store classification info in the bio. */
+	g_classifier_ini();
+}
+
+static void
+g_sched_fini(struct g_class *mp)
+{
+
+	g_classifier_fini();
+
+	G_SCHED_DEBUG(0, "Unloading...");
+
+	KASSERT(LIST_EMPTY(&me.gs_scheds), ("still registered schedulers"));
+	mtx_destroy(&me.gs_mtx);
+}
+
+/*
+ * Read the i-th argument for a request, skipping the /dev/
+ * prefix if present.
+ */
+static const char *
+g_sched_argi(struct gctl_req *req, int i)
+{
+	static const char *dev_prefix = "/dev/";
+	const char *name;
+	char param[16];
+	int l = strlen(dev_prefix);
+
+	snprintf(param, sizeof(param), "arg%d", i);
+	name = gctl_get_asciiparam(req, param);
+	if (name == NULL)
+		gctl_error(req, "No 'arg%d' argument", i);
+	else if (strncmp(name, dev_prefix, l) == 0)
+		name += l;
+	return (name);
+}
+
+/*
+ * Fetch nargs and do appropriate checks.
+ */
+static int
+g_sched_get_nargs(struct gctl_req *req)
+{
+	int *nargs;
+
+	nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
+	if (nargs == NULL) {
+		gctl_error(req, "No 'nargs' argument");
+		return (0);
+	}
+	if (*nargs <= 0)
+		gctl_error(req, "Missing device(s).");
+	return (*nargs);
+}
+
+/*
+ * Check whether we should add the class on certain volumes when
+ * this geom is created. Right now this is under control of a kenv
+ * variable containing the names of all devices that we care about.
+ * Probably we should only support transparent insertion as the
+ * preferred mode of operation.
+ */
+static struct g_geom *
+g_sched_taste(struct g_class *mp, struct g_provider *pp,
+		int flags __unused)
+{
+	struct g_gsched *gsp = NULL;	/* the . algorithm we want */
+	const char *s;			/* generic string pointer */
+	const char *taste_names;	/* devices we like */
+	int l;
+    
+        g_trace(G_T_TOPOLOGY, "%s(%s, %s)", __func__,
+	    mp->name, pp->name);
+        g_topology_assert();
+ 
+        G_SCHED_DEBUG(2, "Tasting %s.", pp->name);
+
+	do {
+		/* do not taste on ourselves */
+		if (pp->geom->class == mp)
+                	break;
+
+		taste_names = getenv("geom.sched.taste");
+		if (taste_names == NULL)
+			break;
+
+		l = strlen(pp->name);
+		for (s = taste_names; *s &&
+		    (s = strstr(s, pp->name)); s++) {
+			/* further checks for an exact match */
+			if ( (s == taste_names || s[-1] == ' ') &&
+			     (s[l] == '\0' || s[l] == ' ') )
+				break;
+		}
+		if (s == NULL)
+			break;
+		G_SCHED_DEBUG(0, "Attach device %s match [%s]\n",
+		    pp->name, s);
+
+		/* look up the provider name in the list */
+		s = getenv("geom.sched.algo");
+		if (s == NULL)
+			s = "rr";
+
+		gsp = g_gsched_find(s);	/* also get a reference */
+		if (gsp == NULL) {
+			G_SCHED_DEBUG(0, "Bad '%s' algorithm.", s);
+			break;
+		}
+
+		/* XXX create with 1 as last argument ? */
+		g_sched_create(NULL, mp, pp, gsp, 0);
+		g_gsched_unref(gsp);
+	} while (0);
+	return NULL;
+}
+
+static void
+g_sched_ctl_create(struct gctl_req *req, struct g_class *mp, int proxy)
+{
+	struct g_provider *pp;
+	struct g_gsched *gsp;
+	const char *name;
+	int i, nargs;
+
+	g_topology_assert();
+
+	name = gctl_get_asciiparam(req, "algo");
+	if (name == NULL) {
+		gctl_error(req, "No '%s' argument", "algo");
+		return;
+	}
+
+	gsp = g_gsched_find(name);	/* also get a reference */
+	if (gsp == NULL) {
+		gctl_error(req, "Bad algorithm '%s'", name);
+		return;
+	}
+
+	nargs = g_sched_get_nargs(req);
+
+	/*
+	 * Run on the arguments, and break on any error.
+	 * We look for a device name, but skip the /dev/ prefix if any.
+	 */
+	for (i = 0; i < nargs; i++) {
+		name = g_sched_argi(req, i);
+		if (name == NULL)
+			break;
+		pp = g_provider_by_name(name);
+		if (pp == NULL) {
+			G_SCHED_DEBUG(1, "Provider %s is invalid.", name);
+			gctl_error(req, "Provider %s is invalid.", name);
+			break;
+		}
+		if (g_sched_create(req, mp, pp, gsp, proxy) != 0)
+			break;
+	}
+
+	g_gsched_unref(gsp);
+}
+
+static void
+g_sched_ctl_configure(struct gctl_req *req, struct g_class *mp)
+{
+	struct g_provider *pp;
+	struct g_gsched *gsp;
+	const char *name;
+	int i, nargs;
+
+	g_topology_assert();
+
+	name = gctl_get_asciiparam(req, "algo");
+	if (name == NULL) {
+		gctl_error(req, "No '%s' argument", "algo");
+		return;
+	}
+
+	gsp = g_gsched_find(name);	/* also get a reference */
+	if (gsp == NULL) {
+		gctl_error(req, "Bad algorithm '%s'", name);
+		return;
+	}
+
+	nargs = g_sched_get_nargs(req);
+
+	/*
+	 * Run on the arguments, and break on any error.
+	 * We look for a device name, but skip the /dev/ prefix if any.
+	 */
+	for (i = 0; i < nargs; i++) {
+		name = g_sched_argi(req, i);
+		if (name == NULL)
+			break;
+		pp = g_provider_by_name(name);
+		if (pp == NULL || pp->geom->class != mp) {
+			G_SCHED_DEBUG(1, "Provider %s is invalid.", name);
+			gctl_error(req, "Provider %s is invalid.", name);
+			break;
+		}
+		if (g_sched_change_algo(req, mp, pp, gsp) != 0)
+			break;
+	}
+
+	g_gsched_unref(gsp);
+}
+
+static struct g_geom *
+g_sched_find_geom(struct g_class *mp, const char *name)
+{
+	struct g_geom *gp;
+
+	LIST_FOREACH(gp, &mp->geom, geom) {
+		if (strcmp(gp->name, name) == 0)
+			return (gp);
+	}
+	return (NULL);
+}
+
+static void
+g_sched_ctl_destroy(struct gctl_req *req, struct g_class *mp)
+{
+	int nargs, *force, error, i;
+	struct g_geom *gp;
+	const char *name;
+
+	g_topology_assert();
+
+	nargs = g_sched_get_nargs(req);
+
+	force = gctl_get_paraml(req, "force", sizeof(*force));
+	if (force == NULL) {
+		gctl_error(req, "No 'force' argument");
+		return;
+	}
+
+	for (i = 0; i < nargs; i++) {
+		name = g_sched_argi(req, i);
+		if (name == NULL)
+			break;
+
+		gp = g_sched_find_geom(mp, name);
+		if (gp == NULL) {
+			G_SCHED_DEBUG(1, "Device %s is invalid.", name);
+			gctl_error(req, "Device %s is invalid.", name);
+			break;
+		}
+
+		error = g_sched_destroy(gp, *force);
+		if (error != 0) {
+			gctl_error(req, "Cannot destroy device %s (error=%d).",
+			    gp->name, error);
+			break;
+		}
+	}
+}
+
+static void
+g_sched_config(struct gctl_req *req, struct g_class *mp, const char *verb)
+{
+	uint32_t *version;
+
+	g_topology_assert();
+
+	version = gctl_get_paraml(req, "version", sizeof(*version));
+	if (version == NULL) {
+		gctl_error(req, "No '%s' argument.", "version");
+		return;
+	}
+
+	if (*version != G_SCHED_VERSION) {
+		gctl_error(req, "Userland and kernel parts are "
+		    "out of sync.");
+		return;
+	}
+
+	if (strcmp(verb, "create") == 0) {
+		g_sched_ctl_create(req, mp, 0);
+		return;
+	} else if (strcmp(verb, "insert") == 0) {
+		g_sched_ctl_create(req, mp, 1);
+		return;
+	} else if (strcmp(verb, "configure") == 0) {
+		g_sched_ctl_configure(req, mp);
+		return;
+	} else if (strcmp(verb, "destroy") == 0) {
+		g_sched_ctl_destroy(req, mp);
+		return;
+	}
+
+	gctl_error(req, "Unknown verb.");
+}
+
+static void
+g_sched_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
+    struct g_consumer *cp, struct g_provider *pp)
+{
+	struct g_sched_softc *sc = gp->softc;
+	struct g_gsched *gsp = sc->sc_gsched;
+	if (indent == NULL) {	/* plaintext */
+		sbuf_printf(sb, " algo %s", gsp ? gsp->gs_name : "--");
+	}
+	if (gsp->gs_dumpconf)
+		gsp->gs_dumpconf(sb, indent, gp, cp, pp);
+}
+
+DECLARE_GEOM_CLASS(g_sched_class, g_sched);
+MODULE_VERSION(geom_sched, 0);
diff --git a/sys/geom/sched/g_sched.h b/sys/geom/sched/g_sched.h
new file mode 100644
index 000000000000..3a34e2922b1e
--- /dev/null
+++ b/sys/geom/sched/g_sched.h
@@ -0,0 +1,138 @@
+/*-
+ * Copyright (c) 2009-2010 Fabio Checconi
+ * Copyright (c) 2009-2010 Luigi Rizzo, Universita` di Pisa
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef	_G_SCHED_H_
+#define	_G_SCHED_H_
+
+/*
+ * $Id$
+ * $FreeBSD$
+ *
+ * Header for the geom_sched class (userland library and kernel part).
+ * See g_sched.c for documentation.
+ * The userland code only needs the three G_SCHED_* values below.
+ */
+
+#define	G_SCHED_CLASS_NAME	"SCHED"
+#define	G_SCHED_VERSION		0
+#define	G_SCHED_SUFFIX		".sched."
+
+#ifdef _KERNEL
+#define	G_SCHED_DEBUG(lvl, ...)	do {				\
+	if (me.gs_debug >= (lvl)) {				\
+		printf("GEOM_SCHED");				\
+		if (me.gs_debug > 0)				\
+			printf("[%u]", lvl);			\
+		printf(": ");					\
+		printf(__VA_ARGS__);				\
+		printf("\n");					\
+	}							\
+} while (0)
+
+#define	G_SCHED_LOGREQ(bp, ...)	do {				\
+	if (me.gs_debug >= 2) {					\
+		printf("GEOM_SCHED[2]: ");			\
+		printf(__VA_ARGS__);				\
+		printf(" ");					\
+		g_print_bio(bp);				\
+		printf("\n");					\
+	}							\
+} while (0)
+
+LIST_HEAD(g_hash, g_sched_class);
+
+/*
+ * Descriptor of a scheduler.
+ * In addition to the obvious fields, sc_flushing and sc_pending
+ * support dynamic switching of scheduling algorithm.
+ * Normally, sc_flushing is 0, and requests that are scheduled are
+ * also added to the sc_pending queue, and removed when we receive
+ * the 'done' event.
+ *
+ * When we are transparently inserted on an existing provider,
+ * sc_proxying is set. The detach procedure is slightly different.
+ *
+ * When switching schedulers, sc_flushing is set so requests bypass us,
+ * and at the same time we update the pointer in the pending bios
+ * to ignore us when they return up.
+ * XXX it would be more efficient to implement sc_pending with
+ * a generation number: the softc generation is increased when
+ * we change scheduling algorithm, we store the current generation
+ * number in the pending bios, and when they come back we ignore
+ * the done() call if the generation number do not match.
+ */
+struct g_sched_softc {
+	/*
+	 * Generic fields used by any scheduling algorithm:
+	 * a mutex, the class descriptor, flags, list of pending
+	 * requests (used when flushing the module) and support
+	 * for hash tables where we store per-flow queues.
+	 */
+	struct mtx	sc_mtx;
+	struct g_gsched	*sc_gsched;	/* Scheduler descriptor. */
+	int		sc_pending;	/* Pending requests. */
+	int		sc_flags;	/* Various flags. */
+
+	/*
+	 * Hash tables to store per-flow queues are generally useful
+	 * so we handle them in the common code.
+	 * sc_hash and sc_mask are parameters of the hash table,
+	 * the last two fields are used to periodically remove
+	 * expired items from the hash table.
+	 */
+	struct g_hash	*sc_hash;
+	u_long		sc_mask;
+	int		sc_flush_ticks;	/* Next tick for a flush. */
+	int		sc_flush_bucket; /* Next bucket to flush. */
+
+	/*
+	 * Pointer to the algorithm's private data, which is the value
+	 * returned by sc_gsched->gs_init() . A NULL here means failure.
+	 * XXX intptr_t might be more appropriate.
+	 */
+	void		*sc_data;
+};
+
+#define	G_SCHED_PROXYING	1
+#define	G_SCHED_FLUSHING	2
+
+/*
+ * Temporary- our own version of the disksort, because the
+ * version in 7.x and 8.x before march 2009 is buggy.
+ */
+void gs_bioq_init(struct bio_queue_head *);
+void gs_bioq_remove(struct bio_queue_head *, struct bio *);
+void gs_bioq_flush(struct bio_queue_head *, struct devstat *, int);
+void gs_bioq_insert_head(struct bio_queue_head *, struct bio *);
+void gs_bioq_insert_tail(struct bio_queue_head *, struct bio *);
+struct bio *gs_bioq_first(struct bio_queue_head *);
+struct bio *gs_bioq_takefirst(struct bio_queue_head *);
+void gs_bioq_disksort(struct bio_queue_head *, struct bio *);
+
+#endif	/* _KERNEL */
+
+#endif	/* _G_SCHED_H_ */
diff --git a/sys/geom/sched/gs_rr.c b/sys/geom/sched/gs_rr.c
new file mode 100644
index 000000000000..c4b1990760d7
--- /dev/null
+++ b/sys/geom/sched/gs_rr.c
@@ -0,0 +1,686 @@
+/*-
+ * Copyright (c) 2009-2010 Fabio Checconi
+ * Copyright (c) 2009-2010 Luigi Rizzo, Universita` di Pisa
+ * 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.
+ */
+
+/*
+ * $Id$
+ * $FreeBSD$
+ *
+ * A round-robin (RR) anticipatory scheduler, with per-client queues.
+ *
+ * The goal of this implementation is to improve throughput compared
+ * to the pure elevator algorithm, and insure some fairness among
+ * clients.
+ * 
+ * Requests coming from the same client are put in the same queue.
+ * We use anticipation to help reducing seeks, and each queue
+ * is never served continuously for more than a given amount of
+ * time or data. Queues are then served in a round-robin fashion.
+ *
+ * Each queue can be in any of the following states:
+ *     READY	immediately serve the first pending request;
+ *     BUSY	one request is under service, wait for completion;
+ *     IDLING	do not serve incoming requests immediately, unless
+ * 		they are "eligible" as defined later.
+ *
+ * Scheduling is made looking at the status of all queues,
+ * and the first one in round-robin order is privileged.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bio.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/proc.h>
+#include <sys/queue.h>
+#include <sys/sysctl.h>
+#include "gs_scheduler.h"
+
+/* possible states of the scheduler */
+enum g_rr_state {
+	G_QUEUE_READY = 0,	/* Ready to dispatch. */
+	G_QUEUE_BUSY,		/* Waiting for a completion. */
+	G_QUEUE_IDLING		/* Waiting for a new request. */
+};
+
+/* possible queue flags */
+enum g_rr_flags {
+	G_FLAG_COMPLETED = 1,	/* Completed a req. in the current budget. */
+};
+
+struct g_rr_softc;
+
+/*
+ * Queue descriptor, containing reference count, scheduling
+ * state, a queue of pending requests, configuration parameters.
+ * Queues with pending request(s) and not under service are also
+ * stored in a Round Robin (RR) list.
+ */
+struct g_rr_queue {
+	struct g_rr_softc *q_sc;	/* link to the parent */
+
+	enum g_rr_state	q_status;
+	unsigned int	q_service;	/* service received so far */
+	int		q_slice_end;	/* actual slice end in ticks */
+	enum g_rr_flags	q_flags;	/* queue flags */
+	struct bio_queue_head q_bioq;
+
+	/* Scheduling parameters */
+	unsigned int	q_budget;	/* slice size in bytes */
+	unsigned int	q_slice_duration; /* slice size in ticks */
+	unsigned int	q_wait_ticks;	/* wait time for anticipation */
+
+	/* Stats to drive the various heuristics. */
+	struct g_savg	q_thinktime;	/* Thinktime average. */
+	struct g_savg	q_seekdist;	/* Seek distance average. */
+
+	int		q_bionum;	/* Number of requests. */
+
+	off_t		q_lastoff;	/* Last submitted req. offset. */
+	int		q_lastsub;	/* Last submitted req. time. */
+
+	/* Expiration deadline for an empty queue. */
+	int		q_expire;
+
+	TAILQ_ENTRY(g_rr_queue) q_tailq; /* RR list link field */
+};
+
+/* List types. */
+TAILQ_HEAD(g_rr_tailq, g_rr_queue);
+
+/* list of scheduler instances */
+LIST_HEAD(g_scheds, g_rr_softc);
+
+/* Default quantum for RR between queues. */
+#define	G_RR_DEFAULT_BUDGET	0x00800000
+
+/*
+ * Per device descriptor, holding the Round Robin list of queues
+ * accessing the disk, a reference to the geom, and the timer.
+ */
+struct g_rr_softc {
+	struct g_geom	*sc_geom;
+
+	/*
+	 * sc_active is the queue we are anticipating for.
+	 * It is set only in gs_rr_next(), and possibly cleared
+	 * only in gs_rr_next() or on a timeout.
+	 * The active queue is never in the Round Robin list
+	 * even if it has requests queued.
+	 */
+	struct g_rr_queue *sc_active;
+	struct callout	sc_wait;	/* timer for sc_active */
+
+	struct g_rr_tailq sc_rr_tailq;	/* the round-robin list */
+	int		sc_nqueues;	/* number of queues */
+
+	/* Statistics */
+	int		sc_in_flight;	/* requests in the driver */
+
+	LIST_ENTRY(g_rr_softc)	sc_next;
+};
+
+/* Descriptor for bounded values, min and max are constant. */
+struct x_bound {		
+	const int	x_min;
+	int		x_cur;
+	const int	x_max;
+};
+
+/*
+ * parameters, config and stats
+ */
+struct g_rr_params {
+	int	queues;			/* total number of queues */
+	int	w_anticipate;		/* anticipate writes */
+	int	bypass;			/* bypass scheduling writes */
+
+	int	units;			/* how many instances */
+	/* sc_head is used for debugging */
+	struct g_scheds	sc_head;	/* first scheduler instance */
+
+	struct x_bound queue_depth;	/* max parallel requests */
+	struct x_bound wait_ms;		/* wait time, milliseconds */
+	struct x_bound quantum_ms;	/* quantum size, milliseconds */
+	struct x_bound quantum_kb;	/* quantum size, Kb (1024 bytes) */
+
+	/* statistics */
+	int	wait_hit;		/* success in anticipation */
+	int	wait_miss;		/* failure in anticipation */
+};
+
+/*
+ * Default parameters for the scheduler.  The quantum sizes target
+ * a 80MB/s disk; if the hw is faster or slower the minimum of the
+ * two will have effect: the clients will still be isolated but
+ * the fairness may be limited.  A complete solution would involve
+ * the on-line measurement of the actual disk throughput to derive
+ * these parameters.  Or we may just choose to ignore service domain
+ * fairness and accept what can be achieved with time-only budgets.
+ */
+static struct g_rr_params me = {
+	.sc_head = LIST_HEAD_INITIALIZER(&me.sc_head),
+	.w_anticipate =	1,
+	.queue_depth =	{ 1,	1,	50 },
+	.wait_ms =	{ 1, 	10,	30 },
+	.quantum_ms =	{ 1, 	100,	500 },
+	.quantum_kb =	{ 16, 	8192,	65536 },
+};
+
+struct g_rr_params *gs_rr_me = &me;
+
+SYSCTL_DECL(_kern_geom_sched);
+SYSCTL_NODE(_kern_geom_sched, OID_AUTO, rr, CTLFLAG_RW, 0,
+    "GEOM_SCHED ROUND ROBIN stuff");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, units, CTLFLAG_RD,
+    &me.units, 0, "Scheduler instances");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, queues, CTLFLAG_RD,
+    &me.queues, 0, "Total rr queues");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, wait_ms, CTLFLAG_RW,
+    &me.wait_ms.x_cur, 0, "Wait time milliseconds");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, quantum_ms, CTLFLAG_RW,
+    &me.quantum_ms.x_cur, 0, "Quantum size milliseconds");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, bypass, CTLFLAG_RW,
+    &me.bypass, 0, "Bypass scheduler");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, w_anticipate, CTLFLAG_RW,
+    &me.w_anticipate, 0, "Do anticipation on writes");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, quantum_kb, CTLFLAG_RW,
+    &me.quantum_kb.x_cur, 0, "Quantum size Kbytes");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, queue_depth, CTLFLAG_RW,
+    &me.queue_depth.x_cur, 0, "Maximum simultaneous requests");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, wait_hit, CTLFLAG_RW,
+    &me.wait_hit, 0, "Hits in anticipation");
+SYSCTL_UINT(_kern_geom_sched_rr, OID_AUTO, wait_miss, CTLFLAG_RW,
+    &me.wait_miss, 0, "Misses in anticipation");
+
+#ifdef DEBUG_QUEUES
+/* print the status of a queue */
+static void
+gs_rr_dump_q(struct g_rr_queue *qp, int index)
+{
+	int l = 0;
+	struct bio *bp;
+
+	TAILQ_FOREACH(bp, &(qp->q_bioq.queue), bio_queue) {
+		l++;
+	}
+	printf("--- rr queue %d %p status %d len %d ---\n",
+	    index, qp, qp->q_status, l);
+}
+
+/*
+ * Dump the scheduler status when writing to this sysctl variable.
+ * XXX right now we only dump the status of the last instance created.
+ * not a severe issue because this is only for debugging
+ */
+static int
+gs_rr_sysctl_status(SYSCTL_HANDLER_ARGS)
+{
+        int error, val = 0;
+	struct g_rr_softc *sc;
+
+        error = sysctl_handle_int(oidp, &val, 0, req);
+        if (error || !req->newptr )
+                return (error);
+
+        printf("called %s\n", __FUNCTION__);
+
+	LIST_FOREACH(sc, &me.sc_head, sc_next) {
+		int i, tot = 0;
+		printf("--- sc %p active %p nqueues %d "
+		    "callout %d in_flight %d ---\n",
+		    sc, sc->sc_active, sc->sc_nqueues,
+		    callout_active(&sc->sc_wait),
+		    sc->sc_in_flight);
+		for (i = 0; i < G_RR_HASH_SIZE; i++) {
+			struct g_rr_queue *qp;
+			LIST_FOREACH(qp, &sc->sc_hash[i], q_hash) {
+				gs_rr_dump_q(qp, tot);
+				tot++;
+			}
+		}
+	}
+        return (0);
+}
+
+SYSCTL_PROC(_kern_geom_sched_rr, OID_AUTO, status,
+	CTLTYPE_UINT | CTLFLAG_RW,
+    0, sizeof(int), gs_rr_sysctl_status, "I", "status");
+
+#endif	/* DEBUG_QUEUES */
+
+/*
+ * Get a bounded value, optionally convert to a min of t_min ticks.
+ */
+static int
+get_bounded(struct x_bound *v, int t_min)
+{
+	int x;
+
+	x = v->x_cur;
+	if (x < v->x_min)
+		x = v->x_min;
+	else if (x > v->x_max)
+		x = v->x_max;
+	if (t_min) {
+		x = x * hz / 1000;	/* convert to ticks */
+		if (x < t_min)
+			x = t_min;
+	}
+	return x;
+}
+
+/*
+ * Get a reference to the queue for bp, using the generic
+ * classification mechanism.
+ */
+static struct g_rr_queue *
+g_rr_queue_get(struct g_rr_softc *sc, struct bio *bp)
+{
+
+	return (g_sched_get_class(sc->sc_geom, bp));
+}
+
+static int
+g_rr_init_class(void *data, void *priv)
+{
+	struct g_rr_softc *sc = data;
+	struct g_rr_queue *qp = priv;
+
+	gs_bioq_init(&qp->q_bioq);
+
+	/*
+	 * Set the initial parameters for the client:
+	 * slice size in bytes and ticks, and wait ticks.
+	 * Right now these are constant, but we could have
+	 * autoconfiguration code to adjust the values based on
+	 * the actual workload.
+	 */
+	qp->q_budget = 1024 * get_bounded(&me.quantum_kb, 0);
+	qp->q_slice_duration = get_bounded(&me.quantum_ms, 2);
+	qp->q_wait_ticks = get_bounded(&me.wait_ms, 2);
+
+	qp->q_sc = sc;		/* link to the parent */
+	qp->q_sc->sc_nqueues++;
+	me.queues++;
+
+	return (0);
+}
+
+/*
+ * Release a reference to the queue.
+ */
+static void
+g_rr_queue_put(struct g_rr_queue *qp)
+{
+
+	g_sched_put_class(qp->q_sc->sc_geom, qp);
+}
+
+static void
+g_rr_fini_class(void *data, void *priv)
+{
+	struct g_rr_queue *qp = priv;
+
+	KASSERT(gs_bioq_first(&qp->q_bioq) == NULL,
+			("released nonempty queue"));
+	qp->q_sc->sc_nqueues--;
+	me.queues--;
+}
+
+static inline int
+g_rr_queue_expired(struct g_rr_queue *qp)
+{
+
+	if (qp->q_service >= qp->q_budget)
+		return (1);
+
+	if ((qp->q_flags & G_FLAG_COMPLETED) &&
+	    ticks - qp->q_slice_end >= 0)
+		return (1);
+
+	return (0);
+}
+
+static inline int
+g_rr_should_anticipate(struct g_rr_queue *qp, struct bio *bp)
+{
+	int wait = get_bounded(&me.wait_ms, 2);
+
+	if (!me.w_anticipate && (bp->bio_cmd & BIO_WRITE))
+		return (0);
+
+	if (g_savg_valid(&qp->q_thinktime) &&
+	    g_savg_read(&qp->q_thinktime) > wait)
+		return (0);
+
+	if (g_savg_valid(&qp->q_seekdist) &&
+	    g_savg_read(&qp->q_seekdist) > 8192)
+		return (0);
+
+	return (1);
+}
+
+/*
+ * Called on a request arrival, timeout or completion.
+ * Try to serve a request among those queued.
+ */
+static struct bio *
+g_rr_next(void *data, int force)
+{
+	struct g_rr_softc *sc = data;
+	struct g_rr_queue *qp;
+	struct bio *bp, *next;
+	int expired;
+
+	qp = sc->sc_active;
+	if (me.bypass == 0 && !force) {
+		if (sc->sc_in_flight >= get_bounded(&me.queue_depth, 0))
+			return (NULL);
+
+		/* Try with the queue under service first. */
+		if (qp != NULL && qp->q_status != G_QUEUE_READY) {
+			/*
+			 * Queue is anticipating, ignore request.
+			 * We should check that we are not past
+			 * the timeout, but in that case the timeout
+			 * will fire immediately afterwards so we
+			 * don't bother.
+			 */
+			return (NULL);
+		}
+	} else if (qp != NULL && qp->q_status != G_QUEUE_READY) {
+		g_rr_queue_put(qp);
+		sc->sc_active = qp = NULL;
+	}
+
+	/*
+	 * No queue under service, look for the first in RR order.
+	 * If we find it, select if as sc_active, clear service
+	 * and record the end time of the slice.
+	 */
+	if (qp == NULL) {
+		qp = TAILQ_FIRST(&sc->sc_rr_tailq);
+		if (qp == NULL)
+			return (NULL); /* no queues at all, return */
+		/* otherwise select the new queue for service. */
+		TAILQ_REMOVE(&sc->sc_rr_tailq, qp, q_tailq);
+		sc->sc_active = qp;
+		qp->q_service = 0;
+		qp->q_flags &= ~G_FLAG_COMPLETED;
+	}
+
+	bp = gs_bioq_takefirst(&qp->q_bioq);	/* surely not NULL */
+	qp->q_service += bp->bio_length;	/* charge the service */
+
+	/*
+	 * The request at the head of the active queue is always
+	 * dispatched, and gs_rr_next() will be called again
+	 * immediately.
+	 * We need to prepare for what to do next:
+	 *
+	 * 1. have we reached the end of the (time or service) slice ?
+	 *    If so, clear sc_active and possibly requeue the previous
+	 *    active queue if it has more requests pending;
+	 * 2. do we have more requests in sc_active ?
+	 *    If yes, do not anticipate, as gs_rr_next() will run again;
+	 *    if no, decide whether or not to anticipate depending
+	 *    on read or writes (e.g., anticipate only on reads).
+	 */
+	expired = g_rr_queue_expired(qp);	/* are we expired ? */
+	next = gs_bioq_first(&qp->q_bioq);	/* do we have one more ? */
+ 	if (expired) {
+		sc->sc_active = NULL;
+		/* Either requeue or release reference. */
+		if (next != NULL)
+			TAILQ_INSERT_TAIL(&sc->sc_rr_tailq, qp, q_tailq);
+		else
+			g_rr_queue_put(qp);
+	} else if (next != NULL) {
+		qp->q_status = G_QUEUE_READY;
+	} else {
+		if (!force && g_rr_should_anticipate(qp, bp)) {
+			/* anticipate */
+			qp->q_status = G_QUEUE_BUSY;
+		} else {
+			/* do not anticipate, release reference */
+			g_rr_queue_put(qp);
+			sc->sc_active = NULL;
+		}
+	}
+	/* If sc_active != NULL, its q_status is always correct. */
+
+	sc->sc_in_flight++;
+
+	return (bp);
+}
+
+static inline void
+g_rr_update_thinktime(struct g_rr_queue *qp)
+{
+	int delta = ticks - qp->q_lastsub, wait = get_bounded(&me.wait_ms, 2);
+
+	if (qp->q_sc->sc_active != qp)
+		return;
+
+	qp->q_lastsub = ticks;
+	delta = (delta > 2 * wait) ? 2 * wait : delta;
+	if (qp->q_bionum > 7)
+		g_savg_add_sample(&qp->q_thinktime, delta);
+}
+
+static inline void
+g_rr_update_seekdist(struct g_rr_queue *qp, struct bio *bp)
+{
+	off_t dist;
+
+	if (qp->q_lastoff > bp->bio_offset)
+		dist = qp->q_lastoff - bp->bio_offset;
+	else
+		dist = bp->bio_offset - qp->q_lastoff;
+
+	if (dist > (8192 * 8))
+		dist = 8192 * 8;
+
+	qp->q_lastoff = bp->bio_offset + bp->bio_length;
+
+	if (qp->q_bionum > 7)
+		g_savg_add_sample(&qp->q_seekdist, dist);
+}
+
+/*
+ * Called when a real request for disk I/O arrives.
+ * Locate the queue associated with the client.
+ * If the queue is the one we are anticipating for, reset its timeout;
+ * if the queue is not in the round robin list, insert it in the list.
+ * On any error, do not queue the request and return -1, the caller
+ * will take care of this request.
+ */
+static int
+g_rr_start(void *data, struct bio *bp)
+{
+	struct g_rr_softc *sc = data;
+	struct g_rr_queue *qp;
+
+	if (me.bypass)
+		return (-1);	/* bypass the scheduler */
+
+	/* Get the queue for the request. */
+	qp = g_rr_queue_get(sc, bp);
+	if (qp == NULL)
+		return (-1); /* allocation failed, tell upstream */
+
+	if (gs_bioq_first(&qp->q_bioq) == NULL) {
+		/*
+		 * We are inserting into an empty queue.
+		 * Reset its state if it is sc_active,
+		 * otherwise insert it in the RR list.
+		 */
+		if (qp == sc->sc_active) {
+			qp->q_status = G_QUEUE_READY;
+			callout_stop(&sc->sc_wait);
+		} else {
+			g_sched_priv_ref(qp);
+			TAILQ_INSERT_TAIL(&sc->sc_rr_tailq, qp, q_tailq);
+		}
+	}
+
+	qp->q_bionum = 1 + qp->q_bionum - (qp->q_bionum >> 3);
+
+	g_rr_update_thinktime(qp);
+	g_rr_update_seekdist(qp, bp);
+
+	/* Inherit the reference returned by g_rr_queue_get(). */
+	bp->bio_caller1 = qp;
+	gs_bioq_disksort(&qp->q_bioq, bp);
+
+	return (0);
+}
+
+/*
+ * Callout executed when a queue times out anticipating a new request.
+ */
+static void
+g_rr_wait_timeout(void *data)
+{
+	struct g_rr_softc *sc = data;
+	struct g_geom *geom = sc->sc_geom;
+
+	g_sched_lock(geom);
+	/*
+	 * We can race with other events, so check if
+	 * sc_active is still valid.
+	 */
+	if (sc->sc_active != NULL) {
+		/* Release the reference to the queue. */
+		g_rr_queue_put(sc->sc_active);
+		sc->sc_active = NULL;
+		me.wait_hit--;
+		me.wait_miss++;	/* record the miss */
+	}
+	g_sched_dispatch(geom);
+	g_sched_unlock(geom);
+}
+
+/*
+ * Module glue: allocate descriptor, initialize its fields.
+ */
+static void *
+g_rr_init(struct g_geom *geom)
+{
+	struct g_rr_softc *sc;
+
+	/* XXX check whether we can sleep */
+	sc = malloc(sizeof *sc, M_GEOM_SCHED, M_NOWAIT | M_ZERO);
+	sc->sc_geom = geom;
+	TAILQ_INIT(&sc->sc_rr_tailq);
+	callout_init(&sc->sc_wait, CALLOUT_MPSAFE);
+	LIST_INSERT_HEAD(&me.sc_head, sc, sc_next);
+	me.units++;
+
+	return (sc);
+}
+
+/*
+ * Module glue -- drain the callout structure, destroy the
+ * hash table and its element, and free the descriptor.
+ */
+static void
+g_rr_fini(void *data)
+{
+	struct g_rr_softc *sc = data;
+
+	callout_drain(&sc->sc_wait);
+	KASSERT(sc->sc_active == NULL, ("still a queue under service"));
+	KASSERT(TAILQ_EMPTY(&sc->sc_rr_tailq), ("still scheduled queues"));
+
+	LIST_REMOVE(sc, sc_next);
+	me.units--;
+	free(sc, M_GEOM_SCHED);
+}
+
+/*
+ * Called when the request under service terminates.
+ * Start the anticipation timer if needed.
+ */
+static void
+g_rr_done(void *data, struct bio *bp)
+{
+	struct g_rr_softc *sc = data;
+	struct g_rr_queue *qp;
+
+	sc->sc_in_flight--;
+
+	qp = bp->bio_caller1;
+	if (qp == sc->sc_active && qp->q_status == G_QUEUE_BUSY) {
+		if (!(qp->q_flags & G_FLAG_COMPLETED)) {
+			qp->q_flags |= G_FLAG_COMPLETED;
+			/* in case we want to make the slice adaptive */
+			qp->q_slice_duration = get_bounded(&me.quantum_ms, 2);
+			qp->q_slice_end = ticks + qp->q_slice_duration;
+		}
+
+		/* The queue is trying anticipation, start the timer. */
+		qp->q_status = G_QUEUE_IDLING;
+		/* may make this adaptive */
+		qp->q_wait_ticks = get_bounded(&me.wait_ms, 2);
+		me.wait_hit++;
+		callout_reset(&sc->sc_wait, qp->q_wait_ticks,
+		    g_rr_wait_timeout, sc);
+	} else
+		g_sched_dispatch(sc->sc_geom);
+
+	/* Release a reference to the queue. */
+	g_rr_queue_put(qp);
+}
+
+static void
+g_rr_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
+    struct g_consumer *cp, struct g_provider *pp)
+{
+	if (indent == NULL) {   /* plaintext */
+		sbuf_printf(sb, " units %d queues %d",
+			me.units, me.queues);
+        }
+}
+
+static struct g_gsched g_rr = {
+	.gs_name = "rr",
+	.gs_priv_size = sizeof(struct g_rr_queue),
+	.gs_init = g_rr_init,
+	.gs_fini = g_rr_fini,
+	.gs_start = g_rr_start,
+	.gs_done = g_rr_done,
+	.gs_next = g_rr_next,
+	.gs_dumpconf = g_rr_dumpconf,
+	.gs_init_class = g_rr_init_class,
+	.gs_fini_class = g_rr_fini_class,
+};
+
+DECLARE_GSCHED_MODULE(rr, &g_rr);
diff --git a/sys/geom/sched/gs_scheduler.h b/sys/geom/sched/gs_scheduler.h
new file mode 100644
index 000000000000..31e47e62ce7d
--- /dev/null
+++ b/sys/geom/sched/gs_scheduler.h
@@ -0,0 +1,237 @@
+/*-
+ * Copyright (c) 2009-2010 Fabio Checconi
+ * Copyright (c) 2009-2010 Luigi Rizzo, Universita` di Pisa
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * $Id$
+ * $FreeBSD$
+ *
+ * Prototypes for GEOM-based disk scheduling algorithms.
+ * See g_sched.c for generic documentation.
+ *
+ * This file is used by the kernel modules implementing the various
+ * scheduling algorithms. They should provide all the methods
+ * defined in struct g_gsched, and also invoke the macro
+ *	DECLARE_GSCHED_MODULE
+ * which registers the scheduling algorithm with the geom_sched module.
+ *
+ * The various scheduling algorithms do not need to know anything
+ * about geom, they only need to handle the 'bio' requests they
+ * receive, pass them down when needed, and use the locking interface
+ * defined below.
+ */
+
+#ifndef	_G_GSCHED_H_
+#define	_G_GSCHED_H_
+
+#ifdef _KERNEL
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/ktr.h>
+#include <sys/module.h>
+#include <sys/queue.h>
+#include <geom/geom.h>
+#include "g_sched.h"
+
+/*
+ * This is the interface exported to scheduling modules.
+ *
+ * gs_init() is called when our scheduling algorithm
+ *    starts being used by a geom 'sched'
+ *
+ * gs_fini() is called when the algorithm is released.
+ *
+ * gs_start() is called when a new request comes in. It should
+ *    enqueue the request and return 0 if success, or return non-zero
+ *    in case of failure (meaning the request is passed down).
+ *    The scheduler can use bio->bio_caller1 to store a non-null
+ *    pointer meaning the request is under its control.
+ *
+ * gs_next() is called in a loop by g_sched_dispatch(), right after
+ *    gs_start(), or on timeouts or 'done' events. It should return
+ *    immediately, either a pointer to the bio to be served or NULL
+ *    if no bio should be served now.  If force is specified, a
+ *    work-conserving behavior is expected.
+ *
+ * gs_done() is called when a request under service completes.
+ *    In turn the scheduler may decide to call the dispatch loop
+ *    to serve other pending requests (or make sure there is a pending
+ *    timeout to avoid stalls).
+ *
+ * gs_init_class() is called when a new client (as determined by
+ *    the classifier) starts being used.
+ *
+ * gs_hash_unref() is called right before the class hashtable is
+ *    destroyed; after this call, the scheduler is supposed to hold no
+ *    more references to the elements in the table.
+ */
+
+/* Forward declarations for prototypes. */
+struct g_geom;
+struct g_sched_class;
+
+typedef void *gs_init_t (struct g_geom *geom);
+typedef void gs_fini_t (void *data);
+typedef int gs_start_t (void *data, struct bio *bio);
+typedef void gs_done_t (void *data, struct bio *bio);
+typedef struct bio *gs_next_t (void *data, int force);
+typedef int gs_init_class_t (void *data, void *priv);
+typedef void gs_fini_class_t (void *data, void *priv);
+typedef void gs_hash_unref_t (void *data);
+
+struct g_gsched {
+	const char	*gs_name;
+	int		gs_refs;
+	int		gs_priv_size;
+
+	gs_init_t	*gs_init;
+	gs_fini_t	*gs_fini;
+	gs_start_t	*gs_start;
+	gs_done_t	*gs_done;
+	gs_next_t	*gs_next;
+	g_dumpconf_t	*gs_dumpconf;
+
+	gs_init_class_t	*gs_init_class;
+	gs_fini_class_t	*gs_fini_class;
+	gs_hash_unref_t *gs_hash_unref;
+
+	LIST_ENTRY(g_gsched) glist;
+};
+
+#define	KTR_GSCHED	KTR_SPARE4
+
+MALLOC_DECLARE(M_GEOM_SCHED);
+
+/*
+ * Basic classification mechanism.  Each request is associated to
+ * a g_sched_class, and each scheduler has the opportunity to set
+ * its own private data for the given (class, geom) pair.  The
+ * private data have a base type of g_sched_private, and are
+ * extended at the end with the actual private fields of each
+ * scheduler.
+ */
+struct g_sched_class {
+	int	gsc_refs;
+	int	gsc_expire;
+	u_long	gsc_key;
+	LIST_ENTRY(g_sched_class) gsc_clist;
+
+	void	*gsc_priv[0];
+};
+
+/*
+ * Manipulate the classifier's data.  g_sched_get_class() gets a reference
+ * to the the class corresponding to bp in gp, allocating and initializing
+ * it if necessary.  g_sched_put_class() releases the reference.
+ * The returned value points to the private data for the class.
+ */
+void *g_sched_get_class(struct g_geom *gp, struct bio *bp);
+void g_sched_put_class(struct g_geom *gp, void *priv);
+
+static inline struct g_sched_class *
+g_sched_priv2class(void *priv)
+{
+
+	return ((struct g_sched_class *)((u_long)priv -
+	    offsetof(struct g_sched_class, gsc_priv)));
+}
+
+static inline void
+g_sched_priv_ref(void *priv)
+{
+	struct g_sched_class *gsc;
+
+	gsc = g_sched_priv2class(priv);
+	gsc->gsc_refs++;
+}
+
+/*
+ * Locking interface.  When each operation registered with the
+ * scheduler is invoked, a per-instance lock is taken to protect
+ * the data associated with it.  If the scheduler needs something
+ * else to access the same data (e.g., a callout) it must use
+ * these functions.
+ */
+void g_sched_lock(struct g_geom *gp);
+void g_sched_unlock(struct g_geom *gp);
+
+/*
+ * Restart request dispatching.  Must be called with the per-instance
+ * mutex held.
+ */
+void g_sched_dispatch(struct g_geom *geom);
+
+/*
+ * Simple gathering of statistical data, used by schedulers to collect
+ * info on process history.  Just keep an exponential average of the
+ * samples, with some extra bits of precision.
+ */
+struct g_savg {
+	uint64_t	gs_avg;
+	unsigned int	gs_smpl;
+};
+
+static inline void
+g_savg_add_sample(struct g_savg *ss, uint64_t sample)
+{
+
+	/* EMA with alpha = 0.125, fixed point, 3 bits of precision. */
+	ss->gs_avg = sample + ss->gs_avg - (ss->gs_avg >> 3);
+	ss->gs_smpl = 1 + ss->gs_smpl - (ss->gs_smpl >> 3);
+}
+
+static inline int
+g_savg_valid(struct g_savg *ss)
+{
+
+	/* We want at least 8 samples to deem an average as valid. */
+	return (ss->gs_smpl > 7);
+}
+
+static inline uint64_t
+g_savg_read(struct g_savg *ss)
+{
+
+	return (ss->gs_avg / ss->gs_smpl);
+}
+
+/*
+ * Declaration of a scheduler module.
+ */
+int g_gsched_modevent(module_t mod, int cmd, void *arg);
+
+#define	DECLARE_GSCHED_MODULE(name, gsched)			\
+	static moduledata_t name##_mod = {			\
+		#name,						\
+		g_gsched_modevent,				\
+		gsched,						\
+	};							\
+	DECLARE_MODULE(name, name##_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE); \
+	MODULE_DEPEND(name, geom_sched, 0, 0, 0);
+
+#endif	/* _KERNEL */
+
+#endif	/* _G_GSCHED_H_ */
diff --git a/sys/geom/sched/subr_disk.c b/sys/geom/sched/subr_disk.c
new file mode 100644
index 000000000000..008eaab1c94b
--- /dev/null
+++ b/sys/geom/sched/subr_disk.c
@@ -0,0 +1,209 @@
+/*-
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ *
+ * The bioq_disksort() (and the specification of the bioq API)
+ * have been written by Luigi Rizzo and Fabio Checconi under the same
+ * license as above.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+//#include "opt_geom.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bio.h>
+#include <sys/conf.h>
+#include <sys/disk.h>
+#include <geom/geom_disk.h>
+#include "g_sched.h"
+
+/*
+ * BIO queue implementation
+ *
+ * Please read carefully the description below before making any change
+ * to the code, or you might change the behaviour of the data structure
+ * in undesirable ways.
+ *
+ * A bioq stores disk I/O request (bio), normally sorted according to
+ * the distance of the requested position (bio->bio_offset) from the
+ * current head position (bioq->last_offset) in the scan direction, i.e.
+ *
+ * 	(uoff_t)(bio_offset - last_offset)
+ *
+ * Note that the cast to unsigned (uoff_t) is fundamental to insure
+ * that the distance is computed in the scan direction.
+ *
+ * The main methods for manipulating the bioq are:
+ *
+ *   bioq_disksort()	performs an ordered insertion;
+ *
+ *   bioq_first()	return the head of the queue, without removing;
+ *
+ *   bioq_takefirst()	return and remove the head of the queue,
+ *		updating the 'current head position' as
+ *		bioq->last_offset = bio->bio_offset + bio->bio_length;
+ *
+ * When updating the 'current head position', we assume that the result of
+ * bioq_takefirst() is dispatched to the device, so bioq->last_offset
+ * represents the head position once the request is complete.
+ *
+ * If the bioq is manipulated using only the above calls, it starts
+ * with a sorted sequence of requests with bio_offset >= last_offset,
+ * possibly followed by another sorted sequence of requests with
+ * 0 <= bio_offset < bioq->last_offset 
+ *
+ * NOTE: historical behaviour was to ignore bio->bio_length in the
+ *	update, but its use tracks the head position in a better way.
+ *	Historical behaviour was also to update the head position when
+ *	the request under service is complete, rather than when the
+ *	request is extracted from the queue. However, the current API
+ *	has no method to update the head position; secondly, once
+ *	a request has been submitted to the disk, we have no idea of
+ *	the actual head position, so the final one is our best guess.
+ *
+ * --- Direct queue manipulation ---
+ *
+ * A bioq uses an underlying TAILQ to store requests, so we also
+ * export methods to manipulate the TAILQ, in particular:
+ *
+ * bioq_insert_tail()	insert an entry at the end.
+ *		It also creates a 'barrier' so all subsequent
+ *		insertions through bioq_disksort() will end up
+ *		after this entry;
+ *
+ * bioq_insert_head()	insert an entry at the head, update
+ *		bioq->last_offset = bio->bio_offset so that
+ *		all subsequent insertions through bioq_disksort()
+ *		will end up after this entry;
+ *
+ * bioq_remove()	remove a generic element from the queue, act as
+ *		bioq_takefirst() if invoked on the head of the queue.
+ *
+ * The semantic of these methods is the same of the operations
+ * on the underlying TAILQ, but with additional guarantees on
+ * subsequent bioq_disksort() calls. E.g. bioq_insert_tail()
+ * can be useful for making sure that all previous ops are flushed
+ * to disk before continuing.
+ *
+ * Updating bioq->last_offset on a bioq_insert_head() guarantees
+ * that the bio inserted with the last bioq_insert_head() will stay
+ * at the head of the queue even after subsequent bioq_disksort().
+ *
+ * Note that when the direct queue manipulation functions are used,
+ * the queue may contain multiple inversion points (i.e. more than
+ * two sorted sequences of requests).
+ *
+ */
+
+void
+gs_bioq_init(struct bio_queue_head *head)
+{
+
+	TAILQ_INIT(&head->queue);
+	head->last_offset = 0;
+	head->insert_point = NULL;
+}
+
+void
+gs_bioq_remove(struct bio_queue_head *head, struct bio *bp)
+{
+
+	if (bp == TAILQ_FIRST(&head->queue))
+		head->last_offset = bp->bio_offset + bp->bio_length;
+
+	if (bp == head->insert_point)
+		head->insert_point = NULL;
+
+	TAILQ_REMOVE(&head->queue, bp, bio_queue);
+}
+
+void
+gs_bioq_flush(struct bio_queue_head *head, struct devstat *stp, int error)
+{
+	struct bio *bp;
+
+	while ((bp = gs_bioq_takefirst(head)) != NULL)
+		biofinish(bp, stp, error);
+}
+
+void
+gs_bioq_insert_head(struct bio_queue_head *head, struct bio *bp)
+{
+
+	head->last_offset = bp->bio_offset;
+	TAILQ_INSERT_HEAD(&head->queue, bp, bio_queue);
+}
+
+void
+gs_bioq_insert_tail(struct bio_queue_head *head, struct bio *bp)
+{
+
+	TAILQ_INSERT_TAIL(&head->queue, bp, bio_queue);
+	head->insert_point = bp;
+}
+
+struct bio *
+gs_bioq_first(struct bio_queue_head *head)
+{
+
+	return (TAILQ_FIRST(&head->queue));
+}
+
+struct bio *
+gs_bioq_takefirst(struct bio_queue_head *head)
+{
+	struct bio *bp;
+
+	bp = TAILQ_FIRST(&head->queue);
+	if (bp != NULL)
+		gs_bioq_remove(head, bp);
+	return (bp);
+}
+
+/*
+ * Compute the sorting key. The cast to unsigned is
+ * fundamental for correctness, see the description
+ * near the beginning of the file.
+ */
+static inline uoff_t
+gs_bioq_bio_key(struct bio_queue_head *head, struct bio *bp)
+{
+
+	return ((uoff_t)(bp->bio_offset - head->last_offset));
+}
+
+/*
+ * Seek sort for disks.
+ *
+ * Sort all requests in a single queue while keeping
+ * track of the current position of the disk with last_offset.
+ * See above for details.
+ */
+void
+gs_bioq_disksort(struct bio_queue_head *head, struct bio *bp)
+{
+	struct bio *cur, *prev = NULL;
+	uoff_t key = gs_bioq_bio_key(head, bp);
+
+	cur = TAILQ_FIRST(&head->queue);
+
+	if (head->insert_point)
+		cur = head->insert_point;
+
+	while (cur != NULL && key >= gs_bioq_bio_key(head, cur)) {
+		prev = cur;
+		cur = TAILQ_NEXT(cur, bio_queue);
+	}
+
+	if (prev == NULL)
+		TAILQ_INSERT_HEAD(&head->queue, bp, bio_queue);
+	else
+		TAILQ_INSERT_AFTER(&head->queue, prev, bp, bio_queue);
+}
diff --git a/sys/i386/i386/machdep.c b/sys/i386/i386/machdep.c
index 695b656f21b8..5293d53c1649 100644
--- a/sys/i386/i386/machdep.c
+++ b/sys/i386/i386/machdep.c
@@ -944,7 +944,8 @@ freebsd4_sigreturn(td, uap)
 		 * one less debugger trap, so allowing it is fairly harmless.
 		 */
 		if (!EFL_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
-			printf("freebsd4_sigreturn: eflags = 0x%x\n", eflags);
+			uprintf("pid %d (%s): freebsd4_sigreturn eflags = 0x%x\n",
+			    td->td_proc->p_pid, td->td_name, eflags);
 	    		return (EINVAL);
 		}
 
@@ -955,7 +956,8 @@ freebsd4_sigreturn(td, uap)
 		 */
 		cs = ucp->uc_mcontext.mc_cs;
 		if (!CS_SECURE(cs)) {
-			printf("freebsd4_sigreturn: cs = 0x%x\n", cs);
+			uprintf("pid %d (%s): freebsd4_sigreturn cs = 0x%x\n",
+			    td->td_proc->p_pid, td->td_name, cs);
 			ksiginfo_init_trap(&ksi);
 			ksi.ksi_signo = SIGBUS;
 			ksi.ksi_code = BUS_OBJERR;
@@ -1056,7 +1058,8 @@ sigreturn(td, uap)
 		 * one less debugger trap, so allowing it is fairly harmless.
 		 */
 		if (!EFL_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
-			printf("sigreturn: eflags = 0x%x\n", eflags);
+			uprintf("pid %d (%s): sigreturn eflags = 0x%x\n",
+			    td->td_proc->p_pid, td->td_name, eflags);
 	    		return (EINVAL);
 		}
 
@@ -1067,7 +1070,8 @@ sigreturn(td, uap)
 		 */
 		cs = ucp->uc_mcontext.mc_cs;
 		if (!CS_SECURE(cs)) {
-			printf("sigreturn: cs = 0x%x\n", cs);
+			uprintf("pid %d (%s): sigreturn cs = 0x%x\n",
+			    td->td_proc->p_pid, td->td_name, cs);
 			ksiginfo_init_trap(&ksi);
 			ksi.ksi_signo = SIGBUS;
 			ksi.ksi_code = BUS_OBJERR;
diff --git a/sys/i386/i386/mpboot.s b/sys/i386/i386/mpboot.s
index 5effeb9b65c2..88708589048f 100644
--- a/sys/i386/i386/mpboot.s
+++ b/sys/i386/i386/mpboot.s
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1995, Jack F. Vogel
+ * Copyright (c) 1995 Jack F. Vogel
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,11 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by Jack F. Vogel
- * 4. The name of the developer may be used to endorse or promote products
- *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/i386/i386/trap.c b/sys/i386/i386/trap.c
index a2274e226fdc..a11daa6ef7e8 100644
--- a/sys/i386/i386/trap.c
+++ b/sys/i386/i386/trap.c
@@ -277,7 +277,7 @@ trap(struct trapframe *frame)
 		 * enabled later.
 		 */
 		if (ISPL(frame->tf_cs) == SEL_UPL || (frame->tf_eflags & PSL_VM))
-			printf(
+			uprintf(
 			    "pid %ld (%s): trap %d with interrupts disabled\n",
 			    (long)curproc->p_pid, curthread->td_name, type);
 		else if (type != T_BPTFLT && type != T_TRCTRAP &&
@@ -507,7 +507,7 @@ trap(struct trapframe *frame)
 			if (npxdna())
 				goto userout;
 #endif
-			printf("pid %d killed due to lack of floating point\n",
+			uprintf("pid %d killed due to lack of floating point\n",
 				p->p_pid);
 			i = SIGKILL;
 			ucode = 0;
diff --git a/sys/i386/include/bootinfo.h b/sys/i386/include/bootinfo.h
index 09b4e2cc351c..9c36e2827129 100644
--- a/sys/i386/include/bootinfo.h
+++ b/sys/i386/include/bootinfo.h
@@ -65,6 +65,13 @@ struct bootinfo {
 	u_int32_t	bi_kernend;		/* end of kernel space */
 	u_int32_t	bi_envp;		/* environment */
 	u_int32_t	bi_modulep;		/* preloaded modules */
+	uint64_t	bi_hcdp;		/* DIG64 HCDP table */
+	uint64_t	bi_fpswa;		/* FPSWA interface */
+	uint64_t	bi_systab;		/* pa of EFI system table */
+	uint64_t	bi_memmap;		/* pa of EFI memory map */
+	uint64_t	bi_memmap_size;		/* size of EFI memory map */
+	uint64_t	bi_memdesc_size;	/* sizeof EFI memory desc */
+	uint32_t	bi_memdesc_version;	/* EFI memory desc version */
 };
 
 #ifdef _KERNEL
diff --git a/sys/i386/include/pmc_mdep.h b/sys/i386/include/pmc_mdep.h
index 4389a20c2036..9209a2b79edf 100644
--- a/sys/i386/include/pmc_mdep.h
+++ b/sys/i386/include/pmc_mdep.h
@@ -49,6 +49,8 @@ struct pmc_mdep;
  * PENTIUM	Intel Pentium MMX.
  * IAP		Intel Core/Core2/Atom programmable PMCs.
  * IAF		Intel fixed-function PMCs.
+ * UCP		Intel Uncore programmable PMCs.
+ * UCF		Intel Uncore fixed-function PMCs.
  */
 
 #include <dev/hwpmc/hwpmc_amd.h> /* K7 and K8 */
@@ -57,11 +59,12 @@ struct pmc_mdep;
 #include <dev/hwpmc/hwpmc_ppro.h>
 #include <dev/hwpmc/hwpmc_pentium.h>
 #include <dev/hwpmc/hwpmc_tsc.h>
+#include <dev/hwpmc/hwpmc_uncore.h>
 
 /*
  * Intel processors implementing V2 and later of the Intel performance
  * measurement architecture have PMCs of the following classes: TSC,
- * IAF and IAP.
+ * IAF, IAP, UCF and UCP.
  */
 #define	PMC_MDEP_CLASS_INDEX_TSC	0
 #define	PMC_MDEP_CLASS_INDEX_K7		1
@@ -71,6 +74,8 @@ struct pmc_mdep;
 #define	PMC_MDEP_CLASS_INDEX_P6		1
 #define	PMC_MDEP_CLASS_INDEX_IAP	1
 #define	PMC_MDEP_CLASS_INDEX_IAF	2
+#define PMC_MDEP_CLASS_INDEX_UCP	3
+#define PMC_MDEP_CLASS_INDEX_UCF	4
 
 /*
  * Architecture specific extensions to <sys/pmc.h> structures.
@@ -80,6 +85,8 @@ union pmc_md_op_pmcallocate  {
 	struct pmc_md_amd_op_pmcallocate	pm_amd;
 	struct pmc_md_iaf_op_pmcallocate	pm_iaf;
 	struct pmc_md_iap_op_pmcallocate	pm_iap;
+	struct pmc_md_ucf_op_pmcallocate	pm_ucf;
+	struct pmc_md_ucp_op_pmcallocate	pm_ucp;
 	struct pmc_md_p4_op_pmcallocate		pm_p4;
 	struct pmc_md_pentium_op_pmcallocate	pm_pentium;
 	struct pmc_md_ppro_op_pmcallocate	pm_ppro;
@@ -97,6 +104,8 @@ union pmc_md_pmc  {
 	struct pmc_md_amd_pmc	pm_amd;
 	struct pmc_md_iaf_pmc	pm_iaf;
 	struct pmc_md_iap_pmc	pm_iap;
+	struct pmc_md_ucf_pmc	pm_ucf;
+	struct pmc_md_ucp_pmc	pm_ucp;
 	struct pmc_md_p4_pmc	pm_p4;
 	struct pmc_md_pentium_pmc pm_pentium;
 	struct pmc_md_ppro_pmc	pm_ppro;
diff --git a/sys/ia64/ia64/mca.c b/sys/ia64/ia64/mca.c
index e25031dec73f..a11742a5ec2b 100644
--- a/sys/ia64/ia64/mca.c
+++ b/sys/ia64/ia64/mca.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2002 Marcel Moolenaar
+ * Copyright (c) 2002-2010 Marcel Moolenaar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -37,6 +37,7 @@
 #include <vm/vm.h>
 #include <vm/vm_kern.h>
 #include <machine/mca.h>
+#include <machine/pal.h>
 #include <machine/sal.h>
 #include <machine/smp.h>
 
@@ -44,19 +45,19 @@ MALLOC_DEFINE(M_MCA, "MCA", "Machine Check Architecture");
 
 struct mca_info {
 	STAILQ_ENTRY(mca_info) mi_link;
-	char	mi_name[32];
+	u_long	mi_seqnr;
+	u_int	mi_cpuid;
 	size_t	mi_recsz;
 	char	mi_record[0];
 };
 
-static STAILQ_HEAD(, mca_info) mca_records =
-    STAILQ_HEAD_INITIALIZER(mca_records);
+STAILQ_HEAD(mca_info_list, mca_info);
 
-int64_t		mca_info_size[SAL_INFO_TYPES];
-vm_offset_t	mca_info_block;
-struct mtx	mca_info_block_lock;
+static int64_t		mca_info_size[SAL_INFO_TYPES];
+static vm_offset_t	mca_info_block;
+static struct mtx	mca_info_block_lock;
 
-SYSCTL_NODE(_hw, OID_AUTO, mca, CTLFLAG_RW, 0, "MCA container");
+SYSCTL_NODE(_hw, OID_AUTO, mca, CTLFLAG_RW, NULL, "MCA container");
 
 static int mca_count;		/* Number of records stored. */
 static int mca_first;		/* First (lowest) record ID. */
@@ -69,6 +70,32 @@ SYSCTL_INT(_hw_mca, OID_AUTO, first, CTLFLAG_RD, &mca_first, 0,
 SYSCTL_INT(_hw_mca, OID_AUTO, last, CTLFLAG_RD, &mca_last, 0,
     "Last record id");
 
+static struct mtx mca_sysctl_lock;
+
+static int
+mca_sysctl_inject(SYSCTL_HANDLER_ARGS)
+{
+	struct ia64_pal_result res;
+	u_int val;
+	int error;
+
+	val = 0;
+	error = sysctl_wire_old_buffer(req, sizeof(u_int));
+	if (!error)
+		error = sysctl_handle_int(oidp, &val, 0, req);
+
+	if (error != 0 || req->newptr == NULL)
+		return (error);
+
+	/* For example: val=137 causes a fatal CPU error. */
+	res = ia64_call_pal_stacked(PAL_MC_ERROR_INJECT, val, 0, 0);
+	printf("%s: %#lx, %#lx, %#lx, %#lx\n", __func__, res.pal_status,
+	    res.pal_result[0], res.pal_result[1], res.pal_result[2]);
+	return (0);
+}
+SYSCTL_PROC(_hw_mca, OID_AUTO, inject, CTLTYPE_INT | CTLFLAG_RW, NULL, 0,
+    mca_sysctl_inject, "I", "set to trigger a MCA");
+
 static int
 mca_sysctl_handler(SYSCTL_HANDLER_ARGS)
 {
@@ -85,27 +112,8 @@ mca_sysctl_handler(SYSCTL_HANDLER_ARGS)
 	return (error);
 }
 
-void
-ia64_mca_populate(void)
-{
-	struct mca_info *rec;
-
-	mtx_lock_spin(&mca_info_block_lock);
-	while (!STAILQ_EMPTY(&mca_records)) {
-		rec = STAILQ_FIRST(&mca_records);
-		STAILQ_REMOVE_HEAD(&mca_records, mi_link);
-		mtx_unlock_spin(&mca_info_block_lock);
-		(void)SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_mca),
-		    OID_AUTO, rec->mi_name, CTLTYPE_OPAQUE | CTLFLAG_RD,
-		    rec->mi_record, rec->mi_recsz, mca_sysctl_handler, "S,MCA",
-		    "Error record");
-		mtx_lock_spin(&mca_info_block_lock);
-	}
-	mtx_unlock_spin(&mca_info_block_lock);
-}
-
-void
-ia64_mca_save_state(int type)
+static void
+ia64_mca_collect_state(int type, struct mca_info_list *reclst)
 {
 	struct ia64_sal_result result;
 	struct mca_record_header *hdr;
@@ -123,13 +131,13 @@ ia64_mca_save_state(int type)
 	if (mca_info_block == 0)
 		return;
 
-	mtx_lock_spin(&mca_info_block_lock);
 	while (1) {
+		mtx_lock_spin(&mca_info_block_lock);
 		result = ia64_sal_entry(SAL_GET_STATE_INFO, type, 0,
 		    mca_info_block, 0, 0, 0, 0);
 		if (result.sal_status < 0) {
 			mtx_unlock_spin(&mca_info_block_lock);
-			return;
+			break;
 		}
 
 		hdr = (struct mca_record_header *)mca_info_block;
@@ -142,9 +150,10 @@ ia64_mca_save_state(int type)
 		    M_NOWAIT | M_ZERO);
 		if (rec == NULL)
 			/* XXX: Not sure what to do. */
-			return;
+			break;
 
-		sprintf(rec->mi_name, "%lld", (long long)seqnr);
+		rec->mi_seqnr = seqnr;
+		rec->mi_cpuid = PCPU_GET(cpuid);
 
 		mtx_lock_spin(&mca_info_block_lock);
 
@@ -163,7 +172,6 @@ ia64_mca_save_state(int type)
 			if (seqnr != hdr->rh_seqnr) {
 				mtx_unlock_spin(&mca_info_block_lock);
 				free(rec, M_MCA);
-				mtx_lock_spin(&mca_info_block_lock);
 				continue;
 			}
 		}
@@ -171,23 +179,51 @@ ia64_mca_save_state(int type)
 		rec->mi_recsz = recsz;
 		bcopy((char*)mca_info_block, rec->mi_record, recsz);
 
-		if (mca_count > 0) {
-			if (seqnr < mca_first)
-				mca_first = seqnr;
-			else if (seqnr > mca_last)
-				mca_last = seqnr;
-		} else
-			mca_first = mca_last = seqnr;
-
-		mca_count++;
-		STAILQ_INSERT_TAIL(&mca_records, rec, mi_link);
-
 		/*
 		 * Clear the state so that we get any other records when
 		 * they exist.
 		 */
 		result = ia64_sal_entry(SAL_CLEAR_STATE_INFO, type, 0, 0, 0,
 		    0, 0, 0);
+
+		mtx_unlock_spin(&mca_info_block_lock);
+
+		STAILQ_INSERT_TAIL(reclst, rec, mi_link);
+	}
+}
+
+void
+ia64_mca_save_state(int type)
+{
+	char name[64];
+	struct mca_info_list reclst = STAILQ_HEAD_INITIALIZER(reclst);
+	struct mca_info *rec;
+	struct sysctl_oid *oid;
+
+	ia64_mca_collect_state(type, &reclst);
+
+	STAILQ_FOREACH(rec, &reclst, mi_link) {
+		sprintf(name, "%lu", rec->mi_seqnr);
+		oid = SYSCTL_ADD_NODE(NULL, SYSCTL_STATIC_CHILDREN(_hw_mca),
+		    OID_AUTO, name, CTLFLAG_RW, NULL, name);
+		if (oid == NULL)
+			continue;
+
+		mtx_lock(&mca_sysctl_lock);
+		if (mca_count > 0) {
+			if (rec->mi_seqnr < mca_first)
+				mca_first = rec->mi_seqnr;
+			else if (rec->mi_seqnr > mca_last)
+				mca_last = rec->mi_seqnr;
+		} else
+			mca_first = mca_last = rec->mi_seqnr;
+		mca_count++;
+		mtx_unlock(&mca_sysctl_lock);
+
+		sprintf(name, "%u", rec->mi_cpuid);
+		SYSCTL_ADD_PROC(NULL, SYSCTL_CHILDREN(oid), rec->mi_cpuid,
+		    name, CTLTYPE_OPAQUE | CTLFLAG_RD, rec->mi_record,
+		    rec->mi_recsz, mca_sysctl_handler, "S,MCA", "MCA record");
 	}
 }
 
@@ -237,7 +273,14 @@ ia64_mca_init(void)
 	 * should be rare. On top of that, performance is not an issue when
 	 * dealing with machine checks...
 	 */
-	mtx_init(&mca_info_block_lock, "MCA spin lock", NULL, MTX_SPIN);
+	mtx_init(&mca_info_block_lock, "MCA info lock", NULL, MTX_SPIN);
+
+	/*
+	 * Serialize sysctl operations with a sleep lock. Note that this
+	 * implies that we update the sysctl tree in a context that allows
+	 * sleeping.
+	 */
+	mtx_init(&mca_sysctl_lock, "MCA sysctl lock", NULL, MTX_DEF);
 
 	/*
 	 * Get and save any processor and platfom error records. Note that in
diff --git a/sys/ia64/ia64/mp_machdep.c b/sys/ia64/ia64/mp_machdep.c
index 600803a74b47..05f352ac6061 100644
--- a/sys/ia64/ia64/mp_machdep.c
+++ b/sys/ia64/ia64/mp_machdep.c
@@ -152,13 +152,15 @@ cpu_topo(void)
 static void
 ia64_store_mca_state(void* arg)
 {
-	unsigned int ncpu = (unsigned int)(uintptr_t)arg;
-	struct thread* td;
+	struct pcpu *pc = arg;
+	struct thread *td = curthread;
 
-	/* ia64_mca_save_state() is CPU-sensitive, so bind ourself to our target CPU */
-	td = curthread;
+	/*
+	 * ia64_mca_save_state() is CPU-sensitive, so bind ourself to our
+	 * target CPU.
+	 */
 	thread_lock(td);
-	sched_bind(td, ncpu);
+	sched_bind(td, pc->pc_cpuid);
 	thread_unlock(td);
 
 	/*
@@ -362,8 +364,7 @@ cpu_mp_unleash(void *dummy)
 	SLIST_FOREACH(pc, &cpuhead, pc_allcpu) {
 		cpus++;
 		if (pc->pc_md.awake) {
-			kproc_create(ia64_store_mca_state,
-			    (void*)((uintptr_t)pc->pc_cpuid), NULL, 0, 0,
+			kproc_create(ia64_store_mca_state, pc, NULL, 0, 0,
 			    "mca %u", pc->pc_cpuid);
 			smp_cpus++;
 		}
diff --git a/sys/ia64/include/mca.h b/sys/ia64/include/mca.h
index 94926d169150..e13d2bfb4b59 100644
--- a/sys/ia64/include/mca.h
+++ b/sys/ia64/include/mca.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2002 Marcel Moolenaar
+ * Copyright (c) 2002-2010 Marcel Moolenaar
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -240,7 +240,6 @@ struct mca_pcidev_reg {
 #ifdef _KERNEL
 
 void ia64_mca_init(void);
-void ia64_mca_populate(void);
 void ia64_mca_save_state(int);
 
 #endif /* _KERNEL */
diff --git a/sys/ia64/include/pal.h b/sys/ia64/include/pal.h
index 6cb865d60ed7..7c0e16f725f7 100644
--- a/sys/ia64/include/pal.h
+++ b/sys/ia64/include/pal.h
@@ -54,11 +54,11 @@
 #define PAL_VERSION		20
 #define PAL_MC_CLEAR_LOG	21
 #define PAL_MC_DRAIN		22
+#define	PAL_MC_EXPECTED		23
 #define PAL_MC_DYNAMIC_STATE	24
 #define PAL_MC_ERROR_INFO	25
-#define PAL_MC_EXPECTED		23
+#define	PAL_MC_RESUME		26
 #define PAL_MC_REGISTER_MEM	27
-#define PAL_MC_RESUME		26
 #define PAL_HALT		28
 #define PAL_HALT_LIGHT		29
 #define PAL_COPY_INFO		30
@@ -66,11 +66,16 @@
 #define PAL_PMI_ENTRYPOINT	32
 #define PAL_ENTER_IA_32_ENV	33
 #define PAL_VM_PAGE_SIZE	34
-#define PAL_MEM_FOR_TEST	37
+#define	PAL_TEST_INFO		37
 #define PAL_CACHE_PROT_INFO	38
 #define PAL_REGISTER_INFO	39
-#define PAL_SHUTDOWN		40
 #define PAL_PREFETCH_VISIBILITY	41
+#define	PAL_LOGICAL_TO_PHYSICAL	42
+#define	PAL_CACHE_SHARED_INFO	43
+#define	PAL_PSTATE_INFO		44
+#define	PAL_SHUTDOWN		45
+#define	PAL_GET_HW_POLICY	48
+#define	PAL_SET_HW_POLICY	49
 
 /*
  * Architected stacked calling convention procedures.
@@ -81,6 +86,19 @@
 #define PAL_CACHE_READ		259
 #define PAL_CACHE_WRITE		260
 #define PAL_VM_TR_READ		261
+#define	PAL_GET_PSTATE		262
+#define	PAL_SET_PSTATE		263
+#define	PAL_VP_CREATE		265
+#define	PAL_VP_ENV_INFO		266
+#define	PAL_VP_EXIT_ENV		267
+#define	PAL_VP_INIT_ENV		268
+#define	PAL_VP_REGISTER		269
+#define	PAL_VP_RESTORE		270
+#define	PAL_VP_SAVE		271
+#define	PAL_VP_TERMINATE	272
+#define	PAL_BRAND_INFO		274
+#define	PAL_MC_ERROR_INJECT	276
+#define	PAL_MEMORY_BUFFER	277
 
 /*
  * Default physical address of the Processor Interrupt Block (PIB).
@@ -90,20 +108,19 @@
 
 struct ia64_pal_result {
 	int64_t		pal_status;
-	u_int64_t	pal_result[3];
+	uint64_t	pal_result[3];
 };
 
-extern struct ia64_pal_result
-	ia64_call_pal_static(u_int64_t proc, u_int64_t arg1,
-			     u_int64_t arg2, u_int64_t arg3);
-extern struct ia64_pal_result
-	ia64_call_pal_static_physical(u_int64_t proc, u_int64_t arg1,
-				      u_int64_t arg2, u_int64_t arg3);
-extern struct ia64_pal_result
-	ia64_call_pal_stacked(u_int64_t proc, u_int64_t arg1,
-			      u_int64_t arg2, u_int64_t arg3);
-extern struct ia64_pal_result
-	ia64_call_pal_stacked_physical(u_int64_t proc, u_int64_t arg1,
-				       u_int64_t arg2, u_int64_t arg3);
+struct ia64_pal_result ia64_call_pal_static(uint64_t proc, uint64_t arg1,
+    uint64_t arg2, uint64_t arg3);
+
+struct ia64_pal_result ia64_call_pal_static_physical(uint64_t proc,
+    uint64_t arg1, uint64_t arg2, uint64_t arg3);
+
+struct ia64_pal_result ia64_call_pal_stacked(uint64_t proc, uint64_t arg1,
+    uint64_t arg2, uint64_t arg3);
+
+struct ia64_pal_result ia64_call_pal_stacked_physical(uint64_t proc,
+    uint64_t arg1, uint64_t arg2, uint64_t arg3);
 
 #endif /* _MACHINE_PAL_H_ */
diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c
index f1508c897372..e9090fb077ba 100644
--- a/sys/kern/init_main.c
+++ b/sys/kern/init_main.c
@@ -382,8 +382,9 @@ static void
 proc0_init(void *dummy __unused)
 {
 	struct proc *p;
-	unsigned i;
 	struct thread *td;
+	vm_paddr_t pageablemem;
+	int i;
 
 	GIANT_REQUIRED;
 	p = &proc0;
@@ -493,10 +494,16 @@ proc0_init(void *dummy __unused)
 	    p->p_limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
 	p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_cur =
 	    p->p_limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
-	i = ptoa(cnt.v_free_count);
-	p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = i;
-	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i;
-	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3;
+	p->p_limit->pl_rlimit[RLIMIT_DATA].rlim_cur = dfldsiz;
+	p->p_limit->pl_rlimit[RLIMIT_DATA].rlim_max = maxdsiz;
+	p->p_limit->pl_rlimit[RLIMIT_STACK].rlim_cur = dflssiz;
+	p->p_limit->pl_rlimit[RLIMIT_STACK].rlim_max = maxssiz;
+	/* Cast to avoid overflow on i386/PAE. */
+	pageablemem = ptoa((vm_paddr_t)cnt.v_free_count);
+	p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_cur =
+	    p->p_limit->pl_rlimit[RLIMIT_RSS].rlim_max = pageablemem;
+	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = pageablemem / 3;
+	p->p_limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = pageablemem;
 	p->p_cpulimit = RLIM_INFINITY;
 
 	p->p_stats = pstats_alloc();
@@ -510,9 +517,8 @@ proc0_init(void *dummy __unused)
 	 * proc0 is not expected to enter usermode, so there is no special
 	 * handling for sv_minuser here, like is done for exec_new_vmspace().
 	 */
-	vm_map_init(&vmspace0.vm_map, p->p_sysent->sv_minuser,
-	    p->p_sysent->sv_maxuser);
-	vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0);
+	vm_map_init(&vmspace0.vm_map, vmspace_pmap(&vmspace0),
+	    p->p_sysent->sv_minuser, p->p_sysent->sv_maxuser);
 
 	/*-
 	 * call the init and ctor for the new thread and proc
diff --git a/sys/kern/kern_clock.c b/sys/kern/kern_clock.c
index 2844103fa406..98e276bb34aa 100644
--- a/sys/kern/kern_clock.c
+++ b/sys/kern/kern_clock.c
@@ -162,6 +162,11 @@ SYSCTL_PROC(_kern, OID_AUTO, cp_times, CTLTYPE_LONG|CTLFLAG_RD|CTLFLAG_MPSAFE,
     0,0, sysctl_kern_cp_times, "LU", "per-CPU time statistics");
 
 #ifdef DEADLKRES
+static const char *blessed[] = {
+	"so_snd_sx",
+	"so_rcv_sx",
+	NULL
+};
 static int slptime_threshold = 1800;
 static int blktime_threshold = 900;
 static int sleepfreq = 3;
@@ -172,7 +177,7 @@ deadlkres(void)
 	struct proc *p;
 	struct thread *td;
 	void *wchan;
-	int blkticks, slpticks, slptype, tryl, tticks;
+	int blkticks, i, slpticks, slptype, tryl, tticks;
 
 	tryl = 0;
 	for (;;) {
@@ -205,6 +210,10 @@ deadlkres(void)
 					 * turnstile channel is in good state.
 					 */
 					MPASS(td->td_blocked != NULL);
+
+					/* Handle ticks wrap-up. */
+					if (ticks < td->td_blktick)
+						continue;
 					tticks = ticks - td->td_blktick;
 					thread_unlock(td);
 					if (tticks > blkticks) {
@@ -222,6 +231,10 @@ deadlkres(void)
 					}
 				} else if (TD_IS_SLEEPING(td)) {
 
+					/* Handle ticks wrap-up. */
+					if (ticks < td->td_blktick)
+						continue;
+
 					/*
 					 * Check if the thread is sleeping on a
 					 * lock, otherwise skip the check.
@@ -242,7 +255,24 @@ deadlkres(void)
 						 * thresholds, this thread is
 						 * stuck for too long on a
 						 * sleepqueue.
+						 * However, being on a
+						 * sleepqueue, we might still
+						 * check for the blessed
+						 * list.
 						 */
+						tryl = 0;
+						for (i = 0; blessed[i] != NULL;
+						    i++) {
+							if (!strcmp(blessed[i],
+							    td->td_wmesg)) {
+								tryl = 1;
+								break;
+							}
+						}
+						if (tryl != 0) {
+							tryl = 0;
+							continue;
+						}
 						PROC_UNLOCK(p);
 						sx_sunlock(&allproc_lock);
 	panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
diff --git a/sys/kern/kern_sig.c b/sys/kern/kern_sig.c
index 98a121b12da0..706433d36043 100644
--- a/sys/kern/kern_sig.c
+++ b/sys/kern/kern_sig.c
@@ -2809,6 +2809,7 @@ killproc(p, why)
 		p, p->p_pid, p->p_comm);
 	log(LOG_ERR, "pid %d (%s), uid %d, was killed: %s\n", p->p_pid, p->p_comm,
 		p->p_ucred ? p->p_ucred->cr_uid : -1, why);
+	p->p_flag |= P_WKILLED;
 	psignal(p, SIGKILL);
 }
 
diff --git a/sys/kern/tty_pts.c b/sys/kern/tty_pts.c
index 5cfbc713be52..51f26412d6b8 100644
--- a/sys/kern/tty_pts.c
+++ b/sys/kern/tty_pts.c
@@ -575,6 +575,15 @@ ptsdev_close(struct file *fp, struct thread *td)
 	tty_lock(tp);
 	tty_rel_gone(tp);
 
+	/*
+	 * Open of /dev/ptmx or /dev/ptyXX changes the type of file
+	 * from DTYPE_VNODE to DTYPE_PTS. vn_open() increases vnode
+	 * use count, we need to decrement it, and possibly do other
+	 * required cleanup.
+	 */
+	if (fp->f_vnode != NULL)
+		return (vnops.fo_close(fp, td));
+
 	return (0);
 }
 
diff --git a/sys/kern/vfs_bio.c b/sys/kern/vfs_bio.c
index df9a257af3b2..4e9cfc699575 100644
--- a/sys/kern/vfs_bio.c
+++ b/sys/kern/vfs_bio.c
@@ -2678,7 +2678,7 @@ loop:
 		 */
 		if (flags & GB_NOCREAT)
 			return NULL;
-		bsize = bo->bo_bsize;
+		bsize = vn_isdisk(vp, NULL) ? DEV_BSIZE : bo->bo_bsize;
 		offset = blkno * bsize;
 		vmio = vp->v_object != NULL;
 		maxsize = vmio ? size + (offset & PAGE_MASK) : size;
diff --git a/sys/kern/vfs_default.c b/sys/kern/vfs_default.c
index 50bf0d2be0d2..37881475f89b 100644
--- a/sys/kern/vfs_default.c
+++ b/sys/kern/vfs_default.c
@@ -67,6 +67,7 @@ __FBSDID("$FreeBSD$");
 #include <vm/vnode_pager.h>
 
 static int	vop_nolookup(struct vop_lookup_args *);
+static int	vop_norename(struct vop_rename_args *);
 static int	vop_nostrategy(struct vop_strategy_args *);
 static int	get_next_dirent(struct vnode *vp, struct dirent **dpp,
 				char *dirbuf, int dirbuflen, off_t *off,
@@ -113,6 +114,7 @@ struct vop_vector default_vnodeops = {
 	.vop_poll =		vop_nopoll,
 	.vop_putpages =		vop_stdputpages,
 	.vop_readlink =		VOP_EINVAL,
+	.vop_rename =		vop_norename,
 	.vop_revoke =		VOP_PANIC,
 	.vop_strategy =		vop_nostrategy,
 	.vop_unlock =		vop_stdunlock,
@@ -206,6 +208,20 @@ vop_nolookup(ap)
 }
 
 /*
+ * vop_norename:
+ *
+ * Handle unlock and reference counting for arguments of vop_rename
+ * for filesystems that do not implement rename operation.
+ */
+static int
+vop_norename(struct vop_rename_args *ap)
+{
+
+	vop_rename_fail(ap);
+	return (EOPNOTSUPP);
+}
+
+/*
  *	vop_nostrategy:
  *
  *	Strategy routine for VFS devices that have none.
diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c
index daaa5b1bcce1..4810e769b157 100644
--- a/sys/kern/vfs_subr.c
+++ b/sys/kern/vfs_subr.c
@@ -1378,7 +1378,7 @@ restartsync:
 
 /*
  * buf_splay() - splay tree core for the clean/dirty list of buffers in
- * 		 a vnode.
+ *		 a vnode.
  *
  *	NOTE: We have to deal with the special case of a background bitmap
  *	buffer, a situation where two buffers will have the same logical
@@ -2100,13 +2100,13 @@ vget(struct vnode *vp, int flags, struct thread *td)
 	/* Upgrade our holdcnt to a usecount. */
 	v_upgrade_usecount(vp);
 	/*
- 	 * We don't guarantee that any particular close will
+	 * We don't guarantee that any particular close will
 	 * trigger inactive processing so just make a best effort
 	 * here at preventing a reference to a removed file.  If
 	 * we don't succeed no harm is done.
 	 */
 	if (vp->v_iflag & VI_OWEINACT) {
-		if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE && 
+		if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE &&
 		    (flags & LK_NOWAIT) == 0)
 			vinactive(vp, td);
 		vp->v_iflag &= ~VI_OWEINACT;
@@ -2362,7 +2362,7 @@ SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
 #endif
 
 int
-vflush( struct mount *mp, int rootrefs, int flags, struct thread *td)
+vflush(struct mount *mp, int rootrefs, int flags, struct thread *td)
 {
 	struct vnode *vp, *mvp, *rootvp = NULL;
 	struct vattr vattr;
@@ -2383,12 +2383,10 @@ vflush( struct mount *mp, int rootrefs, int flags, struct thread *td)
 			return (error);
 		}
 		vput(rootvp);
-
 	}
 	MNT_ILOCK(mp);
 loop:
 	MNT_VNODE_FOREACH(vp, mp, mvp) {
-
 		VI_LOCK(vp);
 		vholdl(vp);
 		MNT_IUNLOCK(mp);
@@ -2799,6 +2797,7 @@ DB_SHOW_COMMAND(mount, db_show_mount)
 	MNT_FLAG(MNT_NOATIME);
 	MNT_FLAG(MNT_NOCLUSTERR);
 	MNT_FLAG(MNT_NOCLUSTERW);
+	MNT_FLAG(MNT_NFS4ACLS);
 	MNT_FLAG(MNT_EXRDONLY);
 	MNT_FLAG(MNT_EXPORTED);
 	MNT_FLAG(MNT_DEFEXPORTED);
@@ -2839,14 +2838,18 @@ DB_SHOW_COMMAND(mount, db_show_mount)
 	MNT_KERN_FLAG(MNTK_ASYNC);
 	MNT_KERN_FLAG(MNTK_SOFTDEP);
 	MNT_KERN_FLAG(MNTK_NOINSMNTQ);
+	MNT_KERN_FLAG(MNTK_DRAINING);
+	MNT_KERN_FLAG(MNTK_REFEXPIRE);
+	MNT_KERN_FLAG(MNTK_EXTENDED_SHARED);
+	MNT_KERN_FLAG(MNTK_SHARED_WRITES);
 	MNT_KERN_FLAG(MNTK_UNMOUNT);
 	MNT_KERN_FLAG(MNTK_MWAIT);
 	MNT_KERN_FLAG(MNTK_SUSPEND);
 	MNT_KERN_FLAG(MNTK_SUSPEND2);
 	MNT_KERN_FLAG(MNTK_SUSPENDED);
 	MNT_KERN_FLAG(MNTK_MPSAFE);
-	MNT_KERN_FLAG(MNTK_NOKNOTE);
 	MNT_KERN_FLAG(MNTK_LOOKUP_SHARED);
+	MNT_KERN_FLAG(MNTK_NOKNOTE);
 #undef MNT_KERN_FLAG
 	if (flags != 0) {
 		if (buf[0] != '\0')
@@ -3526,7 +3529,7 @@ vaccess(enum vtype type, mode_t file_mode, uid_t file_uid, gid_t file_gid,
 	KASSERT((accmode & ~(VEXEC | VWRITE | VREAD | VADMIN | VAPPEND)) == 0,
 	    ("invalid bit in accmode"));
 	KASSERT((accmode & VAPPEND) == 0 || (accmode & VWRITE),
-	    	("VAPPEND without VWRITE"));
+	    ("VAPPEND without VWRITE"));
 
 	/*
 	 * Look for a normal, non-privileged way to access the file/directory
@@ -3751,6 +3754,20 @@ assert_vop_slocked(struct vnode *vp, const char *str)
 #endif /* DEBUG_VFS_LOCKS */
 
 void
+vop_rename_fail(struct vop_rename_args *ap)
+{
+
+	if (ap->a_tvp != NULL)
+		vput(ap->a_tvp);
+	if (ap->a_tdvp == ap->a_tvp)
+		vrele(ap->a_tdvp);
+	else
+		vput(ap->a_tdvp);
+	vrele(ap->a_fdvp);
+	vrele(ap->a_fvp);
+}
+
+void
 vop_rename_pre(void *ap)
 {
 	struct vop_rename_args *a = ap;
diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index c329adc9480c..ab0627d7bf22 100644
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -1047,8 +1047,6 @@ kern_openat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
 	struct filedesc *fdp = p->p_fd;
 	struct file *fp;
 	struct vnode *vp;
-	struct vattr vat;
-	struct mount *mp;
 	int cmode;
 	struct file *nfp;
 	int type, indx, error;
@@ -1124,7 +1122,12 @@ kern_openat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
 	NDFREE(&nd, NDF_ONLY_PNBUF);
 	vp = nd.ni_vp;
 
-	fp->f_vnode = vp;	/* XXX Does devfs need this? */
+	/*
+	 * Store the vnode, for any f_type. Typically, the vnode use
+	 * count is decremented by direct call to vn_closefile() for
+	 * files that switched type in the cdevsw fdopen() method.
+	 */
+	fp->f_vnode = vp;
 	/*
 	 * If the file wasn't claimed by devfs bind it to the normal
 	 * vnode operations here.
@@ -1136,7 +1139,7 @@ kern_openat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
 	}
 
 	VOP_UNLOCK(vp, 0);
-	if (flags & (O_EXLOCK | O_SHLOCK)) {
+	if (fp->f_type == DTYPE_VNODE && (flags & (O_EXLOCK | O_SHLOCK)) != 0) {
 		lf.l_whence = SEEK_SET;
 		lf.l_start = 0;
 		lf.l_len = 0;
@@ -1153,18 +1156,7 @@ kern_openat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
 		atomic_set_int(&fp->f_flag, FHASLOCK);
 	}
 	if (flags & O_TRUNC) {
-		if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
-			goto bad;
-		VATTR_NULL(&vat);
-		vat.va_size = 0;
-		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
-#ifdef MAC
-		error = mac_vnode_check_write(td->td_ucred, fp->f_cred, vp);
-		if (error == 0)
-#endif
-			error = VOP_SETATTR(vp, &vat, td->td_ucred);
-		VOP_UNLOCK(vp, 0);
-		vn_finished_write(mp);
+		error = fo_truncate(fp, 0, td->td_ucred, td);
 		if (error)
 			goto bad;
 	}
diff --git a/sys/kern/vfs_vnops.c b/sys/kern/vfs_vnops.c
index 74e6c0221fbe..838f8f7be318 100644
--- a/sys/kern/vfs_vnops.c
+++ b/sys/kern/vfs_vnops.c
@@ -792,11 +792,10 @@ vn_stat(vp, sb, active_cred, file_cred, td)
 	 *   "a filesystem-specific preferred I/O block size for this 
 	 *    object.  In some filesystem types, this may vary from file
 	 *    to file"
-	 * Default to PAGE_SIZE after much discussion.
-	 * XXX: min(PAGE_SIZE, vp->v_bufobj.bo_bsize) may be more correct.
+	 * Use miminum/default of PAGE_SIZE (e.g. for VCHR).
 	 */
 
-	sb->st_blksize = PAGE_SIZE;
+	sb->st_blksize = max(PAGE_SIZE, vap->va_blocksize);
 	
 	sb->st_flags = vap->va_flags;
 	if (priv_check(td, PRIV_VFS_GENERATION))
diff --git a/sys/libkern/iconv.c b/sys/libkern/iconv.c
index 7e0d2c05eedb..7700937270e2 100644
--- a/sys/libkern/iconv.c
+++ b/sys/libkern/iconv.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/libkern/iconv_converter_if.m b/sys/libkern/iconv_converter_if.m
index 63e16679d48c..592fa1372903 100644
--- a/sys/libkern/iconv_converter_if.m
+++ b/sys/libkern/iconv_converter_if.m
@@ -1,5 +1,5 @@
 #-
-# Copyright (c) 2000-2001, Boris Popov
+# Copyright (c) 2000-2001 Boris Popov
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
 # 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. All advertising materials mentioning features or use of this software
-#    must display the following acknowledgement:
-#    This product includes software developed by Boris Popov.
-# 4. Neither the name of the author nor the names of any co-contributors
-#    may be used to endorse or promote products derived from this software
-#    without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/libkern/iconv_xlat.c b/sys/libkern/iconv_xlat.c
index 8ab4d6c2b3be..c5c2dfd4cd76 100644
--- a/sys/libkern/iconv_xlat.c
+++ b/sys/libkern/iconv_xlat.c
@@ -1,5 +1,5 @@
-/*
- * Copyright (c) 2000-2001, Boris Popov
+/*-
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/libkern/strcasecmp.c b/sys/libkern/strcasecmp.c
index a0586549ff56..a7bba221d02d 100644
--- a/sys/libkern/strcasecmp.c
+++ b/sys/libkern/strcasecmp.c
@@ -1,4 +1,4 @@
-/*
+/*-
  * Copyright (c) 1987, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
diff --git a/sys/mips/atheros/if_arge.c b/sys/mips/atheros/if_arge.c
index da8d181de088..4367bfb001d6 100644
--- a/sys/mips/atheros/if_arge.c
+++ b/sys/mips/atheros/if_arge.c
@@ -171,7 +171,7 @@ extern uint32_t ar711_base_mac[ETHER_ADDR_LEN];
 
 static struct mtx miibus_mtx;
 
-MTX_SYSINIT(miibus_mtx, &miibus_mtx, "arge mii lock", MTX_SPIN);
+MTX_SYSINIT(miibus_mtx, &miibus_mtx, "arge mii lock", MTX_DEF);
 
 
 /*
diff --git a/sys/mips/include/bus.h b/sys/mips/include/bus.h
index ccaeb34b186d..2ab347b4b9c6 100644
--- a/sys/mips/include/bus.h
+++ b/sys/mips/include/bus.h
@@ -713,6 +713,8 @@ void	__bs_c(f,_bs_c_8) (void *t, bus_space_handle_t bsh1,	\
 #define BUS_SPACE_MAXSIZE_32BIT	0xFFFFFFFF
 #define BUS_SPACE_MAXSIZE 	0xFFFFFFFF
 
+#define BUS_SPACE_UNRESTRICTED	(~0)
+
 /* 
  * declare generic bus space, it suits all needs in 
  */
diff --git a/sys/mips/mips/busdma_machdep.c b/sys/mips/mips/busdma_machdep.c
index f2d41dfaad43..a6a7419747cd 100644
--- a/sys/mips/mips/busdma_machdep.c
+++ b/sys/mips/mips/busdma_machdep.c
@@ -687,16 +687,21 @@ _bus_dmamap_count_pages(bus_dma_tag_t dmat, bus_dmamap_t map, pmap_t pmap,
 		 * Count the number of bounce pages
 		 * needed in order to complete this transfer
 		 */
-		vaddr = trunc_page((vm_offset_t)buf);
+		vaddr = (vm_offset_t)buf;
 		vendaddr = (vm_offset_t)buf + buflen;
 
 		while (vaddr < vendaddr) {
+			bus_size_t sg_len;
+
 			KASSERT(kernel_pmap == pmap, ("pmap is not kernel pmap"));
+			sg_len = PAGE_SIZE - ((vm_offset_t)vaddr & PAGE_MASK);
 			paddr = pmap_kextract(vaddr);
 			if (((dmat->flags & BUS_DMA_COULD_BOUNCE) != 0) &&
-			    run_filter(dmat, paddr) != 0)
+			    run_filter(dmat, paddr) != 0) {
+				sg_len = roundup2(sg_len, dmat->alignment);
 				map->pagesneeded++;
-			vaddr += PAGE_SIZE;
+			}
+			vaddr += sg_len;
 		}
 		CTR1(KTR_BUSDMA, "pagesneeded= %d\n", map->pagesneeded);
 	}
diff --git a/sys/modules/Makefile b/sys/modules/Makefile
index 246b90849b7f..3af154c750b3 100644
--- a/sys/modules/Makefile
+++ b/sys/modules/Makefile
@@ -35,15 +35,15 @@ SUBDIR=	${_3dfx} \
 	ata \
 	ath \
 	${_auxio} \
-	${_bce} \
+	bce \
 	bfe \
 	bge \
 	${_bios} \
 	${_bktr} \
 	${_bm} \
 	bridgestp \
-	${_bwi} \
-	${_bwn} \
+	bwi \
+	bwn \
 	cam \
 	${_canbepm} \
 	${_canbus} \
@@ -176,13 +176,13 @@ SUBDIR=	${_3dfx} \
 	mcd \
 	md \
 	mem \
-	${_mfi} \
+	mfi \
 	mii \
 	mlx \
 	${_mly} \
 	mmc \
 	mmcsd \
-	${_mpt} \
+	mpt \
 	mqueue \
 	msdosfs \
 	msdosfs_iconv \
@@ -252,7 +252,7 @@ SUBDIR=	${_3dfx} \
 	sdhci \
 	sem \
 	sf \
-	${_siba_bwn} \
+	siba_bwn \
 	siis \
 	sis \
 	sk \
@@ -280,7 +280,7 @@ SUBDIR=	${_3dfx} \
 	twe \
 	tx \
 	txp \
-	${_uart} \
+	uart \
 	ubsec \
 	udf \
 	udf_iconv \
@@ -321,16 +321,8 @@ _vpo=		vpo
 
 .if ${MACHINE_ARCH} != "arm" && ${MACHINE_ARCH} != "mips"
 # no BUS_SPACE_UNSPECIFIED
-_bce=		bce
-_bwi=		bwi
-_bwn=		bwn
-_mfi=		mfi
-_mpt=		mpt
-_siba_bwn=	siba_bwn
 # No barrier instruction support (specific to this driver)
 _sym=		sym
-# no uart_cpu_$MACHINE_ARCH
-_uart=		uart
 # intr_disable() is a macro, causes problems
 _cxgb=		cxgb
 .endif
diff --git a/sys/modules/dummynet/Makefile b/sys/modules/dummynet/Makefile
index a8813e277d12..dd96e0eb62b8 100644
--- a/sys/modules/dummynet/Makefile
+++ b/sys/modules/dummynet/Makefile
@@ -7,6 +7,7 @@ KMOD=   dummynet
 SRCS=   ip_dummynet.c
 SRCS+= ip_dn_glue.c ip_dn_io.c
 SRCS+= dn_heap.c dn_sched_fifo.c dn_sched_qfq.c dn_sched_rr.c dn_sched_wf2q.c 
+SRCS+= dn_sched_prio.c
 SRCS+=	opt_inet6.h
 
 .if !defined(KERNBUILDDIR)
diff --git a/sys/modules/geom/Makefile b/sys/modules/geom/Makefile
index abce379c7391..0b2e3e8b6220 100644
--- a/sys/modules/geom/Makefile
+++ b/sys/modules/geom/Makefile
@@ -19,6 +19,7 @@ SUBDIR=	geom_bde \
 	geom_part \
 	geom_pc98 \
 	geom_raid3 \
+	geom_sched \
 	geom_shsec \
 	geom_stripe \
 	geom_sunlabel \
diff --git a/sys/modules/geom/geom_sched/Makefile b/sys/modules/geom/geom_sched/Makefile
new file mode 100644
index 000000000000..5937fa04d9c8
--- /dev/null
+++ b/sys/modules/geom/geom_sched/Makefile
@@ -0,0 +1,5 @@
+# $FreeBSD$
+
+SUBDIR=	gs_sched gsched_rr
+
+.include <bsd.subdir.mk>
diff --git a/sys/modules/geom/geom_sched/Makefile.inc b/sys/modules/geom/geom_sched/Makefile.inc
new file mode 100644
index 000000000000..808d6eba89a0
--- /dev/null
+++ b/sys/modules/geom/geom_sched/Makefile.inc
@@ -0,0 +1,9 @@
+# $FreeBSD$
+# included by geom_sched children
+
+.PATH: ${.CURDIR}/../../../../geom/sched
+
+# 6.x needs this path
+#CFLAGS += -I${.CURDIR}/../../../../geom/sched
+
+# .include <bsd.kmod.mk>
diff --git a/sys/modules/geom/geom_sched/gs_sched/Makefile b/sys/modules/geom/geom_sched/gs_sched/Makefile
new file mode 100644
index 000000000000..5739365a3807
--- /dev/null
+++ b/sys/modules/geom/geom_sched/gs_sched/Makefile
@@ -0,0 +1,6 @@
+# $FreeBSD$
+KMOD=   geom_sched
+SRCS=   g_sched.c subr_disk.c
+
+# ../Makefile.inc automatically included
+.include <bsd.kmod.mk>
diff --git a/sys/modules/geom/geom_sched/gsched_rr/Makefile b/sys/modules/geom/geom_sched/gsched_rr/Makefile
new file mode 100644
index 000000000000..42092771f8c3
--- /dev/null
+++ b/sys/modules/geom/geom_sched/gsched_rr/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+KMOD=   gsched_rr
+SRCS=   gs_rr.c
+# hash.h on 6.x has a (char *) cast on a const pointer
+#CWARNFLAGS=
+
+# ../Makefile.inc automatically included
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hwpmc/Makefile b/sys/modules/hwpmc/Makefile
index 0a696a12e081..1febf5489438 100644
--- a/sys/modules/hwpmc/Makefile
+++ b/sys/modules/hwpmc/Makefile
@@ -10,7 +10,7 @@ SRCS=	hwpmc_mod.c hwpmc_logging.c vnode_if.h
 
 .if ${MACHINE_ARCH} == "amd64"
 SRCS+=	hwpmc_amd.c hwpmc_core.c hwpmc_intel.c hwpmc_piv.c hwpmc_tsc.c
-SRCS+=	hwpmc_x86.c
+SRCS+=	hwpmc_x86.c hwpmc_uncore.c
 SRCS+=	device_if.h bus_if.h
 .endif
 
@@ -20,7 +20,7 @@ SRCS+=	hwpmc_arm.c
 
 .if ${MACHINE_ARCH} == "i386"
 SRCS+=	hwpmc_amd.c hwpmc_core.c hwpmc_intel.c hwpmc_piv.c hwpmc_ppro.c
-SRCS+=	hwpmc_pentium.c hwpmc_tsc.c hwpmc_x86.c
+SRCS+=	hwpmc_pentium.c hwpmc_tsc.c hwpmc_x86.c hwpmc_uncore.c
 SRCS+=	device_if.h bus_if.h
 .endif
 
diff --git a/sys/modules/iwnfw/iwn6000/Makefile b/sys/modules/iwnfw/iwn6000/Makefile
index c0295a92cf16..2d2cc3fe1c4c 100644
--- a/sys/modules/iwnfw/iwn6000/Makefile
+++ b/sys/modules/iwnfw/iwn6000/Makefile
@@ -1,6 +1,6 @@
 # $FreeBSD$
 
 KMOD=	iwn6000fw
-IMG=	iwlwifi-6000-9.176.4.1
+IMG=	iwlwifi-6000-9.193.4.1
 
 .include <bsd.kmod.mk>
diff --git a/sys/modules/syscons/Makefile b/sys/modules/syscons/Makefile
index 71e84d040613..13cbc57f0007 100644
--- a/sys/modules/syscons/Makefile
+++ b/sys/modules/syscons/Makefile
@@ -1,6 +1,7 @@
 # $FreeBSD$
 
 SUBDIR=	${_apm} \
+	${_beastie} \
 	blank \
 	${_daemon} \
 	${_dragon} \
@@ -18,6 +19,7 @@ _apm=		apm
 .endif
 
 .if ${MACHINE_ARCH} != "sparc64"
+_beastie=	beastie
 _daemon=	daemon
 _dragon=	dragon
 _fire=		fire
diff --git a/sys/modules/syscons/beastie/Makefile b/sys/modules/syscons/beastie/Makefile
new file mode 100644
index 000000000000..4f0865bd96e4
--- /dev/null
+++ b/sys/modules/syscons/beastie/Makefile
@@ -0,0 +1,10 @@
+# $FreeBSD$
+
+.PATH:	${.CURDIR}/../../../dev/syscons/logo
+
+KMOD=	beastie_saver
+SRCS=	beastie.c logo_saver.c
+
+CFLAGS+=-DBEASTIE_LOGO
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/uart/Makefile b/sys/modules/uart/Makefile
index d47e2abed529..06b3c9bd01dd 100644
--- a/sys/modules/uart/Makefile
+++ b/sys/modules/uart/Makefile
@@ -16,7 +16,7 @@ SRCS=	uart_bus_acpi.c ${uart_bus_ebus} uart_bus_isa.c uart_bus_pccard.c \
 	uart_if.c uart_if.h uart_subr.c uart_tty.c
 .if ${MACHINE} == "sun4v"
 SRCS+=	uart_cpu_sparc64.c
-.else
+.elif exists(${CURDIR}/uart_cpu_${MACHINE}.c)
 SRCS+=	uart_cpu_${MACHINE}.c
 .endif
 SRCS+=	bus_if.h card_if.h device_if.h isa_if.h ${ofw_bus_if} pci_if.h \
diff --git a/sys/modules/wlan/Makefile b/sys/modules/wlan/Makefile
index 07233c693ebb..79d5e75afad2 100644
--- a/sys/modules/wlan/Makefile
+++ b/sys/modules/wlan/Makefile
@@ -3,12 +3,13 @@
 .PATH: ${.CURDIR}/../../net80211
 
 KMOD=	wlan
-SRCS=	ieee80211.c ieee80211_action.c ieee80211_ageq.c \
+SRCS=	ieee80211.c ieee80211_action.c ieee80211_ageq.c ieee80211_amrr.c \
 	ieee80211_crypto.c ieee80211_crypto_none.c ieee80211_dfs.c \
 	ieee80211_freebsd.c ieee80211_input.c ieee80211_ioctl.c \
 	ieee80211_mesh.c ieee80211_node.c ieee80211_output.c ieee80211_phy.c \
 	ieee80211_power.c ieee80211_proto.c ieee80211_scan.c \
-	ieee80211_scan_sta.c ieee80211_radiotap.c ieee80211_regdomain.c \
+	ieee80211_scan_sta.c ieee80211_radiotap.c ieee80211_ratectl.c \
+	ieee80211_regdomain.c ieee80211_rssadapt.c \
 	ieee80211_ht.c ieee80211_hwmp.c ieee80211_adhoc.c ieee80211_hostap.c \
 	ieee80211_monitor.c ieee80211_sta.c ieee80211_wds.c ieee80211_ddb.c
 SRCS+=	bus_if.h device_if.h opt_inet.h opt_inet6.h opt_ipx.h opt_wlan.h \
diff --git a/sys/net/if.c b/sys/net/if.c
index 38b1d5013eb9..e4a200549636 100644
--- a/sys/net/if.c
+++ b/sys/net/if.c
@@ -897,14 +897,20 @@ if_detach_internal(struct ifnet *ifp, int vmove)
 		devctl_notify("IFNET", ifp->if_xname, "DETACH", NULL);
 	if_delgroups(ifp);
 
+	/*
+	 * We cannot hold the lock over dom_ifdetach calls as they might
+	 * sleep, for example trying to drain a callout, thus open up the
+	 * theoretical race with re-attaching.
+	 */
 	IF_AFDATA_LOCK(ifp);
-	for (dp = domains; dp; dp = dp->dom_next) {
+	i = ifp->if_afdata_initialized;
+	ifp->if_afdata_initialized = 0;
+	IF_AFDATA_UNLOCK(ifp);
+	for (dp = domains; i > 0 && dp; dp = dp->dom_next) {
 		if (dp->dom_ifdetach && ifp->if_afdata[dp->dom_family])
 			(*dp->dom_ifdetach)(ifp,
 			    ifp->if_afdata[dp->dom_family]);
 	}
-	ifp->if_afdata_initialized = 0;
-	IF_AFDATA_UNLOCK(ifp);
 }
 
 #ifdef VIMAGE
diff --git a/sys/net/if_clone.c b/sys/net/if_clone.c
index 0dd20fb36108..c02737bd4637 100644
--- a/sys/net/if_clone.c
+++ b/sys/net/if_clone.c
@@ -196,10 +196,11 @@ if_clone_createif(struct if_clone *ifc, char *name, size_t len, caddr_t params)
 int
 if_clone_destroy(const char *name)
 {
+	int err;
 	struct if_clone *ifc;
 	struct ifnet *ifp;
 
-	ifp = ifunit(name);
+	ifp = ifunit_ref(name);
 	if (ifp == NULL)
 		return (ENXIO);
 
@@ -221,10 +222,14 @@ if_clone_destroy(const char *name)
 	}
 #endif
 	IF_CLONERS_UNLOCK();
-	if (ifc == NULL)
+	if (ifc == NULL) {
+		if_rele(ifp);
 		return (EINVAL);
+	}
 
-	return (if_clone_destroyif(ifc, ifp));
+	err = if_clone_destroyif(ifc, ifp);
+	if_rele(ifp);
+	return err;
 }
 
 /*
@@ -234,6 +239,7 @@ int
 if_clone_destroyif(struct if_clone *ifc, struct ifnet *ifp)
 {
 	int err;
+	struct ifnet *ifcifp;
 
 	if (ifc->ifc_destroy == NULL)
 		return(EOPNOTSUPP);
@@ -246,8 +252,17 @@ if_clone_destroyif(struct if_clone *ifc, struct ifnet *ifp)
 	CURVNET_SET_QUIET(ifp->if_vnet);
 
 	IF_CLONE_LOCK(ifc);
-	IFC_IFLIST_REMOVE(ifc, ifp);
+	LIST_FOREACH(ifcifp, &ifc->ifc_iflist, if_clones) {
+		if (ifcifp == ifp) {
+			IFC_IFLIST_REMOVE(ifc, ifp);
+			break;
+		}
+	}
 	IF_CLONE_UNLOCK(ifc);
+	if (ifcifp == NULL) {
+		CURVNET_RESTORE();
+		return (ENXIO);		/* ifp is not on the list. */
+	}
 
 	if_delgroup(ifp, ifc->ifc_name);
 
diff --git a/sys/net/if_llatbl.c b/sys/net/if_llatbl.c
index f934af5d6755..c9b41f9bd376 100644
--- a/sys/net/if_llatbl.c
+++ b/sys/net/if_llatbl.c
@@ -170,9 +170,12 @@ lltable_free(struct lltable *llt)
 
 	for (i=0; i < LLTBL_HASHTBL_SIZE; i++) {
 		LIST_FOREACH_SAFE(lle, &llt->lle_head[i], lle_next, next) {
+			int canceled;
 
-			callout_drain(&lle->la_timer);
+			canceled = callout_drain(&lle->la_timer);
 			LLE_WLOCK(lle);
+			if (canceled)
+				LLE_REMREF(lle);
 			llentry_free(lle);
 		}
 	}
diff --git a/sys/net80211/ieee80211.c b/sys/net80211/ieee80211.c
index 8a50bc02076e..3d5669caec58 100644
--- a/sys/net80211/ieee80211.c
+++ b/sys/net80211/ieee80211.c
@@ -49,6 +49,7 @@ __FBSDID("$FreeBSD$");
 #ifdef IEEE80211_SUPPORT_SUPERG
 #include <net80211/ieee80211_superg.h>
 #endif
+#include <net80211/ieee80211_ratectl.h>
 
 #include <net/bpf.h>
 
@@ -486,6 +487,8 @@ ieee80211_vap_setup(struct ieee80211com *ic, struct ieee80211vap *vap,
 	ieee80211_regdomain_vattach(vap);
 	ieee80211_radiotap_vattach(vap);
 
+	ieee80211_ratectl_set(vap, IEEE80211_RATECTL_AMRR);
+
 	return 0;
 }
 
diff --git a/sys/net80211/ieee80211_amrr.c b/sys/net80211/ieee80211_amrr.c
index a759e64b8125..611105869999 100644
--- a/sys/net80211/ieee80211_amrr.c
+++ b/sys/net80211/ieee80211_amrr.c
@@ -1,6 +1,7 @@
 /*	$OpenBSD: ieee80211_amrr.c,v 1.1 2006/06/17 19:07:19 damien Exp $	*/
 
 /*-
+ * Copyright (c) 2010 Rui Paulo <rpaulo@FreeBSD.org>
  * Copyright (c) 2006
  *	Damien Bergamini <damien.bergamini@free.fr>
  *
@@ -46,6 +47,7 @@ __FBSDID("$FreeBSD$");
 
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_amrr.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #define is_success(amn)	\
 	((amn)->amn_retrycnt < (amn)->amn_txcnt / 10)
@@ -54,15 +56,45 @@ __FBSDID("$FreeBSD$");
 #define is_enough(amn)		\
 	((amn)->amn_txcnt > 10)
 
-static void amrr_sysctlattach(struct ieee80211_amrr *amrr,
-	struct sysctl_ctx_list *ctx, struct sysctl_oid *tree);
+static void	amrr_setinterval(const struct ieee80211vap *, int);
+static void	amrr_init(struct ieee80211vap *);
+static void	amrr_deinit(struct ieee80211vap *);
+static void	amrr_node_init(struct ieee80211_node *);
+static void	amrr_node_deinit(struct ieee80211_node *);
+static int	amrr_update(struct ieee80211_amrr *,
+    			struct ieee80211_amrr_node *, struct ieee80211_node *);
+static int	amrr_rate(struct ieee80211_node *, void *, uint32_t);
+static void	amrr_tx_complete(const struct ieee80211vap *,
+    			const struct ieee80211_node *, int, 
+			void *, void *);
+static void	amrr_tx_update(const struct ieee80211vap *vap,
+			const struct ieee80211_node *, void *, void *, void *);
+static void	amrr_sysctlattach(struct ieee80211vap *,
+			struct sysctl_ctx_list *, struct sysctl_oid *);
 
 /* number of references from net80211 layer */
 static	int nrefs = 0;
 
-void
-ieee80211_amrr_setinterval(struct ieee80211_amrr *amrr, int msecs)
+static const struct ieee80211_ratectl amrr = {
+	.ir_name	= "amrr",
+	.ir_attach	= NULL,
+	.ir_detach	= NULL,
+	.ir_init	= amrr_init,
+	.ir_deinit	= amrr_deinit,
+	.ir_node_init	= amrr_node_init,
+	.ir_node_deinit	= amrr_node_deinit,
+	.ir_rate	= amrr_rate,
+	.ir_tx_complete	= amrr_tx_complete,
+	.ir_tx_update	= amrr_tx_update,
+	.ir_setinterval	= amrr_setinterval,
+};
+IEEE80211_RATECTL_MODULE(amrr, 1);
+IEEE80211_RATECTL_ALG(amrr, IEEE80211_RATECTL_AMRR, amrr);
+
+static void
+amrr_setinterval(const struct ieee80211vap *vap, int msecs)
 {
+	struct ieee80211_amrr *amrr = vap->iv_rs;
 	int t;
 
 	if (msecs < 100)
@@ -71,29 +103,49 @@ ieee80211_amrr_setinterval(struct ieee80211_amrr *amrr, int msecs)
 	amrr->amrr_interval = (t < 1) ? 1 : t;
 }
 
-void
-ieee80211_amrr_init(struct ieee80211_amrr *amrr,
-    struct ieee80211vap *vap, int amin, int amax, int interval)
+static void
+amrr_init(struct ieee80211vap *vap)
 {
-	/* XXX bounds check? */
-	amrr->amrr_min_success_threshold = amin;
-	amrr->amrr_max_success_threshold = amax;
-	ieee80211_amrr_setinterval(amrr, interval);
+	struct ieee80211_amrr *amrr;
+
+	KASSERT(vap->iv_rs == NULL, ("%s called multiple times", __func__));
 
-	amrr_sysctlattach(amrr, vap->iv_sysctl, vap->iv_oid);
+	amrr = vap->iv_rs = malloc(sizeof(struct ieee80211_amrr),
+	    M_80211_RATECTL, M_NOWAIT|M_ZERO);
+	if (amrr == NULL) {
+		if_printf(vap->iv_ifp, "couldn't alloc ratectl structure\n");
+		return;
+	}
+	amrr->amrr_min_success_threshold = IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD;
+	amrr->amrr_max_success_threshold = IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD;
+	amrr_setinterval(vap, 500 /* ms */);
+	amrr_sysctlattach(vap, vap->iv_sysctl, vap->iv_oid);
 }
 
-void
-ieee80211_amrr_cleanup(struct ieee80211_amrr *amrr)
+static void
+amrr_deinit(struct ieee80211vap *vap)
 {
+	free(vap->iv_rs, M_80211_RATECTL);
 }
 
-void
-ieee80211_amrr_node_init(struct ieee80211_amrr *amrr,
-    struct ieee80211_amrr_node *amn, struct ieee80211_node *ni)
+static void
+amrr_node_init(struct ieee80211_node *ni)
 {
 	const struct ieee80211_rateset *rs = &ni->ni_rates;
+	struct ieee80211vap *vap = ni->ni_vap;
+	struct ieee80211_amrr *amrr = vap->iv_rs;
+	struct ieee80211_amrr_node *amn;
+
+	KASSERT(ni->ni_rctls == NULL, ("%s: ni_rctls already initialized",
+	    __func__));
 
+	ni->ni_rctls = amn = malloc(sizeof(struct ieee80211_amrr_node),
+	    M_80211_RATECTL, M_NOWAIT|M_ZERO);
+	if (amn == NULL) {
+		if_printf(vap->iv_ifp, "couldn't alloc per-node ratectl "
+		    "structure\n");
+		return;
+	}
 	amn->amn_amrr = amrr;
 	amn->amn_success = 0;
 	amn->amn_recovery = 0;
@@ -112,6 +164,12 @@ ieee80211_amrr_node_init(struct ieee80211_amrr *amrr,
 	    "AMRR initial rate %d", ni->ni_txrate);
 }
 
+static void
+amrr_node_deinit(struct ieee80211_node *ni)
+{
+	free(ni->ni_rctls, M_80211_RATECTL);
+}
+
 static int
 amrr_update(struct ieee80211_amrr *amrr, struct ieee80211_amrr_node *amn,
     struct ieee80211_node *ni)
@@ -168,10 +226,10 @@ amrr_update(struct ieee80211_amrr *amrr, struct ieee80211_amrr_node *amn,
  * Update our internal state if it's been long enough.
  * If the rate changes we also update ni_txrate to match.
  */
-int
-ieee80211_amrr_choose(struct ieee80211_node *ni,
-    struct ieee80211_amrr_node *amn)
+static int
+amrr_rate(struct ieee80211_node *ni, void *arg __unused, uint32_t iarg __unused)
 {
+	struct ieee80211_amrr_node *amn = ni->ni_rctls;
 	struct ieee80211_amrr *amrr = amn->amn_amrr;
 	int rix;
 
@@ -189,27 +247,65 @@ ieee80211_amrr_choose(struct ieee80211_node *ni,
 	return rix;
 }
 
+/*
+ * Update statistics with tx complete status.  Ok is non-zero
+ * if the packet is known to be ACK'd.  Retries has the number
+ * retransmissions (i.e. xmit attempts - 1).
+ */
+static void
+amrr_tx_complete(const struct ieee80211vap *vap,
+    const struct ieee80211_node *ni, int ok,
+    void *arg1, void *arg2 __unused)
+{
+	struct ieee80211_amrr_node *amn = ni->ni_rctls;
+	int retries = *(int *)arg1;
+
+	amn->amn_txcnt++;
+	if (ok)
+		amn->amn_success++;
+	amn->amn_retrycnt += retries;
+}
+
+/*
+ * Set tx count/retry statistics explicitly.  Intended for
+ * drivers that poll the device for statistics maintained
+ * in the device.
+ */
+static void
+amrr_tx_update(const struct ieee80211vap *vap, const struct ieee80211_node *ni,
+    void *arg1, void *arg2, void *arg3)
+{
+	struct ieee80211_amrr_node *amn = ni->ni_rctls;
+	int txcnt = *(int *)arg1, success = *(int *)arg2, retrycnt = *(int *)arg3;
+
+	amn->amn_txcnt = txcnt;
+	amn->amn_success = success;
+	amn->amn_retrycnt = retrycnt;
+}
+
 static int
 amrr_sysctl_interval(SYSCTL_HANDLER_ARGS)
 {
-	struct ieee80211_amrr *amrr = arg1;
+	struct ieee80211vap *vap = arg1;
+	struct ieee80211_amrr *amrr = vap->iv_rs;
 	int msecs = ticks_to_msecs(amrr->amrr_interval);
 	int error;
 
 	error = sysctl_handle_int(oidp, &msecs, 0, req);
 	if (error || !req->newptr)
 		return error;
-	ieee80211_amrr_setinterval(amrr, msecs);
+	amrr_setinterval(vap, msecs);
 	return 0;
 }
 
 static void
-amrr_sysctlattach(struct ieee80211_amrr *amrr,
+amrr_sysctlattach(struct ieee80211vap *vap,
     struct sysctl_ctx_list *ctx, struct sysctl_oid *tree)
 {
+	struct ieee80211_amrr *amrr = vap->iv_rs;
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "amrr_rate_interval", CTLTYPE_INT | CTLFLAG_RW, amrr,
+	    "amrr_rate_interval", CTLTYPE_INT | CTLFLAG_RW, vap,
 	    0, amrr_sysctl_interval, "I", "amrr operation interval (ms)");
 	/* XXX bounds check values */
 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
@@ -219,8 +315,3 @@ amrr_sysctlattach(struct ieee80211_amrr *amrr,
 	    "amrr_min_sucess_threshold", CTLFLAG_RW,
 	    &amrr->amrr_min_success_threshold, 0, "");
 }
-
-/*
- * Module glue.
- */
-IEEE80211_RATE_MODULE(amrr, 1);
diff --git a/sys/net80211/ieee80211_amrr.h b/sys/net80211/ieee80211_amrr.h
index c03f69978c2b..ec67bdfb8751 100644
--- a/sys/net80211/ieee80211_amrr.h
+++ b/sys/net80211/ieee80211_amrr.h
@@ -58,44 +58,4 @@ struct ieee80211_amrr_node {
 	u_int	amn_retrycnt;
 };
 
-void	ieee80211_amrr_init(struct ieee80211_amrr *, struct ieee80211vap *,
-	    int, int, int);
-void	ieee80211_amrr_cleanup(struct ieee80211_amrr *);
-void	ieee80211_amrr_setinterval(struct ieee80211_amrr *, int);
-void	ieee80211_amrr_node_init(struct ieee80211_amrr *,
-	    struct ieee80211_amrr_node *, struct ieee80211_node *);
-int	ieee80211_amrr_choose(struct ieee80211_node *,
-	    struct ieee80211_amrr_node *);
-
-#define	IEEE80211_AMRR_SUCCESS	1
-#define	IEEE80211_AMRR_FAILURE	0
-
-/*
- * Update statistics with tx complete status.  Ok is non-zero
- * if the packet is known to be ACK'd.  Retries has the number
- * retransmissions (i.e. xmit attempts - 1).
- */
-static __inline void
-ieee80211_amrr_tx_complete(struct ieee80211_amrr_node *amn,
-    int ok, int retries)
-{
-	amn->amn_txcnt++;
-	if (ok)
-		amn->amn_success++;
-	amn->amn_retrycnt += retries;
-}
-
-/*
- * Set tx count/retry statistics explicitly.  Intended for
- * drivers that poll the device for statistics maintained
- * in the device.
- */
-static __inline void
-ieee80211_amrr_tx_update(struct ieee80211_amrr_node *amn,
-    int txcnt, int success, int retrycnt)
-{
-	amn->amn_txcnt = txcnt;
-	amn->amn_success = success;
-	amn->amn_retrycnt = retrycnt;
-}
 #endif /* _NET80211_IEEE80211_AMRR_H_ */
diff --git a/sys/net80211/ieee80211_crypto_ccmp.c b/sys/net80211/ieee80211_crypto_ccmp.c
index 79df266cefcd..9ad240971bd2 100644
--- a/sys/net80211/ieee80211_crypto_ccmp.c
+++ b/sys/net80211/ieee80211_crypto_ccmp.c
@@ -226,7 +226,14 @@ ccmp_decap(struct ieee80211_key *k, struct mbuf *m, int hdrlen)
 	}
 	tid = ieee80211_gettid(wh);
 	pn = READ_6(ivp[0], ivp[1], ivp[4], ivp[5], ivp[6], ivp[7]);
-	if (pn <= k->wk_keyrsc[tid]) {
+	/*
+	 * NB: Multiple stations are using the same key in
+	 * IBSS mode, there is currently no way to sync keyrsc
+	 * counters without discarding too many frames.
+	 */
+	if (vap->iv_opmode != IEEE80211_M_IBSS &&
+	    vap->iv_opmode != IEEE80211_M_AHDEMO &&
+	    pn <= k->wk_keyrsc[tid]) {
 		/*
 		 * Replay violation.
 		 */
diff --git a/sys/net80211/ieee80211_crypto_tkip.c b/sys/net80211/ieee80211_crypto_tkip.c
index 6e1fda1fc9d2..0f17c173e9e4 100644
--- a/sys/net80211/ieee80211_crypto_tkip.c
+++ b/sys/net80211/ieee80211_crypto_tkip.c
@@ -281,7 +281,14 @@ tkip_decap(struct ieee80211_key *k, struct mbuf *m, int hdrlen)
 
 	tid = ieee80211_gettid(wh);
 	ctx->rx_rsc = READ_6(ivp[2], ivp[0], ivp[4], ivp[5], ivp[6], ivp[7]);
-	if (ctx->rx_rsc <= k->wk_keyrsc[tid]) {
+	/*
+	 * NB: Multiple stations are using the same key in
+	 * IBSS mode, there is currently no way to sync keyrsc
+	 * counters without discarding too many frames.
+	 */
+	if (vap->iv_opmode != IEEE80211_M_IBSS &&
+	    vap->iv_opmode != IEEE80211_M_AHDEMO &&
+	    ctx->rx_rsc <= k->wk_keyrsc[tid]) {
 		/*
 		 * Replay violation; notify upper layer.
 		 */
diff --git a/sys/net80211/ieee80211_freebsd.h b/sys/net80211/ieee80211_freebsd.h
index 6a8875a6c75c..861ac5153e3d 100644
--- a/sys/net80211/ieee80211_freebsd.h
+++ b/sys/net80211/ieee80211_freebsd.h
@@ -386,14 +386,19 @@ TEXT_SET(auth_set, name##_modevent)
 /*
  * Rate control modules provide tx rate control support.
  */
-#define	IEEE80211_RATE_MODULE(alg, version)				\
-_IEEE80211_POLICY_MODULE(rate, alg, version);				\
+#define	IEEE80211_RATECTL_MODULE(alg, version)				\
+	_IEEE80211_POLICY_MODULE(ratectl, alg, version);		\
+
+#define	IEEE80211_RATECTL_ALG(name, alg, v)				\
 static void								\
 alg##_modevent(int type)						\
 {									\
-	/* XXX nothing to do until the rate control framework arrives */\
+	if (type == MOD_LOAD)						\
+		ieee80211_ratectl_register(alg, &v);			\
+	else								\
+		ieee80211_ratectl_unregister(alg);			\
 }									\
-TEXT_SET(rate##_set, alg##_modevent)
+TEXT_SET(ratectl##_set, alg##_modevent)
 
 struct ieee80211req;
 typedef int ieee80211_ioctl_getfunc(struct ieee80211vap *,
diff --git a/sys/net80211/ieee80211_ioctl.c b/sys/net80211/ieee80211_ioctl.c
index 237e556f30c5..3c913cc3243c 100644
--- a/sys/net80211/ieee80211_ioctl.c
+++ b/sys/net80211/ieee80211_ioctl.c
@@ -70,6 +70,8 @@ __FBSDID("$FreeBSD$");
 static const uint8_t zerobssid[IEEE80211_ADDR_LEN];
 static struct ieee80211_channel *findchannel(struct ieee80211com *,
 		int ieee, int mode);
+static int ieee80211_scanreq(struct ieee80211vap *,
+		struct ieee80211_scan_req *);
 
 static __noinline int
 ieee80211_ioctl_getkey(struct ieee80211vap *vap, struct ieee80211req *ireq)
@@ -1471,14 +1473,15 @@ mlmelookup(void *arg, const struct ieee80211_scan_entry *se)
 }
 
 static __noinline int
-setmlme_assoc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN],
-	int ssid_len, const uint8_t ssid[IEEE80211_NWID_LEN])
+setmlme_assoc_sta(struct ieee80211vap *vap,
+	const uint8_t mac[IEEE80211_ADDR_LEN], int ssid_len,
+	const uint8_t ssid[IEEE80211_NWID_LEN])
 {
 	struct scanlookup lookup;
 
-	/* XXX ibss/ahdemo */
-	if (vap->iv_opmode != IEEE80211_M_STA)
-		return EINVAL;
+	KASSERT(vap->iv_opmode == IEEE80211_M_STA,
+	    ("expected opmode STA not %s",
+	    ieee80211_opmode_name[vap->iv_opmode]));
 
 	/* NB: this is racey if roaming is !manual */
 	lookup.se = NULL;
@@ -1495,6 +1498,36 @@ setmlme_assoc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN],
 }
 
 static __noinline int
+setmlme_assoc_adhoc(struct ieee80211vap *vap,
+	const uint8_t mac[IEEE80211_ADDR_LEN], int ssid_len,
+	const uint8_t ssid[IEEE80211_NWID_LEN])
+{
+	struct ieee80211_scan_req sr;
+
+	KASSERT(vap->iv_opmode == IEEE80211_M_IBSS ||
+	    vap->iv_opmode == IEEE80211_M_AHDEMO,
+	    ("expected opmode IBSS or AHDEMO not %s",
+	    ieee80211_opmode_name[vap->iv_opmode]));
+
+	if (ssid_len == 0)
+		return EINVAL;
+
+	/* NB: IEEE80211_IOC_SSID call missing for ap_scan=2. */
+	memset(vap->iv_des_ssid[0].ssid, 0, IEEE80211_NWID_LEN);
+	vap->iv_des_ssid[0].len = ssid_len;
+	memcpy(vap->iv_des_ssid[0].ssid, ssid, ssid_len);
+	vap->iv_des_nssid = 1;
+
+	sr.sr_flags = IEEE80211_IOC_SCAN_ACTIVE | IEEE80211_IOC_SCAN_ONCE;
+	sr.sr_duration = IEEE80211_IOC_SCAN_FOREVER;
+	memcpy(sr.sr_ssid[0].ssid, ssid, ssid_len);
+	sr.sr_ssid[0].len = ssid_len;
+	sr.sr_nssid = 1;
+
+	return ieee80211_scanreq(vap, &sr);
+}
+
+static __noinline int
 ieee80211_ioctl_setmlme(struct ieee80211vap *vap, struct ieee80211req *ireq)
 {
 	struct ieee80211req_mlme mlme;
@@ -1505,9 +1538,13 @@ ieee80211_ioctl_setmlme(struct ieee80211vap *vap, struct ieee80211req *ireq)
 	error = copyin(ireq->i_data, &mlme, sizeof(mlme));
 	if (error)
 		return error;
-	if  (mlme.im_op == IEEE80211_MLME_ASSOC)
-		return setmlme_assoc(vap, mlme.im_macaddr,
+	if  (vap->iv_opmode == IEEE80211_M_STA &&
+	    mlme.im_op == IEEE80211_MLME_ASSOC)
+		return setmlme_assoc_sta(vap, mlme.im_macaddr,
 		    vap->iv_des_ssid[0].len, vap->iv_des_ssid[0].ssid);
+	else if (mlme.im_op == IEEE80211_MLME_ASSOC)
+		return setmlme_assoc_adhoc(vap, mlme.im_macaddr,
+		    mlme.im_ssid_len, mlme.im_ssid);
 	else
 		return setmlme_common(vap, mlme.im_op,
 		    mlme.im_macaddr, mlme.im_reason);
@@ -2332,8 +2369,8 @@ ieee80211_ioctl_chanswitch(struct ieee80211vap *vap, struct ieee80211req *ireq)
 	return error;
 }
 
-static __noinline int
-ieee80211_ioctl_scanreq(struct ieee80211vap *vap, struct ieee80211req *ireq)
+static int
+ieee80211_scanreq(struct ieee80211vap *vap, struct ieee80211_scan_req *sr)
 {
 #define	IEEE80211_IOC_SCAN_FLAGS \
 	(IEEE80211_IOC_SCAN_NOPICK | IEEE80211_IOC_SCAN_ACTIVE | \
@@ -2342,48 +2379,38 @@ ieee80211_ioctl_scanreq(struct ieee80211vap *vap, struct ieee80211req *ireq)
 	 IEEE80211_IOC_SCAN_NOJOIN | IEEE80211_IOC_SCAN_FLUSH | \
 	 IEEE80211_IOC_SCAN_CHECK)
 	struct ieee80211com *ic = vap->iv_ic;
-	struct ieee80211_scan_req sr;		/* XXX off stack? */
-	int error, i;
-
-	/* NB: parent must be running */
-	if ((ic->ic_ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
-		return ENXIO;
+	int i;
 
-	if (ireq->i_len != sizeof(sr))
-		return EINVAL;
-	error = copyin(ireq->i_data, &sr, sizeof(sr));
-	if (error != 0)
-		return error;
 	/* convert duration */
-	if (sr.sr_duration == IEEE80211_IOC_SCAN_FOREVER)
-		sr.sr_duration = IEEE80211_SCAN_FOREVER;
+	if (sr->sr_duration == IEEE80211_IOC_SCAN_FOREVER)
+		sr->sr_duration = IEEE80211_SCAN_FOREVER;
 	else {
-		if (sr.sr_duration < IEEE80211_IOC_SCAN_DURATION_MIN ||
-		    sr.sr_duration > IEEE80211_IOC_SCAN_DURATION_MAX)
+		if (sr->sr_duration < IEEE80211_IOC_SCAN_DURATION_MIN ||
+		    sr->sr_duration > IEEE80211_IOC_SCAN_DURATION_MAX)
 			return EINVAL;
-		sr.sr_duration = msecs_to_ticks(sr.sr_duration);
-		if (sr.sr_duration < 1)
-			sr.sr_duration = 1;
+		sr->sr_duration = msecs_to_ticks(sr->sr_duration);
+		if (sr->sr_duration < 1)
+			sr->sr_duration = 1;
 	}
 	/* convert min/max channel dwell */
-	if (sr.sr_mindwell != 0) {
-		sr.sr_mindwell = msecs_to_ticks(sr.sr_mindwell);
-		if (sr.sr_mindwell < 1)
-			sr.sr_mindwell = 1;
+	if (sr->sr_mindwell != 0) {
+		sr->sr_mindwell = msecs_to_ticks(sr->sr_mindwell);
+		if (sr->sr_mindwell < 1)
+			sr->sr_mindwell = 1;
 	}
-	if (sr.sr_maxdwell != 0) {
-		sr.sr_maxdwell = msecs_to_ticks(sr.sr_maxdwell);
-		if (sr.sr_maxdwell < 1)
-			sr.sr_maxdwell = 1;
+	if (sr->sr_maxdwell != 0) {
+		sr->sr_maxdwell = msecs_to_ticks(sr->sr_maxdwell);
+		if (sr->sr_maxdwell < 1)
+			sr->sr_maxdwell = 1;
 	}
 	/* NB: silently reduce ssid count to what is supported */
-	if (sr.sr_nssid > IEEE80211_SCAN_MAX_SSID)
-		sr.sr_nssid = IEEE80211_SCAN_MAX_SSID;
-	for (i = 0; i < sr.sr_nssid; i++)
-		if (sr.sr_ssid[i].len > IEEE80211_NWID_LEN)
+	if (sr->sr_nssid > IEEE80211_SCAN_MAX_SSID)
+		sr->sr_nssid = IEEE80211_SCAN_MAX_SSID;
+	for (i = 0; i < sr->sr_nssid; i++)
+		if (sr->sr_ssid[i].len > IEEE80211_NWID_LEN)
 			return EINVAL;
 	/* cleanse flags just in case, could reject if invalid flags */
-	sr.sr_flags &= IEEE80211_IOC_SCAN_FLAGS;
+	sr->sr_flags &= IEEE80211_IOC_SCAN_FLAGS;
 	/*
 	 * Add an implicit NOPICK if the vap is not marked UP.  This
 	 * allows applications to scan without joining a bss (or picking
@@ -2391,13 +2418,13 @@ ieee80211_ioctl_scanreq(struct ieee80211vap *vap, struct ieee80211req *ireq)
 	 * roaming mode--you just need to mark the parent device UP.
 	 */
 	if ((vap->iv_ifp->if_flags & IFF_UP) == 0)
-		sr.sr_flags |= IEEE80211_IOC_SCAN_NOPICK;
+		sr->sr_flags |= IEEE80211_IOC_SCAN_NOPICK;
 
 	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,
 	    "%s: flags 0x%x%s duration 0x%x mindwell %u maxdwell %u nssid %d\n",
-	    __func__, sr.sr_flags,
+	    __func__, sr->sr_flags,
 	    (vap->iv_ifp->if_flags & IFF_UP) == 0 ? " (!IFF_UP)" : "",
-	    sr.sr_duration, sr.sr_mindwell, sr.sr_maxdwell, sr.sr_nssid);
+	    sr->sr_duration, sr->sr_mindwell, sr->sr_maxdwell, sr->sr_nssid);
 	/*
 	 * If we are in INIT state then the driver has never had a chance
 	 * to setup hardware state to do a scan; we must use the state
@@ -2412,13 +2439,13 @@ ieee80211_ioctl_scanreq(struct ieee80211vap *vap, struct ieee80211req *ireq)
 	IEEE80211_LOCK(ic);
 	if (vap->iv_state == IEEE80211_S_INIT) {
 		/* NB: clobbers previous settings */
-		vap->iv_scanreq_flags = sr.sr_flags;
-		vap->iv_scanreq_duration = sr.sr_duration;
-		vap->iv_scanreq_nssid = sr.sr_nssid;
-		for (i = 0; i < sr.sr_nssid; i++) {
-			vap->iv_scanreq_ssid[i].len = sr.sr_ssid[i].len;
-			memcpy(vap->iv_scanreq_ssid[i].ssid, sr.sr_ssid[i].ssid,
-			    sr.sr_ssid[i].len);
+		vap->iv_scanreq_flags = sr->sr_flags;
+		vap->iv_scanreq_duration = sr->sr_duration;
+		vap->iv_scanreq_nssid = sr->sr_nssid;
+		for (i = 0; i < sr->sr_nssid; i++) {
+			vap->iv_scanreq_ssid[i].len = sr->sr_ssid[i].len;
+			memcpy(vap->iv_scanreq_ssid[i].ssid,
+			    sr->sr_ssid[i].ssid, sr->sr_ssid[i].len);
 		}
 		vap->iv_flags_ext |= IEEE80211_FEXT_SCANREQ;
 		IEEE80211_UNLOCK(ic);
@@ -2427,25 +2454,44 @@ ieee80211_ioctl_scanreq(struct ieee80211vap *vap, struct ieee80211req *ireq)
 		vap->iv_flags_ext &= ~IEEE80211_FEXT_SCANREQ;
 		IEEE80211_UNLOCK(ic);
 		/* XXX neeed error return codes */
-		if (sr.sr_flags & IEEE80211_IOC_SCAN_CHECK) {
-			(void) ieee80211_check_scan(vap, sr.sr_flags,
-			    sr.sr_duration, sr.sr_mindwell, sr.sr_maxdwell,
-			    sr.sr_nssid,
+		if (sr->sr_flags & IEEE80211_IOC_SCAN_CHECK) {
+			(void) ieee80211_check_scan(vap, sr->sr_flags,
+			    sr->sr_duration, sr->sr_mindwell, sr->sr_maxdwell,
+			    sr->sr_nssid,
 			    /* NB: cheat, we assume structures are compatible */
-			    (const struct ieee80211_scan_ssid *) &sr.sr_ssid[0]);
+			    (const struct ieee80211_scan_ssid *) &sr->sr_ssid[0]);
 		} else {
-			(void) ieee80211_start_scan(vap, sr.sr_flags,
-			    sr.sr_duration, sr.sr_mindwell, sr.sr_maxdwell,
-			    sr.sr_nssid,
+			(void) ieee80211_start_scan(vap, sr->sr_flags,
+			    sr->sr_duration, sr->sr_mindwell, sr->sr_maxdwell,
+			    sr->sr_nssid,
 			    /* NB: cheat, we assume structures are compatible */
-			    (const struct ieee80211_scan_ssid *) &sr.sr_ssid[0]);
+			    (const struct ieee80211_scan_ssid *) &sr->sr_ssid[0]);
 		}
 	}
-	return error;
+	return 0;
 #undef IEEE80211_IOC_SCAN_FLAGS
 }
 
 static __noinline int
+ieee80211_ioctl_scanreq(struct ieee80211vap *vap, struct ieee80211req *ireq)
+{
+	struct ieee80211com *ic = vap->iv_ic;
+	struct ieee80211_scan_req sr;		/* XXX off stack? */
+	int error;
+
+	/* NB: parent must be running */
+	if ((ic->ic_ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
+		return ENXIO;
+
+	if (ireq->i_len != sizeof(sr))
+		return EINVAL;
+	error = copyin(ireq->i_data, &sr, sizeof(sr));
+	if (error != 0)
+		return error;
+	return ieee80211_scanreq(vap, &sr);
+}
+
+static __noinline int
 ieee80211_ioctl_setstavlan(struct ieee80211vap *vap, struct ieee80211req *ireq)
 {
 	struct ieee80211_node *ni;
diff --git a/sys/net80211/ieee80211_node.c b/sys/net80211/ieee80211_node.c
index bccb6d5bdd91..b17f42fd51ae 100644
--- a/sys/net80211/ieee80211_node.c
+++ b/sys/net80211/ieee80211_node.c
@@ -51,6 +51,7 @@ __FBSDID("$FreeBSD$");
 #endif
 #include <net80211/ieee80211_wds.h>
 #include <net80211/ieee80211_mesh.h>
+#include <net80211/ieee80211_ratectl.h>
 
 #include <net/bpf.h>
 
@@ -1035,6 +1036,7 @@ node_free(struct ieee80211_node *ni)
 {
 	struct ieee80211com *ic = ni->ni_ic;
 
+	ieee80211_ratectl_node_deinit(ni);
 	ic->ic_node_cleanup(ni);
 	ieee80211_ies_cleanup(&ni->ni_ies);
 	ieee80211_psq_cleanup(&ni->ni_psq);
diff --git a/sys/net80211/ieee80211_node.h b/sys/net80211/ieee80211_node.h
index 63b235528972..01bb2cf11482 100644
--- a/sys/net80211/ieee80211_node.h
+++ b/sys/net80211/ieee80211_node.h
@@ -218,7 +218,8 @@ struct ieee80211_node {
 	struct ieee80211_nodestats ni_stats;	/* per-node statistics */
 
 	struct ieee80211vap	*ni_wdsvap;	/* associated WDS vap */
-	uint64_t		ni_spare[4];
+	void			*ni_rctls;	/* private ratectl state */
+	uint64_t		ni_spare[3];
 };
 MALLOC_DECLARE(M_80211_NODE);
 MALLOC_DECLARE(M_80211_NODE_IE);
diff --git a/sys/net80211/ieee80211_ratectl.c b/sys/net80211/ieee80211_ratectl.c
new file mode 100644
index 000000000000..2e8eb7e21535
--- /dev/null
+++ b/sys/net80211/ieee80211_ratectl.c
@@ -0,0 +1,66 @@
+/*-
+ * Copyright (c) 2010 Rui Paulo <rpaulo@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.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/systm.h>
+#include <sys/socket.h>
+
+#include <net/if.h>
+#include <net/if_media.h>
+
+#include <net80211/ieee80211_var.h>
+#include <net80211/ieee80211_ratectl.h>
+
+static const struct ieee80211_ratectl *ratectls[IEEE80211_RATECTL_MAX];
+
+MALLOC_DEFINE(M_80211_RATECTL, "80211ratectl", "802.11 rate control");
+
+void
+ieee80211_ratectl_register(int type, const struct ieee80211_ratectl *ratectl)
+{
+	if (type >= IEEE80211_RATECTL_MAX)
+		return;
+	ratectls[type] = ratectl;
+}
+
+void
+ieee80211_ratectl_unregister(int type)
+{
+	if (type >= IEEE80211_RATECTL_MAX)
+		return;
+	ratectls[type] = NULL;
+}
+
+void
+ieee80211_ratectl_set(struct ieee80211vap *vap, int type)
+{
+	if (type >= IEEE80211_RATECTL_MAX)
+		return;
+	vap->iv_rate = ratectls[type];
+}
diff --git a/sys/net80211/ieee80211_ratectl.h b/sys/net80211/ieee80211_ratectl.h
new file mode 100644
index 000000000000..73b4f3216505
--- /dev/null
+++ b/sys/net80211/ieee80211_ratectl.h
@@ -0,0 +1,129 @@
+/*-
+ * Copyright (c) 2010 Rui Paulo <rpaulo@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$
+ */
+
+enum ieee80211_ratealgs {
+	IEEE80211_RATECTL_AMRR 		= 0,
+	IEEE80211_RATECTL_RSSADAPT	= 1,
+	IEEE80211_RATECTL_ONOE		= 2,
+	IEEE80211_RATECTL_SAMPLE	= 3,
+	IEEE80211_RATECTL_MAX
+};
+
+#define	IEEE80211_RATECTL_TX_SUCCESS	1
+#define	IEEE80211_RATECTL_TX_FAILURE	0
+
+struct ieee80211_ratectl {
+	const char *ir_name;
+	int	(*ir_attach)(const struct ieee80211vap *);
+	void	(*ir_detach)(const struct ieee80211vap *);
+	void	(*ir_init)(struct ieee80211vap *);
+	void	(*ir_deinit)(struct ieee80211vap *);
+	void	(*ir_node_init)(struct ieee80211_node *);
+	void	(*ir_node_deinit)(struct ieee80211_node *);
+	int	(*ir_rate)(struct ieee80211_node *, void *, uint32_t);
+	void	(*ir_tx_complete)(const struct ieee80211vap *,
+	    			  const struct ieee80211_node *, int,
+	    			  void *, void *);
+	void	(*ir_tx_update)(const struct ieee80211vap *,
+	    			const struct ieee80211_node *,
+	    			void *, void *, void *);
+	void	(*ir_setinterval)(const struct ieee80211vap *, int);
+};
+
+void	ieee80211_ratectl_register(int, const struct ieee80211_ratectl *);
+void	ieee80211_ratectl_unregister(int);
+void	ieee80211_ratectl_set(struct ieee80211vap *, int);
+
+MALLOC_DECLARE(M_80211_RATECTL);
+
+static void __inline
+ieee80211_ratectl_init(struct ieee80211vap *vap)
+{
+	vap->iv_rate->ir_init(vap);
+}
+
+static void __inline
+ieee80211_ratectl_deinit(struct ieee80211vap *vap)
+{
+	vap->iv_rate->ir_deinit(vap);
+}
+
+static void __inline
+ieee80211_ratectl_node_init(struct ieee80211_node *ni)
+{
+	const struct ieee80211vap *vap = ni->ni_vap;
+
+	vap->iv_rate->ir_node_init(ni);
+}
+
+static void __inline
+ieee80211_ratectl_node_deinit(struct ieee80211_node *ni)
+{
+	const struct ieee80211vap *vap = ni->ni_vap;
+
+	if (ni->ni_rctls == NULL)	/* ratectl not setup */
+		return;
+	vap->iv_rate->ir_node_deinit(ni);
+}
+
+static int __inline
+ieee80211_ratectl_rate(struct ieee80211_node *ni, void *arg, uint32_t iarg)
+{
+	const struct ieee80211vap *vap = ni->ni_vap;
+
+	if (ni->ni_rctls == NULL)	/* ratectl not setup */
+		return 0;
+	return vap->iv_rate->ir_rate(ni, arg, iarg);
+}
+
+static void __inline
+ieee80211_ratectl_tx_complete(const struct ieee80211vap *vap,
+    const struct ieee80211_node *ni, int status, void *arg1, void *arg2)
+{
+	if (ni->ni_rctls == NULL)	/* ratectl not setup */
+		return;
+	vap->iv_rate->ir_tx_complete(vap, ni, status, arg1, arg2);
+}
+
+static void __inline
+ieee80211_ratectl_tx_update(const struct ieee80211vap *vap,
+    const struct ieee80211_node *ni, void *arg1, void *arg2, void *arg3)
+{
+	if (vap->iv_rate->ir_tx_update == NULL)
+		return;
+	if (ni->ni_rctls == NULL)	/* ratectl not setup */
+		return;
+	vap->iv_rate->ir_tx_update(vap, ni, arg1, arg2, arg3);
+}
+
+static void __inline
+ieee80211_ratectl_setinterval(const struct ieee80211vap *vap, int msecs)
+{
+	if (vap->iv_rate->ir_setinterval == NULL)
+		return;
+	vap->iv_rate->ir_setinterval(vap, msecs);
+}
diff --git a/sys/net80211/ieee80211_rssadapt.c b/sys/net80211/ieee80211_rssadapt.c
index f1fc409edca1..ad329e0470df 100644
--- a/sys/net80211/ieee80211_rssadapt.c
+++ b/sys/net80211/ieee80211_rssadapt.c
@@ -1,6 +1,7 @@
 /*	$FreeBSD$	*/
 /* $NetBSD: ieee80211_rssadapt.c,v 1.9 2005/02/26 22:45:09 perry Exp $ */
 /*-
+ * Copyright (c) 2010 Rui Paulo <rpaulo@FreeBSD.org>
  * Copyright (c) 2003, 2004 David Young.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or
@@ -42,6 +43,7 @@
 
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_rssadapt.h>
+#include <net80211/ieee80211_ratectl.h>
 
 struct rssadapt_expavgctl {
 	/* RSS threshold decay. */
@@ -71,15 +73,45 @@ static struct rssadapt_expavgctl master_expavgctl = {
                                      (parm##_denom - parm##_old) * (new)) / \
 				    parm##_denom)
 
-static void rssadapt_sysctlattach(struct ieee80211_rssadapt *rs,
-	struct sysctl_ctx_list *ctx, struct sysctl_oid *tree);
+static void	rssadapt_setinterval(const struct ieee80211vap *, int);
+static void	rssadapt_init(struct ieee80211vap *);
+static void	rssadapt_deinit(struct ieee80211vap *);
+static void	rssadapt_updatestats(struct ieee80211_rssadapt_node *);
+static void	rssadapt_node_init(struct ieee80211_node *);
+static void	rssadapt_node_deinit(struct ieee80211_node *);
+static int	rssadapt_rate(struct ieee80211_node *, void *, uint32_t);
+static void	rssadapt_lower_rate(struct ieee80211_rssadapt_node *, int, int);
+static void	rssadapt_raise_rate(struct ieee80211_rssadapt_node *,
+			int, int);
+static void	rssadapt_tx_complete(const struct ieee80211vap *,
+    			const struct ieee80211_node *, int,
+			void *, void *);
+static void	rssadapt_sysctlattach(struct ieee80211vap *,
+			struct sysctl_ctx_list *, struct sysctl_oid *);
 
 /* number of references from net80211 layer */
 static	int nrefs = 0;
 
-void
-ieee80211_rssadapt_setinterval(struct ieee80211_rssadapt *rs, int msecs)
+static const struct ieee80211_ratectl rssadapt = {
+	.ir_name	= "rssadapt",
+	.ir_attach	= NULL,
+	.ir_detach	= NULL,
+	.ir_init	= rssadapt_init,
+	.ir_deinit	= rssadapt_deinit,
+	.ir_node_init	= rssadapt_node_init,
+	.ir_node_deinit	= rssadapt_node_deinit,
+	.ir_rate	= rssadapt_rate,
+	.ir_tx_complete	= rssadapt_tx_complete,
+	.ir_tx_update	= NULL,
+	.ir_setinterval	= rssadapt_setinterval,
+};
+IEEE80211_RATECTL_MODULE(rssadapt, 1);
+IEEE80211_RATECTL_ALG(rssadapt, IEEE80211_RATECTL_RSSADAPT, rssadapt);
+
+static void
+rssadapt_setinterval(const struct ieee80211vap *vap, int msecs)
 {
+	struct ieee80211_rssadapt *rs = vap->iv_rs;
 	int t;
 
 	if (msecs < 100)
@@ -88,18 +120,29 @@ ieee80211_rssadapt_setinterval(struct ieee80211_rssadapt *rs, int msecs)
 	rs->interval = (t < 1) ? 1 : t;
 }
 
-void
-ieee80211_rssadapt_init(struct ieee80211_rssadapt *rs, struct ieee80211vap *vap, int interval)
+static void
+rssadapt_init(struct ieee80211vap *vap)
 {
-	rs->vap = vap;
-	ieee80211_rssadapt_setinterval(rs, interval);
+	struct ieee80211_rssadapt *rs;
 
-	rssadapt_sysctlattach(rs, vap->iv_sysctl, vap->iv_oid);
+	KASSERT(vap->iv_rs == NULL, ("%s: iv_rs already initialized",
+	    __func__));
+	
+	vap->iv_rs = rs = malloc(sizeof(struct ieee80211_rssadapt),
+	    M_80211_RATECTL, M_NOWAIT|M_ZERO);
+	if (rs == NULL) {
+		if_printf(vap->iv_ifp, "couldn't alloc ratectl structure\n");
+		return;
+	}
+	rs->vap = vap;
+	rssadapt_setinterval(vap, 500 /* msecs */);
+	rssadapt_sysctlattach(vap, vap->iv_sysctl, vap->iv_oid);
 }
 
-void
-ieee80211_rssadapt_cleanup(struct ieee80211_rssadapt *rs)
+static void
+rssadapt_deinit(struct ieee80211vap *vap)
 {
+	free(vap->iv_rs, M_80211_RATECTL);
 }
 
 static void
@@ -118,12 +161,21 @@ rssadapt_updatestats(struct ieee80211_rssadapt_node *ra)
 	ra->ra_raise_interval = msecs_to_ticks(interval);
 }
 
-void
-ieee80211_rssadapt_node_init(struct ieee80211_rssadapt *rsa,
-    struct ieee80211_rssadapt_node *ra, struct ieee80211_node *ni)
+static void
+rssadapt_node_init(struct ieee80211_node *ni)
 {
+	struct ieee80211_rssadapt_node *ra;
+	struct ieee80211vap *vap = ni->ni_vap;
+	struct ieee80211_rssadapt *rsa = vap->iv_rs;
 	const struct ieee80211_rateset *rs = &ni->ni_rates;
 
+	ni->ni_rctls = ra = malloc(sizeof(struct ieee80211_rssadapt_node),
+	    M_80211_RATECTL, M_NOWAIT|M_ZERO);
+	if (ra == NULL) {
+		if_printf(vap->iv_ifp, "couldn't alloc per-node ratectl "
+		    "structure\n");
+		return;
+	}
 	ra->ra_rs = rsa;
 	ra->ra_rates = *rs;
 	rssadapt_updatestats(ra);
@@ -140,6 +192,13 @@ ieee80211_rssadapt_node_init(struct ieee80211_rssadapt *rsa,
 	    "RSSADAPT initial rate %d", ni->ni_txrate);
 }
 
+static void
+rssadapt_node_deinit(struct ieee80211_node *ni)
+{
+
+	free(ni->ni_rctls, M_80211_RATECTL);
+}
+
 static __inline int
 bucket(int pktlen)
 {
@@ -155,10 +214,11 @@ bucket(int pktlen)
 	return thridx;
 }
 
-int
-ieee80211_rssadapt_choose(struct ieee80211_node *ni,
-    struct ieee80211_rssadapt_node *ra, u_int pktlen)
+static int
+rssadapt_rate(struct ieee80211_node *ni, void *arg __unused, uint32_t iarg)
 {
+	struct ieee80211_rssadapt_node *ra = ni->ni_rctls;
+	u_int pktlen = iarg;
 	const struct ieee80211_rateset *rs = &ra->ra_rates;
 	uint16_t (*thrs)[IEEE80211_RATE_SIZE];
 	int rix, rssi;
@@ -193,9 +253,8 @@ ieee80211_rssadapt_choose(struct ieee80211_node *ni,
  * raise the RSS threshold for transmitting packets of similar length at
  * the same data rate.
  */
-void
-ieee80211_rssadapt_lower_rate(struct ieee80211_rssadapt_node *ra,
-    int pktlen, int rssi)
+static void
+rssadapt_lower_rate(struct ieee80211_rssadapt_node *ra, int pktlen, int rssi)
 {
 	uint16_t last_thr;
 	uint16_t (*thrs)[IEEE80211_RATE_SIZE];
@@ -214,9 +273,8 @@ ieee80211_rssadapt_lower_rate(struct ieee80211_rssadapt_node *ra,
 	    last_thr, (*thrs)[rix], rssi);
 }
 
-void
-ieee80211_rssadapt_raise_rate(struct ieee80211_rssadapt_node *ra,
-    int pktlen, int rssi)
+static void
+rssadapt_raise_rate(struct ieee80211_rssadapt_node *ra, int pktlen, int rssi)
 {
 	uint16_t (*thrs)[IEEE80211_RATE_SIZE];
 	uint16_t newthr, oldthr;
@@ -243,31 +301,45 @@ ieee80211_rssadapt_raise_rate(struct ieee80211_rssadapt_node *ra,
 	}
 }
 
+static void
+rssadapt_tx_complete(const struct ieee80211vap *vap,
+    const struct ieee80211_node *ni, int success, void *arg1, void *arg2)
+{
+	struct ieee80211_rssadapt_node *ra = ni->ni_rctls;
+	int pktlen = *(int *)arg1, rssi = *(int *)arg2;
+
+	if (success) {
+		ra->ra_nok++;
+		if ((ra->ra_rix + 1) < ra->ra_rates.rs_nrates &&
+		    (ticks - ra->ra_last_raise) >= ra->ra_raise_interval)
+			rssadapt_raise_rate(ra, pktlen, rssi);
+	} else {
+		ra->ra_nfail++;
+		rssadapt_lower_rate(ra, pktlen, rssi);
+	}
+}
+
 static int
 rssadapt_sysctl_interval(SYSCTL_HANDLER_ARGS)
 {
-	struct ieee80211_rssadapt *rs = arg1;
+	struct ieee80211vap *vap = arg1;
+	struct ieee80211_rssadapt *rs = vap->iv_rs;
 	int msecs = ticks_to_msecs(rs->interval);
 	int error;
 
 	error = sysctl_handle_int(oidp, &msecs, 0, req);
 	if (error || !req->newptr)
 		return error;
-	ieee80211_rssadapt_setinterval(rs, msecs);
+	rssadapt_setinterval(vap, msecs);
 	return 0;
 }
 
 static void
-rssadapt_sysctlattach(struct ieee80211_rssadapt *rs,
+rssadapt_sysctlattach(struct ieee80211vap *vap,
     struct sysctl_ctx_list *ctx, struct sysctl_oid *tree)
 {
 
 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
-	    "rssadapt_rate_interval", CTLTYPE_INT | CTLFLAG_RW, rs,
+	    "rssadapt_rate_interval", CTLTYPE_INT | CTLFLAG_RW, vap,
 	    0, rssadapt_sysctl_interval, "I", "rssadapt operation interval (ms)");
 }
-
-/*
- * Module glue.
- */
-IEEE80211_RATE_MODULE(rssadapt, 1);
diff --git a/sys/net80211/ieee80211_rssadapt.h b/sys/net80211/ieee80211_rssadapt.h
index b454f43cadcb..ee1d2d906c99 100644
--- a/sys/net80211/ieee80211_rssadapt.h
+++ b/sys/net80211/ieee80211_rssadapt.h
@@ -43,7 +43,7 @@
 #define	IEEE80211_RSSADAPT_BKTPOWER	3	/* 2**_BKTPOWER */
 
 struct ieee80211_rssadapt {
-	struct ieee80211vap *vap;
+	const struct ieee80211vap *vap;
 	int	interval;			/* update interval (ticks) */
 };
 
@@ -66,36 +66,6 @@ struct ieee80211_rssadapt_node {
 					      [IEEE80211_RATE_SIZE];
 };
 
-void	ieee80211_rssadapt_init(struct ieee80211_rssadapt *,
-	    struct ieee80211vap *, int);
-void	ieee80211_rssadapt_cleanup(struct ieee80211_rssadapt *);
-void	ieee80211_rssadapt_setinterval(struct ieee80211_rssadapt *, int);
-void	ieee80211_rssadapt_node_init(struct ieee80211_rssadapt *,
-	    struct ieee80211_rssadapt_node *, struct ieee80211_node *);
-int	ieee80211_rssadapt_choose(struct ieee80211_node *,
-	    struct ieee80211_rssadapt_node *, u_int);
-
-/* NB: these are public only for the inline below */
-void	ieee80211_rssadapt_raise_rate(struct ieee80211_rssadapt_node *,
-	    int pktlen, int rssi);
-void	ieee80211_rssadapt_lower_rate(struct ieee80211_rssadapt_node *,
-	    int pktlen, int rssi);
-
 #define	IEEE80211_RSSADAPT_SUCCESS	1
 #define	IEEE80211_RSSADAPT_FAILURE	0
-
-static __inline void
-ieee80211_rssadapt_tx_complete(struct ieee80211_rssadapt_node *ra,
-    int success, int pktlen, int rssi)
-{
-	if (success) {
-		ra->ra_nok++;
-		if ((ra->ra_rix + 1) < ra->ra_rates.rs_nrates &&
-		    (ticks - ra->ra_last_raise) >= ra->ra_raise_interval)
-			ieee80211_rssadapt_raise_rate(ra, pktlen, rssi);
-	} else {
-		ra->ra_nfail++;
-		ieee80211_rssadapt_lower_rate(ra, pktlen, rssi);
-	}
-}
 #endif /* _NET80211_IEEE80211_RSSADAPT_H_ */
diff --git a/sys/net80211/ieee80211_var.h b/sys/net80211/ieee80211_var.h
index 3fa0aec0ae8a..ff3694f56a51 100644
--- a/sys/net80211/ieee80211_var.h
+++ b/sys/net80211/ieee80211_var.h
@@ -436,6 +436,9 @@ struct ieee80211vap {
 	const struct ieee80211_aclator *iv_acl;	/* acl glue */
 	void			*iv_as;		/* private aclator state */
 
+	const struct ieee80211_ratectl *iv_rate;
+	void			*iv_rs;		/* private ratectl state */
+
 	struct ieee80211_tdma_state *iv_tdma;	/* tdma state */
 	struct ieee80211_mesh_state *iv_mesh;	/* MBSS state */
 	struct ieee80211_hwmp_state *iv_hwmp;	/* HWMP state */
@@ -471,7 +474,7 @@ struct ieee80211vap {
 	/* 802.3 output method for raw frame xmit */
 	int			(*iv_output)(struct ifnet *, struct mbuf *,
 				    struct sockaddr *, struct route *);
-	uint64_t		iv_spare[8];
+	uint64_t		iv_spare[6];
 };
 MALLOC_DECLARE(M_80211_VAP);
 
diff --git a/sys/netgraph/ng_pipe.c b/sys/netgraph/ng_pipe.c
index 5f5e41096ec1..a094646e6600 100644
--- a/sys/netgraph/ng_pipe.c
+++ b/sys/netgraph/ng_pipe.c
@@ -1,4 +1,4 @@
-/*
+/*-
  * Copyright (c) 2004-2008 University of Zagreb
  * Copyright (c) 2007-2008 FreeBSD Foundation
  *
diff --git a/sys/netgraph/ng_pipe.h b/sys/netgraph/ng_pipe.h
index e468605e9588..6885ed5d18e8 100644
--- a/sys/netgraph/ng_pipe.h
+++ b/sys/netgraph/ng_pipe.h
@@ -1,4 +1,4 @@
-/*
+/*-
  * Copyright (c) 2004-2008 University of Zagreb
  * Copyright (c) 2007-2008 FreeBSD Foundation
  *
diff --git a/sys/netinet/if_ether.c b/sys/netinet/if_ether.c
index 97152a72dbe2..25fba9f10eb1 100644
--- a/sys/netinet/if_ether.c
+++ b/sys/netinet/if_ether.c
@@ -180,6 +180,8 @@ arptimer(void *arg)
 	else {
 		if (!callout_pending(&lle->la_timer) &&
 		    callout_active(&lle->la_timer)) {
+			callout_stop(&lle->la_timer);
+			LLE_REMREF(lle);
 			(void) llentry_free(lle);
 			ARPSTAT_INC(timeouts);
 		} 
@@ -382,9 +384,14 @@ retry:
 		    EHOSTUNREACH : EHOSTDOWN;
 
 	if (renew) {
+		int canceled;
+
 		LLE_ADDREF(la);
 		la->la_expire = time_second + V_arpt_down;
-		callout_reset(&la->la_timer, hz * V_arpt_down, arptimer, la);
+		canceled = callout_reset(&la->la_timer, hz * V_arpt_down,
+		    arptimer, la);
+		if (canceled)
+			LLE_REMREF(la);
 		la->la_asked++;
 		LLE_WUNLOCK(la);
 		arprequest(ifp, NULL, &SIN(dst)->sin_addr,
@@ -696,9 +703,14 @@ match:
 		EVENTHANDLER_INVOKE(arp_update_event, la);
 
 		if (!(la->la_flags & LLE_STATIC)) {
+			int canceled;
+
+			LLE_ADDREF(la);
 			la->la_expire = time_second + V_arpt_keep;
-			callout_reset(&la->la_timer, hz * V_arpt_keep,
-			    arptimer, la);
+			canceled = callout_reset(&la->la_timer,
+			    hz * V_arpt_keep, arptimer, la);
+			if (canceled)
+				LLE_REMREF(la);
 		}
 		la->la_asked = 0;
 		la->la_preempt = V_arp_maxtries;
diff --git a/sys/netinet/in.c b/sys/netinet/in.c
index 319ec953d99b..0a0fe472590c 100644
--- a/sys/netinet/in.c
+++ b/sys/netinet/in.c
@@ -1357,8 +1357,12 @@ in_lltable_prefix_free(struct lltable *llt,
 
 			if (IN_ARE_MASKED_ADDR_EQUAL((struct sockaddr_in *)L3_ADDR(lle), 
 						     pfx, msk)) {
-				callout_drain(&lle->la_timer);
+				int canceled;
+
+				canceled = callout_drain(&lle->la_timer);
 				LLE_WLOCK(lle);
+				if (canceled)
+					LLE_REMREF(lle);
 				llentry_free(lle);
 			}
 		}
diff --git a/sys/netinet/in_mcast.c b/sys/netinet/in_mcast.c
index 1f658da6d838..4edf309c06e4 100644
--- a/sys/netinet/in_mcast.c
+++ b/sys/netinet/in_mcast.c
@@ -1999,9 +1999,12 @@ inp_join_group(struct inpcb *inp, struct sockopt *sopt)
 			}
 		} else {
 			/*
-			 * MCAST_JOIN_GROUP alone, on any existing membership,
-			 * is rejected, to stop the same inpcb tying up
-			 * multiple refs to the in_multi.
+			 * MCAST_JOIN_GROUP on an existing exclusive
+			 * membership is an error; return EADDRINUSE
+			 * to preserve 4.4BSD API idempotence, and
+			 * avoid tedious detour to code below.
+			 * NOTE: This is bending RFC 3678 a bit.
+			 *
 			 * On an existing inclusive membership, this is also
 			 * an error; if you want to change filter mode,
 			 * you must use the userland API setsourcefilter().
@@ -2010,6 +2013,8 @@ inp_join_group(struct inpcb *inp, struct sockopt *sopt)
 			 * is atomic with allocation of a membership.
 			 */
 			error = EINVAL;
+			if (imf->imf_st[1] == MCAST_EXCLUDE)
+				error = EADDRINUSE;
 			goto out_inp_locked;
 		}
 	}
@@ -2186,7 +2191,14 @@ inp_leave_group(struct inpcb *inp, struct sockopt *sopt)
 			ssa->sin.sin_addr = mreqs.imr_sourceaddr;
 		}
 
-		if (!in_nullhost(gsa->sin.sin_addr))
+		/*
+		 * Attempt to look up hinted ifp from interface address.
+		 * Fallthrough with null ifp iff lookup fails, to
+		 * preserve 4.4BSD mcast API idempotence.
+		 * XXX NOTE WELL: The RFC 3678 API is preferred because
+		 * using an IPv4 address as a key is racy.
+		 */
+		if (!in_nullhost(mreqs.imr_interface))
 			INADDR_TO_IFP(mreqs.imr_interface, ifp);
 
 		CTR3(KTR_IGMPV3, "%s: imr_interface = %s, ifp = %p",
@@ -2222,6 +2234,9 @@ inp_leave_group(struct inpcb *inp, struct sockopt *sopt)
 			return (EADDRNOTAVAIL);
 
 		ifp = ifnet_byindex(gsr.gsr_interface);
+
+		if (ifp == NULL)
+			return (EADDRNOTAVAIL);
 		break;
 
 	default:
@@ -2234,9 +2249,6 @@ inp_leave_group(struct inpcb *inp, struct sockopt *sopt)
 	if (!IN_MULTICAST(ntohl(gsa->sin.sin_addr.s_addr)))
 		return (EINVAL);
 
-	if (ifp == NULL)
-		return (EADDRNOTAVAIL);
-
 	/*
 	 * Find the membership in the membership array.
 	 */
diff --git a/sys/netinet/ipfw/ip_dn_glue.c b/sys/netinet/ipfw/ip_dn_glue.c
index c0df1fc04be0..a31ec1f71b81 100644
--- a/sys/netinet/ipfw/ip_dn_glue.c
+++ b/sys/netinet/ipfw/ip_dn_glue.c
@@ -553,7 +553,7 @@ dn_compat_configure(void *v)
 }
 
 int
-dn_compat_calc_size(struct dn_parms dn_cfg)
+dn_compat_calc_size(void)
 {
 	int need = 0;
 	/* XXX use FreeBSD 8 struct size */
diff --git a/sys/netinet/ipfw/ip_dn_io.c b/sys/netinet/ipfw/ip_dn_io.c
index eab9d9e03753..152010eda48a 100644
--- a/sys/netinet/ipfw/ip_dn_io.c
+++ b/sys/netinet/ipfw/ip_dn_io.c
@@ -45,8 +45,11 @@ __FBSDID("$FreeBSD$");
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/sysctl.h>
+
 #include <net/if.h>	/* IFNAMSIZ, struct ifaddr, ifq head, lock.h mutex.h */
 #include <net/netisr.h>
+#include <net/vnet.h>
+
 #include <netinet/in.h>
 #include <netinet/ip.h>		/* ip_len, ip_off */
 #include <netinet/ip_var.h>	/* ip_output(), IP_FORWARDING */
@@ -69,6 +72,7 @@ __FBSDID("$FreeBSD$");
  */
 
 struct dn_parms dn_cfg;
+//VNET_DEFINE(struct dn_parms, _base_dn_cfg);
 
 static long tick_last;		/* Last tick duration (usec). */
 static long tick_delta;		/* Last vs standard tick diff (usec). */
@@ -100,31 +104,34 @@ SYSCTL_DECL(_net_inet);
 SYSCTL_DECL(_net_inet_ip);
 SYSCTL_NODE(_net_inet_ip, OID_AUTO, dummynet, CTLFLAG_RW, 0, "Dummynet");
 
+/* wrapper to pass dn_cfg fields to SYSCTL_* */
+//#define DC(x)	(&(VNET_NAME(_base_dn_cfg).x))
+#define DC(x)	(&(dn_cfg.x))
 /* parameters */
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, hash_size,
-    CTLFLAG_RW, &dn_cfg.hash_size, 0, "Default hash table size");
+    CTLFLAG_RW, DC(hash_size), 0, "Default hash table size");
 SYSCTL_LONG(_net_inet_ip_dummynet, OID_AUTO, pipe_slot_limit,
-    CTLFLAG_RW, &dn_cfg.slot_limit, 0,
+    CTLFLAG_RW, DC(slot_limit), 0,
     "Upper limit in slots for pipe queue.");
 SYSCTL_LONG(_net_inet_ip_dummynet, OID_AUTO, pipe_byte_limit,
-    CTLFLAG_RW, &dn_cfg.byte_limit, 0,
+    CTLFLAG_RW, DC(byte_limit), 0,
     "Upper limit in bytes for pipe queue.");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, io_fast,
-    CTLFLAG_RW, &dn_cfg.io_fast, 0, "Enable fast dummynet io.");
+    CTLFLAG_RW, DC(io_fast), 0, "Enable fast dummynet io.");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, debug,
-    CTLFLAG_RW, &dn_cfg.debug, 0, "Dummynet debug level");
+    CTLFLAG_RW, DC(debug), 0, "Dummynet debug level");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, expire,
-    CTLFLAG_RW, &dn_cfg.expire, 0, "Expire empty queues/pipes");
+    CTLFLAG_RW, DC(expire), 0, "Expire empty queues/pipes");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, expire_cycle,
-    CTLFLAG_RD, &dn_cfg.expire_cycle, 0, "Expire cycle for queues/pipes");
+    CTLFLAG_RD, DC(expire_cycle), 0, "Expire cycle for queues/pipes");
 
 /* RED parameters */
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, red_lookup_depth,
-    CTLFLAG_RD, &dn_cfg.red_lookup_depth, 0, "Depth of RED lookup table");
+    CTLFLAG_RD, DC(red_lookup_depth), 0, "Depth of RED lookup table");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, red_avg_pkt_size,
-    CTLFLAG_RD, &dn_cfg.red_avg_pkt_size, 0, "RED Medium packet size");
+    CTLFLAG_RD, DC(red_avg_pkt_size), 0, "RED Medium packet size");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, red_max_pkt_size,
-    CTLFLAG_RD, &dn_cfg.red_max_pkt_size, 0, "RED Max packet size");
+    CTLFLAG_RD, DC(red_max_pkt_size), 0, "RED Max packet size");
 
 /* time adjustment */
 SYSCTL_LONG(_net_inet_ip_dummynet, OID_AUTO, tick_delta,
@@ -142,13 +149,13 @@ SYSCTL_LONG(_net_inet_ip_dummynet, OID_AUTO, tick_lost,
 
 /* statistics */
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, schk_count,
-    CTLFLAG_RD, &dn_cfg.schk_count, 0, "Number of schedulers");
+    CTLFLAG_RD, DC(schk_count), 0, "Number of schedulers");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, si_count,
-    CTLFLAG_RD, &dn_cfg.si_count, 0, "Number of scheduler instances");
+    CTLFLAG_RD, DC(si_count), 0, "Number of scheduler instances");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, fsk_count,
-    CTLFLAG_RD, &dn_cfg.fsk_count, 0, "Number of flowsets");
+    CTLFLAG_RD, DC(fsk_count), 0, "Number of flowsets");
 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, queue_count,
-    CTLFLAG_RD, &dn_cfg.queue_count, 0, "Number of queues");
+    CTLFLAG_RD, DC(queue_count), 0, "Number of queues");
 SYSCTL_ULONG(_net_inet_ip_dummynet, OID_AUTO, io_pkt,
     CTLFLAG_RD, &io_pkt, 0,
     "Number of packets passed to dummynet.");
@@ -158,7 +165,7 @@ SYSCTL_ULONG(_net_inet_ip_dummynet, OID_AUTO, io_pkt_fast,
 SYSCTL_ULONG(_net_inet_ip_dummynet, OID_AUTO, io_pkt_drop,
     CTLFLAG_RD, &io_pkt_drop, 0,
     "Number of packets dropped by dummynet.");
-
+#undef DC
 SYSEND
 
 #endif
@@ -496,6 +503,8 @@ dummynet_task(void *context, int pending)
 	struct timeval t;
 	struct mq q = { NULL, NULL }; /* queue to accumulate results */
 
+	CURVNET_SET((struct vnet *)context);
+
 	DN_BH_WLOCK();
 
 	/* Update number of lost(coalesced) ticks. */
@@ -560,6 +569,7 @@ dummynet_task(void *context, int pending)
 	dn_reschedule();
 	if (q.head != NULL)
 		dummynet_send(q.head);
+	CURVNET_RESTORE();
 }
 
 /*
diff --git a/sys/netinet/ipfw/ip_dn_private.h b/sys/netinet/ipfw/ip_dn_private.h
index 270f18813268..f1a7f3fa5096 100644
--- a/sys/netinet/ipfw/ip_dn_private.h
+++ b/sys/netinet/ipfw/ip_dn_private.h
@@ -150,6 +150,8 @@ struct dn_parms {
 	uint32_t expire;
 	uint32_t expire_cycle;	/* tick count */
 	
+	int init_done;
+
 	/* if the upper half is busy doing something long,
 	 * can set the busy flag and we will enqueue packets in
 	 * a queue for later processing.
@@ -354,6 +356,8 @@ enum {
 };
 
 extern struct dn_parms dn_cfg;
+//VNET_DECLARE(struct dn_parms, _base_dn_cfg);
+//#define dn_cfg              VNET(_base_dn_cfg)
 
 int dummynet_io(struct mbuf **, int , struct ip_fw_args *);
 void dummynet_task(void *context, int pending);
@@ -392,7 +396,7 @@ int dn_c_copy_fs(struct dn_fsk *f, struct copy_args *a, int nq);
 int dn_compat_copy_queue(struct copy_args *a, void *_o);
 int dn_compat_copy_pipe(struct copy_args *a, void *_o);
 int copy_data_helper_compat(void *_o, void *_arg);
-int dn_compat_calc_size(struct dn_parms dn_cfg);
+int dn_compat_calc_size(void);
 int do_config(void *p, int l);
 
 /* function to drain idle object */
diff --git a/sys/netinet/ipfw/ip_dummynet.c b/sys/netinet/ipfw/ip_dummynet.c
index d7073eb797ee..0a6d16dc0185 100644
--- a/sys/netinet/ipfw/ip_dummynet.c
+++ b/sys/netinet/ipfw/ip_dummynet.c
@@ -1769,7 +1769,7 @@ compute_space(struct dn_id *cmd, struct copy_args *a)
 		x = DN_C_FS | DN_C_QUEUE;
 		break;
 	case DN_GET_COMPAT:	/* compatibility mode */
-		need =  dn_compat_calc_size(dn_cfg); 
+		need =  dn_compat_calc_size(); 
 		break;
 	}
 	a->flags = x;
@@ -2112,14 +2112,10 @@ ip_dn_ctl(struct sockopt *sopt)
 static void
 ip_dn_init(void)
 {
-	static int init_done = 0;
-
-	if (init_done)
+	if (dn_cfg.init_done)
 		return;
-	init_done = 1;
-	if (bootverbose)
-		printf("DUMMYNET with IPv6 initialized (100131)\n");
-
+	printf("DUMMYNET %p with IPv6 initialized (100409)\n", curvnet);
+	dn_cfg.init_done = 1;
 	/* Set defaults here. MSVC does not accept initializers,
 	 * and this is also useful for vimages
 	 */
@@ -2156,10 +2152,8 @@ ip_dn_init(void)
 	SLIST_INIT(&dn_cfg.schedlist);
 
 	DN_LOCK_INIT();
-	ip_dn_ctl_ptr = ip_dn_ctl;
-	ip_dn_io_ptr = dummynet_io;
 
-	TASK_INIT(&dn_task, 0, dummynet_task, NULL);
+	TASK_INIT(&dn_task, 0, dummynet_task, curvnet);
 	dn_tq = taskqueue_create_fast("dummynet", M_NOWAIT,
 	    taskqueue_thread_enqueue, &dn_tq);
 	taskqueue_start_threads(&dn_tq, 1, PI_NET, "dummynet");
@@ -2173,13 +2167,16 @@ ip_dn_init(void)
 
 #ifdef KLD_MODULE
 static void
-ip_dn_destroy(void)
+ip_dn_destroy(int last)
 {
 	callout_drain(&dn_timeout);
 
 	DN_BH_WLOCK();
-	ip_dn_ctl_ptr = NULL;
-	ip_dn_io_ptr = NULL;
+	if (last) {
+		printf("%s removing last instance\n", __FUNCTION__);
+		ip_dn_ctl_ptr = NULL;
+		ip_dn_io_ptr = NULL;
+	}
 
 	dummynet_flush();
 	DN_BH_WUNLOCK();
@@ -2204,13 +2201,15 @@ dummynet_modevent(module_t mod, int type, void *data)
 			return EEXIST ;
 		}
 		ip_dn_init();
+		ip_dn_ctl_ptr = ip_dn_ctl;
+		ip_dn_io_ptr = dummynet_io;
 		return 0;
 	} else if (type == MOD_UNLOAD) {
 #if !defined(KLD_MODULE)
 		printf("dummynet statically compiled, cannot unload\n");
 		return EINVAL ;
 #else
-		ip_dn_destroy();
+		ip_dn_destroy(1 /* last */);
 		return 0;
 #endif
 	} else
@@ -2288,8 +2287,24 @@ static moduledata_t dummynet_mod = {
 	"dummynet", dummynet_modevent, NULL
 };
 
-DECLARE_MODULE(dummynet, dummynet_mod,
-	SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY-1);
+#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, 1);
+
+/*
+ * Starting up. Done in order after dummynet_modevent() has been called.
+ * VNET_SYSINIT is also called for each existing vnet and each new vnet.
+ */
+//VNET_SYSINIT(vnet_dn_init, DN_SI_SUB, DN_MODEV_ORD+2, ip_dn_init, NULL);
+ 
+/*
+ * Shutdown handlers up shop. These are done in REVERSE ORDER, but still
+ * after dummynet_modevent() has been called. Not called on reboot.
+ * VNET_SYSUNINIT is also called for each exiting vnet as it exits.
+ * or when the module is unloaded.
+ */
+//VNET_SYSUNINIT(vnet_dn_uninit, DN_SI_SUB, DN_MODEV_ORD+2, ip_dn_destroy, NULL);
+
 /* end of file */
diff --git a/sys/netinet/ipfw/ip_fw_sockopt.c b/sys/netinet/ipfw/ip_fw_sockopt.c
index 5f203eae6c68..c50572873a16 100644
--- a/sys/netinet/ipfw/ip_fw_sockopt.c
+++ b/sys/netinet/ipfw/ip_fw_sockopt.c
@@ -232,12 +232,49 @@ ipfw_reap_rules(struct ip_fw *head)
 	}
 }
 
+/*
+ * Used by del_entry() to check if a rule should be kept.
+ * Returns 1 if the rule must be kept, 0 otherwise.
+ *
+ * Called with cmd = {0,1,5}.
+ * cmd == 0 matches on rule numbers, excludes rules in RESVD_SET if n == 0 ;
+ * cmd == 1 matches on set numbers only, rule numbers are ignored;
+ * cmd == 5 matches on rule and set numbers.
+ *
+ * n == 0 is a wildcard for rule numbers, there is no wildcard for sets.
+ *
+ * Rules to keep are
+ *	(default || reserved || !match_set || !match_number)
+ * where
+ *   default ::= (rule->rulenum == IPFW_DEFAULT_RULE)
+ *	// the default rule is always protected
+ *
+ *   reserved ::= (cmd == 0 && n == 0 && rule->set == RESVD_SET)
+ *	// RESVD_SET is protected only if cmd == 0 and n == 0 ("ipfw flush")
+ *
+ *   match_set ::= (cmd == 0 || rule->set == set)
+ *	// set number is ignored for cmd == 0
+ *
+ *   match_number ::= (cmd == 1 || n == 0 || n == rule->rulenum)
+ *	// number is ignored for cmd == 1 or n == 0
+ *
+ */
+static int
+keep_rule(struct ip_fw *rule, uint8_t cmd, uint8_t set, uint32_t n)
+{
+	return
+		 (rule->rulenum == IPFW_DEFAULT_RULE)		||
+		 (cmd == 0 && n == 0 && rule->set == RESVD_SET)	||
+		!(cmd == 0 || rule->set == set)			||
+		!(cmd == 1 || n == 0 || n == rule->rulenum);
+}
+
 /**
- * Remove all rules with given number, and also do set manipulation.
+ * Remove all rules with given number, or do set manipulation.
  * Assumes chain != NULL && *chain != NULL.
  *
- * The argument is an u_int32_t. The low 16 bit are the rule or set number,
- * the next 8 bits are the new set, the top 8 bits are the command:
+ * The argument is an uint32_t. The low 16 bit are the rule or set number;
+ * the next 8 bits are the new set; the top 8 bits indicate the command:
  *
  *	0	delete rules numbered "rulenum"
  *	1	delete rules in set "rulenum"
@@ -247,26 +284,26 @@ ipfw_reap_rules(struct ip_fw *head)
  *	5	delete rules "rulenum" and set "new_set"
  */
 static int
-del_entry(struct ip_fw_chain *chain, u_int32_t arg)
+del_entry(struct ip_fw_chain *chain, uint32_t arg)
 {
 	struct ip_fw *rule;
-	uint32_t rulenum;	/* rule or old_set */
+	uint32_t num;	/* rule number or old_set */
 	uint8_t cmd, new_set;
-	int start, end = 0, i, ofs, n;
+	int start, end, i, ofs, n;
 	struct ip_fw **map = NULL;
 	int error = 0;
 
-	rulenum = arg & 0xffff;
+	num = arg & 0xffff;
 	cmd = (arg >> 24) & 0xff;
 	new_set = (arg >> 16) & 0xff;
 
 	if (cmd > 5 || new_set > RESVD_SET)
 		return EINVAL;
 	if (cmd == 0 || cmd == 2 || cmd == 5) {
-		if (rulenum >= IPFW_DEFAULT_RULE)
+		if (num >= IPFW_DEFAULT_RULE)
 			return EINVAL;
 	} else {
-		if (rulenum > RESVD_SET)	/* old_set */
+		if (num > RESVD_SET)	/* old_set */
 			return EINVAL;
 	}
 
@@ -274,20 +311,24 @@ del_entry(struct ip_fw_chain *chain, u_int32_t arg)
 	chain->reap = NULL;	/* prepare for deletions */
 
 	switch (cmd) {
-	case 0:	/* delete rules "rulenum" (rulenum == 0 matches all) */
+	case 0:	/* delete rules "num" (num == 0 matches all) */
 	case 1:	/* delete all rules in set N */
 	case 5: /* delete rules with number N and set "new_set". */
 
 		/*
 		 * Locate first rule to delete (start), the rule after
 		 * the last one to delete (end), and count how many
-		 * rules to delete (n)
+		 * rules to delete (n). Always use keep_rule() to
+		 * determine which rules to keep.
 		 */
 		n = 0;
-		if (cmd == 1) { /* look for a specific set, must scan all */
-			new_set = rulenum;
-			for (start = -1, i = 0; i < chain->n_rules; i++) {
-				if (chain->map[i]->set != new_set)
+		if (cmd == 1) {
+			/* look for a specific set including RESVD_SET.
+			 * Must scan the entire range, ignore num.
+			 */
+			new_set = num;
+			for (start = -1, end = i = 0; i < chain->n_rules; i++) {
+				if (keep_rule(chain->map[i], cmd, new_set, 0))
 					continue;
 				if (start < 0)
 					start = i;
@@ -296,61 +337,54 @@ del_entry(struct ip_fw_chain *chain, u_int32_t arg)
 			}
 			end++;	/* first non-matching */
 		} else {
-			start = ipfw_find_rule(chain, rulenum, 0);
+			/* Optimized search on rule numbers */
+			start = ipfw_find_rule(chain, num, 0);
 			for (end = start; end < chain->n_rules; end++) {
 				rule = chain->map[end];
-				if (rulenum > 0 && rule->rulenum != rulenum)
+				if (num > 0 && rule->rulenum != num)
 					break;
-				if (rule->set != RESVD_SET &&
-				    (cmd == 0 || rule->set == new_set) )
+				if (!keep_rule(rule, cmd, new_set, num))
 					n++;
 			}
 		}
-		if (n == 0 && arg == 0)
-			break; /* special case, flush on empty ruleset */
-		/* allocate the map, if needed */
-		if (n > 0)
-			map = get_map(chain, -n, 1 /* locked */);
-		if (n == 0 || map == NULL) {
+
+		if (n == 0) {
+			/* A flush request (arg == 0) on empty ruleset
+			 * returns with no error. On the contrary,
+			 * if there is no match on a specific request,
+			 * we return EINVAL.
+			 */
+			error = (arg == 0) ? 0 : EINVAL;
+			break;
+		}
+
+		/* We have something to delete. Allocate the new map */
+		map = get_map(chain, -n, 1 /* locked */);
+		if (map == NULL) {
 			error = EINVAL;
 			break;
 		}
-		/*
-		 * bcopy the initial part of the map, then individually
-		 * copy all matching entries between start and end,
-		 * and then bcopy the final part.
-		 * Once we are done we can swap maps and clean up the
-		 * deleted rules (unfortunately we need to repeat a
-		 * convoluted test). Rules to keep are
-		 *	(set == RESVD_SET || !match_set || !match_rule)
-		 * where
-		 *   match_set ::= (cmd == 0 || rule->set == new_set)
-		 *   match_rule ::= (cmd == 1 || rule->rulenum == rulenum)
-		 */
+
+		/* 1. bcopy the initial part of the map */
 		if (start > 0)
 			bcopy(chain->map, map, start * sizeof(struct ip_fw *));
+		/* 2. copy active rules between start and end */
 		for (i = ofs = start; i < end; i++) {
 			rule = chain->map[i];
-			if (rule->set == RESVD_SET ||
-			    !(cmd == 0 || rule->set == new_set) ||
-			    !(cmd == 1 || rule->rulenum == rulenum) ) {
-				map[ofs++] = chain->map[i];
-			}
+			if (keep_rule(rule, cmd, new_set, num))
+				map[ofs++] = rule;
 		}
+		/* 3. copy the final part of the map */
 		bcopy(chain->map + end, map + ofs,
 			(chain->n_rules - end) * sizeof(struct ip_fw *));
-
+		/* 4. swap the maps (under BH_LOCK) */
 		map = swap_map(chain, map, chain->n_rules - n);
-		/* now remove the rules deleted */
+		/* 5. now remove the rules deleted from the old map */
 		for (i = start; i < end; i++) {
 			int l;
 			rule = map[i];
-			/* same test as above */
-			if (rule->set == RESVD_SET ||
-			    !(cmd == 0 || rule->set == new_set) ||
-			    !(cmd == 1 || rule->rulenum == rulenum) )
+			if (keep_rule(rule, cmd, new_set, num))
 				continue;
-
 			l = RULESIZE(rule);
 			chain->static_len -= l;
 			ipfw_remove_dyn_children(rule);
@@ -359,32 +393,38 @@ del_entry(struct ip_fw_chain *chain, u_int32_t arg)
 		}
 		break;
 
-	case 2:	/* move rules with given number to new set */
-		for (i = 0; i < chain->n_rules; i++) {
+	/*
+	 * In the next 3 cases the loop stops at (n_rules - 1)
+	 * because the default rule is never eligible..
+	 */
+
+	case 2:	/* move rules with given RULE number to new set */
+		for (i = 0; i < chain->n_rules - 1; i++) {
 			rule = chain->map[i];
-			if (rule->rulenum == rulenum)
+			if (rule->rulenum == num)
 				rule->set = new_set;
 		}
 		break;
 
-	case 3: /* move rules with given set number to new set */
-		for (i = 0; i < chain->n_rules; i++) {
+	case 3: /* move rules with given SET number to new set */
+		for (i = 0; i < chain->n_rules - 1; i++) {
 			rule = chain->map[i];
-			if (rule->set == rulenum)
+			if (rule->set == num)
 				rule->set = new_set;
 		}
 		break;
 
 	case 4: /* swap two sets */
-		for (i = 0; i < chain->n_rules; i++) {
+		for (i = 0; i < chain->n_rules - 1; i++) {
 			rule = chain->map[i];
-			if (rule->set == rulenum)
+			if (rule->set == num)
 				rule->set = new_set;
 			else if (rule->set == new_set)
-				rule->set = rulenum;
+				rule->set = num;
 		}
 		break;
 	}
+
 	rule = chain->reap;
 	chain->reap = NULL;
 	IPFW_UH_WUNLOCK(chain);
diff --git a/sys/netinet/sctp_asconf.c b/sys/netinet/sctp_asconf.c
index 9513ded33617..f7de414ed1aa 100644
--- a/sys/netinet/sctp_asconf.c
+++ b/sys/netinet/sctp_asconf.c
@@ -556,9 +556,9 @@ sctp_process_asconf_set_primary(struct mbuf *m,
 		 * PRIMARY with DELETE IP ADDRESS of the previous primary
 		 * destination, unacknowledged DATA are retransmitted
 		 * immediately to the new primary destination for seamless
-		 * handover.  If the destination is UNCONFIRMED and marked
-		 * to REQ_PRIM, The retransmission occur when reception of
-		 * the HEARTBEAT-ACK.  (See sctp_handle_heartbeat_ack in
+		 * handover. If the destination is UNCONFIRMED and marked to
+		 * REQ_PRIM, The retransmission occur when reception of the
+		 * HEARTBEAT-ACK.  (See sctp_handle_heartbeat_ack in
 		 * sctp_input.c) Also, when change of the primary
 		 * destination, it is better that all subsequent new DATA
 		 * containing already queued DATA are transmitted to the new
@@ -1166,7 +1166,7 @@ sctp_path_check_and_react(struct sctp_tcb *stcb, struct sctp_ifa *newifa)
 
 	/*
 	 * If number of local valid addresses is 1, the valid address is
-	 * probably newly added address.  Several valid addresses in this
+	 * probably newly added address. Several valid addresses in this
 	 * association.  A source address may not be changed.  Additionally,
 	 * they can be configured on a same interface as "alias" addresses.
 	 * (by micchie)
@@ -1210,7 +1210,7 @@ sctp_path_check_and_react(struct sctp_tcb *stcb, struct sctp_ifa *newifa)
 		/*
 		 * Check if the nexthop is corresponding to the new address.
 		 * If the new address is corresponding to the current
-		 * nexthop, the path will be changed.  If the new address is
+		 * nexthop, the path will be changed. If the new address is
 		 * NOT corresponding to the current nexthop, the path will
 		 * not be changed.
 		 */
diff --git a/sys/netinet/sctp_constants.h b/sys/netinet/sctp_constants.h
index 4a013d3df114..3d886311a677 100644
--- a/sys/netinet/sctp_constants.h
+++ b/sys/netinet/sctp_constants.h
@@ -544,13 +544,7 @@ __FBSDID("$FreeBSD$");
 #define SCTP_INITIAL_MAPPING_ARRAY  16
 /* how much we grow the mapping array each call */
 #define SCTP_MAPPING_ARRAY_INCR     32
-/* EY 05/13/08 - nr_sack version of the previous 3 constants */
-/* Maximum the nr mapping array will  grow to (TSN mapping array) */
-#define SCTP_NR_MAPPING_ARRAY	512
-/* size of the inital malloc on the nr mapping array */
-#define SCTP_INITIAL_NR_MAPPING_ARRAY  16
-/* how much we grow the nr mapping array each call */
-#define SCTP_NR_MAPPING_ARRAY_INCR     32
+
 /*
  * Here we define the timer types used by the implementation as arguments in
  * the set/get timer type calls.
@@ -933,6 +927,13 @@ __FBSDID("$FreeBSD$");
 #define SCTP_IS_TSN_PRESENT(arry, gap) ((arry[(gap >> 3)] >> (gap & 0x07)) & 0x01)
 #define SCTP_SET_TSN_PRESENT(arry, gap) (arry[(gap >> 3)] |= (0x01 << ((gap & 0x07))))
 #define SCTP_UNSET_TSN_PRESENT(arry, gap) (arry[(gap >> 3)] &= ((~(0x01 << ((gap & 0x07)))) & 0xff))
+#define SCTP_CALC_TSN_TO_GAP(gap, tsn, mapping_tsn) do { \
+	                if (tsn >= mapping_tsn) { \
+						gap = tsn - mapping_tsn; \
+					} else { \
+						gap = (MAX_TSN - mapping_tsn) + tsn + 1; \
+					} \
+                  } while(0)
 
 
 #define SCTP_RETRAN_DONE -1
diff --git a/sys/netinet/sctp_indata.c b/sys/netinet/sctp_indata.c
index 243d773723d4..53dcf8f2a6f8 100644
--- a/sys/netinet/sctp_indata.c
+++ b/sys/netinet/sctp_indata.c
@@ -45,13 +45,6 @@ __FBSDID("$FreeBSD$");
 #include <netinet/sctp_uio.h>
 #include <netinet/sctp_timer.h>
 
-#define SCTP_CALC_TSN_TO_GAP(gap, tsn, mapping_tsn) do { \
-	                if (tsn >= mapping_tsn) { \
-						gap = tsn - mapping_tsn; \
-					} else { \
-						gap = (MAX_TSN - mapping_tsn) + tsn + 1; \
-					} \
-                  } while(0)
 
 /*
  * NOTES: On the outbound side of things I need to check the sack timer to
@@ -303,13 +296,13 @@ sctp_mark_non_revokable(struct sctp_association *asoc, uint32_t tsn)
 		return;
 	}
 	SCTP_CALC_TSN_TO_GAP(gap, tsn, asoc->mapping_array_base_tsn);
-#ifdef INVARIANTS
 	if (!SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) {
 		printf("gap:%x tsn:%x\n", gap, tsn);
 		sctp_print_mapping_array(asoc);
+#ifdef INVARIANTS
 		panic("Things are really messed up now!!");
-	}
 #endif
+	}
 	SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap);
 	SCTP_UNSET_TSN_PRESENT(asoc->mapping_array, gap);
 	if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) {
@@ -317,7 +310,8 @@ sctp_mark_non_revokable(struct sctp_association *asoc, uint32_t tsn)
 	}
 	if (tsn == asoc->highest_tsn_inside_map) {
 		/* We must back down to see what the new highest is */
-		for (i = tsn - 1; compare_with_wrap(i, asoc->mapping_array_base_tsn, MAX_TSN); i--) {
+		for (i = tsn - 1; (compare_with_wrap(i, asoc->mapping_array_base_tsn, MAX_TSN) ||
+		    (i == asoc->mapping_array_base_tsn)); i--) {
 			SCTP_CALC_TSN_TO_GAP(gap, i, asoc->mapping_array_base_tsn);
 			if (SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) {
 				asoc->highest_tsn_inside_map = i;
@@ -411,6 +405,7 @@ abandon:
 				end = 1;
 			else
 				end = 0;
+			sctp_mark_non_revokable(asoc, chk->rec.data.TSN_seq);
 			sctp_add_to_readq(stcb->sctp_ep,
 			    stcb, control, &stcb->sctp_socket->so_rcv, end,
 			    SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);
@@ -420,6 +415,7 @@ abandon:
 				end = 1;
 			else
 				end = 0;
+			sctp_mark_non_revokable(asoc, chk->rec.data.TSN_seq);
 			if (sctp_append_to_readq(stcb->sctp_ep, stcb,
 			    stcb->asoc.control_pdapi,
 			    chk->data, end, chk->rec.data.TSN_seq,
@@ -454,7 +450,6 @@ abandon:
 		}
 		/* pull it we did it */
 		TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next);
-		sctp_mark_non_revokable(asoc, chk->rec.data.TSN_seq);
 		if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) {
 			asoc->fragmented_delivery_inprogress = 0;
 			if ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0) {
@@ -501,11 +496,11 @@ abandon:
 						asoc->size_on_all_streams -= ctl->length;
 						sctp_ucount_decr(asoc->cnt_on_all_streams);
 						strm->last_sequence_delivered++;
+						sctp_mark_non_revokable(asoc, ctl->sinfo_tsn);
 						sctp_add_to_readq(stcb->sctp_ep, stcb,
 						    ctl,
 						    &stcb->sctp_socket->so_rcv, 1,
 						    SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);
-						sctp_mark_non_revokable(asoc, ctl->sinfo_tsn);
 						ctl = ctlat;
 					} else {
 						break;
@@ -616,11 +611,11 @@ protocol_error:
 		sctp_ucount_decr(asoc->cnt_on_all_streams);
 		strm->last_sequence_delivered++;
 
+		sctp_mark_non_revokable(asoc, control->sinfo_tsn);
 		sctp_add_to_readq(stcb->sctp_ep, stcb,
 		    control,
 		    &stcb->sctp_socket->so_rcv, 1,
 		    SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);
-		sctp_mark_non_revokable(asoc, control->sinfo_tsn);
 		control = TAILQ_FIRST(&strm->inqueue);
 		while (control != NULL) {
 			/* all delivered */
@@ -641,13 +636,12 @@ protocol_error:
 					sctp_log_strm_del(control, NULL,
 					    SCTP_STR_LOG_FROM_IMMED_DEL);
 				}
-				/* EY will be used to calculate nr-gap */
+				sctp_mark_non_revokable(asoc, control->sinfo_tsn);
 				sctp_add_to_readq(stcb->sctp_ep, stcb,
 				    control,
 				    &stcb->sctp_socket->so_rcv, 1,
 				    SCTP_READ_LOCK_NOT_HELD,
 				    SCTP_SO_NOT_LOCKED);
-				sctp_mark_non_revokable(asoc, control->sinfo_tsn);
 				control = at;
 				continue;
 			}
@@ -965,8 +959,7 @@ sctp_queue_data_for_reasm(struct sctp_tcb *stcb, struct sctp_association *asoc,
 					*abort_flag = 1;
 				} else if ((asoc->fragment_flags & SCTP_DATA_UNORDERED) !=
 					    SCTP_DATA_UNORDERED &&
-					    chk->rec.data.stream_seq !=
-				    asoc->ssn_of_pdapi) {
+				    chk->rec.data.stream_seq != asoc->ssn_of_pdapi) {
 					/* Got to be the right STR Seq */
 					SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, it IS not same stream seq %d vs %d\n",
 					    chk->rec.data.stream_seq,
@@ -1623,7 +1616,6 @@ sctp_process_a_data_chunk(struct sctp_tcb *stcb, struct sctp_association *asoc,
 		}
 		SCTP_STAT_INCR(sctps_badsid);
 		SCTP_TCB_LOCK_ASSERT(stcb);
-
 		SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap);
 		if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) {
 			asoc->highest_tsn_inside_nr_map = tsn;
@@ -1787,6 +1779,7 @@ sctp_process_a_data_chunk(struct sctp_tcb *stcb, struct sctp_association *asoc,
 			    SCTP_STR_LOG_FROM_EXPRS_DEL);
 		}
 		control = NULL;
+
 		SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap);
 		if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) {
 			asoc->highest_tsn_inside_nr_map = tsn;
@@ -1853,10 +1846,6 @@ failed_express_del:
 					need_reasm_check = 1;
 				}
 			}
-			SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap);
-			if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) {
-				asoc->highest_tsn_inside_nr_map = tsn;
-			}
 			control = NULL;
 			goto finish_express_del;
 		}
@@ -2059,10 +2048,10 @@ failed_pdapi_express_del:
 		/* ok, if we reach here we have passed the sanity checks */
 		if (chunk_flags & SCTP_DATA_UNORDERED) {
 			/* queue directly into socket buffer */
+			sctp_mark_non_revokable(asoc, control->sinfo_tsn);
 			sctp_add_to_readq(stcb->sctp_ep, stcb,
 			    control,
 			    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);
-
 		} else {
 			/*
 			 * Special check for when streams are resetting. We
@@ -2134,10 +2123,6 @@ failed_pdapi_express_del:
 		}
 	}
 finish_express_del:
-	if (tsn == (asoc->cumulative_tsn + 1)) {
-		/* Update cum-ack */
-		asoc->cumulative_tsn = tsn;
-	}
 	if (last_chunk) {
 		*m = NULL;
 	}
@@ -2215,43 +2200,43 @@ finish_express_del:
 }
 
 int8_t sctp_map_lookup_tab[256] = {
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 4,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 5,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 4,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 6,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 4,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 5,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 4,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 3,
-	-1, 0, -1, 1, -1, 0, -1, 2,
-	-1, 0, -1, 1, -1, 0, -1, 7,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 5,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 6,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 5,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 7,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 5,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 6,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 5,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 4,
+	0, 1, 0, 2, 0, 1, 0, 3,
+	0, 1, 0, 2, 0, 1, 0, 8
 };
 
 
 void
-sctp_sack_check(struct sctp_tcb *stcb, int ok_to_sack, int was_a_gap, int *abort_flag)
+sctp_slide_mapping_arrays(struct sctp_tcb *stcb)
 {
 	/*
 	 * Now we also need to check the mapping array in a couple of ways.
@@ -2259,7 +2244,6 @@ sctp_sack_check(struct sctp_tcb *stcb, int ok_to_sack, int was_a_gap, int *abort
 	 */
 	struct sctp_association *asoc;
 	int at;
-	int last_all_ones = 0;
 	int slide_from, slide_end, lgap, distance;
 
 	/* EY nr_mapping array variables */
@@ -2279,23 +2263,19 @@ sctp_sack_check(struct sctp_tcb *stcb, int ok_to_sack, int was_a_gap, int *abort
 	 * offset of the current cum-ack as the starting point.
 	 */
 	at = 0;
-	for (slide_from = 0; slide_from < stcb->asoc.nr_mapping_array_size; slide_from++) {
+	for (slide_from = 0; slide_from < stcb->asoc.mapping_array_size; slide_from++) {
 		if (asoc->nr_mapping_array[slide_from] == 0xff) {
 			at += 8;
-			last_all_ones = 1;
 		} else {
 			/* there is a 0 bit */
 			at += sctp_map_lookup_tab[asoc->nr_mapping_array[slide_from]];
-			last_all_ones = 0;
 			break;
 		}
 	}
-	asoc->cumulative_tsn = asoc->nr_mapping_array_base_tsn + (at - last_all_ones);
-	at++;
+	asoc->cumulative_tsn = asoc->mapping_array_base_tsn + (at - 1);
 
 	if (compare_with_wrap(asoc->cumulative_tsn, asoc->highest_tsn_inside_map, MAX_TSN) &&
-	    compare_with_wrap(asoc->cumulative_tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)
-	    ) {
+	    compare_with_wrap(asoc->cumulative_tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) {
 #ifdef INVARIANTS
 		panic("huh, cumack 0x%x greater than high-tsn 0x%x in map",
 		    asoc->cumulative_tsn, asoc->highest_tsn_inside_map);
@@ -2320,18 +2300,22 @@ sctp_sack_check(struct sctp_tcb *stcb, int ok_to_sack, int was_a_gap, int *abort
 	if ((asoc->cumulative_tsn == highest_tsn) && (at >= 8)) {
 		/* The complete array was completed by a single FR */
 		/* highest becomes the cum-ack */
-		int clr;
+		int clr, i;
 
 		/* clear the array */
-		clr = (at >> 3) + 1;
+		clr = ((at + 7) >> 3);
 		if (clr > asoc->mapping_array_size) {
 			clr = asoc->mapping_array_size;
 		}
 		memset(asoc->mapping_array, 0, clr);
 		memset(asoc->nr_mapping_array, 0, clr);
-
+		for (i = 0; i < asoc->mapping_array_size; i++) {
+			if ((asoc->mapping_array[i]) || (asoc->nr_mapping_array[i])) {
+				printf("Error Mapping array's not clean at clear\n");
+				sctp_print_mapping_array(asoc);
+			}
+		}
 		asoc->mapping_array_base_tsn = asoc->cumulative_tsn + 1;
-		asoc->nr_mapping_array_base_tsn = asoc->cumulative_tsn + 1;
 		asoc->highest_tsn_inside_nr_map = asoc->highest_tsn_inside_map = asoc->cumulative_tsn;
 	} else if (at >= 8) {
 		/* we can slide the mapping array down */
@@ -2393,12 +2377,11 @@ sctp_sack_check(struct sctp_tcb *stcb, int ok_to_sack, int was_a_gap, int *abort
 				    asoc->nr_mapping_array[slide_from + ii];
 
 			}
-			for (ii = distance; ii <= slide_end; ii++) {
+			for (ii = distance; ii < asoc->mapping_array_size; ii++) {
 				asoc->mapping_array[ii] = 0;
 				asoc->nr_mapping_array[ii] = 0;
 			}
 			asoc->mapping_array_base_tsn += (slide_from << 3);
-			asoc->nr_mapping_array_base_tsn += (slide_from << 3);
 			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) {
 				sctp_log_map(asoc->mapping_array_base_tsn,
 				    asoc->cumulative_tsn, asoc->highest_tsn_inside_map,
@@ -2406,95 +2389,95 @@ sctp_sack_check(struct sctp_tcb *stcb, int ok_to_sack, int was_a_gap, int *abort
 			}
 		}
 	}
+}
+
+
+void
+sctp_sack_check(struct sctp_tcb *stcb, int was_a_gap, int *abort_flag)
+{
+	struct sctp_association *asoc;
+	uint32_t highest_tsn;
+
+	asoc = &stcb->asoc;
+	if (compare_with_wrap(asoc->highest_tsn_inside_nr_map,
+	    asoc->highest_tsn_inside_map,
+	    MAX_TSN)) {
+		highest_tsn = asoc->highest_tsn_inside_nr_map;
+	} else {
+		highest_tsn = asoc->highest_tsn_inside_map;
+	}
+
 	/*
 	 * Now we need to see if we need to queue a sack or just start the
 	 * timer (if allowed).
 	 */
-	if (ok_to_sack) {
-		if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) {
-			/*
-			 * Ok special case, in SHUTDOWN-SENT case. here we
-			 * maker sure SACK timer is off and instead send a
-			 * SHUTDOWN and a SACK
-			 */
-			if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
-				sctp_timer_stop(SCTP_TIMER_TYPE_RECV,
-				    stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_INDATA + SCTP_LOC_18);
-			}
-			sctp_send_shutdown(stcb, stcb->asoc.primary_destination);
-			/*
-			 * EY if nr_sacks used then send an nr-sack , a sack
-			 * otherwise
-			 */
-			if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) && stcb->asoc.peer_supports_nr_sack)
-				sctp_send_nr_sack(stcb);
-			else
-				sctp_send_sack(stcb);
-		} else {
-			int is_a_gap;
+	if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) {
+		/*
+		 * Ok special case, in SHUTDOWN-SENT case. here we maker
+		 * sure SACK timer is off and instead send a SHUTDOWN and a
+		 * SACK
+		 */
+		if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
+			sctp_timer_stop(SCTP_TIMER_TYPE_RECV,
+			    stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_INDATA + SCTP_LOC_18);
+		}
+		sctp_send_shutdown(stcb, stcb->asoc.primary_destination);
+		sctp_send_sack(stcb);
+	} else {
+		int is_a_gap;
 
-			/* is there a gap now ? */
-			is_a_gap = compare_with_wrap(highest_tsn, stcb->asoc.cumulative_tsn, MAX_TSN);
+		/* is there a gap now ? */
+		is_a_gap = compare_with_wrap(highest_tsn, stcb->asoc.cumulative_tsn, MAX_TSN);
 
-			/*
-			 * CMT DAC algorithm: increase number of packets
-			 * received since last ack
-			 */
-			stcb->asoc.cmt_dac_pkts_rcvd++;
+		/*
+		 * CMT DAC algorithm: increase number of packets received
+		 * since last ack
+		 */
+		stcb->asoc.cmt_dac_pkts_rcvd++;
 
-			if ((stcb->asoc.send_sack == 1) ||	/* We need to send a
-								 * SACK */
-			    ((was_a_gap) && (is_a_gap == 0)) ||	/* was a gap, but no
-								 * longer is one */
-			    (stcb->asoc.numduptsns) ||	/* we have dup's */
-			    (is_a_gap) ||	/* is still a gap */
-			    (stcb->asoc.delayed_ack == 0) ||	/* Delayed sack disabled */
-			    (stcb->asoc.data_pkts_seen >= stcb->asoc.sack_freq)	/* hit limit of pkts */
-			    ) {
+		if ((stcb->asoc.send_sack == 1) ||	/* We need to send a
+							 * SACK */
+		    ((was_a_gap) && (is_a_gap == 0)) ||	/* was a gap, but no
+							 * longer is one */
+		    (stcb->asoc.numduptsns) ||	/* we have dup's */
+		    (is_a_gap) ||	/* is still a gap */
+		    (stcb->asoc.delayed_ack == 0) ||	/* Delayed sack disabled */
+		    (stcb->asoc.data_pkts_seen >= stcb->asoc.sack_freq)	/* hit limit of pkts */
+		    ) {
 
-				if ((SCTP_BASE_SYSCTL(sctp_cmt_on_off)) &&
-				    (SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) &&
-				    (stcb->asoc.send_sack == 0) &&
-				    (stcb->asoc.numduptsns == 0) &&
-				    (stcb->asoc.delayed_ack) &&
-				    (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer))) {
+			if ((SCTP_BASE_SYSCTL(sctp_cmt_on_off)) &&
+			    (SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) &&
+			    (stcb->asoc.send_sack == 0) &&
+			    (stcb->asoc.numduptsns == 0) &&
+			    (stcb->asoc.delayed_ack) &&
+			    (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer))) {
 
-					/*
-					 * CMT DAC algorithm: With CMT,
-					 * delay acks even in the face of
-					 * 
-					 * reordering. Therefore, if acks that
-					 * do not have to be sent because of
-					 * the above reasons, will be
-					 * delayed. That is, acks that would
-					 * have been sent due to gap reports
-					 * will be delayed with DAC. Start
-					 * the delayed ack timer.
-					 */
-					sctp_timer_start(SCTP_TIMER_TYPE_RECV,
-					    stcb->sctp_ep, stcb, NULL);
-				} else {
-					/*
-					 * Ok we must build a SACK since the
-					 * timer is pending, we got our
-					 * first packet OR there are gaps or
-					 * duplicates.
-					 */
-					(void)SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer);
-					/*
-					 * EY if nr_sacks used then send an
-					 * nr-sack , a sack otherwise
-					 */
-					if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) && stcb->asoc.peer_supports_nr_sack)
-						sctp_send_nr_sack(stcb);
-					else
-						sctp_send_sack(stcb);
-				}
+				/*
+				 * CMT DAC algorithm: With CMT, delay acks
+				 * even in the face of
+				 * 
+				 * reordering. Therefore, if acks that do not
+				 * have to be sent because of the above
+				 * reasons, will be delayed. That is, acks
+				 * that would have been sent due to gap
+				 * reports will be delayed with DAC. Start
+				 * the delayed ack timer.
+				 */
+				sctp_timer_start(SCTP_TIMER_TYPE_RECV,
+				    stcb->sctp_ep, stcb, NULL);
 			} else {
-				if (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
-					sctp_timer_start(SCTP_TIMER_TYPE_RECV,
-					    stcb->sctp_ep, stcb, NULL);
-				}
+				/*
+				 * Ok we must build a SACK since the timer
+				 * is pending, we got our first packet OR
+				 * there are gaps or duplicates.
+				 */
+				(void)SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer);
+				sctp_send_sack(stcb);
+			}
+		} else {
+			if (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
+				sctp_timer_start(SCTP_TIMER_TYPE_RECV,
+				    stcb->sctp_ep, stcb, NULL);
 			}
 		}
 	}
@@ -2834,14 +2817,7 @@ sctp_process_data(struct mbuf **mm, int iphlen, int *offset, int length,
 			if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
 				(void)SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer);
 			}
-			/*
-			 * EY if nr_sacks used then send an nr-sack , a sack
-			 * otherwise
-			 */
-			if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) && stcb->asoc.peer_supports_nr_sack)
-				sctp_send_nr_sack(stcb);
-			else
-				sctp_send_sack(stcb);
+			sctp_send_sack(stcb);
 		} else {
 			if (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
 				sctp_timer_start(SCTP_TIMER_TYPE_RECV,
@@ -2849,7 +2825,7 @@ sctp_process_data(struct mbuf **mm, int iphlen, int *offset, int length,
 			}
 		}
 	} else {
-		sctp_sack_check(stcb, 1, was_a_gap, &abort_flag);
+		sctp_sack_check(stcb, was_a_gap, &abort_flag);
 	}
 	if (abort_flag)
 		return (2);
@@ -2867,7 +2843,7 @@ sctp_process_segment_range(struct sctp_tcb *stcb, struct sctp_tmit_chunk **p_tp1
 {
 	struct sctp_tmit_chunk *tp1;
 	unsigned int theTSN;
-	int j, wake_him = 0;
+	int j, wake_him = 0, circled = 0;
 
 	/* Recover the tp1 we last saw */
 	tp1 = *p_tp1;
@@ -3045,12 +3021,6 @@ sctp_process_segment_range(struct sctp_tcb *stcb, struct sctp_tmit_chunk **p_tp1
 					}
 					/* NR Sack code here */
 					if (nr_sacking) {
-						if (tp1->sent != SCTP_FORWARD_TSN_SKIP)
-							tp1->sent = SCTP_DATAGRAM_NR_MARKED;
-						/*
-						 * TAILQ_REMOVE(&asoc->sent_q
-						 * ueue, tp1, sctp_next);
-						 */
 						if (tp1->data) {
 							/*
 							 * sa_ignore
@@ -3058,13 +3028,8 @@ sctp_process_segment_range(struct sctp_tcb *stcb, struct sctp_tmit_chunk **p_tp1
 							 */
 							sctp_free_bufspace(stcb, &stcb->asoc, tp1, 1);
 							sctp_m_freem(tp1->data);
+							tp1->data = NULL;
 						}
-						tp1->data = NULL;
-						/* asoc->sent_queue_cnt--; */
-						/*
-						 * sctp_free_a_chunk(stcb,
-						 * tp1);
-						 */
 						wake_him++;
 					}
 				}
@@ -3075,11 +3040,16 @@ sctp_process_segment_range(struct sctp_tcb *stcb, struct sctp_tmit_chunk **p_tp1
 				break;
 
 			tp1 = TAILQ_NEXT(tp1, sctp_next);
+			if ((tp1 == NULL) && (circled == 0)) {
+				circled++;
+				tp1 = TAILQ_FIRST(&stcb->asoc.sent_queue);
+			}
 		}		/* end while (tp1) */
-		/* In case the fragments were not in order we must reset */
 		if (tp1 == NULL) {
+			circled = 0;
 			tp1 = TAILQ_FIRST(&stcb->asoc.sent_queue);
 		}
+		/* In case the fragments were not in order we must reset */
 	}			/* end for (j = fragStart */
 	*p_tp1 = tp1;
 	return (wake_him);	/* Return value only used for nr-sack */
@@ -3158,6 +3128,9 @@ sctp_handle_segments(struct mbuf *m, int *offset, struct sctp_tcb *stcb, struct
 		} else {
 			non_revocable = 1;
 		}
+		if (i == num_seg) {
+			tp1 = NULL;
+		}
 		if (sctp_process_segment_range(stcb, &tp1, last_tsn, frag_strt, frag_end,
 		    non_revocable, &num_frs, biggest_newly_acked_tsn,
 		    this_sack_lowest_newack, ecn_seg_sums)) {
@@ -3961,6 +3934,7 @@ sctp_express_handle_sack(struct sctp_tcb *stcb, uint32_t cumack,
 #ifdef INVARIANTS
 			panic("Impossible sack 1");
 #else
+
 			*abort_now = 1;
 			/* XXX */
 			oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)),
@@ -4439,50 +4413,6 @@ again:
 	}
 }
 
-/* EY- nr_sack */
-/* Identifies the non-renegable tsns that are revoked*/
-static void
-sctp_check_for_nr_revoked(struct sctp_tcb *stcb,
-    struct sctp_association *asoc, uint32_t cumack,
-    uint32_t biggest_tsn_acked)
-{
-	struct sctp_tmit_chunk *tp1;
-
-	for (tp1 = TAILQ_FIRST(&asoc->sent_queue); tp1; tp1 = TAILQ_NEXT(tp1, sctp_next)) {
-		if (compare_with_wrap(tp1->rec.data.TSN_seq, cumack,
-		    MAX_TSN)) {
-			/*
-			 * ok this guy is either ACK or MARKED. If it is
-			 * ACKED it has been previously acked but not this
-			 * time i.e. revoked.  If it is MARKED it was ACK'ed
-			 * again.
-			 */
-			if (compare_with_wrap(tp1->rec.data.TSN_seq, biggest_tsn_acked,
-			    MAX_TSN))
-				break;
-
-
-			if (tp1->sent == SCTP_DATAGRAM_NR_ACKED) {
-				/*
-				 * EY! a non-renegable TSN is revoked, need
-				 * to abort the association
-				 */
-				/*
-				 * EY TODO: put in the code to abort the
-				 * assoc.
-				 */
-				return;
-			} else if (tp1->sent == SCTP_DATAGRAM_NR_MARKED) {
-				/* it has been re-acked in this SACK */
-				tp1->sent = SCTP_DATAGRAM_NR_ACKED;
-			}
-		}
-		if (tp1->sent == SCTP_DATAGRAM_UNSENT)
-			break;
-	}
-	return;
-}
-
 void
 sctp_handle_sack(struct mbuf *m, int offset_seg, int offset_dup,
     struct sctp_tcb *stcb, struct sctp_nets *net_from,
@@ -4588,22 +4518,23 @@ sctp_handle_sack(struct mbuf *m, int offset_seg, int offset_dup,
 			    sctpchunk_listhead);
 			send_s = tp1->rec.data.TSN_seq + 1;
 		} else {
+			tp1 = NULL;
 			send_s = asoc->sending_seq;
 		}
 		if (cum_ack == send_s ||
 		    compare_with_wrap(cum_ack, send_s, MAX_TSN)) {
-#ifndef INVARIANTS
 			struct mbuf *oper;
 
-#endif
-#ifdef INVARIANTS
-	hopeless_peer:
-			panic("Impossible sack 1");
-#else
 			/*
 			 * no way, we have not even sent this TSN out yet.
 			 * Peer is hopelessly messed up with us.
 			 */
+			printf("NEW cum_ack:%x send_s:%x is smaller or equal\n",
+			    cum_ack, send_s);
+			if (tp1) {
+				printf("Got send_s from tsn:%x + 1 of tp1:%p\n",
+				    tp1->rec.data.TSN_seq, tp1);
+			}
 	hopeless_peer:
 			*abort_now = 1;
 			/* XXX */
@@ -4624,7 +4555,6 @@ sctp_handle_sack(struct mbuf *m, int offset_seg, int offset_dup,
 			stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_25;
 			sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED);
 			return;
-#endif
 		}
 	}
 	/**********************/
@@ -4844,6 +4774,10 @@ sctp_handle_sack(struct mbuf *m, int offset_seg, int offset_dup,
 				 * peer is either confused or we are under
 				 * attack. We must abort.
 				 */
+				printf("Hopeless peer! biggest_tsn_acked:%x largest seq:%x\n",
+				    biggest_tsn_acked,
+				    send_s);
+
 				goto hopeless_peer;
 			}
 		}
@@ -4991,15 +4925,9 @@ done_with_it:
 				 */
 				if ((tp1->sent == SCTP_DATAGRAM_NR_ACKED) ||
 				    (tp1->sent == SCTP_DATAGRAM_NR_MARKED)) {
-					/*
-					 * EY! - TODO: Something previously
-					 * nr_gapped is reneged, abort the
-					 * association
-					 */
-					return;
+					continue;
 				}
-				if ((tp1->sent > SCTP_DATAGRAM_RESEND) &&
-				    (tp1->sent < SCTP_FORWARD_TSN_SKIP)) {
+				if (tp1->sent == SCTP_DATAGRAM_ACKED) {
 					tp1->sent = SCTP_DATAGRAM_SENT;
 					if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) {
 						sctp_misc_ints(SCTP_FLIGHT_LOG_UP_REVOKE,
@@ -5028,15 +4956,11 @@ done_with_it:
 		}
 		asoc->saw_sack_with_frags = 0;
 	}
-	if (num_seg)
+	if (num_seg || num_nr_seg)
 		asoc->saw_sack_with_frags = 1;
 	else
 		asoc->saw_sack_with_frags = 0;
 
-	/* EY! - not sure about if there should be an IF */
-	if (num_nr_seg > 0)
-		sctp_check_for_nr_revoked(stcb, asoc, cum_ack, biggest_tsn_acked);
-
 	/* JRS - Use the congestion control given in the CC module */
 	asoc->cc_functions.sctp_cwnd_update_after_sack(stcb, asoc, accum_moved, reneged_all, will_exit_fast_recovery);
 
@@ -5457,11 +5381,10 @@ sctp_kick_prsctp_reorder_queue(struct sctp_tcb *stcb,
 			sctp_ucount_decr(asoc->cnt_on_all_streams);
 			/* deliver it to at least the delivery-q */
 			if (stcb->sctp_socket) {
-				/* EY need the tsn info for calculating nr */
+				sctp_mark_non_revokable(asoc, ctl->sinfo_tsn);
 				sctp_add_to_readq(stcb->sctp_ep, stcb,
 				    ctl,
 				    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_HELD, SCTP_SO_NOT_LOCKED);
-				sctp_mark_non_revokable(asoc, ctl->sinfo_tsn);
 			}
 		} else {
 			/* no more delivery now. */
@@ -5486,10 +5409,10 @@ sctp_kick_prsctp_reorder_queue(struct sctp_tcb *stcb,
 			/* deliver it to at least the delivery-q */
 			strmin->last_sequence_delivered = ctl->sinfo_ssn;
 			if (stcb->sctp_socket) {
+				sctp_mark_non_revokable(asoc, ctl->sinfo_tsn);
 				sctp_add_to_readq(stcb->sctp_ep, stcb,
 				    ctl,
 				    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_HELD, SCTP_SO_NOT_LOCKED);
-				sctp_mark_non_revokable(asoc, ctl->sinfo_tsn);
 
 			}
 			tt = strmin->last_sequence_delivered + 1;
@@ -5593,7 +5516,8 @@ sctp_flush_reassm_for_str_seq(struct sctp_tcb *stcb,
 
 void
 sctp_handle_forward_tsn(struct sctp_tcb *stcb,
-    struct sctp_forward_tsn_chunk *fwd, int *abort_flag, struct mbuf *m, int offset)
+    struct sctp_forward_tsn_chunk *fwd,
+    int *abort_flag, struct mbuf *m, int offset)
 {
 	/*
 	 * ISSUES that MUST be fixed for ECN! When we are the sender of the
@@ -5619,8 +5543,8 @@ sctp_handle_forward_tsn(struct sctp_tcb *stcb,
 	 * report where we are.
 	 */
 	struct sctp_association *asoc;
-	uint32_t new_cum_tsn, gap;
-	unsigned int i, fwd_sz, cumack_set_flag, m_size;
+	uint32_t new_cum_tsn, tsn, gap;
+	unsigned int i, fwd_sz, cumack_set_flag, m_size, fnd = 0;
 	uint32_t str_seq;
 	struct sctp_stream_in *strm;
 	struct sctp_tmit_chunk *chk, *at;
@@ -5657,7 +5581,7 @@ sctp_handle_forward_tsn(struct sctp_tcb *stcb,
 	 * now we know the new TSN is more advanced, let's find the actual
 	 * gap
 	 */
-	SCTP_CALC_TSN_TO_GAP(gap, new_cum_tsn, asoc->nr_mapping_array_base_tsn);
+	SCTP_CALC_TSN_TO_GAP(gap, new_cum_tsn, asoc->mapping_array_base_tsn);
 	asoc->cumulative_tsn = new_cum_tsn;
 	if (gap >= m_size) {
 		if ((long)gap > sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv)) {
@@ -5697,8 +5621,7 @@ sctp_handle_forward_tsn(struct sctp_tcb *stcb,
 		asoc->mapping_array_base_tsn = new_cum_tsn + 1;
 		asoc->highest_tsn_inside_map = new_cum_tsn;
 
-		memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.nr_mapping_array_size);
-		asoc->nr_mapping_array_base_tsn = new_cum_tsn + 1;
+		memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.mapping_array_size);
 		asoc->highest_tsn_inside_nr_map = new_cum_tsn;
 
 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) {
@@ -5710,14 +5633,32 @@ sctp_handle_forward_tsn(struct sctp_tcb *stcb,
 		for (i = 0; i <= gap; i++) {
 			SCTP_UNSET_TSN_PRESENT(asoc->mapping_array, i);
 			SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, i);
+			/* FIX ME add something to set up highest TSN in map */
+		}
+		if (compare_with_wrap(new_cum_tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) {
+			asoc->highest_tsn_inside_nr_map = new_cum_tsn;
+		}
+		if (compare_with_wrap(new_cum_tsn, asoc->highest_tsn_inside_map, MAX_TSN) ||
+		    new_cum_tsn == asoc->highest_tsn_inside_map) {
+			/* We must back down to see what the new highest is */
+			for (tsn = new_cum_tsn; (compare_with_wrap(tsn, asoc->mapping_array_base_tsn, MAX_TSN) ||
+			    (tsn == asoc->mapping_array_base_tsn)); tsn--) {
+				SCTP_CALC_TSN_TO_GAP(gap, tsn, asoc->mapping_array_base_tsn);
+				if (SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) {
+					asoc->highest_tsn_inside_map = tsn;
+					fnd = 1;
+					break;
+				}
+			}
+			if (!fnd) {
+				asoc->highest_tsn_inside_map = asoc->mapping_array_base_tsn - 1;
+			}
 		}
 		/*
 		 * Now after marking all, slide thing forward but no sack
 		 * please.
 		 */
-		sctp_sack_check(stcb, 0, 0, abort_flag);
-		if (*abort_flag)
-			return;
+		sctp_slide_mapping_arrays(stcb);
 	}
 	/*************************************************************/
 	/* 2. Clear up re-assembly queue                             */
diff --git a/sys/netinet/sctp_indata.h b/sys/netinet/sctp_indata.h
index b6a8323a5d5a..79978a5c9921 100644
--- a/sys/netinet/sctp_indata.h
+++ b/sys/netinet/sctp_indata.h
@@ -121,7 +121,9 @@ sctp_process_data(struct mbuf **, int, int *, int, struct sctphdr *,
     struct sctp_inpcb *, struct sctp_tcb *,
     struct sctp_nets *, uint32_t *);
 
-void sctp_sack_check(struct sctp_tcb *, int, int, int *);
+void sctp_slide_mapping_arrays(struct sctp_tcb *stcb);
+
+void sctp_sack_check(struct sctp_tcb *, int, int *);
 
 #endif
 #endif
diff --git a/sys/netinet/sctp_input.c b/sys/netinet/sctp_input.c
index 07518e42cf9e..a2bb0631b1dc 100644
--- a/sys/netinet/sctp_input.c
+++ b/sys/netinet/sctp_input.c
@@ -343,11 +343,6 @@ sctp_process_init(struct sctp_init_chunk *cp, struct sctp_tcb *stcb,
 	asoc->str_reset_seq_in = asoc->asconf_seq_in + 1;
 
 	asoc->mapping_array_base_tsn = ntohl(init->initial_tsn);
-	/*
-	 * EY 05/13/08 - nr_sack: initialize nr_mapping array's base tsn
-	 * like above
-	 */
-	asoc->nr_mapping_array_base_tsn = ntohl(init->initial_tsn);
 	asoc->tsn_last_delivered = asoc->cumulative_tsn = asoc->asconf_seq_in;
 	asoc->last_echo_tsn = asoc->asconf_seq_in;
 	asoc->advanced_peer_ack_point = asoc->last_acked_seq;
@@ -1862,7 +1857,7 @@ sctp_process_cookie_existing(struct mbuf *m, int iphlen, int offset,
 		}
 		if (asoc->nr_mapping_array) {
 			memset(asoc->nr_mapping_array, 0,
-			    asoc->nr_mapping_array_size);
+			    asoc->mapping_array_size);
 		}
 		SCTP_TCB_UNLOCK(stcb);
 		SCTP_INP_INFO_WLOCK();
@@ -2027,7 +2022,7 @@ sctp_process_cookie_new(struct mbuf *m, int iphlen, int offset,
 	 * socket is unbound and we must do an implicit bind. Since we are
 	 * getting a cookie, we cannot be unbound.
 	 */
-	stcb = sctp_aloc_assoc(inp, init_src, 0, &error,
+	stcb = sctp_aloc_assoc(inp, init_src, &error,
 	    ntohl(initack_cp->init.initiate_tag), vrf_id,
 	    (struct thread *)NULL
 	    );
@@ -3236,13 +3231,10 @@ process_chunk_drop(struct sctp_tcb *stcb, struct sctp_chunk_desc *desc,
 		}
 		break;
 	case SCTP_SELECTIVE_ACK:
+	case SCTP_NR_SELECTIVE_ACK:
 		/* resend the sack */
 		sctp_send_sack(stcb);
 		break;
-		/* EY for nr_sacks */
-	case SCTP_NR_SELECTIVE_ACK:
-		sctp_send_nr_sack(stcb);	/* EY resend the nr-sack */
-		break;
 	case SCTP_HEARTBEAT_REQUEST:
 		/* resend a demand HB */
 		if ((stcb->asoc.overall_error_count + 3) < stcb->asoc.max_send_times) {
@@ -3514,8 +3506,7 @@ sctp_handle_stream_reset_response(struct sctp_tcb *stcb,
 					memset(stcb->asoc.mapping_array, 0, stcb->asoc.mapping_array_size);
 
 					stcb->asoc.highest_tsn_inside_nr_map = stcb->asoc.highest_tsn_inside_map;
-					stcb->asoc.nr_mapping_array_base_tsn = stcb->asoc.mapping_array_base_tsn;
-					memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.nr_mapping_array_size);
+					memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.mapping_array_size);
 
 					stcb->asoc.sending_seq = ntohl(resp->receivers_next_tsn);
 					stcb->asoc.last_acked_seq = stcb->asoc.cumulative_tsn;
@@ -3624,8 +3615,7 @@ sctp_handle_str_reset_request_tsn(struct sctp_tcb *stcb,
 		stcb->asoc.mapping_array_base_tsn = stcb->asoc.highest_tsn_inside_map + 1;
 		memset(stcb->asoc.mapping_array, 0, stcb->asoc.mapping_array_size);
 		stcb->asoc.highest_tsn_inside_nr_map = stcb->asoc.highest_tsn_inside_map;
-		stcb->asoc.nr_mapping_array_base_tsn = stcb->asoc.highest_tsn_inside_map + 1;
-		memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.nr_mapping_array_size);
+		memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.mapping_array_size);
 		atomic_add_int(&stcb->asoc.sending_seq, 1);
 		/* save off historical data for retrans */
 		stcb->asoc.last_sending_seq[1] = stcb->asoc.last_sending_seq[0];
@@ -5636,7 +5626,7 @@ sctp_common_input_processing(struct mbuf **mm, int iphlen, int offset,
 			was_a_gap = 1;
 		}
 		stcb->asoc.send_sack = 1;
-		sctp_sack_check(stcb, 1, was_a_gap, &abort_flag);
+		sctp_sack_check(stcb, was_a_gap, &abort_flag);
 		if (abort_flag) {
 			/* Again, we aborted so NO UNLOCK needed */
 			goto out_now;
diff --git a/sys/netinet/sctp_output.c b/sys/netinet/sctp_output.c
index b3e5781ff521..c7a806c0d9e4 100644
--- a/sys/netinet/sctp_output.c
+++ b/sys/netinet/sctp_output.c
@@ -3709,7 +3709,7 @@ sctp_lowlevel_chunk_output(struct sctp_inpcb *inp,
 			    (stcb) &&
 			    (stcb->asoc.loopback_scope))) {
 				m->m_pkthdr.csum_flags = CSUM_SCTP;
-				m->m_pkthdr.csum_data = 0;	/* FIXME MT */
+				m->m_pkthdr.csum_data = 0;
 				SCTP_STAT_INCR(sctps_sendhwcrc);
 			} else {
 				SCTP_STAT_INCR(sctps_sendnocrc);
@@ -4021,7 +4021,7 @@ sctp_lowlevel_chunk_output(struct sctp_inpcb *inp,
 			    (stcb) &&
 			    (stcb->asoc.loopback_scope))) {
 				m->m_pkthdr.csum_flags = CSUM_SCTP;
-				m->m_pkthdr.csum_data = 0;	/* FIXME MT */
+				m->m_pkthdr.csum_data = 0;
 				SCTP_STAT_INCR(sctps_sendhwcrc);
 			} else {
 				SCTP_STAT_INCR(sctps_sendnocrc);
@@ -9003,6 +9003,11 @@ sctp_chunk_retransmission(struct sctp_inpcb *inp,
 			/* No, not sent to this net or not ready for rtx */
 			continue;
 		}
+		if (chk->data == NULL) {
+			printf("TSN:%x chk->snd_count:%d chk->sent:%d can't retran - no data\n",
+			    chk->rec.data.TSN_seq, chk->snd_count, chk->sent);
+			continue;
+		}
 		if ((SCTP_BASE_SYSCTL(sctp_max_retran_chunk)) &&
 		    (chk->snd_count >= SCTP_BASE_SYSCTL(sctp_max_retran_chunk))) {
 			/* Gak, we have exceeded max unlucky retran, abort! */
@@ -9426,14 +9431,7 @@ sctp_chunk_output(struct sctp_inpcb *inp,
 	 * running, if so piggy-back the sack.
 	 */
 	if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
-		/*
-		 * EY if nr_sacks used then send an nr-sack , a sack
-		 * otherwise
-		 */
-		if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) && asoc->peer_supports_nr_sack)
-			sctp_send_nr_sack(stcb);
-		else
-			sctp_send_sack(stcb);
+		sctp_send_sack(stcb);
 		(void)SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer);
 	}
 	while (asoc->sent_queue_retran_cnt) {
@@ -9856,13 +9854,15 @@ void
 sctp_send_sack(struct sctp_tcb *stcb)
 {
 	/*-
-	 * Queue up a SACK in the control queue. We must first check to see
-	 * if a SACK is somehow on the control queue. If so, we will take
-	 * and and remove the old one.
+	 * Queue up a SACK or NR-SACK in the control queue.
+	 * We must first check to see if a SACK or NR-SACK is
+	 * somehow on the control queue.
+	 * If so, we will take and and remove the old one.
 	 */
 	struct sctp_association *asoc;
 	struct sctp_tmit_chunk *chk, *a_chk;
 	struct sctp_sack_chunk *sack;
+	struct sctp_nr_sack_chunk *nr_sack;
 	struct sctp_gap_ack_block *gap_descriptor;
 	struct sack_track *selector;
 	int mergeable = 0;
@@ -9870,12 +9870,20 @@ sctp_send_sack(struct sctp_tcb *stcb)
 	caddr_t limit;
 	uint32_t *dup;
 	int limit_reached = 0;
-	unsigned int i, jstart, siz, j;
-	unsigned int num_gap_blocks = 0, space;
+	unsigned int i, sel_start, siz, j, starting_index;
+	unsigned int num_gap_blocks = 0, num_nr_gap_blocks = 0, space;
 	int num_dups = 0;
 	int space_req;
 	uint32_t highest_tsn;
+	uint8_t flags;
+	uint8_t type;
 
+	if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) &&
+	    stcb->asoc.peer_supports_nr_sack) {
+		type = SCTP_NR_SELECTIVE_ACK;
+	} else {
+		type = SCTP_SELECTIVE_ACK;
+	}
 	a_chk = NULL;
 	asoc = &stcb->asoc;
 	SCTP_TCB_LOCK_ASSERT(stcb);
@@ -9883,9 +9891,10 @@ sctp_send_sack(struct sctp_tcb *stcb)
 		/* Hmm we never received anything */
 		return;
 	}
+	sctp_slide_mapping_arrays(stcb);
 	sctp_set_rwnd(stcb, asoc);
 	TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) {
-		if (chk->rec.chunk_id.id == SCTP_SELECTIVE_ACK) {
+		if (chk->rec.chunk_id.id == type) {
 			/* Hmm, found a sack already on queue, remove it */
 			TAILQ_REMOVE(&asoc->control_send_queue, chk, sctp_next);
 			asoc->ctrl_queue_cnt++;
@@ -9914,8 +9923,7 @@ sctp_send_sack(struct sctp_tcb *stcb)
 			return;
 		}
 		a_chk->copy_by_ref = 0;
-		/* a_chk->rec.chunk_id.id = SCTP_SELECTIVE_ACK; */
-		a_chk->rec.chunk_id.id = SCTP_SELECTIVE_ACK;
+		a_chk->rec.chunk_id.id = type;
 		a_chk->rec.chunk_id.can_take_data = 1;
 	}
 	/* Clear our pkt counts */
@@ -9967,7 +9975,11 @@ sctp_send_sack(struct sctp_tcb *stcb)
 	}
 	if (highest_tsn == asoc->cumulative_tsn) {
 		/* no gaps */
-		space_req = sizeof(struct sctp_sack_chunk);
+		if (type == SCTP_SELECTIVE_ACK) {
+			space_req = sizeof(struct sctp_sack_chunk);
+		} else {
+			space_req = sizeof(struct sctp_nr_sack_chunk);
+		}
 	} else {
 		/* gaps get a cluster */
 		space_req = MCLBYTES;
@@ -10003,15 +10015,13 @@ sctp_send_sack(struct sctp_tcb *stcb)
 	limit = mtod(a_chk->data, caddr_t);
 	limit += space;
 
-	sack = mtod(a_chk->data, struct sctp_sack_chunk *);
-	sack->ch.chunk_type = SCTP_SELECTIVE_ACK;
 	/* 0x01 is used by nonce for ecn */
 	if ((SCTP_BASE_SYSCTL(sctp_ecn_enable)) &&
 	    (SCTP_BASE_SYSCTL(sctp_ecn_nonce)) &&
 	    (asoc->peer_supports_ecn_nonce))
-		sack->ch.chunk_flags = (asoc->receiver_nonce_sum & SCTP_SACK_NONCE_SUM);
+		flags = (asoc->receiver_nonce_sum & SCTP_SACK_NONCE_SUM);
 	else
-		sack->ch.chunk_flags = 0;
+		flags = 0;
 
 	if (SCTP_BASE_SYSCTL(sctp_cmt_on_off) && SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) {
 		/*-
@@ -10019,7 +10029,7 @@ sctp_send_sack(struct sctp_tcb *stcb)
 		 * received, then set high bit to 1, else 0. Reset
 		 * pkts_rcvd.
 		 */
-		sack->ch.chunk_flags |= (asoc->cmt_dac_pkts_rcvd << 6);
+		flags |= (asoc->cmt_dac_pkts_rcvd << 6);
 		asoc->cmt_dac_pkts_rcvd = 0;
 	}
 #ifdef SCTP_ASOCLOG_OF_TSNS
@@ -10029,348 +10039,81 @@ sctp_send_sack(struct sctp_tcb *stcb)
 		stcb->asoc.cumack_log_atsnt = 0;
 	}
 #endif
-	sack->sack.cum_tsn_ack = htonl(asoc->cumulative_tsn);
-	sack->sack.a_rwnd = htonl(asoc->my_rwnd);
-	asoc->my_last_reported_rwnd = asoc->my_rwnd;
-
 	/* reset the readers interpretation */
 	stcb->freed_by_sorcv_sincelast = 0;
 
-	gap_descriptor = (struct sctp_gap_ack_block *)((caddr_t)sack + sizeof(struct sctp_sack_chunk));
-
-	if (highest_tsn > asoc->mapping_array_base_tsn)
-		siz = (((highest_tsn - asoc->mapping_array_base_tsn) + 1) + 7) / 8;
-	else
-		siz = (((MAX_TSN - highest_tsn) + 1) + highest_tsn + 7) / 8;
-
-	if (compare_with_wrap(asoc->mapping_array_base_tsn, asoc->cumulative_tsn, MAX_TSN)) {
-		offset = 1;
-		/*-
-		 * cum-ack behind the mapping array, so we start and use all
-		 * entries.
-		 */
-		jstart = 0;
-	} else {
-		offset = asoc->mapping_array_base_tsn - asoc->cumulative_tsn;
-		/*-
-		 * we skip the first one when the cum-ack is at or above the
-		 * mapping array base. Note this only works if
-		 */
-		jstart = 1;
-	}
-	if (compare_with_wrap(highest_tsn, asoc->cumulative_tsn, MAX_TSN)) {
-		/* we have a gap .. maybe */
-		for (i = 0; i < siz; i++) {
-			selector = &sack_array[(asoc->mapping_array[i] | asoc->nr_mapping_array[i])];
-			if (mergeable && selector->right_edge) {
-				/*
-				 * Backup, left and right edges were ok to
-				 * merge.
-				 */
-				num_gap_blocks--;
-				gap_descriptor--;
-			}
-			if (selector->num_entries == 0)
-				mergeable = 0;
-			else {
-				for (j = jstart; j < selector->num_entries; j++) {
-					if (mergeable && selector->right_edge) {
-						/*
-						 * do a merge by NOT setting
-						 * the left side
-						 */
-						mergeable = 0;
-					} else {
-						/*
-						 * no merge, set the left
-						 * side
-						 */
-						mergeable = 0;
-						gap_descriptor->start = htons((selector->gaps[j].start + offset));
-					}
-					gap_descriptor->end = htons((selector->gaps[j].end + offset));
-					num_gap_blocks++;
-					gap_descriptor++;
-					if (((caddr_t)gap_descriptor + sizeof(struct sctp_gap_ack_block)) > limit) {
-						/* no more room */
-						limit_reached = 1;
-						break;
-					}
-				}
-				if (selector->left_edge) {
-					mergeable = 1;
-				}
-			}
-			if (limit_reached) {
-				/* Reached the limit stop */
-				break;
-			}
-			jstart = 0;
-			offset += 8;
-		}
-		if (num_gap_blocks == 0) {
-			/*
-			 * slide not yet happened, and somehow we got called
-			 * to send a sack. Cumack needs to move up.
-			 */
-			int abort_flag = 0;
-
-			sctp_sack_check(stcb, 0, 0, &abort_flag);
-		}
-	}
-	/* now we must add any dups we are going to report. */
-	if ((limit_reached == 0) && (asoc->numduptsns)) {
-		dup = (uint32_t *) gap_descriptor;
-		for (i = 0; i < asoc->numduptsns; i++) {
-			*dup = htonl(asoc->dup_tsns[i]);
-			dup++;
-			num_dups++;
-			if (((caddr_t)dup + sizeof(uint32_t)) > limit) {
-				/* no more room */
-				break;
-			}
-		}
-		asoc->numduptsns = 0;
-	}
-	/*
-	 * now that the chunk is prepared queue it to the control chunk
-	 * queue.
-	 */
-	a_chk->send_size = (sizeof(struct sctp_sack_chunk) +
-	    (num_gap_blocks * sizeof(struct sctp_gap_ack_block)) +
-	    (num_dups * sizeof(int32_t)));
-	SCTP_BUF_LEN(a_chk->data) = a_chk->send_size;
-	sack->sack.num_gap_ack_blks = htons(num_gap_blocks);
-	sack->sack.num_dup_tsns = htons(num_dups);
-	sack->ch.chunk_length = htons(a_chk->send_size);
-	TAILQ_INSERT_TAIL(&asoc->control_send_queue, a_chk, sctp_next);
-	asoc->ctrl_queue_cnt++;
-	asoc->send_sack = 0;
-	SCTP_STAT_INCR(sctps_sendsacks);
-	return;
-}
-
-/* EY - This method will replace sctp_send_sack method if nr_sacks negotiated*/
-void
-sctp_send_nr_sack(struct sctp_tcb *stcb)
-{
-	/*-
-	 * Queue up an NR-SACK in the control queue. We must first check to see
-	 * if an NR-SACK is somehow on the control queue. If so, we will take
-	 * and and remove the old one.
-	 */
-	struct sctp_association *asoc;
-	struct sctp_tmit_chunk *chk, *a_chk;
-
-	struct sctp_nr_sack_chunk *nr_sack;
-
-	struct sctp_gap_ack_block *gap_descriptor;
-
-	struct sack_track *selector;
-	struct sack_track *nr_selector;
-
-	/* EY do we need nr_mergeable, NO */
-	int mergeable = 0;
-	int offset;
-	caddr_t limit;
-	uint32_t *dup, highest_tsn;
-	int limit_reached = 0;
-	int seen_non_zero = 0;
-	unsigned int i, jstart, siz, j;
-	unsigned int num_gap_blocks = 0, num_nr_gap_blocks = 0, space;
-	int num_dups = 0;
-	int space_req;
-
-	a_chk = NULL;
-	asoc = &stcb->asoc;
-	SCTP_TCB_LOCK_ASSERT(stcb);
-	if (asoc->last_data_chunk_from == NULL) {
-		/* Hmm we never received anything */
-		return;
-	}
-	sctp_set_rwnd(stcb, asoc);
-	TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) {
-		if (chk->rec.chunk_id.id == SCTP_NR_SELECTIVE_ACK) {
-			/* Hmm, found a sack already on queue, remove it */
-			TAILQ_REMOVE(&asoc->control_send_queue, chk, sctp_next);
-			asoc->ctrl_queue_cnt++;
-			a_chk = chk;
-			if (a_chk->data) {
-				sctp_m_freem(a_chk->data);
-				a_chk->data = NULL;
-			}
-			sctp_free_remote_addr(a_chk->whoTo);
-			a_chk->whoTo = NULL;
-			break;
-		}
-	}
-	if (a_chk == NULL) {
-		sctp_alloc_a_chunk(stcb, a_chk);
-		if (a_chk == NULL) {
-			/* No memory so we drop the idea, and set a timer */
-			if (stcb->asoc.delayed_ack) {
-				sctp_timer_stop(SCTP_TIMER_TYPE_RECV,
-				    stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_5);
-				sctp_timer_start(SCTP_TIMER_TYPE_RECV,
-				    stcb->sctp_ep, stcb, NULL);
-			} else {
-				stcb->asoc.send_sack = 1;
-			}
-			return;
-		}
-		a_chk->copy_by_ref = 0;
-		/* a_chk->rec.chunk_id.id = SCTP_SELECTIVE_ACK; */
-		a_chk->rec.chunk_id.id = SCTP_NR_SELECTIVE_ACK;
-		a_chk->rec.chunk_id.can_take_data = 1;
-	}
-	/* Clear our pkt counts */
-	asoc->data_pkts_seen = 0;
-
-	a_chk->asoc = asoc;
-	a_chk->snd_count = 0;
-	a_chk->send_size = 0;	/* fill in later */
-	a_chk->sent = SCTP_DATAGRAM_UNSENT;
-	a_chk->whoTo = NULL;
-
-	if ((asoc->numduptsns) ||
-	    (asoc->last_data_chunk_from->dest_state & SCTP_ADDR_NOT_REACHABLE)
-	    ) {
-		/*-
-		 * Ok, we have some duplicates or the destination for the
-		 * sack is unreachable, lets see if we can select an
-		 * alternate than asoc->last_data_chunk_from
-		 */
-		if ((!(asoc->last_data_chunk_from->dest_state &
-		    SCTP_ADDR_NOT_REACHABLE)) &&
-		    (asoc->used_alt_onsack > asoc->numnets)) {
-			/* We used an alt last time, don't this time */
-			a_chk->whoTo = NULL;
+	if (type == SCTP_SELECTIVE_ACK) {
+		sack = mtod(a_chk->data, struct sctp_sack_chunk *);
+		nr_sack = NULL;
+		gap_descriptor = (struct sctp_gap_ack_block *)((caddr_t)sack + sizeof(struct sctp_sack_chunk));
+		if (highest_tsn > asoc->mapping_array_base_tsn) {
+			siz = (((highest_tsn - asoc->mapping_array_base_tsn) + 1) + 7) / 8;
 		} else {
-			asoc->used_alt_onsack++;
-			a_chk->whoTo = sctp_find_alternate_net(stcb, asoc->last_data_chunk_from, 0);
-		}
-		if (a_chk->whoTo == NULL) {
-			/* Nope, no alternate */
-			a_chk->whoTo = asoc->last_data_chunk_from;
-			asoc->used_alt_onsack = 0;
+			siz = (((MAX_TSN - highest_tsn) + 1) + highest_tsn + 7) / 8;
 		}
 	} else {
-		/*
-		 * No duplicates so we use the last place we received data
-		 * from.
-		 */
-		asoc->used_alt_onsack = 0;
-		a_chk->whoTo = asoc->last_data_chunk_from;
-	}
-	if (a_chk->whoTo) {
-		atomic_add_int(&a_chk->whoTo->ref_count, 1);
-	}
-	if (compare_with_wrap(asoc->highest_tsn_inside_map, asoc->highest_tsn_inside_nr_map, MAX_TSN)) {
-		highest_tsn = asoc->highest_tsn_inside_map;
-	} else {
-		highest_tsn = asoc->highest_tsn_inside_nr_map;
-	}
-	if (highest_tsn == asoc->cumulative_tsn) {
-		/* no gaps */
-		space_req = sizeof(struct sctp_nr_sack_chunk);
-	} else {
-		/* EY - what is this about? */
-		/* gaps get a cluster */
-		space_req = MCLBYTES;
-	}
-	/* Ok now lets formulate a MBUF with our sack */
-	a_chk->data = sctp_get_mbuf_for_msg(space_req, 0, M_DONTWAIT, 1, MT_DATA);
-	if ((a_chk->data == NULL) ||
-	    (a_chk->whoTo == NULL)) {
-		/* rats, no mbuf memory */
-		if (a_chk->data) {
-			/* was a problem with the destination */
-			sctp_m_freem(a_chk->data);
-			a_chk->data = NULL;
-		}
-		sctp_free_a_chunk(stcb, a_chk);
-		/* sa_ignore NO_NULL_CHK */
-		if (stcb->asoc.delayed_ack) {
-			sctp_timer_stop(SCTP_TIMER_TYPE_RECV,
-			    stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_6);
-			sctp_timer_start(SCTP_TIMER_TYPE_RECV,
-			    stcb->sctp_ep, stcb, NULL);
+		sack = NULL;
+		nr_sack = mtod(a_chk->data, struct sctp_nr_sack_chunk *);
+		gap_descriptor = (struct sctp_gap_ack_block *)((caddr_t)nr_sack + sizeof(struct sctp_nr_sack_chunk));
+		if (asoc->highest_tsn_inside_map > asoc->mapping_array_base_tsn) {
+			siz = (((asoc->highest_tsn_inside_map - asoc->mapping_array_base_tsn) + 1) + 7) / 8;
 		} else {
-			stcb->asoc.send_sack = 1;
+			siz = (((MAX_TSN - asoc->mapping_array_base_tsn) + 1) + asoc->highest_tsn_inside_map + 7) / 8;
 		}
-		return;
-	}
-	/* ok, lets go through and fill it in */
-	SCTP_BUF_RESV_UF(a_chk->data, SCTP_MIN_OVERHEAD);
-	space = M_TRAILINGSPACE(a_chk->data);
-	if (space > (a_chk->whoTo->mtu - SCTP_MIN_OVERHEAD)) {
-		space = (a_chk->whoTo->mtu - SCTP_MIN_OVERHEAD);
 	}
-	limit = mtod(a_chk->data, caddr_t);
-	limit += space;
-
-	nr_sack = mtod(a_chk->data, struct sctp_nr_sack_chunk *);
-	nr_sack->ch.chunk_type = SCTP_NR_SELECTIVE_ACK;
-	/* EYJ */
-	/* 0x01 is used by nonce for ecn */
-	if ((SCTP_BASE_SYSCTL(sctp_ecn_enable)) &&
-	    (SCTP_BASE_SYSCTL(sctp_ecn_nonce)) &&
-	    (asoc->peer_supports_ecn_nonce))
-		nr_sack->ch.chunk_flags = (asoc->receiver_nonce_sum & SCTP_SACK_NONCE_SUM);
-	else
-		nr_sack->ch.chunk_flags = 0;
-
-	if (SCTP_BASE_SYSCTL(sctp_cmt_on_off) && SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) {
-		/*-
-		 * CMT DAC algorithm: If 2 (i.e., 0x10) packets have been
-		 * received, then set high bit to 1, else 0. Reset
-		 * pkts_rcvd.
-		 */
-		/* EY - TODO: which chunk flag is used in here? -The LSB */
-		nr_sack->ch.chunk_flags |= (asoc->cmt_dac_pkts_rcvd << 6);
-		asoc->cmt_dac_pkts_rcvd = 0;
-	}
-#ifdef SCTP_ASOCLOG_OF_TSNS
-	stcb->asoc.cumack_logsnt[stcb->asoc.cumack_log_atsnt] = asoc->cumulative_tsn;
-	stcb->asoc.cumack_log_atsnt++;
-	if (stcb->asoc.cumack_log_atsnt >= SCTP_TSN_LOG_SIZE) {
-		stcb->asoc.cumack_log_atsnt = 0;
-	}
-#endif
-	nr_sack->nr_sack.cum_tsn_ack = htonl(asoc->cumulative_tsn);
-	nr_sack->nr_sack.a_rwnd = htonl(asoc->my_rwnd);
-	asoc->my_last_reported_rwnd = asoc->my_rwnd;
-
-	/* reset the readers interpretation */
-	stcb->freed_by_sorcv_sincelast = 0;
-
-	gap_descriptor = (struct sctp_gap_ack_block *)((caddr_t)nr_sack + sizeof(struct sctp_nr_sack_chunk));
-
-	if (asoc->highest_tsn_inside_map > asoc->mapping_array_base_tsn)
-		siz = (((asoc->highest_tsn_inside_map - asoc->mapping_array_base_tsn) + 1) + 7) / 8;
-	else
-		siz = (((MAX_TSN - asoc->mapping_array_base_tsn) + 1) + asoc->highest_tsn_inside_map + 7) / 8;
 
 	if (compare_with_wrap(asoc->mapping_array_base_tsn, asoc->cumulative_tsn, MAX_TSN)) {
 		offset = 1;
 		/*-
-		 * cum-ack behind the mapping array, so we start and use all
-		 * entries.
+		 * The base TSN is intialized to be the first TSN the peer
+		 * will send us. If the cum-ack is behind this then when they
+		 * send us the next in sequence it will mark the base_tsn bit.
+		 * Thus we need to use the very first selector and the offset
+		 * is 1. Our table is built for this case.
 		 */
-		jstart = 0;
+		starting_index = 0;
+		sel_start = 0;
 	} else {
-		offset = asoc->mapping_array_base_tsn - asoc->cumulative_tsn;
 		/*-
-		 * we skip the first one when the cum-ack is at or above the
-		 * mapping array base. Note this only works if
+		 * we skip the first selector  when the cum-ack is at or above the
+		 * mapping array base. This is because the bits at the base or above
+		 * are turned on and our first selector in the table assumes they are
+		 * off. We thus will use the second selector (first is 0). We use
+		 * the reverse of our macro to fix the offset, in bits, that our
+		 * table is at. Note that this method assumes that the cum-tsn is
+		 * within the first bit, i.e. its value is 0-7 which means the
+		 * result to our offset will be either a 0 - -7. If the cumack
+		 * is NOT in the first byte (0) (which it should be since we did
+		 * a mapping array slide above) then we need to calculate the starting
+		 * index i.e. which byte of the mapping array we should start at. We
+		 * do this by dividing by 8 and pushing the remainder (mod) into offset.
+		 * then we multiply the offset to be negative, since we need a negative
+		 * offset into the selector table.
 		 */
-		jstart = 1;
+		SCTP_CALC_TSN_TO_GAP(offset, asoc->cumulative_tsn, asoc->mapping_array_base_tsn);
+		if (offset > 7) {
+			starting_index = offset / 8;
+			offset = offset % 8;
+			printf("Strange starting index is %d offset:%d (not 0/x)\n",
+			    starting_index, offset);
+		} else {
+			starting_index = 0;
+		}
+		/* We need a negative offset in our table */
+		offset *= -1;
+		sel_start = 1;
 	}
-	if (compare_with_wrap(asoc->highest_tsn_inside_map, asoc->cumulative_tsn, MAX_TSN)) {
+	if (((type == SCTP_SELECTIVE_ACK) &&
+	    compare_with_wrap(highest_tsn, asoc->cumulative_tsn, MAX_TSN)) ||
+	    ((type == SCTP_NR_SELECTIVE_ACK) &&
+	    compare_with_wrap(asoc->highest_tsn_inside_map, asoc->cumulative_tsn, MAX_TSN))) {
 		/* we have a gap .. maybe */
-		for (i = 0; i < siz; i++) {
-			seen_non_zero = 1;
-			selector = &sack_array[asoc->mapping_array[i]];
+		for (i = starting_index; i < siz; i++) {
+			if (type == SCTP_SELECTIVE_ACK) {
+				selector = &sack_array[asoc->mapping_array[i] | asoc->nr_mapping_array[i]];
+			} else {
+				selector = &sack_array[asoc->mapping_array[i]];
+			}
 			if (mergeable && selector->right_edge) {
 				/*
 				 * Backup, left and right edges were ok to
@@ -10382,7 +10125,7 @@ sctp_send_nr_sack(struct sctp_tcb *stcb)
 			if (selector->num_entries == 0)
 				mergeable = 0;
 			else {
-				for (j = jstart; j < selector->num_entries; j++) {
+				for (j = sel_start; j < selector->num_entries; j++) {
 					if (mergeable && selector->right_edge) {
 						/*
 						 * do a merge by NOT setting
@@ -10414,39 +10157,40 @@ sctp_send_nr_sack(struct sctp_tcb *stcb)
 				/* Reached the limit stop */
 				break;
 			}
-			jstart = 0;
+			sel_start = 0;
 			offset += 8;
 		}
 	}
-	if (limit_reached == 0) {
+	if ((type == SCTP_NR_SELECTIVE_ACK) &&
+	    (limit_reached == 0)) {
 
 		mergeable = 0;
 
-		if (asoc->highest_tsn_inside_nr_map > asoc->nr_mapping_array_base_tsn)
-			siz = (((asoc->highest_tsn_inside_nr_map - asoc->nr_mapping_array_base_tsn) + 1) + 7) / 8;
+		if (asoc->highest_tsn_inside_nr_map > asoc->mapping_array_base_tsn)
+			siz = (((asoc->highest_tsn_inside_nr_map - asoc->mapping_array_base_tsn) + 1) + 7) / 8;
 		else
-			siz = (((MAX_TSN - asoc->nr_mapping_array_base_tsn) + 1) + asoc->highest_tsn_inside_nr_map + 7) / 8;
+			siz = (((MAX_TSN - asoc->mapping_array_base_tsn) + 1) + asoc->highest_tsn_inside_nr_map + 7) / 8;
 
-		if (compare_with_wrap(asoc->nr_mapping_array_base_tsn, asoc->cumulative_tsn, MAX_TSN)) {
+		if (compare_with_wrap(asoc->mapping_array_base_tsn, asoc->cumulative_tsn, MAX_TSN)) {
 			offset = 1;
 			/*-
 			* cum-ack behind the mapping array, so we start and use all
 			* entries.
 			*/
-			jstart = 0;
+			sel_start = 0;
 		} else {
-			offset = asoc->nr_mapping_array_base_tsn - asoc->cumulative_tsn;
+			offset = asoc->mapping_array_base_tsn - asoc->cumulative_tsn;
 			/*-
 			* we skip the first one when the cum-ack is at or above the
 			* mapping array base. Note this only works if
 			*/
-			jstart = 1;
+			sel_start = 1;
 		}
 		if (compare_with_wrap(asoc->highest_tsn_inside_nr_map, asoc->cumulative_tsn, MAX_TSN)) {
 			/* we have a gap .. maybe */
 			for (i = 0; i < siz; i++) {
-				nr_selector = &sack_array[asoc->nr_mapping_array[i]];
-				if (mergeable && nr_selector->right_edge) {
+				selector = &sack_array[asoc->nr_mapping_array[i]];
+				if (mergeable && selector->right_edge) {
 					/*
 					 * Backup, left and right edges were
 					 * ok to merge.
@@ -10454,11 +10198,11 @@ sctp_send_nr_sack(struct sctp_tcb *stcb)
 					num_nr_gap_blocks--;
 					gap_descriptor--;
 				}
-				if (nr_selector->num_entries == 0)
+				if (selector->num_entries == 0)
 					mergeable = 0;
 				else {
-					for (j = jstart; j < nr_selector->num_entries; j++) {
-						if (mergeable && nr_selector->right_edge) {
+					for (j = sel_start; j < selector->num_entries; j++) {
+						if (mergeable && selector->right_edge) {
 							/*
 							 * do a merge by NOT
 							 * setting the left
@@ -10471,9 +10215,9 @@ sctp_send_nr_sack(struct sctp_tcb *stcb)
 							 * left side
 							 */
 							mergeable = 0;
-							gap_descriptor->start = htons((nr_selector->gaps[j].start + offset));
+							gap_descriptor->start = htons((selector->gaps[j].start + offset));
 						}
-						gap_descriptor->end = htons((nr_selector->gaps[j].end + offset));
+						gap_descriptor->end = htons((selector->gaps[j].end + offset));
 						num_nr_gap_blocks++;
 						gap_descriptor++;
 						if (((caddr_t)gap_descriptor + sizeof(struct sctp_gap_ack_block)) > limit) {
@@ -10482,7 +10226,7 @@ sctp_send_nr_sack(struct sctp_tcb *stcb)
 							break;
 						}
 					}
-					if (nr_selector->left_edge) {
+					if (selector->left_edge) {
 						mergeable = 1;
 					}
 				}
@@ -10490,11 +10234,12 @@ sctp_send_nr_sack(struct sctp_tcb *stcb)
 					/* Reached the limit stop */
 					break;
 				}
-				jstart = 0;
+				sel_start = 0;
 				offset += 8;
 			}
 		}
 	}
+	/* now we must add any dups we are going to report. */
 	if ((limit_reached == 0) && (asoc->numduptsns)) {
 		dup = (uint32_t *) gap_descriptor;
 		for (i = 0; i < asoc->numduptsns; i++) {
@@ -10512,17 +10257,35 @@ sctp_send_nr_sack(struct sctp_tcb *stcb)
 	 * now that the chunk is prepared queue it to the control chunk
 	 * queue.
 	 */
-	a_chk->send_size = sizeof(struct sctp_nr_sack_chunk) +
-	    (num_gap_blocks + num_nr_gap_blocks) * sizeof(struct sctp_gap_ack_block) +
-	    num_dups * sizeof(int32_t);
-
-	SCTP_BUF_LEN(a_chk->data) = a_chk->send_size;
-	nr_sack->nr_sack.num_gap_ack_blks = htons(num_gap_blocks);
-	nr_sack->nr_sack.num_nr_gap_ack_blks = htons(num_nr_gap_blocks);
-	nr_sack->nr_sack.num_dup_tsns = htons(num_dups);
-	nr_sack->nr_sack.reserved = 0;
-	nr_sack->ch.chunk_length = htons(a_chk->send_size);
+	if (type == SCTP_SELECTIVE_ACK) {
+		a_chk->send_size = sizeof(struct sctp_sack_chunk) +
+		    (num_gap_blocks + num_nr_gap_blocks) * sizeof(struct sctp_gap_ack_block) +
+		    num_dups * sizeof(int32_t);
+		SCTP_BUF_LEN(a_chk->data) = a_chk->send_size;
+		sack->sack.cum_tsn_ack = htonl(asoc->cumulative_tsn);
+		sack->sack.a_rwnd = htonl(asoc->my_rwnd);
+		sack->sack.num_gap_ack_blks = htons(num_gap_blocks);
+		sack->sack.num_dup_tsns = htons(num_dups);
+		sack->ch.chunk_type = type;
+		sack->ch.chunk_flags = flags;
+		sack->ch.chunk_length = htons(a_chk->send_size);
+	} else {
+		a_chk->send_size = sizeof(struct sctp_nr_sack_chunk) +
+		    (num_gap_blocks + num_nr_gap_blocks) * sizeof(struct sctp_gap_ack_block) +
+		    num_dups * sizeof(int32_t);
+		SCTP_BUF_LEN(a_chk->data) = a_chk->send_size;
+		nr_sack->nr_sack.cum_tsn_ack = htonl(asoc->cumulative_tsn);
+		nr_sack->nr_sack.a_rwnd = htonl(asoc->my_rwnd);
+		nr_sack->nr_sack.num_gap_ack_blks = htons(num_gap_blocks);
+		nr_sack->nr_sack.num_nr_gap_ack_blks = htons(num_nr_gap_blocks);
+		nr_sack->nr_sack.num_dup_tsns = htons(num_dups);
+		nr_sack->nr_sack.reserved = 0;
+		nr_sack->ch.chunk_type = type;
+		nr_sack->ch.chunk_flags = flags;
+		nr_sack->ch.chunk_length = htons(a_chk->send_size);
+	}
 	TAILQ_INSERT_TAIL(&asoc->control_send_queue, a_chk, sctp_next);
+	asoc->my_last_reported_rwnd = asoc->my_rwnd;
 	asoc->ctrl_queue_cnt++;
 	asoc->send_sack = 0;
 	SCTP_STAT_INCR(sctps_sendsacks);
@@ -10779,7 +10542,7 @@ sctp_send_shutdown_complete2(struct mbuf *m, int iphlen, struct sctphdr *sh,
 			SCTP_ENABLE_UDP_CSUM(mout);
 		} else {
 			mout->m_pkthdr.csum_flags = CSUM_SCTP;
-			mout->m_pkthdr.csum_data = 0;	/* FIXME MT */
+			mout->m_pkthdr.csum_data = 0;
 			SCTP_STAT_INCR(sctps_sendhwcrc);
 		}
 		SCTP_ATTACH_CHAIN(o_pak, mout, mlen);
@@ -10803,14 +10566,29 @@ sctp_send_shutdown_complete2(struct mbuf *m, int iphlen, struct sctphdr *sh,
 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING)
 			sctp_packet_log(mout, mlen);
 #endif
-		comp_cp->sh.checksum = sctp_calculate_cksum(mout, offset_out);
-		SCTP_STAT_INCR(sctps_sendswcrc);
 		SCTP_ATTACH_CHAIN(o_pak, mout, mlen);
 		if (port) {
-			if ((udp->uh_sum = in6_cksum(o_pak, IPPROTO_UDP, sizeof(struct ip6_hdr),
-			    sizeof(struct sctp_shutdown_complete_msg) + sizeof(struct udphdr))) == 0) {
+			if (!(SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback) &&
+			    (stcb) &&
+			    (stcb->asoc.loopback_scope))) {
+				comp_cp->sh.checksum = sctp_calculate_cksum(mout, sizeof(struct ip6_hdr) + sizeof(struct udphdr));
+				SCTP_STAT_INCR(sctps_sendswcrc);
+			} else {
+				SCTP_STAT_INCR(sctps_sendnocrc);
+			}
+			if ((udp->uh_sum = in6_cksum(o_pak, IPPROTO_UDP, sizeof(struct ip6_hdr), mlen - sizeof(struct ip6_hdr))) == 0) {
 				udp->uh_sum = 0xffff;
 			}
+		} else {
+			if (!(SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback) &&
+			    (stcb) &&
+			    (stcb->asoc.loopback_scope))) {
+				mout->m_pkthdr.csum_flags = CSUM_SCTP;
+				mout->m_pkthdr.csum_data = 0;
+				SCTP_STAT_INCR(sctps_sendhwcrc);
+			} else {
+				SCTP_STAT_INCR(sctps_sendnocrc);
+			}
 		}
 		SCTP_IP6_OUTPUT(ret, o_pak, &ro, &ifp, stcb, vrf_id);
 
@@ -11830,7 +11608,7 @@ sctp_send_abort(struct mbuf *m, int iphlen, struct sctphdr *sh, uint32_t vtag,
 			SCTP_ENABLE_UDP_CSUM(o_pak);
 		} else {
 			mout->m_pkthdr.csum_flags = CSUM_SCTP;
-			mout->m_pkthdr.csum_data = 0;	/* FIXME MT */
+			mout->m_pkthdr.csum_data = 0;
 			SCTP_STAT_INCR(sctps_sendhwcrc);
 		}
 		SCTP_IP_OUTPUT(ret, o_pak, &ro, stcb, vrf_id);
@@ -11858,13 +11636,29 @@ sctp_send_abort(struct mbuf *m, int iphlen, struct sctphdr *sh, uint32_t vtag,
 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING)
 			sctp_packet_log(mout, len);
 #endif
-		abm->sh.checksum = sctp_calculate_cksum(mout, iphlen_out);
-		SCTP_STAT_INCR(sctps_sendswcrc);
 		SCTP_ATTACH_CHAIN(o_pak, mout, len);
 		if (port) {
+			if (!(SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback) &&
+			    (stcb) &&
+			    (stcb->asoc.loopback_scope))) {
+				abm->sh.checksum = sctp_calculate_cksum(mout, sizeof(struct ip6_hdr) + sizeof(struct udphdr));
+				SCTP_STAT_INCR(sctps_sendswcrc);
+			} else {
+				SCTP_STAT_INCR(sctps_sendnocrc);
+			}
 			if ((udp->uh_sum = in6_cksum(o_pak, IPPROTO_UDP, sizeof(struct ip6_hdr), len - sizeof(struct ip6_hdr))) == 0) {
 				udp->uh_sum = 0xffff;
 			}
+		} else {
+			if (!(SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback) &&
+			    (stcb) &&
+			    (stcb->asoc.loopback_scope))) {
+				mout->m_pkthdr.csum_flags = CSUM_SCTP;
+				mout->m_pkthdr.csum_data = 0;
+				SCTP_STAT_INCR(sctps_sendhwcrc);
+			} else {
+				SCTP_STAT_INCR(sctps_sendnocrc);
+			}
 		}
 		SCTP_IP6_OUTPUT(ret, o_pak, &ro, &ifp, stcb, vrf_id);
 
@@ -12052,7 +11846,7 @@ sctp_send_operr_to(struct mbuf *m, int iphlen, struct mbuf *scm, uint32_t vtag,
 			SCTP_ENABLE_UDP_CSUM(o_pak);
 		} else {
 			mout->m_pkthdr.csum_flags = CSUM_SCTP;
-			mout->m_pkthdr.csum_data = 0;	/* FIXME MT */
+			mout->m_pkthdr.csum_data = 0;
 			SCTP_STAT_INCR(sctps_sendhwcrc);
 		}
 		SCTP_IP_OUTPUT(ret, o_pak, &ro, stcb, vrf_id);
@@ -12078,13 +11872,29 @@ sctp_send_operr_to(struct mbuf *m, int iphlen, struct mbuf *scm, uint32_t vtag,
 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING)
 			sctp_packet_log(mout, len);
 #endif
-		sh_out->checksum = sctp_calculate_cksum(mout, iphlen_out);
-		SCTP_STAT_INCR(sctps_sendswcrc);
 		SCTP_ATTACH_CHAIN(o_pak, mout, len);
 		if (port) {
+			if (!(SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback) &&
+			    (stcb) &&
+			    (stcb->asoc.loopback_scope))) {
+				sh_out->checksum = sctp_calculate_cksum(mout, sizeof(struct ip6_hdr) + sizeof(struct udphdr));
+				SCTP_STAT_INCR(sctps_sendswcrc);
+			} else {
+				SCTP_STAT_INCR(sctps_sendnocrc);
+			}
 			if ((udp->uh_sum = in6_cksum(o_pak, IPPROTO_UDP, sizeof(struct ip6_hdr), len - sizeof(struct ip6_hdr))) == 0) {
 				udp->uh_sum = 0xffff;
 			}
+		} else {
+			if (!(SCTP_BASE_SYSCTL(sctp_no_csum_on_loopback) &&
+			    (stcb) &&
+			    (stcb->asoc.loopback_scope))) {
+				mout->m_pkthdr.csum_flags = CSUM_SCTP;
+				mout->m_pkthdr.csum_data = 0;
+				SCTP_STAT_INCR(sctps_sendhwcrc);
+			} else {
+				SCTP_STAT_INCR(sctps_sendnocrc);
+			}
 		}
 		SCTP_IP6_OUTPUT(ret, o_pak, &ro, &ifp, stcb, vrf_id);
 
@@ -12576,7 +12386,7 @@ sctp_lower_sosend(struct socket *so,
 				panic("Error, should hold create lock and I don't?");
 			}
 #endif
-			stcb = sctp_aloc_assoc(inp, addr, 1, &error, 0, vrf_id,
+			stcb = sctp_aloc_assoc(inp, addr, &error, 0, vrf_id,
 			    p
 			    );
 			if (stcb == NULL) {
diff --git a/sys/netinet/sctp_output.h b/sys/netinet/sctp_output.h
index bd40a0b1f099..6488b1cf739c 100644
--- a/sys/netinet/sctp_output.h
+++ b/sys/netinet/sctp_output.h
@@ -155,9 +155,6 @@ void send_forward_tsn(struct sctp_tcb *, struct sctp_association *);
 
 void sctp_send_sack(struct sctp_tcb *);
 
-/* EY 05/07/08 if nr_sacks used, the following function will be called instead of sctp_send_sack */
-void sctp_send_nr_sack(struct sctp_tcb *);
-
 int sctp_send_hb(struct sctp_tcb *, int, struct sctp_nets *);
 
 void sctp_send_ecn_echo(struct sctp_tcb *, struct sctp_nets *, uint32_t);
diff --git a/sys/netinet/sctp_pcb.c b/sys/netinet/sctp_pcb.c
index fa188249a960..273a4a7766c6 100644
--- a/sys/netinet/sctp_pcb.c
+++ b/sys/netinet/sctp_pcb.c
@@ -3960,7 +3960,7 @@ try_again:
  */
 struct sctp_tcb *
 sctp_aloc_assoc(struct sctp_inpcb *inp, struct sockaddr *firstaddr,
-    int for_a_init, int *error, uint32_t override_tag, uint32_t vrf_id,
+    int *error, uint32_t override_tag, uint32_t vrf_id,
     struct thread *p
 )
 {
@@ -4080,7 +4080,7 @@ sctp_aloc_assoc(struct sctp_inpcb *inp, struct sockaddr *firstaddr,
 	/* setup back pointer's */
 	stcb->sctp_ep = inp;
 	stcb->sctp_socket = inp->sctp_socket;
-	if ((err = sctp_init_asoc(inp, stcb, for_a_init, override_tag, vrf_id))) {
+	if ((err = sctp_init_asoc(inp, stcb, override_tag, vrf_id))) {
 		/* failed */
 		SCTP_TCB_LOCK_DESTROY(stcb);
 		SCTP_TCB_SEND_LOCK_DESTROY(stcb);
@@ -4681,7 +4681,7 @@ sctp_free_assoc(struct sctp_inpcb *inp, struct sctp_tcb *stcb, int from_inpcbfre
 	    inp->sctp_lport, stcb->rport);
 
 	/*
-	 * Now restop the timers to be sure - this is paranoia at is finest!
+	 * Now restop the timers to be sure this is paranoia at is finest!
 	 */
 	(void)SCTP_OS_TIMER_STOP(&asoc->strreset_timer.timer);
 	(void)SCTP_OS_TIMER_STOP(&asoc->hb_timer.timer);
@@ -6422,9 +6422,11 @@ sctp_drain_mbufs(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
 	 */
 	struct sctp_association *asoc;
 	struct sctp_tmit_chunk *chk, *nchk;
-	uint32_t cumulative_tsn_p1, tsn;
+	uint32_t cumulative_tsn_p1;
 	struct sctp_queued_to_read *ctl, *nctl;
-	int cnt, strmat, gap;
+	int cnt, strmat;
+	uint32_t gap, i;
+	int fnd = 0;
 
 	/* We look for anything larger than the cum-ack + 1 */
 
@@ -6445,13 +6447,7 @@ sctp_drain_mbufs(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
 		    cumulative_tsn_p1, MAX_TSN)) {
 			/* Yep it is above cum-ack */
 			cnt++;
-			tsn = chk->rec.data.TSN_seq;
-			if (tsn >= asoc->mapping_array_base_tsn) {
-				gap = tsn - asoc->mapping_array_base_tsn;
-			} else {
-				gap = (MAX_TSN - asoc->mapping_array_base_tsn) +
-				    tsn + 1;
-			}
+			SCTP_CALC_TSN_TO_GAP(gap, chk->rec.data.TSN_seq, asoc->mapping_array_base_tsn);
 			asoc->size_on_reasm_queue = sctp_sbspace_sub(asoc->size_on_reasm_queue, chk->send_size);
 			sctp_ucount_decr(asoc->cnt_on_reasm_queue);
 			SCTP_UNSET_TSN_PRESENT(asoc->mapping_array, gap);
@@ -6473,22 +6469,11 @@ sctp_drain_mbufs(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
 			    cumulative_tsn_p1, MAX_TSN)) {
 				/* Yep it is above cum-ack */
 				cnt++;
-				tsn = ctl->sinfo_tsn;
-				if (tsn >= asoc->mapping_array_base_tsn) {
-					gap = tsn -
-					    asoc->mapping_array_base_tsn;
-				} else {
-					gap = (MAX_TSN -
-					    asoc->mapping_array_base_tsn) +
-					    tsn + 1;
-				}
+				SCTP_CALC_TSN_TO_GAP(gap, ctl->sinfo_tsn, asoc->mapping_array_base_tsn);
 				asoc->size_on_all_streams = sctp_sbspace_sub(asoc->size_on_all_streams, ctl->length);
 				sctp_ucount_decr(asoc->cnt_on_all_streams);
-
-				SCTP_UNSET_TSN_PRESENT(asoc->mapping_array,
-				    gap);
-				TAILQ_REMOVE(&asoc->strmin[strmat].inqueue,
-				    ctl, next);
+				SCTP_UNSET_TSN_PRESENT(asoc->mapping_array, gap);
+				TAILQ_REMOVE(&asoc->strmin[strmat].inqueue, ctl, next);
 				if (ctl->data) {
 					sctp_m_freem(ctl->data);
 					ctl->data = NULL;
@@ -6500,69 +6485,44 @@ sctp_drain_mbufs(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
 			ctl = nctl;
 		}
 	}
-	/*
-	 * Question, should we go through the delivery queue? The only
-	 * reason things are on here is the app not reading OR a p-d-api up.
-	 * An attacker COULD send enough in to initiate the PD-API and then
-	 * send a bunch of stuff to other streams... these would wind up on
-	 * the delivery queue.. and then we would not get to them. But in
-	 * order to do this I then have to back-track and un-deliver
-	 * sequence numbers in streams.. el-yucko. I think for now we will
-	 * NOT look at the delivery queue and leave it to be something to
-	 * consider later. An alternative would be to abort the P-D-API with
-	 * a notification and then deliver the data.... Or another method
-	 * might be to keep track of how many times the situation occurs and
-	 * if we see a possible attack underway just abort the association.
-	 */
-#ifdef SCTP_DEBUG
 	if (cnt) {
+		/* We must back down to see what the new highest is */
+		for (i = asoc->highest_tsn_inside_map;
+		    (compare_with_wrap(i, asoc->mapping_array_base_tsn, MAX_TSN) || (i == asoc->mapping_array_base_tsn));
+		    i--) {
+			SCTP_CALC_TSN_TO_GAP(gap, i, asoc->mapping_array_base_tsn);
+			if (SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) {
+				asoc->highest_tsn_inside_map = i;
+				fnd = 1;
+				break;
+			}
+		}
+		if (!fnd) {
+			asoc->highest_tsn_inside_map = asoc->mapping_array_base_tsn - 1;
+		}
+		/*
+		 * Question, should we go through the delivery queue? The
+		 * only reason things are on here is the app not reading OR
+		 * a p-d-api up. An attacker COULD send enough in to
+		 * initiate the PD-API and then send a bunch of stuff to
+		 * other streams... these would wind up on the delivery
+		 * queue.. and then we would not get to them. But in order
+		 * to do this I then have to back-track and un-deliver
+		 * sequence numbers in streams.. el-yucko. I think for now
+		 * we will NOT look at the delivery queue and leave it to be
+		 * something to consider later. An alternative would be to
+		 * abort the P-D-API with a notification and then deliver
+		 * the data.... Or another method might be to keep track of
+		 * how many times the situation occurs and if we see a
+		 * possible attack underway just abort the association.
+		 */
+#ifdef SCTP_DEBUG
 		SCTPDBG(SCTP_DEBUG_PCB1, "Freed %d chunks from reneg harvest\n", cnt);
-	}
 #endif
-	if (cnt) {
 		/*
 		 * Now do we need to find a new
 		 * asoc->highest_tsn_inside_map?
 		 */
-		if (asoc->highest_tsn_inside_map >= asoc->mapping_array_base_tsn) {
-			gap = asoc->highest_tsn_inside_map - asoc->mapping_array_base_tsn;
-		} else {
-			gap = (MAX_TSN - asoc->mapping_array_base_tsn) +
-			    asoc->highest_tsn_inside_map + 1;
-		}
-		if (gap >= (asoc->mapping_array_size << 3)) {
-			/*
-			 * Something bad happened or cum-ack and high were
-			 * behind the base, but if so earlier checks should
-			 * have found NO data... wierd... we will start at
-			 * end of mapping array.
-			 */
-			SCTP_PRINTF("Gap was larger than array?? %d set to max:%d maparraymax:%x\n",
-			    (int)gap,
-			    (int)(asoc->mapping_array_size << 3),
-			    (int)asoc->highest_tsn_inside_map);
-			gap = asoc->mapping_array_size << 3;
-		}
-		while (gap > 0) {
-			if (SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) {
-				/* found the new highest */
-				asoc->highest_tsn_inside_map = asoc->mapping_array_base_tsn + gap;
-				if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) {
-					sctp_log_map(0, 8, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT);
-				}
-				break;
-			}
-			gap--;
-		}
-		if (gap == 0) {
-			/* Nothing left in map */
-			memset(asoc->mapping_array, 0, asoc->mapping_array_size);
-			asoc->mapping_array_base_tsn = asoc->cumulative_tsn + 1;
-			asoc->highest_tsn_inside_map = asoc->cumulative_tsn;
-			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) {
-				sctp_log_map(0, 9, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT);
-			}
-		}
 		asoc->last_revoke_count = cnt;
 		(void)SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer);
 		/* sa_ignore NO_NULL_CHK */
diff --git a/sys/netinet/sctp_pcb.h b/sys/netinet/sctp_pcb.h
index bf14175cac30..1a468f8632d3 100644
--- a/sys/netinet/sctp_pcb.h
+++ b/sys/netinet/sctp_pcb.h
@@ -564,7 +564,7 @@ void sctp_inpcb_free(struct sctp_inpcb *, int, int);
 
 struct sctp_tcb *
 sctp_aloc_assoc(struct sctp_inpcb *, struct sockaddr *,
-    int, int *, uint32_t, uint32_t, struct thread *);
+    int *, uint32_t, uint32_t, struct thread *);
 
 int sctp_free_assoc(struct sctp_inpcb *, struct sctp_tcb *, int, int);
 
diff --git a/sys/netinet/sctp_structs.h b/sys/netinet/sctp_structs.h
index 9b952fd022b5..cd798b521d86 100644
--- a/sys/netinet/sctp_structs.h
+++ b/sys/netinet/sctp_structs.h
@@ -477,7 +477,6 @@ struct sctp_asconf_addr {
 	struct sctp_ifa *ifa;	/* save the ifa for add/del ip */
 	uint8_t sent;		/* has this been sent yet? */
 	uint8_t special_del;	/* not to be used in lookup */
-
 };
 
 struct sctp_scoping {
@@ -771,9 +770,7 @@ struct sctp_association {
 
 	/* EY - new NR variables used for nr_sack based on mapping_array */
 	uint8_t *nr_mapping_array;
-	uint32_t nr_mapping_array_base_tsn;
 	uint32_t highest_tsn_inside_nr_map;
-	uint16_t nr_mapping_array_size;
 
 	uint32_t last_echo_tsn;
 	uint32_t last_cwr_tsn;
diff --git a/sys/netinet/sctp_usrreq.c b/sys/netinet/sctp_usrreq.c
index 2851272d35a0..fc6a4ac1abb0 100644
--- a/sys/netinet/sctp_usrreq.c
+++ b/sys/netinet/sctp_usrreq.c
@@ -1492,7 +1492,7 @@ sctp_do_connect_x(struct socket *so, struct sctp_inpcb *inp, void *optval,
 
 
 	/* We are GOOD to go */
-	stcb = sctp_aloc_assoc(inp, sa, 1, &error, 0, vrf_id,
+	stcb = sctp_aloc_assoc(inp, sa, &error, 0, vrf_id,
 	    (struct thread *)p
 	    );
 	if (stcb == NULL) {
@@ -4459,7 +4459,7 @@ sctp_connect(struct socket *so, struct sockaddr *addr, struct thread *p)
 	}
 	vrf_id = inp->def_vrf_id;
 	/* We are GOOD to go */
-	stcb = sctp_aloc_assoc(inp, addr, 1, &error, 0, vrf_id, p);
+	stcb = sctp_aloc_assoc(inp, addr, &error, 0, vrf_id, p);
 	if (stcb == NULL) {
 		/* Gak! no memory */
 		goto out_now;
diff --git a/sys/netinet/sctp_var.h b/sys/netinet/sctp_var.h
index 1ccccf3d3c48..bff7f5def1e3 100644
--- a/sys/netinet/sctp_var.h
+++ b/sys/netinet/sctp_var.h
@@ -108,7 +108,7 @@ extern struct pr_usrreqs sctp_usrreqs;
 		sctp_auth_key_release((_stcb), (_chk)->auth_keyid); \
 		(_chk)->holds_key_ref = 0; \
 	} \
-        if(_stcb) { \
+        if (_stcb) { \
           SCTP_TCB_LOCK_ASSERT((_stcb)); \
           if ((_chk)->whoTo) { \
                   sctp_free_remote_addr((_chk)->whoTo); \
@@ -231,7 +231,7 @@ extern struct pr_usrreqs sctp_usrreqs;
 
 #ifdef SCTP_FS_SPEC_LOG
 #define sctp_total_flight_decrease(stcb, tp1) do { \
-        if(stcb->asoc.fs_index > SCTP_FS_SPEC_LOG_SIZE) \
+        if (stcb->asoc.fs_index > SCTP_FS_SPEC_LOG_SIZE) \
 		stcb->asoc.fs_index = 0;\
 	stcb->asoc.fslog[stcb->asoc.fs_index].total_flight = stcb->asoc.total_flight; \
 	stcb->asoc.fslog[stcb->asoc.fs_index].tsn = tp1->rec.data.TSN_seq; \
@@ -252,7 +252,7 @@ extern struct pr_usrreqs sctp_usrreqs;
 } while (0)
 
 #define sctp_total_flight_increase(stcb, tp1) do { \
-        if(stcb->asoc.fs_index > SCTP_FS_SPEC_LOG_SIZE) \
+        if (stcb->asoc.fs_index > SCTP_FS_SPEC_LOG_SIZE) \
 		stcb->asoc.fs_index = 0;\
 	stcb->asoc.fslog[stcb->asoc.fs_index].total_flight = stcb->asoc.total_flight; \
 	stcb->asoc.fslog[stcb->asoc.fs_index].tsn = tp1->rec.data.TSN_seq; \
diff --git a/sys/netinet/sctputil.c b/sys/netinet/sctputil.c
index e9f5aecb998c..0f2805fb613d 100644
--- a/sys/netinet/sctputil.c
+++ b/sys/netinet/sctputil.c
@@ -52,9 +52,15 @@ __FBSDID("$FreeBSD$");
 #define NUMBER_OF_MTU_SIZES 18
 
 
+#if defined(__Windows__) && !defined(SCTP_LOCAL_TRACE_BUF)
+#include "eventrace_netinet.h"
+#include "sctputil.tmh"		/* this is the file that will be auto
+				 * generated */
+#else
 #ifndef KTR_SCTP
 #define KTR_SCTP KTR_SUBSYS
 #endif
+#endif
 
 void
 sctp_sblog(struct sockbuf *sb,
@@ -869,7 +875,7 @@ sctp_select_a_tag(struct sctp_inpcb *inp, uint16_t lport, uint16_t rport, int sa
 
 int
 sctp_init_asoc(struct sctp_inpcb *m, struct sctp_tcb *stcb,
-    int for_a_init, uint32_t override_tag, uint32_t vrf_id)
+    uint32_t override_tag, uint32_t vrf_id)
 {
 	struct sctp_association *asoc;
 
@@ -1132,9 +1138,7 @@ sctp_init_asoc(struct sctp_inpcb *m, struct sctp_tcb *stcb,
 		return (ENOMEM);
 	}
 	memset(asoc->mapping_array, 0, asoc->mapping_array_size);
-	/* EY  - initialize the nr_mapping_array just like mapping array */
-	asoc->nr_mapping_array_size = SCTP_INITIAL_NR_MAPPING_ARRAY;
-	SCTP_MALLOC(asoc->nr_mapping_array, uint8_t *, asoc->nr_mapping_array_size,
+	SCTP_MALLOC(asoc->nr_mapping_array, uint8_t *, asoc->mapping_array_size,
 	    SCTP_M_MAP);
 	if (asoc->nr_mapping_array == NULL) {
 		SCTP_FREE(asoc->strmout, SCTP_M_STRMO);
@@ -1142,7 +1146,7 @@ sctp_init_asoc(struct sctp_inpcb *m, struct sctp_tcb *stcb,
 		SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOMEM);
 		return (ENOMEM);
 	}
-	memset(asoc->nr_mapping_array, 0, asoc->nr_mapping_array_size);
+	memset(asoc->nr_mapping_array, 0, asoc->mapping_array_size);
 
 	/* Now the init of the other outqueues */
 	TAILQ_INIT(&asoc->free_chunks);
@@ -1183,87 +1187,70 @@ sctp_init_asoc(struct sctp_inpcb *m, struct sctp_tcb *stcb,
 void
 sctp_print_mapping_array(struct sctp_association *asoc)
 {
-	int i, limit;
+	unsigned int i, limit;
 
-	printf("Mapping size:%d baseTSN:%8.8x cumAck:%8.8x highestTSN:%8.8x\n",
+	printf("Mapping array size: %d, baseTSN: %8.8x, cumAck: %8.8x, highestTSN: (%8.8x, %8.8x).\n",
 	    asoc->mapping_array_size,
 	    asoc->mapping_array_base_tsn,
 	    asoc->cumulative_tsn,
-	    asoc->highest_tsn_inside_map
-	    );
-	limit = asoc->mapping_array_size;
-	for (i = asoc->mapping_array_size; i >= 0; i--) {
-		if (asoc->mapping_array[i]) {
-			limit = i;
+	    asoc->highest_tsn_inside_map,
+	    asoc->highest_tsn_inside_nr_map);
+	for (limit = asoc->mapping_array_size; limit > 1; limit--) {
+		if (asoc->mapping_array[limit - 1]) {
 			break;
 		}
 	}
-	if (limit == 0)
-		limit = 1;
+	printf("Renegable mapping array (last %d entries are zero):\n", asoc->mapping_array_size - limit);
 	for (i = 0; i < limit; i++) {
-		printf("%2.2x ", asoc->mapping_array[i]);
+		printf("%2.2x%c", asoc->mapping_array[i], ((i + 1) % 16) ? ' ' : '\n');
 		if (((i + 1) % 16) == 0)
 			printf("\n");
 	}
-	printf("\n");
-	printf("NR Mapping size:%d baseTSN:%8.8x highestTSN:%8.8x\n",
-	    asoc->nr_mapping_array_size,
-	    asoc->nr_mapping_array_base_tsn,
-	    asoc->highest_tsn_inside_nr_map
-	    );
-	limit = asoc->nr_mapping_array_size;
-	for (i = asoc->nr_mapping_array_size; i >= 0; i--) {
-		if (asoc->nr_mapping_array[i]) {
-			limit = i;
+	if (limit % 16)
+		printf("\n");
+	for (limit = asoc->mapping_array_size; limit > 1; limit--) {
+		if (asoc->nr_mapping_array[limit - 1]) {
 			break;
 		}
 	}
-	if (limit == 0)
-		limit = 1;
-
+	printf("Non renegable mapping array (last %d entries are zero):\n", asoc->mapping_array_size - limit);
 	for (i = 0; i < limit; i++) {
-		printf("%2.2x ", asoc->nr_mapping_array[i]);
-		if (((i + 1) % 16) == 0)
-			printf("\n");
+		printf("%2.2x%c", asoc->mapping_array[i], ((i + 1) % 16) ? ' ' : '\n');
 	}
-	printf("\n");
+	if (limit % 16)
+		printf("\n");
 }
 
 int
 sctp_expand_mapping_array(struct sctp_association *asoc, uint32_t needed)
 {
 	/* mapping array needs to grow */
-	uint8_t *new_array;
+	uint8_t *new_array1, *new_array2;
 	uint32_t new_size;
 
-
 	new_size = asoc->mapping_array_size + ((needed + 7) / 8 + SCTP_MAPPING_ARRAY_INCR);
-
-	SCTP_MALLOC(new_array, uint8_t *, new_size, SCTP_M_MAP);
-	if (new_array == NULL) {
+	SCTP_MALLOC(new_array1, uint8_t *, new_size, SCTP_M_MAP);
+	SCTP_MALLOC(new_array2, uint8_t *, new_size, SCTP_M_MAP);
+	if ((new_array1 == NULL) || (new_array2 == NULL)) {
 		/* can't get more, forget it */
-		SCTP_PRINTF("No memory for expansion of SCTP mapping array %d\n",
-		    new_size);
+		SCTP_PRINTF("No memory for expansion of SCTP mapping array %d\n", new_size);
+		if (new_array1) {
+			SCTP_FREE(new_array1, SCTP_M_MAP);
+		}
+		if (new_array2) {
+			SCTP_FREE(new_array2, SCTP_M_MAP);
+		}
 		return (-1);
 	}
-	memset(new_array, 0, new_size);
-	memcpy(new_array, asoc->mapping_array, asoc->mapping_array_size);
+	memset(new_array1, 0, new_size);
+	memset(new_array2, 0, new_size);
+	memcpy(new_array1, asoc->mapping_array, asoc->mapping_array_size);
+	memcpy(new_array2, asoc->nr_mapping_array, asoc->mapping_array_size);
 	SCTP_FREE(asoc->mapping_array, SCTP_M_MAP);
-	asoc->mapping_array = new_array;
-	asoc->mapping_array_size = new_size;
-	new_size = asoc->nr_mapping_array_size + ((needed + 7) / 8 + SCTP_NR_MAPPING_ARRAY_INCR);
-	SCTP_MALLOC(new_array, uint8_t *, new_size, SCTP_M_MAP);
-	if (new_array == NULL) {
-		/* can't get more, forget it */
-		SCTP_PRINTF("No memory for expansion of SCTP mapping array %d\n",
-		    new_size);
-		return (-1);
-	}
-	memset(new_array, 0, new_size);
-	memcpy(new_array, asoc->nr_mapping_array, asoc->nr_mapping_array_size);
 	SCTP_FREE(asoc->nr_mapping_array, SCTP_M_MAP);
-	asoc->nr_mapping_array = new_array;
-	asoc->nr_mapping_array_size = new_size;
+	asoc->mapping_array = new_array1;
+	asoc->nr_mapping_array = new_array2;
+	asoc->mapping_array_size = new_size;
 	return (0);
 }
 
@@ -1684,21 +1671,9 @@ sctp_timeout_handler(void *t)
 		if ((stcb == NULL) || (inp == NULL)) {
 			break;
 		} {
-			int abort_flag;
-
 			SCTP_STAT_INCR(sctps_timosack);
 			stcb->asoc.timosack++;
-			if (stcb->asoc.cumulative_tsn != stcb->asoc.highest_tsn_inside_map)
-				sctp_sack_check(stcb, 0, 0, &abort_flag);
-
-			/*
-			 * EY if nr_sacks used then send an nr-sack , a sack
-			 * otherwise
-			 */
-			if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) && stcb->asoc.peer_supports_nr_sack)
-				sctp_send_nr_sack(stcb);
-			else
-				sctp_send_sack(stcb);
+			sctp_send_sack(stcb);
 		}
 #ifdef SCTP_AUDITING_ENABLED
 		sctp_auditing(4, inp, stcb, net);
@@ -4758,8 +4733,7 @@ next_on_sent:
 		 */
 		if ((tp1) &&
 		    (tp1->rec.data.stream_number == stream) &&
-		    (tp1->rec.data.stream_seq == seq)
-		    ) {
+		    (tp1->rec.data.stream_seq == seq)) {
 			/*
 			 * save to chk in case we have some on stream out
 			 * queue. If so and we have an un-transmitted one we
@@ -5102,14 +5076,7 @@ sctp_user_rcvd(struct sctp_tcb *stcb, uint32_t * freed_so_far, int hold_rlock,
 			goto out;
 		}
 		SCTP_STAT_INCR(sctps_wu_sacks_sent);
-		/*
-		 * EY if nr_sacks used then send an nr-sack , a sack
-		 * otherwise
-		 */
-		if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off) && stcb->asoc.peer_supports_nr_sack)
-			sctp_send_nr_sack(stcb);
-		else
-			sctp_send_sack(stcb);
+		sctp_send_sack(stcb);
 
 		sctp_chunk_output(stcb->sctp_ep, stcb,
 		    SCTP_OUTPUT_FROM_USR_RCVD, SCTP_SO_LOCKED);
@@ -5479,8 +5446,7 @@ restart_nosblocks:
 					    ((ctl->some_taken) ||
 					    ((ctl->do_not_ref_stcb == 0) &&
 					    ((ctl->spec_flags & M_NOTIFICATION) == 0) &&
-					    (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0)))
-				    ) {
+				    (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0)))) {
 					/*-
 					 * If we have the same tcb, and there is data present, and we
 					 * have the strm interleave feature present. Then if we have
@@ -5939,8 +5905,7 @@ wait_some_more:
 			hold_sblock = 1;
 		}
 		if ((copied_so_far) && (control->length == 0) &&
-		    (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE))
-		    ) {
+		    (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE))) {
 			goto release;
 		}
 		if (so->so_rcv.sb_cc <= control->held_length) {
diff --git a/sys/netinet/sctputil.h b/sys/netinet/sctputil.h
index 8a6ee6fb2134..dfd552aea196 100644
--- a/sys/netinet/sctputil.h
+++ b/sys/netinet/sctputil.h
@@ -81,7 +81,7 @@ uint32_t sctp_select_initial_TSN(struct sctp_pcb *);
 
 uint32_t sctp_select_a_tag(struct sctp_inpcb *, uint16_t lport, uint16_t rport, int);
 
-int sctp_init_asoc(struct sctp_inpcb *, struct sctp_tcb *, int, uint32_t, uint32_t);
+int sctp_init_asoc(struct sctp_inpcb *, struct sctp_tcb *, uint32_t, uint32_t);
 
 void sctp_fill_random_store(struct sctp_pcb *);
 
diff --git a/sys/netinet/tcp_input.c b/sys/netinet/tcp_input.c
index edc8d0a6a894..0254cff0b47c 100644
--- a/sys/netinet/tcp_input.c
+++ b/sys/netinet/tcp_input.c
@@ -1134,6 +1134,8 @@ tcp_do_segment(struct mbuf *m, struct tcphdr *th, struct socket *so,
 	 * TCP ECN processing.
 	 */
 	if (tp->t_flags & TF_ECN_PERMIT) {
+		if (thflags & TH_CWR)
+			tp->t_flags &= ~TF_ECN_SND_ECE;
 		switch (iptos & IPTOS_ECN_MASK) {
 		case IPTOS_ECN_CE:
 			tp->t_flags |= TF_ECN_SND_ECE;
@@ -1146,10 +1148,6 @@ tcp_do_segment(struct mbuf *m, struct tcphdr *th, struct socket *so,
 			TCPSTAT_INC(tcps_ecn_ect1);
 			break;
 		}
-
-		if (thflags & TH_CWR)
-			tp->t_flags &= ~TF_ECN_SND_ECE;
-
 		/*
 		 * Congestion experienced.
 		 * Ignore if we are already trying to recover.
diff --git a/sys/netinet6/in6.c b/sys/netinet6/in6.c
index c839efdc8df5..74c15d58a4ae 100644
--- a/sys/netinet6/in6.c
+++ b/sys/netinet6/in6.c
@@ -2344,8 +2344,12 @@ in6_lltable_prefix_free(struct lltable *llt,
 				    &((struct sockaddr_in6 *)L3_ADDR(lle))->sin6_addr, 
 				    &pfx->sin6_addr, 
 				    &msk->sin6_addr)) {
-				callout_drain(&lle->la_timer);
+				int canceled;
+
+				canceled = callout_drain(&lle->la_timer);
 				LLE_WLOCK(lle);
+				if (canceled)
+					LLE_REMREF(lle);
 				llentry_free(lle);
 			}
 		}
diff --git a/sys/netinet6/mld6.c b/sys/netinet6/mld6.c
index cade0d2b2083..21d9eabe363b 100644
--- a/sys/netinet6/mld6.c
+++ b/sys/netinet6/mld6.c
@@ -195,8 +195,10 @@ static int	sysctl_mld_ifinfo(SYSCTL_HANDLER_ARGS);
 static struct mtx		 mld_mtx;
 MALLOC_DEFINE(M_MLD, "mld", "mld state");
 
-#define	MLD_EMBEDSCOPE(pin6, zoneid) \
-	(pin6)->s6_addr16[1] = htons((zoneid) & 0xFFFF)
+#define	MLD_EMBEDSCOPE(pin6, zoneid)					\
+	if (IN6_IS_SCOPE_LINKLOCAL(pin6) ||				\
+	    IN6_IS_ADDR_MC_INTFACELOCAL(pin6))				\
+		(pin6)->s6_addr16[1] = htons((zoneid) & 0xFFFF)		\
 
 /*
  * VIMAGE-wide globals.
diff --git a/sys/netinet6/nd6.c b/sys/netinet6/nd6.c
index 5c250f4417b6..a0ef2040de12 100644
--- a/sys/netinet6/nd6.c
+++ b/sys/netinet6/nd6.c
@@ -1125,6 +1125,7 @@ nd6_free(struct llentry *ln, int gc)
 	ifp = ln->lle_tbl->llt_ifp;
 	IF_AFDATA_LOCK(ifp);
 	LLE_WLOCK(ln);
+	LLE_REMREF(ln);
 	llentry_free(ln);
 	IF_AFDATA_UNLOCK(ifp);
 
diff --git a/sys/netinet6/sctp6_usrreq.c b/sys/netinet6/sctp6_usrreq.c
index 50f5ef83746c..02e288023208 100644
--- a/sys/netinet6/sctp6_usrreq.c
+++ b/sys/netinet6/sctp6_usrreq.c
@@ -1033,7 +1033,7 @@ sctp6_connect(struct socket *so, struct sockaddr *addr, struct thread *p)
 		return (EALREADY);
 	}
 	/* We are GOOD to go */
-	stcb = sctp_aloc_assoc(inp, addr, 1, &error, 0, vrf_id, p);
+	stcb = sctp_aloc_assoc(inp, addr, &error, 0, vrf_id, p);
 	SCTP_ASOC_CREATE_UNLOCK(inp);
 	if (stcb == NULL) {
 		/* Gak! no memory */
diff --git a/sys/netipsec/ipsec.c b/sys/netipsec/ipsec.c
index 4b552c8139c6..5ee4bbb8f400 100644
--- a/sys/netipsec/ipsec.c
+++ b/sys/netipsec/ipsec.c
@@ -592,7 +592,7 @@ ipsec4_get_ulp(struct mbuf *m, struct secpolicyindex *spidx, int needport)
 	IPSEC_ASSERT(m->m_pkthdr.len >= sizeof(struct ip),("packet too short"));
 
 	/* NB: ip_input() flips it into host endian. XXX Need more checking. */
-	if (m->m_len < sizeof (struct ip)) {
+	if (m->m_len >= sizeof (struct ip)) {
 		struct ip *ip = mtod(m, struct ip *);
 		if (ip->ip_off & (IP_MF | IP_OFFMASK))
 			goto done;
diff --git a/sys/netncp/ncp_conn.c b/sys/netncp/ncp_conn.c
index 5b61dfef879c..03ef5e315d1b 100644
--- a/sys/netncp/ncp_conn.c
+++ b/sys/netncp/ncp_conn.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_conn.h b/sys/netncp/ncp_conn.h
index 1524d4033a02..0a8705161fee 100644
--- a/sys/netncp/ncp_conn.h
+++ b/sys/netncp/ncp_conn.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_file.h b/sys/netncp/ncp_file.h
index cebf4b9db10a..207a1589912e 100644
--- a/sys/netncp/ncp_file.h
+++ b/sys/netncp/ncp_file.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_lib.h b/sys/netncp/ncp_lib.h
index f3ce680ab438..2e8eebe767a5 100644
--- a/sys/netncp/ncp_lib.h
+++ b/sys/netncp/ncp_lib.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_login.c b/sys/netncp/ncp_login.c
index a61eb76dd496..bce8e68b7425 100644
--- a/sys/netncp/ncp_login.c
+++ b/sys/netncp/ncp_login.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_ncp.c b/sys/netncp/ncp_ncp.c
index 92b7e59e95e7..943639e6b815 100644
--- a/sys/netncp/ncp_ncp.c
+++ b/sys/netncp/ncp_ncp.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_ncp.h b/sys/netncp/ncp_ncp.h
index ab1c74229e8c..e62eda25a85a 100644
--- a/sys/netncp/ncp_ncp.h
+++ b/sys/netncp/ncp_ncp.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_nls.c b/sys/netncp/ncp_nls.c
index bb746fc1474f..b5826264106a 100644
--- a/sys/netncp/ncp_nls.c
+++ b/sys/netncp/ncp_nls.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_nls.h b/sys/netncp/ncp_nls.h
index 0a391528536b..0180a92a0fbe 100644
--- a/sys/netncp/ncp_nls.h
+++ b/sys/netncp/ncp_nls.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_rcfile.h b/sys/netncp/ncp_rcfile.h
index 034402d33e07..926af4ecec59 100644
--- a/sys/netncp/ncp_rcfile.h
+++ b/sys/netncp/ncp_rcfile.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_rq.c b/sys/netncp/ncp_rq.c
index f8f7ce2ec3eb..e011c10aabd3 100644
--- a/sys/netncp/ncp_rq.c
+++ b/sys/netncp/ncp_rq.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_rq.h b/sys/netncp/ncp_rq.h
index d0ad9ad57ab7..8d20d3f59661 100644
--- a/sys/netncp/ncp_rq.h
+++ b/sys/netncp/ncp_rq.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_sock.c b/sys/netncp/ncp_sock.c
index 0095f3f094e8..4be432ed3cf0 100644
--- a/sys/netncp/ncp_sock.c
+++ b/sys/netncp/ncp_sock.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_sock.h b/sys/netncp/ncp_sock.h
index a3998a4adada..f8feac511bb2 100644
--- a/sys/netncp/ncp_sock.h
+++ b/sys/netncp/ncp_sock.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_subr.c b/sys/netncp/ncp_subr.c
index da0a6d964792..6664dbdf16bf 100644
--- a/sys/netncp/ncp_subr.c
+++ b/sys/netncp/ncp_subr.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_subr.h b/sys/netncp/ncp_subr.h
index 5c5775565d28..a0d3ce9799ad 100644
--- a/sys/netncp/ncp_subr.h
+++ b/sys/netncp/ncp_subr.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netncp/ncp_user.h b/sys/netncp/ncp_user.h
index dc6d3cddedd9..832715e43f1e 100644
--- a/sys/netncp/ncp_user.h
+++ b/sys/netncp/ncp_user.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1999, Boris Popov
+ * Copyright (c) 1999 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/netbios.h b/sys/netsmb/netbios.h
index 9ee78d8191c1..dff79b9d6256 100644
--- a/sys/netsmb/netbios.h
+++ b/sys/netsmb/netbios.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb.h b/sys/netsmb/smb.h
index a12746538b6c..c6945d3a2de1 100644
--- a/sys/netsmb/smb.h
+++ b/sys/netsmb/smb.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_conn.c b/sys/netsmb/smb_conn.c
index 2307f97ff50b..c14cb8b0c2b2 100644
--- a/sys/netsmb/smb_conn.c
+++ b/sys/netsmb/smb_conn.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_conn.h b/sys/netsmb/smb_conn.h
index 153c83a2a99e..370f6cfaa7f0 100644
--- a/sys/netsmb/smb_conn.h
+++ b/sys/netsmb/smb_conn.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_dev.c b/sys/netsmb/smb_dev.c
index 8c47498869b7..6867804f57d9 100644
--- a/sys/netsmb/smb_dev.c
+++ b/sys/netsmb/smb_dev.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_dev.h b/sys/netsmb/smb_dev.h
index 1454ab3e3ff4..8eb41f30303c 100644
--- a/sys/netsmb/smb_dev.h
+++ b/sys/netsmb/smb_dev.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_iod.c b/sys/netsmb/smb_iod.c
index 29b48e737a85..78def4739f1f 100644
--- a/sys/netsmb/smb_iod.c
+++ b/sys/netsmb/smb_iod.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_rq.c b/sys/netsmb/smb_rq.c
index 3d068b6c1574..4f5c5e63e42b 100644
--- a/sys/netsmb/smb_rq.c
+++ b/sys/netsmb/smb_rq.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_rq.h b/sys/netsmb/smb_rq.h
index d989e4fc0703..af17c9cec0de 100644
--- a/sys/netsmb/smb_rq.h
+++ b/sys/netsmb/smb_rq.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_smb.c b/sys/netsmb/smb_smb.c
index d6633e7d9d94..d3fb94aececf 100644
--- a/sys/netsmb/smb_smb.c
+++ b/sys/netsmb/smb_smb.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_subr.c b/sys/netsmb/smb_subr.c
index 23598a73939e..39d3b49e09a4 100644
--- a/sys/netsmb/smb_subr.c
+++ b/sys/netsmb/smb_subr.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_subr.h b/sys/netsmb/smb_subr.h
index 15e4a7a11474..12730ccaee06 100644
--- a/sys/netsmb/smb_subr.h
+++ b/sys/netsmb/smb_subr.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_tran.h b/sys/netsmb/smb_tran.h
index 4d8955da036d..0169807ef1e0 100644
--- a/sys/netsmb/smb_tran.h
+++ b/sys/netsmb/smb_tran.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_trantcp.c b/sys/netsmb/smb_trantcp.c
index 1a74e728b6ff..c8984510bf7c 100644
--- a/sys/netsmb/smb_trantcp.c
+++ b/sys/netsmb/smb_trantcp.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_trantcp.h b/sys/netsmb/smb_trantcp.h
index 6251b0ef0d70..b4201031ea76 100644
--- a/sys/netsmb/smb_trantcp.h
+++ b/sys/netsmb/smb_trantcp.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/netsmb/smb_usr.c b/sys/netsmb/smb_usr.c
index 2916ee840eee..b5388079052c 100644
--- a/sys/netsmb/smb_usr.c
+++ b/sys/netsmb/smb_usr.c
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/pc98/cbus/clock.c b/sys/pc98/cbus/clock.c
index 22ed8a5f5c9d..3028c074d153 100644
--- a/sys/pc98/cbus/clock.c
+++ b/sys/pc98/cbus/clock.c
@@ -93,7 +93,7 @@ TUNABLE_INT("hw.i8254.freq", &i8254_freq);
 int	i8254_max_count;
 static int i8254_real_max_count;
 
-static int lapic_allclocks;
+static int lapic_allclocks = 1;
 TUNABLE_INT("machdep.lapic_allclocks", &lapic_allclocks);
 
 static	struct mtx clock_lock;
diff --git a/sys/pci/if_rlreg.h b/sys/pci/if_rlreg.h
index b5752895a857..7d2c7e4ad652 100644
--- a/sys/pci/if_rlreg.h
+++ b/sys/pci/if_rlreg.h
@@ -133,6 +133,7 @@
 #define RL_GMEDIASTAT		0x006C	/* 8 bits */
 #define RL_MACDBG		0x006D	/* 8 bits, 8168C SPIN2 only */
 #define RL_GPIO			0x006E	/* 8 bits, 8168C SPIN2 only */
+#define RL_PMCH			0x006F	/* 8 bits */
 #define RL_MAXRXPKTLEN		0x00DA	/* 16 bits, chip multiplies by 8 */
 #define RL_GTXSTART		0x0038	/* 8 bits */
 
@@ -159,9 +160,10 @@
 #define RL_HWREV_8169_8110SB	0x10000000
 #define RL_HWREV_8169_8110SC	0x18000000
 #define RL_HWREV_8102EL		0x24800000
-#define RL_HWREV_8102EL_SPIN1	0x24c00000
+#define RL_HWREV_8102EL_SPIN1	0x24C00000
 #define RL_HWREV_8168D		0x28000000
 #define RL_HWREV_8168DP		0x28800000
+#define RL_HWREV_8168E		0x2C000000
 #define RL_HWREV_8168_SPIN1	0x30000000
 #define RL_HWREV_8100E		0x30800000
 #define RL_HWREV_8101E		0x34000000
@@ -180,7 +182,7 @@
 #define RL_HWREV_8139C		0x74000000
 #define RL_HWREV_8139D		0x74400000
 #define RL_HWREV_8139CPLUS	0x74800000
-#define RL_HWREV_8101		0x74c00000
+#define RL_HWREV_8101		0x74C00000
 #define RL_HWREV_8100		0x78800000
 #define RL_HWREV_8169_8110SBL	0x7CC00000
 #define RL_HWREV_8169_8110SCE	0x98000000
@@ -884,6 +886,7 @@ struct rl_softc {
 	uint32_t		rl_flags;
 #define	RL_FLAG_MSI		0x0001
 #define	RL_FLAG_AUTOPAD		0x0002
+#define	RL_FLAG_PHYWAKE_PM	0x0004
 #define	RL_FLAG_PHYWAKE		0x0008
 #define	RL_FLAG_NOJUMBO		0x0010
 #define	RL_FLAG_PAR		0x0020
diff --git a/sys/powerpc/ofw/ofw_real.c b/sys/powerpc/ofw/ofw_real.c
index 094025c41943..4425ad1bc5de 100644
--- a/sys/powerpc/ofw/ofw_real.c
+++ b/sys/powerpc/ofw/ofw_real.c
@@ -737,6 +737,7 @@ ofw_real_close(ofw_t ofw, ihandle_t instance)
 	} args = {
 		(cell_t)"close",
 		1,
+		0,
 	};
 
 	args.instance = instance;
@@ -876,6 +877,7 @@ ofw_real_release(ofw_t ofw, void *virt, size_t size)
 	} args = {
 		(cell_t)"release",
 		2,
+		0,
 	};
 
 	args.virt = (cell_t)virt;
@@ -897,6 +899,8 @@ ofw_real_enter(ofw_t ofw)
 		cell_t nreturns;
 	} args = {
 		(cell_t)"enter",
+		0,
+		0,
 	};
 
 	openfirmware(&args);
@@ -913,6 +917,8 @@ ofw_real_exit(ofw_t ofw)
 		cell_t nreturns;
 	} args = {
 		(cell_t)"exit",
+		0,
+		0,
 	};
 
 	openfirmware(&args);
diff --git a/sys/sparc64/conf/GENERIC b/sys/sparc64/conf/GENERIC
index 0dc9f5c16bd0..be3cfd3f9ab4 100644
--- a/sys/sparc64/conf/GENERIC
+++ b/sys/sparc64/conf/GENERIC
@@ -143,6 +143,9 @@ device		mk48txx		# Mostek MK48Txx clocks
 device		rtc		# rtc (really a front-end for the MC146818)
 device		mc146818	# Motorola MC146818 and compatible clocks
 device		epic		# Sun Fire V215/V245 LEDs
+device		sbbc		# Sun BootBus controller (time-of-day clock for
+				# Serengeti and StarCat, console for Serengeti,
+				# requires device uart)
 
 # Serial (COM) ports
 device		puc		# Multi-channel uarts
diff --git a/sys/sparc64/conf/NOTES b/sys/sparc64/conf/NOTES
index d9c5be538ea1..5e0228900b54 100644
--- a/sys/sparc64/conf/NOTES
+++ b/sys/sparc64/conf/NOTES
@@ -37,6 +37,7 @@ device		eeprom		# eeprom (really a front-end for the MK48Txx)
 device		mk48txx		# Mostek MK48Txx clocks
 device		rtc		# rtc (really a front-end for the MC146818)
 device		mc146818	# Motorola MC146818 and compatible clocks
+device		sbbc		# Sun BootBus controller
 
 #
 # Optional devices:
diff --git a/sys/sparc64/include/dcr.h b/sys/sparc64/include/dcr.h
index b1f993a06095..42159adc9c13 100644
--- a/sys/sparc64/include/dcr.h
+++ b/sys/sparc64/include/dcr.h
@@ -43,8 +43,8 @@
 #define	DCR_OBSDATA_CT_MASK						\
 	(((1UL << DCR_OBSDATA_CT_BITS) - 1) << DCR_OBSDATA_SHIFT)
 
-/* The following bits are valid for the UltraSPARC-III+/IV+ only. */
-#define	DCR_IPE			(1UL << 5)
+/* The following bits are valid for the UltraSPARC-III++/IV+ only. */
+#define	DCR_IPE			(1UL << 2)
 
 #define	DCR_OBSDATA_CTP_BITS	6
 #define	DCR_OBSDATA_CTP_MASK						\
diff --git a/sys/sparc64/include/lsu.h b/sys/sparc64/include/lsu.h
index a8787dcabdc7..5eeaa5566fcf 100644
--- a/sys/sparc64/include/lsu.h
+++ b/sys/sparc64/include/lsu.h
@@ -29,7 +29,7 @@
 
 /*
  * Definitions for the Load-Store-Unit Control Register. This is called
- * Data Cache Unit Control Register (DCUCR) for UltraSPARC-III.
+ * Data Cache Unit Control Register (DCUCR) for UltraSPARC-III and greater.
  */
 #define	LSU_IC		(1UL << 0)
 #define	LSU_DC		(1UL << 1)
@@ -41,7 +41,7 @@
 #define	LSU_FM_BITS	16
 #define	LSU_FM_MASK	(((1UL << LSU_FM_BITS) - 1) << LSU_FM_SHIFT)
 
-#define LSU_VM_SHIFT	25
+#define	LSU_VM_SHIFT	25
 #define	LSU_VM_BITS	8
 #define	LSU_VM_MASK	(((1UL << LSU_VM_BITS) - 1) << LSU_VM_SHIFT)
 
@@ -65,4 +65,22 @@
 #define	LSU_CV		(1UL << 48)
 #define	LSU_CP		(1UL << 49)
 
+/* The following bit is valid for the UltraSPARC-IV only. */
+#define	LSU_WIH		(1UL << 4)
+
+/* The following bits are valid for the UltraSPARC-IV+ only. */
+#define	LSU_PPS_SHIFT	50
+#define	LSU_PPS_BITS	2
+#define	LSU_PPS_MASK	(((1UL << LSU_PPS_BITS) - 1) << LSU_PPS_SHIFT)
+
+#define	LSU_IPS_SHIFT	52
+#define	LSU_IPS_BITS	2
+#define	LSU_IPS_MASK	(((1UL << LSU_IPS_BITS) - 1) << LSU_IPS_SHIFT)
+
+#define	LSU_PCM		(1UL << 54)
+#define	LSU_WCE		(1UL << 55)
+
+/* The following bit is valid for the SPARC64 V, VI, VII and VIIIfx only. */
+#define	LSU_WEAK_SPCA	(1UL << 41)
+
 #endif	/* _MACHINE_LSU_H_ */
diff --git a/sys/sparc64/pci/sbbc.c b/sys/sparc64/pci/sbbc.c
new file mode 100644
index 000000000000..0aa1df3850c6
--- /dev/null
+++ b/sys/sparc64/pci/sbbc.c
@@ -0,0 +1,1074 @@
+/*	$OpenBSD: sbbc.c,v 1.7 2009/11/09 17:53:39 nicm Exp $	*/
+/*-
+ * Copyright (c) 2008 Mark Kettenis
+ *
+ * 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.
+ */
+/*-
+ * Copyright (c) 2010 Marius Strobl <marius@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>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+#include <sys/clock.h>
+#include <sys/endian.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/module.h>
+#include <sys/mutex.h>
+#include <sys/resource.h>
+#include <sys/rman.h>
+
+#include <dev/ofw/ofw_bus.h>
+#include <dev/ofw/openfirm.h>
+
+#include <machine/bus.h>
+#include <machine/cpu.h>
+#include <machine/resource.h>
+
+#include <dev/pci/pcireg.h>
+#include <dev/pci/pcivar.h>
+#include <dev/uart/uart.h>
+#include <dev/uart/uart_cpu.h>
+#include <dev/uart/uart_bus.h>
+
+#include "clock_if.h"
+#include "uart_if.h"
+
+#define	SBBC_PCI_BAR		PCIR_BAR(0)
+#define	SBBC_PCI_VENDOR		0x108e
+#define	SBBC_PCI_PRODUCT	0xc416
+
+#define	SBBC_REGS_OFFSET	0x800000
+#define	SBBC_REGS_SIZE		0x6230
+#define	SBBC_EPLD_OFFSET	0x8e0000
+#define	SBBC_EPLD_SIZE		0x20
+#define	SBBC_SRAM_OFFSET	0x900000
+#define	SBBC_SRAM_SIZE		0x20000	/* 128KB SRAM */
+
+#define	SBBC_PCI_INT_STATUS	0x2320
+#define	SBBC_PCI_INT_ENABLE	0x2330
+#define	SBBC_PCI_ENABLE_INT_A	0x11
+
+#define	SBBC_EPLD_INTERRUPT	0x13
+#define	SBBC_EPLD_INTERRUPT_ON	0x01
+
+#define	SBBC_SRAM_CONS_IN		0x00000001
+#define	SBBC_SRAM_CONS_OUT		0x00000002
+#define	SBBC_SRAM_CONS_BRK		0x00000004
+#define	SBBC_SRAM_CONS_SPACE_IN		0x00000008
+#define	SBBC_SRAM_CONS_SPACE_OUT	0x00000010
+
+#define	SBBC_TAG_KEY_SIZE	8
+#define	SBBC_TAG_KEY_SCSOLIE	"SCSOLIE"	/* SC -> OS int. enable */
+#define	SBBC_TAG_KEY_SCSOLIR	"SCSOLIR"	/* SC -> OS int. reason */
+#define	SBBC_TAG_KEY_SOLCONS	"SOLCONS"	/* OS console buffer */
+#define	SBBC_TAG_KEY_SOLSCIE	"SOLSCIE"	/* OS -> SC int. enable */
+#define	SBBC_TAG_KEY_SOLSCIR	"SOLSCIR"	/* OS -> SC int. reason */
+#define	SBBC_TAG_KEY_TODDATA	"TODDATA"	/* OS TOD struct */
+#define	SBBC_TAG_OFF(x)		offsetof(struct sbbc_sram_tag, x)
+
+struct sbbc_sram_tag {
+	char		tag_key[SBBC_TAG_KEY_SIZE];
+	uint32_t	tag_size;
+	uint32_t	tag_offset;
+} __packed;
+
+#define	SBBC_TOC_MAGIC		"TOCSRAM"
+#define	SBBC_TOC_MAGIC_SIZE	8
+#define	SBBC_TOC_TAGS_MAX	32
+#define	SBBC_TOC_OFF(x)		offsetof(struct sbbc_sram_toc, x)
+
+struct sbbc_sram_toc {
+	char			toc_magic[SBBC_TOC_MAGIC_SIZE];
+	uint8_t			toc_reserved;
+	uint8_t			toc_type;
+	uint16_t		toc_version;
+	uint32_t		toc_ntags;
+	struct sbbc_sram_tag	toc_tag[SBBC_TOC_TAGS_MAX];
+} __packed;
+
+#define	SBBC_TOD_MAGIC		0x54443100	/* "TD1" */
+#define	SBBC_TOD_VERSION	1
+#define	SBBC_TOD_OFF(x)		offsetof(struct sbbc_sram_tod, x)
+
+struct sbbc_sram_tod {
+	uint32_t	tod_magic;
+	uint32_t	tod_version;
+	uint64_t	tod_time;
+	uint64_t	tod_skew;
+	uint32_t	tod_reserved;
+	uint32_t	tod_heartbeat;
+	uint32_t	tod_timeout;
+} __packed;
+
+#define	SBBC_CONS_MAGIC		0x434f4e00	/* "CON" */
+#define	SBBC_CONS_VERSION	1
+#define	SBBC_CONS_OFF(x)	offsetof(struct sbbc_sram_cons, x)
+
+struct sbbc_sram_cons {
+	uint32_t cons_magic;
+	uint32_t cons_version;
+	uint32_t cons_size;
+
+	uint32_t cons_in_begin;
+	uint32_t cons_in_end;
+	uint32_t cons_in_rdptr;
+	uint32_t cons_in_wrptr;
+
+	uint32_t cons_out_begin;
+	uint32_t cons_out_end;
+	uint32_t cons_out_rdptr;
+	uint32_t cons_out_wrptr;
+} __packed;
+
+struct sbbc_softc {
+	struct resource *sc_res;
+};
+
+#define	SBBC_READ_N(wdth, offs)						\
+	bus_space_read_ ## wdth((bst), (bsh), (offs))
+#define	SBBC_WRITE_N(wdth, offs, val)					\
+	bus_space_write_ ## wdth((bst), (bsh), (offs), (val))
+
+#define	SBBC_READ_1(offs)						\
+	SBBC_READ_N(1, (offs))
+#define	SBBC_READ_2(offs)						\
+	bswap16(SBBC_READ_N(2, (offs)))
+#define	SBBC_READ_4(offs)						\
+	bswap32(SBBC_READ_N(4, (offs)))
+#define	SBBC_READ_8(offs)						\
+	bswap64(SBBC_READ_N(8, (offs)))
+#define	SBBC_WRITE_1(offs, val)						\
+	SBBC_WRITE_N(1, (offs), (val))
+#define	SBBC_WRITE_2(offs, val)						\
+	SBBC_WRITE_N(2, (offs), bswap16(val))
+#define	SBBC_WRITE_4(offs, val)						\
+	SBBC_WRITE_N(4, (offs), bswap32(val))
+#define	SBBC_WRITE_8(offs, val)						\
+	SBBC_WRITE_N(8, (offs), bswap64(val))
+
+#define	SBBC_REGS_READ_1(offs)						\
+	SBBC_READ_1((offs) + SBBC_REGS_OFFSET)
+#define	SBBC_REGS_READ_2(offs)						\
+	SBBC_READ_2((offs) + SBBC_REGS_OFFSET)
+#define	SBBC_REGS_READ_4(offs)						\
+	SBBC_READ_4((offs) + SBBC_REGS_OFFSET)
+#define	SBBC_REGS_READ_8(offs)						\
+	SBBC_READ_8((offs) + SBBC_REGS_OFFSET)
+#define	SBBC_REGS_WRITE_1(offs, val)					\
+	SBBC_WRITE_1((offs) + SBBC_REGS_OFFSET, (val))
+#define	SBBC_REGS_WRITE_2(offs, val)					\
+	SBBC_WRITE_2((offs) + SBBC_REGS_OFFSET, (val))
+#define	SBBC_REGS_WRITE_4(offs, val)					\
+	SBBC_WRITE_4((offs) + SBBC_REGS_OFFSET, (val))
+#define	SBBC_REGS_WRITE_8(offs, val)					\
+	SBBC_WRITE_8((offs) + SBBC_REGS_OFFSET, (val))
+
+#define	SBBC_EPLD_READ_1(offs)						\
+	SBBC_READ_1((offs) + SBBC_EPLD_OFFSET)
+#define	SBBC_EPLD_READ_2(offs)						\
+	SBBC_READ_2((offs) + SBBC_EPLD_OFFSET)
+#define	SBBC_EPLD_READ_4(offs)						\
+	SBBC_READ_4((offs) + SBBC_EPLD_OFFSET)
+#define	SBBC_EPLD_READ_8(offs)						\
+	SBBC_READ_8((offs) + SBBC_EPLD_OFFSET)
+#define	SBBC_EPLD_WRITE_1(offs, val)					\
+	SBBC_WRITE_1((offs) + SBBC_EPLD_OFFSET, (val))
+#define	SBBC_EPLD_WRITE_2(offs, val)					\
+	SBBC_WRITE_2((offs) + SBBC_EPLD_OFFSET, (val))
+#define	SBBC_EPLD_WRITE_4(offs, val)					\
+	SBBC_WRITE_4((offs) + SBBC_EPLD_OFFSET, (val))
+#define	SBBC_EPLD_WRITE_8(offs, val)					\
+	SBBC_WRITE_8((offs) + SBBC_EPLD_OFFSET, (val))
+
+#define	SBBC_SRAM_READ_1(offs)						\
+	SBBC_READ_1((offs) + SBBC_SRAM_OFFSET)
+#define	SBBC_SRAM_READ_2(offs)						\
+	SBBC_READ_2((offs) + SBBC_SRAM_OFFSET)
+#define	SBBC_SRAM_READ_4(offs)						\
+	SBBC_READ_4((offs) + SBBC_SRAM_OFFSET)
+#define	SBBC_SRAM_READ_8(offs)						\
+	SBBC_READ_8((offs) + SBBC_SRAM_OFFSET)
+#define	SBBC_SRAM_WRITE_1(offs, val)					\
+	SBBC_WRITE_1((offs) + SBBC_SRAM_OFFSET, (val))
+#define	SBBC_SRAM_WRITE_2(offs, val)					\
+	SBBC_WRITE_2((offs) + SBBC_SRAM_OFFSET, (val))
+#define	SBBC_SRAM_WRITE_4(offs, val)					\
+	SBBC_WRITE_4((offs) + SBBC_SRAM_OFFSET, (val))
+#define	SBBC_SRAM_WRITE_8(offs, val)					\
+	SBBC_WRITE_8((offs) + SBBC_SRAM_OFFSET, (val))
+
+#define	SUNW_SETCONSINPUT	"SUNW,set-console-input"
+#define	SUNW_SETCONSINPUT_CLNT	"CON_CLNT"
+#define	SUNW_SETCONSINPUT_OBP	"CON_OBP"
+
+static u_int sbbc_console;
+
+static uint32_t	sbbc_scsolie;
+static uint32_t	sbbc_scsolir;
+static uint32_t	sbbc_solcons;
+static uint32_t	sbbc_solscie;
+static uint32_t	sbbc_solscir;
+static uint32_t	sbbc_toddata;
+
+/*
+ * internal helpers
+ */
+static int sbbc_parse_toc(bus_space_tag_t bst, bus_space_handle_t bsh);
+static inline void sbbc_send_intr(bus_space_tag_t bst,
+    bus_space_handle_t bsh);
+static const char *sbbc_serengeti_set_console_input(char *new);
+
+/*
+ * SBBC PCI interface
+ */
+static bus_alloc_resource_t sbbc_bus_alloc_resource;
+static bus_release_resource_t sbbc_bus_release_resource;
+static bus_get_resource_list_t sbbc_bus_get_resource_list;
+static bus_setup_intr_t sbbc_bus_setup_intr;
+static bus_teardown_intr_t sbbc_bus_teardown_intr;
+
+static device_attach_t sbbc_pci_attach;
+static device_probe_t sbbc_pci_probe;
+
+static clock_gettime_t sbbc_tod_gettime;
+static clock_settime_t sbbc_tod_settime;
+
+static device_method_t sbbc_pci_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		sbbc_pci_probe),
+	DEVMETHOD(device_attach,	sbbc_pci_attach),
+
+	DEVMETHOD(bus_print_child,	bus_generic_print_child),
+	DEVMETHOD(bus_alloc_resource,	sbbc_bus_alloc_resource),
+	DEVMETHOD(bus_release_resource,	sbbc_bus_release_resource),
+	DEVMETHOD(bus_setup_intr,	sbbc_bus_setup_intr),
+	DEVMETHOD(bus_teardown_intr,	sbbc_bus_teardown_intr),
+	DEVMETHOD(bus_get_resource_list, sbbc_bus_get_resource_list),
+
+	/* clock interface */
+	DEVMETHOD(clock_gettime,	sbbc_tod_gettime),
+	DEVMETHOD(clock_settime,	sbbc_tod_settime),
+
+	KOBJMETHOD_END
+};
+
+static devclass_t sbbc_devclass;
+
+DEFINE_CLASS_0(sbbc, sbbc_driver, sbbc_pci_methods, sizeof(struct sbbc_softc));
+DRIVER_MODULE(sbbc, pci, sbbc_driver, sbbc_devclass, 0, 0);
+
+static int
+sbbc_pci_probe(device_t dev)
+{
+
+	if (pci_get_vendor(dev) == SBBC_PCI_VENDOR &&
+	    pci_get_device(dev) == SBBC_PCI_PRODUCT) {
+		device_set_desc(dev, "Sun BootBus controller");
+		return (BUS_PROBE_DEFAULT);
+	}
+	return (ENXIO);
+}
+
+static int
+sbbc_pci_attach(device_t dev)
+{
+	struct sbbc_softc *sc;
+	struct timespec ts;
+	device_t child;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	phandle_t node;
+	int error, rid;
+	uint32_t val;
+
+	/* Nothing to to if we're not the chosen one. */
+	if ((node = OF_finddevice("/chosen")) == -1) {
+		device_printf(dev, "failed to find /chosen\n");
+		return (ENXIO);
+	}
+	if (OF_getprop(node, "iosram", &node, sizeof(node)) == -1) {
+		device_printf(dev, "failed to get iosram\n");
+		return (ENXIO);
+	}
+	if (node != ofw_bus_get_node(dev))
+		return (0);
+
+	sc = device_get_softc(dev);
+	rid = SBBC_PCI_BAR;
+	/*
+	 * Note that we don't activate the resource so it's not mapped twice
+	 * but only once by the the firmware.
+	 */
+	sc->sc_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 0);
+	if (sc->sc_res == NULL) {
+		device_printf(dev, "failed to allocate resources\n");
+		return (ENXIO);
+	}
+	bst = rman_get_bustag(sc->sc_res);
+	bsh = rman_get_bushandle(sc->sc_res);
+	if (sbbc_console != 0) {
+		/* Once again the interrupt pin isn't set. */
+		if (pci_get_intpin(dev) == 0)
+			pci_set_intpin(dev, 1);
+		child = device_add_child(dev, NULL, -1);
+		if (child == NULL)
+			device_printf(dev, "failed to add UART device\n");
+		error = bus_generic_attach(dev);
+		if (error != 0)
+			device_printf(dev, "failed to attach UART device\n");
+	} else {
+		error = sbbc_parse_toc(rman_get_bustag(sc->sc_res),
+		    rman_get_bushandle(sc->sc_res));
+		if (error != 0) {
+			device_printf(dev, "failed to parse TOC\n");
+			if (sbbc_console != 0) {
+				bus_release_resource(dev, SYS_RES_MEMORY, rid,
+				    sc->sc_res);
+				return (error);
+			}
+		}
+	}
+	if (sbbc_toddata != 0) {
+		if ((val = SBBC_SRAM_READ_4(sbbc_toddata +
+		    SBBC_TOD_OFF(tod_magic))) != SBBC_TOD_MAGIC)
+			device_printf(dev, "invalid TOD magic %#x\n", val);
+		else if ((val = SBBC_SRAM_READ_4(sbbc_toddata +
+		    SBBC_TOD_OFF(tod_version))) < SBBC_TOD_VERSION)
+			device_printf(dev, "invalid TOD version %#x\n", val);
+		else {
+			clock_register(dev, 1000000); /* 1 sec. resolution */
+			if (bootverbose) {
+				sbbc_tod_gettime(dev, &ts);
+				device_printf(dev,
+				    "current time: %ld.%09ld\n",
+				    (long)ts.tv_sec, ts.tv_nsec);
+			}
+		}
+	}
+	return (0);
+}
+
+/*
+ * Note that the bus methods don't pass-through the uart(4) requests but act
+ * as if they would come from sbbc(4) in order to avoid complications with
+ * pci(4) (actually, uart(4) isn't a real child but rather a function of
+ * sbbc(4) anyway).
+ */
+
+static struct resource *
+sbbc_bus_alloc_resource(device_t dev, device_t child __unused, int type,
+    int *rid, u_long start, u_long end, u_long count, u_int flags)
+{
+	struct sbbc_softc *sc;
+
+	sc = device_get_softc(dev);
+	switch (type) {
+	case SYS_RES_IRQ:
+		return (BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, type,
+		    rid, start, end, count, flags));
+	case SYS_RES_MEMORY:
+		return (sc->sc_res);
+	default:
+		return (NULL);
+		/* NOTREACHED */
+	}
+}
+
+static int
+sbbc_bus_release_resource(device_t dev, device_t child __unused, int type,
+    int rid, struct resource *res)
+{
+
+	if (type == SYS_RES_IRQ)
+		return (BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
+		    type, rid, res));
+	return (0);
+}
+
+static struct resource_list *
+sbbc_bus_get_resource_list(device_t dev, device_t child __unused)
+{
+
+	return (BUS_GET_RESOURCE_LIST(device_get_parent(dev), dev));
+}
+
+static int
+sbbc_bus_setup_intr(device_t dev, device_t child __unused,
+    struct resource *res, int flags, driver_filter_t *filt,
+    driver_intr_t *intr, void *arg, void **cookiep)
+{
+
+	return (BUS_SETUP_INTR(device_get_parent(dev), dev, res, flags, filt,
+	    intr, arg, cookiep));
+}
+
+static int
+sbbc_bus_teardown_intr(device_t dev, device_t child __unused,
+    struct resource *res, void *cookie)
+{
+
+	return (BUS_TEARDOWN_INTR(device_get_parent(dev), dev, res, cookie));
+}
+
+/*
+ * internal helpers
+ */
+static int
+sbbc_parse_toc(bus_space_tag_t bst, bus_space_handle_t bsh)
+{
+	char buf[MAX(SBBC_TAG_KEY_SIZE, SBBC_TOC_MAGIC_SIZE)];
+	bus_size_t tag;
+	phandle_t node;
+	uint32_t off, sram_toc;
+	u_int i, tags;
+
+	if ((node = OF_finddevice("/chosen")) == -1)
+		return (ENXIO);
+	/* SRAM TOC offset defaults to 0. */
+	if (OF_getprop(node, "iosram-toc", &sram_toc, sizeof(sram_toc)) <= 0)
+		sram_toc = 0;
+
+	bus_space_read_region_1(bst, bsh, SBBC_SRAM_OFFSET + sram_toc +
+	    SBBC_TOC_OFF(toc_magic), buf, SBBC_TOC_MAGIC_SIZE);
+	buf[SBBC_TOC_MAGIC_SIZE - 1] = '\0';
+	if (strcmp(buf, SBBC_TOC_MAGIC) != 0)
+		return (ENXIO);
+
+	tags = SBBC_SRAM_READ_4(sram_toc + SBBC_TOC_OFF(toc_ntags));
+	for (i = 0; i < tags; i++) {
+		tag = sram_toc + SBBC_TOC_OFF(toc_tag) +
+		    i * sizeof(struct sbbc_sram_tag);
+		bus_space_read_region_1(bst, bsh, SBBC_SRAM_OFFSET + tag +
+		    SBBC_TAG_OFF(tag_key), buf, SBBC_TAG_KEY_SIZE);
+		buf[SBBC_TAG_KEY_SIZE - 1] = '\0';
+		off = SBBC_SRAM_READ_4(tag + SBBC_TAG_OFF(tag_offset));
+		if (strcmp(buf, SBBC_TAG_KEY_SCSOLIE) == 0)
+			sbbc_scsolie = off;
+		else if (strcmp(buf, SBBC_TAG_KEY_SCSOLIR) == 0)
+			sbbc_scsolir = off;
+		else if (strcmp(buf, SBBC_TAG_KEY_SOLCONS) == 0)
+			sbbc_solcons = off;
+		else if (strcmp(buf, SBBC_TAG_KEY_SOLSCIE) == 0)
+			sbbc_solscie = off;
+		else if (strcmp(buf, SBBC_TAG_KEY_SOLSCIR) == 0)
+			sbbc_solscir = off;
+		else if (strcmp(buf, SBBC_TAG_KEY_TODDATA) == 0)
+			sbbc_toddata = off;
+	}
+	return (0);
+}
+
+static const char *
+sbbc_serengeti_set_console_input(char *new)
+{
+	struct {
+		cell_t name;
+		cell_t nargs;
+		cell_t nreturns;
+		cell_t new;
+		cell_t old;
+	} args = {
+		(cell_t)SUNW_SETCONSINPUT,
+		1,
+		1,
+	};
+
+	args.new = (cell_t)new;
+	if (ofw_entry(&args) == -1)
+		return (NULL);
+	return ((const char *)args.old);
+}
+
+static inline void
+sbbc_send_intr(bus_space_tag_t bst, bus_space_handle_t bsh)
+{
+
+	SBBC_EPLD_WRITE_1(SBBC_EPLD_INTERRUPT, SBBC_EPLD_INTERRUPT_ON);
+	bus_space_barrier(bst, bsh, SBBC_EPLD_OFFSET + SBBC_EPLD_INTERRUPT, 1,
+	    BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
+}
+
+/*
+ * TOD interface
+ */
+static int
+sbbc_tod_gettime(device_t dev, struct timespec *ts)
+{
+	struct sbbc_softc *sc;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+
+	sc = device_get_softc(dev);
+	bst = rman_get_bustag(sc->sc_res);
+	bsh = rman_get_bushandle(sc->sc_res);
+
+	ts->tv_sec = SBBC_SRAM_READ_8(sbbc_toddata + SBBC_TOD_OFF(tod_time)) +
+	    SBBC_SRAM_READ_8(sbbc_toddata + SBBC_TOD_OFF(tod_skew));
+	ts->tv_nsec = 0;
+	return (0);
+}
+
+static int
+sbbc_tod_settime(device_t dev, struct timespec *ts)
+{
+	struct sbbc_softc *sc;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+
+	sc = device_get_softc(dev);
+	bst = rman_get_bustag(sc->sc_res);
+	bsh = rman_get_bushandle(sc->sc_res);
+
+	SBBC_SRAM_WRITE_8(sbbc_toddata + SBBC_TOD_OFF(tod_skew), ts->tv_sec -
+	    SBBC_SRAM_READ_8(sbbc_toddata + SBBC_TOD_OFF(tod_time)));
+	return (0);
+}
+
+/*
+ * UART bus front-end
+ */
+static device_probe_t sbbc_uart_sbbc_probe;
+
+static device_method_t sbbc_uart_sbbc_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		sbbc_uart_sbbc_probe),
+	DEVMETHOD(device_attach,	uart_bus_attach),
+	DEVMETHOD(device_detach,	uart_bus_detach),
+
+	KOBJMETHOD_END
+};
+
+DEFINE_CLASS_0(uart, sbbc_uart_driver, sbbc_uart_sbbc_methods,
+    sizeof(struct uart_softc));
+DRIVER_MODULE(uart, sbbc, sbbc_uart_driver, uart_devclass, 0, 0);
+
+static int
+sbbc_uart_sbbc_probe(device_t dev)
+{
+	struct uart_softc *sc;
+
+	sc = device_get_softc(dev);
+	sc->sc_class = &uart_sbbc_class;
+	device_set_desc(dev, "Serengeti console");
+	return (uart_bus_probe(dev, 0, 0, SBBC_PCI_BAR, 0));
+}
+
+/*
+ * Low-level UART interface
+ */
+static int sbbc_uart_probe(struct uart_bas *bas);
+static void sbbc_uart_init(struct uart_bas *bas, int baudrate, int databits,
+    int stopbits, int parity);
+static void sbbc_uart_term(struct uart_bas *bas);
+static void sbbc_uart_putc(struct uart_bas *bas, int c);
+static int sbbc_uart_rxready(struct uart_bas *bas);
+static int sbbc_uart_getc(struct uart_bas *bas, struct mtx *hwmtx);
+
+static struct uart_ops sbbc_uart_ops = {
+	.probe = sbbc_uart_probe,
+	.init = sbbc_uart_init,
+	.term = sbbc_uart_term,
+	.putc = sbbc_uart_putc,
+	.rxready = sbbc_uart_rxready,
+	.getc = sbbc_uart_getc,
+};
+
+static int
+sbbc_uart_probe(struct uart_bas *bas)
+{
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	int error;
+
+	sbbc_console = 1;
+	bst = bas->bst;
+	bsh = bas->bsh;
+	error = sbbc_parse_toc(bst, bsh);
+	if (error != 0)
+		return (error);
+
+	if (sbbc_scsolie == 0 || sbbc_scsolir == 0 || sbbc_solcons == 0 ||
+	    sbbc_solscie == 0 || sbbc_solscir == 0)
+		return (ENXIO);
+
+	if (SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_magic)) !=
+	    SBBC_CONS_MAGIC || SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_version)) < SBBC_CONS_VERSION)
+		return (ENXIO);
+	return (0);
+}
+
+static void
+sbbc_uart_init(struct uart_bas *bas, int baudrate __unused,
+    int databits __unused, int stopbits __unused, int parity __unused)
+{
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	/* Enable output to and space in from the SC interrupts. */
+	SBBC_SRAM_WRITE_4(sbbc_solscie, SBBC_SRAM_READ_4(sbbc_solscie) |
+	    SBBC_SRAM_CONS_OUT | SBBC_SRAM_CONS_SPACE_IN);
+	uart_barrier(bas);
+
+	/* Take over the console input. */
+	sbbc_serengeti_set_console_input(SUNW_SETCONSINPUT_CLNT);
+}
+
+static void
+sbbc_uart_term(struct uart_bas *bas __unused)
+{
+
+	/* Give back the console input. */
+	sbbc_serengeti_set_console_input(SUNW_SETCONSINPUT_OBP);
+}
+
+static void
+sbbc_uart_putc(struct uart_bas *bas, int c)
+{
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	uint32_t wrptr;
+
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	wrptr = SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_out_wrptr));
+	SBBC_SRAM_WRITE_1(sbbc_solcons + wrptr, c);
+	uart_barrier(bas);
+	if (++wrptr == SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_out_end)))
+		wrptr = SBBC_SRAM_READ_4(sbbc_solcons +
+		    SBBC_CONS_OFF(cons_out_begin));
+	SBBC_SRAM_WRITE_4(sbbc_solcons + SBBC_CONS_OFF(cons_out_wrptr),
+	    wrptr);
+	uart_barrier(bas);
+
+	SBBC_SRAM_WRITE_4(sbbc_solscir, SBBC_SRAM_READ_4(sbbc_solscir) |
+	    SBBC_SRAM_CONS_OUT);
+	uart_barrier(bas);
+	sbbc_send_intr(bst, bsh);
+}
+
+static int
+sbbc_uart_rxready(struct uart_bas *bas)
+{
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	if (SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_rdptr)) ==
+	    SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_wrptr)))
+		return (0);
+	return (1);
+}
+
+static int
+sbbc_uart_getc(struct uart_bas *bas, struct mtx *hwmtx)
+{
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	int c;
+	uint32_t rdptr;
+
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	uart_lock(hwmtx);
+
+	while (sbbc_uart_rxready(bas) == 0) {
+		uart_unlock(hwmtx);
+		DELAY(4);
+		uart_lock(hwmtx);
+	}
+
+	rdptr = SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_rdptr));
+	c = SBBC_SRAM_READ_1(sbbc_solcons + rdptr);
+	uart_barrier(bas);
+	if (++rdptr == SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_in_end)))
+		rdptr = SBBC_SRAM_READ_4(sbbc_solcons +
+		    SBBC_CONS_OFF(cons_in_begin));
+	SBBC_SRAM_WRITE_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_rdptr),
+	    rdptr);
+	uart_barrier(bas);
+	SBBC_SRAM_WRITE_4(sbbc_solscir, SBBC_SRAM_READ_4(sbbc_solscir) |
+	    SBBC_SRAM_CONS_SPACE_IN);
+	uart_barrier(bas);
+	sbbc_send_intr(bst, bsh);
+
+	uart_unlock(hwmtx);
+	return (c);
+}
+
+/*
+ * High-level UART interface
+ */
+static int sbbc_uart_bus_attach(struct uart_softc *sc);
+static int sbbc_uart_bus_detach(struct uart_softc *sc);
+static int sbbc_uart_bus_flush(struct uart_softc *sc, int what);
+static int sbbc_uart_bus_getsig(struct uart_softc *sc);
+static int sbbc_uart_bus_ioctl(struct uart_softc *sc, int request,
+    intptr_t data);
+static int sbbc_uart_bus_ipend(struct uart_softc *sc);
+static int sbbc_uart_bus_param(struct uart_softc *sc, int baudrate,
+    int databits, int stopbits, int parity);
+static int sbbc_uart_bus_probe(struct uart_softc *sc);
+static int sbbc_uart_bus_receive(struct uart_softc *sc);
+static int sbbc_uart_bus_setsig(struct uart_softc *sc, int sig);
+static int sbbc_uart_bus_transmit(struct uart_softc *sc);
+
+static kobj_method_t sbbc_uart_methods[] = {
+	KOBJMETHOD(uart_attach,		sbbc_uart_bus_attach),
+	KOBJMETHOD(uart_detach,		sbbc_uart_bus_detach),
+	KOBJMETHOD(uart_flush,		sbbc_uart_bus_flush),
+	KOBJMETHOD(uart_getsig,		sbbc_uart_bus_getsig),
+	KOBJMETHOD(uart_ioctl,		sbbc_uart_bus_ioctl),
+	KOBJMETHOD(uart_ipend,		sbbc_uart_bus_ipend),
+	KOBJMETHOD(uart_param,		sbbc_uart_bus_param),
+	KOBJMETHOD(uart_probe,		sbbc_uart_bus_probe),
+	KOBJMETHOD(uart_receive,	sbbc_uart_bus_receive),
+	KOBJMETHOD(uart_setsig,		sbbc_uart_bus_setsig),
+	KOBJMETHOD(uart_transmit,	sbbc_uart_bus_transmit),
+
+	KOBJMETHOD_END
+};
+
+struct uart_class uart_sbbc_class = {
+	"sbbc",
+	sbbc_uart_methods,
+	sizeof(struct uart_softc),
+	.uc_ops = &sbbc_uart_ops,
+	.uc_range = 1,
+	.uc_rclk = 0x5bbc	/* arbitrary */
+};
+
+#define	SIGCHG(c, i, s, d)						\
+	if ((c) != 0) {							\
+		i |= (((i) & (s)) != 0) ? (s) : (s) | (d);		\
+	} else {							\
+		i = (((i) & (s)) != 0) ? ((i) & ~(s)) | (d) : (i);	\
+	}
+
+static int
+sbbc_uart_bus_attach(struct uart_softc *sc)
+{
+	struct uart_bas *bas;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	uint32_t wrptr;
+
+	bas = &sc->sc_bas;
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	sc->sc_rxfifosz = SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_in_end)) - SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_in_begin)) - 1;
+	sc->sc_txfifosz = SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_out_end)) - SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_out_begin)) - 1;
+
+	uart_lock(sc->sc_hwmtx);
+
+	/*
+	 * Let the current output drain before enabling interrupts.  Not
+	 * doing so tends to cause lost output when turning them on.
+	 */
+	wrptr = SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_out_wrptr));
+	while (SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_out_rdptr)) != wrptr);
+		cpu_spinwait();
+
+	/* Clear and acknowledge possibly outstanding interrupts. */
+	SBBC_SRAM_WRITE_4(sbbc_scsolir, 0);
+	uart_barrier(bas);
+	SBBC_REGS_WRITE_4(SBBC_PCI_INT_STATUS,
+	    SBBC_SRAM_READ_4(sbbc_scsolir));
+	uart_barrier(bas);
+	/* Enable PCI interrupts. */
+	SBBC_REGS_WRITE_4(SBBC_PCI_INT_ENABLE, SBBC_PCI_ENABLE_INT_A);
+	uart_barrier(bas);
+	/* Enable input from and output to SC as well as break interrupts. */
+	SBBC_SRAM_WRITE_4(sbbc_scsolie, SBBC_SRAM_READ_4(sbbc_scsolie) |
+	    SBBC_SRAM_CONS_IN | SBBC_SRAM_CONS_BRK |
+	    SBBC_SRAM_CONS_SPACE_OUT);
+	uart_barrier(bas);
+
+	uart_unlock(sc->sc_hwmtx);
+	return (0);
+}
+
+static int
+sbbc_uart_bus_detach(struct uart_softc *sc)
+{
+
+	/* Give back the console input. */
+	sbbc_serengeti_set_console_input(SUNW_SETCONSINPUT_OBP);
+	return (0);
+}
+
+static int
+sbbc_uart_bus_flush(struct uart_softc *sc, int what)
+{
+	struct uart_bas *bas;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+
+	bas = &sc->sc_bas;
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	if ((what & UART_FLUSH_TRANSMITTER) != 0)
+		return (ENODEV);
+	if ((what & UART_FLUSH_RECEIVER) != 0) {
+		SBBC_SRAM_WRITE_4(sbbc_solcons +
+		    SBBC_CONS_OFF(cons_in_rdptr),
+		    SBBC_SRAM_READ_4(sbbc_solcons +
+		    SBBC_CONS_OFF(cons_in_wrptr)));
+		uart_barrier(bas);
+	}
+	return (0);
+}
+
+static int
+sbbc_uart_bus_getsig(struct uart_softc *sc)
+{
+	uint32_t dummy, new, old, sig;
+
+	do {
+		old = sc->sc_hwsig;
+		sig = old;
+		dummy = 0;
+		SIGCHG(dummy, sig, SER_CTS, SER_DCTS);
+		SIGCHG(dummy, sig, SER_DCD, SER_DDCD);
+		SIGCHG(dummy, sig, SER_DSR, SER_DDSR);
+		new = sig & ~SER_MASK_DELTA;
+	} while (!atomic_cmpset_32(&sc->sc_hwsig, old, new));
+	return (sig);
+}
+
+static int
+sbbc_uart_bus_ioctl(struct uart_softc *sc, int request, intptr_t data)
+{
+	int error;
+
+	error = 0;
+	uart_lock(sc->sc_hwmtx);
+	switch (request) {
+	case UART_IOCTL_BAUD:
+		*(int*)data = 9600;	/* arbitrary */
+		break;
+	default:
+		error = EINVAL;
+		break;
+	}
+	uart_unlock(sc->sc_hwmtx);
+	return (error);
+}
+
+static int
+sbbc_uart_bus_ipend(struct uart_softc *sc)
+{
+	struct uart_bas *bas;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	int ipend;
+	uint32_t reason, status;
+
+	bas = &sc->sc_bas;
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	uart_lock(sc->sc_hwmtx);
+	status = SBBC_REGS_READ_4(SBBC_PCI_INT_STATUS);
+	if (status == 0) {
+		uart_unlock(sc->sc_hwmtx);
+		return (0);
+	}
+
+	/*
+	 * Unfortunately, we can't use compare and swap for non-cachable
+	 * memory.
+	 */
+	reason = SBBC_SRAM_READ_4(sbbc_scsolir);
+	SBBC_SRAM_WRITE_4(sbbc_scsolir, 0);
+	uart_barrier(bas);
+	/* Acknowledge the interrupt. */
+	SBBC_REGS_WRITE_4(SBBC_PCI_INT_STATUS, status);
+	uart_barrier(bas);
+
+	uart_unlock(sc->sc_hwmtx);
+
+	ipend = 0;
+	if ((reason & SBBC_SRAM_CONS_IN) != 0)
+		ipend |= SER_INT_RXREADY;
+	if ((reason & SBBC_SRAM_CONS_BRK) != 0)
+		ipend |= SER_INT_BREAK;
+	if ((reason & SBBC_SRAM_CONS_SPACE_OUT) != 0 &&
+	    SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_out_rdptr)) ==
+	    SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_out_wrptr)))
+		ipend |= SER_INT_TXIDLE;
+	return (ipend);
+}
+
+static int
+sbbc_uart_bus_param(struct uart_softc *sc __unused, int baudrate __unused,
+    int databits __unused, int stopbits __unused, int parity __unused)
+{
+
+	return (0);
+}
+
+static int
+sbbc_uart_bus_probe(struct uart_softc *sc __unused)
+{
+
+	if (sbbc_console != 0)
+		return (0);
+	return (ENXIO);
+}
+
+static int
+sbbc_uart_bus_receive(struct uart_softc *sc)
+{
+	struct uart_bas *bas;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	int c;
+	uint32_t end, rdptr, wrptr;
+
+	bas = &sc->sc_bas;
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	uart_lock(sc->sc_hwmtx);
+
+	end = SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_end));
+	rdptr = SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_rdptr));
+	wrptr = SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_wrptr));
+	while (rdptr != wrptr) {
+		if (uart_rx_full(sc) != 0) {
+			sc->sc_rxbuf[sc->sc_rxput] = UART_STAT_OVERRUN;
+			break;
+		}
+		c = SBBC_SRAM_READ_1(sbbc_solcons + rdptr);
+		uart_rx_put(sc, c);
+		if (++rdptr == end)
+			rdptr = SBBC_SRAM_READ_4(sbbc_solcons +
+			    SBBC_CONS_OFF(cons_in_begin));
+	}
+	uart_barrier(bas);
+	SBBC_SRAM_WRITE_4(sbbc_solcons + SBBC_CONS_OFF(cons_in_rdptr),
+	    rdptr);
+	uart_barrier(bas);
+	SBBC_SRAM_WRITE_4(sbbc_solscir, SBBC_SRAM_READ_4(sbbc_solscir) |
+	    SBBC_SRAM_CONS_SPACE_IN);
+	uart_barrier(bas);
+	sbbc_send_intr(bst, bsh);
+
+	uart_unlock(sc->sc_hwmtx);
+	return (0);
+}
+
+static int
+sbbc_uart_bus_setsig(struct uart_softc *sc, int sig)
+{
+	struct uart_bas *bas;
+	uint32_t new, old;
+
+	bas = &sc->sc_bas;
+	do {
+		old = sc->sc_hwsig;
+		new = old;
+		if ((sig & SER_DDTR) != 0) {
+			SIGCHG(sig & SER_DTR, new, SER_DTR, SER_DDTR);
+		}
+		if ((sig & SER_DRTS) != 0) {
+			SIGCHG(sig & SER_RTS, new, SER_RTS, SER_DRTS);
+		}
+	} while (!atomic_cmpset_32(&sc->sc_hwsig, old, new));
+	return (0);
+}
+
+static int
+sbbc_uart_bus_transmit(struct uart_softc *sc)
+{
+	struct uart_bas *bas;
+	bus_space_tag_t bst;
+	bus_space_handle_t bsh;
+	int i;
+	uint32_t end, wrptr;
+
+	bas = &sc->sc_bas;
+	bst = bas->bst;
+	bsh = bas->bsh;
+
+	uart_lock(sc->sc_hwmtx);
+
+	end = SBBC_SRAM_READ_4(sbbc_solcons + SBBC_CONS_OFF(cons_out_end));
+	wrptr = SBBC_SRAM_READ_4(sbbc_solcons +
+	    SBBC_CONS_OFF(cons_out_wrptr));
+	for (i = 0; i < sc->sc_txdatasz; i++) {
+		SBBC_SRAM_WRITE_1(sbbc_solcons + wrptr, sc->sc_txbuf[i]);
+		if (++wrptr == end)
+			wrptr = SBBC_SRAM_READ_4(sbbc_solcons +
+			    SBBC_CONS_OFF(cons_out_begin));
+	}
+	uart_barrier(bas);
+	SBBC_SRAM_WRITE_4(sbbc_solcons + SBBC_CONS_OFF(cons_out_wrptr),
+	    wrptr);
+	uart_barrier(bas);
+	SBBC_SRAM_WRITE_4(sbbc_solscir, SBBC_SRAM_READ_4(sbbc_solscir) |
+	    SBBC_SRAM_CONS_OUT);
+	uart_barrier(bas);
+	sbbc_send_intr(bst, bsh);
+	sc->sc_txbusy = 1;
+
+	uart_unlock(sc->sc_hwmtx);
+	return (0);
+}
diff --git a/sys/sparc64/sparc64/ofw_machdep.c b/sys/sparc64/sparc64/ofw_machdep.c
index 9d522629c788..07f95e20e511 100644
--- a/sys/sparc64/sparc64/ofw_machdep.c
+++ b/sys/sparc64/sparc64/ofw_machdep.c
@@ -186,13 +186,10 @@ OF_decode_addr(phandle_t node, int bank, int *space, bus_addr_t *addr)
 			name[sizeof(name) - 1] = '\0';
 			goto skip;
 		}
-		if (lbus != bus) {
-			if (OF_getprop(bus, "#size-cells", &szc,
-			    sizeof(szc)) == -1)
-				szc = 1;
-			if (szc < 1 || szc > 2)
-				return (ENXIO);
-		}
+		if (OF_getprop(bus, "#size-cells", &szc, sizeof(szc)) == -1)
+			szc = 1;
+		if (szc < 1 || szc > 2)
+			return (ENXIO);
 		nbank /= sizeof(banks[0]) * (addrc + paddrc + szc);
 		bank = 0;
 		for (i = 0; i < nbank; i++) {
@@ -232,9 +229,9 @@ OF_decode_addr(phandle_t node, int bank, int *space, bus_addr_t *addr)
 		}
 		if (i == nbank)
 			return (ENXIO);
+		lbus = bus;
  skip:
 		addrc = paddrc;
-		lbus = bus;
 		bus = pbus;
 	}
 
diff --git a/sys/sparc64/sparc64/trap.c b/sys/sparc64/sparc64/trap.c
index 3df335bcc48d..c0772a188697 100644
--- a/sys/sparc64/sparc64/trap.c
+++ b/sys/sparc64/sparc64/trap.c
@@ -106,6 +106,7 @@ void trap(struct trapframe *tf);
 void syscall(struct trapframe *tf);
 
 static int fetch_syscall_args(struct thread *td, struct syscall_args *sa);
+static int trap_cecc(void);
 static int trap_pfault(struct thread *td, struct trapframe *tf);
 
 extern char copy_fault[];
@@ -240,6 +241,10 @@ int debugger_on_signal = 0;
 SYSCTL_INT(_debug, OID_AUTO, debugger_on_signal, CTLFLAG_RW,
     &debugger_on_signal, 0, "");
 
+u_int corrected_ecc = 0;
+SYSCTL_UINT(_machdep, OID_AUTO, corrected_ecc, CTLFLAG_RD, &corrected_ecc, 0,
+    "corrected ECC errors");
+
 /*
  * SUNW,set-trap-table allows to take over %tba from the PROM, which
  * will turn off interrupts and handle outstanding ones while doing so,
@@ -255,7 +260,8 @@ sun4u_set_traptable(void *tba_addr)
 		cell_t tba_addr;
 	} args = {
 		(cell_t)"SUNW,set-trap-table",
-		2,
+		1,
+		0,
 	};
 
 	args.tba_addr = (cell_t)tba_addr;
@@ -308,10 +314,16 @@ trap(struct trapframe *tf)
 		case T_SPILL:
 			sig = rwindow_save(td);
 			break;
+		case T_CORRECTED_ECC_ERROR:
+			sig = trap_cecc();
+			break;
 		default:
-			if (tf->tf_type < 0 || tf->tf_type >= T_MAX ||
-			    trap_sig[tf->tf_type] == -1)
-				panic("trap: bad trap type");
+			if (tf->tf_type < 0 || tf->tf_type >= T_MAX)
+				panic("trap: bad trap type %#lx (user)",
+				    tf->tf_type);
+			else if (trap_sig[tf->tf_type] == -1)
+				panic("trap: %s (user)",
+				    trap_msg[tf->tf_type]);
 			sig = trap_sig[tf->tf_type];
 			break;
 		}
@@ -400,18 +412,53 @@ trap(struct trapframe *tf)
 			}
 			error = 1;
 			break;
+		case T_CORRECTED_ECC_ERROR:
+			error = trap_cecc();
+			break;
 		default:
 			error = 1;
 			break;
 		}
 
-		if (error != 0)
-			panic("trap: %s", trap_msg[tf->tf_type & ~T_KERNEL]);
+		if (error != 0) {
+			tf->tf_type &= ~T_KERNEL;
+			if (tf->tf_type < 0 || tf->tf_type >= T_MAX)
+				panic("trap: bad trap type %#lx (kernel)",
+				    tf->tf_type);
+			else if (trap_sig[tf->tf_type] == -1)
+				panic("trap: %s (kernel)",
+				    trap_msg[tf->tf_type]);
+		}
 	}
 	CTR1(KTR_TRAP, "trap: td=%p return", td);
 }
 
 static int
+trap_cecc(void)
+{
+	u_long eee;
+
+	/*
+	 * Turn off (non-)correctable error reporting while we're dealing
+	 * with the error.
+	 */
+	eee = ldxa(0, ASI_ESTATE_ERROR_EN_REG);
+	stxa_sync(0, ASI_ESTATE_ERROR_EN_REG, eee & ~(AA_ESTATE_NCEEN |
+	    AA_ESTATE_CEEN));
+	/* Flush the caches in order ensure no corrupt data got installed. */
+	cache_flush();
+	/* Ensure the caches are still turned on (should be). */
+	cache_enable(PCPU_GET(impl));
+	/* Clear the the error from the AFSR. */
+	stxa_sync(0, ASI_AFSR, ldxa(0, ASI_AFSR));
+	corrected_ecc++;
+	printf("corrected ECC error\n");
+	/* Turn (non-)correctable error reporting back on. */
+	stxa_sync(0, ASI_ESTATE_ERROR_EN_REG, eee);
+	return (0);
+}
+
+static int
 trap_pfault(struct thread *td, struct trapframe *tf)
 {
 	struct vmspace *vm;
@@ -664,7 +711,7 @@ syscall(struct trapframe *tf)
 	 */
 	WITNESS_WARN(WARN_PANIC, NULL, "System call %s returning",
 	    (sa.code >= 0 && sa.code < SYS_MAXSYSCALL) ?
-	     syscallnames[sa.code] : "???");
+	    syscallnames[sa.code] : "???");
 	KASSERT(td->td_critnest == 0,
 	    ("System call %s returning in a critical section",
 	    (sa.code >= 0 && sa.code < SYS_MAXSYSCALL) ?
diff --git a/sys/sys/iconv.h b/sys/sys/iconv.h
index 862086343654..7ca84b5a2089 100644
--- a/sys/sys/iconv.h
+++ b/sys/sys/iconv.h
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2000-2001, Boris Popov
+ * Copyright (c) 2000-2001 Boris Popov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/sys/mchain.h b/sys/sys/mchain.h
index 69775ffe2372..4ee32e419dfd 100644
--- a/sys/sys/mchain.h
+++ b/sys/sys/mchain.h
@@ -10,12 +10,6 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    This product includes software developed by Boris Popov.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
diff --git a/sys/sys/pmc.h b/sys/sys/pmc.h
index 02a87143c529..9da2cc8fe7a0 100644
--- a/sys/sys/pmc.h
+++ b/sys/sys/pmc.h
@@ -40,7 +40,7 @@
 
 #define	PMC_MODULE_NAME		"hwpmc"
 #define	PMC_NAME_MAX		16 /* HW counter name size */
-#define	PMC_CLASS_MAX		4  /* max #classes of PMCs per-system */
+#define	PMC_CLASS_MAX		6  /* max #classes of PMCs per-system */
 
 /*
  * Kernel<->userland API version number [MMmmpppp]
@@ -85,6 +85,7 @@
 	__PMC_CPU(INTEL_CORE2EXTREME,	0x89,	"Intel Core2 Extreme")	\
 	__PMC_CPU(INTEL_ATOM,	0x8A,	"Intel Atom") \
 	__PMC_CPU(INTEL_COREI7, 0x8B,   "Intel Core i7") \
+	__PMC_CPU(INTEL_WESTMERE, 0x8C,   "Intel Westmere") \
 	__PMC_CPU(INTEL_XSCALE,	0x100,	"Intel XScale") \
 	__PMC_CPU(MIPS_24K,     0x200,  "MIPS 24K") 
 
@@ -110,6 +111,8 @@ enum pmc_cputype {
 	__PMC_CLASS(P4)		/* Intel Pentium-IV counters */		\
 	__PMC_CLASS(IAF)	/* Intel Core2/Atom, fixed function */	\
 	__PMC_CLASS(IAP)	/* Intel Core...Atom, programmable */   \
+	__PMC_CLASS(UCF)	/* Intel Uncore programmable */		\
+	__PMC_CLASS(UCP)	/* Intel Uncore fixed function */	\
 	__PMC_CLASS(XSCALE)	/* Intel XScale counters */ \
 	__PMC_CLASS(MIPS24K)    /* MIPS 24K */
 
diff --git a/sys/sys/proc.h b/sys/sys/proc.h
index dd9efae05241..fb31cfc13182 100644
--- a/sys/sys/proc.h
+++ b/sys/sys/proc.h
@@ -573,7 +573,7 @@ struct proc {
 #define	P_WAITED	0x01000	/* Someone is waiting for us. */
 #define	P_WEXIT		0x02000	/* Working on exiting. */
 #define	P_EXEC		0x04000	/* Process called exec. */
-#define	P_UNUSED8000	0x08000	/* available. */
+#define	P_WKILLED	0x08000	/* Killed, go to kernel/user boundary ASAP. */
 #define	P_CONTINUED	0x10000	/* Proc has continued from a stopped state. */
 #define	P_STOPPED_SIG	0x20000	/* Stopped due to SIGSTOP/SIGTSTP. */
 #define	P_STOPPED_TRACE	0x40000	/* Stopped because of tracing. */
@@ -592,6 +592,7 @@ struct proc {
 
 #define	P_STOPPED	(P_STOPPED_SIG|P_STOPPED_SINGLE|P_STOPPED_TRACE)
 #define	P_SHOULDSTOP(p)	((p)->p_flag & P_STOPPED)
+#define	P_KILLED(p)	((p)->p_flag & P_WKILLED)
 
 /*
  * These were process status values (p_stat), now they are only used in
diff --git a/sys/sys/vnode.h b/sys/sys/vnode.h
index 4c84ea30ebe2..b5784e4a75a7 100644
--- a/sys/sys/vnode.h
+++ b/sys/sys/vnode.h
@@ -720,6 +720,8 @@ void	vop_symlink_post(void *a, int rc);
 void	vop_unlock_post(void *a, int rc);
 void	vop_unlock_pre(void *a);
 
+void	vop_rename_fail(struct vop_rename_args *ap);
+
 #define	VOP_WRITE_PRE(ap)						\
 	struct vattr va;						\
 	int error, osize, ooffset, noffset;				\
diff --git a/sys/teken/teken.c b/sys/teken/teken.c
index 1435d2fa9b18..91d706f3c328 100644
--- a/sys/teken/teken.c
+++ b/sys/teken/teken.c
@@ -36,7 +36,7 @@
 #else /* !(__FreeBSD__ && _KERNEL) */
 #include <sys/types.h>
 #include <assert.h>
-#include <inttypes.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #define	teken_assert(x)		assert(x)
diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c
index 8aa9f9c53a4c..656c03666c5e 100644
--- a/sys/ufs/ffs/ffs_vfsops.c
+++ b/sys/ufs/ffs/ffs_vfsops.c
@@ -665,7 +665,6 @@ ffs_mountfs(devvp, mp, td)
 	if (mp->mnt_iosize_max > MAXPHYS)
 		mp->mnt_iosize_max = MAXPHYS;
 
-	devvp->v_bufobj.bo_private = cp;
 	devvp->v_bufobj.bo_ops = &ffs_ops;
 
 	fs = NULL;
diff --git a/sys/vm/memguard.c b/sys/vm/memguard.c
index 861ba3d73c1f..a3792d9f8e95 100644
--- a/sys/vm/memguard.c
+++ b/sys/vm/memguard.c
@@ -1,4 +1,4 @@
-/*
+/*-
  * Copyright (c) 2005,
  *     Bosko Milekic <bmilekic@FreeBSD.org>.  All rights reserved.
  *
diff --git a/sys/vm/memguard.h b/sys/vm/memguard.h
index 34d79cf0f3cb..cabcc0aa173c 100644
--- a/sys/vm/memguard.h
+++ b/sys/vm/memguard.h
@@ -1,4 +1,4 @@
-/*
+/*-
  * Copyright (c) 2005,
  *     Bosko Milekic <bmilekic@FreeBSD.org>.  All rights reserved.
  *
diff --git a/sys/vm/vm_contig.c b/sys/vm/vm_contig.c
index 7358cb0cca81..78d7e2808364 100644
--- a/sys/vm/vm_contig.c
+++ b/sys/vm/vm_contig.c
@@ -87,6 +87,8 @@ __FBSDID("$FreeBSD$");
 #include <vm/vm_phys.h>
 #include <vm/vm_extern.h>
 
+static void vm_contig_grow_cache(int tries);
+
 static int
 vm_contig_launder_page(vm_page_t m, vm_page_t *next)
 {
@@ -186,6 +188,99 @@ vm_page_release_contig(vm_page_t m, vm_pindex_t count)
 }
 
 /*
+ * Increase the number of cached pages.
+ */
+static void
+vm_contig_grow_cache(int tries)
+{
+	int actl, actmax, inactl, inactmax;
+
+	vm_page_lock_queues();
+	inactl = 0;
+	inactmax = tries < 1 ? 0 : cnt.v_inactive_count;
+	actl = 0;
+	actmax = tries < 2 ? 0 : cnt.v_active_count;
+again:
+	if (inactl < inactmax && vm_contig_launder(PQ_INACTIVE)) {
+		inactl++;
+		goto again;
+	}
+	if (actl < actmax && vm_contig_launder(PQ_ACTIVE)) {
+		actl++;
+		goto again;
+	}
+	vm_page_unlock_queues();
+}
+
+/*
+ * Allocates a region from the kernel address map and pages within the
+ * specified physical address range to the kernel object, creates a wired
+ * mapping from the region to these pages, and returns the region's starting
+ * virtual address.  The allocated pages are not necessarily physically
+ * contiguous.  If M_ZERO is specified through the given flags, then the pages
+ * are zeroed before they are mapped.
+ */
+vm_offset_t
+kmem_alloc_attr(vm_map_t map, vm_size_t size, int flags, vm_paddr_t low,
+    vm_paddr_t high, vm_memattr_t memattr)
+{
+	vm_object_t object = kernel_object;
+	vm_offset_t addr, i, offset;
+	vm_page_t m;
+	int tries;
+
+	size = round_page(size);
+	vm_map_lock(map);
+	if (vm_map_findspace(map, vm_map_min(map), size, &addr)) {
+		vm_map_unlock(map);
+		return (0);
+	}
+	offset = addr - VM_MIN_KERNEL_ADDRESS;
+	vm_object_reference(object);
+	vm_map_insert(map, object, offset, addr, addr + size, VM_PROT_ALL,
+	    VM_PROT_ALL, 0);
+	VM_OBJECT_LOCK(object);
+	for (i = 0; i < size; i += PAGE_SIZE) {
+		tries = 0;
+retry:
+		m = vm_phys_alloc_contig(1, low, high, PAGE_SIZE, 0);
+		if (m == NULL) {
+			if (tries < ((flags & M_NOWAIT) != 0 ? 1 : 3)) {
+				VM_OBJECT_UNLOCK(object);
+				vm_map_unlock(map);
+				vm_contig_grow_cache(tries);
+				vm_map_lock(map);
+				VM_OBJECT_LOCK(object);
+				goto retry;
+			}
+			while (i != 0) {
+				i -= PAGE_SIZE;
+				m = vm_page_lookup(object, OFF_TO_IDX(offset +
+				    i));
+				vm_page_lock_queues();
+				vm_page_free(m);
+				vm_page_unlock_queues();
+			}
+			VM_OBJECT_UNLOCK(object);
+			vm_map_delete(map, addr, addr + size);
+			vm_map_unlock(map);
+			return (0);
+		}
+		if (memattr != VM_MEMATTR_DEFAULT)
+			pmap_page_set_memattr(m, memattr);
+		vm_page_insert(m, object, OFF_TO_IDX(offset + i));
+		if ((flags & M_ZERO) && (m->flags & PG_ZERO) == 0)
+			pmap_zero_page(m);
+		m->valid = VM_PAGE_BITS_ALL;
+	}
+	VM_OBJECT_UNLOCK(object);
+	vm_map_unlock(map);
+	vm_map_wire(map, addr, addr + size, VM_MAP_WIRE_SYSTEM |
+	    VM_MAP_WIRE_NOHOLES);
+	return (addr);
+}
+
+/*
  *	Allocates a region from the kernel address map, inserts the
  *	given physically contiguous pages into the kernel object,
  *	creates a wired mapping from the region to the pages, and
@@ -253,7 +348,7 @@ kmem_alloc_contig(vm_map_t map, vm_size_t size, int flags, vm_paddr_t low,
 	vm_offset_t ret;
 	vm_page_t pages;
 	unsigned long npgs;
-	int actl, actmax, inactl, inactmax, tries;
+	int tries;
 
 	size = round_page(size);
 	npgs = size >> PAGE_SHIFT;
@@ -262,23 +357,7 @@ retry:
 	pages = vm_phys_alloc_contig(npgs, low, high, alignment, boundary);
 	if (pages == NULL) {
 		if (tries < ((flags & M_NOWAIT) != 0 ? 1 : 3)) {
-			vm_page_lock_queues();
-			inactl = 0;
-			inactmax = tries < 1 ? 0 : cnt.v_inactive_count;
-			actl = 0;
-			actmax = tries < 2 ? 0 : cnt.v_active_count;
-again:
-			if (inactl < inactmax &&
-			    vm_contig_launder(PQ_INACTIVE)) {
-				inactl++;
-				goto again;
-			}
-			if (actl < actmax &&
-			    vm_contig_launder(PQ_ACTIVE)) {
-				actl++;
-				goto again;
-			}
-			vm_page_unlock_queues();
+			vm_contig_grow_cache(tries);
 			tries++;
 			goto retry;
 		}
diff --git a/sys/vm/vm_extern.h b/sys/vm/vm_extern.h
index ad6087eae337..83c468e08015 100644
--- a/sys/vm/vm_extern.h
+++ b/sys/vm/vm_extern.h
@@ -41,6 +41,8 @@ struct vnode;
 
 int kernacc(void *, int, int);
 vm_offset_t kmem_alloc(vm_map_t, vm_size_t);
+vm_offset_t kmem_alloc_attr(vm_map_t map, vm_size_t size, int flags,
+    vm_paddr_t low, vm_paddr_t high, vm_memattr_t memattr);
 vm_offset_t kmem_alloc_contig(vm_map_t map, vm_size_t size, int flags,
     vm_paddr_t low, vm_paddr_t high, unsigned long alignment,
     unsigned long boundary, vm_memattr_t memattr);
@@ -49,7 +51,7 @@ vm_offset_t kmem_alloc_wait(vm_map_t, vm_size_t);
 void kmem_free(vm_map_t, vm_offset_t, vm_size_t);
 void kmem_free_wakeup(vm_map_t, vm_offset_t, vm_size_t);
 void kmem_init(vm_offset_t, vm_offset_t);
-vm_offset_t kmem_malloc(vm_map_t, vm_size_t, boolean_t);
+vm_offset_t kmem_malloc(vm_map_t map, vm_size_t size, int flags);
 vm_map_t kmem_suballoc(vm_map_t, vm_offset_t *, vm_offset_t *, vm_size_t,
     boolean_t);
 void swapout_procs(int);
@@ -82,7 +84,5 @@ struct sf_buf *vm_imgact_map_page(vm_object_t object, vm_ooffset_t offset);
 void vm_imgact_unmap_page(struct sf_buf *sf);
 void vm_thread_dispose(struct thread *td);
 int vm_thread_new(struct thread *td, int pages);
-void vm_thread_swapin(struct thread *td);
-void vm_thread_swapout(struct thread *td);
 #endif				/* _KERNEL */
 #endif				/* !_VM_EXTERN_H_ */
diff --git a/sys/vm/vm_fault.c b/sys/vm/vm_fault.c
index 0a5a4125bef4..f40985678879 100644
--- a/sys/vm/vm_fault.c
+++ b/sys/vm/vm_fault.c
@@ -216,7 +216,7 @@ vm_fault(vm_map_t map, vm_offset_t vaddr, vm_prot_t fault_type,
 	vm_object_t next_object;
 	vm_page_t marray[VM_FAULT_READ];
 	int hardfault;
-	int faultcount, ahead, behind;
+	int faultcount, ahead, behind, alloc_req;
 	struct faultstate fs;
 	struct vnode *vp;
 	int locked, error;
@@ -386,9 +386,14 @@ RetryFault:;
 
 			/*
 			 * Allocate a new page for this object/offset pair.
+			 *
+			 * Unlocked read of the p_flag is harmless. At
+			 * worst, the P_KILLED might be not observed
+			 * there, and allocation can fail, causing
+			 * restart and new reading of the p_flag.
 			 */
 			fs.m = NULL;
-			if (!vm_page_count_severe()) {
+			if (!vm_page_count_severe() || P_KILLED(curproc)) {
 #if VM_NRESERVLEVEL > 0
 				if ((fs.object->flags & OBJ_COLORED) == 0) {
 					fs.object->flags |= OBJ_COLORED;
@@ -396,10 +401,13 @@ RetryFault:;
 					    fs.pindex;
 				}
 #endif
+				alloc_req = P_KILLED(curproc) ?
+				    VM_ALLOC_SYSTEM : VM_ALLOC_NORMAL;
+				if (fs.object->type != OBJT_VNODE &&
+				    fs.object->backing_object == NULL)
+					alloc_req |= VM_ALLOC_ZERO;
 				fs.m = vm_page_alloc(fs.object, fs.pindex,
-				    (fs.object->type == OBJT_VNODE ||
-				     fs.object->backing_object != NULL) ?
-				    VM_ALLOC_NORMAL : VM_ALLOC_ZERO);
+				    alloc_req);
 			}
 			if (fs.m == NULL) {
 				unlock_and_deallocate(&fs);
@@ -424,7 +432,8 @@ readrest:
 			int reqpage = 0;
 			u_char behavior = vm_map_entry_behavior(fs.entry);
 
-			if (behavior == MAP_ENTRY_BEHAV_RANDOM) {
+			if (behavior == MAP_ENTRY_BEHAV_RANDOM ||
+			    P_KILLED(curproc)) {
 				ahead = 0;
 				behind = 0;
 			} else {
diff --git a/sys/vm/vm_glue.c b/sys/vm/vm_glue.c
index 8882565ef831..c080ca04c6cd 100644
--- a/sys/vm/vm_glue.c
+++ b/sys/vm/vm_glue.c
@@ -99,12 +99,6 @@ extern int maxslp;
 /*
  * System initialization
  *
- * Note: proc0 from proc.h
- */
-static void vm_init_limits(void *);
-SYSINIT(vm_limits, SI_SUB_VM_CONF, SI_ORDER_FIRST, vm_init_limits, &proc0);
-
-/*
  * THIS MUST BE THE LAST INITIALIZATION ITEM!!!
  *
  * Note: run scheduling should be divorced from the vm system.
@@ -115,6 +109,8 @@ SYSINIT(scheduler, SI_SUB_RUN_SCHEDULER, SI_ORDER_ANY, scheduler, NULL);
 #ifndef NO_SWAPPING
 static int swapout(struct proc *);
 static void swapclear(struct proc *);
+static void vm_thread_swapin(struct thread *td);
+static void vm_thread_swapout(struct thread *td);
 #endif
 
 /*
@@ -498,10 +494,11 @@ kstack_cache_init(void *nulll)
 MTX_SYSINIT(kstack_cache, &kstack_cache_mtx, "kstkch", MTX_DEF);
 SYSINIT(vm_kstacks, SI_SUB_KTHREAD_INIT, SI_ORDER_ANY, kstack_cache_init, NULL);
 
+#ifndef NO_SWAPPING
 /*
  * Allow a thread's kernel stack to be paged out.
  */
-void
+static void
 vm_thread_swapout(struct thread *td)
 {
 	vm_object_t ksobj;
@@ -528,7 +525,7 @@ vm_thread_swapout(struct thread *td)
 /*
  * Bring the kernel stack for a specified thread back in.
  */
-void
+static void
 vm_thread_swapin(struct thread *td)
 {
 	vm_object_t ksobj;
@@ -539,7 +536,8 @@ vm_thread_swapin(struct thread *td)
 	ksobj = td->td_kstack_obj;
 	VM_OBJECT_LOCK(ksobj);
 	for (i = 0; i < pages; i++) {
-		m = vm_page_grab(ksobj, i, VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
+		m = vm_page_grab(ksobj, i, VM_ALLOC_NORMAL | VM_ALLOC_RETRY |
+		    VM_ALLOC_WIRED);
 		if (m->valid != VM_PAGE_BITS_ALL) {
 			rv = vm_pager_get_pages(ksobj, &m, 1, 0);
 			if (rv != VM_PAGER_OK)
@@ -547,15 +545,13 @@ vm_thread_swapin(struct thread *td)
 			m = vm_page_lookup(ksobj, i);
 		}
 		ma[i] = m;
-		vm_page_lock_queues();
-		vm_page_wire(m);
-		vm_page_unlock_queues();
 		vm_page_wakeup(m);
 	}
 	VM_OBJECT_UNLOCK(ksobj);
 	pmap_qenter(td->td_kstack, ma, pages);
 	cpu_thread_swapin(td);
 }
+#endif /* !NO_SWAPPING */
 
 /*
  * Implement fork's actions on an address space.
@@ -629,38 +625,6 @@ vm_waitproc(p)
 	vmspace_exitfree(p);		/* and clean-out the vmspace */
 }
 
-/*
- * Set default limits for VM system.
- * Called for proc 0, and then inherited by all others.
- *
- * XXX should probably act directly on proc0.
- */
-static void
-vm_init_limits(udata)
-	void *udata;
-{
-	struct proc *p = udata;
-	struct plimit *limp;
-	int rss_limit;
-
-	/*
-	 * Set up the initial limits on process VM. Set the maximum resident
-	 * set size to be half of (reasonably) available memory.  Since this
-	 * is a soft limit, it comes into effect only when the system is out
-	 * of memory - half of main memory helps to favor smaller processes,
-	 * and reduces thrashing of the object cache.
-	 */
-	limp = p->p_limit;
-	limp->pl_rlimit[RLIMIT_STACK].rlim_cur = dflssiz;
-	limp->pl_rlimit[RLIMIT_STACK].rlim_max = maxssiz;
-	limp->pl_rlimit[RLIMIT_DATA].rlim_cur = dfldsiz;
-	limp->pl_rlimit[RLIMIT_DATA].rlim_max = maxdsiz;
-	/* limit the limit to no less than 2MB */
-	rss_limit = max(cnt.v_free_count, 512);
-	limp->pl_rlimit[RLIMIT_RSS].rlim_cur = ptoa(rss_limit);
-	limp->pl_rlimit[RLIMIT_RSS].rlim_max = RLIM_INFINITY;
-}
-
 void
 faultin(p)
 	struct proc *p;
diff --git a/sys/vm/vm_map.c b/sys/vm/vm_map.c
index 3b17a30a4170..fe0c0f513780 100644
--- a/sys/vm/vm_map.c
+++ b/sys/vm/vm_map.c
@@ -126,7 +126,8 @@ static int vmspace_zinit(void *mem, int size, int flags);
 static void vmspace_zfini(void *mem, int size);
 static int vm_map_zinit(void *mem, int ize, int flags);
 static void vm_map_zfini(void *mem, int size);
-static void _vm_map_init(vm_map_t map, vm_offset_t min, vm_offset_t max);
+static void _vm_map_init(vm_map_t map, pmap_t pmap, vm_offset_t min,
+    vm_offset_t max);
 static void vm_map_entry_dispose(vm_map_t map, vm_map_entry_t entry);
 #ifdef INVARIANTS
 static void vm_map_zdtor(void *mem, int size, void *arg);
@@ -281,8 +282,7 @@ vmspace_alloc(min, max)
 		return (NULL);
 	}
 	CTR1(KTR_VM, "vmspace_alloc: %p", vm);
-	_vm_map_init(&vm->vm_map, min, max);
-	vm->vm_map.pmap = vmspace_pmap(vm);		/* XXX */
+	_vm_map_init(&vm->vm_map, vmspace_pmap(vm), min, max);
 	vm->vm_refcnt = 1;
 	vm->vm_shm = NULL;
 	vm->vm_swrss = 0;
@@ -313,6 +313,7 @@ vm_init2(void)
 static inline void
 vmspace_dofree(struct vmspace *vm)
 {
+
 	CTR1(KTR_VM, "vmspace_free: %p", vm);
 
 	/*
@@ -329,12 +330,8 @@ vmspace_dofree(struct vmspace *vm)
 	(void)vm_map_remove(&vm->vm_map, vm->vm_map.min_offset,
 	    vm->vm_map.max_offset);
 
-	/*
-	 * XXX Comment out the pmap_release call for now. The
-	 * vmspace_zone is marked as UMA_ZONE_NOFREE, and bugs cause
-	 * pmap.resident_count to be != 0 on exit sometimes.
-	 */
-/* 	pmap_release(vmspace_pmap(vm)); */
+	pmap_release(vmspace_pmap(vm));
+	vm->vm_map.pmap = NULL;
 	uma_zfree(vmspace_zone, vm);
 }
 
@@ -681,23 +678,22 @@ vm_map_create(pmap_t pmap, vm_offset_t min, vm_offset_t max)
 
 	result = uma_zalloc(mapzone, M_WAITOK);
 	CTR1(KTR_VM, "vm_map_create: %p", result);
-	_vm_map_init(result, min, max);
-	result->pmap = pmap;
+	_vm_map_init(result, pmap, min, max);
 	return (result);
 }
 
 /*
  * Initialize an existing vm_map structure
  * such as that in the vmspace structure.
- * The pmap is set elsewhere.
  */
 static void
-_vm_map_init(vm_map_t map, vm_offset_t min, vm_offset_t max)
+_vm_map_init(vm_map_t map, pmap_t pmap, vm_offset_t min, vm_offset_t max)
 {
 
 	map->header.next = map->header.prev = &map->header;
 	map->needs_wakeup = FALSE;
 	map->system_map = 0;
+	map->pmap = pmap;
 	map->min_offset = min;
 	map->max_offset = max;
 	map->flags = 0;
@@ -707,9 +703,10 @@ _vm_map_init(vm_map_t map, vm_offset_t min, vm_offset_t max)
 }
 
 void
-vm_map_init(vm_map_t map, vm_offset_t min, vm_offset_t max)
+vm_map_init(vm_map_t map, pmap_t pmap, vm_offset_t min, vm_offset_t max)
 {
-	_vm_map_init(map, min, max);
+
+	_vm_map_init(map, pmap, min, max);
 	mtx_init(&map->system_mtx, "system map", NULL, MTX_DEF | MTX_DUPOK);
 	sx_init(&map->lock, "user map");
 }
diff --git a/sys/vm/vm_map.h b/sys/vm/vm_map.h
index 963084555127..5454ce6ed15e 100644
--- a/sys/vm/vm_map.h
+++ b/sys/vm/vm_map.h
@@ -346,7 +346,7 @@ int vm_map_fixed(vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t, vm_size_t,
     vm_prot_t, vm_prot_t, int);
 int vm_map_findspace (vm_map_t, vm_offset_t, vm_size_t, vm_offset_t *);
 int vm_map_inherit (vm_map_t, vm_offset_t, vm_offset_t, vm_inherit_t);
-void vm_map_init (struct vm_map *, vm_offset_t, vm_offset_t);
+void vm_map_init(vm_map_t, pmap_t, vm_offset_t, vm_offset_t);
 int vm_map_insert (vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t, vm_offset_t, vm_prot_t, vm_prot_t, int);
 int vm_map_lookup (vm_map_t *, vm_offset_t, vm_prot_t, vm_map_entry_t *, vm_object_t *,
     vm_pindex_t *, vm_prot_t *, boolean_t *);
diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c
index 665baa9dcf38..7c149c9bc885 100644
--- a/sys/vm/vm_page.c
+++ b/sys/vm/vm_page.c
@@ -1084,6 +1084,7 @@ vm_page_alloc(vm_object_t object, vm_pindex_t pindex, int req)
 			return (NULL);
 #if VM_NRESERVLEVEL > 0
 		} else if (object == NULL || object->type == OBJT_DEVICE ||
+		    object->type == OBJT_SG ||
 		    (object->flags & OBJ_COLORED) == 0 ||
 		    (m = vm_reserv_alloc_page(object, pindex)) == NULL) {
 #else
diff --git a/sys/vm/vm_pageout.c b/sys/vm/vm_pageout.c
index 723b14d2175a..dc2b3b77d569 100644
--- a/sys/vm/vm_pageout.c
+++ b/sys/vm/vm_pageout.c
@@ -1206,10 +1206,10 @@ vm_pageout_oom(int shortage)
 		if (PROC_TRYLOCK(p) == 0)
 			continue;
 		/*
-		 * If this is a system or protected process, skip it.
+		 * If this is a system, protected or killed process, skip it.
 		 */
 		if ((p->p_flag & (P_INEXEC | P_PROTECTED | P_SYSTEM)) ||
-		    (p->p_pid == 1) ||
+		    (p->p_pid == 1) || P_KILLED(p) ||
 		    ((p->p_pid < 48) && (swap_pager_avail != 0))) {
 			PROC_UNLOCK(p);
 			continue;
diff --git a/sys/x86/isa/clock.c b/sys/x86/isa/clock.c
index 4a207090d62b..83026d6c2585 100644
--- a/sys/x86/isa/clock.c
+++ b/sys/x86/isa/clock.c
@@ -97,7 +97,7 @@ TUNABLE_INT("hw.i8254.freq", &i8254_freq);
 int	i8254_max_count;
 static int i8254_real_max_count;
 
-static int lapic_allclocks;
+static int lapic_allclocks = 1;
 TUNABLE_INT("machdep.lapic_allclocks", &lapic_allclocks);
 
 struct mtx clock_lock;