diff --git a/Makefile b/Makefile
index 1560bff..1eb6821 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 2015
 PATCHLEVEL = 01
 SUBLEVEL =
-EXTRAVERSION = -rc3
+EXTRAVERSION = -rc4
 NAME =
 
 # *DOCUMENTATION*
@@ -947,7 +947,9 @@
 rom: u-boot.rom FORCE
 
 IFDTOOL=$(objtree)/tools/ifdtool
-IFDTOOL_FLAGS  = -w $(CONFIG_SYS_TEXT_BASE):$(objtree)/u-boot-dtb.bin
+IFDTOOL_FLAGS  = -f 0:$(objtree)/u-boot.dtb
+IFDTOOL_FLAGS += -m 0x$(shell $(NM) u-boot |grep _dt_ucode_base_size |cut -d' ' -f1)
+IFDTOOL_FLAGS += -U $(CONFIG_SYS_TEXT_BASE):$(objtree)/u-boot.bin
 IFDTOOL_FLAGS += -w $(CONFIG_SYS_X86_START16):$(objtree)/u-boot-x86-16bit.bin
 
 ifneq ($(CONFIG_HAVE_INTEL_ME),)
@@ -956,11 +958,19 @@
 endif
 
 ifneq ($(CONFIG_HAVE_MRC),)
-IFDTOOL_FLAGS += -w $(CONFIG_X86_MRC_START):$(srctree)/board/$(BOARDDIR)/mrc.bin
+IFDTOOL_FLAGS += -w $(CONFIG_X86_MRC_ADDR):$(srctree)/board/$(BOARDDIR)/mrc.bin
 endif
 
+ifneq ($(CONFIG_HAVE_FSP),)
+IFDTOOL_FLAGS += -w $(CONFIG_FSP_ADDR):$(srctree)/board/$(BOARDDIR)/$(CONFIG_FSP_FILE)
+endif
+
+ifneq ($(CONFIG_HAVE_CMC),)
+IFDTOOL_FLAGS += -w $(CONFIG_CMC_ADDR):$(srctree)/board/$(BOARDDIR)/$(CONFIG_CMC_FILE)
+endif
+
 ifneq ($(CONFIG_X86_OPTION_ROM_ADDR),)
-IFDTOOL_FLAGS += -w $(CONFIG_X86_OPTION_ROM_ADDR):$(srctree)/board/$(BOARDDIR)/$(CONFIG_X86_OPTION_ROM_FILENAME)
+IFDTOOL_FLAGS += -w $(CONFIG_X86_OPTION_ROM_ADDR):$(srctree)/board/$(BOARDDIR)/$(CONFIG_X86_OPTION_ROM_FILE)
 endif
 
 quiet_cmd_ifdtool = IFDTOOL $@
diff --git a/README b/README
index 4ca04d0..42ece99 100644
--- a/README
+++ b/README
@@ -1773,6 +1773,15 @@
 		regarding the non-volatile storage device. Define this to
 		the eMMC device that fastboot should use to store the image.
 
+		CONFIG_FASTBOOT_GPT_NAME
+		The fastboot "flash" command supports writing the downloaded
+		image to the Protective MBR and the Primary GUID Partition
+		Table. (Additionally, this downloaded image is post-processed
+		to generate and write the Backup GUID Partition Table.)
+		This occurs when the specified "partition name" on the
+		"fastboot flash" command line matches this value.
+		Default is GPT_ENTRY_NAME (currently "gpt") if undefined.
+
 - Journaling Flash filesystem support:
 		CONFIG_JFFS2_NAND, CONFIG_JFFS2_NAND_OFF, CONFIG_JFFS2_NAND_SIZE,
 		CONFIG_JFFS2_NAND_DEV
diff --git a/arch/arm/cpu/armv7/bcm281xx/Makefile b/arch/arm/cpu/armv7/bcm281xx/Makefile
index bd867a2..f24aeb3 100644
--- a/arch/arm/cpu/armv7/bcm281xx/Makefile
+++ b/arch/arm/cpu/armv7/bcm281xx/Makefile
@@ -10,3 +10,4 @@
 obj-y	+= clk-sdio.o
 obj-y	+= clk-bsc.o
 obj-$(CONFIG_BCM_SF2_ETH) += clk-eth.o
+obj-y	+= clk-usb-otg.o
diff --git a/arch/arm/cpu/armv7/bcm281xx/clk-bcm281xx.c b/arch/arm/cpu/armv7/bcm281xx/clk-bcm281xx.c
index d16b99f..7e25255 100644
--- a/arch/arm/cpu/armv7/bcm281xx/clk-bcm281xx.c
+++ b/arch/arm/cpu/armv7/bcm281xx/clk-bcm281xx.c
@@ -209,6 +209,10 @@
 	.gate		= SW_ONLY_GATE(0x0360, 20, 4),
 };
 
+static struct bus_clk_data usb_otg_ahb_data = {
+	.gate		= HW_SW_GATE_AUTO(0x0348, 16, 0, 1),
+};
+
 static struct bus_clk_data sdio1_ahb_data = {
 	.gate		= HW_SW_GATE_AUTO(0x0358, 16, 0, 1),
 };
@@ -331,6 +335,17 @@
  */
 
 /* KPM bus clocks */
+static struct bus_clock usb_otg_ahb_clk = {
+	.clk = {
+		.name = "usb_otg_ahb_clk",
+		.parent = &kpm_ccu_clk.clk,
+		.ops = &bus_clk_ops,
+		.ccu_clk_mgr_base = KONA_MST_CLK_BASE_ADDR,
+	},
+	.freq_tbl = master_ahb_freq_tbl,
+	.data = &usb_otg_ahb_data,
+};
+
 static struct bus_clock sdio1_ahb_clk = {
 	.clk = {
 		.name = "sdio1_ahb_clk",
@@ -541,6 +556,7 @@
 	CLK_LK(bsc2),
 	CLK_LK(bsc3),
 	/* Bus clocks */
+	CLK_LK(usb_otg_ahb),
 	CLK_LK(sdio1_ahb),
 	CLK_LK(sdio2_ahb),
 	CLK_LK(sdio3_ahb),
diff --git a/arch/arm/cpu/armv7/bcm281xx/clk-usb-otg.c b/arch/arm/cpu/armv7/bcm281xx/clk-usb-otg.c
new file mode 100644
index 0000000..1d7c5af
--- /dev/null
+++ b/arch/arm/cpu/armv7/bcm281xx/clk-usb-otg.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2014 Broadcom Corporation.
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/errno.h>
+#include <asm/arch/sysmap.h>
+#include "clk-core.h"
+
+/* Enable appropriate clocks for the USB OTG port */
+int clk_usb_otg_enable(void *base)
+{
+	char *ahbstr;
+
+	switch ((u32) base) {
+	case HSOTG_BASE_ADDR:
+		ahbstr = "usb_otg_ahb_clk";
+		break;
+	default:
+		printf("%s: base 0x%p not found\n", __func__, base);
+		return -EINVAL;
+	}
+
+	return clk_get_and_enable(ahbstr);
+}
diff --git a/arch/arm/cpu/armv7/kona-common/clk-stubs.c b/arch/arm/cpu/armv7/kona-common/clk-stubs.c
index 338e0e4..fa10802 100644
--- a/arch/arm/cpu/armv7/kona-common/clk-stubs.c
+++ b/arch/arm/cpu/armv7/kona-common/clk-stubs.c
@@ -19,3 +19,8 @@
 {
 	return 0;
 }
+
+int __weak clk_usb_otg_enable(void *base)
+{
+	return 0;
+}
diff --git a/arch/arm/include/asm/arch-bcm281xx/sysmap.h b/arch/arm/include/asm/arch-bcm281xx/sysmap.h
index 350e7f6..93ebf34 100644
--- a/arch/arm/include/asm/arch-bcm281xx/sysmap.h
+++ b/arch/arm/include/asm/arch-bcm281xx/sysmap.h
@@ -13,6 +13,8 @@
 #define ESUB_CLK_BASE_ADDR	0x38000000
 #define ESW_CONTRL_BASE_ADDR	0x38200000
 #define GPIO2_BASE_ADDR		0x35003000
+#define HSOTG_BASE_ADDR		0x3f120000
+#define HSOTG_CTRL_BASE_ADDR	0x3f130000
 #define KONA_MST_CLK_BASE_ADDR	0x3f001000
 #define KONA_SLV_CLK_BASE_ADDR	0x3e011000
 #define PMU_BSC_BASE_ADDR	0x3500d000
diff --git a/arch/arm/include/asm/arch-bcm2835/mbox.h b/arch/arm/include/asm/arch-bcm2835/mbox.h
index 0289ba6..88d2ec1 100644
--- a/arch/arm/include/asm/arch-bcm2835/mbox.h
+++ b/arch/arm/include/asm/arch-bcm2835/mbox.h
@@ -140,6 +140,7 @@
 #define BCM2835_BOARD_REV_B_REV2_f	0xf
 #define BCM2835_BOARD_REV_B_PLUS	0x10
 #define BCM2835_BOARD_REV_CM		0x11
+#define BCM2835_BOARD_REV_A_PLUS	0x12
 
 struct bcm2835_mbox_tag_get_board_rev {
 	struct bcm2835_mbox_tag_hdr tag_hdr;
diff --git a/arch/arm/include/asm/kona-common/clk.h b/arch/arm/include/asm/kona-common/clk.h
index 2c7e829..a5e2fd9 100644
--- a/arch/arm/include/asm/kona-common/clk.h
+++ b/arch/arm/include/asm/kona-common/clk.h
@@ -25,5 +25,6 @@
 struct clk *clk_get_parent(struct clk *clk);
 int clk_sdio_enable(void *base, u32 rate, u32 *actual_ratep);
 int clk_bsc_enable(void *base);
+int clk_usb_otg_enable(void *base);
 
 #endif
diff --git a/arch/arm/include/asm/semihosting.h b/arch/arm/include/asm/semihosting.h
index 74111dc..835ca7e 100644
--- a/arch/arm/include/asm/semihosting.h
+++ b/arch/arm/include/asm/semihosting.h
@@ -12,10 +12,6 @@
  * code for more information.
  */
 int smh_load(const char *fname, void *memp, int avail, int verbose);
-int smh_read(int fd, void *memp, int len);
-int smh_open(const char *fname, char *modestr);
-int smh_close(int fd);
-int smh_len_fd(int fd);
-int smh_len(const char *fname);
+long smh_len(const char *fname);
 
 #endif /* __SEMIHOSTING_H__ */
diff --git a/arch/arm/lib/semihosting.c b/arch/arm/lib/semihosting.c
index cb5dc26..fd6d857 100644
--- a/arch/arm/lib/semihosting.c
+++ b/arch/arm/lib/semihosting.c
@@ -26,9 +26,9 @@
 /*
  * Call the handler
  */
-static int smh_trap(unsigned int sysnum, void *addr)
+static long smh_trap(unsigned int sysnum, void *addr)
 {
-	register int result asm("r0");
+	register long result asm("r0");
 #if defined(CONFIG_ARM64)
 	asm volatile ("hlt #0xf000" : "=r" (result) : "0"(sysnum), "r"(addr));
 #else
@@ -39,167 +39,164 @@
 }
 
 /*
- * Open, load a file into memory, and close it. Check that the available space
- * is sufficient to store the entire file. Return the bytes actually read from
- * the file as seen by the read function. The verbose flag enables some extra
- * printing of successful read status.
+ * Open a file on the host. Mode is "r" or "rb" currently. Returns a file
+ * descriptor or -1 on error.
  */
-int smh_load(const char *fname, void *memp, int avail, int verbose)
+static long smh_open(const char *fname, char *modestr)
 {
-	int ret, fd, len;
-
-	ret = -1;
-
-	debug("%s: fname \'%s\', avail %u, memp %p\n", __func__, fname,
-	      avail, memp);
-
-	/* Open the file */
-	fd = smh_open(fname, "rb");
-	if (fd == -1)
-		return ret;
+	long fd;
+	unsigned long mode;
+	struct smh_open_s {
+		const char *fname;
+		unsigned long mode;
+		size_t len;
+	} open;
 
-	/* Get the file length */
-	ret = smh_len_fd(fd);
-	if (ret == -1) {
-		smh_close(fd);
-		return ret;
-	}
+	debug("%s: file \'%s\', mode \'%s\'\n", __func__, fname, modestr);
 
-	/* Check that the file will fit in the supplied buffer */
-	if (ret > avail) {
-		printf("%s: ERROR ret %d, avail %u\n", __func__, ret,
-		       avail);
-		smh_close(fd);
-		return ret;
+	/* Check the file mode */
+	if (!(strcmp(modestr, "r"))) {
+		mode = MODE_READ;
+	} else if (!(strcmp(modestr, "rb"))) {
+		mode = MODE_READBIN;
+	} else {
+		printf("%s: ERROR mode \'%s\' not supported\n", __func__,
+		       modestr);
+		return -1;
 	}
 
-	len = ret;
-
-	/* Read the file into the buffer */
-	ret = smh_read(fd, memp, len);
-	if (ret == 0) {
-		/* Print successful load information if requested */
-		if (verbose) {
-			printf("\n%s\n", fname);
-			printf("    0x%8p dest\n", memp);
-			printf("    0x%08x size\n", len);
-			printf("    0x%08x avail\n", avail);
-		}
-	}
+	open.fname = fname;
+	open.len = strlen(fname);
+	open.mode = mode;
 
-	/* Close the file */
-	smh_close(fd);
+	/* Open the file on the host */
+	fd = smh_trap(SYSOPEN, &open);
+	if (fd == -1)
+		printf("%s: ERROR fd %ld for file \'%s\'\n", __func__, fd,
+		       fname);
 
-	return ret;
+	return fd;
 }
 
 /*
  * Read 'len' bytes of file into 'memp'. Returns 0 on success, else failure
  */
-int smh_read(int fd, void *memp, int len)
+static long smh_read(long fd, void *memp, size_t len)
 {
-	int ret;
+	long ret;
 	struct smh_read_s {
-		int fd;
+		long fd;
 		void *memp;
-		int len;
+		size_t len;
 	} read;
 
-	debug("%s: fd %d, memp %p, len %d\n", __func__, fd, memp, len);
+	debug("%s: fd %ld, memp %p, len %lu\n", __func__, fd, memp, len);
 
 	read.fd = fd;
 	read.memp = memp;
 	read.len = len;
 
 	ret = smh_trap(SYSREAD, &read);
-	if (ret == 0) {
-		return 0;
-	} else {
+	if (ret < 0) {
 		/*
 		 * The ARM handler allows for returning partial lengths,
 		 * but in practice this never happens so rather than create
 		 * hard to maintain partial read loops and such, just fail
 		 * with an error message.
 		 */
-		printf("%s: ERROR ret %d, fd %d, len %u memp %p\n",
+		printf("%s: ERROR ret %ld, fd %ld, len %lu memp %p\n",
 		       __func__, ret, fd, len, memp);
+		return -1;
 	}
-	return ret;
+
+	return 0;
 }
 
 /*
- * Open a file on the host. Mode is "r" or "rb" currently. Returns a file
- * descriptor or -1 on error.
+ * Close the file using the file descriptor
  */
-int smh_open(const char *fname, char *modestr)
+static long smh_close(long fd)
 {
-	int ret, fd, mode;
-	struct smh_open_s {
-		const char *fname;
-		unsigned int mode;
-		unsigned int len;
-	} open;
+	long ret;
 
-	debug("%s: file \'%s\', mode \'%s\'\n", __func__, fname, modestr);
-
-	ret = -1;
+	debug("%s: fd %ld\n", __func__, fd);
 
-	/* Check the file mode */
-	if (!(strcmp(modestr, "r"))) {
-		mode = MODE_READ;
-	} else if (!(strcmp(modestr, "rb"))) {
-		mode = MODE_READBIN;
-	} else {
-		printf("%s: ERROR mode \'%s\' not supported\n", __func__,
-		       modestr);
-		return ret;
-	}
-
-	open.fname = fname;
-	open.len = strlen(fname);
-	open.mode = mode;
-
-	/* Open the file on the host */
-	fd = smh_trap(SYSOPEN, &open);
-	if (fd == -1)
-		printf("%s: ERROR fd %d for file \'%s\'\n", __func__, fd,
-		       fname);
+	ret = smh_trap(SYSCLOSE, &fd);
+	if (ret == -1)
+		printf("%s: ERROR fd %ld\n", __func__, fd);
 
-	return fd;
+	return ret;
 }
 
 /*
- * Close the file using the file descriptor
+ * Get the file length from the file descriptor
  */
-int smh_close(int fd)
+static long smh_len_fd(long fd)
 {
-	int ret;
-	long fdlong;
+	long ret;
 
-	debug("%s: fd %d\n", __func__, fd);
+	debug("%s: fd %ld\n", __func__, fd);
 
-	fdlong = (long)fd;
-	ret = smh_trap(SYSCLOSE, &fdlong);
+	ret = smh_trap(SYSFLEN, &fd);
 	if (ret == -1)
-		printf("%s: ERROR fd %d\n", __func__, fd);
+		printf("%s: ERROR ret %ld, fd %ld\n", __func__, ret, fd);
 
 	return ret;
 }
 
 /*
- * Get the file length from the file descriptor
+ * Open, load a file into memory, and close it. Check that the available space
+ * is sufficient to store the entire file. Return the bytes actually read from
+ * the file as seen by the read function. The verbose flag enables some extra
+ * printing of successful read status.
  */
-int smh_len_fd(int fd)
+int smh_load(const char *fname, void *memp, int avail, int verbose)
 {
-	int ret;
-	long fdlong;
+	long ret;
+	long fd;
+	size_t len;
 
-	debug("%s: fd %d\n", __func__, fd);
+	ret = -1;
 
-	fdlong = (long)fd;
-	ret = smh_trap(SYSFLEN, &fdlong);
-	if (ret == -1)
-		printf("%s: ERROR ret %d\n", __func__, ret);
+	debug("%s: fname \'%s\', avail %u, memp %p\n", __func__, fname,
+	      avail, memp);
+
+	/* Open the file */
+	fd = smh_open(fname, "rb");
+	if (fd == -1)
+		return -1;
+
+	/* Get the file length */
+	ret = smh_len_fd(fd);
+	if (ret == -1) {
+		smh_close(fd);
+		return -1;
+	}
+
+	/* Check that the file will fit in the supplied buffer */
+	if (ret > avail) {
+		printf("%s: ERROR ret %ld, avail %u\n", __func__, ret,
+		       avail);
+		smh_close(fd);
+		return -1;
+	}
+
+	len = ret;
+
+	/* Read the file into the buffer */
+	ret = smh_read(fd, memp, len);
+	if (ret == 0) {
+		/* Print successful load information if requested */
+		if (verbose) {
+			printf("\n%s\n", fname);
+			printf("    0x%8p dest\n", memp);
+			printf("    0x%08lx size\n", len);
+			printf("    0x%08x avail\n", avail);
+		}
+	}
+
+	/* Close the file */
+	smh_close(fd);
 
 	return ret;
 }
@@ -207,26 +204,32 @@
 /*
  * Get the file length from the filename
  */
-int smh_len(const char *fname)
+long smh_len(const char *fname)
 {
-	int ret, fd, len;
+	long ret;
+	long fd;
+	long len;
 
 	debug("%s: file \'%s\'\n", __func__, fname);
 
 	/* Open the file */
 	fd = smh_open(fname, "rb");
-	if (fd == -1)
+	if (fd < 0)
 		return fd;
 
 	/* Get the file length */
 	len = smh_len_fd(fd);
+	if (len < 0) {
+		smh_close(fd);
+		return len;
+	}
 
 	/* Close the file */
 	ret = smh_close(fd);
-	if (ret == -1)
+	if (ret < 0)
 		return ret;
 
-	debug("%s: returning len %d\n", __func__, len);
+	debug("%s: returning len %ld\n", __func__, len);
 
 	/* Return the file length (or -1 error indication) */
 	return len;
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index fdfb618..ebf72b3 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -32,6 +32,15 @@
 	  and it provides a 2560x1700 high resolution touch-enabled LCD
 	  display.
 
+config TARGET_CROWNBAY
+	bool "Support Intel Crown Bay CRB"
+	help
+	  This is the Intel Crown Bay Customer Reference Board. It contains
+	  the Intel Atom Processor E6xx populated on the COM Express module
+	  with 1GB DDR2 soldered down memory and a carrier board with the
+	  Intel Platform Controller Hub EG20T, other system components and
+	  peripheral connectors for PCIe/SATA/USB/LAN/SD/UART/Audio/LVDS.
+
 endchoice
 
 config RAMBASE
@@ -310,8 +319,12 @@
 
 source "arch/x86/cpu/ivybridge/Kconfig"
 
+source "arch/x86/cpu/queensbay/Kconfig"
+
 source "board/coreboot/coreboot/Kconfig"
 
 source "board/google/chromebook_link/Kconfig"
 
+source "board/intel/crownbay/Kconfig"
+
 endmenu
diff --git a/arch/x86/cpu/Makefile b/arch/x86/cpu/Makefile
index 7f09db5..5033d2b 100644
--- a/arch/x86/cpu/Makefile
+++ b/arch/x86/cpu/Makefile
@@ -15,6 +15,7 @@
 obj-$(CONFIG_SYS_COREBOOT) += coreboot/
 obj-$(CONFIG_NORTHBRIDGE_INTEL_SANDYBRIDGE) += ivybridge/
 obj-$(CONFIG_NORTHBRIDGE_INTEL_IVYBRIDGE) += ivybridge/
+obj-$(CONFIG_INTEL_QUEENSBAY) += queensbay/
 obj-y += lapic.o
 obj-$(CONFIG_PCI) += pci.o
 obj-y += turbo.o
diff --git a/arch/x86/cpu/ivybridge/microcode_intel.c b/arch/x86/cpu/ivybridge/microcode_intel.c
index 8c11a63..0817751 100644
--- a/arch/x86/cpu/ivybridge/microcode_intel.c
+++ b/arch/x86/cpu/ivybridge/microcode_intel.c
@@ -40,6 +40,8 @@
 	update->data = fdt_getprop(blob, node, "data", &update->size);
 	if (!update->data)
 		return -EINVAL;
+	update->data += 48;
+	update->size -= 48;
 
 	update->header_version = fdtdec_get_int(blob, node,
 						"intel,header-version", 0);
@@ -48,17 +50,17 @@
 	update->date_code = fdtdec_get_int(blob, node,
 					   "intel,date-code", 0);
 	update->processor_signature = fdtdec_get_int(blob, node,
-					"intel.processor-signature", 0);
+					"intel,processor-signature", 0);
 	update->checksum = fdtdec_get_int(blob, node, "intel,checksum", 0);
 	update->loader_revision = fdtdec_get_int(blob, node,
-						 "loader-revision", 0);
+						 "intel,loader-revision", 0);
 	update->processor_flags = fdtdec_get_int(blob, node,
-						 "processor-flags", 0);
+						 "intel,processor-flags", 0);
 
 	return 0;
 }
 
-static uint32_t microcode_read_rev(void)
+static inline uint32_t microcode_read_rev(void)
 {
 	/*
 	 * Some Intel CPUs can be very finicky about the CPUID sequence used.
@@ -114,6 +116,7 @@
 {
 	struct microcode_update cpu, update;
 	const void *blob = gd->fdt_blob;
+	int skipped;
 	int count;
 	int node;
 	int ret;
@@ -121,12 +124,13 @@
 	microcode_read_cpu(&cpu);
 	node = 0;
 	count = 0;
+	skipped = 0;
 	do {
 		node = fdtdec_next_compatible(blob, node,
 					      COMPAT_INTEL_MICROCODE);
 		if (node < 0) {
 			debug("%s: Found %d updates\n", __func__, count);
-			return count ? 0 : -ENOENT;
+			return count ? 0 : skipped ? -EEXIST : -ENOENT;
 		}
 
 		ret = microcode_decode_node(blob, node, &update);
@@ -135,12 +139,15 @@
 			      ret);
 			return ret;
 		}
-		if (update.processor_signature == cpu.processor_signature &&
-		    (update.processor_flags & cpu.processor_flags)) {
-			debug("%s: Update already exists\n", __func__);
-			return -EEXIST;
+		if (!(update.processor_signature == cpu.processor_signature &&
+		      (update.processor_flags & cpu.processor_flags))) {
+			debug("%s: Skipping non-matching update, sig=%x, pf=%x\n",
+			      __func__, update.processor_signature,
+			      update.processor_flags);
+			skipped++;
+			continue;
 		}
-
+		ret = microcode_read_rev();
 		wrmsr(0x79, (ulong)update.data, 0);
 		debug("microcode: updated to revision 0x%x date=%04x-%02x-%02x\n",
 		      microcode_read_rev(), update.date_code & 0xffff,
diff --git a/arch/x86/cpu/ivybridge/sdram.c b/arch/x86/cpu/ivybridge/sdram.c
index df2b990..b95e781 100644
--- a/arch/x86/cpu/ivybridge/sdram.c
+++ b/arch/x86/cpu/ivybridge/sdram.c
@@ -177,7 +177,7 @@
 
 	debug("PEI data at %p, size %x:\n", pei_data, sizeof(*pei_data));
 
-	data = (char *)CONFIG_X86_MRC_START;
+	data = (char *)CONFIG_X86_MRC_ADDR;
 	if (data) {
 		int rv;
 		int (*func)(struct pei_data *);
diff --git a/arch/x86/cpu/queensbay/Kconfig b/arch/x86/cpu/queensbay/Kconfig
new file mode 100644
index 0000000..f6b5201
--- /dev/null
+++ b/arch/x86/cpu/queensbay/Kconfig
@@ -0,0 +1,79 @@
+#
+# Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+#
+# SPDX-License-Identifier:	GPL-2.0+
+#
+
+config INTEL_QUEENSBAY
+	bool
+	select HAVE_FSP
+	select HAVE_CMC
+
+if INTEL_QUEENSBAY
+
+config HAVE_FSP
+	bool "Add an Firmware Support Package binary"
+	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
+	  to set up SDRAM and other chipset specific initialization.
+
+	  Note: Without this binary U-Boot will not be able to set up its
+	  SDRAM so will not boot.
+
+config FSP_FILE
+	string "Firmware Support Package binary filename"
+	depends on HAVE_FSP
+	default "fsp.bin"
+	help
+	  The filename of the file to use as Firmware Support Package binary
+	  in the board directory.
+
+config FSP_ADDR
+	hex "Firmware Support Package binary location"
+	depends on HAVE_FSP
+	default 0xfffc0000
+	help
+	  FSP is not Position Independent Code (PIC) and the whole FSP has to
+	  be rebased if it is placed at a location which is different from the
+	  perferred base address specified during the FSP build. Use Intel's
+	  Binary Configuration Tool (BCT) to do the rebase.
+
+	  The default base address of 0xfffc0000 indicates that the binary must
+	  be located at offset 0xc0000 from the beginning of a 1MB flash device.
+
+config FSP_TEMP_RAM_ADDR
+	hex
+	default 0x2000000
+	help
+	  Stack top address which is used in FspInit after DRAM is ready and
+	  CAR is disabled.
+
+config HAVE_CMC
+	bool "Add a Chipset Micro Code state machine binary"
+	help
+	  Select this option to add a Chipset Micro Code state machine binary
+	  to the resulting U-Boot image. It is a 64K data block of machine
+	  specific code which must be put in the flash for the processor to
+	  access when powered up before system BIOS is executed.
+
+config CMC_FILE
+	string "Chipset Micro Code state machine filename"
+	depends on HAVE_CMC
+	default "cmc.bin"
+	help
+	  The filename of the file to use as Chipset Micro Code state machine
+	  binary in the board directory.
+
+config CMC_ADDR
+	hex "Chipset Micro Code state machine binary location"
+	depends on HAVE_CMC
+	default 0xfffb0000
+	help
+	  The location of the CMC binary is determined by a strap. It must be
+	  put in flash at a location matching the strap-determined base address.
+
+	  The default base address of 0xfffb0000 indicates that the binary must
+	  be located at offset 0xb0000 from the beginning of a 1MB flash device.
+
+endif
diff --git a/arch/x86/cpu/queensbay/Makefile b/arch/x86/cpu/queensbay/Makefile
new file mode 100644
index 0000000..2c2ec01
--- /dev/null
+++ b/arch/x86/cpu/queensbay/Makefile
@@ -0,0 +1,9 @@
+#
+# Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+#
+# SPDX-License-Identifier:	GPL-2.0+
+#
+
+obj-y += tnc_car.o tnc_dram.o tnc.o topcliff.o
+obj-y += fsp_configs.o fsp_support.o
+obj-$(CONFIG_PCI) += tnc_pci.o
diff --git a/arch/x86/cpu/queensbay/fsp_configs.c b/arch/x86/cpu/queensbay/fsp_configs.c
index aef18fc..af28e45 100644
--- a/arch/x86/cpu/queensbay/fsp_configs.c
+++ b/arch/x86/cpu/queensbay/fsp_configs.c
@@ -8,7 +8,7 @@
 #include <common.h>
 #include <asm/arch/fsp/fsp_support.h>
 
-void update_fsp_upd(struct upd_region_t *fsp_upd)
+void update_fsp_upd(struct upd_region *fsp_upd)
 {
 	/* Override any UPD setting if required */
 
diff --git a/arch/x86/cpu/queensbay/fsp_support.c b/arch/x86/cpu/queensbay/fsp_support.c
index df3bbd0..ef1916b 100644
--- a/arch/x86/cpu/queensbay/fsp_support.c
+++ b/arch/x86/cpu/queensbay/fsp_support.c
@@ -10,67 +10,48 @@
 #include <asm/post.h>
 
 /**
- * Reads a 64-bit value from memory that may be unaligned.
- *
- * This function returns the 64-bit value pointed to by buf. The function
- * guarantees that the read operation does not produce an alignment fault.
- *
- * If the buf is NULL, then ASSERT().
- *
- * @buf: Pointer to a 64-bit value that may be unaligned.
- *
- * @return: The 64-bit value read from buf.
- */
-static u64 read_unaligned64(const u64 *buf)
-{
-	ASSERT(buf != NULL);
-
-	return *buf;
-}
-
-/**
  * Compares two GUIDs
  *
- * If the GUIDs are identical then TRUE is returned.
- * If there are any bit differences in the two GUIDs, then FALSE is returned.
- *
- * If guid1 is NULL, then ASSERT().
- * If guid2 is NULL, then ASSERT().
+ * If the GUIDs are identical then true is returned.
+ * If there are any bit differences in the two GUIDs, then false is returned.
  *
  * @guid1:        A pointer to a 128 bit GUID.
  * @guid2:        A pointer to a 128 bit GUID.
  *
- * @retval TRUE:  guid1 and guid2 are identical.
- * @retval FALSE: guid1 and guid2 are not identical.
+ * @retval true:  guid1 and guid2 are identical.
+ * @retval false: guid1 and guid2 are not identical.
  */
-static unsigned char compare_guid(const struct efi_guid_t *guid1,
-				  const struct efi_guid_t *guid2)
+static bool compare_guid(const struct efi_guid *guid1,
+			 const struct efi_guid *guid2)
 {
-	u64 guid1_low;
-	u64 guid2_low;
-	u64 guid1_high;
-	u64 guid2_high;
-
-	guid1_low  = read_unaligned64((const u64 *)guid1);
-	guid2_low  = read_unaligned64((const u64 *)guid2);
-	guid1_high = read_unaligned64((const u64 *)guid1 + 1);
-	guid2_high = read_unaligned64((const u64 *)guid2 + 1);
-
-	return (unsigned char)(guid1_low == guid2_low && guid1_high == guid2_high);
+	if (memcmp(guid1, guid2, sizeof(struct efi_guid)) == 0)
+		return true;
+	else
+		return false;
 }
 
 u32 __attribute__((optimize("O0"))) find_fsp_header(void)
 {
+	/*
+	 * This function may be called before the a stack is established,
+	 * so special care must be taken. First, it cannot declare any local
+	 * variable using stack. Only register variable can be used here.
+	 * Secondly, some compiler version will add prolog or epilog code
+	 * for the C function. If so the function call may not work before
+	 * stack is ready.
+	 *
+	 * GCC 4.8.1 has been verified to be working for the following codes.
+	 */
 	volatile register u8 *fsp asm("eax");
 
 	/* Initalize the FSP base */
-	fsp = (u8 *)CONFIG_FSP_LOCATION;
+	fsp = (u8 *)CONFIG_FSP_ADDR;
 
 	/* Check the FV signature, _FVH */
-	if (((struct fv_header_t *)fsp)->sign == 0x4856465F) {
+	if (((struct fv_header *)fsp)->sign == EFI_FVH_SIGNATURE) {
 		/* Go to the end of the FV header and align the address */
-		fsp += ((struct fv_header_t *)fsp)->ext_hdr_off;
-		fsp += ((struct fv_ext_header_t *)fsp)->ext_hdr_size;
+		fsp += ((struct fv_header *)fsp)->ext_hdr_off;
+		fsp += ((struct fv_ext_header *)fsp)->ext_hdr_size;
 		fsp  = (u8 *)(((u32)fsp + 7) & 0xFFFFFFF8);
 	} else {
 		fsp  = 0;
@@ -78,20 +59,27 @@
 
 	/* Check the FFS GUID */
 	if (fsp &&
-	    (((u32 *)&(((struct ffs_file_header_t *)fsp)->name))[0] == 0x912740BE) &&
-	    (((u32 *)&(((struct ffs_file_header_t *)fsp)->name))[1] == 0x47342284) &&
-	    (((u32 *)&(((struct ffs_file_header_t *)fsp)->name))[2] == 0xB08471B9) &&
-	    (((u32 *)&(((struct ffs_file_header_t *)fsp)->name))[3] == 0x0C3F3527)) {
+	    ((struct ffs_file_header *)fsp)->name.data1 == FSP_GUID_DATA1 &&
+	    ((struct ffs_file_header *)fsp)->name.data2 == FSP_GUID_DATA2 &&
+	    ((struct ffs_file_header *)fsp)->name.data3 == FSP_GUID_DATA3 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[0] == FSP_GUID_DATA4_0 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[1] == FSP_GUID_DATA4_1 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[2] == FSP_GUID_DATA4_2 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[3] == FSP_GUID_DATA4_3 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[4] == FSP_GUID_DATA4_4 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[5] == FSP_GUID_DATA4_5 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[6] == FSP_GUID_DATA4_6 &&
+	    ((struct ffs_file_header *)fsp)->name.data4[7] == FSP_GUID_DATA4_7) {
 		/* Add the FFS header size to find the raw section header */
-		fsp += sizeof(struct ffs_file_header_t);
+		fsp += sizeof(struct ffs_file_header);
 	} else {
 		fsp = 0;
 	}
 
 	if (fsp &&
-	    ((struct raw_section_t *)fsp)->type == EFI_SECTION_RAW) {
+	    ((struct raw_section *)fsp)->type == EFI_SECTION_RAW) {
 		/* Add the raw section header size to find the FSP header */
-		fsp += sizeof(struct raw_section_t);
+		fsp += sizeof(struct raw_section);
 	} else {
 		fsp = 0;
 	}
@@ -99,7 +87,7 @@
 	return (u32)fsp;
 }
 
-void fsp_continue(struct shared_data_t *shared_data, u32 status, void *hob_list)
+void fsp_continue(struct shared_data *shared_data, u32 status, void *hob_list)
 {
 	u32 stack_len;
 	u32 stack_base;
@@ -107,18 +95,18 @@
 
 	post_code(POST_MRC);
 
-	ASSERT(status == 0);
+	assert(status == 0);
 
 	/* Get the migrated stack in normal memory */
-	stack_base = (u32)get_bootloader_tmp_mem(hob_list, &stack_len);
-	ASSERT(stack_base != 0);
+	stack_base = (u32)fsp_get_bootloader_tmp_mem(hob_list, &stack_len);
+	assert(stack_base != 0);
 	stack_top  = stack_base + stack_len - sizeof(u32);
 
 	/*
 	 * Old stack base is stored at the very end of the stack top,
 	 * use it to calculate the migrated shared data base
 	 */
-	shared_data = (struct shared_data_t *)(stack_base +
+	shared_data = (struct shared_data *)(stack_base +
 			((u32)shared_data - *(u32 *)stack_top));
 
 	/* The boot loader main function entry */
@@ -127,50 +115,50 @@
 
 void fsp_init(u32 stack_top, u32 boot_mode, void *nvs_buf)
 {
-	struct shared_data_t shared_data;
+	struct shared_data shared_data;
 	fsp_init_f init;
-	struct fsp_init_params_t params;
-	struct fspinit_rtbuf_t rt_buf;
-	struct vpd_region_t *fsp_vpd;
-	struct fsp_header_t *fsp_hdr;
-	struct fsp_init_params_t *params_ptr;
-	struct upd_region_t *fsp_upd;
+	struct fsp_init_params params;
+	struct fspinit_rtbuf rt_buf;
+	struct vpd_region *fsp_vpd;
+	struct fsp_header *fsp_hdr;
+	struct fsp_init_params *params_ptr;
+	struct upd_region *fsp_upd;
 
-	fsp_hdr = (struct fsp_header_t *)find_fsp_header();
+	fsp_hdr = (struct fsp_header *)find_fsp_header();
 	if (fsp_hdr == NULL) {
 		/* No valid FSP info header was found */
-		ASSERT(FALSE);
+		panic("Invalid FSP header");
 	}
 
-	fsp_upd = (struct upd_region_t *)&shared_data.fsp_upd;
-	memset((void *)&rt_buf, 0, sizeof(struct fspinit_rtbuf_t));
+	fsp_upd = (struct upd_region *)&shared_data.fsp_upd;
+	memset(&rt_buf, 0, sizeof(struct fspinit_rtbuf));
 
 	/* Reserve a gap in stack top */
 	rt_buf.common.stack_top = (u32 *)stack_top - 32;
 	rt_buf.common.boot_mode = boot_mode;
-	rt_buf.common.upd_data = (struct upd_region_t *)fsp_upd;
+	rt_buf.common.upd_data = (struct upd_region *)fsp_upd;
 
 	/* Get VPD region start */
-	fsp_vpd = (struct vpd_region_t *)(fsp_hdr->img_base +
+	fsp_vpd = (struct vpd_region *)(fsp_hdr->img_base +
 			fsp_hdr->cfg_region_off);
 
 	/* Verifify the VPD data region is valid */
-	ASSERT((fsp_vpd->img_rev == VPD_IMAGE_REV) &&
+	assert((fsp_vpd->img_rev == VPD_IMAGE_REV) &&
 	       (fsp_vpd->sign == VPD_IMAGE_ID));
 
 	/* Copy default data from Flash */
 	memcpy(fsp_upd, (void *)(fsp_hdr->img_base + fsp_vpd->upd_offset),
-	       sizeof(struct upd_region_t));
+	       sizeof(struct upd_region));
 
 	/* Verifify the UPD data region is valid */
-	ASSERT(fsp_upd->terminator == 0x55AA);
+	assert(fsp_upd->terminator == UPD_TERMINATOR);
 
 	/* Override any UPD setting if required */
 	update_fsp_upd(fsp_upd);
 
-	memset((void *)&params, 0, sizeof(struct fsp_init_params_t));
+	memset(&params, 0, sizeof(struct fsp_init_params));
 	params.nvs_buf = nvs_buf;
-	params.rt_buf = (struct fspinit_rtbuf_t *)&rt_buf;
+	params.rt_buf = (struct fspinit_rtbuf *)&rt_buf;
 	params.continuation = (fsp_continuation_f)asm_continuation;
 
 	init = (fsp_init_f)(fsp_hdr->img_base + fsp_hdr->fsp_init);
@@ -199,32 +187,28 @@
 
 	/*
 	 * Should never get here.
-	 * Control will continue from romstage_main_continue_asm.
+	 * Control will continue from fsp_continue.
 	 * This line below is to prevent the compiler from optimizing
 	 * structure intialization.
+	 *
+	 * DO NOT REMOVE!
 	 */
 	init(&params);
-
-	/*
-	 * Should never return.
-	 * Control will continue from ContinuationFunc
-	 */
-	ASSERT(FALSE);
 }
 
-u32 fsp_notify(struct fsp_header_t *fsp_hdr, u32 phase)
+u32 fsp_notify(struct fsp_header *fsp_hdr, u32 phase)
 {
 	fsp_notify_f notify;
-	struct fsp_notify_params_t params;
-	struct fsp_notify_params_t *params_ptr;
+	struct fsp_notify_params params;
+	struct fsp_notify_params *params_ptr;
 	u32 status;
 
 	if (!fsp_hdr)
-		fsp_hdr = (struct fsp_header_t *)find_fsp_header();
+		fsp_hdr = (struct fsp_header *)find_fsp_header();
 
 	if (fsp_hdr == NULL) {
 		/* No valid FSP info header */
-		ASSERT(FALSE);
+		panic("Invalid FSP header");
 	}
 
 	notify = (fsp_notify_f)(fsp_hdr->img_base + fsp_hdr->fsp_notify);
@@ -245,9 +229,9 @@
 	return status;
 }
 
-u32 get_usable_lowmem_top(const void *hob_list)
+u32 fsp_get_usable_lowmem_top(const void *hob_list)
 {
-	union hob_pointers_t hob;
+	union hob_pointers hob;
 	phys_addr_t phys_start;
 	u32 top;
 
@@ -255,26 +239,26 @@
 	hob.raw = (void *)hob_list;
 
 	/* * Collect memory ranges */
-	top = 0x100000;
-	while (!END_OF_HOB(hob)) {
-		if (hob.hdr->type == HOB_TYPE_RES_DESC) {
+	top = FSP_LOWMEM_BASE;
+	while (!end_of_hob(hob)) {
+		if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
 			if (hob.res_desc->type == RES_SYS_MEM) {
 				phys_start = hob.res_desc->phys_start;
 				/* Need memory above 1MB to be collected here */
-				if (phys_start >= 0x100000 &&
-				    phys_start < (phys_addr_t)0x100000000)
+				if (phys_start >= FSP_LOWMEM_BASE &&
+				    phys_start < (phys_addr_t)FSP_HIGHMEM_BASE)
 					top += (u32)(hob.res_desc->len);
 			}
 		}
-		hob.raw = GET_NEXT_HOB(hob);
+		hob.raw = get_next_hob(hob);
 	}
 
 	return top;
 }
 
-u64 get_usable_highmem_top(const void *hob_list)
+u64 fsp_get_usable_highmem_top(const void *hob_list)
 {
-	union hob_pointers_t hob;
+	union hob_pointers hob;
 	phys_addr_t phys_start;
 	u64 top;
 
@@ -282,33 +266,33 @@
 	hob.raw = (void *)hob_list;
 
 	/* Collect memory ranges */
-	top = 0x100000000;
-	while (!END_OF_HOB(hob)) {
-		if (hob.hdr->type == HOB_TYPE_RES_DESC) {
+	top = FSP_HIGHMEM_BASE;
+	while (!end_of_hob(hob)) {
+		if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
 			if (hob.res_desc->type == RES_SYS_MEM) {
 				phys_start = hob.res_desc->phys_start;
 				/* Need memory above 1MB to be collected here */
-				if (phys_start >= (phys_addr_t)0x100000000)
+				if (phys_start >= (phys_addr_t)FSP_HIGHMEM_BASE)
 					top += (u32)(hob.res_desc->len);
 			}
 		}
-		hob.raw = GET_NEXT_HOB(hob);
+		hob.raw = get_next_hob(hob);
 	}
 
 	return top;
 }
 
-u64 get_fsp_reserved_mem_from_guid(const void *hob_list, u64 *len,
-				   struct efi_guid_t *guid)
+u64 fsp_get_reserved_mem_from_guid(const void *hob_list, u64 *len,
+				   struct efi_guid *guid)
 {
-	union hob_pointers_t hob;
+	union hob_pointers hob;
 
 	/* Get the HOB list for processing */
 	hob.raw = (void *)hob_list;
 
 	/* Collect memory ranges */
-	while (!END_OF_HOB(hob)) {
-		if (hob.hdr->type == HOB_TYPE_RES_DESC) {
+	while (!end_of_hob(hob)) {
+		if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
 			if (hob.res_desc->type == RES_MEM_RESERVED) {
 				if (compare_guid(&hob.res_desc->owner, guid)) {
 					if (len)
@@ -318,99 +302,100 @@
 				}
 			}
 		}
-		hob.raw = GET_NEXT_HOB(hob);
+		hob.raw = get_next_hob(hob);
 	}
 
 	return 0;
 }
 
-u32 get_fsp_reserved_mem(const void *hob_list, u32 *len)
+u32 fsp_get_fsp_reserved_mem(const void *hob_list, u32 *len)
 {
-	const struct efi_guid_t guid = FSP_HOB_RESOURCE_OWNER_FSP_GUID;
+	const struct efi_guid guid = FSP_HOB_RESOURCE_OWNER_FSP_GUID;
 	u64 length;
 	u32 base;
 
-	base = (u32)get_fsp_reserved_mem_from_guid(hob_list,
-			&length, (struct efi_guid_t *)&guid);
+	base = (u32)fsp_get_reserved_mem_from_guid(hob_list,
+			&length, (struct efi_guid *)&guid);
 	if ((len != 0) && (base != 0))
 		*len = (u32)length;
 
 	return base;
 }
 
-u32 get_tseg_reserved_mem(const void *hob_list, u32 *len)
+u32 fsp_get_tseg_reserved_mem(const void *hob_list, u32 *len)
 {
-	const struct efi_guid_t guid = FSP_HOB_RESOURCE_OWNER_TSEG_GUID;
+	const struct efi_guid guid = FSP_HOB_RESOURCE_OWNER_TSEG_GUID;
 	u64 length;
 	u32 base;
 
-	base = (u32)get_fsp_reserved_mem_from_guid(hob_list,
-			&length, (struct efi_guid_t *)&guid);
+	base = (u32)fsp_get_reserved_mem_from_guid(hob_list,
+			&length, (struct efi_guid *)&guid);
 	if ((len != 0) && (base != 0))
 		*len = (u32)length;
 
 	return base;
 }
 
-void *get_next_hob(u16 type, const void *hob_list)
+void *fsp_get_next_hob(u16 type, const void *hob_list)
 {
-	union hob_pointers_t hob;
+	union hob_pointers hob;
 
-	ASSERT(hob_list != NULL);
+	assert(hob_list != NULL);
 
 	hob.raw = (u8 *)hob_list;
 
 	/* Parse the HOB list until end of list or matching type is found */
-	while (!END_OF_HOB(hob)) {
-		if (hob.hdr->type == type)
+	while (!end_of_hob(hob)) {
+		if (get_hob_type(hob) == type)
 			return hob.raw;
 
-		hob.raw = GET_NEXT_HOB(hob);
+		hob.raw = get_next_hob(hob);
 	}
 
 	return NULL;
 }
 
-void *get_next_guid_hob(const struct efi_guid_t *guid, const void *hob_list)
+void *fsp_get_next_guid_hob(const struct efi_guid *guid, const void *hob_list)
 {
-	union hob_pointers_t hob;
+	union hob_pointers hob;
 
 	hob.raw = (u8 *)hob_list;
-	while ((hob.raw = get_next_hob(HOB_TYPE_GUID_EXT,
+	while ((hob.raw = fsp_get_next_hob(HOB_TYPE_GUID_EXT,
 			hob.raw)) != NULL) {
 		if (compare_guid(guid, &hob.guid->name))
 			break;
-		hob.raw = GET_NEXT_HOB(hob);
+		hob.raw = get_next_hob(hob);
 	}
 
 	return hob.raw;
 }
 
-void *get_guid_hob_data(const void *hob_list, u32 *len, struct efi_guid_t *guid)
+void *fsp_get_guid_hob_data(const void *hob_list, u32 *len,
+			    struct efi_guid *guid)
 {
 	u8 *guid_hob;
 
-	guid_hob = get_next_guid_hob(guid, hob_list);
+	guid_hob = fsp_get_next_guid_hob(guid, hob_list);
 	if (guid_hob == NULL) {
 		return NULL;
 	} else {
 		if (len)
-			*len = GET_GUID_HOB_DATA_SIZE(guid_hob);
+			*len = get_guid_hob_data_size(guid_hob);
 
-		return GET_GUID_HOB_DATA(guid_hob);
+		return get_guid_hob_data(guid_hob);
 	}
 }
 
-void *get_fsp_nvs_data(const void *hob_list, u32 *len)
+void *fsp_get_nvs_data(const void *hob_list, u32 *len)
 {
-	const struct efi_guid_t guid = FSP_NON_VOLATILE_STORAGE_HOB_GUID;
+	const struct efi_guid guid = FSP_NON_VOLATILE_STORAGE_HOB_GUID;
 
-	return get_guid_hob_data(hob_list, len, (struct efi_guid_t *)&guid);
+	return fsp_get_guid_hob_data(hob_list, len, (struct efi_guid *)&guid);
 }
 
-void *get_bootloader_tmp_mem(const void *hob_list, u32 *len)
+void *fsp_get_bootloader_tmp_mem(const void *hob_list, u32 *len)
 {
-	const struct efi_guid_t guid = FSP_BOOTLOADER_TEMP_MEM_HOB_GUID;
+	const struct efi_guid guid = FSP_BOOTLOADER_TEMP_MEM_HOB_GUID;
 
-	return get_guid_hob_data(hob_list, len, (struct efi_guid_t *)&guid);
+	return fsp_get_guid_hob_data(hob_list, len, (struct efi_guid *)&guid);
 }
diff --git a/arch/x86/cpu/queensbay/tnc.c b/arch/x86/cpu/queensbay/tnc.c
new file mode 100644
index 0000000..8637cdc
--- /dev/null
+++ b/arch/x86/cpu/queensbay/tnc.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/io.h>
+#include <asm/pci.h>
+#include <asm/post.h>
+#include <asm/arch/tnc.h>
+#include <asm/arch/fsp/fsp_support.h>
+#include <asm/processor.h>
+
+static void unprotect_spi_flash(void)
+{
+	u32 bc;
+
+	bc = pci_read_config32(PCH_LPC_DEV, 0xd8);
+	bc |= 0x1;	/* unprotect the flash */
+	pci_write_config32(PCH_LPC_DEV, 0xd8, bc);
+}
+
+int arch_cpu_init(void)
+{
+	struct pci_controller *hose;
+	int ret;
+
+	post_code(POST_CPU_INIT);
+#ifdef CONFIG_SYS_X86_TSC_TIMER
+	timer_set_base(rdtsc());
+#endif
+
+	ret = x86_cpu_init_f();
+	if (ret)
+		return ret;
+
+	ret = pci_early_init_hose(&hose);
+	if (ret)
+		return ret;
+
+	unprotect_spi_flash();
+
+	return 0;
+}
+
+int print_cpuinfo(void)
+{
+	post_code(POST_CPU_INFO);
+	return default_print_cpuinfo();
+}
+
+void reset_cpu(ulong addr)
+{
+	/* cold reset */
+	outb(0x06, PORT_RESET);
+}
+
+void board_final_cleanup(void)
+{
+	u32 status;
+
+	/* call into FspNotify */
+	debug("Calling into FSP (notify phase INIT_PHASE_BOOT): ");
+	status = fsp_notify(NULL, INIT_PHASE_BOOT);
+	if (status != FSP_SUCCESS)
+		debug("fail, error code %x\n", status);
+	else
+		debug("OK\n");
+
+	return;
+}
diff --git a/arch/x86/cpu/queensbay/tnc_car.S b/arch/x86/cpu/queensbay/tnc_car.S
new file mode 100644
index 0000000..5e09568
--- /dev/null
+++ b/arch/x86/cpu/queensbay/tnc_car.S
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <config.h>
+#include <asm/post.h>
+
+.globl car_init
+car_init:
+	/*
+	 * Note: ebp holds the BIST value (built-in self test) so far, but ebp
+	 * will be destroyed through the FSP call, thus we have to test the
+	 * BIST value here before we call into FSP.
+	 */
+	test	%ebp, %ebp
+	jz	car_init_start
+	post_code(POST_BIST_FAILURE)
+	jmp	die
+
+car_init_start:
+	post_code(POST_CAR_START)
+	lea	find_fsp_header_romstack, %esp
+	jmp	find_fsp_header
+
+find_fsp_header_ret:
+	/* EAX points to FSP_INFO_HEADER */
+	mov	%eax, %ebp
+
+	/* sanity test */
+	cmp	$CONFIG_FSP_ADDR, %eax
+	jb	die
+
+	/* calculate TempRamInitEntry address */
+	mov	0x30(%ebp), %eax
+	add	0x1c(%ebp), %eax
+
+	/* call FSP TempRamInitEntry to setup temporary stack */
+	lea	temp_ram_init_romstack, %esp
+	jmp	*%eax
+
+temp_ram_init_ret:
+	addl	$4, %esp
+	cmp	$0, %eax
+	jnz	car_init_fail
+
+	post_code(POST_CAR_CPU_CACHE)
+
+	/*
+	 * The FSP TempRamInit initializes the ecx and edx registers to
+	 * point to a temporary but writable memory range (Cache-As-RAM).
+	 * ecx: the start of this temporary memory range,
+	 * edx: the end of this range.
+	 */
+
+	/* stack grows down from top of CAR */
+	movl	%edx, %esp
+
+	/*
+	 * TODO:
+	 *
+	 * According to FSP architecture spec, the fsp_init() will not return
+	 * to its caller, instead it requires the bootloader to provide a
+	 * so-called continuation function to pass into the FSP as a parameter
+	 * of fsp_init, and fsp_init() will call that continuation function
+	 * directly.
+	 *
+	 * The call to fsp_init() may need to be moved out of the car_init()
+	 * to cpu_init_f() with the help of some inline assembly codes.
+	 * Note there is another issue that fsp_init() will setup another stack
+	 * using the fsp_init parameter stack_top after DRAM is initialized,
+	 * which means any data on the previous stack (on the CAR) gets lost
+	 * (ie: U-Boot global_data). FSP is supposed to support such scenario,
+	 * however it does not work. This should be revisited in the future.
+	 */
+	movl	$CONFIG_FSP_TEMP_RAM_ADDR, %eax
+	xorl	%edx, %edx
+	xorl	%ecx, %ecx
+	call	fsp_init
+
+.global fsp_init_done
+fsp_init_done:
+	/*
+	 * We come here from FspInit with eax pointing to the HOB list.
+	 * Save eax to esi temporarily.
+	 */
+	movl	%eax, %esi
+	/*
+	 * Re-initialize the ebp (BIST) to zero, as we already reach here
+	 * which means we passed BIST testing before.
+	 */
+	xorl	%ebp, %ebp
+	jmp	car_init_ret
+
+car_init_fail:
+	post_code(POST_CAR_FAILURE)
+
+die:
+	hlt
+	jmp	die
+	hlt
+
+	/*
+	 * The function call before CAR initialization is tricky. It cannot
+	 * be called using the 'call' instruction but only the 'jmp' with
+	 * the help of a handcrafted stack in the ROM. The stack needs to
+	 * contain the function return address as well as the parameters.
+	 */
+	.balign	4
+find_fsp_header_romstack:
+	.long	find_fsp_header_ret
+
+	.balign	4
+temp_ram_init_romstack:
+	.long	temp_ram_init_ret
+	.long	temp_ram_init_params
+temp_ram_init_params:
+_dt_ucode_base_size:
+	/* These next two fields are filled in by ifdtool */
+	.long	0			/* microcode base */
+	.long	0			/* microcode size */
+	.long	CONFIG_SYS_MONITOR_BASE	/* code region base */
+	.long	CONFIG_SYS_MONITOR_LEN	/* code region size */
diff --git a/arch/x86/cpu/queensbay/tnc_dram.c b/arch/x86/cpu/queensbay/tnc_dram.c
new file mode 100644
index 0000000..8e97c9b
--- /dev/null
+++ b/arch/x86/cpu/queensbay/tnc_dram.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/arch/fsp/fsp_support.h>
+#include <asm/e820.h>
+#include <asm/post.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+int dram_init(void)
+{
+	phys_size_t ram_size = 0;
+	union hob_pointers hob;
+
+	hob.raw = gd->arch.hob_list;
+	while (!end_of_hob(hob)) {
+		if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
+			if (hob.res_desc->type == RES_SYS_MEM ||
+			    hob.res_desc->type == RES_MEM_RESERVED) {
+				ram_size += hob.res_desc->len;
+			}
+		}
+		hob.raw = get_next_hob(hob);
+	}
+
+	gd->ram_size = ram_size;
+	post_code(POST_DRAM);
+
+	return 0;
+}
+
+void dram_init_banksize(void)
+{
+	gd->bd->bi_dram[0].start = 0;
+	gd->bd->bi_dram[0].size = gd->ram_size;
+}
+
+/*
+ * 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)
+{
+	return fsp_get_usable_lowmem_top(gd->arch.hob_list);
+}
+
+unsigned install_e820_map(unsigned max_entries, struct e820entry *entries)
+{
+	unsigned num_entries = 0;
+
+	union hob_pointers hob;
+
+	hob.raw = gd->arch.hob_list;
+
+	while (!end_of_hob(hob)) {
+		if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
+			entries[num_entries].addr = hob.res_desc->phys_start;
+			entries[num_entries].size = hob.res_desc->len;
+
+			if (hob.res_desc->type == RES_SYS_MEM)
+				entries[num_entries].type = E820_RAM;
+			else if (hob.res_desc->type == RES_MEM_RESERVED)
+				entries[num_entries].type = E820_RESERVED;
+		}
+		hob.raw = get_next_hob(hob);
+		num_entries++;
+	}
+
+	return num_entries;
+}
diff --git a/arch/x86/cpu/queensbay/tnc_pci.c b/arch/x86/cpu/queensbay/tnc_pci.c
new file mode 100644
index 0000000..39bff49
--- /dev/null
+++ b/arch/x86/cpu/queensbay/tnc_pci.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <pci.h>
+#include <asm/pci.h>
+#include <asm/arch/fsp/fsp_support.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+void board_pci_setup_hose(struct pci_controller *hose)
+{
+	hose->first_busno = 0;
+	hose->last_busno = 0;
+
+	/* PCI memory space */
+	pci_set_region(hose->regions + 0,
+		       CONFIG_PCI_MEM_BUS,
+		       CONFIG_PCI_MEM_PHYS,
+		       CONFIG_PCI_MEM_SIZE,
+		       PCI_REGION_MEM);
+
+	/* PCI IO space */
+	pci_set_region(hose->regions + 1,
+		       CONFIG_PCI_IO_BUS,
+		       CONFIG_PCI_IO_PHYS,
+		       CONFIG_PCI_IO_SIZE,
+		       PCI_REGION_IO);
+
+	pci_set_region(hose->regions + 2,
+		       CONFIG_PCI_PREF_BUS,
+		       CONFIG_PCI_PREF_PHYS,
+		       CONFIG_PCI_PREF_SIZE,
+		       PCI_REGION_PREFETCH);
+
+	pci_set_region(hose->regions + 3,
+		       0,
+		       0,
+		       gd->ram_size,
+		       PCI_REGION_MEM | PCI_REGION_SYS_MEMORY);
+
+	hose->region_count = 4;
+}
+
+int board_pci_post_scan(struct pci_controller *hose)
+{
+	u32 status;
+
+	/* call into FspNotify */
+	debug("Calling into FSP (notify phase INIT_PHASE_PCI): ");
+	status = fsp_notify(NULL, INIT_PHASE_PCI);
+	if (status != FSP_SUCCESS)
+		debug("fail, error code %x\n", status);
+	else
+		debug("OK\n");
+
+	return 0;
+}
diff --git a/arch/x86/cpu/queensbay/topcliff.c b/arch/x86/cpu/queensbay/topcliff.c
new file mode 100644
index 0000000..b01422a
--- /dev/null
+++ b/arch/x86/cpu/queensbay/topcliff.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <errno.h>
+#include <malloc.h>
+#include <pci.h>
+#include <pci_ids.h>
+#include <sdhci.h>
+
+static struct pci_device_id mmc_supported[] = {
+	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_0 },
+	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_1 },
+	{ }
+};
+
+int cpu_mmc_init(bd_t *bis)
+{
+	struct sdhci_host *mmc_host;
+	pci_dev_t devbusfn;
+	u32 iobase;
+	int ret;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(mmc_supported); i++) {
+		devbusfn =  pci_find_devices(mmc_supported, i);
+		if (devbusfn == -1)
+			return -ENODEV;
+
+		mmc_host = (struct sdhci_host *)malloc(sizeof(struct sdhci_host));
+		if (!mmc_host)
+			return -ENOMEM;
+
+		mmc_host->name = "Topcliff SDHCI";
+		pci_read_config_dword(devbusfn, PCI_BASE_ADDRESS_0, &iobase);
+		mmc_host->ioaddr = (void *)iobase;
+		mmc_host->quirks = 0;
+		ret = add_sdhci(mmc_host, 0, 0);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
diff --git a/arch/x86/dts/coreboot.dtsi b/arch/x86/dts/coreboot.dtsi
index c8dc4ce..65a93ac 100644
--- a/arch/x86/dts/coreboot.dtsi
+++ b/arch/x86/dts/coreboot.dtsi
@@ -6,7 +6,7 @@
 	};
 
 	serial {
-		compatible = "coreboot-uart";
+		compatible = "x86-uart";
 		reg = <0x3f8 0x10>;
 		reg-shift = <0>;
 		io-mapped = <1>;
diff --git a/arch/x86/dts/crownbay.dts b/arch/x86/dts/crownbay.dts
index 399dafb..3f43f3c 100644
--- a/arch/x86/dts/crownbay.dts
+++ b/arch/x86/dts/crownbay.dts
@@ -50,4 +50,11 @@
 			memory-map = <0xffe00000 0x00200000>;
 		};
 	};
+
+	microcode {
+		update@0 {
+#include "microcode/m0220661105_cv.dtsi"
+		};
+	};
+
 };
diff --git a/arch/x86/dts/link.dts b/arch/x86/dts/link.dts
index 592af16..a739080 100644
--- a/arch/x86/dts/link.dts
+++ b/arch/x86/dts/link.dts
@@ -214,10 +214,10 @@
 
 	microcode {
 		update@0 {
-#include "m12206a7_00000028.dtsi"
+#include "microcode/m12206a7_00000029.dtsi"
 		};
 		update@1 {
-#include "m12306a9_00000017.dtsi"
+#include "microcode/m12306a9_0000001b.dtsi"
 		};
 	};
 
diff --git a/arch/x86/dts/m12206a7_00000028.dtsi b/arch/x86/dts/m12206a7_00000028.dtsi
deleted file mode 100644
index bcd5248..0000000
--- a/arch/x86/dts/m12206a7_00000028.dtsi
+++ /dev/null
@@ -1,622 +0,0 @@
-/*
- * Copyright (c) <1995-2013>, Intel Corporation.
- * All rights reserved.
- *
- * Redistribution. Redistribution and use in binary form, without modification, are
- * permitted provided that the following conditions are met:
- *	.Redistributions must reproduce the above copyright notice and the following
- * disclaimer in the documentation and/or other materials provided with the
- * distribution.
- * Neither the name of Intel Corporation nor the names of its suppliers may be used
- * to endorse or promote products derived from this software without specific prior
- * written permission.
- *	.No reverse engineering, decompilation, or disassembly of this software is
- * permitted.
- *	."Binary form" includes any format commonly used for electronic conveyance
- * which is a reversible, bit-exact translation of binary representation to ASCII or
- * ISO text, for example, "uuencode."
- *
- * DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
- * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *---
- * This is a device tree fragment. Use #include to add these properties to a
- * node.
- */
-
-compatible = "intel,microcode";
-intel,header-version = <1>;
-intel,update-revision = <0x28>;
-intel,date-code = <0x04242012>;
-intel,processor-signature = <0x000206a7>;
-intel,checksum = <0xf3e9935d>;
-intel,loader-revision = <1>;
-intel,processor-flags = <0x12>;
-
-/* The 48-byte public header is omitted. */
-data = <
-	0x00000000	0x000000a1	0x00020001	0x00000028
-	0x00000000	0x00000000	0x20120423	0x000008f1
-	0x00000001	0x000206a7	0x00000000	0x00000000
-	0x00000000	0x00000000	0x00000000	0x00000000
-	0x00000000	0x000008f1	0x00000000	0x00000000
-	0x00000000	0x00000000	0x00000000	0x00000000
-	0x52b813ac	0xdb8994c7	0x70e9f6bb	0x9d6db2ff
-	0xf4d70f5d	0x5b1eccf6	0xac59106f	0x0ae2e2c1
-	0x1a7bbeb1	0x355a1d62	0x2e7eb594	0x09f8dea9
-	0x432a49e4	0xbf520253	0xdafa4010	0x893a858a
-	0x766e0efb	0xd91e196d	0x838bd2ef	0xe5146494
-	0xd515f413	0x29704828	0xe85598b6	0xdcbe6c51
-	0x88eabbfa	0xa1e8909f	0xd8931721	0x35386554
-	0x089a78a7	0xd9914775	0xd4644748	0x1556a4dc
-	0xf44448f6	0xd054d7db	0xf30f2b7d	0x5ae223d0
-	0xcbbb48b0	0x5c8b0383	0x177de157	0x9c1e5f73
-	0x2ec28289	0xd72a7b6c	0x823b6eb2	0x35e02171
-	0xba8deae4	0x06f4d468	0x13dbafaa	0x72b419f1
-	0x033385b5	0x05806920	0x4c6034cf	0x9bd117dc
-	0x976e2d04	0x250330f0	0x7250b5e1	0x184980c2
-	0x12a9d7d6	0x1bc808f9	0xae79994f	0xc6f87901
-	0xc0e3132f	0x671491c5	0x236cad39	0x37889d9c
-	0x67f7c3f3	0x964a6be5	0xbcced7da	0x57eeaa6e
-	0x7bca1522	0x654fee4c	0x2a1ca5d9	0xa1803cf3
-	0x00000011	0x8c316d2c	0x17603b7e	0x32e42981
-	0xc26c1400	0xf0fbccb6	0xeab6b43a	0x11d456a5
-	0x5b912d46	0x15195fe0	0x542f6db3	0x0b7f212e
-	0x47718dd9	0x7c41b108	0x06c21111	0x4445d5ea
-	0xb4fb8128	0xe07404a6	0x8d503da4	0x78fc7e44
-	0xb9919656	0x9968c797	0x87f26ab0	0x23bb1af7
-	0x1ec5d761	0x26f30d2c	0x7cdb747c	0xe4d42033
-	0x8a5d4801	0x768aff57	0xbcfd5d11	0x7c853c2d
-	0x231e6207	0x8b1988a6	0xd68fdb75	0x58dcb417
-	0x44422ef9	0x2a186ebb	0x7d27e85f	0x36ac31f7
-	0x1e487e77	0x2b0b8c37	0xd8ba682f	0x2cba791b
-	0xe6d3dece	0x1b2c2a99	0x4e5decab	0xfbd313a3
-	0xdbc78294	0x5a80cce7	0x2d8e0f0b	0xcf564f71
-	0x073d1f37	0x25162870	0x96cdb85b	0x9c553048
-	0x24eba740	0xfc0f352e	0x0c83be68	0x89b5076c
-	0xc39c4355	0x6a4cf25c	0x2bbd2682	0xc524fdb9
-	0x7ea19bae	0x191ad6f1	0xd3fbf3bf	0x21bf77fa
-	0x8f77fec4	0x0f90f635	0xe55e165c	0x868d58c0
-	0x966bc0ad	0x6c276364	0x9d8f7eff	0x4b7925d4
-	0x8b2f9326	0x4ab7b47e	0x33a9087c	0xf31ab949
-	0x69831dfb	0x4711a215	0x8128c1fa	0x8481c213
-	0x7401b01b	0xfdcfdc50	0xd6b55266	0xae9b23ac
-	0xfa2ad275	0xa225bb45	0x4dd720c4	0x760a20e6
-	0x5f1223c9	0x2f334372	0x6e1dcdab	0xe8ee8638
-	0x1c19ba8a	0xef9341c4	0x360aaa9d	0x90452ea9
-	0x65852446	0xe9398fa3	0xbba6a631	0x1a3e90b9
-	0xe2a73a56	0x6e8c0747	0x35c7c53d	0xcc1ac842
-	0x183356af	0xb6e98608	0x987b43c2	0xa8a3cfd2
-	0xc2c5fce0	0xcc3af64a	0xd6d3a291	0xe59ad1f5
-	0x124ca513	0x9522b50a	0x25150477	0xa2eb5797
-	0x7fc63626	0x648c48e3	0x9f5797ff	0x2307b84d
-	0x980625a4	0xabc05983	0x24980807	0x773c4f99
-	0x3407b872	0x07c3657a	0xa2cd9e48	0x49c1e6a8
-	0xa881b84c	0xf804d72c	0xb5319d2a	0x3e39780f
-	0x97518822	0x0acd54c2	0x0721a9ff	0x10e1d2fd
-	0xa7b6db77	0x845b1a56	0xef00160e	0x6b41bfd5
-	0xc994df0d	0xcf44a5ca	0x794b36a4	0xf9fdb127
-	0x922a1366	0x822aa8a9	0x4b137bd5	0x5722a49f
-	0x8933719a	0x17edc1a9	0x079d9538	0x21fae7d5
-	0xe534fd73	0x9d3038d5	0x48c3a056	0x5b22d58a
-	0x6f142866	0xf1d767cd	0xb51ad5a6	0x34a0ef85
-	0x0111703e	0xca4b3a30	0xa0f3c34d	0x9d48775a
-	0x3f2059f9	0xf2fe2c36	0x588861a9	0xed5bd9fe
-	0x8231f7cb	0x8c115969	0x3f82ba00	0x21b3730c
-	0xba757997	0x3ec0bb2c	0x16f11def	0x5d4356c6
-	0xdc2e0bc2	0x58c1eb6e	0x313ede0c	0xb68fcc52
-	0x84d3e1b5	0xcc6d9201	0x95046196	0x276b527b
-	0x80a4a729	0xe782916d	0x5cf09e0b	0x98aaf9fa
-	0x1de6dd43	0xab4f1962	0x49ece734	0x81455488
-	0xc2597b61	0x5b22af85	0x646f7b94	0x09213a1f
-	0x08edf7e4	0x963d343c	0x059ba888	0xb4e804ed
-	0xe7cc826c	0xf87bafc7	0xeecaec10	0x8e60919c
-	0xbf14c996	0xd3dcaee3	0xb8fa0b7e	0x81563c6e
-	0x7f59a258	0x2f344446	0x374d8aa6	0x9b6de5c9
-	0xbf992857	0xbc5b94fc	0x28adb080	0x17e41044
-	0xb87b469e	0xda504d12	0xf21bef8b	0xce75c1e3
-	0xdbd92c83	0x58bba0af	0x77b42977	0x506cfd75
-	0x1139e875	0x6ce5fe43	0xc6a5d7b3	0x87f9e628
-	0x7b5c500b	0x130066b3	0x789b611f	0xec8c1ba9
-	0xb7e6872d	0xaf828cd6	0xc28d3316	0x2a91f6d0
-	0xc725f063	0x065ac531	0x4f9ef4b8	0x2b9d927e
-	0xaf54f3f9	0x7c924f72	0xda1d77ad	0xff00db67
-	0xaf4f03c0	0xb4f4ee64	0x169e64e5	0x04653ac0
-	0xed51cb70	0xfeaff0e5	0x51dbf346	0x072a2407
-	0x23fb74f4	0x9a906eef	0x5d6fc3f0	0xbc3c374c
-	0x1cf9f063	0x919015d9	0x5b3e9d07	0xd6209d8b
-	0xa3710b3d	0x90ad23b8	0x420ceedc	0x58e8371f
-	0x5d419d1f	0xb8acd13f	0x7d100d6d	0x210c10d1
-	0xcd0a697e	0x5023db4b	0x33e6d8e7	0x44bbe6b4
-	0x827e859f	0x6ca4cc81	0x661bb2c3	0x71209ee8
-	0xb8c3ffaf	0xd1075f51	0xba1eae10	0x728b0a6a
-	0xe4af7a2f	0xca9bcf2e	0xb249a631	0xdce6be47
-	0x5c910321	0x425c3c27	0x33083e43	0xdea067ae
-	0xea594a23	0x41b75c2c	0x3a401a95	0xd33cd88a
-	0xc295cad0	0x67f48045	0x1dc9ad4c	0x4bc48864
-	0x53991b6e	0x7aadde5f	0x2b0bf775	0x06ba5380
-	0x9eb874be	0x2c4b967a	0x1bcc342f	0xe875001b
-	0x15b5642d	0x5be99c9d	0xcb210ace	0x1b4924ad
-	0x3793ed81	0x8b983114	0x3ec33981	0x75ec71e7
-	0x8b5b7df3	0x834756f4	0x100fad01	0x70037fdf
-	0x0cef9a36	0x3d9e3a2d	0x38b48efd	0xfc4034b6
-	0xa32e29dd	0x388944bc	0xc1c15614	0x3877e9c7
-	0xa5e733fa	0xa621bd53	0x4b651df6	0xce082970
-	0x85f30d6f	0x729a5c87	0x31dd7ba9	0xdb495828
-	0x7b12c698	0x953495c9	0x6b5f99e7	0x2cc42fa8
-	0x697ac512	0x1be679de	0xc116d305	0x94a36606
-	0x9e5e141e	0x874affed	0x58d40b0b	0x5e3cf5e5
-	0x5d05e9a9	0x06840efc	0xd2f98b21	0xa1e83ab2
-	0x4f726202	0xa6394535	0x62a02403	0x9f2167ec
-	0x4f9fc77b	0x98073be4	0x2bc781fa	0xfc8e4c89
-	0xc7179b97	0x692cf793	0x708ff7bb	0x12ecba93
-	0xacd06e21	0x202bef76	0x03852241	0xe84e02a1
-	0xf1f9ac8d	0xcee61aef	0x61a4f235	0xd22991eb
-	0x67a81345	0x375a15c6	0xe8fae8a3	0xb4ff2b37
-	0x339ee4ea	0x14ffadc3	0xf49340dd	0xf285e568
-	0x00fc6970	0x369c52d1	0x4f55368f	0x3f4d75f1
-	0x6a73b603	0x963c1f59	0x171e2bdc	0x72bac76b
-	0x9e2e5c32	0x307f7c3f	0xd3b48637	0x3a917acf
-	0xea52a65f	0xecd209fb	0xf0ad84bf	0xd4bdea70
-	0xa2647b38	0xce040b49	0xc6d5f13d	0x5d942c52
-	0xf8edc042	0x798fdefd	0x4b074246	0x1cb1873a
-	0x6793c186	0x23b9c774	0x77bb0202	0xc519b3aa
-	0xa30c09a2	0xe1f6669a	0xb7eddb8d	0x7aaa91d6
-	0x076a3789	0x0ac47791	0x1e503404	0x44fe8c54
-	0xf3cbbf49	0xd3234eef	0x0d898b3f	0xe854984b
-	0xe3986de9	0x923a5c76	0x2ee9abca	0x1a9fedbe
-	0xdf76dcd1	0xea07936b	0xcdaaf247	0xe62d98fa
-	0xa99c7f7b	0x34fc84d4	0x03a35111	0xad5675c8
-	0xcc64075b	0x408203f9	0x846e1f08	0xe934019e
-	0x423d1223	0x2f04f9e3	0xee1dbf40	0x65edc60f
-	0x097aa22f	0x7058a2b7	0x41c8a0a5	0xa68aa391
-	0x0f345c40	0x667517e6	0x860838ba	0x6dae933b
-	0x764d5919	0x6673fa0f	0xf0a5e97d	0x4262ebbe
-	0x64b413f2	0xd2c4145a	0x0b2c11f3	0xfdfe9f93
-	0x96c77107	0x1399fdda	0xf599f215	0xb504da5d
-	0xf8a95268	0x9ed1ef87	0x9ae33cfb	0x3b21f1ef
-	0xc6d447c2	0xe0694d4e	0x967febab	0xc13f631d
-	0x8393bfba	0x37438788	0x1724194d	0x8e77a045
-	0x20e2483c	0xb961c2fc	0x485cf593	0xb3462621
-	0xcb2959b8	0x10307e19	0xf71fbbfd	0xdda641e1
-	0x0daf5f66	0x56d85178	0x145f6749	0xebc46ed1
-	0x5593c249	0x94561f51	0x534cc654	0xca7c8814
-	0xb59a578c	0x40b2b614	0xeaf3437a	0x198d5b4e
-	0xf245fa53	0xfb75e0b0	0xa363c46d	0xc43b5468
-	0xdf036413	0xc59f5a36	0xd8ff4381	0xa3af3e36
-	0x7af63462	0x414526d7	0x7bdc41c5	0xa416f1e7
-	0x6987d9ad	0x472c5499	0x4f10ee37	0x47bb7ff7
-	0xc7f2e621	0x820008f7	0x33a475db	0x91ff5d72
-	0x0517401c	0x73d067c8	0xe417b69d	0xb86d9903
-	0x1ac9a032	0x74bbf582	0x8b65596e	0x883be34c
-	0x95dcc26f	0xe232c646	0xfae9c19f	0x35cb5273
-	0x6a94d095	0xfff6ca91	0xb9c40eb5	0xd351dcac
-	0xc90d464f	0x9b609642	0x15663b56	0x15f7f88d
-	0x22499f60	0x417fd6c5	0x2dc36fe2	0x712bf66a
-	0x22f1fba8	0x531b8092	0x40d269b6	0x1d227898
-	0xeb6ff35b	0x2490ac31	0xc958ed65	0x3ce6ffb7
-	0x9338a806	0x3beadfe2	0x1c361ac9	0x53d0e3b0
-	0x91d46102	0x4d57045f	0xb5c8afb3	0xfd2c9e7d
-	0x3d578410	0x2adb9406	0x10df7459	0x90abccfb
-	0xe3f217ed	0xef5f4e09	0x74925ce4	0x169b5879
-	0xfeff4ad5	0xb300dd1d	0xc96022ba	0x72da501b
-	0x1e694296	0x9efa33cb	0x0dc3ee6c	0x0ac4e7ea
-	0x73041130	0xf0e6a295	0xc46bdb6a	0x6a927044
-	0xd217ceca	0x0b744007	0xd5a2bafb	0x4220cd92
-	0x70d3352a	0x5ee4f661	0xfa07e5c0	0x155542d9
-	0x4a39fba0	0xcec0552d	0x30c1d8ef	0xbef9d21e
-	0x183879aa	0x5b3f30a8	0x54a06db4	0xef876e4e
-	0x5e823680	0x53e2a353	0xc9aa4112	0x13a56ee5
-	0x848859fd	0x0ba2b801	0xec15260f	0x7bb22672
-	0x1a097332	0xb141339f	0x752a67d9	0xdae373f3
-	0x3c8cfd49	0x2dfaf2a9	0x95820c6c	0x956b39a2
-	0x1ca0d24e	0x1312b978	0x7280e1bd	0xa7a7c2ff
-	0x0b48e987	0xb6083e55	0x4b4b82f4	0x9c6104ad
-	0xcb93beca	0xe1c34035	0x34de740d	0xbb151baa
-	0x71f5942f	0x1eaac228	0x0c68331b	0x3d2a1dd0
-	0xe7a3d41a	0x7253acae	0xfd4de230	0x79988d80
-	0x4468f19b	0xac4440fd	0x6e8a6ef3	0x5736adf8
-	0xded67716	0x1f1d5a4b	0x96c5f451	0x85bae181
-	0x1293ab28	0xc2ba53c2	0x729ff4cf	0x60218df8
-	0xc2870138	0x6127d844	0x89604e9e	0xd2b9ad4e
-	0x4f6ded9f	0xdd263849	0x1633bd92	0x64b03a24
-	0x96dabd4d	0x6e85d235	0x1ab69ad0	0x9aa80454
-	0x6b9041e0	0x106c7e9a	0x8f54812f	0xa274efe4
-	0xe45d6695	0xf3aa7bd3	0x6a5a2a63	0xe36f3525
-	0x6238fa4b	0x7d6cb06f	0x16d3b4a2	0xf3b04822
-	0x638f1a60	0x0e1875fa	0x1c0292b9	0x6b519ea4
-	0x9faba37b	0x209341ec	0x83c9061f	0x3387dfe8
-	0xc7f12ceb	0x2bef45d7	0x8f8acb47	0x35d9741b
-	0x7009f514	0xfd003802	0x6f9489c5	0xe2ea2504
-	0x910e996a	0xcc81d016	0x3280730d	0xdedfef59
-	0x5a7357cc	0x8fe8dd39	0x15543fe5	0x976c4207
-	0xe41cf62b	0x0ba6b4b5	0x5c3b7ced	0xa6c5b72b
-	0x72ad3b4d	0xff143181	0x2b78a157	0x7fe231a5
-	0x6ff0538a	0xe58ed1ac	0x81a311a5	0xefaa54b8
-	0xf04a797e	0xce6e69c7	0xdc810726	0x7bab7be3
-	0xdd5923e8	0x5a2413ed	0x31cef794	0x73dfd806
-	0x1b9223c1	0x0c370882	0x04fa3b68	0x87c50bc1
-	0x1d78c90f	0xf4e2cee6	0xebea941b	0x73e5838f
-	0xca8d39a6	0xe004296b	0x28cf8a0e	0x7c73e7ef
-	0x26a296c2	0x789d4c72	0xd1490265	0xd9a9e843
-	0xf03504c3	0xfae6dffb	0x7a48f00d	0x51e369c8
-	0xcb3eeee6	0x0625e936	0xe93d0d7d	0xfb15ba6b
-	0xec5c76da	0x8fdf44f1	0xa036653a	0x5730c4a3
-	0xe5bfe6dd	0x0b8c091f	0x3b51558c	0x403748f4
-	0xf4007f86	0x952b5db6	0x5524d8ba	0x8046409a
-	0xe3fc61a9	0x66f4ea56	0x5645150b	0xdb2bec15
-	0x50672218	0x7f40e87d	0x2b8359f8	0x438787dc
-	0x7f221597	0xf8b1590c	0x4f468251	0xff586d05
-	0xb9195380	0x0ee09e0b	0x2fa7dbd9	0xd197b327
-	0xa0dbad58	0xb485681f	0x5ef0937c	0x1e07ebb6
-	0xcb49fe3f	0xc2427cd9	0x6c2c5298	0x4a2e171a
-	0xa7f333a8	0xb3609ad6	0x94e374d6	0x0e1eb64d
-	0x22c3367d	0xcdf89975	0x647aceef	0x16727c9c
-	0xf476ae53	0x35a1212e	0x0db768b8	0xfff8b53d
-	0xbd4fe45e	0xab28a5a3	0x59cec0af	0x28bcd1ef
-	0x6f43ad69	0x2658a059	0x27aee0ec	0x4e8bbd15
-	0xa9fdcf04	0xc9aa329f	0x687f010f	0x5c968a07
-	0xb894e607	0x0e1cba22	0x2f00f203	0xe8e133ac
-	0x494a4746	0xe8bdff9a	0xf69791a2	0x64179ce2
-	0xbfd10dc6	0xc026f6d8	0x4871923a	0x8946b277
-	0x609f49a4	0x6466df1b	0xd8c3c131	0x46ef0291
-	0x0fdce8b6	0x2b9aedb7	0x225c4520	0x72b332cf
-	0x4e220d47	0xf2f69c36	0x2c23fad9	0x57a2a918
-	0xe017409c	0x490819af	0xf2121afd	0x951ff7ff
-	0x40363fcf	0x5078b94e	0x9e4be775	0xee97ef16
-	0xdb3a2390	0x17d42af9	0x96f56a51	0x1b4c2934
-	0xc866315c	0x2b746f99	0x9a3b73f6	0xa1e081fc
-	0xa9d07ebd	0xa6359fae	0xdf50d099	0x55304e01
-	0xfe5aaa81	0x1e74267d	0x38b1d2d7	0x8633e9af
-	0x99b013df	0x3aa05831	0x86279736	0xd2b464e0
-	0xdf036a9f	0xe8162915	0x876c0d4f	0x4beb7d0e
-	0xfec9b170	0x46bc9df4	0x46cb88fa	0x0cb5904d
-	0x2e2961cf	0x7ea5dc1a	0x60670df2	0xf935ca32
-	0x67e6777b	0x8bacc97a	0x5cd07248	0x32e483e6
-	0xfdf09b0d	0xca57150b	0x3f432d09	0xdea2d7db
-	0x9f6a2954	0x6f07dff3	0x4133f394	0x60272f97
-	0x1b98c9ec	0x2ab648d9	0xb5df14a8	0x0d2c38f2
-	0x5dfde2c4	0x7cb43ca3	0x8d0c6c01	0xe80ea41e
-	0x5f58b71e	0x4ca9fef2	0xabd201a4	0x50905c08
-	0xca8ba387	0x5592922b	0xfa4e05f5	0xceb64b14
-	0x0845c5bd	0x518d369b	0x727e570c	0x1daaab31
-	0x801e8b9c	0xec6568f3	0xd4c3760f	0x40a78d22
-	0x38af58b5	0xc406a76e	0x8c3a7779	0x18272c42
-	0x45cf7b70	0xa6f3c0f3	0x88021e41	0xda662504
-	0xe97aa709	0xe93bafe0	0x8862ed5f	0x35bc8268
-	0xf5a41551	0x3dd3bb21	0x1af0cf11	0x08fe1ad7
-	0x53ecae41	0x01a4a8ae	0xfed636b7	0xf09323e6
-	0x73b9b253	0x7ebd7ce2	0x7074b4de	0x21c719b2
-	0x50982743	0xd23cfd27	0x136a1f4a	0x23260f6e
-	0xfad89dcd	0x57586681	0xadc4fba5	0xad0f71b8
-	0x91a3f188	0x20d62385	0xfecda9cb	0x33d67776
-	0x2abb0e6c	0x0ad16087	0x486332da	0x2928d342
-	0xf6d1b174	0x5e133a4e	0x72fc0ad4	0x940578b8
-	0x320a42b1	0x9cbda7d4	0xf2a36135	0x00ab8de3
-	0x5bad9000	0x5778e633	0x3952763d	0xe0e58583
-	0xdfb0bf19	0xb11914b6	0xa67da7a1	0x8d9a9f81
-	0x638cbcf7	0x83bf931d	0x8703b0dd	0xcab30fa4
-	0xd6db2ee6	0x5cc2e5ac	0x717e636b	0xfdcbc760
-	0x563b3b25	0x0e4df458	0x9efb8fa7	0x95aaa7a1
-	0xf05b6680	0x5e237e59	0xc884018a	0x177b5a30
-	0x3ea2c9bc	0xd0325ee6	0xb1dae51b	0x812ee29d
-	0x6d58db21	0xb787fa68	0xfd092294	0x09683dd3
-	0xfe0d6405	0xfdd99aad	0x78744a59	0x936738e6
-	0x6ad6cba7	0x370f7f8f	0xd208c214	0x12239384
-	0xbe71f0e7	0xfc0ef264	0xc04e4a49	0x354f9cf3
-	0xf5d7572c	0x07839ad0	0x834a003d	0x23ba26e2
-	0xf4049ecf	0x5ff402b2	0xff9d6769	0x074ebe6d
-	0xdc829da1	0xc3d7697d	0x973efe4f	0xfc2a9165
-	0x126dc518	0x0b824ca4	0xc438fb70	0xb7b0ee00
-	0xbe56afd9	0xa3d8defd	0x971455ae	0xc11ffde7
-	0x346e619a	0xb41111a9	0x6004b62e	0x896c668d
-	0x738e458c	0x351f9fdd	0xe771b2ba	0xad6d7464
-	0x719b57c2	0x6f6a4611	0x8a676f2d	0xb8db1c43
-	0x3f102641	0x51bffdbc	0xb7862565	0x5d8dd231
-	0x7a79bd39	0xfa472894	0x0fd1d2ff	0x64cf589a
-	0x38234d7a	0x5c9acefd	0x8eb0b9f8	0x761e1c95
-	0xf2fe78fa	0xe06220d7	0xaf82a919	0xf4e196e1
-	0xa17c8935	0x06d08d16	0x6bad807b	0xf410805d
-	0x4ff2bce6	0x3297c81f	0x06e35353	0xbe1f5e1c
-	0x65d1cb92	0x0dc69b2f	0xac55d597	0x636ff24c
-	0xe2e4f2ba	0x63d64922	0x4b2e9f71	0xad2279ec
-	0x5f0b5c0e	0xac688638	0x35613358	0xf5531360
-	0x54a304e8	0x27ebfe65	0x977b5a3c	0x3dc5e10c
-	0x73b32ee9	0x3a2c9454	0x30a149c6	0x31e5b55c
-	0x2c10854f	0x745cd38a	0x2853a27b	0x6629e355
-	0x0bb67e39	0x5469184d	0x694a9bb6	0x0a0ca25f
-	0xa878c5de	0xee15fd46	0x23d92ff8	0x02328404
-	0x1c9402b5	0xa46b6ce0	0xefc3e947	0x0e9312ad
-	0x5830ae9e	0xe30e32f2	0x9db8ee81	0xe8aeebbc
-	0x30675c83	0x447278c2	0xab2bad3b	0x08ba3d0c
-	0x1124e681	0x3691242d	0x903c8d2b	0x3281c312
-	0x22af690f	0xd69a150c	0x57622c5b	0x29313c73
-	0x6ab2d7c6	0x39b06dad	0x6e1f9f81	0x03324986
-	0x53a49093	0x7654eba3	0x2527245a	0x9af596fb
-	0x818ffb3a	0xa3817173	0x6a2c4b80	0xfcc42ad5
-	0xfb1bbb69	0x3a3720a2	0x90a89bcf	0xed80308d
-	0x7753cb1c	0x1c2654a5	0xb01ee4af	0x81091e85
-	0x9067b3f1	0x2e2b9b5e	0x9fb0c7d1	0x78fd9f69
-	0x5771c46d	0xacdf498d	0xfd8b8e77	0x4c15fa61
-	0x607120ce	0x18a298d8	0x73716420	0x65e5e06a
-	0x18c53e04	0x35b84427	0xcd82b522	0x9a7d26bb
-	0xd56b4b74	0x49b47fe8	0x63178dc6	0x0bac0f46
-	0xc8b0755a	0x9bbaaf1f	0x18131d2b	0xcc019330
-	0x0ceb89bb	0x8808c2d6	0xfb5bd86c	0x6c945b71
-	0xdc911924	0x4ebb8d35	0x44e46d08	0xabfee615
-	0xf456931f	0x7a244955	0x0bffce7d	0x5533ca5f
-	0xb1b2c636	0x4f29075e	0x64012561	0x7aa5e7c7
-	0x9c8a0666	0x9698782d	0x3481ad8f	0x21a55b19
-	0x735aa45d	0x4245b9c4	0x0d4c3fdc	0xd1b10966
-	0x7035fcde	0xc2257947	0x4a37271a	0x9da464a9
-	0x228adbf8	0xbf309e03	0x096f560a	0xa2b8ca78
-	0x427702cd	0x35a99cf5	0x99811758	0x6953db58
-	0xec07533e	0xe95838b9	0x61c71654	0xc9cce595
-	0x275af106	0xc8697af3	0xb3f27e58	0x411d8d30
-	0xd0d90ecd	0x1503b9dc	0x76bf070e	0x49f89ef0
-	0x7333b083	0x53f9c44b	0x8330c3a2	0x6a1119c3
-	0xca555f2b	0x3d51fc6f	0xac7b3320	0xf8e42cdf
-	0x053753fe	0xc122336f	0x94d289c6	0x088b5a64
-	0xc3aac7f0	0x96a76344	0x2ff05828	0x9b4f2af3
-	0x46de6a46	0x4ed29d98	0xe2ab7634	0x27481ddc
-	0x300ca71f	0xce7ac539	0x88240e09	0xb1a14e78
-	0x2addd4c5	0xb3a7f320	0xe91f549b	0x6881c45b
-	0x0e381c47	0x1018feb4	0x64679650	0xe62281cc
-	0x670ee6d4	0x0d226160	0x947b7f08	0xbc595a74
-	0x2380c0b3	0xc0235785	0x63b41221	0x80b9cc31
-	0x3231b4ae	0x33ed5718	0xf2c5c90f	0xdd3b03ea
-	0x67dfca08	0x453e9d29	0xa2bdecbf	0x5e9a3181
-	0xad17aea2	0xff0a8f13	0xdf946849	0xcfbbecb7
-	0xb0a602d7	0xb1a820c6	0xfe7abbc8	0x7f70790d
-	0xeb5f8863	0x266d3cc1	0xbd552a44	0xe19b1b3d
-	0x856aefbd	0x51c11f1e	0xde661b7f	0x61c075d2
-	0xd0f6a834	0xff1d0d37	0x6793d1c2	0x70c133a5
-	0x20c4d2cf	0x8c80d4d3	0x61ebe382	0x788b74df
-	0x11c56903	0x535889ba	0x0a9c7380	0xf9de2837
-	0x09437fe7	0x1627c6b2	0xb943bdb8	0x69bc29b2
-	0xee9795a4	0x83c992e0	0x95437918	0x8ce166a2
-	0x56b56b66	0xb0680941	0x623d38a9	0x2add07ad
-	0xe583ba09	0x96f6532a	0x3eff4696	0x2a8a6b0b
-	0x905b913b	0xafc01673	0xe871e006	0x2c2339ad
-	0x248438e5	0x96d83e53	0xb3a75d6b	0x2258cf63
-	0x69ff39bf	0x95727173	0xc3ac09d5	0xea8d2c06
-	0x0e7c0a4b	0x144fcade	0x28a9a5a3	0x97c11ae8
-	0x89865e3d	0x1640cd32	0xe3e551f8	0x1f7ba770
-	0x6d23fb31	0x11eceae3	0xc8ccb8ee	0x46dd0bb0
-	0xd01a46ff	0x0504adf5	0xec6e170e	0x2e3d7ac5
-	0x70f893ac	0xaf9963db	0x061e283c	0xf0ad248f
-	0x2fe97e19	0x881fd340	0xc686c9d5	0x88ea8ba5
-	0x92f05cd7	0xd6716148	0x6fc47fc3	0x2c51d9b9
-	0xd50a7faf	0x4eccacd1	0x7c92f802	0xa63ffc83
-	0x7cb0ab1d	0x4492e81b	0x7d906554	0x43306ba1
-	0x73a5d57a	0xe57a05d6	0x6850b964	0xefed595c
-	0x7754978f	0x629e8236	0x62ec4dde	0x247439ee
-	0x8b9982fa	0x4eece5c2	0x48599175	0x0fdc752c
-	0xecd87b12	0x94936c75	0x17a45ea1	0x80a899ac
-	0x22a39ee7	0x745730b6	0x03ea4daf	0x4a7570d7
-	0x307621fa	0x7322e0a7	0x3a8e0316	0x454e46f7
-	0x08773750	0x156dcaad	0x5562bc06	0xa23a1ee3
-	0x20435211	0x1d679ea0	0xb220e205	0x682cc1a6
-	0xd64a71c7	0x3ca7f8e3	0x2e92f253	0xa7cfdd0b
-	0xd62b4053	0xf5c5f641	0xbf72dde1	0xdcb716c1
-	0xe2f7b05d	0xa03145ea	0xc09828d2	0x7dae7916
-	0x6fb97c79	0xb3a85204	0x998a9c7b	0x5f42ba8c
-	0xd9c628b3	0x6b17bacb	0xa889b716	0x450ff97d
-	0xe9166f3c	0x2d20777b	0x82a003ae	0x2c7ae0aa
-	0x6011a9fe	0xfeed34be	0x1328f67e	0xf61003a3
-	0xfaecdf20	0xee18c81e	0x731a0302	0x11a39e60
-	0x355d78dc	0x99088f2c	0xcf253759	0x97347603
-	0x736f71f1	0x37e4b395	0x9cc74540	0xf7e39994
-	0xf01c5f64	0xbec519f1	0xa79c1067	0x76000d5e
-	0x1ac85b6e	0x51e5b7a3	0x62a97ddf	0x6f20096a
-	0x2af51e77	0xea5554f6	0xb4e581da	0xc1ac4ba8
-	0xc8f22bf7	0x9e254d3b	0xd7dd62f6	0x6461ae3e
-	0x423e1f10	0xf143e7b9	0x18c73b04	0xa43de614
-	0x2da8d02f	0x9befa706	0xc01dcd49	0xa278f1e0
-	0xd85f3177	0x6b6679fd	0x1ccef04e	0x53af9252
-	0x34d751db	0xc8d32c86	0x3d725097	0xa64ed581
-	0xd090c42f	0x9e92bf3f	0x6f82b089	0xd42728eb
-	0x3dd651e0	0x1985bc52	0x4b0f4159	0x0f99bd7f
-	0xe2597023	0xca0cae4c	0xce48a894	0x7249dd88
-	0x8e146632	0xb4be1d6c	0x790ae7e5	0x6747b657
-	0x52143947	0xa2e42ed3	0xea359617	0x6ca01a11
-	0x35c5e2dc	0xc97b78fc	0x5db6db2a	0x80fe3414
-	0x27da19d4	0xd7431d04	0xa91e9110	0x7d8ecb23
-	0x2508700a	0xc8c71ed9	0xd28835af	0x018c2887
-	0x3d0a6fab	0x3e8523d6	0xd0688dee	0xe5c3865c
-	0x838d72e4	0x6bb73a1d	0x497a59ca	0xf77c56de
-	0x38ecb72e	0xa55e3565	0x04b12c92	0x1aec9997
-	0x037c340a	0xef0d04c3	0x78f74bd6	0xdec9b9e8
-	0xd95b61ea	0x5528e8f5	0x4ecd325c	0x88ffdc0b
-	0xb337ac61	0x899d90e7	0xb5eeb978	0x8295d9ae
-	0x1ed8978b	0xa8849eda	0x8633b4a3	0xb8c858b5
-	0xbe3c4375	0x28b9e84e	0xb2a26def	0x22f8f66b
-	0x3a4aed99	0x0c4914ea	0xad103249	0xba5a5eff
-	0x8a052461	0x26938899	0x915c6ed7	0xe6268ad9
-	0x246e8c74	0x75f3c196	0xc3e725d6	0x92e02549
-	0x1f78a5cb	0xeada57e5	0x40f14906	0x0215e49c
-	0x57c06bae	0xc1896b87	0x0cd40a63	0x60741d80
-	0x11a69899	0x80fed942	0x0497e115	0x56697b55
-	0xba89c3d4	0x27d6b7c5	0xddff87b0	0xd3b1ff2f
-	0x3160e528	0x9cca1286	0x13b4fdf1	0x38cdd907
-	0xb50c4597	0x4c151714	0x1cab86c7	0x23126a3e
-	0xe26e9749	0x289a0d0e	0xc4004640	0x9d33928d
-	0x33b691a2	0x15ed6e6b	0x6e773980	0xadd59678
-	0x188ba49f	0x08da4c6d	0x6d150d0b	0x0c6c7b98
-	0xc8e1df7e	0xb8b1e692	0x5e89fd35	0xcb253d24
-	0xfc6ee27c	0x8013de3d	0x1d38012b	0xe50a8f7b
-	0x7d410ff1	0xceee4e9f	0x0e8094b6	0xaa1a5f57
-	0xb395a551	0xbd62b2ae	0x5d7b34c8	0xbd2d6195
-	0x33af4109	0x0769ff18	0x9c6cc123	0x78ee6eb6
-	0x412644e7	0x70e0c6f4	0xf45d8fc6	0x0435f5af
-	0xd43622b7	0x27409d5b	0x6dd04e8f	0x9f02ecf5
-	0xca415f7d	0xc9f439c2	0x7198e539	0x20476b75
-	0x3cdd8dd8	0xce17fbb0	0xa5bc115e	0xb0ee52c1
-	0x0b074cfa	0xd26d4f99	0x3b43320b	0x230b680b
-	0x9908f2d2	0xcbcb1952	0xf45a2f53	0x7b4564c6
-	0xcf2fd983	0x414fe4b2	0x55ea7f11	0x63e8117d
-	0xe8954052	0x7c2ea344	0x97a02aaf	0x6ca874c3
-	0x1ae5b4ee	0x41754eae	0x6954abe0	0x115ddcda
-	0x9a27968b	0x32a53e65	0xffe47b2f	0x4fe7e5a7
-	0x6016dedc	0xb3c0893e	0x9626776d	0x5ec773f9
-	0x1104e01c	0x1473cfb3	0x43b2cedf	0x8ca9d119
-	0x7f1bc844	0xd8bb7387	0xba90d2ef	0x2bb0dcf4
-	0x2340f124	0xa5bd514c	0x50afab05	0x718f5ad5
-	0x7c03fad9	0x71d00d2d	0x1c31fdc2	0x4a938809
-	0x40945ded	0x437f2a0d	0x83c10d64	0xd224c6ab
-	0x0cd44481	0xb0040966	0x27fd6e7f	0x6ff45d4c
-	0xab057ad1	0x8fa4e5d4	0xac50270c	0x6e4926ca
-	0xc5721498	0x2529b458	0x40ee2ad5	0xde5e21f2
-	0xea8964ca	0x56766e60	0xdc3b8702	0xa93528d4
-	0x28d7713d	0x42edf022	0x59774dd8	0x200ff942
-	0xe7a4d769	0xd8c4ef5e	0xe177f715	0xe9d53cd6
-	0xc11270bb	0xb25977e5	0xb80867b4	0xfb48468b
-	0xdbf166a8	0x49700d85	0x0f85f98a	0xa7ca7a75
-	0x109817ce	0xca243f19	0x8bed7688	0x9a1c8231
-	0x94f0ce97	0xc36309ca	0x90ecac24	0x67e7e0de
-	0x86b18d62	0x18c7b7a5	0x622f5d3a	0x47e1e067
-	0xdc96b94d	0xe4a03beb	0x59d17692	0x040abc0d
-	0x44a5ae50	0x3d3dab7d	0xc18dfd30	0x2802b9d9
-	0x6818379f	0x56db41d7	0x97cbf039	0xe41d6a32
-	0x64b5fb01	0x6506e0b4	0xd60a3234	0xdf3573d2
-	0xac148579	0xe7f46ac0	0x05e1c763	0x904a5aa9
-	0xc7ca1ee0	0xe0c3b047	0x5e36e1bc	0x447a9141
-	0xe24654df	0x9853a49b	0x6a29cedb	0x022f00dc
-	0x6df2a7a7	0x3636da02	0x72bb9c81	0x4f0e0918
-	0xd649f4a5	0xbb0c81f9	0xc0ba93fd	0xc1b390f1
-	0xda84e720	0x1aea0064	0xf3ee67e1	0xb874ef4a
-	0x82467ce6	0x59abf506	0xafbf145a	0x9a4cf8a1
-	0x17247c89	0xd8669398	0x1796eaf7	0xbc2d24a9
-	0xcb486570	0x17a9db23	0x3e6504f0	0x08684517
-	0x2723ab28	0x7081b814	0x8a265a04	0x697e6d8b
-	0x69b146dc	0x6434c182	0x27ec8101	0x864405c5
-	0xfff86c9e	0x3052d8a6	0x23d283db	0x492970e8
-	0xbc6c64c3	0x46d8f98b	0xe16e7ff3	0x731e4f82
-	0xbd26b1af	0x6b30e6c1	0xff192fce	0x097e0bba
-	0x49df63a5	0x2fdc3f01	0x50aae053	0x60177b8f
-	0x1949eb85	0xa46084ce	0x9658f694	0xcb951fbc
-	0xc53806d9	0x63a17d30	0x3b3f86c2	0x8a37aa6c
-	0xedf8fe5c	0x87aee1d3	0x8c680126	0xfd8b27a6
-	0x231fa106	0x69358c25	0x4502c348	0xc107861c
-	0x46280e70	0xcf6067ac	0xf6a04ff3	0x3e488677
-	0x6f3fb4c1	0xeec1f758	0x560e1c48	0xb604c06b
-	0x69e34b1e	0x8ef41dec	0x854cea22	0x726581d7
-	0x55ea91f3	0x38ae4053	0x5ff7389d	0x6952cbf6
-	0x09aa0fc1	0xcccb1d50	0x5c1a633a	0xde1eba46
-	0x797212d8	0xa943fb3d	0x6063a1a8	0xbe68ef36
-	0x6ba0d5ba	0x0dbe2061	0x47711712	0x62679807
-	0x6f34009e	0xe6fe8f18	0x66a6a64b	0x3f80f472
-	0xe953d5e0	0xbcd8196a	0x086faad0	0x49da7f16
-	0x7f2199a5	0x55af4af2	0x085b4d38	0x22e634bd
-	0x6cff0416	0x343466f4	0xd121a7a6	0x6caa3942
-	0xe4f365a2	0xd832eb0c	0x616728e5	0xcca4c71a
-	0x4010cdc2	0xd0f1d1cb	0x5e695f89	0x27719206
-	0x0ec92854	0x76144a1b	0x49808021	0x12457a1b
-	0xdde7aa5c	0x8f1a077f	0x110a4a5a	0xb3a5ad31
-	0xaacebf8f	0x66ff7f33	0xa2340971	0xfb4c7e82
-	0x8dd536d7	0xafd2021a	0x72aa9c6e	0x22df6952
-	0x83c4b4fb	0xba515555	0x93eee8f0	0x22d0ed5a
-	0xbec05586	0x83828f28	0xe0d7f930	0xac0f0199
-	0xef6d76f9	0xf56ebdf8	0xf67323c9	0x8b805745
-	0xce5902c0	0xfa2ce3da	0x10f836dd	0xe1ac6d97
-	0xa0e415ea	0xbb7c32ad	0xc421f3b0	0x8166e898
-	0x74e7a73c	0xf454b82a	0x631369b1	0xe30ed23f
-	0xdaa1c75b	0xe7c9c6a7	0x5f33c375	0x99c05187
-	0xf2d6e6ae	0xcd2045b8	0x92ff3009	0x15082015
-	0xd1a1580e	0xdce25f9b	0x21984a75	0xa9be5388
-	0x099a5372	0x3ab9bcfa	0xdb9069aa	0x49a99be6
-	0x42a9ee0b	0xfe32d832	0x24e11ad3	0xd16f596b
-	0xb95982cc	0x754ab1c8	0x42ffa128	0x539e823d
-	0x28e0f976	0x262ddfc0	0x2a16e7ad	0x49b5acd9
-	0x931f3def	0xdc419b84	0x8412cc3c	0x81056cd9
-	0x91933e1f	0x57710b15	0xa55d2696	0x87d88724
-	0xd4fedfdc	0xcc3825c6	0x397f382f	0x80f9b6ba
-	0xcdd6d59f	0x24b984d8	0x8f1c5bcf	0x25bcef1d
-	0x00dc603a	0x76fd94c2	0xa267a7dc	0xa6e90a6a
-	0x5c5916d6	0x065a52cf	0xa28d3263	0x9b17b72d
-	0xb8436b48	0x1b1c2391	0x1fda3395	0xa6cecbcb
-	0xbc4ec502	0x1766b590	0x5945fbd6	0x6a124405
-	0xf92d06f2	0xe24694b7	0xf6befd08	0x8266cf5c
-	0x03ed670a	0x5f98be62	0xf27b7e2e	0x598cf22c
-	0x2e855591	0x879815fb	0x153799c6	0x3820faf6
-	0x3d3a2cc6	0xdbb6dece	0x1a3c46b2	0x5031bdda
-	0x47894c03	0xe43661fe	0x7a6ee548	0xa5ca9779
-	0x6aa9e105	0xbc8505a3	0xa03b860a	0x448faeb9
-	0x367de4a9	0xc9779c7d	0x6535ad8c	0x4b7fcacc
-	0xb2db5c10	0x0ab41ec6	0xe528ab90	0x5e6f03da
-	0x98bc76d3	0xf38df42e	0xea59b039	0x1c2eaa28
-	0xca30dac5	0xdb0eb8c6	0x60063860	0x18823f8d
-	0x164e2f28	0x7cbbe080	0x70a12315	0xb08f44d9
-	0x5fbb9453	0x4bc62738	0x9fa15ffc	0xe4033ca1
-	0xc9dfbc13	0x58245d7d	0x588113aa	0x8f5a6ac8
-	0x92588a60	0x26330c74	0xb2aaf0e3	0x24ada1ea
-	0xa9e973ae	0x624b73e7	0x4ef961db	0x95ede155
-	0xf2bb86ff	0x96bc79d9	0x95cd646b	0x1c3af453
-	0xf60fa711	0x10905115	0x0e24b740	0x169bb227
-	0x34cee6f0	0x990980db	0x18d8ace5	0xd4c87504
-	0x29515d32	0x2e5d9c04	0x87dffa60	0x12e815d1
-	0x021db8e9	0x2c5a42fd	0x6e3a1a13	0x88889ab5
-	0x3bc915a6	0x608919c5	0xd310a970	0xea8f3218
-	0x949f55bc	0x9ed7aadd	0x6d990157	0x181f1c2f
-	0xa940df64	0xf3be8c39	0x7ca2e699	0x7b4f07f9
-	0x89e83fee	0xe66b9493	0x54fc3d17	0xa63d2d46
-	0xd5e835d5	0x910e0144	0xecf67025	0x1fa6a93a
-	0xe692dbca	0x466af681	0xc2bc808c	0xbb4ebd60
-	0x74d5c729	0xa283ad25	0x1e66fa23	0x6d372988
-	0x753c9fcb	0x1742efdb	0x5b68cf15	0x372a0e33
-	0xaa3a7ebd	0xa0e944d5	0x95d5cbb4	0x4fb6020b
-	0xced927b0	0xb2afea78	0xd0646b72	0x1622fad4
-	0x4672c6b6	0x736ae4f8	0x8d46a4db	0x0e6a432e
-	0xe0a30a98	0x4c2bcf4f	0xd87acedd	0x19682d7a
-	0xf97c025c	0x55d8feb3	0xbcd4d2ff	0x236c6f9f
-	0x8ba0246d	0x42812f73	0x327636f5	0xc92cd30a
-	0x08a69d9d	0xc735a946	0x82eca01f	0xda0753a0
-	0x7077b1d1	0x17b05834	0xfa24bc02	0xf49f4473
-	0x8f9ac6b4	0xa880c630	0xf7457b4d	0xd5f829e4
-	0x25c49a99	0x1176a997	0xbb2d2009	0x61d35764
-	0xa322c752	0x6ef3ae02	0x5faae6f8	0x9a52acf1
-	0x19176f43	0x43843b07	0x14efc471	0xee474403
-	0x319c4857	0xa19adcf0	0xc0a466e1	0x02db14ad
-	0xb7f211f3	0x72aa6ca6	0x0eb9bffe	0x48a6d284
-	0x9a93a2ee	0xac09fc5f	0x92a62c4f	0xd34f0271
-	0xffb348c7	0xf229b6e2	0xc68ec1ca	0x19577dbc
-	0x069a10bf	0xf64ac347	0xf7c3c848	0x81975294
-	0x6376e550	0x93b53440	0x8bb17daa	0xc4c64c07
-	0xcaeff293	0xd51497b0	0x33da3565	0xa73d5def
-	0x4bf4dcde	0xfb470fcd	0xca7db864	0x7ef17022
-	0x47567363	0xd8fb8d74	0xa68c3c72	0x8202e4f3
-	0x75bf1798	0x16a70fd2	0xcc3b697f	0xab9a1075
-	0x13f56ef3	0x269d0302	0xcb655a43	0xc9a4de88
-	0xfb8363de	0xff40f36d	0xd2555489	0x647a7995
-	0xfd8eda6e	0xa3958c9a	0x20e029b4	0xbed3e225
-	0xa7df5f17	0x63bc3c1a	0x337ecc9d	0x6c329508
-	0x786aa47e	0x1db5b093	0xc0acd73b	0xf9587237
-	0x243e5d40	0xd3623c3a	0x338c4740	0xb672140e
-	0x43640a9b	0xb7ef3f6a	0x44151074	0x749bcc46
-	0xfa1f103b	0x0fefb19e	0x58855538	0x138ad276
-	0x2641fd80	0x297d99d0	0xfaa63ba2	0x00b6f11a
-	0x3793fb6b	0x124763a1	0x8b9419ac	0x56abf9eb
-	0xdbf83419	0x43570571	0x37299cd8	0x8b201e62
-	0xa4058fa5	0xb320e91b	0xbe7d40b7	0x4eca3b2d
-	0x8519c155	0xf4b17021	0x9e4c572a	0xdc1f9e16
-	0x39a589a3	0xa6cfc7a8	0x5b986910	0x64e150e7
-	0x60b6f2c1	0x02bacd3f	0x2f3b5a5c	0xc6f453a8
-	0x15a87a7e	0x76104a14	0xafa2ef63	0x2cd48dbe
-	0x3c7abddc	0xd786ea5a	0x4f65867a	0x355cda38
-	0x2ae03d9e	0x4f11f6be	0xfc0a0034	0xde4ea602
-	0x21ff83ea	0x0f12d913	0xedf4da28	0xc96d8fd1
-	0xd7e82c3c	0xfec63bdc	0x37a456d7	0x3007e18c
-	0x091a47b6	0x82f1c641	0x82219cce	0x3e7e6993
-	0x7b3a2115	0x0b8e1a02	0x40f88213	0xfa2f9c21
-	>;
diff --git a/arch/x86/dts/m12306a9_00000017.dtsi b/arch/x86/dts/m12306a9_00000017.dtsi
deleted file mode 100644
index 299d663..0000000
--- a/arch/x86/dts/m12306a9_00000017.dtsi
+++ /dev/null
@@ -1,750 +0,0 @@
-/*
- * Copyright (c) <1995-2013>, Intel Corporation.
- * All rights reserved.
- *
- * Redistribution. Redistribution and use in binary form, without modification, are
- * permitted provided that the following conditions are met:
- *	.Redistributions must reproduce the above copyright notice and the following
- * disclaimer in the documentation and/or other materials provided with the
- * distribution.
- * Neither the name of Intel Corporation nor the names of its suppliers may be used
- * to endorse or promote products derived from this software without specific prior
- * written permission.
- *	.No reverse engineering, decompilation, or disassembly of this software is
- * permitted.
- *	."Binary form" includes any format commonly used for electronic conveyance
- * which is a reversible, bit-exact translation of binary representation to ASCII or
- * ISO text, for example, "uuencode."
- *
- * DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
- * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *---
- * This is a device tree fragment. Use #include to add these properties to a
- * node.
- */
-
-compatible = "intel,microcode";
-intel,header-version = <1>;
-intel,update-revision = <0x17>;
-intel,date-code = <0x01092013>;
-intel,processor-signature = <0x000306a9>;
-intel,checksum = <0x3546450b>;
-intel,loader-revision = <1>;
-intel,processor-flags = <0x12>;
-
-/* The 48-byte public header is omitted. */
-data = <
-	0x00000000	0x000000a1	0x00020001	0x00000017
-	0x00000000	0x00000000	0x20130107	0x00000a61
-	0x00000001	0x000306a9	0x00000000	0x00000000
-	0x00000000	0x00000000	0x00000000	0x00000000
-	0x00000000	0x00000000	0x00000000	0x00000000
-	0x00000000	0x00000000	0x00000000	0x00000000
-	0x86c5b0d4	0xf6978804	0x7f4f5870	0x6319dc3c
-	0xbb3b7d61	0x33cf9075	0xe8424658	0xf611a357
-	0x5a3401db	0x42caecce	0xb4d8e75e	0xe6dbaf24
-	0x7861b35f	0x6bd717bc	0x23b9b731	0x82ec1ac8
-	0x20337b64	0x5396dbf1	0x59973bff	0x724bc7e9
-	0x5237193b	0x0b8647c1	0x6a0d0e16	0xbf9ddb5b
-	0xace2cc1c	0xad707638	0x056f102f	0xa37e60f8
-	0x76255642	0xfb86e030	0xb8069a40	0x367795f1
-	0x653fb05e	0xab7f14ad	0xb6e8a8e1	0xd2598d20
-	0x2eba3f68	0x78b372f1	0xba8d13f8	0x1f1de861
-	0x97f951d5	0x8097c728	0x27dbf904	0xb97906a8
-	0xffe7a4ac	0x4b947668	0xc1dbd726	0x2adcf777
-	0x63b1bcf0	0x818e2a1b	0x49aa907b	0x2faf5e8d
-	0xae842352	0x82707fae	0x0aa12b41	0xa0bae11c
-	0xb4298c47	0xd2b4099c	0x4ff625f2	0xcd2630d4
-	0x79850981	0x05dbf57d	0xb05b81a5	0x56e73ec7
-	0x95cb3897	0xe262bda5	0xb2c6e288	0xcb7f8e77
-	0x72b8bdd3	0x3f400494	0x63ade65b	0xbc4adc71
-	0x00000011	0x06c0f8ff	0x0eb63d77	0xc54cdabf
-	0x76bc8860	0xdd142643	0xe7bfc220	0x17aa0a91
-	0x4fd676ba	0x4b6b1a15	0x2a1a1c16	0x4fed6de0
-	0x8c3d6bcf	0xbb319bf6	0xa82532f1	0x7c8ce014
-	0xb830a38b	0xec25bc6b	0x61c8a8a9	0x49a21dba
-	0xfcf8bad0	0x7372f29c	0x1f7fbcdd	0xc2ff42f4
-	0x780878f0	0xc967068e	0xe19cc3c9	0x155e6646
-	0x75235c43	0x9aaf3741	0x9dfd116d	0x0f031b6a
-	0x4963e039	0x6918daa8	0x7f0ca4ab	0xd77dad79
-	0x2f8847e8	0xf79c82a4	0x6a6aaad4	0x24f07dbc
-	0x895d3f6a	0xc96b2eb0	0xff50228f	0x573d364a
-	0x5fca9d56	0x3c11c35b	0x3e90fb12	0xc4604067
-	0x5c980234	0x7c42e0c7	0x60cca3de	0x637a4644
-	0xedc43956	0xb0efb4e1	0xe94716fa	0xa6478f51
-	0x33965654	0xdf6b40a3	0x48ac1b18	0xd6723c94
-	0xf040d6d1	0xaf850470	0xe2bcde48	0xb90a4998
-	0x8f620105	0x3d592878	0x2f697bad	0x9f7721d9
-	0xec34444a	0xb0594770	0xd7180f9f	0xa510a168
-	0x460563b0	0x5d4f34f4	0x21dfc16b	0x051de344
-	0xa57bc344	0xff2c7863	0xf0bc063d	0xf5a89004
-	0x79a81dab	0x9e8cb974	0x2309b0a4	0xa47a46de
-	0xcf9c0c44	0xf761c817	0x67ab642c	0x0db4422f
-	0xca3616fc	0x79e66c8a	0xd56a3332	0x5e0f338b
-	0x5814cb3a	0xed1b9a4d	0x47d59f72	0x25b03786
-	0x3edd1d42	0x8cd947cd	0x706e6ebd	0x82c2bada
-	0x1bf6a96b	0x77dd859a	0xda35335f	0x22fab458
-	0xd0661fd8	0x02bb4a42	0xe2a2bcdb	0x0616580e
-	0xd35be23f	0xc206d16c	0x401218be	0x51107c3d
-	0xba84b8be	0xace4d8f2	0x505b9b28	0xc517034b
-	0xac5ba582	0x7419fe54	0x43493cb1	0x2fe0a66e
-	0x206039b5	0x07569011	0x230ce53d	0x168d427f
-	0xbfe0bd10	0x82bf11be	0x5b55475b	0x5490a0e9
-	0x1c3c1e3c	0xacad77de	0x1666512f	0xfc3250d8
-	0x930a6312	0xdd85c066	0x1b95c18f	0xc8bbd3b0
-	0x1bb2a34e	0x642c7653	0x0f536213	0x1f7ab4eb
-	0xaa5ef677	0xe6ac9581	0xd7a2fe73	0xd417dc79
-	0x455a6877	0xae825a40	0xe0c98bec	0xac39ba49
-	0x299d9bd9	0x957d0bb0	0x1645111b	0xe9da4beb
-	0x1b005ce7	0xddb742ce	0x6c5f3ffc	0x24f74d2c
-	0xf4ace044	0xb21bc7ba	0x338002dc	0x240effa1
-	0xd208ae00	0xfe8c2b5c	0x9a457293	0xd9365ac4
-	0x98f24244	0xf6d1aaea	0x7b874350	0x1ba4086b
-	0x1d3bf168	0x2bb6f4fa	0xb27f8477	0x8da836f6
-	0xa8762693	0xc377fa64	0x74cfd979	0x90435c25
-	0x29d80e17	0xc3503c9c	0xaacd2178	0x232c748d
-	0x6fecd3ba	0x00fb4aa0	0xbac3ee19	0x6e5c63e3
-	0x17823c14	0x0e9d33bc	0x0fa9de06	0x998b14b2
-	0xfdd8c80d	0x01b0591b	0xf70bc4ce	0xb278c496
-	0xa7e30708	0x69cf8420	0x14f8b744	0x8bb8a0ff
-	0x168f6db0	0x95da6db2	0xf96d121d	0x67fd06f7
-	0xcd81d278	0x8693d095	0x15e1a24c	0xe5f554f2
-	0x499874e8	0x30fc0785	0x0f4fa1b9	0x65c93dad
-	0xd939bf24	0xdad29721	0xf253b752	0xf6ff59da
-	0xc5dfaffc	0xf0071f34	0xdb0db8b0	0x24475e2d
-	0x2a4d5b8a	0xf7624bea	0x3fdcbc90	0xb5a66e35
-	0xd0f08636	0x24643caa	0xc5d08e83	0xb134c55c
-	0x8e3653c7	0x34496b0c	0x6b2aeebc	0x2fbab601
-	0x105613a2	0x7babd55d	0xa01af846	0x248be690
-	0xed27917c	0x26ee6e13	0xa1dac5fe	0x852ed91a
-	0xfc83fcca	0xdf479c33	0xfd6efe96	0xdc62521b
-	0xa37d2a8c	0x1d2bad9e	0x4287614f	0xc4f7b62c
-	0x2aab0562	0xec6d4226	0x52853fb4	0x264e3507
-	0x1c3af366	0x33269776	0x81b8529d	0x115530dc
-	0xe035f98f	0x433d1b6c	0x1ea6daea	0xecfd2ad2
-	0xa57a0c22	0x1dbe3e12	0x6fafe41b	0x8e579e35
-	0x6c493fbb	0x034dd4f9	0xd17cd6f2	0x05c5cfa8
-	0xd9bffa39	0x0fc16e9c	0x831b88c8	0x7e7dce3e
-	0x3320bc7f	0xd5abafaa	0x217ab526	0xade2597d
-	0xf01b00f2	0xc9e34b72	0x00a4cb0b	0xdc198512
-	0xdc7cc8a1	0x89db07b5	0x6c2153ea	0xb8bdb8aa
-	0xdf8a1ae8	0xa517f6b1	0xd32569d9	0x37e79008
-	0x3c7527c3	0x7d5b2d3b	0xb31cb907	0x35db7f6c
-	0x0ab0cd65	0x75feaded	0x7c8260a9	0x5bc04f56
-	0x2fac9f60	0xd7b3a2c0	0x2b393634	0xc2df7f43
-	0x1ff2fa9f	0xc81af169	0x188b1f4e	0x08bf6f86
-	0x5ab2f188	0x0a71eb64	0x03b57501	0xa684fc23
-	0xa729ffef	0xe3b4a709	0xf9eb97d2	0x01506c95
-	0x0d9285f5	0x8e1ee93c	0x7d15a0d8	0xd9390673
-	0xf116ebd8	0x7e68798b	0x3dc8412e	0x5a9a04b4
-	0xe3805f51	0x00493bb1	0x4ec65ca2	0x2aedd69a
-	0x7f2a5b18	0x9994ac32	0x476f3703	0x7d3da882
-	0x5635f55f	0x7a0887e0	0x0af46feb	0xfc2f3591
-	0x02e29400	0x70fd3234	0xc549379e	0xaf34fa5a
-	0x5bf7c649	0xeb183cff	0xa236d508	0x4525ab64
-	0xc4301026	0xf281df99	0x0b298e46	0x9b7c1a99
-	0xc4b24e77	0xea536992	0x5a39e37c	0x570fb6df
-	0xae5d5c49	0x01142cc2	0xda05d3f1	0x337bf65c
-	0x3c986598	0xbecefd30	0xb5e34c2a	0xe7c3847f
-	0x18cb24b4	0x71278c26	0x4b8d6caa	0xaf7c300e
-	0xfb6ce9b8	0x94c4b785	0x67275f17	0x59498cf5
-	0xca8eeec6	0x3374e7a6	0x649affac	0x9049ba78
-	0xff9d3908	0xaceec446	0x225ece3a	0xac1d4fec
-	0xdc050fed	0x04e3ed8a	0xb303d8e9	0xe9d26aff
-	0x0a98691d	0xf243492d	0xe3b42f00	0x6c21a97b
-	0xa385ae98	0x14ba3f4d	0xc0215cc1	0xe1ba6c0d
-	0x412bbbe4	0x39f95d1c	0x593bd878	0x45d3066a
-	0x9fcee8a1	0x3f29b2fa	0xc9ae58ee	0xed6def92
-	0x6c8f2182	0xdba64e20	0x276c2c21	0x81ea9dfe
-	0x20ae00b2	0x8c2d2724	0x66c09f5c	0x24908e2e
-	0xfecf8194	0x6be61e94	0xcdf5d7db	0x98b829a3
-	0x4241ab07	0x1207ef2f	0x96e7b073	0x766293ea
-	0x58eb0882	0xf12a6426	0x741b074b	0xbd4302cb
-	0x909b6c4f	0x1c4949cc	0xd4d6a3e9	0x442b74b3
-	0xbc8cb3f9	0x0efad89a	0xa2ceff3d	0xecdf86bb
-	0x46a4a72e	0xe9d8abe4	0x94c91479	0xe99a80b9
-	0x1072b708	0xb8318ad3	0x0685426f	0x3e89a0d8
-	0x0b7c438e	0xb4b577d0	0x046599e2	0xd0ef85f2
-	0x3566d2d2	0x43ade22b	0x8753a78a	0x8f6d8e02
-	0xbdf33e56	0x8b2b6696	0x22a5e911	0xd0e0f4eb
-	0x42729c29	0x425921fb	0x82f7634e	0x2c145fd5
-	0xff59deeb	0x018a5372	0x33c4e11a	0xc001c097
-	0xf250cfcf	0x2f682912	0x21f40dc0	0x883196aa
-	0xcd5c58d0	0x7c329754	0x481c450e	0x9411c6c0
-	0x69a9df82	0xacb01a1a	0xc0b569a7	0x0b7fd1a9
-	0x4c339ad3	0xb0d9e211	0x07098664	0x14a5cff9
-	0x53beae37	0x4e173257	0x4e1d2e6c	0xce981dd1
-	0x45d6204f	0x3c193268	0x4f51ac3c	0x5ecffa12
-	0x48068ee9	0xde12270f	0x0a0aa980	0xd6fe8ca2
-	0x97d51da8	0xccf2db36	0xb3ad0598	0xbc56eb56
-	0x0adf5e5e	0x9e320aa1	0x8ebb75ef	0x3973a323
-	0x7e3d87e0	0x2c0d1858	0x83b7fa0c	0x36effdb5
-	0xcd9eba1a	0xab5b5790	0xa48fbf00	0x536e2ae9
-	0x2f2a3f61	0x05706a73	0xd2dfed08	0x7e4626b1
-	0x172c6ced	0xbf2e44ba	0x15aefc2e	0x9cf56c37
-	0x663c6695	0x04cece5f	0x4ce00027	0x465b1cd4
-	0x333dc2c7	0xce41f1f1	0x6dd8503b	0x52b79af7
-	0x564c81de	0x0e5e2daf	0x869753f5	0x16667889
-	0xe1acaf08	0x38ffbb0b	0x83400589	0x5144052f
-	0xa3819950	0xd21501c5	0x1bdadeda	0x0a874e2b
-	0x05480284	0xe8f76f11	0x582cad8a	0x0553f942
-	0xb6451cb9	0x76bdc86f	0x96ffe0c7	0xc630eba2
-	0xa82ec683	0x5902ef45	0xc362248c	0x18c412a9
-	0x1d09c103	0x2355ed98	0x5ec5c718	0x5037e359
-	0x1508f804	0x09cfea9d	0xa16cbdfa	0x5f962b17
-	0x85a35a27	0xa048dd30	0x6fe7ba90	0x0dc20150
-	0xcb56daa0	0x4188fb20	0xb4182598	0xa1bc5dd7
-	0x8c11e0bf	0x2104df35	0x025e74b8	0x79d177df
-	0xad74bb77	0x4b2419aa	0xe374add2	0x411593d5
-	0x796778da	0x9e43a420	0x4a2e0860	0xefb48578
-	0x47cafbdb	0xea15924d	0x70ac1467	0xf52fd888
-	0xd2df4bd6	0xc1fc63bb	0x119ab88e	0x0e147ead
-	0xa85bd8b5	0xc2e61ddb	0xd566417d	0x6bb9f9ec
-	0x69bbcf1e	0x24d46989	0x3caf067f	0x58151211
-	0xc2a6b6e5	0xb233416f	0x3da28155	0xf9cd9385
-	0x7a530045	0x1eab05ce	0xb86ed141	0xa8f13a5b
-	0xf9819f81	0x66d5d5c5	0x148c1a02	0x496d3c56
-	0x370dcd45	0x5f13f0b6	0xdd4eaeed	0x8dbad50d
-	0x0747ce54	0x69d2adcc	0xfb69c18f	0xd44ea186
-	0x74ab7537	0x0c642449	0x88b096cf	0x3a8ad683
-	0x408cd7aa	0x6daa6708	0xb267b312	0xa4225c7a
-	0x7a56dce7	0x6a8d497d	0x8837bcbb	0x6125397c
-	0xeb51d233	0x362bdde9	0x689657f7	0x32d09e1f
-	0x753a3d39	0xf77db5b2	0x8057908a	0xef12815d
-	0x594fffe6	0xcf3402c5	0x1a0d4923	0xca547b2f
-	0xaf9d604d	0x5d2e30f3	0xffe18005	0xe29bb0d9
-	0x36fc10f9	0x3720aac6	0x37bc1ad3	0x47d000ae
-	0xa4b0da0a	0xa178228b	0xdd9374e6	0xa1f3df5f
-	0x9ae2e451	0x21c4aceb	0x8f9fb226	0x5190b712
-	0x70253633	0x9c9cb5f1	0xc9178689	0x551c1a2d
-	0x6db67cc0	0xcf1b1ade	0x48449272	0xd18634f1
-	0x9d9c3de7	0x19025530	0x121d78d4	0xae4a39e1
-	0x62850819	0xf3d4af6a	0xe5ad5b80	0xfa053c7d
-	0x7ed68b9a	0xdbde2894	0x4b5c04de	0x65178203
-	0x9181cdd8	0xb17e27b9	0x0e29b338	0x50156ab4
-	0xf7726438	0x178108d6	0x1d8dc6b7	0xc3e7512f
-	0x0eb8339c	0xe2684a6f	0x7668ed31	0xd0ed6eda
-	0x4342a534	0x03840286	0xad1e6969	0xa9a6c98d
-	0x1bf77774	0xd32fc9d8	0x405620d2	0x8ab19efc
-	0xce4d7506	0x6f4eaae4	0x3e830dbd	0x76818782
-	0xfde4ee8d	0x1953cd0f	0xd47be276	0xf2480bc0
-	0xd1010013	0x2dd56a58	0x083084f4	0xc91b0ad6
-	0xc2524e12	0xa60710f2	0x3d955047	0xce380846
-	0x0f6dec2b	0x604d1492	0x5ca43ee1	0x6b51a626
-	0x350d5483	0x8d99ae30	0xcba06491	0xcc0185eb
-	0x7b64caa6	0x2f1754db	0xca0691f1	0x6219efb6
-	0x43291db0	0x259d3f12	0xeaf6ef9f	0x5f0e065b
-	0xad576541	0x8615a414	0x81124bdf	0x62b855a9
-	0xabdc529f	0x01bfdf75	0x10e4c656	0xf8e86f78
-	0x1fbe10d1	0xa6873c2c	0xdf83dcd8	0x20d35872
-	0xf46f2861	0x22f3d642	0xfdcda29a	0x16adbdb4
-	0x01e5844c	0x011e5454	0xf5432b04	0xd5f6a80d
-	0xb081fab6	0x64fc2fbd	0x4ca76e0f	0x3a8d8b29
-	0x3f03ec12	0x58e2bf6c	0x24f2b8b1	0x108e414f
-	0xe76a02ab	0xcb525af9	0x623ba7a3	0x31412c27
-	0x69c2f5db	0xd5546d8b	0x8200d2c9	0xf1e34a71
-	0x393e24dd	0x2b867933	0x0596e778	0xc5112b49
-	0xf433cdea	0xbc505e7b	0xf64bb064	0x1e892633
-	0xbf17307b	0x9118de2c	0x6b1d61a8	0x1945519c
-	0x32638ca4	0x5e436733	0x3dc20ff6	0x9babf127
-	0x485c1555	0x0d0c4e2d	0xc4d5d718	0x8cfffc16
-	0xf64050db	0xaa4ef416	0x8d398a00	0xe4a16eca
-	0x5d9d9314	0xefa2bf1c	0x05917dd4	0xca5f1660
-	0x59642534	0x02639b9f	0x12b895df	0xb2deaf0e
-	0x20d8f0b9	0x04d8342c	0xa1ba5f57	0xa26cdb06
-	0xca732ca8	0xdce0c561	0xf5e4b205	0xc05f5cfb
-	0xba4a41a6	0xaf219d7b	0xce08df01	0xa02bbdb9
-	0xc1adbc20	0xcb9ae4fd	0xd828cfb5	0x690b17db
-	0xd29ae8bc	0x8fc71289	0xd6fc9cf6	0x61c7a6fc
-	0x8e8012d5	0xd3320498	0x36e80084	0x0036d3ab
-	0x53141aae	0x987d0cba	0x57581df5	0xace4704c
-	0x3ce49642	0x991556c1	0x6cb0b984	0xac15e528
-	0xe7d208ca	0x2486d1c5	0x93b6623e	0x340b7622
-	0xe7e1cf7b	0x3cdeed88	0xa23c849a	0xcc6e8b3b
-	0x292add5a	0x17763ee1	0x9f87203e	0x72cf4551
-	0x2053e66f	0x06c3a411	0xb61c2e0c	0xa4a7f3ae
-	0x0ff87dbb	0x03999ed8	0x48aacedc	0x2e126ef3
-	0x799441bb	0xaee15b4d	0xea08bf54	0x47248787
-	0xb60afc11	0x8c3d6a20	0x7c04f801	0xb902760e
-	0x319040eb	0x370bbd5d	0x9a1dd5e6	0x63f7da1d
-	0xb3784eac	0x3b304dea	0x987ada9f	0x2b6b1cda
-	0xf9241003	0x0d3d16f2	0x1185dcbf	0x519b7a5f
-	0xeb612361	0x28b57da5	0xdeb8419a	0x0ba13122
-	0x062e28fa	0x5ffb9b36	0xb1258247	0x8337401f
-	0xed1f6423	0x730cafe6	0xf728c690	0xe40557eb
-	0xc4951a15	0x04a988a9	0xbf5fe18c	0x2766e40a
-	0xe4d74d13	0x8638d052	0x8eefeaf2	0x9ad07978
-	0x32042a87	0x4385f38d	0xc9b48f02	0x02ab0ae7
-	0x9eaeb632	0xf386c14d	0x8b1c2ab2	0xad432a24
-	0xfc5bd462	0x2d7ac5fe	0x45dff5c6	0xa235e1a6
-	0x825b770c	0x5568471b	0xa7ac3a3a	0xfcc6e40c
-	0x0c1be59c	0x77685a3c	0x5b1bafbd	0x40b8a139
-	0x3dd1bf01	0xb6651001	0xf2915a6a	0x16fe1cf2
-	0xe78467d1	0x4bec9fb1	0x88615320	0xa3920831
-	0xed4afac7	0x206cffba	0x96c42567	0xcc2b5215
-	0x7ca0193f	0x0e1a60e5	0xf3892c10	0x2ceee7b2
-	0x110d3311	0x9a322e7e	0x3cb7e5fc	0x3fb971c1
-	0x59971332	0x08386001	0xe4a2444d	0x17d9c47f
-	0x9f53c4a5	0xdb54e5c2	0xfaac9f08	0x975c07c6
-	0x8a6e6bcd	0x4392053a	0x6473bef8	0x4b3b91a3
-	0xfb7e8ebc	0x46c6ffed	0x04939839	0x71b93766
-	0x47e4f74a	0x786545c8	0x77f55b59	0xdf8e992d
-	0x60a0d2a5	0x6cc8a5cb	0x113ee95c	0xa378558d
-	0x5d3b8bd9	0x3c95b2a8	0x6efa3682	0x9535dd34
-	0x3e29974d	0xa477d069	0x2dbf58d2	0x165edae3
-	0xea25d53d	0x44e3ef71	0xba6341cf	0xc61b964c
-	0x4612838b	0x62151b9e	0xc1de2511	0xa364130c
-	0xa9710643	0x1a436c70	0x97030b09	0x5cef28e0
-	0xd5197e49	0x02b9ffa8	0x1b52dc7b	0x04f9428b
-	0x01ebed2a	0x1eaecbee	0xc53c4d54	0x3e34c125
-	0x05b4f37a	0x6e3d042b	0xf1c1f40d	0x39cfe9e1
-	0xd2938e89	0xa14b9846	0xb1333676	0x31068254
-	0x4b627e4b	0xb5185882	0x101b52bc	0x73e05abf
-	0x68a4e24c	0x67e301f4	0x6bf8b538	0xc502e1e1
-	0xc3889b5b	0xdfbc6d96	0x4239d0e1	0xbf3667ab
-	0xb0c4cb00	0x3efdcffd	0x7cd9661d	0x4f5eca03
-	0x0ef218dd	0x464f0826	0x048fc539	0x6a1c63fe
-	0x76cc341a	0x1ae2945c	0x7a339006	0x858fdc20
-	0x2a4a7270	0xd4cbe12c	0x7b27e5d8	0x998cf520
-	0x4795ccf7	0x52e15388	0x86aa7b96	0xff1845fa
-	0xd49d1061	0x035b6a80	0x1df18220	0x28fc4fd1
-	0xa8e8f333	0x3a9240a6	0x41a4caca	0xee736b6f
-	0xdfa7ce4b	0xd4bf5c0c	0x4e62f6d3	0xe98ae9b4
-	0x7f544550	0x2b0706df	0x8fb2e752	0x546af9d1
-	0x8517758f	0x53f522fc	0x03bd1819	0x6fd264e2
-	0x16839ef8	0x44a1200d	0xcd5a586b	0x1ead251c
-	0xf58dd3be	0x80217ce7	0x0367ff42	0x2d8f2ce8
-	0xe8a0a689	0xba33e366	0x5dc7980d	0x005c0eaf
-	0xc0c44118	0x5553076a	0xdaf39389	0x703e09eb
-	0xc54c8112	0x4a26135c	0x36a46f2b	0xdc93ee12
-	0x7060db72	0x7778befc	0xe028fc55	0x52e86278
-	0xd0b00188	0x6ed5565a	0xb5e2785c	0x3608bffa
-	0x55c3f5a3	0xe1e41afa	0x08a227fe	0x94c793ce
-	0x650934f7	0xddc36524	0x6dac40de	0x9eec3ceb
-	0x8fe3d1cc	0x3cebab86	0x61e4d63a	0x5382ea11
-	0xa90c9495	0x0277ccb3	0x412cecc1	0x5853c945
-	0x97df9a48	0x364d9b10	0x7e8c9bf1	0x6b4974ef
-	0xd3dbaeeb	0x6626dd26	0x2b746d2c	0xfb762155
-	0xf942f687	0x1317d1b5	0x0c989def	0x5f4c0ed6
-	0x31aebbd3	0x51cd8d5b	0x3d729511	0xc07c8f23
-	0xa7f3e6f7	0x7683dba9	0x5f051d5c	0x750437f5
-	0x1b9ffe98	0xa4de609b	0x4c498e9a	0x18dfc535
-	0x376c6c34	0x19a57039	0xa70e93eb	0x7e966bc7
-	0xb6e9d77a	0x3ab98e5f	0x1607125e	0xe8845aa3
-	0xa20a2d80	0xb17ac63b	0xa07a9790	0x71e5a14f
-	0xb6b5fc78	0x4c610f86	0xb57b21b6	0x1bcfb3ac
-	0xbf812998	0xd429986b	0x02b837e9	0x0823aca8
-	0xd8a85194	0x708bad39	0xff94ef19	0xc3599461
-	0xaee622f6	0xa8b5a808	0xf801b298	0x0aeb35b7
-	0x4db4bf27	0xfa31c205	0xa047dc66	0x7e0ae406
-	0x2ceea6cb	0xef0ef96f	0x4cc4fdba	0x6161256f
-	0x94505fd1	0xbced5596	0xbf9e36a5	0x271e68bd
-	0x7a3308b6	0xef1af50d	0xb55ede06	0x6783e602
-	0x1152acf0	0xdc644ccd	0x1b692da3	0x59f6886b
-	0xd7236158	0xe39d75a6	0xe7026697	0x25496283
-	0xb6b0a61c	0x09d0931c	0xe8d459a1	0x1a124097
-	0x88e50621	0xf2ed18ff	0x37681783	0x4afa1ffc
-	0x8a96ec4a	0x4474a860	0x274591b1	0x59df3968
-	0x34f56fb9	0xce821f96	0x7ec825b2	0x6ed4a9bf
-	0x687253cf	0xa511c1d3	0xaf2bd6f0	0xd1ce1a5c
-	0x241dd505	0x39037238	0x0c761934	0x53181db5
-	0x11ad47ec	0x915a527b	0x748bc970	0xeb8f2669
-	0xb8bfd5af	0xd8d19145	0x0361ff58	0x6dc6e2f2
-	0x1fd06556	0x120db4c5	0xbd704c8b	0x70a1a57c
-	0x27543851	0x095403a6	0x28171887	0x640e7c92
-	0xb48fd7d1	0x62ad2774	0x224767cd	0x347b8843
-	0x821ca7f3	0xf94749c6	0x2bc7f40f	0x700cc1d8
-	0x50d50832	0xc2f9465c	0xa6e1cbaa	0xe0f5e934
-	0x7f33617f	0x8876cb07	0x408c24fe	0xc0cfcdf7
-	0x39152b72	0xa0ba80ab	0x301a73eb	0x6e704f6c
-	0x3b73c24b	0xd433f861	0x43192007	0xa56d2ca4
-	0x2d28bd5d	0x14f4c9cd	0xb7fe189c	0x031e1818
-	0xf8f4133e	0xdc8e7727	0x4f8f5a06	0xe7b114cd
-	0x5cb9ff12	0xdb4c5a53	0xed956df5	0xf3634f5f
-	0x6cce1cc2	0x5393f9ac	0x1184c2f7	0x0b6fd240
-	0x64771374	0xaafed1a1	0xbdc55bcf	0x976414ef
-	0x6a333e56	0x0c5cefb2	0xff2574e0	0x11b059ef
-	0xff8b7f2a	0x9651e97b	0x594fe89b	0x7be60f6a
-	0x7b7695ac	0x612036f7	0x5be0d4fa	0x25855737
-	0x12e32ee2	0x8e86130f	0x46d75d41	0x3769d438
-	0xd14752d4	0x1612ad6d	0x8f86f2a0	0x63e01251
-	0x9a44ac4a	0x49fdb148	0xe1757062	0x42798804
-	0xf21f46c1	0xed0a3794	0x5528add4	0xeddc0c90
-	0x7f188ce8	0x59568b7a	0x8e25d50f	0x9277c492
-	0x955c6e6a	0x79f94a59	0x3a65fb08	0xceb23267
-	0x7d8dce01	0xd15c492d	0xa35f005c	0x0e7cba9a
-	0x950485d9	0x2d92e448	0x4aced016	0x0d10136d
-	0x3d2ec365	0xd982e881	0xe81940d2	0xb1a84849
-	0xdb30d967	0x9f51d3d4	0x4fbe18a9	0xef21cd28
-	0x5d3cba6c	0xaa89b02b	0xbe1e9526	0xa20a918e
-	0x0c26bd72	0x8372eff8	0xcf7ab414	0x1d3ab83f
-	0xfd2c8f79	0x4929f77e	0x2416e8df	0x65dcaaca
-	0x58fbf7b3	0x1c4a3089	0x9bfb6e26	0xc7338ac9
-	0x88e5ad26	0xc62bb3d4	0xad6d36f5	0x6445167d
-	0xe9de8daf	0xc391c6bc	0xa78b4558	0x0216bcdd
-	0xbd4365b9	0xb0a874b2	0xe95e9453	0x77296b9a
-	0x49803c1e	0xc01fd0ed	0x165a9d5d	0xf7da6442
-	0x4c00818d	0xaad5bfca	0xdb252937	0x0e4e0f74
-	0x0c2738e8	0xd075b8ba	0xe3b2df11	0x8aee60a4
-	0x36052cd8	0xb4aa190b	0x413e7155	0x3e7e646d
-	0x807e6eea	0x97993e6f	0xa5129ff5	0x98e01bca
-	0xa8bd70c9	0x8800721e	0xb3407ffa	0x266b2f99
-	0xd9da73ee	0xa06f634a	0xcaae53b1	0xd98e53c6
-	0x49368291	0xc89485fe	0x938a8a29	0xb57f77cc
-	0x58c867de	0xcdac8a84	0xf4d57b6f	0xc6daf080
-	0xe3d9c67f	0x0264b194	0xc3b2ca50	0x6d214667
-	0x88503872	0x549ed8cf	0xe827689f	0xcbe94e2e
-	0x4a02516d	0x24ddcfa1	0x3cbc736e	0x34c88707
-	0x9f4c9376	0x4ced4d41	0xfdbabfb5	0xafd291d9
-	0x2fa602a3	0x53e19d9c	0x44422427	0xf85e2c53
-	0x40e91ef7	0x02646045	0x3d1fa703	0x1613b99f
-	0xa108de10	0xf9cb3d04	0x7b9f9523	0x007d74b1
-	0x961771dc	0x2e49fe1b	0x5fefe27d	0x54737b43
-	0xa11d7c40	0x7f0cc2d9	0x67c6533e	0xd1ab10fa
-	0xb1950645	0x536087d2	0xd6937b40	0xc35960c1
-	0x2df0c356	0xecb5ab53	0x61e08998	0x1671bdd0
-	0xd72935b5	0xdf1a9d7c	0x70b1aa4e	0xa9272818
-	0x1f7b8d55	0xc7292a0f	0xda7af847	0x190076ad
-	0x58370ba6	0x3020fb4e	0xff8a4b30	0x13818958
-	0x6ba1ca38	0x6a90d39b	0x5e180929	0x206e8a22
-	0x0568f241	0x5f83ad21	0xef05e5c6	0x21d0521c
-	0xe7886eff	0x68eebbce	0x550c1659	0xa0843444
-	0x19468c2b	0x539cb9b8	0xa4b18b62	0xdab0680e
-	0x1b254dbc	0x47068aaf	0xa8193743	0x44b60b88
-	0x90c07337	0x2e55666a	0x632f4b23	0x68af10db
-	0x8e29f54b	0x5f436bcd	0x8bf81d55	0xb640ccc5
-	0x2e4ab6a9	0x198697a5	0x8a1c8481	0x572fb679
-	0x7597c416	0x608fd45e	0x57c8c7f4	0xe151d349
-	0xed9e17bb	0xa66f2816	0x8175fe68	0xd57d91ad
-	0x79df0711	0x7a349868	0x13403cd4	0x7d974c60
-	0x8860ce70	0x2e6d62ea	0x8916e2f2	0x0e336838
-	0xf54d382d	0xc4e172c8	0x94bfcfbf	0x5fa53172
-	0x2933cecd	0x4d5b8439	0x0ca0e6e4	0x8ef87b00
-	0x2fdd121c	0x24beae76	0xa85b47f4	0x4e38af2e
-	0x12b8734a	0xf698abf4	0xde2c2d93	0xeb100795
-	0x8ab19df8	0x93a6f4d1	0x43c4b2cb	0xbaff7c4a
-	0xf52b1471	0x72804f4f	0x0c0ca257	0x1dc24c77
-	0xbad7203b	0x3a998fa0	0x9cb20388	0x7ef1fb3b
-	0xbae66020	0x9a22144f	0x39ac47db	0x3f145996
-	0x05a32b6c	0xd201a2ec	0xd868727f	0x08b2df4f
-	0x4583bbfa	0x9a422baa	0xa6a2e8f5	0x236310ec
-	0x5aafc3cf	0x344156a6	0x6f964ceb	0xed0495ae
-	0xb5638c98	0x2c8e84ba	0x63d8c7a5	0xec956b66
-	0x69c54f32	0x767874ec	0xe8fb6ce1	0x68b1c780
-	0xe4b861e4	0x2787cc38	0x4b2202e7	0x23b476be
-	0xecdf296f	0x094aa000	0xe95ef073	0x4182ebb5
-	0x30daa31a	0xef68cb68	0x2fbcf6bc	0x21c52620
-	0x19abf83e	0x4de7528c	0x05fe4c05	0x32c2a1e9
-	0x8c23abdb	0xabba9a90	0xa6a215c1	0x891f915c
-	0x667cd65a	0xaa5a9b2c	0x689fd1e9	0x42b52c95
-	0xd9872e76	0x05dd5278	0xc19798f7	0x8d031d86
-	0x25690670	0x165f4b19	0x76b51d6f	0x61cd8232
-	0x7b530271	0xa8e9326c	0xd952e94d	0x56a7021b
-	0x128be860	0x4da40144	0xeb4ac3d5	0x82b7ff5a
-	0xea2abda7	0x690a9ebc	0x33562378	0x6bc91b2f
-	0x46134185	0x8fb77fb2	0x029518a2	0xe1fa1f4c
-	0xf78783b9	0x5d8ebe63	0x103e8050	0x924085bf
-	0x80593f2e	0x5be4bcb6	0xcb935edd	0x882d0a5f
-	0x7deb8205	0xcdc0fe2e	0x9c333db4	0x1d0c888d
-	0xf8dc3575	0x2f901125	0x6bf48cdb	0x98ab6fb4
-	0x491d7df2	0xa064922e	0xbbb86c70	0x88aad77d
-	0xfcff0669	0xb0c47c1c	0x0fcc6fe1	0x50df8a83
-	0x014460e4	0xb014e6ab	0xbeff4bc5	0x8d939fae
-	0xd750ae17	0x42dd29c9	0xdb1cbf70	0x82265be9
-	0xd11afd6a	0x21834e1c	0xd11e3c3a	0xbe568139
-	0x6cf92d50	0x9304ebf1	0xf177046b	0xa5b127a5
-	0xfb57e4a7	0xf94291df	0x0f089d58	0x07395b5f
-	0xde4ba5b9	0xf7371fc5	0xae44f190	0xd529271d
-	0xbcaea246	0xfa777c0b	0xad3bab9f	0x0d6251ec
-	0x6f4fa894	0xc39273e2	0x7710fcc3	0x81f08a5d
-	0x395b54ee	0x87295638	0x57398bb0	0xfd46c7c9
-	0x3f1dafc6	0x548479b7	0x37c42fba	0xa2130147
-	0x99dc0bb0	0x3596c5cf	0xbcca6bec	0x418735ed
-	0xfcd4273d	0xee141135	0x8457cf47	0x95fe7220
-	0x041aaf8a	0x6e947153	0xc963afa7	0x09390a74
-	0xc40dffd3	0x4208039c	0x319b1f84	0x42b6b3b7
-	0xade789da	0x83338c91	0xf2d74712	0xe80011dd
-	0xdd61645e	0x286fc63a	0x26e2fb23	0xfef2b4ea
-	0x3290efb8	0x595a0c17	0x6cd9bea9	0x7be1338e
-	0xe0ff2c09	0x1b93aea5	0xbbd97e91	0x5e1ae1e7
-	0x7c6c078b	0x0b9b3a03	0x43d38011	0x824cd94b
-	0x9725170d	0x87ce6f33	0x60525d85	0xc0a5e853
-	0x242e613b	0xebf72857	0xcb500fc6	0x0de5c3f0
-	0x382b625d	0x08840e50	0xcef30663	0x1bc848b6
-	0xefa78141	0x81b860d6	0x4eb125fe	0x7e125296
-	0x276a5558	0x45caa775	0x7c6ec23c	0x5dcddd08
-	0xc41aa32d	0x6a2851b1	0xb69ae1c1	0x8f603c43
-	0x763497f2	0x73344cbd	0xcffd175c	0xfccf5a91
-	0xb2318bf7	0x66ac628f	0xa98fa975	0xb68e5426
-	0x27555715	0x5157a93f	0x666fd404	0xb37fcc40
-	0x563b0512	0xb70f8446	0xe10d257f	0x73793ef2
-	0x31a84915	0xe0de9489	0x08dfa368	0x9169d4fd
-	0xc14f5c9a	0x92e6db4f	0xa30b6cec	0xca04670e
-	0x8a664367	0xe8984e70	0x1c96a39c	0x655f9abd
-	0x6999a190	0x76267621	0x0f49f963	0x8ddad3a1
-	0x51fdab6a	0xaf0d6863	0x23b71bdb	0x32818c8a
-	0x6398044d	0x26c60bec	0xb0b631fa	0x938f69c7
-	0x52f11913	0x1e6fbe7a	0x92dcd409	0x419bfeae
-	0xb147bb96	0xbac5bf9d	0x08de155a	0xde8ca968
-	0x20aef902	0x62df25a8	0x64a4042f	0xef19da4e
-	0xc75fd112	0xc9863e47	0xaccfdbcb	0xd29b6090
-	0x6dc67b4a	0xa84b3cd6	0x45a0e708	0xd28673bd
-	0x00bebebe	0xd5e518d7	0xc63d647c	0xa28f5f6d
-	0x3372edc8	0xa1c44ed1	0x88e61d44	0x5e095835
-	0x2d8713ce	0x6791a885	0xae89c04a	0xf1dc5105
-	0x6423f3b7	0xf4e2f384	0x2d2761a7	0x38ea905d
-	0xa263d776	0xd1936fa6	0x2fc54081	0x429a25c2
-	0x13f6c5df	0xffffa6c1	0xfaf82002	0xe4bbb103
-	0x2fc0c622	0x669ee281	0xec785fda	0x91156b25
-	0xa9f4444e	0x354fdfc2	0x7c5f5069	0x72ae591b
-	0x73bfd64e	0x6b96d744	0xf261daaa	0x2de15dae
-	0xedaba9c2	0xf287b3fd	0x8b2097b6	0x589934c0
-	0x7edc2a73	0x469b16eb	0x247b9a22	0x8b7e6c7b
-	0x3e71ffe2	0x5275f242	0x032a211f	0x977bff60
-	0x4306ad03	0x6a212383	0xceb36448	0xa2a79209
-	0xe3842f42	0xcee0cbe7	0x37cdb626	0x29a0a515
-	0x2857ead6	0x981d5d9b	0xf0ff9b06	0x95de8cad
-	0x4dcb565b	0x065d585d	0xe7eb754b	0x278fa774
-	0xe4d8fb7a	0xe152f018	0xfb7bb25e	0x50323b64
-	0xba618e43	0xf8cb1c61	0x1b6dce25	0xb4fc7867
-	0x2a7fb213	0xea9e646e	0x3f9b735b	0x5640315d
-	0x0793ba5b	0x71ff31fb	0x4b41f1d6	0xb1538146
-	0x336f4272	0xf176d509	0xb7fc03c5	0xd6a1c927
-	0x56a68c10	0x8b4740cd	0x14c54f8a	0xf07ad8a9
-	0xa8403db8	0x37c23f2b	0xdca69aba	0x4b39ef9d
-	0x2af13bdb	0x6baace1f	0x8c7ca0d2	0xba86bd02
-	0x2a74681c	0x5542ae58	0xc36709e2	0x82b34568
-	0x26ea06be	0xd4bf458c	0xde209de7	0xa311b4e5
-	0xdc00e139	0x7d305958	0xc5d76ed7	0x0943a285
-	0x48ce4e29	0xe371bd9a	0xfe6a6501	0x4167d215
-	0x402e47ba	0x588458be	0xbf4bcf37	0xf7fa27a8
-	0xb725f91a	0xc17f5c07	0xce771dbe	0x66f9d592
-	0xe8521ed4	0x42f75171	0x343b3e74	0x2d5448b5
-	0x2d1fca8c	0xd7a32431	0xc29a88d2	0xffb07fd7
-	0xcca0333f	0x43204f2f	0x866c1867	0xcb215814
-	0xfcb67d4f	0x423680be	0xdf22f6d6	0x03373eda
-	0x3bd202e3	0xd8972fe3	0xb7733d70	0x7a472c76
-	0x6cc8a627	0x3b27e643	0xa3475f3f	0x87ffb286
-	0xf823d69f	0x6d57c38e	0xa0fd464e	0x53e2e341
-	0xaaab23ef	0x439429ef	0x55ba2a2b	0x4da5ea4c
-	0xc1fe05fc	0x874b7a34	0x9a875956	0x713ccc90
-	0x49afcff2	0x5905dc0b	0x1f5dddb7	0x8ef5c1d9
-	0xf60eca50	0x25172569	0x3525639a	0x25804bbe
-	0x5729cd49	0x17f84e66	0xc540d86d	0x51524bc9
-	0x9a6e9901	0xf5bcc70e	0xf7a73ffd	0x54509c8f
-	0xec58b8a4	0x9993703b	0x6ef45fc4	0x5ce3a507
-	0x1d73c611	0x8780e8ff	0xc7d2e02b	0x0bc825f2
-	0x02f75fca	0xe80c0758	0x24646fe9	0xd378ff5a
-	0x592c5619	0x6c80372e	0x1f7351d1	0x4db5182d
-	0x3985fdfb	0x16ca9158	0x58ee1ae4	0xaf2b9fa0
-	0xe97f60ce	0xbb911e68	0x01748fa0	0xaef578d3
-	0xc3736418	0x8ab0deb5	0x0de16af1	0xb8369f7b
-	0x68e43c12	0x914ca0f6	0xe950ef28	0x834eff90
-	0x51adb952	0xc42ee4ce	0xf70ab4a5	0xbf9fc916
-	0xed9444b1	0x845a6a1e	0xf92e7b64	0xb9ca8a1b
-	0xa9cdfcd0	0xb5956bc8	0xb8520e59	0xdde7aa57
-	0xb41d390f	0x364aef3c	0xf39d4482	0x8b4e651e
-	0x0b82f5fb	0x7960e81c	0x12ed7b84	0xe9f123ca
-	0x88a64db2	0xa0c714cb	0x57b01471	0x80ff31a6
-	0x7571d8cd	0x857035d9	0x0508587c	0x594a4a42
-	0x011503e5	0x27c75e55	0x03264f62	0x9316ed1d
-	0x36e5cd1e	0xfa9b23b4	0x5bc8c606	0x0902bd38
-	0xd6745c69	0x6fa73118	0xa50f7b94	0xc529e962
-	0x28738486	0x7b85a599	0x2c495a35	0x85f2cbef
-	0xa09dfe51	0x1c763ab2	0x4effdb5c	0x506586f0
-	0xec182a58	0x45293146	0xaf8d78b8	0xa89bd228
-	0xec24826a	0x752cc421	0xbf36aa46	0x6760e225
-	0xe15d0987	0x6fa9bdf3	0x6837c755	0x9426d654
-	0x14b48f5b	0x5d70567d	0x63a14f92	0x809d5361
-	0x3b6e2729	0x84ce5415	0x7eaca6e0	0x9b467302
-	0x8f39d484	0x8e78398c	0x33108b33	0xdc07005c
-	0xbdc2500f	0x35f1f452	0x9d254e3d	0xfa61eb21
-	0x2ab6c7aa	0x83561fdc	0x8735d598	0x416e8591
-	0xfe10e93a	0x18da409d	0xab6d0bfd	0x675baaf1
-	0x287fdd24	0x6b50b63c	0x8c08abca	0x871a59c9
-	0x41bb2ae4	0xfba9abdf	0xb46491c7	0x4e433d5a
-	0x01e4fbda	0x0bc40399	0x3bdb61c2	0x3cf051ba
-	0x910daa46	0x8d4065d6	0x270667eb	0xf6d42459
-	0x01993a1b	0x00a95dda	0x6ed5a693	0xed4fbf7b
-	0x24dbb70f	0x67fd62ee	0xcef5f0a4	0x9e65b798
-	0x9a9913fd	0x3d0e7190	0x4265b4e4	0x80bfc46f
-	0x6b354d2c	0x2b90a987	0xc989cb75	0x773e6b64
-	0x55325e9f	0x18816a56	0x07413406	0x5177ae31
-	0x24a19ef7	0xdac405a4	0xdca2d3b4	0xab7c7b70
-	0x42b5de0e	0xfcf918a5	0xa54d934b	0xcaa9eab6
-	0x50e63e2a	0x4b168926	0xb2442913	0x594c0f94
-	0xf387f31f	0x4d716749	0xc8433297	0x34c1a5de
-	0xe929008e	0x5644251b	0x736476d0	0x0d00aee7
-	0xf20b2f64	0x5e158173	0x9af3e568	0x5f19fa7e
-	0xb23b2861	0x8659ee6e	0x94058a64	0x66ec4fb1
-	0x37cd6a4a	0xbd2944fe	0x0ea44ec6	0xe7d64c24
-	0x75a170e3	0xb4a9479c	0x2215716a	0x64a8a574
-	0x257e86ab	0x86bae993	0x3030352b	0x15cb88bc
-	0x576363a0	0x61138c36	0x7cc4fe7f	0x648977a8
-	0x0ef71fec	0x1c60df47	0xc75f70ea	0x88509798
-	0x172b407a	0xf888e400	0xef33cd15	0x5976757d
-	0xf8cfef13	0xbf024380	0xbb9c1b02	0xe4c38ec9
-	0xf30fce01	0x8efa5213	0xf4b48aad	0xc94c3a37
-	0xeb1bcece	0x09a18b56	0x4e83c0d3	0x6fcf9f77
-	0xf52f4d76	0xf3368a12	0x33b2797f	0x627b6e41
-	0xefd05154	0xa83ae2a0	0xea211129	0xd25723d5
-	0x7bbb0e3b	0x7131f088	0x5dd5193f	0xef5aa905
-	0x39f77be7	0xa21b48c1	0x1ded01c1	0x5cf98c5f
-	0x6e23d207	0xd7e7dadf	0x5932ed1a	0x2a729061
-	0x29a89f4a	0xac0e8447	0x01ff4205	0x8b1456c6
-	0x3fba0156	0x658c03f7	0x5c69f968	0xf6570582
-	0x21bb0145	0x8683bf5b	0xa4b6eba5	0x4ccfe5cb
-	0xd202898c	0xbd2411cc	0xc2fc702a	0x5c39b695
-	0x87584ccf	0xeae3c735	0xc472b6f9	0x4249f637
-	0x3fa89c0e	0xce5a8bd7	0xbb28138b	0xc080ecb1
-	0x9cbf1916	0xd70424e9	0x75cc4ed1	0xa575f3e9
-	0x1c571f68	0xe2906205	0xc26520cf	0xf9c1fc8e
-	0x61c982de	0x1af6cfcc	0xaf397c9a	0x46830771
-	0x623d98bb	0xda7b52fa	0x5a3c57d3	0xfa35d2f0
-	0x4783df19	0x6ad07325	0x487406f4	0x3fae5152
-	0x189137cb	0xd98a644e	0x17ffe880	0xeb6aa9f7
-	0x67184e3e	0xe475734b	0x0f1113c2	0x39a4df47
-	0xbf8f6ec9	0xe13a4d8b	0x63ec02f5	0xdfe7d75d
-	0x1379034c	0x5db7314a	0xa9d9ad3e	0xfaaed8f2
-	0xf0fb6074	0x12f27b84	0xc97a92bb	0xae5e3bb7
-	0x5f7fc2bf	0x00cbc1f7	0x9360a4d9	0x3632ba04
-	0xad044c83	0xeda13ec1	0x34a214c0	0xcf9c972a
-	0x96352243	0xf1a35357	0x2d77bc30	0x8485bbad
-	0x67fbaa99	0x8035b1a5	0x8ca763c0	0x109d7887
-	0xa1c35cd8	0xdc79e308	0x4495404d	0x64419226
-	0xacdcea08	0x9545c0ef	0x5493e09e	0x7fe16336
-	0x41381aa2	0x5c344f46	0xb40cab9f	0xc43951c4
-	0xd86e52a5	0xb141d934	0xd78efcff	0xf37ec320
-	0xc184a45b	0xf4a57954	0xc8aed0bd	0xe602c15a
-	0x71a6b48b	0xce837428	0x02733706	0xc4a4a044
-	0xa75efb97	0xcb63d62e	0xd0580b5a	0xce499087
-	0xc12bf4ca	0x9c995345	0x1d8adfbc	0xe62fd60e
-	0xccbf5412	0x6161f8d0	0x64268e34	0x565d066b
-	0x1896b63f	0x838f8f2a	0x1e314a00	0xac470276
-	0x1879cfdf	0x4702d7f9	0x83b4d777	0x81fcb068
-	0x1b6da94d	0xd075ed01	0x3c7734e8	0x56389a0b
-	0x0743b9cd	0xb6b0bf0d	0x63107ab9	0x193172bc
-	0xc7b84c8e	0x982ce2aa	0xb8e387a6	0xc264a4b0
-	0x2ac6c802	0xb89ea335	0x052332a4	0x49932ecc
-	0xb940f808	0xa7a09330	0x19f3f49d	0x7aef6b5a
-	0x201d8ed0	0xf29aac4b	0x8ae2ac0f	0x998c1ca7
-	0x665c3927	0xab4ef641	0xf136710d	0x9644ee9b
-	0x34efae96	0x4c596035	0x8cfe8b3b	0x5d9f742e
-	0xab2c63ca	0x017d864d	0xd0604d6e	0xab24eee0
-	0x75916a9a	0xad0d1167	0xbeb47775	0x6ac822d1
-	0x776907aa	0x9e9377f2	0x438c5d81	0xd70e9964
-	0x1c09c914	0xab90e5cf	0x31cee523	0x26ba6ea7
-	0xef00781d	0x622b886d	0x36a54031	0x88b1221c
-	0x666333f5	0x60e1c93e	0x5e4d0e0a	0x3ee6ff69
-	0xceb4c76b	0xa5deb4f8	0x0668ced8	0x30225378
-	0x6697cf37	0xc5d9661d	0x089eab85	0x7684a876
-	0x018a81af	0x221a7fb2	0x31d80de0	0x9f18ae90
-	0xa29c9af0	0xc3e2b00f	0xda0edbab	0x7ee9cd2a
-	0x3ab0f88e	0x02c58228	0x606fa7aa	0x7776cb0a
-	0x4e8ad99c	0x3b527469	0x58123d62	0x4ce428d2
-	0xee91a210	0x466ba2cc	0x043c57b9	0xaf7bdd43
-	0x98e76fee	0x8f3eac1b	0x00dffd6c	0x6fcb1c6a
-	0x5cb90573	0x485d4505	0x0df5418a	0x26eafe35
-	0x0faddf3e	0x4e972930	0xe113c823	0xe45944d1
-	0xa646077f	0xc1708ae5	0x6ba07c20	0xc7e4e234
-	0xc6754ed5	0xbd6e85aa	0x8cc1756e	0x02afda29
-	0x72809597	0x75b6f5a1	0x61141874	0x1774047f
-	0x7a10afed	0xfac2c4ad	0x42cf5c99	0x24f0350e
-	0x042f2864	0xfab55b67	0xc8ead5bc	0x914e9512
-	0x77c8ef6b	0x8369aeb1	0x71bc947f	0x0c6b49d8
-	0x8ddd0513	0x028ad10d	0x99a1b28f	0xe6cfbdc8
-	0x7978b4a6	0x3ebbade8	0x9985f5cf	0x431f42f1
-	0x004372b2	0x18b67f68	0x20111c21	0xbb6f77ff
-	0x1783b030	0xa045d7d1	0x0e9c7e09	0x3ccbd95f
-	0x0b84a2ed	0xf0ee3325	0x63f2e126	0x5ec4c67b
-	0x2ca782cc	0xcaf20d04	0x8b59d515	0x3212aa33
-	0x335ca0c3	0x6f9e0cdd	0x4d4bf189	0x44d2fa0c
-	0x5abe9396	0x492794ee	0x10dcfcb1	0x9acda9bd
-	0xe8aa2803	0x3f1b9605	0x3e2ecb5a	0x971bfa8a
-	0xcbf141d2	0x0afafe10	0x2fc906a6	0xefad20c0
-	0x9e922581	0xe69142cc	0xc9c0ba82	0xc069e640
-	0xb99c08b6	0x4b62ca1f	0xf3c5767a	0x6ab088c7
-	0x8f0f0c0b	0x6726f64a	0x9711a3cd	0x46462571
-	0x3a58350e	0xa2561911	0xe24dfdfe	0x97443fdc
-	0xf80540be	0x069978bf	0xb38a359b	0x8e574f62
-	0x69aea75c	0xdc753fcb	0x2a74002c	0xced027b4
-	0xda993254	0x03409b83	0xf827331d	0x75fb3271
-	0x01ad839d	0x68520842	0xca65c45c	0x1a3db5a0
-	0x91d37dd3	0x6168c0fb	0x935f5a08	0x002007c3
-	0x42eb4760	0xdab3a804	0x72a6297e	0x905c32d9
-	0x81abcfa9	0x1b21d04a	0x5a1289ae	0x424e7183
-	0xc207906c	0x31fe9134	0x5eb2e5af	0xc9253fc7
-	0xc32be24f	0xe5474cbd	0xeff6e1b0	0x710e5e69
-	0xe6c4c538	0x96b5f1de	0x2abc9c35	0xddbd1a92
-	0x8aca40d7	0xe359c238	0x954718f4	0x18b157e5
-	0xeeed790e	0x6948a963	0x24e70bfb	0x4d681547
-	0xf68369a7	0x5b54409a	0x1f0b787a	0xc2610047
-	0x0f8bd269	0xd7c8c154	0x9dee62d9	0xd4738ed8
-	0x1a66c6b1	0x5bad5a5b	0xb110311a	0xfaec6802
-	0x6b750f2d	0xcbf8d0e0	0x11edaf4b	0xf64a07bb
-	0x422e7c15	0xb1732663	0x1ff404f0	0x2d5052b0
-	0x6e45356c	0x7e2201e8	0x7c5ebcd1	0x1cb4425a
-	0xb1539a64	0xa2e4459f	0xcf1ade8a	0xfc476473
-	0xf4147deb	0x2afbdd77	0xff01fabc	0x6597408a
-	0x0951220b	0x6750f3ec	0x0a242763	0xf3d71c05
-	0x84cb1c26	0xdb7a81bd	0x7aea1a5d	0x7e719a48
-	0xc5c12fe1	0x0ce2e988	0x29ecc6f0	0x5ede901a
-	0xda8399b1	0x31c05d6b	0xe1956aff	0x59ed7c3d
-	0x60832637	0x9bcb7cac	0x63c530d1	0x14c677de
-	0x9225ed18	0x065327c9	0xd1ff6a0e	0x5516517e
-	0x53c6f5c2	0xed5983cf	0xaa1d18b9	0xbe300d7f
-	0xadc525a7	0x07ea81b6	0xfc517a09	0x4ead3f86
-	0x45435f41	0x2efa58df	0x02348ebc	0x30ed6783
-	0x190b4fb9	0x85c55d6e	0xc9ed8896	0x416ee113
-	0x9b3536d9	0x30577cc0	0xbc4b88c8	0xcda59612
-	0xdfe2bd89	0xd60cde71	0x98843881	0xcc1f32f2
-	0x18b3f643	0x671a14ca	0xd6482a47	0xac6a7d38
-	0x1897da16	0x91b6fcb3	0xf199bb35	0xd38c00ba
-	0xa8c946b6	0x52a1ad37	0xd38ed2d4	0xa1d6f81d
-	0x5af6865b	0xebdb858f	0xb844b110	0x53201ea2
-	0x08870945	0x10c869de	0x19849613	0xdb35d3ed
-	0xd68ebd6e	0x1056fd48	0xf1a0e305	0xe3982ebd
-	0x6f7cc391	0x5956374a	0xf414a5a2	0x325119ab
-	0x99ee1f96	0x6f044bd9	0x8374805b	0xb55c366c
-	0xa2c77051	0x68f199e5	0xd36a9714	0x878f847b
-	0xec0394ae	0x86d0584b	0xf4df66b9	0x451cd039
-	0xf4de06ae	0x35dd0554	0x818a342f	0xeefdbfc9
-	0x5b4e9edd	0x22d9313a	0x3b710d60	0x6deaeb4c
-	0xa9e26512	0x98d31867	0x3c2c2d61	0x7eb5ce41
-	0x40890db6	0x7a3aa660	0x3ef4f306	0x7322881f
-	0x49dac4d5	0x96efe685	0x27bb7f49	0xbb955283
-	0x79c5f2b7	0xff599c28	0x28ee7f5e	0x9f324b73
-	0x45edb7cf	0x39a8b79c	0xd0919c6e	0xe149b29d
-	0x62f5f82e	0xebcfa23e	0xd4d68937	0x54270090
-	0x958af0d4	0xa1e4e799	0xaf68ac19	0x82a84f4e
-	0x50f67b84	0xd5e59629	0xf5fdf24c	0xab1d63c5
-	0x30835807	0x431fce5f	0xe5f96f4d	0x3f6b4802
-	0x14010be8	0xdca45ae5	0xc82709af	0xff76ce2c
-	0x8b222c22	0x73a2d948	0xa8d59cea	0x8c31849e
-	0x469c2e5f	0x3777ee84	0x5fdfa5da	0x02ef9bb2
-	0x792d3194	0xbed63f21	0x0b6dc5f1	0xc9d7fe08
-	0x6df7883d	0x366566cf	0xef772769	0x37826465
-	0x1cdc3086	0xa69ff7b6	0x235012ea	0x292f7e75
-	0x30bdd0fd	0xffdc9df1	0x95c6d570	0xec206204
-	0xc6cd42cb	0xc0d6dfd9	0xb7a16b71	0x17fa527e
-	0x295f2c79	0x990f9820	0x8b8f447d	0x193f9ad1
-	0xebddb2af	0x5dd532eb	0xf1bbd8e8	0x3444a3f4
-	0x18ccce93	0x05edeb4f	0xc4a6b935	0xba37aab0
-	0x96076ba4	0x250dc2f7	0xc4093548	0x030e777d
-	0x7ea40933	0x8da7b1dd	0x59c0b79f	0x807d437c
-	0xf5233ddf	0x54c1983f	0xfc18771b	0xe74b85f0
-	0xdbd725b5	0x70cdd153	0x4ffe300c	0xfda4bdae
-	0xf4ac75d2	0x91c4e15a	0x34d92b97	0x16356a79
-	>;
diff --git a/arch/x86/dts/microcode/m0220661105_cv.dtsi b/arch/x86/dts/microcode/m0220661105_cv.dtsi
new file mode 100644
index 0000000..ada8bfc
--- /dev/null
+++ b/arch/x86/dts/microcode/m0220661105_cv.dtsi
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) <1995-2014>, Intel Corporation.
+ * All rights reserved.
+ * Redistribution. Redistribution and use in binary form, without modification, are
+ * permitted provided that the following conditions are met:
+ *	.Redistributions must reproduce the above copyright notice and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *	.Neither the name of Intel Corporation nor the names of its suppliers may be used
+ * to endorse or promote products derived from this software without specific prior
+ * written permission.
+ *	.No reverse engineering, decompilation, or disassembly of this software is
+ * permitted.
+ *	."Binary form" includes any format commonly used for electronic conveyance
+ * which is a reversible, bit-exact translation of binary representation to ASCII or
+ * ISO text, for example, "uuencode."
+ * DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ---
+ * This is a device tree fragment. Use #include to add these properties to a
+ * node.
+ *
+ * Date: Sat Sep 13 22:51:38 CST 2014
+ */
+
+compatible = "intel,microcode";
+intel,header-version = <1>;
+intel,update-revision = <0x105>;
+intel,date-code = <0x7182011>;
+intel,processor-signature = <0x20661>;
+intel,checksum = <0x52558795>;
+intel,loader-revision = <1>;
+intel,processor-flags = <0x2>;
+
+/* The first 48-bytes are the public header which repeats the above data */
+data = <
+	0x01000000	0x05010000	0x11201807	0x61060200
+	0x95875552	0x01000000	0x02000000	0xd0130000
+	0x00140000	0x00000000	0x00000000	0x00000000
+	0x00000000	0xa1000000	0x01000200	0x05010000
+	0x19000000	0x00010500	0x15071120	0x01040000
+	0x01000000	0x61060200	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0x9557a557	0x7d7a0fe3	0x8e2fbe53	0x0db9e346
+	0xd35c00d6	0x21bb34b7	0x662b6406	0xa0425035
+	0x3d028208	0xcb843695	0xee06be0a	0x9817efa7
+	0xb86c0d16	0x45f70c93	0x79fdc3af	0xd5f30da7
+	0x460f62b0	0x238a0470	0xf0ec95bf	0x97b9c176
+	0x6d612851	0x69b9b4b6	0x1df769cc	0xe11674df
+	0x1b579adf	0xc8bcc050	0xcdb3e285	0x327592c1
+	0xbeb6047a	0x977f6be5	0xc4854052	0x27f38b66
+	0x4ca5eab3	0xf806decc	0x2be4b409	0x460a3b03
+	0xde2f6e0f	0x53ce08b3	0x3ef0ef93	0x4e013088
+	0x226f8a5c	0x57f7d291	0x8d640bf7	0x8a998907
+	0x40464dd8	0x804ef3e5	0x647e35f3	0xeabee2d1
+	0x3a5ce9c7	0x4d7ee530	0x564321ec	0x9e85107e
+	0xd595581d	0xcbf6efde	0xed3010ed	0x3d607e82
+	0xe32d4b6b	0xd06fec83	0xf39240a6	0xe487988d
+	0xddbefcbe	0xefaf1121	0x96bf9acb	0xacce795c
+	0x7fa5f89b	0xbe440e5d	0xb6d3a3dc	0xcad17290
+	0x503ae748	0x04c80b8d	0xd394ea6a	0x3e4072c3
+	0x11000000	0x0b0ae65d	0xc6c53cbd	0xd52a6c2d
+	0x84cc192f	0x89498e7d	0x89270686	0xe68105e0
+	0x4073a570	0xd3338d8e	0x51193152	0x7266182f
+	0x980553fa	0x51b89c90	0xd13b6151	0xe6e40a91
+	0x0ab997d8	0x2d0a443b	0x9d3d566d	0x820402d1
+	0xdbe79fcc	0x7c5e0b45	0xaf94216d	0xbf717950
+	0x520b3dd4	0x566a3396	0x0b6f794f	0xc5dfeda5
+	0x71ba0f02	0x4839a5ed	0x39a4e4a6	0xe567c652
+	0x0e044997	0x84a0effd	0x09c67178	0x89a815c8
+	0xac821555	0xd6719303	0x582b964e	0xfe3a53f6
+	0x241b9b8b	0xc6e65457	0x623a4e0a	0x590d7d03
+	0xe50e7ce1	0x4bca4700	0xf24f5eff	0x1f1b20d9
+	0x77e3227e	0x699b5e5d	0x9aa5f621	0xff08bba0
+	0xf17ce716	0x0f5336f5	0xbce055a7	0x8cea9dac
+	0x8e09d26c	0x66c3ddf0	0xbec71660	0x75248cd2
+	0x29afcf8d	0xa5ade5ce	0xf68bace5	0x63b513cd
+	0x4736a842	0x4dbf80df	0x4e85fbdf	0x4dce3d56
+	0xf2150fdc	0xc4232709	0xffdc3e3a	0x92b72a3d
+	0x9ffce715	0x682959d1	0x091ba33c	0x0f1dc729
+	0x2f29a924	0x1df72429	0x19b0365d	0x2d5a3cd8
+	0x20617351	0x109074f9	0xf232874a	0x40d79569
+	0x97dbe4c6	0xa3b66845	0xa04d2faa	0x6dce9a96
+	0xd4963c67	0xd4516f76	0x64a0b04d	0x0b87ddfe
+	0xd8a5305d	0x717ecf67	0x77189035	0x40542ed4
+	0x5a180ff1	0xb2042e2c	0x6639819b	0x0f0756c3
+	0xf939bd70	0x25efe0d6	0x3eb65ae9	0x39a057d2
+	0xb2595655	0xf808b4fd	0xe22d0593	0x76256500
+	0x0eeee6ee	0x6895d1cf	0x9fc117a7	0xd19e5f15
+	0xf677f085	0x1ecdb30d	0x704d0975	0x9099f42e
+	0x421be0b2	0xd02548bd	0x3a16e675	0x7d8b051d
+	0x9d24480f	0xbc006432	0x184da9ec	0xbad7abef
+	0x299f58aa	0xc1a249fa	0x8d9d31f3	0xe73cda17
+	0xf41ac993	0x7b88d3bb	0xf349c676	0xb8341361
+	0x1b69bc01	0x98e0bfd2	0xf31db8d9	0xeb49b275
+	0xabc40133	0xfb7d0701	0xcd5ff353	0x4eaceb8d
+	0x67aac555	0x6d81693b	0xe81c555d	0x5d7f3688
+	0xd4347083	0xcd861b1d	0xd332f2cb	0x43130028
+	0x7f1a1c51	0xe2ce3af2	0xdff5076e	0x6ef21237
+	0xf65fc8c4	0xbd28ff14	0xd70f49a3	0x4f559249
+	0xd6fe7530	0x1fe89b4a	0xc1cc8975	0x2fd705c5
+	0xf2993d77	0x60f2e3da	0xe3ca3c44	0xbd0f70b1
+	0x0d333d10	0xa29a6aa1	0x43b5a6d4	0x30d15a08
+	0x6df9564a	0xea09045d	0x54ca3f5a	0xfbcfa037
+	0x6dd64d1b	0xa4a8995c	0x1f4298f0	0x3f4d9a86
+	0x924ee146	0xc2e3f464	0xc247747f	0x8bf5c7d7
+	0xf8f0b05d	0xf65a115f	0x4b1ae4e5	0xe131e187
+	0xfaf713c1	0x5ff88660	0xcd4916b0	0x448028e0
+	0x140711ca	0xffe77575	0x8b7740bd	0x82b6ed95
+	0xd94d9647	0x2623c011	0xd54fba11	0x30a7050b
+	0x28fe4069	0x70b8bf7d	0xf786eb6d	0xe39db734
+	0xa3290669	0x8747e1d6	0x35804a42	0x1c26ed60
+	0x30a8880f	0x8170a277	0xa1d97657	0x6ebcb3ed
+	0x3bb6ce89	0xff808c1b	0xc919fd1e	0x911d8b14
+	0xcbf41a24	0x82abc738	0xfb5e988e	0x328aa123
+	0xf19146e3	0x587baa80	0xd105e811	0x83b09389
+	0xa29fc554	0xe3831a28	0x183f8de7	0x4ef5656e
+	0xcc940baf	0x938bf4b4	0x90627bae	0x14fc3cdb
+	0x75e45681	0xf912c1b3	0x7a5b8a0f	0x3b970524
+	0x6a74d34a	0xb3da9fe6	0x847a3bd8	0xfc4f7dd6
+	0x88fd7f3b	0xbcd74a15	0x3afed836	0x17e31cd0
+	0x5d866dcb	0x0ab69608	0xe334f0fb	0x7181d4a3
+	0x8dc87560	0xd9c94d6f	0x491c2c91	0xca295ed6
+	0xfb8dcd79	0xeb4d3f89	0xec581071	0x0457ebc6
+	0x6b63590b	0x9dde4b79	0x3dc0a0aa	0x41ec8a1e
+	0xfb2ab80e	0x07adc629	0xb8534a4f	0xd0d23901
+	0xcfd024da	0x47c4163a	0xc89d26bb	0xe5cac48c
+	0x17c7fbba	0xd992f42e	0x466f5e35	0xce48304e
+	0x394683c8	0xef6e6b7a	0xb9d1242d	0xb961debd
+	0x432a3dff	0xa4931ea7	0xd9f03907	0xc29e9ce6
+	0x4fccf4c9	0xbf234555	0x0b6a6771	0xb29f29ef
+	0x7edc4bfd	0x781dcf74	0x4ae31020	0x1ab72d9b
+	0x0ac457e2	0xf9291e09	0xd4084918	0xa540d999
+	0x223408d3	0x0bd039aa	0xaf0dd904	0x9cfd6a01
+	0x826c6bca	0x8e41a96d	0xa56fc4ee	0x6a7509fb
+	0x5cd2e6fc	0xb89aa158	0xb1e5d3f5	0x92ccd05e
+	0x995d5acb	0x5ed1dc08	0x75038dac	0x4377c835
+	0x265d66d8	0x3692096f	0xcd69ee59	0x310df351
+	0x087e3133	0xe89e2d58	0x137fd054	0x00f3562b
+	0x2ae304e5	0x9db0316d	0x6868cec6	0xb249ccec
+	0x9f602c90	0xd3715e7c	0x3fcc8a62	0xa1c1e065
+	0x5b4281d4	0x124dfd7e	0xe9d21462	0x77cbc940
+	0xf915f2a5	0x66df82fc	0xa8c67c56	0xac4d461b
+	0x836deb52	0x95fbb48d	0x3454b6bd	0xd87d7a64
+	0xe64d32b8	0xc44c2aa0	0x3e213c1f	0x4d31b94d
+	0x4640be5e	0xe127234b	0x9ca54856	0xac7d093f
+	0x03d0508b	0x30f5121d	0x6e347d91	0x47772312
+	0x318ea26e	0xad3f6902	0xb5598746	0x8be3b65b
+	0xc8bbd31d	0x24691564	0xee77d2e8	0x3581944e
+	0xeff8eed5	0xa29ea86c	0xc2597492	0x23c1c118
+	0x7810c079	0xb966ee47	0x823e9954	0x9e558c0a
+	0x74759c12	0x193c6b4e	0x7544597d	0x65c9bf8a
+	0x68f5e263	0x718c679b	0xc8dc50ba	0x5f5ab841
+	0xc3eaf579	0xc2072358	0x62481939	0xffe7e686
+	0x201f3215	0x1d88dc8e	0x28fb4002	0x40c56ec5
+	0xb7bcce00	0xd52f5042	0x84498e04	0xcc97fb7d
+	0x64035e93	0xcd3478a4	0x15d63309	0xa9e47b85
+	0xe835e45f	0x9de598b7	0x94f569f7	0x56689b0c
+	0x381f9173	0x708b3e52	0xc81f0649	0x12113041
+	0x4694aae2	0x69040fc0	0xe4ba7bf4	0xfadc5729
+	0xc168381f	0x1985f118	0xab0ca720	0xf0150799
+	0x42690e4a	0x71af3be9	0x9325f3b8	0x36575996
+	0x4dc1dca7	0x7e534c37	0x01830a21	0x221eef4f
+	0x18698322	0x57a80837	0x483ae2d8	0xef905b54
+	0xe01827de	0xae9a8ff1	0x0058be7b	0x052632ad
+	0x9df5c90b	0xb763fc7a	0x5535c95c	0x8eb5916a
+	0x75fde5cc	0x57d8eeab	0x0dcc35c6	0xbf11c88f
+	0x69142118	0x4f35c928	0x7966066c	0xb2d13b4b
+	0xdad06d34	0xb5d8f5c7	0xe0bb11e6	0x8a36325d
+	0xc1122d64	0xcf07a1a5	0xfe7ce9b1	0x176b624b
+	0x4de883fd	0x00a9024b	0x3d3f7271	0x5072895d
+	0x2634e158	0x2f3c9a35	0x95e374d1	0x65e66528
+	0x47766433	0x4cb805ff	0xbc8f0319	0x6d5055a5
+	0x4932e8c2	0xa93fbb4d	0x87f08bd9	0xf5e5706e
+	0x409af40e	0x017edf5c	0xc5394c71	0x6fb97b6d
+	0x7b5ddb6b	0x0256adfe	0x76d337e2	0xa3327113
+	0xfbb4cb29	0xea68ca27	0xa76a865e	0x8cdb2dd3
+	0x902642bd	0x16772269	0xb2341eaf	0x858fa943
+	0xb087fac9	0xd17de85b	0x3d9c248a	0x0bdcf2d0
+	0x874fc03c	0xf19f2591	0x190c06a9	0xc6b5c3ea
+	0x472b6245	0xdb9f8201	0x46d27a0d	0x52218ffe
+	0xece78c44	0x3ef6e38a	0xfcf19b65	0x536c840c
+	0x86d363e8	0xaa852826	0xde17e3ec	0xa9c3b45b
+	0xd322302a	0x48f03728	0x2f60d01a	0x3b356752
+	0x8a869fd4	0x055d04f4	0x765074fb	0xb0b5c2d1
+	0x865ad360	0x0cb6c6e8	0x5de9cf99	0x863938d3
+	0xd4d9aeea	0x0babfa86	0x172cfb57	0x972d8f4f
+	0xe9aeeb95	0x6acbe297	0xf2459e42	0x415fdd12
+	0x84b2e67b	0x47d2d466	0x44bc85a4	0x1a55b957
+	0xe4d01142	0xbf4ea387	0x5651e1a2	0x19124703
+	0x8aaed1b2	0x841f3ecd	0xc6d6cc4f	0x1f2d8565
+	0xba08e74a	0x68e5ecf4	0x07af5ef4	0xdd5a43a9
+	0x6086c705	0x37ced045	0x0fb05ca6	0x35f39f3b
+	0xda1ecbef	0x1daf6d76	0x5481d7ed	0xc51e8385
+	0xa705e11e	0x127d2a7f	0x654d4710	0x1a34370e
+	0xf8496ea4	0x4392b6ec	0x2f209933	0x9c5ab017
+	0xa4f7b837	0x33e0a7d0	0x98fb0635	0xdefc042a
+	0xc7a1f6b5	0x47107766	0xd06acfba	0xb8ac2a93
+	0xe21cca44	0xf0150492	0xd4de2e01	0xe0d6e9a5
+	0xa758b5df	0x2e1c31c0	0xc4794495	0x3d9cc157
+	0xf94aa4f7	0xc2325855	0xcf9ddd12	0xaa70e611
+	0x2b2404b8	0x75d87f38	0xa2a6f772	0x61abfa04
+	0x23b61fb0	0x87f4067f	0x355abf99	0x2c4e6c48
+	0x2dc8a3b2	0x119b08b5	0x3f1f6d09	0x374372f0
+	0x24d79d32	0xef2b58be	0x461ab91c	0x1d31267e
+	0x8b1b2c7e	0x27a4f103	0x1686c7c3	0x55af0d87
+	0x61c2503b	0x9ffcca7f	0xc3cbdd07	0xd49a4f3c
+	0x9ddc2ac9	0x335e1b2a	0xd8dcfc08	0x6e83f11c
+	0x53de9e30	0x7b774670	0x15a97571	0x1ecacf66
+	0x26581520	0xeee3496b	0x1fdf8174	0x4ddd3c61
+	0xaa504fc2	0x0b09792e	0x9b81d1c7	0x10765c95
+	0xd3e7b9d1	0xefdb38f9	0x4c44d38e	0xaaf8fd08
+	0xceb22e7c	0x5ac74242	0x6baee02d	0x5c7eaa5b
+	0x27265dca	0x614c3b5e	0x2994874d	0x486d48a3
+	0x5945c4f9	0xe465f343	0x934e55de	0x633199a2
+	0x147222cc	0x9bbb0c16	0x6a7e7ef1	0xb7bce9b5
+	0x13413d18	0x628231af	0x0fd2d58c	0x4cbafba0
+	0xa930fae6	0x91733823	0xe06f99c3	0xda3b57b7
+	0x04b8a9dd	0x53451e33	0x11fde5fd	0x0e35bcb8
+	0x3a5799d4	0x3893f9c0	0x6b9d0e1d	0xf8d948ce
+	0xa33a6628	0x7d09792d	0xd74b3719	0x0afb4de0
+	0xfaa5a685	0xecf7f8ac	0xcf34b855	0x89453b4d
+	0x12f028c3	0x45edc3fd	0x792c43fc	0x2b054962
+	0xb8799a92	0x0ab38d61	0xa6c6a76d	0x7670cdbd
+	0xf878b511	0x9a3474ba	0x478673f0	0x7398bba8
+	0x4fa10ff5	0xf0a1931c	0xd5938e03	0xe9a23c28
+	0x7bea2a5b	0xf7a8db22	0xb94ae0e3	0x2abe6385
+	0x0ef2cc36	0x6b997544	0x1e8cc4f1	0x69a5b182
+	0x54f9b7c7	0x8fe56cba	0xc7c12fcc	0x8d689865
+	0x2d6ef011	0xc6a1b740	0x66af0a76	0x76018cdd
+	0x30661377	0xcf1fcf93	0x08046423	0xdf9371c8
+	0x1795ec3e	0xf5ea09c6	0xe462de69	0xd7da78a1
+	0xd8bda1eb	0x1179f53a	0x2b394767	0x3ba153a7
+	0xf9c85bd7	0x5700c827	0x8478ac99	0x080a2f52
+	0xdd1c18f1	0x579cea67	0x345c56ce	0x4563f16a
+	0xfa1a5b74	0x0b6e233e	0xadc7bd9a	0xbee6d2f0
+	0xa249f3ef	0xcdea9b77	0xeaaed82e	0xcc4448a7
+	0x34f7cafb	0x7621bb44	0x4965b0eb	0xe6d6b8bf
+	0x3c683b25	0x33bcb5fe	0x3f376249	0x5b40dc67
+	0x658bf6aa	0x7f0c5d0d	0x61514591	0xeb3bb83f
+	0xc2e208dd	0xe82f08f2	0x6ef75ae5	0x9c11bc0d
+	0x289c0553	0x1578ce5d	0xb7f05c0e	0x818c5ebd
+	0xe566ec9b	0xc6995b3f	0x0c02aac3	0x2b4264b3
+	0xf9cad304	0x5b0479fb	0xf8ce8d6f	0xb7d80d8b
+	0x41a0d223	0x71ec8a7a	0xc9d74d41	0x245c5988
+	0xf607fc59	0xf1c7b6ab	0x142ef712	0xbf607800
+	0x281e5911	0xad9a3e63	0x87b59384	0x7ebdc04c
+	0x6f47867b	0xb6a304ac	0x289f65e7	0x335fc866
+	0x77eb11b3	0xb70c25b2	0x70b43d52	0x684d46c0
+	0x0940459b	0xde739ede	0x0b438a29	0xb713e77e
+	0x71f539b7	0x8b2f0f7b	0x8d8ab95d	0x42cde8c9
+	0x08c259d1	0x021eda69	0x2af81ddc	0xc7d13028
+	0x05abfa20	0x6a61008b	0xfc62557f	0xd6d731b2
+	0xb080aca3	0x6acae4a3	0xab33d2bc	0x7983c177
+	0xdf0c357d	0xb8dcb956	0x9c214460	0xfeb75d75
+	0x9b3d468b	0xd2c3106c	0xb1bd118e	0xf26df6a8
+	0x11b9c4d2	0x031357f9	0xf7af8a12	0x70fef26c
+	0xe5d8b8d5	0xf6746fd8	0xd6cc3266	0x4158e59f
+	0xa38fbfcb	0x01c61ff6	0x44c7c4e6	0xf26db3aa
+	0x46bb6d84	0x0a794535	0x1d5eab72	0x42345de7
+	0x0c7e6d47	0x8bacc223	0xb7334b8d	0x3d9d951b
+	0x18f4afc4	0x9c0cb708	0x53b71b82	0x603e8350
+	0x6f2df978	0x0c6f3f0f	0x661ebca9	0x30788bd0
+	0x982959c0	0x50aa1351	0x672297c1	0xa490a756
+	0x21c9e911	0x977e172e	0x0446db50	0x49b711c1
+	0xbc6d54c7	0x0fe0adb4	0xc4ec0fe4	0xae6d09b6
+	0x316cfa53	0xba68cc8b	0x104bdbe9	0xc31639a3
+	0x812a97fb	0xa1c6884b	0xc884d473	0xe3057c15
+	0x5ee879a3	0x5abe8262	0xb906bbde	0xfd98fcbd
+	0x6ae15c96	0x44a17e0e	0x28acfa15	0xb345122c
+	0x6ddc4244	0x005eb369	0x22d038bc	0x0d226e4f
+	0x64c7ed6c	0x7964b8d9	0xbc5d668d	0x99155e56
+	0x9979151c	0x65312a00	0x0271d338	0x64867293
+	0xed0d26fb	0xe69c5f02	0x93fd6871	0xf5702656
+	0x4fad1c2b	0x20f8c272	0x438b964a	0x87ff3fa2
+	0x6706537a	0x437b5709	0x6fb797dd	0x85679fab
+	0x00da6b51	0xeecc5540	0x2998791c	0xc36d40ef
+	0xb545e334	0x9ace5e06	0x8a9e6c54	0xc341d0cd
+	0x1478a2d4	0xb81413bd	0x80601f72	0xa1b250b9
+	0x1cb7f5ce	0xefad630c	0x32325fcc	0x29e3474d
+	0x6a7ae043	0x879ee630	0xdc1e8a55	0x7ae794a8
+	0x4ee38039	0x2ff4947a	0x53bb84b1	0x8f0b077d
+	0xaa4c543b	0x9aa88443	0xeb31a017	0xf3485983
+	0xe53b855c	0x6e17aec6	0x726458a6	0x5acf4345
+	0xa1b95c5a	0x30668c67	0x47fb5dc7	0x8aafbff4
+	0x4b94ef01	0x07bd6231	0x544afcf3	0xfdffca2f
+	0xce847471	0xe90abc6e	0xf05e3cc1	0xf602a9c8
+	0x8f104b51	0x1ae3da07	0xd07dfc04	0x561d9373
+	0x6f6cc833	0xac982489	0x3c0f8afd	0xfab974d0
+	0x397e135e	0x8edb3eb4	0x452b9509	0x3972829d
+	0x639e3981	0x1c758ec1	0x11428fa5	0xe8308fa7
+	0x571d71b9	0x94e40c2b	0x1aaaa397	0xce9283ae
+	0x599bbb93	0x51c04bf7	0x556bc74f	0xf6e6e799
+	0xc34191e0	0x5f06bce6	0x9f63ecd1	0x54437905
+	0xf8f9bd50	0xde82cbf6	0xe11a9949	0x9d312bfa
+	0xe712e3db	0xb57eabc9	0x57682068	0xc91c2e3c
+	0x681e4fbd	0x0ecd3452	0xcc893248	0xf13f0600
+	0x9a8a9194	0xb4c1cd29	0xd504d8f2	0xee6c5b8a
+	0x211c9958	0x7a4f9c30	0x32775708	0xda97bf03
+	0xf7035e57	0xbe77d547	0x37accd1e	0x6c537775
+	0x8d63b752	0x7fec4a3c	0x94211d9e	0x60bfeb2a
+	0xebd47130	0x747d52fc	0x8434f487	0xac9091cc
+	0x8f8b228f	0xb77f96a1	0xc21fede9	0xa9e2678a
+	0xbc815194	0x54d677ac	0x66c11faf	0xfb666595
+	0x01e5e973	0x5c990d0c	0xf2cea425	0x5b516ff8
+	0x8c932784	0xd18feb32	0xb5acd3d3	0x1703b89a
+	0x34fb512c	0x0ac83386	0xd58c5728	0x5c018ed6
+	0xbe0908a0	0xd490b0e9	0x0ec94527	0x2f281499
+	0x471df723	0x03eddc08	0x9b99d975	0x11535b70
+	0x5802288c	0xb3512d42	0x415a9c0d	0x52dbd146
+	0x8b0c59bf	0xd8160cc7	0xe37dee6e	0xfd5211cc
+	0x5635ff4d	0x8d783398	0xc11f5d62	0x54ca73b4
+	0xc3ebdf96	0x835e7883	0x9cd03137	0xe4b4f709
+	0xdbde6d86	0x2b562b2d	0xfecc0df5	0x172a5ec2
+	0x568b52b9	0xf542957c	0xd738b325	0x49c49aaf
+	0x6eb4c9ad	0x363f4978	0xac4b0cb3	0x4ec8dca8
+	0x7a2ec2ba	0x10ff39bc	0x8b8748d5	0x6a86e67b
+	0x0d81e2b6	0xf4bde138	0x02249333	0xab0c7acf
+	0x4ce5e894	0x1656dad7	0x46c59329	0xa849fea0
+	0x3d0400be	0x6898c4f7	0xd866ff9a	0x84a5b170
+	0xc997009e	0x80524f6e	0xc80fb5dd	0x5bde0181
+	0x0bb0c8a8	0xe5a6b9e4	0xd4753f0a	0xda9bf0c6
+	0xd6dd041b	0x4c7338f0	0xa223bd71	0x23b58f4a
+	0xf6e127dc	0x1777033d	0x5b057a0f	0xe08af0bf
+	0x17c07032	0xbbc3f27f	0xac6dc98b	0x921e2f12
+	0xcf32236d	0x6cb700a8	0xa3b4e5cc	0xe9b65d73
+	0xca7d6f44	0x7b5917f6	0x7b80dd21	0x5ee87e45
+	0x86799f71	0x0667e036	0x8f97dcca	0xc4bfd5d9
+	0x90737eed	0x41b5a457	0xc6c96301	0xf8933e95
+	0xe51c2456	0x00c661f4	0x8a0e1aaa	0x92aa4181
+	0x1e3f8638	0xd481a14a	0xaf637189	0x91622fb3
+	0x4450865d	0x4202b431	0x5248342b	0x01ff713b
+	0xe33b5ec5	0x912d6856	0x10deb2ac	0x9072c180
+	0x24d792af	0xa39c5dfd	0xb4c94140	0xfeb32004
+	0xa174dae8	0x49da7dfc	0xa4db1090	0x7d2a998b
+	0xb7eba69b	0x9b824871	0x3557bd1d	0xd3a73d9b
+	0xf225310b	0xad1ffcf6	0x2d5f075b	0x592de6f4
+	0x69e438f4	0x4ed8cac4	0xa79c947f	0xb95f9590
+	0xb8ede5c9	0x0b1c9229	0x85a4b30e	0x65149920
+	0x433461a8	0x186fda4f	0xbaee7097	0xd3cac1bd
+	0x8bc32ca2	0x914f1512	0x9b619478	0x582a53c9
+	0x4e624a00	0x77e445ec	0x6f823159	0xa9c4766b
+	0x0dd6ad28	0xfabdadc5	0x704bfd95	0x08645056
+	0xe1939821	0x76650b62	0x8876941a	0xf812239f
+	0x2869ce13	0xa4d292c7	0xecba40fd	0x83d2fd8f
+	0xdd45ccc0	0x7c12b7cb	0xdc0a20bb	0x0d9be34d
+	0x4dd16a9d	0x25835446	0xb94d8c21	0x97ca8010
+	0xddd09324	0x95ffe31f	0xa86136c9	0x828ac571
+	0x9aa7fc00	0x382cc48c	0x015f7186	0xc3fd040d
+	0x505408e0	0x21cdc34c	0xbd266059	0x6e2f673e
+	0xe4523c1b	0x3ba56bb3	0x1c343938	0xabc0df54
+	0x8ba4f1e8	0xfbd4c592	0xb678c884	0xff3be2f1
+	0xca013570	0xfb0598df	0x3cb9cc1d	0xe3ba8ca3
+	0xc3d7ecee	0x0ae84a0b	0x0d70f0c3	0x963110ff
+	>;
diff --git a/arch/x86/dts/microcode/m12206a7_00000029.dtsi b/arch/x86/dts/microcode/m12206a7_00000029.dtsi
new file mode 100644
index 0000000..fe888bf
--- /dev/null
+++ b/arch/x86/dts/microcode/m12206a7_00000029.dtsi
@@ -0,0 +1,686 @@
+/*
+ * Copyright (c) <1995-2014>, Intel Corporation.
+ * All rights reserved.
+ * Redistribution. Redistribution and use in binary form, without modification, are
+ * permitted provided that the following conditions are met:
+ *	.Redistributions must reproduce the above copyright notice and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *	.Neither the name of Intel Corporation nor the names of its suppliers may be used
+ * to endorse or promote products derived from this software without specific prior
+ * written permission.
+ *	.No reverse engineering, decompilation, or disassembly of this software is
+ * permitted.
+ *	."Binary form" includes any format commonly used for electronic conveyance
+ * which is a reversible, bit-exact translation of binary representation to ASCII or
+ * ISO text, for example, "uuencode."
+ * DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ---
+ * This is a device tree fragment. Use #include to add these properties to a
+ * node.
+ */
+
+compatible = "intel,microcode";
+intel,header-version = <1>;
+intel,update-revision = <0x29>;
+intel,date-code = <0x6122013>;
+intel,processor-signature = <0x206a7>;
+intel,checksum = <0xc9c91df0>;
+intel,loader-revision = <1>;
+intel,processor-flags = <0x12>;
+
+/* The first 48-bytes are the public header which repeats the above data */
+data = <
+	0x01000000	0x29000000	0x13201206	0xa7060200
+	0xf01dc9c9	0x01000000	0x12000000	0xd0270000
+	0x00280000	0x00000000	0x00000000	0x00000000
+	0x00000000	0xa1000000	0x01000200	0x29000000
+	0x00000000	0x00000000	0x11061320	0xd1090000
+	0x01000000	0xa7060200	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0x00000000	0xd1090000	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0xfd2a2f68	0x82ac7ebb	0xa4916328	0x7480b81b
+	0xd329a777	0x25750339	0x9a8f7a9b	0xf1da9cb8
+	0xb1be7b1a	0x621d5a35	0x94b57e2e	0xa9def809
+	0xe4492a43	0x530252bf	0x1040fada	0x8a853a89
+	0xfb0e6e76	0x6d191ed9	0xefd28b83	0x946414e5
+	0x13f415d5	0x28487029	0xb69855e8	0x516cbedc
+	0xfabbea88	0x9f90e8a1	0x211793d8	0x54653835
+	0xa7789a08	0x754791d9	0x484764d4	0xdca45615
+	0xf64844f4	0xdbd754d0	0x7d2b0ff3	0xd023e25a
+	0xb048bbcb	0x83038b5c	0x57e17d17	0x735f1e9c
+	0x8982c22e	0x6c7b2ad7	0xb26e3b82	0x7121e035
+	0xe4ea8dba	0x68d4f406	0xaaafdb13	0xf119b472
+	0xb5853303	0x20698005	0xcf34604c	0xdc17d19b
+	0x042d6e97	0xf0300325	0xe1b55072	0xc2804918
+	0xd6d7a912	0xf908c81b	0x4f9979ae	0x0179f8c6
+	0x2f13e3c0	0xc5911467	0x39ad6c23	0x9c9d8837
+	0xf3c3f767	0xe56b4a96	0xdad7cebc	0x6eaaee57
+	0x2215ca7b	0x4cee4f65	0xd9a51c2a	0xf33c80a1
+	0x11000000	0x0b468bda	0x0b57c7cb	0x885fad4b
+	0x8a37307a	0x68cc7d5b	0xb6395b55	0x583626b8
+	0x21efe98d	0xa516cc42	0xf5b978b1	0x585d8a11
+	0xdd5f2ee4	0x17b1c7eb	0xb6f005ea	0x9ecc6ac6
+	0x82c0f1b2	0x25a114fb	0xa6086296	0x93da75f4
+	0x0695ff88	0xd413dd65	0xccf7609e	0xb7718aa8
+	0x334406dd	0x28de253f	0xfb43ca83	0xa4674656
+	0x7392e05f	0x9b062c62	0x17571892	0xb5811cbf
+	0x9d64666b	0xa01c1500	0x5893e418	0x07ba6ed1
+	0x0eebedd8	0x299a52bf	0xdfdb6191	0x4e846b26
+	0x298b7431	0x576f4479	0xf5317e04	0xc9492745
+	0x167c42e3	0x0c0cd705	0x82756ce5	0xe81ba860
+	0x536c357c	0xc27433fa	0x41c8078f	0x1ff779d0
+	0x73ddd76d	0xe606c66c	0xe0ad45bf	0xfebdc310
+	0xcb2aa836	0x39903a79	0xe53d5dc1	0x0cb6a1ff
+	0xe6091d08	0xcb2961d8	0xd38987ff	0x2bd624fd
+	0xfb4e484a	0x8c60efbb	0x0ed088b5	0x5a142b04
+	0xa737bab1	0x44da29a2	0xc046ecb1	0xe7ccefdc
+	0x81895d2d	0x41266fa8	0x52a5e25e	0xcfeac133
+	0x252b0737	0xec54b6c8	0xe1c9ebf6	0x25180c1a
+	0xea65b9e2	0x5e9ada96	0x08559e07	0x414fcece
+	0xdb4927f7	0xa229106d	0x6a7db273	0x8ac6a901
+	0x00a87e4d	0x14fd1e2a	0x63a5fa87	0x5ca223c5
+	0xc0c980c1	0x42c447ef	0x5b274187	0x75bd6279
+	0xdb44dae2	0x60856af1	0x777caf5f	0x298e810a
+	0x93f4f418	0x9e1ddf3f	0x6f589046	0x18ea149c
+	0x4a5ce4b0	0x529db285	0x3c2dde59	0x1d680e51
+	0x3a62d819	0xdf4c01d2	0x432a8f06	0x70a37043
+	0x4a0d4baf	0x0d3395be	0xfce0391f	0x5228aac2
+	0x9dd9b00e	0x6149f393	0x6fee1d85	0x1d3628cb
+	0x107076de	0xd99fe940	0xa227eec2	0xc97d8119
+	0xcf2fa8b2	0x821dac93	0x518875f2	0xd18d1d47
+	0x3e27fdcb	0x47823f98	0x20d42c1e	0x9a58812b
+	0xe0987435	0x1426f12f	0x61d6f627	0x5c58d415
+	0xe5ca80de	0x9e11e526	0xbccc0f94	0xb49cec4d
+	0x357f947c	0xbef0e2f2	0x5b9b2596	0xddc87ff7
+	0x5f2705f8	0xa25f2be7	0xbb45a165	0xe49ef6d5
+	0xe76e250a	0x75584c7d	0x7900da7b	0xee0e3360
+	0x6988740c	0x4aa56944	0x2d485383	0xef45f5d5
+	0x0df4b0f7	0x48199182	0x5b33c21c	0x8f2483c1
+	0x8aae6c50	0xaf406ccb	0xb7522bda	0xeafb64de
+	0x9a9b1fd7	0x3ab46c34	0x0ec5f025	0xe5bc9668
+	0xdb108e78	0xd6152ac8	0xc382ec93	0x5abc2565
+	0x4f256030	0x856f6eb5	0xb589dc96	0x3de80942
+	0x49d20a05	0x8e3ac21b	0x0262ecc7	0x5f1bce89
+	0xec50198c	0x0115b078	0xf67d94e3	0x1cc3682b
+	0xfb2d4ab0	0x4d6ce252	0x1d7aace9	0xf7e99257
+	0xc1235e85	0x8129ee72	0xb6cfbb13	0x6b851ab5
+	0x430633d1	0xe9ed33e9	0xfe85a42a	0xb4583c0a
+	0x35a65f5e	0x5fb0bc81	0xe16db440	0x7d022cf2
+	0x8f832920	0x20ed9ad4	0x6a4ace8b	0xf4c85869
+	0xf17dd57b	0x277ae0d5	0xb5f59c50	0x35d099a5
+	0x9ce955ae	0xcb200000	0xcedc4073	0x2a2ba8b2
+	0xa1b53439	0x46ced775	0x59069604	0x6488f5d8
+	0x2bc0af55	0x643178a2	0x36f62be3	0x2606f0a1
+	0x3057cf8a	0xc28f4a3d	0x708e8020	0xb3fccf9a
+	0x29b79fa7	0x35622d93	0x85eb0e68	0x80fa3b59
+	0x143f340f	0x20e17166	0x169fe55d	0x698f3655
+	0x0bc8b45b	0xde3aaf6c	0xbd597266	0x75505401
+	0x44d0095d	0x4c00f346	0xfb9ef2c6	0xee70ef96
+	0xae807621	0xfbbe7490	0x9c0a283e	0x01a8058d
+	0x1be53568	0x0b8dc8a8	0x45afb745	0x3ee1ff58
+	0xe772e14e	0x3ca4e729	0x6973e751	0x764f244e
+	0xca8d1621	0x6c4fb15c	0xae972e6d	0x3d26c6d3
+	0x5ca8f450	0x6328d65c	0x2e7cd88c	0x87dddcc1
+	0xcbbdefc6	0x1ab8c0cc	0xd21e503a	0x20c11d27
+	0x2f0adc1d	0xc24240d2	0xc73aa069	0x99afc53e
+	0xcab27e40	0xbe107ccb	0x8ad5f0ae	0x9024c188
+	0xe02bb39d	0xdb784309	0xf91acb54	0x4d15b75d
+	0xd339c237	0x3b556619	0xf69f91f6	0xca6fcfd4
+	0xb5ddf471	0x0698490e	0xb0855c30	0xe2b34b13
+	0x3c979248	0xc0484a59	0xb4cf9f4f	0x7975f2ac
+	0x602259d3	0x89364c24	0x37f29913	0x0b4c88a0
+	0x23f0b663	0x309c13d2	0x80a3d12c	0x4c866e87
+	0xea7e29c0	0xbc33db6e	0x3c3af584	0x63da0de7
+	0x9bc6bf5f	0x3b948269	0x4d41b09b	0x5724dd20
+	0x4e16618b	0x5917781f	0x4bdec762	0x562cc3fd
+	0x50e59d92	0xb3edea05	0xa6ceaa68	0x60af473d
+	0x78a99aca	0xd60ba313	0xe502992c	0x0c25c2ba
+	0x476eebd4	0xe7e23958	0xc4ac2757	0x0d6695ec
+	0x7664b4f0	0xb87ed0a5	0xdcf23b2a	0x76d38802
+	0x21699284	0x87b80e7c	0xf0e34f45	0x4bb84bc8
+	0x0316744a	0x26de0ed4	0xb25ff5e3	0x31445bb1
+	0xaccc5b87	0x271b976a	0xcdf5663b	0xe142d271
+	0x1af28339	0x7d304ca4	0x11ee6243	0xdf70fbc3
+	0xb8d88f25	0x4c2d9626	0x8eb72c77	0xceee1817
+	0x4e1b35f7	0x6c261f67	0xa32a2801	0x67ace2af
+	0x7c87f8c1	0xca6f2505	0x982269dc	0x137080a9
+	0xe40fa78a	0x3897a66a	0xdc5d0ff7	0x58016e44
+	0x21bcc988	0xf2a4df15	0x9fb021d4	0xca59e882
+	0x3673d08e	0x7cf5d500	0xd41ab9df	0xc17b4a58
+	0x2cb85aa3	0x01103427	0x5a8fac5b	0x7ac856b2
+	0xb1532563	0x1b94b518	0xadea3bfa	0x597109a9
+	0xf28df608	0xc2bf64bf	0xf517bb53	0x61b7d5ad
+	0xa4a38e9d	0xa9fdc597	0xf990f2f1	0x00466640
+	0xcecd06a7	0x5eef09d3	0xb67a08ae	0xd780d8a0
+	0x07641a71	0x9dc9f7b9	0x5f0b5a44	0x94dfe40f
+	0x6db0cf7c	0x3fe72d11	0xb2443ea3	0xe051f336
+	0x4ec8a6a4	0x11201430	0xb44e2b28	0x5bd018b0
+	0x444ba2bf	0xa63031eb	0x147f9826	0x3fc56ac1
+	0xd3a75ad3	0xc3f71815	0x340bd72b	0x3e5a488d
+	0x0cd8fb05	0x17791534	0x68e7321c	0x1489c701
+	0xa39f2d71	0x7cbbd9f9	0x42cba365	0x024f7d9a
+	0x29ef2da1	0x1eb9c4e6	0xc8b24985	0x9c33412c
+	0x5fd3003d	0x7f0793b9	0x497b6ef4	0x3af648f2
+	0x22f4a1db	0xac8500c7	0x3b1a859a	0x57921c78
+	0xb0efd82e	0x8e60452d	0xd86ed85f	0xc1ae73d1
+	0x633d83dd	0x7dbee7f6	0x46ef5590	0x027f2d50
+	0x3c81bcf1	0x37a3940d	0xc92d0a8f	0x270cd02d
+	0xaeed9d1c	0xb6d76bcd	0xda27f251	0x1625a683
+	0xf2d1302d	0x3f95bc0e	0xdb4b36e0	0x96fe1e6e
+	0x1dcbca54	0x57d44867	0x14aada62	0xf20f5444
+	0x9ccf560e	0xb8d178af	0x9affe58e	0x8e3bd741
+	0x7dff29e9	0x3c1998e5	0x9909e1df	0x1bbbd50f
+	0xfda14fdb	0xb66fb65e	0xe646d5f3	0x71f41791
+	0xbca50c12	0x57c6d2a2	0x8f5c750f	0x48f87301
+	0x9103acac	0xef185c41	0x6dbe9524	0x3c040c16
+	0x211dc2ac	0xa61925bb	0x20bfb41a	0x98253e77
+	0x4d5ea3b8	0xc2b11b6d	0x7f072104	0x58340448
+	0x596e3090	0x72484d15	0xf5e5d16b	0xc1b9faca
+	0x5c786fdb	0xdcd97509	0x73d21aa9	0x2a90c7ae
+	0x396ed0b1	0xa23e63da	0xea20cb1b	0xb2bb359b
+	0xb5df6ff5	0xdbc470b4	0xa6fd8d97	0x9458f6d0
+	0x97434866	0x2c9521c4	0xc51f6ad2	0xa33fb3b5
+	0xb26915d7	0x3ef363da	0x9ff9f5c7	0xfa236e60
+	0xa12b879d	0x2f98bd3b	0x95282ca8	0x64f90513
+	0xc03d2962	0xb13b82f8	0xfdc2eb41	0xc39dcf3b
+	0x95a409af	0xbaba6e7e	0x0d028543	0xc5b9426b
+	0x35f5727b	0x8f3b9f8c	0x6e7b85d8	0x2cfa9b2e
+	0x2a7117cb	0xa41f3fe5	0xbe17ff18	0x0f4a8be4
+	0x20b9003a	0xebce04ff	0xd6f276d6	0x9fc66d07
+	0x83f40250	0x560eaffe	0x92be2ddd	0xdb0ff83e
+	0x424f0605	0xb3cf76a4	0x167725c5	0xe3b513e2
+	0xc31a1a72	0x9f7161a4	0x25707dd1	0xdb5f2a91
+	0x85db06af	0x78443bf6	0xebbd8e7d	0x7909e5fe
+	0x618237a6	0xe6dea70c	0xcd3299c2	0x7736d40a
+	0x044cda94	0x6cec190e	0xb9652583	0x51946c01
+	0xcba67203	0x0dae0f1d	0x6d0dff0d	0x85756bf7
+	0x1db9e08a	0x88977944	0xa6252c60	0x06ff1a07
+	0x1b8d319f	0x884f10eb	0xbdeb7feb	0xe1681bb9
+	0xb5f0cefc	0x5359534d	0x6de87cf9	0x94a78727
+	0x15c17557	0x398876df	0x2f85f258	0xa0284d4b
+	0x4879ca57	0xb5ab7844	0xb402fde8	0xd520cb53
+	0x8a601365	0x8853b510	0x1e0538f6	0x0135f899
+	0xa78c7bba	0xa33c8ccc	0x6cf0da00	0xa5f96757
+	0x94714373	0x79413ed2	0x27c7b9cd	0xda172153
+	0xeeeee91b	0x959d8437	0x660efcda	0x2a6ab94a
+	0x8913d65f	0x24246350	0xf6c85ab5	0xf6b696f7
+	0xd75840c8	0x046b7435	0xb55474fc	0xd8d8bab0
+	0x265e79e0	0x0dd030b3	0x826a182c	0x38f1121b
+	0xeb33b5cb	0xe3ca835b	0xe8850761	0x25955d7a
+	0xbb6b7fb4	0xbc02ca0f	0x1b03bd1f	0xdd1a59d6
+	0x5d48f10b	0x35e35688	0x1411d34a	0x6131c664
+	0xc1b8b277	0x1bc8afd3	0x886f0c09	0xc1b6b517
+	0x74ec9ecb	0xee2d43a5	0xbc0f122a	0xd1911c88
+	0xc7e39b2e	0xa60c39b0	0x942fce7e	0xc8c2a2b6
+	0x51978cc2	0xad8d9ed2	0xcc2b0c3d	0xf6aff0f7
+	0xbfb3920a	0xd25aa79c	0x67d87d44	0xf612df60
+	0xf06dbe9f	0xd4ab61da	0xd96c6b1b	0xb39ab4b7
+	0x3368a90d	0x39c8bd81	0xf4ba5ead	0x6fe656ad
+	0x93b946dc	0x2181219e	0x7b98805d	0x675af3fd
+	0x59760289	0x934b4803	0x4189f27d	0x9503a5fd
+	0x42aaa076	0x6b4bd024	0x86c826e9	0xe0370ff4
+	0x1bfdf980	0xc487f797	0xd4754c3b	0x1098b2e8
+	0x05753a1c	0x3833ede3	0x5f1065ec	0x40cb562e
+	0x8d4fc418	0x392290d2	0x622d2e29	0x55df1f46
+	0x4ae0893e	0x24ddf8a9	0x302a64dc	0xc93f7504
+	0xde8e1674	0x033acbcd	0xc9732a64	0x6f7a7da3
+	0x72b7c43a	0xb5110e6a	0x00865c19	0xaf5e00f7
+	0x0a80b55d	0x6e638c0c	0x3771d602	0xb4a95ae7
+	0x01ba3cff	0x42e350eb	0xedb1d897	0x82f0cfff
+	0x98e79055	0x6b0cc62e	0x8ce1735b	0x62645395
+	0xd99fc208	0x86ee3066	0xc8f13758	0x2378d582
+	0xad41c218	0xc3954b87	0x47acab9a	0x69126227
+	0xbf778357	0xc5a7b76c	0xb96894c4	0x89e2dd88
+	0x27cc53b7	0x2187116c	0xd397c13b	0x578a6686
+	0xe3e58b11	0xdc3e4d40	0x69f064f5	0xdfb64348
+	0x42291e77	0xacc21c46	0x5444d976	0x616bcdc1
+	0x01ffb3bd	0x5cb926e5	0xbd763a24	0xbf224c70
+	0xdeca1d57	0xded1cc56	0x9b6cbcd2	0xee6efaf4
+	0x44d634ff	0xf33334c6	0xd275d66b	0x6a1a4c9d
+	0xbd675ae0	0x6289d1c1	0x053aeaf0	0x8a170aa1
+	0xe12cfbb9	0x0ae15a94	0x1dab08f3	0x9a2657ab
+	0x8348417f	0x9572e6dc	0x9c69e518	0x5397dfa1
+	0xe46120cd	0xad4457fa	0x0106a79d	0x40b191be
+	0xbb64bccb	0x9dda8fb0	0xc74fe994	0x64ac0ef1
+	0x3a57986c	0x86e8dc78	0xbb055d88	0x7a1243da
+	0x585cafe1	0x8968ad92	0x5b73bf26	0xccf77edc
+	0x10ac1643	0x5738ba43	0x3d39ecee	0x57fd555b
+	0x36ee9d5b	0xec9115fb	0x4250e03f	0x9e4fd6a6
+	0xc547b01e	0x9c84f42a	0x37756616	0x217cb517
+	0x33da3c5e	0xa0a7ae6f	0x8ddb7b99	0xbd84ac35
+	0x644ec4e0	0xaa62a7ac	0x71795f77	0xd5f67163
+	0x77dcc227	0x59f09342	0xf6666ce4	0x1e164a0c
+	0x011e205b	0xc4a80a0c	0x7fd31f1d	0x05ccae4c
+	0x39b6abfb	0xf4b7ac82	0x39d38e89	0x14c1e7f3
+	0xdb3bb53b	0x02577ec5	0x7bc12087	0x65ccc2bd
+	0x72492c6e	0xa6ae0062	0x965946ea	0x58e5f31a
+	0xfdfd7770	0x052afb9c	0x889b8358	0x2dd65c3e
+	0x55418587	0x445af0e9	0x43fe6671	0xae45e776
+	0x2c25d02c	0x44805865	0xaa3a70c5	0x7dd55d11
+	0x3499f5d7	0xc12e4a51	0x9ef98a38	0x5462e98c
+	0x0f73c72f	0xd0481aa2	0x56bccd0e	0x64143a1a
+	0xa7913ef6	0x0ca932ae	0x3739ec96	0xac5d38d5
+	0xe9c8c754	0xd56e855b	0x950cadcc	0x91cb2e5e
+	0x6e170c11	0x1eb66637	0xf641b0ae	0x8ba43c21
+	0x3f43b8af	0x8f1596e7	0xb614d1ae	0xac99c14c
+	0xe7beddce	0x5757f98b	0xfec1cf89	0x19608162
+	0x96479a49	0x1f089d9e	0xc2e4ac47	0x1cdea563
+	0x027f57a7	0xc0ba57c6	0x6eb2faa1	0x8e85c333
+	0xc391dfd2	0xe2c0bcbf	0xc1f87d66	0xb597d958
+	0x3655d5a3	0x2d9adaaf	0x8efd0aa0	0x05d65caf
+	0xa28991d9	0x28b6d7cf	0xdcb48013	0x65e75783
+	0x8b8b77ed	0xa4b36df8	0xa8ccfb9d	0xd0a1734c
+	0x2dc97601	0x35d81082	0x2e6d26f8	0xf3baf2c5
+	0x416084dc	0xd8b84ad5	0xa06b9edb	0x45c2b0b6
+	0x553c973a	0xbbcda1bf	0xca154d25	0x7a781012
+	0x4864ea32	0x0784f663	0x27656507	0xb359d4dd
+	0x43d4c165	0x69b844c7	0x31b1b9e2	0x0f3420f8
+	0x3cd2e455	0x201920cb	0x93018659	0x5c4a08f0
+	0x3a0d094b	0x5448c1ed	0xc888d1a2	0x4826cb64
+	0x625da2c7	0x12110d40	0x5cd8e76b	0x26e09eb5
+	0x8c6aab45	0x6dd192c6	0x937f1252	0xc927efc5
+	0x4c5bf11c	0xdd62c6fa	0xeef59620	0xbffc2d5b
+	0xb90299f0	0xb24df71b	0x76656678	0x550b3228
+	0x01536098	0x4fbfe03c	0xa82d0c31	0x2eec9bb6
+	0x752e6720	0x26322556	0x5d94bd64	0xa2e1122a
+	0x25899986	0xb63d5cc2	0x9222b055	0xbf4f0bcf
+	0x3d182483	0xc7bb9999	0x97ffc8c1	0xa6500a8b
+	0xb8b97382	0x3f6f39b0	0xcaca9f6c	0x7b67941d
+	0x7875ea1e	0x3ff25c0d	0x4cff1a40	0xb5a351ef
+	0x556a59e5	0x011e995f	0x25a7a5e9	0xedc8707a
+	0x42b4ddfa	0xa51a3ddd	0x9c9f1d73	0xc8f24ef3
+	0xfcd73118	0x1a61c16f	0x1e2fa7c7	0x1f49826a
+	0xd8418fe9	0x726358a8	0x6a0857fa	0x6804ccc1
+	0x78a55fa0	0xc3e41419	0x60416b10	0x2afe46d8
+	0x0c0ba2f7	0xd3dfa8ca	0xfa474ea2	0x8e763446
+	0x1f664c64	0x6a8d06cf	0x1b891114	0xa27c1a28
+	0x98ddd324	0x26cc9fb8	0x544078da	0x03acbeee
+	0xc3f3b761	0x56797b83	0xf04ac5a1	0x8603b17f
+	0xb8989b96	0x28c7be17	0xb750b4a6	0x84b2f7f8
+	0x32138f9b	0x7661c86b	0xb7517518	0xf2a961c6
+	0x240a0100	0x100c5b96	0xa1931730	0x18513938
+	0xdf2baa73	0xd6b55cce	0xf89cab59	0x238c90c3
+	0x4799f50d	0x29cd7942	0x62677a47	0x7261f326
+	0x4ff7da96	0x294ba5e9	0xb6474251	0x96de1b44
+	0x9d84552f	0x1103468f	0xcfd063af	0x5d8a0b6c
+	0x172670ac	0xc1a9b97f	0x0a278773	0x08b48bb5
+	0x392b3563	0x8f65e926	0x4be71f10	0x7615e05e
+	0x98b0c931	0x50bf9779	0x5baa97aa	0xb6e26fe4
+	0x2c40971a	0xe5d739f0	0xa7e30500	0xc724895c
+	0xc7a3f44a	0x5b381b1b	0xa7a478c7	0x219f567c
+	0x42d7a960	0xaae6780f	0xa96c56d1	0xe3787bf4
+	0x743f3a5e	0x6b99c9e1	0x36cf72b0	0x784ab5c2
+	0x5113773d	0x625393af	0x62c4da61	0x05422921
+	0x339711f3	0x3ee04f5e	0xf3a778b9	0x55e1bcf7
+	0xe49e5a9f	0x5f0935f6	0xa13e17f5	0x3028d23b
+	0xac9a6fd9	0x14006013	0xbf1b3fb2	0xce785f7b
+	0x83942244	0xd299d59b	0xf8c0593b	0x71c74beb
+	0x7561a1f5	0xb133ace7	0x15d5d4c1	0x21c3bb29
+	0x6ab1c2c7	0xee20d3dd	0xcfd62c54	0xedf9a43e
+	0x0e23222c	0x5eef5bc2	0xe7426bd0	0x42db58e9
+	0x62ffe203	0xd63163c5	0x8dbbcb48	0x9e16d9c7
+	0xb6d51e39	0xbee5a6c4	0x5d0bd775	0xeded86db
+	0x9eb1454f	0x6217eb64	0xa4b76ae7	0xe3481698
+	0x6d576cec	0xe751f610	0x1473bd83	0x4aaead8c
+	0xff4a602b	0x01ed092b	0x310f16cb	0x2e199177
+	0x693a8ad1	0xf5e520d1	0x1713d604	0xfff1225c
+	0x644c81b8	0x1adf5032	0x79058d81	0x7aafda08
+	0x80b6c9df	0x6f927c46	0x307bcaa6	0x0a1aac12
+	0x7d20bdae	0xd0e9c9a7	0x4530bebc	0xf1dbac36
+	0xdee3e8a9	0xa96d2aca	0x291c6944	0x436cfac8
+	0x9dd501c3	0x696e0c6b	0xa85d7036	0xca1c1321
+	0xcb802235	0xae614fec	0x4f0cf745	0x08604468
+	0x93bd00f3	0xf39eb605	0x89a8f420	0x18a7f61a
+	0xa0aebc3b	0x723e6ba9	0xed00f2a0	0x231b43d5
+	0x37c81702	0x891ffeb9	0x122de4f5	0x90f16757
+	0x1eb06046	0x21d5cdd1	0x75fd0e6f	0x7d595ae9
+	0xeb8ed50e	0x7bfd8696	0x3b91f3e4	0xd629e74a
+	0x1650dfcd	0xda48163d	0x2f8f5aba	0xbc40ee60
+	0x5291b6b0	0xb059d788	0x1ed5f092	0x65b7a885
+	0x44503d18	0x3a2893c8	0xaf3dab25	0x8ee0a8e5
+	0xf82f0696	0xf4fe9322	0x863feff8	0x2cfee629
+	0xacd8bcbc	0xb3791232	0xdd694c06	0x2a606479
+	0xaed9bc38	0x49a126fd	0x2a9c7581	0xaf43095c
+	0xb97acc90	0xca7a25b6	0x06adceb3	0xc8bf7269
+	0x6eeb0c59	0xa953657b	0x8e175c3a	0x9facc87c
+	0x4c143d0b	0xb4467fe4	0x372b6cbf	0x2099b361
+	0xb8ac2cfe	0xb9a798d0	0x15b8b336	0xdab5d568
+	0xb53a4dda	0x00ce1ef7	0xefef7644	0x41823aa2
+	0xcb8d307d	0x3baf1baa	0x7124a219	0x8d2820df
+	0xf3b8cfed	0x95e55a1b	0x8199fa40	0x631042fc
+	0xf7886353	0x3592b875	0x3b516841	0xac7aa00a
+	0x3dbfec52	0x9b91e8d6	0x0a8ffce6	0xd11429db
+	0x92392bec	0xe194095b	0x253d7425	0x6b55919c
+	0x4c11de8c	0x10b46ae6	0x5902c153	0x9509ace0
+	0xbb65fc04	0x648a35e0	0xab728bec	0x738effb4
+	0x416f95fd	0xee30a0da	0xcbaf3cb4	0x312fdeda
+	0xcdb5aaf3	0xcc631b82	0xe3bf4d97	0x37e2a1b5
+	0x2920c6b2	0x0d995ad3	0x11af607c	0xcacf31d6
+	0x781496f2	0x9e478c0e	0xc4c14545	0x89ba2ab0
+	0xdb1a8262	0xbb924c65	0xad836a24	0x4374fbd6
+	0xd45a10df	0xd4158c0f	0xd4e88c1a	0xee8b8e23
+	0x3472ee5c	0xc0a0de0c	0xb1ba04dd	0x7be6532b
+	0x0101669b	0x2a56f032	0x12879eef	0xa600458f
+	0x20a96992	0xa2e7910d	0x13235ef1	0xb1185320
+	0x418ffba7	0xc0ba01af	0x27571c7a	0xde5b661f
+	0xdd359089	0x6ae76b8d	0x095784d0	0x400a29fd
+	0x5b3276cc	0x774c4e38	0x6a85e14f	0x37d8d1bd
+	0x2007cea4	0x3e6942be	0x1a49828d	0xea4d84ff
+	0x681b5a30	0xd8ff8440	0xac19844b	0x7553a6d0
+	0x389fb0a2	0x1b0526fc	0xa193b9e0	0xb9987cb7
+	0x6f14d980	0x0507f958	0xf6a1354f	0xcb9e49d8
+	0x5a4e1d3f	0x10d8c348	0xb77cf166	0x5097503d
+	0xf0e17ed5	0x72a2e029	0xddc756b8	0x0a0e30e8
+	0xf12c6bc7	0x809db2c5	0x243fee9c	0xd2b57957
+	0xc1b19244	0x8d59262c	0xff94c28e	0x2050edc2
+	0xa4806d15	0x02026bf6	0x2d95c9d1	0xeb336e65
+	0x84bcf6ac	0xe53b97b7	0x954eedc9	0xf22209fe
+	0xf4771bc0	0x1e405f04	0x1d0ec592	0xcd479333
+	0xdfeb3738	0x0ae23cb7	0x03d509c5	0x837a5e1a
+	0x634a4467	0x7ee22185	0x102f5326	0x5d002daf
+	0xea4e31ce	0x1d2be82e	0x5ebe1ad6	0x354259bd
+	0xdaed312d	0x1e598ea0	0xd6a2b9af	0x76eb9bbb
+	0x338645d3	0x4d3236f8	0x777011eb	0x0221d076
+	0x22dee347	0x1e35037e	0x2f34d4c5	0xdda03e2e
+	0xa541311d	0x3acf0087	0xb435b17c	0x08b8210e
+	0x7c77f156	0xe20025f2	0xea0e32a9	0xbf766fd1
+	0x8b6c4f43	0xf6ca80f1	0x07d1d342	0x272b865d
+	0x8261aed7	0xf3bbe9cf	0x5835370f	0xfaaf4623
+	0x8cb5a665	0xe6c92e5f	0x22ce69f6	0x61e16f89
+	0xf15ec311	0xbacaf7b4	0x1317e388	0xa1869c49
+	0x328da67f	0xd818a8fb	0x6f4c7613	0xcc13480c
+	0x06789788	0xa7b4e1a8	0x0d8fed7b	0x48308fe3
+	0xbe5ff9e2	0x7e7a74ee	0x4ffbb70c	0x551895c8
+	0x734ffc0e	0x82b8b8d6	0xdf710f9c	0xc3df529d
+	0xf175e377	0xcec6194f	0xc3443fb1	0x52655208
+	0x94be229e	0x3279939e	0x771647a1	0x34c9a15a
+	0xaae80baa	0x0b32ec13	0x6d59b440	0x50ddd10b
+	0x98c166cd	0xfd465f40	0x74eabbc2	0x6dcb95c0
+	0xddef6f85	0x54348377	0x905f31bd	0xbde86f48
+	0x1322356f	0x90f3d5f2	0x5d2d4de3	0x2d5253a5
+	0x729b8879	0x41839289	0x845f8061	0xf5ffcf8b
+	0xf25ec4d7	0x30570dda	0xcc69f64b	0xeb024bde
+	0xc847bf80	0xeb8c5624	0x4e4d28eb	0x43f6cc1e
+	0x8c201bfb	0x1475f9cc	0xde13b005	0x11fd9342
+	0x07617ac9	0x2fec6867	0x5b30a62e	0x5a8c91f7
+	0x47208b6f	0x680a22af	0x60fd0ebd	0x229ebe44
+	0x568c37d6	0xa3eb78b7	0x6f06f502	0x1b183db2
+	0xd48e4d35	0x4fb23b3d	0x57d7dc0b	0x3d34b427
+	0x0415552f	0x1bbe91d1	0x74e7ecf8	0xb1fdc30e
+	0x466a69f5	0xfddf86b3	0xfb61fd48	0xae250961
+	0x6a99bcec	0x2142c5c8	0x1c08d4ea	0xe8f849c2
+	0xa3cb1614	0x43ac8702	0x22b50659	0x92dc3644
+	0x7a40a305	0x4a1e0780	0xfb638be0	0xb0912795
+	0x522a688e	0x1133c55d	0x0544a27b	0x3c56a574
+	0x748502e1	0xaee58228	0x30ae0736	0x41a029ad
+	0xa1e3d0e1	0xa9b66582	0x6ec07231	0xda4dba0d
+	0x41db8fa0	0x731529eb	0x87f679d3	0x593d1579
+	0x10935a3c	0x793d7b44	0xac680a86	0x1d01ec27
+	0x6d669681	0xef056753	0x96aab271	0xae070e5f
+	0x3321dc26	0xa5ea33a2	0xf8f14406	0xdc755c9d
+	0x7f8e3210	0xc2fd90cd	0x34c102d7	0xe1c744a7
+	0xa79f623f	0x07507959	0x34d28c67	0x26cbff85
+	0xfa24075b	0x618dcdfc	0x64d52c6e	0xce650b7d
+	0xcc414394	0xadc52ceb	0x43667ed0	0xa04f518d
+	0xe52196a2	0xbcb7e578	0x2ed0486e	0x4d669b00
+	0xf765e153	0xd2f097df	0x4ef97542	0xfa31d688
+	0x1698d42e	0x3d828d65	0x222355aa	0xf2c37eb2
+	0x3da4052b	0x198577ae	0x819590ff	0x5ab919a5
+	0x673d5552	0xd2fa9d52	0xb711b72c	0xabd9c188
+	0xb73a4ce5	0x2d20447b	0x3d19d4c4	0x4bbe86d0
+	0xd205021c	0xe9875ec2	0x8dcb01f3	0x6e109fec
+	0x60a3a693	0x2fb6b975	0x0ed26de1	0x7487f920
+	0x83092880	0x4d5fcb5d	0x72b047d0	0xa256dcdd
+	0xfef28251	0x41e36ee6	0xd91e2c20	0x7698357b
+	0xb3684b1a	0x272311be	0x32860f75	0x44a6cc61
+	0x63e3f66f	0x5a1497b7	0xeddf5a57	0xcdd4577c
+	0x3cc63cd3	0xf7e72773	0x3fc9bb40	0x97ce4118
+	0x1438da68	0x7a32210b	0x2aa07598	0x04e858ca
+	0x850e0082	0x0b0f78d1	0xb178c391	0x9a2e231e
+	0xa8f3b67b	0x2a08ea99	0x340d101b	0x42973ffa
+	0x755ae5cf	0x201213c4	0x445e44f7	0x15a872c8
+	0x857b94f3	0x24c023ab	0xb203df2a	0xc4711de8
+	0xd1faaeea	0x1eb857b6	0x8c1b712b	0x11ad0f2a
+	0xc64cf474	0xff6c128c	0xff13eac3	0xc4952e8f
+	0xacdac9d1	0xb8c2f092	0x38d50a33	0xaeec4534
+	0xa661a7ee	0x4d19a2bd	0x0f2d95e4	0x9a221827
+	0xc9fe071f	0xe53486d7	0x1dc5426c	0x848eea4c
+	0x607f616b	0x41a301f6	0xeadc389c	0x1f109048
+	0x249f14da	0x2a20d362	0x7c93cd00	0x7ca633e8
+	0xe50fb5a4	0xace8f92f	0x49638c89	0x478b4371
+	0x60d70e8b	0x0bfb8bfb	0x6cac803d	0x702996e4
+	0x15a35d2c	0xd68a2d93	0xe025d5ee	0xd8ca8c86
+	0x295393d3	0xce1be3f8	0x0ee6bd15	0xd6735f38
+	0x311495e6	0x7eb8bc83	0xea53551f	0x4fa9a90d
+	0xe16a9ea0	0x651eb233	0x95f0afec	0xc687ed29
+	0x0cd3abc8	0x132bb8b4	0xd70dadd3	0x538e630a
+	0x98481e4c	0x0d7e6f1b	0x3986b2de	0xbe0924dd
+	0x1d14608e	0x189f553e	0x7a6b7786	0x48bae520
+	0xed56a3cf	0x795b4c6f	0x8670597a	0x40eb02ab
+	0xf9b0b287	0xec9f86c3	0xe9a8c3a1	0xe6860542
+	0x387ad930	0x8676e402	0x633f0709	0xd661d134
+	0x011c1396	0xabf1f3f5	0x3fd76128	0x7be75289
+	0xa6046e69	0xf3713680	0xa2ed30c5	0x893df28d
+	0x197b8543	0x9860bef6	0xf6930c5c	0x6c0c379b
+	0x0b0026e1	0x3ca86896	0xa7ea0bdc	0xca94413f
+	0x6cbe8d16	0xd3e4edf9	0xb06efcef	0x3a8934c6
+	0x00195592	0xa978bf0c	0x7435b0d1	0x3b17d97c
+	0x0438684e	0x576ced8e	0x648683fc	0x362a8a87
+	0x493fd86f	0x6bbe0476	0x16f74de4	0xbfeaaba8
+	0xe6b90728	0xdc252878	0xe0b72eac	0x0872f52c
+	0x2bab1521	0xa6c0d894	0x9f2b3726	0xd392e334
+	0x785f82ce	0x15bba4af	0xb55cd743	0x6e8e9cf8
+	0x047fd2e7	0x1fdfe424	0x8d4820e5	0xce7dd8c3
+	0x88c82282	0x31ef9a76	0x1881fc38	0x3932a9da
+	0x65bbfefb	0xe00f33b6	0xdd0754aa	0x1f596051
+	0x704dfd7b	0x2604be1b	0x08b6c4f5	0x3f244085
+	0xd89c65e3	0xcc4cdb71	0x143a2681	0x1bd3d004
+	0x009460ff	0x86e314a5	0xb1aff86f	0xaa2599df
+	0xbf68de69	0x355c8267	0x9588dbed	0xe47edd9b
+	0x266b2ddd	0x129b0b01	0x6e6622a6	0xb3ea4a00
+	0x802abd6b	0x7a268c1d	0x9f5a7b41	0x6f4aba0e
+	0xe279b988	0x660ef08f	0xf4207beb	0xfa0168f6
+	0x93266ea0	0xedfef092	0x302b5e5f	0x7278d2be
+	0x58a494ab	0x8f53a302	0xf5e766de	0x1ef717bf
+	0x45e2d6fd	0xf593b066	0xaea0f1e1	0x1bd1e027
+	0xf853ba21	0x1127c5c4	0x8aa43b18	0xf1fba0b8
+	0xe1cfb0b8	0xa9f9fef6	0x1320f1ab	0x5f7dfc74
+	0x30f11ab4	0xaf47a3cc	0x9c190830	0xac085edb
+	0x8b4db7c8	0x771ec065	0x6d5f3c3f	0xb8815437
+	0x20d3c99c	0x00823c74	0x24d63cae	0x7587e453
+	0x1a3fd67b	0xa5b361cd	0x789d168b	0x98a93943
+	0xd7505c0a	0xa923b38d	0x46097a4f	0x814e41dc
+	0x0f50f2de	0xbb548368	0xc48273d4	0xf27b6798
+	0x9a6b5231	0x68491e7b	0x3f482179	0x89ea3b35
+	0xa7525ffd	0xf8f1f616	0x07859572	0x738cb4b3
+	0x8937c6dd	0xf5988c71	0x4874905e	0x677a8c17
+	0xd58df987	0xc4210078	0xe6b1c480	0x7a91e14d
+	0xa1228a7a	0x09057467	0x6cd59ec7	0x6ba93248
+	0xb8e263cb	0xd3305730	0xaec36ee6	0xc773d0b5
+	0x2895f8ec	0x6c9f5fb5	0xd32a21a5	0xcea9d058
+	0xfa97282f	0x5559ceb4	0x5a0bf57c	0xf3cd99b5
+	0x2771f6c4	0xfcc9a35d	0x5143417e	0x7c6f9db7
+	0xb47cb7df	0xe7dde37b	0x70a07531	0xe25e06a2
+	0x3bbb7d30	0xaf41b085	0xe664f973	0xee2c7ab7
+	0xef8eb1b5	0xfba67f7d	0xd71568dc	0xbbff3339
+	0xdf49725d	0xbc0e7edc	0x5361e6d3	0xb0978c73
+	0x1320540a	0xa9843a06	0x34099c74	0x4bdddd23
+	0x18680496	0x44f9cc19	0x6de71a34	0xe4eae858
+	0x3349a819	0x28400571	0x10a55fe9	0x05672399
+	0xb376eadd	0xed4b1a35	0xe79d0a4f	0xca8d0601
+	0x78a7b066	0x8ea59a40	0x7be112a2	0xe99ea438
+	0x44bd9efa	0x6e5227a1	0x70325aef	0x777282e9
+	0xb579c189	0x4ee92bc9	0x0d0236dd	0xb57cf232
+	0xb815e184	0xd05823e4	0x0c9490b8	0x70a5fa56
+	0xdf0f178a	0x99d27374	0x1aba9e05	0x18378c3d
+	0x86991118	0x3a199a70	0x90b2a2cf	0x67a6923b
+	0x0975e5f2	0xf50fb0a3	0xbffbd67a	0xce6371e7
+	0x203564ef	0xb1d7a395	0x201cb1c4	0x30085e3c
+	0xfb2c66b4	0xf80ae969	0x1d407625	0x0bca1a0f
+	0xb62c078f	0x83efbf38	0xbd7b0a69	0x7d9bb66a
+	0x46b5c885	0xb256d753	0x0b5d008e	0x1756d5bf
+	0xa9ffdaf6	0x01231fcb	0x8c69e461	0xbb2ad661
+	0x29dee8f7	0xf1f23d56	0xd5e90ffa	0x48d9d93e
+	0x77b26e95	0x49c47953	0x7565da8e	0x41a6124a
+	0xfce69643	0x55f99554	0xa5501d6e	0x5738b726
+	0x4c989c96	0x93cbe27e	0x20ff3d38	0xf4787a09
+	0xfa3520e4	0x26b2dc11	0xb701c94b	0xcd8857ee
+	0xb4b07229	0x0bbcf1a7	0x3d31cd32	0x08ced413
+	0x3da04c1d	0x7bdf1787	0x344f510d	0x53a02e8e
+	0x7e295418	0xa5ed24b3	0x3a5a2c98	0x34947e44
+	0xb398bfcb	0x7c0ea498	0x18db3289	0xec646beb
+	0x2e8ed766	0x5aff9ee3	0x497dc7fa	0xa70c3be4
+	0xfc9306c4	0x729f532c	0xd87d61d0	0x635fadbd
+	0x1efb1234	0x66fdb543	0xf5b86d07	0x3a4836fd
+	0x9caf7dd3	0x8a9d9e5b	0x179529ac	0xa9a3fee8
+	0x4cfa4495	0x791b8b7a	0xc503fc2b	0x1e07d0e5
+	0x0561cfae	0xb5e7c403	0x0809744a	0xea84c654
+	0x23614fd6	0x23ae773f	0x545be2c5	0x3585b8b4
+	0xcad8b6ed	0x088a56c0	0x81054caf	0xecb13d9f
+	0x44bd49f7	0x90a3da4a	0xf4b04300	0x32a2b69f
+	0x44bed501	0x85cb54ef	0x85dde589	0xe410132b
+	0x1c2e41c7	0x3d28cc9b	0x4df948de	0xaa058c37
+	0xb82cf615	0xfa0574f8	0xd0391f5d	0xfb2b98b3
+	0x3ce5585d	0x80ca4d6a	0x4b138f75	0x721ccc65
+	0x496a3e37	0x4a8dd025	0x2d77b3db	0x65800ff3
+	0x1d2df03e	0xb4b12a59	0x4c6a5b9b	0x17413fda
+	0x4e938a09	0x7e3aa03a	0xf86cc8f3	0x972cd7b7
+	0x871849b1	0x0c0879d2	0xc7c652a9	0xe9531ae1
+	0x541142d9	0x4f731afa	0x9c43e538	0x866b695d
+	0x4a4c4076	0x1e8aa293	0x51bc1eaa	0x5f57d28a
+	0x142eb7f5	0x14096954	0xae0e9eb3	0xef732983
+	0x70187474	0x3569b88a	0xfd3a3c61	0x54f0e2d0
+	0x7afff032	0xa89cd23d	0x658114ec	0x434ccbc9
+	0xc25f33c7	0x1b6e9a7a	0xd97bd017	0x3b7489d7
+	0x67129c97	0x333ee180	0x04bf73ae	0x4731105f
+	0x09d589f9	0x7d5a67a3	0x3e8fcb8c	0x2090c536
+	0x14a623c0	0x21a247fb	0xe117bbe6	0xe98bbd1c
+	0x09e23674	0x02f09f22	0xba7f9f45	0xd18573b6
+	0xa6eb18fb	0xe01a7904	0xa8869f58	0x82ec81ee
+	0xf4549f1a	0xfa0f6085	0x1cf809e9	0xe603d078
+	0x13525306	0xd5611c7a	0x2c92b32b	0x5fdc0c0a
+	0x0b3aaced	0xa40059b7	0x27c42499	0xcc619db5
+	0x9f9b7841	0xfdca5eb2	0x2d3e833a	0x2830a6a0
+	0x4c81f3b0	0x3ec8a8bd	0x50b95605	0x33a9d515
+	0x7fe14795	0x4ff1d83d	0xef92fbfe	0x87f4faed
+	0x35d5fc69	0xd8764a49	0xec81abfe	0x634a2ed8
+	0x9635825a	0x0943624c	0x5eea8464	0x578e2344
+	0x551bd5af	0xca02915b	0xea419d8c	0x9d0fa00e
+	0xf3633f48	0xc6ad62ae	0x1eeef6ab	0x21ab106a
+	0xe325954d	0x60457916	0x6ac9168c	0xea8a9d6f
+	0x14772361	0x7630452f	0x8795e1de	0x21144d8d
+	0xe7996dd2	0x45aff64a	0xfa62c37f	0x3f5a04cf
+	0x250f988b	0x7985d243	0x1f717008	0x7908d22f
+	0x4fc0d5d5	0x856d9819	0xccfab84e	0x3fec2a74
+	0xe75c1af6	0xe2682ac3	0x2f08e560	0x7133d2a0
+	0x63e5fcca	0x3a17438f	0x9cb826c8	0x06a2f3cd
+	0x4bac2001	0x50596ba4	0xe74758d4	0x64d17e0a
+	0x08fc5b67	0xb0d62f6e	0x95eb8e15	0xd51bfa64
+	0x421c68b9	0xdd1526a8	0xfb7ea10e	0xab21193a
+	0x4b1186dc	0x77bbfd82	0x1ab08e9f	0x871659a5
+	0x1658fd5f	0xa04f322d	0xf50ed273	0xb8d411a7
+	0x8056489c	0xfbd858ae	0xd70f7d88	0x3c5cbc78
+	0xf53ec2be	0x1d2228e2	0x8b53aace	0x212454d9
+	0x76ea1d2e	0x9ca66373	0x9f6679c2	0x51c48b56
+	0x47348811	0x8abc0a27	0x60050980	0x5d290483
+	0x7ea8504f	0xde186466	0x91219d4c	0xa73144ed
+	0xb5f36fa4	0xa37912b8	0x02625bd3	0x3bc2d9ed
+	0x2e623844	0xa9a751af	0xf0ba18af	0x4433e06e
+	0xca7cda24	0x686c9163	0x86a437c1	0xf8c17120
+	0xed50542e	0x62b61fa1	0x600e47b6	0xdff86df8
+	0x77502dd5	0xea5d75ac	0x095a06e4	0xa18efafd
+	0xfbd01eaa	0x27a1cb0a	0x3dfcab8e	0x07be7250
+	0x086cb680	0x2c1ddcf4	0x6fa79784	0xcd874edb
+	0xa383d520	0xa5c0d1cd	0x2e09cd9a	0x34d645c4
+	0xf6b9b98d	0xe8e80ab0	0x39b78c60	0x6098b6f2
+	0xc3c13e53	0x88c9fd83	0x60c9e766	0xf49c4c2d
+	0x79e3d3d3	0xbfade7d5	0x6ba57dc1	0x3069e3ad
+	0x59632e2b	0xb86e871e	0x2dd63287	0x9704b283
+	0x343a6cb3	0x37d7950d	0x283f262d	0xd49d5f75
+	0xdacc49b7	0x5952e045	0xc0fefa19	0x69effce3
+	0x5b2a3c0b	0x3757339f	0x18584f8a	0x77a80760
+	0x5fcdadc0	0xc9b4df80	0xfa521be0	0xbcfc8ecb
+	0xfd3f8eb8	0xbee4739a	0x139caf94	0xbdea1cd7
+	0xab158240	0x233fd8dc	0x8ec63274	0x34eee6d8
+	0x4603b2f8	0xae544fc5	0xcd444551	0x2b2b349a
+	0x0a562524	0xb2e02518	0x577b1125	0x8b3c1ff9
+	0xfd27d88c	0x2ad77d04	0x1f82a54e	0x20254fdc
+	0xee8e63cf	0x8df3fa2f	0x9ffc7c43	0x421ae12f
+	0x9b166441	0xb74a5a4f	0xdad0511e	0x0a8ee5e9
+	0x8fe86041	0x37ef90ea	0x3fcf8380	0x87288691
+	0x384b8b8a	0x98d8a45f	0x995443d7	0x6c617236
+	0x9a40f76f	0x9f30733f	0xfdbf3927	0x7b4c0281
+	0x9e87e64f	0x9802938c	0x65f9de31	0x829c3eda
+	0x0a1d2f4a	0x22e0e854	0x30045b70	0xbf84a44f
+	0xc2c30b57	0x47c5ff90	0xaea87e93	0x99c69ae5
+	0x1080e89f	0xc2896e80	0x09ba0cb2	0xd16ee263
+	0xe05337b0	0xef1d8359	0xc1d4b102	0x08620117
+	0x2e4ab2bf	0x05dc3af8	0xc7ab866b	0xeee05983
+	0xd0a00c19	0x96996791	0x75ac6042	0x29001ada
+	0x13440a23	0x2b1eca42	0x4cddfd68	0x81a98384
+	0x6bcda226	0xa8594443	0x92f26e53	0x434de4ec
+	0x07596ee2	0x4c8ea6ed	0x5596054d	0xaffe0ef4
+	0x6dc1ab64	0x20bc006b	0xad4e3933	0xe6df0d3f
+	0xfb3ca9ee	0xc2895a4e	0x8fed0d43	0xa5ed7985
+	0xc364f083	0xc397a806	0x7b651ff9	0x1d7e22e5
+	0xfd02f57d	0x5f16a429	0x8612177a	0xd36b8983
+	0xd87b0303	0xeaa632b0	0x57dff2b2	0x19772dd0
+	0x51317bfc	0x28404b1f	0x9e35d818	0x9c771bb7
+	0x6d42a5c1	0xa6030578	0x9c844d5f	0x95d5eb7f
+	0xdf15f5ec	0xf0f8c86e	0xf8ebfd20	0xae32d9b5
+	0x4ce2b066	0x776f0149	0xda8a429f	0x0e895a79
+	0xbe62c881	0xf9c051d8	0xcaa48f97	0x9e8dcb1b
+	0x69cafc21	0x411f1bff	0x4f4d71dd	0x102cf709
+	0x974ebe53	0x7373aea6	0xef2a7ec1	0xedabaccc
+	0xdac969c4	0xe010b562	0xb6880570	0xa7a7f5d4
+	0x3c6464f2	0x96dea774	0x1614a588	0x06074080
+	0xb37304f0	0x99da7dda	0xd3e36214	0xb27b7cae
+	0xb4cef0b3	0xa435dc77	0x9d1c1a15	0x616993f4
+	0xb8a5ec8f	0xdce1ff5a	0xaaea14c4	0xa5d2172f
+	0x90c8c636	0x49c0b81e	0xff9db895	0x4252b336
+	0xd420b5ce	0x87b35be4	0xae32bda2	0x441092d9
+	0x321e8583	0x7d863719	0x3c888147	0x3f2bb9f6
+	0xd1daf5f1	0x682f2ffe	0xae62e280	0xcf8f928a
+	0x4a7237f5	0x6f3a55af	0xb91dba98	0x9b83b723
+	0x0e857ed8	0xd5ac567d	0xaf8bf791	0x23f8269a
+	0xe369638f	0x6a88edb1	0x5ff0be07	0x5c02b513
+	0x7d22f89e	0x2f865c08	0x9cc0d56e	0x31c87205
+	0x420508f2	0x95a21602	0x04d838e3	0x353353e8
+	0x7ca1feb6	0x61c6f7dc	0xf78a68eb	0x918f2ac1
+	0x413037a4	0x09692d1c	0xc8eceb54	0xb1bf975a
+	0x2ab63552	0x467bceeb	0x408bf024	0xeaed2b31
+	0x3255158b	0x8d9c6617	0xe450350f	0x615cf5f3
+	0x1a7fd744	0x27a0da59	0x43298211	0x77392298
+	0x9511e81a	0x08a2c2dc	0x3d6f1113	0x967e6586
+	0xd1726b35	0xb9292da6	0xaa6f8ad4	0x0f13b47f
+	0x34b96cea	0xebd9487d	0xfe533d60	0x41bcdc60
+	0x364c8c79	0x32be8bb8	0x1395ead9	0x9e85e474
+	0x146b6fbc	0xc93267cf	0xcdda98d4	0xccfb2835
+	0xe779dbd5	0xf9288237	0x2073e129	0x16fe4ab8
+	0x34ca576d	0xac313eb7	0x5deb3b4d	0x1727510b
+	0xc168a414	0x332cd921	0xe38e8123	0x9a2c1aef
+	0x80f5d1d9	0x7c88c923	0x8af17577	0x59ae1408
+	0xffa5e565	0xb418ab13	0xdd6376aa	0x45cd70d9
+	0x3c3a06a2	0xbc555669	0x34d1fc08	0xc2aa934a
+	0x385416e2	0x91ceeadb	0xe06c9cef	0x0394dbd4
+	0x43e7c657	0x296d7621	0x55dafcba	0x808b836b
+	0x61c41f0c	0xd9689bc5	0x3a531ffd	0x8417ed30
+	0x3f3f8616	0x641eb4a9	0x24964006	0xe8d2612a
+	0x3b916d7c	0x5603319f	0x29007523	0xc9c7dc1c
+	0xd1f7212e	0x22ac1932	0x05c39a5a	0xd55081ce
+	0x589ae996	0xa998fcbe	0xd8df5512	0xef7d7a01
+	>;
diff --git a/arch/x86/dts/microcode/m12306a9_0000001b.dtsi b/arch/x86/dts/microcode/m12306a9_0000001b.dtsi
new file mode 100644
index 0000000..53417c2
--- /dev/null
+++ b/arch/x86/dts/microcode/m12306a9_0000001b.dtsi
@@ -0,0 +1,814 @@
+/*
+ * Copyright (c) <1995-2014>, Intel Corporation.
+ * All rights reserved.
+ * Redistribution. Redistribution and use in binary form, without modification, are
+ * permitted provided that the following conditions are met:
+ *	.Redistributions must reproduce the above copyright notice and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *	.Neither the name of Intel Corporation nor the names of its suppliers may be used
+ * to endorse or promote products derived from this software without specific prior
+ * written permission.
+ *	.No reverse engineering, decompilation, or disassembly of this software is
+ * permitted.
+ *	."Binary form" includes any format commonly used for electronic conveyance
+ * which is a reversible, bit-exact translation of binary representation to ASCII or
+ * ISO text, for example, "uuencode."
+ * DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ---
+ * This is a device tree fragment. Use #include to add these properties to a
+ * node.
+ */
+
+compatible = "intel,microcode";
+intel,header-version = <1>;
+intel,update-revision = <0x1b>;
+intel,date-code = <0x5292014>;
+intel,processor-signature = <0x306a9>;
+intel,checksum = <0x579ae07a>;
+intel,loader-revision = <1>;
+intel,processor-flags = <0x12>;
+
+/* The first 48-bytes are the public header which repeats the above data */
+data = <
+	0x01000000	0x1b000000	0x14202905	0xa9060300
+	0x7ae09a57	0x01000000	0x12000000	0xd02f0000
+	0x00300000	0x00000000	0x00000000	0x00000000
+	0x00000000	0xa1000000	0x01000200	0x1b000000
+	0x00000000	0x00000000	0x16051420	0x610b0000
+	0x01000000	0xa9060300	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0x00000000	0x00000000	0x00000000	0x00000000
+	0xc2b13ad8	0x6ce74fea	0xd364ad12	0xf6404a69
+	0xc89041e4	0x217fa2f6	0x6ff6e43f	0x79cde4eb
+	0xdb01345a	0xceecca42	0x5ee7d8b4	0x24afdbe6
+	0x5fb36178	0xbc17d76b	0x31b7b923	0xc81aec82
+	0x647b3320	0xf1db9653	0xff3b9759	0xe9c74b72
+	0x3b193752	0xc147860b	0x160e0d6a	0x5bdb9dbf
+	0x1ccce2ac	0x387670ad	0x2f106f05	0xf8607ea3
+	0x42562576	0x30e086fb	0x409a06b8	0xf1957736
+	0x5eb03f65	0xad147fab	0xe1a8e8b6	0x208d59d2
+	0x683fba2e	0xf172b378	0xf8138dba	0x61e81d1f
+	0xd551f997	0x28c79780	0x04f9db27	0xa80679b9
+	0xaca4e7ff	0x6876944b	0x26d7dbc1	0x77f7dc2a
+	0xf0bcb163	0x1b2a8e81	0x7b90aa49	0x8d5eaf2f
+	0x522384ae	0xae7f7082	0x412ba10a	0x1ce1baa0
+	0x478c29b4	0x9c09b4d2	0xf225f64f	0xd43026cd
+	0x81098579	0x7df5db05	0xa5815bb0	0xc73ee756
+	0x9738cb95	0xa5bd62e2	0x88e2c6b2	0x778e7fcb
+	0xd3bdb872	0x9404403f	0x5be6ad63	0x71dc4abc
+	0x11000000	0xd350099c	0x242d0996	0x1a4ddff8
+	0xd7f1f03b	0x77590eb8	0x45c3ad79	0x3b714d23
+	0xa85ba322	0x31851c5a	0x540fe0ce	0x38692bd6
+	0xe3d9927b	0xb33428b5	0xcf0ac8d2	0xd3646604
+	0xca88adc7	0x8afc41c8	0x721432b3	0x8fd19454
+	0x26344e0d	0x3acf6c28	0xbda18c21	0x526d52ac
+	0xf8d37e15	0x09305e37	0xf6907871	0xdb56cc21
+	0x6802cccc	0x6693c8a3	0x0f4dbe32	0x0d924103
+	0xee9242a7	0x5f867a13	0x2f65a246	0x6b35ad05
+	0x39fb7da1	0xd69cb7d8	0x45869424	0x4768b466
+	0xe3ace365	0xa85eea7c	0xa59939d9	0x2ae32fb9
+	0xa20b1559	0x8865f3d3	0xbe02e023	0x4199575b
+	0x0c43089a	0x0d57b287	0xd37544ad	0xcd4573b4
+	0xa96b7485	0x05b67259	0x117414ca	0x2ba24577
+	0x439db14d	0xf82c5833	0x54ec9806	0xf8282306
+	0x1de7d3cf	0xf7a76dc2	0xcd897f60	0x0bb1decd
+	0xae58efb0	0x743c07af	0x48adffb5	0x262260e7
+	0xaa9fa071	0x9a9ef7c0	0x98e861eb	0x14a48871
+	0x0b4c3292	0xad851820	0xe0f7f45c	0xd71366c5
+	0xc63a2f01	0xd02f23c6	0x49645eb3	0x2365fe48
+	0x44817f1f	0x576ee68e	0x396b6134	0xd9fc4857
+	0x9a771368	0xda5f2693	0x6ad30ec2	0xc8d08171
+	0xe40bcd42	0xf82291a8	0x3094a8b1	0xd3edffa3
+	0x5d5fb5e6	0x93802a7e	0xdf0ff376	0x09ebeae6
+	0x35091690	0xe938ec68	0xd203065b	0xcf2e8172
+	0x85282b27	0xe59fb64d	0x4b2ad981	0xeb5dde75
+	0xc07eac26	0xa78c969e	0x74165d84	0x61c4cfc8
+	0x740452f3	0xe5f6435e	0xb712e157	0xac49215d
+	0x5be5e61b	0x09f46a94	0xde5cd48d	0xe3ed6b11
+	0x2e8173de	0xabb6759b	0x46ffc47e	0x0cd84607
+	0x6046c26d	0x19356116	0xe1da098e	0x8e1bbe9f
+	0x5c8d6c20	0xa17cfe55	0x101a1f91	0xd64aef70
+	0xef2e7b34	0xbb428dc4	0xf2252a3d	0x8ab3f6c0
+	0x161db4ef	0xfdbf4f9c	0xb5bf9f19	0x414ea8b5
+	0xc3db5422	0xfc3934f2	0x635a8253	0x86260b8c
+	0xa4c0e59a	0xa45d24cd	0x4a25da59	0x7a568be1
+	0x4ae3587e	0xbc77a3e8	0x70723657	0x9abcabaf
+	0xe0a95d4e	0x25519f22	0x3ee1d340	0x2ddc2ca8
+	0x04ae20c3	0xc143f7c1	0x4a79e4d6	0x19377b64
+	0x2ab0d3f5	0xd3f19f6d	0xc8dc880e	0xf577dab6
+	0x69b6ac46	0x37d4af3b	0x0999bc85	0x3d9fbbf5
+	0xb9387ac9	0xc148824f	0x4d11f5f7	0x1ff4594b
+	0x59beb5b7	0x29474f52	0x68e6b2b9	0x4b60966e
+	0x5e40a736	0xdeff5ef2	0xe623bbc1	0x50407021
+	0x34ec34ec	0x131b3d57	0x628bda97	0x58152b10
+	0xdd830410	0xf953e469	0xea4c8d25	0xd79d7ba0
+	0x7a4da4f4	0x887d6841	0x7ff1e41f	0xdeffc5dd
+	0x8354cb26	0xb133716f	0xae73deaa	0x292e200b
+	0x9a9400f9	0x7a5d21c3	0x590d4799	0x1333b4a3
+	0x782bbe3f	0x314fcb2c	0x475a1cca	0x4cd07c7f
+	0x7a69a5fe	0xaef5a52a	0x0e9957f3	0xf7d86f6b
+	0xd0983d0b	0xdffd48b9	0xbeea1e9c	0x19de4c7a
+	0x46487695	0x5719e4e5	0x6dab39ac	0x856bf2bb
+	0xc0644339	0xe60e92ee	0xc328b5e5	0x2d0c31e9
+	0xeb73f1f4	0x7b577248	0x361159ba	0xd0f7002b
+	0x5fa816ae	0x11ace78c	0xab62e0da	0xc924891a
+	0x1d5800e7	0x4f90e04a	0x21374c9b	0xa3350e64
+	0xcb9c1901	0xcc350b3d	0x5c3e5932	0x3cc6261d
+	0xc3b54acc	0x849cf200	0x1425fad1	0xb3a479d9
+	0xfd4dfda8	0x62973133	0xdd528736	0xd7e62e0e
+	0x6921e1d6	0x7e41d7f0	0x74397b86	0xf739079a
+	0x4ff82d1b	0x38b6fcdc	0xb20e36bb	0x0cef9b7d
+	0xa737fdf3	0x1d18ef1a	0xc2c5dda1	0xdb16c5e7
+	0xbfa99b2a	0xf83f2c10	0x883c8183	0xad10014d
+	0xcf9f6321	0x5e0c079c	0x3ddd3d29	0x306325e0
+	0xebdaff05	0xa88741be	0x181fbf20	0xa58a3a1c
+	0x1f7c7165	0x7f5f5141	0x12576e50	0x9db22976
+	0xd1fbe204	0x6ca2025a	0x10c15009	0x920649fa
+	0xf42d3035	0x79efbc73	0xad2bde6c	0xb4e317ab
+	0x1f7358be	0x447d850f	0x9bb2d1ee	0x3545cea3
+	0x78eff6bc	0xaa86e51f	0x6383ada5	0x0c969d05
+	0xadd720e6	0x92f77e04	0xda58e24d	0x401bd323
+	0xdac090fd	0x9dc372b2	0x86726956	0xc508fde7
+	0x20ec1cf1	0x29fdb66a	0xa3f7e3b2	0x5ffa58ac
+	0x653c0106	0xf0d01026	0x55feffa1	0x661399b6
+	0x5b23998d	0x91add159	0xbf917f02	0x87ef6fee
+	0x64c4d653	0xbfadf48f	0x23f3ebcd	0x67869030
+	0x3b90b7ae	0x19efc2a4	0x26596a35	0xaaa5fcf9
+	0x5a14fd14	0xebeb9c9f	0x72224625	0x3a2c0009
+	0xbe5a09af	0x5aad7b74	0x7d92261a	0x8bd722bb
+	0xfff48488	0x0379b991	0x750cdaf8	0x83d3ec67
+	0x2f582115	0xfdeca132	0x889817f9	0x2bcccbb5
+	0x58107ba4	0xb57e016c	0xbbc45c80	0x5f14439f
+	0x6e71c73c	0x5e18e93f	0x43c07fca	0x6d49bc66
+	0x6641a788	0x234f48cc	0x9e18222c	0x86efa566
+	0x450ad39c	0xbc3ef112	0x98e7d17c	0x5334659e
+	0x9919cb9c	0x9fb4f0c5	0x2ea90893	0xc70453a6
+	0xe83cc486	0x454da884	0x4cba0511	0xfb83f2aa
+	0x0cf7ec27	0x20ef41bb	0x08355d0e	0x732798dc
+	0x1689d337	0x61bf955b	0xa10d3f79	0x05fe9c6a
+	0x1cbbc776	0x42e00326	0xf92509f4	0x71488be8
+	0x3d92da26	0x839acf18	0x6dae5781	0xeecfcc85
+	0xc63c0f72	0xcd79f887	0x677dd4c5	0x167c779a
+	0x3359b45d	0x48f974f6	0xbd7debdb	0xd57d5935
+	0x41beb132	0x1574e273	0x417a8fb4	0x46ca9d85
+	0x859f3434	0x7cd1675e	0x1fb4e8b2	0xc55de45b
+	0x4be8afa5	0x193c1260	0xd4225590	0x255fb988
+	0xde63caee	0x96108c66	0xacc2b48a	0xad2992d2
+	0xdd4cf4ad	0x0f6f5246	0xaf20d77d	0xf1c81d1f
+	0x0db57bac	0xbb39c168	0xb78944a1	0x4ea55714
+	0x0bb537be	0x5824ab81	0xdb9345fe	0xab0606d4
+	0x12a8b9c2	0x90001c30	0x12c7197e	0x603cae66
+	0xe2cb6b47	0xab0f94ba	0x28091fbd	0xb79d112d
+	0xc53a69b4	0x7de8c3bd	0x4aee880f	0x5a5dd399
+	0x850105e4	0x366d8714	0x4da7971b	0xc3a0013f
+	0xfbc2461e	0x65954a32	0x4c8f348e	0x3ddf0054
+	0xc615725a	0x3021e167	0x4a88ec0c	0xd69c44b1
+	0xb21cd2b1	0x08e16586	0x90f02d12	0x554afff3
+	0x65067d72	0x8c310d6a	0xd62ab40d	0x443bda33
+	0xb6eac5c1	0xd0cd461e	0xaf200f23	0x41fd1b8e
+	0x84e74a66	0x15b0bc4a	0x13fb1a4e	0xb36bf139
+	0xeeaa0c1c	0xa91d6fab	0x64c99859	0xc049d5ae
+	0x38921c4f	0x92b2f269	0x5c867fd7	0x41bd4d62
+	0x70009a4c	0x85a37897	0xe228af8e	0x9ef4f31e
+	0x891bbb42	0x3c09f291	0x32c29325	0x88f9ee6c
+	0x81a0bc38	0xfef31889	0x8d2e3f79	0xc5e405f7
+	0xb78e4127	0x3d61f392	0x3427d259	0x9f0bb662
+	0xfe6ffb44	0x57e1e8c2	0xd4abd164	0xd0449914
+	0x5bd5fe60	0x873601a5	0x0b07ae28	0xf4aac893
+	0xb9c8f9f5	0xe3a514ed	0x9da193c2	0x55ebeca0
+	0xa9d8f9bd	0x0a37dcc7	0x3f1d9f15	0x0bc645d8
+	0xb808085a	0xc79b0f4e	0x0286eafc	0xefc87a56
+	0xf1225ab8	0x58ac6a9c	0x9227ea3c	0x82deed0f
+	0xff0f8edb	0x3c29a1b6	0x6d777dae	0xbeeee7d2
+	0x0bdca157	0xf8d9d18d	0x52fda265	0x630da310
+	0x4f660e86	0x1c985fc0	0x68f1c993	0xf4ae63bf
+	0x3ec5373e	0xf6a10f89	0x2b19bd61	0x8aab04b4
+	0x75653336	0x4be6689f	0xc2631812	0xc6d386f4
+	0x93a6268a	0x4e5851ad	0xc2b47fdd	0x5acbd226
+	0xd2aaf25f	0xbe83081c	0xe57eb32e	0x00debc3c
+	0xcd8d7dbe	0x7cf67994	0xba17c779	0x34c19529
+	0x5cf29a31	0xe10b7d8e	0x7b116896	0xf702de15
+	0x6ee2e8cd	0x2f3a12d0	0x0e2a4666	0xbc1333e7
+	0x2b653c7f	0x36e282a5	0x0ca0544a	0x2255b148
+	0x5e413d5b	0x0fc88547	0x81e3073f	0xbcef6576
+	0x12b29e93	0x233bef85	0xd41790ed	0x4f4dbf15
+	0x20dea3d6	0x25f86504	0xb13177fb	0xee626fbb
+	0x2f7529e3	0x6157578f	0xeee068f6	0xc97c5909
+	0x053c28cb	0x6f540d47	0x692bb599	0x7004243d
+	0x1c5620cd	0x0ca53749	0x9d7d6a4b	0xb8e504f7
+	0xdd138f32	0x4d2fd525	0x676904b1	0x67b90411
+	0x6777ede4	0xc1fbe02f	0xd7eb61fe	0x1c62f909
+	0x91cfdb29	0x293a8d72	0x4475e4dc	0xba9d955f
+	0x5413cb0b	0x952694f7	0x3b8eede3	0x33f1f6cc
+	0x61c2604a	0x244f8403	0x862316a5	0x2e0387fc
+	0xb3b3c699	0x418f5b0b	0x89a49abb	0x6c325320
+	0xa952f0c0	0x72454ccd	0xaa272d96	0xf05e80d4
+	0x1dceb03a	0xdb00d312	0x96cbcca4	0xc87c31f7
+	0x96b17422	0xdba12c7d	0xedaac717	0x99b1da89
+	0x48f3e07e	0xbace3088	0x71937740	0xd754a585
+	0x31784510	0x36d08e4c	0x4e8e2396	0x081fe566
+	0x0cd2092c	0xec932481	0xfae11d02	0xcb3b8609
+	0xe20559f2	0xa2330b46	0x2beec857	0x86911540
+	0x5e8e1895	0x4f42f3cf	0x8e32bede	0x78285f4c
+	0xaf267610	0x9dc86091	0x6adf9b99	0xfc91da24
+	0xc987356d	0x78f260f0	0x9cc6f796	0x1d6aa013
+	0x5f1922de	0x54d065e8	0x8a7c3cea	0x13768df3
+	0x4e8858b2	0x712b5b8d	0x0b64c3be	0x3845ef6a
+	0xff77b842	0x83a497a5	0x77f15aaf	0xccfc6df7
+	0x20084d31	0xaacdde0d	0x4059b446	0xb940b3a7
+	0x3fa88d6f	0x3162ec66	0x43cc767b	0x2a2a6916
+	0xd0dea02d	0x5b9f11a1	0xec36c7a9	0x6d7eb6ce
+	0x4506fc1a	0x1c3e362e	0x9e2b0f99	0x547e6ba7
+	0x6b8169ea	0xbd89401a	0x2cf5ea6a	0x100e6249
+	0x47ef40de	0x063a0b33	0xb1f49499	0x3026e75d
+	0x3b6d951b	0x6212fd9a	0x5073aa23	0x9bd609b2
+	0x760cf7bf	0xe6766d03	0xff811dac	0xa461d069
+	0xf40e74b3	0xec113577	0xa2cf15e0	0x6f43a20a
+	0x43f52321	0x96896eb8	0x480c1129	0x35190a4d
+	0x29a80a08	0x8ce4dd2c	0xf4b40d21	0x2324ef9a
+	0xf3f2b54d	0x7a0cc79e	0x3e9d973e	0x2d28dd0a
+	0x1a5e9aae	0x5abb6fab	0x215bade0	0x39e678c3
+	0xd6543c64	0x1652e0d4	0xca2f5303	0x0a6879bf
+	0x24841561	0x05c559e7	0xa1ac6c48	0x3fc52191
+	0x29527695	0xb977ce60	0x04589311	0xaff7180b
+	0xdeb08866	0xd62d8f6a	0xa6f62306	0xfdef1235
+	0x1946ad8d	0x1d49fa21	0xac486c1e	0x3ca80491
+	0xba8c2a76	0x06ce9ac6	0xcbfbc465	0x675c4ada
+	0x1eb6b108	0x27d03a7a	0x606144e6	0x2eedb163
+	0x64d8d1b7	0xe7695fde	0x75d593a5	0xe7f00f68
+	0xc3c45a5a	0x522c4164	0x37833c3d	0xddfda19e
+	0xd7b9f984	0x77e6ea85	0xd148df03	0x89989155
+	0x80fd8f07	0x3adafce3	0xf4e07aa6	0x6ea417b4
+	0xd1732fad	0xd13cba8a	0x01729b17	0xb9e666be
+	0x48addea4	0xffb3a560	0x4a96d730	0x0349777c
+	0xbf355e6a	0xb5055554	0x22442c5e	0xd8bda1b4
+	0xb0a088ab	0xef18b9a6	0x11ecc51d	0xd59247f1
+	0xf86fe339	0x17752dba	0x0bfacac1	0xdef25155
+	0x035b4275	0x02a3f293	0x8466a5bc	0xf376864f
+	0x04265d7d	0xc6fc5aa3	0x36adf7ec	0x4e16af5b
+	0xe3b28d5a	0xa49c6535	0x2b05f03b	0x46d5d914
+	0xfcae58a0	0xda644349	0x656d72c0	0x75d47095
+	0x302a9fad	0x4e245aaf	0xe2a3e852	0xa9b73076
+	0x8d9a2469	0xe7c05607	0x1c17b4b3	0xc2e63302
+	0x49fa365d	0xabf1f5dd	0xc850b090	0xdced47ac
+	0xd60b15d7	0xb25efb14	0x33f9a3af	0xd011cc8f
+	0xf0414eaf	0xff212e84	0x9e2fbd61	0xf6636285
+	0xd892696a	0x6d9ffc34	0x253ad380	0xffb7ed45
+	0xaae31520	0xadba81d1	0x7f1e41bf	0xcd7e1eb7
+	0x9dabd0e9	0x5de91eeb	0xe9fa68ed	0x3fae0c6a
+	0x6da21b40	0xac743c3a	0x19228523	0xf5098069
+	0xf647fe8d	0x95666621	0xa2a3613d	0xe6278031
+	0x6901cfe4	0x3bf132be	0xc3314ee8	0x5b8261b8
+	0x9b724149	0xd0838d83	0xb0d05c76	0x57295707
+	0xcb11fd8f	0xfdce9b20	0x346449b6	0xe8b44745
+	0xc0784ff6	0xe6083a3f	0xb0b87142	0xd2df2210
+	0x7b9dc719	0x961585df	0x359390ec	0x0d40e1f0
+	0x56436a52	0x8ccb0d80	0x78066e70	0xcfd04ac4
+	0xd850a6a2	0x00612831	0x19e74acb	0x5a80989e
+	0x0d7b151c	0xca9bee4e	0x2fea9d99	0xfdd7ec3c
+	0x3a73b4e7	0xa70068d1	0x38aff576	0x4c861c14
+	0x2e23b093	0x0e429806	0x8cce23dd	0xb0ce104f
+	0x1684bf8d	0xb2756213	0xa64c594a	0xdd8ee144
+	0xda5316cc	0x76dc877f	0xa1c5fe35	0xb5e04383
+	0xc9e10000	0x8ac58408	0xf6d7e781	0xbda6cdc5
+	0x81517c56	0xdee2ba90	0x3cbfc247	0x4c84887c
+	0xa722c632	0x4767a4b3	0xe83b79a3	0x7f100150
+	0x1074198a	0x220260db	0x1c940f4a	0x92c42619
+	0x56dc9f64	0x1c0f7eef	0x3694f4e8	0x5b4b63d0
+	0xe784afaf	0xcdcdb039	0xf7040a88	0x47f2d84b
+	0x143a94b5	0xf68f4fab	0xf6640462	0x3cd6b1c1
+	0x7fbe0e60	0x700ee673	0x030e877f	0x60779cb8
+	0xddb6933d	0xe46f377f	0x9f9c43c9	0xce0f0d58
+	0xe6bf42a4	0xae09f51b	0x295e8cf0	0x140df2b9
+	0xfb04c209	0xb6d46f7b	0xa86e0c91	0x64fc624d
+	0xa7a8760d	0xdac844b4	0xbe1491b0	0xad480684
+	0xea874ca4	0x3535e483	0xd49365c9	0x83f2c050
+	0x05ec206f	0x7fe3b010	0xb72aadbf	0x40b3a286
+	0xafe395a8	0x3506d4af	0x9c4e33e7	0x0259eba9
+	0x0daecf5c	0x264c008c	0x898bdada	0x0f3ac833
+	0x7ef5f3f8	0x41934050	0xc3bda261	0xab624dd0
+	0x5d93609b	0x495a5f1f	0x34119efb	0x3bfd15fd
+	0x49255da9	0x3ab2d260	0x15ce2006	0xd466d454
+	0x3d052ca5	0x567977cc	0x7f8b8657	0xd9b34f42
+	0x36c65ff5	0x5f96bffb	0x2d32daf1	0xb301cf05
+	0x933435e1	0x316fb1ae	0x48be2982	0x657c3286
+	0x1916c189	0xa3a030b5	0xe4c7bce9	0x6a762931
+	0x1e90df3b	0xe9084ef0	0x1236cfe1	0x7239326c
+	0x29bd4dfe	0xaa01cc46	0x93e514ef	0x4e376f6d
+	0x14087975	0x9cdad6f9	0x86b31bd6	0x2c206281
+	0xe178b367	0x4943f013	0x9f97c9dd	0xe848fb0d
+	0x7d19e49e	0xde4d9b1c	0xee7f552b	0xadea7634
+	0x605ab7c5	0xef66b062	0xaf369aec	0x39a96463
+	0xb39ed4e0	0xf4c38bbd	0x48565c84	0xcb4ccad7
+	0x37b656c4	0xa5291b2c	0xba05d037	0x0027ff97
+	0xec2034c9	0xa19abaff	0x99dd50bb	0x44bd5f0b
+	0x8cc4193d	0xe1dca3f4	0xae2896c9	0x992105a5
+	0x46b04aed	0x3ca454cd	0x9a0e86a3	0xfdb3702e
+	0xf2ddfd7c	0x6b7ca41e	0xe49f2227	0x4839351f
+	0x201f1173	0xc9af9d40	0x7942ef65	0xf35e5867
+	0xe5358390	0x0beff1a6	0xd057a81e	0x89830387
+	0xe496a246	0x45007e0b	0x62c34ed5	0xc2170342
+	0xa095780e	0x00682a8d	0xfab7e24d	0x207cb6f9
+	0x7d5c8058	0xb0164454	0xee8b6d44	0x0aa01190
+	0x70637e84	0x1268c1cb	0xf7a1eb80	0xbe90b153
+	0xcdc765f5	0x5841d605	0x00141f5d	0x475f8d3a
+	0xff60a6f1	0x5f7a2e3a	0x30d3f150	0xd9a22f7e
+	0xdded3241	0xfb05ea5e	0x4093fd88	0xb11f5a9e
+	0xf1b36594	0xc7579059	0x7f66c5e6	0x8fdb1095
+	0x46ff7f62	0x70925647	0x207287e3	0x6bddfe5d
+	0x240fb596	0xc91784fd	0x28acd7f8	0x7cfbc9da
+	0x2d6b3cc8	0xf8e9aaf5	0x489616b8	0x9ed70056
+	0x586bca94	0x6a95971e	0xa2238b5e	0xc9a06325
+	0xb90882a9	0xb5b3ffab	0xae4b2beb	0x5aa0ee34
+	0x52e23123	0x9a019e1c	0x84b0f00c	0xba2cf495
+	0xca4108dc	0x9272b0e7	0x760b209d	0x3e294274
+	0xb8f0316a	0xb666af5b	0xcf436e91	0x365dd253
+	0xbf11262e	0xdfa3f8ee	0xd6e0ab96	0xd8a639f8
+	0xcba8b31f	0x58940e1a	0xa4bf5e3a	0x7f8cec5e
+	0xb5ec87d4	0xb7924503	0xe2bff3a9	0xc7ec4445
+	0x1e94324c	0xccf28ba8	0x2294b594	0xad297087
+	0x18624369	0xa017851f	0xc635302f	0x802becac
+	0xe631eaeb	0x386589dc	0x780823c4	0x7b989c1d
+	0x94554d93	0xfc22d343	0xb8edbd0e	0x8bc08005
+	0x998a234e	0x507d3976	0xf1f9833c	0x522a2971
+	0x2765433f	0xe1ef356f	0xd45d5fd5	0x8d3294d3
+	0xabcffdba	0x9b7a6338	0x2f261e1f	0x891fdbd0
+	0x67008f6c	0x23d96866	0x057410ec	0x2f360684
+	0x8380c618	0xc968f3ae	0x91ac868d	0xdb5cc503
+	0xf092b320	0x73ef35c1	0x0fada995	0x56316744
+	0xde2290fc	0x7070dee5	0xcf1cd6ab	0xf1a47253
+	0x2c53b495	0x8952b433	0xa5b47637	0x9dfe09ae
+	0x2fb36206	0xcb1dec3f	0xec188994	0x10407824
+	0x91f27ffe	0xd461edb0	0xc3779ae4	0xe3f9bede
+	0x183a107a	0x0122654f	0xe319bba5	0xe75c33cc
+	0xc657ea24	0xe5490f98	0x653d01c7	0xce09c546
+	0x631ea29b	0x81278443	0x0cd4dd3c	0x6b7da4ff
+	0xacf1363c	0x563ed879	0xe8420e5b	0x43adcc25
+	0xc6ff7dd8	0x21e26910	0xa4b4f3be	0xaea31be5
+	0xc241c837	0x07178d5d	0x2b69f8b3	0x3bc0b4e6
+	0x429c50c1	0xe493ba56	0x5933b099	0x237b2036
+	0x0e807425	0xe450e510	0xd72a6007	0xc1459771
+	0xe9b22ad9	0xb25e452b	0xeda83668	0xb00e8d93
+	0x12b8f351	0x703ed783	0x901c6109	0x72b3e601
+	0x099cfb54	0x7fc68f6b	0xda7f436b	0x1dd70c40
+	0x5a57914c	0xddc3fe51	0xf1b692dc	0xe8b066bd
+	0xaa7b0d19	0x4a593520	0xd3bb712f	0x1e1b4c0e
+	0xe651f456	0x4fd0e108	0xdef8932f	0x3de33c3a
+	0x4c189801	0x62c607ea	0x708e8086	0xf1b9d204
+	0x19656d6f	0x216430e3	0xc8bab24c	0x4ea84e4f
+	0x659f0cea	0x4e7bad1d	0x7f4d77d5	0xf6d114a2
+	0x6d8038b8	0x8d56f1fb	0x2f015191	0x0b3770bf
+	0xd81e40db	0xfe66c348	0xffd1d3bf	0x07021042
+	0x8ce5e26a	0xcdaa21ca	0x1bd4b85d	0xfabd423f
+	0xba6814e4	0xaa5fe624	0xb2591597	0x81e601e5
+	0xf3601f5f	0xf4dbb30a	0x0950789f	0xbe9b1f70
+	0x35faf9cf	0x9f27e299	0xf9c1075e	0x09b04ac9
+	0x2bb3cb1e	0x8c197668	0x8dffa14f	0xda4a57de
+	0x5e0f0a9a	0xd1521120	0x31c26430	0x46a75d9c
+	0x6c7e1a50	0xda1db6de	0xaef50782	0xd32d301c
+	0xa4688102	0x77c6bc1a	0x3c7e2525	0xcbd4284f
+	0x5f493a22	0xb35abf25	0xc996f4ff	0x009f0c05
+	0x6143581f	0x7a864557	0xd0e1d52f	0x0725f9fa
+	0xdcc0b294	0xc3609ee2	0x75373ce8	0x1ffd4ead
+	0x331b82b2	0xfa833542	0x43c00611	0x7ab1215a
+	0x099bb7f3	0x1c95dc3b	0xbbfb8231	0xf62659ba
+	0xf9cc6fbc	0x030b6f56	0x793603cb	0xe7c48d71
+	0x9754aa20	0x41710095	0x35b92718	0xf464fca0
+	0x4ad77ab4	0xd5582574	0xe0552ad4	0x7393e896
+	0x34920ff9	0xd0a44180	0x2e523669	0x81d5573c
+	0x1959ad82	0xfb153a03	0x1cfa615f	0x8b302a87
+	0x4e4eea7e	0x21ca24c2	0x5a971dcd	0x788e063e
+	0x2c9beb8d	0xb3b98af9	0x24079012	0xbdec8a61
+	0xc41752df	0x8d2c0a3d	0xe960ac61	0x658cae63
+	0x891956fa	0xd0d1a216	0xbc37b8fb	0x5e2c3009
+	0xd600a7ad	0x47c7c30c	0x8fbd13f4	0xbae4d97c
+	0xdd15d643	0x71440bb6	0x3fccfa22	0x1ef82308
+	0x2c48907e	0xf6ad303e	0xc1ed250f	0x6f9204f8
+	0x19062b0a	0xfe8ab325	0x379e8b1b	0x8116d220
+	0xc6d4d8cc	0x624098ee	0x3e6aad4d	0xbce3ace2
+	0xba349982	0x7439dd11	0x6ac6d240	0x9f2cf9c6
+	0x3dff687d	0xe5b6f2c9	0xbe1645a3	0x39a39bfb
+	0x7956d69e	0x50d22da6	0xb7e32b7a	0xf4144b4e
+	0xb94151a5	0xee36b1b1	0xc8cd8d65	0x5e571859
+	0x0db49c4b	0xd9d71cd9	0x4bc017ca	0xc81d5130
+	0x0c9660c7	0xe4b12b28	0x5549e753	0x97a9fa4a
+	0x0dac4813	0x7854b977	0x7c8cc619	0xe4166449
+	0x020ae016	0x02448146	0xa3924345	0x1542cba9
+	0x461583ad	0x7bf66ddd	0xaff59684	0x398b370c
+	0x5ffbd30c	0x87900806	0x0891afff	0x7aa84ad3
+	0x62e35158	0x995e545a	0x6ff3779d	0xa05bdc9b
+	0x777a7e83	0x53643dc4	0xd77d4704	0x422ec993
+	0xabd03cd1	0xcb6ad4b7	0xa94c512d	0x6562975c
+	0x63b27747	0xecc0955d	0xd965b2b6	0xc67b64c5
+	0xfd69b042	0xfe7314c4	0x9f807bbe	0xafaba4d7
+	0xbd63eb72	0x811a8901	0x7ea1be4d	0x7316f0fa
+	0xa6cf004c	0xc17d9363	0xe3fe88d2	0xe60faddc
+	0x5d3a1b02	0x8a9f1ed3	0xebfb9234	0xbc453cf2
+	0x190085ca	0x369a1df9	0x55721790	0xb071a9f3
+	0x0697bfc2	0x65753b76	0x177d720f	0x1563979f
+	0x970c4dd8	0x511aec5d	0x19878647	0xc17280ee
+	0xe61c4188	0x7a4c0756	0xdb49157b	0x0d461f37
+	0xcf0bc73b	0x1c6e7ac1	0x683a9e1e	0x0dd9ae7c
+	0x72be0902	0x85a22cd8	0x8b98d2dc	0x2f3a9ff1
+	0x4540314d	0x3a4e344f	0x3ada6bee	0x3408b829
+	0x711ba0cb	0x0c92ae4a	0x621bc5f1	0x908043da
+	0x8f8ac31f	0xed15f127	0x731dc6d9	0xdc6eb058
+	0x6815eb3e	0xaca3d9e0	0xef7b5c61	0xfea2a032
+	0xd3c76315	0x0f88f4c8	0x291b8710	0xa5ef8346
+	0xcab00448	0x78ef9fb3	0xebf0388d	0x33f2a5da
+	0xc41190f2	0x0cb6bcf7	0x0afe5680	0xef88d3ea
+	0xc0e10f4d	0x7e028bfb	0x933657d9	0x6f61fcd0
+	0x7e03e392	0x23258472	0xfb16ab16	0xfaf74a5b
+	0x7ab0a634	0x8346df0a	0xc3c93451	0xdff93a32
+	0x3920a816	0xc3331312	0xa6a2270c	0x10025010
+	0xa8f4d842	0x36b96367	0x77a30dad	0xe1bd6d0c
+	0xf3ddb722	0x9412e861	0x4e7cd927	0xef243451
+	0x41d7258f	0x6eb34be2	0x026ef296	0x46112337
+	0x656c8c07	0x18deff2a	0x5be15cbb	0xbaed3a53
+	0xc795a134	0xdcb1350b	0x758b6482	0xc6cd0e88
+	0x9be9d4f6	0x1ec7c2da	0xc5c1fe49	0x3e86e8f1
+	0x09126f9e	0x96772352	0xa4d5c70b	0xc6f1f2d6
+	0x3c22e595	0xd5ccf006	0x48f6167e	0x415dfe21
+	0xf49891e0	0xab4c4a7c	0xcd9b336f	0x5777d2af
+	0x6a8ad930	0x3f47c079	0x72286c81	0x44b565fc
+	0x5ff87a6d	0x6aad7ebe	0x66535422	0x4dfcef23
+	0xc0ffcc8b	0x6e2cfe00	0xf1e7e1f4	0x06e46379
+	0xce1bf7c8	0x70fec576	0xe9d0014a	0x844f7b07
+	0xb7a27720	0x4a62dde1	0x39207994	0xe12e7ef1
+	0x75f2152c	0xec05cfff	0xac67a90a	0xbb9f0c88
+	0x8fe2e008	0x58e15130	0xd54c4808	0x71fc616c
+	0x02564be1	0xf3d121e1	0x904f4a7e	0x7eaa8b70
+	0x893d8579	0xeb94b6a0	0x4c84f056	0xebf49f0a
+	0x2b2fb4cc	0xb6014008	0x1fe0a076	0x9e7af7eb
+	0xc168be50	0x61653283	0x2016760c	0x57c36535
+	0x720405de	0xb4924329	0xb1189d2c	0x9dd8f5c0
+	0x2a5f1ab8	0x49580b2e	0xacbbd3d3	0x3261e254
+	0x7a827ba0	0xfc91f0bc	0x2b02ba34	0x96edf03b
+	0xfd7fd36a	0x24edb430	0xafc7e2cb	0x0a8cd505
+	0x22ed5205	0xb42ca58f	0x24fc4009	0xf064cb61
+	0xa564a202	0xe42a9b54	0xd2a28338	0xca1f1a5a
+	0xbe51905d	0x9a960bd5	0x4238b656	0xfb08649e
+	0x76c93495	0xaccc0877	0xc465148e	0xa2bc11d6
+	0x84a54419	0x2a2ddd16	0xd9e1d2e4	0x622bbcfb
+	0xcf0608d2	0x93a26458	0x2b666698	0x0645f585
+	0xed3df83d	0xf6e81a41	0xce11e962	0x93c27f84
+	0x30f41197	0x659aba68	0x57c01eea	0x2a4cc4de
+	0xecf2f07d	0x3340329a	0x1084f771	0x9d4c351c
+	0x32d28528	0xa3b947ae	0x78fce7f7	0x14d0290c
+	0x7b7ac82e	0x7de381ad	0xa907d620	0xc31ae25b
+	0x513a2723	0xd8cc3457	0x8fe676a6	0x04039d12
+	0xdce5a5ff	0xcc0af574	0x1406d489	0x3393d517
+	0x004cfc81	0xeffe2eba	0xf2ee0c96	0xacac4889
+	0x6484e7d3	0xdecdce02	0x029dacc5	0x95c52292
+	0x0dfaa257	0x7150527a	0x0b59ab84	0x3a915b26
+	0x2624fe20	0x46309564	0x704261ba	0xdf434f92
+	0x2eb248c1	0x26d555d7	0xc75d81f5	0xbd0185b8
+	0xf53b1298	0x059b9353	0x7821a25e	0x4d7fe1cc
+	0x811b5179	0xe42e22a9	0x4fb78808	0xd6841c31
+	0xd9edb88a	0x9b433474	0x1c54ca12	0x4887f63d
+	0xf1b21006	0x8f7761fe	0x62a15331	0x6b35788c
+	0x4a5a9edf	0xfdee39c8	0xed95d818	0xe087b392
+	0xcdc89907	0x5ee58605	0xd4d7290b	0x46f8d2ce
+	0x6c9c3f65	0xd129f26e	0xd8cd5b87	0x2bc19529
+	0x7ab5b036	0xc44a6fbf	0x76fb68b1	0x6bffe654
+	0x482067f6	0xf8ed9d43	0xdad6bd63	0xa9ac77a2
+	0x76e6c089	0xe24ba46c	0x420ccbe3	0xfb09b718
+	0x83ec3694	0xf76e47d9	0x5f3a8859	0xe85f7fcd
+	0x61f1d09a	0x35065817	0x88bf5c6b	0xfbb9f76d
+	0x8b68fca3	0xed95dcb5	0xc2ff7cf1	0x855a2958
+	0xf7d28d92	0xb61802f7	0xf9814028	0xac8703c5
+	0x4ce8c7cd	0x1876cfe3	0x851c045a	0x56b3d146
+	0xe7abf1e7	0xdc46d720	0xd1e35c3a	0x2243ff60
+	0xc257c828	0x16513009	0xcb797d5d	0xe0f2cb11
+	0xf7e40b66	0x721e0495	0xce72e9b7	0x32eeedcf
+	0xf5dc5e01	0x355de93e	0xc20ad627	0x95aa436a
+	0xe69cab2b	0x511fef1c	0x18522a80	0x203e240f
+	0x882fb1f6	0xfed4db9a	0xa4bf7193	0x420df144
+	0x84791341	0xdb4767a1	0x8c0b40fb	0xcfa5c5d2
+	0x2783cad4	0xcf8dd48c	0x051037a0	0xc2994140
+	0xaf2a0a2e	0x29619774	0xffd83edd	0x1e346b24
+	0xb058a539	0x8118011a	0xb1722fcf	0x4f89c7b1
+	0x0e6f2f4b	0xdb155d1d	0x21d21cf9	0x25ba315b
+	0x7a17b541	0x3f23c32b	0x301e0881	0x9b0ad7f7
+	0x8adfccee	0x6c2f2975	0xbc9c318d	0x8d220d3b
+	0x33d2d0c1	0x5bc2dbf5	0xe0290856	0xedd38c75
+	0x56642fea	0xf7f5609b	0x5bdb0058	0x511dfc07
+	0xc6b0b515	0xeac6f4af	0x7da3a898	0x50452011
+	0x4668042b	0x4055890e	0x7bd41459	0x9b98f96a
+	0xc516cb64	0x15313f77	0x04f6816a	0xd622931a
+	0xbe2be61e	0xd549a421	0x380373c2	0xabb7123d
+	0xc54b9d3b	0x5a130630	0xafff90c4	0x50f5b4ce
+	0x75b0ecf0	0x16078950	0x44d547f1	0x8353af66
+	0x587bb496	0xf8f3c68a	0xd3b06119	0xef05594d
+	0xd403c928	0xf12b06bf	0x2b78eb2d	0x7de9106d
+	0x4966726e	0xa8b5ef1a	0x1c42a3f6	0xd55aa69b
+	0xe409c51f	0x93533259	0xc6d9dbf5	0xb4d63a17
+	0xaaf73aaa	0xe485f5d5	0x753f0d34	0x1a3e6dde
+	0x41183e36	0x2ec20e27	0x6b66bead	0xfc5f1d42
+	0xfecdf91f	0xb7066b78	0x8ed6da1c	0xbbeb87d7
+	0x8a72de9b	0x1e0e2f97	0xc377f532	0xedbdeb81
+	0x0f5b9e33	0x6ae7ebf2	0xca7440df	0xe9c3eefd
+	0x4bd50433	0xc25a6b95	0x9d2bd1e2	0x70709639
+	0x9050c202	0x7cbd2f1d	0x41443fa5	0x63dd89b1
+	0xb2607a0e	0x88c1417d	0x1631dbb0	0x13508ae3
+	0x4e78d90c	0x19811ae0	0x4bc827fb	0x459a55aa
+	0x52c0fd8d	0x8359500c	0x6a886312	0xbe704e33
+	0x441b7c24	0x5121c79c	0x86066830	0x1a0d013f
+	0xe78bfa0b	0x3f9e3ffc	0x7b3abb16	0xfc24b9ee
+	0x4f543a26	0x0619ad49	0x6a20077e	0xc8191371
+	0xd1d2876f	0x8b83645d	0x48330de1	0xe132ea1a
+	0xdc077f5a	0xfd14dd79	0xf606c198	0xec47c478
+	0x17c3f14f	0x334fd708	0xe39cf072	0x39f543c2
+	0xebab93a2	0xf7febed4	0x79971f6b	0x888858d4
+	0xdfd11199	0xafe72dfa	0x13f30ff8	0x6141ada3
+	0x5fe75eb0	0x75dcecd6	0x70fb1b33	0x073f9823
+	0x7afb726d	0x04b10ea5	0x6c881a5b	0x945a5c69
+	0x2ecb950a	0xb384f045	0xe5eb9ac8	0xa46dfd3b
+	0xb8185584	0xc095b417	0x86173c80	0x6a509180
+	0x4eddcc32	0xf408ac80	0x0833ae99	0x58ca79b2
+	0x2eac5d79	0x85c2deb7	0x400e6a01	0xdc6caa56
+	0x706176e7	0xa5dadc8f	0x0d4969de	0x259553d9
+	0x52425195	0x7d074da3	0x784ef596	0x8580e28c
+	0xbaa52874	0x71abf00e	0x8434cb32	0xc3a8ffe2
+	0x6ec52581	0xa4cd744f	0xd5820757	0x7e257e4d
+	0xb7428f60	0xb55fd824	0xd454c529	0x8de72e07
+	0xf84abcb4	0x30b7c926	0x5140a1d2	0x4e9550c6
+	0x18826ed6	0xf561a8eb	0x28c7cde6	0xe91022ea
+	0x73cdc0ef	0x32bea752	0xc7a0138d	0xa0af6cd3
+	0x52c4736d	0x0b459241	0x2156a8d8	0x0d32a2ad
+	0x49bb6600	0x8752c2bd	0x45d0a0ec	0xc89f9bc3
+	0x76d775a6	0x963f0a6b	0xb5d100fc	0x2731528b
+	0x2719d1a1	0x2b201af5	0xc337ea7b	0x70ce1c8f
+	0x8cb21437	0x9869038c	0x53e9458e	0x624904e5
+	0xcb7cdad7	0x13b9bba7	0xc66ec1ae	0x86bbb14d
+	0x018c25ad	0x88573452	0x4165b4bd	0xa719f640
+	0xd4b8227a	0xdace857f	0x701c449e	0xa835c09e
+	0xef8e4608	0x72ec0d91	0xe88703ac	0xb6470c3d
+	0x0cae0aff	0xae650f6c	0x384c382e	0x5d4b6275
+	0x6691c449	0xfba67785	0xe3a5b7b7	0xfb72c85e
+	0x09056be6	0x15e28bd0	0xb6be7e9e	0xd97fac13
+	0x1e6023bc	0x0f28cfbd	0x840eeee5	0xd208ac51
+	0x12b36d98	0xd28885de	0x108c3e86	0xff2ae965
+	0x09b446c4	0xe453ba28	0x42c997ac	0x880e22f3
+	0x0eeee913	0x5a0c9803	0xf080f33c	0x47e99f76
+	0xa62e02f6	0x38283513	0x5ecad92f	0xaef2a1eb
+	0xa5cdc2c5	0xd5e6ae58	0x03dbffd9	0xc24ddb4f
+	0xaaeecc9d	0xdbeb2dfc	0xfda7e5a0	0x8e537029
+	0x8ae38058	0xfce24682	0xcdd46b74	0x0cc2b384
+	0x89cd2e8b	0xe955abd6	0x82c64f39	0x716c7713
+	0x70dbaa6c	0x271b7a9c	0x332e6234	0x8d081fed
+	0xb47ac8d3	0x818af259	0x6d97d09f	0x7aaca213
+	0x2124cd22	0x70fc4cbc	0x02988745	0x29e28390
+	0x2b11e888	0xe62b3826	0x8c6260e9	0x2b2d9036
+	0xc3cd85c3	0x3a08e1a7	0xf406364f	0x6ff5f0d9
+	0xc0c2a847	0x076cac4b	0x85eea1ab	0xbe6d6dbc
+	0xdffbd36d	0xf1bb8934	0xae696cac	0xfe51475b
+	0x6bce710a	0x83d6ff0d	0x44cb120f	0xd0c01d5a
+	0x997f8469	0xdaad8626	0xdff160f7	0xf2954b72
+	0xd4efa312	0x07035ee6	0x03e8dbb0	0x5a33d382
+	0xc6527dc6	0x0b7391a3	0xfe568e01	0x24c28c70
+	0x76e65ea0	0xeafaf171	0x1ab4ebfa	0x4ff66462
+	0xc9949824	0x776d25fe	0x3689d8f9	0x1ec65a2c
+	0x746581f5	0x227209d2	0xbff7bc69	0x91b4c927
+	0x171c5962	0xb4dd5f85	0x72e4917a	0xd01ff1af
+	0x9c6ba703	0xdb9d9be6	0xae1cf2c5	0x48b85c21
+	0x9628b693	0xa8d2e2f7	0x856584db	0x1b33821e
+	0xff5de311	0x4126d04c	0xf00ac027	0x54bdaa98
+	0xa3dd5b0a	0xce2b2558	0xea5f50d8	0xb2e88f18
+	0x19590981	0x6dae2c0a	0xbfd758bc	0x2897e93c
+	0x3ba5d054	0x2d809b4c	0x3de6aa52	0xea171509
+	0x7d8b7b44	0x19a1ad1c	0xe99b2657	0x98ac56e9
+	0xc2150187	0x63a12506	0x4ffc1739	0x50e2ca6c
+	0x4f2ff10c	0xb7323ff6	0x81d9f57a	0x5146beee
+	0xa1f45456	0xf6ce5d75	0xdff7be9a	0x75ab2dc9
+	0x5ff2901a	0xec756ab3	0x8a5e0299	0xc4e248ce
+	0x248502e8	0xd8c62cf1	0xc7001b23	0xf7c636d2
+	0xefbb67e1	0xec507025	0x1820ac19	0x39e1624c
+	0x4ee603b2	0xb70e1c67	0xaf9376fc	0x371af05b
+	0xa19209fe	0x8ecdf499	0x9a607cb2	0xcbe61a2c
+	0x9f4e950c	0xb9a1546f	0xe718f140	0xc75d5d02
+	0xabe66af2	0xecc54d7b	0xb4373489	0x22254496
+	0x4b4b7f7c	0x40dde60e	0xfe621a3e	0xa6605c67
+	0x5cf6a3a2	0x75df88a3	0xbf0749b0	0x705a0a04
+	0xf3cae078	0x392bdebd	0x98878e65	0x0f5a2be5
+	0xec172835	0xf610cc90	0xac6ff369	0x0a71c173
+	0x8eae2d62	0x2ccbb630	0xd3b702ea	0x1626bfff
+	0xdb4a6975	0xd2a936f7	0x0bb63194	0x5d9120dd
+	0x5860e04e	0x3baeca91	0x95a621db	0xa6d23aaf
+	0xfebcfa2d	0xa5ed89cf	0x2192280a	0x72322cb8
+	0xd79e14d2	0x0528ce06	0x1c6a8f9c	0x6703407c
+	0x93819694	0x6c554390	0x7875452a	0xf45d2757
+	0xe0458d1d	0x335f6179	0x48989cc9	0xdc16cec8
+	0x9e2c0ee5	0x78daabe2	0x2069e8eb	0x0e87f238
+	0x0a928dda	0xc66e14b3	0x2a6c4031	0x73821630
+	0x8b8c4a40	0x243702b7	0xded80901	0x5de34802
+	0xea029b73	0x59a47771	0xe747d796	0xe80aea8d
+	0x0bd01815	0x76fe1f68	0xa345fc34	0x73737383
+	0x76753b6c	0x57dcba56	0xb11d6b21	0x81dc371e
+	0x311f4ea0	0x3b4b2522	0xe8a66ef4	0x1932df0c
+	0x9f3790d6	0x0d0478a3	0x7dd0a24b	0xeb581381
+	0x6fe8ff06	0xe34c2d69	0x26842e15	0xe9a39562
+	0x78f2d7d1	0x79ab33f5	0x197df69c	0x38a9a004
+	0x9391dba9	0xfbb4b7c5	0xa97bb70f	0x0720b57b
+	0xd9b26325	0x3ed1a3fc	0x11f5aba0	0x6e6a53ef
+	0xe2ce236e	0x30994468	0x9d4369cd	0xcb6b5b5c
+	0x61a0945c	0x090e7dea	0x5d9b676a	0xd474cb52
+	0x8ebf1af3	0x35f2a70b	0x417d48a0	0x45062dcc
+	0x841d8d90	0x30f8e590	0x1c935ad3	0x29313e0c
+	0x46ecf673	0x4998b596	0x95f23529	0xf31bd581
+	0x1b32045a	0x90432d28	0xa2a6c268	0xbf40fcae
+	0x4104b314	0x02677221	0xa99231ac	0xe28abada
+	0xd7d72a73	0xf1b2ce4c	0xf753f8be	0x9d7fc1c7
+	0x9a0e7a7a	0xf04ccf32	0x58433f5f	0xab9a6d51
+	0x71262b1c	0x48f84d91	0x897670bb	0x47dd10cb
+	0xac7ef74d	0x78dc3e54	0x30b17eaa	0xc8f46618
+	0xc636fe3b	0x86ac06e3	0xfb8edd16	0xed357170
+	0xbfd34bf8	0xaeb9571a	0x4eec6a50	0xe881a1b7
+	0x8a1cbbde	0xc6c077b6	0xaeda1441	0xf990296a
+	0xc91e87d6	0xad0ca921	0x855537b6	0xfc0da57d
+	0xf8427d87	0x9ece7413	0xc5d4b4c9	0x2fca7822
+	0xa1888443	0xd3bf617e	0xab21ce7d	0xe63b5f53
+	0x828501c5	0x81a39da9	0xb8cfb4c6	0x6b23b8dc
+	0x853fe425	0xba262321	0x34f11b05	0x8044aea4
+	0x67a3f99d	0x51e8afb7	0x04efcf27	0x7773f9ff
+	0x8abceec1	0xd75d87a2	0x7e30d774	0xdd7a42f2
+	0x2ca6ad73	0x27d4e62f	0xbc228d26	0x035a7713
+	0x5dbcc13a	0x792a97da	0x56cf9fc2	0x5906fa3e
+	0x97a3147c	0x85e59863	0x19ad1f49	0x1af659a8
+	0xddc6a273	0xd254a195	0x44d83a00	0x3b7c5fa7
+	0xcaf756aa	0x68ad08b9	0xfc57da12	0x3b278f24
+	0xbd165574	0x3cf597ca	0xdeb872ba	0x543eb2f5
+	0xfabc0d4f	0x0799c544	0x3d71181d	0x22c8a598
+	0xb82840fc	0x1a198d19	0xf529a0ea	0x2f65bc24
+	0xe979f99d	0xff8617b4	0x376e5abb	0xb095a03e
+	0xa36b1107	0x2dacf004	0xe4c565e1	0xc96463cd
+	0x3b495e2d	0x4a2c2cd7	0xa0053fc2	0x6c82a085
+	0x6b801c45	0xc1481d77	0x6d95dc15	0x44dc8bf6
+	0x3eed7d25	0x901a6b49	0x2797e953	0x502ad2c3
+	0x8491c3f2	0x3ce059eb	0x992c1a76	0x6c56d2a2
+	0xcf1878a7	0x10574487	0x5a2f85e6	0xf94e418e
+	0x4c149aed	0x9381b5a3	0x79c90da4	0x635e696e
+	0x243073ba	0x67504105	0xe82ac957	0xaccda7b3
+	0x29bdd624	0xd0c1533c	0xbc080065	0x8d617329
+	0x27e6f74a	0x31e87692	0x50a3857d	0xc5b1ec3f
+	0x4f03be5f	0xa35fde17	0x537a59bb	0x793d1eb5
+	0xc11a0588	0x067e5593	0x102532c3	0x4024b312
+	0x32504cf4	0x4ddc0e9a	0xad5b1d24	0x41081874
+	0xf94fced4	0x16f39da6	0x9bdfbe58	0xc5615db4
+	0x1fdd769d	0x4278b52e	0x4525b8b6	0x7feed258
+	0xe0b4348b	0xb4925ccc	0x5547cc88	0x3f7f5443
+	0x5b8cc6d3	0xbe6a15cf	0x7308c088	0xde4219df
+	0x4685593c	0xc4ae83a3	0xaea72ff0	0x403b0c08
+	0xe533a9aa	0xed46be76	0x4390bcd0	0x683a9f3f
+	0x338b5cd3	0x7cd59689	0x2eb11aec	0x74e91cfd
+	0x7ae588aa	0x0eadf94e	0x30a6b42f	0x1965f165
+	0xd96de54b	0x06c85abf	0x1bbc0ab8	0x79f3ddd0
+	0x871fd58d	0x498dd69d	0x9197dd0e	0x6cbb3a4f
+	0x8a1f2a01	0x0d9cf747	0x80e66655	0x770d2b25
+	0x567bd3eb	0x59583c5a	0x58afeddd	0x9296d0e3
+	0xcf5af62c	0xf48b4c78	0x746f657e	0xe543b903
+	0x24603809	0xd1bceeea	0x16d04950	0x2a7c754b
+	0x4ea8bb99	0x9daecb97	0x3045b9a9	0x4a3e84d9
+	0x5487e79f	0xd6145e57	0xc3b17f6f	0x14448bb6
+	0x8e8529f5	0xf895acb9	0x6605c0f0	0x52d00ca9
+	0xabf6e3e9	0x8f36e307	0xa7a15442	0x55144801
+	0x69b028b2	0x8ab3b912	0xb493f80e	0x2dc9fdfa
+	0x1b091fbf	0x1bce6b31	0x79eb414e	0xe5f86ea0
+	0x39ef7dbd	0x2f86faf0	0xec366923	0xe770c7be
+	0x74e4aa61	0xef3b9da0	0xd77bd8be	0xfd13d3cb
+	0x4e8023c6	0x3d993904	0xfcb2f700	0xa14b753b
+	0xde16c1c3	0x983c5a86	0x52ba5e61	0x1d67b044
+	0x0f9a302d	0x2f13b653	0x769cbb97	0xea3e1cbd
+	0x5791778c	0x540fcff1	0x5e6c53f2	0xc9cbac0f
+	0x40ceadf0	0x648713d3	0xb5347ada	0xfe280079
+	0xb8389f3f	0x5a6be26a	0x8e683d28	0x6a3e8e3a
+	0x97ecac7a	0x70b648f1	0xe4eca20e	0x088cd0b4
+	0xbad30405	0x0f77e382	0x673cdf65	0x438af1f0
+	0x0b4f4eea	0xf0cc34e9	0x374a3c04	0x4370d27d
+	0xc3e1e84d	0x141205c2	0xfa831e8d	0x32f2f10a
+	0x77899366	0xc9d07590	0x9b6f2286	0xcac96a03
+	0xf822808b	0x265606cd	0xbeef275d	0x73415b15
+	0x4c87250e	0xf95a8c8a	0xdc8d6166	0x68522e63
+	0xb9becc14	0x7b5f20be	0x3d158dab	0xa73b1716
+	0x3b2cac15	0xf0498939	0xb60653bf	0x33fafc0e
+	0x3b416955	0x3addca50	0x16ab21cf	0xd18cbdb6
+	0x3b29b87b	0xa6fb7e4b	0x6634147f	0x44283b1e
+	0x430ae726	0xa907ab82	0x2baa6706	0x621d2390
+	0x15944559	0x2516c807	0x7d1eeb61	0xe2714121
+	0x288d3998	0x47713cbb	0xa1ce3c1e	0x0c29b6dd
+	0x9923131c	0x2dd19cfa	0x83d0ece5	0x78474c7b
+	0x92dee4f0	0xba5cb0f7	0x780c1d41	0x50da5a89
+	0xe303cebb	0xe8d5a2bd	0x7d6269a9	0xb75484f1
+	0x33ee8186	0x085b7657	0x7b1c7863	0xdb1a43ce
+	0x3d0c4bf0	0x302c1292	0x81e42216	0xee1f2c9d
+	0x822451ab	0xcefd8067	0x8330dc41	0x14492542
+	0xf038f54d	0x90a1abf9	0xc3067a77	0x40d9a42c
+	0x127285c1	0x80ad15ff	0xaf4854e2	0xa47874f4
+	0x2ed59760	0x67252c6a	0xe2830f38	0x8150c00c
+	0x16f61cca	0x1331f815	0x2d832d17	0x163c6010
+	0x69464e2f	0x99940411	0xbce5e85f	0x43d39ef2
+	0x9b7224dc	0x28652b6d	0x331a7632	0x127f669e
+	0x44a034ad	0xe95d2cec	0x3d83fefb	0xfa6d40a2
+	0x9b535bf4	0xc83411ce	0xd661655b	0x64bcd8d2
+	0xd99e1570	0x7dc4d877	0x9756b210	0x7623dc0d
+	0x484dd33f	0xe7bca204	0xa06efbc5	0xa358c03f
+	0x362cb282	0xe40e6d04	0x17ab9f5e	0x79a71a09
+	0x804bf1a9	0x6bca7d73	0x5504a4ff	0xd3946f75
+	0x18b0b9d4	0xd85993cc	0x94d000a5	0x8dda1609
+	0x30afb8f6	0xb3c99c3c	0x7686d59d	0x68b719db
+	0xdc7b3edb	0xedb76012	0xbfa0ba3b	0x280b829d
+	0x72fcf1aa	0xe3d8f83c	0x088a57cf	0x95156217
+	0x3306eb47	0x1d09cf54	0x1391876f	0x5b15ecde
+	0xb46104e1	0x8d8f2593	0x90ee50cc	0x78dad4b2
+	0xfd96daee	0xdbf15e95	0xfc859faa	0xdb4422a5
+	0xa00eeab6	0x525232c6	0x9b665668	0x8a70518b
+	0xbb27f7ac	0xb066b096	0x25754db6	0xe8c7d748
+	0xd4e8d361	0x380dd246	0x9bdf15e6	0x6823c660
+	0x5d408fe7	0xe59a5a89	0x1eb7523b	0x4997158e
+	0xfa6214d2	0x03b35025	0x9aeff33c	0x20a38aad
+	0x522f79cd	0x4141f19c	0xc58cd2bd	0xc816da37
+	0x62c6f8d9	0xc15ea9f4	0x138d1f45	0xd36cef03
+	0x88183bd6	0xe0de9036	0xefcbe8fc	0x5ebdce26
+	0x9e83b01b	0xd35f6747	0x552951f1	0x4e20dd66
+	0x419702b1	0x45446e7c	0x7ce5616b	0x6152e3a8
+	0xffd572e1	0x4fab25b0	0x07563b80	0x98720ee7
+	0x176d29bf	0x21cbd730	0xbde74431	0x09a8cce2
+	0xc15e548e	0xe6a92b4b	0x14f17e74	0x75f7817b
+	0x592143e8	0x113dbd25	0x5f7d7160	0xbdd8b1e0
+	0x6ce045e5	0x53b27b2d	0x371c8aa8	0xa4da8be0
+	0xf1f6df4e	0x9519bac4	0x6d6169cf	0x7846253f
+	0xccb95d95	0x6ad11a98	0x4a3bd21d	0x5389f44c
+	0x7c07ef3a	0xb983ca57	0xcf7f290d	0x4ec516f1
+	0xa7711e70	0x818d45a9	0x49db6441	0xd032fc2a
+	0x657df4d3	0xe37e6809	0x459a22da	0x41df8aa5
+	0x462108a6	0x65177d27	0x1ddffa9f	0x7fa6631b
+	0xdd7a414c	0x6351f0d1	0x1b38a419	0x6b529c8e
+	0x167745e4	0xcac35897	0x3d7bf419	0xd59ed67a
+	0x6486b2c9	0x9ae4fc90	0x8f608920	0xd35335c0
+	0x8f113cba	0x0fcc11a1	0xdc180fbf	0x57a99319
+	0x2c54185f	0x764c18d0	0x4f84b111	0x30a11040
+	0xd15620af	0x496af145	0x263b2de2	0x3ff103dd
+	0x38484dac	0xf143a3bc	0xb62c0de6	0xb122c545
+	0x72f10466	0x63728442	0xee0117c9	0x2309f14b
+	0x4ccdd5de	0x37ae022d	0x2ee7f050	0xf2aa9af6
+	0xcd314a20	0x86954941	0x97215303	0xcd7e1687
+	0x1dab6672	0x1c920209	0x41102dae	0x8b21c8ab
+	0x6f70b04b	0x2988b209	0x86e6f033	0x5eb91718
+	0x925b3c40	0xdcad0288	0x0ee98331	0xc3096ceb
+	0x9fa04740	0x3ce3fb23	0x90d75cbd	0xeab21768
+	0xaca5db0a	0x1c440578	0x762cb728	0x315a699f
+	0xcd2b6490	0x11e3e267	0xa10d1bbc	0x23ac26d3
+	0xc0c7c268	0x37ecf7ac	0x28de6fe5	0x6fb8e3e8
+	0x583d1131	0x8370812a	0x3afd5d58	0x4569a06e
+	0xf27ad86f	0x0db6a631	0x9add5128	0x1748c9fd
+	0xc46e3c57	0x4c0df93e	0xc595c544	0x397f7e7e
+	0x241f4086	0x7d7ed51b	0x56027473	0x656a6110
+	0x970a8011	0xf9c7beb5	0xc6cb9957	0xb7426461
+	0x62d3d89d	0xf99d48ca	0x3e4d4a88	0x9f751b71
+	0xfa020205	0xa3124337	0x59935869	0x98c58314
+	0xff7c4385	0x69191265	0xaf85ebb9	0xe434cda2
+	0xb1ad3e0e	0x221d32e1	0x022d73a0	0xd676ce06
+	0xab7f0c21	0x915c2444	0xf5bdaba2	0x74e4e789
+	0x11ff0d95	0x58c53feb	0xa54eb847	0x9af982ae
+	0x8d721596	0x73510fe4	0x95e3bd19	0xd82f8359
+	0xc09cdd5b	0xc07f57a4	0xbece605b	0xa8a43c5b
+	0x0acbeb6d	0x3c5cd8ce	0xb631050d	0xd558c921
+	0xcb5054c2	0xefb06252	0x40d2e2cc	0x14ffe6ff
+	0x761001a9	0xad64e7a5	0xb55618b4	0x2a40a1fc
+	0x2cbe6d40	0x2bc18fc1	0x196e7092	0x3c137791
+	0xa799eb23	0x1156feb9	0xd55d7ed1	0x0149c315
+	0xae77081f	0xfe724690	0x55ed2fd7	0x04b18cd7
+	0x691583f4	0xb1be4fde	0x19ae1cf7	0x3250140b
+	0x35daeeb2	0xc9459a84	0xea2c19e1	0x57f8c9cb
+	0xe05e07a4	0xcc77a363	0x43afd702	0x48305862
+	0x6c4b459f	0x66ed6178	0x26be9f81	0xeac41ee5
+	0xbe5e2e6b	0x177f9068	0xede56c48	0x438b3811
+	0xd5bd7ee4	0xc027d1a8	0xc1c0f725	0x48d4d4eb
+	0x6ffa28d5	0xbd6ac9eb	0xd497781d	0x24d3a154
+	0x409bb5c0	0x8079bf76	0x90a522dc	0x19bf7033
+	0x1a529b6e	0xe5207e4d	0x3d49b7bc	0x3eca6d54
+	0xa37681a6	0xaa9a62e4	0xe54aa1e1	0xb91e7157
+	0x8cce8f65	0xbcbbd62c	0x7fa477b5	0x44f46b50
+	0x54263fcf	0x529cbb5d	0x8923e390	0x0778d6d7
+	0x0cc0503f	0x02c374ce	0xb89c3e5c	0x25b1b353
+	0xb227cb2d	0x44108698	0x5e5968c2	0x82c48632
+	0x0b8f4209	0x1a241879	0x9edca6f1	0xa1fa51ab
+	0x206db0c6	0xbfbbbe98	0xa71c91f6	0xa1b28056
+	0xb8bfaaa9	0xa5914f75	0x77d26574	0xacfd459d
+	0x77f7cab2	0x249ebf26	0xef902bdd	0x77f6e48d
+	0x82497035	0x93333a9d	0x34ea9953	0x8f08d41c
+	>;
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_api.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_api.h
index 25b938f..a9d7156 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_api.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_api.h
@@ -14,9 +14,7 @@
  */
 typedef void (*fsp_continuation_f)(u32 status, void *hob_list);
 
-#pragma pack(1)
-
-struct fsp_init_params_t {
+struct fsp_init_params {
 	/* Non-volatile storage buffer pointer */
 	void			*nvs_buf;
 	/* Runtime buffer pointer */
@@ -25,7 +23,7 @@
 	fsp_continuation_f	continuation;
 };
 
-struct common_buf_t {
+struct common_buf {
 	/*
 	 * Stack top pointer used by the bootloader. The new stack frame will be
 	 * set up at this location after FspInit API call.
@@ -36,24 +34,22 @@
 	u32	reserved[7];	/* Reserved */
 };
 
-enum fsp_phase_t {
+enum fsp_phase {
 	/* Notification code for post PCI enuermation */
 	INIT_PHASE_PCI	= 0x20,
 	/* Notification code before transfering control to the payload */
 	INIT_PHASE_BOOT	= 0x40
 };
 
-struct fsp_notify_params_t {
+struct fsp_notify_params {
 	/* Notification phase used for NotifyPhase API */
-	enum fsp_phase_t	phase;
+	enum fsp_phase	phase;
 };
 
-#pragma pack()
-
 /* FspInit API function prototype */
-typedef u32 (*fsp_init_f)(struct fsp_init_params_t *param);
+typedef u32 (*fsp_init_f)(struct fsp_init_params *params);
 
 /* FspNotify API function prototype */
-typedef u32 (*fsp_notify_f)(struct fsp_notify_params_t *param);
+typedef u32 (*fsp_notify_f)(struct fsp_notify_params *params);
 
 #endif
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_ffs.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_ffs.h
index 1f73680..eaec2b4 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_ffs.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_ffs.h
@@ -8,10 +8,8 @@
 #ifndef __FSP_FFS_H__
 #define __FSP_FFS_H__
 
-#pragma pack(1)
-
 /* Used to verify the integrity of the file */
-union ffs_integrity_t {
+union __packed ffs_integrity {
 	struct {
 		/*
 		 * The IntegrityCheck.checksum.header field is an 8-bit
@@ -43,14 +41,14 @@
  * Each file begins with the header that describe the
  * contents and state of the files.
  */
-struct ffs_file_header_t {
+struct __packed ffs_file_header {
 	/*
 	 * This GUID is the file name.
 	 * It is used to uniquely identify the file.
 	 */
-	struct efi_guid_t	name;
+	struct efi_guid		name;
 	/* Used to verify the integrity of the file */
-	union ffs_integrity_t	integrity;
+	union ffs_integrity	integrity;
 	/* Identifies the type of file */
 	u8			type;
 	/* Declares various file attribute bits */
@@ -64,16 +62,16 @@
 	u8			state;
 };
 
-struct ffs_file_header2_t {
+struct __packed ffs_file_header2 {
 	/*
 	 * This GUID is the file name. It is used to uniquely identify the file.
 	 * There may be only one instance of a file with the file name GUID of
 	 * Name in any given firmware volume, except if the file type is
 	 * EFI_FV_FILE_TYPE_FFS_PAD.
 	 */
-	struct efi_guid_t	name;
+	struct efi_guid		name;
 	/* Used to verify the integrity of the file */
-	union ffs_integrity_t	integrity;
+	union ffs_integrity	integrity;
 	/* Identifies the type of file */
 	u8			type;
 	/* Declares various file attribute bits */
@@ -81,9 +79,9 @@
 	/*
 	 * The length of the file in bytes, including the FFS header.
 	 * The length of the file data is either
-	 * (size - sizeof(struct ffs_file_header_t)). This calculation means a
+	 * (size - sizeof(struct ffs_file_header)). This calculation means a
 	 * zero-length file has a size of 24 bytes, which is
-	 * sizeof(struct ffs_file_header_t). Size is not required to be a
+	 * sizeof(struct ffs_file_header). Size is not required to be a
 	 * multiple of 8 bytes. Given a file F, the next file header is located
 	 * at the next 8-byte aligned firmware volume offset following the last
 	 * byte of the file F.
@@ -98,7 +96,7 @@
 	 * If FFS_ATTRIB_LARGE_FILE is set in attr, then ext_size exists
 	 * and size must be set to zero.
 	 * If FFS_ATTRIB_LARGE_FILE is not set then
-	 * struct ffs_file_header_t is used.
+	 * struct ffs_file_header is used.
 	 */
 	u32			ext_size;
 };
@@ -129,7 +127,7 @@
 #define EFI_SECTION_SMM_DEPEX			0x1C
 
 /* Common section header */
-struct raw_section_t {
+struct __packed raw_section {
 	/*
 	 * A 24-bit unsigned integer that contains the total size of
 	 * the section in bytes, including the EFI_COMMON_SECTION_HEADER.
@@ -138,7 +136,7 @@
 	u8	type;
 };
 
-struct raw_section2_t {
+struct __packed raw_section2 {
 	/*
 	 * A 24-bit unsigned integer that contains the total size of
 	 * the section in bytes, including the EFI_COMMON_SECTION_HEADER.
@@ -153,6 +151,4 @@
 	u32	ext_size;
 };
 
-#pragma pack()
-
 #endif
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_fv.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_fv.h
index 01300db..a024451 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_fv.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_fv.h
@@ -63,7 +63,7 @@
 #define EFI_FVB2_ALIGNMENT_1G		0x001E0000
 #define EFI_FVB2_ALIGNMENT_2G		0x001F0000
 
-struct fv_blkmap_entry_t {
+struct fv_blkmap_entry {
 	/* The number of sequential blocks which are of the same size */
 	u32	num_blocks;
 	/* The size of the blocks */
@@ -71,7 +71,7 @@
 };
 
 /* Describes the features and layout of the firmware volume */
-struct fv_header_t {
+struct fv_header {
 	/*
 	 * The first 16 bytes are reserved to allow for the reset vector of
 	 * processors whose reset vector is at address 0.
@@ -81,7 +81,7 @@
 	 * Declares the file system with which the firmware volume
 	 * is formatted.
 	 */
-	struct efi_guid_t	fs_guid;
+	struct efi_guid		fs_guid;
 	/*
 	 * Length in bytes of the complete firmware volume, including
 	 * the header.
@@ -118,18 +118,18 @@
 	 * An array of run-length encoded FvBlockMapEntry structures.
 	 * The array is terminated with an entry of {0,0}.
 	 */
-	struct fv_blkmap_entry_t	block_map[1];
+	struct fv_blkmap_entry	block_map[1];
 };
 
-#define EFI_FVH_SIGNATURE SIGNATURE_32('_', 'F', 'V', 'H')
+#define EFI_FVH_SIGNATURE	SIGNATURE_32('_', 'F', 'V', 'H')
 
 /* Firmware Volume Header Revision definition */
 #define EFI_FVH_REVISION	0x02
 
 /* Extension header pointed by ExtHeaderOffset of volume header */
-struct fv_ext_header_t {
+struct fv_ext_header {
 	/* firmware volume name */
-	struct efi_guid_t	fv_name;
+	struct efi_guid		fv_name;
 	/* Size of the rest of the extension header including this structure */
 	u32			ext_hdr_size;
 };
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_hob.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_hob.h
index 44c0f90..380b64e 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_hob.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_hob.h
@@ -19,14 +19,14 @@
  * Describes the format and size of the data inside the HOB.
  * All HOBs must contain this generic HOB header.
  */
-struct hob_header_t {
+struct hob_header {
 	u16	type;		/* HOB type */
 	u16	len;		/* HOB length */
 	u32	reserved;	/* always zero */
 };
 
 /* Enumeration of memory types introduced in UEFI */
-enum efi_mem_type_t {
+enum efi_mem_type {
 	EFI_RESERVED_MEMORY_TYPE,
 	/*
 	 * The code portions of a loaded application.
@@ -87,16 +87,16 @@
  * exist outside the HOB list. This HOB type describes how memory is used,
  * not the physical attributes of memory.
  */
-struct hob_mem_alloc_t {
-	struct hob_header_t	hdr;
+struct hob_mem_alloc {
+	struct hob_header	hdr;
 	/*
 	 * A GUID that defines the memory allocation region's type and purpose,
 	 * as well as other fields within the memory allocation HOB. This GUID
 	 * is used to define the additional data within the HOB that may be
-	 * present for the memory allocation HOB. Type efi_guid_t is defined in
+	 * present for the memory allocation HOB. Type efi_guid is defined in
 	 * InstallProtocolInterface() in the UEFI 2.0 specification.
 	 */
-	struct efi_guid_t	name;
+	struct efi_guid		name;
 	/*
 	 * The base address of memory allocated by this HOB.
 	 * Type phys_addr_t is defined in AllocatePages() in the UEFI 2.0
@@ -111,7 +111,7 @@
 	 * Type EFI_MEMORY_TYPE is defined in AllocatePages() in the UEFI 2.0
 	 * specification.
 	 */
-	enum efi_mem_type_t	mem_type;
+	enum efi_mem_type	mem_type;
 	/* padding */
 	u8			reserved[4];
 };
@@ -155,14 +155,14 @@
  * Describes the resource properties of all fixed, nonrelocatable resource
  * ranges found on the processor host bus during the HOB producer phase.
  */
-struct hob_res_desc_t {
-	struct hob_header_t	hdr;
+struct hob_res_desc {
+	struct hob_header	hdr;
 	/*
 	 * A GUID representing the owner of the resource. This GUID is
 	 * used by HOB consumer phase components to correlate device
 	 * ownership of a resource.
 	 */
-	struct efi_guid_t	owner;
+	struct efi_guid		owner;
 	u32			type;
 	u32			attr;
 	/* The physical start address of the resource region */
@@ -175,24 +175,24 @@
  * Allows writers of executable content in the HOB producer phase to
  * maintain and manage HOBs with specific GUID.
  */
-struct hob_guid_t {
-	struct hob_header_t	hdr;
+struct hob_guid {
+	struct hob_header	hdr;
 	/* A GUID that defines the contents of this HOB */
-	struct efi_guid_t	name;
+	struct efi_guid		name;
 	/* GUID specific data goes here */
 };
 
 /* Union of all the possible HOB Types */
-union hob_pointers_t {
-	struct hob_header_t	*hdr;
-	struct hob_mem_alloc_t	*mem_alloc;
-	struct hob_res_desc_t	*res_desc;
-	struct hob_guid_t	*guid;
+union hob_pointers {
+	struct hob_header	*hdr;
+	struct hob_mem_alloc	*mem_alloc;
+	struct hob_res_desc	*res_desc;
+	struct hob_guid		*guid;
 	u8			*raw;
 };
 
 /**
- * Returns the type of a HOB.
+ * get_hob_type() - return the type of a HOB
  *
  * This macro returns the type field from the HOB header for the
  * HOB specified by hob.
@@ -201,11 +201,13 @@
  *
  * @return: HOB type.
  */
-#define GET_HOB_TYPE(hob) \
-	((*(struct hob_header_t **)&(hob))->type)
+static inline u16 get_hob_type(union hob_pointers hob)
+{
+	return hob.hdr->type;
+}
 
 /**
- * Returns the length, in bytes, of a HOB.
+ * get_hob_length() - return the length, in bytes, of a HOB
  *
  * This macro returns the len field from the HOB header for the
  * HOB specified by hob.
@@ -214,11 +216,13 @@
  *
  * @return: HOB length.
  */
-#define GET_HOB_LENGTH(hob) \
-	((*(struct hob_header_t **)&(hob))->len)
+static inline u16 get_hob_length(union hob_pointers hob)
+{
+	return hob.hdr->len;
+}
 
 /**
- * Returns a pointer to the next HOB in the HOB list.
+ * get_next_hob() - return a pointer to the next HOB in the HOB list
  *
  * This macro returns a pointer to HOB that follows the HOB specified by hob
  * in the HOB List.
@@ -227,25 +231,31 @@
  *
  * @return: A pointer to the next HOB in the HOB list.
  */
-#define GET_NEXT_HOB(hob)	\
-	(void *)(*(u8 **)&(hob) + GET_HOB_LENGTH(hob))
+static inline void *get_next_hob(union hob_pointers hob)
+{
+	return (void *)(*(u8 **)&(hob) + get_hob_length(hob));
+}
 
 /**
- * Determines if a HOB is the last HOB in the HOB list.
+ * end_of_hob() - determine if a HOB is the last HOB in the HOB list
  *
  * This macro determine if the HOB specified by hob is the last HOB in the
- * HOB list.  If hob is last HOB in the HOB list, then TRUE is returned.
- * Otherwise, FALSE is returned.
+ * HOB list.  If hob is last HOB in the HOB list, then true is returned.
+ * Otherwise, false is returned.
  *
  * @hob:          A pointer to a HOB.
  *
- * @retval TRUE:  The HOB specified by hob is the last HOB in the HOB list.
- * @retval FALSE: The HOB specified by hob is not the last HOB in the HOB list.
+ * @retval true:  The HOB specified by hob is the last HOB in the HOB list.
+ * @retval false: The HOB specified by hob is not the last HOB in the HOB list.
  */
-#define END_OF_HOB(hob)	(GET_HOB_TYPE(hob) == (u16)HOB_TYPE_EOH)
+static inline bool end_of_hob(union hob_pointers hob)
+{
+	return get_hob_type(hob) == HOB_TYPE_EOH;
+}
 
 /**
- * Returns a pointer to data buffer from a HOB of type HOB_TYPE_GUID_EXT.
+ * get_guid_hob_data() - return a pointer to data buffer from a HOB of
+ *                       type HOB_TYPE_GUID_EXT
  *
  * This macro returns a pointer to the data buffer in a HOB specified by hob.
  * hob is assumed to be a HOB of type HOB_TYPE_GUID_EXT.
@@ -254,11 +264,14 @@
  *
  * @return: A pointer to the data buffer in a HOB.
  */
-#define GET_GUID_HOB_DATA(hob)	\
-	(void *)(*(u8 **)&(hob) + sizeof(struct hob_guid_t))
+static inline void *get_guid_hob_data(u8 *hob)
+{
+	return (void *)(hob + sizeof(struct hob_guid));
+}
 
 /**
- * Returns the size of the data buffer from a HOB of type HOB_TYPE_GUID_EXT.
+ * get_guid_hob_data_size() - return the size of the data buffer from a HOB
+ *                            of type HOB_TYPE_GUID_EXT
  *
  * This macro returns the size, in bytes, of the data buffer in a HOB
  * specified by hob. hob is assumed to be a HOB of type HOB_TYPE_GUID_EXT.
@@ -267,14 +280,31 @@
  *
  * @return: The size of the data buffer.
  */
-#define GET_GUID_HOB_DATA_SIZE(hob)	\
-	(u16)(GET_HOB_LENGTH(hob) - sizeof(struct hob_guid_t))
+static inline u16 get_guid_hob_data_size(u8 *hob)
+{
+	union hob_pointers hob_p = *(union hob_pointers *)hob;
+	return get_hob_length(hob_p) - sizeof(struct hob_guid);
+}
 
 /* FSP specific GUID HOB definitions */
+#define FSP_GUID_DATA1		0x912740be
+#define FSP_GUID_DATA2		0x2284
+#define FSP_GUID_DATA3		0x4734
+#define FSP_GUID_DATA4_0	0xb9
+#define FSP_GUID_DATA4_1	0x71
+#define FSP_GUID_DATA4_2	0x84
+#define FSP_GUID_DATA4_3	0xb0
+#define FSP_GUID_DATA4_4	0x27
+#define FSP_GUID_DATA4_5	0x35
+#define FSP_GUID_DATA4_6	0x3f
+#define FSP_GUID_DATA4_7	0x0c
+
 #define FSP_HEADER_GUID \
 	{ \
-	0x912740be, 0x2284, 0x4734, \
-	{0xb9, 0x71, 0x84, 0xb0, 0x27, 0x35, 0x3f, 0x0c} \
+	FSP_GUID_DATA1, FSP_GUID_DATA2, FSP_GUID_DATA3, \
+	{ FSP_GUID_DATA4_0, FSP_GUID_DATA4_1, FSP_GUID_DATA4_2, \
+	  FSP_GUID_DATA4_3, FSP_GUID_DATA4_4, FSP_GUID_DATA4_5, \
+	  FSP_GUID_DATA4_6, FSP_GUID_DATA4_7 } \
 	}
 
 #define FSP_NON_VOLATILE_STORAGE_HOB_GUID \
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_infoheader.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_infoheader.h
index ad78bcd..4a4d627 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_infoheader.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_infoheader.h
@@ -10,9 +10,7 @@
 
 #define FSP_HEADER_OFF	0x94	/* Fixed FSP header offset in the FSP image */
 
-#pragma pack(1)
-
-struct fsp_header_t {
+struct __packed fsp_header {
 	u32	sign;			/* 'FSPH' */
 	u32	hdr_len;		/* header length */
 	u8	reserved1[3];
@@ -31,6 +29,4 @@
 	u32	reserved2;
 };
 
-#pragma pack()
-
 #endif
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_platform.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_platform.h
index a7b6e6b..61286ce 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_platform.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_platform.h
@@ -8,12 +8,8 @@
 #ifndef __FSP_PLATFORM_H__
 #define __FSP_PLATFORM_H__
 
-#pragma pack(1)
-
-struct fspinit_rtbuf_t {
-	struct common_buf_t	common;	/* FSP common runtime data structure */
+struct fspinit_rtbuf {
+	struct common_buf	common;	/* FSP common runtime data structure */
 };
 
-#pragma pack()
-
 #endif
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_support.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_support.h
index 3296a2b..3ae1b66 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_support.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_support.h
@@ -18,14 +18,30 @@
 #include "fsp_bootmode.h"
 #include "fsp_vpd.h"
 
-struct shared_data_t {
-	struct fsp_header_t	*fsp_hdr;
+struct shared_data {
+	struct fsp_header	*fsp_hdr;
 	u32			*stack_top;
-	struct upd_region_t	fsp_upd;
+	struct upd_region	fsp_upd;
 };
 
+#define FSP_LOWMEM_BASE		0x100000UL
+#define FSP_HIGHMEM_BASE	0x100000000ULL
+
+/**
+ * FSP Continuation assembly helper routine
+ *
+ * This routine jumps to the C version of FSP continuation function
+ */
 void asm_continuation(void);
 
+/**
+ * FSP initialization complete
+ *
+ * This is the function that indicates FSP initialization is complete and jumps
+ * back to the bootloader with HOB list pointer as the parameter.
+ *
+ * @hob_list:    HOB list pointer
+ */
 void fsp_init_done(void *hob_list);
 
 /**
@@ -37,19 +53,12 @@
  *
  * @retval:      Never returns
  */
-void fsp_continue(struct shared_data_t *shared_data, u32 status,
+void fsp_continue(struct shared_data *shared_data, u32 status,
 		  void *hob_list);
 
 /**
  * Find FSP header offset in FSP image
  *
- * If this function is called before the a stack is established, special care
- * must be taken. First, it cannot declare any local variable using stack.
- * Only register variable can be used here. Secondly, some compiler version
- * will add prolog or epilog code for the C function. If so the function call
- * may not work before stack is ready. GCC 4.8.1 has been verified to be
- * working for the following code.
- *
  * @retval: the offset of FSP header. If signature is invalid, returns 0.
  */
 u32 find_fsp_header(void);
@@ -67,11 +76,11 @@
  * FSP notification wrapper function
  *
  * @fsp_hdr: Pointer to FSP information header
- * @phase:   FSP initialization phase defined in enum fsp_phase_t
+ * @phase:   FSP initialization phase defined in enum fsp_phase
  *
  * @retval:  compatible status code with EFI_STATUS defined in PI spec
  */
-u32 fsp_notify(struct fsp_header_t *fsp_hdr, u32 phase);
+u32 fsp_notify(struct fsp_header *fsp_hdr, u32 phase);
 
 /**
  * This function retrieves the top of usable low memory.
@@ -80,7 +89,7 @@
  *
  * @retval:   Usable low memory top.
  */
-u32 get_usable_lowmem_top(const void *hob_list);
+u32 fsp_get_usable_lowmem_top(const void *hob_list);
 
 /**
  * This function retrieves the top of usable high memory.
@@ -89,7 +98,7 @@
  *
  * @retval:   Usable high memory top.
  */
-u64 get_usable_highmem_top(const void *hob_list);
+u64 fsp_get_usable_highmem_top(const void *hob_list);
 
 /**
  * This function retrieves a special reserved memory region.
@@ -102,8 +111,8 @@
  * @retval:   Reserved region start address.
  *            0 if this region does not exist.
  */
-u64 get_fsp_reserved_mem_from_guid(const void *hob_list,
-				   u64 *len, struct efi_guid_t *guid);
+u64 fsp_get_reserved_mem_from_guid(const void *hob_list,
+				   u64 *len, struct efi_guid *guid);
 
 /**
  * This function retrieves the FSP reserved normal memory.
@@ -114,7 +123,7 @@
  * @retval:   FSP reserved memory base
  *            0 if this region does not exist.
  */
-u32 get_fsp_reserved_mem(const void *hob_list, u32 *len);
+u32 fsp_get_fsp_reserved_mem(const void *hob_list, u32 *len);
 
 /**
  * This function retrieves the TSEG reserved normal memory.
@@ -126,7 +135,7 @@
  * @retval NULL:   Failed to find the TSEG reserved memory.
  * @retval others: TSEG reserved memory base.
  */
-u32 get_tseg_reserved_mem(const void *hob_list, u32 *len);
+u32 fsp_get_tseg_reserved_mem(const void *hob_list, u32 *len);
 
 /**
  * Returns the next instance of a HOB type from the starting HOB.
@@ -136,7 +145,7 @@
  *
  * @retval:   A HOB object with matching type; Otherwise NULL.
  */
-void *get_next_hob(u16 type, const void *hob_list);
+void *fsp_get_next_hob(u16 type, const void *hob_list);
 
 /**
  * Returns the next instance of the matched GUID HOB from the starting HOB.
@@ -146,7 +155,7 @@
  *
  * @retval:   A HOB object with matching GUID; Otherwise NULL.
  */
-void *get_next_guid_hob(const struct efi_guid_t *guid, const void *hob_list);
+void *fsp_get_next_guid_hob(const struct efi_guid *guid, const void *hob_list);
 
 /**
  * This function retrieves a GUID HOB data buffer and size.
@@ -159,8 +168,8 @@
  * @retval NULL:   Failed to find the GUID HOB.
  * @retval others: GUID HOB data buffer pointer.
  */
-void *get_guid_hob_data(const void *hob_list, u32 *len,
-			struct efi_guid_t *guid);
+void *fsp_get_guid_hob_data(const void *hob_list, u32 *len,
+			    struct efi_guid *guid);
 
 /**
  * This function retrieves FSP Non-volatile Storage HOB buffer and size.
@@ -172,7 +181,7 @@
  * @retval NULL:   Failed to find the NVS HOB.
  * @retval others: FSP NVS data buffer pointer.
  */
-void *get_fsp_nvs_data(const void *hob_list, u32 *len);
+void *fsp_get_nvs_data(const void *hob_list, u32 *len);
 
 /**
  * This function retrieves Bootloader temporary stack buffer and size.
@@ -184,15 +193,15 @@
  * @retval NULL:   Failed to find the bootloader temporary stack HOB.
  * @retval others: Bootloader temporary stackbuffer pointer.
  */
-void *get_bootloader_tmp_mem(const void *hob_list, u32 *len);
+void *fsp_get_bootloader_tmp_mem(const void *hob_list, u32 *len);
 
 /**
  * This function overrides the default configurations in the UPD data region.
  *
- * @fsp_upd: A pointer to the upd_region_t data strcture
+ * @fsp_upd: A pointer to the upd_region data strcture
  *
  * @return:  None
  */
-void update_fsp_upd(struct upd_region_t *fsp_upd);
+void update_fsp_upd(struct upd_region *fsp_upd);
 
 #endif
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_types.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_types.h
index 12ebbfd..f32d827 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_types.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_types.h
@@ -8,20 +8,8 @@
 #ifndef __FSP_TYPES_H__
 #define __FSP_TYPES_H__
 
-/*
- * Boolean true value.  UEFI Specification defines this value to be 1,
- * but this form is more portable.
- */
-#define TRUE			((unsigned char)(1 == 1))
-
-/*
- * Boolean false value.  UEFI Specification defines this value to be 0,
- * but this form is more portable.
- */
-#define FALSE			((unsigned char)(0 == 1))
-
 /* 128 bit buffer containing a unique identifier value */
-struct efi_guid_t {
+struct efi_guid {
 	u32	data1;
 	u16	data2;
 	u16	data3;
@@ -80,9 +68,6 @@
 #define SIGNATURE_64(A, B, C, D, E, F, G, H)	\
 	(SIGNATURE_32(A, B, C, D) | ((u64)(SIGNATURE_32(E, F, G, H)) << 32))
 
-/* Assertion for debug */
-#define ASSERT(exp)	do { if (!(exp)) for (;;); } while (FALSE)
-
 /*
  * Define FSP API return status code.
  * Compatiable with EFI_STATUS defined in PI Spec.
diff --git a/arch/x86/include/asm/arch-queensbay/fsp/fsp_vpd.h b/arch/x86/include/asm/arch-queensbay/fsp/fsp_vpd.h
index 11cc32f..bce58b1 100644
--- a/arch/x86/include/asm/arch-queensbay/fsp/fsp_vpd.h
+++ b/arch/x86/include/asm/arch-queensbay/fsp/fsp_vpd.h
@@ -10,9 +10,9 @@
 #ifndef __VPDHEADER_H__
 #define __VPDHEADER_H__
 
-#pragma pack(1)
+#define UPD_TERMINATOR	0x55AA
 
-struct upd_region_t {
+struct __packed upd_region {
 	u64	sign;			/* Offset 0x0000 */
 	u64	reserved;		/* Offset 0x0008 */
 	u8	dummy[240];		/* Offset 0x0010 */
@@ -39,7 +39,7 @@
 #define VPD_IMAGE_ID	0x445056574F4E4E4D	/* 'MNNOWVPD' */
 #define VPD_IMAGE_REV	0x00000301
 
-struct vpd_region_t {
+struct __packed vpd_region {
 	u64	sign;			/* Offset 0x0000 */
 	u32	img_rev;		/* Offset 0x0008 */
 	u32	upd_offset;		/* Offset 0x000C */
@@ -53,6 +53,4 @@
 	u8	pcie_port_ioh;		/* Offset 0x0029 */
 };
 
-#pragma pack()
-
 #endif
diff --git a/arch/x86/include/asm/arch-queensbay/gpio.h b/arch/x86/include/asm/arch-queensbay/gpio.h
new file mode 100644
index 0000000..ab4e059
--- /dev/null
+++ b/arch/x86/include/asm/arch-queensbay/gpio.h
@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef _X86_ARCH_GPIO_H_
+#define _X86_ARCH_GPIO_H_
+
+/* Where in config space is the register that points to the GPIO registers? */
+#define PCI_CFG_GPIOBASE 0x44
+
+#endif /* _X86_ARCH_GPIO_H_ */
diff --git a/arch/x86/include/asm/arch-queensbay/tnc.h b/arch/x86/include/asm/arch-queensbay/tnc.h
new file mode 100644
index 0000000..67c5e05
--- /dev/null
+++ b/arch/x86/include/asm/arch-queensbay/tnc.h
@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef _X86_ARCH_TNC_H_
+#define _X86_ARCH_TNC_H_
+
+#include <pci.h>
+
+/* PCI Configuration Space (D31:F0): LPC */
+#define PCH_LPC_DEV	PCI_BDF(0, 0x1f, 0)
+
+#endif /* _X86_ARCH_TNC_H_ */
diff --git a/arch/x86/include/asm/gpio.h b/arch/x86/include/asm/gpio.h
index 1787e52..1099427 100644
--- a/arch/x86/include/asm/gpio.h
+++ b/arch/x86/include/asm/gpio.h
@@ -11,7 +11,7 @@
 #include <asm-generic/gpio.h>
 
 struct ich6_bank_platdata {
-	uint32_t base_addr;
+	uint16_t base_addr;
 	const char *bank_name;
 };
 
@@ -147,7 +147,7 @@
 	} set3;
 };
 
-void setup_pch_gpios(u32 gpiobase, const struct pch_gpio_map *gpio);
+void setup_pch_gpios(u16 gpiobase, const struct pch_gpio_map *gpio);
 void ich_gpio_set_gpio_map(const struct pch_gpio_map *map);
 
 #endif /* _X86_GPIO_H_ */
diff --git a/arch/x86/include/asm/ibmpc.h b/arch/x86/include/asm/ibmpc.h
index e6d183b..c3b5187 100644
--- a/arch/x86/include/asm/ibmpc.h
+++ b/arch/x86/include/asm/ibmpc.h
@@ -18,4 +18,7 @@
 #define SYSCTLA         0x92
 #define SLAVE_PIC       0xa0
 
+#define UART0_BASE	0x3f8
+#define UART1_BASE	0x2f8
+
 #endif
diff --git a/arch/x86/lib/cmd_hob.c b/arch/x86/lib/cmd_hob.c
index 2fdff2b..b552fe6 100644
--- a/arch/x86/lib/cmd_hob.c
+++ b/arch/x86/lib/cmd_hob.c
@@ -17,18 +17,18 @@
 	"Memory Allocation",
 	"Resource Descriptor",
 	"GUID Extension",
-	"Firmware Volumn",
+	"Firmware Volume",
 	"CPU",
 	"Memory Pool",
 	"reserved",
-	"Firmware Volumn 2",
+	"Firmware Volume 2",
 	"Load PEIM Unused",
 	"UEFI Capsule",
 };
 
 int do_hob(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
-	union hob_pointers_t hob;
+	union hob_pointers hob;
 	u16 type;
 	char *desc;
 	int i = 0;
@@ -39,29 +39,27 @@
 
 	printf("No. | Address  | Type                | Length in Bytes\n");
 	printf("----|----------|---------------------|----------------\n");
-	while (!END_OF_HOB(hob)) {
+	while (!end_of_hob(hob)) {
 		printf("%-3d | %08x | ", i, (unsigned int)hob.raw);
-		type = hob.hdr->type;
+		type = get_hob_type(hob);
 		if (type == HOB_TYPE_UNUSED)
 			desc = "*Unused*";
 		else if (type == HOB_TYPE_EOH)
-			desc = "**END OF HOB**";
+			desc = "*END OF HOB*";
 		else if (type >= 0 && type <= ARRAY_SIZE(hob_type))
 			desc = hob_type[type];
 		else
-			desc = "!!!Invalid Type!!!";
-		printf("%-19s | %-15d\n", desc, hob.hdr->len);
-		hob.raw = GET_NEXT_HOB(hob);
+			desc = "*Invalid Type*";
+		printf("%-19s | %-15d\n", desc, get_hob_length(hob));
+		hob.raw = get_next_hob(hob);
 		i++;
 	}
 
 	return 0;
 }
 
-/* -------------------------------------------------------------------- */
-
 U_BOOT_CMD(
 	hob,	1,	1,	do_hob,
-	"print FSP Hand-Off Block information",
+	"print Firmware Support Package (FSP) Hand-Off Block information",
 	""
 );
diff --git a/board/armltd/vexpress64/MAINTAINERS b/board/armltd/vexpress64/MAINTAINERS
index 97c4b0e..66c8dff 100644
--- a/board/armltd/vexpress64/MAINTAINERS
+++ b/board/armltd/vexpress64/MAINTAINERS
@@ -6,6 +6,6 @@
 F:	configs/vexpress_aemv8a_defconfig
 
 VEXPRESS_AEMV8A_SEMI BOARD
-M:	Steve Rae <srae@broadcom.com>
+M:	Linus Walleij <linus.walleij@linaro.org>
 S:	Maintained
 F:	configs/vexpress_aemv8a_semi_defconfig
diff --git a/board/coreboot/coreboot/coreboot.c b/board/coreboot/coreboot/coreboot.c
index b260f9a..154faf6 100644
--- a/board/coreboot/coreboot/coreboot.c
+++ b/board/coreboot/coreboot/coreboot.c
@@ -16,7 +16,7 @@
 	return 0;
 }
 
-void setup_pch_gpios(u32 gpiobase, const struct pch_gpio_map *gpio)
+void setup_pch_gpios(u16 gpiobase, const struct pch_gpio_map *gpio)
 {
 	return;
 }
diff --git a/board/google/chromebook_link/link.c b/board/google/chromebook_link/link.c
index 4d95c1c..9978e92 100644
--- a/board/google/chromebook_link/link.c
+++ b/board/google/chromebook_link/link.c
@@ -125,7 +125,7 @@
 	return 0;
 }
 
-void setup_pch_gpios(u32 gpiobase, const struct pch_gpio_map *gpio)
+void setup_pch_gpios(u16 gpiobase, const struct pch_gpio_map *gpio)
 {
 	/* GPIO Set 1 */
 	if (gpio->set1.level)
diff --git a/board/intel/crownbay/Kconfig b/board/intel/crownbay/Kconfig
new file mode 100644
index 0000000..4709f9b
--- /dev/null
+++ b/board/intel/crownbay/Kconfig
@@ -0,0 +1,20 @@
+if TARGET_CROWNBAY
+
+config SYS_BOARD
+	default "crownbay"
+
+config SYS_VENDOR
+	default "intel"
+
+config SYS_SOC
+	default "queensbay"
+
+config SYS_CONFIG_NAME
+	default "crownbay"
+
+config BOARD_SPECIFIC_OPTIONS # dummy
+	def_bool y
+	select INTEL_QUEENSBAY
+	select BOARD_ROMSIZE_KB_1024
+
+endif
diff --git a/board/intel/crownbay/MAINTAINERS b/board/intel/crownbay/MAINTAINERS
new file mode 100644
index 0000000..1eb6869
--- /dev/null
+++ b/board/intel/crownbay/MAINTAINERS
@@ -0,0 +1,6 @@
+INTEL CROWNBAY BOARD
+M:	Bin Meng <bmeng.cn@gmail.com>
+S:	Maintained
+F:	board/intel/crownbay/
+F:	include/configs/crownbay.h
+F:	configs/crownbay_defconfig
diff --git a/board/intel/crownbay/Makefile b/board/intel/crownbay/Makefile
new file mode 100644
index 0000000..aeb219b
--- /dev/null
+++ b/board/intel/crownbay/Makefile
@@ -0,0 +1,7 @@
+#
+# Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+#
+# SPDX-License-Identifier:	GPL-2.0+
+#
+
+obj-y	+= crownbay.o start.o
diff --git a/board/intel/crownbay/crownbay.c b/board/intel/crownbay/crownbay.c
new file mode 100644
index 0000000..2a254ef
--- /dev/null
+++ b/board/intel/crownbay/crownbay.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/ibmpc.h>
+#include <asm/pnp_def.h>
+#include <netdev.h>
+#include <smsc_lpc47m.h>
+
+#define SERIAL_DEV PNP_DEV(0x2e, 4)
+
+DECLARE_GLOBAL_DATA_PTR;
+
+int board_early_init_f(void)
+{
+	lpc47m_enable_serial(SERIAL_DEV, UART0_BASE);
+
+	return 0;
+}
+
+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/crownbay/start.S b/board/intel/crownbay/start.S
new file mode 100644
index 0000000..cf92b4c
--- /dev/null
+++ b/board/intel/crownbay/start.S
@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2014, 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/raspberrypi/rpi/rpi.c b/board/raspberrypi/rpi/rpi.c
index 7dbd40e..c18271f 100644
--- a/board/raspberrypi/rpi/rpi.c
+++ b/board/raspberrypi/rpi/rpi.c
@@ -82,58 +82,82 @@
 static const struct {
 	const char *name;
 	const char *fdtfile;
+	bool has_onboard_eth;
 } models[] = {
+	[0] = {
+		"Unknown model",
+		"bcm2835-rpi-other.dtb",
+		false,
+	},
 	[BCM2835_BOARD_REV_B_I2C0_2] = {
 		"Model B (no P5)",
 		"bcm2835-rpi-b-i2c0.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_B_I2C0_3] = {
 		"Model B (no P5)",
 		"bcm2835-rpi-b-i2c0.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_B_I2C1_4] = {
 		"Model B",
 		"bcm2835-rpi-b.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_B_I2C1_5] = {
 		"Model B",
 		"bcm2835-rpi-b.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_B_I2C1_6] = {
 		"Model B",
 		"bcm2835-rpi-b.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_A_7] = {
 		"Model A",
 		"bcm2835-rpi-a.dtb",
+		false,
 	},
 	[BCM2835_BOARD_REV_A_8] = {
 		"Model A",
 		"bcm2835-rpi-a.dtb",
+		false,
 	},
 	[BCM2835_BOARD_REV_A_9] = {
 		"Model A",
 		"bcm2835-rpi-a.dtb",
+		false,
 	},
 	[BCM2835_BOARD_REV_B_REV2_d] = {
 		"Model B rev2",
 		"bcm2835-rpi-b-rev2.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_B_REV2_e] = {
 		"Model B rev2",
 		"bcm2835-rpi-b-rev2.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_B_REV2_f] = {
 		"Model B rev2",
 		"bcm2835-rpi-b-rev2.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_B_PLUS] = {
 		"Model B+",
 		"bcm2835-rpi-b-plus.dtb",
+		true,
 	},
 	[BCM2835_BOARD_REV_CM] = {
 		"Compute Module",
 		"bcm2835-rpi-cm.dtb",
+		false,
+	},
+	[BCM2835_BOARD_REV_A_PLUS] = {
+		"Model A+",
+		"bcm2835-rpi-a-plus.dtb",
+		false,
 	},
 };
 
@@ -166,9 +190,6 @@
 		return;
 
 	fdtfile = models[rpi_board_rev].fdtfile;
-	if (!fdtfile)
-		fdtfile = "bcm2835-rpi-other.dtb";
-
 	setenv("fdtfile", fdtfile);
 }
 
@@ -177,6 +198,9 @@
 	ALLOC_ALIGN_BUFFER(struct msg_get_mac_address, msg, 1, 16);
 	int ret;
 
+	if (!models[rpi_board_rev].has_onboard_eth)
+		return;
+
 	if (getenv("usbethaddr"))
 		return;
 
@@ -243,12 +267,17 @@
 	}
 
 	rpi_board_rev = msg->get_board_rev.body.resp.rev;
-	if (rpi_board_rev >= ARRAY_SIZE(models))
+	if (rpi_board_rev >= ARRAY_SIZE(models)) {
+		printf("RPI: Board rev %u outside known range\n",
+		       rpi_board_rev);
+		rpi_board_rev = 0;
+	}
+	if (!models[rpi_board_rev].name) {
+		printf("RPI: Board rev %u unknown\n", rpi_board_rev);
 		rpi_board_rev = 0;
+	}
 
 	name = models[rpi_board_rev].name;
-	if (!name)
-		name = "Unknown model";
 	printf("RPI model: %s\n", name);
 }
 
diff --git a/common/board_f.c b/common/board_f.c
index 98c9c72..cfd77f8 100644
--- a/common/board_f.c
+++ b/common/board_f.c
@@ -813,7 +813,9 @@
 #endif
 	setup_mon_len,
 	setup_fdt,
+#ifdef CONFIG_TRACE
 	trace_early_init,
+#endif
 	initf_malloc,
 #if defined(CONFIG_MPC85xx) || defined(CONFIG_MPC86xx)
 	/* TODO: can this go into arch_cpu_init()? */
diff --git a/common/cmd_dfu.c b/common/cmd_dfu.c
index 9e020b4..e975abe 100644
--- a/common/cmd_dfu.c
+++ b/common/cmd_dfu.c
@@ -38,10 +38,10 @@
 
 	int controller_index = simple_strtoul(usb_controller, NULL, 0);
 	board_usb_init(controller_index, USB_INIT_DEVICE);
-	dfu_clear_detach();
+	g_dnl_clear_detach();
 	g_dnl_register("usb_dnl_dfu");
 	while (1) {
-		if (dfu_detach()) {
+		if (g_dnl_detach()) {
 			/*
 			 * Check if USB bus reset is performed after detach,
 			 * which indicates that -R switch has been passed to
@@ -74,7 +74,7 @@
 	if (dfu_reset)
 		run_command("reset", 0);
 
-	dfu_clear_detach();
+	g_dnl_clear_detach();
 
 	return ret;
 }
diff --git a/common/cmd_fastboot.c b/common/cmd_fastboot.c
index 909616d..b72f4f3 100644
--- a/common/cmd_fastboot.c
+++ b/common/cmd_fastboot.c
@@ -15,17 +15,21 @@
 {
 	int ret;
 
+	g_dnl_clear_detach();
 	ret = g_dnl_register("usb_dnl_fastboot");
 	if (ret)
 		return ret;
 
 	while (1) {
+		if (g_dnl_detach())
+			break;
 		if (ctrlc())
 			break;
 		usb_gadget_handle_interrupts();
 	}
 
 	g_dnl_unregister();
+	g_dnl_clear_detach();
 	return CMD_RET_SUCCESS;
 }
 
diff --git a/common/cmd_hash.c b/common/cmd_hash.c
index 90facbb..704d21e 100644
--- a/common/cmd_hash.c
+++ b/common/cmd_hash.c
@@ -18,9 +18,9 @@
 static int do_hash(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	char *s;
-#ifdef CONFIG_HASH_VERIFY
 	int flags = HASH_FLAG_ENV;
 
+#ifdef CONFIG_HASH_VERIFY
 	if (argc < 4)
 		return CMD_RET_USAGE;
 	if (!strcmp(argv[1], "-v")) {
@@ -28,8 +28,6 @@
 		argc--;
 		argv++;
 	}
-#else
-	const int flags = HASH_FLAG_ENV;
 #endif
 	/* Move forward to 'algorithm' parameter */
 	argc--;
@@ -40,19 +38,19 @@
 }
 
 #ifdef CONFIG_HASH_VERIFY
-U_BOOT_CMD(
-	hash,	6,	1,	do_hash,
-	"compute hash message digest",
-	"algorithm address count [[*]sum_dest]\n"
-		"    - compute message digest [save to env var / *address]\n"
-	"hash -v algorithm address count [*]sum\n"
-		"    - verify hash of memory area with env var / *address"
-);
+#define HARGS 6
 #else
+#define HARGS 5
+#endif
+
 U_BOOT_CMD(
-	hash,	5,	1,	do_hash,
-	"compute message digest",
-	"algorithm address count [[*]sum_dest]\n"
+	hash,	HARGS,	1,	do_hash,
+	"compute hash message digest",
+	"algorithm address count [[*]hash_dest]\n"
 		"    - compute message digest [save to env var / *address]"
-);
+#ifdef CONFIG_HASH_VERIFY
+	"\nhash -v algorithm address count [*]hash\n"
+		"    - verify message digest of memory area to immediate value, \n"
+		"      env var or *address"
 #endif
+);
diff --git a/common/fb_mmc.c b/common/fb_mmc.c
index fb06d8a..6ea3938 100644
--- a/common/fb_mmc.c
+++ b/common/fb_mmc.c
@@ -4,12 +4,17 @@
  * SPDX-License-Identifier:	GPL-2.0+
  */
 
+#include <config.h>
 #include <common.h>
 #include <fb_mmc.h>
 #include <part.h>
 #include <aboot.h>
 #include <sparse_format.h>
 
+#ifndef CONFIG_FASTBOOT_GPT_NAME
+#define CONFIG_FASTBOOT_GPT_NAME GPT_ENTRY_NAME
+#endif
+
 /* The 64 defined bytes plus the '\0' */
 #define RESPONSE_LEN	(64 + 1)
 
@@ -62,7 +67,6 @@
 void fb_mmc_flash_write(const char *cmd, void *download_buffer,
 			unsigned int download_bytes, char *response)
 {
-	int ret;
 	block_dev_desc_t *dev_desc;
 	disk_partition_t info;
 
@@ -76,8 +80,24 @@
 		return;
 	}
 
-	ret = get_partition_info_efi_by_name(dev_desc, cmd, &info);
-	if (ret) {
+	if (strcmp(cmd, CONFIG_FASTBOOT_GPT_NAME) == 0) {
+		printf("%s: updating MBR, Primary and Backup GPT(s)\n",
+		       __func__);
+		if (is_valid_gpt_buf(dev_desc, download_buffer)) {
+			printf("%s: invalid GPT - refusing to write to flash\n",
+			       __func__);
+			fastboot_fail("invalid GPT partition");
+			return;
+		}
+		if (write_mbr_and_gpt_partitions(dev_desc, download_buffer)) {
+			printf("%s: writing GPT partitions failed\n", __func__);
+			fastboot_fail("writing GPT partitions failed");
+			return;
+		}
+		printf("........ success\n");
+		fastboot_okay("");
+		return;
+	} else if (get_partition_info_efi_by_name(dev_desc, cmd, &info)) {
 		error("cannot find partition: '%s'\n", cmd);
 		fastboot_fail("cannot find partition");
 		return;
diff --git a/common/hash.c b/common/hash.c
index 12d6759..aceabc5 100644
--- a/common/hash.c
+++ b/common/hash.c
@@ -256,7 +256,7 @@
 			env_var = 1;
 	}
 
-	if (env_var) {
+	if (!env_var) {
 		ulong addr;
 		void *buf;
 
@@ -347,7 +347,7 @@
 {
 	ulong addr, len;
 
-	if (argc < 2)
+	if ((argc < 2) || ((flags & HASH_FLAG_VERIFY) && (argc < 3)))
 		return CMD_RET_USAGE;
 
 	addr = simple_strtoul(*argv++, NULL, 16);
@@ -380,8 +380,6 @@
 #else
 		if (0) {
 #endif
-			if (!argc)
-				return CMD_RET_USAGE;
 			if (parse_verify_sum(algo, *argv, vsum,
 					flags & HASH_FLAG_ENV)) {
 				printf("ERROR: %s does not contain a valid "
diff --git a/configs/armadillo-800eva_defconfig b/configs/armadillo-800eva_defconfig
index 9b17895..22dc1f8 100644
--- a/configs/armadillo-800eva_defconfig
+++ b/configs/armadillo-800eva_defconfig
@@ -1,3 +1,3 @@
 CONFIG_ARM=y
-+S:CONFIG_RMOBILE=y
+CONFIG_RMOBILE=y
 CONFIG_TARGET_ARMADILLO_800EVA=y
diff --git a/configs/crownbay_defconfig b/configs/crownbay_defconfig
new file mode 100644
index 0000000..ce90553
--- /dev/null
+++ b/configs/crownbay_defconfig
@@ -0,0 +1,6 @@
+CONFIG_SYS_EXTRA_OPTIONS="SYS_TEXT_BASE=0xfff00000"
+CONFIG_X86=y
+CONFIG_TARGET_CROWNBAY=y
+CONFIG_OF_CONTROL=y
+CONFIG_OF_SEPARATE=y
+CONFIG_DEFAULT_DEVICE_TREE="crownbay"
diff --git a/configs/kzm9g_defconfig b/configs/kzm9g_defconfig
index d4d340f..20656dd 100644
--- a/configs/kzm9g_defconfig
+++ b/configs/kzm9g_defconfig
@@ -1,3 +1,3 @@
 CONFIG_ARM=y
-+S:CONFIG_RMOBILE=y
+CONFIG_RMOBILE=y
 CONFIG_TARGET_KZM9G=y
diff --git a/disk/part_efi.c b/disk/part_efi.c
index efed58f..338010e 100644
--- a/disk/part_efi.c
+++ b/disk/part_efi.c
@@ -69,6 +69,107 @@
 			sizeof(efi_guid_t));
 }
 
+static int validate_gpt_header(gpt_header *gpt_h, lbaint_t lba,
+		lbaint_t lastlba)
+{
+	uint32_t crc32_backup = 0;
+	uint32_t calc_crc32;
+
+	/* Check the GPT header signature */
+	if (le64_to_cpu(gpt_h->signature) != GPT_HEADER_SIGNATURE) {
+		printf("%s signature is wrong: 0x%llX != 0x%llX\n",
+		       "GUID Partition Table Header",
+		       le64_to_cpu(gpt_h->signature),
+		       GPT_HEADER_SIGNATURE);
+		return -1;
+	}
+
+	/* Check the GUID Partition Table CRC */
+	memcpy(&crc32_backup, &gpt_h->header_crc32, sizeof(crc32_backup));
+	memset(&gpt_h->header_crc32, 0, sizeof(gpt_h->header_crc32));
+
+	calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
+		le32_to_cpu(gpt_h->header_size));
+
+	memcpy(&gpt_h->header_crc32, &crc32_backup, sizeof(crc32_backup));
+
+	if (calc_crc32 != le32_to_cpu(crc32_backup)) {
+		printf("%s CRC is wrong: 0x%x != 0x%x\n",
+		       "GUID Partition Table Header",
+		       le32_to_cpu(crc32_backup), calc_crc32);
+		return -1;
+	}
+
+	/*
+	 * Check that the my_lba entry points to the LBA that contains the GPT
+	 */
+	if (le64_to_cpu(gpt_h->my_lba) != lba) {
+		printf("GPT: my_lba incorrect: %llX != " LBAF "\n",
+		       le64_to_cpu(gpt_h->my_lba),
+		       lba);
+		return -1;
+	}
+
+	/*
+	 * Check that the first_usable_lba and that the last_usable_lba are
+	 * within the disk.
+	 */
+	if (le64_to_cpu(gpt_h->first_usable_lba) > lastlba) {
+		printf("GPT: first_usable_lba incorrect: %llX > " LBAF "\n",
+		       le64_to_cpu(gpt_h->first_usable_lba), lastlba);
+		return -1;
+	}
+	if (le64_to_cpu(gpt_h->last_usable_lba) > lastlba) {
+		printf("GPT: last_usable_lba incorrect: %llX > " LBAF "\n",
+		       le64_to_cpu(gpt_h->last_usable_lba), lastlba);
+		return -1;
+	}
+
+	debug("GPT: first_usable_lba: %llX last_usable_lba: %llX last lba: "
+	      LBAF "\n", le64_to_cpu(gpt_h->first_usable_lba),
+	      le64_to_cpu(gpt_h->last_usable_lba), lastlba);
+
+	return 0;
+}
+
+static int validate_gpt_entries(gpt_header *gpt_h, gpt_entry *gpt_e)
+{
+	uint32_t calc_crc32;
+
+	/* Check the GUID Partition Table Entry Array CRC */
+	calc_crc32 = efi_crc32((const unsigned char *)gpt_e,
+		le32_to_cpu(gpt_h->num_partition_entries) *
+		le32_to_cpu(gpt_h->sizeof_partition_entry));
+
+	if (calc_crc32 != le32_to_cpu(gpt_h->partition_entry_array_crc32)) {
+		printf("%s: 0x%x != 0x%x\n",
+		       "GUID Partition Table Entry Array CRC is wrong",
+		       le32_to_cpu(gpt_h->partition_entry_array_crc32),
+		       calc_crc32);
+		return -1;
+	}
+
+	return 0;
+}
+
+static void prepare_backup_gpt_header(gpt_header *gpt_h)
+{
+	uint32_t calc_crc32;
+	uint64_t val;
+
+	/* recalculate the values for the Backup GPT Header */
+	val = le64_to_cpu(gpt_h->my_lba);
+	gpt_h->my_lba = gpt_h->alternate_lba;
+	gpt_h->alternate_lba = cpu_to_le64(val);
+	gpt_h->partition_entry_lba =
+			cpu_to_le64(le64_to_cpu(gpt_h->last_usable_lba) + 1);
+	gpt_h->header_crc32 = 0;
+
+	calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
+			       le32_to_cpu(gpt_h->header_size));
+	gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
+}
+
 #ifdef CONFIG_EFI_PARTITION
 /*
  * Public Functions (include/part.h)
@@ -259,7 +360,6 @@
 	const int pte_blk_cnt = BLOCK_CNT((gpt_h->num_partition_entries
 					   * sizeof(gpt_entry)), dev_desc);
 	u32 calc_crc32;
-	u64 val;
 
 	debug("max lba: %x\n", (u32) dev_desc->lba);
 	/* Setup the Protective MBR */
@@ -284,15 +384,7 @@
 	    != pte_blk_cnt)
 		goto err;
 
-	/* recalculate the values for the Backup GPT Header */
-	val = le64_to_cpu(gpt_h->my_lba);
-	gpt_h->my_lba = gpt_h->alternate_lba;
-	gpt_h->alternate_lba = cpu_to_le64(val);
-	gpt_h->header_crc32 = 0;
-
-	calc_crc32 = efi_crc32((const unsigned char *)gpt_h,
-			      le32_to_cpu(gpt_h->header_size));
-	gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
+	prepare_backup_gpt_header(gpt_h);
 
 	if (dev_desc->block_write(dev_desc->dev,
 				  (lbaint_t)le64_to_cpu(gpt_h->last_usable_lba)
@@ -455,6 +547,97 @@
 	free(gpt_h);
 	return ret;
 }
+
+int is_valid_gpt_buf(block_dev_desc_t *dev_desc, void *buf)
+{
+	gpt_header *gpt_h;
+	gpt_entry *gpt_e;
+
+	/* determine start of GPT Header in the buffer */
+	gpt_h = buf + (GPT_PRIMARY_PARTITION_TABLE_LBA *
+		       dev_desc->blksz);
+	if (validate_gpt_header(gpt_h, GPT_PRIMARY_PARTITION_TABLE_LBA,
+				dev_desc->lba))
+		return -1;
+
+	/* determine start of GPT Entries in the buffer */
+	gpt_e = buf + (le64_to_cpu(gpt_h->partition_entry_lba) *
+		       dev_desc->blksz);
+	if (validate_gpt_entries(gpt_h, gpt_e))
+		return -1;
+
+	return 0;
+}
+
+int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf)
+{
+	gpt_header *gpt_h;
+	gpt_entry *gpt_e;
+	int gpt_e_blk_cnt;
+	lbaint_t lba;
+	int cnt;
+
+	if (is_valid_gpt_buf(dev_desc, buf))
+		return -1;
+
+	/* determine start of GPT Header in the buffer */
+	gpt_h = buf + (GPT_PRIMARY_PARTITION_TABLE_LBA *
+		       dev_desc->blksz);
+
+	/* determine start of GPT Entries in the buffer */
+	gpt_e = buf + (le64_to_cpu(gpt_h->partition_entry_lba) *
+		       dev_desc->blksz);
+	gpt_e_blk_cnt = BLOCK_CNT((le32_to_cpu(gpt_h->num_partition_entries) *
+				   le32_to_cpu(gpt_h->sizeof_partition_entry)),
+				  dev_desc);
+
+	/* write MBR */
+	lba = 0;	/* MBR is always at 0 */
+	cnt = 1;	/* MBR (1 block) */
+	if (dev_desc->block_write(dev_desc->dev, lba, cnt, buf) != cnt) {
+		printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
+		       __func__, "MBR", cnt, lba);
+		return 1;
+	}
+
+	/* write Primary GPT */
+	lba = GPT_PRIMARY_PARTITION_TABLE_LBA;
+	cnt = 1;	/* GPT Header (1 block) */
+	if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_h) != cnt) {
+		printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
+		       __func__, "Primary GPT Header", cnt, lba);
+		return 1;
+	}
+
+	lba = le64_to_cpu(gpt_h->partition_entry_lba);
+	cnt = gpt_e_blk_cnt;
+	if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_e) != cnt) {
+		printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
+		       __func__, "Primary GPT Entries", cnt, lba);
+		return 1;
+	}
+
+	prepare_backup_gpt_header(gpt_h);
+
+	/* write Backup GPT */
+	lba = le64_to_cpu(gpt_h->partition_entry_lba);
+	cnt = gpt_e_blk_cnt;
+	if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_e) != cnt) {
+		printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
+		       __func__, "Backup GPT Entries", cnt, lba);
+		return 1;
+	}
+
+	lba = le64_to_cpu(gpt_h->my_lba);
+	cnt = 1;	/* GPT Header (1 block) */
+	if (dev_desc->block_write(dev_desc->dev, lba, cnt, gpt_h) != cnt) {
+		printf("%s: failed writing '%s' (%d blks at 0x" LBAF ")\n",
+		       __func__, "Backup GPT Header", cnt, lba);
+		return 1;
+	}
+
+	return 0;
+}
 #endif
 
 /*
@@ -511,10 +694,6 @@
 static int is_gpt_valid(block_dev_desc_t *dev_desc, u64 lba,
 			gpt_header *pgpt_head, gpt_entry **pgpt_pte)
 {
-	u32 crc32_backup = 0;
-	u32 calc_crc32;
-	u64 lastlba;
-
 	if (!dev_desc || !pgpt_head) {
 		printf("%s: Invalid Argument(s)\n", __func__);
 		return 0;
@@ -527,55 +706,8 @@
 		return 0;
 	}
 
-	/* Check the GPT header signature */
-	if (le64_to_cpu(pgpt_head->signature) != GPT_HEADER_SIGNATURE) {
-		printf("GUID Partition Table Header signature is wrong:"
-			"0x%llX != 0x%llX\n",
-			le64_to_cpu(pgpt_head->signature),
-			GPT_HEADER_SIGNATURE);
-		return 0;
-	}
-
-	/* Check the GUID Partition Table CRC */
-	memcpy(&crc32_backup, &pgpt_head->header_crc32, sizeof(crc32_backup));
-	memset(&pgpt_head->header_crc32, 0, sizeof(pgpt_head->header_crc32));
-
-	calc_crc32 = efi_crc32((const unsigned char *)pgpt_head,
-		le32_to_cpu(pgpt_head->header_size));
-
-	memcpy(&pgpt_head->header_crc32, &crc32_backup, sizeof(crc32_backup));
-
-	if (calc_crc32 != le32_to_cpu(crc32_backup)) {
-		printf("GUID Partition Table Header CRC is wrong:"
-			"0x%x != 0x%x\n",
-		       le32_to_cpu(crc32_backup), calc_crc32);
-		return 0;
-	}
-
-	/* Check that the my_lba entry points to the LBA that contains the GPT */
-	if (le64_to_cpu(pgpt_head->my_lba) != lba) {
-		printf("GPT: my_lba incorrect: %llX != %" PRIX64 "\n",
-		       le64_to_cpu(pgpt_head->my_lba),
-		       lba);
+	if (validate_gpt_header(pgpt_head, (lbaint_t)lba, dev_desc->lba))
 		return 0;
-	}
-
-	/* Check the first_usable_lba and last_usable_lba are within the disk. */
-	lastlba = (u64)dev_desc->lba;
-	if (le64_to_cpu(pgpt_head->first_usable_lba) > lastlba) {
-		printf("GPT: first_usable_lba incorrect: %llX > %" PRIX64 "\n",
-		       le64_to_cpu(pgpt_head->first_usable_lba), lastlba);
-		return 0;
-	}
-	if (le64_to_cpu(pgpt_head->last_usable_lba) > lastlba) {
-		printf("GPT: last_usable_lba incorrect: %llX > %" PRIX64 "\n",
-		       le64_to_cpu(pgpt_head->last_usable_lba), lastlba);
-		return 0;
-	}
-
-	debug("GPT: first_usable_lba: %llX last_usable_lba %llX last lba %"
-	      PRIX64 "\n", le64_to_cpu(pgpt_head->first_usable_lba),
-	      le64_to_cpu(pgpt_head->last_usable_lba), lastlba);
 
 	/* Read and allocate Partition Table Entries */
 	*pgpt_pte = alloc_read_gpt_entries(dev_desc, pgpt_head);
@@ -584,17 +716,7 @@
 		return 0;
 	}
 
-	/* Check the GUID Partition Table Entry Array CRC */
-	calc_crc32 = efi_crc32((const unsigned char *)*pgpt_pte,
-		le32_to_cpu(pgpt_head->num_partition_entries) *
-		le32_to_cpu(pgpt_head->sizeof_partition_entry));
-
-	if (calc_crc32 != le32_to_cpu(pgpt_head->partition_entry_array_crc32)) {
-		printf("GUID Partition Table Entry Array CRC is wrong:"
-			"0x%x != 0x%x\n",
-			le32_to_cpu(pgpt_head->partition_entry_array_crc32),
-			calc_crc32);
-
+	if (validate_gpt_entries(pgpt_head, *pgpt_pte)) {
 		free(*pgpt_pte);
 		return 0;
 	}
diff --git a/doc/README.x86 b/doc/README.x86
new file mode 100644
index 0000000..5fab044
--- /dev/null
+++ b/doc/README.x86
@@ -0,0 +1,126 @@
+#
+# Copyright (C) 2014, Simon Glass <sjg@chromium.org>
+# Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
+#
+# SPDX-License-Identifier:	GPL-2.0+
+#
+
+U-Boot on x86
+=============
+
+This document describes the information about U-Boot running on x86 targets,
+including supported boards, build instructions, todo list, etc.
+
+Status
+------
+U-Boot supports running as a coreboot [1] payload on x86. So far only Link
+(Chromebook Pixel) has been tested, but it should work with minimal adjustments
+on other x86 boards since coreboot deals with most of the low-level details.
+
+U-Boot also supports booting directly from x86 reset vector without coreboot,
+aka raw support or bare support. Currently Link and Intel Crown Bay board
+support running U-Boot 'bare metal'.
+
+As for loading OS, U-Boot supports directly booting a 32-bit or 64-bit Linux
+kernel as part of a FIT image. It also supports a compressed zImage.
+
+Build Instructions
+------------------
+Building U-Boot as a coreboot payload is just like building U-Boot for targets
+on other architectures, like below:
+
+$ make coreboot-x86_defconfig
+$ make all
+
+Building ROM version of U-Boot (hereafter referred to as u-boot.rom) is a
+little bit tricky, as generally it requires several binary blobs which are not
+shipped in the U-Boot source tree. Due to this reason, the u-boot.rom build is
+not turned on by default in the U-Boot source tree. Firstly, you need turn it
+on by uncommenting the following line in the main U-Boot Makefile:
+
+# ALL-$(CONFIG_X86_RESET_VECTOR) += u-boot.rom
+
+Link-specific instructions:
+
+First, you need the following binary blobs:
+
+* descriptor.bin - Intel flash descriptor
+* me.bin - Intel Management Engine
+* mrc.bin - Memory Reference Code, which sets up SDRAM
+* video ROM - sets up the display
+
+You can get these binary blobs by:
+
+$ git clone http://review.coreboot.org/p/blobs.git
+$ cd blobs
+
+Find the following files:
+
+* ./mainboard/google/link/descriptor.bin
+* ./mainboard/google/link/me.bin
+* ./northbridge/intel/sandybridge/systemagent-ivybridge.bin
+
+The 3rd one should be renamed to mrc.bin.
+As for the video ROM, you can get it here [2].
+Make sure all these binary blobs are put in the board directory.
+
+Now you can build U-Boot and obtain u-boot.rom:
+
+$ make chromebook_link_defconfig
+$ make all
+
+Intel Crown Bay specific instructions:
+
+U-Boot support of Intel Crown Bay board [3] relies on a binary blob called
+Firmware Support Package [4] to perform all the necessary initialization steps
+as documented in the BIOS Writer Guide, including initialization of the CPU,
+memory controller, chipset and certain bus interfaces.
+
+Download the Intel FSP for Atom E6xx series and Platform Controller Hub EG20T,
+install it on your host and locate the FSP binary blob. Note this platform
+also requires a Chipset Micro Code (CMC) state machine binary to be present in
+the SPI flash where u-boot.rom resides, and this CMC binary blob can be found
+in this FSP package too.
+
+* ./FSP/QUEENSBAY_FSP_GOLD_001_20-DECEMBER-2013.fd
+* ./Microcode/C0_22211.BIN
+
+Rename the first one to fsp.bin and second one to cmc.bin and put them in the
+board directory.
+
+Now you can build U-Boot and obtaim u-boot.rom
+
+$ make crownbay_defconfig
+$ make all
+
+CPU Microcode
+-------------
+Modern CPU usually requires a special bit stream called microcode [5] to be
+loaded on the processor after power up in order to function properly. U-Boot
+has already integrated these as hex dumps in the source tree.
+
+Driver Model
+------------
+x86 has been converted to use driver model for serial and GPIO.
+
+Device Tree
+-----------
+x86 uses device tree to configure the board thus requires CONFIG_OF_CONTROL to
+be turned on. Not every device on the board is configured via devie tree, but
+more and more devices will be added as time goes by. Check out the directory
+arch/x86/dts/ for these device tree source files.
+
+TODO List
+---------
+- MTRR support (for performance)
+- Audio
+- Chrome OS verified boot
+- SMI and ACPI support, to provide platform info and facilities to Linux
+
+References
+----------
+[1] http://www.coreboot.org
+[2] http://www.coreboot.org/~stepan/pci8086,0166.rom
+[3] http://www.intel.com/content/www/us/en/embedded/design-tools/evaluation-platforms/atom-e660-eg20t-development-kit.html
+[4] http://www.intel.com/fsp
+[5] http://en.wikipedia.org/wiki/Microcode
diff --git a/drivers/dfu/dfu.c b/drivers/dfu/dfu.c
index 14cb366..ad0a7e7 100644
--- a/drivers/dfu/dfu.c
+++ b/drivers/dfu/dfu.c
@@ -17,7 +17,6 @@
 #include <linux/list.h>
 #include <linux/compiler.h>
 
-static bool dfu_detach_request;
 static LIST_HEAD(dfu_list);
 static int dfu_alt_num;
 static int alt_num_cnt;
@@ -39,21 +38,6 @@
 	return true;
 }
 
-bool dfu_detach(void)
-{
-	return dfu_detach_request;
-}
-
-void dfu_trigger_detach(void)
-{
-	dfu_detach_request = true;
-}
-
-void dfu_clear_detach(void)
-{
-	dfu_detach_request = false;
-}
-
 static int dfu_find_alt_num(const char *s)
 {
 	int i = 0;
@@ -111,8 +95,12 @@
 		return dfu_buf;
 
 	s = getenv("dfu_bufsiz");
-	dfu_buf_size = s ? (unsigned long)simple_strtol(s, NULL, 16) :
-			CONFIG_SYS_DFU_DATA_BUF_SIZE;
+	if (s)
+		dfu_buf_size = (unsigned long)simple_strtol(s, NULL, 0);
+
+	if (!s || !dfu_buf_size)
+		dfu_buf_size = CONFIG_SYS_DFU_DATA_BUF_SIZE;
+
 	if (dfu->max_buf_size && dfu_buf_size > dfu->max_buf_size)
 		dfu_buf_size = dfu->max_buf_size;
 
diff --git a/drivers/dfu/dfu_mmc.c b/drivers/dfu/dfu_mmc.c
index 72fa03e..62d72fe 100644
--- a/drivers/dfu/dfu_mmc.c
+++ b/drivers/dfu/dfu_mmc.c
@@ -40,10 +40,16 @@
 static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
 			u64 offset, void *buf, long *len)
 {
-	struct mmc *mmc = find_mmc_device(dfu->data.mmc.dev_num);
+	struct mmc *mmc;
 	u32 blk_start, blk_count, n = 0;
 	int ret, part_num_bkp = 0;
 
+	mmc = find_mmc_device(dfu->data.mmc.dev_num);
+	if (!mmc) {
+		error("Device MMC %d - not found!", dfu->data.mmc.dev_num);
+		return -ENODEV;
+	}
+
 	/*
 	 * We must ensure that we work in lba_blk_size chunks, so ALIGN
 	 * this value.
diff --git a/drivers/gpio/intel_ich6_gpio.c b/drivers/gpio/intel_ich6_gpio.c
index 3433216..7720cc3 100644
--- a/drivers/gpio/intel_ich6_gpio.c
+++ b/drivers/gpio/intel_ich6_gpio.c
@@ -39,9 +39,9 @@
 
 struct ich6_bank_priv {
 	/* These are I/O addresses */
-	uint32_t use_sel;
-	uint32_t io_sel;
-	uint32_t lvl;
+	uint16_t use_sel;
+	uint16_t io_sel;
+	uint16_t lvl;
 };
 
 /* TODO: Move this to device tree, or platform data */
@@ -57,7 +57,7 @@
 	u8 tmpbyte;
 	u16 tmpword;
 	u32 tmplong;
-	u32 gpiobase;
+	u16 gpiobase;
 	int offset;
 
 	/* Where should it be? */
@@ -116,11 +116,15 @@
 	/*
 	 * GPIOBASE moved to its current offset with ICH6, but prior to
 	 * that it was unused (or undocumented). Check that it looks
-	 * okay: not all ones or zeros, and mapped to I/O space (bit 0).
+	 * okay: not all ones or zeros.
+	 *
+	 * Note we don't need check bit0 here, because the Tunnel Creek
+	 * GPIO base address register bit0 is reserved (read returns 0),
+	 * while on the Ivybridge the bit0 is used to indicate it is an
+	 * I/O space.
 	 */
 	tmplong = pci_read_config32(pci_dev, PCI_CFG_GPIOBASE);
-	if (tmplong == 0x00000000 || tmplong == 0xffffffff ||
-	    !(tmplong & 0x00000001)) {
+	if (tmplong == 0x00000000 || tmplong == 0xffffffff) {
 		debug("%s: unexpected GPIOBASE value\n", __func__);
 		return -ENODEV;
 	}
@@ -131,7 +135,7 @@
 	 * at the offset that we just read. Bit 0 indicates that it's
 	 * an I/O address, not a memory address, so mask that off.
 	 */
-	gpiobase = tmplong & 0xfffffffe;
+	gpiobase = tmplong & 0xfffe;
 	offset = fdtdec_get_int(gd->fdt_blob, dev->of_offset, "reg", -1);
 	if (offset == -1) {
 		debug("%s: Invalid register offset %d\n", __func__, offset);
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 8c84942..4cc00cd 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -43,7 +43,7 @@
 obj-$(CONFIG_TEGRA_SERIAL) += serial_tegra.o
 obj-$(CONFIG_UNIPHIER_SERIAL) += serial_uniphier.o
 obj-$(CONFIG_OMAP_SERIAL) += serial_omap.o
-obj-$(CONFIG_COREBOOT_SERIAL) += serial_coreboot.o
+obj-$(CONFIG_X86_SERIAL) += serial_x86.o
 
 ifndef CONFIG_SPL_BUILD
 obj-$(CONFIG_USB_TTY) += usbtty.o
diff --git a/drivers/serial/serial_coreboot.c b/drivers/serial/serial_x86.c
similarity index 67%
rename from drivers/serial/serial_coreboot.c
rename to drivers/serial/serial_x86.c
index 5c6a76c..e81e035 100644
--- a/drivers/serial/serial_coreboot.c
+++ b/drivers/serial/serial_x86.c
@@ -9,12 +9,12 @@
 #include <ns16550.h>
 #include <serial.h>
 
-static const struct udevice_id coreboot_serial_ids[] = {
-	{ .compatible = "coreboot-uart" },
+static const struct udevice_id x86_serial_ids[] = {
+	{ .compatible = "x86-uart" },
 	{ }
 };
 
-static int coreboot_serial_ofdata_to_platdata(struct udevice *dev)
+static int x86_serial_ofdata_to_platdata(struct udevice *dev)
 {
 	struct ns16550_platdata *plat = dev_get_platdata(dev);
 	int ret;
@@ -27,10 +27,10 @@
 	return 0;
 }
 U_BOOT_DRIVER(serial_ns16550) = {
-	.name	= "serial_coreboot",
+	.name	= "serial_x86",
 	.id	= UCLASS_SERIAL,
-	.of_match = coreboot_serial_ids,
-	.ofdata_to_platdata = coreboot_serial_ofdata_to_platdata,
+	.of_match = x86_serial_ids,
+	.ofdata_to_platdata = x86_serial_ofdata_to_platdata,
 	.platdata_auto_alloc_size = sizeof(struct ns16550_platdata),
 	.priv_auto_alloc_size = sizeof(struct NS16550),
 	.probe = ns16550_serial_probe,
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index 12628ef..fbc74f3 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -1062,7 +1062,6 @@
 	if ((epstatus & epctrl) & USBA_RX_BK_RDY) {
 		DBG(DBG_BUS, "%s: RX data ready\n", ep->ep.name);
 		receive_data(ep);
-		usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
 	}
 }
 
diff --git a/drivers/usb/gadget/f_dfu.c b/drivers/usb/gadget/f_dfu.c
index 16fc9dd..ead71eb 100644
--- a/drivers/usb/gadget/f_dfu.c
+++ b/drivers/usb/gadget/f_dfu.c
@@ -366,7 +366,7 @@
 		to_runtime_mode(f_dfu);
 		f_dfu->dfu_state = DFU_STATE_appIDLE;
 
-		dfu_trigger_detach();
+		g_dnl_trigger_detach();
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
diff --git a/drivers/usb/gadget/f_fastboot.c b/drivers/usb/gadget/f_fastboot.c
index 71b62e5..310175a 100644
--- a/drivers/usb/gadget/f_fastboot.c
+++ b/drivers/usb/gadget/f_fastboot.c
@@ -480,6 +480,17 @@
 	fastboot_tx_write_str("OKAY");
 }
 
+static void do_exit_on_complete(struct usb_ep *ep, struct usb_request *req)
+{
+	g_dnl_trigger_detach();
+}
+
+static void cb_continue(struct usb_ep *ep, struct usb_request *req)
+{
+	fastboot_func->in_req->complete = do_exit_on_complete;
+	fastboot_tx_write_str("OKAY");
+}
+
 #ifdef CONFIG_FASTBOOT_FLASH
 static void cb_flash(struct usb_ep *ep, struct usb_request *req)
 {
@@ -520,6 +531,9 @@
 	}, {
 		.cmd = "boot",
 		.cb = cb_boot,
+	}, {
+		.cmd = "continue",
+		.cb = cb_continue,
 	},
 #ifdef CONFIG_FASTBOOT_FLASH
 	{
diff --git a/drivers/usb/gadget/f_thor.c b/drivers/usb/gadget/f_thor.c
index 78519fa..2d0410d 100644
--- a/drivers/usb/gadget/f_thor.c
+++ b/drivers/usb/gadget/f_thor.c
@@ -205,12 +205,24 @@
 
 static int download_tail(long long int left, int cnt)
 {
-	struct dfu_entity *dfu_entity = dfu_get_entity(alt_setting_num);
-	void *transfer_buffer = dfu_get_buf(dfu_entity);
+	struct dfu_entity *dfu_entity;
+	void *transfer_buffer;
 	int ret;
 
 	debug("%s: left: %llu cnt: %d\n", __func__, left, cnt);
 
+	dfu_entity = dfu_get_entity(alt_setting_num);
+	if (!dfu_entity) {
+		error("Alt setting: %d entity not found!\n", alt_setting_num);
+		return -ENOENT;
+	}
+
+	transfer_buffer = dfu_get_buf(dfu_entity);
+	if (!transfer_buffer) {
+		error("Transfer buffer not allocated!");
+		return -ENXIO;
+	}
+
 	if (left) {
 		ret = dfu_write(dfu_entity, transfer_buffer, left, cnt++);
 		if (ret) {
diff --git a/drivers/usb/gadget/g_dnl.c b/drivers/usb/gadget/g_dnl.c
index 25611ac..ee52a29 100644
--- a/drivers/usb/gadget/g_dnl.c
+++ b/drivers/usb/gadget/g_dnl.c
@@ -163,6 +163,23 @@
 	return -EOPNOTSUPP;
 }
 
+static bool g_dnl_detach_request;
+
+bool g_dnl_detach(void)
+{
+	return g_dnl_detach_request;
+}
+
+void g_dnl_trigger_detach(void)
+{
+	g_dnl_detach_request = true;
+}
+
+void g_dnl_clear_detach(void)
+{
+	g_dnl_detach_request = false;
+}
+
 static int g_dnl_get_bcd_device_number(struct usb_composite_dev *cdev)
 {
 	struct usb_gadget *gadget = cdev->gadget;
diff --git a/include/configs/chromebook_link.h b/include/configs/chromebook_link.h
index 645b31c..8930210 100644
--- a/include/configs/chromebook_link.h
+++ b/include/configs/chromebook_link.h
@@ -25,10 +25,10 @@
 
 #define CONFIG_X86_RESET_VECTOR
 #define CONFIG_NR_DRAM_BANKS			8
-#define CONFIG_X86_MRC_START			0xfffa0000
+#define CONFIG_X86_MRC_ADDR			0xfffa0000
 #define CONFIG_CACHE_MRC_SIZE_KB		512
 
-#define CONFIG_COREBOOT_SERIAL
+#define CONFIG_X86_SERIAL
 
 #define CONFIG_SCSI_DEV_LIST		{PCI_VENDOR_ID_INTEL, \
 			PCI_DEVICE_ID_INTEL_NM10_AHCI},	      \
@@ -39,7 +39,7 @@
 	{PCI_VENDOR_ID_INTEL,		\
 			PCI_DEVICE_ID_INTEL_PANTHERPOINT_AHCI_MOBILE}
 
-#define CONFIG_X86_OPTION_ROM_FILENAME		pci8086,0166.bin
+#define CONFIG_X86_OPTION_ROM_FILE		pci8086,0166.bin
 #define CONFIG_X86_OPTION_ROM_ADDR		0xfff90000
 #define CONFIG_VIDEO_X86
 
diff --git a/include/configs/coreboot.h b/include/configs/coreboot.h
index 2581380..990a2d1 100644
--- a/include/configs/coreboot.h
+++ b/include/configs/coreboot.h
@@ -49,7 +49,7 @@
 	{PCI_VENDOR_ID_INTEL,		\
 			PCI_DEVICE_ID_INTEL_PANTHERPOINT_AHCI_MOBILE}
 
-#define CONFIG_COREBOOT_SERIAL
+#define CONFIG_X86_SERIAL
 
 #define CONFIG_STD_DEVICES_SETTINGS     "stdin=usbkbd,vga,serial\0" \
 					"stdout=vga,serial,cbmem\0" \
diff --git a/include/configs/crownbay.h b/include/configs/crownbay.h
new file mode 100644
index 0000000..eadb339
--- /dev/null
+++ b/include/configs/crownbay.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2014, 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_SYS_X86_START16		0xfffff800
+#define CONFIG_BOARD_EARLY_INIT_F
+
+#define CONFIG_X86_RESET_VECTOR
+#define CONFIG_NR_DRAM_BANKS		1
+
+#define CONFIG_X86_SERIAL
+#define CONFIG_SMSC_LPC47M
+
+#define CONFIG_PCI_MEM_BUS		0x40000000
+#define CONFIG_PCI_MEM_PHYS		CONFIG_PCI_MEM_BUS
+#define CONFIG_PCI_MEM_SIZE		0x80000000
+
+#define CONFIG_PCI_PREF_BUS		0xc0000000
+#define CONFIG_PCI_PREF_PHYS		CONFIG_PCI_PREF_BUS
+#define CONFIG_PCI_PREF_SIZE		0x20000000
+
+#define CONFIG_PCI_IO_BUS		0x2000
+#define CONFIG_PCI_IO_PHYS		CONFIG_PCI_IO_BUS
+#define CONFIG_PCI_IO_SIZE		0xe000
+
+#define CONFIG_SYS_EARLY_PCI_INIT
+#define CONFIG_PCI_PNP
+#define CONFIG_E1000
+
+#define CONFIG_STD_DEVICES_SETTINGS     "stdin=serial\0" \
+					"stdout=serial\0" \
+					"stderr=serial\0"
+
+#define CONFIG_SCSI_DEV_LIST            \
+	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SATA}
+
+#define CONFIG_SPI_FLASH_SST
+
+#define CONFIG_MMC
+#define CONFIG_SDHCI
+#define CONFIG_GENERIC_MMC
+#define CONFIG_MMC_SDMA
+#define CONFIG_CMD_MMC
+
+/* Video is not supported */
+#undef CONFIG_VIDEO
+#undef CONFIG_CFB_CONSOLE
+
+#endif	/* __CONFIG_H */
diff --git a/include/configs/vexpress_aemv8a.h b/include/configs/vexpress_aemv8a.h
index f3af971..027d78b 100644
--- a/include/configs/vexpress_aemv8a.h
+++ b/include/configs/vexpress_aemv8a.h
@@ -8,6 +8,9 @@
 #ifndef __VEXPRESS_AEMV8A_H
 #define __VEXPRESS_AEMV8A_H
 
+/* We use generic board for v8 Versatile Express */
+#define CONFIG_SYS_GENERIC_BOARD
+
 #ifdef CONFIG_BASE_FVP
 #ifndef CONFIG_SEMIHOSTING
 #error CONFIG_BASE_FVP requires CONFIG_SEMIHOSTING
@@ -25,8 +28,6 @@
 
 /*#define CONFIG_ARMV8_SWITCH_TO_EL1*/
 
-/*#define CONFIG_SYS_GENERIC_BOARD*/
-
 #define CONFIG_SYS_NO_FLASH
 
 #define CONFIG_SUPPORT_RAW_INITRD
diff --git a/include/dfu.h b/include/dfu.h
index f1a71c7..c27856c 100644
--- a/include/dfu.h
+++ b/include/dfu.h
@@ -150,9 +150,6 @@
 char *dfu_extract_token(char** e, int *n);
 void dfu_trigger_reset(void);
 int dfu_get_alt(char *name);
-bool dfu_detach(void);
-void dfu_trigger_detach(void);
-void dfu_clear_detach(void);
 int dfu_init_env_entities(char *interface, char *devstr);
 unsigned char *dfu_get_buf(struct dfu_entity *dfu);
 unsigned char *dfu_free_buf(void);
diff --git a/include/g_dnl.h b/include/g_dnl.h
index 1b1b35e..4eeb5e4 100644
--- a/include/g_dnl.h
+++ b/include/g_dnl.h
@@ -39,4 +39,8 @@
 void g_dnl_unregister(void);
 void g_dnl_set_serialnumber(char *);
 
+bool g_dnl_detach(void);
+void g_dnl_trigger_detach(void);
+void g_dnl_clear_detach(void);
+
 #endif /* __G_DOWNLOAD_H_ */
diff --git a/include/part.h b/include/part.h
index a496a4a..8ea9b30 100644
--- a/include/part.h
+++ b/include/part.h
@@ -244,6 +244,26 @@
  */
 int gpt_restore(block_dev_desc_t *dev_desc, char *str_disk_guid,
 		disk_partition_t *partitions, const int parts_count);
+
+/**
+ * is_valid_gpt_buf() - Ensure that the Primary GPT information is valid
+ *
+ * @param dev_desc - block device descriptor
+ * @param buf - buffer which contains the MBR and Primary GPT info
+ *
+ * @return - '0' on success, otherwise error
+ */
+int is_valid_gpt_buf(block_dev_desc_t *dev_desc, void *buf);
+
+/**
+ * write_mbr_and_gpt_partitions() - write MBR, Primary GPT and Backup GPT
+ *
+ * @param dev_desc - block device descriptor
+ * @param buf - buffer which contains the MBR and Primary GPT info
+ *
+ * @return - '0' on success, otherwise error
+ */
+int write_mbr_and_gpt_partitions(block_dev_desc_t *dev_desc, void *buf);
 #endif
 
 #endif /* _PART_H */
diff --git a/lib/initcall.c b/lib/initcall.c
index 39f4b3f..7142744 100644
--- a/lib/initcall.c
+++ b/lib/initcall.c
@@ -19,7 +19,11 @@
 
 		if (gd->flags & GD_FLG_RELOC)
 			reloc_ofs = gd->reloc_off;
-		debug("initcall: %p\n", (char *)*init_fnc_ptr - reloc_ofs);
+		debug("initcall: %p", (char *)*init_fnc_ptr - reloc_ofs);
+		if (gd->flags & GD_FLG_RELOC)
+			debug(" (relocated to %p)\n", (char *)*init_fnc_ptr);
+		else
+			debug("\n");
 		ret = (*init_fnc_ptr)();
 		if (ret) {
 			printf("initcall sequence %p failed at call %p (err=%d)\n",
diff --git a/scripts/binutils-version.sh b/scripts/binutils-version.sh
index d4d9eb4..0bc26cf 100755
--- a/scripts/binutils-version.sh
+++ b/scripts/binutils-version.sh
@@ -14,7 +14,9 @@
 	exit 1
 fi
 
-MAJOR=$($gas --version | head -1 | awk '{print $NF}' | cut -d . -f 1)
-MINOR=$($gas --version | head -1 | awk '{print $NF}' | cut -d . -f 2)
+version_string=$($gas --version | head -1 | sed -e 's/.*) *\([0-9.]*\).*/\1/' )
+
+MAJOR=$(echo $version_string | cut -d . -f 1)
+MINOR=$(echo $version_string | cut -d . -f 2)
 
 printf "%02d%02d\\n" $MAJOR $MINOR
diff --git a/tools/Makefile b/tools/Makefile
index a4216a1..e549f8e 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -126,6 +126,7 @@
 hostprogs-$(CONFIG_EXYNOS5420) += mkexynosspl
 HOSTCFLAGS_mkexynosspl.o := -pedantic
 
+ifdtool-objs := $(LIBFDT_OBJS) ifdtool.o
 hostprogs-$(CONFIG_X86) += ifdtool
 
 hostprogs-$(CONFIG_MX23) += mxsboot
diff --git a/tools/buildman/README b/tools/buildman/README
index bfb2f18..0f8ea20 100644
--- a/tools/buildman/README
+++ b/tools/buildman/README
@@ -42,7 +42,7 @@
 Buildman is a builder. It is not make, although it runs make. It does not
 produce any useful output on the terminal while building, except for
 progress information (except with -v, see below). All the output (errors,
-warnings and binaries if you are ask for them) is stored in output
+warnings and binaries if you ask for them) is stored in output
 directories, which you can look at while the build is progressing, or when
 it is finished.
 
@@ -121,7 +121,7 @@
 means to build all arm boards except nvidia, freescale and anything ending
 with 'ball'.
 
-It is convenient to use the -n option to see whaat will be built based on
+It is convenient to use the -n option to see what will be built based on
 the subset given.
 
 Buildman does not store intermediate object files. It optionally copies
@@ -371,7 +371,7 @@
 
 
 To find out how the build went, ask for a summary with -s. You can do this
-either before the build completes (presumably in another terminal) or or
+either before the build completes (presumably in another terminal) or
 afterwards. Let's work through an example of how this is used:
 
 $ ./tools/buildman/buildman -b lcd9b -s
@@ -439,7 +439,7 @@
 
 At commit 16, the error moves - you can see that the old error at line 120
 is fixed, but there is a new one at line 126. This is probably only because
-we added some code and moved the broken line father down the file.
+we added some code and moved the broken line further down the file.
 
 If many boards have the same error, then -e will display the error only
 once. This makes the output as concise as possible. To see which boards have
@@ -647,8 +647,8 @@
 board was built) and by 96 bytes for powerpc. This increase was offset in both
 cases by reductions in rodata and data/bss.
 
-Shown below the summary lines is the sizes for each board. Below each board
-is the sizes for each function. This information starts with:
+Shown below the summary lines are the sizes for each board. Below each board
+are the sizes for each function. This information starts with:
 
    add - number of functions added / removed
    grow - number of functions which grew / shrunk
@@ -817,7 +817,7 @@
 This has mostly be written in my spare time as a response to my difficulties
 in testing large series of patches. Apart from tidying up there is quite a
 bit of scope for improvement. Things like better error diffs and easier
-access to log files. Also it would be nice it buildman could 'hunt' for
+access to log files. Also it would be nice if buildman could 'hunt' for
 problems, perhaps by building a few boards for each arch, or checking
 commits for changed files and building only boards which use those files.
 
diff --git a/tools/ifdtool.c b/tools/ifdtool.c
index 4a27b82..fe8366b 100644
--- a/tools/ifdtool.c
+++ b/tools/ifdtool.c
@@ -18,6 +18,7 @@
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <libfdt.h>
 #include "ifdtool.h"
 
 #undef DEBUG
@@ -32,6 +33,18 @@
 #define FLREG_BASE(reg)		((reg & 0x00000fff) << 12);
 #define FLREG_LIMIT(reg)	(((reg & 0x0fff0000) >> 4) | 0xfff);
 
+enum input_file_type_t {
+	IF_normal,
+	IF_fdt,
+	IF_uboot,
+};
+
+struct input_file {
+	char *fname;
+	unsigned int addr;
+	enum input_file_type_t type;
+};
+
 /**
  * find_fd() - Find the flash description in the ROM image
  *
@@ -54,7 +67,8 @@
 		return NULL;
 	}
 
-	debug("Found Flash Descriptor signature at 0x%08x\n", i);
+	debug("Found Flash Descriptor signature at 0x%08lx\n",
+	      (char *)ptr - image);
 
 	return (struct fdbar_t *)ptr;
 }
@@ -464,6 +478,16 @@
 	return ret;
 }
 
+static int perror_fname(const char *fmt, const char *fname)
+{
+	char msg[strlen(fmt) + strlen(fname) + 1];
+
+	sprintf(msg, fmt, fname);
+	perror(msg);
+
+	return -1;
+}
+
 /**
  * write_image() - Write the image to a file
  *
@@ -480,10 +504,10 @@
 
 	new_fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR |
 		      S_IWUSR | S_IRGRP | S_IROTH);
-	if (write(new_fd, image, size) != size) {
-		perror("Error while writing");
-		return -1;
-	}
+	if (new_fd < 0)
+		return perror_fname("Could not open file '%s'", filename);
+	if (write(new_fd, image, size) != size)
+		return perror_fname("Could not write file '%s'", filename);
 	close(new_fd);
 
 	return 0;
@@ -585,14 +609,10 @@
 	int fd = open(fname, O_RDONLY);
 	struct stat buf;
 
-	if (fd == -1) {
-		perror("Could not open file");
-		return -1;
-	}
-	if (fstat(fd, &buf) == -1) {
-		perror("Could not stat file");
-		return -1;
-	}
+	if (fd == -1)
+		return perror_fname("Could not open file '%s'", fname);
+	if (fstat(fd, &buf) == -1)
+		return perror_fname("Could not stat file '%s'", fname);
 	*sizep = buf.st_size;
 	debug("File %s is %d bytes\n", fname, *sizep);
 
@@ -686,7 +706,7 @@
  *			0xffffffff so use an address relative to that. For an
  *			8MB ROM the start address is 0xfff80000.
  * @write_fname:	Filename to add to the image
- * @return 0 if OK, -ve on error
+ * @return number of bytes written if OK, -ve on error
  */
 static int write_data(char *image, int size, unsigned int addr,
 		      const char *write_fname)
@@ -698,7 +718,7 @@
 	if (write_fd < 0)
 		return write_fd;
 
-	offset = addr + size;
+	offset = (uint32_t)(addr + size);
 	debug("Writing %s to offset %#x\n", write_fname, offset);
 
 	if (offset < 0 || offset + write_size > size) {
@@ -714,6 +734,68 @@
 
 	close(write_fd);
 
+	return write_size;
+}
+
+/**
+ * write_uboot() - Write U-Boot, device tree and microcode pointer
+ *
+ * This writes U-Boot into a place in the flash, followed by its device tree.
+ * The microcode pointer is written so that U-Boot can find the microcode in
+ * the device tree very early in boot.
+ *
+ * @image:	Pointer to image
+ * @size:	Size of image in bytes
+ * @uboot:	Input file information for u-boot.bin
+ * @fdt:	Input file information for u-boot.dtb
+ * @ucode_ptr:	Address in U-Boot where the microcode pointer should be placed
+ * @return 0 if OK, -ve on error
+ */
+static int write_uboot(char *image, int size, struct input_file *uboot,
+		       struct input_file *fdt, unsigned int ucode_ptr)
+{
+	const void *blob;
+	const char *data;
+	int uboot_size;
+	uint32_t *ptr;
+	int data_size;
+	int offset;
+	int node;
+	int ret;
+
+	uboot_size = write_data(image, size, uboot->addr, uboot->fname);
+	if (uboot_size < 0)
+		return uboot_size;
+	fdt->addr = uboot->addr + uboot_size;
+	debug("U-Boot size %#x, FDT at %#x\n", uboot_size, fdt->addr);
+	ret = write_data(image, size, fdt->addr, fdt->fname);
+	if (ret < 0)
+		return ret;
+
+	if (ucode_ptr) {
+		blob = (void *)image + (uint32_t)(fdt->addr + size);
+		debug("DTB at %lx\n", (char *)blob - image);
+		node = fdt_node_offset_by_compatible(blob, 0,
+						     "intel,microcode");
+		if (node < 0) {
+			debug("No microcode found in FDT: %s\n",
+			      fdt_strerror(node));
+			return -ENOENT;
+		}
+		data = fdt_getprop(blob, node, "data", &data_size);
+		if (!data) {
+			debug("No microcode data found in FDT: %s\n",
+			      fdt_strerror(data_size));
+			return -ENOENT;
+		}
+		offset = ucode_ptr - uboot->addr;
+		ptr = (void *)image + offset;
+		ptr[0] = uboot->addr + (data - image);
+		ptr[1] = data_size;
+		debug("Wrote microcode pointer at %x: addr=%x, size=%x\n",
+		      ucode_ptr, ptr[0], ptr[1]);
+	}
+
 	return 0;
 }
 
@@ -783,8 +865,7 @@
 	char *desc_fname = NULL, *addr_str = NULL;
 	int region_type = -1, inputfreq = 0;
 	enum spi_frequency spifreq = SPI_FREQUENCY_20MHZ;
-	unsigned int addr[WRITE_MAX];
-	char *wr_fname[WRITE_MAX];
+	struct input_file input_file[WRITE_MAX], *ifile, *fdt = NULL;
 	unsigned char wr_idx, wr_num = 0;
 	int rom_size = -1;
 	bool write_it;
@@ -792,6 +873,8 @@
 	char *outfile = NULL;
 	struct stat buf;
 	int size = 0;
+	unsigned int ucode_ptr = 0;
+	bool have_uboot = false;
 	int bios_fd;
 	char *image;
 	int ret;
@@ -801,18 +884,21 @@
 		{"descriptor", 1, NULL, 'D'},
 		{"em100", 0, NULL, 'e'},
 		{"extract", 0, NULL, 'x'},
+		{"fdt", 1, NULL, 'f'},
 		{"inject", 1, NULL, 'i'},
 		{"lock", 0, NULL, 'l'},
+		{"microcode", 1, NULL, 'm'},
 		{"romsize", 1, NULL, 'r'},
 		{"spifreq", 1, NULL, 's'},
 		{"unlock", 0, NULL, 'u'},
+		{"uboot", 1, NULL, 'U'},
 		{"write", 1, NULL, 'w'},
 		{"version", 0, NULL, 'v'},
 		{"help", 0, NULL, 'h'},
 		{0, 0, 0, 0}
 	};
 
-	while ((opt = getopt_long(argc, argv, "cdD:ehi:lr:s:uvw:x?",
+	while ((opt = getopt_long(argc, argv, "cdD:ef:hi:lm:r:s:uU:vw:x?",
 				  long_options, &option_index)) != EOF) {
 		switch (opt) {
 		case 'c':
@@ -855,6 +941,9 @@
 		case 'l':
 			mode_locked = 1;
 			break;
+		case 'm':
+			ucode_ptr = strtoul(optarg, NULL, 0);
+			break;
 		case 'r':
 			rom_size = strtol(optarg, NULL, 0);
 			debug("ROM size %d\n", rom_size);
@@ -888,14 +977,23 @@
 			exit(EXIT_SUCCESS);
 			break;
 		case 'w':
+		case 'U':
+		case 'f':
+			ifile = &input_file[wr_num];
 			mode_write = 1;
 			if (wr_num < WRITE_MAX) {
 				if (get_two_words(optarg, &addr_str,
-						  &wr_fname[wr_num])) {
+						  &ifile->fname)) {
 					print_usage(argv[0]);
 					exit(EXIT_FAILURE);
 				}
-				addr[wr_num] = strtol(optarg, NULL, 0);
+				ifile->addr = strtol(optarg, NULL, 0);
+				ifile->type = opt == 'f' ? IF_fdt :
+					opt == 'U' ? IF_uboot : IF_normal;
+				if (ifile->type == IF_fdt)
+					fdt = ifile;
+				else if (ifile->type == IF_uboot)
+					have_uboot = true;
 				wr_num++;
 			} else {
 				fprintf(stderr,
@@ -952,6 +1050,13 @@
 		exit(EXIT_FAILURE);
 	}
 
+	if (have_uboot && !fdt) {
+		fprintf(stderr,
+			"You must supply a device tree file for U-Boot\n\n");
+		print_usage(argv[0]);
+		exit(EXIT_FAILURE);
+	}
+
 	filename = argv[optind];
 	if (optind + 2 != argc)
 		outfile = argv[optind + 1];
@@ -1015,9 +1120,17 @@
 
 	if (mode_write) {
 		for (wr_idx = 0; wr_idx < wr_num; wr_idx++) {
-			ret = write_data(image, size,
-					 addr[wr_idx], wr_fname[wr_idx]);
-			if (ret)
+			ifile = &input_file[wr_idx];
+			if (ifile->type == IF_fdt) {
+				continue;
+			} else if (ifile->type == IF_uboot) {
+				ret = write_uboot(image, size, ifile, fdt,
+						  ucode_ptr);
+			} else {
+				ret = write_data(image, size, ifile->addr,
+					 ifile->fname);
+			}
+			if (ret < 0)
 				break;
 		}
 	}
@@ -1052,5 +1165,5 @@
 	free(image);
 	close(bios_fd);
 
-	return ret ? 1 : 0;
+	return ret < 0 ? 1 : 0;
 }
diff --git a/tools/microcode-tool b/tools/microcode-tool
new file mode 120000
index 0000000..8be8507
--- /dev/null
+++ b/tools/microcode-tool
@@ -0,0 +1 @@
+microcode-tool.py
\ No newline at end of file
diff --git a/tools/microcode-tool.py b/tools/microcode-tool.py
new file mode 100755
index 0000000..003716d
--- /dev/null
+++ b/tools/microcode-tool.py
@@ -0,0 +1,253 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2014 Google, Inc
+#
+# SPDX-License-Identifier:      GPL-2.0+
+#
+# Intel microcode update tool
+
+from optparse import OptionParser
+import os
+import re
+import struct
+import sys
+
+MICROCODE_DIR = 'arch/x86/dts/microcode'
+
+class Microcode:
+    """Holds information about the microcode for a particular model of CPU.
+
+    Attributes:
+        name:  Name of the CPU this microcode is for, including any version
+                   information (e.g. 'm12206a7_00000029')
+        model: Model code string (this is cpuid(1).eax, e.g. '206a7')
+        words: List of hex words containing the microcode. The first 16 words
+                   are the public header.
+    """
+    def __init__(self, name, data):
+        self.name = name
+        # Convert data into a list of hex words
+        self.words = []
+        for value in ''.join(data).split(','):
+            hexval = value.strip()
+            if hexval:
+                self.words.append(int(hexval, 0))
+
+        # The model is in the 4rd hex word
+        self.model = '%x' % self.words[3]
+
+def ParseFile(fname):
+    """Parse a micrcode.dat file and return the component parts
+
+    Args:
+        fname: Filename to parse
+    Returns:
+        3-Tuple:
+            date:         String containing date from the file's header
+            license_text: List of text lines for the license file
+            microcodes:   List of Microcode objects from the file
+    """
+    re_date = re.compile('/\* *(.* [0-9]{4}) *\*/$')
+    re_license = re.compile('/[^-*+] *(.*)$')
+    re_name = re.compile('/\* *(.*)\.inc *\*/', re.IGNORECASE)
+    microcodes = {}
+    license_text = []
+    date = ''
+    data = []
+    name = None
+    with open(fname) as fd:
+        for line in fd:
+            line = line.rstrip()
+            m_date = re_date.match(line)
+            m_license = re_license.match(line)
+            m_name = re_name.match(line)
+            if m_name:
+                if name:
+                    microcodes[name] = Microcode(name, data)
+                name = m_name.group(1).lower()
+                data = []
+            elif m_license:
+                license_text.append(m_license.group(1))
+            elif m_date:
+                date = m_date.group(1)
+            else:
+                data.append(line)
+    if name:
+        microcodes[name] = Microcode(name, data)
+    return date, license_text, microcodes
+
+def List(date, microcodes, model):
+    """List the available microcode chunks
+
+    Args:
+        date:           Date of the microcode file
+        microcodes:     Dict of Microcode objects indexed by name
+        model:          Model string to search for, or None
+    """
+    print 'Date: %s' % date
+    if model:
+        mcode_list, tried = FindMicrocode(microcodes, model.lower())
+        print 'Matching models %s:' % (', '.join(tried))
+    else:
+        print 'All models:'
+        mcode_list = [microcodes[m] for m in microcodes.keys()]
+    for mcode in mcode_list:
+        print '%-20s: model %s' % (mcode.name, mcode.model)
+
+def FindMicrocode(microcodes, model):
+    """Find all the microcode chunks which match the given model.
+
+    This model is something like 306a9 (the value returned in eax from
+    cpuid(1) when running on Intel CPUs). But we allow a partial match,
+    omitting the last 1 or two characters to allow many families to have the
+    same microcode.
+
+    If the model name is ambiguous we return a list of matches.
+
+    Args:
+        microcodes: Dict of Microcode objects indexed by name
+        model:      String containing model name to find
+    Returns:
+        Tuple:
+            List of matching Microcode objects
+            List of abbreviations we tried
+    """
+    # Allow a full name to be used
+    mcode = microcodes.get(model)
+    if mcode:
+        return [mcode], []
+
+    tried = []
+    found = []
+    for i in range(3):
+        abbrev = model[:-i] if i else model
+        tried.append(abbrev)
+        for mcode in microcodes.values():
+            if mcode.model.startswith(abbrev):
+                found.append(mcode)
+        if found:
+            break
+    return found, tried
+
+def CreateFile(date, license_text, mcode, outfile):
+    """Create a microcode file in U-Boot's .dtsi format
+
+    Args:
+        date:       String containing date of original microcode file
+        license:    List of text lines for the license file
+        mcode:      Microcode object to write
+        outfile:    Filename to write to ('-' for stdout)
+    """
+    out = '''/*%s
+ * ---
+ * This is a device tree fragment. Use #include to add these properties to a
+ * node.
+ *
+ * Date: %s
+ */
+
+compatible = "intel,microcode";
+intel,header-version = <%d>;
+intel,update-revision = <%#x>;
+intel,date-code = <%#x>;
+intel,processor-signature = <%#x>;
+intel,checksum = <%#x>;
+intel,loader-revision = <%d>;
+intel,processor-flags = <%#x>;
+
+/* The first 48-bytes are the public header which repeats the above data */
+data = <%s
+\t>;'''
+    words = ''
+    for i in range(len(mcode.words)):
+        if not (i & 3):
+            words += '\n'
+        val = mcode.words[i]
+        # Change each word so it will be little-endian in the FDT
+        # This data is needed before RAM is available on some platforms so we
+        # cannot do an endianness swap on boot.
+        val = struct.unpack("<I", struct.pack(">I", val))[0]
+        words += '\t%#010x' % val
+
+    # Take care to avoid adding a space before a tab
+    text = ''
+    for line in license_text:
+        if line[0] == '\t':
+            text += '\n *' + line
+        else:
+            text += '\n * ' + line
+    args = [text, date]
+    args += [mcode.words[i] for i in range(7)]
+    args.append(words)
+    if outfile == '-':
+        print out % tuple(args)
+    else:
+        if not outfile:
+            if not os.path.exists(MICROCODE_DIR):
+                print >> sys.stderr, "Creating directory '%s'" % MICROCODE_DIR
+                os.makedirs(MICROCODE_DIR)
+            outfile = os.path.join(MICROCODE_DIR, mcode.name + '.dtsi')
+            print >> sys.stderr, "Writing microcode for '%s' to '%s'" % (
+                     mcode.name, outfile)
+        with open(outfile, 'w') as fd:
+            print >> fd, out % tuple(args)
+
+def MicrocodeTool():
+    """Run the microcode tool"""
+    commands = 'create,license,list'.split(',')
+    parser = OptionParser()
+    parser.add_option('-d', '--mcfile', type='string', action='store',
+                    help='Name of microcode.dat file')
+    parser.add_option('-m', '--model', type='string', action='store',
+                    help='Model name to extract')
+    parser.add_option('-o', '--outfile', type='string', action='store',
+                    help='Filename to use for output (- for stdout), default is'
+                    ' %s/<name>.dtsi' % MICROCODE_DIR)
+    parser.usage += """ command
+
+    Process an Intel microcode file (use -h for help). Commands:
+
+       create     Create microcode .dtsi file for a model
+       list       List available models in microcode file
+       license    Print the license
+
+    Typical usage:
+
+       ./tools/microcode-tool -d microcode.dat -m 306a create
+
+    This will find the appropriate file and write it to %s.""" % MICROCODE_DIR
+
+    (options, args) = parser.parse_args()
+    if not args:
+        parser.error('Please specify a command')
+    cmd = args[0]
+    if cmd not in commands:
+        parser.error("Unknown command '%s'" % cmd)
+
+    if not options.mcfile:
+        parser.error('You must specify a microcode file')
+    date, license_text, microcodes = ParseFile(options.mcfile)
+
+    if cmd == 'list':
+        List(date, microcodes, options.model)
+    elif cmd == 'license':
+        print '\n'.join(license_text)
+    elif cmd == 'create':
+        if not options.model:
+            parser.error('You must specify a model to create')
+        model = options.model.lower()
+        mcode_list, tried = FindMicrocode(microcodes, model)
+        if not mcode_list:
+            parser.error("Unknown model '%s' (%s) - try 'list' to list" %
+                        (model, ', '.join(tried)))
+        if len(mcode_list) > 1:
+            parser.error("Ambiguous model '%s' (%s) matched %s - try 'list' "
+                        "to list or specify a particular file" %
+                        (model, ', '.join(tried),
+                        ', '.join([m.name for m in mcode_list])))
+        CreateFile(date, license_text, mcode_list[0], options.outfile)
+    else:
+        parser.error("Unknown command '%s'" % cmd)
+
+if __name__ == "__main__":
+    MicrocodeTool()