Merge git://git.denx.de/u-boot-x86

diff --git a/.gitignore b/.gitignore
index a40c277105ea65efe81a70c53715099adf6d2548..33abbd3d0783ce75b4b1d111b1ee085bc150e30f 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -48,6 +48,7 @@
 /LOG
 /spl/
 /tpl/
+/defconfig
 
 #
 # Generated include files

diff --git a/Kconfig b/Kconfig
index fc69189217a15d63b701f74cff93e3cd97964aa6..05a34f7301e095a704753c02c983959f6ce3a902 100644 (file)
--- a/Kconfig
+++ b/Kconfig
@@ -179,6 +179,7 @@ config SYS_EXTRA_OPTIONS
 
 config SYS_TEXT_BASE
        depends on SPARC || ARC || X86 || ARCH_UNIPHIER || ARCH_ZYNQMP
+       depends on !EFI_APP
        hex "Text Base"
        help
          TODO: Move CONFIG_SYS_TEXT_BASE for all the architecture

diff --git a/Makefile b/Makefile
index 7ccd614e1c297c0fb4d34aeccfd1173699d4e222..bb0ba9f8a22473e297b77ef8a4ec1ff8b3bc0fff 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -754,6 +754,8 @@ ifneq ($(CONFIG_SPL_TARGET),)
 ALL-$(CONFIG_SPL) += $(CONFIG_SPL_TARGET:"%"=%)
 endif
 ALL-$(CONFIG_REMAKE_ELF) += u-boot.elf
+ALL-$(CONFIG_EFI_APP) += u-boot-app.efi
+ALL-$(CONFIG_EFI_STUB) += u-boot-payload.efi
 
 ifneq ($(BUILD_ROM),)
 ALL-$(CONFIG_X86_RESET_VECTOR) += u-boot.rom
@@ -780,8 +782,17 @@ ifneq ($(CONFIG_SYS_TEXT_BASE),)
 LDFLAGS_u-boot += -Ttext $(CONFIG_SYS_TEXT_BASE)
 endif
 
+# Normally we fill empty space with 0xff
 quiet_cmd_objcopy = OBJCOPY $@
-cmd_objcopy = $(OBJCOPY) $(OBJCOPYFLAGS) $(OBJCOPYFLAGS_$(@F)) $< $@
+cmd_objcopy = $(OBJCOPY) --gap-fill=0xff $(OBJCOPYFLAGS) \
+       $(OBJCOPYFLAGS_$(@F)) $< $@
+
+# Provide a version which does not do this, for use by EFI
+quiet_cmd_zobjcopy = OBJCOPY $@
+cmd_zobjcopy = $(OBJCOPY) $(OBJCOPYFLAGS) $(OBJCOPYFLAGS_$(@F)) $< $@
+
+quiet_cmd_efipayload = OBJCOPY $@
+cmd_efipayload = $(OBJCOPY) -I binary -O $(EFIPAYLOAD_BFDTARGET) -B $(EFIPAYLOAD_BFDARCH) $< $@
 
 quiet_cmd_mkimage = MKIMAGE $@
 cmd_mkimage = $(objtree)/tools/mkimage $(MKIMAGEFLAGS_$(@F)) -d $< $@ \
@@ -1076,6 +1087,30 @@ u-boot-dtb-tegra.bin: u-boot-nodtb-tegra.bin dts/dt.dtb FORCE
 endif
 endif
 
+OBJCOPYFLAGS_u-boot-app.efi := $(OBJCOPYFLAGS_EFI)
+u-boot-app.efi: u-boot FORCE
+       $(call if_changed,zobjcopy)
+
+u-boot-dtb.bin.o: u-boot-dtb.bin FORCE
+       $(call if_changed,efipayload)
+
+u-boot-payload.lds: $(LDSCRIPT_EFI) FORCE
+       $(call if_changed_dep,cpp_lds)
+
+# Rule to link the EFI payload which contains a stub and a U-Boot binary
+quiet_cmd_u-boot_payload ?= LD      $@
+      cmd_u-boot_payload ?= $(LD) $(LDFLAGS_EFI_PAYLOAD) -o $@ \
+      -T u-boot-payload.lds arch/x86/cpu/call32.o \
+      lib/efi/efi.o lib/efi/efi_stub.o u-boot-dtb.bin.o \
+      $(addprefix arch/$(ARCH)/lib/efi/,$(EFISTUB))
+
+u-boot-payload: u-boot-dtb.bin.o u-boot-payload.lds FORCE
+       $(call if_changed,u-boot_payload)
+
+OBJCOPYFLAGS_u-boot-payload.efi := $(OBJCOPYFLAGS_EFI)
+u-boot-payload.efi: u-boot-payload FORCE
+       $(call if_changed,zobjcopy)
+
 u-boot-img.bin: spl/u-boot-spl.bin u-boot.img FORCE
        $(call if_changed,cat)
 

diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index e8968a7182bbcbc0b64722b4667b97fcc7c00ac4..01ed76042f755f03b54e565e7f6bfff68b7b0b15 100644 (file)
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -11,6 +11,9 @@ choice
 config VENDOR_COREBOOT
        bool "coreboot"
 
+config VENDOR_EFI
+       bool "efi"
+
 config VENDOR_EMULATION
        bool "emulation"
 
@@ -24,6 +27,7 @@ endchoice
 
 # board-specific options below
 source "board/coreboot/Kconfig"
+source "board/efi/Kconfig"
 source "board/emulation/Kconfig"
 source "board/google/Kconfig"
 source "board/intel/Kconfig"
@@ -190,6 +194,7 @@ config X86_RAMTEST
 
 config HAVE_FSP
        bool "Add an Firmware Support Package binary"
+       depends on !EFI
        help
          Select this option to add an Firmware Support Package binary to
          the resulting U-Boot image. It is a binary blob which U-Boot uses
@@ -305,6 +310,7 @@ menu "System tables"
 
 config GENERATE_PIRQ_TABLE
        bool "Generate a PIRQ table"
+       depends on !EFI
        default n
        help
          Generate a PIRQ routing table for this board. The PIRQ routing table
@@ -315,6 +321,7 @@ config GENERATE_PIRQ_TABLE
 
 config GENERATE_SFI_TABLE
        bool "Generate a SFI (Simple Firmware Interface) table"
+       depends on !EFI
        help
          The Simple Firmware Interface (SFI) provides a lightweight method
          for platform firmware to pass information to the operating system
@@ -329,6 +336,7 @@ config GENERATE_SFI_TABLE
 
 config GENERATE_MP_TABLE
        bool "Generate an MP (Multi-Processor) table"
+       depends on !EFI
        default n
        help
          Generate an MP (Multi-Processor) table for this board. The MP table
@@ -379,4 +387,6 @@ config PCIE_ECAM_SIZE
          so a default 0x10000000 size covers all of the 256 buses which is the
          maximum number of PCI buses as defined by the PCI specification.
 
+source "arch/x86/lib/efi/Kconfig"
+
 endmenu

diff --git a/arch/x86/Makefile b/arch/x86/Makefile
index 36a601822a204c476be6f129e2c810498763c765..d104a497301dd3e41b828a03beda6178e40fbae8 100644 (file)
--- a/arch/x86/Makefile
+++ b/arch/x86/Makefile
@@ -2,7 +2,9 @@
 # SPDX-License-Identifier:     GPL-2.0+
 #
 
+ifeq ($(CONFIG_EFI_APP),)
 head-y := arch/x86/cpu/start.o
+endif
 ifeq ($(CONFIG_SPL_BUILD),y)
 head-y += arch/x86/cpu/start16.o
 head-y += arch/x86/cpu/resetvec.o

diff --git a/arch/x86/config.mk b/arch/x86/config.mk
index 999143e9df1f635d6a407dbdda775d9c94178d1a..d7addd872866a7e752ae2be4856157fe5bd9242c 100644 (file)
--- a/arch/x86/config.mk
+++ b/arch/x86/config.mk
@@ -8,19 +8,60 @@
 CONFIG_STANDALONE_LOAD_ADDR ?= 0x40000
 
 PLATFORM_CPPFLAGS += -fno-strict-aliasing
-PLATFORM_CPPFLAGS += -mregparm=3
 PLATFORM_CPPFLAGS += -fomit-frame-pointer
 PF_CPPFLAGS_X86   := $(call cc-option, -fno-toplevel-reorder, \
                       $(call cc-option, -fno-unit-at-a-time)) \
                     $(call cc-option, -mpreferred-stack-boundary=2)
+
 PLATFORM_CPPFLAGS += $(PF_CPPFLAGS_X86)
 PLATFORM_CPPFLAGS += -fno-dwarf2-cfi-asm
 PLATFORM_CPPFLAGS += -march=i386 -m32
 
 PLATFORM_RELFLAGS += -ffunction-sections -fvisibility=hidden
 
-PLATFORM_LDFLAGS += --emit-relocs -Bsymbolic -Bsymbolic-functions -m elf_i386
+PLATFORM_LDFLAGS += -Bsymbolic -Bsymbolic-functions -m elf_i386
 
-LDFLAGS_FINAL += --gc-sections -pie
 LDFLAGS_FINAL += --wrap=__divdi3 --wrap=__udivdi3
 LDFLAGS_FINAL += --wrap=__moddi3 --wrap=__umoddi3
+
+# This is used in the top-level Makefile which does not include
+# PLATFORM_LDFLAGS
+LDFLAGS_EFI_PAYLOAD := -Bsymbolic -Bsymbolic-functions -shared --no-undefined
+
+OBJCOPYFLAGS_EFI := -j .text -j .sdata -j .data -j .dynamic -j .dynsym \
+       -j .rel -j .rela -j .reloc
+
+CFLAGS_NON_EFI := -mregparm=3
+CFLAGS_EFI := -fpic -fshort-wchar
+
+ifeq ($(CONFIG_EFI_STUB_64BIT),)
+CFLAGS_EFI += $(call cc-option, -mno-red-zone)
+EFIARCH = ia32
+EFIPAYLOAD_BFDTARGET = elf32-i386
+else
+EFIARCH = x86_64
+EFIPAYLOAD_BFDTARGET = elf64-x86-64
+endif
+
+EFIPAYLOAD_BFDARCH = i386
+
+LDSCRIPT_EFI := $(srctree)/$(CPUDIR)/efi/elf_$(EFIARCH)_efi.lds
+EFISTUB := crt0-efi-$(EFIARCH).o reloc_$(EFIARCH).o
+OBJCOPYFLAGS_EFI += --target=efi-app-$(EFIARCH)
+
+CPPFLAGS_REMOVE_crt0-efi-$(EFIARCH).o += $(CFLAGS_NON_EFI)
+CPPFLAGS_crt0-efi-$(EFIARCH).o += $(CFLAGS_EFI)
+
+ifeq ($(CONFIG_EFI_APP),y)
+
+PLATFORM_CPPFLAGS += $(CFLAGS_EFI)
+LDFLAGS_FINAL += -znocombreloc -shared
+LDSCRIPT := $(LDSCRIPT_EFI)
+
+else
+
+PLATFORM_CPPFLAGS += $(CFLAGS_NON_EFI)
+PLATFORM_LDFLAGS += --emit-relocs
+LDFLAGS_FINAL += --gc-sections -pie
+
+endif

diff --git a/arch/x86/cpu/Makefile b/arch/x86/cpu/Makefile
index 8a8e63e1d3d1c270ec39aa592a9eaac86eb28df9..e7979254dbfad255366d35d68f397ee4538d8e81 100644 (file)
--- a/arch/x86/cpu/Makefile
+++ b/arch/x86/cpu/Makefile
@@ -12,8 +12,15 @@ extra-y      = start.o
 obj-$(CONFIG_X86_RESET_VECTOR) += resetvec.o start16.o
 obj-y  += interrupts.o cpu.o cpu_x86.o call64.o
 
+AFLAGS_REMOVE_call32.o := -mregparm=3 \
+       $(if $(CONFIG_EFI_STUB_64BIT),-march=i386 -m32)
+AFLAGS_call32.o := -fpic -fshort-wchar
+
+extra-y += call32.o
+
 obj-$(CONFIG_INTEL_BAYTRAIL) += baytrail/
 obj-$(CONFIG_SYS_COREBOOT) += coreboot/
+obj-$(CONFIG_EFI_APP) += efi/
 obj-$(CONFIG_QEMU) += qemu/
 obj-$(CONFIG_NORTHBRIDGE_INTEL_SANDYBRIDGE) += ivybridge/
 obj-$(CONFIG_NORTHBRIDGE_INTEL_IVYBRIDGE) += ivybridge/

diff --git a/arch/x86/cpu/baytrail/Kconfig b/arch/x86/cpu/baytrail/Kconfig
index e86cc01115b29597531d31e69ab0478381449edd..407feb214bf864dd3ed51e451e746ce90fdc0579 100644 (file)
--- a/arch/x86/cpu/baytrail/Kconfig
+++ b/arch/x86/cpu/baytrail/Kconfig
@@ -6,4 +6,4 @@
 
 config INTEL_BAYTRAIL
        bool
-       select HAVE_FSP
+       select HAVE_FSP if !EFI

diff --git a/arch/x86/cpu/baytrail/cpu.c b/arch/x86/cpu/baytrail/cpu.c
index a0117308aeb4d2ec3ed88a0f73ad33b464b422b4..b1faf8ca32607e7da0e55df203b8cf954d44ce6b 100644 (file)
--- a/arch/x86/cpu/baytrail/cpu.c
+++ b/arch/x86/cpu/baytrail/cpu.c
@@ -45,6 +45,8 @@ static void set_max_freq(void)
 
 static int cpu_x86_baytrail_probe(struct udevice *dev)
 {
+       if (!ll_boot_init())
+               return 0;
        debug("Init BayTrail core\n");
 
        /*

diff --git a/arch/x86/cpu/baytrail/valleyview.c b/arch/x86/cpu/baytrail/valleyview.c
index 9915da5bd7d0beb73a5822b2243f6ee57243cad8..610e9d9b1d8a4237e02cf5e36b2c04f03d58c8bf 100644 (file)
--- a/arch/x86/cpu/baytrail/valleyview.c
+++ b/arch/x86/cpu/baytrail/valleyview.c
@@ -7,6 +7,7 @@
 #include <common.h>
 #include <mmc.h>
 #include <pci_ids.h>
+#include <asm/irq.h>
 #include <asm/post.h>
 
 static struct pci_device_id mmc_supported[] = {
@@ -20,6 +21,7 @@ int cpu_mmc_init(bd_t *bis)
                            ARRAY_SIZE(mmc_supported));
 }
 
+#ifndef CONFIG_EFI_APP
 int arch_cpu_init(void)
 {
        int ret;
@@ -35,3 +37,11 @@ int arch_cpu_init(void)
 
        return 0;
 }
+
+int arch_misc_init(void)
+{
+       pirq_init();
+
+       return 0;
+}
+#endif

diff --git a/arch/x86/cpu/call32.S b/arch/x86/cpu/call32.S
new file mode 100644 (file)
index 0000000..c517e4a
--- /dev/null
+++ b/arch/x86/cpu/call32.S
@@ -0,0 +1,64 @@
+/*
+ * (C) Copyright 2015 Google, Inc
+ * Written by Simon Glass <sjg@chromium.org>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <asm/global_data.h>
+#include <asm/msr-index.h>
+#include <asm/processor-flags.h>
+
+       /*
+        * rdi - 32-bit code segment selector
+        * rsi - target address
+        * rdx - table address (0 if none)
+        */
+.code64
+.globl cpu_call32
+cpu_call32:
+       cli
+
+       /* Save table pointer */
+       mov     %edx, %ebx
+
+       /*
+        * Debugging option, this outputs characters to the console UART
+        * mov  $0x3f8,%edx
+        * mov  $'a',%al
+        * out  %al,(%dx)
+        */
+
+       pushf
+       push    %rdi    /* 32-bit code segment */
+       lea     compat(%rip), %rax
+       push    %rax
+       .byte   0x48    /* REX prefix to force 64-bit far return */
+       retf
+.code32
+compat:
+       /*
+        * We are now in compatibility mode with a default operand size of
+        * 32 bits. First disable paging.
+        */
+       movl    %cr0, %eax
+       andl    $~X86_CR0_PG, %eax
+       movl    %eax, %cr0
+
+       /* Invalidate TLB */
+       xorl    %eax, %eax
+       movl    %eax, %cr3
+
+       /* Disable Long mode in EFER (Extended Feature Enable Register) */
+       movl    $MSR_EFER, %ecx
+       rdmsr
+       btr     $_EFER_LME, %eax
+       wrmsr
+
+       /* Set up table pointer for _x86boot_start */
+       mov     %ebx, %ecx
+
+       /* Jump to the required target */
+       pushl   %edi    /* 32-bit code segment */
+       pushl   %esi    /* 32-bit target address */
+       retf

diff --git a/arch/x86/cpu/call64.S b/arch/x86/cpu/call64.S
index 74dd5a89dceeb3e55dcb6e7400b154d7b7cf2444..08dc473d6af40e528f574c19f26fae07cb658778 100644 (file)
--- a/arch/x86/cpu/call64.S
+++ b/arch/x86/cpu/call64.S
@@ -82,8 +82,8 @@ lret_target:
 
        .data
 gdt:
-       .word   gdt_end - gdt
-       .long   gdt
+       .word   gdt_end - gdt - 1
+       .long   gdt                     /* Fixed up by code above */
        .word   0
        .quad   0x0000000000000000      /* NULL descriptor */
        .quad   0x00af9a000000ffff      /* __KERNEL_CS */

diff --git a/arch/x86/cpu/cpu.c b/arch/x86/cpu/cpu.c
index b9134cfef3747602ea8cee9cc4964afae8511abd..129777c71755a327a8da460069481aa2ac194580 100644 (file)
--- a/arch/x86/cpu/cpu.c
+++ b/arch/x86/cpu/cpu.c
@@ -330,13 +330,15 @@ int x86_cpu_init_f(void)
        const u32 em_rst = ~X86_CR0_EM;
        const u32 mp_ne_set = X86_CR0_MP | X86_CR0_NE;
 
-       /* initialize FPU, reset EM, set MP and NE */
-       asm ("fninit\n" \
-            "movl %%cr0, %%eax\n" \
-            "andl %0, %%eax\n" \
-            "orl  %1, %%eax\n" \
-            "movl %%eax, %%cr0\n" \
-            : : "i" (em_rst), "i" (mp_ne_set) : "eax");
+       if (ll_boot_init()) {
+               /* initialize FPU, reset EM, set MP and NE */
+               asm ("fninit\n" \
+               "movl %%cr0, %%eax\n" \
+               "andl %0, %%eax\n" \
+               "orl  %1, %%eax\n" \
+               "movl %%eax, %%cr0\n" \
+               : : "i" (em_rst), "i" (mp_ne_set) : "eax");
+       }
 
        /* identify CPU via cpuid and store the decoded info into gd->arch */
        if (has_cpuid()) {
@@ -456,7 +458,7 @@ void x86_full_reset(void)
 
 int dcache_status(void)
 {
-       return !(read_cr0() & 0x40000000);
+       return !(read_cr0() & X86_CR0_CD);
 }
 
 /* Define these functions to allow ehch-hcd to function */
@@ -712,5 +714,8 @@ __weak int x86_init_cpus(void)
 
 int cpu_init_r(void)
 {
-       return x86_init_cpus();
+       if (ll_boot_init())
+               return x86_init_cpus();
+
+       return 0;
 }

diff --git a/arch/x86/cpu/efi/Makefile b/arch/x86/cpu/efi/Makefile
new file mode 100644 (file)
index 0000000..e091637
--- /dev/null
+++ b/arch/x86/cpu/efi/Makefile
@@ -0,0 +1,8 @@
+#
+# Copyright (c) 2015 Google, Inc
+#
+# SPDX-License-Identifier:     GPL-2.0+
+#
+
+obj-y += efi.o
+obj-y += sdram.o

diff --git a/arch/x86/cpu/efi/efi.c b/arch/x86/cpu/efi/efi.c
new file mode 100644 (file)
index 0000000..75ba0d4
--- /dev/null
+++ b/arch/x86/cpu/efi/efi.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <fdtdec.h>
+#include <netdev.h>
+
+int arch_cpu_init(void)
+{
+#ifdef CONFIG_SYS_X86_TSC_TIMER
+       timer_set_base(rdtsc());
+#endif
+
+       return 0;
+}
+
+int board_early_init_f(void)
+{
+       return 0;
+}
+
+int print_cpuinfo(void)
+{
+       return default_print_cpuinfo();
+}
+
+void board_final_cleanup(void)
+{
+}
+
+int misc_init_r(void)
+{
+       return 0;
+}
+
+int arch_misc_init(void)
+{
+       return 0;
+}

diff --git a/arch/x86/cpu/efi/elf_ia32_efi.lds b/arch/x86/cpu/efi/elf_ia32_efi.lds
new file mode 100644 (file)
index 0000000..cd3b0a9
--- /dev/null
+++ b/arch/x86/cpu/efi/elf_ia32_efi.lds
@@ -0,0 +1,94 @@
+/*
+ * U-Boot EFI linker script
+ *
+ * SPDX-License-Identifier:    BSD-2-Clause
+ *
+ * Modified from usr/lib32/elf_ia32_efi.lds in gnu-efi
+ */
+
+#include <config.h>
+
+OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
+OUTPUT_ARCH(i386)
+ENTRY(_start)
+SECTIONS
+{
+       image_base = .;
+       .hash : { *(.hash) }    /* this MUST come first, EFI expects it */
+       . = ALIGN(4096);
+       .text :
+       {
+               *(.text)
+               *(.text.*)
+               *(.gnu.linkonce.t.*)
+       }
+       . = ALIGN(4096);
+       .sdata :
+       {
+               *(.got.plt)
+               *(.got)
+               *(.srodata)
+               *(.sdata)
+               *(.sbss)
+               *(.scommon)
+       }
+       . = ALIGN(4096);
+       .data :
+       {
+               *(.rodata*)
+               *(.data)
+               *(.data1)
+               *(.data.*)
+               *(.sdata)
+               *(.got.plt)
+               *(.got)
+               /*
+                * the EFI loader doesn't seem to like a .bss section, so we
+                * stick it all into .data:
+                */
+               *(.sbss)
+               *(.scommon)
+               *(.dynbss)
+               *(.bss)
+               *(COMMON)
+
+               /* U-Boot lists and device tree */
+               . = ALIGN(8);
+               *(SORT(.u_boot_list*));
+               . = ALIGN(8);
+               *(.dtb*);
+       }
+
+       . = ALIGN(4096);
+       .dynamic  : { *(.dynamic) }
+       . = ALIGN(4096);
+       .rel :
+       {
+               *(.rel.data)
+               *(.rel.data.*)
+               *(.rel.got)
+               *(.rel.stab)
+               *(.data.rel.ro.local)
+               *(.data.rel.local)
+               *(.data.rel.ro)
+               *(.data.rel*)
+               *(.rel.u_boot_list*)
+       }
+       . = ALIGN(4096);
+               .reloc :        /* This is the PECOFF .reloc section! */
+       {
+       *(.reloc)
+       }
+       . = ALIGN(4096);
+       .dynsym   : { *(.dynsym) }
+       . = ALIGN(4096);
+       .dynstr   : { *(.dynstr) }
+       . = ALIGN(4096);
+       /DISCARD/ :
+       {
+               *(.rel.reloc)
+               *(.eh_frame)
+               *(.note.GNU-stack)
+       }
+       .comment 0 : { *(.comment) }
+}

diff --git a/arch/x86/cpu/efi/elf_x86_64_efi.lds b/arch/x86/cpu/efi/elf_x86_64_efi.lds
new file mode 100644 (file)
index 0000000..9d9f057
--- /dev/null
+++ b/arch/x86/cpu/efi/elf_x86_64_efi.lds
@@ -0,0 +1,83 @@
+/*
+ * U-Boot EFI linker script
+ *
+ * SPDX-License-Identifier:    BSD-2-Clause
+ *
+ * Modified from usr/lib32/elf_x86_64_efi.lds in gnu-efi
+ */
+
+#include <config.h>
+
+OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
+OUTPUT_ARCH(i386:x86-64)
+ENTRY(_start)
+SECTIONS
+{
+       image_base = .;
+       .hash : { *(.hash) }    /* this MUST come first, EFI expects it */
+       . = ALIGN(4096);
+       .eh_frame : {
+               *(.eh_frame)
+       }
+
+       . = ALIGN(4096);
+
+       .text : {
+               *(.text)
+               *(.text.*)
+               *(.gnu.linkonce.t.*)
+       }
+
+       . = ALIGN(4096);
+
+       .reloc : {
+               *(.reloc)
+       }
+
+       . = ALIGN(4096);
+
+       .data : {
+               *(.rodata*)
+               *(.got.plt)
+               *(.got)
+               *(.data*)
+               *(.sdata)
+               /* the EFI loader doesn't seem to like a .bss section, so we stick
+                * it all into .data: */
+               *(.sbss)
+               *(.scommon)
+               *(.dynbss)
+               *(.bss)
+               *(COMMON)
+               *(.rel.local)
+
+               /* U-Boot lists and device tree */
+               . = ALIGN(8);
+               *(SORT(.u_boot_list*));
+               . = ALIGN(8);
+               *(.dtb*);
+       }
+
+       . = ALIGN(4096);
+       .dynamic : { *(.dynamic) }
+       . = ALIGN(4096);
+
+       .rela : {
+               *(.rela.data*)
+               *(.rela.got)
+               *(.rela.stab)
+       }
+
+       . = ALIGN(4096);
+       .dynsym : { *(.dynsym) }
+       . = ALIGN(4096);
+       .dynstr : { *(.dynstr) }
+       . = ALIGN(4096);
+       .ignored.reloc : {
+               *(.rela.reloc)
+               *(.eh_frame)
+               *(.note.GNU-stack)
+       }
+
+       .comment 0 : { *(.comment) }
+}

diff --git a/arch/x86/cpu/efi/sdram.c b/arch/x86/cpu/efi/sdram.c
new file mode 100644 (file)
index 0000000..5159944
--- /dev/null
+++ b/arch/x86/cpu/efi/sdram.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <efi.h>
+#include <asm/u-boot-x86.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+ulong board_get_usable_ram_top(ulong total_size)
+{
+       return (ulong)efi_get_ram_base() + gd->ram_size;
+}
+
+int dram_init(void)
+{
+       /* gd->ram_size is set as part of EFI init */
+
+       return 0;
+}
+
+void dram_init_banksize(void)
+{
+       gd->bd->bi_dram[0].start = efi_get_ram_base();
+       gd->bd->bi_dram[0].size = CONFIG_EFI_RAM_SIZE;
+}

diff --git a/arch/x86/cpu/interrupts.c b/arch/x86/cpu/interrupts.c
index 853c82f5a7709105b822309abc2edcd44f6e7635..9217307e4abfa2d2776e2bcacce2bbfeb468bf41 100644 (file)
--- a/arch/x86/cpu/interrupts.c
+++ b/arch/x86/cpu/interrupts.c
@@ -19,6 +19,7 @@
 #include <asm/processor-flags.h>
 #include <linux/compiler.h>
 #include <asm/msr.h>
+#include <asm/processor.h>
 #include <asm/u-boot-x86.h>
 #include <asm/i8259.h>
 
@@ -46,7 +47,7 @@ static char *exceptions[] = {
        "Invalid TSS",
        "Segment Not Present",
        "Stack Segment Fault",
-       "Gerneral Protection",
+       "General Protection",
        "Page Fault",
        "Reserved",
        "x87 FPU Floating-Point Error",
@@ -165,7 +166,6 @@ struct idt_entry {
 struct desc_ptr {
        unsigned short size;
        unsigned long address;
-       unsigned short segment;
 } __packed;
 
 struct idt_entry idt[256] __aligned(16);
@@ -202,14 +202,13 @@ int cpu_init_interrupts(void)
        for (i = 0; i < 256; i++) {
                idt[i].access = 0x8e;
                idt[i].res = 0;
-               idt[i].selector = 0x10;
+               idt[i].selector = X86_GDT_ENTRY_32BIT_CS * X86_GDT_ENTRY_SIZE;
                set_vector(i, irq_entry);
                irq_entry += irq_entry_size;
        }
 
-       idt_ptr.size = 256 * 8;
+       idt_ptr.size = 256 * 8 - 1;
        idt_ptr.address = (unsigned long) idt;
-       idt_ptr.segment = 0x18;
 
        load_idt(&idt_ptr);
 
@@ -243,6 +242,11 @@ int disable_interrupts(void)
 
 int interrupt_init(void)
 {
+       /*
+        * When running as an EFI application we are not in control of
+        * interrupts and should leave them alone.
+        */
+#ifndef CONFIG_EFI_APP
        /* Just in case... */
        disable_interrupts();
 
@@ -254,8 +258,15 @@ int interrupt_init(void)
        /* Initialize core interrupt and exception functionality of CPU */
        cpu_init_interrupts();
 
-       /* It is now safe to enable interrupts */
-       enable_interrupts();
+       /*
+        * It is now safe to enable interrupts.
+        *
+        * TODO(sjg@chromium.org): But we don't handle these correctly when
+        * booted from EFI.
+        */
+       if (ll_boot_init())
+               enable_interrupts();
+#endif
 
        return 0;
 }

diff --git a/arch/x86/cpu/mp_init.c b/arch/x86/cpu/mp_init.c
index e686b28c9ca3bd6a0747861ccb5da4db32753122..3294a50b760cd2ee76802733dd30a4fa1db1d58c 100644 (file)
--- a/arch/x86/cpu/mp_init.c
+++ b/arch/x86/cpu/mp_init.c
@@ -24,6 +24,8 @@
 #include <dm/uclass-internal.h>
 #include <linux/linkage.h>
 
+DECLARE_GLOBAL_DATA_PTR;
+
 /* Total CPUs include BSP */
 static int num_cpus;
 

diff --git a/arch/x86/cpu/qemu/Makefile b/arch/x86/cpu/qemu/Makefile
index be79723a67ba11aa5a2741843fa7de1f7320d881..9a66b166fe1d434fbd1a81caf5a4c468d1521ab0 100644 (file)
--- a/arch/x86/cpu/qemu/Makefile
+++ b/arch/x86/cpu/qemu/Makefile
@@ -4,5 +4,8 @@
 # SPDX-License-Identifier:     GPL-2.0+
 #
 
-obj-y += car.o dram.o qemu.o
+ifndef CONFIG_EFI_STUB
+obj-y += car.o dram.o
+endif
+obj-y += qemu.o
 obj-$(CONFIG_PCI) += pci.o

diff --git a/arch/x86/cpu/qemu/qemu.c b/arch/x86/cpu/qemu/qemu.c
index 930d2b6c9d11f2e6d6be03c9db9d7875560d51a6..64634a9229a428a4114bb3982089955ab1342ae3 100644 (file)
--- a/arch/x86/cpu/qemu/qemu.c
+++ b/arch/x86/cpu/qemu/qemu.c
@@ -25,11 +25,13 @@ int arch_cpu_init(void)
        return 0;
 }
 
+#ifndef CONFIG_EFI_STUB
 int print_cpuinfo(void)
 {
        post_code(POST_CPU_INFO);
        return default_print_cpuinfo();
 }
+#endif
 
 void reset_cpu(ulong addr)
 {

diff --git a/arch/x86/cpu/start.S b/arch/x86/cpu/start.S
index 00e585e19bfccdd4e0465c9575b98d137fc811b4..e5c1733e594b0a4b2be7ae7f0f1849433382aedd 100644 (file)
--- a/arch/x86/cpu/start.S
+++ b/arch/x86/cpu/start.S
@@ -25,11 +25,11 @@
 .globl _x86boot_start
 _x86boot_start:
        /*
-        * This is the fail safe 32-bit bootstrap entry point. The
-        * following code is not executed from a cold-reset (actually, a
-        * lot of it is, but from real-mode after cold reset. It is
-        * repeated here to put the board into a state as close to cold
-        * reset as necessary)
+        * This is the fail-safe 32-bit bootstrap entry point.
+        *
+        * This code is used when booting from another boot loader like
+        * coreboot or EFI. So we repeat some of the same init found in
+        * start16.
         */
        cli
        cld
@@ -41,19 +41,34 @@ _x86boot_start:
        wbinvd
 
        /* Tell 32-bit code it is being entered from an in-RAM copy */
-       movw    $GD_FLG_WARM_BOOT, %bx
+       movl    $GD_FLG_WARM_BOOT, %ebx
+
+       /*
+        * Zero the BIST (Built-In Self Test) value since we don't have it.
+        * It must be 0 or the previous loader would have reported an error.
+        */
+       movl    $0, %ebp
+
        jmp     1f
+
+       /* Add a way for tools to discover the _start entry point */
+       .align  4
+       .long   0x12345678
 _start:
        /*
-        * This is the 32-bit cold-reset entry point. Initialize %bx to 0
-        * in case we're preceeded by some sort of boot stub.
+        * This is the 32-bit cold-reset entry point, coming from start16.
+        * Set %ebx to GD_FLG_COLD_BOOT to indicate this.
         */
-       movw    $GD_FLG_COLD_BOOT, %bx
-1:
+       movl    $GD_FLG_COLD_BOOT, %ebx
+
        /* Save BIST */
        movl    %eax, %ebp
+1:
+
+       /* Save table pointer */
+       movl    %ecx, %esi
 
-       /* Load the segement registes to match the gdt loaded in start16.S */
+       /* Load the segement registers to match the GDT loaded in start16.S */
        movl    $(X86_GDT_ENTRY_32BIT_DS * X86_GDT_ENTRY_SIZE), %eax
        movw    %ax, %fs
        movw    %ax, %ds
@@ -64,7 +79,11 @@ _start:
        /* Clear the interrupt vectors */
        lidt    blank_idt_ptr
 
-       /* Early platform init (setup gpio, etc ) */
+       /*
+        * Critical early platform init - generally not used, we prefer init
+        * to happen later when we have a console, in case something goes
+        * wrong.
+        */
        jmp     early_board_init
 .globl early_board_init_ret
 early_board_init_ret:
@@ -79,7 +98,7 @@ car_init_ret:
         * We now have CONFIG_SYS_CAR_SIZE bytes of Cache-As-RAM (or SRAM,
         * or fully initialised SDRAM - we really don't care which)
         * starting at CONFIG_SYS_CAR_ADDR to be used as a temporary stack
-        * and early malloc area. The MRC requires some space at the top.
+        * and early malloc() area. The MRC requires some space at the top.
         *
         * Stack grows down from top of CAR. We have:
         *
@@ -97,7 +116,7 @@ car_init_ret:
 #endif
 #else
        /*
-        * When we get here after car_init, esp points to a temporary stack
+        * When we get here after car_init(), esp points to a temporary stack
         * and esi holds the HOB list address returned by the FSP.
         */
 #endif
@@ -125,7 +144,13 @@ car_init_ret:
        movl    %esi, (%edx)
 
 skip_hob:
+#else
+       /* Store table pointer */
+       movl    %esp, %edx
+       addl    $GD_TABLE, %edx
+       movl    %esi, (%edx)
 #endif
+
        /* Setup first parameter to setup_gdt, pointer to global_data */
        movl    %esp, %eax
 
@@ -137,17 +162,18 @@ skip_hob:
        movl    %esp, %ecx
 
 #if defined(CONFIG_SYS_MALLOC_F_LEN)
+       /* Set up the pre-relocation malloc pool */
        subl    $CONFIG_SYS_MALLOC_F_LEN, %esp
        movl    %eax, %edx
        addl    $GD_MALLOC_BASE, %edx
        movl    %esp, (%edx)
 #endif
-       /* Store BIST */
+       /* Store BIST into global_data */
        movl    %eax, %edx
        addl    $GD_BIST, %edx
        movl    %ebp, (%edx)
 
-       /* Set second parameter to setup_gdt */
+       /* Set second parameter to setup_gdt() */
        movl    %ecx, %edx
 
        /* Setup global descriptor table so gd->xyz works */
@@ -157,7 +183,7 @@ skip_hob:
        post_code(POST_START_DONE)
        xorl    %eax, %eax
 
-       /* Enter, U-boot! */
+       /* Enter, U-Boot! */
        call    board_init_f
 
        /* indicate (lack of) progress */
@@ -184,13 +210,13 @@ board_init_f_r_trampoline:
        /* Align global data to 16-byte boundary */
        andl    $0xfffffff0, %esp
 
-       /* Setup first parameter to memcpy (and setup_gdt) */
+       /* Setup first parameter to memcpy() and setup_gdt() */
        movl    %esp, %eax
 
-       /* Setup second parameter to memcpy */
+       /* Setup second parameter to memcpy() */
        fs movl 0, %edx
 
-       /* Set third parameter to memcpy */
+       /* Set third parameter to memcpy() */
        movl    $GENERATED_GBL_DATA_SIZE, %ecx
 
        /* Copy global data from CAR to SDRAM stack */
@@ -202,7 +228,7 @@ board_init_f_r_trampoline:
        /* Align global descriptor table to 16-byte boundary */
        andl    $0xfffffff0, %esp
 
-       /* Set second parameter to setup_gdt */
+       /* Set second parameter to setup_gdt() */
        movl    %esp, %edx
 
        /* Setup global descriptor table so gd->xyz works */
@@ -216,7 +242,7 @@ board_init_f_r_trampoline:
 
        call    car_uninit
 1:
-       /* Re-enter U-Boot by calling board_init_f_r */
+       /* Re-enter U-Boot by calling board_init_f_r() */
        call    board_init_f_r
 
 die:
@@ -230,9 +256,10 @@ blank_idt_ptr:
 
        .p2align        2       /* force 4-byte alignment */
 
+       /* Add a multiboot header so U-Boot can be loaded by GRUB2 */
 multiboot_header:
        /* magic */
-       .long   0x1BADB002
+       .long   0x1badb002
        /* flags */
        .long   (1 << 16)
        /* checksum */

diff --git a/arch/x86/dts/Makefile b/arch/x86/dts/Makefile
index f86514ce83930c6e5c77e72f266b8c2f48c0af1b..71595c79fb72de37f1d59cbde36872b7e132f7d0 100644 (file)
--- a/arch/x86/dts/Makefile
+++ b/arch/x86/dts/Makefile
@@ -1,6 +1,8 @@
-dtb-y += chromebook_link.dtb \
+dtb-y += bayleybay.dtb \
+       chromebook_link.dtb \
        chromebox_panther.dtb \
        crownbay.dtb \
+       efi.dtb \
        galileo.dtb \
        minnowmax.dtb \
        qemu-x86_i440fx.dtb \

diff --git a/arch/x86/dts/bayleybay.dts b/arch/x86/dts/bayleybay.dts
new file mode 100644 (file)
index 0000000..9f8fa70
--- /dev/null
+++ b/arch/x86/dts/bayleybay.dts
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2015, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+/dts-v1/;
+
+#include <dt-bindings/gpio/x86-gpio.h>
+#include <dt-bindings/interrupt-router/intel-irq.h>
+
+/include/ "skeleton.dtsi"
+/include/ "serial.dtsi"
+/include/ "rtc.dtsi"
+
+/ {
+       model = "Intel Bayley Bay";
+       compatible = "intel,bayleybay", "intel,baytrail";
+
+       aliases {
+               serial0 = &serial;
+               spi0 = "/spi";
+       };
+
+       config {
+               silent_console = <0>;
+       };
+
+       chosen {
+               stdout-path = "/serial";
+       };
+
+       cpus {
+               #address-cells = <1>;
+               #size-cells = <0>;
+
+               cpu@0 {
+                       device_type = "cpu";
+                       compatible = "intel,baytrail-cpu";
+                       reg = <0>;
+                       intel,apic-id = <0>;
+               };
+
+               cpu@1 {
+                       device_type = "cpu";
+                       compatible = "intel,baytrail-cpu";
+                       reg = <1>;
+                       intel,apic-id = <2>;
+               };
+
+               cpu@2 {
+                       device_type = "cpu";
+                       compatible = "intel,baytrail-cpu";
+                       reg = <2>;
+                       intel,apic-id = <4>;
+               };
+
+               cpu@3 {
+                       device_type = "cpu";
+                       compatible = "intel,baytrail-cpu";
+                       reg = <3>;
+                       intel,apic-id = <6>;
+               };
+       };
+
+       spi {
+               #address-cells = <1>;
+               #size-cells = <0>;
+               compatible = "intel,ich-spi";
+               spi-flash@0 {
+                       reg = <0>;
+                       compatible = "winbond,w25q64dw", "spi-flash";
+                       memory-map = <0xff800000 0x00800000>;
+               };
+       };
+
+       gpioa {
+               compatible = "intel,ich6-gpio";
+               u-boot,dm-pre-reloc;
+               reg = <0 0x20>;
+               bank-name = "A";
+       };
+
+       gpiob {
+               compatible = "intel,ich6-gpio";
+               u-boot,dm-pre-reloc;
+               reg = <0x20 0x20>;
+               bank-name = "B";
+       };
+
+       gpioc {
+               compatible = "intel,ich6-gpio";
+               u-boot,dm-pre-reloc;
+               reg = <0x40 0x20>;
+               bank-name = "C";
+       };
+
+       gpiod {
+               compatible = "intel,ich6-gpio";
+               u-boot,dm-pre-reloc;
+               reg = <0x60 0x20>;
+               bank-name = "D";
+       };
+
+       gpioe {
+               compatible = "intel,ich6-gpio";
+               u-boot,dm-pre-reloc;
+               reg = <0x80 0x20>;
+               bank-name = "E";
+       };
+
+       gpiof {
+               compatible = "intel,ich6-gpio";
+               u-boot,dm-pre-reloc;
+               reg = <0xA0 0x20>;
+               bank-name = "F";
+       };
+
+       pci {
+               compatible = "pci-x86";
+               #address-cells = <3>;
+               #size-cells = <2>;
+               u-boot,dm-pre-reloc;
+               ranges = <0x02000000 0x0 0x80000000 0x80000000 0 0x40000000
+                         0x42000000 0x0 0xc0000000 0xc0000000 0 0x20000000
+                         0x01000000 0x0 0x2000 0x2000 0 0xe000>;
+
+               irq-router@1f,0 {
+                       reg = <0x0000f800 0 0 0 0>;
+                       compatible = "intel,irq-router";
+                       intel,pirq-config = "ibase";
+                       intel,ibase-offset = <0x50>;
+                       intel,pirq-link = <8 8>;
+                       intel,pirq-mask = <0xdee0>;
+                       intel,pirq-routing = <
+                               /* BayTrail PCI devices */
+                               PCI_BDF(0, 2, 0) INTA PIRQA
+                               PCI_BDF(0, 3, 0) INTA PIRQA
+                               PCI_BDF(0, 16, 0) INTA PIRQA
+                               PCI_BDF(0, 17, 0) INTA PIRQA
+                               PCI_BDF(0, 18, 0) INTA PIRQA
+                               PCI_BDF(0, 19, 0) INTA PIRQA
+                               PCI_BDF(0, 20, 0) INTA PIRQA
+                               PCI_BDF(0, 21, 0) INTA PIRQA
+                               PCI_BDF(0, 22, 0) INTA PIRQA
+                               PCI_BDF(0, 23, 0) INTA PIRQA
+                               PCI_BDF(0, 24, 0) INTA PIRQA
+                               PCI_BDF(0, 24, 1) INTC PIRQC
+                               PCI_BDF(0, 24, 2) INTD PIRQD
+                               PCI_BDF(0, 24, 3) INTB PIRQB
+                               PCI_BDF(0, 24, 4) INTA PIRQA
+                               PCI_BDF(0, 24, 5) INTC PIRQC
+                               PCI_BDF(0, 24, 6) INTD PIRQD
+                               PCI_BDF(0, 24, 7) INTB PIRQB
+                               PCI_BDF(0, 26, 0) INTA PIRQA
+                               PCI_BDF(0, 27, 0) INTA PIRQA
+                               PCI_BDF(0, 28, 0) INTA PIRQA
+                               PCI_BDF(0, 28, 1) INTB PIRQB
+                               PCI_BDF(0, 28, 2) INTC PIRQC
+                               PCI_BDF(0, 28, 3) INTD PIRQD
+                               PCI_BDF(0, 29, 0) INTA PIRQA
+                               PCI_BDF(0, 30, 0) INTA PIRQA
+                               PCI_BDF(0, 30, 1) INTD PIRQD
+                               PCI_BDF(0, 30, 2) INTB PIRQB
+                               PCI_BDF(0, 30, 3) INTC PIRQC
+                               PCI_BDF(0, 30, 4) INTD PIRQD
+                               PCI_BDF(0, 30, 5) INTB PIRQB
+                               PCI_BDF(0, 31, 3) INTB PIRQB
+
+                               /* PCIe root ports downstream interrupts */
+                               PCI_BDF(1, 0, 0) INTA PIRQA
+                               PCI_BDF(1, 0, 0) INTB PIRQB
+                               PCI_BDF(1, 0, 0) INTC PIRQC
+                               PCI_BDF(1, 0, 0) INTD PIRQD
+                               PCI_BDF(2, 0, 0) INTA PIRQB
+                               PCI_BDF(2, 0, 0) INTB PIRQC
+                               PCI_BDF(2, 0, 0) INTC PIRQD
+                               PCI_BDF(2, 0, 0) INTD PIRQA
+                               PCI_BDF(3, 0, 0) INTA PIRQC
+                               PCI_BDF(3, 0, 0) INTB PIRQD
+                               PCI_BDF(3, 0, 0) INTC PIRQA
+                               PCI_BDF(3, 0, 0) INTD PIRQB
+                               PCI_BDF(4, 0, 0) INTA PIRQD
+                               PCI_BDF(4, 0, 0) INTB PIRQA
+                               PCI_BDF(4, 0, 0) INTC PIRQB
+                               PCI_BDF(4, 0, 0) INTD PIRQC
+                       >;
+               };
+       };
+
+       microcode {
+               update@0 {
+#include "microcode/m0230671117.dtsi"
+               };
+       };
+
+};

diff --git a/arch/x86/dts/efi.dts b/arch/x86/dts/efi.dts
new file mode 100644 (file)
index 0000000..1f50428
--- /dev/null
+++ b/arch/x86/dts/efi.dts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+/dts-v1/;
+
+/include/ "skeleton.dtsi"
+
+/ {
+       model = "EFI";
+       compatible = "efi,app";
+
+       chosen {
+               stdout-path = &serial;
+       };
+
+       serial: serial {
+               compatible = "efi,uart";
+       };
+};

diff --git a/arch/x86/dts/microcode/m0230671117.dtsi b/arch/x86/dts/microcode/m0230671117.dtsi
new file mode 100644 (file)
index 0000000..439e84a
--- /dev/null
+++ b/arch/x86/dts/microcode/m0230671117.dtsi
@@ -0,0 +1,4244 @@
+/*
+ * ---
+ * This is a device tree fragment. Use #include to add these properties to a
+ * node.
+ *
+ * Date:
+ */
+
+compatible = "intel,microcode";
+intel,header-version = <1>;
+intel,update-revision = <0x117>;
+intel,date-code = <0x4102013>;
+intel,processor-signature = <0x30671>;
+intel,checksum = <0x2abfd907>;
+intel,loader-revision = <1>;
+intel,processor-flags = <0x2>;
+
+/* The first 48-bytes are the public header which repeats the above data */
+data = <
+       0x01000000      0x17010000      0x13201004      0x71060300
+       0x07d9bf2a      0x01000000      0x02000000      0xd0070100
+       0x00080100      0x00000000      0x00000000      0x00000000
+       0x00000000      0xa1000000      0x01000200      0x17010000
+       0x00000000      0x00000000      0x09041320      0x41410000
+       0x01000000      0x71060300      0x00000000      0x00000000
+       0x00000000      0x00000000      0x00000000      0x00000000
+       0x00000000      0xf4410000      0x00000000      0x00000000
+       0x00000000      0x00000000      0x00000000      0x00000000
+       0x66cf0793      0x27bf71f6      0x80b10062      0x8ecb5c66
+       0x158f5c1e      0xea343126      0xc3f7f3a2      0xe4863e94
+       0xdb666815      0x5a17bfc4      0x4fca009d      0x099ae8b3
+       0x198e2c7d      0x7c665bbf      0xc07a1a7a      0x7dbcee26
+       0x867296b2      0xc885b6ce      0xe602baff      0x68544b14
+       0xc928c400      0x3add156d      0x531946f9      0x92a03216
+       0xda352322      0xd967ee1f      0x3c5170a7      0xf6de834e
+       0x5a2ed8b3      0x9fb8f050      0x450de17f      0xfd5ef070
+       0x4954575f      0xa3a071ab      0xb56e2afb      0xe2b48302
+       0x6655a958      0x57c9a438      0x1b2f688a      0x09309bc4
+       0x0be95612      0x529c1633      0xc48515d9      0x29eb78df
+       0x9933409f      0xda58dea9      0x58c805fd      0xbc110f5a
+       0x40780ec0      0x6ad59bb3      0xc7387fb8      0x591c1490
+       0xf9335932      0x32130e0b      0xef4b3c96      0xacd903f2
+       0x5b362539      0xe7f85529      0xcb17c41f      0xe7e440d8
+       0xfaf7e925      0x969b76fb      0x5edab8c7      0xf00012e8
+       0x121c2971      0xe5b18959      0xadfd07c0      0x1f09c9d7
+       0x9781006a      0x39550073      0x6c438b6d      0x436f60bc
+       0x11000000      0xe652e618      0x13c8666a      0x3b61e025
+       0xa07f9120      0x29d9f7bb      0x710dcff6      0x1e3c82e1
+       0x5757a634      0xafdc75ca      0xebd0b2cf      0x61f3ef48
+       0x1bc78714      0x1c5217e5      0x62cde08c      0x4b9de061
+       0x99425c27      0x3b8bbbcb      0xad68d252      0xdf3f7a9b
+       0x4f20f8d4      0x295b2c1b      0xff10528f      0x8cc5052e
+       0xdc9a1a30      0xbc2c6da4      0xc73c4031      0x767f5d70
+       0x7105731c      0xba15b967      0x1cc9d3cf      0x0fc90a14
+       0x5ca6cf86      0x34bbf254      0x9a527776      0x993e4707
+       0x20653854      0xf23908e4      0x28b4c751      0xea9ec331
+       0x296f176f      0x7ae60609      0xd73ae7a9      0xa749cf4a
+       0xe6356939      0x5f10991d      0xf008b336      0x6bea7d12
+       0xcb4c8f5c      0x90066bbc      0x04d56a77      0x05707157
+       0x706cf097      0xd3bf95e4      0x281e9765      0x85aba829
+       0x709f6dda      0xf91c80f1      0x20ae30b0      0xd72b63a9
+       0x9dee5635      0x9a75be10      0xb8e4493e      0x68cf8302
+       0xc9f3dba0      0x7d8d2d34      0x7c1ff523      0x7bb2f6ca
+       0x6e3bcc24      0x06dfd137      0xf8ad42a5      0x5f43fb38
+       0x4f6ef5c2      0x6aaf58fe      0xf31c1d4c      0x6cde5863
+       0x346344a7      0xe8c7a056      0x5a38b9ef      0xf756b3b5
+       0xe82d606a      0x7aad9c2d      0xee1bb194      0x50e748b6
+       0x23989423      0xea008e2a      0xeabe64df      0x80e38649
+       0x72fab067      0x5cbd907e      0xb3b45ecf      0x0915aefb
+       0xf607d22e      0x68eea13b      0xcbe6eb4f      0xe7eed298
+       0xc55ddcb5      0x6c7fd23a      0x6b7dd237      0x93735913
+       0x3f1cd52b      0x45dc23d4      0x650a836e      0x8e4bafbc
+       0x9602cbe4      0x347b18c2      0xb9f8dbc3      0xe792d712
+       0xb435c211      0x71755e7e      0x738f7f0b      0x8697ce7c
+       0x6a3f8360      0xe000a076      0xb8f99495      0x39ebeed8
+       0xa6496a45      0xdb24d8a8      0x3aa866c9      0x7d5b2401
+       0x73be59a9      0x980cc211      0x8478f5a2      0x68d84900
+       0xa96baa87      0x911b2970      0xaf373e15      0x81bc2e71
+       0x7c94ca27      0xc33d4795      0x73ba7ae9      0x29e6e73d
+       0xfadc0054      0x07f98e87      0x162ede5c      0x59c3b6f2
+       0x683337dc      0x87dd64f5      0xf7856bb4      0xb6ce50dd
+       0xa3c86db9      0x6100827b      0x7cc4de14      0x02c3f93e
+       0x2f977a39      0xb043c1c0      0xb113decb      0xe4c554a6
+       0x7082d8ef      0x8ae434f7      0x3a14bc50      0x53aabb43
+       0xdf5ef188      0x1a2dd4d5      0xf5ac5687      0x11e4291b
+       0x62e9883a      0xb3d923cd      0xc12858b1      0x710a5d69
+       0x7d70f45e      0xe18e9faa      0xc1603517      0x3ccdc05d
+       0xc01e5418      0xb9747285      0x76c04eb9      0x2d5db847
+       0xa116adca      0x9ecaf1fe      0x0982d9e2      0xcb0f10de
+       0x077d48ae      0xdbd7e114      0xb28cb0d8      0x0374ac9c
+       0x3021be55      0xfb970aed      0x6e48792b      0x93aef002
+       0x072acf1b      0xae4e8c24      0xd4763e81      0x9e2c57b5
+       0xcdd91a44      0x459025bc      0x60b6fe21      0xb0c5e214
+       0x9fc40de3      0x58540754      0x323b25fd      0x60308baf
+       0xaab5ffbd      0x4c6cea8c      0x56b1d95a      0x723fd96d
+       0x8bd9aac3      0x436c3228      0x7b16f7e3      0xe2d50c54
+       0x61ab1d0d      0x2daf7b32      0xab3f19ae      0x94593302
+       0x6284d706      0x0846c148      0x72a30aad      0xad6091ae
+       0x4ab48110      0x41946288      0xb5fbfc87      0x810e9d10
+       0x14d59f71      0x780a9242      0x13606651      0x7e3a608a
+       0x7e66968b      0x1a273e42      0x37088eaf      0x06cf0ae3
+       0x474abea0      0xc3687382      0x4e9d0fc1      0xd9a60259
+       0x2799a0ca      0x7564ef87      0xeff4705a      0xa4f54561
+       0x33f80a5d      0xb5a49d64      0x53e38a7e      0x46b69062
+       0xf522bb74      0x9e3ae357      0xf589864e      0x2df83ddd
+       0x0b53fa6d      0xafe7755f      0xd0a66571      0x630ac3d3
+       0x3e6317f6      0x69520a4e      0x117869ef      0x3d2881a1
+       0xfb05a373      0xcf3d6bf3      0x2d616ed8      0x597ed224
+       0x458f5db4      0x4e6833d2      0x7e673934      0x37cc067d
+       0x3cd649a5      0x256fa294      0x4d4f9f5f      0xa35b0be5
+       0x881edd0e      0x34d280e7      0xb38a8892      0xb1c34db4
+       0x67742084      0x1cae3bc9      0xf7a84084      0xb5a54833
+       0x9e2c029b      0x5821a0d8      0x70703e03      0x149e48d4
+       0x338c1f36      0x21150844      0xe2ad4015      0x39b91fc9
+       0xb4399f34      0x88785b31      0x9ff09389      0x79219aa7
+       0xfbebe952      0x37784809      0xf2094ff7      0x4c06fb61
+       0x56692d3d      0x31679fe2      0xe468128f      0xb24053bf
+       0x358eb887      0x98f817ad      0x7ae65ea3      0x438704d2
+       0x43f6aa4e      0x2d6fb5aa      0x49b4be2d      0x40049dd0
+       0x4a885d24      0xad691ae4      0xf5710f4b      0x1dc64b4a
+       0x4d58c8bb      0x945d1a94      0x9d84c7a9      0x5f34b750
+       0x75ebd027      0x0a0d4bc4      0x8fd759d9      0x183c19fe
+       0xfb8c0f9f      0x9c09e8b8      0xbb894ea2      0xa427ab65
+       0x2b60731b      0x7c6c1d0c      0x9d0cc436      0x33958a85
+       0xa4f0912a      0xe89a1b95      0xbede6929      0xad6d2767
+       0xf3360a63      0xb8f5716d      0x49a83c0c      0x14445574
+       0xd6d2365e      0x822d1054      0x6807d024      0xf3a7686a
+       0xdcd4d639      0x7ffb42cd      0x830feb26      0xc9d9fcb7
+       0x2809d826      0xc35b54be      0x65750da3      0x1bbf50db
+       0x85439000      0x7f0210f6      0x04b89093      0xab9aa7b5
+       0xe9cac3ec      0xb8b2d7e4      0x8f3d7304      0xe512c15f
+       0x99107240      0xa375c1f0      0x0d39872c      0x509cd526
+       0xdc31838e      0xba2630a2      0x321e7ed6      0xc27d21a0
+       0x664f47c4      0x63412208      0x459f700c      0x0c821488
+       0x95c5cc79      0xadef7930      0xdcb0e9df      0x7bb93d5d
+       0xaacc4c9f      0x7f70a483      0xc3be5f51      0x12d03dc0
+       0x9921275a      0x5588e3f4      0x3030083d      0x5cd232c5
+       0xe8b894ae      0x0ea03f14      0xca590d11      0x468b56b5
+       0xd7e9da8a      0x438b7469      0x52ecb778      0xb781f082
+       0x90fb85ca      0x570c48dc      0xba24873a      0x51c56aae
+       0x2b42f540      0x6cc3b56d      0x8dedefbb      0x85539ef8
+       0x7ab2b791      0xd05a8cc4      0xef7ba4e8      0xabe26755
+       0x14f3c623      0xd39241bd      0xa9940c2e      0xbacc97de
+       0x3c992d87      0xb31dc186      0x1ce4c029      0xfdbf027b
+       0x22602f9f      0x61e938d6      0xf4a0f3d3      0x280ae5d9
+       0x0d6bab9b      0x2ac13169      0xa9cf8ae1      0xca00f69a
+       0x45b6130f      0x259dd978      0x12172dc2      0xf90507cf
+       0x77fa35fd      0xf9b57468      0x888bc279      0x10078d47
+       0xba2317de      0xa2530e84      0x6e80b12b      0xe2af6974
+       0xbd1e3e46      0x9e50508d      0x96e44714      0x7626af33
+       0x29a3fc4a      0x13b34442      0xc8688695      0x38e169b0
+       0x0eb22a2e      0x9f2b9425      0x60a392a5      0x0174bbbb
+       0x352af493      0xd92a4015      0x19426fde      0x4b452c1c
+       0x9cce485c      0xa0b0ebc1      0x32466629      0x28108bff
+       0xcada5023      0x4587441c      0x4e846728      0xb4c6b41f
+       0x762f4e28      0x71706b0c      0xf5e81b67      0xd30a921d
+       0x067d78bc      0x23031ebd      0x23af3eba      0x13e72830
+       0x7958554c      0x4bcb1485      0x72eeba39      0xb68d363d
+       0x31abb9ca      0x88822de8      0x6485de80      0x0b783d37
+       0x4fc11610      0xda1c34b0      0xa137c6cd      0x8ad14539
+       0xc0f99d2d      0x90552329      0x3c5df379      0xf55715c8
+       0x5ed64f60      0xdd4f037b      0x994576ae      0x426ad08f
+       0x9ba62c94      0x48a211ce      0xb4b617cd      0xa0b5668f
+       0x5f6dbcb6      0x9f3837f0      0xfe0da3dc      0xac4c13cf
+       0x021a4f62      0xa32894b6      0x0cd733cb      0x2f5a71fd
+       0xf4f414a1      0x7f086e01      0x73b64a6f      0x5641dd58
+       0xfc2ad18d      0xe1559400      0xa0890b3d      0x3ec1b9a8
+       0x22584743      0xfdfef8be      0xa562f2e4      0x2a0ae0be
+       0xe1e7d1a8      0x70405887      0xeb3f7d96      0x0db4f98c
+       0x8af5e404      0x5a49a00e      0xc445daac      0x1d7f8237
+       0xf33aabd8      0x06d59d71      0xd4f46eb8      0x274f1159
+       0x96ccfe62      0x479327fe      0x34171f9b      0x7011e473
+       0xe91a424c      0x59863dec      0x531630a2      0x66d41540
+       0x00282275      0xe021fcf1      0xe8569d4a      0xf962b220
+       0xa930ccd5      0x105d8a31      0xfdd49522      0xcc54b78e
+       0x75fb603b      0x47d82622      0xb73f5554      0x0f365710
+       0x6faf2167      0xbd8b2255      0xff882d76      0xac073c24
+       0xce8ed585      0x62b07311      0x32e22ede      0x406f0ed5
+       0x867b5c91      0x8cf2f4d6      0x6a296fe6      0xb12dc4a1
+       0xe1f21d4a      0xefa44a54      0x7fba27b2      0x357d8e6b
+       0x3fc3a445      0x3864a1eb      0xe9b4560a      0x541125bb
+       0xfeff3745      0x4ffa5713      0xb53fa0b9      0xcaa2e9c4
+       0x39e38368      0x934a011e      0xba91bde3      0xea0834d2
+       0xc73b8c21      0xedb06e01      0x3527f015      0x51fcdbfc
+       0xfed02233      0x3fedc737      0x7f658fa0      0xf22f888c
+       0x38a7bae8      0x492ba8ff      0x21726f4f      0x32d82b9a
+       0x2c43ac2a      0x96b38b0a      0x447c18f2      0x4580c115
+       0xc9e3738a      0x1f0b740c      0x2b8e9799      0xf6e3847f
+       0xd6de65ae      0x3f282155      0x9554e2ad      0x88cedcf5
+       0x919ad323      0xa0387e81      0x1876aba6      0xd34dc487
+       0xc96363eb      0xfc8438c0      0x52051c80      0xc559d5ea
+       0x5783994d      0xf8b66607      0xa7c58856      0xb38ec05c
+       0x37d316d2      0xee4063ea      0xea1ec2e0      0x29d0ea35
+       0xb05a8230      0xd6381c0e      0xa169aa17      0x4e2b4337
+       0xac01a4ee      0x83bd13a4      0x20df3adf      0xb31c4a7c
+       0xa6922b01      0x3378eeec      0x98a06786      0xb99831d1
+       0xba2f4883      0x7028ba22      0xaecf94a3      0x462ea2c7
+       0x2dbf7eba      0x86ff73bd      0x02b16159      0xe7345819
+       0xfba7a4f8      0x2207cee4      0x19dbe11d      0xc38faa86
+       0x6031b894      0x0b04305a      0xf9959e75      0x91d8c49c
+       0x2cf356ae      0x03d4b9b3      0x7fc0c8bc      0x55693f51
+       0xd5631d75      0x91bcb2dd      0x073cc5bd      0x61af589a
+       0x0277bb9d      0x2f7788ea      0x2526e064      0xcb1e0707
+       0x109da720      0xece097fb      0xa025b94a      0x28a0bb82
+       0xe73d9730      0x0721cab9      0x56c37076      0x4a52ad04
+       0xfdeee063      0xe6e577cf      0xb56686e3      0xe47ad6a7
+       0xdde8c808      0xa63bd912      0x06326ee2      0xb138e8d6
+       0x523ca082      0x9a64ddc2      0x759f294a      0xe6bcfe71
+       0xfabb2f52      0x87402972      0x1f003178      0x8e98c126
+       0x17d2d6af      0x7ace1f6d      0x867b4424      0x228cd3a5
+       0x3f1dfa48      0x659738cf      0x05732be4      0x13e218d1
+       0xd9813aca      0x194b553b      0x07771d59      0xa8aa8ecd
+       0xf79c64f8      0x4bd9a556      0x73add168      0xb6ce7173
+       0x863a8689      0x06e2ca6a      0x1b6e57c1      0xaf4ec81d
+       0xe7da76a6      0xcbba80a4      0x3b1509ab      0x8197bcd1
+       0x9f8501fe      0x5506a2fb      0xe82131a0      0x1225c4c5
+       0x008bf36c      0x1a9e8cd9      0x4c2c10d8      0x0d86c5a4
+       0x18f2ad63      0xcadf4f3a      0xd9498033      0x9dcd6824
+       0xa777af9d      0xe503b0b2      0xf22872da      0xd0a467b4
+       0x4a6fc769      0xac1c2d39      0x723f65d1      0x72364f17
+       0x88a8f8f2      0xb597b6b9      0x9d1e4b11      0xcfa45135
+       0x28d1fd2e      0x60b749bf      0x9ac993a7      0x7c64502d
+       0x2f70824a      0x2f8604f0      0x1c842aeb      0x41cdcc9b
+       0x02797a5d      0x910db85f      0x2822c411      0xace6305e
+       0x894bffd6      0x2bb32510      0xf1833540      0x10338438
+       0x4e8ba28d      0x78166fba      0x75f36213      0x8862bde0
+       0x09aba673      0xd1b22481      0x759681fb      0x57b46836
+       0x4a0870ca      0x07f36df4      0xbb31007f      0xc587df38
+       0x235ea743      0x4c1327ec      0x053d1562      0x5ba5c8c6
+       0x9f8e5e54      0xd1bb23cb      0x0696c576      0xac010be8
+       0x04fd424e      0x307c66b9      0xdcb2d738      0x036e7628
+       0x2d809655      0x920ece11      0x6858924a      0x526637a5
+       0x50be416f      0x9b3765a1      0x3f1bb33b      0x0f28f276
+       0x5e4f041b      0x7e1c4d64      0xf131ed7e      0x8ab7010f
+       0x58f17380      0x1f77f07e      0xc2a2d84f      0x969d4d93
+       0x608d45fb      0xf22cc923      0xf06059da      0x0a14d768
+       0xedabc967      0x370491a5      0xe38ddbb7      0x8b843097
+       0x962a53a6      0x650fb320      0x7ae3202d      0xa65f7fc1
+       0xc0d6063b      0xead552e7      0x581c7779      0x761a1de3
+       0x1d8f182e      0xa0cf6625      0xbb31dd3a      0x2a44f0c5
+       0xcd023c91      0x142830f3      0x8a0013dd      0x137a6ef0
+       0x1d7821c2      0x5d0ec9d1      0xae0e696c      0xe81ae73a
+       0x61cc25bd      0x6f8da945      0xfdd781c6      0xbac221f9
+       0xf4adcae7      0x5b690896      0xb1dfb0a2      0xd703f470
+       0x06acc776      0xe61a8081      0xcd0767a1      0x44329159
+       0xa28d4585      0xb35d4be0      0xdfc41ddb      0x5356a17b
+       0x4890436d      0xf68aa276      0x035c9f88      0xed8bd5f6
+       0xe28cec4f      0xaebc059c      0x8773a24d      0xf52a846f
+       0xcb823cec      0x47a13771      0x65714805      0x18310d29
+       0x7863c5c8      0xefc4a69f      0xf17c7a5e      0x5dae6c37
+       0x8bc2a8b9      0xa9688adc      0xf82fde9a      0xbcc23399
+       0xf60bffd5      0x97d05a15      0x9330adda      0xdcce3c43
+       0x758873e6      0xf4a11ba2      0x98ffd4dd      0x97704883
+       0xf678f9fe      0xc3562535      0x124dd194      0x08cacce1
+       0x23a38be9      0xd8fd7289      0x503f43e6      0x75e7f684
+       0x35568dbe      0xf15b72eb      0x40104ed5      0x68ba0dd0
+       0x71d64cf1      0xe32e89bd      0x81367bd2      0xfec7ee32
+       0x6aacfc72      0xfb654ae9      0x5a087751      0xf841c50b
+       0xc795749e      0x5d87a119      0x56de9a64      0x86142c59
+       0xbd922667      0xe7e166d3      0x182f47ce      0xd5524fa8
+       0xa2e915b2      0x2e574c42      0xa7d216bf      0xac6c3f23
+       0xaf0681aa      0xf7bfba75      0xafe7101a      0xafee8752
+       0x4a54798f      0x9b51e7d9      0x6eaa8100      0x08f74200
+       0xcb52d45c      0x3bec0463      0xa412bf2e      0xa20f0676
+       0x00e78e9e      0xa52a1388      0xbe851a2c      0xc2784556
+       0x9c0cd599      0xff3dd303      0x1d43945a      0xc950ee43
+       0xe43f73cb      0x33c53566      0x9fe8057c      0x65d0bf5d
+       0xf45c1b1e      0x34a5e2fc      0x74f43505      0xe4aa361f
+       0xf325d00d      0xde8b3033      0xc1c99dcf      0x3e7653b2
+       0xd01726e5      0x2d7b37af      0x42824709      0xb6afe8b4
+       0x359293d5      0x7541120b      0x2a4ac72a      0x2aaa165f
+       0xfbfd3be2      0x014b0438      0xb736ae49      0xf0a608a9
+       0x30ed8f6a      0x8eb5364c      0xb5ab9ff2      0x3fb519a9
+       0xa94eba6d      0x759cc294      0x97293a63      0x8b5fd2f8
+       0x9fba3768      0x16936eb4      0xa48a8b95      0x35ad65ea
+       0x01a22520      0xa5222930      0xf9843cf0      0x5cac7ca3
+       0x0b56ded8      0x77b6003a      0xe2053349      0x7702785c
+       0x64c4387f      0xe79fd3a8      0xc0fd10a3      0x6937dadd
+       0x9bba0eb8      0x79c0f36f      0x5932a24e      0x882957a6
+       0xc8476f1d      0xa6596c6a      0x7c0a4905      0x3e9ee62e
+       0x1b1977e3      0xf1c97ffd      0xb3f04625      0x9a989e27
+       0x6b4e4799      0x268f72f8      0x2a4c5ea6      0xc4becafe
+       0xbb4fb7ab      0x12201ff5      0x234d8199      0xe9d0bcb0
+       0x3ebafcd5      0xc08e33a0      0x8928e265      0xdb9bb763
+       0x89ace538      0x39becf19      0xa7528896      0x4a8fca8c
+       0x6da81c66      0xcf7c3354      0x37d294e5      0xaaa0e0c4
+       0x3dac5d70      0x749408fe      0x56033ede      0xa9a30a3b
+       0x27afddec      0xd8dd2a24      0x02b11dc8      0xe17aa9d4
+       0xb6868ac8      0x9670065b      0x425ba6de      0xc7b9f545
+       0x12476d1b      0x9195512f      0x7ddca2d0      0x23910434
+       0x8d5be871      0x125a6111      0xf7ab2682      0x25fdda96
+       0x3bd707e1      0xee88eda5      0x969825f2      0xf31f724a
+       0x5c08c1b5      0xa206d305      0x75d44dc5      0xeaade37b
+       0x033aa02a      0x0592b199      0x35640d70      0x1b3266e7
+       0x240dfd55      0xef240d05      0x2c7cece0      0x2d7dc1a4
+       0x8d901727      0x5a6aacbd      0x15d1ea44      0x3d685bc7
+       0xd470dba6      0x967ce301      0xf1dfd7f5      0x1ef28d9c
+       0xa572fc7b      0xa9c2b1fe      0x176b5c3e      0x56a814ab
+       0x1121b7d2      0xf2326765      0xfc10c112      0xf793c504
+       0xab2de3f5      0x571a8725      0x9d8c1693      0xae79b4d0
+       0x6f69f778      0x1bddfa55      0x7986fcfb      0xb3dad9d1
+       0xe0fb60ea      0x4884754a      0xb4a34841      0x22c4facd
+       0xcab8d257      0x9822d49c      0x477f0550      0xafe462e1
+       0xa86b88c9      0x2bc251db      0x36874ecc      0xbed1c885
+       0xf4520fcb      0x2b320dfc      0x21a4fb26      0xa936dbb3
+       0xe015826a      0x13c64833      0xc5836b75      0xfd26f878
+       0x08da825f      0xcaa207f4      0xa7aaa1e8      0x20c47e48
+       0x0ddae3c5      0xe993f07d      0x435b518e      0x0ddf826e
+       0xac682880      0xf1ee6d2f      0x9601302e      0x49abfce4
+       0xf5a558fb      0x64d6e5b6      0x88df9f73      0x442b3ffb
+       0x8c45fc76      0x75473246      0x0e6d0fc2      0xe22886f1
+       0xe73902f6      0x5fa82139      0x6f7ed1f8      0xad59d050
+       0xa53f9328      0x19973446      0xb8091f49      0x91d62fcf
+       0xbf738b2c      0x8bbf1743      0xb88d3706      0xed17b558
+       0x78551363      0x1a6662bb      0xf9d5bb28      0x282eb827
+       0x2f5e9101      0xe2cc8aac      0x593e6f13      0x1c5726cc
+       0x3d8023f8      0x823df211      0x27736cb5      0x948a0c9d
+       0x35d6a2dc      0x488d6dd3      0x076d21c8      0xacc56c82
+       0x01e80a4d      0x6d62482b      0x12bd8602      0xf677aa0f
+       0x923995f2      0xe9814bc6      0x74f43e5d      0xb08e10e1
+       0xb4769404      0xfd9721ad      0x528e13cf      0x1ee6bbef
+       0x30ea2d8e      0x83d4b1cf      0xb05989ea      0x2a99da6d
+       0xf57febfb      0xc464ad28      0x10dc96a8      0x8f0040ea
+       0x60cb7260      0xcc7193a3      0x5b443847      0x58234992
+       0xbb5f6fb9      0x01a15df8      0xb12b0a57      0x61760cdc
+       0xb9becefa      0xb3941413      0x7b732ce7      0x95aa40b8
+       0xf7588d7c      0x598057c1      0x33d1a8fb      0xae68346a
+       0x9fa48686      0xe106cac4      0xcd558fd6      0xce52b92f
+       0x8910d4ae      0xc962a8f1      0x60c31134      0x3f4eb2f9
+       0x966860af      0xa894760c      0x73664ee0      0x00984dec
+       0xdc6ed525      0x122ca0ac      0x6fb30822      0x519a3eff
+       0x03d20627      0xac9fc6b8      0xa7211c07      0x9f5cbe5e
+       0x17118661      0xa94609ed      0x2b6d3ddf      0x9cf5fe8c
+       0x02b0de88      0x60788bf3      0x3f95f306      0x901f7ea6
+       0x4d54aa36      0xaf157451      0x15764441      0x72d31ba1
+       0xe3eec03f      0x897f687f      0x95de5128      0xec10d879
+       0xf8d6b32e      0x0aaec2f1      0xe9fd7d35      0x5e7fc4d0
+       0x8ea54dc6      0xed12a0ba      0x659774d1      0x2e343624
+       0x374708e3      0xa4239f38      0x02929b28      0x7632f3e8
+       0x8d9faa2b      0x76716685      0x3a0c47f6      0xd4dd397a
+       0xaa0d758f      0x75a92d46      0xb934311f      0x8a9e4d93
+       0x0591ede6      0x30505b0d      0xc6db377a      0x34221c8b
+       0x20bf4176      0x6f95c1b4      0xbd391053      0xac6a43a0
+       0xf40c822f      0xeb1c36db      0x552c02cf      0xaca67c89
+       0xd699bab6      0x922c4f95      0x7287e674      0xe113df00
+       0x38799f89      0xe4415aac      0x52832c9a      0xd005b9cd
+       0xc91ab86a      0x14892928      0x5a442a8c      0x009574fc
+       0x89253c9b      0xab0bfa39      0x1e53f048      0x2c858191
+       0xe529b997      0xd3c35ac1      0xa452891a      0xe59c506a
+       0xd6840d6e      0x6b223b42      0xc9e2122a      0x648aad58
+       0x985cb8bc      0xa4f3f264      0x6ae8ea23      0x05b3d719
+       0x95c7f064      0x0f2a9634      0xce67532d      0x6bca9c32
+       0xf5e12a38      0xa64145ff      0x8cb8974f      0x94af4ce6
+       0xfd628608      0x74137512      0xee2c89fe      0xf0d48f8f
+       0x7f991b3a      0x10c08cac      0xf3773a30      0xdb6f0610
+       0x0c52f45a      0x99f7f347      0x773e6181      0xa4cb4211
+       0xfb181021      0x2a47234a      0xfb06fe84      0x3b563e70
+       0x35ac92f4      0xcbc0c29b      0x59a690bc      0x6c364180
+       0xda3c3970      0xc400e75a      0xa6cd253c      0x06daca2c
+       0xae65c73a      0xebeb7155      0xfcdb0e89      0x943e925d
+       0x94310e78      0x412a543f      0xf7c06297      0xceeaf334
+       0x61adaa47      0x0428b995      0x78557c57      0xcce66458
+       0x5a1ab7df      0x3a0a418f      0xff78fe6c      0x8d22e7d6
+       0x27b13fb4      0xbba60e34      0x7a875f83      0xe080c8d3
+       0x18f4b641      0x193d0419      0x16091918      0x3ea17793
+       0xbb66953b      0x03141f8a      0x139fb30c      0x81d8fd2e
+       0x9bfdf330      0x9b7b3f17      0xb1bfa1d7      0xe0ab44d7
+       0x597b1deb      0x13601dfc      0x7b6cbf0a      0xef48305d
+       0x2324dc5c      0xad9aeccb      0x3d67204a      0x2150955d
+       0xcac1bbbf      0xd2c0a837      0xf5e3b7d8      0xae1f4637
+       0x1dc80559      0xa1682043      0x9ea66fd2      0xfdb77819
+       0x776a68b6      0x70949ee2      0x74cad033      0xb73536e1
+       0x9ff8dc88      0xbf62df79      0x2d826e27      0xa0d4967c
+       0x2b1306d6      0x40bd7c4d      0xaed6f818      0xb701976d
+       0xcf6c8657      0xa891cd84      0x6b6a37d2      0xff24243a
+       0x0132f9f6      0xa66de3d8      0xc170e50b      0xc3f45dfa
+       0x5053c2b1      0x0f7983d8      0x73178c0c      0xcd6534d9
+       0xe3d0c32f      0x092bdd9c      0x97c85ce9      0x0533c2f9
+       0xe5e6e7c0      0xfec8b159      0x3d814ebe      0x199339ed
+       0x8e2bb367      0x109be987      0x1ec80f48      0xb82c7af7
+       0x5f848109      0x77ccb551      0x6fd529a5      0xac31dc61
+       0xee217024      0x603ed96c      0xf0b479ac      0x31c7e76e
+       0x2649c63d      0x9ee4e83d      0xbd71c5cb      0xd1bfeaf6
+       0x0d2d3035      0x8d3a5fa4      0xc3d455d5      0x491a5356
+       0x87ffed33      0x07e48edf      0xd1329ef8      0x21b1f58b
+       0x5d5c2b6c      0x935469bb      0x726b2168      0xa4193fa8
+       0x5fb88a64      0x43739f20      0x5571ddcf      0xdedbdcfc
+       0x2e8bf185      0x5fa7e4f0      0x67d74ffb      0x74dcf1c2
+       0xf566eba8      0xc6cb7580      0xaa024821      0xb8c80f1e
+       0xe63e2d03      0x0e17f59a      0xc916700c      0x92958bad
+       0xf5489165      0xa09fd35e      0xb06632ec      0x285bcbb5
+       0x2f6aa2cd      0x8677f633      0xb6d90906      0xb695cf7b
+       0x88198001      0x8110c4c8      0x35822492      0xb61fde14
+       0x89be0f4d      0xa99285e7      0xbc500dcc      0xf78ddf06
+       0xd85279d8      0xdb3d57b7      0xe5b1958c      0xef462845
+       0xd3f4f2b4      0x89f99687      0x5aaa5f4c      0xb05962d2
+       0x76a94503      0x2f9dca9a      0x363d4e96      0xc59be2a1
+       0xb4eb235c      0x611771f7      0x9d2c9754      0x83ade31c
+       0x1d34e106      0x49b22838      0x1b8fcc6e      0x386e8236
+       0xd64abcdd      0x0c4ecc42      0xc9952301      0xf96f0188
+       0x216ff7bc      0x9a34f715      0x854d53e3      0x509e0eea
+       0x511e088e      0xf4d92e88      0x04eb420d      0xa97d7614
+       0xab088d7d      0x15fb6fad      0x460bff2a      0xb3fd5cd6
+       0xc928cd47      0x6f0786f4      0xb81c8981      0x2eba3535
+       0xd81e03f8      0xf7de953f      0x1a8090d1      0x8865943e
+       0x8363ac2d      0x3d8b17b1      0x0e40348b      0x1fde33ea
+       0xc6a82db8      0xcf2ecd35      0x7b6fda2e      0x267160a6
+       0x366274f1      0xb55e25b5      0xb5b6301b      0xae2baf33
+       0xfa244811      0x3b372713      0x3288094f      0xc683a72d
+       0xc1f86817      0x41e00c42      0x2ab3ecbe      0x851c3453
+       0x3ba01930      0xfa7915ea      0x31bcaa6a      0x2f39443c
+       0xc1ea2a5f      0x6a5e9631      0x6ef7c7b2      0xf537113e
+       0x765d2338      0x2ea59864      0x3a912f70      0xd0c67609
+       0x99d72935      0x47bd5577      0xcf2e5b57      0xf6900ed8
+       0x8ec5e798      0x2c75514e      0x5786c484      0x3e60397b
+       0xb3332186      0x7cbc957c      0x921da828      0x4ad24f5c
+       0x7da17b5c      0x5494ccbf      0x5799f9e5      0x549c4f28
+       0x7a22bb9a      0x136ed2d4      0x042dd1ce      0x1899e529
+       0xb0cf93be      0x2ad39a08      0x58f4bf11      0xa32da783
+       0x9923680e      0xf12b6824      0xf942959c      0xf6091875
+       0xdb5e89cc      0xd143d3b2      0x2670ae0b      0xb2498f22
+       0x149bbac6      0x19bfdb50      0x6d940721      0x4c895a64
+       0x6648265f      0xd3508d66      0x53c8bf4d      0x9a44faf7
+       0x00ee8b01      0xcf830381      0xd3d14f54      0x5954477d
+       0xc1d05e35      0x59a8142a      0x5c87be7d      0x18c81f05
+       0x25d7fea3      0xcbc52771      0x05197d90      0x49e15bb5
+       0xb76f00ad      0xec3358ca      0x11d29e10      0xe73f6b67
+       0xcc08aaea      0x430207ff      0x997b2989      0x0dd5759c
+       0x56017e91      0x39ab824f      0xe13ea3f8      0x1933f3d2
+       0xaf8a3f35      0x95a8e284      0x17c6ce86      0xa2e1ce50
+       0x303b16d3      0x6e9a553a      0x6f1ab2d8      0x13051e34
+       0x5d171dca      0x6d47bdf5      0x3773f14e      0xa1d8e687
+       0x2aba3a4d      0xef2cc50f      0xc03a2ca2      0x1737f5fc
+       0x072495ac      0x17339cdb      0x21b10591      0xe3e77dbf
+       0x38d7ee73      0x856ac37c      0x5f81816a      0xf4c432cb
+       0x64986775      0xd06eeb08      0x10ff3eb3      0xacefa0b9
+       0x853c7583      0x2f63f837      0x57680095      0x52be4f85
+       0xb76b8363      0xd6b16857      0xdc5f356d      0x0f537d1a
+       0x02be1d5b      0x2badfd9c      0xa9eb499d      0xa4d89382
+       0x6cb2c4e7      0x2d379fa3      0xf49d2241      0xa19a7758
+       0x8d6b50c8      0xd75aa57a      0xd15bac1c      0x3ee7876a
+       0x2ade5129      0x3477531c      0x681dcfc5      0x062e4980
+       0x32bac08c      0x247f0e68      0xef282bc2      0x118b2066
+       0x9d582b76      0x9aee7c76      0x6530aeef      0xcecd2903
+       0x458370de      0x97ef53a7      0xbdea1fb9      0x85c93ed5
+       0x382ac268      0x8bfa041d      0x243cd307      0x3117dcaf
+       0x5f4ed66c      0x0ac0dd4f      0xa26f37dc      0x46dcca48
+       0x4c4802c2      0xd30920c2      0xfae5acbf      0xae963fb2
+       0xeaf09d17      0xebdce2f4      0x05b1fdb8      0xa5053dcb
+       0x95109140      0xc3090898      0x604c554e      0x6b1a968f
+       0xb85c56e4      0x28537505      0xfdd6ff50      0x94a61afd
+       0xd8235af8      0x0e766e5e      0xd435bcc4      0x98f5a081
+       0xa5a509a4      0x0cd1ab37      0x072a8cc6      0x8551a11b
+       0xab657fff      0x0ad00287      0x462aea0b      0x67c5f920
+       0x37eab7ec      0x188ce405      0xbd9ab92b      0x2d371f58
+       0xf9147e3a      0xbf39e9a0      0x92af373d      0xec1004e6
+       0xbbb47b6f      0xb184858a      0x1cff4eb6      0xf9e1bc5b
+       0x7bee47a7      0xd45ea3eb      0xb2f833bb      0xfc14eb83
+       0x796e88e5      0xaf5713be      0x4473c576      0xf340c33f
+       0xefe4ec23      0xa0e506e9      0x1a45cde6      0xcc493d89
+       0xd2953b79      0xf933e3ab      0x7abdb237      0x909c6795
+       0xa41830b5      0x64d7e260      0xc35b73ab      0x0511d5eb
+       0x55cef5b2      0x1e98dc45      0x85e0736c      0x086ab02f
+       0x0800cb06      0x2913dda3      0x2cff6bbc      0xc2ee819f
+       0x5c4a93f4      0xba816554      0xf3d612bf      0x23c38faa
+       0x383b9c04      0x72152702      0x561cbcba      0xa5712d74
+       0x23179d51      0xd9d8d1b2      0x8bb5aa06      0x19bd4974
+       0x63fb7192      0x39a99561      0xd68818b8      0x169745ac
+       0x9f6c0cb1      0x1dab2c19      0xa635e5e1      0x0b7e3e9a
+       0xf0104d65      0x51e5154d      0x5874e178      0x8c00d3b5
+       0x5240a4e2      0xec43b42e      0x691271ed      0xcd2ca92e
+       0xec875ac2      0x21563b84      0x129428d4      0xec3ec825
+       0x785485f9      0x5b6e31a7      0xdc52e08a      0x03e0e7e8
+       0xb2958ce3      0x81047170      0xe6df8310      0xb0e1e688
+       0x5c92ee96      0x3c538f0a      0x9b79c996      0x8063542e
+       0x85b675c3      0xe1e94477      0xe9601baf      0x0c1c51e7
+       0xe7bb67d9      0xb46cc2d3      0x6554a38b      0x6c9b05dc
+       0xba982ee0      0xbd25414b      0xc5c9ad09      0xebe1c436
+       0xd8afd29d      0x87959206      0x138f1210      0xad6968f0
+       0x9aaf3448      0xf897db65      0x4e78b6b8      0x1dd5ae35
+       0x6a766d71      0x14a1d6c9      0x8c02f544      0x779f00d6
+       0xc26fae00      0xff10307a      0x375a71bc      0x7596f865
+       0xde22772b      0xa2c2324f      0x803f2ccd      0xa177fbc9
+       0xe1691e88      0xab43f4c0      0x1ea18371      0x21f9355c
+       0x4754ab6f      0x3e9b619e      0xd0b0bae2      0xed702e62
+       0x52627ed6      0xb524e2d4      0x5d3f321c      0x9f5feda7
+       0x595536ec      0xe5c3fc85      0xf7ac36ef      0xa295b8e4
+       0xa89ab948      0x48364f8d      0xbddde0ae      0x28dbfd8e
+       0xab4628e3      0x8687e6e8      0xbbeb2ac1      0x1ab758a6
+       0xa27eeae4      0xc4d1d84c      0xa27109d5      0x753ae1a3
+       0x2ec15429      0xed714c82      0xa6bab357      0x376270ca
+       0x3da11852      0x8712af51      0xa7784d99      0xee9a6108
+       0xf6c52eab      0xc9a31435      0x77d2de81      0x592e2ad2
+       0x9bac83d7      0x00300a48      0x2364e748      0xded2d4dc
+       0x798b8e7f      0x2056604f      0x0d2da97c      0x4d33bed2
+       0x1fb830f4      0x83fde71a      0x7df638b9      0x523a3c44
+       0x0d35871a      0x21db268b      0x781375a6      0xcef0feea
+       0x9a303736      0xeda47dac      0x829b47b7      0x7aea1a8d
+       0x9474cccb      0x10fcd199      0x32c8d767      0x68a2eb71
+       0xcfc5e096      0xfa419799      0x6b86ba7f      0x5e531df4
+       0xd0886159      0xa7e40686      0x8990e4c3      0x8712c827
+       0xc865afb0      0xf6eba9b7      0x4be657af      0x4068942e
+       0x8bd26f15      0x88de80af      0xd89e408a      0x0a9afecd
+       0x98d4af20      0xc9188fbc      0x27981755      0xa5f56ae4
+       0x75f2f512      0x9108402d      0x411018ee      0x3905625d
+       0xfc342bfe      0x54ea2697      0xd6c699ff      0xef0c5434
+       0xd458c93e      0x8f5e0c66      0x4401edb1      0x80941279
+       0x2d347055      0xc0dbbe17      0xe2ba08f1      0xf9755e6e
+       0x06883f92      0xba6fe81c      0xb7a45342      0xf910c0a8
+       0xf750f50d      0xd4c9ea72      0x3404532f      0x81188ddb
+       0x05fd3de5      0xe5b9af28      0x728bdb6e      0xdcafccc0
+       0x4208d329      0xa5d9d6da      0x0ff406a5      0x64429d02
+       0x840fb2be      0x770a1db8      0x1bfba7c6      0x7dec58c4
+       0x332bae55      0xe723e48b      0xdb3ed978      0x2e8a8209
+       0x3b11fb45      0xf9a6c238      0x851f630f      0x3f3a26f3
+       0x7c1107ba      0xe311701e      0x6d03365d      0x5fe6dfbe
+       0x972023d0      0x13cf2a5c      0xdf923032      0xa1cb4cfc
+       0xf309eb2c      0xdafefbb0      0x2e746cc4      0xa95f5a00
+       0xb55ce89b      0xa549ece8      0xd276614b      0x476c74f7
+       0xe81e5ac6      0x44c64a4d      0x29c6976d      0x8e0ddadb
+       0xdce949e4      0xdb8aec77      0x31cf7dd0      0x3b15bbb1
+       0x88a937d7      0x542fa921      0x30afd596      0xa0e5c8cd
+       0x06b9256c      0x6c405f7a      0xeb11d4ff      0x950effce
+       0x83b3eda4      0xc73bc2c6      0x5635b14f      0xdf52e4f7
+       0xe472a63f      0x6606868e      0x079737c6      0x4e7d6da9
+       0xcbd79878      0x80d4f629      0xc3b27764      0x26494a47
+       0xcc33ecaa      0xc8492ee7      0x8a604b3e      0x95eabfe9
+       0xa4b36cde      0xf22a05c6      0x18f0820f      0x3533be03
+       0xaaaacdc8      0xfbbbf7ae      0xb741ecdb      0xc4934b98
+       0x60ba602e      0xdb6702ef      0x5758f91e      0x58ae94a8
+       0x21ba03ae      0x9d1969ea      0xa543caeb      0xae1e8022
+       0x85f76a36      0x57e1f384      0x440d830b      0x56c3941b
+       0x15b1f50e      0xef39ee3c      0xbae88658      0xde1ed682
+       0x6e0c1ee7      0x678b1125      0x60a9b4cc      0x027e9cf6
+       0x2d45c486      0xa6330af2      0xc55b8b92      0x3ad6233e
+       0xe43e4487      0xdbc4fa0c      0xfa25370b      0x6e951f74
+       0x542e0dd3      0x739d0a6b      0xc7cde111      0xa44b6de8
+       0x77c35075      0xad8ec0f1      0x5e001532      0xcadad4bb
+       0x9f199d81      0xef2d6ea1      0xbee44cea      0x1b23b663
+       0x2e1f1e03      0x1a2b97cc      0xf6e19118      0xdcc89526
+       0x00439b0a      0x2d60204e      0x61436f86      0xb7ff697a
+       0xa6873ed6      0x1565de45      0x522cdad5      0x9e20ac4e
+       0x53d8f51a      0x69702a0f      0x7faf0cc3      0x49699cca
+       0x33099339      0xa6026fc2      0xe7a01029      0x682aab4e
+       0x813ee0b7      0x6ae6e27f      0xf2647231      0x69854354
+       0xe4a9177f      0x796555a2      0x40a9e12d      0x50b037ed
+       0xee3a1007      0xaae0f40e      0xdbac9628      0x9d2617a1
+       0x651a0494      0xa39eb938      0x10933b0b      0xe0edd561
+       0xe4859cd4      0x7b7cb75d      0xf403026a      0x1d607ac7
+       0x450c0eb5      0xa86045db      0xc6d56796      0x25503974
+       0x58b799d9      0xaa778b7f      0x0ec3caac      0x395e01d2
+       0xf11f28ba      0x98d43c61      0x8b10171c      0x4157bd27
+       0x5526c365      0x8d025e4f      0x4efc6b28      0xb595b3e4
+       0xeef7bc75      0xb2b15e9b      0x11cf8cbd      0xb90333de
+       0x4e5ad49b      0x8fb3f85c      0x56553b3f      0x1542ec72
+       0x02e753f4      0xe6668b3f      0xfd69c69c      0xc63760c5
+       0x1c34c964      0xe925a22b      0x8da78af4      0xe05c7de4
+       0x6c86a5bd      0x0806505e      0xf76bb4e0      0x4414fbea
+       0x7a12dde1      0x0b01f2a3      0x249e88b1      0x48cbf830
+       0xe75b244b      0x03a4b2a3      0x00b11349      0x4fa9ff09
+       0x9d69b189      0xe7983559      0x21e21191      0x45976021
+       0xfc397ced      0x3356f20d      0x0ab7ed8b      0x1753960c
+       0xe5c825b5      0xbed16e75      0x0aae8565      0x9f4cb02b
+       0x3fe0fb67      0x5482c247      0xe32d5d2b      0xe5123367
+       0xc087cad1      0x3da3ca98      0x11fbfd27      0x096bdd22
+       0x7bd4900d      0x08e5d154      0xa24b4c55      0x3521ac4b
+       0x9e9b280f      0x4c2f0193      0x61db8965      0xeb6b1ef1
+       0x91bc1db7      0x37432ebb      0xbd7d89f9      0x0bbffc4e
+       0xf933b300      0x686406db      0xbb097167      0x2e05d987
+       0x835b9103      0x7a7d614e      0x3fada5e5      0xc3f11ba2
+       0xc2d45537      0x330717bd      0xfccdbf4d      0xdc3a6c4d
+       0xefbf81bb      0x6ad740b1      0x6bc7d827      0xa119fa8e
+       0x1d356478      0x36d9029d      0x464d3ee3      0x288e52ce
+       0xc583b4a3      0xcee7efa0      0x249294b5      0xe8db7303
+       0xc83ba051      0x11eb9c66      0x19f521c0      0x88d3d368
+       0x55e124d7      0x2685656e      0x82b89464      0x8621ea0d
+       0xf6c8854c      0xa28a1830      0x346136ce      0xccf73586
+       0x939c6da0      0x8beddcbd      0x02211723      0x34b87863
+       0x55060604      0x25919b8c      0x4a3ebc09      0xc986b25a
+       0x18f279a8      0x6c481340      0x8dda2b6e      0x948c4dd1
+       0x455f0d21      0xd83820d6      0x46ec1759      0x32aa7144
+       0x42a86cd4      0x3b0960ff      0xad706cac      0xd336870b
+       0x9c58328f      0xe8458fae      0x7e08f5aa      0x7ffba0a4
+       0x352b2ef2      0xceaab349      0x769403a5      0xff8822ca
+       0x06120d82      0x4f6ef250      0x6cc534d1      0x0779dd02
+       0xd7a37a5e      0x720a57ba      0x28ce5bbe      0xefa7cae9
+       0xe6aca959      0x05fcc460      0x336d5c5e      0xa1611b61
+       0xd4bf21ba      0xf39049f4      0x0267a91b      0x88f9574a
+       0x51ff4796      0xf4232e18      0x5cd01b4a      0xa6148e1a
+       0x4cbf2ca5      0xdfd92d3c      0x082ba197      0xa285a159
+       0x699d89b9      0x47cf64c8      0x6e82b3da      0xffbb4b69
+       0xbe73173d      0x082ac205      0x33fa0f45      0xd6db94a3
+       0x46ea915e      0xff4cd464      0x67b723fa      0x009de5d5
+       0xa4910051      0x1482e9da      0x5155cce0      0xf36e52f0
+       0x4cc9a545      0x825c03ce      0x38e4d367      0x69fb18a9
+       0x07ccac36      0x4f90c6dc      0x1cc63e0d      0x08a6cb38
+       0x46370b27      0x081f3f8c      0x0d932c0e      0xd971ae6f
+       0x81ae7309      0x145737b2      0x86bbfea5      0x81bffc75
+       0xc5613498      0xf6f29e64      0x4ba60cad      0x11f0f89c
+       0xfc212425      0x779a4de1      0xffd5e5f0      0xe82102f1
+       0xc3f925cc      0xe4bc4b84      0xf7b525d6      0x7a1a1091
+       0xa76555b9      0xfed8587b      0x93b4ccbd      0xd4672c02
+       0xcd0c4380      0x650dd741      0x270a196a      0x8973789a
+       0xd9d9e7f3      0xa13d4691      0x22a8a9cf      0x1fc41544
+       0x2028b552      0x33fa1956      0xeb0bf71a      0x5415c636
+       0x01e2afbe      0x842bd37c      0x054a0c29      0x8e4efbee
+       0x9c08c411      0x7a557d5b      0xae09b391      0xeb20088a
+       0xf0a35f64      0x1e6cb9c8      0xd4ce5c8e      0xb9f70840
+       0x09fe9ac5      0x802dd9ce      0xa7a5e059      0xca146c39
+       0x3ffcd4b6      0xaa2a8d1c      0x68ce70ef      0x588d2f5c
+       0x02fb8282      0xe3d4efa7      0xf5bfb6fa      0x92611de1
+       0x16899731      0x8ae500c4      0x289d3ab7      0xd7987454
+       0xaa8805fb      0x574feee6      0x7637d525      0x5f2708b9
+       0xdf90dce3      0x23903580      0xc6c9f1d7      0x9d35fd92
+       0x1a9f0779      0xb3639301      0xaf4ac473      0x2087cf2b
+       0x7c53fa10      0x8b42cfd8      0x97b40b1b      0x355361eb
+       0x4fce4acf      0xd646cd4f      0xa5c5f8ce      0x5c9b4e08
+       0xde4b504f      0x60482fc1      0x99ff74fe      0x227558b1
+       0x0a4c366e      0x7e41ef03      0xde23731c      0x09883152
+       0x6b51c14f      0x40fa762c      0xaab9752e      0xafcd40db
+       0xe8d1aa17      0xb8de5c5a      0x1cd688ef      0x455d3cd6
+       0x173ce289      0x713811ed      0x211efa2b      0xf6476416
+       0x5a4a3620      0xf24da960      0x900b41c6      0x7491e67e
+       0x810f0d96      0x87057b9d      0xe49f7e87      0x9a254515
+       0xfbbf358c      0x1e948059      0x53f988ed      0x82d2ae2b
+       0x9f0ca82e      0x1d417d0f      0xf297009b      0x9a2b8f17
+       0x0c42d014      0xd6a02787      0xa1525556      0xbb42c30f
+       0x9d451930      0xa0ae81ef      0x3c2dae74      0x555c9f8d
+       0xe53efcb4      0xceb48c3f      0x08c52a15      0x9f708dc3
+       0x4d11f8a8      0xdb88331a      0x39224b1a      0xe7316fbf
+       0xc893edea      0xdb54fe89      0x7a11020b      0xd54ec595
+       0x47b4f7ca      0xfec50200      0xb9d99919      0x5430b3f3
+       0x370bd753      0xaa9660aa      0xe44fcadf      0xa6049488
+       0x993c643f      0x1647348f      0x07584b21      0x1ee6931f
+       0x886913b3      0xb2e60af4      0x3c039365      0x73fb6e80
+       0x2f546656      0x9cdc3096      0x8f5ab865      0x9a3f72b7
+       0xf21dd444      0xc0063db9      0x1157ada3      0xa56b3920
+       0x0d7c4f16      0xd4d6abcd      0xf7d43b8e      0x1354ebe8
+       0xd293dde7      0xafc80df3      0x8cc9fcd9      0x1d7d4720
+       0x0e9023f2      0x6d5649cb      0x50c6499e      0xb567bb39
+       0xf88e6e62      0xeeca3f1f      0x695a7f4a      0x0b113206
+       0x81922c9b      0xea50add5      0x1cab0671      0xea0151e4
+       0xd97cef3b      0xf9809c7f      0xdcbeff86      0xaa954a26
+       0x6d49292f      0x7cbfb140      0xc4594e46      0xdda48061
+       0x252ac5a9      0x36ac9cc2      0x21aef647      0xa53f69aa
+       0x63431a2d      0xfa615241      0x6ea588f5      0xb9cdebd5
+       0xee7d9521      0xdbae35ab      0x94da8afd      0x423f1c48
+       0x2af8c253      0x23b6d4d8      0x189d9b3d      0xf163c33f
+       0x1190da5d      0x3f53a713      0x896205cc      0xb3498c64
+       0x45c91930      0x672cde67      0x44db4e4b      0xa22c24f7
+       0x498ac180      0x4b7988fc      0x7e4eee67      0xb6b3ca6c
+       0x81fa6c73      0x9eeea44a      0x7a1db57f      0xec9e668c
+       0x3226c2f3      0x7fdc01e2      0x137a219d      0xfb0f6b97
+       0x314bea56      0x2ed481b5      0xe612c860      0xfcaf8b65
+       0x352dd59b      0x4619e846      0x9b7e242e      0x693d0666
+       0xfae9233a      0x9f90c1ee      0x549d583e      0x84c6ca8f
+       0x9104b775      0x3cb78dc2      0x27e863c9      0xe6b8b69f
+       0x21071330      0x414d88e4      0xe91b3215      0x3a0f0b91
+       0x8e7b2e66      0xfc5494be      0x45b76a5e      0x00c1be61
+       0xf687d442      0x177db6e1      0x6f8f4b49      0x6889973d
+       0xc9c8a2e2      0xe777dda9      0xf89485c6      0x27394030
+       0xf1178582      0x801feb07      0x8776800d      0x6e80a0e6
+       0x3b388018      0x4b38b58d      0xba77dfd4      0x1c30dd27
+       0x46a29a7c      0xf6963535      0x31de9c7f      0x13299881
+       0xb094abab      0x2ba94bdc      0x8359b047      0xe84dcd95
+       0x1752d031      0x24524cbc      0xaca81f56      0xf47ad3c2
+       0x2d0b035c      0x72728374      0xc6bb67ec      0xf9dab8fd
+       0x77b62d20      0x4ccba311      0x756feb65      0x80451ddf
+       0x35f274cb      0xedaa1d30      0x1c9d7067      0xd219e0de
+       0xbeccea82      0x42cc4bb4      0x78a46fae      0xd804273c
+       0x28d494ad      0xde1fa84a      0x44b339bf      0xf6d899eb
+       0x0a0ea1b0      0xb6c5b705      0xa9a49339      0xbab4f1d9
+       0xbb33de48      0xab2cceda      0x5652cbbc      0xa181f8d9
+       0x6c8c86e1      0x7c3bb03f      0x82586c0d      0x7bc855e7
+       0x84f247af      0x98b5a5e5      0xb6b65e5f      0xcc633a26
+       0x3ec6e5dc      0x94368a1d      0xbd579b62      0xe2e1d9d1
+       0x00b97d4e      0xd3dd22d3      0x10f59a15      0x951e69a5
+       0xeb006584      0x6f4c7a0f      0x8afacc15      0xcaeffa1f
+       0xf01676f0      0x9e85c75c      0xcb19f96e      0xaff35eea
+       0x00804c8e      0x4578f90c      0x67302b6f      0x9d1a84db
+       0x7935bc6b      0xb9e7b7ab      0xae465905      0x73aa4e99
+       0x86b5a3dc      0x2def3002      0xa6c01f27      0xa6238136
+       0x58d039e1      0x5f74ea1f      0x1cfa512b      0x6b3ac86c
+       0x543842b5      0x768086cf      0x4e369eb1      0xe8a7066c
+       0x8c243dfa      0x10a8b7da      0x698d3f28      0xc8f36357
+       0x1f15015a      0x3822d715      0xc03ec75d      0x630fc279
+       0x530faa4c      0x7b4b9ca4      0x036a089f      0x9826d917
+       0x8187a3db      0x4a141756      0x4d26e8c5      0x0e75f8a7
+       0x5ac2dfca      0x28560883      0x774c2cd5      0x70e3131b
+       0x1863ae86      0x10f3f167      0xedf6286a      0xc02d6a1b
+       0x556bda36      0x20e445b6      0xf4ea40cb      0xdda83b66
+       0xfce4ea5e      0xf52c254e      0x1f8a3a64      0x8cf0562e
+       0x85f59cba      0x85fa0c4a      0x069e339d      0xa16a52ed
+       0x1cc655c3      0x5f13caa3      0xc96e8801      0xab90c8bb
+       0xd469ba5d      0xfb89626c      0x8beb244e      0xc49eebca
+       0x03f7f766      0x304340a7      0xc3df3a9b      0xd637958e
+       0x56250bbc      0xb51683ff      0x90be752d      0xde122622
+       0xca4c63ef      0xce5dc37a      0x1e180b4c      0xee6b7901
+       0x6b479b2c      0x3a2ab091      0xabc99414      0x7cd6be6e
+       0xb2bdd380      0xb03c6bde      0x0284bbb4      0xe4729a9f
+       0x08943741      0xb1f1643e      0x7a616e83      0x9cb2477c
+       0x44ac3c1c      0xbdd48fb9      0x7aa5fb90      0x132109cf
+       0xd3e410dd      0x51005bd1      0x84fb47ef      0xd13c4af6
+       0xa50ccbc3      0x27b77540      0x9e6ae18a      0x9ef50d99
+       0x8d157110      0x8337516f      0xfd3e64bf      0x9b1e3dc8
+       0xea832c80      0x22f5b334      0x4d77c390      0x96664b4b
+       0x639585f4      0xc48ca68b      0x7d583366      0x01613541
+       0xd7c87479      0x6a220312      0xcd774824      0xd07948a1
+       0x96a3c235      0x8271186e      0xf04ab95e      0xbbd60afb
+       0xea8777bf      0x5b732701      0xfc2871eb      0x336197ce
+       0x1c446c77      0xfd9da880      0xa8a31a09      0x264f50f1
+       0xf1184c29      0x005a0022      0xa452e901      0xb4aad591
+       0xd541531f      0xd8e82e88      0x338e9a53      0x486fe4b3
+       0xf4deedda      0xd23f27a2      0xf8868f93      0xb10fe77d
+       0xdf582a76      0xeca50286      0x09c2b519      0x1dd340b3
+       0x18582ee5      0x84846eda      0x9bcf4813      0x9b279f66
+       0xf4239b3a      0x83046261      0x856b79f3      0xf0981d4b
+       0xe0fb02cc      0x8abe2b29      0x413a37f6      0x02107c16
+       0xb9cd9e78      0x34b716ca      0x08dc4229      0x65972a64
+       0xf26198e8      0xa2f3c5d5      0x9487b9bc      0x13822c45
+       0x189ecfe1      0xada5b897      0x683ea9f4      0x9f96a0ca
+       0x6377e718      0x6f2edc94      0x5ea214ad      0xf1c72441
+       0x4ed5075c      0xea8a7509      0xf0561584      0x6b2e685c
+       0x306f759a      0x1d64834a      0x84b0f061      0x722dd461
+       0x51b9a0d8      0x64b306c9      0x8d1306b8      0xc77be83a
+       0x73e555c9      0xfdcf9da0      0x37bd73d3      0x2e3f5a12
+       0x4ca40860      0xbc7aadb0      0xf9b02efb      0xfe3aec5b
+       0x81daa8c6      0x7f9f3b3b      0x6ea61f59      0x0377fbbf
+       0x99e51dcb      0x0b85f013      0x9e181bc6      0x3f659e36
+       0x73de7092      0x44b15a23      0x282a0ef8      0xd25f63b4
+       0xbad95f3c      0x3d81c484      0xeea6fa69      0xcdd72167
+       0xd032f70e      0xad38fda6      0x616319a0      0xdd467387
+       0x82599e9b      0x8455c4b3      0x2f299154      0x4598d082
+       0x127eebe5      0x5d5b7f39      0xa8828893      0x09f74d5a
+       0x1e617f93      0x90372117      0x284fc344      0x6064ab6a
+       0x7755874d      0x07d7a42d      0x8dbb160c      0xb7a2e13e
+       0x3549bc32      0xd51dc73b      0x546a8045      0x37758ea1
+       0x8d76f575      0x8360c2d5      0x7e782677      0x5b26bb9e
+       0x2cbf080a      0x1b9ae362      0x9b074c3f      0x7fbaa15b
+       0x74fd16a7      0x41060999      0x93ea1dd8      0xc8ba4de9
+       0x1dc6cf6c      0xe07afa34      0xe287a760      0x6fd2c470
+       0xd8e34f2b      0xb49bf9bc      0xff3d7ebe      0xdf4175b1
+       0x6efc9cfa      0x98a821cc      0x834f3cf8      0x8bb70a08
+       0x9ebb523a      0x369e4373      0x9f1abc90      0x532b8598
+       0x1b73a592      0x357decc2      0xa05593fa      0x3c2e7a29
+       0x9b7e0f8d      0x1b4b2040      0xcaf2744a      0x1421d818
+       0x198f6c50      0x4d61e5f4      0xa9e7a00e      0xf1335077
+       0x33c344f7      0x59347bc7      0x14d7e700      0x300857e4
+       0x60d371b6      0xeab350c2      0xd4d4b70b      0x6738f2e3
+       0xb2fa43da      0xf27d9c2e      0x1eb85473      0x225e1b86
+       0x487c32cc      0x7626b33a      0x4d252ac6      0x5d3ac080
+       0x3902d625      0x2e5d3605      0xc1e55ce4      0x53bef26d
+       0xc6707340      0x0af8a810      0x9e5ce673      0x38f02d53
+       0xb151970f      0xf196df3f      0x545009b5      0xf892401f
+       0x51ad751a      0xe68f9aa4      0xadfcb408      0x45f8ccb8
+       0x18165565      0x424cc716      0x7746377c      0x6baa5c87
+       0xd28bd133      0x7f640622      0x6d62940a      0x98898ae2
+       0x31f9898d      0x63cd1a95      0x62578688      0x37add7b5
+       0x98764171      0x5ba3b7f5      0x9cbb0101      0x0bf2c6f8
+       0x853e0b95      0x06f6c8f5      0xcecc33c5      0xf2f708bd
+       0x5b3390cb      0xc8e60640      0xae781cd5      0xe210987b
+       0x34cd6e99      0x2d5ac012      0xda785945      0x61d861b4
+       0xbf6a5a6a      0x1f58cd61      0x2896f204      0x529eef4e
+       0x439acbf6      0x6a1f997e      0xf76e187e      0xae8d5866
+       0x0a24ff5b      0x30d4c406      0xcbc43583      0x490b5c86
+       0x1b368987      0x83c18dfb      0x67ad047c      0xeed1846f
+       0x591b7ada      0xc3ae408e      0x13b70e8d      0x4d707e99
+       0x0c56a0fc      0x38d7dce9      0x62b35680      0x49d7cebd
+       0x5f081591      0xb88a4f13      0x269c484e      0x39c4155a
+       0x0944201b      0xfb779d43      0x4f0aef80      0x80252c2a
+       0x9a0f0384      0x91a90e11      0x6ff2b75a      0xd0bd1bb7
+       0xced364e9      0xb887d9a4      0x499f4439      0x827dfb51
+       0x24b13f5f      0x3f5982bf      0xc5bc152d      0xb936c05e
+       0x1de9595d      0x6c3aed39      0x917e24d9      0x36ba4dd6
+       0x7ad2aaa2      0x134a3d4e      0xe16b6895      0x662e5ca0
+       0xc54415f2      0x84d87908      0x432aa79c      0x878d3870
+       0x0728485e      0x8c235f08      0xe2408c88      0xe9ea535a
+       0x45199377      0xe555757d      0x1db0088e      0xf7dbb2b1
+       0x0730531e      0x06091bcc      0x357c895c      0x98b1d02f
+       0x5058afe1      0xb781c921      0x566baed3      0xda6e9be3
+       0xa1b9a4f2      0xf4989c3c      0xb6b3d46c      0x28e07651
+       0x8985cda7      0xab4f1690      0x157fa05c      0x048e8e7a
+       0x592066de      0x0b7bce93      0xa90889b5      0xeeb37397
+       0x5c613de2      0x9d4bc924      0x0a287636      0xbb55f0f3
+       0x17ea3d42      0xa30e5abf      0x65673bed      0x9029900c
+       0x073d3ae1      0x8563112b      0x5ed2a666      0x31ed6038
+       0x5e677cab      0x270b8ef6      0x71411b29      0x5ca36d53
+       0xeb983179      0x766eff14      0x50c4158e      0x7e819800
+       0xe157f2ff      0x1e17d258      0x7cd66859      0x311e1df9
+       0x5fb8c4fc      0xccc72b27      0xc072e4f3      0xeba0bc8b
+       0x57b9f6f4      0x3a0a6b51      0xe0be1e32      0x9970ea98
+       0xc188b885      0xb067a7b2      0xc95bf34a      0xea6e1ecd
+       0x7357acd6      0xfd4232aa      0x0dc2c903      0x8a1027df
+       0xd24ed3a9      0xf555294f      0x1e69ba8c      0x24a18468
+       0x462f6236      0x48f5050e      0x2f9730c4      0x116d39f6
+       0x6bd4817c      0x0c23fafc      0x6c995e2c      0x96ff74d4
+       0xc95ec457      0x20b48100      0x36ac3260      0xd0488b05
+       0x59698bd0      0xd77354df      0x864cb682      0x47729924
+       0xe57d7d65      0xb3b225b9      0x9817cd77      0xaaf5b987
+       0x0556ddf9      0x3e97426e      0xe65af403      0x49dea887
+       0x0fa9fdad      0x85ae3f78      0x16ae2e0a      0x8674723f
+       0x0cb4052c      0xb6ba18a8      0xb6732ed1      0xc83da485
+       0x05cd2ebd      0xc6d085ab      0xb7c1f943      0x21ecae50
+       0x7e2c7a87      0x6091b571      0x67d599ae      0x669a1df7
+       0x59db546a      0x4648a768      0xd92144bd      0xef1281a7
+       0xf6e6e46d      0xe8e3517a      0xbde04ced      0x87d9d93a
+       0x140db702      0xba0cfa14      0xb100a6e5      0x54dbcc5f
+       0xa229dddf      0x9f41bb63      0x48fabd5e      0x6afaa300
+       0x23530d03      0xb68758ab      0x5017d7ae      0x393f5c1d
+       0xb1c186cb      0x70070dd6      0x227eb11a      0x04e00b26
+       0x1bc139a7      0x95962a78      0x5a368d66      0xb16f55c2
+       0xa0bee5ec      0x33dfd7bd      0xa225a273      0xcb39513a
+       0x0d3c1333      0xef8c4946      0x97edf173      0x8dd4a24d
+       0x0398b0d7      0x0658c12a      0x0cc52bce      0xf6c50557
+       0xb30ef1c6      0xe73d5cab      0xd2b023f0      0xe9cb5e5c
+       0xbdac1c49      0xcabd8490      0xd1f67dbc      0x8276394a
+       0xf4d92b45      0x16720096      0x5bc61a7d      0xaf1a8a44
+       0x2b15f763      0x214ed076      0xed5cb34d      0xb7705486
+       0x7ccf0188      0x70db0d23      0x221a5d65      0xb1cfed27
+       0xd6fb0a93      0xbca3c549      0xe78d9313      0xc279e6cf
+       0x80bcc0ca      0xf4cabc63      0x2581ec7a      0x9f8776fc
+       0xd8d12c74      0x8e1e31f7      0xfdf8366c      0x7d87452a
+       0x371651a5      0x93711829      0x40551e71      0xa6a2ca53
+       0x03510cac      0xf477dbe0      0xad96a381      0x785d712c
+       0xcfd48f42      0x6e0c7e29      0x82c824e0      0xca56d64a
+       0xb114d102      0x54857b61      0x80ae5320      0xf9e59322
+       0x879edea0      0xb5d3bb2b      0xcea51e29      0xd5dd1ebe
+       0xf4942dd4      0xa8627803      0xbe19da98      0xfaea0747
+       0x5b3e4230      0xa7a99a54      0x24178b4c      0x3c4e2a0c
+       0x6aaf5cf2      0x5e61998a      0xc8583975      0x98a44f48
+       0xa267f95c      0x8cd7e717      0x507e66d5      0xce1f5af5
+       0x96a57b5e      0x1ef7be28      0x56cadd5c      0xdce60b1e
+       0x51a9b6cf      0x537ec0f8      0x97c33f42      0x40989bf2
+       0x3e4aa079      0x89252bcd      0x58e16fab      0x7cf59a78
+       0x169fe52d      0x288bebaa      0x0475db28      0xd36a0eb7
+       0xdab82ab9      0x927708bb      0xd86b4558      0x5313ff89
+       0xddad3825      0xb20bdf2a      0x8c11eb1e      0x637630a3
+       0xef3882b5      0x4434f297      0xc6e6719e      0x04965e9f
+       0xa354c5a3      0x57811a01      0xd557c840      0xeb825e12
+       0x7846a35f      0x4b0d0a16      0xc2f0e894      0x2f57d378
+       0x9de98732      0x75c771eb      0xa6b15e34      0xb0c2028b
+       0x62cc4fbe      0x702fe318      0x4683dbd0      0x6987488b
+       0x5371ec5d      0x5d6dba4e      0x597b4d28      0x9d958e4d
+       0x568dc21f      0x563af77e      0xa1bb7f28      0x88a7e2bf
+       0x234086a6      0x22cb8e9d      0x69a89d42      0xf3ccaa93
+       0x21046610      0x147e01f0      0xe47c25b1      0x143cb6e6
+       0x3363695f      0x25ec9b84      0xbe4b2810      0x24a201e6
+       0xab96575f      0xcb76e8bf      0x5b53676d      0xc57242ce
+       0xf0ca8591      0x40d17a35      0xed4c6e1f      0x49455e6e
+       0xef0f7f15      0x81a75c74      0xf7607d34      0xc53ef3b0
+       0x58d9ab1a      0x7be3c097      0x8a3018ec      0x768b45ab
+       0x01e5d056      0x8626aee4      0x74678f22      0x04f879be
+       0x5de2cc43      0x8e8a01d2      0x909a3a46      0x4ffd40b1
+       0xbbc43410      0xfbedd961      0xc7272dd3      0x5179304c
+       0xfb2448a3      0xdad69bb9      0x63b11e88      0x2c113811
+       0xd4fc9418      0xe81c076a      0xadf5dea9      0xd6235fa8
+       0x790687d0      0x54f3c6e5      0x1f3cb30a      0x5bdcc35c
+       0xd5d7a708      0x5f9360dc      0x37db3b66      0xb2d2525c
+       0x77f57eae      0x174c9046      0x177a1d8b      0x09ab8214
+       0x6d98c8e4      0xa00c8bf6      0x90176427      0xf9825762
+       0xedc6e23e      0x91c783b8      0xc4ecc812      0xcf9dcfb4
+       0xdd198482      0x90106edd      0x749ad5df      0xd081c055
+       0xbadd744b      0x1f7f67db      0xf2fab6c6      0xfda72461
+       0xb5f8dc29      0x041beafe      0x22afaeca      0xc511d4dc
+       0x67ffcdfc      0x714869ac      0x9da3735c      0xdbecb091
+       0x49ab7326      0xebd8456e      0x86b9a3a9      0xcc0cf3d0
+       0xc458a8aa      0xcef51edc      0x2c346054      0x5da2ef36
+       0x7003e562      0x383add1c      0x9b4ad885      0x1c9431d8
+       0xf579d69a      0xc158cdaa      0x5cb86875      0xa2a1585f
+       0xd0145622      0xcc16b016      0x407c65d1      0x0a47902d
+       0x617fd355      0xb38722a8      0x96797770      0x8556a324
+       0x61f62b1a      0x4b868b1e      0x7bcf5d2c      0x690b228c
+       0x01ed1340      0xa93077d1      0x507b91e0      0xff1afb78
+       0xaa3e8c9b      0x7f3959ce      0x73921eda      0x4bec8b98
+       0xf14546c1      0xb349be29      0xcbbf596c      0xdc49cd5a
+       0xab0e9dd8      0x492b1a71      0x51d40f49      0xb4561b8c
+       0x62443b79      0x4fd6c485      0x5c0035a4      0x6324e20c
+       0xa0a4c129      0x3706696c      0xb1e00b67      0x776d4da1
+       0x0dfe8455      0x2c1a7831      0xa348ccb2      0x43c81263
+       0x8542535f      0x80065160      0x80f83b52      0x7a8451b0
+       0x3692494e      0x03a350c6      0x626e65f2      0x349c8564
+       0x2b5d4dfa      0x65563379      0xa842dbbd      0xba88d4f6
+       0xb31edb1d      0xd11e179c      0xb129a5ba      0xacd21d1a
+       0xb1780bd3      0x1a465659      0xd34a5ff1      0xe7ea8229
+       0x6d61d93a      0x266e70bb      0x0f086511      0x42c8abee
+       0x42f9668d      0x4ea8de2b      0x1c1ca3b1      0xa92d3e21
+       0x81226c30      0x2012ec27      0xa186e9a5      0xa47343e5
+       0x741687db      0x77087bc1      0x0c8ea7bb      0xfc934dce
+       0x23ccff20      0x2eab3f8d      0xb0dd8477      0x36c1d3d6
+       0x711c09f6      0x119ce3b1      0x6bc80df6      0xf358702b
+       0x54f23765      0x2f7ca820      0x0f529594      0x2c9db4d2
+       0x276be15c      0x6e044aec      0xa4f4d7df      0xb941c057
+       0xe40e11ef      0x22b18555      0x16880f87      0x3a262bee
+       0x02008cdd      0xb71a4fc8      0x7bfbbf95      0xb31e695d
+       0x93dccead      0xc607c87d      0xe0e7fddc      0x92361c05
+       0x0f300298      0x0b24b480      0xa2063e18      0xcac5d905
+       0xb36a3ac9      0x464a7ec1      0x88c89d73      0x3dd47926
+       0x16342e44      0xd297fe03      0x3abaa867      0x76780ad0
+       0x328d0460      0x380f87ed      0x5cd4c74a      0xd86069f8
+       0xff51bb0a      0xb91a4d30      0xdc7cd290      0x98930871
+       0xe0424976      0xac0e0de8      0xd9491688      0x708ecbff
+       0x7b0968b4      0xc5b901ad      0x09a9a420      0x216edb9e
+       0x4da813d5      0xffd91f6d      0x572cd483      0xf9c07520
+       0x60c562d7      0xe07593f1      0xd733f65f      0x65d0d022
+       0x5c7def49      0xa852177c      0x2236235c      0x53416af3
+       0xec3f365a      0x5d8a95d5      0xf2dd27d2      0xd7448884
+       0x235a631d      0x12fb3056      0xf03b9ba8      0x3f221ec0
+       0x0179e54a      0xbbc89034      0x656b1104      0xe7f434a2
+       0xfa45ba5a      0x6c6984a8      0xcbeaaf7d      0xa4bc1df3
+       0x7cd3ebf5      0xf686626b      0x10a80b0c      0xc5c2088f
+       0xd95c69d2      0xd46f9613      0x3b1e5d15      0xce8fdcce
+       0xfd704c9a      0x5521b64c      0x43eb4af0      0x5b34a935
+       0x6ea922dd      0x3bda24e3      0x5b65f22d      0xa48a2b89
+       0x4b00241c      0xccc8c186      0x3b45c602      0x3c48b790
+       0xf74aeae7      0xaa23c77d      0x3abcd620      0x4ae70e0b
+       0x979047c9      0x8eb588e9      0x2317ffa5      0xa401a3ba
+       0x044fcfa8      0x32c15baf      0x3011c3a2      0x1378ba18
+       0x70208ef2      0x614d23b3      0x10597dbf      0xab4cd6c2
+       0xf21220b7      0x09581235      0x0a72028a      0x98b414f6
+       0xdc96530b      0x5d712c86      0x2137e58c      0xe771d436
+       0x7c85cdf7      0x02ed6c5d      0xe0ece553      0x2412c27f
+       0x4b2ddd3e      0x7bed4840      0x3982ddff      0x7dba1c5c
+       0x0df3bcb2      0xaf4beaeb      0x88c9423a      0x0d60817b
+       0x9cd0d431      0x0405c856      0xec53943c      0x59ee2092
+       0xc4d8d0da      0xaa3e8e31      0x39b17698      0x1b2d9a6f
+       0x3a95a7a5      0x09eb67f6      0xc93ae662      0x443a8d0a
+       0xc36df900      0x0c7f6a97      0x325b7572      0x8cf14421
+       0xc00934c6      0x51a37d4a      0x9006c0fa      0xb0faf78c
+       0xefe9d965      0x015a2db2      0xedb51e67      0x964cdc18
+       0xb0164b41      0xfad88d86      0x4f3d324d      0x1fed60fe
+       0x61de37ad      0x0671869f      0xf06b5d92      0x5ffac3cd
+       0xd1dea595      0xc2e4e37a      0x064006b0      0x9d35eaf8
+       0x260f0e58      0x95d9c6c2      0x7409135b      0x8b28e4ff
+       0x7c7aa1f5      0x97bb905c      0xcfb81126      0x7b84551f
+       0x836c7718      0x2f1409f1      0xaaead49e      0x3b34d87b
+       0xab8f041c      0x48356c02      0xa4f9b009      0x793c6506
+       0x99c321de      0x94b8a9bf      0x1ba16b86      0x143278a0
+       0x7494ac26      0x3af964e4      0x2c86df4d      0x7e2b1afc
+       0xaa8351ba      0xfff1001b      0xf86fb46d      0x831e5b92
+       0x185519a4      0x63e6fff7      0x8c3fea8c      0xbb0fbf83
+       0x70760f75      0x484f687d      0xf17cc54e      0x40911d01
+       0xd74f5afd      0xddf8a361      0x02af907b      0xc139a61a
+       0x42e5f4c7      0x672f8454      0x6f51fa4c      0x87d3ac80
+       0xa6c8ebc3      0xb5a5ae91      0x00b791a5      0x605765e3
+       0xdec5086c      0x06987df8      0xb51fbd2b      0x64844b7c
+       0x6d57b01e      0xef8e31ac      0x3f24bf90      0x7ce9bc06
+       0x3f0b314b      0xb256c7d9      0x57f4e962      0x570720cb
+       0xb989c96a      0xc77975c6      0x49e65138      0x30d2b485
+       0xd5e874ed      0x29ee4c78      0x0fb9acb4      0x94a42e00
+       0x8edfb4e2      0xf13d9f94      0x774c4fd8      0x999a5ee2
+       0xff4bb48d      0xae4910e5      0xa23172d1      0x4232b9cd
+       0xdb6119f7      0x8f08d42e      0x5e0025d5      0x895278e5
+       0x15a076c8      0x207a7908      0x869f39d0      0x14caa1a8
+       0xc931cf3d      0xa6d14c0c      0x1ae2bbbc      0x372a5e50
+       0x53705a0a      0x22928d5b      0x792e9210      0x86efac46
+       0xf993df9d      0xa3043252      0xb09621e2      0xb0039d3d
+       0x96f4c702      0xfe730875      0xa10fecdb      0x93ecbbd3
+       0x712ffe11      0xef82740e      0x28314ba6      0x6f17c9a2
+       0xd213f31f      0x1a11224c      0x3a881fb9      0xa82b3cea
+       0x22b85dc8      0xb74ae4d9      0x8108371d      0x6db7cd85
+       0xb6e9db36      0x1d4d157f      0x7d70f326      0x950f4c7a
+       0x1edb2160      0xfc92f6f7      0xd23ae455      0x1d485c8f
+       0x64e9f40b      0x75b2867f      0x96c14225      0xa9166e8c
+       0x85365b71      0x381c7efd      0x440b8b03      0xf893c85b
+       0x090d59e5      0x53e680f1      0x90cf9ba6      0xca147d1d
+       0xd47c140f      0x13063966      0xf2cb8905      0xdecd5dde
+       0xace222c6      0x9c4266e7      0x9d009bba      0xe664ab8c
+       0x4288c71a      0xf26fd966      0xd8851b49      0xf5aa55b5
+       0xc200f1c6      0xf791ffb1      0x2407f953      0x54dbd328
+       0x0f139d60      0xf1a6098d      0x7498fa47      0xdf31fbac
+       0xa038f39e      0xed6f24a2      0xd8da411e      0xe76e76e6
+       0xe1ad6abc      0x82582d6b      0xc81d44a3      0xec3bc54f
+       0x900ed3fc      0xca050e6a      0x3957a6ea      0xeaa469d1
+       0x3661c0e3      0x6d58e5b5      0x54a2d352      0x10aebcca
+       0x62b168f2      0xc70102a1      0x859473bf      0x70faf369
+       0x5614c51e      0x5b91d39d      0xc896ebd8      0x15411474
+       0x1d205429      0x811a2365      0x87231a44      0xe5eb3e63
+       0x185562a2      0xc2eb11e3      0xb1d0c7e8      0x79203d90
+       0x6c6f985e      0xe7a0444f      0x7fc82e22      0xb6e7c361
+       0xa682c215      0xc4f64ccb      0x6abeb869      0x86505184
+       0xf60139ea      0xe870d573      0x71eb195f      0x1a38cf83
+       0x5b8e4912      0xe2ab819e      0x6604082d      0x7b6e2a90
+       0x0e02c29d      0xd173d514      0x24966934      0xa3800a52
+       0x0098bf06      0xedee20b9      0x18d833d9      0xe59dd61c
+       0xacb08e55      0x3cba782d      0xdd926293      0xf7a188c0
+       0xf7eab45e      0xcc952750      0x0db17cad      0x487f346d
+       0x794c588c      0xddaf3aea      0x2fe6db01      0x2e84c02d
+       0x74e74cc6      0x97b87e0b      0x72527094      0x385b44d4
+       0x0c11638f      0x312d4144      0xf8f90a35      0x6fbc47e6
+       0x7a6f607b      0xdad58374      0x5c0f0a4f      0xb3c73469
+       0x57514f1a      0xfa31da75      0xa1b0d1ef      0x8f941fdd
+       0xe483e78c      0xb09a5e0a      0x7ce508ec      0xd8b00395
+       0xc223fff8      0x8b72eca2      0x0cfad036      0x67eaa3b1
+       0xa7c8fc11      0x3e6e736a      0x61879983      0x7756d5d5
+       0x7a917391      0x0259c539      0xa33f65e7      0xd4642153
+       0xfbd1c772      0x5d74b1bc      0x56163458      0xea4eda34
+       0x7f86f55b      0x245c5a68      0xae875cdd      0xc853215b
+       0x45a106a9      0xc69cf199      0x614bef7c      0xd69f7cb1
+       0xc565c1ce      0x4c6e51e3      0xf91e5923      0xb1dc77d4
+       0xf5f50401      0x8559da14      0x8ff79a5f      0x7cabed12
+       0x0d870e1c      0x7f3183a2      0x778c91fb      0xc95d0c05
+       0x4d93e46a      0x22745a43      0xd2ffc074      0xd7558411
+       0xf14c1e92      0x53bab6b0      0x642d75d8      0x96cec842
+       0x97c46870      0xeecb0cd4      0xb949724a      0x245f9a4c
+       0x64a54fee      0xaca6af3b      0x839944b3      0x3879c5c6
+       0x405d0020      0x6ce1bd3d      0xbfb76024      0x821e9d10
+       0x46603579      0xdf02ef00      0x8e6ca39e      0x3cae9573
+       0x9e4e49fa      0xc7429e9a      0x92544164      0x80f5129b
+       0x17389f26      0x6443b97a      0x31236f1b      0x1afc58a2
+       0xfe03e4e7      0xbcd94b42      0x1a829d3f      0xda84e89c
+       0x208b9238      0x359e4156      0x1f8fdbb2      0xae1182f8
+       0x30e87fee      0xe2d41753      0x46b29107      0xa10cc2ec
+       0xd7460f63      0x4588956a      0x0fb13957      0xd9289012
+       0xa0fc3474      0xf65a278e      0x158253f6      0xf8c1b011
+       0xd9dcdc77      0x1fda5bb4      0x7891b4f0      0x96fcc983
+       0x17edd4df      0x32ad3dcd      0x0736215b      0x97cd4037
+       0x125ab02e      0x18d9a4e4      0xf8abc490      0xecf4d028
+       0x1a302287      0xad4394f1      0x79c0d853      0x3043bc6f
+       0x340468e9      0xbd17aa79      0x8bab1522      0x06972cd0
+       0x56004f48      0xe14c4627      0xd8af386c      0x835ae6e4
+       0xac488735      0xde846833      0xea3db1dd      0x059702f1
+       0x19b36693      0x477f9d4f      0xec430c82      0xfc50ae57
+       0xf298fbde      0xdbaa4b75      0xc52031e9      0x22efe51f
+       0x7a7cdebb      0x57d3f00d      0x4b5adbde      0x34be5e49
+       0xcebba54e      0x689741f1      0xfe4c0436      0xc19af52b
+       0x9f7b8786      0xc0205a6a      0x6cef0dba      0x6043d56a
+       0xaa72c9d0      0x6c663da9      0x812de625      0x5b139449
+       0x708581ee      0x634ebbec      0xb92e413a      0x0e07f2af
+       0x8a2d960f      0xdc17eeeb      0x8c5487a2      0x3d1ef2bc
+       0xa3434151      0xcf8b2efb      0x247a1175      0x0c17fbce
+       0xdc936e9e      0xe4dbc20d      0xc0b8b0e5      0x08aea23b
+       0x4ee89c1f      0x715e348c      0xa5367549      0xb9998529
+       0x69ffec04      0x9fed3d5d      0xf915ad08      0xbbf6cd86
+       0xc3bf5c5f      0xdaf8eb80      0xe18936b4      0x7bea5d95
+       0x8deed9e6      0x8bda269f      0x38572677      0x0ca97017
+       0xf61c6c6e      0x494a3cfe      0xac1e80b2      0x4eebcbd1
+       0x132b36e0      0xfc94f6f6      0xed19a471      0x212ff3d4
+       0xb7f51896      0xd1e0d93a      0x4324e9d7      0x6970e86f
+       0x07a0616e      0x823ef423      0x8a7b3507      0xf27efae1
+       0xf2cf470a      0x96e7b4d7      0xaf4be539      0x71de0267
+       0x3c71bcb7      0x14a6aece      0x580fe2f2      0x2b4cfde3
+       0x0271a2b4      0xe4b4b7bd      0x6ab3cd46      0x6df49c00
+       0x9ece36c9      0x067110fc      0x203601e1      0x35b913ca
+       0xa59e0ec1      0x2766a825      0xb55cbd65      0x87a74af2
+       0x9d3a1132      0x070b1ed2      0xaf1211aa      0xff1d7b45
+       0xfb386536      0x6946268e      0xdfa0f226      0x34cdc1fd
+       0x78496e4b      0x77524591      0x210dc267      0x1e0e18d9
+       0x3f74c1bb      0x82264f86      0x7d673793      0x632cd653
+       0x2991d488      0xfa3cb417      0xaf5dd796      0xc5c26335
+       0x9debd851      0xf76cd1d8      0x143216f4      0xc2724aee
+       0xeac39da7      0x153e1ad1      0xa7914a7d      0x2b271ddf
+       0x2926aa04      0x603a72e0      0x37783275      0xd0aef556
+       0x120d0ec3      0x6101fd12      0x5fe772bd      0xa0c2e335
+       0xf2d95ff6      0x1d2a920e      0xd53979b3      0xfa864401
+       0x16ea1062      0x4be6b953      0x045b417a      0x103f12c9
+       0x7bae23ee      0x12126db6      0x9dd1d28a      0x1289efba
+       0x2f6b5535      0x09035975      0xd4ae250e      0x519acae2
+       0xa770b213      0x379af3aa      0x2ce48657      0x012962e2
+       0xea8ebdc7      0xc0728f39      0xfdcba1ec      0x98bf6c2e
+       0x9ee376d6      0x39fea46f      0x19bf522f      0x640ca1fe
+       0x83719a02      0x7b8da0d4      0xe51ff580      0x920832af
+       0x9c86e70e      0x90873199      0x75af146a      0x0222bf8b
+       0x5cfe493c      0x9cdc3080      0x7095af37      0xd255182e
+       0x33a962a4      0x7ea7d9aa      0x09ba2dbc      0x47eddfcd
+       0xeba6412c      0xda4603da      0x8af0b838      0xb72f1709
+       0x1c69a7b8      0x6373dd57      0x094bb8cf      0xa43925c6
+       0x836447b9      0x91387bd9      0xe3dcba58      0xb33788ef
+       0xc6c5b2fc      0xa5b46fea      0xb9a844e4      0xd9288df6
+       0xe33eb49a      0x7cc5cdfe      0xf1fb769e      0x288f7a57
+       0xb97a1e7d      0x0f93cccb      0xbbd28cc8      0x4bf7c0a3
+       0xfa99416f      0x7b28585f      0xb8a8c347      0x28e14ef1
+       0x105f7ad8      0xe385db42      0xb0f22eeb      0x38c72e79
+       0x0b75d272      0xb659da56      0x8fbfa32b      0x5704c44b
+       0x4cc049a6      0x11b9dc0a      0x6e7accd4      0xcd62bd7c
+       0x8d7afab6      0xb6cfefe1      0x3e130f7e      0x3fd38f0d
+       0x15523914      0xee809864      0x5482249a      0x32ae9814
+       0x589cb041      0x78ab8c18      0x8921f381      0x433d6211
+       0x7264a64d      0x7a30a460      0x3cd6bc27      0xc58b63c8
+       0xbb99c553      0x2e71234b      0xd7b1993e      0xe825d9d8
+       0x391e6e19      0x84d69afb      0x1f2ecdfb      0xea7c002f
+       0xa1f8cb1e      0xf0a70cf7      0x16725572      0x96145daa
+       0xdc09b1f2      0x19063e5a      0xf5fb80b7      0x23256a36
+       0x2a112727      0x180221d8      0x726eb9b9      0xffae971d
+       0x93fba90c      0xdd7adec2      0xc0732048      0x48c164a8
+       0x450edac4      0xd6173158      0x2ca3148a      0x43ba4f3d
+       0xe523306d      0xec9ee34c      0x77bd353e      0x58ff6b77
+       0xdc013c26      0xd87d434c      0x11c9c268      0x57788500
+       0x073c6544      0xbf7ee918      0xf5a38c5d      0x655a7674
+       0xf334986e      0x09e7d8d3      0x986d4848      0x9d233689
+       0xd1edff80      0xf97619b7      0xdaa3432a      0x77ef4828
+       0xbc602daf      0x2d9e5410      0x3380b232      0x0ded05b0
+       0x6b26968f      0x68febf48      0x1a4a4c4d      0x58764cd1
+       0xa3a02358      0x3d29a4c0      0x37e2dd64      0x0755044b
+       0x62524533      0x36a53faf      0x64d34008      0xaffc31e0
+       0x91948b29      0x14e6e726      0x8ee97ef5      0x58510482
+       0x1c33b1bc      0xa30bde28      0xfca017e4      0x524d2204
+       0x8412073e      0x83445e4d      0x390d0cda      0x86211393
+       0x524f0e52      0xf343ca67      0x2f062c35      0x4cebeec2
+       0x2d408f93      0x0a3bd0e4      0x48417ef0      0x216447ae
+       0x4368f584      0x204f417a      0xb61cf28b      0x44620f1e
+       0x9fb70e0b      0x37518af4      0x29b612e4      0xe268604e
+       0x1a2ac5af      0xfd0474cb      0x54067197      0xd5d8718e
+       0xe4b6558f      0xf3dbece1      0x72304b5d      0x7a6c121f
+       0x5dd6a395      0xb110596e      0xe8e160f5      0x8234bcb7
+       0x5ec15509      0xbbd4aecd      0xf0d3911c      0xd0092032
+       0x7cabba36      0xa5d2d61d      0x637765d8      0xa940628d
+       0xdd4968c6      0xbe28c171      0xb6341d39      0xa2ca95f9
+       0x62e40d61      0xeb729f42      0x20a75965      0xa0150105
+       0x68989526      0x3a1ad99c      0x5feaf67b      0x6f8e157e
+       0x660a60a5      0x59de9830      0xe3b5c9d6      0x07678e04
+       0x807fb4e3      0x235f26d9      0x041a8b1e      0xa903cd29
+       0x8c4523be      0xc3164dcf      0x87be5766      0x38f94b40
+       0x5fe93334      0x0e6c26a0      0xffa794b8      0x60b60bc1
+       0x4ee6ea74      0x6a11a481      0x70544700      0x918c8bc9
+       0x26152718      0x231e3a6f      0x0da0b783      0x9e5a3b6f
+       0x546914a8      0xe5b80a89      0x0c2cc676      0xb0e7b857
+       0xf0e6b42b      0xdf5e64c1      0x24811610      0x00d553ab
+       0x2978949d      0x5f59a3ad      0x213f4924      0x1aabfc47
+       0x36eada29      0x0616deb1      0x321acd00      0x688950ca
+       0xc78a0101      0xac7bb36e      0xa90f8437      0xb2f3463f
+       0x252b1b0e      0xb4834fb9      0xf4a947fe      0x3e9146ce
+       0x11f5ab35      0xb1301d59      0x01863d88      0x87660b8c
+       0x2e6e3868      0x78b15f03      0x21eb1931      0xc24a80eb
+       0x3b257f98      0xd0fb64c5      0x79840796      0x3c5f197e
+       0xab7f701d      0xa74421dc      0xf338b1c4      0x5d0071a9
+       0x732b7ea6      0x387571da      0x533847e6      0x2119f8d5
+       0xc0b927d3      0x29bf7f4a      0x959a5203      0xc3a76927
+       0x833b22aa      0x35d4ac16      0xead2bdda      0x258afdc2
+       0xa8b0428f      0x86beb83f      0x757ecf1b      0xc3564c82
+       0x8dcd4b43      0x692fb5b9      0x0b9eb8ca      0x7f961597
+       0x2bed27a9      0xa5250498      0xee79df9d      0x923906e2
+       0x8db8037f      0x47098d0a      0xe13cc83a      0x3b372052
+       0x70c3d1ea      0xeac54018      0xe9140878      0xf8bb605b
+       0xebc901a4      0x99eeaa4e      0x76881167      0xba10606b
+       0x5152ede2      0x0b1e4c63      0xaca091dd      0x7c79e765
+       0xf7b2ffc8      0x9f99d4e6      0xb9b5ec51      0x20d0207a
+       0xaceb2f18      0xe07dfc42      0x325c3a15      0xa930c1b8
+       0xbb90db2b      0x421407fb      0x8f6d9923      0xe6dd2721
+       0x5e9e16c9      0x0537f892      0xaab9f93a      0x782a7944
+       0xe7e6cd14      0x4f9f3eb1      0x2eaed2c0      0x4fda4dc2
+       0xeaa0fde2      0x3f0fd6c5      0x401c525c      0x06b3732a
+       0xbf15c559      0xe9f7e0a6      0x59a74bb5      0xd36cbd8f
+       0xa243b0ca      0x2f61aef4      0x6d68d57b      0xb0ac1c14
+       0x45a73388      0xaf0dcbd1      0x8450d8fb      0xd23daec4
+       0x5550017e      0xb29937e2      0x2fa140c2      0xbd9c7d78
+       0xad9d1c09      0x1caaf3e9      0x395e8446      0x9f4975e4
+       0x0d0e247f      0x5222070e      0x9f657788      0xa5c96dde
+       0xf0ced647      0x8bb51ead      0xcd0fdbf3      0x1158a8c3
+       0x83528585      0xf48731a2      0xefc489ec      0x0eaff488
+       0x3d2ab83c      0x75774679      0xcf89a5d3      0x7e9f5162
+       0xdab26e09      0xff6b816d      0xf697d6db      0x7fc9f5e5
+       0x2831c5b9      0x0ed934e5      0x9b014521      0x74a76204
+       0xaf4ab3b0      0xa71a3b22      0xe87a341c      0x74f0c0b8
+       0xec2dafe9      0xc01c0af4      0xf7050a68      0xfe50d6b2
+       0xfee79f85      0x1650d8f4      0x214d2391      0xf7c88ad7
+       0x668c46d3      0x59533b0c      0x5f54aeda      0x2dc0df06
+       0x6f5869f7      0xfe4b1994      0x08aaa3dc      0x900fa558
+       0x43fb653a      0x0113beba      0xeaacd04d      0x48b43615
+       0xecd886dd      0x96bfbf5d      0x197a552a      0xa85fff9f
+       0x9211a5fb      0xba592fd5      0x3292d6b4      0xdc66d6ab
+       0x485a74ae      0xf96dc02d      0x416d2e4c      0x0d4ea7f6
+       0xf3af2a0a      0x761f64f4      0x21a50d7e      0xb58ae772
+       0x8b950a5b      0xcbdd567b      0xb67bf2a2      0x7d5a7bdf
+       0xa19a1c75      0x40d13be4      0xd6ee8566      0x9fada85d
+       0x7ed8120b      0x7c5e6a2e      0x3c063fc2      0x0cc2effb
+       0xe654c499      0x2b6e16cd      0x74e8f50d      0x0b6e074e
+       0x9f51176a      0x2bb2304b      0xe343aee9      0xcd0dd27e
+       0x32ef1461      0xdcc330cd      0x7caf84a5      0xfa5e9903
+       0x711aee04      0xeb68d9e2      0x31453f3c      0x8475d51d
+       0xa49c4aee      0xfdb2c017      0xa567e6af      0xcbfc5e8a
+       0x8b6b7007      0x728ffcc6      0xc17b9609      0x8464115b
+       0x645fe5a0      0x239cee47      0xf7a4986e      0x8843f306
+       0xf70f735f      0x912cb0e1      0xce31ec9f      0x2b185265
+       0xc4261422      0x57f99347      0xe3f69a3e      0xba9581d6
+       0xc526e989      0xfc762593      0x2034f8a7      0x6d19e0b5
+       0xc77cdc8e      0xd04909d5      0xf49383ca      0x7e2abd7d
+       0xf70ce590      0xceaa3f22      0x552d675d      0x70b6bc74
+       0x7ea43aaa      0xce4bb4d1      0x74927b8f      0xa3d99e42
+       0x8ff4a58b      0x0c3fd498      0x2c651f32      0xb01d62b7
+       0xbbde59f3      0x68390ee3      0xc95fafcb      0x631ecfdc
+       0x59ac8f7b      0x1984e67a      0x8e260f0d      0x9e47c602
+       0x8be13c3d      0xe01372eb      0x97d9f3e0      0xfad64511
+       0x47fba817      0x6dc0f7b9      0x963df47f      0x92c74845
+       0x63033690      0xd6ac4bc7      0xeaf5fb99      0x71377223
+       0xf8097e28      0x6f8bea47      0xa481b6c5      0xdb995f83
+       0x6c7b2d44      0xf9f6c0e8      0xef8a27ca      0xf57fb75d
+       0x6d11a89f      0xd77c0024      0x8e3c9a89      0x261086e4
+       0x4020a760      0xd605584e      0x2bb7f5e0      0xeebcb006
+       0x95d2d695      0x7607fd40      0x8ad28c1f      0x435f2276
+       0x15be5c7d      0x7f48aad7      0xeac85de9      0x43bb9a8c
+       0xd72cb4a3      0xc89f19c0      0xeb0370f4      0xed388bd5
+       0x2852edc1      0x7a3c57bd      0x64069891      0x3c1f97de
+       0xf776506d      0x9d850084      0x9b6da920      0x9a0ea68b
+       0x5733e264      0x985d690a      0x0bca00b1      0xc4bee308
+       0xb334e18a      0x94f06ace      0x53af49ee      0xf7fa352d
+       0xf6cebae1      0x0b1603b7      0xdaf6b77b      0xda7610ca
+       0x37e8f1f7      0x65543d19      0xc686e7f9      0x15e1c891
+       0x948519dd      0x458e8f93      0x2d9ef49d      0x304674b1
+       0x53085c5c      0x44a03f39      0xdef55225      0xa0f6c617
+       0x4eaefd51      0x24684b23      0xf63c9075      0x16e263fb
+       0xa4c48573      0x0373f4ab      0xec8eb293      0x58ba3a0d
+       0x82b0d08f      0x39edb7ef      0x7e3cc645      0x0636a024
+       0x4f122bec      0x704bd650      0xe868d5e1      0xd8dc27ad
+       0x4d77ef4f      0x8ce4d4a3      0x9f89b625      0x738fd2a4
+       0xedcedf8d      0x9ed7d690      0xd0d59278      0x47f4d74b
+       0x9ac7a3b8      0xe05a305c      0xcf1e3bbc      0x25a3aa55
+       0xca35f9ff      0xf166b9b5      0xe0d8ee15      0x13cb8aea
+       0x7f38eeab      0xeb912609      0x0559e521      0x00e2c1ff
+       0x158e636f      0xb11fa6b5      0x7be5172e      0xfa73e5ff
+       0x54f696d4      0x2cd7139f      0xccac7bcf      0x1f80b6d8
+       0xcdc72706      0xed512f44      0xa08a1e61      0x53029c66
+       0x6e487983      0x68f33e28      0x3d0201a6      0x33dffbf6
+       0xe2966708      0x82a52ec2      0x59be5082      0x0a6d7116
+       0x056a734c      0x666e9550      0x239fe9b7      0xeb9d0b3f
+       0x8ed2ed08      0xa8c050ff      0xcc5b7c97      0x7f95d3b2
+       0x62ff19f7      0x2fddd0e1      0xd98d2e7b      0x1845e12e
+       0xaf5005b2      0xfb23d7b0      0x88436356      0x4d470db8
+       0x63c4998a      0x737e94a1      0xfb941048      0xe68fa02c
+       0x16354fd6      0x79c7efb9      0x75db8260      0x44a7ab3e
+       0xfa938bc8      0xfe0b7768      0x2c58fc07      0x8879d81d
+       0xcea91771      0xd3165fc7      0x66c34a88      0xbe20fa3f
+       0x27d0d961      0xe37fb590      0xa6e3552b      0x7dc2183d
+       0x9518736a      0xd17d4490      0x379754d7      0x48251d7e
+       0x890779dc      0x34179395      0x33cdc5e1      0xd2720374
+       0xa791b9e5      0xd867f4b6      0x41e33789      0x8a4ff733
+       0x1244e370      0x945fde91      0x71190686      0x0cdd82ba
+       0x0500ed15      0xac742cb1      0x21140d8a      0xf77ae76c
+       0x60c56f1e      0x25e8be7a      0x79172631      0xf61b7c83
+       0xdf196cd7      0xda0ead95      0x33973a33      0x88ae98af
+       0x6e1c15d3      0xb5fbde6f      0x546f8042      0x2182306f
+       0xc6522278      0x423b3013      0x72285817      0x4fab2968
+       0x4b161e43      0x1b51ca55      0x3f116c62      0xb05bc43b
+       0xf9823867      0x317fe905      0x5207a0c0      0x8054de48
+       0x9133dfe7      0xea6d06d1      0x9608c446      0x65e4673a
+       0x9cc5ed15      0x1acc3ec9      0xfbd8c96a      0x9b61922e
+       0x9b1c9340      0x66930cf8      0x4d3a3f80      0x1d7b8984
+       0x000c8706      0x3d6415bc      0xa02471ee      0x37e3aff6
+       0x317c60b5      0x1a70773b      0x3cf6c5d6      0xa02b7480
+       0xb8326876      0xd9440bf0      0xb50c7e17      0x7efd080e
+       0x81e040ba      0x345c6c2e      0xad108c52      0xa46660e2
+       0xdc2bdcfe      0xf989daf7      0x2379fc1a      0xf7cbdd78
+       0x10e91f76      0xcbfc5f59      0x621190fd      0xe09ac09c
+       0xb0f5638c      0x6f01afaa      0xc21a1192      0x62368336
+       0x0ddf28f1      0xcc9e1b7a      0x9999417d      0x8245f48c
+       0x8cefd598      0x265c6156      0x57f27601      0xaf2aa76d
+       0xc3fcfa23      0xe3f760e7      0x1d4ee5c0      0xa81c3bfc
+       0x5fdf7011      0xbb4690e6      0xebb97ab5      0x6a974cd3
+       0xab9a9b97      0x2cfddcc1      0x0e2cf4c6      0x9b57d858
+       0x775d7bcf      0xb570d19f      0xf6c157a6      0xf7824940
+       0x35fd56c0      0x40c9fbde      0x8ea2f072      0xcd586ea6
+       0x76910fc2      0x620c098e      0x0127acae      0x3684f504
+       0xa1074e97      0x82236db1      0x7ccb5145      0x21a19687
+       0xa2e71c52      0xcd0e97b7      0x0d066665      0x886daf7b
+       0xbf80deea      0xd520e82b      0x27347bdf      0xc188e967
+       0xca9c977e      0x1dab26d6      0x611075c3      0xba72afc3
+       0x7e8b24ab      0x41851352      0x5c39f911      0x337b7a3e
+       0x54930066      0xf9d23e95      0xeddbe967      0x58eb6d77
+       0xead74bb4      0x2680c817      0x3422d2ad      0x7e859df6
+       0x48f5d7c6      0xe99d8d30      0x933a6fe8      0x69d867d7
+       0xbf99b2b8      0x52999aa7      0x49061bd2      0x62d38cab
+       0xcb506f14      0x64f70998      0x930c9a16      0x9d7f6c86
+       0x9afabed4      0x95aeeb53      0x1a8dd19e      0xec4394e6
+       0xd9e65b47      0xc039016d      0x9f4cd03b      0xb9747818
+       0x5645c4fc      0x9e8a1b1d      0xe39db149      0x84aa65a3
+       0xa5ca8b42      0x8fcf92ab      0x2c9e05fd      0x28086215
+       0x4bcb0ff0      0xf343a34c      0x9acf6baf      0xab1305c3
+       0xa06b0c1c      0x093b8a3f      0x540f25d9      0x1febebcf
+       0x7eb7c479      0x2f53c430      0x922ab0f5      0xd87836b7
+       0x19afbc61      0x2b2005ef      0x16b352f4      0x277c780f
+       0xdaef65f3      0x4243a4ca      0xea43dc8c      0x436947d8
+       0xcc6603e8      0x57820111      0x02e56b1e      0x8fd8aaf2
+       0x3684e49a      0xa325174c      0x572f1a3b      0x5637616b
+       0xdde1b5d0      0xf41e1230      0xa065b5ef      0x924062a2
+       0x9e7668cf      0xdbbb4fd1      0xae246951      0x8c911834
+       0x216c51d1      0x72f09e16      0x2e2bfb24      0xf188bca3
+       0x0a24f9ef      0xde8293c1      0x6c0e5701      0x6d198fa7
+       0xf397a4df      0x3f43f5f6      0x853a1a0c      0xe403aa64
+       0xfa99f021      0xad503e90      0xb3d701a7      0xe3d8f0f1
+       0x3efbeb0f      0x4d0113e9      0x6f761b7d      0xc25933d9
+       0xf4d95337      0xcbc62eb2      0x2aa92dca      0x8e307eb3
+       0x13457ad8      0x3379ffa6      0xe4627155      0x4864b238
+       0xdd21687d      0x6a03410c      0x19e4117e      0x2f80ca4b
+       0x1f7aeb84      0x74ea8637      0xd2d012d0      0x5a4813c0
+       0x6ef1f7d1      0x4ddd81b9      0x50ce0a11      0x3b041b1c
+       0x13dccd88      0xfdb229fa      0xa022213b      0x3ee6a47f
+       0x1f6e5a42      0x43819409      0x100d5564      0x616985dd
+       0xdb1863a7      0x8307c69a      0x10c4669b      0x52ccfded
+       0x263b8522      0x8a9ebbeb      0x9073cd01      0x8981677a
+       0x89482c5f      0xdabf771e      0x504029f0      0x1afeddfd
+       0x66d60db6      0x6d363a56      0x6cef1a1e      0x3c1e591b
+       0x6171aacf      0x682d10bb      0xe33a69f0      0x25ae610e
+       0xc654eca0      0x89a45111      0xc260e041      0xaa362e1b
+       0xbdef7635      0x6fb8e062      0xf423b995      0x300517d7
+       0x915b9335      0x0cc0f76e      0xe57a9c9a      0x0c1350cc
+       0x4c513c38      0x7e1a748e      0xf52959fe      0x732e8fb1
+       0xaa2168f7      0x68c80276      0x274b912a      0x5eef44be
+       0xaf68af03      0xa6da203c      0x039a37ce      0xee588967
+       0x88493109      0x7cc5f0e0      0x24462d6b      0x50bd0093
+       0x95f4c6ac      0x967feecb      0xb45790d5      0xe2614002
+       0x4518e7c5      0xf76553e5      0x426196b0      0x310ca300
+       0x0acd9552      0xdc34ec49      0x6db7f336      0xf5118fef
+       0xa0e714c9      0xf019d044      0x11676c8e      0x921b6d42
+       0x845c2453      0x1abdec4d      0x0ff24ab3      0x345228ea
+       0x2dbe50b5      0xdfe58c96      0x9fbebeaa      0x3be8a949
+       0x197dedde      0xcd3684af      0x06809433      0x86aa627f
+       0xcfcae4e5      0xc679a594      0xf450dc29      0xf2eeb175
+       0x16779ea7      0x8215f5e8      0x89e2645f      0xc383c018
+       0xbdd3cfc7      0xff7437db      0xf9b533fd      0x02286fed
+       0x44b2c92d      0xbdb4d192      0x49c254f2      0xe3557372
+       0x1089cd56      0x38340ef0      0xe13baede      0x300aaf1d
+       0xfa3fc9c5      0x4b650f9f      0x11fe6203      0xe800e034
+       0xf0cc4cd8      0x27cbe017      0xb14a81d3      0x4ad4ddfe
+       0x446c75fe      0x323e02c9      0x6d016a6e      0x553f0976
+       0xaaa44ad8      0x128d0633      0x332b6480      0x1c7df1d8
+       0x29fb33dd      0xdd05be19      0xf1362330      0x4c1ff5d2
+       0x03f5c2d3      0x640d999f      0x17b9b76f      0x0d6f9443
+       0x02068a98      0x0a8c22c4      0x315c11de      0x7cb2ba2e
+       0xb6690193      0xa4cff098      0xcfb40359      0x451d893b
+       0x879d6fce      0x9e7b6e55      0x194bac1b      0xcf07f492
+       0x6592ca51      0xf84f8627      0x39ee7b5b      0x7f1b8b1a
+       0x6494f7df      0xa2399763      0x535ef299      0x0658e6cd
+       0x9caae527      0x4f8dc441      0xf65e4816      0x4621f73d
+       0x8dc77080      0x1552b397      0x5e8dacb6      0xb5933d67
+       0xcd1d927b      0x164f6f00      0x1f738876      0x86a76ed0
+       0xf45ca72e      0x7cfbaf96      0xaf7367eb      0xe275e364
+       0x42aecc6e      0xe604af50      0x42e07bb3      0x801b7545
+       0xb4d64d5e      0xa08cef19      0x964049ee      0x5835723e
+       0x131d82f1      0xc103706f      0x063a6540      0xbf7b57cf
+       0x6e6922f8      0x801a4b44      0x175b0d51      0xd5f86627
+       0xdd768668      0x01901c05      0xce457970      0x03256309
+       0x70467922      0x608debbc      0x9aa21133      0x2b909bc5
+       0xedde72aa      0x8d25f831      0x2829a85a      0x7f75e448
+       0x953cffba      0x8f915fbd      0xef80339e      0x2a78441d
+       0x75970293      0xa1ffca03      0xa5a0aee3      0xeb418444
+       0xc3c445d5      0x4b29e5ba      0xc0e1bf83      0x752a326a
+       0x6670c3d6      0x997303a1      0xdb209170      0x0b299b5f
+       0x386f128c      0x6515d39e      0x7eebd563      0x02cdc722
+       0xf4b9c3f5      0x34ec0dd9      0x8de5276e      0xe6a9fe94
+       0x62fab877      0x7e226252      0x0e52a7c7      0x4b149f47
+       0xc224bb17      0x3b620b7a      0x1fa38337      0xdc6e8d4d
+       0xf092a7c5      0xf8975ee9      0xa1429c9c      0x738f47b9
+       0x578811fe      0x07924ff5      0xaa297dfb      0x09d6e5ea
+       0xd7592072      0x60f82913      0x3aec8f95      0x29693f8c
+       0xf35376e2      0xf02d92cc      0xdd164d60      0xfe77007f
+       0x448d2920      0x4d2a0294      0x640a8485      0xbfe0adee
+       0xf3c65bd0      0x6eff81a7      0xf40f7553      0x0d7ba205
+       0x6cd44c39      0x07f12216      0xfb3bc77d      0x3fe5fb77
+       0xd5bd0732      0xc6885d83      0x0d0a24c9      0x1dea68fd
+       0xe8c2bbfc      0xdb490964      0x3e3f588a      0x1d6a1b90
+       0x0c469d22      0xae70cf7b      0x0da9f1da      0xa4788941
+       0x6a26e4fe      0xe9c758d8      0x453d3658      0xf5494548
+       0xe8b45b8f      0x6ced8b96      0xdd1b23b1      0xb47dd705
+       0x4bfcba7b      0x9af7491b      0xb494c68c      0x5cfb45c1
+       0x7a35d9b3      0xbf38ddd7      0x4754701f      0xd9c8112e
+       0x6a70e7f3      0x1a24da3e      0xecea6c6e      0x5bb93595
+       0x6581512a      0xf68008c3      0xef1f8166      0x7cf46642
+       0xffaf4b05      0xe74d4d21      0x533940a7      0xae8ee994
+       0x49f8fb20      0x389ae800      0x560d68f6      0x4b8a2926
+       0x65c73b0a      0x937b05d4      0x5e59aea7      0x4cafa104
+       0x076776b6      0x41d8f8c9      0x6afeea79      0x16d628da
+       0xfda2c80a      0x98572779      0x001e4fcb      0xd6672844
+       0x8dcbcecb      0x4718ea41      0x086c8351      0x672e4521
+       0x7a732a66      0x4102f8be      0x6d18d08e      0x31b3d5b3
+       0x6e7dbb6c      0x183a8308      0x7e76e8bf      0xd54a0dff
+       0xfe33db5a      0xe1664c0b      0x134c522a      0xfece5c3b
+       0x7ec2904d      0xbcfd91d6      0xc0184efc      0xb0560459
+       0xb459e42b      0x3dd1ae43      0x00d9a77e      0xd40a5c64
+       0xd91ebe29      0x72ee9953      0x597900f2      0x6a0aa8a0
+       0x7e77488d      0x3b2586c1      0xcbcf3d8d      0x9b0b455a
+       0xa56e7390      0x083ff321      0x51474f51      0xe5a907fb
+       0x7d628be5      0xa565bc2b      0xc6256826      0x5d79708c
+       0x90d19d77      0x1c7c6882      0x3c0be314      0x05ea3445
+       0xf5952862      0xab0ebf30      0xbbcc9ec4      0xc7fff7ed
+       0x90d37bc5      0x96d4c910      0x4485f0ec      0x76f9c631
+       0x1dd5be8b      0xa1dcb450      0x626046d4      0x221754f1
+       0xa97f0458      0x31e83e12      0xa427c11e      0x7468109e
+       0xcb6eaeef      0x2e058d78      0xbc04c9e7      0x9777fe44
+       0xdb3213a1      0x1b9666a6      0xabd44b84      0x937f3f8a
+       0xd49cf16e      0xbee28cbc      0x60614201      0xa2e1f810
+       0x39e3d84b      0x22608ab8      0x5b7863de      0xc72765c0
+       0x7ec5828c      0x2d75d36e      0xc4010be8      0x5f5b68e5
+       0x5ef45410      0x195c4116      0x4256c573      0x17d50ede
+       0x1e573bfb      0x1b59ecd3      0x54480efa      0x32a34ff3
+       0xc38c0de7      0x3e652d7a      0xa44b7a6c      0xc5dd3f95
+       0x629d5feb      0xfb88efbc      0x4728814c      0x66fe7cc5
+       0x9cb230bd      0xf7057e54      0x9f5b9e0c      0xc5bd4bce
+       0x814ad3d5      0x884a0e61      0x9674f3cd      0x6c6421a4
+       0x0995c4a4      0x221ddfe7      0x84321c08      0x088f66e1
+       0x34bd791b      0xb7e7bd74      0x959aa379      0xcf13236b
+       0xadeb8d2b      0xdcf10c07      0x26120d8a      0x8db10bc5
+       0x8634eedb      0x20b1a438      0x9ab7fbb4      0xc410113e
+       0x224590f0      0x8bb37412      0xe1984da2      0x8c408790
+       0xa448cd00      0x271c33f1      0x27517460      0x4504d470
+       0x8bec55f0      0xa270d7bc      0x2439c3aa      0x7ce149dc
+       0xebd28de6      0x609a17be      0xed9ba31f      0xaf6dc664
+       0xa9e6ea45      0xaa9663f6      0x6b1b922b      0xf1e17fd0
+       0x4034243a      0x45a6ece0      0x3ce2d430      0xd183ccac
+       0x8f12feda      0x3e239159      0xd2ddf668      0x98aca550
+       0x6107dd44      0x8c147cec      0xd16a5728      0xfd2b1a82
+       0x2b64af60      0x15e58a78      0xe5f275cc      0x43d368fe
+       0x6a3b27f4      0x192bf12a      0xcd7c0fe6      0x268493d4
+       0xd776b540      0x980064c1      0x93d1e704      0x096531dc
+       0x2510d58d      0x0066b674      0x7e198a0d      0xb7ae5756
+       0x503438ef      0x0a216cef      0x2e36e854      0x745d482d
+       0xa68073d1      0xffc69681      0xe8ac33f4      0x5138bdf5
+       0x78edae2d      0x9b0207a1      0x84068e54      0x6c2a1c5e
+       0x1d71cf25      0x0e26ce26      0x1c54fde5      0xfaf67c3e
+       0x512710aa      0x19e5354c      0x87026ba5      0xaffa131e
+       0x6b596c39      0x52c9f36f      0x289b6593      0xc5f9ef86
+       0xd7ae655d      0x4206ca55      0xdb951f6e      0x16e4affe
+       0x18c48716      0x4cb5fcfb      0x8fa56b43      0xf327990c
+       0x0e13ba6c      0x67a0ef83      0x1d065b0d      0xd5a24553
+       0xdbe215c5      0x91059feb      0x404ebfb3      0x01b1c277
+       0xb6b52400      0xbeef28be      0x2bc8b218      0xdd48cc2d
+       0x1cb29493      0xae670c34      0x858d574f      0xc7c97cfb
+       0xcb28adf4      0x023c1237      0xb2d94d3e      0x8dbdc045
+       0xfa3fb17d      0x004317ad      0x5e364b6c      0x4acb5af4
+       0x7cd6c12a      0xdb5badb7      0xba52b526      0x847aa1bf
+       0x89caf467      0xebb3cb1a      0x187e737b      0x947ccfd2
+       0x39bfb21b      0x5d09d8e1      0x92b51af2      0xdca11b41
+       0x33b8cea4      0x278c02e4      0x6c5f03c3      0xdd1a015d
+       0xa582a543      0xd47c8c41      0x548b2cd3      0x9c0edeb0
+       0x4f0743a2      0x6ef8f3af      0xf7af7618      0xf97bb1ac
+       0x685e8540      0x5f0a8f0f      0x5f0e7a13      0x4fd44054
+       0x700a8769      0x20d1e116      0x4c690868      0x8fa65bf7
+       0xf9b66a9d      0xe831b46d      0x433bae59      0xcb6e6cbf
+       0x50654683      0xb238f14e      0x26ca9db9      0x47e4b283
+       0x0a8c9ccd      0x39ed7eac      0xbadf3717      0xfecc2ff2
+       0x70391a24      0x67f0eacd      0x7b3b7a0f      0x2d2ff26d
+       0xbb0c39c5      0x79e6ab3f      0x9b9057f9      0x48f80b77
+       0x5a56c234      0x813d5693      0x38b89f5e      0x4796c04d
+       0x4e97f25e      0xe50d30c1      0x12234407      0x6c8dad12
+       0x0b1f3a1a      0xe8a702f1      0xff58e3b5      0x3b19fec5
+       0x38ee9d2d      0xc010c2df      0x5b202285      0x12c2de1e
+       0x7fd9cebf      0x457e23f2      0x450cedaa      0x6be3372f
+       0x39fdade3      0x29695b61      0xbeb64e0f      0xf20924cf
+       0x0753deec      0x2f9976c6      0x0290c605      0x11c201f7
+       0x84d75507      0xb5841a27      0x38807eb0      0xa2b11285
+       0xedf44510      0x328361d5      0xb0a1b901      0xf884caef
+       0xf07b1793      0x8443bd4b      0x4276720e      0x209641d5
+       0x60f2ceac      0x18ce689d      0x892324b7      0xb8c01b12
+       0x8048c41f      0xbc7225ff      0x4218152a      0x42fd7bae
+       0xe7f366dd      0x2830f720      0xc4244414      0xc7df5be8
+       0xc153ae0c      0x73be7387      0xd29d61de      0xe30d5e5b
+       0x7fb8f223      0x2fa52560      0xebc9426c      0x0eb8b322
+       0x533f6f0b      0xa24bfa03      0x505e00c8      0x8e9dd157
+       0xdc30e0a4      0xae5a3b07      0x4a5e6a0d      0x109d0459
+       0x30c81909      0x3d55e967      0xc488753c      0xc49f321b
+       0x6de5f2e7      0x1a1d1c96      0x2ae59844      0x112e506c
+       0x2c30d253      0x85ede4ec      0x754d1fd7      0x81d482a7
+       0xf6f5c2eb      0xe503851c      0xc01a9d79      0x576247ae
+       0x173f9b25      0x966c7d13      0x36e630e0      0x2b4d2cbb
+       0x720c71a2      0x34ce91c2      0x114ca19c      0xec5652dd
+       0x24879c10      0xea4b5c84      0x44e0df80      0xc37b111a
+       0xbec615ed      0xc28c2a42      0x65acea8e      0x5528f54a
+       0xc84fc58c      0x0518ee18      0xfd526aad      0xc3157b18
+       0xbffd0cd3      0x6df8808b      0x55448199      0x967a5e00
+       0x38dc1d59      0x538d4c30      0x77cf5e5e      0xdb55cfa8
+       0x86e6ee1e      0x8d346609      0xa5064cb2      0x70fa9d18
+       0xf11f22f6      0x219ff257      0x79de0dca      0x80b3db54
+       0xfc70c85c      0x2348db5f      0x23f6021c      0xf5952b70
+       0xf06e674b      0xe054c30c      0x43a11435      0x900be73b
+       0xf56770b8      0xebe25ca8      0x22dc92fa      0xbc176ee8
+       0x37120781      0x7a500cc5      0xd722846f      0x4c9cbd62
+       0xf1a64901      0x948babc0      0x1cbde746      0x039baf4a
+       0xa5cca155      0x86fa1fec      0x4d68bb4f      0xff03e0ee
+       0x718421c6      0x7c6ea458      0x5cc348e9      0xf03a7668
+       0x6e3cde6d      0x07e30f3f      0x3bed4328      0x12602444
+       0x4a856ccc      0xae33fbe5      0x3b0ed600      0x273c8f79
+       0x65b09d6a      0x70e6283b      0x076ad0d1      0x1d4fd208
+       0x2fdec84a      0xefebf7cb      0x7e1695e9      0x614a8135
+       0xf15cebb5      0x3c8bbcec      0x7d80ea11      0xf121cb60
+       0xbe86b223      0xbf110618      0xe2133e26      0xf0b9be4b
+       0x128362ea      0x6d1ef4f9      0xbdc1503f      0xc5034aae
+       0x1c6c8c93      0x42382a5f      0x4eee4ebc      0x4b01405e
+       0x6b955540      0x35a5ce76      0x0bbc7308      0xc6f93aa3
+       0x47592a3f      0x8e15c9be      0x3638ccce      0xce451ccc
+       0x47a8f7c4      0x704b544b      0x14aa2d83      0x9a2654e7
+       0xe039d8be      0x0e455719      0xecd0df67      0x120407be
+       0x182da157      0xeb6a179b      0xed355d72      0x3c257780
+       0x9f3c8cb7      0x5f616cbb      0x1481e558      0x7553ed2c
+       0x23eeb069      0x3d01e25b      0xdef0ddc9      0x6e2cd5f7
+       0x647e1abb      0x238e7a32      0x3dcf5e83      0xe2846a76
+       0x2ce6f198      0x6e098976      0xb32c4bbc      0x0c609f72
+       0x80e51839      0xc0211309      0xa275bdb2      0x19a4c253
+       0xbbbaf32f      0xb30fcdba      0x42540b28      0xcd37e774
+       0xaafc3163      0xc04a9765      0x407a88f6      0xad963e85
+       0x57bf2884      0x3fa8ee53      0xaca0b232      0x56cb8c74
+       0x388a92a4      0x5d626db7      0x45288612      0xb251ffbf
+       0x8bacfa44      0xc8377aee      0x54c24b7b      0xd4cc4f01
+       0xd24c5405      0x4896ce50      0xcbb742b0      0xff5254c1
+       0x64c6a97c      0xccae56df      0x16a3df23      0x94a8ac74
+       0xdc3ca70d      0x56f0783d      0x25457d7e      0xed9fb6b2
+       0xdd060008      0x87de48ee      0x7768fb20      0xab0b8928
+       0xd54d723d      0xcb0b9662      0x939f90f9      0x3c22ca70
+       0xc3a15312      0x5c28761c      0x9b161ab5      0x13bfa903
+       0x18cd22a4      0x81c81042      0xcb47aaff      0xbffef159
+       0x60647a9b      0x7a92332d      0x3513e6d0      0x4a57cfa8
+       0x1fdf8cba      0x8c64f66c      0xad9e592d      0x48735537
+       0x00bf32f5      0x2e7027f3      0x950d228c      0x4e165f08
+       0x2f1c80fc      0x22960f94      0x7b34613d      0xaf0915e4
+       0xce08b0c7      0x02735e3a      0x93be6c24      0x0c50d55c
+       0xd01bf90b      0x9a7556d4      0x53339513      0xcaceec9f
+       0x9a030ed8      0x09eaf6ed      0x6661d8c7      0x7d7da4f9
+       0x1faabbc7      0xac7a1dcb      0xe399d68d      0x768e06d7
+       0xca5bc562      0x5d003bf6      0x1383c5eb      0xdb3dca81
+       0x6b540929      0x019fb800      0xe33df97c      0xfc6a99fe
+       0xcf9bcc4b      0xc205bb4f      0x47361ef6      0x04e3bec9
+       0x157e5528      0xd917a78e      0x366bfc27      0x266f0f6c
+       0xdaa7f21e      0xbc1d624f      0xf28390f3      0xb108917b
+       0x7e35b05f      0x7f2262f1      0x2d75b99c      0x5bc7efb3
+       0x74ee3105      0x15898886      0x36b4504d      0xad4dd74b
+       0x48c5ebff      0x77e328ec      0x5efdcf20      0x83545597
+       0x91341c7d      0x7511a4fc      0x27ca55bf      0x37e60261
+       0xb99a201f      0x1e9ab357      0xde6e0c0f      0xcb455f36
+       0xd5484cac      0x326c85ce      0x06e7ae26      0x175d73f7
+       0x16b02181      0xf813ce0c      0xa64b745a      0xb7d2a060
+       0x98b8dc04      0xef32243a      0x6757c776      0xebe370ee
+       0xc6538383      0x6fb50ccc      0xd4bab51d      0x1e63963a
+       0x09fbc9c2      0x6d5df610      0x5c746f19      0x71f2c71b
+       0x090b6433      0x86e081a0      0x2c5a0070      0x2153667a
+       0x675b4038      0x8dbfc60a      0xe1072f2a      0xea5f0bfb
+       0xa28bfc93      0xebc5301c      0xe1a1e78a      0x712ce3c6
+       0xef9f1344      0x80bdaa8a      0xbbf33885      0x494ad260
+       0x9ee45bd3      0x128e8e7b      0xf3d8b85e      0x53fc396b
+       0x4b8c827e      0x50b2712f      0x2d0ae24f      0xb8b4f332
+       0x66e0296f      0x2ad04f99      0xccbf2e14      0xf379e4c2
+       0xff478955      0x59562633      0x209b944f      0x893ae6ad
+       0x02d470b5      0xb47a4202      0xab6d1fd7      0xb6d3c83e
+       0xedc60d3b      0x95295d01      0x87738018      0xd97d960c
+       0xaa422790      0xf6699b61      0xf2303963      0xa7351d80
+       0xcd8c4f0b      0x15dbe9f0      0x83f6a7b3      0x9f96679f
+       0x95c9df3c      0x2c169b44      0x5bf5dc77      0x7a0b3d08
+       0x66f9fdd5      0x2560dca2      0x471fc548      0x9f08d7d3
+       0xc332d164      0x79d01010      0xd45a6f95      0x675ebfad
+       0x4c9bedbd      0x71d1114c      0xcfc0ec8e      0xaaf9e774
+       0x24a90f2b      0xd5d91761      0x2837c02b      0xaf19d25c
+       0x0bbea611      0x3cb1f264      0x2aadb290      0x87a042a2
+       0x159432b6      0xfdd157c6      0x9733f6fc      0x5655cf79
+       0xfc4f3b68      0x0972c723      0xd24350b7      0xe7009360
+       0x58ee87dd      0x4546cf9a      0x544e3736      0x53e99f0c
+       0xc98bad91      0x3f6b00ce      0x937d1d47      0x6a01953f
+       0x9f90a788      0x2710e7d8      0xbf1e6ee0      0x73c8492c
+       0xff751279      0x83faef5b      0x0f1a2031      0xb75ca4ad
+       0x5f902083      0xefd1e091      0x889611ab      0xdc82b8f3
+       0xb279a44b      0xd5b9b532      0x88a072a4      0xe51ac937
+       0x33c11692      0x1181205d      0x7243c3cd      0x1c56b1a9
+       0x8d6fc2a1      0x1cefd081      0x0e64013f      0x87ad78d1
+       0x1ef30d55      0x0618d07b      0x3ee5266d      0x1bbcfcbf
+       0x0cb57971      0xb75f3c41      0x8fd00c72      0xdaf44c98
+       0x03de4cfa      0xa357a679      0xfd542b0c      0x925109ac
+       0x4ca787c9      0x0b993b77      0x87eab730      0x8de32379
+       0x847fbdc5      0xf0174257      0x3b0ad1bf      0xcf178268
+       0xbf6700e2      0x257f75e6      0xdff9d993      0x4ff499af
+       0xe802373e      0x3838a816      0xcbc35a81      0x0e8b1340
+       0x045929f2      0xe15ff9e8      0x16ab3901      0x39dec822
+       0x47ed2875      0x08c6bbc5      0x78d52b68      0xe466065a
+       0x2cbe9d82      0xf58f833b      0x02449574      0x8ad9b17a
+       0x3a1e011f      0x320a1562      0xd5b6802e      0x813f3658
+       0xb3db879d      0xed919f67      0x2c0785bc      0x93a26355
+       0xaecc370b      0x2ca7f04d      0x97719081      0x6a669285
+       0xb1d195ed      0x356c7f57      0x3f936cec      0xe460e4c3
+       0x27def91d      0xe6737c41      0xef4e98fc      0xd1afde9b
+       0x52227e09      0x38e5ba02      0x218044b8      0x94186988
+       0xd3e1eaa5      0x5cf5d996      0x912b743e      0xaf49f9aa
+       0x360c9f32      0xe73239e4      0x1a5aac4d      0xc12baff8
+       0x8197b9da      0x5e502643      0x84304e2e      0x7d4c2ef3
+       0x12071f6a      0x185fd504      0x7ba2499b      0x765e5946
+       0x8d49bbd4      0x4efe6bdd      0xb3ffa885      0x416203bc
+       0xefd9a99c      0xd08eaf8e      0x64c47468      0xbcee7fb2
+       0xc5c51826      0xcb39dddc      0x64cea8c4      0x3eb81ba0
+       0xdbf9c8e0      0x2f814b49      0x5996b631      0x3fff8af7
+       0x620ae7f1      0x690b65d5      0x9721a28c      0x0f4cc20b
+       0x5583d487      0xdb1dc861      0x27df4591      0xc3e58f7f
+       0x28f2a028      0x6a6c4ebf      0x4b870531      0x4c12c647
+       0x09a132c7      0xce680bcc      0x824cf254      0xd9f325aa
+       0xedf92efd      0xa3f77c96      0x84ad8877      0x07b87e24
+       0x8e2c387d      0x9dd2c896      0x8ce2988b      0x3925b20e
+       0xea941641      0x4ed0114d      0x26ac9814      0xb205b9f4
+       0x06fcdf4c      0x9ead52b7      0x9459d02d      0x805e3afc
+       0xfa091424      0x3d051e1d      0x4a5c54cc      0xcf88e38b
+       0x11ea2014      0x4bff0b62      0x0052671a      0xe23ea1c8
+       0x75841379      0xd0a63f01      0xf982e2e8      0x9227dd6e
+       0xe43ba560      0x78b9b135      0x80a03436      0xb1c7140d
+       0x8d111a1f      0x7c2dc94d      0x8a1b8729      0xbdd38258
+       0x26189f8f      0x284e3dac      0x69c9f930      0x08a7acf8
+       0x501b5c5a      0x0403c670      0xfc24c437      0x44183671
+       0xe73f8de0      0x0f56788a      0x58193016      0x4d469d28
+       0x1acf7ffd      0x261b1d61      0x85febc2f      0xbb154bfa
+       0xaf318d11      0xa8aa8033      0xab45346f      0xb5fc7f83
+       0x0f7a4f6c      0xd04e77bf      0x661f2bfa      0x9cfb806c
+       0x29fd1005      0xdce6fdd3      0x7ee299f4      0x9eaa0b7d
+       0x9fb4269e      0xb6735111      0x7142d9b5      0xb53f2055
+       0xf54c77a3      0xbb4d9ff7      0x29902d61      0xfaafe9c3
+       0x80413515      0x6a1c2761      0x1a94be4d      0x51064621
+       0x302f1aa6      0xb00aefcf      0x1645e87d      0x063a0fed
+       0x23e22926      0x892093c9      0xe7992dbe      0x60a5fe9c
+       0x07098d08      0x389cfeef      0x5fbe161e      0x57f58240
+       0xdf5096ef      0x742ae859      0xec45f58f      0x54da6053
+       0x7146da80      0xc282f957      0xb8ca5de5      0x6e1586d4
+       0x8afb41c8      0x9e81fdca      0x0ad3c4cf      0xfc9c1668
+       0x236106c1      0x69380ba8      0x6bf3387b      0xd53a1b3d
+       0x0d804a04      0xd63164a8      0xab278bf8      0x77911621
+       0x17c62b1f      0x07cce3ef      0x8801d982      0xa6b8eb63
+       0xbdf0bcb5      0x153aae22      0x3588d891      0xefadbb66
+       0x9bee1771      0xab6cc71a      0x3cbdb459      0xe279e4b6
+       0xa85a357b      0x6405c173      0x49009ce0      0xbf789e70
+       0x05b48b55      0x8c563680      0xb8c46c54      0x75b3b84f
+       0xd4c5b37e      0x3be0e725      0xbdad48a2      0xde04fea2
+       0x798460a6      0x5e2d9bd3      0xdd51b61d      0xd82a0c09
+       0xfd64645f      0x716abcda      0xcdbd9beb      0xf6340099
+       0x5e0ebcf5      0xac66decf      0x31f30d93      0x40a8b2c3
+       0x21a52ca9      0xc1604acb      0x22152aa4      0xd6c0ba20
+       0xf3c9f7b4      0x9c3067d2      0xd65ce46d      0x09df4646
+       0x91fb9f80      0xf07d5099      0x2356e4e6      0x6a74f5ca
+       0x61cd88a5      0x037c423c      0x6400ea12      0xa6544b34
+       0x4c0e797d      0x9d5419f6      0xf036f5cb      0xb2c91544
+       0x3ee6001c      0x0689901b      0x7dee9dd7      0x21d1f1a9
+       0x81275937      0xf917651d      0xfdd106ec      0x80ced4ea
+       0x2f33aaf6      0xf972d4a2      0xee8577d8      0x5a4f08cc
+       0xf36fe1f5      0x17fa2817      0x5fa7ba30      0x64b7afce
+       0x863a55ad      0xe06e8382      0x55f51d7c      0xd6211e8a
+       0xfedf49a1      0x4735a7ca      0x425b275a      0xe8308354
+       0x45a5fd65      0x01a78c29      0x749fb0c5      0x2ca3283a
+       0xa20c3cc1      0x97b87e5b      0x6099d897      0x05e54cf6
+       0x261268c3      0x614aac41      0x4e8e7463      0x78491fa0
+       0xfb15488c      0x75a7b2c6      0x95592e98      0xe3238850
+       0xcbe64eb7      0xceb22616      0x16f85fbc      0x88f08885
+       0xf503ee96      0xa88e2a73      0xee188bfa      0x76c64f79
+       0x7965a663      0x88741be2      0x8d870f48      0x0b52508f
+       0x7f40bded      0x05a25e9b      0x96f30b02      0x4a8be75a
+       0xcda07cdd      0x381a1641      0x59171527      0x6ea88f76
+       0x74a6d415      0x9faf3a10      0x5f54c03f      0xa9e49a64
+       0xaca31f63      0xfeb5833e      0x333094f9      0x9922a8df
+       0x0f551e61      0xa201a040      0xe6b40c15      0x776febdb
+       0xf4462b85      0x3e6f7538      0x23cf68cc      0x6b0e68de
+       0x17266e2a      0x29899d57      0x282679be      0xf79fe214
+       0x7d0b1fd1      0xc8870fa9      0x7134e539      0x8372244c
+       0x2c936c45      0xe6e62224      0x4d826edc      0x00c1f81a
+       0xd54fc626      0x2c7286d9      0x1e8a9b2d      0x68aa54e9
+       0x210113b5      0x17c6d759      0x5135dc64      0xfcbc240a
+       0xb8f35b18      0xd1fc30ec      0x7949088b      0x4d832950
+       0x4f68a47e      0x061649f1      0x05494a5e      0xd75dcb54
+       0x872d1695      0x081d8e27      0x6418df25      0xb9727097
+       0x4e453cfc      0x375a77d9      0x8689b2d9      0x7ab79dd5
+       0x9fdaf8bc      0x74cc8ac7      0x133f8fb5      0xf37fd3f4
+       0x44ee01cd      0x1f6ebc10      0xcfb8abb4      0xe96511c3
+       0xbaa85d8b      0x2fcd20c4      0xbb6c854d      0x4c261c48
+       0x2a00d544      0xdbf74171      0x410a62a9      0xe82b3f35
+       0xeef4caf2      0x77a74cba      0x63c78b56      0x00bb8955
+       0x7a50faba      0x2b537389      0x8c335622      0xf8f14487
+       0xb0539ea4      0x729895ae      0x555e1696      0xc353b700
+       0x43c192a8      0x3fae11f3      0xc73f18e5      0x2f4b5c11
+       0xf12b97e1      0x2dba0c80      0x39a87dac      0xa997b869
+       0xc4af7748      0x36cfc63d      0x95db456a      0x24114f6d
+       0x6b7544a5      0x9eba85a2      0xe5a8caa9      0x53145050
+       0xc7703995      0x7dd9bcbf      0x5cb73804      0x2051b5c4
+       0x7c79de04      0xce429c7e      0xd3c82d1e      0xf26d2440
+       0x0c4880b4      0x8048ff6b      0x3328778f      0xa4d96486
+       0x1de6c5b5      0x6f2fc972      0xb3455762      0xbe37f7ab
+       0xb0de6a2e      0xac05e009      0xb74b38ac      0x90839623
+       0xac53a601      0xa402b2a9      0x064e0d24      0x8932acbc
+       0xecd77a8e      0xfb1e72d6      0xfff0c899      0x7737e87e
+       0xbb7edc0b      0xb3d8b9fb      0x8fc04a0e      0x964cc7a9
+       0x704a3fd9      0x840c3df7      0xa2e19c7d      0xbf030dc8
+       0x0973ba35      0x5b267c7f      0x8bdeaf35      0xd50b6c72
+       0x159e0ce3      0x0b1d84ce      0xb89e6b0e      0x37a9a983
+       0xef3df574      0xdc77bc87      0x65d0527c      0x0675e032
+       0x3ae9a33e      0xc0868b6b      0xe31f9f34      0x35fc360e
+       0xd9c3e27b      0xe7cfa77b      0x6e1c2faa      0x85eb62a9
+       0x7409dbd9      0x77ab5fb4      0xdad7a46b      0x2db78db1
+       0x08201790      0xdef8088d      0x5eec8336      0x1278690c
+       0x57a8eee6      0x43514f3a      0xa777d559      0xe4f2b7c5
+       0x60c45001      0x39aeeee6      0x093d85fe      0xf6241cfe
+       0xdbf8bb72      0x0f79b341      0x624efa5c      0x53ed43ea
+       0x72aca6c1      0xf16eff2d      0x778d2da0      0xe7619317
+       0x978f9d17      0x6031ad22      0x0069d90c      0x6f450b55
+       0x9635ec37      0x1d7cbf7e      0x461d9c0d      0xe9e9eb55
+       0xdf96b418      0x573b0fe3      0x56516a32      0x74ca937a
+       0x61514754      0xffb8360e      0xac86c390      0x83c61d12
+       0xd6adf071      0x9158e07f      0xeab4f9f2      0x5b1cd53a
+       0x6d5c07d8      0x561a18ed      0xd8c5d18e      0xb7720287
+       0xd551365a      0xdba3ba15      0x6e7e8609      0xe8c36c42
+       0x1b9f83ca      0x4227a599      0x1838d681      0x2b8b606c
+       0x2f3aa2fa      0x935b0ff2      0xbc9ea123      0x78ba8f0a
+       0x5a3c1b93      0x0d442c60      0x1b97a210      0xd3a10523
+       0x83271d06      0x101cfbcd      0x6ee001ec      0xe96290f2
+       0xa42dbff5      0x877987db      0xe9e8308f      0x1965c682
+       0x114030c2      0xb00758a3      0x6abcc176      0xd383b8c9
+       0x2cf0e976      0xc9baca44      0x6d76c773      0x49505898
+       0x99ce282d      0x09e172c8      0x2d02b7a1      0x1808303b
+       0xce8aa4df      0x03524e5a      0xbb602b26      0x92f00b7b
+       0x3513cc5b      0x45e5b377      0x53c9210e      0xcc80aa24
+       0xbcb4eb56      0x70754a5f      0x9120338d      0x12ca33eb
+       0xfbc52998      0xe790e73c      0x69c158d5      0xf99cd03f
+       0x492323de      0x82942cdf      0xa34c9cfb      0xd397c6f6
+       0x31658a00      0xece78adc      0x7e7b05df      0xb989bde1
+       0x8a485b6c      0x97110f43      0x8d87c487      0x769b2a56
+       0x1102e11f      0x0ee36940      0x20765e9b      0x056ff8ca
+       0x3034af32      0xe7d683bb      0xc015c381      0x454da6dd
+       0x88b588dd      0x33a7d10e      0xa7a165ad      0x617a01df
+       0x841ce9ab      0xb2b2d05f      0x5f3178c6      0x78e66380
+       0x383697ac      0x27b24e6b      0x1eb97209      0x4c54e7bb
+       0x9fcf3c51      0x59e82d20      0xa1cc8383      0x8a3c7d9f
+       0x320d7b07      0xc4c84359      0x30bf4e7f      0x10bb6224
+       0xfb7d6673      0xa4fecf50      0x0dc92701      0x5f560c33
+       0xda347e85      0xb3491afc      0xbbf3b7b5      0x777a93f4
+       0xf47f19cd      0xfd7152a9      0xc13ebb7a      0x0c522ab2
+       0x92924a6e      0xe81dbdd8      0x0e49e175      0x64280940
+       0xefcb65a4      0xf0ba4ad6      0x185ca397      0xe6bcf031
+       0xe7e4dc62      0xd30d44b4      0x88d546c9      0x0fdf9042
+       0xef6ab5cf      0x0b4799ea      0x63a1cc4e      0x5f364b74
+       0x4aee3147      0x2f9989c0      0x7c1a3ac4      0xe4fe4345
+       0x52e2c1c3      0x2dd28454      0xbc84a9ea      0x6f03b9d4
+       0x6bad3135      0xb77cb21c      0x285622bf      0xcfbae4ab
+       0xda152409      0xe965f46b      0xa56f4ac0      0x793732a6
+       0xc8ce819a      0xc9eef10a      0x5405d22f      0x62e017b1
+       0xca14adb5      0x3aabca15      0x450ddc0f      0x6a890f9b
+       0x07ce8e26      0x3478ff46      0xa847a43a      0x7cb2753e
+       0x54cd3a89      0x3dd3b7a4      0x720479ed      0x09c14f72
+       0xc1b2577e      0x8ef7de25      0x74a8e353      0x2099bd70
+       0x7f348ad0      0x6779fd16      0x7b2cf271      0x2d6ee3d5
+       0x62b71d93      0x28dd2c67      0x2beb10a5      0xb60a76d7
+       0x70c363a9      0x607cdf72      0xcca759c0      0xa76fdb97
+       0xd80d628f      0x4f555255      0x57323ada      0xae329854
+       0x5763cd79      0x1f2bc014      0x112a7c99      0xbc1493f2
+       0x0d052fcb      0xb0fc968c      0x679f225c      0x78f44c6f
+       0x43940254      0x89cde38e      0x377c72e2      0x4e122ff9
+       0x0738278c      0xf334b3fb      0x94bb97aa      0x618ded59
+       0x911d2583      0xd2b06dc8      0x96e2f759      0x8ad4be5b
+       0xc0102ed2      0xf90385ba      0x00b01e90      0x2361d308
+       0x36783633      0x00d1c983      0x4e6d8955      0x4b8551d5
+       0x01021b64      0xcab23320      0xf2b563ec      0xe4d59ff1
+       0x7329fa64      0x337e7b50      0xd5b66c85      0x7bb39c09
+       0x47827142      0xca67be26      0x9025894a      0xc61ca5f6
+       0xfe3a0c53      0xfd76ae93      0x88643dea      0xb207c8d8
+       0x8191ff49      0x32583fb2      0x0d3cdc56      0x0bff08fc
+       0x23954283      0x0e05b4d3      0x635b1189      0x2f08eb8c
+       0xdc050c40      0xf460ada1      0x61952304      0xaed90ddd
+       0x06452f78      0xdaba3e01      0xf32b310d      0xcc3010be
+       0xbfa466c1      0xa43daab5      0x444a47f4      0xefd75b63
+       0x85e17cf8      0xeba80645      0xec115b89      0x708b242a
+       0x226c1702      0x837798f3      0x4398356f      0xd02057ae
+       0x42095052      0x32ae94b6      0x01bc221c      0x57c62bf0
+       0x5d4b1e56      0xbf7bd0a6      0x2db0f6b7      0x96819ff2
+       0x63c8b7c2      0x49bacb6c      0xc6491c15      0x2071e984
+       0xce608a69      0xa210f1b5      0xb78a2460      0xfe4e4c68
+       0xfbae49cb      0x57ecc3d7      0x2e0629e0      0x78a0c80e
+       0xf6860e8e      0x79d2c22e      0x1d379cc2      0xbe6ee2ec
+       0x5bf9e2ba      0x2b6e0fdb      0xc0425e03      0xfa448380
+       0x3743ece6      0x787448a3      0x645276c5      0x81b3b30a
+       0x8fd94f89      0x52aaa059      0xdc7608bc      0x95772fcb
+       0x744b738a      0x997bf280      0x7483816c      0x181bfa49
+       0x1ff6d108      0xc0574da6      0x55c0ad24      0x79cb9a27
+       0x15246a87      0x34e2ff1a      0x13295051      0x58eef1c4
+       0x1e57d00b      0xedcdbd3a      0x2c2370f3      0x3445e71e
+       0xad5f6355      0x189f459b      0xf0bfe969      0xbfd1f5eb
+       0x17d2e507      0x1a8a0d08      0x633f4e8c      0x9522fd64
+       0x99e1e6e4      0x55d92e7f      0x7bb8ac94      0x9358418f
+       0xeef4fb5c      0x41eed0e6      0x947b65fa      0xa2e6fec9
+       0xd61c6d93      0x969c21cd      0x05a31b86      0x8c396b62
+       0xbf273f29      0x93ba1ff1      0xe41bfc62      0x3a818c0d
+       0x320996f2      0x18eb5db0      0xebc4cd15      0x7a394ec4
+       0x5185f763      0xee570798      0x9d0e14f9      0xa1adea01
+       0xe2fd5499      0xdaeeda8f      0x389860e8      0x78bc18a7
+       0xe8028569      0x56bf48f1      0xb0962113      0x91b5f045
+       0x7f90ae4d      0x204c1ad5      0x5ce51670      0x68a380d8
+       0xb4a6433d      0x8fad0609      0x06b60c1a      0x99ed36cb
+       0x384896f8      0xe02a98c7      0x0a236de8      0x50bbef30
+       0xaa6edc59      0x782cb201      0x76d59efc      0x78e3042c
+       0x01686d78      0x43de823c      0x68c34c3e      0x702e21f8
+       0xced88518      0x603b1a5a      0x76a9a254      0xa26d8897
+       0x85a5f69f      0x554c090a      0x4ef1f271      0x0ffe998c
+       0x5e11efb1      0xffa35006      0xadc08641      0xb657ccc6
+       0x0b7bf3bf      0x13525734      0x42d73e64      0x7ebc4df3
+       0x9ee5bf27      0xf43fca21      0xa20d6b10      0x8e5890b5
+       0x4b8a2219      0xbb0cd000      0x8453e1cb      0xb2762a4d
+       0x6ce1225a      0xc12b6b07      0x913cd288      0x71be605b
+       0x667cfe8a      0x72da7612      0xdad5c972      0x02c857d1
+       0x0ff4f261      0x63933149      0xc89d1408      0xcf170599
+       0x300841bc      0x17cd55c6      0x8d5fb39e      0x0daa5d8a
+       0xa715f9a0      0xe1e2f723      0x235a3acd      0x2bcf3114
+       0x52ddc4c7      0x4652c5bb      0x8a03aca5      0xa9c716b9
+       0x56f02055      0x9779c869      0xf5d9207c      0x4114c478
+       0xcaa17eb2      0xc7cb3aee      0xb3899276      0xfe8f0c67
+       0x6594ce9e      0x9caf33e8      0x72de24e1      0xc65b0bbe
+       0x3ccbeed2      0x0c4eb9f7      0xd4ddd087      0xa463d741
+       0x8f883f24      0x903cb206      0x4168bc52      0x8e46370a
+       0xe0cca2bc      0x0ffaff03      0x6f296914      0x48e9a13d
+       0x2c7c75bd      0xc0a1d00f      0x5ad8ac4b      0xbde41afd
+       0x7a813c3d      0x0e7d4991      0xe4d31848      0xc639b480
+       0x05839d17      0x48cf4654      0xb17b817f      0x8f2f5451
+       0xee3a1f4a      0x0acc151a      0x261b8347      0x38ca1120
+       0x42884552      0x7d7df5cc      0xe1d12b64      0xb9379aaf
+       0xf8c580b1      0x6d3137de      0x9a697e7a      0xe5f9a822
+       0xf9562fd9      0x85778b78      0x85c50d49      0xdd293e30
+       0x64260b8b      0xdd5b0a47      0xd6fedd60      0x1b14866f
+       0x057b9f8d      0x5a6992b1      0xc3fe98c6      0xd8539fd3
+       0x3a853a95      0xc69ba8ab      0x16bc30af      0x7d7da1a2
+       0xf35f9341      0x81ad1603      0x1e6dedfa      0x54ce067d
+       0x6dce7ca1      0x1cd2bd75      0xed3193c0      0xff60e501
+       0x4c918733      0x367cc560      0xa784adab      0x88f78cdb
+       0xa9f6eaa4      0xbcb9eaa8      0x521aaf7b      0xcac1d80e
+       0x8d9e1499      0xb6592d82      0xa3a3bbad      0x3255692e
+       0xed9aa54e      0x8dfb6a19      0x78a24e5a      0x341add52
+       0x8331cd92      0x8971a729      0xecdfd5aa      0xc75b43cd
+       0x794b5e25      0xb706fcaa      0xd13e6863      0x0342d775
+       0x794a13db      0x8d2dabb2      0x7ecf0e06      0x73ff58ab
+       0x23fd2a61      0x91873866      0x7638400f      0xf7da1c75
+       0x2721b09d      0x436166e3      0x7d2f8ca0      0xd0a5c7ac
+       0xfbbf22b6      0x157521ae      0xfb9877ba      0x21a1c667
+       0xb72ce935      0x08aee5dd      0x023c9e00      0xa83022d7
+       0x6d6eb2a9      0xa4e9c33c      0x8beb93db      0xf0c1c586
+       0xd1db310d      0xac92f434      0x31ce7c62      0x7577e1e3
+       0x129308bb      0x69716c4a      0x917b6f76      0xd5146b29
+       0xcac441d9      0xc3adfa31      0x427c4cbc      0x71f47f1a
+       0x475a3cd8      0x1783b15d      0xa0d48f1f      0xc4293897
+       0x33806303      0x5278971c      0x03bcbea6      0x3623dc6d
+       0x8ba3f2f0      0xe0fa2614      0x4fb87ac5      0x5dab4f23
+       0x11d0ba53      0x612721d0      0xcaf8e6c8      0xa93a9b14
+       0x381fe12c      0x2a942a5d      0x2225c613      0x9a433253
+       0x6988bb49      0x6f33b72e      0x7984d716      0x8807634d
+       0x6a2007bd      0x54b66132      0x79958596      0x30021008
+       0x435027ef      0xe603128d      0xa366f836      0x4d126e87
+       0x1c9db8e9      0xa05d64de      0x37400293      0xbdf66fad
+       0x6a3b58fa      0x198f2a10      0xb0643bf0      0x3a60ae41
+       0x0530b552      0x33222acd      0x50473d0c      0x2614f6a4
+       0xbb3460dc      0x09721261      0xdd418b45      0xbf4e3dea
+       0x0c2e4b6d      0x664a5b71      0x6274f9ea      0x8e4c2090
+       0xdca0d311      0x757a5a28      0xa6c146b6      0xd2796cf6
+       0x3409b847      0xd16e0e62      0xc5844a53      0xfba85f57
+       0x52ab4758      0x8c1e6793      0x8625a546      0x63d2f8dc
+       0xfbdc20a1      0xdc594fe8      0x857afa98      0x92495545
+       0xe14c06fb      0x844ab99a      0xfa6a8431      0x1e95eb1d
+       0xf6465c56      0xd3a0c476      0xed9ef63d      0x697305ba
+       0xcad7ef3d      0xb343fb28      0x1b2a8b83      0x9abe64b2
+       0x406a1f17      0x48409006      0x69dcd02e      0x9f824ac2
+       0x5ae0bfb0      0x6a4d7f1e      0xb6bce0f1      0xfdb53543
+       0x7164de88      0xd7e16cb5      0x086f96a2      0x9ad43be0
+       0xf57223dc      0x9a7594e3      0xd7ce2aac      0x881ede7a
+       0x107d5221      0xea23396a      0x9471acef      0x3a86be90
+       0x1f32e259      0xee01aaee      0xc9f82463      0xd29ba979
+       0x90f87083      0x5db18a4e      0x1b1a3d2d      0xdd788236
+       0xa8dc25a3      0x225e02c2      0xa2183324      0x289997dd
+       0x1b2513c3      0xd7871be6      0x0c350b3b      0x14253063
+       0xbad53873      0xb88a4553      0xe4dc114b      0x7889236a
+       0x15d95e0b      0x3e305f33      0x5ec3b76d      0xcf5a7b65
+       0xc528888d      0x80a30558      0x95e43a88      0x1ede3c7e
+       0x1437a94a      0xd0266864      0xab133c96      0x38f27dea
+       0xd0f5a7ca      0x6bd0e09b      0x050cdf55      0x88fe3968
+       0x6b28d381      0x0f327320      0x90ac81eb      0x039696fc
+       0x5f736386      0xa38a3434      0x164b1104      0xdcf5584d
+       0xdf556d02      0xead0b920      0x6c676b5a      0xeb11e583
+       0xaaa0a6c7      0xab399ce9      0x49bc74ae      0x5f5390e6
+       0x626467c2      0x22bc860f      0x077ea13f      0x64e39e3d
+       0xb4e9c152      0x1d913ac3      0x4813faf1      0x5a89c08c
+       0x906b9a62      0x894b0a84      0x7962450f      0x3de5c67f
+       0xf9b4d213      0xda9538f8      0x47de7800      0x9ce47732
+       0x80577b6d      0x5225c3e5      0xe6b837c7      0x14a6a822
+       0x060f9074      0x6651d59b      0xb29c7cb1      0xc36702b2
+       0x2e6188ea      0x4c3f6b71      0x373cafd6      0x5d5cb417
+       0x4f34be02      0xb84782ad      0xd3397f66      0xffabc035
+       0x06eb6fb9      0x665212a4      0xcc523aa4      0xc42100f7
+       0x9d8e0cac      0x890fa9fd      0xa48e9210      0x58ef6912
+       0x1dd95ae4      0x36437c20      0x6cb9f8b9      0x52ce560d
+       0xca1943d0      0xcef04668      0x1e681da4      0xcfff1f49
+       0x56376cf2      0xf5028d20      0xb191498c      0x7832fd6a
+       0x11748970      0xae357390      0xff4e4e91      0xfb6910bc
+       0x0cdf00db      0x614d3f80      0xe1ca0fbf      0xb5f0c0a8
+       0xb61b768b      0xe207471e      0x62fb5874      0x6d7756c5
+       0xa0de7abb      0x12c91cbe      0x5ca2215c      0x7817a064
+       0x95563db3      0x09f4e7bd      0xbebcc9f6      0x45b9a2de
+       0x8b1e1edc      0x12e4b5f5      0xf98005f8      0xed7dff7c
+       0xd4bf5ec8      0x5a8fce5d      0xa8a2eb82      0x91578f50
+       0x77bbb425      0x926b88b2      0x2cc255e5      0xa53e94a3
+       0x66c84456      0x4d0f49a2      0xe45ac28c      0x4b774708
+       0xb7135cc0      0xded3139a      0x106c121c      0xa0d73853
+       0xe2fa4c95      0xf58ad05b      0x31a5b314      0x2bf5685d
+       0x15ffd576      0x7554545c      0xd68b12a8      0x3b4bf7e8
+       0xdf8bf01a      0x316c7f03      0xb4669bb6      0xe8dd4ede
+       0xd68ac685      0x67348276      0xb1ff07e3      0x1d82351e
+       0x3a11076e      0xdebd9a94      0xdd685cfd      0x4542a360
+       0x03b8f1a3      0x4a010bd9      0xdd1d5b89      0xd0b05f4c
+       0xcb54984f      0x326d0c66      0xacdd98f7      0x372867c5
+       0x5cac6b17      0x415eca5e      0xb535775c      0x91e2a732
+       0x4428c803      0x8b3353e3      0x4b2be06b      0x605668ba
+       0xd9dab41e      0xa8b8f437      0x2e7918fc      0x286b9425
+       0x7962930d      0xef266255      0xaa23b7a5      0x2b4c013e
+       0x56bba273      0x926feb57      0x75886ed3      0x63747643
+       0xb33514cb      0xcb54660e      0x8afc2ee4      0xb73cbd44
+       0xd196e8bf      0x2ce848e3      0xcfc39059      0xf64f5803
+       0xe011f74c      0x5ccbfbf0      0x5eab119e      0x798e059e
+       0xb4597c18      0xa0d9a951      0x2170880d      0xb78db543
+       0xc7296d05      0xc1d84f42      0x0fc7c193      0xc86cce96
+       0x9a8e8a05      0xfe7b2df1      0x5169e08d      0x84c70c89
+       0x718a2eb8      0xdb1166aa      0xfbc157a5      0x7698ed85
+       0x7072ec86      0x9229c46d      0xb77fbc6a      0xa094a8ae
+       0x9815419d      0xc1c34b7f      0x47d5e1db      0x827ad2b9
+       0x099e658e      0x2a2e1b90      0x4d590c47      0x4bbf250c
+       0x56200e09      0xa439971a      0xab7ec88b      0x6dcf5707
+       0x41a3a4ed      0x47799d76      0xeec45688      0xbee5cb3b
+       0x0dc051cc      0xadd3df90      0x438599e1      0x16b44efd
+       0x5f1a3cf2      0xfdb7b50f      0xd62aabc6      0xab74fb96
+       0x7f6b4092      0xa6ad5edf      0x47b58bbb      0x3c35d55e
+       0xf50611dc      0x32a89709      0x3495c23c      0x8a3bd7ee
+       0x0bebcdee      0x71654d04      0xcc59af41      0xadf8162f
+       0x881f6aca      0xbb49d9a2      0x66ac3fb4      0xad14c851
+       0xb1d91743      0x798067e9      0xa97971ee      0x24f89c50
+       0xbf04aadb      0x03b5f978      0x6841e07b      0xc8598643
+       0x3a58a3e3      0x6f1b4bbd      0x0af6d03d      0xc35d3f33
+       0x8729d9bd      0xd64a0c61      0x542157f6      0xa282bc04
+       0x857d37c3      0x5e6adace      0x7555044e      0x5a248361
+       0x6565e136      0x17da1a91      0x34050097      0x405bd3e2
+       0xf1120b01      0x203dd9d8      0x95b0e1c6      0xb78c812a
+       0x0e0a63ef      0x896b318b      0x1ad0b155      0x94c9dda9
+       0xcf6f6ba7      0xfd027946      0xc9587ab4      0xd2db65e0
+       0x3ce4ba1c      0xf499983f      0x199e2fab      0xb6ec7955
+       0xebc36992      0xb0eb28ae      0xfe431b2f      0x6f361886
+       0x383db1c4      0xb4806494      0xc7ff6411      0xc8cf7b3f
+       0x51d91abd      0x78965a69      0xf8b7c21e      0x6a4a0a56
+       0xfe99eb9e      0x4b81f5d4      0xcf2746be      0x73f04cd4
+       0x314680c5      0xdc8b2bb5      0xc0962a8b      0x3662fd5f
+       0x4ee83f14      0x12b241bb      0x58b66465      0x1ec3230e
+       0xb01feb48      0x50f51490      0x1cb250d5      0xc5d2feeb
+       0x9541aa75      0x7b6b3777      0xc23bec48      0xbb91ac32
+       0x3f153613      0x3e9df1e8      0x7595924d      0x10e72587
+       0xe2d4a74a      0x162829ad      0xa5089d0d      0x5ece52b1
+       0xc3f1168c      0xc6a93f18      0xbba86d95      0xf9b0a2a8
+       0x47b28d75      0xe7cbace5      0x0fe705c4      0xc8648f6d
+       0x3c268591      0x2b43d4b8      0x75ef7b71      0x99e6a9e8
+       0xcf725d46      0xd2fcedea      0x540083ac      0xe5f72895
+       0xe2a4842a      0xef3817e1      0x1975a120      0x89b13231
+       0x3b66301f      0xa7f2fb49      0xd85b86ac      0xd9ded889
+       0xf19b04af      0x41904c68      0x18f37c71      0xe3444a3e
+       0x53762b06      0xe6891ed9      0x814d50ab      0x4ed4657a
+       0x99ce9cb6      0x52e5f075      0xaf13c81b      0xd6565c1b
+       0x7bc2fcb9      0xc8f8e74c      0x3a96988c      0x9c9180e9
+       0x8f0ec0a6      0x8753ac45      0xcf9dad12      0x40f00c60
+       0x11312116      0x98b29629      0xf7946c8c      0xcfda0516
+       0xf67820db      0x92e08eb9      0x2b46d789      0x02186715
+       0x74b62a7c      0x0f039ed1      0xb2967ff8      0xdc66da3b
+       0xfccaa021      0x37b51ca5      0x4acef25c      0x148fe172
+       0x5096bc94      0x4a04ba6e      0xbb63961e      0x01cd00d7
+       0x6865eba9      0x75677999      0x604bb9a9      0xe75f4ee7
+       0x51bcf14a      0xf1f9a6f9      0x2cc17a63      0x955044af
+       0x45342530      0x4bc020ca      0x71523af8      0x20a1e07c
+       0xec273f9c      0x09f07430      0x56a7fde6      0xc1b9eaf5
+       0x28f0c251      0x0d9d037e      0xada6e611      0x913269e6
+       0xf78b1d88      0x2888c690      0xa28b9683      0x41f2643e
+       0xc972a3fe      0xc7368a1a      0x5fe34b32      0xb1bc0e51
+       0x12f756a6      0xbe217a80      0x9c6b6db7      0x7e51bc3a
+       0x7becd1c0      0xe3b3038a      0xec900d68      0x97b282ed
+       0xe5559c20      0x3242121d      0xa2af2a4d      0xbf3333ed
+       0x9b0a4f97      0x61b25e08      0x418cc8dd      0x76f72456
+       0x458c6401      0xdb1d8950      0xd0f25670      0x923a5811
+       0x17262230      0x261f6c60      0xf96f244a      0x1a9affd0
+       0xefb7a2a7      0xd721ae7e      0xd087217d      0x3bcb9f0a
+       0xb6f0f870      0xe2915586      0x66cd96e8      0x2bf0ea5a
+       0xd37f84c0      0xfae6304a      0x6fa41e5a      0x65c3b930
+       0x381f4e5d      0x43d06647      0x48c1214e      0xe481a99c
+       0xf863b1b9      0x5e1855bd      0xa3f81c54      0x954b44e5
+       0x6d094559      0x1bcee36f      0xec34bcb2      0x2d4098f2
+       0x7706ebe1      0xfab8d0dd      0xcfa2f614      0x6e5c176a
+       0x666a1ef6      0xaf4f268e      0x25203e5d      0x6c14f506
+       0xa4fb35b5      0x266a64e5      0x9370c58b      0x949122dd
+       0x90052488      0x2a906e5d      0xd0c25404      0x6e5dc043
+       0x8d958e6e      0x2de4e533      0x6945ba79      0xc0e99d8f
+       0xf99f3828      0x15ddf872      0x52e0f623      0x408ddf99
+       0x942e6b2c      0xe6d5bc2e      0xbd9e5cdb      0xb0823a23
+       0xcb7e5e0f      0xcc6b158d      0x5bc493c4      0x1aba51da
+       0x66e0a392      0x821acfe3      0x1da98d30      0x4a0762e5
+       0xe8f9ee17      0x91d29814      0x43d89846      0x8740024a
+       0xf55c6758      0xcf02a999      0x7b3011fe      0x87eb805e
+       0xc7da2d1d      0x7e001591      0x02d6ebaf      0x7836dba1
+       0x7c21b9b6      0x34c476c5      0xf5a3d3f7      0xb74600a2
+       0xd2df7552      0x0248e3f7      0x656e5139      0xc5ac2463
+       0x18fb64a3      0x0a972cf1      0x8cb90b93      0xf6d8394c
+       0xf3a06089      0x923f42f5      0x70ced056      0x7ca5c981
+       0x9beb98b8      0x66c1f8f7      0x6947891a      0x3898f57d
+       0x23ffa13c      0x2d978183      0x8eb904b5      0x7a639b51
+       0x0fd90599      0x32e6d104      0x808e4ee4      0x2564e5b4
+       0x157b6941      0x3e795d67      0xb7b68fea      0xecc31a23
+       0x0548918c      0x27e970df      0x5c1785b2      0xfacff6ab
+       0xbde5d0bf      0xbe223371      0x6ad09992      0xe6b06985
+       0xd39c9148      0x6e2df5a0      0xdd419e14      0xba3fa4ea
+       0xe7e0fdda      0x604576d9      0x4ba317fb      0x1f32c81e
+       0xaa1bd664      0xc4033a27      0xab6c0d10      0x1c04c87a
+       0xf7c3d5bb      0x8955e93d      0xc4539c55      0xadf09456
+       0x4d914fcb      0x43115518      0x36e4ba3e      0xdcb7d4e6
+       0x26cf2cf5      0xa9a0ea4c      0x406da630      0xa831bbda
+       0xd18b6027      0x05e6f711      0xd4801027      0x01fc2816
+       0xd060a6f2      0x39bf527f      0xa587b154      0xe985598b
+       0x1ec4c946      0x5c4e9147      0xd2ca8e5f      0xd8e601c1
+       0xee1e2e20      0x72ecbdbd      0x1c88c8a2      0x0a0bb9ac
+       0x7f1be7b9      0x24fd8ced      0x959cc4d8      0x55164485
+       0x2c331335      0x5b0210fc      0x5372b0e9      0xc4b90d3a
+       0x3d3a61b0      0xd97b8ad8      0x38331046      0x76ca0822
+       0xdcc664da      0x00898189      0x9134a407      0x3285fd56
+       0xde35ed5e      0x45f2082b      0x1430c4e7      0x65f7e707
+       0x64408ada      0xe7d006a6      0x8e23a395      0x8604413c
+       0x7e50aa80      0xe48bd72e      0xaaf6531b      0x49974f7b
+       0x8cecde21      0x99aa6c38      0x07c00884      0x0f6c948d
+       0xd9d29ba6      0x093a0ea4      0x2fa8d5e5      0xaae0975a
+       0xf1cec760      0x62f9a80a      0xd528e915      0x9ce1f32c
+       0x4211d928      0xb343151a      0xab86a08f      0xc7d7aee7
+       0xe8f38a0e      0xcd8c729f      0xb6046236      0x02eb3c97
+       0x52247be8      0x0ecf8082      0x2b0b8c11      0x4f32e6e4
+       0x43f17364      0xb33ad07c      0x3353706e      0xc8dc6279
+       0xf0687f7b      0x32070b2f      0xd9f55394      0x8bbc60f0
+       0xc82c259f      0xf6d2bd7b      0xdfc0035e      0xb94393f2
+       0x822a5067      0x17299c56      0x06bb8f31      0x132a3770
+       0x9f9e864c      0xa2b12322      0x05d66241      0xe6e828c6
+       0x8011ab7d      0x2961a7f8      0x0595fa6f      0x40a6f249
+       0x178686c6      0xd826dd90      0x36036ef3      0x9a7897fe
+       0x1ab9d29e      0xfd8ab140      0xee2009f0      0x725fb3bf
+       0xaa2002f6      0xa827bad6      0xb8914a01      0x17d29016
+       0xe82a26b7      0xa4482f86      0xec3736a1      0x150ad17c
+       0xc0de3d63      0xc820fdb4      0x95874514      0x8cba8adf
+       0x43c1787f      0xd64e452d      0xb71969a0      0x7e9dfb92
+       0xd293dd74      0x7f96cbed      0x453cb56c      0xb21e7aec
+       0x61363a59      0xb1213daa      0x2883f5ae      0x15cc03d8
+       0x598df452      0xf8966ad1      0x0fbce326      0xb4e0b355
+       0xbab4c66b      0x3ad3f11a      0xc7246465      0xd464d742
+       0x179c4695      0xfd5367ef      0xe4460247      0x0354988e
+       0x0069ff85      0x8f7f3e0e      0xef7111cc      0x1652425e
+       0x6b3a16e2      0x027dbf25      0x9131fc2b      0x93b08b02
+       0x0fbeff96      0xd6c6c7cc      0xf3423a23      0x222226d0
+       0x3af3fc91      0x431e0a0b      0x6c779ed6      0x1fa812eb
+       0x830bf09e      0xb6cbee22      0x40e3b081      0x0a4b2b59
+       0x15181d90      0x87ff8f9c      0x2985741c      0xa5aaee14
+       0x172cd8d6      0x93a88e73      0xf0081ee5      0xa8fddd01
+       0x2dbb0486      0xad3c8286      0xe1ea8d4d      0x08639639
+       0xec49fc2f      0xf39cf5a3      0x743a047d      0x08e00c5c
+       0xba47c3bf      0x095787fb      0x9c467b76      0xbab95f02
+       0x315bd75e      0xabf00507      0x81052347      0xb046d6b6
+       0x575c4f91      0xd7ff1b6c      0x5f457e4f      0xee100f89
+       0x53bef45d      0x9d183d35      0xe17f9595      0xda5a4a57
+       0x9edd0c67      0x85ad518d      0x24daa9cd      0x58ec924f
+       0x2184673e      0x7b6fcc41      0xbc929758      0x2e35a31b
+       0x9a42b511      0xf317246a      0x07240adf      0x30d6ea38
+       0x0c466d11      0xc8589b73      0x25e10990      0x53cee8ac
+       0x2dbd67a2      0x44be9b63      0x346dd927      0x74fecc71
+       0x47597a4f      0xae0b2a8e      0x5ab1535b      0x9830b76f
+       0xbbac732c      0x4a40ef9d      0x345fca77      0x27f4bdb8
+       0x41e55ca5      0x5b939078      0xaf3b1770      0xd6279a0d
+       0xd754d2fb      0xf3b7a020      0xfa063ed2      0x615e9981
+       0x11fcd282      0x8384d011      0x212321de      0xf0bbc665
+       0xb96cff87      0x9715a8ed      0x09e50015      0x9ee2aee7
+       0xf56eb51a      0x9aad2464      0x70cfdfac      0xa4c6cefd
+       0x95822f60      0xb0f42584      0xaaae5962      0x31fc2f12
+       0x5454ee2c      0x093f6828      0x065409ec      0xeb3f3b8a
+       0x368ab338      0x656094c6      0x40ef5979      0xd0ffe70f
+       0x25392ca1      0x333d2af9      0x16ba3263      0xc2b1506d
+       0x24e7de89      0xce913501      0x746668b3      0xcb7ece8d
+       0x262187c0      0xc91ea7ba      0xd435c8e0      0x3c48a76d
+       0x3257f421      0x4525407a      0x35a1af91      0x968dd74d
+       0x10f0fbf8      0xeec63807      0x050c1875      0x05276507
+       0xdb5af01d      0x39c2395e      0x0ac3e221      0x19d45b09
+       0x876a6113      0xd9ad6d99      0x45956d8a      0xb4123b4e
+       0x2f43dfff      0x0141f776      0x63fcf920      0xa543f1fa
+       0x96e5c5ea      0xcf6d39c2      0xf215e7d3      0x4546682a
+       0x36f1fb3a      0x364c46a5      0x4e6acb1d      0x16ce975c
+       0x53b111e5      0x6389f4fc      0xd34bac9b      0xd7bf867a
+       0xd61572e7      0xbad6406d      0x18df17e1      0xbc62bba3
+       0x80656102      0xa00c669b      0x66a20795      0x2c17f551
+       0x3785f84e      0x23889af7      0x0aff5a71      0xb5d35e34
+       0xd6bc8485      0xdc0e7918      0xe70235d4      0xef0ac566
+       0xc84ba982      0x293ef48b      0x526c658a      0x9b9c1276
+       0x1fc8e7bd      0xcc763e59      0x74426a94      0xe96e5a73
+       0x0cb14c11      0xfcb8f6c4      0xb8f77a33      0xa39670b6
+       0x41fe586e      0x8b8c7e1b      0x7221a414      0x0581f3d7
+       0x9d2a6aa4      0x9092f216      0x1143214b      0xc3dcf4d5
+       0xf9d83505      0xdb7ce1f9      0x9936c95a      0x7fd7de5d
+       0x55ac7acb      0x926e7280      0xdb7a0df9      0x6784d076
+       0x69db45c4      0x392b98ae      0x4610933f      0x1a308cae
+       0x2080e7ee      0x0d6440f7      0xea9c453f      0xcfba5640
+       0xde27beab      0xd1a1f4fb      0xb67a6855      0x01aec9d4
+       0x8b4a85a2      0x7b2f326c      0xd9383ffa      0x4de0128e
+       0xe9d9c3eb      0x265343b9      0xd7f969aa      0x2846b1d0
+       0xb11de303      0x9a79b95b      0x4816b796      0x26698fcc
+       0x99e3bbc2      0x2bab5533      0x30aaeb98      0xf5553e10
+       0xd52058a2      0x709d88a3      0x99913521      0x2f607662
+       0xd5a29ebc      0xb2004a12      0x773c6961      0xa963abea
+       0x141902db      0x2052552d      0x8e0fa837      0x6343a0d4
+       0xa97f2476      0xb60f3e24      0x86e8b3c3      0x9ef1265a
+       0x35433e93      0xccdaadec      0x25ec9e0d      0xa49a5136
+       0x6b0f657a      0x944aab1b      0xbe8bb4ab      0x80ded52f
+       0x1ec9845b      0xa7cbaa3d      0x601ea616      0x27c5da14
+       0x41a0060b      0xee995ec7      0xc7b884db      0xd6dc69b1
+       0xf1965c27      0x75c3bb26      0xcf435c0e      0xb535e16a
+       0xca18edf5      0xf406afa8      0x74dfa094      0x8e749c1b
+       0xa7fee7ab      0x92fc6e7f      0x30433359      0xb01eb22d
+       0x2e30b15b      0x18748336      0x6f010670      0x93be1ee1
+       0xbb609e88      0x3614ba52      0xc399c07c      0x92178ec6
+       0xeaa6025e      0xe92834d2      0x395cfc67      0x8bafed81
+       0x04dff852      0x68e747f2      0x439cd13c      0x5f6d2515
+       0x9739e1f8      0x17e1cb91      0x52961f20      0xde6e3d4e
+       0x2d0ae08d      0xf052a2ae      0x0d113f73      0xb9fdd5b4
+       0x68294a2b      0x5128693d      0x0edd1f65      0x1df92526
+       0x3038389f      0xc53d5aaf      0x695d5e69      0x032ac946
+       0xa804f03f      0x9d30de49      0xd7f98ffa      0x7cc30b6a
+       0x91a41221      0xf266d85f      0x881ee4b3      0x0d2e5547
+       0x433cce94      0xf32bcd94      0xd4770b0a      0x191f5ae2
+       0x9c8b3a12      0xa79355fd      0x979cd499      0x2edf771f
+       0x30809e8e      0x21516903      0x8d7e4ec6      0x2509ab5c
+       0x8dea9047      0x10c1fa6b      0x5f1ea7bc      0x4f2dbf33
+       0x3f470aed      0x977e440d      0xf7bfe3eb      0x032d2c14
+       0x45c252f7      0x86f67f95      0x8fff0f06      0x1d7ddd5a
+       0xcce170ea      0xf7f6e7fd      0xc6852452      0x6b133e7f
+       0x0eb7ac74      0xe2e8ea7d      0x65f7f62b      0x59e1b6b0
+       0x00cd19be      0x95ac6813      0x6255d72d      0x8867a453
+       0x9ff624fe      0xa4a059e6      0xab361629      0x4597d82c
+       0x9fd7316b      0xd78bd7a8      0x20bb1457      0x0319c4a2
+       0x265d21da      0x6560b01c      0xe022dafe      0xfda837f4
+       0x3892ca30      0x858531d1      0x348da25a      0xdd2d6406
+       0xee0d7c9d      0x26d77164      0x6fb0706a      0xe1a0e901
+       0xf0f7254c      0xb765962d      0x866edea6      0x68a5ac3e
+       0x583e12d5      0x6ed3b43e      0x8e227eb0      0x3c44a223
+       0xfc6b91b2      0xd7b65b04      0x3d26cd98      0x9a74192c
+       0x866606ba      0xe42d20ee      0x1403356e      0x81007e38
+       0x255ca5ea      0x76ea33bb      0x78c505f8      0x81f2b3e9
+       0x8ad9789f      0x7836cf63      0x76285a37      0x7dd89c34
+       0x2f1917bd      0x3df8d06b      0x38ce86aa      0x7cc6dbdd
+       0xc506c1bd      0x8d6b5b3d      0x4d6821fe      0xd31eb5a1
+       0xea84b904      0x4c3a7344      0x41d1dd6c      0xfd0e905b
+       0x1e78d0de      0x7aa18ca3      0x2dbfe357      0xc222c63d
+       0xe02d3860      0xc6b6c9ed      0x9a2d0f99      0x0515c651
+       0xe0e8beb4      0x22ff1c64      0x2dc27735      0x41bf0647
+       0x39ac9384      0xbb6ea363      0x2fa909b0      0x9d555319
+       0xb3db799e      0x2e763ac1      0x1c2e2c85      0x57d1c765
+       0x037c16bc      0x2199830a      0xafcc7b9f      0x1b010bd1
+       0x4b73ea78      0x0fcf89c9      0x80540e39      0xf46e495f
+       0xcaed57ba      0xb1958a78      0xb1f16c0e      0x07c6961d
+       0x8f86e8e6      0xcb328b2a      0xba84121f      0x3a674941
+       0x19a2d7dd      0xc7114e6f      0x9a2c7cc7      0x9a929229
+       0x418e7908      0xe34c9835      0x0eac9d26      0x81844731
+       0x2139b075      0x92fa8d11      0x38476154      0xa2c510a6
+       0x68e9b3ce      0xf127b91b      0x4713fdb4      0x910af5c6
+       0xfcfad9ea      0xc62faf47      0x51ed376e      0xef9868a6
+       0x7fa61cf5      0xbfc2c286      0x7f2fec73      0x8ce7a5da
+       0x76df9b34      0x85c4a4a7      0xefda3c1a      0x1f551fa1
+       0xe1482349      0x63a1c752      0x2a142adf      0x1e87fdbf
+       0x5286c087      0x0069d075      0x55ed04b4      0x07148276
+       0x4c44e54f      0x9d112217      0xe3aef71b      0x1c719099
+       0x83ca0f3b      0xa9519078      0x9844a810      0x2477b5ac
+       0x13b99f06      0x205ca93a      0x2c2650b6      0xbc2e4914
+       0xe6479470      0x0b3a40e4      0xe512c09d      0x3760d755
+       0xe40b6a25      0x82834ffe      0xf3e632a9      0xa79672f0
+       0x3120af49      0xcb9f6c6c      0x08416d83      0xf12a55f2
+       0xbe71f896      0x294b72ea      0x6dc6f745      0x2c86da4a
+       0x11eeafae      0xcf5fca01      0xcdfbd957      0xee119ab7
+       0xbe1629b0      0x2fc1382e      0x256fa5b1      0xdb892e51
+       0x8e0b6834      0xf44a6da4      0x05dac8d5      0x042eb8bb
+       0xe5622395      0xdba1e071      0x9cb9e98b      0xd756f385
+       0x9368e11a      0xf739a78c      0xe1c2a848      0xc18a37a2
+       0x77a15f68      0x4c1430c6      0x23a8e73b      0xe37fa9b3
+       0x7ac329ff      0x19628ada      0xb3f1df4b      0x179d4083
+       0x6f541ccc      0x448d4c67      0x8c74e255      0x505e50df
+       0x8b811b69      0x59a79799      0x4c2d0f31      0xf0f6a538
+       0x97e39db8      0x3984e480      0x13243d85      0xd8fd2048
+       0x7bae15e5      0x621249ea      0xfc8d6fad      0xb0b2c6e8
+       0xdf800bef      0x0cae6636      0xc8d0fcaf      0x382dbced
+       0xabe1c750      0xf43bd435      0x41c40c31      0xf4d286d7
+       0x3a4eb3e6      0xf85b6edb      0xb184bdde      0xc777a6d7
+       0x20e9e1d2      0x969890c5      0xc6f401c4      0x072418ac
+       0xe985a37a      0xcce8ae3f      0x21698475      0xff28bda3
+       0x46a3fd04      0x1fa960ff      0xba81f51f      0x105782a4
+       0x5d70936a      0x45ec11f6      0x55e96bbd      0x8c2fe102
+       0x59ef367e      0x490feb0e      0x5d64055c      0x6a7750c2
+       0x1e710e2d      0x570b5ada      0x73e3139d      0xecda999f
+       0x74c4d7b2      0x68adb168      0x36ac423e      0x78e97fdf
+       0x07e28101      0x28179187      0x29b56903      0xf8eb70f9
+       0x2b4777c8      0xd20d91ff      0xef938c3e      0xdfa2b9a7
+       0xefb12a82      0x27a06eab      0x7197cc82      0x5cd94520
+       0x9c9f5a51      0x309a4141      0x190cccfd      0x6eb7ce1c
+       0xc3b42d1c      0xbb2e3a77      0x3075b9c3      0xf7f25734
+       0xfa00d974      0x4f38604a      0x14b4cfec      0x0ae7157b
+       0x1daa8ee4      0xb07687ce      0x0fa15ee8      0x27f2853b
+       0x9b9bf945      0xa7e9c948      0xadcacb5f      0x4ca93ff3
+       0xb7a145d7      0x9a86c44b      0x6425c19d      0x90d86f4b
+       0x2fc3966b      0x4b3032df      0x4c75d5b5      0x704c961b
+       0xd03d76ef      0x13ea755c      0x184a475f      0x5a429691
+       0x8f6fa37a      0x99d0978a      0xa49be619      0xd61586ad
+       0x78f740d0      0x84ea95e2      0x975327fa      0x3d01ef92
+       0x43adf632      0x9965b9fe      0x01547a96      0xdb056d6f
+       0x0de34150      0x35a56d6c      0x66a9a7c3      0x2941e292
+       0xb84ae64d      0xed50d9ee      0x57db8fad      0x6e821638
+       0x90d1fa31      0x2c4b685b      0x1875721e      0xcff25eeb
+       0x37c4b778      0x0fb3c32f      0xaa1763da      0xe3de6187
+       0x070d705e      0xb754fff6      0x2317f620      0xfc4067b6
+       0xa626879b      0xf86fbfd1      0x403a94b4      0xac48a3a5
+       0xcec7528c      0xe931cd44      0xa4671559      0x4612a8a9
+       0x62fcbc6b      0xaf0a57b5      0x315b4d17      0x93c90f27
+       0x9e989b60      0xdff30c97      0xb69a3763      0x9eceaa84
+       0x862dcaff      0xf1becb0f      0x0280c071      0x18e88815
+       0xe4ade0dc      0xbf540db1      0x2aee6225      0xe1753fbc
+       0x13e770ad      0x37472716      0xca9507f4      0x6a31a6a1
+       0x34b82e2d      0x48c457aa      0xab288c8a      0x41b3cf16
+       0xc74eee27      0x10c897ef      0xc2d95fc1      0x42064b42
+       0xe464bc6e      0xc8d2d912      0xb54ee9bd      0x7827f36e
+       0x8d3fbef2      0xb726d874      0xf37847af      0x5aed16d6
+       0x4efa2c23      0x7c557918      0xab83054c      0x45d1ac89
+       0x934c823a      0xd1d1df99      0x026c3c98      0x02815b1b
+       0x4f38ed8f      0x8a4efc88      0x2006cf30      0xb7d76098
+       0xccfb9d24      0x0f659dae      0xaade2eac      0x6bff2c6f
+       0xa1d5212c      0xfe61e75f      0x33c22bb9      0x7e72cbd0
+       0x0345719a      0xbd234359      0x8ee7cf5c      0x8447747e
+       0x916705e3      0x1f34a5f3      0xba872d5f      0x4ef8e8d6
+       0xb5993d3b      0x833b89bf      0x5fdc0cf3      0x77f0f36c
+       0xac9b5a85      0x4b35298b      0x5f56845d      0xb9ce7061
+       0x0ba49d38      0x49189e7f      0x00ec6bc8      0x636de591
+       0x0b75d9f8      0xaa2ba10b      0xa6e404fc      0xd0c242af
+       0x79db5a8b      0x18fb989e      0x62bd98ca      0x96c908ab
+       0xd90e1c76      0x2ea0431e      0x60e8a164      0x1b01ea98
+       0xfb44a78c      0xc983347b      0x586d7d92      0x8a461ef0
+       0x9db9f28b      0x7f12e941      0x958c9959      0xbd86b588
+       0x5f0b7632      0x6d1006c0      0xd4f05892      0x3d2317d9
+       0xc271ef3c      0xaed55cdc      0xb06b27e6      0x4d98b711
+       0x78d41e00      0x3a6e5751      0x6ae754c3      0xd82051d4
+       0x6ebe2a78      0x3d04b0b4      0x89f9967c      0xc8320170
+       0x1b46b62a      0x4b7d6174      0x58fbfe54      0xb115efe8
+       0xd9a269f0      0x929fa2c4      0xa599c40d      0x7cccda14
+       0x2b3babc7      0x71a11011      0x16e73179      0x25ae6f17
+       0xa35ba3e3      0x7146503b      0x8a8afb8e      0xc9e6553d
+       0x6615eefc      0xd1bd815e      0xecbd77a2      0x22418ead
+       0xdd74a026      0x07199bce      0x0197404c      0xea8ab54d
+       0x8416235e      0x0aa70a1f      0xfbcc0191      0x045bf520
+       0xf358a0d8      0x3e00551a      0x1b548feb      0x54bf7b20
+       0x7edcf6f7      0x3ee8bfb2      0x5647c2a1      0x7a5862eb
+       0x39fb4231      0xff2e0b3b      0xfded2af1      0x0ea2e71a
+       0xd79559e8      0xb37fe356      0x82893ea5      0xdfe45d72
+       0x46e03140      0xbafd450e      0xc375fa2d      0xb6b5dd5c
+       0xe08b2bbc      0x2a5b12cf      0x460dc1b5      0xdf4f9385
+       0xb66213ed      0x828ae2fa      0xe20903f3      0x9ffee39b
+       0x48050fbb      0xd4f75804      0xe88d787d      0x0ef3988a
+       0xa4653bc3      0x871e8b29      0xde3f1a0f      0xa5b77022
+       0x8b6ba7a0      0x9508b22b      0xc1c9da8c      0x36cb512c
+       0xd095fa13      0x064f3609      0xffce3140      0x5b189ead
+       0x677cf8fa      0x95e2d7d2      0x14e6bb22      0x45003ca8
+       0x8a9d1ca2      0xa654dca5      0xddf35c50      0x63e63418
+       0x0883675f      0x052eb0c0      0xca4e7b8c      0x555d5fe3
+       0xdfc64f7f      0xff3bb091      0x07633704      0x6d83443d
+       0x48e87d0e      0xc06135a9      0xd637befd      0xb74de05f
+       0xcd5dc723      0x363f9b49      0xcff22c22      0x32228ae7
+       0x37fb4d01      0x777e1a7c      0x0b42cf8f      0x2d35314d
+       0x93a0ae9a      0x96feaaa7      0xb377a794      0xfdf2fce1
+       0x1a1dd7a3      0xd9d40a93      0x7cb1e45c      0x69c09130
+       0xe38909dc      0xcec2f074      0xd7400073      0x944a4996
+       0xbe313685      0x9426630b      0xec099c63      0xb31e9ff9
+       0xc56a050f      0xa09cdb43      0x41752ee4      0x2266b523
+       0x1a912cdf      0x2ff9cbc7      0x030ab08c      0x5a8ea97f
+       0x7168e475      0xfcd48589      0x07e740e4      0x91841539
+       0x4bec6e45      0xae7f3b6c      0x018181b6      0x107e7f7e
+       0x9fb91b2a      0xd3c72f9d      0xfdd86838      0xa75ca4d2
+       0xc624ae9f      0x1a824877      0x92caaded      0xb43f1fbe
+       0xe19f4eca      0x977a11ab      0x8e3c937d      0x40182ee1
+       0x211ad89b      0x8fc60360      0xb74604c8      0x9e3d5b77
+       0xcc3929c9      0x8842f0a9      0xb0f7daeb      0x9a492ccd
+       0xeb640ba1      0x2eae5d39      0xe832eaf6      0xc7ce11fe
+       0x3f4bb694      0xa7529b68      0x26be7885      0xd23390f8
+       0x60caf14f      0x53d6a3ee      0x0264cdc9      0x55719e01
+       0xaeec6904      0xa90b0e32      0x1a7cce39      0x6878c001
+       0xcc473c43      0xb74e0ae7      0x8802ce7e      0x9493f0db
+       0xf30f9fd7      0x03661ac0      0xfc8b2895      0xe8643ae8
+       0x633b8be5      0x9056e50b      0x2323deec      0x8e787866
+       0x746bb4b7      0xebfeeb05      0x02afe01b      0x1582a924
+       0x7265b631      0x12c592ee      0xf6629f52      0xa5682346
+       0xac5f5866      0x643971be      0xb9782a4d      0x0355f6ca
+       0x001418c0      0xca97c1d3      0x2175611e      0x9ec4dd06
+       0xd17ba5c5      0xa00d132a      0xc37ab0ad      0xcbadb9cb
+       0x91fb8d08      0x733162fa      0xaca65f12      0x7d74b9b1
+       0x835ed5c3      0x9ffc1f2e      0xf7cd44b5      0x069414f5
+       0x148ae981      0x7a23281b      0x5992f041      0xf9ff3600
+       0x285272c1      0x50931337      0x3bc9d286      0x825130d1
+       0x7d50b511      0x2e631715      0xb50ee018      0x714a5795
+       0x9c95d165      0x34057f7b      0xc34105e8      0xca488d60
+       0x469c0a0b      0x34802889      0xed0e9f0e      0xa37931ea
+       0xa2685625      0xc2765d45      0x5579e907      0xedd484e3
+       0x35f454b7      0xc42edacb      0x6e7e5824      0xdcad31de
+       0xaf987db2      0x13c08a95      0x735f5d56      0x14e2ee33
+       0x65a6697f      0x74e79e3f      0x2c6f5017      0xc1777dbc
+       0x8a51a60e      0x25626410      0x18fa093e      0xc736bde8
+       0x10ca3e8f      0x6ede0978      0xaf3a9a75      0xb24acad5
+       0xa44b3031      0xb752935b      0xa8307f37      0x1c9dba35
+       0xf0e40311      0xddb26c80      0x70d81c76      0xe8581883
+       0xa8d29b12      0xf75921b7      0x15316278      0xe1d60cfc
+       0xebb8ff57      0x41266b16      0xe20ba098      0x6f2142e0
+       0x3a0b277f      0xcf74ee4a      0xf9f9d804      0x2b6dde0d
+       0xe395ac06      0x7f16a85a      0x2c398610      0x7e5c0209
+       0x3e2fefed      0x5f03c713      0xa6be16db      0xabce860e
+       0xa57822b0      0x2699a649      0x038a8951      0xd9767490
+       0xcef01cf9      0x1fa7392e      0xc0a4d251      0xbe260514
+       0x4d075328      0xa9a33cc0      0x0970b9e1      0xea3b66c9
+       0x496f2f7d      0xd431dade      0xd4f0982e      0xd85319ef
+       0x47d6de67      0xe9e7ff96      0x3c9278e2      0xae390d0e
+       0x2482fd84      0x3d5eb82b      0x041f2ed3      0x364bb59f
+       0xe841f3c7      0xd47afb55      0xd17048fb      0x9e1fe58c
+       0x50fb5ba9      0x3835203f      0x5fb45d46      0x0e224992
+       0x9f9ad591      0x0dad116f      0x573f019a      0x3c741dea
+       0x91680cd1      0xd98f1cf3      0xc1cac6a0      0x08eaafc4
+       0x1a4165ad      0xba887088      0x313526c2      0x1318a596
+       0xc8c83ad3      0x7a1275b2      0xf90921ec      0xad7c2177
+       0x759e1355      0x8e74e222      0xe97a09eb      0xca1e1f58
+       0x2507b38e      0x4c318284      0x48a708d9      0x0b4d05be
+       0x36f9501a      0x2326ca1e      0x2ec9f187      0x584e4bf1
+       0x06a07ac5      0x16446b28      0x16f2d837      0xd8f1498a
+       0xcfda17a6      0x3d0b8bee      0xc4d8f889      0xa0b1537b
+       0x1f00920e      0xa20c8d44      0x2d1e2993      0x15459051
+       0x58ef83f4      0xf406a745      0x37231c44      0x99358127
+       0x5990ce2f      0xb76bcffc      0xb4e1e14e      0x20538b52
+       0xa4e05749      0x1452111b      0x7ab4d513      0xf5aa2aaf
+       0xb025b075      0x9724466f      0xa5884e72      0xef288853
+       0x651cb1d9      0x2b2ff53e      0xffeaaadf      0xc63f0f3c
+       0x8955869e      0x3c4f572f      0x7e29d480      0x8a95aab5
+       0xe7ad4f27      0x97a87e3d      0x46dedfb5      0x27a1d50e
+       0x36b89960      0x94906e60      0xda72e714      0x2d962f4e
+       0xda523edb      0xbe9cfafb      0x85deb865      0xdb8ce67c
+       0x0dad75d3      0xfa4620c9      0xf524c61e      0x1d963d43
+       0xd5327f3d      0xbaca1c47      0x882629d8      0x6d21fb47
+       0xfa8e7136      0x7795035a      0xd64fea64      0x9910ca22
+       0x9e02da96      0x397573a2      0x3c791fd5      0x20f3b903
+       0x5ad5cc71      0x9cfd6cb2      0x77b42ac8      0x70c0b1e5
+       0x0751bb57      0xa5d00e1a      0x1e293cc5      0x3682334c
+       0x86724d1b      0xceb5c580      0x15a6b1b6      0x40e72961
+       0xf3ee7933      0x3b286b97      0x8eb43b67      0x43c1bd0b
+       0x60f3568b      0xc04d4812      0x5663bda3      0xf79b3fe1
+       0x8f322739      0xf2c6263d      0xcfd6edc9      0x6abdcd73
+       0x7064d9b0      0x603a9b46      0x1f1c327b      0x01820b15
+       0xbd9c7984      0xb797cd90      0x6391ff33      0x1cd88b90
+       0x311a2ea1      0x49433287      0x48b8e5b1      0xbbd09f66
+       0x56929fab      0xc8805952      0x64aa8771      0xa2062e65
+       0xa8ea119b      0xf2bf6280      0x202db2ab      0x0a569fed
+       0x8af1b9e2      0x0613be89      0xf6e7f3bb      0x33254426
+       0x5b145e71      0xd455d469      0xfca13489      0x5ef3161b
+       0xf9e4c11b      0x1585a566      0xd445f28e      0xd34f3116
+       0x4ee35745      0x3af7530d      0x56cf6443      0x570a7304
+       0xdd510fd2      0x51cb5791      0x6f2172ff      0x8541e632
+       0x58fd12a8      0x9ac35f7d      0x90fa9909      0x07dcc7c2
+       0x06375d01      0x8b80a3ed      0xd15f5578      0xa5919fa0
+       0x241c7c72      0x8805fd51      0xec9abf57      0xdc80a59d
+       0x0b046532      0x59d6ad5a      0x78013be3      0x3bf37e4f
+       0x4533cff5      0x94894744      0xca6ff328      0xa0af3a0a
+       0xb10c9053      0x55637d72      0x591e8dee      0x89850fc6
+       0x70a1a2f9      0x1be4473e      0x6f949576      0x4a534dec
+       0xae074a3c      0x7b8772ad      0x18576a9b      0xbbd70bf3
+       0x3fb84c0d      0x9aaf077c      0xbfbda40c      0x8c2d3df6
+       0x8f7cbdf5      0x36d5bc6c      0x9e781554      0xed21dce7
+       0x1969510c      0xa73d4cd1      0x984fe328      0x951ff009
+       0x2939ffff      0xe06565de      0xdf0f5395      0x82a9edc2
+       0xd3ae7f50      0x8e99986b      0x4ad34b85      0x3de28069
+       0xab3395ac      0x30fd2c2a      0xb558b98a      0xae996c7c
+       0x83d236fa      0x8ec6aed4      0x5db8510c      0x5dd11141
+       0x0613f868      0x13884605      0xa86037f9      0x9514497d
+       0xc3e1bc2c      0x7d4a0efd      0x87ab9fff      0x7df6742c
+       0xc10b0893      0x383f0b45      0x36fd56c0      0xff3449a6
+       0x15e137a3      0x6128e0cb      0x5ed51953      0x3c82a11a
+       0xeb875908      0x3c51641b      0x8b916d83      0x0c98ecf7
+       0x17bf4681      0xf8a31852      0xf4fc9706      0xbb85906b
+       0x922bc6a9      0x86e9b9da      0xff4909b9      0xec4af606
+       0x0dfba7b8      0xae4cdb22      0xc01b64c8      0x7bffb5d9
+       0xce05f32b      0x81f7e368      0xa4159a77      0x1bd93e9c
+       0x516c24ca      0x37aeadb0      0x85529a78      0x91373189
+       0xc0b8d897      0x2fbf5920      0x7917597a      0x2619a734
+       0xc9dd5610      0x468aac0a      0x9b26706b      0x7fe02d66
+       0xf4448dd9      0xecde6376      0x31509285      0x5e8dd54b
+       0x0873de48      0xc31644ed      0x238486dd      0x21c1cb9e
+       0xe3b1e1cb      0x887d59f2      0xaad4c10c      0x5ccf3211
+       0xe8de396e      0x83691dce      0x22931b67      0x23ae3b5b
+       0x522d2c38      0xbd76eb0f      0x045b1762      0x835b064d
+       0x5247ae9b      0x1bab3b52      0x562fdfbb      0x38fa07e5
+       0x9c54b72a      0xafc2ec23      0xf677822d      0x9a02b7f7
+       0x081b98cb      0x33e3180d      0x2ff02688      0x28387402
+       0x4bd8af81      0x2d58f284      0x4621b4b4      0x97a9607a
+       0x6d045127      0x9d814e55      0xcc161640      0x5c2e5460
+       0xe41ea73b      0x5160448c      0x722b4f7a      0x007b8eb7
+       0xd141bdff      0x7e6e99d2      0xe6c5009d      0x19a2d2a2
+       0xe0b9853d      0xacc54573      0x33ee759e      0x5a749b15
+       0x3fee27fe      0x73e40612      0x5b34e827      0x285701a7
+       0xa8f6cc22      0x6a77bb44      0x3f8e422e      0x1d3bbbd7
+       0x0cf9900e      0xa17be270      0x9f4a31c6      0xbf3ec715
+       0x1ffc10b3      0x83b950cf      0xbbd94cfa      0x3f2a72bb
+       0x224d9301      0xcfcd5656      0xf26acbee      0x89d1cdbe
+       0x162c775e      0x5f4f04ae      0xecbbd12e      0xd8e82dce
+       0x30b9f48e      0x1d625fc9      0x4ebe54ad      0x4275ac9d
+       0x6dd4d49b      0x8964e4b7      0xe1069692      0xe22cbb70
+       0x56f0acad      0x40c48126      0xc1fcc150      0xd5e67a62
+       0x31c634e3      0x1cf968ad      0xbb6dd3c9      0x6729af06
+       0x3d236b26      0xc4f0baca      0x6cac0f4c      0xa777b385
+       0x7aafda0f      0x10010dc6      0x8f792d99      0x1a5fab24
+       0xb699a96c      0x343cfa5b      0x2514ab8e      0x98521f22
+       0xbb232cfd      0x2086da38      0x3af0627e      0xc14093e1
+       0xfe79213f      0x288e945b      0xcccfdb0f      0xf5c6c221
+       0xa2769c12      0xc7c81079      0xc9cb61b8      0xb9e97b74
+       0x5ec73d1a      0x324e8290      0xb589179c      0x9cb1cc69
+       0x9ee6fba5      0xad3841c6      0x4be36d41      0xfa4fdfcd
+       0x1e0c7dda      0x54461d82      0x8a2af1f8      0x217a11d4
+       0x1c74701f      0xb03db469      0x99598b84      0xeab768b1
+       0x2158ef88      0xa398647c      0x68e026cf      0x9bc3387a
+       0xdcfd34d7      0x62e08157      0x5cdfa163      0x8fd5b481
+       0xac0cf677      0x13dce69f      0xedcb88dd      0xbea2fdd9
+       0xe0ea2067      0x519b1711      0x26b9eaea      0xa2686d14
+       0xca5a0642      0xe8114a62      0x8390e885      0xd2895799
+       0x8fa4f14c      0xdd28c8e5      0xcb0cad8d      0x179603a8
+       0xf7fa54d4      0x90b70289      0x74896aea      0x9275ce78
+       0x34199028      0xe63312ec      0x4c77bcc9      0x8ef4d631
+       0xaa02c7b5      0xa44fa37d      0x7bd966c2      0xe73edd6b
+       0x621f45a0      0xe52b0978      0xa240a268      0x460dae64
+       0x8db74a04      0x85fe1425      0x6ba1bfd9      0xf569bf46
+       0x8ff5802c      0x881acd6e      0x37d8ae71      0xa285bd8b
+       0xce83b57f      0xa7800401      0x63d286e4      0x2f58f23e
+       0x8f2dd0a5      0x9903e6af      0x303f32d4      0xe15e77b7
+       0xcad22621      0x2a025aed      0xa89f13e4      0x591d0db7
+       0xadc34571      0xf1556f93      0x8b8b7252      0xf9740b69
+       0xd05c37ab      0x934bf91d      0x1cecfadf      0xd528d15a
+       0x861f8a1e      0x4bdc5557      0x7661490b      0x3bf626ee
+       0x1fa62544      0xbfd6a9b3      0x2fbe5dec      0x3c9f9ddd
+       0x1ed99112      0xdc1c5d30      0x4afe4868      0xb4f6c4ed
+       0x58cf781a      0xeabc5fde      0x559750ec      0x72661357
+       0x2c8a9d67      0xf87d108e      0x0b4f84d0      0x375ce5c3
+       0x4c308df1      0xa40548d8      0xf281c575      0xa5bbbe6c
+       0x81dbc523      0x91212d7e      0x968b2ac6      0x82135861
+       0x70d78dc0      0xbf847a79      0x6809ea9a      0x8584d69b
+       0x6637331c      0x10f33234      0x5058bcb9      0x88be0c87
+       0x9254fb77      0x43976553      0x5e4968e9      0x2d4f0ee5
+       0x325b4e4f      0x831b5647      0xd7485367      0xc82f770d
+       0x25ddbe8f      0xf58265ea      0xc41a19b2      0x274115b5
+       0x4713d209      0x3728fbd2      0x627263cc      0x3d11cfb1
+       0x5455e7cc      0x77f5ea5b      0x6ad0fda0      0xe778ada3
+       0x9a9216ce      0x7858edab      0x456d7a86      0x0d8cad31
+       0xc1d34ac0      0x2492727f      0xc610ed57      0x6bc3bf8f
+       0x6345e6ac      0xe5a8725a      0xe281ced0      0xfb6ff15e
+       0x1865b013      0x4c6d268d      0x1fec7ce3      0xa5bdae31
+       0x27d44731      0x3b579637      0x87e5587b      0x30b9bad8
+       0x2ae8e492      0xb3f18a17      0xcea86ccd      0x35cedf32
+       0x5c09ff91      0x5a5b4dfe      0x40db65f8      0x29b575b3
+       0x59322e4e      0xd8b6ad6b      0x637a37b5      0x6f20a9b8
+       0x805d3745      0xcd0c3baa      0x3bcc2b65      0x495f1893
+       0xf9acd6c1      0x89219844      0x801b8945      0x318b78f0
+       0xb4f59a26      0xf805dfed      0xc8990b39      0xcb88ace1
+       0xb8ef6c2a      0xb79263d8      0x1a24a462      0x89a617f1
+       0xd2edea67      0x2ce1dc89      0xe20e93de      0xb4930958
+       0xd570f3b1      0x27bc43c7      0xcf21567d      0x735b7c12
+       0xed2ffdfa      0x798e0939      0xe8cb7ad4      0xe69862e7
+       0x1c417ee2      0x247b0eb6      0x68697526      0xe68cd314
+       0xa24bb8d7      0xa7f6b218      0xcd0bbfed      0xec66536a
+       0x4a650627      0xe419fed4      0xcb10a99f      0x7ad024a9
+       0x8ad145fd      0x438d74b2      0xb4162b64      0xe19154c0
+       0xff2e57be      0x8e77d788      0xd09c9c7f      0xe42838df
+       0xcd07f3cd      0xf3c0a456      0xe57ace44      0x71f47613
+       0x03a3b469      0xfbd5b964      0x8a4f51cf      0x2dcbd593
+       0x21b50a82      0x685fc7f4      0x7410f798      0x1c7da00c
+       0x9989a8c7      0x5f888117      0x2b2e1bd6      0x0baad325
+       0x31863edc      0x1db5913a      0xbfba2b82      0x1fdc1823
+       0xdf65d342      0x0da872a0      0xf1eaadac      0x5aee5ab5
+       0xc75bfbfe      0xa0ad157e      0x15c1a77e      0xd4a04a90
+       0x6358b67b      0x96287d21      0xd161b25c      0x1b46264c
+       0x449e099c      0x75014182      0x9ff0cee2      0x8f8850bd
+       0x7be71c35      0x057860b3      0x947e7b3c      0xcdf7ac71
+       0x81557c7f      0x6e38351a      0x82ea1a07      0x467f9d3e
+       0xba182513      0x167e9049      0xce626890      0x6547dc59
+       0xe107444e      0xcf10e0d2      0x321f407a      0xfd20cdd6
+       0x46d61e29      0xdf42d913      0xbe997d24      0xc3dd5649
+       0x00f64534      0xdc77b452      0x7d65c7df      0xf626ef4a
+       0xea1f36dd      0x33353840      0x1e0ad383      0x2a19a6f2
+       0x10e6aa40      0x145597ba      0xf84f70c6      0x49a43447
+       0xb57e0ebc      0x8cadff1c      0x96291de9      0xa4aab08c
+       0x938ea090      0xcc2e56d6      0xd88f8530      0x966b59d2
+       0x75cddeda      0xca92d382      0xe60bfd25      0xa2a50481
+       0x036fc2e5      0xebc64b63      0xb60fcb4b      0x84b18ae0
+       0x2301f6d6      0xf2627f7e      0x116e899b      0x59b32400
+       0xe34a5f10      0x27ea2775      0xcffd4524      0x99ad1760
+       0x28dc9f42      0x76546637      0x09b31d5d      0x6057a2a0
+       0x814e342f      0xc0310ffb      0x09221293      0xc23489fc
+       0x4ffdf69a      0xfd177e65      0xa4c62313      0x6ebdb347
+       0xde1d7311      0x6b5f69ff      0x712cee14      0x0876287e
+       0xe6f06c83      0xa22afd75      0x4cada5b9      0xf4efb45b
+       0x168c1900      0x119999e1      0x31790fd2      0xc6e22df7
+       0xbaef3e37      0x59b757f0      0x2f76c65c      0xb33a8603
+       0xdaf08617      0xc4f7a13e      0x8b32edfe      0x0246bfe5
+       0x28107d3b      0x6ae259aa      0x6cb8c884      0xa831298e
+       0x745fa963      0x1250404b      0x21a9d2fb      0xb684f25d
+       0x4137b496      0x00ff06b4      0x0c641a34      0xae08bf4f
+       0x4814966b      0x46d15123      0x3a999946      0x98e88d88
+       0xbc5a133a      0x5c8fc249      0xe9444319      0xff7d6782
+       0xe82681a8      0xef34f1d6      0x3368c6d8      0xd13560f4
+       0xbe6e2d76      0x99080e3e      0xf62242c7      0x40aa96e4
+       0x70da6580      0x59e2a1cf      0x7d917654      0xf8a6c389
+       0x88d70c92      0x96038958      0xd7f325f6      0x9973b9a9
+       0xf3372375      0xc2429c7b      0xeace3170      0xd4972d34
+       0xca54fe57      0xcd9e32aa      0x74da0d70      0xa895d3ca
+       0x6bb72951      0x4960b6d8      0xb79105fa      0x4741e043
+       0xacd5047f      0x11f842e2      0xb6a825f1      0x0f504783
+       0xf2c3f466      0x1919d6d7      0xd8c6b3da      0x187c1443
+       0xa8e4dc49      0x2f32e814      0xa35506cd      0xbae980d7
+       0x757f603a      0x56a825fe      0x8f16b8b0      0xe5a76498
+       0xab7f4a31      0x1880708a      0x87220eb9      0xb556cd27
+       0x4f8f58ea      0x6a921eb5      0xd46bb334      0x7f639301
+       0xb677433e      0x9b4502c8      0xae712cb4      0xa0645573
+       0xa4c11528      0x7f338aa7      0xa8959900      0xafe37968
+       0x6c86ced6      0xe7e4e507      0xe11e4342      0x89c7ed69
+       0x36116943      0xf3b387e3      0x335b69a7      0x68c885cd
+       0xf27bc66b      0xe86dd580      0x6b5bf692      0x16ad19fc
+       0x6003a9a2      0xb4dd4ee1      0xc1d61118      0xa299a17a
+       0x5f11feff      0x2066d90e      0x480d9eec      0x130ce2e2
+       0xbe9c2d80      0xe9c36b62      0x84e788d4      0xf21d9115
+       0xe958c53f      0xb923415b      0x30a43a13      0x5f76a766
+       0xd3260ac3      0x0c998080      0xb6f0ee3d      0x87fc5896
+       0x0173a21a      0xe5144ee7      0xdc94596b      0xd8a27a41
+       0xd6e56444      0xc64cef84      0xd6ef564c      0x62b02083
+       0xeda77cde      0xf9afd453      0xebce3963      0xc4b203af
+       0x8a9bfeb9      0xdd10c5cc      0x15009395      0x8923663c
+       0x2d1d7941      0xeec2b48b      0xb574bb65      0xa88661d8
+       0x85c906a7      0x4809d4c9      0x310a4338      0x3e9ff5be
+       0x75d986cf      0x47f2e74c      0x85a3b24f      0x2edc5152
+       0x5428bac5      0x22522ca5      0xc43a4c44      0x06d8ef65
+       0x3c244839      0x47cb9214      0x08346904      0x1d8b9b77
+       0x77876246      0x3181b22b      0x9001574c      0xa1209405
+       0xce0a23ff      0x2ad6b7af      0x976413ee      0x2aab0f94
+       0x737776f2      0xf2e252eb      0x3c3c0d39      0x66521301
+       0xefa53ce3      0xf460e7e8      0xeb191b16      0xa1c437ab
+       0x351fe90b      0x695c6e5a      0x5c5c988e      0x6af9c946
+       0x538420b0      0x80aee531      0xa4c93d7f      0x1a4a0a88
+       0x27746ecd      0x78a108b5      0xecca3c7e      0x482a8ac8
+       0x1bfbbfbb      0xabc6972f      0xfd4bbb35      0xee51f092
+       0x0ad74def      0x5afd2a10      0xbd851e8c      0x91a124a6
+       0x30b37b7e      0x169571e2      0x4bc68fe7      0xb56753a9
+       0x1c797aed      0x7ff7dd61      0x607213fe      0xe37e297b
+       0x2ed2ea45      0x9545e54c      0x40004842      0xf5ca1645
+       0x8c0f13a4      0x292929fa      0xbc5db147      0xa79292b6
+       0xec4d98df      0xde9d96f2      0x33dd8e1f      0x664f24fd
+       0x082a0a01      0x34785b5f      0x390b6779      0x38c80650
+       0xf5d5ff02      0x1d65cbbd      0xbe5dbe04      0x48fee382
+       0x8529b226      0x27fcf35b      0x47069a0e      0xc87b09b2
+       0xd87e86b9      0xe99ea4f1      0xdb7dc858      0x31ee8f30
+       0x0e91c9a4      0x027b9e5b      0x3dfba09d      0x02ad8818
+       0x7b551aa3      0xcc327b67      0x95a5fe3d      0x4bf1695e
+       0xaf1b786c      0xcbb3d68d      0xbdc99a8d      0x5fbbd10a
+       0x4e7e3bf5      0xb8a3e180      0x9d35d659      0x4d7233ed
+       0x1341ccf5      0x3f9feab5      0xcef7b7a9      0x6e4479bf
+       0xf79411da      0x8a891828      0x58de9d1a      0x086fad59
+       0x7d7f2517      0x710af6b2      0x396693f4      0x800e2c8a
+       0x01e4c229      0xe2204834      0x33e07ede      0x3a7e535f
+       0x50b33269      0xa7d77528      0xa158450e      0x83136519
+       0x9670f09c      0xb6fccf7e      0x71baa055      0xa198aad2
+       0x89cd3ae3      0xf027a1b4      0x3fe3eac5      0x559e9441
+       0x23be91fb      0x93c116c6      0xac0cb029      0x99aa4735
+       0xc19bf7dc      0xf3f2c2ed      0x7f85d33e      0xe24c6e2e
+       0x9c5495be      0xf895a51a      0x593fdee7      0x788edcda
+       0x830c013b      0x8096696a      0x8a3e6559      0x88cb68c5
+       0x97396635      0xa659d10e      0xfa8f4a83      0x3777a83f
+       0xc9a9375a      0xe6b81dea      0xa46638f0      0x45547950
+       0xf1d720af      0xa2612767      0xc9583113      0xd970abc3
+       0xb7e77124      0xc846d401      0x463fb1a1      0xf4798cd8
+       0x83304ee8      0xbf43891d      0x811c09c5      0x32cd41a7
+       0xa7daec30      0x818b86a1      0x67b7fa87      0xff5b2c0e
+       0x9a69ebe4      0x25e80d81      0x72ee9e5b      0x335eb56d
+       0xc8faaca6      0xf034cad5      0xc5fc1482      0xfef8cee6
+       0x326f459e      0xd8068fde      0x8c04de96      0x52999b49
+       0xbb187fdc      0x01bdeb7d      0xb59b4da3      0x92ec8b4c
+       0x942605d4      0x5efc4f2b      0xa781db90      0x1af56e54
+       0xa0bce7a5      0xf7f657a5      0x6f790d4d      0x43bd6451
+       0x64720a13      0x0f3937f3      0x2fc2a16f      0x3e53be1a
+       0x830befee      0xfe56cdfd      0x267fa267      0x021c6284
+       0x97f2559a      0xa46c1abb      0x2ba30b07      0x25c13642
+       0xaea3681b      0x85a7d05b      0xf4c7fcf0      0xda1950c3
+       0xc83db54c      0xd445db85      0xd242edb4      0xd13468a7
+       0xca600058      0x592d24cc      0x37336503      0xf11e65ea
+       0xe3241468      0x6ed653e3      0xf2cffead      0x9005f06e
+       0x26dc97e6      0x6c3c0272      0x0398f3dc      0x5231f2a8
+       0xd8f73cc3      0xad8af000      0xb32fe57d      0x609b172a
+       0x9c5e66eb      0x03dd9d0e      0xeefb1329      0xee1b320c
+       0xdbebd09a      0x86c72c92      0x5d546bc3      0x3d05328b
+       0x2dd37833      0xc1cf1827      0x9c67e6c8      0x62c8ab1d
+       0x8bb723ad      0x78392178      0x510ab255      0x90ac2426
+       0xc0d2b6e4      0x0fb602fc      0x14ef802b      0x84f64723
+       0x01f39092      0xfd25ffb8      0xd653c708      0xcf7a2be4
+       0xd304b3ee      0x50a1731e      0x3e68ebfd      0x5fd37931
+       0x08276248      0x97e171db      0xcda437ee      0x8890b6c5
+       0x53581ce1      0x61ecf3c6      0x98f5d737      0x9a611f9c
+       0x5814a31f      0xf518a5be      0x3b1abaaf      0xf2848ff7
+       0xa4421e5c      0xc7a772f4      0xd5440c81      0x70fa5763
+       0x6e4df117      0xc68b910c      0x4bf2af94      0xf4fd2b96
+       0x1e3da8a1      0x2eae6466      0x1f3bf947      0xd184ddaf
+       0xfaa96a46      0x562d3822      0x870cf98f      0x0d97c0a2
+       0x4c5cbdb3      0x1947efe2      0xf925752e      0x1f1244f8
+       0x8f37c900      0xd2628f77      0xbe7a9fd7      0x27c9c5a3
+       0xaa9c7859      0xfc20d88f      0xc3cfdf95      0xc0862834
+       0xfe7c9584      0xfde222de      0x022f1c56      0xae3b435c
+       0xc39aac0c      0x7ef0b826      0x53afa2ad      0xcc078e88
+       0xab55f5f3      0x4c1b8efb      0x5e80ca4f      0x1716a84d
+       0xd3b47f7f      0x1561a47d      0xf9aa466e      0x7b54c490
+       0x0da5cf26      0x9931aba5      0x632a94c5      0xd8ecfb0e
+       0x987e7151      0x8c304f01      0x86ed0d85      0xd173bffd
+       0x19e9de74      0x62dd1d50      0xdf441d34      0xa8816141
+       0xce8839da      0xb824281c      0xe3e29334      0x37975262
+       0x202d80f7      0x35a88fad      0x86902b37      0x98f43d1b
+       0xb7518b35      0xf9f16932      0xbbc7097f      0xef86e0a2
+       0x642dac09      0x07ccce92      0xbf161d30      0x2392fb13
+       0x5b94c5ea      0x2275547d      0x52543a5b      0x26d8be56
+       0x2b7c0284      0xd2e6b34c      0x2de42560      0x0a1af77a
+       0xf7acafa5      0xcb0c6d73      0x7ab48d17      0x57f54fff
+       0xcfb735fb      0xe0811c17      0x17c6f0bf      0x1f8a9c6b
+       0x70708973      0xe51ffde8      0xbac040d0      0xc4cf1aec
+       0xc85180ab      0xe324521b      0xeb6af9f3      0xd7cca0c2
+       0xfed0a8b5      0x93573627      0x09fa137d      0x8c029cf4
+       0x36439d3c      0x89e184e7      0x64790ab6      0xe845f1db
+       0xb60056e0      0x3a79895e      0x89198c10      0x663cdeb1
+       0x487b5f5c      0x2a1ccc04      0x7822b459      0xc191397b
+       0x026c2ade      0x699ff8f7      0xc4a4db8c      0x4297aaa2
+       0x893da153      0xa3bfd4ce      0x30258664      0x2673767b
+       0x8a97ce71      0xff549e00      0x2a62802f      0x9d0d074b
+       0x1e36ce47      0x011cc6a4      0xfd2843cc      0x5dbe9d55
+       0x9ecb987e      0xac82e8c3      0xefd79ced      0xb4999f71
+       0x1f8af041      0x4563fa4f      0x800a9e3d      0xb21e7618
+       0x6dd1dae0      0x1e6b6f2d      0xdf657f65      0x87065680
+       0xe918f2c4      0x90334203      0x7f321a34      0x5b6023fe
+       0xc5dc340f      0x7710cf9d      0x752d9b5e      0x3406e103
+       0xfd59dbb6      0xd31e992b      0x7196956c      0x14c4390c
+       0x1a4a74d5      0x0348088b      0x5867c1da      0x28452eb2
+       0x9efd5fb9      0x5d488ab7      0xaec910c3      0x69f8cfde
+       0x93e0eb56      0xa116323d      0xa8af57a1      0x75167cbd
+       0x82b587ee      0xdfff5917      0x71e0e97e      0xeaa20293
+       0x10f062e7      0xcb0f15c2      0xc14ce998      0x16b41f45
+       0x7626a30e      0x78253e15      0x07291d8f      0xfe3a85a7
+       0xbe55c931      0xc32ae20b      0x42a724f2      0xafbd658e
+       0x252a71f2      0x40e96cd4      0xc8ec4bc6      0xe43badf3
+       0x454e88e6      0xfb4f3d72      0x2c024b77      0xdf6379e4
+       0x3ad1ac0d      0x57d461f4      0x70fdecc9      0x5ab97fac
+       0xe3421259      0xba10002e      0x3f10aa09      0x1f65fbca
+       0xfd963911      0xd23f00d5      0x28806fa9      0x8ec95e0c
+       0xb6110ec2      0xcb314825      0xcff7a277      0x7b48892a
+       0xfd8c297c      0x036b2e5b      0xbd07af50      0xb3858b09
+       0x27f92f45      0x7764bdaa      0x7202dcc9      0x86b310ca
+       0x32b1a8fc      0xa213783b      0x188f43d1      0xa8830b8d
+       0x3f97df21      0x90db2fd1      0x3578e3d0      0x83b62ecc
+       0x98f37ccf      0x8774c96c      0x1eda3f8a      0xc81bee58
+       0xd2313c8c      0xb73fa31c      0x9a9227f3      0xd126e710
+       0x2f8fd633      0x1e617b3e      0x2a3e1a94      0x1626eab5
+       0x920a8ea1      0x5416ec15      0xf5e9dc6d      0x8eb85d9f
+       0x3ac965f2      0x506cabb4      0x1ac82512      0xf7e54922
+       0x816ce973      0xd4a698c6      0x5a848c08      0xc836b193
+       0x9b7431dc      0x22567c93      0x6ad6b192      0x54282257
+       0xb6d37f63      0xe171ba2d      0x2c62a40b      0x98fc76fe
+       0x1910ed76      0x42aad6cf      0x0b973b81      0xa8250bf5
+       0x3095fdc9      0xa551c77b      0x0607055f      0x69c22fc2
+       0x700b34dd      0x0a3ea687      0x9fd82d86      0x01102d91
+       0xf111df9d      0xeb3506f5      0x72e7bb6a      0x8fb54935
+       0x08f463ff      0xcd1da8c6      0xae29c718      0xa3c1c1de
+       0x973d6bd6      0x8577f767      0xec747096      0x4b4436ea
+       0xd1b23b12      0xc1fad2c2      0xc3d4889b      0xd2592576
+       0x68354419      0xefcb7b5d      0xf3bfc0e1      0x0491d0cd
+       0x419b05a6      0xc42b0f59      0x9dae25f9      0xf7805eae
+       0xd65e9681      0x46c7fa50      0xcd57f133      0xdb60792b
+       0xabbbd12d      0x942cad96      0xf166e608      0x89304d4f
+       0x15cce276      0x1560437f      0x3e0de399      0x1b5f81d0
+       0x6690b393      0x66e3628e      0xd63910b3      0xb7c86a88
+       0xccb0e1d2      0x7b420fba      0xec573a13      0x36db1aef
+       0x440f0140      0x6ecfc3f6      0xa357a256      0x021f2b45
+       0xf609d50b      0x2dcfbff9      0x86bb63d9      0xa288b02b
+       0x9d16586f      0x4390c46c      0x5af62467      0xc1a89a11
+       0x62abba4c      0xc0fb47b0      0x7b2cff71      0x34505aba
+       0x2f6605b7      0xb8bdd96b      0x5ac2421b      0x31c8c7b4
+       0x21d7cd2d      0xc74cd5a2      0x8c03e9f4      0xc28d754e
+       0xcff55a16      0x2aea65e1      0xedc89507      0xe5211c2f
+       0xc4b4c048      0x3390c64a      0x275b5c04      0xdb7bac18
+       0xfb06470d      0xdb9133a3      0x081cb969      0xb327843c
+       0x8bb97fe4      0xcb477acf      0xf392ba40      0x3e4a6037
+       0x20af5291      0xce5c2023      0xa7796930      0x1d714fb9
+       0xc80ca541      0xf7207bd6      0xbed3a436      0x702147ae
+       0x1e812c5e      0x44302902      0x280ccf78      0x3d84b333
+       0xdea40080      0xb6fcff1a      0x8076e4b5      0x1aa26f2f
+       0x99dcacd8      0x3329a829      0xc2679c34      0xf7431124
+       0xd472e452      0x6e0aa9b8      0xb07d21ae      0x77f4253c
+       0x35302203      0x1bab342e      0xa99bf1c1      0xf31b3097
+       0x22267281      0xc8368c39      0x17eac5ad      0x528f57d3
+       0x7b5fd506      0xdff6f577      0xd0ee154b      0xe82feaf9
+       0xf660ea59      0x6f1f4182      0xbdc94b0c      0xf6bbd8a6
+       0x4f19dc81      0x11425818      0xe9b65abb      0xd796f2d3
+       0x245ecdb4      0xbe75d4cc      0xf8c5727d      0x46278c8a
+       0xcd41b7cc      0xba02ba73      0x78ed7698      0x2a9a504f
+       0x38e18283      0xbe1f8caa      0xdd9dae4e      0x447cd909
+       0x29e442d9      0x116599fd      0x1dedf028      0x762ef3fc
+       0x8bfd67a4      0xd448e099      0x5ab081f5      0xfbfc7499
+       0x5aab99fb      0x8745802a      0x9388013f      0x0d1c8afc
+       0xeef8d9de      0xf8dcc8b0      0x1f62597c      0x1305d02d
+       0x929e5f38      0x8e052a26      0xf6089704      0x55c9e4f5
+       0x867ec68a      0x403e58cb      0xc1de4ffd      0x22aa38ba
+       0x6aee81f0      0x59b31342      0xbcfea246      0x1683920a
+       0xb3ab26cf      0x7439465d      0xc2cef68c      0xe2f5cc07
+       0x10b1b604      0x6bfa6653      0x45bd3b46      0xfeb30a41
+       0x5943f961      0x2440df12      0xa572f8f4      0x2e135f74
+       0xacf6aae0      0xd959eb5f      0xf9c59a32      0xf0f93d61
+       0x4e0bae26      0xaa0d08ca      0xdfc9f82b      0x5bb1fa07
+       0xbf437938      0x5040681b      0x5d4fa4c6      0x7762a6b4
+       0xa34c31e5      0xddf70a08      0x29da3c77      0xc27fddca
+       0xefd4d9d7      0x92aae611      0x2bdbc968      0x87ae5b72
+       0x7d6bc790      0x873ef76c      0xdab885f4      0x753ebcdd
+       0x55ae2846      0x76b223de      0xeabed0e5      0xda96b1aa
+       0x6146251e      0x2c0d4332      0x4301e497      0x633cdef0
+       0xd7dce9a9      0xdf561e30      0x9181ebd1      0xa68f4d21
+       0xd89e83d3      0x2daf3c76      0x7b825691      0x96a1b53c
+       0x5805624e      0x55a3795b      0xc98cc5fd      0x8c51fc32
+       0xeb320f13      0x0e9264cd      0xbd8e8951      0x9f2b2cc7
+       0x76bfc3d5      0x1cec2ac0      0xc464a354      0x0e0a2048
+       0x022ea658      0xdbac711b      0x0fd18f98      0xc4bac56b
+       0x9aa321bd      0x4e40ebb5      0x0acc9069      0x1ac881a8
+       0x59539d9e      0xa9bb184d      0x6aadd34d      0xfa57d95b
+       0x31249812      0xebf818b3      0x90661127      0x2ea99293
+       0x1c51d486      0x001c1355      0xab0baa44      0x6326d159
+       0xde0fbf85      0xbd113265      0x106f959f      0xcece40b2
+       0xf144e295      0xe60c033a      0x3e66ba7d      0x449f4b9f
+       0xec558982      0x46b69668      0x5d5640d2      0x133092f7
+       0x69217b68      0x598a695c      0x41930ff9      0x42ec8ec5
+       0xb039b0aa      0xdbfbde89      0x6d03bcc7      0xc9cd5733
+       0xa7fd4d45      0x8ea1f07d      0x25d57fec      0xc670190b
+       0xb6d78a20      0x803c02bb      0x2a4301a2      0x7d3ff663
+       0x84774cd7      0xcb1eb9a9      0x70004c34      0xcfc4caf0
+       0x30770345      0x5c3ec2cd      0x4748ac5e      0x82c9003c
+       0x49866393      0xee85a73f      0xc898b43b      0x2f0444b1
+       0xa0e6c421      0x0de95e81      0xbde1ba37      0xe37d80fe
+       0xb79c27ad      0xdc0acf1a      0xb7591505      0x373cad2b
+       0x00b4f562      0x46539867      0x9bc81fa8      0x9e39845b
+       0x560f4b5a      0x0f586c3d      0xe23f9264      0xa5823db3
+       0x6328f8b2      0x5e004072      0x1ef40013      0xa9aa6513
+       0x42097240      0x049702e4      0xf449210d      0xfdfcb404
+       0x7fbcec7c      0x56676211      0x74f11ff2      0xddf131c1
+       0xef51d94c      0xc7048465      0x72365cb5      0xd8b7a520
+       0xa15df264      0x595ce809      0x6e6df1c8      0x0fc76cbe
+       0x4c0174f7      0xafd6e518      0x36dbf4a6      0x6f05dd75
+       0xb323710a      0xe93900fa      0x1fad3f4a      0x8ef5c147
+       0xb111a1f5      0x15d10afb      0x991e6cbd      0x1d18dd7e
+       0x8dfbf3b5      0x86b439e1      0x7f5387e5      0xb9c2691d
+       0xba2a764d      0x72dc59c2      0x221f3732      0xa63fcc85
+       0x82032df4      0x67b654b4      0xbdae6cf9      0x5add5764
+       0xe563c80e      0x69600181      0xc4afb314      0x41acc35e
+       0x3c510b18      0x81020fac      0x5a3b3a17      0x1d291b04
+       0xae0234a8      0xd7e024e0      0x00f9949e      0x7cbe71a8
+       0xaaa540ff      0xecf8eeba      0x613a7128      0xc3fde063
+       0x8c0fa39c      0x0d3a06cb      0x38d9f12d      0xf1ec603a
+       0xadba2d97      0x8e750f05      0xfbc8e6aa      0x77e27fc7
+       0x5df86734      0xae941a3c      0x447bb6e3      0x215ead79
+       0xd60053ae      0x36ac6433      0x24c71bfe      0x15862269
+       0x39853b18      0x886b8abb      0x1af9519f      0xccc58ba5
+       0xeafc49b5      0x517aa4c8      0xd2963ca8      0x54161cbb
+       0x5e028476      0x2e00f374      0x187842d9      0x59f465c5
+       0x65b04c2c      0x327b6b75      0xfa4f7b82      0xb412d2c2
+       0xcc7fd58f      0x2dda5fa8      0xb6f7aa78      0xe48fb5fe
+       0x9c8e28bf      0x698e2652      0x41833198      0x60b4e2af
+       0x064b056d      0x67fa0db1      0xa6ae4827      0xb0006df2
+       0x6b8ad4e1      0x8de98db1      0xc45a737e      0x2e0c3ff1
+       0x9a76dcf9      0x979ed5f4      0xea6135f7      0x6d733694
+       0xdd2778d7      0x36ca722b      0x346fe5f8      0x8187f615
+       0xcc933395      0xd74c2838      0xb00dbe54      0x57070673
+       0x433d98d3      0x7d61cb24      0x6fcd51dc      0x2f8d61bc
+       0xbc034a0c      0x6930a618      0x234ad7d0      0x25d840e9
+       0x41b8fff6      0x099a619d      0x6afa7955      0xe7996bb7
+       0x9441fa51      0x1ffee7a6      0x1fd664af      0xcd7435dc
+       0x9a9963e4      0x17b4f0ec      0x36978352      0x7e2c48bd
+       0xee783f1b      0x47026816      0xf076c1b7      0xeb550744
+       0x92a27989      0x6dd6511e      0x4f08fea9      0xae6cf35d
+       0x8940b1f0      0xc2fe91a9      0xf8bfef82      0xc5a785ff
+       0x35f51ca7      0x970dad84      0x8fd8e53b      0x2025d130
+       0xbaea269b      0x12c12ea3      0xcb4c1d29      0x65f310a6
+       0x9c3d4c1f      0x561f6159      0x80fa4b6b      0xc407f56a
+       0x0a234ee4      0x8ce074cc      0x5cdc86cf      0x7e20d12f
+       0x71c1598a      0x0181c857      0x7b1ea5c4      0x9dd3534a
+       0x00ecdb21      0x081aa90c      0x44c5d9ff      0x5aaa8e52
+       0xd99b468e      0xc3df7aab      0xac8193db      0xb2cc345d
+       0x86ddf327      0xb6550f70      0xffe23d81      0xac3acbb2
+       0x1b31b8c9      0x01893169      0x4eb23d78      0xc6735d8d
+       0xdf574536      0x41474eb8      0x50d59c1a      0xd9b1ff0e
+       0x50662a2e      0xc11fe2a3      0x9f9140e8      0xacad95a4
+       0x1c9a5536      0xd95c5505      0x999ce085      0x7e66d307
+       0x4b2f9b2a      0xc7167d7b      0x99db8e3a      0x63db373d
+       0x31584376      0x10659271      0x64d9c513      0xad7f3e8d
+       0x8ca2d4bc      0xeda05bb9      0xad8b9ad9      0x6eee8d94
+       0xe1cee469      0xbf049e8c      0xa4517aa3      0xbd57369e
+       0x8f626a04      0x702317fe      0xc1927a2b      0x9af537ae
+       0x39e057ef      0xf769e765      0xd175e771      0x8767af10
+       0x0c7be609      0x482066d5      0xa70343eb      0xb2ba635e
+       0x6318b032      0xa6b63348      0x83757f17      0x116fd8ef
+       0xdd612a25      0x4d12c971      0xcef2e76a      0x4adf66b3
+       0x29f7a6fe      0x66f247b3      0x9f1f578f      0xa76021a5
+       0x51a39952      0xe2c954b7      0xb7924940      0xa80e9d51
+       0x0b28027b      0x43c0ea90      0xafc2589a      0x913b578f
+       0x1ac94ced      0x9f79d3c8      0x7a105047      0x6b7addf4
+       0x8f309688      0xbdb80562      0x39324225      0x93d83cce
+       0xcec53c2c      0x46fd263e      0x4bd4d850      0x7d788f80
+       0xcbbe5b2c      0xc25f2a50      0xcb50e317      0x399bc9ce
+       0x31a7e47e      0x6b508df0      0x68b5d606      0xdd66f1f7
+       0x0e971400      0x3ffae5b6      0x6d8de773      0xac7796bf
+       0x6ba7a0ed      0x3c1fd957      0x528e76b7      0x76c70aae
+       0x3a1c1acc      0xbaa62887      0x50e47d57      0xd244c3aa
+       0xae721ff0      0x029abb7f      0xe7b5e29d      0xe13ec747
+       0x5129b1bb      0x894b1416      0xc88751a5      0x60551840
+       0x339b0170      0x0022ae86      0xdf9d8cfe      0x3950ef28
+       0x07ddff1a      0x75328ee9      0xa93dde04      0xc3042c02
+       0x828e4b21      0x0d30b3c4      0xd8a18f63      0x077c7ddf
+       0xefc69b27      0xc68ea174      0xea256564      0x104aee19
+       0xc14de745      0x03345345      0x33910c03      0x90281d71
+       0x716cd399      0x2ff7e2b6      0x301029c4      0xf6b95db5
+       0x41362819      0x9ab846fd      0x7bf6d4c3      0x52b7915e
+       0x745b0b10      0x9e5c619c      0xfde2e6e7      0xe510d602
+       0x60c7ee72      0x9a8129b7      0xc41cb083      0x2243ae79
+       0x23aec0fd      0x92a13ada      0xdd00f7fd      0x3f7cc01d
+       0x999b793a      0x3e6e8944      0x9a24c998      0x2f7a7595
+       0x96953045      0xa1d49c39      0xa9a49b6b      0x3ad37d77
+       0xcc77a270      0xac2fab74      0x857f1f94      0x56684ee7
+       0xbedfec7c      0x7b88c599      0x2a6670bb      0xa457bd42
+       0xa14043c3      0xd1762926      0x303419ec      0xbebf610e
+       0x9546e7ec      0xd0ed618b      0x5388d1c4      0xb4f0d001
+       0x8f6d0335      0xfd6d1f40      0x6e31fe45      0x8a7a71ed
+       0x8178070e      0xefb7b9a5      0x10d5edaa      0x76380e27
+       0x46c5ba87      0xeccfaadb      0xae5a31d0      0xebe338e0
+       0x8d94f0fb      0x7a55e038      0xdbf4de5f      0x08f17fe7
+       0x39415f0a      0x0e853177      0x1e3cf4e6      0x6d25cbd6
+       0xb296e31f      0x6536509e      0x4de64a63      0x4dec224c
+       0x9aefa2df      0x4a2ddb6d      0x5145956a      0x524711b1
+       0x0887dc40      0x8d6f8c51      0x6981bf43      0x1cf309a6
+       0xa7536ac2      0x212a4579      0xdf006f9f      0x7e8e78b3
+       0x69a601b2      0x3b6ccb70      0xabda5887      0x7b0b2aee
+       0xbcb96f74      0xb259b163      0x980ab7db      0xbdc52a18
+       0x37b6bfdc      0x6c3fd2f4      0x4a819517      0x6ae9216e
+       0x0d0073f8      0xb32564b0      0x2a4baf45      0x642aa210
+       0xc44e8182      0x91bd4898      0xb5fc8e2d      0x70f0657f
+       0x2a254ff2      0x5d9e95d9      0xf1a222f3      0xd462ea89
+       0x3d5eaa9b      0xfff562a7      0xef5e87f5      0x360e07d1
+       0xa9ce2be9      0xaf838a6c      0xe1a5e473      0xf217e53b
+       0x8eaf1ce2      0xdf557138      0xac89f183      0xa59918a0
+       0xe1454e1b      0x5cd11e8d      0x80a83d02      0xb837db4c
+       0xf4f9c312      0x278dbdfc      0x7f5d3f68      0x1b81a7c6
+       0x06b3242a      0x8917aeb9      0xa7f2a09b      0x1e632caf
+       0xd9bbb280      0x1f65f19f      0x84d428f6      0xe7b34642
+       0x9ca2f562      0x551225bb      0xcb3995f1      0xf4e61c9a
+       0xedecabb8      0x0a15d37a      0x2acb27a6      0x55d05846
+       0xcb4ff104      0xa0de120a      0x15bcdd62      0x47689602
+       0x5d444c87      0x4d8f24f6      0x8b56af60      0xb5fc74eb
+       0x483eb747      0x934ea389      0x41b84971      0x216e799b
+       0xc9aa34fa      0xc62ccabf      0x59525e31      0xe0593bf8
+       0xeb4186eb      0x14983a04      0x3a7d1362      0xb24bcdfb
+       0x2e3fe783      0x6f1a510d      0x1f6894bb      0xcc3f2950
+       0xab201239      0xea5f32e5      0x915e46d3      0xcd052c8c
+       0xd70ba12f      0xeaf9e745      0x32465aef      0x4b936312
+       0xdcdf6afd      0x79e6491f      0xd379b7bf      0xe5da6960
+       0x828af869      0xd61794b0      0xa054ebc9      0x1da28701
+       0xc9efbffa      0x9a9461da      0x57633a64      0x60567e3f
+       0x76e048a6      0x51f58d04      0x818b2ba3      0x0d8818de
+       0x97eb0716      0x61ef787d      0x66f1e091      0xcef63e25
+       0x05d7e260      0x75127a98      0xe0ffbe80      0x689307c4
+       0x7429cf88      0x897b5a49      0x4469978b      0x030a92b1
+       0xed122cba      0x90fff02e      0xe3fd61f5      0x4f92b6a1
+       0xa0685ab6      0x2df86b21      0xcc4a92f6      0x4ed5c548
+       0x0013ae35      0x87b13c94      0x48cfa5fc      0x2473ea35
+       0xf26a508d      0x31fba90a      0x433f792f      0x99139d28
+       0xd0494d63      0x1b2374fd      0x9e6e80cd      0x74f86d87
+       0x812fed25      0x0a3f5341      0x63b3a064      0xdbb2f15c
+       0xd7c770a9      0xd1c8cc8b      0xdb3efe4c      0xdf06ab0b
+       0x086ee139      0xd0a5828c      0x6eba453b      0x10026a2a
+       0x6e39e3b0      0xa24d5ce3      0x1f46121a      0x440c7e72
+       0xf9ec84d6      0xff8f2234      0x980deeef      0xe02101a1
+       0xe7f9fdfe      0x721540e1      0xcf051a51      0x54b35304
+       0x683519a5      0xcbe6c12a      0x4c8c155b      0x6539f895
+       0x0c5d9a11      0xe7e1d38a      0x79f5d04b      0xee613384
+       0x0ea9f613      0x4a13c91d      0x59dede5e      0x6ad11053
+       0xa7594630      0xf020d3fa      0xa7632306      0x0ddcd0ce
+       0x179d5964      0x4675887c      0xb536d0f5      0xc95b55fe
+       0xe4f54b8b      0xae15b5a8      0x71665864      0x04aced3a
+       0x0d847a6f      0xa07cc0b6      0x59b5cc70      0xd1b1e97e
+       0xc3355d40      0x387c63f5      0xb9ac6771      0xd15a3176
+       0x12ceafbe      0xfeac845f      0xdddd60ff      0x6262ab76
+       0x09015481      0xce07bc2c      0x22318997      0x24122d08
+       0xe63dc9a0      0xf5c9eec6      0x03c17c97      0x4602b988
+       0x3a902a2c      0xf9ed6ab1      0x00dd47d1      0xeb5dd4ad
+       0x7ca46460      0xd484f029      0x0f5105da      0xc32c83bc
+       0xd93a15c7      0x5d5496bb      0xf9cfcc88      0x5b86c7bd
+       0x8a83da4a      0xb1181de6      0x37072675      0x0b0ef18b
+       0x480d6770      0x60f6ee30      0x66956e71      0x6c162fcd
+       0xb4164423      0xdb532eb1      0x7d4dcd6e      0x93548098
+       0xd09a7e2b      0x6542e04b      0x27a443d4      0x7965c796
+       0x4f0fcec9      0xfb056e12      0x55fa786c      0xa76e17f1
+       0x5177e9c6      0x638738e2      0x8a94a5ed      0x7bb00110
+       0x42915715      0x741025cc      0xeafd8f8f      0x3eb11e2c
+       0xa2164712      0x398e3929      0xae05e58c      0x5e96d2f2
+       0x192ef998      0x25404ded      0x84c5f8d4      0x9f6ad23c
+       0x80bca4e2      0x8481d22c      0x9b51b2bf      0xec33c434
+       0x9e8ecf55      0x0e4c0892      0x9066acc8      0xd87830d3
+       0xc9a2e986      0x2be58fbb      0xde71e76e      0x6e3d392d
+       0x332f6658      0x4fc11e14      0x8521e16d      0xadfeb165
+       0x74911971      0x84014084      0xbe8293c7      0xbce7b943
+       0xb1e579c3      0xd4ea8e40      0x8bbe070c      0xf6758982
+       0x1ca18a6b      0x0bf21adb      0xb810c39e      0x4c7c1faf
+       0x4b46cca3      0xb3f244d3      0xd4d20427      0x40d3ae24
+       0x6840b88c      0x51ae0c70      0x76ea6b86      0xf9173f94
+       0x0b674738      0xd052fe1b      0xdebb056d      0xd71358a7
+       0x9f139011      0x6f96026f      0x527e9641      0x1460eac3
+       0xd8a086f9      0x4229dbec      0x12660f28      0xc3d6986b
+       0x674f59f0      0x4e3ebdfb      0x494b9425      0xfa502c28
+       0xa180d24b      0x435d2ab5      0x29d0b566      0x454e6a8e
+       0x99ef13b0      0xee3bccfc      0x547ad6cd      0x53156aa0
+       0x192baaf9      0xdbe4be30      0xd03e3376      0x448f1b95
+       0x5cba96f9      0xd957f76b      0x1bcffbe7      0xeb762cf8
+       0xe7a27e33      0x191f270f      0x59b6b6f6      0xa0a96c58
+       0x53a1c595      0x167e5922      0x14a6258f      0xe119c56f
+       0x9804781f      0x467ed20b      0x409c685b      0xc704cd52
+       0x1fd52432      0xe0711f21      0xf6d09b85      0xfc47b5d6
+       0x32378ba5      0x83459ca2      0x2fb79a84      0xc23f83d8
+       0x3a0fd755      0xd6bae4a2      0x1482764d      0xff99a272
+       0xc3c122b4      0xae55ba8b      0x07d1c8d7      0x9b521f1f
+       0xe5b66290      0x7f8b4b80      0x81a3e934      0x420122cf
+       0x4bc55e91      0x6975ef66      0xbe58723b      0x408b4463
+       0xbb16a4c4      0xf3279c14      0xad955f7b      0xb5317e8e
+       0x1ed745a6      0x61b1eb97      0x7754b538      0x13fc572a
+       0xd3b374df      0x69e4eb9a      0x42f377f0      0x3ca2bdbf
+       0x89ff8ae9      0x2c19ad10      0xb5ddaf97      0xd9d54de5
+       0x1660907d      0x92c5eadc      0xbfc5c298      0xb3e00f51
+       0xac552f84      0x7228b04d      0x1ea18f85      0xa5d74eeb
+       0x9df19b58      0x062ff03c      0xd21f36ba      0xc3dc80f8
+       0xbecc8f79      0x89e6c9d8      0xb53b5a62      0x7415999c
+       0xc7267dbe      0x2845d902      0xee0e0dca      0x89fec5f9
+       0x9e252916      0xf52734cf      0xc02e84e4      0xded4f71b
+       0x7f1c9e8a      0x7b566113      0xd0a0a584      0x5d4486eb
+       0x155cef33      0x447f49b4      0xdfb41924      0x25fb1882
+       0xe9310a18      0xf944dff5      0xed3067e8      0x16ebd448
+       0x4d9db932      0xeefe0cb8      0x4d84a9f6      0x3b36f25c
+       0xdc35894d      0x40db0cb1      0xa42c9b2b      0xe11c463f
+       0x7fae15f4      0xf2e296b2      0xb34ef6ae      0x85bdd6c4
+       0xcb494418      0xe60093cf      0x8473d5ff      0xa5fa9364
+       0x1554d40d      0x99d3dea5      0xe9c2411a      0xd7c9d05e
+       0x371afd9d      0x593909aa      0x4d1199a6      0x2a13ad09
+       0x4816a22f      0x7f4f2a04      0xfb3e97a6      0xd89b1799
+       0xdfd32462      0x08a95040      0xb958822a      0x53b508e0
+       0xf3df1640      0x5d815da7      0xeda82000      0x318146e2
+       0x6159a20d      0x823d1671      0xf3f07bb8      0xffc46bb3
+       0xd140d3ff      0x79ff0741      0xdd1d17ab      0x781377ff
+       0x527860d2      0x46f32030      0x69371fdf      0xdb7eef22
+       0xbb0fb08d      0xee5c863f      0x76335c43      0xbdac0b6b
+       0x24fe5a02      0x37f49000      0xd26da2ee      0x9e24a2b3
+       0x75136a86      0xe254e80d      0xf4e2c777      0x46c6f34b
+       0x73b9ec95      0x00da1a94      0x46208574      0x2c9c4673
+       0x7cffd72d      0x80528b32      0xbae3dad0      0x82e6d2e4
+       0x903f9d56      0x6eb0b34d      0xddd726d7      0xd8a3beb3
+       0xe597a953      0xc8954e5b      0x26e0e6ed      0xe3ad648c
+       0xaca4a261      0xae57a292      0xcc3b70c0      0x52a76e74
+       0x42613f2e      0xa360a58e      0x12bf7dc6      0xb0396d16
+       0xf7285324      0xa37f943f      0x6513a412      0x846b7eb2
+       0x56e6e85e      0x233086e8      0x146deb75      0x38e0435f
+       0x0cbcc432      0xcc6d1f28      0xaffbc73a      0xcfd536d2
+       0x1eefa6ca      0x6dcfd752      0x50638d98      0x76103ded
+       0x7e6ac680      0x41509bc3      0x6f70ab29      0x19822731
+       0x131712df      0x8be27413      0x091b5de5      0x448380ed
+       0x7814ce67      0xcdb5e72a      0xc4db964b      0xe78ab909
+       0x9afe4a38      0x432a56cb      0xd31357ce      0x7c071d8e
+       0x2b253bd5      0x0ed1cb55      0x673078bb      0xabf17be1
+       0x83b43afb      0x650b72dc      0xd9f3e950      0xbe1eaffd
+       0xa50c40fb      0xbf2f8fd3      0x5e9cba39      0xf2cabdbc
+       0xaa55bbd9      0x767f2678      0x6cf6787a      0x9c80323e
+       0xf8701990      0x75bce60b      0x7a31fadf      0x96d89157
+       0xafd6f796      0x3ce058ff      0x93dbd921      0xb201ff77
+       0x01f2ae01      0x4c6bda67      0xe12d8a9c      0x5b5636e8
+       0xfeb31a00      0x4ba3a704      0x147fb737      0x95de6ddc
+       0x5885e2c7      0x11670023      0x1b295dcb      0x12856790
+       0x6a19d15a      0x7412ca13      0xb29c0628      0xc14d35b8
+       0x0ba3b876      0xe0505f95      0x1bd299f3      0xd5729987
+       0x542e1456      0x0559a4fd      0x45b9c53b      0xf71cbb16
+       0x1c2a1383      0x0717a366      0x6d555a5c      0x767caebb
+       0xf85fe814      0x667c868b      0xd93b0a77      0xc7e9af5a
+       0x3c591f8f      0xa7dcfd57      0xf74ed603      0x480c38af
+       0x3a3d10ed      0x3730a656      0x8b7ef0a4      0x6bcd8213
+       0x830f8e36      0x1ef44516      0x71bfdf2d      0x33034d5f
+       0xeeaaee2f      0xf53d05c8      0x50191b09      0x86a91a5c
+       0x2053d0a5      0x632f9de8      0xdefc3d0d      0xac61f698
+       0xa0c3dddf      0x40c1b34c      0xf1a0fac5      0x2e7ffb4d
+       0xfd2a19ef      0x5c57dc55      0xecbe2d2d      0x3c18b6ba
+       0x952adc08      0x5f3678a1      0x5d68b650      0x64567498
+       0x549e7a62      0x80cb6837      0xea26f110      0x8dc067d6
+       0x4389f780      0x3b874da0      0x408b04ff      0x97825d56
+       0x8e2dd9f0      0xf76c851d      0x03a38cdd      0x4a1ff0e5
+       0xae5c491c      0x2af085eb      0x689f2409      0x8d97af49
+       0x89245d85      0x98cc3415      0xa7ab8cd2      0x1c30b386
+       0x7858cc64      0x563eb2f7      0xb9bfb1df      0xdfb4b610
+       0xc0e22565      0x70355532      0x4213b950      0x0d962d43
+       0xb274b2a9      0xa21cd48d      0x32c30913      0x728a395c
+       0x35281a83      0x0a1a181a      0xbd2c1c53      0xc0ac7807
+       0xf0f8d2f8      0x9fd94ffd      0xde9b573a      0x76b99355
+       0x3c06b268      0x02d03112      0x6ba6871a      0x410b1a6f
+       0xb7cc6e6d      0xee7355fa      0xf44ceac2      0x89e51984
+       0x6ecca838      0x9e37472f      0xef43d96f      0xb99bce36
+       0x4752ccc2      0xe43efcee      0x87ddcffc      0x12d40269
+       0x7ecd7701      0xf04f4898      0x0bb4f428      0x4d693cb7
+       0xe5784406      0x4c7b57e8      0xde9de32a      0x8b0d0ff2
+       0x88174c54      0xe6eb0350      0x96b25dd0      0x624407da
+       0x1b73d68a      0x6bff265a      0xe0fcee06      0x7ef965ca
+       0xe2cff1f2      0xa7d58284      0x92afbb4c      0x7d148298
+       0xe968415b      0x13871ede      0x03f7e7dd      0x3cf9efd2
+       0xe8bc910a      0xcafdb12d      0x9463b84a      0xbece4202
+       0x8b92053e      0x6f711c92      0xc91cc23a      0x9f170d14
+       0xb1179366      0xceb899c5      0x8fe3339c      0xb09a57d4
+       0x3e7fd65d      0xd561b0a6      0x0a06370b      0x818e9d54
+       0xfd3dff1b      0x31164bbe      0x277d45d4      0x8275f252
+       0x8a68b1db      0x8e57ec02      0x120e404d      0x8b0f8347
+       0x18eb6105      0x143bdeeb      0xcb36c257      0x4aea9e5c
+       0x098abba8      0x7e7c5e60      0xa4653ef3      0x208c9dad
+       0x0645c295      0xfe9607cc      0x6018a3dc      0x970cef02
+       0x1b592ac3      0x701e4bbc      0x47713ea1      0x8bebdd25
+       0x89bcbaf8      0x24c0e17a      0x834a6d5a      0x36bf0715
+       0xb98a9d4c      0xed118095      0x8894525f      0x68a77a01
+       0x86956dc1      0x776fb273      0x0523ce8b      0xd6ed3a3b
+       0x6e56f702      0x0566261c      0x8c97f9ab      0x72110c37
+       0xa3e8ee8a      0xc05e9293      0xc611310d      0x20f1bd50
+       0xe65e10a4      0xe0c674d9      0x15a39671      0x696a55cc
+       0x97aab320      0xc7fab654      0x0a311fc8      0x286abe92
+       0x24596e29      0xd5206a30      0xde030aa7      0x9ae91fcb
+       0xd7574574      0xdae49e31      0x41fb7d20      0x1c1b4c5a
+       0x38d6f6b2      0x046d80f2      0xfceb966e      0xe29507cf
+       0xe3bf909d      0x2cb613b0      0xc2de5655      0x3e4fe36d
+       0x154ec709      0xa953f6b2      0xf9842032      0x64b88b5a
+       0xc3e35ea7      0x69da23ea      0x22a2a6eb      0xeb58e435
+       0x78ed5213      0x95a04cf7      0x317b749f      0x56dd9aa9
+       0xc2f21dca      0x14c77e6f      0xe8a0bc8e      0xa5af0452
+       0x7c4c679b      0xa86f5c8b      0xa519ab52      0x1a81ecd1
+       0x02fe1de5      0x6bf2bd6e      0x5ae20d65      0x2284d722
+       0xbe4ee500      0xbeba774c      0xfcb7e5af      0xecc32e0a
+       0x1ac73c2c      0x08d16c41      0xa5e1e01e      0x62905f9d
+       0x3b8eaf03      0xf1cb42aa      0xd15de190      0xae3a2f1d
+       0x2c6672a3      0x68097779      0x9e7c924f      0xdf74eb26
+       0xf9eba53f      0x57fbc661      0x4136dc8a      0x52e1ab29
+       0xe619807a      0x7c5b88c4      0xa78fddde      0x709dba81
+       0xc9e3f360      0x63d847b3      0xe27261de      0x65bf0c8c
+       0x75d84f2e      0x599646ca      0x952f70dc      0x209c698e
+       0x246d07b3      0xe66afefb      0x29121a12      0x8b903a03
+       0xcb1a8b5b      0xd2315283      0xc5f0051f      0xa38cad89
+       0x3ac5e5df      0x79235a8d      0x028b40aa      0x966f75e8
+       0xe0e63a97      0x7fe01f86      0x46bdec69      0x40f55bfc
+       0xdf1a1235      0xebc16429      0x0115c828      0x68d47854
+       0xc116c850      0x6e94b756      0xc4725288      0xcd6f30f0
+       0x5a5ce835      0x92df5f2a      0xc7bd69cb      0xd497a868
+       0x84019fc1      0xb2d59260      0x540263ab      0x24969f35
+       0x1afcdca1      0xde438af8      0xe932dd4a      0xd4c0c9d6
+       0x5fbd7964      0x7bf6d32d      0x6df2cfcd      0xea86dacc
+       0xe3611fa6      0x16c3e5af      0xb2ad11ff      0x8061fcc3
+       0xdf89c0fa      0xe3376f5e      0x0beed2e3      0xe8ff9eec
+       0x0d15ca89      0x9d1c99ad      0x722bd570      0xe81ed5f4
+       0x44c89d0c      0x8c80aa61      0x8fd82d7a      0xc62c9f0f
+       0xe6bde9f6      0xaa6418e9      0x60e0b294      0xd04f9600
+       0x4e777057      0x13d19a11      0x6a074bbf      0x1e8c11bd
+       0x0d4587ed      0x668f86b1      0x62868c1b      0x5cc16557
+       0x98ac8c1c      0x9ecfe074      0x01b089d5      0x6801e7cb
+       0x8a07fbbe      0xccd7df2d      0x85c45eb1      0xabe5ea6f
+       0xa912fbdf      0x0f9a3512      0x810c3981      0x93445bad
+       0xe833269d      0xeadf4952      0x97b8f9e0      0x0e6ee79a
+       0x422044bb      0x1f0a6908      0x4ca9b7a1      0xd6dbdffa
+       0x677810b7      0x5f741a38      0x97744d22      0xe225f97d
+       0xbceef172      0x6e940097      0xae95f1f7      0xd2c28d1e
+       0x2b187224      0x809e0431      0xa1d457ae      0x1b9696df
+       0x671c9eda      0xcbf8730a      0x4860791a      0xf83d136a
+       0x717fe82c      0xe4fd4587      0xd1ac3530      0x94c7cd2a
+       0xfe7d8cd2      0xd8beddd5      0xae8ad9b0      0xccc4896a
+       0x5c9f79ad      0xe4baf0ce      0x7c70433a      0x617a6336
+       0xa2fe8b7b      0xa1c0d9bd      0xe0b4c58f      0xe5a9792c
+       0x855078ad      0xe4fe1e20      0xc1699599      0x5a321308
+       0x32abce27      0xfa402731      0xababb4df      0x0c212d95
+       0xbfbe453d      0xb096719b      0x8cfea26e      0x368f5341
+       0xcdaa5eab      0x3917d740      0xde2bd952      0x5813ca79
+       0x67e5b124      0xba1ee88b      0x22dd49f3      0xbb64a020
+       0x03a267a8      0xc1f1f753      0xcb35ac8c      0x0f539102
+       0xc3a84b9d      0x06401783      0xf0adf7a8      0x06adb375
+       0x677bfda0      0x0e598b9a      0x040bb132      0x99ddf860
+       0xf5f91085      0xa65a4e56      0x9e891b05      0x153732f3
+       0x673c1963      0xb04f791b      0x61130603      0xdd67c75d
+       0x5b959b5f      0xe1d140fb      0x2b34aa4a      0x4736e3ee
+       0xfb522949      0xf244c354      0x18526967      0xccfb5036
+       0x0af41c81      0x087ddcb5      0xc4a116fd      0xf42a9d9b
+       0xcf62a4d8      0xbc5ce41c      0x948a4b55      0x6da09f2f
+       0x9028f0cf      0x2158ecb9      0x7443d9e8      0x7bb46592
+       0x562833f4      0x83b3caa3      0xa8974145      0x94a67d73
+       0x95a67162      0x363ea4b9      0x21f99d48      0x676bc76b
+       0x65536311      0x20c7fa0e      0x183b31c5      0x6181a2ce
+       0x3f253184      0xe933084f      0x000901b1      0x14cbaa92
+       0xe4919354      0xcd89461b      0x95969ba5      0x4412908c
+       0xa310e2f3      0xe76e80a5      0x5c881d1e      0x4b2a87a7
+       0x00e1586e      0x58b81c7d      0x42c474ad      0xa5b4737d
+       0x6a565f64      0xba3826ca      0x19f984a7      0xd33b5aa3
+       0xc9145bd6      0x6305b112      0x1d07162c      0x78e54fe9
+       0x12be2626      0x83ca10d2      0xc0c0b347      0x0a0a10d5
+       0x37c04127      0x79006747      0x1eb08fac      0xec29d3e4
+       0x42d20b1a      0x7b0a83f1      0x67df6f7b      0x1cb3ffcb
+       0x2dcbb1fb      0xc7213820      0x2c64989f      0x26cf60df
+       0x5107531e      0x98e72417      0x8e099e4c      0x2e91782d
+       0x597e2c77      0x228bedfe      0x52002a42      0x4c6fcc6a
+       0xacbb749a      0xb3a27bfd      0x077c7ba6      0x13722038
+       0x05da5c88      0xa5ee0b6e      0x5de4b9f4      0x0bf1d9a8
+       0x2156ed6f      0x829b55b3      0xd16c4b98      0x993a7dda
+       0xac8c1f59      0xef0ab25b      0x2d7e5155      0x948f94d2
+       0x5a1676a3      0xa657b43b      0x5c2dcb66      0xd60ba9d0
+       0xe4d03542      0x01b375c6      0x2c2ffb1c      0xfb203f99
+       0xb63bdd4f      0x4725af2e      0x7eebc7a1      0xfbfb89ec
+       0x6e17b7f4      0x1d9092e1      0xc38aceb6      0xac511922
+       0xb303a85c      0x367f01af      0x33a23892      0x826680b3
+       0x02d6a15d      0x9bdbd969      0x67b5e913      0x766030ca
+       0x38b1cb92      0x8d7ec927      0x74bfee4a      0xb7ddaaca
+       0xa8f5f3bf      0xdb52db5e      0x093a6c87      0x86737932
+       0x1062f817      0xcf7f85bc      0x7acd78b9      0x987d7018
+       0x14720ce5      0x67aa3180      0xf3364709      0xf346ae7f
+       0x0083e6ba      0x777c0bc3      0x2fd80fd2      0x0c3e4169
+       0x840f0365      0xafe21a04      0xfb04fd1a      0xc5549460
+       0x6142320a      0x062c0fb9      0xee644ba8      0x0e0959e5
+       0x418bd38f      0xaa3e065e      0xaaa1087e      0xe85763b6
+       0x5a4a2174      0x4e6f5181      0xc628f23e      0x5a554a46
+       0x3a84f622      0xbd54d5a9      0x6ae477db      0x597a4bd9
+       0x070f0eaa      0x02e4adf9      0x9905f394      0x8a3d79bf
+       0xc12cdd59      0xd2ec2394      0xaf926fcc      0xecc18314
+       0x859c1097      0x8d332480      0xd7918edc      0x9fe1ba44
+       0xf44f7a1d      0x5f1a9da9      0x8842067d      0x8256d59b
+       0xf24fd125      0xd8b4e10c      0x087e70d1      0x2d1211f5
+       0xae0b95d2      0xff755537      0x20b984d3      0x6f9e7238
+       0x5482dc10      0xdd416596      0xf7f17424      0x89650400
+       0xf85e1726      0xf3ed3602      0xde792547      0xe2fa183b
+       0xdabe59f2      0x4d415f32      0xad5c3d71      0x7477ea8e
+       0x0e99d183      0x4399c696      0xc7936ac0      0x8730e924
+       0x21235ca6      0xa49512f0      0x91effb1c      0x965f6d59
+       0xc6e53079      0xcf5365d5      0x711c0904      0x7c63abee
+       0xbcbd92c8      0x1295425d      0xf5be80e9      0xbb0bd9d4
+       0x6e5d4161      0x17da7c60      0xacafbd27      0x3d4247af
+       0x6a3890fe      0x8c8673a7      0xc24f28ca      0xa3818c64
+       0x0eeb3212      0x8b833690      0x90dc8ea2      0x6f3457e4
+       0xc784827b      0x8188f9e7      0x1cfb1118      0xe5a5bb9e
+       0x937d2b11      0xa3df95b9      0xaeecbccd      0xbfcde79f
+       0x1d3fa4ae      0x2d635785      0x39c98d40      0x3f85a6d6
+       0x98f7a353      0xa1dfe02f      0x7bf6a3b7      0xe8d36f8d
+       0xf561b341      0xbda51c58      0x3c086a27      0xecbf5b13
+       0x89fb6ae4      0x19639750      0xbf3612c8      0x30c23a89
+       0x5e3e2e4c      0x39e12260      0x73abb21b      0xbe0998ea
+       0x1af23e28      0x52125ae0      0x6d697765      0x322a4af1
+       0x29182697      0x845253c6      0x962e1425      0xaa35c780
+       0x8e5552eb      0xb9a4379d      0x8b5cc99e      0x329ca3cb
+       0x012e726a      0x0c89834c      0x9a7085d0      0x6191beae
+       0xe79ffa19      0xaf76ff20      0x4a70f3c7      0xe65ce032
+       0xc4c12dfa      0x62e04fc6      0xdbfb9468      0x3d383f0b
+       0x7f5a7886      0x54096591      0x29247ec7      0xa5882898
+       0x318ce560      0x95d65f29      0x8eeb2057      0x701a715e
+       0x253883d5      0xe63d4fe8      0xb1a630b6      0x2fe922da
+       0x95fd3879      0x9d363d32      0x787fe1cc      0x9cdf699b
+       0xd6669487      0x057305c2      0x6dc8f4ff      0x44b1d1db
+       0x988b68bc      0xdc70e79d      0x271118b8      0x6b55d2e3
+       0x50f8feaa      0x9d3e48b8      0x6cfb67f9      0x6eb36d2f
+       0x454be644      0x7b142bec      0x92037606      0x6a26dd83
+       0x63f8808c      0xfcf44af4      0x2016f1e0      0xbe00d5c7
+       0x9b9b9fea      0x9abee5fd      0x737defce      0x5b812305
+       0xca052faf      0xcbe5174f      0x7afd6d0d      0x151e0225
+       0x5c481544      0x24dbfb8c      0xf7c6e77b      0x3fc2f140
+       0x7100d6cf      0x02ac3e35      0x8b158a38      0xea394ca4
+       0x79fa7b17      0x34a05c2c      0x8d01cdf5      0x1cc18940
+       0x2f581fc8      0x1bbdb263      0x26f623fd      0xe6929d85
+       0x681641cd      0xb7e2e768      0x266b799e      0x58f94e0d
+       0xedaac87a      0x9f8bfa42      0x923783c8      0x880645f5
+       0x9bd5595f      0xc175d909      0x3ec04376      0xb0a38d04
+       0xe62ca54d      0x6bd558c6      0x927f81ab      0xd88cca8d
+       0x7b5e31be      0x4ff15a2b      0x991e6ff2      0x1d198d26
+       0xe7e30b0e      0xda7c2342      0xe7953dc9      0x0e06044f
+       0xf90d6512      0x269125ab      0x22d9822e      0x443baca8
+       0xf6e1c7ba      0x20c7d35f      0x9ae13228      0xa3b2d1b1
+       0xbb65dddb      0xc895a9c1      0x462d2a3f      0x99be550f
+       0x7ebf4f3c      0xa384ff36      0xa9b58738      0x1939798c
+       0x7a8e80c0      0x542b9d6e      0x3f677e7c      0xc8b64983
+       0x9f449381      0xed3f8b83      0x8f4920fd      0xd21b9507
+       0x4757af05      0x17492a91      0xa3589748      0x8760ff18
+       0x26b25ece      0xb08c91f0      0xa15cd4c1      0xb0b4c5e1
+       0xf27a5c78      0x3f646d72      0xb46c401e      0x66e712a8
+       0x6736fdb6      0x261ac883      0x1805edfd      0xefc27fac
+       0x742426f1      0x40211b71      0x8d865aac      0x7fed4161
+       0xcc2e5951      0x2f806ecd      0x19f43244      0x5ad67f1b
+       0xdcd32802      0x3703fc18      0x7ac1b7ce      0xe37dc1b5
+       0x36185053      0x3fbf49f3      0x1cd62a63      0x21a1362b
+       0x10a47537      0x16099cba      0xa374e947      0xc8bc6a6d
+       0xffaa3f91      0x07136851      0x9b9e5efa      0x87c5a9c8
+       0x86230a32      0xc2282ea3      0x42a24d99      0xdb9bee1c
+       0x9224cf9c      0x21518526      0x3399a9b3      0x1a1b4b82
+       0x41a52e43      0xabf3e09a      0xe81107df      0xee0525da
+       0x317438ae      0x8a0cc8c8      0x060e5622      0x546c20f9
+       0x0eed85ba      0x8737aacb      0xfcd9712b      0x4f4a3a4f
+       0xf98d9b65      0x84c46935      0x7f0e7c4f      0x2ccd4b47
+       0xd2bd8b2f      0x913a6b5b      0x44e8c105      0xe938e360
+       0x402d3691      0x23360938      0xfea85cbe      0xa4817d58
+       0xfba8fb94      0xf630e4a5      0x2b79ce93      0x65ee6a76
+       0x53b636ea      0x92e5c39d      0xcf12573c      0x41d90428
+       0x27a17380      0xac2da94c      0x05927161      0x7fb3515b
+       0x4ca2da3e      0xeda0d0f1      0x3c25b8c2      0x8df1c4c2
+       0x7501085e      0x1fc21a54      0x30f6c998      0x276c9a1f
+       0x375d111c      0x8c59e009      0xa03a5105      0x32499ccc
+       0x32883869      0x20b2738e      0xb49e5035      0xf4825a6f
+       0x90deb6d1      0x8609a2c1      0xd322ed03      0x956cbb5e
+       0xff14440c      0x9e9b1d7d      0x630e4c6a      0xb81d44cd
+       0x378a14ba      0xe486c51d      0x65616855      0x399b9291
+       0x17be99a9      0x4f2a34b4      0x81a551f0      0x54e8d8f1
+       0x985a90f3      0xd5cb0c42      0x68c8480c      0x63b0b7e3
+       0x1404264d      0x2b4515ae      0x8e3f84ab      0xde2d2b2e
+       0x6bae4908      0xd5b9a6c8      0x0eb5d3ec      0x87bbd411
+       0x8e615747      0x12033537      0x205d10c2      0x46d0fa85
+       0xa9ff883a      0x6c6d2680      0xa03010d9      0xcbc56dd6
+       0x16930553      0xcd982168      0x8ab672ac      0xfe5634ec
+       0x4dd65606      0xaec75586      0x9dc39770      0xcb0df430
+       0xa87c5967      0x1d24be25      0x04735bf8      0x9592173b
+       0x3cc8ac1c      0x07a4b77b      0xcec8ab43      0xd8968086
+       0x01569b6a      0xac006333      0x1cdf731b      0x2bc5e66f
+       0x7ca77e66      0x8f21fe9f      0x54b44e2d      0xcf59a315
+       0xb87a8a21      0xc331ed9f      0x0e5842db      0xec54b17f
+       0x4da03c26      0x1296ebc2      0xd7257eb8      0x199aef05
+       0xbfa1c033      0x12ae4ea6      0xc725d837      0xcbccfbbe
+       0x6d4171cc      0x8eee338f      0xf9608e11      0xbed2126f
+       0x73b97cc8      0xbe59920a      0x64efc0ec      0x378c7d43
+       0xcc28b4f2      0xb17fda32      0x7b1ce5ca      0xef8336c8
+       0xca3401af      0x64a0c490      0x8892ae47      0xc874c76a
+       0x72b52277      0xd5fa0054      0xa71605ed      0x9686ed9b
+       0x3aa0d4c9      0x355514e5      0x96b4ccaf      0x59d6d72b
+       0x648f0f9a      0xdef71ad9      0x84d087c5      0xbd51b932
+       0x46702753      0x8f66b99a      0x0e4fc657      0x2f081024
+       0xaadfaba4      0xb485f25a      0x6b45a778      0xd88352d2
+       0xf2858a7f      0xdab29466      0xc58fec15      0x49c20664
+       0xcffa09f9      0x966b6b85      0x418fa131      0xe3ff0edb
+       0x34ad047f      0xb486fc6e      0x3bce1970      0x59a0f932
+       0xdfbd5ffa      0xd434e097      0xc0cb2629      0x66c759f2
+       0x827f7b68      0xcb798f6c      0x23d827e4      0xe145f878
+       0x3a3ab1dc      0x21dcee2b      0xb647ff61      0x92c031cf
+       0x52bd768b      0xecad5dfa      0xa0cc4ae2      0x2f9bff4d
+       0xf01703b8      0xe6bf1fcc      0x2f72f797      0xa21bb22a
+       0x65b1706a      0xdb100f24      0x11bf1f9d      0x83f21760
+       0x1a8b87f2      0xb899e7da      0x17f6119c      0xd22224cb
+       0x448516b8      0xa11ea991      0x712e48d5      0x20fed9a4
+       0x5379a0bf      0xa7d7bf41      0xdacab026      0x0517a6fa
+       0xa8a7c39d      0x402272b0      0x7cbda31d      0xe8319be3
+       0x98e61191      0xf999cf02      0x50c8a22f      0x589143e5
+       0x48390dea      0xe5f33ef0      0x54ba1a49      0x0ac2cff9
+       0xa516c49c      0xb311ab1b      0x454eb7b6      0x20a89b82
+       0x54a4ba11      0xb2bc6701      0x4d1ade8c      0x5ff02466
+       0xf5c19b8c      0xca9e709d      0x0fcad20f      0x529067f4
+       0x259e9261      0xc50b4b43      0xf2ec0605      0xdd9b3055
+       0xa8321e45      0xf340600d      0x29d4523b      0xee0ba7dc
+       0x50162711      0x652d751d      0xe896b7eb      0x903b6027
+       0x70b73846      0x427f0a47      0xa6fcb5b1      0x831a5ed8
+       0x6abbe528      0x23c9d1e3      0x2f049f05      0x17f6b2ce
+       0xd101ad69      0x25754dbb      0x4b6d82a9      0xef991bdf
+       0x82caf2c6      0xadb077ac      0xd8c5d4d3      0x1eaf30e9
+       0xf8e5c8ce      0x06480d20      0xc896557f      0xf3393e77
+       0xaeca19cf      0xf9a26bb1      0x9a9549bf      0xb743d8fa
+       0xad824e14      0xd7b47176      0xa502b684      0xc9ebc12f
+       0x89aea3dd      0x63895bec      0xc98d8f23      0xc5c0ae9c
+       0xe69302f4      0x3cdbb58c      0x6ac81270      0xaf86bcf0
+       0x5a272400      0xab3d8cb7      0x06e97f45      0x99f2417a
+       0x27a4e160      0xf584831e      0x7b715166      0x1048b6c0
+       0x201522c6      0x683329d0      0xb22d04f6      0x95a21a4c
+       0xefbe7cb3      0xdfacf5f1      0x524679b9      0x0ee42fab
+       0x22b18121      0xeff9ea02      0x31c56fdb      0x81023e4e
+       0x4a358710      0x63ca6f03      0x363ecb21      0x31a8a7bc
+       0x7d381287      0xc2e87c45      0x9b677a24      0xfa986672
+       0x3d835e76      0xcfa21f60      0x17411ac8      0xc55dd5f0
+       0x38e05dde      0x6a0f13d2      0x022a254a      0x0d06c07e
+       0x98a8a1fb      0x6b63661d      0x9fda6edd      0xe5a25e1f
+       0x5f1f23b0      0x74a41be5      0x47e653e8      0x11496031
+       0xa3ddb39e      0xc9bbe236      0xaf4eb188      0xbf164375
+       0x259b822b      0xafc76e4e      0xec295c85      0x9a0fd0da
+       0x0bb89b1f      0xc920cbff      0x23d9bbd4      0xb03c234b
+       0x38757ccf      0x9c8180a8      0xc5b8db79      0x726f55d5
+       0x02f838ad      0xa60b4235      0x1388f1b4      0x7a93af02
+       0x7fbaaa24      0x25bd5c2f      0xc6924c88      0xcc18e048
+       0x50ced491      0xf8b1c21a      0x2978388a      0x523e2bda
+       0x3df3e1d7      0x1453cf5a      0x3774e0e7      0x54c54978
+       0x765d9303      0xde549870      0x036cb91d      0x7e7f52a1
+       0xde2ba12d      0xb5ffe3fd      0x644b2b77      0x9f583a7a
+       0xab06348b      0xa0593877      0x46069e84      0xaa7dfd7e
+       0xfbf240b1      0xf9dea4e0      0x8117090a      0x13766f49
+       0x3d677d7e      0x12d514e2      0x8dc5877e      0x09b957b5
+       0x35e5f9cd      0x67c1d3cd      0xa26e22ce      0x37dbd29d
+       0x567fc34c      0xe6405562      0x5a5d465a      0x9f5ad9e7
+       0x9642788e      0x581dc1b7      0xdbcbd637      0x5dd1f9b7
+       0x2d25362d      0x978f907a      0x83a79ad1      0x37e5c903
+       0x7ecc5e0f      0xcc122b4d      0x4917242c      0xcc9ee573
+       0x5fa78b3a      0x9073fa0d      0xfb571495      0x880dc878
+       0x69121fe4      0x9fa357fd      0x3c8d63aa      0xd80bd862
+       0xc422c954      0x73c2ce03      0x327561f9      0x67fbf57e
+       0x9f78ec30      0xb7b02694      0xb1098e91      0xbc139503
+       0x143ab747      0x8ab7eaef      0xb5f7f34b      0x578702b4
+       0xff7d204f      0x29d7531b      0x551dbdb8      0x9727f00e
+       0xbe9da306      0x0b3ca84c      0x7ee20024      0xf2a9caa0
+       0xe6d2cb54      0x7fd8a503      0xbda55d83      0x7dfd2f35
+       0x78f4bbe7      0x2c00bca4      0xbf206c0e      0xf6e1f1fa
+       0x3f9c901c      0x1cfce979      0x0461f168      0x1301035a
+       0x36e94186      0xa1dbd8db      0x2aa297f4      0xafaf9e8c
+       0x1475f0b9      0xff42eb38      0x0af1bcbb      0x335b1bf5
+       0xb05f5788      0x94f97d0a      0xd0656ad4      0x4411527f
+       0x691d1083      0x1358ce09      0xb88a4248      0xe4687bc0
+       0x90e77bc8      0xb7664eec      0x204b67ff      0x1d3a4566
+       0x9e510682      0x9a1cbe93      0xef9d888e      0xd4ea30a6
+       0x9d852ac6      0x0b1aed2e      0xe5918e91      0x8020ab52
+       0x685d9e37      0x54ce959c      0xc074ece5      0x13fa1424
+       0x83b7bcbf      0x6550491e      0x514eef7f      0x987a36b3
+       0x55c54ff9      0xafb1fc2b      0x2f6f8b8e      0x25f5c65a
+       0xd6a0d163      0x25fd15f3      0xc32ac15b      0x4544266e
+       0x34239436      0xcbabd369      0x3bacd907      0x1af33492
+       0x391939f0      0x60701ce0      0xab3142af      0xb3bc31cf
+       0xe6448f24      0xe844a422      0x23fba1dd      0xef419e5c
+       0x598f4596      0x71457c96      0xe911b080      0xfb1d4952
+       0x37f2cb60      0x946839de      0x1292a14b      0xd5068f42
+       0x2e8cb2cb      0xa412f68a      0x76d6d31d      0xfd5b5ce5
+       0x5a6600cb      0x959468ba      0x7aaca357      0x6874184f
+       0xce703cc6      0x51792a99      0x75219402      0xe7635f88
+       0x90cb9fa2      0x2de03cf5      0xc2f32af6      0x8c695995
+       0x726f764b      0x1eac9046      0xb2a183ca      0xfd7161ed
+       0xb5dc16d7      0x328b5113      0x7ba1b285      0x27defbab
+       0x1bc56f59      0x1fd2e1f8      0xa4d2080c      0x9b565ff8
+       0x6006ed8f      0xe555e161      0xef3be7b6      0x51ff0cca
+       0xe8921761      0x44580228      0xa78e370d      0xcf912780
+       0xb9cc6079      0x12885d0c      0xce8a95a1      0xb1e29a2d
+       0x579981cd      0x2553cc9c      0x140c0c0e      0x5399faf7
+       0xf3730624      0x5a8f16b3      0x46bfc5d2      0x840195a1
+       0xb02d4c5b      0x43d3848f      0x6abdbdb1      0xea188ae2
+       0x4daca4aa      0xd0217d44      0xf63694d9      0x887c9e7b
+       0x47ac7919      0x222ee72a      0x1da3db59      0x8d541345
+       0x36cdd45f      0x0e87bbf4      0xead58cde      0xf1a2876a
+       0x1650d5ee      0x31b96dc5      0xe137f4d4      0x437d1be5
+       0x6f9f8ba9      0x8b93237a      0x379c651e      0x611a578c
+       0x934e296c      0x0eece67a      0x7cf84a44      0x16b8d182
+       0x41dde30b      0xaac167c2      0xe12aa674      0x678ee090
+       0xb56455e3      0x0a834416      0xd01c0647      0xaad3fb86
+       0x37bc51f5      0x4657ff59      0xd765bb8e      0xcfd6a33f
+       0x370d9df5      0xa9bcfe46      0xa431b104      0xdfadac2e
+       0x942a99ab      0xb5a74aaf      0xb17ac8c4      0xedb055b6
+       0x8d1d3eb0      0x4078ffec      0xd91cba70      0x2ebbc17d
+       0xa5f361cd      0x5dfd880b      0x088464f5      0x3cfeefe2
+       0x98569410      0x3d2b2319      0x95c4ad44      0xfc1c4088
+       0x29c461ef      0x3f1361b6      0x7fb853d1      0x6a73ceea
+       0xdd846e45      0xfe0c0e9a      0xd46ba008      0x9027920e
+       0x1bf45245      0x73d0a0c6      0xe4d437de      0x94384e52
+       0x101b5487      0xbe1e7177      0xb83adfb5      0x5b710f67
+       0xa624f0f8      0x821e3801      0xf19ad22f      0xadd34669
+       0x76885dd1      0x3e561ee6      0xf76f529d      0x55632513
+       0xf7bcc249      0x84df7b1f      0x959fab55      0xb8222f86
+       0x7a614e61      0x78e015a7      0x9ac7d4e3      0x81005340
+       0x1bbc2a64      0x9007ed5d      0x19da3e88      0xf2db6f1d
+       0x97912174      0x3d97fb89      0xc1c23d0c      0x2bf8eead
+       0xf97c0c90      0x3e77a3e7      0x0b5abb98      0xae119897
+       0x6095b4f2      0xce0f80d2      0x24612115      0xc76b3469
+       0xe712af37      0x20399929      0x1c6aef11      0x19edad91
+       0xb69d79fd      0xc67e1628      0xae59b9a8      0x87837f2e
+       0x4d0ffd9f      0x84767827      0x6bc8f576      0x86e9f656
+       0x6350fb4d      0xf25a902b      0x3a334ed6      0x7a1f2ea5
+       0x2a277aad      0x9eaa8bbc      0x34cdbb75      0x659211e1
+       0x449ef7ba      0xdb0f27b4      0xf9f5b51a      0x3c5755fa
+       0x73bde027      0x3a831703      0x3eb27a91      0x02cb91b8
+       0x69cef6bd      0x763b04da      0xf0ad5746      0x07f4cee8
+       0xbb90f444      0xcaf432b2      0xbef166ed      0xea51562f
+       0x4ef5cc2d      0x340adf3f      0x051a903f      0x5fac94a5
+       0x8f045133      0x054f20df      0x156df385      0x947eed28
+       0xf6f4c232      0x280821d5      0xdc87461c      0xdbf69fc1
+       0xa91d26cc      0x0723055c      0xc678cf7f      0x482798e7
+       0xdee8e4bd      0x7f9b996e      0x9add6ad4      0x8c6074e6
+       0x7b50964a      0xba9b65cd      0xe976dd25      0xa9b6b815
+       0x0db66ddb      0x6a600968      0x92906b2d      0xcbbb63ec
+       0x279ae91b      0x6b2f7bd8      0x2957bef7      0xe04f3eb2
+       0x0c76c3f7      0xd9552c55      0x0cb49c61      0xb575b4aa
+       0xcac8fe1f      0x298c7835      0xfbb4d6b0      0x6b1a001b
+       0x7a0d13b4      0x2c7db44d      0xa7a2e87d      0x772bff55
+       0xcf3a21f7      0x014c2f2c      0xeb1c5ec7      0x19b08e37
+       0xd6b58aad      0xf70ce36c      0x7ccb4671      0xf808b3f1
+       0x77dba7c3      0xd027c2d9      0xfdde9c79      0xb8f33cdb
+       0x6cdab1ec      0x9c772d17      0x2b2577a5      0xf70edebd
+       0xef7f0509      0x0caf7907      0xe533c146      0xf1b95053
+       0x29ab2835      0x9be51d99      0xafbc1275      0xf7e20597
+       0x46cc5dcc      0x2fc01b02      0x35249e36      0x8bea0692
+       0x46b6d650      0x1090860e      0x93480a3e      0x0ff5840b
+       0xfab90544      0x20efd5a9      0xd823d8a2      0x1415d4b4
+       0x4094d116      0x64a2f0c0      0x55c8ce25      0xe2827575
+       0x02b593e3      0xdae96750      0x5d3bc757      0xef5da616
+       0x6b3e40f6      0x322c5f8d      0x942e8ade      0x1cf2efc0
+       0x5ac62379      0xd438dbda      0xb46fdd89      0xcabd0401
+       0xa127011e      0x111db191      0x10f56f6b      0x85dcd3d3
+       0x0534fd5e      0x5a31e894      0x8a526f41      0x728a366d
+       0x5558b404      0x171b946c      0x0cfef354      0x2197aa17
+       0x082bf992      0x73d17388      0x319e394c      0x5908d3d7
+       0x36b8721d      0xa16a1103      0xd28863f8      0x9d903d72
+       0xc21c4955      0x4039cee7      0x41bc785e      0x927e2aed
+       0x46cd6c30      0xac2a1645      0xd50a96b4      0x6efe7115
+       0x3bea5b1f      0x2df52d1e      0xd4c3845b      0x19b1ee05
+       0x3e55b057      0xa0c53e95      0xb6278d69      0xe12bd985
+       0x2157915a      0x4a093c0c      0xc0b5ddaa      0xe774c47b
+       0x1ead565d      0x395539f0      0x40134cc5      0x179156df
+       0x1b8fc748      0x23f3a676      0x9253ddaf      0x010c83c6
+       0x4d68e24c      0x950a7d1a      0x09ea482c      0x90de5203
+       0xa87a27a4      0x96e160da      0x80c9fd7c      0x1955513e
+       0x174961ef      0x4b241716      0x9d25ae8f      0x2828fb2d
+       0x5e612823      0x6f77c806      0x9be262e5      0x1ccec26d
+       0x6dc32801      0x7ecf2f81      0x6a4e7c2e      0x9dd158df
+       0x5d47597e      0xb1e3f6ba      0x45792c67      0x4bf55b67
+       0xc198caa7      0x8ab31972      0xfb57141a      0x32bd09ca
+       0x9039dc7b      0x1dd0dbdb      0x0ce6b133      0x3c4f1547
+       0x7a239615      0x42b03593      0x775b42db      0xb5d193c6
+       0xdfc36140      0x183ebb89      0x568e2be5      0x72be8e24
+       0x39b1e1b5      0xc79d354f      0xcfbffda8      0xd33f2371
+       0x3ddf16c2      0x39cb5435      0xb260afe2      0xbd800370
+       0xf5f6ef4b      0x252a58b4      0x7e160f72      0x68a2d43d
+       0xb7eda2dc      0xb3f75a98      0xcf729fbb      0xb6079e83
+       0x99aa43d4      0x1915991f      0xcdac7ff6      0x1a7ba5fa
+       0x18cb2073      0xc8be7842      0x43d3b57e      0x1f7bdde5
+       0x80631ff4      0x5ba355ba      0x132eee83      0x9bd41f5b
+       0x433b1686      0x5b4343b2      0x935b097a      0x8606f65b
+       0x6ff9d708      0xfd11ee6d      0xffbcb2a8      0x11db4238
+       0x12e8f406      0xeb88f505      0xe6829a5a      0xd4dcd1e1
+       0x3771d0e7      0x80fa5bdd      0xdac04527      0xd4e95918
+       0xa988f200      0xe9ca5b40      0x5534df22      0x6571e87e
+       0xc1fcaf2d      0x73c41dc9      0xeca06d37      0x571582bd
+       0x5f49b0d1      0xe3f4d2ef      0x73d48971      0x55c71afb
+       0xc106d67a      0xbff4ef57      0xe89455e8      0xe4792818
+       0x920c98e6      0xee5e2ba0      0x978e7408      0x637f2f55
+       0x2af71dd8      0x5eabc23b      0xa318038c      0xbdcd6074
+       0x040dbe95      0xcc4a0dda      0x9575244e      0xffd0078c
+       0x206bdfe7      0x7646553f      0x09343d9c      0x56038707
+       0x7ee7103c      0x9b78eeff      0x8c470c5e      0x62a5ddbe
+       0x1dcf932e      0x106430c5      0xf8b3c88c      0x88b03eb3
+       0xe2f85fe5      0x22243994      0x4901abd5      0x647415c2
+       0xff131a76      0x7fb51a90      0xdfb27b0e      0x6369083c
+       0x970ab8e2      0x744ab44a      0xc90decb5      0x6830a2c3
+       0x461de171      0x15ed0e38      0xeaa29374      0x338d5d10
+       0xc78f3062      0x78d4e951      0x87e432e4      0x96efe159
+       0xbd929d28      0x6319fdd9      0x84b1b4f8      0x5fe18e3b
+       0x4e7956da      0x29f31002      0x5f05a557      0x97237f26
+       0x5a15bcbc      0x049c4b9d      0xbf80f654      0xe500fa2e
+       0x0281e9c0      0x2722f835      0x231fab84      0x3a4f6b75
+       0x13495452      0xc5ff244e      0xf32268ac      0x7b1b0aa4
+       0xbe94508d      0x38efb53a      0xf3120f13      0xa23e628d
+       0x63e46533      0x45a8115b      0xe152f140      0x021e708b
+       0x33d08a51      0x00d1409d      0xcfca0079      0x2bca0acd
+       0x992f7173      0x548c9327      0x9fa8d657      0xc275f142
+       0x5b56d863      0x86be0152      0x711ccc18      0x11c847de
+       0xf54b58eb      0xb2635dbb      0xeeb4c609      0xb4ac5e70
+       0x9ce653db      0x7ddc55e1      0xca681e36      0x8ef084b3
+       0x19fb3e21      0x4dda8b0e      0x044c7d67      0x2123d91c
+       0xe2e0d280      0x1aae5000      0xf06f73eb      0xc5ddae09
+       0x44a6431e      0xb01f3e32      0xc393232c      0x5b9cbe47
+       0xdbb44bd2      0x7a3cb7b2      0xd1395956      0xaf27d586
+       0xbd520022      0xfbbaf8e2      0xda0130b8      0xd211e856
+       0x64abeaee      0x6891a738      0x8cd74799      0xf5ca592c
+       0xda100d38      0x9d5d8093      0x165e0e3e      0xcc4bdcea
+       0xf1d8155a      0x4b77baf5      0x9fa59524      0x206f8519
+       0x336082cb      0xd10a78eb      0xdf5be5d7      0xee0e2d81
+       0xe677a8ca      0x252d765e      0x6fef90b6      0xcbdbae73
+       0x106f04e1      0x62e331a5      0xb64bb7b3      0x8a8636c4
+       0xebf586db      0x3495d7f5      0xf972542d      0xe725800e
+       0x444bd737      0xaed8790a      0x386ee305      0x57c311a4
+       0x501790ee      0x5ae653b1      0x89a1cdab      0x646fb444
+       0xd153f9bc      0xb4eb6787      0x2d51a93a      0x76f70e57
+       0x925ede9e      0xc44b02fa      0x4bd3f38a      0x52607e7e
+       0x99d1e92d      0x88f9c1a9      0x472f39fe      0x95449631
+       0xeaa54b24      0xabb023fe      0xd2a0a663      0xd058bc8a
+       0x810b9dc0      0xb6d94bd2      0x20e0f710      0x8e343ed7
+       0x4de50efe      0xdb5d858d      0xf2d0ba21      0xcd0707ce
+       0xae3d1696      0xaa55c48a      0x3327fe08      0x549fccae
+       0x0250ef88      0xd1572707      0x75bc7766      0x70326833
+       0x3cff2412      0xd1c332b9      0xc02774c0      0x87721e8a
+       0x6fbe2d1b      0xd55bcf1d      0xfed8ac91      0xb191e307
+       0x79c0b700      0xa067b338      0x188ab8ba      0x0aefe2a7
+       0xeabb0b52      0xbf101a41      0xa59b2838      0xea3669fa
+       0xa72a9064      0x91b3d073      0x1d1edb6a      0x83f024f3
+       0xe8621c99      0x516ea04a      0xdc3649f3      0x34938a24
+       0xdc055e22      0xa87e4680      0x8de08bfd      0x7c96c631
+       0xd347dc0c      0xab61f019      0xc5727add      0x8ee60136
+       0x6fd4894f      0x7bbc24a0      0xe8c86340      0x89ed0d28
+       0xc561c258      0x058b8497      0x9f257eb6      0x9e9ab53f
+       0x46cde459      0xe6019cff      0x1fb0f2eb      0x2c248e66
+       0x7f0e57e1      0xceac2019      0xa194f330      0x0868ae1f
+       0x76c66881      0x92f11852      0xda17c68c      0x1849187b
+       0xafecd610      0x249012c1      0x83878f22      0x57106850
+       0xf3d329bd      0x9c2feb04      0xd1b5d906      0x8382d9f7
+       0x8c696b4d      0x88178fde      0x11dd4154      0x35949fa1
+       0xeeb2681a      0x3eef9bfa      0x084e8c19      0xdd19e45a
+       0x243ca0cf      0xd09166c9      0x05f7c58a      0xbb14c266
+       0x9820a5e0      0xb77888ca      0xd10f11d3      0x370b2b3d
+       0x380483da      0xb69deca2      0x57775252      0xdbd09709
+       0xb4995288      0xdc2f64fe      0x5e84fd14      0xbdf22b82
+       0x7b8014f5      0x85366667      0xfef4b83d      0x45405771
+       0x08fead4c      0x5aa9e77c      0xa955a372      0x8d17b700
+       0xdea00d0f      0x9844b113      0xca3c8b3d      0x1aa0aac8
+       0x6784082e      0x88a4ba40      0xd73f5b82      0x89d05dd5
+       0xbfacb596      0xc32ccbde      0xab81a777      0x22401c47
+       0x11afa556      0x03bfebf0      0x26b452ab      0xae5ea9a0
+       0x05658eb0      0x7def6aa4      0x583d2091      0x91e9e4c0
+       0x5805d41e      0x0fc4536e      0xe68d173c      0xe3bf6879
+       0x842c85a1      0x753e5282      0x7bcc0884      0xbb5e7eb8
+       0xddb5ebff      0x378672d3      0x89f668cf      0xb94bcd17
+       0x30cdedcb      0xcf58ab4a      0xa2d67c52      0x9e7484e6
+       0x84fdb9d3      0xf0c1620b      0x7b1fc70d      0xac4c5a5e
+       0xe91fc4ca      0x6a103118      0x0cbc7945      0x3031e86f
+       0xc462e419      0x9ee8e84d      0x2c9366d2      0xe01520ab
+       0x5448a022      0x031f1b13      0xa5c6ca5d      0xf23522e7
+       0x86eb5787      0x47cc203b      0x68b99b9a      0x93a34563
+       0xeb3c5208      0x649ddaf5      0x9a658c41      0xe5b0e273
+       0x1411bde3      0xa3a24fca      0xaba08203      0x8e003ac1
+       0x45c4a3c8      0xe24a41c7      0xb7dcee29      0xd29d0522
+       0xe23150fa      0x0b6e7029      0xd2167edb      0x398ba3c5
+       0x7ef1c58d      0xceed2ab6      0x5706fe58      0xce8cdcb5
+       0x1779c255      0x365be3f0      0x046fdbf3      0x183074f5
+       0x9fac8728      0x9d9e6037      0xf7efdbf5      0xdf230937
+       0xd136ff52      0x8d1dcdb6      0xf3f3a5e8      0xd89cc6c4
+       0xeac36a4a      0x804baf9e      0x9b7c7b81      0x3a4a7673
+       0xbe8abe9c      0x15001cc8      0x068a4a31      0x4fc99070
+       0xdae06ef0      0x23fb48ea      0xf1667af0      0xf10640e6
+       0xb8ac49a6      0xf3bb6550      0xd9c41981      0xdf68a68e
+       0x7235e755      0x96ad365b      0x9f408a09      0x5c98772d
+       0x1fc21a18      0xe793368f      0xc1de7f21      0x0d938abe
+       0x52da8c34      0x578aa05f      0xe4d02024      0x1df66d1f
+       0x227890fb      0x98e08315      0xa2686cdd      0xffe24f5e
+       0x26737566      0x290ec536      0xfe2b34ba      0xeb3dcdaf
+       0xdfefaeeb      0x47db5b8f      0x98435839      0xd3f7a93b
+       0x56237915      0x1e8e641e      0x1a1cd258      0xdb8622b1
+       0xa1a53a80      0x054cdb9b      0x6ec79c04      0x9a4175b7
+       0x454bbf4b      0xb49940bd      0x5c0ef774      0xf1113462
+       0x52537cf8      0x55a82114      0x7e00b724      0xe0a439eb
+       0xbca18b1d      0x275ae44c      0xc6f38962      0x64e961f1
+       0x87e9528f      0x8cffc48b      0x2f534693      0x945573de
+       0x6a96092b      0x80051718      0x8b209bad      0x25286dbd
+       0x8cbf1b2b      0x6091a7b6      0x71b7f055      0xbff6f0ef
+       0xbda94cba      0xa7a67173      0xccd12821      0x7aff8c65
+       0x37b4ef1e      0xa0ec6cfb      0xbe3763f3      0x89ff9cc2
+       0xd0328c4c      0x12356ef6      0xc7fb5009      0x21560263
+       0xebe812ac      0x189eaa20      0xff974375      0x12988088
+       0x3051ee00      0xa093b1e7      0x2e412509      0x524e8912
+       0x03759b38      0x62e5bb8d      0x3779ee6c      0xee3f354f
+       0x1e887938      0xb06ff422      0xfc9be41d      0xc846a538
+       0x8b69f873      0x03b35eeb      0x828ba1ec      0x3085b48c
+       0xa444412b      0x502774ff      0xe8859efb      0x00a672ec
+       0x43b02095      0x77379908      0x7825bfb9      0xf5ff4294
+       0x7856e44d      0xbc93ca35      0xcb438147      0xd97fd733
+       0x99688600      0xdc733710      0x2f037638      0xc4ddb296
+       0x7ccbda40      0x778f7ccf      0x74b2b98f      0xcc05f661
+       0x924e43b9      0x5c431963      0xb88c96ca      0x5ccfa245
+       0x02f99a10      0x9da22350      0x11fc025c      0x3ef0aca9
+       0xe5f590c2      0x7f85d107      0x06f7e54f      0xb8470205
+       0xde118611      0xa4eb40bf      0x25121ed3      0x01d6f88c
+       0xe16d339e      0x7a8a875f      0x31f95cea      0xf57d041e
+       0x8ed06d87      0x316bdbb4      0x445daaba      0xfb55d984
+       0xc64a786a      0x07242056      0xa86c9064      0xc4bff6ce
+       0xa64f3d4c      0x28b47b65      0x9989382a      0x8f546383
+       0x79619d0e      0x88612e34      0xe3cfd442      0x0aac6573
+       0x1093f74a      0xfdf8dc1b      0xb8fafdaa      0x73fc032b
+       0x6e9b3d06      0x50e3542b      0xea0b6f72      0x265a948f
+       0xa9e645a3      0xc57a87b9      0x0321e2c8      0x89c711e6
+       0x5a66ad02      0xfc4f5b0f      0x33819f0a      0x029b0bc8
+       0x76a339e0      0xfc1fd1d0      0x29745623      0xff9183c5
+       0xd51745eb      0x178d6d30      0xef2fc6ba      0x76189053
+       0x7be1ad16      0x52eb636c      0x1254487e      0xea770377
+       0xc9940681      0x990324c7      0x5350267f      0x4e10dff0
+       0xd3db772c      0xcb359038      0xa57b5d86      0x80cbfd45
+       0x3f8ea91a      0x96096f27      0x74098d7c      0x45bb09ab
+       0x3cff7b73      0x239e92d5      0x2f7f722f      0xdbc59f3f
+       0xe2676f35      0xc14f2ebe      0x0bd46e04      0x28b40535
+       0xeab78871      0x0e1742f9      0x7ff67fa5      0x93701a02
+       0x58ced560      0x85b6a72e      0x2950e89a      0xbac5af0a
+       0xb2fad2ce      0xc96447ad      0xf634aeff      0xbb70d82a
+       0x2ce34c1f      0x1f029058      0x5c2a18de      0x009dfb22
+       0xbb189060      0x962b4797      0x01f11409      0x246a7e91
+       0x16c9fdd0      0x7bc68f13      0xeaca3ff1      0x5332ce8b
+       0x783d4289      0x18a9c034      0x1b506ff0      0xd25fc977
+       0x8141ca94      0x68768888      0x8baded6f      0xd1c0f20e
+       0x69a95bdf      0xa08d8079      0x8497200a      0xbd91818d
+       0x332b8820      0x2b8b51c4      0x4873f5d4      0x4ec3d928
+       0xe60d83ff      0x3fbf3ac1      0x27e6fc4f      0x1071bcab
+       0x3b6ed966      0xf19a393e      0xd797a29a      0x8c2d8482
+       0xc843e2ce      0x062f75b6      0x426d29ef      0x6ab45715
+       0x3c9faa60      0xb4850681      0xdeb05bf7      0xdbff981a
+       0x7a3ee54f      0x105aa065      0x29269622      0x815c88af
+       0x7d6b6771      0x25f5ac55      0xf796b0c4      0x3d6f57a9
+       0x1ca5f54e      0xed0fc5f9      0xef827d3a      0xb112b24a
+       0x7e5bf570      0x2f63313b      0x6126ed6b      0x44227976
+       0x14f37ac2      0x8b52c982      0xf78e83b2      0x64f9a2f4
+       0x00e70c20      0xfa74347a      0x538e32da      0x94b11c2e
+       0x21cdea2b      0xdb0938ab      0x26bcc414      0xb4c59112
+       0xf992d315      0x67dd364d      0x463623c0      0x6647309e
+       0x7bf5c64f      0x8ace892f      0x68ad30e8      0x01389d55
+       0x11b700dc      0x74efb5d3      0x1d25ced0      0x2c86bd8c
+       0xe59fdb35      0x57e63120      0xd84d0997      0x2208cf29
+       0x998f807d      0x8e0256f8      0xe15fd329      0x5b10270a
+       0x0ec96ff6      0xd955d7b8      0x13e764bf      0x5e554bcb
+       0x45c0cdf3      0xf8c9f91c      0x7daa0755      0x1c6f6413
+       0xb122a9e8      0xa43d31f6      0x12269c02      0x9557f518
+       0x7d849a7c      0x2d9e0766      0x85d33619      0x1f5b2a10
+       0xdb9fafd1      0xd7fab94b      0x7dd5280a      0x8cead80c
+       0xd95aad93      0x2b0baf2d      0x5aeb1731      0x8ed77d31
+       0xd6586f58      0x31037e3f      0xae849fee      0x6c4eee35
+       0xb991f5e7      0x71dab084      0xf2180f7a      0xe75969d9
+       0xea22cb4e      0xf845ada2      0x16da579a      0x22fd285e
+       0x4435d048      0x40908c17      0x57706823      0x8063272b
+       0x754f6158      0x8b08452f      0x374515ae      0xdd823527
+       0x78d7aac5      0x77b3a6ff      0x02f7d9d6      0x7850cbeb
+       0x7e6ddf2c      0xcd7f19f0      0x7f707b62      0xbb6cf4f8
+       0xb93a6657      0x1b33be42      0x74b9ab37      0x29644e44
+       0x8aeea86f      0xd3580ee5      0x9ece82fe      0xe01ed986
+       0x9162c18e      0x660f0bb0      0x7262e6bc      0x077f899f
+       0xae40bc7a      0x4719cc7c      0x3ee1b76c      0xc4468fb7
+       0x3f34dbff      0xdafb5a72      0x5ff9e4fe      0x4539989c
+       0xbdbe1081      0xdab2a1f7      0xb8d425af      0x9d9e59a3
+       0xc1a690a9      0x61016860      0xcdfd1061      0x2e272398
+       0xb028a23f      0x4752677b      0x67a087ac      0x8615bfdc
+       0xea5d12ce      0x10fd6a7b      0x49c15797      0xf1c76b96
+       0x38d40685      0x01049c6f      0xc4540c7c      0x78d039c4
+       0xf101a6a3      0xd6f44784      0x5a8599d3      0xa14a649a
+       0xaf617fd3      0x853c8316      0x8b790fa8      0x6fed8ab1
+       0x4f034bbc      0x0b6f32f6      0x8a8ce9eb      0xee8e1fe1
+       0xeb09fc73      0x99b5eb22      0xd8ffb384      0x5615f2e2
+       0x08b5e33a      0x1df76cd4      0x01f7628a      0x8e739ceb
+       0xe7bbbb8c      0x6eef63ca      0x30f5c2e3      0xa673de17
+       0xc7b7cbcd      0x8c58cec8      0x3467a1e0      0x14129161
+       0xe7548bfe      0x38aef9b2      0xc10e96c2      0x08e2cc5d
+       0xd05bf301      0x35bf57cf      0xab0ce3a8      0x80b0b4eb
+       0xb23abadb      0x8730620b      0xd7206e10      0x23a049b7
+       0x3de18d52      0x4e2a6252      0xab9a26f0      0xc55c8928
+       0x15dc991b      0x9b66ec2e      0x97506ada      0xb8976895
+       0xee7ef25f      0x1307c16b      0xa99c6e5f      0x663f8d95
+       0x0bea1bce      0x6e3c4039      0x0e4b3441      0xc4516bfe
+       0xe9231822      0x23c4e50d      0xc6c6dfcb      0x13210518
+       0x9d55ffc6      0xc0d5812a      0xc6403d3a      0xcc1ec8e3
+       0x3d60068b      0x6fb6dd0f      0x0f1c91f8      0xcfabc117
+       0x44f2f075      0xfa0ca3fd      0xe6b03a76      0x68fc3f91
+       0xe77fd6be      0xad1b08e5      0x7d358dca      0xbc32351f
+       0x23b03270      0x3b0eced5      0x219025a2      0x5278c6fc
+       0x199dc506      0x53116f1e      0x7579a021      0x992f0867
+       0xec9de52c      0xca738f44      0x8e528cce      0xaea4a86b
+       0xe550a4bb      0xf87b7b2d      0xda9dfb39      0x52a24b5f
+       0xe9636fb2      0xc0bdc3ea      0x2905b45b      0x0f4b986e
+       0xbfe81d98      0x07fb4fb9      0xa8006475      0x90ab6d40
+       0x4f2a59eb      0xab3a8cdf      0xa9694ff3      0x45f475cd
+       0xac58b6a4      0x6ef7ac33      0xc6b395c6      0x05a7f1ca
+       0x4ae3b73d      0xb6ec7ed9      0x054dc4e9      0xd931cc46
+       0xef695afb      0xa4da64e4      0x49443295      0x3a2a32fe
+       0x486917f0      0xddaf27aa      0xa69289a8      0xf20da38c
+       0xcdab928d      0x75f11623      0xeb04bda2      0x529d78bd
+       0xff5977f7      0x321c95fb      0x7af587a6      0x075f0b99
+       0xdf00681b      0x251b0fb4      0x087ffdda      0xdbc629cc
+       0x2d727603      0x00fb176c      0xcf2299b8      0x4c18d302
+       0x56b7c53d      0xd1659e01      0x3a15095c      0x084bc3ab
+       0xb9cd09a3      0x74b68adb      0x5d3b0b55      0x91ea5fa7
+       0x7d7fd69b      0xe10db4ba      0xcff44599      0x8cc7c57a
+       0x705acfca      0x45938a42      0x5adfc06a      0xfdf53e40
+       0xae863f94      0x1d714c35      0x163eec74      0x7a783abf
+       0x5198bd0a      0x1c58dfcf      0x475bf311      0x7ce65014
+       0x56aa90e5      0x42c895a2      0xc596de93      0x2430dd39
+       0xe3842b54      0x69f17ed4      0x751e15f0      0x7cdd4802
+       0xc7a38bb1      0xba4e8928      0x25ad8804      0x86bb405c
+       0x830aa8cf      0x4e895c62      0xced039b4      0xc114eee9
+       0xe0e0a60c      0x97d19ed6      0xe6092c51      0x841a3043
+       0x5eb7ddc3      0x71448935      0xed0d7a26      0xf235d4d2
+       0x288d2d88      0xb99a50b9      0x9bcfc8c3      0x2b55289d
+       0x8bfb6172      0x40ceebc5      0x402c0c77      0xd4ceb34d
+       0xf6385897      0xf7df4d01      0xf18e0e6f      0x0fa058ef
+       0xb0112cad      0xfec885d9      0x2c6e2143      0xe4aa44b3
+       0xcc123799      0x8110e66a      0xf9f7d645      0x5bd300c6
+       0x1214d21c      0xef5804b8      0x2d3b2b7e      0xaf3a9031
+       0x5c180002      0x75b90aeb      0x18c29e8a      0xbdfb01d4
+       0xdd4dc595      0x7f8076f3      0xa9cba2e2      0x99cf6f67
+       0x0fd022fe      0xb5538834      0x5b0291d6      0xd8dbe942
+       0x1661c100      0x01c0e25c      0x995373f4      0xb9d5210b
+       0x46de577b      0x66edc055      0x5b494e09      0x82994be5
+       0xb5319c5a      0x3c032d30      0xfcfd3122      0xf70f6841
+       0x55833150      0x45500f5e      0x6308d114      0x93ae1d2d
+       0x4b251b37      0xd864e850      0xb9666118      0x9cc376b8
+       0x0ff2d556      0x3d554482      0xb167bd78      0xe5326edb
+       0x6f96ded1      0xd36a3819      0x5d2533c6      0xd8bb6f76
+       0x9117f098      0xd15d3490      0x1a809511      0xe29ac377
+       0x59e4a6a0      0xc6a26923      0x39ad2b18      0x0a0e25d9
+       0xf90b9ed6      0x557979b0      0x63f46a50      0xbf4db542
+       0x385fa5b9      0xfa5203ae      0xcc0fc7cd      0x093f4e88
+       0xac6935dd      0x958383d1      0x7546fc71      0xdd55a8da
+       0x014c1390      0x2b5e4a4a      0x3e98f6e5      0x54c9dd32
+       0xf9b8ad65      0xc34c22e9      0xfee4bd68      0xbc76386b
+       0x444e0de9      0xf453f4db      0x2bf32c8e      0x04e59b70
+       0xd5f64156      0xeb92df14      0xb5c6a23f      0xe266523a
+       0xcca5173b      0x01d591d4      0xbc2539a6      0x1fe2e8ac
+       0xe41c0479      0x08b926da      0x1042ce0c      0x4caab34d
+       0x4262e57c      0xe6e22d27      0x11cbb858      0x386d9752
+       0x94c78761      0x2a5f6ec2      0x109e1570      0x8afa7f1b
+       0xf80c3f45      0xeed3e35f      0xc0f21335      0x4b9bdfc0
+       0x5ccf7898      0x8b3faa0a      0xff063c10      0x23e1fd5b
+       0x1439bce9      0x7bf0cfe2      0xd6ddb09d      0xe75be413
+       0x73171bc6      0x4c27f83c      0x87fa22e0      0x5cdb9816
+       0xc69e7a60      0x64411e92      0xa5526093      0x9e933164
+       0xa221f062      0x48ce59f1      0x55b16d57      0x67a62b38
+       0x2412ea48      0x2bc2e179      0xcdf4a4e6      0x4137109d
+       0xd839f653      0x0adcfdc0      0x0f05fa9e      0x1a18ba0d
+       0x06c16e26      0x853cc6fc      0xf1397dda      0x22c5e2f7
+       0xe8765f56      0x25ce158a      0x8e793357      0x4d7b8b30
+       0xf588b997      0x06a32454      0xd839d6d8      0xd692f2a1
+       0xec36dc6c      0x0228727c      0xf69c9f73      0xd3e1c478
+       0xf32ba4e3      0x96882a1a      0x754d7eca      0xc599575d
+       0xf549c236      0x0d41a167      0xf1577beb      0xfd3b2f10
+       0x89b03bbc      0x566bae51      0x0d044d5a      0xb937cb9c
+       0x69c6b7a4      0x1ebf11f6      0x7b09c9a4      0x403d1034
+       0x8117641d      0x75deec4f      0x99344c99      0x3845cfea
+       0x8f136ad5      0xc45bf1bd      0x36427b55      0xaf7a5a6c
+       0xe798b507      0xfbce0aa5      0x45468f1f      0xb0962e39
+       0x267cc5f9      0x3d5037c6      0x6677c27d      0xe7159a11
+       0x1fc259a2      0x1cb37a96      0x301c5c5c      0x293a615b
+       0xce8d19d7      0xe81fb54a      0x0c7ffbb1      0xa4d7323c
+       0x7c3f486d      0x535fb696      0x3906cd94      0xeed39f9f
+       0x362c31de      0xaeb55004      0x9c0eef76      0x452c520a
+       0xf3cfaa7f      0xbdbee79b      0xfd7f66e1      0xf44ac540
+       0x170292eb      0xcfb9d013      0x0b28e250      0xfba3d60b
+       0x421bc9e5      0xd8c15315      0xb56dc725      0x99f68442
+       0xd67d3ff5      0xb6011295      0xce6b90ce      0xdc500103
+       0x09a4a39c      0x92d30818      0x09041f41      0x3c8d8d47
+       0xc0d659d7      0xdf7440f7      0x3727070d      0x2a0d1581
+       0xd1a498d0      0xa504267f      0x864a924f      0x3879f03d
+       0x6062cb1d      0x7ae7e805      0x9c22d959      0x97248838
+       0x3a662647      0xfdd9b098      0xb8d3431f      0xe6915cfd
+       0x74822dd8      0x5ef76b97      0x401faec1      0xdc84cb41
+       0xcf2d741d      0x88ad7cdb      0x066f4c50      0x89dce129
+       0x118c7e20      0x2defee1e      0xd0ebafd1      0xf4d681ed
+       0x90c46177      0x892d7289      0x48f9828a      0x50cb9b23
+       0x7827ce47      0xf0616533      0x748a5081      0x19fc4294
+       0x5fda3f95      0x9499164c      0xf9d7f352      0x952bf990
+       0xb4dc8f9c      0xcc88812e      0x0258400e      0x6b050b68
+       0x79de2d6d      0xa1deeb92      0xd55eb430      0xc81e31f4
+       0x97767d50      0xa35b3db2      0xd74a63da      0x61927047
+       0x861339a2      0xccf2a638      0xa904c57a      0xebbe70e0
+       0x0672d7fa      0x53847bc3      0x2bd19d6e      0x35f87e55
+       0x79dfa574      0xc77c9259      0x3db8e204      0x4f69a7aa
+       0x0eae5ea9      0x90127e41      0xe50a3226      0x237116aa
+       0x4d8a8759      0x96e5892d      0x221ba34a      0x35910c0d
+       0x0b406faa      0x3dbbda98      0xd5c6d746      0xa41c2cd6
+       0xcef55c3e      0x8c812c91      0xfd7916af      0x4aeeb39e
+       0x80554580      0x5d5c2154      0xf82dc479      0xbea6dfe6
+       0x4a4a8dcf      0x592da727      0x19744180      0x07620b3b
+       0x431ff0aa      0xbc87521f      0xe19f6511      0x79ead9af
+       0xe23bce04      0xd5abc76e      0x5759924d      0x474898d0
+       0x9441a1b6      0x52fcf281      0x9955e182      0x9724989b
+       0x7c33c814      0xac183167      0xedbc9b72      0xebd53093
+       0x34ca4385      0x48b1f81c      0xd907dc84      0x1ba2af8b
+       0x3005b61f      0x8773a1f9      0xe6c4f7b4      0x56fa373c
+       0x9bf07793      0x5d0c12d0      0x8816beff      0x5aaafe03
+       0x7c83d3b4      0x3663f1e2      0xa8eb3a75      0xb1df9a8d
+       0x9e9f963b      0x2590d1e1      0xb5a22e6c      0x50bd5747
+       0xf9a712c8      0xf4b38d4c      0xda7983ea      0xccf13693
+       0x2a8a1316      0x3fff4538      0x49b95af7      0x7d6ba752
+       0x22e1eb18      0x0bddd19a      0x1515fbfa      0xd43be578
+       0x41c5fa80      0x8677b07d      0x0c60aa31      0xd6954051
+       0xb1da146f      0x7159de7c      0x5ac7fb92      0x5253ad7d
+       0x632bd4ab      0x557f6b62      0xa25f11f2      0x657dd844
+       0x66fcb6da      0x5bc59a0f      0x94b9a794      0xac1781df
+       0xf1a7de97      0xc9c71a7d      0xede0155d      0x6962220b
+       0x16f3a89a      0x1146d6ca      0xafda34e0      0x2d722029
+       0x588e0e82      0x009e3aa9      0xe5d38bab      0x71d2a0e8
+       0x712ee851      0x9a94cfb0      0xb0797474      0xababf02e
+       0x5096543e      0xbc58135b      0x98d6652a      0x2e698c4e
+       0xf7056fab      0xb15fc513      0xd961fea9      0x1a267639
+       0x3a0f44fa      0x80b11f1d      0x4be6cc50      0x280006b1
+       0x21f13484      0xb5e02c7b      0x5cd92e48      0x19cd5adb
+       0x872900c5      0x42dd5a7a      0xaad2200e      0x1c48308c
+       0x5f7ec677      0x06ac63b4      0xe0a6ade0      0x1940156e
+       0xe7046241      0x45220c46      0x295ae299      0x4bb0f6bb
+       0x2a60dd76      0xa104450e      0x21a10980      0xe2f2077c
+       0x40b8d577      0x2a03c63e      0xc8a6973e      0xa7138a4d
+       0xa2676991      0x567f81ec      0x9cb52e57      0x5e32f8bd
+       0x1ef58792      0xa66e1ee4      0x0a90db6b      0xd33d85ac
+       0x14b49b71      0xc9659989      0x9c8a0ddd      0xdc957741
+       0x156b62c1      0x9eed3ad9      0xbee1afdc      0x90cc0017
+       0xaf81bd10      0x83b6e93c      0xe5f9a7fc      0x2f3e1479
+       0x8b02a83c      0x08113f61      0x35423597      0xfa7342b0
+       0x16eddb81      0xd03c8e32      0xac7939fd      0x26427c43
+       0x799470b8      0xb5bcbb06      0x20f80b2b      0x58448c86
+       0x10dca136      0x90b88e18      0xd7665da8      0xf5cde886
+       0x9444a426      0xeb2f7fd0      0x3ee76b79      0xb1ee249a
+       0x4ac57ef7      0xd9bc7832      0x079f51d4      0xe7a83b41
+       0xeb2ecbae      0xc0345aa6      0x13aa6af9      0xdc5ca595
+       0x875a8f87      0x6405c814      0xc62cfbae      0xc7ff51e4
+       0xd5f4fe20      0x10c527fa      0x0c88c6d2      0xe0c2aa78
+       0xc813a577      0x83488757      0xc46ea7db      0xdbe578f5
+       0x44a84e9f      0xcb9a4526      0x458087bf      0xaa09fed9
+       0xe276d1f3      0x8fd4ff78      0x77aca453      0x328f496d
+       0x8eb4f1ad      0xc04665ca      0x695a8afa      0x7098f984
+       0x08321558      0xbe3acc1b      0xd4ad0cdf      0x76304b6c
+       0x1a43b8e1      0xc049e514      0x928f94f5      0x2ad3dd9a
+       0x6bf4af9f      0xbf46f13a      0x2e338d1c      0x1cd0b823
+       0x06f721fe      0x091a3734      0x0f883cc5      0x80f530ee
+       0x26fdaa91      0x6a5c5516      0x18ba8e97      0xa7c0ebb6
+       0x9551b39a      0xec2d31e7      0x6e0a828e      0x3579c327
+       0x4b25896a      0xe76622d6      0xc8bbd6c8      0x0617ea89
+       0x8044700a      0x59fccb83      0xdb6ce1c5      0x3f421bbe
+       0xa231c0f7      0x05d5ca07      0xc2b8ae19      0xea8dcdfa
+       0x79b10952      0x14e9789a      0x3deb8a4d      0x889f2c82
+       0xa57269ee      0x0b13800d      0xec698375      0x4ddec8ad
+       0x5a27ec6a      0x404c3ffa      0xc1d2ab93      0xf9467c64
+       0x2a2cf76f      0x5094040f      0x02c948f8      0xc2320050
+       0xb1aac90f      0x8aac5ae9      0xccc0987c      0xe004dd86
+       0x91fb4514      0x20380ca3      0x28123886      0x15fdbb6d
+       0x4a55f90a      0x46d4f6fd      0xc08cac23      0x53426f96
+       0x071dd140      0xd9c7000c      0xd637fe69      0xf6e6eaeb
+       0xbd35733f      0x914820f9      0x28138700      0xe5043ee5
+       0x1c328710      0xa9e4e2e5      0x22a8b90e      0x7f3db751
+       0x202181b5      0xda03ad84      0x2dd67be2      0x725443b2
+       0xff166384      0x5017dcd8      0x4e7e1aec      0x30b7f67b
+       0x9450369e      0x8011988f      0xad4ec671      0xf31d8577
+       0xb3360158      0x8b2f0243      0x5a031949      0x5fe77f92
+       0x18d80acc      0xbbc1de0b      0x0e9dc1f4      0xd9841e11
+       0x0c4fa249      0xbd8a7b39      0x0686bb06      0xcdcb1b9b
+       0x6c9f5724      0xdc5dc57a      0x2e8579bb      0x53b889ef
+       0x7950a90c      0xe8ad0555      0x767baebc      0x4c8f5053
+       0x5e7c0471      0xaf2c92f7      0x906c2997      0xea2a2fe3
+       0xed846bf0      0x96ea7dbf      0xcd01cc5f      0xcb9e8d0e
+       0x74219ef0      0xef3adc34      0xeb163834      0xa1c4e676
+       0xff1b6585      0xee5e8ccf      0x55dced19      0x1f18e912
+       0x4aeddf34      0x3134baf2      0x8c7408f9      0xd3d555ad
+       0xa71d5e8e      0x48ff7ac1      0x40bb0d16      0xdd3a8b8d
+       0x12ff2338      0x90448ef6      0x09acd582      0xe72ba1cf
+       0x72a5c4b6      0x98c73d08      0xcae03eee      0x3df5819f
+       0x6db887cd      0x98a293ce      0x96dbb431      0x2d821188
+       0x03ce7b77      0x0ba452e8      0xe88d892c      0x9b10177d
+       0x0549b0d3      0x55d55fcc      0x9f2bdf95      0x0b0294f2
+       0xcec42d31      0x873c794f      0x5377c1fc      0x77708f23
+       0x63ca4ddc      0xa7e5d602      0x8fdbc57a      0xaa18aff1
+       0x62b605e8      0xa2b86848      0xa20016a2      0x00fd7692
+       0x9a873fe3      0x5de68e1d      0xd9e42257      0xefb67bc1
+       0x93c88af9      0xf75fc72d      0x9b25656d      0x668ed375
+       0xd9acbb0c      0xd1c7c924      0x981b9525      0xd662c26a
+       0xed72f096      0xd3c3fdda      0xb04355fe      0x6bc8bab6
+       0x789d63cc      0x740583d6      0x70abb714      0xad48ff9f
+       0x2ca22ad4      0xa854d444      0x9677aaab      0x0e81c911
+       0xa25444cc      0xf9a06e43      0x4d2db8d1      0xac2053a9
+       0x613dd679      0xbf7e3c40      0x2943a806      0xa61d38ef
+       0x9ae94609      0x436b4e5c      0x187ff98e      0x231e52a2
+       0x86054ca6      0xecf257d6      0xe5257c77      0xe70da685
+       0xc3e421eb      0xd60aa7fc      0x6e1919a2      0x93ca9f56
+       0xb4c47047      0xed7b326a      0xb0d4c65e      0x1b4c6585
+       0x98ee23a9      0x8b02be50      0xe7a550fc      0xba65ee41
+       0xa21e2ae6      0x96358109      0x366bf2cd      0xf59457cb
+       0xdd6f7b53      0x558ebc30      0xaeaa74fd      0x1ee49f6f
+       0x537c6d28      0x8c5444cd      0xff6f593f      0xd945af32
+       0x9773c46e      0xa704e271      0x1063d8ab      0x93923079
+       0xbd337761      0x355a24d9      0xf8d29328      0x37c5abe1
+       0x3ae0413e      0x570362f5      0x4725920a      0xfc0c8480
+       0xc9013266      0x254bdb6d      0xe4ea07be      0xac8516a2
+       0xfdb434c0      0x5e6b63bb      0x20d8c301      0x0a711005
+       0x54e746c3      0x70f31e33      0x228f6eec      0x958771e5
+       0x4b28b880      0xc200c74d      0x142828e3      0xdbcb1bcb
+       0xa478999b      0x972e952f      0x44a087bb      0x23454d9e
+       0x1ee0c41b      0x465d4fcd      0x13f0748c      0x1c5fdf9b
+       0x0ae695e7      0x7cbc0003      0xfddcb384      0x28709530
+       0x28b31b1d      0x0e97b9be      0x34ac30ec      0xf32183a2
+       0x27efad6c      0xdf59d9f4      0xd4d0fe3c      0xd7f2d272
+       0x7aa0f994      0x6b80a7ff      0xef6237ac      0xd01476a9
+       0xae3779f8      0x70a300b4      0xb70ce74a      0xb8269584
+       0x5e952160      0xae3a4370      0x5c059379      0xf852fb5d
+       0x4878dd84      0x1bc1fa53      0x831d8146      0x09a7161c
+       0x2ad0c319      0x02322b64      0xb20a59d5      0x00a5ab41
+       0x9fee3763      0xd326b5f8      0xc77ae60f      0x74f365bb
+       0xe03e9119      0x402a8743      0x9546d220      0xbe3b033f
+       0x6880bb9b      0x88e4a68d      0xbbe891e3      0xd013b88c
+       0x241ccb6d      0xb8f84d10      0xc0380977      0xe92cf4ed
+       0xb9865c02      0x52080d16      0xd8087180      0x4f812ff0
+       0xf9c92032      0x34ef19d4      0xe4c9234a      0xe19d5826
+       0x0806dc19      0x0c2f57a7      0xe95fd568      0x8791759d
+       0x08d873e1      0xee84f913      0xe707325f      0x194d223a
+       0xbec998ed      0xe6634d6a      0xbd6bec97      0x33aed549
+       0xdef231ae      0xd3e8f30d      0x7e22487c      0x382b640a
+       0x64dfe286      0xa451a5d0      0xfc0cac50      0x60130b4d
+       0x280ca76e      0x3ab1f4a8      0x04e7c852      0xff970d16
+       0xd04441ed      0x9b7ac0ff      0xd6fc36ab      0x484e5bab
+       0x5fa47f7c      0x4cec1597      0x7296d1da      0x42f79edb
+       0x2258c124      0x0ac2bee7      0x61f4aff9      0xcb215cd9
+       0xeb78d060      0xe4f4ab1b      0x6acded2b      0xacc0b7c1
+       0x4ae274b1      0x6d927b9f      0x84400c02      0x662dbfd6
+       0xe7c5ca69      0x93979af0      0x21ac483a      0x9be6a2bc
+       0x46c74097      0xe89d095c      0xf32bb932      0x36689533
+       0x472ff5c3      0xe9475a7f      0x867a2761      0x60b5bf9d
+       0xe99a3872      0x30be62db      0xc0dbbb03      0xaf2ced29
+       0xfec115a0      0x4c61d616      0x38617ca0      0xc51f3fa1
+       0xc665dd17      0xc0e1d431      0x17e7a214      0x1e183a38
+       0x3021f00f      0xbc982f5d      0xbcc22a68      0xc0450303
+       0xfd61f6da      0x43ff2a1e      0x55cf7053      0x249e1749
+       0x27e0be78      0xb5b91f52      0xf56124f7      0x76634cbf
+       0x76b675e4      0xde357ca4      0x20a257e0      0xbd756e46
+       0x27a8e847      0xc8ac0a42      0x5e2b6fce      0x0bd2448c
+       0x140bb6d9      0xa988442b      0x54d15ea4      0xeaee73cc
+       0x74cebce5      0xb78c2adc      0xc839757f      0xb36b17d3
+       0xf4f5b379      0x51bb74f9      0x37d67eaa      0x575d74ac
+       0x1de29504      0xe9cc5581      0x6aed1b4a      0xba9fa86f
+       0x3182d3b6      0x022d7572      0x0d8a22dc      0xa64334ff
+       0x3f761958      0xa9037576      0xfc4d7f96      0x3aa22b65
+       0x846efa4a      0xdd80a3e0      0x03fbde27      0xfc855b1f
+       0x150c8f6f      0x5d637d49      0xc5eab850      0x92b90863
+       0xac9f35f8      0xdcbfad29      0x8aa17deb      0xbb3be924
+       0x66fe646c      0x43947c14      0x6ec1f7a1      0x8ddcace3
+       0x6b83a354      0xdd4af970      0x5eab946b      0xb5252709
+       0x0eab6c81      0x79691c50      0xc9bc05c2      0xc56f724b
+       0xdfafe3e0      0x2914d4df      0xc8d180ad      0xd3f0dfb6
+       0x6c488c50      0xba6ec58e      0x6e4eef8b      0x16f3ed1e
+       0xb4543d92      0xc0e7d982      0x39f2a328      0xc3a1f1bc
+       0xa064fe61      0x0214a735      0x1a1386dc      0x28854bf2
+       0xada8fec1      0x467373d6      0x679185d2      0x43addac1
+       0x9c09012b      0xf4ef51df      0x78ed05e4      0x2a6d0f9b
+       0xffa16159      0x0c458d27      0xdec28434      0x760e394c
+       0xc723e3f2      0xa81a05ee      0xf9e899e7      0x96471a02
+       0x1cd751dd      0x1325bbae      0x36f8ce98      0xe86b606a
+       0x02eece60      0xad8ebcf0      0x41e18188      0x21b49788
+       0xaf8dc963      0xe3d3a040      0x6ade028f      0xa2fa82bd
+       0x122c3683      0xee4fdae0      0x8efa07ec      0x6a7288dc
+       0x4fddf86e      0x44268c33      0x5fbb1a4d      0x8700fd54
+       0x797f7612      0x749820cf      0x615a74f7      0x459af147
+       0xf3c5ef9c      0x2db1a903      0x0cf987ea      0xbbaf9ec6
+       0x928003fc      0xb7d640ae      0x20404e87      0x7c22beaf
+       0x17b2cac5      0x2645ff60      0xdfad9c15      0xeba8d4b8
+       0x4c24b1d7      0xd0ad14da      0x02f59912      0xca103268
+       0x3fd5c882      0xb33eb2a1      0x15d53b45      0x1c4b40f1
+       0x6f167209      0x277428a1      0xb24d3d67      0x8bf2dd6f
+       0x5036e270      0x8c14131a      0x773c0308      0xb3fa442a
+       0xdb94b529      0x9b6212ea      0x5b336ffb      0x022bf0d8
+       0x3f640b34      0xef9c4aa3      0xf2bbfc50      0x03c2ce01
+       0xcf2cdb10      0x5cf42856      0x52febc20      0xe9ae08b6
+       0xefffdf15      0x661789fe      0x0684fcf5      0x8f93fcfe
+       0xdaa62f2a      0x64256c13      0xbf7b84fe      0x3cfb782c
+       0xbec00099      0x2f0128fe      0x31ae7cd3      0xde1e2bfe
+       0xde8c06ca      0x5cbf3fab      0x3736139e      0x198bd420
+       0x0150480f      0x641babfe      0x7921a3f7      0x507aec00
+       0xfe8b84c9      0x3fae514e      0x83176c72      0x5083eeaa
+       0xa55539d6      0x61c0c0df      0xd9a0a973      0xe2d31942
+       0xf207e311      0x3ce074c7      0xf1bebe23      0x7191da1a
+       0x0753863a      0x6fd1dbcb      0x6bf5b29f      0xa4efbf25
+       0x32262b80      0x57cccd0f      0xb7db7e8f      0x6a23e3a9
+       0x88aaf00c      0x8d3a8771      0xe12063f2      0x09d4a3bd
+       0x84f4e9a2      0x4f5befe7      0x55e3d393      0x67a665ba
+       0x34843f6c      0x6ffc7586      0xe9cfa15e      0x5a2254c3
+       0xe51f2252      0xa16a798e      0xd1fcdc73      0xe605da6b
+       0x2d2e6a8d      0x745d9344      0x4e2c26aa      0xb00452d9
+       0xa10a5335      0x616dbe86      0x761b2901      0x01983b05
+       0x2910a1be      0xe0675eea      0x817e14a5      0x6d593239
+       0xb94cd6c1      0x95a37b1a      0xc34e19ee      0x3602f3fb
+       0x78a39034      0x2c86ebc4      0x6334d07a      0x8ba000ef
+       0x7074f02c      0x94f06d72      0x32de9bf4      0xf48778e0
+       0xf651e46b      0xabf2a2bd      0x523de3ca      0xf58ad983
+       0x86d8399e      0xcb662a76      0xfc022a46      0x6173aba7
+       0x36d33756      0x6e3d332b      0x517a04bc      0xf02f76fe
+       0xdb561162      0xb3c78359      0x9f16f1dd      0x3aec1af6
+       0x5ea0b06b      0xa657151e      0xe44eb56a      0x13e33ce9
+       0x40fbfe5b      0x10a29421      0xc9819551      0x88ea4e14
+       0x45eaaebc      0x2fe5ffd5      0xe4cc195c      0x54eb68e9
+       0x1742728f      0x8367f6f6      0x8c688da7      0xac11884f
+       0xaa56c42a      0xa29c6913      0x91b4bde2      0x30870b8a
+       0xbc9fe340      0x56fd2ed6      0xac4c634f      0x8909ae88
+       0xd11f283d      0xb4316e11      0x7c78e08f      0xd57a01ad
+       0x17f35816      0xc238b141      0xaa7e0207      0x181287bd
+       0x3e89e951      0x9fe4d51b      0x23585101      0x6f7c22de
+       0xb7fc5edb      0xf8eec9de      0x2abe6258      0x2596aea1
+       0x8b3a5da2      0x29dc6c79      0x70006c13      0x61ba4a1b
+       0x220619e7      0xd7daaa5f      0x43a3f342      0xfef7e868
+       0xc522f4b3      0xdcf0d420      0xcdbd86b5      0x63127851
+       0xd26ef11e      0x68b4d310      0x6407192b      0xfa1bb250
+       0x19df44c7      0x51a94190      0x64fdc4c9      0x5ce63a21
+       0xdbb155bb      0x7518c3ac      0x22c0ecae      0x217fe9f5
+       0xea2187f8      0xf7ba95ce      0x9056efb1      0x1ce5a738
+       0x088db3a0      0x9da2f504      0x8c1bea48      0x183f94c9
+       0x00036f43      0xf968103f      0xc4bf8df7      0x8d3d2999
+       0x5df4e220      0xc81eef6f      0x0f3d9677      0x47f1cada
+       0x2649acf5      0xb5130cbe      0xc18f6b49      0xdadd8e60
+       0x498228bf      0x150cac1f      0xb42c0b2d      0xf01a47fb
+       0xb241af06      0xee91bcb1      0xa2d34e38      0x02464f7e
+       0xca8fb706      0x50899acb      0xd97ca84f      0x0c9e0de7
+       0xe6caa938      0x4a10a877      0x1d5d24f9      0xdcd2f18a
+       0xaab730e2      0x74a740ad      0xb3a283a0      0x72e793fb
+       0xeef94d91      0x7d2b4126      0x8c6bd15c      0x0f26ceae
+       0x111a3221      0xeacb6b03      0xb49c4a78      0x2a58bc52
+       0x11628f34      0x4408efb4      0x28d9a45b      0x56349c15
+       0x3d22cfda      0x3bfc45d7      0x1ff60af5      0xda9b4d89
+       0xa85bc42b      0xf6c9f43f      0xb36a970b      0x5b53b5f6
+       0x7af9bc44      0x8d9027d5      0x14777756      0x97b7ae5a
+       0xc5e869de      0x8747cb67      0x9e22f39c      0x289597ce
+       0x41799183      0x1d016198      0xdfa33050      0xc565cfc7
+       0xa76eabb6      0xbe73fd3e      0x7daf7a1d      0xbba1af3b
+       0xea46e5d6      0x1c2b02ab      0x11014a8f      0x2393a58f
+       0xe7323094      0x579a260d      0x9cd929f2      0xf91aa449
+       0x0a8c78c2      0x7b73cfe4      0xe76e9cac      0x0fa27ad8
+       0x2e2b902f      0x403ec747      0x1ef3ddd4      0x30031e60
+       0xed842692      0xe3ea51f8      0x47635090      0xc01de2b5
+       0xbf3b751e      0x3587b5c9      0x59e8755e      0xc1693522
+       0x8b7ddc6c      0x58c43d4a      0x1d9b9054      0xba226c04
+       0x2bf7ec73      0x1deee9ec      0xdba3d539      0x80745e39
+       0xc9e284ac      0x0ee09570      0xeaa8bc65      0xa620b6e4
+       0x0b0c5d97      0x7f55d0e6      0x833c43ea      0x24220df6
+       0xddacbd4b      0x1f8fc529      0x0f4fe0b3      0x891a1591
+       0x7012b3f1      0x07832622      0x3c61374b      0x2b13cc2d
+       0x059836ca      0xb905dd30      0x46bbdf40      0x22dca3f0
+       0x0490b639      0xb56bcd63      0xf195cf4e      0xba3d0356
+       0x99b96a01      0xe755273c      0x6c3ec9e0      0x778b7f08
+       0x7d387316      0x6faaf9cf      0x1790dfec      0x27f2ada2
+       0x3ac69b89      0x08959cf8      0x763ab69a      0x073ff2c5
+       0xcf571c25      0x08fd7088      0x7d19976a      0x1678b9d6
+       0x2ac19909      0xe797d8c8      0xb2e4d084      0xd9ea75c2
+       0x80346355      0x81640d42      0xaf02d6fa      0x8e54dab8
+       0x9b31b549      0xe88ea631      0x319b2af9      0xdefb5e41
+       0xd407ea84      0xcfd07ef6      0x6048f9af      0x256cff61
+       0xf9c2a5dc      0x81714aac      0x78b889b9      0x081e430b
+       0x685d3e62      0xa1407d5e      0xdd17ea85      0x9ca8ee79
+       0xd3cdad92      0x5223c7f0      0xa1183331      0x7541200f
+       0x3ddc098d      0xb9036569      0x41ba59e3      0x9c2a3ece
+       0x98244c69      0x1f4cc02d      0x6b7c36d4      0x8f6c7e73
+       0x498f95a2      0x29b5d208      0x2c07d419      0x48509d4d
+       0x6d123798      0xfbebb981      0x08d7ffca      0x0167ae70
+       0xf7ea6ecf      0x47db3ba2      0x3f8fa989      0x0621efc4
+       0xe7928352      0x968ffea2      0x7a6e6599      0x966653fc
+       0x4f1552fd      0xf60871ca      0x3c47f43c      0x91cbbdcc
+       0xd733d221      0x3622a213      0xf5b7611b      0xec76f2b9
+       0xd204e140      0xa5cf7e9d      0x77bb0b17      0xf1d5563c
+       0x178aa04c      0x5ccf3598      0xdd989873      0xe4119d76
+       0x09066c42      0x7ac26142      0x6d59c50e      0x35f30792
+       0x631dbc96      0x9bf5de1e      0x5b29235b      0x9be7314c
+       0x89d845ab      0x14dd590f      0x0abcb26b      0x72165c7b
+       0x5c91c4cc      0x545c2f25      0xbbd8a9ee      0x68254246
+       0xe5a0d066      0x748a2f6f      0x5f9b8df2      0xcb326324
+       0xc08a3313      0x36bb5986      0xdb56e140      0x84b1da59
+       0x61386c35      0x6b4f5b57      0x4777dc98      0x1adf379c
+       0xc87b6604      0xac32cdc9      0x5ca4f599      0xde1dc898
+       0x156a1d1d      0x82ae2868      0x88fd10f7      0xe081eb89
+       0x163a59e2      0x9706310e      0x5d816169      0x96ca0ac7
+       0x7327e60f      0x2ff46a31      0x72883285      0xd3c60e64
+       0x13e7712a      0xbf8f00d5      0xd70e6fb3      0xc75c31dc
+       0x959266c5      0x9e7ceef5      0x493e7dd4      0xd8326f9b
+       0x232823a0      0x4b49547e      0x41effcca      0xd0ac2afa
+       0x929b8818      0xe225c03a      0xb9021161      0xd2a7a1be
+       0x78bf1d64      0x532a6ae3      0x9da903dd      0xef52a703
+       0x2b061c1a      0x7be50bd8      0x259ae7a0      0x307554d0
+       0xda2fef9d      0x81e7a2f5      0x2c9ecc8c      0x77c147f9
+       0xbd2c0c77      0x09356522      0xb1335de9      0xdeef78a3
+       0x5b064b9f      0xecf44e3a      0xc9857343      0x24ee2559
+       0xd191fd85      0xaaff6408      0xf655031b      0xc5ad281f
+       0x379bd03b      0x720af68e      0x5963cf0b      0x75f1f1af
+       0x8d02f77f      0x64ebd0a8      0xfedfdb40      0x44d66bca
+       0xc05fc130      0x9eec62dd      0xa7e31f6c      0xdc02a5d8
+       0xb6538f56      0x2b82de31      0x0d1e7021      0x3b0606d3
+       0x58d122b8      0x23523afd      0x85d4d9d5      0x5e01d3a0
+       0xe07114b7      0x63b3848c      0x11364889      0xd68ae79d
+       0x3d6d5075      0x700eef85      0x573d1375      0x8ebc9e2b
+       0x66a73b54      0xa43a8644      0xa1502474      0x7db81eba
+       0xd9a7dc21      0x70ac5451      0x6bac2f9a      0x0b18dfe6
+       0x8df3b69f      0x0d7c8b4e      0x5bc6fc02      0xfeea33f8
+       0xfc758abf      0x481c98a4      0xd3b80752      0x3c2fd24f
+       0xd9864242      0x3eded654      0x79ea765b      0xfeded0f1
+       0x43f5af84      0x24aef30d      0x9167eb00      0xc04973ac
+       0xc08966fb      0xab9e3963      0x86aec525      0x6b4a4cc6
+       0x1b2c5811      0x1b6edd2d      0xbc9573bb      0x598836f3
+       0xd91c432f      0x78c32ac4      0xa141af48      0x8b669392
+       0xf03887d1      0xb93a1fc7      0xd7b4289b      0x18d33daf
+       0xc98acaf2      0x1292ba46      0x536e9fa2      0x1a6bd688
+       0x520d3c8c      0x71ed033e      0x08c18a1a      0xa7930480
+       0xbd9e9fc3      0x317a9e5f      0x5d1795eb      0x4f11fb40
+       0xd5fd6e1c      0x96f77c02      0xf038bd42      0x0de6ca9c
+       0x0b91905f      0xd3ba1530      0x21560d65      0xdc45835e
+       0x18c9a448      0x941a6c48      0x2c2066e9      0x66a51835
+       0x9686761b      0x07c23247      0xcd098550      0x41ecf37a
+       0x243e54e4      0xcdfbfddf      0x1849494a      0x0bf543db
+       0x152eadb3      0x89c72809      0xa4cbac40      0x183146e5
+       0x7d168d60      0x1086ccc3      0x3367dd72      0x3b1d0aa2
+       0x3c01db33      0xe43d91e4      0x873bb868      0x19fe5836
+       0x47035551      0x1c8b37c8      0xbd0f807b      0x214b2494
+       0x0ca07c1c      0x646d577e      0x2da32b30      0x7da19a7b
+       0xb74aecac      0x385b23cc      0x2cbe78d1      0xdc037d61
+       0x1539639a      0x94ca15b6      0xda3dedeb      0x5167af0d
+       0x13c22413      0x549a0e4a      0x5915ec25      0xaed28ae8
+       0x267bad80      0xe7b8af5b      0x48b355d1      0xad0fc876
+       0x68f9c818      0xa76d8b4f      0xf47281ea      0x70c6e67b
+       0x02419edf      0x536b7b7e      0x254e86a2      0x98fbc494
+       0x96f9463d      0x6a978187      0x2fc08c58      0x05101c10
+       0x8fa0c5b6      0xfbe88410      0x8c2b36f6      0x442890ff
+       0x227654c7      0x86d1293a      0x17ba3b3c      0x648f19fa
+       0x80fc1fe0      0xb0f97d52      0xb7310f35      0x15d27e62
+       0xacbc0311      0xb34e2cfd      0x91d042a8      0x73e25391
+       0xe0e53cce      0x0c4e02e8      0xbf5606b0      0xfd360ca6
+       0x60c06c8d      0x4f8a7cef      0x84a51fde      0x4b861128
+       0x768341e9      0x2cad02f5      0x35a2f271      0x20741420
+       0x75aed6c2      0xe37a9401      0xa2fe173c      0x72b236bd
+       0xc2e0b472      0x5c5d5562      0x76b531e7      0x703bc983
+       0xa2b048d1      0xa078a201      0x5124a232      0x3ea1d42e
+       0x5e7d56f3      0x920658d3      0x3d8bffe3      0x1fa7face
+       0x01e5a75b      0x4bb398a9      0x6275874a      0x218fcc0b
+       0x57f06899      0xe0b2d1ef      0x9dc04f42      0xe547ed86
+       0x12b2aa12      0xbfd5c053      0x319b8717      0x0a0ade8b
+       0xfa5ef974      0x5772999b      0xc1ad9c2f      0x19e03f38
+       0x9c008c55      0x55d0ac71      0xa0ee2c9e      0x4a3218a2
+       0xc0ee37e2      0x79866535      0xcca8d2c8      0xa0c93ec9
+       0x4368d328      0xaf4fe74e      0x043f3c8f      0x24932601
+       0x5be76619      0x17ae10af      0xfa283086      0xacd83f7f
+       0x4aafbb78      0xa79724ff      0x11594592      0x3e4a2775
+       0x9b0a796d      0xeeaf0d54      0x846b693d      0x8e4f58d9
+       0x3bdb0678      0xdec4f3cf      0x28629851      0xf217adb9
+       0xbffb887e      0x0952a334      0xb64f45b4      0x3f8d2c6b
+       0xac576def      0xd4a80251      0x89bf1933      0xa844ca5f
+       0x5824ddc9      0x37ee7e4f      0x3dd5fd74      0x14f67396
+       0xe6b55410      0x44b39da5      0xfd6252d3      0x8f713e82
+       0xc86894db      0xf6763c3c      0x0a3f0bb0      0x13e03d38
+       0xea061c52      0x9487ab04      0x17979993      0xd0f23689
+       0x79dcb3a5      0x527eb6de      0x64c3cefa      0xa6e2ad65
+       0xf3d80b30      0x6c708fa8      0xe9eeae0c      0x7b3c9198
+       0xcc899f52      0x5b827c75      0xd1c34bc4      0xe932d438
+       0x7f49c7d9      0xfd90b94c      0xf616c822      0xb37401a0
+       0x4215fe95      0x5cd6ccc3      0x42c8ff31      0x407c411c
+       0x70d166fe      0x7ea8c68a      0x941d200e      0x50903d79
+       0x6e363ce6      0x9c5c9af8      0xbcf4b2ec      0x17385ae0
+       0x6e9c212d      0x7fd49b50      0x2077cb58      0xbbd7f447
+       0x59699bcb      0x8c85fbb7      0x9ce177eb      0xea7d55b3
+       0x82d92086      0xe803be8c      0xfb60bfbf      0xa9f66bc5
+       0x7c462802      0xab26bc44      0x11a3c4b8      0xddabf962
+       0xf7e2207e      0xcfee1818      0x51bd15a7      0xceb14b3d
+       0x3f0da511      0x108cac56      0x085c53ff      0x3d86c681
+       0x056546fd      0x7825e0e1      0xbd745f97      0x3de25871
+       0x1ab0d0a6      0x7f39826a      0x69f2a0f2      0xc768731a
+       0x5fc56ff1      0x43f26d03      0x71df5c93      0x9c7bd966
+       0x2070d08e      0xa93e9dee      0x07244191      0x5a8c1c75
+       0x6fb19c50      0xb1a526c7      0x6ccf56a5      0x4c2dcc34
+       0xf953969b      0xe215cf7c      0xf7f633f5      0xe9739906
+       0xf4702133      0x14b47721      0x3a3102ea      0xfbdf5b7a
+       0x381355d0      0xced321e2      0xb79a12d9      0x25cc2ef3
+       0xf412ba68      0x0dce9ac4      0x44287d86      0x7514a7a8
+       0x6e7ed020      0x25d62bbf      0x52201e01      0x789ffa14
+       0x65422551      0xc0e5818e      0xade0dd15      0xb260c82f
+       0x60ae188b      0x410c82bf      0xd7b7826d      0x30f3877f
+       0x6fc73286      0xf46e453a      0xb249469a      0x573d35f9
+       0xa963de9d      0x6675b1c4      0xf92ea74b      0x0f44294c
+       0xb3e745ef      0x42ff7571      0x18c10675      0x789a6b4d
+       0x7fcb443f      0x0174620a      0x3d6ac615      0x7e455dad
+       0x4920d08b      0xac64c661      0xd32efa96      0xedf34d51
+       0x4f124ac0      0xc19911d4      0xc5a26fec      0x5504f157
+       0x4c2f258b      0x61791cbd      0xf755ea65      0x4eaaeccb
+       0x828487f9      0xfde7e75d      0x05c36545      0xa245c7b7
+       0x3a7ee600      0x2e455055      0x761f612f      0xc7e4caf9
+       0xc35b2ead      0xb1d36910      0x7e730284      0xbc752ed0
+       0x1c089712      0x47b97c41      0xb5ff6990      0xecc0ad6a
+       0x156a722d      0x1b19d460      0x5f62a0d7      0x0e9af8cb
+       0xb4d9e908      0x0f2f1f2c      0x2579d59c      0x158cf00a
+       0x1f8d0d95      0xeed21aa9      0xfd32a24a      0x67ca6a87
+       0x16158824      0xdefd3a77      0x7e959fa9      0xa0ad2ef8
+       0x043dc799      0x1af58242      0x6626121f      0x6952d127
+       0xca7359da      0xd983f144      0x64234ebf      0x549e9d6a
+       0x86c878da      0x1949a6ab      0x204735bd      0x9d1cccce
+       0xbb155530      0x04599b33      0xe77c65aa      0x188bc6ae
+       0x7a5f9e0c      0xe54447c4      0xc6117c29      0x66ab15d2
+       0xcec48c6c      0xfccd374a      0x11299889      0x78b3f739
+       0x62e9cd7f      0x080b9c34      0x3649fe49      0xba4a79e9
+       0x1506f40b      0xaab7ffca      0xeca09b9a      0xe06c5857
+       0x7278e73e      0x84c5ec07      0x75e9b3e3      0x30d12090
+       0xdc55f4be      0xae1abf96      0x587f37ee      0x7435c374
+       0xa54e1fd6      0x3053f495      0x1b529b06      0xa85ee2d3
+       0x1cd31383      0x65a0b842      0xb3a6da29      0x652ab73b
+       0x180e84fb      0x23da2a91      0xa5ce847e      0x8fa06e65
+       0xb3a289e8      0xad5cec7e      0xf64d80c7      0x61478d3d
+       0x84db47ef      0xf585a73e      0xcb375c3b      0x8e3a3cbe
+       0x624b7c29      0x9a62fe29      0x402d5b03      0x28bfdfd6
+       0x317c872b      0x75393f25      0x925c6574      0x8f0f1cf1
+       0x14904e0f      0x4a92936f      0xb4c285bb      0xe1f18562
+       0x3cbfd5ea      0x055c6d21      0xa01bf3a0      0xf49838d1
+       0xddb029a9      0xee2e19eb      0x8868f661      0x5e0293be
+       0x87b452c4      0xd9f2cae0      0x9f09805d      0xc27a8d29
+       0x46e6c80f      0x0746ea1b      0x766588fe      0x7083c5ef
+       0xb26c80b4      0xb80a9870      0x8965bf44      0x831141bc
+       0x983f6dfd      0x4aea746d      0xb6a6868a      0xd5d3ff7f
+       0x4d47d04c      0x0578acdf      0x75d364e1      0x82458818
+       0xd69241b2      0xc017c8b5      0xc57f1424      0xcc0ce6e7
+       0xda776779      0xb17c4559      0x818906e1      0xb3a456e0
+       0x013a920e      0x9ab92a32      0xfae89bca      0x95d3bcdd
+       0x2a062819      0x1eaaf582      0xbee69c95      0x78c136c6
+       0xcb344597      0x32282e9e      0x75a1292f      0x2f44e2a4
+       0x2c063975      0x189a5bbe      0x409fe732      0x7b8c86df
+       0x64806b9d      0x80492807      0xa6ea51dd      0x0ed1c939
+       0x19a169d7      0xc0d5f9ef      0x4975fe61      0x373b3081
+       0x4f9c30e5      0x09050af4      0x87823aff      0x8180cd1b
+       0xf257959d      0xf7f923ad      0xdc723bcc      0xd208c4d2
+       0xcbf899f0      0xba6f3637      0xd5971aa8      0xfef92a9b
+       0x3eb21c5f      0xfe49dd03      0xfa56c184      0x833509ac
+       0x390d868a      0x2a719374      0x8e0b2f31      0xa03601fa
+       0x57716451      0x3e7985bc      0x2b209209      0xc328d7f0
+       0xb66f63a1      0xcecd4afe      0xdd25db81      0x828fb153
+       0xedcc0634      0xc50371e9      0x26befe0f      0xd27e91a6
+       0x65d13c7f      0xbaa9228b      0x5cf84d0d      0xd23113ed
+       0xa9c49c35      0xb5f56083      0xcb62eda2      0x6beb244b
+       0x2ed6fe75      0x7d1b6d3a      0xbfd3a154      0x6922d045
+       0x7f5e16e7      0x54ae7dcd      0xf6207e7b      0x24ea0306
+       0x0de191c9      0xc17533de      0x62863b55      0x4eda7343
+       0xf619a868      0x1c10dfdf      0xd18fa204      0x5e54bf57
+       0x85b86529      0xa78d8acc      0x68c1bd65      0x36db193e
+       0xfad25f35      0xa8782cd4      0x642d36f7      0x7589edfa
+       0xfbb5a9c5      0xece7b11a      0x3d4fdacd      0xf91cb430
+       0x760f1353      0x88ca281d      0x8e015980      0x4ead0d20
+       0xf49902a2      0x3779a778      0x95b7f01c      0xd93d19f4
+       0x6e35ed1f      0x9502b095      0xfa1eda17      0x51958a6f
+       0x738086fe      0x69614027      0x757670d5      0xe39a0823
+       0x1678be8f      0xaba262d3      0xe3630a66      0x203c4cfe
+       0xd6f20b31      0x5a4d2cd0      0x87807db4      0x03aab12a
+       0x7cd38212      0x3d2fa8d2      0x727897c2      0x63f915aa
+       0xc62647cc      0x24a4661b      0x4cb48c7a      0x0236a44d
+       0x8010b995      0xfc5d34b4      0x3e27266e      0x0599f4f3
+       0x6723916f      0x8d05b41b      0x1579a658      0x5857ad06
+       0xf31cb1e4      0xe3ec3d22      0xed5e6614      0x248813df
+       0x4ba7f160      0xe6aae07e      0x573b9725      0x2d5958fc
+       0xd4fcc070      0xbff5051b      0x1d18493d      0xeb7498c0
+       0x591c24cb      0xef5b7d5b      0x1f09ecba      0x669f0e5b
+       0x6ea31dae      0x086a6619      0xbd9828e6      0x4deec094
+       0xe82fd4a5      0x9d76681d      0x30c52de7      0x2246d260
+       0x2d97fe50      0x5e54cfde      0xe0dbf9f8      0x05875177
+       0x126bae9d      0x3871b4a5      0x70bf3fbf      0x04dbcfa1
+       0x3ca4b296      0xebfaaaf9      0x5c9c06cd      0x106d81d6
+       0xc1566322      0x55debd41      0x70898db7      0x57a59e02
+       0xb53753f0      0xdc358da0      0x1c28315b      0xc10425da
+       0x0c8304d5      0xf308b06a      0xee890456      0x5ff1ab50
+       0xa54fb4c2      0x2c3e354d      0x4585c47f      0xbcf4c8f6
+       0x81e775d5      0x5458933f      0x91b2d4cd      0x29140191
+       0x8eb806c4      0x172e70c9      0x423a6661      0xcbf1413e
+       0x0752f409      0x95420ffa      0xa46a0775      0x9f4c506d
+       0xeaa0104b      0x73bc45ac      0xecbb267e      0x303cc2b1
+       0x5c3d5fc3      0xca2f4657      0xa077571e      0x212c5842
+       0xa719d011      0x8086b1b9      0x94a7566f      0x7322cf8b
+       0x8642864f      0x7b49b221      0xbe3f32cc      0x7d4299cc
+       0x889f9730      0x1f64fef1      0x0aa5fe78      0x97c5f71e
+       0x2bc152de      0x9e322f49      0x71c2f971      0x64c964b0
+       0x7dc99f56      0x8142a95d      0x8ccc1b3a      0xc25a6d26
+       0xe55af85e      0xf4a30836      0xcca268b8      0x480b365a
+       0xe7370885      0x3e01dfe2      0xa96c8012      0x55266fa5
+       0x7cdd0b3a      0xe2e81e44      0xde9f3dfa      0xaa4169f4
+       0xcfe050d1      0xe8cd8db1      0x130c7613      0x766c84b2
+       0x11389d0d      0xb5381e93      0xfdd60cee      0xe0a6406f
+       0x0cd541f4      0x037a0313      0x61830990      0x01938dcb
+       0x451732d0      0x52e8d298      0xfd2b4bb2      0x3b773ed8
+       0x579a4faa      0x6f4729aa      0xbe0a14a2      0xf6b0a98f
+       0x3dc4cbff      0x5d708522      0x5a338e30      0xb09dd87d
+       0x5236692a      0x44a75471      0x9017ef38      0x51c7ebfb
+       0xa5e2c8c1      0xc54374b2      0x53faf90c      0xe0c7739c
+       0x7e064238      0x24679b02      0x02e6e186      0x4edfef87
+       0x9da9cd18      0xd8725b66      0xf608ec96      0x9e9dc091
+       0x1f810f97      0xecc8cef7      0x8f8a43e2      0x204a30bf
+       0x94339595      0xa61610d4      0x13fad76f      0xded761d3
+       0x16fbb3e1      0xec00076f      0x6c674e6f      0x203e4734
+       0x1b81be27      0xee803a89      0x2e054bdd      0x0ff3f125
+       0xa48e650d      0x7896b400      0xefe1a527      0x5b0deaea
+       0x9eca85f3      0x6f2c121b      0x51d63bfb      0xf1384bd1
+       0x1c3fc01b      0xf72259b4      0xdb339714      0xa331d495
+       0x15bd7c51      0xab693bf3      0xde0f7743      0xd3dd3acf
+       0x8c755ac1      0x67ebc6c0      0xaa3404d1      0x006a6b45
+       0x9e3d255d      0x20c4b946      0x3fd24a1f      0x41ed7231
+       0x59f2bb05      0x3ad0fb24      0xb6f610a8      0x9a254d64
+       0x0d5094b7      0xe01beae3      0x98a56a78      0x26c2da3b
+       0xba4fd221      0xbe0f8666      0x61146fe5      0x1278a21e
+       0x6dbcfa62      0xb46f9dc4      0x5e21fc7d      0x58c634f0
+       >;

diff --git a/arch/x86/dts/qemu-x86_i440fx.dts b/arch/x86/dts/qemu-x86_i440fx.dts
index c26c71bcf7368d250e67c90055ddff41c19b65c7..fc74cd0f01415fa6fe04b781cd90942caaef9daa 100644 (file)
--- a/arch/x86/dts/qemu-x86_i440fx.dts
+++ b/arch/x86/dts/qemu-x86_i440fx.dts
@@ -34,6 +34,13 @@
                        reg = <0>;
                        intel,apic-id = <0>;
                };
+
+               cpu@1 {
+                       device_type = "cpu";
+                       compatible = "cpu-x86";
+                       reg = <1>;
+                       intel,apic-id = <1>;
+               };
        };
 
        pci {

diff --git a/arch/x86/dts/qemu-x86_q35.dts b/arch/x86/dts/qemu-x86_q35.dts
index 2e785fa4bf507ed38f6d92d472c0f2f7b81195e4..7f16971783bf647670bdc71c9400dde2cd178ba1 100644 (file)
--- a/arch/x86/dts/qemu-x86_q35.dts
+++ b/arch/x86/dts/qemu-x86_q35.dts
@@ -45,6 +45,13 @@
                        reg = <0>;
                        intel,apic-id = <0>;
                };
+
+               cpu@1 {
+                       device_type = "cpu";
+                       compatible = "cpu-x86";
+                       reg = <1>;
+                       intel,apic-id = <1>;
+               };
        };
 
        pci {

diff --git a/arch/x86/include/asm/arch-baytrail/fsp/fsp_vpd.h b/arch/x86/include/asm/arch-baytrail/fsp/fsp_vpd.h
index 82862f626d37efe9fa81c008ed92deb5ee7bd883..eb0d5062164ca623ef584bb53829a9aa0d7488e1 100644 (file)
--- a/arch/x86/include/asm/arch-baytrail/fsp/fsp_vpd.h
+++ b/arch/x86/include/asm/arch-baytrail/fsp/fsp_vpd.h
@@ -75,7 +75,8 @@ struct __packed upd_region {
        uint8_t emmc45_ddr50_enabled;           /* Offset 0x0051 */
        uint8_t emmc45_hs200_enabled;           /* Offset 0x0052 */
        uint8_t emmc45_retune_timer_value;      /* Offset 0x0053 */
-       uint8_t unused_upd_space1[156];         /* Offset 0x0054 */
+       uint8_t enable_igd;                     /* Offset 0x0054 */
+       uint8_t unused_upd_space1[155];         /* Offset 0x0055 */
        struct memory_down_data memory_params;  /* Offset 0x00f0 */
        uint16_t terminator;                    /* Offset 0x0100 */
 };

diff --git a/arch/x86/include/asm/arch-efi/gpio.h b/arch/x86/include/asm/arch-efi/gpio.h
new file mode 100644 (file)
index 0000000..f044f07
--- /dev/null
+++ b/arch/x86/include/asm/arch-efi/gpio.h
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2015 Google, Inc.
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#ifndef _X86_ARCH_GPIO_H_
+#define _X86_ARCH_GPIO_H_
+
+#endif /* _X86_ARCH_GPIO_H_ */

diff --git a/arch/x86/include/asm/cpu.h b/arch/x86/include/asm/cpu.h
index 08284ee29530c46a3d33ed52956b4f661113de01..c70183ccefffba8effd9fdb080210328285b03a3 100644 (file)
--- a/arch/x86/include/asm/cpu.h
+++ b/arch/x86/include/asm/cpu.h
@@ -27,6 +27,24 @@ enum {
        X86_VENDOR_UNKNOWN = 0xff
 };
 
+/* Global descriptor table (GDT) bits */
+enum {
+       GDT_4KB                 = 1ULL << 55,
+       GDT_32BIT               = 1ULL << 54,
+       GDT_LONG                = 1ULL << 53,
+       GDT_PRESENT             = 1ULL << 47,
+       GDT_NOTSYS              = 1ULL << 44,
+       GDT_CODE                = 1ULL << 43,
+       GDT_LIMIT_LOW_SHIFT     = 0,
+       GDT_LIMIT_LOW_MASK      = 0xffff,
+       GDT_LIMIT_HIGH_SHIFT    = 48,
+       GDT_LIMIT_HIGH_MASK     = 0xf,
+       GDT_BASE_LOW_SHIFT      = 16,
+       GDT_BASE_LOW_MASK       = 0xffff,
+       GDT_BASE_HIGH_SHIFT     = 56,
+       GDT_BASE_HIGH_MASK      = 0xf,
+};
+
 struct cpuid_result {
        uint32_t eax;
        uint32_t ebx;
@@ -211,6 +229,15 @@ char *cpu_get_name(char *name);
  */
 void cpu_call64(ulong pgtable, ulong setup_base, ulong target);
 
+/**
+ * cpu_call32() - Jump to a 32-bit entry point
+ *
+ * @code_seg32:        32-bit code segment to use (GDT offset, e.g. 0x20)
+ * @target:    Pointer to the start of the 32-bit U-Boot image/entry point
+ * @table:     Pointer to start of info table to pass to U-Boot
+ */
+void cpu_call32(ulong code_seg32, ulong target, ulong table);
+
 /**
  * cpu_jump_to_64bit() - Jump to a 64-bit Linux kernel
  *

diff --git a/arch/x86/include/asm/elf.h b/arch/x86/include/asm/elf.h
new file mode 100644 (file)
index 0000000..3bdcdfe
--- /dev/null
+++ b/arch/x86/include/asm/elf.h
@@ -0,0 +1,46 @@
+/*
+ * Brought in from Linux 4.1, removed things not useful to U-Boot.
+ * The definitions perhaps came from the GNU Library which is GPL.
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#ifndef _ASM_X86_ELF_H
+#define _ASM_X86_ELF_H
+
+/* ELF register definitions */
+#define R_386_NONE     0
+#define R_386_32       1
+#define R_386_PC32     2
+#define R_386_GOT32    3
+#define R_386_PLT32    4
+#define R_386_COPY     5
+#define R_386_GLOB_DAT 6
+#define R_386_JMP_SLOT 7
+#define R_386_RELATIVE 8
+#define R_386_GOTOFF   9
+#define R_386_GOTPC    10
+#define R_386_NUM      11
+
+/* x86-64 relocation types */
+#define R_X86_64_NONE          0       /* No reloc */
+#define R_X86_64_64            1       /* Direct 64 bit  */
+#define R_X86_64_PC32          2       /* PC relative 32 bit signed */
+#define R_X86_64_GOT32         3       /* 32 bit GOT entry */
+#define R_X86_64_PLT32         4       /* 32 bit PLT address */
+#define R_X86_64_COPY          5       /* Copy symbol at runtime */
+#define R_X86_64_GLOB_DAT      6       /* Create GOT entry */
+#define R_X86_64_JUMP_SLOT     7       /* Create PLT entry */
+#define R_X86_64_RELATIVE      8       /* Adjust by program base */
+/* 32 bit signed pc relative offset to GOT */
+#define R_X86_64_GOTPCREL      9
+#define R_X86_64_32            10      /* Direct 32 bit zero extended */
+#define R_X86_64_32S           11      /* Direct 32 bit sign extended */
+#define R_X86_64_16            12      /* Direct 16 bit zero extended */
+#define R_X86_64_PC16          13      /* 16 bit sign extended pc relative */
+#define R_X86_64_8             14      /* Direct 8 bit sign extended  */
+#define R_X86_64_PC8           15      /* 8 bit sign extended pc relative */
+
+#define R_X86_64_NUM           16
+
+#endif

diff --git a/arch/x86/include/asm/fsp/fsp_hob.h b/arch/x86/include/asm/fsp/fsp_hob.h
index 6cca7f5654192db293c6a2af7db48ec22fa92245..3fb3546e27f8f76e1bd72fd1b3db6f8cdeb5f6c8 100644 (file)
--- a/arch/x86/include/asm/fsp/fsp_hob.h
+++ b/arch/x86/include/asm/fsp/fsp_hob.h
@@ -8,6 +8,8 @@
 #ifndef __FSP_HOB_H__
 #define __FSP_HOB_H__
 
+#include <efi.h>
+
 /* Type of HOB Header */
 #define HOB_TYPE_MEM_ALLOC     0x0002
 #define HOB_TYPE_RES_DESC      0x0003
@@ -25,63 +27,6 @@ struct hob_header {
        u32     reserved;       /* always zero */
 };
 
-/* Enumeration of memory types introduced in UEFI */
-enum efi_mem_type {
-       EFI_RESERVED_MEMORY_TYPE,
-       /*
-        * The code portions of a loaded application.
-        * (Note that UEFI OS loaders are UEFI applications.)
-        */
-       EFI_LOADER_CODE,
-       /*
-        * The data portions of a loaded application and
-        * the default data allocation type used by an application
-        * to allocate pool memory.
-        */
-       EFI_LOADER_DATA,
-       /* The code portions of a loaded Boot Services Driver */
-       EFI_BOOT_SERVICES_CODE,
-       /*
-        * The data portions of a loaded Boot Serves Driver and
-        * the default data allocation type used by a Boot Services
-        * Driver to allocate pool memory.
-        */
-       EFI_BOOT_SERVICES_DATA,
-       /* The code portions of a loaded Runtime Services Driver */
-       EFI_RUNTIME_SERVICES_CODE,
-       /*
-        * The data portions of a loaded Runtime Services Driver and
-        * the default data allocation type used by a Runtime Services
-        * Driver to allocate pool memory.
-        */
-       EFI_RUNTIME_SERVICES_DATA,
-       /* Free (unallocated) memory */
-       EFI_CONVENTIONAL_MEMORY,
-       /* Memory in which errors have been detected */
-       EFI_UNUSABLE_MEMORY,
-       /* Memory that holds the ACPI tables */
-       EFI_ACPI_RECLAIM_MEMORY,
-       /* Address space reserved for use by the firmware */
-       EFI_ACPI_MEMORY_NVS,
-       /*
-        * Used by system firmware to request that a memory-mapped IO region
-        * be mapped by the OS to a virtual address so it can be accessed by
-        * EFI runtime services.
-        */
-       EFI_MMAP_IO,
-       /*
-        * System memory-mapped IO region that is used to translate
-        * memory cycles to IO cycles by the processor.
-        */
-       EFI_MMAP_IO_PORT,
-       /*
-        * Address space reserved by the firmware for code that is
-        * part of the processor.
-        */
-       EFI_PAL_CODE,
-       EFI_MAX_MEMORY_TYPE
-};
-
 /*
  * Describes all memory ranges used during the HOB producer phase that
  * exist outside the HOB list. This HOB type describes how memory is used,

diff --git a/arch/x86/include/asm/global_data.h b/arch/x86/include/asm/global_data.h
index 4d9eac676ee91030221533c7a63131cd80d8ffdb..f7e3889df07ef4a25181675bb5b3dd14b0dbe79b 100644 (file)
--- a/arch/x86/include/asm/global_data.h
+++ b/arch/x86/include/asm/global_data.h
@@ -69,6 +69,7 @@ struct arch_global_data {
        char *mrc_output;
        unsigned int mrc_output_len;
        void *gdt;                      /* Global descriptor table */
+       ulong table;                    /* Table pointer from previous loader */
 };
 
 #endif
@@ -76,6 +77,12 @@ struct arch_global_data {
 #include <asm-generic/global_data.h>
 
 #ifndef __ASSEMBLY__
+# ifdef CONFIG_EFI_APP
+
+#define gd global_data_ptr
+
+#define DECLARE_GLOBAL_DATA_PTR   extern struct global_data *global_data_ptr
+# else
 static inline __attribute__((no_instrument_function)) gd_t *get_fs_gd_ptr(void)
 {
        gd_t *gd_ptr;
@@ -87,14 +94,15 @@ static inline __attribute__((no_instrument_function)) gd_t *get_fs_gd_ptr(void)
 
 #define gd     get_fs_gd_ptr()
 
+#define DECLARE_GLOBAL_DATA_PTR
+# endif
+
 #endif
 
 /*
  * Our private Global Data Flags
  */
-#define GD_FLG_COLD_BOOT       0x00100 /* Cold Boot */
-#define GD_FLG_WARM_BOOT       0x00200 /* Warm Boot */
-
-#define DECLARE_GLOBAL_DATA_PTR
+#define GD_FLG_COLD_BOOT       0x10000 /* Cold Boot */
+#define GD_FLG_WARM_BOOT       0x20000 /* Warm Boot */
 
 #endif /* __ASM_GBL_DATA_H */

diff --git a/arch/x86/include/asm/relocate.h b/arch/x86/include/asm/relocate.h
index eb186b9fb8959d2d9b9ce6dfa7024b750897a35f..cff3abc23a5e324f91a9495a37bf2a7c8d7c1598 100644 (file)
--- a/arch/x86/include/asm/relocate.h
+++ b/arch/x86/include/asm/relocate.h
@@ -11,7 +11,6 @@
 #include <common.h>
 
 int copy_uboot_to_ram(void);
-int copy_fdt_to_ram(void);
 int clear_bss(void);
 int do_elf_reloc_fixups(void);
 

diff --git a/arch/x86/include/asm/types.h b/arch/x86/include/asm/types.h
index e272c90eb7f6bd3ef52bfb5c1171aab136110c27..766617f9aa3e22a5ac2346acac4312104e7821ff 100644 (file)
--- a/arch/x86/include/asm/types.h
+++ b/arch/x86/include/asm/types.h
@@ -44,8 +44,11 @@ typedef __INT64_TYPE__ s64;
 typedef __UINT64_TYPE__ u64;
 #endif
 
+#ifdef CONFIG_EFI_STUB_64BIT
+#define BITS_PER_LONG 64
+#else
 #define BITS_PER_LONG 32
-
+#endif
 /* Dma addresses are 32-bits wide.  */
 
 typedef u32 dma_addr_t;

diff --git a/arch/x86/lib/Makefile b/arch/x86/lib/Makefile
index 43489fdc1f8f82f197cf91347cc1a1798cb82fb3..dcfe9ee85c5412218278d691d9af1d402f5efa1c 100644 (file)
--- a/arch/x86/lib/Makefile
+++ b/arch/x86/lib/Makefile
@@ -11,6 +11,7 @@ obj-y += bios_interrupts.o
 obj-$(CONFIG_CMD_BOOTM) += bootm.o
 obj-y  += cmd_boot.o
 obj-$(CONFIG_HAVE_FSP) += cmd_hob.o
+obj-$(CONFIG_EFI) += efi/
 obj-y  += gcc.o
 obj-y  += init_helpers.o
 obj-y  += interrupts.o
@@ -34,7 +35,7 @@ obj-$(CONFIG_SYS_X86_TSC_TIMER)       += tsc_timer.o
 obj-$(CONFIG_CMD_ZBOOT)        += zimage.o
 obj-$(CONFIG_HAVE_FSP) += fsp/
 
-extra-$(CONFIG_USE_PRIVATE_LIBGCC) := lib.a
+extra-$(CONFIG_USE_PRIVATE_LIBGCC) += lib.a
 
 NORMAL_LIBGCC = $(shell $(CC) $(PLATFORM_CPPFLAGS) -print-libgcc-file-name)
 OBJCOPYFLAGS := --prefix-symbols=__normal_

diff --git a/arch/x86/lib/asm-offsets.c b/arch/x86/lib/asm-offsets.c
index 70ccf1b0b041cb2afd17adce8bfc7beab8501629..9da04dd875927deedbd940330ca636991f7cd516 100644 (file)
--- a/arch/x86/lib/asm-offsets.c
+++ b/arch/x86/lib/asm-offsets.c
@@ -21,5 +21,6 @@ int main(void)
 #ifdef CONFIG_HAVE_FSP
        DEFINE(GD_HOB_LIST, offsetof(gd_t, arch.hob_list));
 #endif
+       DEFINE(GD_TABLE, offsetof(gd_t, arch.table));
        return 0;
 }

diff --git a/arch/x86/lib/bootm.c b/arch/x86/lib/bootm.c
index 86030cf52aab1c3994d805d47d16c17e27178f05..f441c84df5628290bd1803c6c4c0a58753b910c1 100644 (file)
--- a/arch/x86/lib/bootm.c
+++ b/arch/x86/lib/bootm.c
@@ -22,6 +22,8 @@
 #include <asm/arch/timestamp.h>
 #endif
 
+DECLARE_GLOBAL_DATA_PTR;
+
 #define COMMAND_LINE_OFFSET 0x9000
 
 /*
@@ -162,7 +164,11 @@ int boot_linux_kernel(ulong setup_base, ulong load_address, bool image_64bit)
                * the data segments are 0x18, 4GB flat, and read/write.
                * U-boot is setting them up that way for itself in
                * arch/i386/cpu/cpu.c.
+               *
+               * Note that we cannot currently boot a kernel while running as
+               * an EFI application. Please use the payload option for that.
                */
+#ifndef CONFIG_EFI_APP
                __asm__ __volatile__ (
                "movl $0, %%ebp\n"
                "cli\n"
@@ -171,6 +177,7 @@ int boot_linux_kernel(ulong setup_base, ulong load_address, bool image_64bit)
                [boot_params] "S"(setup_base),
                "b"(0), "D"(0)
                );
+#endif
        }
 
        /* We can't get to here */

diff --git a/arch/x86/lib/efi/Kconfig b/arch/x86/lib/efi/Kconfig
new file mode 100644 (file)
index 0000000..e0975d3
--- /dev/null
+++ b/arch/x86/lib/efi/Kconfig
@@ -0,0 +1,11 @@
+if EFI
+
+config SYS_CAR_ADDR
+       hex
+       default 0x100000
+
+config SYS_CAR_SIZE
+       hex
+       default 0x20000
+
+endif

diff --git a/arch/x86/lib/efi/Makefile b/arch/x86/lib/efi/Makefile
new file mode 100644 (file)
index 0000000..af4503e
--- /dev/null
+++ b/arch/x86/lib/efi/Makefile
@@ -0,0 +1,27 @@
+#
+# (C) Copyright 2002-2006
+# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+#
+# SPDX-License-Identifier:     GPL-2.0+
+#
+
+obj-$(CONFIG_EFI_STUB) += car.o
+obj-$(CONFIG_EFI_STUB) += efi.o
+
+obj-$(CONFIG_EFI_APP) += crt0-efi-ia32.o reloc_ia32.o
+
+ifneq ($(CONFIG_EFI_STUB),)
+
+CFLAGS_REMOVE_reloc_ia32.o += -mregparm=3
+CFLAGS_reloc_ia32.o += -fpic -fshort-wchar
+
+# When building for 64-bit we must remove the i386-specific flags
+CFLAGS_REMOVE_reloc_x86_64.o += -mregparm=3 -march=i386 -m32
+CFLAGS_reloc_x86_64.o += -fpic -fshort-wchar
+
+AFLAGS_REMOVE_crt0-efi-x86_64.o += -mregparm=3 -march=i386 -m32
+AFLAGS_crt0-efi-x86_64.o += -fpic -fshort-wchar
+
+extra-$(CONFIG_EFI_STUB_32BIT) += crt0-efi-ia32.o reloc_ia32.o
+extra-$(CONFIG_EFI_STUB_64BIT) += crt0-efi-x86_64.o reloc_x86_64.o
+endif

diff --git a/arch/x86/lib/efi/car.S b/arch/x86/lib/efi/car.S
new file mode 100644 (file)
index 0000000..613af9a
--- /dev/null
+++ b/arch/x86/lib/efi/car.S
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ * Written by Simon Glass <sjg@chromium.org>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+.globl car_init
+car_init:
+       jmp     car_init_ret

diff --git a/arch/x86/lib/efi/crt0-efi-ia32.S b/arch/x86/lib/efi/crt0-efi-ia32.S
new file mode 100644 (file)
index 0000000..30e5eb0
--- /dev/null
+++ b/arch/x86/lib/efi/crt0-efi-ia32.S
@@ -0,0 +1,52 @@
+/*
+ * crt0-efi-ia32.S - x86 EFI startup code.
+ *
+ * Copyright (C) 1999 Hewlett-Packard Co.
+ * Contributed by David Mosberger <davidm@hpl.hp.com>.
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:    BSD-3-Clause
+ */
+
+       .text
+       .align 4
+
+       .globl _start
+_start:
+       pushl %ebp
+       movl %esp,%ebp
+
+       pushl 12(%ebp)                  # copy "image" argument
+       pushl  8(%ebp)                  # copy "systab" argument
+
+       call 0f
+0:     popl %eax
+       movl %eax,%ebx
+
+       addl $image_base-0b,%eax        # %eax = ldbase
+       addl $_DYNAMIC-0b,%ebx          # %ebx = _DYNAMIC
+
+       pushl %ebx                      # pass _DYNAMIC as second argument
+       pushl %eax                      # pass ldbase as first argument
+       call _relocate
+       popl %ebx
+       popl %ebx
+       testl %eax,%eax
+       jne .exit
+       call efi_main           # call app with "image" and "systab" argument
+
+.exit: leave
+       ret
+
+       /*
+        * hand-craft a dummy .reloc section so EFI knows it's a relocatable
+        * executable:
+        */
+       .data
+dummy: .long   0
+
+#define IMAGE_REL_ABSOLUTE     0
+       .section .reloc
+       .long   dummy                                   /* Page RVA */
+       .long   10                                      /* Block Size (2*4+2) */
+       .word   (IMAGE_REL_ABSOLUTE << 12) +  0         /* reloc for dummy */

diff --git a/arch/x86/lib/efi/crt0-efi-x86_64.S b/arch/x86/lib/efi/crt0-efi-x86_64.S
new file mode 100644 (file)
index 0000000..c5cbf41
--- /dev/null
+++ b/arch/x86/lib/efi/crt0-efi-x86_64.S
@@ -0,0 +1,51 @@
+/*
+ * crt0-efi-x86_64.S - x86_64 EFI startup code.
+ * Copyright (C) 1999 Hewlett-Packard Co.
+ * Contributed by David Mosberger <davidm@hpl.hp.com>.
+ * Copyright (C) 2005 Intel Co.
+ * Contributed by Fenghua Yu <fenghua.yu@intel.com>.
+ *
+ * All rights reserved.
+ * SPDX-License-Identifier:    BSD-3-Clause
+ */
+       .text
+       .align 4
+
+       .globl _start
+_start:
+       subq $8, %rsp
+       pushq %rcx
+       pushq %rdx
+
+0:
+       lea image_base(%rip), %rdi
+       lea _DYNAMIC(%rip), %rsi
+
+       popq %rcx
+       popq %rdx
+       pushq %rcx
+       pushq %rdx
+       call _relocate
+
+       popq %rdi
+       popq %rsi
+
+       call efi_main
+       addq $8, %rsp
+
+.exit:
+       ret
+
+       /*
+        * hand-craft a dummy .reloc section so EFI knows it's a relocatable
+        * executable:
+        */
+       .data
+dummy: .long   0
+
+#define IMAGE_REL_ABSOLUTE     0
+       .section .reloc, "a"
+label1:
+       .long   dummy-label1                            /* Page RVA */
+       .long   10                                      /* Block Size (2*4+2) */
+       .word   (IMAGE_REL_ABSOLUTE << 12) +  0         /* reloc for dummy */

diff --git a/arch/x86/lib/efi/efi.c b/arch/x86/lib/efi/efi.c
new file mode 100644 (file)
index 0000000..ede5d56
--- /dev/null
+++ b/arch/x86/lib/efi/efi.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ * Written by Simon Glass <sjg@chromium.org>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <debug_uart.h>
+#include <efi.h>
+#include <errno.h>
+#include <linux/err.h>
+#include <linux/types.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+/*
+ * This function looks for the highest region of memory lower than 4GB which
+ * has enough space for U-Boot where U-Boot is aligned on a page boundary.
+ * It overrides the default implementation found elsewhere which simply
+ * picks the end of ram, wherever that may be. The location of the stack,
+ * the relocation address, and how far U-Boot is moved by relocation are
+ * set in the global data structure.
+ */
+ulong board_get_usable_ram_top(ulong total_size)
+{
+       struct efi_mem_desc *desc, *end;
+       struct efi_entry_memmap *map;
+       int ret, size;
+       uintptr_t dest_addr = 0;
+       struct efi_mem_desc *largest = NULL;
+
+       /*
+        * Find largest area of memory below 4GB. We could
+        * call efi_build_mem_table() for a more accurate picture since it
+        * merges areas together where possible. But that function uses more
+        * pre-relocation memory, and it's not critical that we find the
+        * absolute largest region.
+        */
+       ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
+       if (ret) {
+               /* We should have stopped in dram_init(), something is wrong */
+               debug("%s: Missing memory map\n", __func__);
+               goto err;
+       }
+
+       end = (struct efi_mem_desc *)((ulong)map + size);
+       desc = map->desc;
+       for (; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
+               if (desc->type != EFI_CONVENTIONAL_MEMORY ||
+                   desc->physical_start >= 1ULL << 32)
+                       continue;
+               if (!largest || desc->num_pages > largest->num_pages)
+                       largest = desc;
+       }
+
+       /* If no suitable area was found, return an error. */
+       assert(largest);
+       if (!largest || (largest->num_pages << EFI_PAGE_SHIFT) < (2 << 20))
+               goto err;
+
+       dest_addr = largest->physical_start + (largest->num_pages <<
+                       EFI_PAGE_SHIFT);
+
+       return (ulong)dest_addr;
+err:
+       panic("No available memory found for relocation");
+       return 0;
+}
+
+int dram_init(void)
+{
+       struct efi_mem_desc *desc, *end;
+       struct efi_entry_memmap *map;
+       int size, ret;
+
+       ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
+       if (ret) {
+               printf("Cannot find EFI memory map tables, ret=%d\n", ret);
+
+               return -ENODEV;
+       }
+
+       end = (struct efi_mem_desc *)((ulong)map + size);
+       gd->ram_size = 0;
+       desc = map->desc;
+       for (; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
+               if (desc->type < EFI_MMAP_IO)
+                       gd->ram_size += desc->num_pages << EFI_PAGE_SHIFT;
+       }
+
+       return 0;
+}
+
+void dram_init_banksize(void)
+{
+       struct efi_mem_desc *desc, *end;
+       struct efi_entry_memmap *map;
+       int ret, size;
+       int num_banks;
+
+       ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
+       if (ret) {
+               /* We should have stopped in dram_init(), something is wrong */
+               debug("%s: Missing memory map\n", __func__);
+               return;
+       }
+       end = (struct efi_mem_desc *)((ulong)map + size);
+       desc = map->desc;
+       for (num_banks = 0;
+            desc < end && num_banks < CONFIG_NR_DRAM_BANKS;
+            desc = efi_get_next_mem_desc(map, desc)) {
+               /*
+                * We only use conventional memory below 4GB, and ignore
+                * anything less than 1MB.
+                */
+               if (desc->type != EFI_CONVENTIONAL_MEMORY ||
+                   desc->physical_start >= 1ULL << 32 ||
+                   (desc->num_pages << EFI_PAGE_SHIFT) < 1 << 20)
+                       continue;
+               gd->bd->bi_dram[num_banks].start = desc->physical_start;
+               gd->bd->bi_dram[num_banks].size = desc->num_pages <<
+                       EFI_PAGE_SHIFT;
+               num_banks++;
+       }
+}
+
+int print_cpuinfo(void)
+{
+       return default_print_cpuinfo();
+}
+
+/* Find any available tables and copy them to a safe place */
+int reserve_arch(void)
+{
+       struct efi_info_hdr *hdr;
+
+       debug("table=%lx\n", gd->arch.table);
+       if (!gd->arch.table)
+               return 0;
+
+       hdr = (struct efi_info_hdr *)gd->arch.table;
+
+       gd->start_addr_sp -= hdr->total_size;
+       memcpy((void *)gd->start_addr_sp, hdr, hdr->total_size);
+       debug("Stashing EFI table at %lx to %lx, size %x\n",
+             gd->arch.table, gd->start_addr_sp, hdr->total_size);
+       gd->arch.table = gd->start_addr_sp;
+
+       return 0;
+}

diff --git a/arch/x86/lib/efi/reloc_ia32.c b/arch/x86/lib/efi/reloc_ia32.c
new file mode 100644 (file)
index 0000000..4d68255
--- /dev/null
+++ b/arch/x86/lib/efi/reloc_ia32.c
@@ -0,0 +1,72 @@
+/*
+ * reloc_ia32.c - position independent x86 ELF shared object relocator
+ * Copyright (C) 1999 Hewlett-Packard Co.
+ * Contributed by David Mosberger <davidm@hpl.hp.com>.
+ *
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:    BSD-3-Clause
+ */
+
+#include <common.h>
+#include <efi.h>
+#include <elf.h>
+#include <asm/elf.h>
+
+efi_status_t _relocate(long ldbase, Elf32_Dyn *dyn, efi_handle_t image,
+                      struct efi_system_table *systab)
+{
+       long relsz = 0, relent = 0;
+       Elf32_Rel *rel = 0;
+       unsigned long *addr;
+       int i;
+
+       for (i = 0; dyn[i].d_tag != DT_NULL; ++i) {
+               switch (dyn[i].d_tag) {
+               case DT_REL:
+                       rel = (Elf32_Rel *)((unsigned long)dyn[i].d_un.d_ptr +
+                                                               ldbase);
+                       break;
+
+               case DT_RELSZ:
+                       relsz = dyn[i].d_un.d_val;
+                       break;
+
+               case DT_RELENT:
+                       relent = dyn[i].d_un.d_val;
+                       break;
+
+               case DT_RELA:
+                       break;
+
+               default:
+                       break;
+               }
+       }
+
+       if (!rel && relent == 0)
+               return EFI_SUCCESS;
+
+       if (!rel || relent == 0)
+               return EFI_LOAD_ERROR;
+
+       while (relsz > 0) {
+               /* apply the relocs */
+               switch (ELF32_R_TYPE(rel->r_info)) {
+               case R_386_NONE:
+                       break;
+
+               case R_386_RELATIVE:
+                       addr = (unsigned long *)(ldbase + rel->r_offset);
+                       *addr += ldbase;
+                       break;
+
+               default:
+                       break;
+               }
+               rel = (Elf32_Rel *)((char *)rel + relent);
+               relsz -= relent;
+       }
+
+       return EFI_SUCCESS;
+}

diff --git a/arch/x86/lib/efi/reloc_x86_64.c b/arch/x86/lib/efi/reloc_x86_64.c
new file mode 100644 (file)
index 0000000..5f71f2a
--- /dev/null
+++ b/arch/x86/lib/efi/reloc_x86_64.c
@@ -0,0 +1,66 @@
+/*
+ * reloc_x86_64.c - position independent x86_64 ELF shared object relocator
+ * Copyright (C) 1999 Hewlett-Packard Co.
+ * Contributed by David Mosberger <davidm@hpl.hp.com>.
+ * Copyright (C) 2005 Intel Co.
+ * Contributed by Fenghua Yu <fenghua.yu@intel.com>.
+ *
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:    BSD-3-Clause
+ */
+
+#include <common.h>
+#include <efi.h>
+#include <elf.h>
+#include <asm/elf.h>
+
+efi_status_t _relocate(long ldbase, Elf64_Dyn *dyn, efi_handle_t image,
+                      struct efi_system_table *systab)
+{
+       long relsz = 0, relent = 0;
+       Elf64_Rel *rel = 0;
+       unsigned long *addr;
+       int i;
+
+       for (i = 0; dyn[i].d_tag != DT_NULL; ++i) {
+               switch (dyn[i].d_tag) {
+               case DT_RELA:
+                       rel = (Elf64_Rel *)
+                               ((unsigned long)dyn[i].d_un.d_ptr + ldbase);
+                       break;
+               case DT_RELASZ:
+                       relsz = dyn[i].d_un.d_val;
+                       break;
+               case DT_RELAENT:
+                       relent = dyn[i].d_un.d_val;
+                       break;
+               default:
+                       break;
+               }
+       }
+
+       if (!rel && relent == 0)
+               return EFI_SUCCESS;
+
+       if (!rel || relent == 0)
+               return EFI_LOAD_ERROR;
+
+       while (relsz > 0) {
+               /* apply the relocs */
+               switch (ELF64_R_TYPE(rel->r_info)) {
+               case R_X86_64_NONE:
+                       break;
+               case R_X86_64_RELATIVE:
+                       addr = (unsigned long *)(ldbase + rel->r_offset);
+                       *addr += ldbase;
+                       break;
+               default:
+                       break;
+               }
+               rel = (Elf64_Rel *)((char *)rel + relent);
+               relsz -= relent;
+       }
+
+       return EFI_SUCCESS;
+}

diff --git a/arch/x86/lib/fsp/fsp_common.c b/arch/x86/lib/fsp/fsp_common.c
index 5b256324e1721c546ca058eb83468060274feaae..c585710824cce08cb9a0fcba2fb957f0591ce425 100644 (file)
--- a/arch/x86/lib/fsp/fsp_common.c
+++ b/arch/x86/lib/fsp/fsp_common.c
@@ -11,6 +11,8 @@
 #include <asm/processor.h>
 #include <asm/fsp/fsp_support.h>
 
+DECLARE_GLOBAL_DATA_PTR;
+
 int print_cpuinfo(void)
 {
        post_code(POST_CPU_INFO);

diff --git a/arch/x86/lib/lpc-uclass.c b/arch/x86/lib/lpc-uclass.c
index 6aeb4d461a9b5e952d255955e185c1a7874591d9..c6e8f73d2254934497e9938bb8938188fd750d81 100644 (file)
--- a/arch/x86/lib/lpc-uclass.c
+++ b/arch/x86/lib/lpc-uclass.c
@@ -9,6 +9,8 @@
 #include <dm.h>
 #include <dm/root.h>
 
+DECLARE_GLOBAL_DATA_PTR;
+
 static int lpc_uclass_post_bind(struct udevice *bus)
 {
        /*

diff --git a/arch/x86/lib/pch-uclass.c b/arch/x86/lib/pch-uclass.c
index d1082e1a475b5aaeb37a7861c5befbc5936355c7..20dfa815d20c3847ec5cbceb74fdf86a11688def 100644 (file)
--- a/arch/x86/lib/pch-uclass.c
+++ b/arch/x86/lib/pch-uclass.c
@@ -9,6 +9,8 @@
 #include <dm.h>
 #include <dm/root.h>
 
+DECLARE_GLOBAL_DATA_PTR;
+
 static int pch_uclass_post_bind(struct udevice *bus)
 {
        /*

diff --git a/arch/x86/lib/relocate.c b/arch/x86/lib/relocate.c
index b33586b54c0311a9b596cbcca23ed357ab78b3e0..0d683bfc12282ee5ca1243fde252da6771c0f165 100644 (file)
--- a/arch/x86/lib/relocate.c
+++ b/arch/x86/lib/relocate.c
@@ -17,8 +17,6 @@
 
 #include <common.h>
 #include <inttypes.h>
-#include <libfdt.h>
-#include <malloc.h>
 #include <asm/u-boot-x86.h>
 #include <asm/relocate.h>
 #include <asm/sections.h>
@@ -30,32 +28,20 @@ int copy_uboot_to_ram(void)
 {
        size_t len = (size_t)&__data_end - (size_t)&__text_start;
 
+       if (gd->flags & GD_FLG_SKIP_RELOC)
+               return 0;
        memcpy((void *)gd->relocaddr, (void *)&__text_start, len);
 
        return 0;
 }
 
-int copy_fdt_to_ram(void)
-{
-       if (gd->new_fdt) {
-               ulong fdt_size;
-
-               fdt_size = ALIGN(fdt_totalsize(gd->fdt_blob) + 0x1000, 32);
-
-               memcpy(gd->new_fdt, gd->fdt_blob, fdt_size);
-               debug("Relocated fdt from %p to %p, size %lx\n",
-                      gd->fdt_blob, gd->new_fdt, fdt_size);
-               gd->fdt_blob = gd->new_fdt;
-       }
-
-       return 0;
-}
-
 int clear_bss(void)
 {
        ulong dst_addr = (ulong)&__bss_start + gd->reloc_off;
        size_t len = (size_t)&__bss_end - (size_t)&__bss_start;
 
+       if (gd->flags & GD_FLG_SKIP_RELOC)
+               return 0;
        memset((void *)dst_addr, 0x00, len);
 
        return 0;
@@ -72,36 +58,43 @@ int do_elf_reloc_fixups(void)
 
        Elf32_Addr *offset_ptr_rom, *last_offset = NULL;
        Elf32_Addr *offset_ptr_ram;
+       unsigned int text_base = 0;
 
        /* The size of the region of u-boot that runs out of RAM. */
        uintptr_t size = (uintptr_t)&__bss_end - (uintptr_t)&__text_start;
 
+       if (gd->flags & GD_FLG_SKIP_RELOC)
+               return 0;
        if (re_src == re_end)
                panic("No relocation data");
 
+#ifdef CONFIG_SYS_TEXT_BASE
+       text_base = CONFIG_SYS_TEXT_BASE;
+#else
+       panic("No CONFIG_SYS_TEXT_BASE");
+#endif
        do {
                /* Get the location from the relocation entry */
                offset_ptr_rom = (Elf32_Addr *)re_src->r_offset;
 
                /* Check that the location of the relocation is in .text */
-               if (offset_ptr_rom >= (Elf32_Addr *)CONFIG_SYS_TEXT_BASE &&
-                               offset_ptr_rom > last_offset) {
+               if (offset_ptr_rom >= (Elf32_Addr *)text_base &&
+                   offset_ptr_rom > last_offset) {
 
                        /* Switch to the in-RAM version */
                        offset_ptr_ram = (Elf32_Addr *)((ulong)offset_ptr_rom +
                                                        gd->reloc_off);
 
                        /* Check that the target points into .text */
-                       if (*offset_ptr_ram >= CONFIG_SYS_TEXT_BASE &&
-                                       *offset_ptr_ram <=
-                                       (CONFIG_SYS_TEXT_BASE + size)) {
+                       if (*offset_ptr_ram >= text_base &&
+                           *offset_ptr_ram <= text_base + size) {
                                *offset_ptr_ram += gd->reloc_off;
                        } else {
                                debug("   %p: rom reloc %x, ram %p, value %x,"
                                        " limit %" PRIXPTR "\n", re_src,
                                        re_src->r_offset, offset_ptr_ram,
                                        *offset_ptr_ram,
-                                       CONFIG_SYS_TEXT_BASE + size);
+                                       text_base + size);
                        }
                } else {
                        debug("   %p: rom reloc %x, last %p\n", re_src,

diff --git a/arch/x86/lib/tsc_timer.c b/arch/x86/lib/tsc_timer.c
index 7f5ba2ca6f1dd69f2d461723fec4536fc92a4523..0df1af238c1d654e59d9b09c555c363cb2196943 100644 (file)
--- a/arch/x86/lib/tsc_timer.c
+++ b/arch/x86/lib/tsc_timer.c
@@ -355,7 +355,15 @@ void __udelay(unsigned long usec)
        stop = now + usec * get_tbclk_mhz();
 
        while ((int64_t)(stop - get_ticks()) > 0)
+#if defined(CONFIG_QEMU) && defined(CONFIG_SMP)
+               /*
+                * Add a 'pause' instruction on qemu target,
+                * to give other VCPUs a chance to run.
+                */
+               asm volatile("pause");
+#else
                ;
+#endif
 }
 
 int timer_init(void)

diff --git a/board/efi/Kconfig b/board/efi/Kconfig
new file mode 100644 (file)
index 0000000..6f86a48
--- /dev/null
+++ b/board/efi/Kconfig
@@ -0,0 +1,19 @@
+if VENDOR_EFI
+
+choice
+       prompt "Mainboard model"
+       optional
+
+config TARGET_EFI
+       bool "efi"
+       help
+         This target is used for running U-Boot on top of EFI. In
+         this case EFI does the early initialisation, and U-Boot
+         takes over once the RAM, video and CPU are fully running.
+         U-Boot is loaded as an application from EFI.
+
+endchoice
+
+source "board/efi/efi-x86/Kconfig"
+
+endif

diff --git a/board/efi/efi-x86/Kconfig b/board/efi/efi-x86/Kconfig
new file mode 100644 (file)
index 0000000..fa609ba
--- /dev/null
+++ b/board/efi/efi-x86/Kconfig
@@ -0,0 +1,15 @@
+if TARGET_EFI
+
+config SYS_BOARD
+       default "efi-x86"
+
+config SYS_VENDOR
+       default "efi"
+
+config SYS_SOC
+       default "efi"
+
+config SYS_CONFIG_NAME
+       default "efi-x86"
+
+endif

diff --git a/board/efi/efi-x86/MAINTAINERS b/board/efi/efi-x86/MAINTAINERS
new file mode 100644 (file)
index 0000000..a44c7c6
--- /dev/null
+++ b/board/efi/efi-x86/MAINTAINERS
@@ -0,0 +1,6 @@
+EFI-X86 BOARD
+M:     Simon Glass <sjg@chromium.org>
+S:     Maintained
+F:     board/efi/efi-x86/
+F:     include/configs/efi-x86.h
+F:     configs/efi-x86_defconfig

diff --git a/board/efi/efi-x86/Makefile b/board/efi/efi-x86/Makefile
new file mode 100644 (file)
index 0000000..9b1e0bd
--- /dev/null
+++ b/board/efi/efi-x86/Makefile
@@ -0,0 +1,7 @@
+#
+# Copyright (c) 2015 Google, Inc
+#
+# SPDX-License-Identifier:     GPL-2.0+
+#
+
+obj-y  += efi.o

diff --git a/board/efi/efi-x86/efi.c b/board/efi/efi-x86/efi.c
new file mode 100644 (file)
index 0000000..08958f9
--- /dev/null
+++ b/board/efi/efi-x86/efi.c
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/gpio.h>
+
+int arch_early_init_r(void)
+{
+       return 0;
+}
+
+void setup_pch_gpios(u16 gpiobase, const struct pch_gpio_map *gpio)
+{
+       return;
+}

diff --git a/board/emulation/qemu-x86/Kconfig b/board/emulation/qemu-x86/Kconfig
index e777ef44090a15377ae8b40fcb9314c26663a535..c9181fc1bf217dde1779fa09aeb4aef0fc9f5b61 100644 (file)
--- a/board/emulation/qemu-x86/Kconfig
+++ b/board/emulation/qemu-x86/Kconfig
@@ -13,11 +13,12 @@ config SYS_CONFIG_NAME
        default "qemu-x86"
 
 config SYS_TEXT_BASE
-       default 0xfff00000
+       default 0xfff00000 if !EFI_STUB
+       default 0x01110000 if EFI_STUB
 
 config BOARD_SPECIFIC_OPTIONS # dummy
        def_bool y
-       select X86_RESET_VECTOR
+       select X86_RESET_VECTOR if !EFI_STUB
        select QEMU
        select BOARD_ROMSIZE_KB_1024
 

diff --git a/board/intel/Kconfig b/board/intel/Kconfig
index 3d9ecf06930bb641fc10651df73dc3203ff213ea..f7d71c3612a15293f3952eb18db6c0b23a09f481 100644 (file)
--- a/board/intel/Kconfig
+++ b/board/intel/Kconfig
@@ -10,6 +10,14 @@ choice
        prompt "Mainboard model"
        optional
 
+config TARGET_BAYLEYBAY
+       bool "Bayley Bay"
+       help
+         This is the Intel Bayley Bay Customer Reference Board. It contains an
+         Intel quad-core Atom Processor E3800 with dual-channel DDR3L SODIMM
+         4GB memory, HDMI/DP/VGA display, HD audio, SATA, USB2, USB3, SD, eMMC,
+         PCIe and some other sensor interfaces.
+
 config TARGET_CROWNBAY
        bool "Crown Bay"
        help
@@ -45,6 +53,7 @@ config TARGET_MINNOWMAX
 
 endchoice
 
+source "board/intel/bayleybay/Kconfig"
 source "board/intel/crownbay/Kconfig"
 source "board/intel/galileo/Kconfig"
 source "board/intel/minnowmax/Kconfig"

diff --git a/board/intel/bayleybay/Kconfig b/board/intel/bayleybay/Kconfig
new file mode 100644 (file)
index 0000000..597228f
--- /dev/null
+++ b/board/intel/bayleybay/Kconfig
@@ -0,0 +1,27 @@
+if TARGET_BAYLEYBAY
+
+config SYS_BOARD
+       default "bayleybay"
+
+config SYS_VENDOR
+       default "intel"
+
+config SYS_SOC
+       default "baytrail"
+
+config SYS_CONFIG_NAME
+       default "bayleybay"
+
+config SYS_TEXT_BASE
+       default 0xfff00000
+
+config BOARD_SPECIFIC_OPTIONS # dummy
+       def_bool y
+       select X86_RESET_VECTOR
+       select INTEL_BAYTRAIL
+       select BOARD_ROMSIZE_KB_8192
+
+config PCIE_ECAM_BASE
+       default 0xe0000000
+
+endif

diff --git a/board/intel/bayleybay/MAINTAINERS b/board/intel/bayleybay/MAINTAINERS
new file mode 100644 (file)
index 0000000..85fa516
--- /dev/null
+++ b/board/intel/bayleybay/MAINTAINERS
@@ -0,0 +1,6 @@
+Intel Bayley Bay
+M:     Bin Meng <bmeng.cn@gmail.com>
+S:     Maintained
+F:     board/intel/bayleybay
+F:     include/configs/bayleybay.h
+F:     configs/bayleybay_defconfig

diff --git a/board/intel/bayleybay/Makefile b/board/intel/bayleybay/Makefile
new file mode 100644 (file)
index 0000000..88b5aad
--- /dev/null
+++ b/board/intel/bayleybay/Makefile
@@ -0,0 +1,7 @@
+#
+# Copyright (C) 2015, Bin Meng <bmeng.cn@gmail.com>
+#
+# SPDX-License-Identifier:     GPL-2.0+
+#
+
+obj-y  += bayleybay.o start.o

diff --git a/board/intel/bayleybay/bayleybay.c b/board/intel/bayleybay/bayleybay.c
new file mode 100644 (file)
index 0000000..7844796
--- /dev/null
+++ b/board/intel/bayleybay/bayleybay.c
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2015, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/gpio.h>
+#include <netdev.h>
+
+void setup_pch_gpios(u16 gpiobase, const struct pch_gpio_map *gpio)
+{
+       return;
+}
+
+int board_eth_init(bd_t *bis)
+{
+       return pci_eth_init(bis);
+}

diff --git a/board/intel/bayleybay/start.S b/board/intel/bayleybay/start.S
new file mode 100644 (file)
index 0000000..a71db69
--- /dev/null
+++ b/board/intel/bayleybay/start.S
@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2015, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+.globl early_board_init
+early_board_init:
+       jmp     early_board_init_ret

diff --git a/board/intel/minnowmax/Kconfig b/board/intel/minnowmax/Kconfig
index f2a0b71c442c8d482fe24fc9f144fb8af23edae5..7e975f9c3ae71606459d0316a7521eba43500d12 100644 (file)
--- a/board/intel/minnowmax/Kconfig
+++ b/board/intel/minnowmax/Kconfig
@@ -13,11 +13,12 @@ config SYS_CONFIG_NAME
        default "minnowmax"
 
 config SYS_TEXT_BASE
-       default 0xfff00000
+       default 0xfff00000 if !EFI_STUB
+       default 0x01110000 if EFI_STUB
 
 config BOARD_SPECIFIC_OPTIONS # dummy
        def_bool y
-       select X86_RESET_VECTOR
+       select X86_RESET_VECTOR if !EFI_STUB
        select INTEL_BAYTRAIL
        select BOARD_ROMSIZE_KB_8192
 

diff --git a/board/intel/minnowmax/minnowmax.c b/board/intel/minnowmax/minnowmax.c
index 383cae068bdff48b828c4b137fd96fae9e5d1d4e..c4f2c33b877f8b1ead8753a089ed14ad0cbfad1e 100644 (file)
--- a/board/intel/minnowmax/minnowmax.c
+++ b/board/intel/minnowmax/minnowmax.c
@@ -6,12 +6,7 @@
 
 #include <common.h>
 #include <asm/gpio.h>
-#include <asm/ibmpc.h>
-#include <asm/pnp_def.h>
 #include <netdev.h>
-#include <smsc_lpc47m.h>
-
-#define SERIAL_DEV PNP_DEV(0x2e, 4)
 
 int arch_early_init_r(void)
 {
@@ -21,13 +16,6 @@ int arch_early_init_r(void)
        return 0;
 }
 
-int board_early_init_f(void)
-{
-       lpc47m_enable_serial(SERIAL_DEV, UART0_BASE, UART0_IRQ);
-
-       return 0;
-}
-
 void setup_pch_gpios(u16 gpiobase, const struct pch_gpio_map *gpio)
 {
        return;

diff --git a/common/Makefile b/common/Makefile
index d6c1d4844dd69063fbec831f5364859db7ad935e..6dc4c899bcb4a8bda268b2d6d022ab46b1986e53 100644 (file)
--- a/common/Makefile
+++ b/common/Makefile
@@ -90,6 +90,7 @@ obj-$(CONFIG_CMD_DTT) += cmd_dtt.o
 obj-$(CONFIG_CMD_ECHO) += cmd_echo.o
 obj-$(CONFIG_ENV_IS_IN_EEPROM) += cmd_eeprom.o
 obj-$(CONFIG_CMD_EEPROM) += cmd_eeprom.o
+obj-$(CONFIG_EFI_STUB) += cmd_efi.o
 obj-$(CONFIG_CMD_ELF) += cmd_elf.o
 obj-$(CONFIG_SYS_HUSH_PARSER) += cmd_exit.o
 obj-$(CONFIG_CMD_EXT4) += cmd_ext4.o

diff --git a/common/board_f.c b/common/board_f.c
index 21be26f8e4051289b78de72933688ecd8d39135e..c7cc67c7a482901f993781452919880280f1c2a8 100644 (file)
--- a/common/board_f.c
+++ b/common/board_f.c
@@ -144,7 +144,7 @@ static int init_baud_rate(void)
 
 static int display_text_info(void)
 {
-#ifndef CONFIG_SANDBOX
+#if !defined(CONFIG_SANDBOX) && !defined(CONFIG_EFI_APP)
        ulong bss_start, bss_end, text_base;
 
        bss_start = (ulong)&__bss_start;
@@ -267,7 +267,7 @@ static int setup_mon_len(void)
 {
 #if defined(__ARM__) || defined(__MICROBLAZE__)
        gd->mon_len = (ulong)&__bss_end - (ulong)_start;
-#elif defined(CONFIG_SANDBOX)
+#elif defined(CONFIG_SANDBOX) || defined(CONFIG_EFI_APP)
        gd->mon_len = (ulong)&_end - (ulong)_init;
 #elif defined(CONFIG_BLACKFIN) || defined(CONFIG_NIOS2)
        gd->mon_len = CONFIG_SYS_MONITOR_LEN;
@@ -654,6 +654,8 @@ static int setup_dram_config(void)
 
 static int reloc_fdt(void)
 {
+       if (gd->flags & GD_FLG_SKIP_RELOC)
+               return 0;
        if (gd->new_fdt) {
                memcpy(gd->new_fdt, gd->fdt_blob, gd->fdt_size);
                gd->fdt_blob = gd->new_fdt;
@@ -664,6 +666,11 @@ static int reloc_fdt(void)
 
 static int setup_reloc(void)
 {
+       if (gd->flags & GD_FLG_SKIP_RELOC) {
+               debug("Skipping relocation due to flag\n");
+               return 0;
+       }
+
 #ifdef CONFIG_SYS_TEXT_BASE
        gd->reloc_off = gd->relocaddr - CONFIG_SYS_TEXT_BASE;
 #ifdef CONFIG_M68K
@@ -689,6 +696,8 @@ static int setup_reloc(void)
 
 static int jump_to_copy(void)
 {
+       if (gd->flags & GD_FLG_SKIP_RELOC)
+               return 0;
        /*
         * x86 is special, but in a nice way. It uses a trampoline which
         * enables the dcache if possible.
@@ -968,7 +977,8 @@ void board_init_f(ulong boot_flags)
        if (initcall_run_list(init_sequence_f))
                hang();
 
-#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX)
+#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX) && \
+               !defined(CONFIG_EFI_APP)
        /* NOTREACHED - jump_to_copy() does not return */
        hang();
 #endif

diff --git a/common/board_info.c b/common/board_info.c
index 4e5a1f7808119d329e71815a6c89b7ea3708da27..6afe98edeee936ebf4313cfdcad1e11def5a8934 100644 (file)
--- a/common/board_info.c
+++ b/common/board_info.c
@@ -8,7 +8,6 @@
 
 int __weak checkboard(void)
 {
-       printf("Board: Unknown\n");
        return 0;
 }
 

diff --git a/common/cmd_efi.c b/common/cmd_efi.c
new file mode 100644 (file)
index 0000000..c76296e
--- /dev/null
+++ b/common/cmd_efi.c
@@ -0,0 +1,257 @@
+/*
+ * (C) Copyright 2015 Google, Inc
+ * Written by Simon Glass <sjg@chromium.org>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <command.h>
+#include <efi.h>
+#include <errno.h>
+#include <malloc.h>
+
+static const char *const type_name[] = {
+       "reserved",
+       "loader_code",
+       "loader_data",
+       "bs_code",
+       "bs_data",
+       "rt_code",
+       "rt_data",
+       "conv",
+       "unusable",
+       "acpi_reclaim",
+       "acpi_nvs",
+       "io",
+       "io_port",
+       "pal_code",
+};
+
+static struct attr_info {
+       int shift;
+       const char *name;
+} mem_attr[] = {
+       { EFI_MEMORY_UC_SHIFT, "uncached" },
+       { EFI_MEMORY_WC_SHIFT, "write-coalescing" },
+       { EFI_MEMORY_WT_SHIFT, "write-through" },
+       { EFI_MEMORY_WB_SHIFT, "write-back" },
+       { EFI_MEMORY_UCE_SHIFT, "uncached & exported" },
+       { EFI_MEMORY_WP_SHIFT, "write-protect" },
+       { EFI_MEMORY_RP_SHIFT, "read-protect" },
+       { EFI_MEMORY_XP_SHIFT, "execute-protect" },
+       { EFI_MEMORY_RUNTIME_SHIFT, "needs runtime mapping" }
+};
+
+/* Maximum different attribute values we can track */
+#define ATTR_SEEN_MAX  30
+
+static inline bool is_boot_services(int type)
+{
+       return type == EFI_LOADER_CODE || type == EFI_LOADER_DATA ||
+               type == EFI_BOOT_SERVICES_CODE ||
+               type == EFI_BOOT_SERVICES_DATA;
+}
+
+static int h_cmp_entry(const void *v1, const void *v2)
+{
+       const struct efi_mem_desc *desc1 = v1;
+       const struct efi_mem_desc *desc2 = v2;
+       int64_t diff = desc1->physical_start - desc2->physical_start;
+
+       /*
+        * Manually calculate the difference to avoid sign loss in the 64-bit
+        * to 32-bit conversion
+        */
+       return diff < 0 ? -1 : diff > 0 ? 1 : 0;
+}
+
+void *efi_build_mem_table(struct efi_entry_memmap *map, int size, bool skip_bs)
+{
+       struct efi_mem_desc *desc, *end, *base, *dest, *prev;
+       int count;
+       u64 addr;
+
+       base = malloc(size + sizeof(*desc));
+       if (!base) {
+               debug("%s: Cannot allocate %#x bytes\n", __func__, size);
+               return NULL;
+       }
+       end = (struct efi_mem_desc *)((ulong)map + size);
+       count = ((ulong)end - (ulong)map->desc) / map->desc_size;
+       memcpy(base, map->desc, (ulong)end - (ulong)map->desc);
+       qsort(base, count, map->desc_size, h_cmp_entry);
+       prev = NULL;
+       addr = 0;
+       dest = base;
+       end = base + count;
+       for (desc = base; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
+               bool merge = true;
+               int type = desc->type;
+
+               if (skip_bs && is_boot_services(desc->type))
+                       type = EFI_CONVENTIONAL_MEMORY;
+
+               memcpy(dest, desc, map->desc_size);
+               dest->type = type;
+               if (!skip_bs || !prev)
+                       merge = false;
+               else if (desc->physical_start != addr)
+                       merge = false;
+               else if (type != EFI_CONVENTIONAL_MEMORY)
+                       merge = false;
+               else if (prev->type != EFI_CONVENTIONAL_MEMORY)
+                       merge = false;
+
+               if (merge) {
+                       prev->num_pages += desc->num_pages;
+               } else {
+                       prev = dest;
+                       dest = efi_get_next_mem_desc(map, dest);
+               }
+               addr = desc->physical_start + (desc->num_pages <<
+                               EFI_PAGE_SHIFT);
+       }
+
+       /* Mark the end */
+       dest->type = EFI_TABLE_END;
+
+       return base;
+}
+
+static void efi_print_mem_table(struct efi_entry_memmap *map,
+                               struct efi_mem_desc *desc, bool skip_bs)
+{
+       u64 attr_seen[ATTR_SEEN_MAX];
+       int attr_seen_count;
+       int upto, i;
+       u64 addr;
+
+       printf(" #  %-14s  %10s  %10s  %10s  %s\n", "Type", "Physical",
+              "Virtual", "Size", "Attributes");
+
+       /* Keep track of all the different attributes we have seen */
+       attr_seen_count = 0;
+       addr = 0;
+       for (upto = 0; desc->type != EFI_TABLE_END;
+            upto++, desc = efi_get_next_mem_desc(map, desc)) {
+               const char *name;
+               u64 size;
+
+               if (skip_bs && is_boot_services(desc->type))
+                       continue;
+               if (desc->physical_start != addr) {
+                       printf("    %-14s  %010llx  %10s  %010llx\n", "<gap>",
+                              addr, "", desc->physical_start - addr);
+               }
+               size = desc->num_pages << EFI_PAGE_SHIFT;
+
+               name = desc->type < ARRAY_SIZE(type_name) ?
+                               type_name[desc->type] : "<invalid>";
+               printf("%2d  %x:%-12s  %010llx  %010llx  %010llx  ", upto,
+                      desc->type, name, desc->physical_start,
+                      desc->virtual_start, size);
+               if (desc->attribute & EFI_MEMORY_RUNTIME)
+                       putc('r');
+               printf("%llx", desc->attribute & ~EFI_MEMORY_RUNTIME);
+               putc('\n');
+
+               for (i = 0; i < attr_seen_count; i++) {
+                       if (attr_seen[i] == desc->attribute)
+                               break;
+               }
+               if (i == attr_seen_count && i < ATTR_SEEN_MAX)
+                       attr_seen[attr_seen_count++] = desc->attribute;
+               addr = desc->physical_start + size;
+       }
+
+       printf("\nAttributes key:\n");
+       for (i = 0; i < attr_seen_count; i++) {
+               u64 attr = attr_seen[i];
+               bool first;
+               int j;
+
+               printf("%c%llx: ", attr & EFI_MEMORY_RUNTIME ? 'r' : ' ',
+                      attr & ~EFI_MEMORY_RUNTIME);
+               for (j = 0, first = true; j < ARRAY_SIZE(mem_attr); j++) {
+                       if (attr & (1ULL << mem_attr[j].shift)) {
+                               if (first)
+                                       first = false;
+                               else
+                                       printf(", ");
+                               printf("%s", mem_attr[j].name);
+                       }
+               }
+               putc('\n');
+       }
+       if (skip_bs)
+               printf("*Some areas are merged (use 'all' to see)\n");
+}
+
+static int do_efi_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+       struct efi_mem_desc *desc;
+       struct efi_entry_memmap *map;
+       int size, ret;
+       bool skip_bs;
+
+       skip_bs = !argc || *argv[0] != 'a';
+       ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
+       switch (ret) {
+       case -ENOENT:
+               printf("No EFI table available\n");
+               goto done;
+       case -EPROTONOSUPPORT:
+               printf("Incorrect EFI table version\n");
+               goto done;
+       }
+       printf("EFI table at %lx, memory map %p, size %x, version %x, descr. size %#x\n",
+              gd->arch.table, map, size, map->version, map->desc_size);
+       if (map->version != EFI_MEM_DESC_VERSION) {
+               printf("Incorrect memory map version\n");
+               ret = -EPROTONOSUPPORT;
+               goto done;
+       }
+
+       desc = efi_build_mem_table(map, size, skip_bs);
+       if (!desc) {
+               ret = -ENOMEM;
+               goto done;
+       }
+
+       efi_print_mem_table(map, desc, skip_bs);
+       free(desc);
+done:
+       if (ret)
+               printf("Error: %d\n", ret);
+
+       return ret ? CMD_RET_FAILURE : 0;
+}
+
+static cmd_tbl_t efi_commands[] = {
+       U_BOOT_CMD_MKENT(mem, 1, 1, do_efi_mem, "", ""),
+};
+
+static int do_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+       cmd_tbl_t *efi_cmd;
+       int ret;
+
+       if (argc < 2)
+               return CMD_RET_USAGE;
+       efi_cmd = find_cmd_tbl(argv[1], efi_commands, ARRAY_SIZE(efi_commands));
+       argc -= 2;
+       argv += 2;
+       if (!efi_cmd || argc > efi_cmd->maxargs)
+               return CMD_RET_USAGE;
+
+       ret = efi_cmd->cmd(efi_cmd, flag, argc, argv);
+
+       return cmd_process_error(efi_cmd, ret);
+}
+
+U_BOOT_CMD(
+       efi,     3,      1,      do_efi,
+       "EFI access",
+       "mem [all]        Dump memory information [include boot services]"
+);

diff --git a/common/command.c b/common/command.c
index 4719f4978ba637edb2ff4cc1b7ee67cb3462cfc7..381e6a20b6cdc1a458e0401ea4e857a6020ef042 100644 (file)
--- a/common/command.c
+++ b/common/command.c
@@ -492,7 +492,7 @@ static int cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
        result = (cmdtp->cmd)(cmdtp, flag, argc, argv);
        if (result)
-               debug("Command failed, result=%d", result);
+               debug("Command failed, result=%d\n", result);
        return result;
 }
 

diff --git a/config.mk b/config.mk
index 6282919482bc8b8cc7c879e44e3814858573fa9a..b77d58903c8148db98b6b204c8d2b314397fd5a6 100644 (file)
--- a/config.mk
+++ b/config.mk
@@ -73,8 +73,6 @@ endif
 
 RELFLAGS := $(PLATFORM_RELFLAGS)
 
-OBJCOPYFLAGS += --gap-fill=0xff
-
 PLATFORM_CPPFLAGS += $(RELFLAGS)
 PLATFORM_CPPFLAGS += -pipe
 

diff --git a/configs/bayleybay_defconfig b/configs/bayleybay_defconfig
new file mode 100644 (file)
index 0000000..7f92ead
--- /dev/null
+++ b/configs/bayleybay_defconfig
@@ -0,0 +1,27 @@
+CONFIG_X86=y
+CONFIG_VENDOR_INTEL=y
+CONFIG_DEFAULT_DEVICE_TREE="bayleybay"
+CONFIG_TARGET_BAYLEYBAY=y
+CONFIG_HAVE_INTEL_ME=y
+CONFIG_SMP=y
+CONFIG_HAVE_VGA_BIOS=y
+CONFIG_GENERATE_PIRQ_TABLE=y
+CONFIG_GENERATE_MP_TABLE=y
+CONFIG_CMD_CPU=y
+# CONFIG_CMD_IMLS is not set
+# CONFIG_CMD_FLASH is not set
+# CONFIG_CMD_SETEXPR is not set
+# CONFIG_CMD_NFS is not set
+CONFIG_BOOTSTAGE=y
+CONFIG_BOOTSTAGE_REPORT=y
+CONFIG_CMD_BOOTSTAGE=y
+CONFIG_OF_CONTROL=y
+CONFIG_CPU=y
+CONFIG_DM_PCI=y
+CONFIG_SPI_FLASH=y
+CONFIG_VIDEO_VESA=y
+CONFIG_FRAMEBUFFER_SET_VESA_MODE=y
+CONFIG_FRAMEBUFFER_VESA_MODE_11A=y
+CONFIG_DM_RTC=y
+CONFIG_USE_PRIVATE_LIBGCC=y
+CONFIG_SYS_VSNPRINTF=y

diff --git a/configs/chromebook_link_defconfig b/configs/chromebook_link_defconfig
index e394dab719b9c3106b177e9023c386b3ee14abf8..b987f3f52f690c30afffe6ffcf7f10f22b53dd11 100644 (file)
--- a/configs/chromebook_link_defconfig
+++ b/configs/chromebook_link_defconfig
@@ -14,6 +14,9 @@ CONFIG_CMD_BOOTSTAGE=y
 CONFIG_OF_CONTROL=y
 CONFIG_DM_PCI=y
 CONFIG_SPI_FLASH=y
+CONFIG_CMD_CROS_EC=y
+CONFIG_CROS_EC=y
+CONFIG_CROS_EC_LPC=y
 CONFIG_VIDEO_VESA=y
 CONFIG_FRAMEBUFFER_SET_VESA_MODE=y
 CONFIG_FRAMEBUFFER_VESA_MODE_11A=y

diff --git a/configs/chromebox_panther_defconfig b/configs/chromebox_panther_defconfig
index 340510f71a6af0f72a6f67cc157f8fe1a97f109c..e82c8ecf64e90e44795e0ec2a662917f3ed2c4b1 100644 (file)
--- a/configs/chromebox_panther_defconfig
+++ b/configs/chromebox_panther_defconfig
@@ -14,6 +14,9 @@ CONFIG_CMD_BOOTSTAGE=y
 CONFIG_OF_CONTROL=y
 CONFIG_DM_PCI=y
 CONFIG_SPI_FLASH=y
+CONFIG_CMD_CROS_EC=y
+CONFIG_CROS_EC=y
+CONFIG_CROS_EC_LPC=y
 CONFIG_VIDEO_VESA=y
 CONFIG_FRAMEBUFFER_SET_VESA_MODE=y
 CONFIG_FRAMEBUFFER_VESA_MODE_11A=y

diff --git a/configs/efi-x86_defconfig b/configs/efi-x86_defconfig
new file mode 100644 (file)
index 0000000..1aa0655
--- /dev/null
+++ b/configs/efi-x86_defconfig
@@ -0,0 +1,16 @@
+CONFIG_X86=y
+CONFIG_VENDOR_EFI=y
+CONFIG_TARGET_EFI=y
+CONFIG_TSC_CALIBRATION_BYPASS=y
+CONFIG_OF_CONTROL=y
+CONFIG_OF_EMBED=y
+CONFIG_DM_PCI=y
+CONFIG_DEFAULT_DEVICE_TREE="efi"
+CONFIG_EFI=y
+CONFIG_EFI_APP=y
+CONFIG_DEBUG_UART=y
+CONFIG_DEBUG_EFI_CONSOLE=y
+CONFIG_DEBUG_UART_BASE=0
+CONFIG_DEBUG_UART_CLOCK=0
+# CONFIG_CMD_NET is not set
+# CONFIG_CMD_BOOTM is not set

diff --git a/configs/qemu-x86_defconfig b/configs/qemu-x86_defconfig
index 4b18d5173864e42b55d6ae1a77e85bccb78d6166..e579c36200c17fa12f2f29c88b7a09b8b73fd544 100644 (file)
--- a/configs/qemu-x86_defconfig
+++ b/configs/qemu-x86_defconfig
@@ -1,5 +1,7 @@
 CONFIG_X86=y
 CONFIG_DEFAULT_DEVICE_TREE="qemu-x86_i440fx"
+CONFIG_SMP=y
+CONFIG_MAX_CPUS=2
 CONFIG_GENERATE_PIRQ_TABLE=y
 CONFIG_GENERATE_MP_TABLE=y
 CONFIG_CMD_CPU=y

diff --git a/doc/README.efi b/doc/README.efi
new file mode 100644 (file)
index 0000000..7c95579
--- /dev/null
+++ b/doc/README.efi
@@ -0,0 +1,237 @@
+#
+# Copyright (C) 2015 Google, Inc
+#
+# SPDX-License-Identifier:     GPL-2.0+
+#
+
+U-Boot on EFI
+=============
+This document provides information about U-Boot running on top of EFI, either
+as an application or just as a means of getting U-Boot onto a new platform.
+
+
+In God's Name, Why?
+-------------------
+This is useful in several situations:
+
+- You have EFI running on a board but U-Boot does not natively support it
+fully yet. You can boot into U-Boot from EFI and use that until U-Boot is
+fully ported
+
+- You need to use an EFI implementation (e.g. UEFI) because your vendor
+requires it in order to provide support
+
+- You plan to use coreboot to boot into U-Boot but coreboot support does
+not currently exist for your platform. In the meantime you can use U-Boot
+on EFI and then move to U-Boot on coreboot when ready
+
+- You use EFI but want to experiment with a simpler alternative like U-Boot
+
+
+Status
+------
+Only x86 is supported at present. If you are using EFI on another architecture
+you may want to reconsider. However, much of the code is generic so could be
+ported.
+
+U-Boot supports running as an EFI application for 32-bit EFI only. This is
+not very useful since only a serial port is provided. You can look around at
+memory and type 'help' but that is about it.
+
+More usefully, U-Boot supports building itself as a payload for either 32-bit
+or 64-bit EFI. U-Boot is packaged up and loaded in its entirety by EFI. Once
+started, U-Boot changes to 32-bit mode (currently) and takes over the
+machine. You can use devices, boot a kernel, etc.
+
+
+Build Instructions
+------------------
+First choose a board that has EFI support and obtain an EFI implementation
+for that board. It will be either 32-bit or 64-bit.
+
+To build U-Boot as an EFI application (32-bit EFI required), enable
+CONFIG_EFI and CONFIG_EFI_APP. The efi-x86 config is set up for this.
+
+To build U-Boot as an EFI payload (32-bit or 64-bit EFI can be used), adjust
+an existing config to enable CONFIG_EFI, CONFIG_EFI_STUB and either
+CONFIG_EFI_STUB_32BIT or CONFIG_EFI_STUB_64BIT.
+
+Then build U-Boot as normal, e.g.
+
+   make qemu-x86_defconfig
+   make menuconfig    (or make xconfig if you prefer)
+   # change the settings as above
+   make
+
+You will end up with one of these files:
+
+   u-boot-app.efi      - U-Boot EFI application
+   u-boot-payload.efi  - U-Boot EFI payload application
+
+
+Trying it out
+-------------
+Qemu is an emulator and it can emulate an x86 machine. You can run the
+payload with something like this:
+
+   mkdir /tmp/efi
+   cp /path/to/u-boot*.efi /tmp/efi
+   qemu-system-x86_64 -bios bios.bin -hda fat:/tmp/efi/
+
+Add -nographic if you want to use the terminal for output. Once it starts
+type 'fs0:u-boot-payload.efi' to run the payload or 'fs0:u-boot-app.efi' to
+run the application. 'bios.bin' is the EFI 'BIOS'.
+
+To try it on real hardware, put u-boot-app.efi on a suitable boot medium,
+such as a USB stick. Then you can type something like this to start it:
+
+   fs0:u-boot-payload.efi
+
+(or fs0:u-boot-app.efi for the application)
+
+This will start the payload, copy U-Boot into RAM and start U-Boot. Note
+that EFI does not support booting a 64-bit application from a 32-bit
+EFI (or vice versa). Also it will often fail to print an error message if
+you get this wrong.
+
+
+Inner workings
+==============
+Here follow a few implementation notes for those who want to fiddle with
+this and perhaps contribute patches.
+
+The application and payload approaches sound similar but are in fact
+implemented completely differently.
+
+EFI Application
+---------------
+For the application the whole of U-Boot is built as a shared library. The
+efi_main() function is in lib/efi/efi_app.c. It sets up some basic EFI
+functions with efi_init(), sets up U-Boot global_data, allocates memory for
+U-Boot's malloc(), etc. and enters the normal init sequence (board_init_f()
+and board_init_r()).
+
+Since U-Boot limits its memory access to the allocated regions very little
+special code is needed. The CONFIG_EFI_APP option controls a few things
+that need to change so 'git grep CONFIG_EFI_APP' may be instructive.
+The CONFIG_EFI option controls more general EFI adjustments.
+
+The only available driver is the serial driver. This calls back into EFI
+'boot services' to send and receive characters. Although it is implemented
+as a serial driver the console device is not necessarilly serial. If you
+boot EFI with video output then the 'serial' device will operate on your
+target devices's display instead and the device's USB keyboard will also
+work if connected. If you have both serial and video output, then both
+consoles will be active. Even though U-Boot does the same thing normally,
+These are features of EFI, not U-Boot.
+
+Very little code is involved in implementing the EFI application feature.
+U-Boot is highly portable. Most of the difficulty is in modifying the
+Makefile settings to pass the right build flags. In particular there is very
+little x86-specific code involved - you can find most of it in
+arch/x86/cpu. Porting to ARM (which can also use EFI if you are brave
+enough) should be straightforward.
+
+Use the 'reset' command to get back to EFI.
+
+EFI Payload
+-----------
+The payload approach is a different kettle of fish. It works by building
+U-Boot exactly as normal for your target board, then adding the entire
+image (including device tree) into a small EFI stub application responsible
+for booting it. The stub application is built as a normal EFI application
+except that it has a lot of data attached to it.
+
+The stub application is implemented in lib/efi/efi_stub.c. The efi_main()
+function is called by EFI. It is responsible for copying U-Boot from its
+original location into memory, disabling EFI boot services and starting
+U-Boot. U-Boot then starts as normal, relocates, starts all drivers, etc.
+
+The stub application is architecture-dependent. At present it has some
+x86-specific code and a comment at the top of efi_stub.c describes this.
+
+While the stub application does allocate some memory from EFI this is not
+used by U-Boot (the payload). In fact when U-Boot starts it has all of the
+memory available to it and can operate as it pleases (but see the next
+section).
+
+Tables
+------
+The payload can pass information to U-Boot in the form of EFI tables. At
+present this feature is used to pass the EFI memory map, an inordinately
+large list of memory regions. You can use the 'efi mem all' command to
+display this list. U-Boot uses the list to work out where to relocate
+itself.
+
+Although U-Boot can use any memory it likes, EFI marks some memory as used
+by 'run-time services', code that hangs around while U-Boot is running and
+is even present when Linux is running. This is common on x86 and provides
+a way for Linux to call back into the firmware to control things like CPU
+fan speed. U-Boot uses only 'conventional' memory, in EFI terminology. It
+will relocate itself to the top of the largest block of memory it can find
+below 4GB.
+
+Interrupts
+----------
+U-Boot drivers typically don't use interrupts. Since EFI enables interrupts
+it is possible that an interrupt will fire that U-Boot cannot handle. This
+seems to cause problems. For this reason the U-Boot payload runs with
+interrupts disabled at present.
+
+32/64-bit
+---------
+While the EFI application can in principle be built as either 32- or 64-bit,
+only 32-bit is currently supported. This means that the application can only
+be used with 32-bit EFI.
+
+The payload stub can be build as either 32- or 64-bits. Only a small amount
+of code is built this way (see the extra- line in lib/efi/Makefile).
+Everything else is built as a normal U-Boot, so is always 32-bit on x86 at
+present.
+
+Future work
+-----------
+This work could be extended in a number of ways:
+
+- Add a generic x86 EFI payload configuration. At present you need to modify
+an existing one, but mostly the low-level x86 code is disabled when booting
+on EFI anyway, so a generic 'EFI' board could be created with a suitable set
+of drivers enabled.
+
+- Add ARM support
+
+- Add 64-bit application support
+
+- Figure out how to solve the interrupt problem
+
+- Add more drivers to the application side (e.g. video, block devices, USB,
+environment access). This would mostly be an academic exercise as a strong
+use case is not readily apparent, but it might be fun.
+
+- Avoid turning off boot services in the stub. Instead allow U-Boot to make
+use of boot services in case it wants to. It is unclear what it might want
+though.
+
+Where is the code?
+------------------
+lib/efi
+       payload stub, application, support code. Mostly arch-neutral
+
+arch/x86/lib/efi
+       helper functions for the fake DRAM init, etc. These can be used by
+       any board that runs as a payload.
+
+arch/x86/cpu/efi
+       x86 support code for running as an EFI application
+
+board/efi/efi-x86/efi.c
+       x86 board code for running as an EFI application
+
+common/cmd_efi.c
+       the 'efi' command
+
+
+--
+Ben Stoltz, Simon Glass
+Google, Inc
+July 2015

diff --git a/doc/README.x86 b/doc/README.x86
index 5d712445df5c6222106898713074eda5394cb5ed..af2459c7ed6af55d989f2902bbf8ec4646975aaa 100644 (file)
--- a/doc/README.x86
+++ b/doc/README.x86
@@ -281,6 +281,11 @@ QEMU emulates a graphic card which U-Boot supports. Removing '-nographic' will
 show QEMU's VGA console window. Note this will disable QEMU's serial output.
 If you want to check both consoles, use '-serial stdio'.
 
+Multicore is also supported by QEMU via '-smp n' where n is the number of cores
+to instantiate. Currently the default U-Boot built for QEMU supports 2 cores.
+In order to support more cores, you need add additional cpu nodes in the device
+tree and change CONFIG_MAX_CPUS accordingly.
+
 CPU Microcode
 -------------
 Modern CPUs usually require a special bit stream called microcode [8] to be
@@ -325,6 +330,281 @@ mtrr - List and set the Memory Type Range Registers (MTRR). These are used to
         mode to use. U-Boot sets up some reasonable values but you can
         adjust then with this command.
 
+Booting Ubuntu
+--------------
+As an example of how to set up your boot flow with U-Boot, here are
+instructions for starting Ubuntu from U-Boot. These instructions have been
+tested on Minnowboard MAX with a SATA driver but are equally applicable on
+other platforms and other media. There are really only four steps and its a
+very simple script, but a more detailed explanation is provided here for
+completeness.
+
+Note: It is possible to set up U-Boot to boot automatically using syslinux.
+It could also use the grub.cfg file (/efi/ubuntu/grub.cfg) to obtain the
+GUID. If you figure these out, please post patches to this README.
+
+Firstly, you will need Ubunutu installed on an available disk. It should be
+possible to make U-Boot start a USB start-up disk but for now let's assume
+that you used another boot loader to install Ubuntu.
+
+Use the U-Boot command line to find the UUID of the partition you want to
+boot. For example our disk is SCSI device 0:
+
+=> part list scsi 0
+
+Partition Map for SCSI device 0  --   Partition Type: EFI
+
+   Part        Start LBA       End LBA         Name
+       Attributes
+       Type GUID
+       Partition GUID
+   1   0x00000800      0x001007ff      ""
+       attrs:  0x0000000000000000
+       type:   c12a7328-f81f-11d2-ba4b-00a0c93ec93b
+       guid:   9d02e8e4-4d59-408f-a9b0-fd497bc9291c
+   2   0x00100800      0x037d8fff      ""
+       attrs:  0x0000000000000000
+       type:   0fc63daf-8483-4772-8e79-3d69d8477de4
+       guid:   965c59ee-1822-4326-90d2-b02446050059
+   3   0x037d9000      0x03ba27ff      ""
+       attrs:  0x0000000000000000
+       type:   0657fd6d-a4ab-43c4-84e5-0933c84b4f4f
+       guid:   2c4282bd-1e82-4bcf-a5ff-51dedbf39f17
+   =>
+
+This shows that your SCSI disk has three partitions. The really long hex
+strings are called Globally Unique Identifiers (GUIDs). You can look up the
+'type' ones here [11]. On this disk the first partition is for EFI and is in
+VFAT format (DOS/Windows):
+
+   => fatls scsi 0:1
+               efi/
+
+   0 file(s), 1 dir(s)
+
+
+Partition 2 is 'Linux filesystem data' so that will be our root disk. It is
+in ext2 format:
+
+   => ext2ls scsi 0:2
+   <DIR>       4096 .
+   <DIR>       4096 ..
+   <DIR>      16384 lost+found
+   <DIR>       4096 boot
+   <DIR>      12288 etc
+   <DIR>       4096 media
+   <DIR>       4096 bin
+   <DIR>       4096 dev
+   <DIR>       4096 home
+   <DIR>       4096 lib
+   <DIR>       4096 lib64
+   <DIR>       4096 mnt
+   <DIR>       4096 opt
+   <DIR>       4096 proc
+   <DIR>       4096 root
+   <DIR>       4096 run
+   <DIR>      12288 sbin
+   <DIR>       4096 srv
+   <DIR>       4096 sys
+   <DIR>       4096 tmp
+   <DIR>       4096 usr
+   <DIR>       4096 var
+   <SYM>         33 initrd.img
+   <SYM>         30 vmlinuz
+   <DIR>       4096 cdrom
+   <SYM>         33 initrd.img.old
+   =>
+
+and if you look in the /boot directory you will see the kernel:
+
+   => ext2ls scsi 0:2 /boot
+   <DIR>       4096 .
+   <DIR>       4096 ..
+   <DIR>       4096 efi
+   <DIR>       4096 grub
+            3381262 System.map-3.13.0-32-generic
+            1162712 abi-3.13.0-32-generic
+             165611 config-3.13.0-32-generic
+             176500 memtest86+.bin
+             178176 memtest86+.elf
+             178680 memtest86+_multiboot.bin
+            5798112 vmlinuz-3.13.0-32-generic
+             165762 config-3.13.0-58-generic
+            1165129 abi-3.13.0-58-generic
+            5823136 vmlinuz-3.13.0-58-generic
+           19215259 initrd.img-3.13.0-58-generic
+            3391763 System.map-3.13.0-58-generic
+            5825048 vmlinuz-3.13.0-58-generic.efi.signed
+           28304443 initrd.img-3.13.0-32-generic
+   =>
+
+The 'vmlinuz' files contain a packaged Linux kernel. The format is a kind of
+self-extracting compressed file mixed with some 'setup' configuration data.
+Despite its size (uncompressed it is >10MB) this only includes a basic set of
+device drivers, enough to boot on most hardware types.
+
+The 'initrd' files contain a RAM disk. This is something that can be loaded
+into RAM and will appear to Linux like a disk. Ubuntu uses this to hold lots
+of drivers for whatever hardware you might have. It is loaded before the
+real root disk is accessed.
+
+The numbers after the end of each file are the version. Here it is Linux
+version 3.13. You can find the source code for this in the Linux tree with
+the tag v3.13. The '.0' allows for additional Linux releases to fix problems,
+but normally this is not needed. The '-58' is used by Ubuntu. Each time they
+release a new kernel they increment this number. New Ubuntu versions might
+include kernel patches to fix reported bugs. Stable kernels can exist for
+some years so this number can get quite high.
+
+The '.efi.signed' kernel is signed for EFI's secure boot. U-Boot has its own
+secure boot mechanism - see [12] [13] and cannot read .efi files at present.
+
+To boot Ubuntu from U-Boot the steps are as follows:
+
+1. Set up the boot arguments. Use the GUID for the partition you want to
+boot:
+
+   => setenv bootargs root=/dev/disk/by-partuuid/965c59ee-1822-4326-90d2-b02446050059 ro
+
+Here root= tells Linux the location of its root disk. The disk is specified
+by its GUID, using '/dev/disk/by-partuuid/', a Linux path to a 'directory'
+containing all the GUIDs Linux has found. When it starts up, there will be a
+file in that directory with this name in it. It is also possible to use a
+device name here, see later.
+
+2. Load the kernel. Since it is an ext2/4 filesystem we can do:
+
+   => ext2load scsi 0:2 03000000 /boot/vmlinuz-3.13.0-58-generic
+
+The address 30000000 is arbitrary, but there seem to be problems with using
+small addresses (sometimes Linux cannot find the ramdisk). This is 48MB into
+the start of RAM (which is at 0 on x86).
+
+3. Load the ramdisk (to 64MB):
+
+   => ext2load scsi 0:2 04000000 /boot/initrd.img-3.13.0-58-generic
+
+4. Start up the kernel. We need to know the size of the ramdisk, but can use
+a variable for that. U-Boot sets 'filesize' to the size of the last file it
+loaded.
+
+   => zboot 03000000 0 04000000 ${filesize}
+
+Type 'help zboot' if you want to see what the arguments are. U-Boot on x86 is
+quite verbose when it boots a kernel. You should see these messages from
+U-Boot:
+
+   Valid Boot Flag
+   Setup Size = 0x00004400
+   Magic signature found
+   Using boot protocol version 2.0c
+   Linux kernel version 3.13.0-58-generic (buildd@allspice) #97-Ubuntu SMP Wed Jul 8 02:56:15 UTC 2015
+   Building boot_params at 0x00090000
+   Loading bzImage at address 100000 (5805728 bytes)
+   Magic signature found
+   Initial RAM disk at linear address 0x04000000, size 19215259 bytes
+   Kernel command line: "console=ttyS0,115200 root=/dev/disk/by-partuuid/965c59ee-1822-4326-90d2-b02446050059 ro"
+
+   Starting kernel ...
+
+U-Boot prints out some bootstage timing. This is more useful if you put the
+above commands into a script since then it will be faster.
+
+   Timer summary in microseconds:
+          Mark    Elapsed  Stage
+             0          0  reset
+       241,535    241,535  board_init_r
+     2,421,611  2,180,076  id=64
+     2,421,790        179  id=65
+     2,428,215      6,425  main_loop
+    48,860,584 46,432,369  start_kernel
+
+   Accumulated time:
+                  240,329  ahci
+                1,422,704  vesa display
+
+Now the kernel actually starts:
+
+   [    0.000000] Initializing cgroup subsys cpuset
+   [    0.000000] Initializing cgroup subsys cpu
+   [    0.000000] Initializing cgroup subsys cpuacct
+   [    0.000000] Linux version 3.13.0-58-generic (buildd@allspice) (gcc version 4.8.2 (Ubuntu 4.8.2-19ubuntu1) ) #97-Ubuntu SMP Wed Jul 8 02:56:15 UTC 2015 (Ubuntu 3.13.0-58.97-generic 3.13.11-ckt22)
+   [    0.000000] Command line: console=ttyS0,115200 root=/dev/disk/by-partuuid/965c59ee-1822-4326-90d2-b02446050059 ro
+
+It continues for a long time. Along the way you will see it pick up your
+ramdisk:
+
+   [    0.000000] RAMDISK: [mem 0x04000000-0x05253fff]
+...
+   [    0.788540] Trying to unpack rootfs image as initramfs...
+   [    1.540111] Freeing initrd memory: 18768K (ffff880004000000 - ffff880005254000)
+...
+
+Later it actually starts using it:
+
+   Begin: Running /scripts/local-premount ... done.
+
+You should also see your boot disk turn up:
+
+   [    4.357243] scsi 1:0:0:0: Direct-Access     ATA      ADATA SP310      5.2  PQ: 0 ANSI: 5
+   [    4.366860] sd 1:0:0:0: [sda] 62533296 512-byte logical blocks: (32.0 GB/29.8 GiB)
+   [    4.375677] sd 1:0:0:0: Attached scsi generic sg0 type 0
+   [    4.381859] sd 1:0:0:0: [sda] Write Protect is off
+   [    4.387452] sd 1:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
+   [    4.399535]  sda: sda1 sda2 sda3
+
+Linux has found the three partitions (sda1-3). Mercifully it doesn't print out
+the GUIDs. In step 1 above we could have used:
+
+   setenv bootargs root=/dev/sda2 ro
+
+instead of the GUID. However if you add another drive to your board the
+numbering may change whereas the GUIDs will not. So if your boot partition
+becomes sdb2, it will still boot. For embedded systems where you just want to
+boot the first disk, you have that option.
+
+The last thing you will see on the console is mention of plymouth (which
+displays the Ubuntu start-up screen) and a lot of 'Starting' messages:
+
+ * Starting Mount filesystems on boot                                    [ OK ]
+
+After a pause you should see a login screen on your display and you are done.
+
+If you want to put this in a script you can use something like this:
+
+   setenv bootargs root=UUID=b2aaf743-0418-4d90-94cc-3e6108d7d968 ro
+   setenv boot zboot 03000000 0 04000000 \${filesize}
+   setenv bootcmd "ext2load scsi 0:2 03000000 /boot/vmlinuz-3.13.0-58-generic; ext2load scsi 0:2 04000000 /boot/initrd.img-3.13.0-58-generic; run boot"
+   saveenv
+
+The \ is to tell the shell not to evaluate ${filesize} as part of the setenv
+command.
+
+You will also need to add this to your board configuration file, e.g.
+include/configs/minnowmax.h:
+
+   #define CONFIG_BOOTDELAY    2
+
+Now when you reset your board it wait a few seconds (in case you want to
+interrupt) and then should boot straight into Ubuntu.
+
+You can also bake this behaviour into your build by hard-coding the
+environment variables if you add this to minnowmax.h:
+
+#undef CONFIG_BOOTARGS
+#undef CONFIG_BOOTCOMMAND
+
+#define CONFIG_BOOTARGS                \
+       "root=/dev/sda2 ro"
+#define CONFIG_BOOTCOMMAND     \
+       "ext2load scsi 0:2 03000000 /boot/vmlinuz-3.13.0-58-generic; " \
+       "ext2load scsi 0:2 04000000 /boot/initrd.img-3.13.0-58-generic; " \
+       "run boot"
+
+#undef CONFIG_EXTRA_ENV_SETTINGS
+#define CONFIG_EXTRA_ENV_SETTINGS "boot=zboot 03000000 0 04000000 ${filesize}"
+
+
 Development Flow
 ----------------
 These notes are for those who want to port U-Boot to a new x86 platform.
@@ -388,6 +668,46 @@ boot progress. This can be good for debugging.
 If not, you can try to get serial working as early as possible. The early
 debug serial port may be useful here. See setup_early_uart() for an example.
 
+During the U-Boot porting, one of the important steps is to write correct PIRQ
+routing information in the board device tree. Without it, device drivers in the
+Linux kernel won't function correctly due to interrupt is not working. Please
+refer to U-Boot doc [14] for the device tree bindings of Intel interrupt router.
+Here we have more details on the intel,pirq-routing property below.
+
+       intel,pirq-routing = <
+               PCI_BDF(0, 2, 0) INTA PIRQA
+               ...
+       >;
+
+As you see each entry has 3 cells. For the first one, we need describe all pci
+devices mounted on the board. For SoC devices, normally there is a chapter on
+the chipset datasheet which lists all the available PCI devices. For example on
+Bay Trail, this is chapter 4.3 (PCI configuration space). For the second one, we
+can get the interrupt pin either from datasheet or hardware via U-Boot shell.
+The reliable source is the hardware as sometimes chipset datasheet is not 100%
+up-to-date. Type 'pci header' plus the device's pci bus/device/function number
+from U-Boot shell below.
+
+  => pci header 0.1e.1
+    vendor ID =                        0x8086
+    device ID =                        0x0f08
+    ...
+    interrupt line =           0x09
+    interrupt pin =            0x04
+    ...
+
+It shows this PCI device is using INTD pin as it reports 4 in the interrupt pin
+register. Repeat this until you get interrupt pins for all the devices. The last
+cell is the PIRQ line which a particular interrupt pin is mapped to. On Intel
+chipset, the power-up default mapping is INTA/B/C/D maps to PIRQA/B/C/D. This
+can be changed by registers in LPC bridge. So far Intel FSP does not touch those
+registers so we can write down the PIRQ according to the default mapping rule.
+
+Once we get the PIRQ routing information in the device tree, the interrupt
+allocation and assignment will be done by U-Boot automatically. Now you can
+enable CONFIG_GENERATE_PIRQ_TABLE for testing Linux kernel using i8259 PIC and
+CONFIG_GENERATE_MP_TABLE for testing Linux kernel using local APIC and I/O APIC.
+
 TODO List
 ---------
 - Audio
@@ -406,3 +726,7 @@ References
 [8] http://en.wikipedia.org/wiki/Microcode
 [9] http://simplefirmware.org
 [10] http://www.intel.com/design/archives/processors/pro/docs/242016.htm
+[11] https://en.wikipedia.org/wiki/GUID_Partition_Table
+[12] http://events.linuxfoundation.org/sites/events/files/slides/chromeos_and_diy_vboot_0.pdf
+[13] http://events.linuxfoundation.org/sites/events/files/slides/elce-2014.pdf
+[14] doc/device-tree-bindings/misc/intel,irq-router.txt

diff --git a/doc/device-tree-bindings/misc/intel,irq-router.txt b/doc/device-tree-bindings/misc/intel,irq-router.txt
index 598b4b1c2f5cfd43c5b6c428e8da90a75a489542..e4d8ead2ee5d3a06c483b1702ff3e5dd6f07fb3b 100644 (file)
--- a/doc/device-tree-bindings/misc/intel,irq-router.txt
+++ b/doc/device-tree-bindings/misc/intel,irq-router.txt
@@ -17,8 +17,8 @@ Required properties :
 - intel,pirq-link : Specifies the PIRQ link information with two cells. The
     first cell is the register offset that controls the first PIRQ link routing.
     The second cell is the total number of PIRQ links the router supports.
-- intel,pirq-mask : Specifies the IRQ mask reprenting the 16 IRQs in 8259 PIC.
-    Bit N is 1 means IRQ N is available to be routed.
+- intel,pirq-mask : Specifies the IRQ mask representing the 16 IRQs in the
+    8259 PIC. Bit N is 1 means IRQ N is available to be routed.
 - intel,pirq-routing : Specifies all PCI devices' IRQ routing information,
    encoded as 3 cells a group for a device. The first cell is the device's PCI
    bus number, device number and function number encoding with PCI_BDF() macro.

diff --git a/doc/driver-model/pci-info.txt b/doc/driver-model/pci-info.txt
index 63efcb7b92f8d1bd80e286482d76fb9e763fb343..cf69167bd171b0b6203642ef7c3530f06fae79a5 100644 (file)
--- a/doc/driver-model/pci-info.txt
+++ b/doc/driver-model/pci-info.txt
@@ -6,7 +6,7 @@ How busses are scanned
 
 Any config read will end up at pci_read_config(). This uses
 uclass_get_device_by_seq() to get the PCI bus for a particular bus number.
-Bus number 0 will need to  be requested first, and the alias in the device
+Bus number 0 will need to be requested first, and the alias in the device
 tree file will point to the correct device:
 
 
@@ -23,7 +23,7 @@ tree file will point to the correct device:
 If there is no alias the devices will be numbered sequentially in the device
 tree.
 
-The call to uclass_get_device by seq() will cause the PCI bus to be probed.
+The call to uclass_get_device() will cause the PCI bus to be probed.
 This does a scan of the bus to locate available devices. These devices are
 bound to their appropriate driver if available. If there is no driver, then
 they are bound to a generic PCI driver which does nothing.
@@ -32,7 +32,7 @@ After probing a bus, the available devices will appear in the device tree
 under that bus.
 
 Note that this is all done on a lazy basis, as needed, so until something is
-touched on PCI it will not be probed.
+touched on PCI (eg: a call to pci_find_devices()) it will not be probed.
 
 PCI devices can appear in the device tree. If they do this serves to specify
 the driver to use for the device. In this case they will be bound at

diff --git a/drivers/core/uclass.c b/drivers/core/uclass.c
index aba98801fd4505b269f3aecf6ac454c3f21bff86..ffe69956d591c058e3a4410f5a1bbee71a63eec0 100644 (file)
--- a/drivers/core/uclass.c
+++ b/drivers/core/uclass.c
@@ -153,6 +153,8 @@ int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
        ret = uclass_get(id, &uc);
        if (ret)
                return ret;
+       if (list_empty(&uc->dev_head))
+               return -ENODEV;
 
        list_for_each_entry(dev, &uc->dev_head, uclass_node) {
                if (!index--) {

diff --git a/drivers/gpio/intel_ich6_gpio.c b/drivers/gpio/intel_ich6_gpio.c
index 8a108f3805a0b7929ea69dfdde3cf72784006b34..cb408a413e647c2861af3d600768d75a1b198895 100644 (file)
--- a/drivers/gpio/intel_ich6_gpio.c
+++ b/drivers/gpio/intel_ich6_gpio.c
@@ -35,6 +35,8 @@
 #include <asm/io.h>
 #include <asm/pci.h>
 
+DECLARE_GLOBAL_DATA_PTR;
+
 #define GPIO_PER_BANK  32
 
 struct ich6_bank_priv {

diff --git a/drivers/pci/pci-uclass.c b/drivers/pci/pci-uclass.c
index c7d93f92d6f7259682591ebb8cb05d9622f01a40..6262f352c999206cdf8681560e48b60a67718f6a 100644 (file)
--- a/drivers/pci/pci-uclass.c
+++ b/drivers/pci/pci-uclass.c
@@ -641,10 +641,6 @@ static int pci_uclass_post_probe(struct udevice *bus)
 {
        int ret;
 
-       /* Don't scan buses before relocation */
-       if (!(gd->flags & GD_FLG_RELOC))
-               return 0;
-
        debug("%s: probing bus %d\n", __func__, bus->seq);
        ret = pci_bind_bus_devices(bus);
        if (ret)

diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index df50b480035f4bf14c62b81422f3f532957f19a7..645ecd423f8fa72a62cb0412b1f8c0cbe301c7cf 100644 (file)
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -269,7 +269,8 @@ int pci_hose_config_device(struct pci_controller *hose,
        /* Disable interrupt line, if device says it wants to use interrupts */
        pci_hose_read_config_byte(hose, dev, PCI_INTERRUPT_PIN, &pin);
        if (pin != 0) {
-               pci_hose_write_config_byte(hose, dev, PCI_INTERRUPT_LINE, 0xff);
+               pci_hose_write_config_byte(hose, dev, PCI_INTERRUPT_LINE,
+                                          PCI_INTERRUPT_LINE_DISABLE);
        }
 
        pci_hose_read_config_dword(hose, dev, PCI_COMMAND, &old_command);

diff --git a/drivers/pci/pci_auto.c b/drivers/pci/pci_auto.c
index a7af8cb5f1751c418715486627ae597c77d77668..41d5447f122b129b65adc1b25484657663e601d4 100644 (file)
--- a/drivers/pci/pci_auto.c
+++ b/drivers/pci/pci_auto.c
@@ -14,12 +14,6 @@
 #include <errno.h>
 #include <pci.h>
 
-#ifdef DEBUG
-#define DEBUGF(x...) printf(x)
-#else
-#define DEBUGF(x...)
-#endif /* DEBUG */
-
 /* the user can define CONFIG_SYS_PCI_CACHE_LINE_SIZE to avoid problems */
 #ifndef CONFIG_SYS_PCI_CACHE_LINE_SIZE
 #define CONFIG_SYS_PCI_CACHE_LINE_SIZE 8
@@ -50,20 +44,21 @@ int pciauto_region_allocate(struct pci_region *res, pci_size_t size,
        pci_addr_t addr;
 
        if (!res) {
-               DEBUGF("No resource");
+               debug("No resource");
                goto error;
        }
 
        addr = ((res->bus_lower - 1) | (size - 1)) + 1;
 
        if (addr - res->bus_start + size > res->size) {
-               DEBUGF("No room in resource");
+               debug("No room in resource");
                goto error;
        }
 
        res->bus_lower = addr + size;
 
-       DEBUGF("address=0x%llx bus_lower=0x%llx", (u64)addr, (u64)res->bus_lower);
+       debug("address=0x%llx bus_lower=0x%llx", (unsigned long long)addr,
+             (unsigned long long)res->bus_lower);
 
        *bar = addr;
        return 0;
@@ -87,9 +82,9 @@ void pciauto_setup_device(struct pci_controller *hose,
        pci_size_t bar_size;
        u16 cmdstat = 0;
        int bar, bar_nr = 0;
+#ifndef CONFIG_PCI_ENUM_ONLY
        u8 header_type;
        int rom_addr;
-#ifndef CONFIG_PCI_ENUM_ONLY
        pci_addr_t bar_value;
        struct pci_region *bar_res;
        int found_mem64 = 0;
@@ -122,7 +117,8 @@ void pciauto_setup_device(struct pci_controller *hose,
                        bar_res = io;
 #endif
 
-                       DEBUGF("PCI Autoconfig: BAR %d, I/O, size=0x%llx, ", bar_nr, (u64)bar_size);
+                       debug("PCI Autoconfig: BAR %d, I/O, size=0x%llx, ",
+                             bar_nr, (unsigned long long)bar_size);
                } else {
                        if ((bar_response & PCI_BASE_ADDRESS_MEM_TYPE_MASK) ==
                             PCI_BASE_ADDRESS_MEM_TYPE_64) {
@@ -152,7 +148,9 @@ void pciauto_setup_device(struct pci_controller *hose,
                                bar_res = mem;
 #endif
 
-                       DEBUGF("PCI Autoconfig: BAR %d, Mem, size=0x%llx, ", bar_nr, (u64)bar_size);
+                       debug("PCI Autoconfig: BAR %d, %s, size=0x%llx, ",
+                             bar_nr, bar_res == prefetch ? "Prf" : "Mem",
+                             (unsigned long long)bar_size);
                }
 
 #ifndef CONFIG_PCI_ENUM_ONLY
@@ -179,11 +177,12 @@ void pciauto_setup_device(struct pci_controller *hose,
                cmdstat |= (bar_response & PCI_BASE_ADDRESS_SPACE) ?
                        PCI_COMMAND_IO : PCI_COMMAND_MEMORY;
 
-               DEBUGF("\n");
+               debug("\n");
 
                bar_nr++;
        }
 
+#ifndef CONFIG_PCI_ENUM_ONLY
        /* Configure the expansion ROM address */
        pci_hose_read_config_byte(hose, dev, PCI_HEADER_TYPE, &header_type);
        if (header_type != PCI_HEADER_TYPE_CARDBUS) {
@@ -193,16 +192,18 @@ void pciauto_setup_device(struct pci_controller *hose,
                pci_hose_read_config_dword(hose, dev, rom_addr, &bar_response);
                if (bar_response) {
                        bar_size = -(bar_response & ~1);
-                       DEBUGF("PCI Autoconfig: ROM, size=%#x, ", bar_size);
+                       debug("PCI Autoconfig: ROM, size=%#x, ",
+                             (unsigned int)bar_size);
                        if (pciauto_region_allocate(mem, bar_size,
                                                    &bar_value) == 0) {
                                pci_hose_write_config_dword(hose, dev, rom_addr,
                                                            bar_value);
                        }
                        cmdstat |= PCI_COMMAND_MEMORY;
-                       DEBUGF("\n");
+                       debug("\n");
                }
        }
+#endif
 
        pci_hose_write_config_word(hose, dev, PCI_COMMAND, cmdstat);
        pci_hose_write_config_byte(hose, dev, PCI_CACHE_LINE_SIZE,
@@ -411,7 +412,7 @@ void pciauto_config_init(struct pci_controller *hose)
        if (hose->pci_mem) {
                pciauto_region_init(hose->pci_mem);
 
-               DEBUGF("PCI Autoconfig: Bus Memory region: [0x%llx-0x%llx],\n"
+               debug("PCI Autoconfig: Bus Memory region: [0x%llx-0x%llx],\n"
                       "\t\tPhysical Memory [%llx-%llxx]\n",
                    (u64)hose->pci_mem->bus_start,
                    (u64)(hose->pci_mem->bus_start + hose->pci_mem->size - 1),
@@ -422,7 +423,7 @@ void pciauto_config_init(struct pci_controller *hose)
        if (hose->pci_prefetch) {
                pciauto_region_init(hose->pci_prefetch);
 
-               DEBUGF("PCI Autoconfig: Bus Prefetchable Mem: [0x%llx-0x%llx],\n"
+               debug("PCI Autoconfig: Bus Prefetchable Mem: [0x%llx-0x%llx],\n"
                       "\t\tPhysical Memory [%llx-%llx]\n",
                    (u64)hose->pci_prefetch->bus_start,
                    (u64)(hose->pci_prefetch->bus_start +
@@ -435,7 +436,7 @@ void pciauto_config_init(struct pci_controller *hose)
        if (hose->pci_io) {
                pciauto_region_init(hose->pci_io);
 
-               DEBUGF("PCI Autoconfig: Bus I/O region: [0x%llx-0x%llx],\n"
+               debug("PCI Autoconfig: Bus I/O region: [0x%llx-0x%llx],\n"
                       "\t\tPhysical Memory: [%llx-%llx]\n",
                    (u64)hose->pci_io->bus_start,
                    (u64)(hose->pci_io->bus_start + hose->pci_io->size - 1),
@@ -475,8 +476,8 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev)
 
        switch (class) {
        case PCI_CLASS_BRIDGE_PCI:
-               DEBUGF("PCI Autoconfig: Found P2P bridge, device %d\n",
-                      PCI_DEV(dev));
+               debug("PCI Autoconfig: Found P2P bridge, device %d\n",
+                     PCI_DEV(dev));
 
                pciauto_setup_device(hose, dev, 2, pci_mem,
                                     pci_prefetch, pci_io);
@@ -512,8 +513,8 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev)
                pciauto_setup_device(hose, dev, 0, pci_mem,
                                     pci_prefetch, pci_io);
 
-               DEBUGF("PCI Autoconfig: Found P2CardBus bridge, device %d\n",
-                       PCI_DEV(dev));
+               debug("PCI Autoconfig: Found P2CardBus bridge, device %d\n",
+                     PCI_DEV(dev));
 
 #ifndef CONFIG_DM_PCI
                hose->current_busno++;
@@ -522,8 +523,8 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev)
 
 #if defined(CONFIG_PCIAUTO_SKIP_HOST_BRIDGE)
        case PCI_CLASS_BRIDGE_OTHER:
-               DEBUGF("PCI Autoconfig: Skipping bridge device %d\n",
-                      PCI_DEV(dev));
+               debug("PCI Autoconfig: Skipping bridge device %d\n",
+                     PCI_DEV(dev));
                break;
 #endif
 #if defined(CONFIG_MPC834x) && !defined(CONFIG_VME8349)
@@ -534,14 +535,14 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev)
                 * device claiming resources io/mem/irq.. we only allow for
                 * the PIMMR window to be allocated (BAR0 - 1MB size)
                 */
-               DEBUGF("PCI Autoconfig: Broken bridge found, only minimal config\n");
+               debug("PCI Autoconfig: Broken bridge found, only minimal config\n");
                pciauto_setup_device(hose, dev, 0, hose->pci_mem,
                        hose->pci_prefetch, hose->pci_io);
                break;
 #endif
 
        case PCI_CLASS_PROCESSOR_POWERPC: /* an agent or end-point */
-               DEBUGF("PCI AutoConfig: Found PowerPC device\n");
+               debug("PCI AutoConfig: Found PowerPC device\n");
 
        default:
                pciauto_setup_device(hose, dev, 6, pci_mem,

diff --git a/drivers/pci/pci_compat.c b/drivers/pci/pci_compat.c
index 05c35105ab421568e4441c2f8f5d5edccefc5d80..712c48f28f46220c2e7088282e5a53b2e756d7f9 100644 (file)
--- a/drivers/pci/pci_compat.c
+++ b/drivers/pci/pci_compat.c
@@ -5,7 +5,6 @@
  *
  * SPDX-License-Identifier:    GPL-2.0+
  */
-#define DEBUG
 #include <common.h>
 #include <dm.h>
 #include <errno.h>

diff --git a/drivers/pci/pci_rom.c b/drivers/pci/pci_rom.c
index a33efae2636a4593fdb366bd5c62a91e58cb506b..26db3ca0a1344c7b928168ff301be507cfff695b 100644 (file)
--- a/drivers/pci/pci_rom.c
+++ b/drivers/pci/pci_rom.c
@@ -235,6 +235,10 @@ void setup_video(struct screen_info *screen_info)
 #ifdef CONFIG_FRAMEBUFFER_SET_VESA_MODE
        struct vesa_mode_info *vesa = &mode_info.vesa;
 
+       /* Sanity test on VESA parameters */
+       if (!vesa->x_resolution || !vesa->y_resolution)
+               return;
+
        screen_info->orig_video_isVGA = VIDEO_TYPE_VLFB;
 
        screen_info->lfb_width = vesa->x_resolution;

diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 4829284216c2fcb6eb5b280ce62163b496008da4..b5a91b707ed72374d7ebf3a0beb9f6f31379a006 100644 (file)
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -44,6 +44,15 @@ config DEBUG_UART_NS16550
          will need to provide parameters to make this work. The driver will
          be available until the real driver model serial is running.
 
+config DEBUG_EFI_CONSOLE
+       bool "EFI"
+       depends on EFI_APP
+       help
+         Select this to enable a debug console which calls back to EFI to
+         output to the console. This can be useful for early debugging of
+         U-Boot when running on top of EFI (Extensive Firmware Interface).
+         This is a type of BIOS used by PCs.
+
 endchoice
 
 config DEBUG_UART_BASE
@@ -102,3 +111,13 @@ config UNIPHIER_SERIAL
        help
          If you have a UniPhier based board and want to use the on-chip
          serial ports, say Y to this option. If unsure, say N.
+
+config X86_SERIAL
+       bool "Support for 16550 serial port on x86 machines"
+       depends on X86
+       default y
+       help
+         Most x86 machines have a ns16550 UART or compatible. This can be
+         enabled in the device tree with the correct input clock frequency
+         provided (default 1843200). Enable this to obtain serial console
+         output.

diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index d183eedbcb3f8598c82968092c6bf493208b1f23..1d1f0361cd71a40bf0585a0a2216945a977cdc68 100644 (file)
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_ALTERA_JTAG_UART) += altera_jtag_uart.o
 obj-$(CONFIG_ARM_DCC) += arm_dcc.o
 obj-$(CONFIG_ATMEL_USART) += atmel_usart.o
 obj-$(CONFIG_DW_SERIAL) += serial_dw.o
+obj-$(CONFIG_EFI_APP) += serial_efi.o
 obj-$(CONFIG_LPC32XX_HSUART) += lpc32xx_hsuart.o
 obj-$(CONFIG_MCFUART) += mcfuart.o
 obj-$(CONFIG_OPENCORES_YANU) += opencores_yanu.o

diff --git a/drivers/serial/serial-uclass.c b/drivers/serial/serial-uclass.c
index 815fec32646924c2c8000cbb25798cd6b227460a..bbc366b32283d9b29320a714063705de934c8db6 100644 (file)
--- a/drivers/serial/serial-uclass.c
+++ b/drivers/serial/serial-uclass.c
@@ -71,7 +71,7 @@ static void serial_find_console_or_panic(void)
 #endif
                if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
                    !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) ||
-                   (!uclass_first_device(UCLASS_SERIAL, &dev) || dev)) {
+                   (!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) {
                        gd->cur_serial_dev = dev;
                        return;
                }

diff --git a/drivers/serial/serial_efi.c b/drivers/serial/serial_efi.c
new file mode 100644 (file)
index 0000000..cf57d89
--- /dev/null
+++ b/drivers/serial/serial_efi.c
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ * Written by Simon Glass <sjg@chromium.org>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <debug_uart.h>
+#include <dm.h>
+#include <efi.h>
+#include <efi_api.h>
+#include <errno.h>
+#include <fdtdec.h>
+#include <linux/compiler.h>
+#include <asm/io.h>
+#include <serial.h>
+
+/* Information about the efi console */
+struct serial_efi_priv {
+       struct efi_simple_input_interface *con_in;
+       struct efi_simple_text_output_protocol *con_out;
+       struct efi_input_key key;
+       bool have_key;
+};
+
+int serial_efi_setbrg(struct udevice *dev, int baudrate)
+{
+       return 0;
+}
+
+static int serial_efi_get_key(struct serial_efi_priv *priv)
+{
+       int ret;
+
+       if (priv->have_key)
+               return 0;
+       ret = priv->con_in->read_key_stroke(priv->con_in, &priv->key);
+       if (ret == EFI_NOT_READY)
+               return -EAGAIN;
+       else if (ret != EFI_SUCCESS)
+               return -EIO;
+
+       priv->have_key = true;
+
+       return 0;
+}
+
+static int serial_efi_getc(struct udevice *dev)
+{
+       struct serial_efi_priv *priv = dev_get_priv(dev);
+       int ret, ch;
+
+       ret = serial_efi_get_key(priv);
+       if (ret)
+               return ret;
+
+       priv->have_key = false;
+       ch = priv->key.unicode_char;
+
+       /*
+        * Unicode char 8 (for backspace) is never returned. Instead we get a
+        * key scan code of 8. Handle this so that backspace works correctly
+        * in the U-Boot command line.
+        */
+       if (!ch && priv->key.scan_code == 8)
+               ch = 8;
+       debug(" [%x %x %x] ", ch, priv->key.unicode_char, priv->key.scan_code);
+
+       return ch;
+}
+
+static int serial_efi_putc(struct udevice *dev, const char ch)
+{
+       struct serial_efi_priv *priv = dev_get_priv(dev);
+       uint16_t ucode[2];
+       int ret;
+
+       ucode[0] = ch;
+       ucode[1] = '\0';
+       ret = priv->con_out->output_string(priv->con_out, ucode);
+       if (ret)
+               return -EIO;
+
+       return 0;
+}
+
+static int serial_efi_pending(struct udevice *dev, bool input)
+{
+       struct serial_efi_priv *priv = dev_get_priv(dev);
+       int ret;
+
+       /* We assume that EFI will stall if its output buffer fills up */
+       if (!input)
+               return 0;
+
+       ret = serial_efi_get_key(priv);
+       if (ret == -EAGAIN)
+               return 0;
+       else if (ret)
+               return ret;
+
+       return 1;
+}
+
+/*
+ * There is nothing to init here since the EFI console is already running by
+ * the time we enter U-Boot.
+ */
+void debug_uart_init(void)
+{
+}
+
+static inline void _debug_uart_putc(int ch)
+{
+       struct efi_system_table *sys_table = efi_get_sys_table();
+       uint16_t ucode[2];
+
+       ucode[0] = ch;
+       ucode[1] = '\0';
+       sys_table->con_out->output_string(sys_table->con_out, ucode);
+}
+
+DEBUG_UART_FUNCS
+
+static int serial_efi_probe(struct udevice *dev)
+{
+       struct efi_system_table *table = efi_get_sys_table();
+       struct serial_efi_priv *priv = dev_get_priv(dev);
+
+       priv->con_in = table->con_in;
+       priv->con_out = table->con_out;
+
+       return 0;
+}
+
+static const struct dm_serial_ops serial_efi_ops = {
+       .putc = serial_efi_putc,
+       .getc = serial_efi_getc,
+       .pending = serial_efi_pending,
+       .setbrg = serial_efi_setbrg,
+};
+
+static const struct udevice_id serial_efi_ids[] = {
+       { .compatible = "efi,uart" },
+       { }
+};
+
+U_BOOT_DRIVER(serial_efi) = {
+       .name   = "serial_efi",
+       .id     = UCLASS_SERIAL,
+       .of_match = serial_efi_ids,
+       .priv_auto_alloc_size = sizeof(struct serial_efi_priv),
+       .probe = serial_efi_probe,
+       .ops    = &serial_efi_ops,
+       .flags = DM_FLAG_PRE_RELOC,
+};

diff --git a/drivers/video/vesa_fb.c b/drivers/video/vesa_fb.c
index 909f8e8091a028e3b493c2fb75e92721c44f03fe..4e6d070a5fefce337b5016f1213ac525e1020ac3 100644 (file)
--- a/drivers/video/vesa_fb.c
+++ b/drivers/video/vesa_fb.c
@@ -24,6 +24,14 @@ void *video_hw_init(void)
        int ret;
 
        printf("Video: ");
+       if (!ll_boot_init()) {
+               /*
+                * If we are running from EFI or coreboot, this driver can't
+                * work.
+                */
+               printf("Not available (previous bootloader prevents it)\n");
+               return NULL;
+       }
        if (vbe_get_video_info(gdev)) {
                dev = pci_find_class(PCI_CLASS_DISPLAY_VGA << 8, 0);
                if (dev == -1) {

diff --git a/include/asm-generic/global_data.h b/include/asm-generic/global_data.h
index 7ef3e259b46b501b5dd0053e47a13e9c03684a0c..21552650025a108f4136267e4c63ea01584ea34c 100644 (file)
--- a/include/asm-generic/global_data.h
+++ b/include/asm-generic/global_data.h
@@ -104,7 +104,7 @@ typedef struct global_data {
 #endif
 
 /*
- * Global Data Flags
+ * Global Data Flags - the top 16 bits are reserved for arch-specific flags
  */
 #define GD_FLG_RELOC           0x00001 /* Code was relocated to RAM       */
 #define GD_FLG_DEVINIT         0x00002 /* Devices have been initialized   */
@@ -117,5 +117,6 @@ typedef struct global_data {
 #define GD_FLG_SERIAL_READY    0x00100 /* Pre-reloc serial console ready  */
 #define GD_FLG_FULL_MALLOC_INIT        0x00200 /* Full malloc() is ready          */
 #define GD_FLG_SPL_INIT                0x00400 /* spl_init() has been called      */
+#define GD_FLG_SKIP_RELOC      0x00800 /* Don't relocate */
 
 #endif /* __ASM_GENERIC_GBL_DATA_H */

diff --git a/include/common.h b/include/common.h
index 4566bd11111c97061856a4386e883fa53f784bab..fcc9ae7c21cf5b2ff5e2e57264bfa908f739fc99 100644 (file)
--- a/include/common.h
+++ b/include/common.h
@@ -1021,6 +1021,13 @@ int cpu_release(int nr, int argc, char * const argv[]);
        offsetof(struct structure, member) == offset, \
        "`struct " #structure "` offset for `" #member "` is not " #offset)
 
+/* Avoid using CONFIG_EFI_STUB directly as we may boot from other loaders */
+#ifdef CONFIG_EFI_STUB
+#define ll_boot_init() false
+#else
+#define ll_boot_init() true
+#endif
+
 /* Pull in stuff for the build system */
 #ifdef DO_DEPS_ONLY
 # include <environment.h>

diff --git a/include/configs/bayleybay.h b/include/configs/bayleybay.h
new file mode 100644 (file)
index 0000000..ecda4ba
--- /dev/null
+++ b/include/configs/bayleybay.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2015, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+/*
+ * board/config.h - configuration options, board specific
+ */
+
+#ifndef __CONFIG_H
+#define __CONFIG_H
+
+#include <configs/x86-common.h>
+
+#define CONFIG_SYS_MONITOR_LEN         (1 << 20)
+#define CONFIG_ARCH_MISC_INIT
+
+#define CONFIG_PCI_CONFIG_HOST_BRIDGE
+#define CONFIG_SYS_EARLY_PCI_INIT
+#define CONFIG_PCI_PNP
+#define CONFIG_E1000
+
+#define CONFIG_STD_DEVICES_SETTINGS    "stdin=serial,vga,usbkbd\0" \
+                                       "stdout=serial,vga\0" \
+                                       "stderr=serial,vga\0"
+
+#define CONFIG_SCSI_DEV_LIST           \
+       {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_VALLEYVIEW_SATA}
+
+#define CONFIG_MMC
+#define CONFIG_SDHCI
+#define CONFIG_GENERIC_MMC
+#define CONFIG_MMC_SDMA
+#define CONFIG_CMD_MMC
+
+/* BayTrail IGD support */
+#define CONFIG_VGA_AS_SINGLE_DEVICE
+
+/* Environment configuration */
+#define CONFIG_ENV_SECT_SIZE           0x1000
+#define CONFIG_ENV_OFFSET              0x006ff000
+
+#endif /* __CONFIG_H */

diff --git a/include/configs/crownbay.h b/include/configs/crownbay.h
index 6cf53a3e42a64d32d4c5b099220514df2e22a734..1ea320bcb575e89e8f89a542d24d6895b10b4f83 100644 (file)
--- a/include/configs/crownbay.h
+++ b/include/configs/crownbay.h
@@ -17,7 +17,6 @@
 #define CONFIG_BOARD_EARLY_INIT_F
 #define CONFIG_ARCH_MISC_INIT
 
-#define CONFIG_X86_SERIAL
 #define CONFIG_SMSC_LPC47M
 
 #define CONFIG_PCI_MEM_BUS             0x40000000

diff --git a/include/configs/efi-x86.h b/include/configs/efi-x86.h
new file mode 100644 (file)
index 0000000..5779cfd
--- /dev/null
+++ b/include/configs/efi-x86.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#ifndef __CONFIG_H
+#define __CONFIG_H
+
+#include <configs/x86-common.h>
+
+#undef CONFIG_CMD_SF_TEST
+
+#undef CONFIG_TPM
+#undef CONFIG_TPM_TIS_LPC
+#undef CONFIG_TPM_TIS_BASE_ADDRESS
+
+#undef CONFIG_CMD_IMLS
+
+#undef CONFIG_SYS_NS16550
+#undef CONFIG_X86_SERIAL
+#undef CONFIG_ENV_IS_IN_SPI_FLASH
+#define CONFIG_ENV_IS_NOWHERE
+#undef CONFIG_VIDEO
+#undef CONFIG_CFB_CONSOLE
+#undef CONFIG_SCSI_AHCI
+#undef CONFIG_CMD_SCSI
+#undef CONFIG_INTEL_ICH6_GPIO
+
+#define CONFIG_STD_DEVICES_SETTINGS     "stdin=usbkbd,vga,serial\0" \
+                                       "stdout=vga,serial\0" \
+                                       "stderr=vga,serial\0"
+
+#endif

diff --git a/include/configs/galileo.h b/include/configs/galileo.h
index fd89bf30ef3a3d87547cf3437113e4618d89ab1f..3c3c6e9d543e11d1244bd72901d9de598bfe52a9 100644 (file)
--- a/include/configs/galileo.h
+++ b/include/configs/galileo.h
@@ -17,8 +17,6 @@
 #define CONFIG_BOARD_EARLY_INIT_F
 #define CONFIG_ARCH_MISC_INIT
 
-#define CONFIG_X86_SERIAL
-
 /* ns16550 UART is memory-mapped in Quark SoC */
 #undef  CONFIG_SYS_NS16550_PORT_MAPPED
 

diff --git a/include/configs/minnowmax.h b/include/configs/minnowmax.h
index 4781e792f9bc899572bd405889381c2d16ef50e7..2a40d1f947f55a8d267113abdbfe71873396ac91 100644 (file)
--- a/include/configs/minnowmax.h
+++ b/include/configs/minnowmax.h
@@ -14,24 +14,10 @@
 #include <configs/x86-common.h>
 
 #define CONFIG_SYS_MONITOR_LEN         (1 << 20)
-#define CONFIG_BOARD_EARLY_INIT_F
 #define CONFIG_ARCH_EARLY_INIT_R
 
-#define CONFIG_X86_SERIAL
 #define CONFIG_SMSC_LPC47M
 
-#define CONFIG_PCI_MEM_BUS             0xd0000000
-#define CONFIG_PCI_MEM_PHYS            CONFIG_PCI_MEM_BUS
-#define CONFIG_PCI_MEM_SIZE            0x10000000
-
-#define CONFIG_PCI_PREF_BUS            0xc0000000
-#define CONFIG_PCI_PREF_PHYS           CONFIG_PCI_PREF_BUS
-#define CONFIG_PCI_PREF_SIZE           0x10000000
-
-#define CONFIG_PCI_IO_BUS              0x2000
-#define CONFIG_PCI_IO_PHYS             CONFIG_PCI_IO_BUS
-#define CONFIG_PCI_IO_SIZE             0xe000
-
 #define CONFIG_PCI_CONFIG_HOST_BRIDGE
 #define CONFIG_SYS_EARLY_PCI_INIT
 #define CONFIG_PCI_PNP

diff --git a/include/configs/qemu-x86.h b/include/configs/qemu-x86.h
index 78c296f5ad6ac3f16e41e54aafb1c7b29ec0bba7..c25e331579e65106b070c9ddc63c66969ecabd44 100644 (file)
--- a/include/configs/qemu-x86.h
+++ b/include/configs/qemu-x86.h
@@ -16,8 +16,6 @@
 #define CONFIG_SYS_MONITOR_LEN         (1 << 20)
 #define CONFIG_ARCH_MISC_INIT
 
-#define CONFIG_X86_SERIAL
-
 #define CONFIG_PCI_MEM_BUS             0xc0000000
 #define CONFIG_PCI_MEM_PHYS            CONFIG_PCI_MEM_BUS
 #define CONFIG_PCI_MEM_SIZE            0x10000000

diff --git a/include/configs/x86-chromebook.h b/include/configs/x86-chromebook.h
index 408cbb19577eb7154dd9bc4dfd8d8b18d0c37a28..2be885079e9ccc72f7f021cce26d9c4a6a8c0033 100644 (file)
--- a/include/configs/x86-chromebook.h
+++ b/include/configs/x86-chromebook.h
@@ -10,15 +10,12 @@
 
 #define CONFIG_SYS_MONITOR_LEN                 (1 << 20)
 
-#define CONFIG_DCACHE_RAM_MRC_VAR_SIZE         0x4000
 #define CONFIG_BOARD_EARLY_INIT_F
 #define CONFIG_MISC_INIT_R
 
 #define CONFIG_X86_MRC_ADDR                    0xfffa0000
 #define CONFIG_CACHE_MRC_SIZE_KB               512
 
-#define CONFIG_X86_SERIAL
-
 #define CONFIG_SCSI_DEV_LIST   \
        {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_NM10_AHCI}, \
        {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COUGARPOINT_AHCI_MOBILE}, \
@@ -45,9 +42,6 @@
 #define VIDEO_IO_OFFSET                                0
 #define CONFIG_X86EMU_RAW_IO
 
-#define CONFIG_CROS_EC
-#define CONFIG_CROS_EC_LPC
-#define CONFIG_CMD_CROS_EC
 #define CONFIG_ARCH_EARLY_INIT_R
 
 #undef CONFIG_ENV_IS_NOWHERE

diff --git a/include/dm/device.h b/include/dm/device.h
index 9fa0048bd0a4448b481071d5aae8b14c7d063898..12fd02d09a7f3abce5d36638e14167ae1445b878 100644 (file)
--- a/include/dm/device.h
+++ b/include/dm/device.h
@@ -318,6 +318,8 @@ const char *dev_get_uclass_name(struct udevice *dev);
  * @dev:       Parent device to check
  * @index:     Child index
  * @devp:      Returns pointer to device
+ * @return 0 if OK, -ENODEV if no such device, other error if the device fails
+ *        to probe
  */
 int device_get_child(struct udevice *parent, int index, struct udevice **devp);
 
@@ -413,7 +415,7 @@ int device_get_global_by_of_offset(int of_offset, struct udevice **devp);
 int device_find_first_child(struct udevice *parent, struct udevice **devp);
 
 /**
- * device_find_first_child() - Find the first child of a device
+ * device_find_next_child() - Find the next child of a device
  *
  * @devp: Pointer to previous child device on entry. Returns pointer to next
  *             child device, or NULL if none

diff --git a/include/efi.h b/include/efi.h
new file mode 100644 (file)
index 0000000..fcafda0
--- /dev/null
+++ b/include/efi.h
@@ -0,0 +1,367 @@
+/*
+ * Extensible Firmware Interface
+ * Based on 'Extensible Firmware Interface Specification' version 0.9,
+ * April 30, 1999
+ *
+ * Copyright (C) 1999 VA Linux Systems
+ * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
+ * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co.
+ *     David Mosberger-Tang <davidm@hpl.hp.com>
+ *     Stephane Eranian <eranian@hpl.hp.com>
+ *
+ * From include/linux/efi.h in kernel 4.1 with some additions/subtractions
+ */
+
+#ifndef _EFI_H
+#define _EFI_H
+
+#include <linux/string.h>
+#include <linux/types.h>
+
+#ifdef CONFIG_EFI_STUB_64BIT
+/* EFI uses the Microsoft ABI which is not the default for GCC */
+#define EFIAPI __attribute__((ms_abi))
+#else
+#define EFIAPI
+#endif
+
+struct efi_device_path;
+
+#define EFI_SUCCESS            0
+#define EFI_LOAD_ERROR         (1 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_INVALID_PARAMETER  (2 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_UNSUPPORTED                (3 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_BAD_BUFFER_SIZE    (4 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_BUFFER_TOO_SMALL   (5 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_NOT_READY          (6 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_DEVICE_ERROR       (7 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_WRITE_PROTECTED    (8 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_OUT_OF_RESOURCES   (9 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_NOT_FOUND          (14 | (1UL << (BITS_PER_LONG - 1)))
+#define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG - 1)))
+
+typedef unsigned long efi_status_t;
+typedef u64 efi_physical_addr_t;
+typedef u64 efi_virtual_addr_t;
+typedef void *efi_handle_t;
+
+#define EFI_GUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
+       ((efi_guid_t) \
+       {{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, \
+               ((a) >> 24) & 0xff, \
+               (b) & 0xff, ((b) >> 8) & 0xff, \
+               (c) & 0xff, ((c) >> 8) & 0xff, \
+               (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) } })
+
+/* Generic EFI table header */
+struct efi_table_hdr {
+       u64 signature;
+       u32 revision;
+       u32 headersize;
+       u32 crc32;
+       u32 reserved;
+};
+
+/* Enumeration of memory types introduced in UEFI */
+enum efi_mem_type {
+       EFI_RESERVED_MEMORY_TYPE,
+       /*
+        * The code portions of a loaded application.
+        * (Note that UEFI OS loaders are UEFI applications.)
+        */
+       EFI_LOADER_CODE,
+       /*
+        * The data portions of a loaded application and
+        * the default data allocation type used by an application
+        * to allocate pool memory.
+        */
+       EFI_LOADER_DATA,
+       /* The code portions of a loaded Boot Services Driver */
+       EFI_BOOT_SERVICES_CODE,
+       /*
+        * The data portions of a loaded Boot Serves Driver and
+        * the default data allocation type used by a Boot Services
+        * Driver to allocate pool memory.
+        */
+       EFI_BOOT_SERVICES_DATA,
+       /* The code portions of a loaded Runtime Services Driver */
+       EFI_RUNTIME_SERVICES_CODE,
+       /*
+        * The data portions of a loaded Runtime Services Driver and
+        * the default data allocation type used by a Runtime Services
+        * Driver to allocate pool memory.
+        */
+       EFI_RUNTIME_SERVICES_DATA,
+       /* Free (unallocated) memory */
+       EFI_CONVENTIONAL_MEMORY,
+       /* Memory in which errors have been detected */
+       EFI_UNUSABLE_MEMORY,
+       /* Memory that holds the ACPI tables */
+       EFI_ACPI_RECLAIM_MEMORY,
+       /* Address space reserved for use by the firmware */
+       EFI_ACPI_MEMORY_NVS,
+       /*
+        * Used by system firmware to request that a memory-mapped IO region
+        * be mapped by the OS to a virtual address so it can be accessed by
+        * EFI runtime services.
+        */
+       EFI_MMAP_IO,
+       /*
+        * System memory-mapped IO region that is used to translate
+        * memory cycles to IO cycles by the processor.
+        */
+       EFI_MMAP_IO_PORT,
+       /*
+        * Address space reserved by the firmware for code that is
+        * part of the processor.
+        */
+       EFI_PAL_CODE,
+
+       EFI_MAX_MEMORY_TYPE,
+       EFI_TABLE_END,  /* For efi_build_mem_table() */
+};
+
+/* Attribute values */
+enum {
+       EFI_MEMORY_UC_SHIFT     = 0,    /* uncached */
+       EFI_MEMORY_WC_SHIFT     = 1,    /* write-coalescing */
+       EFI_MEMORY_WT_SHIFT     = 2,    /* write-through */
+       EFI_MEMORY_WB_SHIFT     = 3,    /* write-back */
+       EFI_MEMORY_UCE_SHIFT    = 4,    /* uncached, exported */
+       EFI_MEMORY_WP_SHIFT     = 12,   /* write-protect */
+       EFI_MEMORY_RP_SHIFT     = 13,   /* read-protect */
+       EFI_MEMORY_XP_SHIFT     = 14,   /* execute-protect */
+       EFI_MEMORY_RUNTIME_SHIFT = 63,  /* range requires runtime mapping */
+
+       EFI_MEMORY_RUNTIME = 1ULL << EFI_MEMORY_RUNTIME_SHIFT,
+       EFI_MEM_DESC_VERSION    = 1,
+};
+
+#define EFI_PAGE_SHIFT         12
+#define EFI_PAGE_SIZE          (1UL << EFI_PAGE_SHIFT)
+
+struct efi_mem_desc {
+       u32 type;
+       u32 reserved;
+       efi_physical_addr_t physical_start;
+       efi_virtual_addr_t virtual_start;
+       u64 num_pages;
+       u64 attribute;
+};
+
+/* Allocation types for calls to boottime->allocate_pages*/
+#define EFI_ALLOCATE_ANY_PAGES         0
+#define EFI_ALLOCATE_MAX_ADDRESS       1
+#define EFI_ALLOCATE_ADDRESS           2
+#define EFI_MAX_ALLOCATE_TYPE          3
+
+/* Types and defines for Time Services */
+#define EFI_TIME_ADJUST_DAYLIGHT 0x1
+#define EFI_TIME_IN_DAYLIGHT     0x2
+#define EFI_UNSPECIFIED_TIMEZONE 0x07ff
+
+struct efi_time {
+       u16 year;
+       u8 month;
+       u8 day;
+       u8 hour;
+       u8 minute;
+       u8 second;
+       u8 pad1;
+       u32 nanosecond;
+       s16 timezone;
+       u8 daylight;
+       u8 pad2;
+};
+
+struct efi_time_cap {
+       u32 resolution;
+       u32 accuracy;
+       u8 sets_to_zero;
+};
+
+enum efi_locate_search_type {
+       all_handles,
+       by_register_notify,
+       by_protocol
+};
+
+struct efi_open_protocol_info_entry {
+       efi_handle_t agent_handle;
+       efi_handle_t controller_handle;
+       u32 attributes;
+       u32 open_count;
+};
+
+enum efi_entry_t {
+       EFIET_END,      /* Signals this is the last (empty) entry */
+       EFIET_MEMORY_MAP,
+
+       /* Number of entries */
+       EFIET_MEMORY_COUNT,
+};
+
+#define EFI_TABLE_VERSION      1
+
+/**
+ * struct efi_info_hdr - Header for the EFI info table
+ *
+ * @version:   EFI_TABLE_VERSION
+ * @hdr_size:  Size of this struct in bytes
+ * @total_size:        Total size of this header plus following data
+ * @spare:     Spare space for expansion
+ */
+struct efi_info_hdr {
+       u32 version;
+       u32 hdr_size;
+       u32 total_size;
+       u32 spare[5];
+};
+
+/**
+ * struct efi_entry_hdr - Header for a table entry
+ *
+ * @type:      enum eft_entry_t
+ * @size       size of entry bytes excluding header and padding
+ * @addr:      address of this entry (0 if it follows the header )
+ * @link:      size of entry including header and padding
+ * @spare1:    Spare space for expansion
+ * @spare2:    Spare space for expansion
+ */
+struct efi_entry_hdr {
+       u32 type;
+       u32 size;
+       u64 addr;
+       u32 link;
+       u32 spare1;
+       u64 spare2;
+};
+
+/**
+ * struct efi_entry_memmap - a memory map table passed to U-Boot
+ *
+ * @version:   EFI's memory map table version
+ * @desc_size: EFI's size of each memory descriptor
+ * @spare:     Spare space for expansion
+ * @desc:      An array of descriptors, each @desc_size bytes apart
+ */
+struct efi_entry_memmap {
+       u32 version;
+       u32 desc_size;
+       u64 spare;
+       struct efi_mem_desc desc[];
+};
+
+static inline struct efi_mem_desc *efi_get_next_mem_desc(
+               struct efi_entry_memmap *map, struct efi_mem_desc *desc)
+{
+       return (struct efi_mem_desc *)((ulong)desc + map->desc_size);
+}
+
+struct efi_priv {
+       efi_handle_t parent_image;
+       struct efi_device_path *device_path;
+       struct efi_system_table *sys_table;
+       struct efi_boot_services *boot;
+       struct efi_runtime_services *run;
+       bool use_pool_for_malloc;
+       unsigned long ram_base;
+       unsigned int image_data_type;
+       struct efi_info_hdr *info;
+       unsigned int info_size;
+       void *next_hdr;
+};
+
+/* Base address of the EFI image */
+extern char image_base[];
+
+/* Start and end of U-Boot image (for payload) */
+extern char _binary_u_boot_dtb_bin_start[], _binary_u_boot_dtb_bin_end[];
+
+/**
+ * efi_get_sys_table() - Get access to the main EFI system table
+ *
+ * @return pointer to EFI system table
+ */
+
+struct efi_system_table *efi_get_sys_table(void);
+
+/**
+ * efi_get_ram_base() - Find the base of RAM
+ *
+ * This is used when U-Boot is built as an EFI application.
+ *
+ * @return the base of RAM as known to U-Boot
+ */
+unsigned long efi_get_ram_base(void);
+
+/**
+ * efi_init() - Set up ready for use of EFI boot services
+ *
+ * @priv:      Pointer to our private EFI structure to fill in
+ * @banner:    Banner to display when starting
+ * @image:     The image handle passed to efi_main()
+ * @sys_table: The EFI system table pointer passed to efi_main()
+ */
+int efi_init(struct efi_priv *priv, const char *banner, efi_handle_t image,
+            struct efi_system_table *sys_table);
+
+/**
+ * efi_malloc() - Allocate some memory from EFI
+ *
+ * @priv:      Pointer to private EFI structure
+ * @size:      Number of bytes to allocate
+ * @retp:      Return EFI status result
+ * @return pointer to memory allocated, or NULL on error
+ */
+void *efi_malloc(struct efi_priv *priv, int size, efi_status_t *retp);
+
+/**
+ * efi_free() - Free memory allocated from EFI
+ *
+ * @priv:      Pointer to private EFI structure
+ * @ptr:       Pointer to memory to free
+ */
+void efi_free(struct efi_priv *priv, void *ptr);
+
+/**
+ * efi_puts() - Write out a string to the EFI console
+ *
+ * @priv:      Pointer to private EFI structure
+ * @str:       String to write (note this is a ASCII, not unicode)
+ */
+void efi_puts(struct efi_priv *priv, const char *str);
+
+/**
+ * efi_putc() - Write out a character to the EFI console
+ *
+ * @priv:      Pointer to private EFI structure
+ * @ch:                Character to write (note this is not unicode)
+ */
+void efi_putc(struct efi_priv *priv, const char ch);
+
+/**
+ * efi_info_get() - get an entry from an EFI table
+ *
+ * @type:      Entry type to search for
+ * @datap:     Returns pointer to entry data
+ * @sizep:     Returns pointer to entry size
+ * @return 0 if OK, -ENODATA if there is no table, -ENOENT if there is no entry
+ * of the requested type, -EPROTONOSUPPORT if the table has the wrong version
+ */
+int efi_info_get(enum efi_entry_t type, void **datap, int *sizep);
+
+/**
+ * efi_build_mem_table() - make a sorted copy of the memory table
+ *
+ * @map:       Pointer to EFI memory map table
+ * @size:      Size of table in bytes
+ * @skip_bs:   True to skip boot-time memory and merge it with conventional
+ *             memory. This will significantly reduce the number of table
+ *             entries.
+ * @return pointer to the new table. It should be freed with free() by the
+ *        caller
+ */
+void *efi_build_mem_table(struct efi_entry_memmap *map, int size, bool skip_bs);
+
+#endif /* _LINUX_EFI_H */

diff --git a/include/efi_api.h b/include/efi_api.h
new file mode 100644 (file)
index 0000000..4fd17d6
--- /dev/null
+++ b/include/efi_api.h
@@ -0,0 +1,244 @@
+/*
+ * Extensible Firmware Interface
+ * Based on 'Extensible Firmware Interface Specification' version 0.9,
+ * April 30, 1999
+ *
+ * Copyright (C) 1999 VA Linux Systems
+ * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
+ * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co.
+ *     David Mosberger-Tang <davidm@hpl.hp.com>
+ *     Stephane Eranian <eranian@hpl.hp.com>
+ *
+ * From include/linux/efi.h in kernel 4.1 with some additions/subtractions
+ */
+
+#ifndef _EFI_API_H
+#define _EFI_API_H
+
+#include <efi.h>
+
+/* EFI Boot Services table */
+struct efi_boot_services {
+       struct efi_table_hdr hdr;
+       void *raise_tpl;
+       void *restore_tpl;
+
+       efi_status_t (EFIAPI *allocate_pages)(int, int, unsigned long,
+                                             efi_physical_addr_t *);
+       efi_status_t (EFIAPI *free_pages)(efi_physical_addr_t, unsigned long);
+       efi_status_t (EFIAPI *get_memory_map)(unsigned long *memory_map_size,
+                       struct efi_mem_desc *desc, unsigned long *key,
+                       unsigned long *desc_size, u32 *desc_version);
+       efi_status_t (EFIAPI *allocate_pool)(int, unsigned long, void **);
+       efi_status_t (EFIAPI *free_pool)(void *);
+
+       void *create_event;
+       void *set_timer;
+       efi_status_t(EFIAPI *wait_for_event)(unsigned long number_of_events,
+                                            void *event, unsigned long *index);
+       void *signal_event;
+       void *close_event;
+       void *check_event;
+
+       void *install_protocol_interface;
+       void *reinstall_protocol_interface;
+       void *uninstall_protocol_interface;
+       efi_status_t (EFIAPI *handle_protocol)(efi_handle_t, efi_guid_t *,
+                                              void **);
+       void *reserved;
+       void *register_protocol_notify;
+       efi_status_t (EFIAPI *locate_handle)(
+                       enum efi_locate_search_type search_type,
+                       efi_guid_t *protocol, void *search_key,
+                       unsigned long *buffer_size, efi_handle_t *buffer);
+       efi_status_t (EFIAPI *locate_device_path)(efi_guid_t *protocol,
+                       struct efi_device_path **device_path,
+                       efi_handle_t *device);
+       void *install_configuration_table;
+
+       efi_status_t (EFIAPI *load_image)(bool boot_policiy,
+                       efi_handle_t parent_image,
+                       struct efi_device_path *file_path, void *source_buffer,
+                       unsigned long source_size, efi_handle_t *image);
+       efi_status_t (EFIAPI *start_image)(efi_handle_t handle,
+                                          unsigned long *exitdata_size,
+                                          s16 **exitdata);
+       efi_status_t (EFIAPI *exit)(efi_handle_t handle,
+                                   efi_status_t exit_status,
+                                   unsigned long exitdata_size, s16 *exitdata);
+       void *unload_image;
+       efi_status_t (EFIAPI *exit_boot_services)(efi_handle_t, unsigned long);
+
+       efi_status_t (EFIAPI *get_next_monotonic_count)(u64 *count);
+       efi_status_t (EFIAPI *stall)(unsigned long usecs);
+       void *set_watchdog_timer;
+       efi_status_t(EFIAPI *connect_controller)(efi_handle_t controller_handle,
+                       efi_handle_t *driver_image_handle,
+                       struct efi_device_path *remaining_device_path,
+                       bool recursive);
+       void *disconnect_controller;
+#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL  0x00000001
+#define EFI_OPEN_PROTOCOL_GET_PROTOCOL        0x00000002
+#define EFI_OPEN_PROTOCOL_TEST_PROTOCOL       0x00000004
+#define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008
+#define EFI_OPEN_PROTOCOL_BY_DRIVER           0x00000010
+#define EFI_OPEN_PROTOCOL_EXCLUSIVE           0x00000020
+       efi_status_t (EFIAPI *open_protocol)(efi_handle_t handle,
+                       efi_guid_t *protocol, void **interface,
+                       efi_handle_t agent_handle,
+                       efi_handle_t controller_handle, u32 attributes);
+       void *close_protocol;
+       efi_status_t(EFIAPI *open_protocol_information)(efi_handle_t handle,
+                       efi_guid_t *protocol,
+                       struct efi_open_protocol_info_entry **entry_buffer,
+                       unsigned long *entry_count);
+       efi_status_t (EFIAPI *protocols_per_handle)(efi_handle_t handle,
+                       efi_guid_t ***protocol_buffer,
+                       unsigned long *protocols_buffer_count);
+       efi_status_t (EFIAPI *locate_handle_buffer) (
+                       enum efi_locate_search_type search_type,
+                       efi_guid_t *protocol, void *search_key,
+                       unsigned long *no_handles, efi_handle_t **buffer);
+       void *locate_protocol;
+       void *install_multiple_protocol_interfaces;
+       void *uninstall_multiple_protocol_interfaces;
+       void *calculate_crc32;
+       void *copy_mem;
+       void *set_mem;
+       void *create_event_ex;
+};
+
+/* Types and defines for EFI ResetSystem */
+enum efi_reset_type {
+       EFI_RESET_COLD = 0,
+       EFI_RESET_WARM = 1,
+       EFI_RESET_SHUTDOWN = 2
+};
+
+/* EFI Runtime Services table */
+#define EFI_RUNTIME_SERVICES_SIGNATURE 0x5652453544e5552ULL
+#define EFI_RUNTIME_SERVICES_REVISION  0x00010000
+
+struct efi_runtime_services {
+       struct efi_table_hdr hdr;
+       void *get_time;
+       void *set_time;
+       void *get_wakeup_time;
+       void *set_wakeup_time;
+       void *set_virtual_address_map;
+       void *convert_pointer;
+       efi_status_t (EFIAPI *get_variable)(s16 *variable_name,
+                       efi_guid_t *vendor, u32 *attributes,
+                       unsigned long *data_size, void *data);
+       efi_status_t (EFIAPI *get_next_variable)(
+                       unsigned long *variable_name_size,
+                       s16 *variable_name, efi_guid_t *vendor);
+       efi_status_t (EFIAPI *set_variable)(s16 *variable_name,
+                       efi_guid_t *vendor, u32 attributes,
+                       unsigned long data_size, void *data);
+       void *get_next_high_mono_count;
+       void (EFIAPI *reset_system)(enum efi_reset_type reset_type,
+                                   efi_status_t reset_status,
+                                   unsigned long data_size, void *reset_data);
+       void *update_capsule;
+       void *query_capsule_caps;
+       void *query_variable_info;
+};
+
+/* EFI Configuration Table and GUID definitions */
+#define NULL_GUID \
+       EFI_GUID(0x00000000, 0x0000, 0x0000, 0x00, 0x00, \
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
+
+#define LOADED_IMAGE_PROTOCOL_GUID \
+       EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, \
+                0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
+
+struct efi_system_table {
+       struct efi_table_hdr hdr;
+       unsigned long fw_vendor;   /* physical addr of wchar_t vendor string */
+       u32 fw_revision;
+       unsigned long con_in_handle;
+       struct efi_simple_input_interface *con_in;
+       unsigned long con_out_handle;
+       struct efi_simple_text_output_protocol *con_out;
+       unsigned long stderr_handle;
+       unsigned long std_err;
+       struct efi_runtime_services *runtime;
+       struct efi_boot_services *boottime;
+       unsigned long nr_tables;
+       unsigned long tables;
+};
+
+struct efi_loaded_image {
+       u32 revision;
+       void *parent_handle;
+       struct efi_system_table *system_table;
+       void *device_handle;
+       void *file_path;
+       void *reserved;
+       u32 load_options_size;
+       void *load_options;
+       void *image_base;
+       aligned_u64 image_size;
+       unsigned int image_code_type;
+       unsigned int image_data_type;
+       unsigned long unload;
+};
+
+struct efi_device_path {
+       u8 type;
+       u8 sub_type;
+       u16 length;
+};
+
+struct simple_text_output_mode {
+       s32 max_mode;
+       s32 mode;
+       s32 attribute;
+       s32 cursor_column;
+       s32 cursor_row;
+       bool cursor_visible;
+};
+
+struct efi_simple_text_output_protocol {
+       void *reset;
+       efi_status_t (EFIAPI *output_string)(
+                       struct efi_simple_text_output_protocol *this,
+                       const unsigned short *str);
+       void *test_string;
+
+       efi_status_t(EFIAPI *query_mode)(
+                       struct efi_simple_text_output_protocol *this,
+                       unsigned long mode_number, unsigned long *columns,
+                       unsigned long *rows);
+       efi_status_t(EFIAPI *set_mode)(
+                       struct efi_simple_text_output_protocol *this,
+                       unsigned long mode_number);
+       efi_status_t(EFIAPI *set_attribute)(
+                       struct efi_simple_text_output_protocol *this,
+                       unsigned long attribute);
+       efi_status_t(EFIAPI *clear_screen) (
+                       struct efi_simple_text_output_protocol *this);
+       efi_status_t(EFIAPI *set_cursor_position) (
+                       struct efi_simple_text_output_protocol *this,
+                       unsigned long column, unsigned long row);
+       efi_status_t(EFIAPI *enable_cursor)(void *, bool enable);
+       struct simple_text_output_mode *mode;
+};
+
+struct efi_input_key {
+       u16 scan_code;
+       s16 unicode_char;
+};
+
+struct efi_simple_input_interface {
+       efi_status_t(EFIAPI *reset)(struct efi_simple_input_interface *this,
+                       bool ExtendedVerification);
+       efi_status_t(EFIAPI *read_key_stroke)(
+                       struct efi_simple_input_interface *this,
+                       struct efi_input_key *key);
+       void *wait_for_key;
+};
+
+#endif

diff --git a/include/elf.h b/include/elf.h
index 63d93416a3e1246975bd390b8990b6067c350f97..a35e085d82a3beade121accaa44b2d54268f7915 100644 (file)
--- a/include/elf.h
+++ b/include/elf.h
@@ -28,6 +28,16 @@ typedef int32_t              Elf32_Sword;    /* Signed large integer */
 typedef uint32_t       Elf32_Word;     /* Unsigned large integer */
 typedef uint16_t       Elf32_Half;     /* Unsigned medium integer */
 
+/* 64-bit ELF base types. */
+typedef uint64_t       Elf64_Addr;
+typedef uint16_t       Elf64_Half;
+typedef int16_t                Elf64_SHalf;
+typedef uint64_t       Elf64_Off;
+typedef int32_t                Elf64_Sword;
+typedef uint32_t       Elf64_Word;
+typedef uint64_t       Elf64_Xword;
+typedef int64_t                Elf64_Sxword;
+
 /* e_ident[] identification indexes */
 #define EI_MAG0                0               /* file ID */
 #define EI_MAG1                1               /* file ID */
@@ -379,6 +389,11 @@ typedef struct
        Elf32_Sword     r_addend;
 } Elf32_Rela;
 
+typedef struct {
+       Elf64_Addr r_offset;    /* Location at which to apply the action */
+       Elf64_Xword r_info;     /* index and type of relocation */
+} Elf64_Rel;
+
 /* Extract relocation info - r_info */
 #define ELF32_R_SYM(i)         ((i) >> 8)
 #define ELF32_R_TYPE(i)                ((unsigned char) (i))
@@ -431,6 +446,17 @@ typedef struct
 
 extern Elf32_Dyn       _DYNAMIC[];
 
+typedef struct {
+       Elf64_Sxword d_tag;             /* entry tag value */
+       union {
+               Elf64_Xword d_val;
+               Elf64_Addr d_ptr;
+       } d_un;
+} Elf64_Dyn;
+
+#define ELF64_R_SYM(i)                 ((i) >> 32)
+#define ELF64_R_TYPE(i)                        ((i) & 0xffffffff)
+
 /* Dynamic Array Tags - d_tag */
 #define DT_NULL                0               /* marks end of _DYNAMIC array */
 #define DT_NEEDED      1               /* string table offset of needed lib */

diff --git a/include/linux/types.h b/include/linux/types.h
index c9a8d9a8c2cc8befa9fa37b75f9615999928decb..6f75be4253786888b7717febfadc74a22afb29d3 100644 (file)
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -113,6 +113,11 @@ typedef            __s64           int64_t;
 
 #endif /* __KERNEL_STRICT_NAMES */
 
+/* this is a special 64bit data type that is 8-byte aligned */
+#define aligned_u64 __u64 __aligned(8)
+#define aligned_be64 __be64 __aligned(8)
+#define aligned_le64 __le64 __aligned(8)
+
 #if defined(CONFIG_USE_STDINT) && defined(__INT64_TYPE__)
 typedef                __UINT64_TYPE__ uint64_t;
 typedef                __UINT64_TYPE__ u_int64_t;
@@ -145,7 +150,6 @@ typedef __u64 __bitwise __be64;
 typedef __u16 __bitwise __sum16;
 typedef __u32 __bitwise __wsum;
 
-
 typedef unsigned __bitwise__   gfp_t;
 
 struct ustat {

diff --git a/include/part_efi.h b/include/part_efi.h
index d68ef3bb3741691baa1becb09f094400850bbc89..3012b91adee8f57d07ecb8892e2e786ee994bafd 100644 (file)
--- a/include/part_efi.h
+++ b/include/part_efi.h
@@ -18,6 +18,8 @@
 #ifndef _DISK_PART_EFI_H
 #define _DISK_PART_EFI_H
 
+#include <efi.h>
+
 #define MSDOS_MBR_SIGNATURE 0xAA55
 #define EFI_PMBR_OSTYPE_EFI 0xEF
 #define EFI_PMBR_OSTYPE_EFI_GPT 0xEE
@@ -29,13 +31,6 @@
 #define GPT_ENTRY_NUMBERS              128
 #define GPT_ENTRY_SIZE                 128
 
-#define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \
-       ((efi_guid_t) \
-       {{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \
-               (b) & 0xff, ((b) >> 8) & 0xff, \
-               (c) & 0xff, ((c) >> 8) & 0xff, \
-               (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})
-
 #define PARTITION_SYSTEM_GUID \
        EFI_GUID( 0xC12A7328, 0xF81F, 0x11d2, \
                0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B)

diff --git a/include/pci.h b/include/pci.h
index dce159f27760eddbf116ba12e8e423e1ab1a8a40..628ede0957b12c1c606e0fefc593b74cae230d86 100644 (file)
--- a/include/pci.h
+++ b/include/pci.h
@@ -231,6 +231,8 @@
 #define PCI_MIN_GNT            0x3e    /* 8 bits */
 #define PCI_MAX_LAT            0x3f    /* 8 bits */
 
+#define PCI_INTERRUPT_LINE_DISABLE     0xff
+
 /* Header type 1 (PCI-to-PCI bridges) */
 #define PCI_PRIMARY_BUS                0x18    /* Primary bus number */
 #define PCI_SECONDARY_BUS      0x19    /* Secondary bus number */

diff --git a/lib/Kconfig b/lib/Kconfig
index 972ac1793daa3353a0ebf8bc12a9e2a901e37117..884218a3c667f53877c84b462344cfaa1e651ef5 100644 (file)
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -98,4 +98,6 @@ config ERRNO_STR
          - if errno is null or positive number - a pointer to "Success" message
          - if errno is negative - a pointer to errno related message
 
+source lib/efi/Kconfig
+
 endmenu

diff --git a/lib/Makefile b/lib/Makefile
index fd106b91c80f0335fbdeb66a8bb4d53fb07c0900..db7d9806df88b8243d26b1a0ff89b44d9ec743da 100644 (file)
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -7,6 +7,7 @@
 
 ifndef CONFIG_SPL_BUILD
 
+obj-$(CONFIG_EFI) += efi/
 obj-$(CONFIG_RSA) += rsa/
 obj-$(CONFIG_LZMA) += lzma/
 obj-$(CONFIG_LZO) += lzo/

diff --git a/lib/efi/Kconfig b/lib/efi/Kconfig
new file mode 100644 (file)
index 0000000..919e314
--- /dev/null
+++ b/lib/efi/Kconfig
@@ -0,0 +1,54 @@
+config EFI
+       bool "Support running U-Boot from EFI"
+       depends on X86
+       help
+         U-Boot can be started from EFI on certain platforms. This allows
+         EFI to perform most of the system init and then jump to U-Boot for
+         final system boot. Another option is to run U-Boot as an EFI
+         application, with U-Boot using EFI's drivers instead of its own.
+
+choice
+       prompt "Select EFI mode to use"
+       depends on X86 && EFI
+
+config EFI_APP
+       bool "Support running as an EFI application"
+       help
+         Build U-Boot as an application which can be started from EFI. This
+         is useful for examining a platform in the early stages of porting
+         U-Boot to it. It allows only very basic functionality, such as a
+         command prompt and memory and I/O functions. Use 'reset' to return
+         to EFI.
+
+config EFI_STUB
+       bool "Support running as an EFI payload"
+
+endchoice
+
+config EFI_RAM_SIZE
+       hex "Amount of EFI RAM for U-Boot"
+       depends on EFI_APP
+       default 0x2000000
+       help
+         Set the amount of EFI RAM which is claimed by U-Boot for its own
+         use. U-Boot allocates this from EFI on start-up (along with a few
+         other smaller amounts) and it can never be increased after that.
+         It is used as the RAM size in with U-Boot.
+
+choice
+       prompt "EFI 32/64-bit selection"
+       depends on EFI_STUB
+       help
+         EFI does not support mixing 32-bit and 64-bit modes. This is a
+         significant problem because it means that you must build a stub with
+         the correct type for EFI to load it correctly. If you are using
+         32-bit EFI, select 32-bit here, else select 64-bit. Failure to do
+         this may produce no error message - it just won't start!
+
+config EFI_STUB_32BIT
+       bool "Produce a stub for running with 32-bit EFI"
+
+config EFI_STUB_64BIT
+       bool "Produce a stub for running with 64-bit EFI"
+
+endchoice

diff --git a/lib/efi/Makefile b/lib/efi/Makefile
new file mode 100644 (file)
index 0000000..e32dc14
--- /dev/null
+++ b/lib/efi/Makefile
@@ -0,0 +1,17 @@
+#
+# (C) Copyright 2015 Google, Inc
+#
+# SPDX-License-Identifier:     GPL-2.0+
+#
+
+obj-$(CONFIG_EFI_APP) += efi_app.o efi.o
+obj-$(CONFIG_EFI_STUB) += efi_info.o
+
+CFLAGS_REMOVE_efi_stub.o := -mregparm=3 \
+       $(if $(CONFIG_EFI_STUB_64BIT),-march=i386 -m32)
+CFLAGS_efi_stub.o := -fpic -fshort-wchar
+CFLAGS_REMOVE_efi.o := -mregparm=3 \
+       $(if $(CONFIG_EFI_STUB_64BIT),-march=i386 -m32)
+CFLAGS_efi.o := -fpic -fshort-wchar
+
+extra-$(CONFIG_EFI_STUB) += efi_stub.o efi.o

diff --git a/lib/efi/efi.c b/lib/efi/efi.c
new file mode 100644 (file)
index 0000000..81af27c
--- /dev/null
+++ b/lib/efi/efi.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ *
+ * EFI information obtained here:
+ * http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
+ *
+ * Common EFI functions
+ */
+
+#include <common.h>
+#include <debug_uart.h>
+#include <errno.h>
+#include <linux/err.h>
+#include <linux/types.h>
+#include <efi.h>
+#include <efi_api.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+/*
+ * Unfortunately we cannot access any code outside what is built especially
+ * for the stub. lib/string.c is already being built for the U-Boot payload
+ * so it uses the wrong compiler flags. Add our own memset() here.
+ */
+static void efi_memset(void *ptr, int ch, int size)
+{
+       char *dest = ptr;
+
+       while (size-- > 0)
+               *dest++ = ch;
+}
+
+/*
+ * Since the EFI stub cannot access most of the U-Boot code, add our own
+ * simple console output functions here. The EFI app will not use these since
+ * it can use the normal console.
+ */
+void efi_putc(struct efi_priv *priv, const char ch)
+{
+       struct efi_simple_text_output_protocol *con = priv->sys_table->con_out;
+       uint16_t ucode[2];
+
+       ucode[0] = ch;
+       ucode[1] = '\0';
+       con->output_string(con, ucode);
+}
+
+void efi_puts(struct efi_priv *priv, const char *str)
+{
+       while (*str)
+               efi_putc(priv, *str++);
+}
+
+int efi_init(struct efi_priv *priv, const char *banner, efi_handle_t image,
+            struct efi_system_table *sys_table)
+{
+       efi_guid_t loaded_image_guid = LOADED_IMAGE_PROTOCOL_GUID;
+       struct efi_boot_services *boot = sys_table->boottime;
+       struct efi_loaded_image *loaded_image;
+       int ret;
+
+       efi_memset(priv, '\0', sizeof(*priv));
+       priv->sys_table = sys_table;
+       priv->boot = sys_table->boottime;
+       priv->parent_image = image;
+       priv->run = sys_table->runtime;
+
+       efi_puts(priv, "U-Boot EFI ");
+       efi_puts(priv, banner);
+       efi_putc(priv, ' ');
+
+       ret = boot->open_protocol(priv->parent_image, &loaded_image_guid,
+                                 (void **)&loaded_image, &priv->parent_image,
+                                 NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+       if (ret) {
+               efi_puts(priv, "Failed to get loaded image protocol\n");
+               return ret;
+       }
+       priv->image_data_type = loaded_image->image_data_type;
+
+       return 0;
+}
+
+void *efi_malloc(struct efi_priv *priv, int size, efi_status_t *retp)
+{
+       struct efi_boot_services *boot = priv->boot;
+       void *buf = NULL;
+
+       *retp = boot->allocate_pool(priv->image_data_type, size, &buf);
+
+       return buf;
+}
+
+void efi_free(struct efi_priv *priv, void *ptr)
+{
+       struct efi_boot_services *boot = priv->boot;
+
+       boot->free_pool(ptr);
+}

diff --git a/lib/efi/efi_app.c b/lib/efi/efi_app.c
new file mode 100644 (file)
index 0000000..452ab5d
--- /dev/null
+++ b/lib/efi/efi_app.c
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ *
+ * EFI information obtained here:
+ * http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
+ *
+ * This file implements U-Boot running as an EFI application.
+ */
+
+#include <common.h>
+#include <debug_uart.h>
+#include <errno.h>
+#include <linux/err.h>
+#include <linux/types.h>
+#include <efi.h>
+#include <efi_api.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+static struct efi_priv *global_priv;
+
+struct efi_system_table *efi_get_sys_table(void)
+{
+       return global_priv->sys_table;
+}
+
+unsigned long efi_get_ram_base(void)
+{
+       return global_priv->ram_base;
+}
+
+static efi_status_t setup_memory(struct efi_priv *priv)
+{
+       struct efi_boot_services *boot = priv->boot;
+       efi_physical_addr_t addr;
+       efi_status_t ret;
+       int pages;
+
+       /*
+        * Use global_data_ptr instead of gd since it is an assignment. There
+        * are very few assignments to global_data in U-Boot and this makes
+        * it easier to find them.
+        */
+       global_data_ptr = efi_malloc(priv, sizeof(struct global_data), &ret);
+       if (!global_data_ptr)
+               return ret;
+       memset(gd, '\0', sizeof(*gd));
+
+       gd->malloc_base = (ulong)efi_malloc(priv, CONFIG_SYS_MALLOC_F_LEN,
+                                           &ret);
+       if (!gd->malloc_base)
+               return ret;
+       pages = CONFIG_EFI_RAM_SIZE >> 12;
+
+       /*
+        * Don't allocate any memory above 4GB. U-Boot is a 32-bit application
+        * so we want it to load below 4GB.
+        */
+       addr = 1ULL << 32;
+       ret = boot->allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
+                                  priv->image_data_type, pages, &addr);
+       if (ret) {
+               printf("(using pool %lx) ", ret);
+               priv->ram_base = (ulong)efi_malloc(priv, CONFIG_EFI_RAM_SIZE,
+                                                  &ret);
+               if (!priv->ram_base)
+                       return ret;
+               priv->use_pool_for_malloc = true;
+       } else {
+               priv->ram_base = addr;
+       }
+       gd->ram_size = pages << 12;
+
+       return 0;
+}
+
+static void free_memory(struct efi_priv *priv)
+{
+       struct efi_boot_services *boot = priv->boot;
+
+       if (priv->use_pool_for_malloc)
+               efi_free(priv, (void *)priv->ram_base);
+       else
+               boot->free_pages(priv->ram_base, gd->ram_size >> 12);
+
+       efi_free(priv, (void *)gd->malloc_base);
+       efi_free(priv, gd);
+       global_data_ptr = NULL;
+}
+
+/**
+ * efi_main() - Start an EFI image
+ *
+ * This function is called by our EFI start-up code. It handles running
+ * U-Boot. If it returns, EFI will continue. Another way to get back to EFI
+ * is via reset_cpu().
+ */
+efi_status_t efi_main(efi_handle_t image, struct efi_system_table *sys_table)
+{
+       struct efi_priv local_priv, *priv = &local_priv;
+       efi_status_t ret;
+
+       /* Set up access to EFI data structures */
+       efi_init(priv, "App", image, sys_table);
+
+       global_priv = priv;
+
+       /*
+        * Set up the EFI debug UART so that printf() works. This is
+        * implemented in the EFI serial driver, serial_efi.c. The application
+        * can use printf() freely.
+        */
+       debug_uart_init();
+
+       ret = setup_memory(priv);
+       if (ret) {
+               printf("Failed to set up memory: ret=%lx\n", ret);
+               return ret;
+       }
+
+       printf("starting\n");
+
+       board_init_f(GD_FLG_SKIP_RELOC);
+       board_init_r(NULL, 0);
+       free_memory(priv);
+
+       return EFI_SUCCESS;
+}
+
+void reset_cpu(ulong addr)
+{
+       struct efi_priv *priv = global_priv;
+
+       free_memory(priv);
+       printf("U-Boot EFI exiting\n");
+       priv->boot->exit(priv->parent_image, EFI_SUCCESS, 0, NULL);
+}

diff --git a/lib/efi/efi_info.c b/lib/efi/efi_info.c
new file mode 100644 (file)
index 0000000..0cd9a7e
--- /dev/null
+++ b/lib/efi/efi_info.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ *
+ * Access to the EFI information table
+ */
+
+#include <common.h>
+#include <efi.h>
+#include <errno.h>
+#include <mapmem.h>
+
+int efi_info_get(enum efi_entry_t type, void **datap, int *sizep)
+{
+       struct efi_entry_hdr *entry;
+       struct efi_info_hdr *info;
+       int ret;
+
+       if (!gd->arch.table)
+               return -ENODATA;
+
+       info = map_sysmem(gd->arch.table, 0);
+       if (info->version != EFI_TABLE_VERSION) {
+               ret = -EPROTONOSUPPORT;
+               goto err;
+       }
+
+       entry = (struct efi_entry_hdr *)((ulong)info + info->hdr_size);
+       while (entry->type != EFIET_END) {
+               if (entry->type == type) {
+                       if (entry->addr)
+                               *datap = map_sysmem(entry->addr, entry->size);
+                       else
+                               *datap = entry + 1;
+                       *sizep = entry->size;
+                       return 0;
+               }
+               entry = (struct efi_entry_hdr *)((ulong)entry + entry->link);
+       }
+
+       ret = -ENOENT;
+err:
+       unmap_sysmem(info);
+
+       return ret;
+}

diff --git a/lib/efi/efi_stub.c b/lib/efi/efi_stub.c
new file mode 100644 (file)
index 0000000..d4d3e49
--- /dev/null
+++ b/lib/efi/efi_stub.c
@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2015 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ *
+ * EFI information obtained here:
+ * http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
+ *
+ * Loads a payload (U-Boot) within the EFI environment. This is built as an
+ * EFI application. It can be built either in 32-bit or 64-bit mode.
+ */
+
+#include <common.h>
+#include <debug_uart.h>
+#include <efi.h>
+#include <efi_api.h>
+#include <errno.h>
+#include <ns16550.h>
+#include <asm/cpu.h>
+#include <asm/io.h>
+#include <linux/err.h>
+#include <linux/types.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+#ifndef CONFIG_X86
+/*
+ * Problem areas:
+ * - putc() uses the ns16550 address directly and assumed I/O access. Many
+ *     platforms will use memory access
+ * get_codeseg32() is only meaningful on x86
+ */
+#error "This file needs to be ported for use on architectures"
+#endif
+
+static struct efi_priv *global_priv;
+static bool use_uart;
+
+struct __packed desctab_info {
+       uint16_t limit;
+       uint64_t addr;
+       uint16_t pad;
+};
+
+/*
+ * EFI uses Unicode and we don't. The easiest way to get a sensible output
+ * function is to use the U-Boot debug UART. We use EFI's console output
+ * function where available, and assume the built-in UART after that. We rely
+ * on EFI to set up the UART for us and just bring in the functions here.
+ * This last bit is a bit icky, but it's only for debugging anyway. We could
+ * build in ns16550.c with some effort, but this is a payload loader after
+ * all.
+ *
+ * Note: We avoid using printf() so we don't need to bring in lib/vsprintf.c.
+ * That would require some refactoring since we already build this for U-Boot.
+ * Building an EFI shared library version would have to be a separate stem.
+ * That might push us to using the SPL framework to build this stub. However
+ * that would involve a round of EFI-specific changes in SPL. Worth
+ * considering if we start needing more U-Boot functionality. Note that we
+ * could then move get_codeseg32() to arch/x86/cpu/cpu.c.
+ */
+void debug_uart_init(void)
+{
+}
+
+void putc(const char ch)
+{
+       if (use_uart) {
+               NS16550_t com_port = (NS16550_t)0x3f8;
+
+               while ((inb((ulong)&com_port->lsr) & UART_LSR_THRE) == 0)
+                       ;
+               outb(ch, (ulong)&com_port->thr);
+       } else {
+               efi_putc(global_priv, ch);
+       }
+       if (ch == '\n')
+               putc('\r');
+}
+
+void puts(const char *str)
+{
+       while (*str)
+               putc(*str++);
+}
+
+static void _debug_uart_putc(int ch)
+{
+       putc(ch);
+}
+
+DEBUG_UART_FUNCS
+
+void *memcpy(void *dest, const void *src, size_t size)
+{
+       unsigned char *dptr = dest;
+       const unsigned char *ptr = src;
+       const unsigned char *end = src + size;
+
+       while (ptr < end)
+               *dptr++ = *ptr++;
+
+       return dest;
+}
+
+void *memset(void *inptr, int ch, size_t size)
+{
+       char *ptr = inptr;
+       char *end = ptr + size;
+
+       while (ptr < end)
+               *ptr++ = ch;
+
+       return ptr;
+}
+
+static void jump_to_uboot(ulong cs32, ulong addr, ulong info)
+{
+#ifdef CONFIG_EFI_STUB_32BIT
+       /*
+        * U-Boot requires these parameters in registers, not on the stack.
+        * See _x86boot_start() for this code.
+        */
+       typedef void (*func_t)(int bist, int unused, ulong info)
+               __attribute__((regparm(3)));
+
+       ((func_t)addr)(0, 0, info);
+#else
+       cpu_call32(cs32, CONFIG_SYS_TEXT_BASE, info);
+#endif
+}
+
+#ifdef CONFIG_EFI_STUB_64BIT
+static void get_gdt(struct desctab_info *info)
+{
+       asm volatile ("sgdt %0" : : "m"(*info) : "memory");
+}
+#endif
+
+static inline unsigned long read_cr3(void)
+{
+       unsigned long val;
+
+       asm volatile("mov %%cr3,%0" : "=r" (val) : : "memory");
+       return val;
+}
+
+/**
+ * get_codeseg32() - Find the code segment to use for 32-bit code
+ *
+ * U-Boot only works in 32-bit mode at present, so when booting from 64-bit
+ * EFI we must first change to 32-bit mode. To do this we need to find the
+ * correct code segment to use (an entry in the Global Descriptor Table).
+ *
+ * @return code segment GDT offset, or 0 for 32-bit EFI, -ENOENT if not found
+ */
+static int get_codeseg32(void)
+{
+       int cs32 = 0;
+
+#ifdef CONFIG_EFI_STUB_64BIT
+       struct desctab_info gdt;
+       uint64_t *ptr;
+       int i;
+
+       get_gdt(&gdt);
+       for (ptr = (uint64_t *)(unsigned long)gdt.addr, i = 0; i < gdt.limit;
+            i += 8, ptr++) {
+               uint64_t desc = *ptr;
+               uint64_t base, limit;
+
+               /*
+                * Check that the target U-Boot jump address is within the
+                * selector and that the selector is of the right type.
+                */
+               base = ((desc >> GDT_BASE_LOW_SHIFT) & GDT_BASE_LOW_MASK) |
+                       ((desc >> GDT_BASE_HIGH_SHIFT) & GDT_BASE_HIGH_MASK)
+                               << 16;
+               limit = ((desc >> GDT_LIMIT_LOW_SHIFT) & GDT_LIMIT_LOW_MASK) |
+                       ((desc >> GDT_LIMIT_HIGH_SHIFT) & GDT_LIMIT_HIGH_MASK)
+                               << 16;
+               base <<= 12;    /* 4KB granularity */
+               limit <<= 12;
+               if ((desc & GDT_PRESENT) && (desc && GDT_NOTSYS) &&
+                   !(desc & GDT_LONG) && (desc & GDT_4KB) &&
+                   (desc & GDT_32BIT) && (desc & GDT_CODE) &&
+                   CONFIG_SYS_TEXT_BASE > base &&
+                   CONFIG_SYS_TEXT_BASE + CONFIG_SYS_MONITOR_LEN < limit
+               ) {
+                       cs32 = i;
+                       break;
+               }
+       }
+
+#ifdef DEBUG
+       puts("\ngdt: ");
+       printhex8(gdt.limit);
+       puts(", addr: ");
+       printhex8(gdt.addr >> 32);
+       printhex8(gdt.addr);
+       for (i = 0; i < gdt.limit; i += 8) {
+               uint32_t *ptr = (uint32_t *)((unsigned long)gdt.addr + i);
+
+               puts("\n");
+               printhex2(i);
+               puts(": ");
+               printhex8(ptr[1]);
+               puts("  ");
+               printhex8(ptr[0]);
+       }
+       puts("\n ");
+       puts("32-bit code segment: ");
+       printhex2(cs32);
+       puts("\n ");
+
+       puts("page_table: ");
+       printhex8(read_cr3());
+       puts("\n ");
+#endif
+       if (!cs32) {
+               puts("Can't find 32-bit code segment\n");
+               return -ENOENT;
+       }
+#endif
+
+       return cs32;
+}
+
+static int setup_info_table(struct efi_priv *priv, int size)
+{
+       struct efi_info_hdr *info;
+       efi_status_t ret;
+
+       /* Get some memory for our info table */
+       priv->info_size = size;
+       info = efi_malloc(priv, priv->info_size, &ret);
+       if (ret) {
+               printhex2(ret);
+               puts(" No memory for info table: ");
+               return ret;
+       }
+
+       memset(info, '\0', sizeof(*info));
+       info->version = EFI_TABLE_VERSION;
+       info->hdr_size = sizeof(*info);
+       priv->info = info;
+       priv->next_hdr = (char *)info + info->hdr_size;
+
+       return 0;
+}
+
+static void add_entry_addr(struct efi_priv *priv, enum efi_entry_t type,
+                          void *ptr1, int size1, void *ptr2, int size2)
+{
+       struct efi_entry_hdr *hdr = priv->next_hdr;
+
+       hdr->type = type;
+       hdr->size = size1 + size2;
+       hdr->addr = 0;
+       hdr->link = ALIGN(sizeof(*hdr) + hdr->size, 16);
+       priv->next_hdr += hdr->link;
+       memcpy(hdr + 1, ptr1, size1);
+       memcpy((void *)(hdr + 1) + size1, ptr2, size2);
+       priv->info->total_size = (ulong)priv->next_hdr - (ulong)priv->info;
+}
+
+/**
+ * efi_main() - Start an EFI image
+ *
+ * This function is called by our EFI start-up code. It handles running
+ * U-Boot. If it returns, EFI will continue.
+ */
+efi_status_t efi_main(efi_handle_t image, struct efi_system_table *sys_table)
+{
+       struct efi_priv local_priv, *priv = &local_priv;
+       struct efi_boot_services *boot = sys_table->boottime;
+       struct efi_mem_desc *desc;
+       struct efi_entry_memmap map;
+       ulong key, desc_size, size;
+       efi_status_t ret;
+       u32 version;
+       int cs32;
+
+       ret = efi_init(priv, "Payload", image, sys_table);
+       if (ret) {
+               printhex2(ret); puts(" efi_init() failed\n");
+               return ret;
+       }
+       global_priv = priv;
+
+       cs32 = get_codeseg32();
+       if (cs32 < 0)
+               return EFI_UNSUPPORTED;
+
+       /* Get the memory map so we can switch off EFI */
+       size = 0;
+       ret = boot->get_memory_map(&size, NULL, &key, &desc_size, &version);
+       if (ret != EFI_BUFFER_TOO_SMALL) {
+               printhex2(BITS_PER_LONG);
+               printhex2(ret);
+               puts(" No memory map\n");
+               return ret;
+       }
+       size += 1024;   /* Since doing a malloc() may change the memory map! */
+       desc = efi_malloc(priv, size, &ret);
+       if (!desc) {
+               printhex2(ret);
+               puts(" No memory for memory descriptor: ");
+               return ret;
+       }
+       ret = setup_info_table(priv, size + 128);
+       if (ret)
+               return ret;
+
+       ret = boot->get_memory_map(&size, desc, &key, &desc_size, &version);
+       if (ret) {
+               printhex2(ret);
+               puts(" Can't get memory map\n");
+               return ret;
+       }
+
+       ret = boot->exit_boot_services(image, key);
+       if (ret) {
+               /*
+                * Unfortunately it happens that we cannot exit boot services
+                * the first time. But the second time it work. I don't know
+                * why but this seems to be a repeatable problem. To get
+                * around it, just try again.
+                */
+               printhex2(ret);
+               puts(" Can't exit boot services\n");
+               size = sizeof(desc);
+               ret = boot->get_memory_map(&size, desc, &key, &desc_size,
+                                          &version);
+               if (ret) {
+                       printhex2(ret);
+                       puts(" Can't get memory map\n");
+                       return ret;
+               }
+               ret = boot->exit_boot_services(image, key);
+               if (ret) {
+                       printhex2(ret);
+                       puts(" Can't exit boot services 2\n");
+                       return ret;
+               }
+       }
+
+       map.version = version;
+       map.desc_size = desc_size;
+       add_entry_addr(priv, EFIET_MEMORY_MAP, &map, sizeof(map), desc, size);
+       add_entry_addr(priv, EFIET_END, NULL, 0, 0, 0);
+
+       /* The EFI UART won't work now, switch to a debug one */
+       use_uart = true;
+
+       memcpy((void *)CONFIG_SYS_TEXT_BASE, _binary_u_boot_dtb_bin_start,
+              (ulong)_binary_u_boot_dtb_bin_end -
+              (ulong)_binary_u_boot_dtb_bin_start);
+
+#ifdef DEBUG
+       puts("EFI table at ");
+       printhex8((ulong)priv->info);
+       puts(" size ");
+       printhex8(priv->info->total_size);
+#endif
+       putc('\n');
+       jump_to_uboot(cs32, CONFIG_SYS_TEXT_BASE, (ulong)priv->info);
+
+       return EFI_LOAD_ERROR;
+}

diff --git a/lib/fdtdec.c b/lib/fdtdec.c
index a954051f7e108d5e5e373c6e75eea088564f9001..48667efcb5873cffce378c9f6df58f3d58a02018 100644 (file)
--- a/lib/fdtdec.c
+++ b/lib/fdtdec.c
@@ -1167,7 +1167,7 @@ int fdtdec_setup(void)
 #  else
        /* FDT is at end of image */
        gd->fdt_blob = (ulong *)&_end;
-#endif
+#  endif
 # elif defined(CONFIG_OF_HOSTFILE)
        if (sandbox_read_fdt_from_file()) {
                puts("Failed to read control FDT\n");

diff --git a/lib/initcall.c b/lib/initcall.c
index 714274415c9f2e3ab21783f3e0806c466908d84d..db7c558bde5efc9fbf03b33298936614e6a61bf3 100644 (file)
--- a/lib/initcall.c
+++ b/lib/initcall.c
@@ -6,6 +6,7 @@
 
 #include <common.h>
 #include <initcall.h>
+#include <efi.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
@@ -19,6 +20,9 @@ int initcall_run_list(const init_fnc_t init_sequence[])
 
                if (gd->flags & GD_FLG_RELOC)
                        reloc_ofs = gd->reloc_off;
+#ifdef CONFIG_EFI_APP
+               reloc_ofs = (unsigned long)image_base;
+#endif
                debug("initcall: %p", (char *)*init_fnc_ptr - reloc_ofs);
                if (gd->flags & GD_FLG_RELOC)
                        debug(" (relocated to %p)\n", (char *)*init_fnc_ptr);

diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib
index 84915d7e51dc6dfe1c77ef9e8484beb26c7a4c8f..1c949fc0eb966cb13ea1c76fe509f50a92a74494 100644 (file)
--- a/scripts/Makefile.lib
+++ b/scripts/Makefile.lib
@@ -104,8 +104,9 @@ modname_flags  = $(if $(filter 1,$(words $(modname))),\
 orig_c_flags   = $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(KBUILD_SUBDIR_CCFLAGS) \
                  $(ccflags-y) $(CFLAGS_$(basetarget).o)
 _c_flags       = $(filter-out $(CFLAGS_REMOVE_$(basetarget).o), $(orig_c_flags))
-_a_flags       = $(KBUILD_CPPFLAGS) $(KBUILD_AFLAGS) $(KBUILD_SUBDIR_ASFLAGS) \
+orig_a_flags   = $(KBUILD_CPPFLAGS) $(KBUILD_AFLAGS) $(KBUILD_SUBDIR_ASFLAGS) \
                  $(asflags-y) $(AFLAGS_$(basetarget).o)
+_a_flags       = $(filter-out $(AFLAGS_REMOVE_$(basetarget).o), $(orig_a_flags))
 _cpp_flags     = $(KBUILD_CPPFLAGS) $(cppflags-y) $(CPPFLAGS_$(@F))
 
 #

diff --git a/tools/.gitignore b/tools/.gitignore
index eb1a27e36d4b7bd319ebdada7e4c467e76601d55..ff0768030852575249de7605172e6fb083870599 100644 (file)
--- a/tools/.gitignore
+++ b/tools/.gitignore
@@ -1,6 +1,7 @@
 /atmel_pmecc_params
 /bmp_logo
 /envcrc
+/fdtgrep
 /fit_check_sign
 /fit_info
 /gen_eth_addr