diff options
122 files changed, 8325 insertions, 235 deletions
diff --git a/.gitignore b/.gitignore index a40c277105..33abbd3d07 100644 --- a/.gitignore +++ b/.gitignore @@ -48,6 +48,7 @@ /LOG /spl/ /tpl/ +/defconfig # # Generated include files @@ -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 @@ -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 e8968a7182..01ed76042f 100644 --- 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 36a601822a..d104a49730 100644 --- 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 999143e9df..d7addd8728 100644 --- 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 8a8e63e1d3..e7979254db 100644 --- 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 e86cc01115..407feb214b 100644 --- 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 a0117308ae..b1faf8ca32 100644 --- 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 9915da5bd7..610e9d9b1d 100644 --- 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 index 0000000000..c517e4a89f --- /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 74dd5a89dc..08dc473d6a 100644 --- 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 b9134cfef3..129777c717 100644 --- 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 index 0000000000..e09163715d --- /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 index 0000000000..75ba0d4844 --- /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 index 0000000000..cd3b0a982d --- /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 index 0000000000..9d9f05774a --- /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 index 0000000000..51599445ab --- /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 853c82f5a7..9217307e4a 100644 --- 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 e686b28c9c..3294a50b76 100644 --- 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 be79723a67..9a66b166fe 100644 --- 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 930d2b6c9d..64634a9229 100644 --- 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 00e585e19b..e5c1733e59 100644 --- 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 f86514ce83..71595c79fb 100644 --- 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 index 0000000000..9f8fa70f96 --- /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 index 0000000000..1f50428aa2 --- /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 index 0000000000..439e84ae3d --- /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 c26c71bcf7..fc74cd0f01 100644 --- 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 2e785fa4bf..7f16971783 100644 --- 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 82862f626d..eb0d506216 100644 --- 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 index 0000000000..f044f07537 --- /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 08284ee295..c70183ccef 100644 --- 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; @@ -212,6 +230,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 * * The kernel is uncompressed and the 64-bit entry point is expected to be diff --git a/arch/x86/include/asm/elf.h b/arch/x86/include/asm/elf.h new file mode 100644 index 0000000000..3bdcdfe70b --- /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 6cca7f5654..3fb3546e27 100644 --- 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 4d9eac676e..f7e3889df0 100644 --- 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 eb186b9fb8..cff3abc23a 100644 --- 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 e272c90eb7..766617f9aa 100644 --- 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 43489fdc1f..dcfe9ee85c 100644 --- 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 70ccf1b0b0..9da04dd875 100644 --- 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 86030cf52a..f441c84df5 100644 --- 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 index 0000000000..e0975d34d3 --- /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 index 0000000000..af4503e1c2 --- /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 index 0000000000..613af9ac8a --- /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 index 0000000000..30e5eb0c1a --- /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 index 0000000000..c5cbf4108b --- /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 index 0000000000..ede5d5676b --- /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 index 0000000000..4d6825515d --- /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 index 0000000000..5f71f2ac8a --- /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 5b256324e1..c585710824 100644 --- 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 6aeb4d461a..c6e8f73d22 100644 --- 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 d1082e1a47..20dfa815d2 100644 --- 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 b33586b54c..0d683bfc12 100644 --- 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 7f5ba2ca6f..0df1af238c 100644 --- 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 index 0000000000..6f86a48fa7 --- /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 index 0000000000..fa609ba5d2 --- /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 index 0000000000..a44c7c64be --- /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 index 0000000000..9b1e0bdb31 --- /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 index 0000000000..08958f91f6 --- /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 e777ef4409..c9181fc1bf 100644 --- 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 3d9ecf0693..f7d71c3612 100644 --- 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 index 0000000000..597228fdbc --- /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 index 0000000000..85fa51626a --- /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 index 0000000000..88b5aad634 --- /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 index 0000000000..78447965b9 --- /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 index 0000000000..a71db69be9 --- /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 f2a0b71c44..7e975f9c3a 100644 --- 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 383cae068b..c4f2c33b87 100644 --- 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 d6c1d4844d..6dc4c899bc 100644 --- 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 21be26f8e4..c7cc67c7a4 100644 --- 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 4e5a1f7808..6afe98edee 100644 --- 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 index 0000000000..c76296e725 --- /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 4719f4978b..381e6a20b6 100644 --- 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; } @@ -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 index 0000000000..7f92ead9a6 --- /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 e394dab719..b987f3f52f 100644 --- 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 340510f71a..e82c8ecf64 100644 --- 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 index 0000000000..1aa0655a17 --- /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 4b18d51738..e579c36200 100644 --- 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 index 0000000000..7c95579442 --- /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 5d712445df..af2459c7ed 100644 --- 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 598b4b1c2f..e4d8ead2ee 100644 --- 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 63efcb7b92..cf69167bd1 100644 --- 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 aba98801fd..ffe69956d5 100644 --- 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 8a108f3805..cb408a413e 100644 --- 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 c7d93f92d6..6262f352c9 100644 --- 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 df50b48003..645ecd423f 100644 --- 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 a7af8cb5f1..41d5447f12 100644 --- 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 05c35105ab..712c48f28f 100644 --- 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 a33efae263..26db3ca0a1 100644 --- 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 4829284216..b5a91b707e 100644 --- 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 d183eedbcb..1d1f0361cd 100644 --- 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 815fec3264..bbc366b322 100644 --- 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 index 0000000000..cf57d8977b --- /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 909f8e8091..4e6d070a5f 100644 --- 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 7ef3e259b4..2155265002 100644 --- 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 4566bd1111..fcc9ae7c21 100644 --- 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 index 0000000000..ecda4bae08 --- /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 6cf53a3e42..1ea320bcb5 100644 --- 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 index 0000000000..5779cfdb66 --- /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 fd89bf30ef..3c3c6e9d54 100644 --- 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 4781e792f9..2a40d1f947 100644 --- 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 78c296f5ad..c25e331579 100644 --- 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 408cbb1957..2be885079e 100644 --- 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 9fa0048bd0..12fd02d09a 100644 --- 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 index 0000000000..fcafda0b0b --- /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 index 0000000000..4fd17d6b68 --- /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 63d93416a3..a35e085d82 100644 --- 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 c9a8d9a8c2..6f75be4253 100644 --- 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 d68ef3bb37..3012b91ade 100644 --- 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 dce159f277..628ede0957 100644 --- 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 972ac1793d..884218a3c6 100644 --- 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 fd106b91c8..db7d9806df 100644 --- 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 index 0000000000..919e314a0c --- /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 index 0000000000..e32dc14f3d --- /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 index 0000000000..81af27caab --- /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 index 0000000000..452ab5d6ce --- /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 index 0000000000..0cd9a7e9c7 --- /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 index 0000000000..d4d3e49689 --- /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 a954051f7e..48667efcb5 100644 --- 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 714274415c..db7c558bde 100644 --- 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 84915d7e51..1c949fc0eb 100644 --- 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 eb1a27e36d..ff07680308 100644 --- 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 |
