v2/util: romfs -> cbfs rename

It's all sed here. romfs->cbfs, ROMFS->CBFS, romtool->cbfstool

Signed-off-by: Peter Stuge <peter@stuge.se>
Acked-by: Ronald G. Minnich <rminnich@gmail.com>


git-svn-id: svn://svn.coreboot.org/coreboot/trunk@4110 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1

71 files changed, 11845 insertions, 0 deletions

diff --git a/util/cbfstool/EXAMPLE b/util/cbfstool/EXAMPLE
new file mode 100644
index 0000000000..e4e198e355
--- /dev/null
+++ b/util/cbfstool/EXAMPLE
@@ -0,0 +1,8 @@
+ rm coreboot.rom; 
+./cbfstool coreboot.rom create 0x80000 0x10000 /tmp/coreboot.strip
+./cbfstool coreboot.rom add-payload /tmp/filo.elf normal/payload l
+./cbfstool coreboot.rom print
+#./cbfstool coreboot.rom add-stage /tmp/filo.elf normal/payload
+
+./cbfstool coreboot.rom print
+cp coreboot.rom /home/rminnich/qemutest/
diff --git a/util/cbfstool/Makefile b/util/cbfstool/Makefile
new file mode 100644
index 0000000000..71e0d3b7d7
--- /dev/null
+++ b/util/cbfstool/Makefile
@@ -0,0 +1,40 @@
+#
+#
+#
+
+obj ?= $(shell pwd)
+
+COMMANDS=create.o bootblock.o delete.o add.o print.o resize.o
+OBJ=$(COMMANDS) cbfstool.o util.o fs.o
+INC=cbfstool.h cbfs.h
+
+CC=gcc
+CFLAGS=-g -Wall # -W -Werror
+
+DESTDIR ?= /usr/local/bin
+
+all: $(obj)/cbfstool $(obj)/tools/rom-mkpayload $(obj)/tools/rom-mkstage
+
+$(obj)/cbfstool: $(patsubst %,$(obj)/%,$(OBJ))
+	$(CC) -o $@ $(patsubst %,$(obj)/%,$(OBJ))
+
+tobj = $(obj)/tools
+tsrc = $(shell pwd)/tools
+
+include $(tsrc)/Makefile
+
+$(obj)/%.o: %.c $(INC)
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+install: $(obj)/cbfstool $(obj)/tools/rom-mkpayload $(obj)/tools/rom-mkstage
+	@ install -d $(DESTDIR)
+	@ install -m 0755 $(obj)/cbfstool $(DESTDIR)/cbfstool
+	@ install -m 0755 $(obj)/tools/rom-mkstage $(DESTDIR)/rom-mkstage
+	@ install -m 0755 $(obj)/tools/rom-mkpayload $(DESTDIR)/rom-mkpayload
+
+tags: 
+	ctags *.[ch] */*.[ch]
+
+clean: tools-clean
+	rm -f $(patsubst %,$(obj)/%,$(OBJ)) $(obj)/cbfstool
+
diff --git a/util/cbfstool/README b/util/cbfstool/README
new file mode 100644
index 0000000000..9c8e818721
--- /dev/null
+++ b/util/cbfstool/README
@@ -0,0 +1,358 @@
+Coreboot CBFS Specification
+Jordan Crouse <jordan@cosmicpenguin.net>
+
+= Introduction =
+
+This document describes the coreboot CBFS specification (from here referred 
+to as CBFS).  CBFS is a scheme for managing independent chunks of data in
+a system ROM.  Though not a true filesystem, the style and concepts are
+similar.
+
+= Architecture =
+
+The CBFS architecture looks like the following:
+
+/---------------\ <-- Start of ROM
+| /-----------\ | --|
+| | Header    | |   |
+| |-----------| |   |
+| | Name      | |   |-- Component
+| |-----------| |   |
+| |Data       | |   |
+| |..         | |   |
+| \-----------/ | --|
+|               |
+| /-----------\ |
+| | Header    | |
+| |-----------| |
+| | Name      | |
+| |-----------| |
+| |Data       | |
+| |..         | |
+| \-----------/ |
+|               |
+| ...           |
+| /-----------\ |
+| |           | |
+| | Bootblock | |
+| | --------- | |
+| | Reset     | | <- 0xFFFFFFF0
+| \-----------/ | 
+\---------------/ 
+
+
+The CBFS architecture consists of a binary associated with a physical
+ROM disk referred hereafter as the ROM. A number of independent of
+components, each with a  header prepended on to data are located within
+the ROM.  The components are nominally arranged sequentially, though they
+are aligned along a pre-defined boundary.
+
+The bootblock occupies the last 20k of the ROM.  Within
+the bootblock is a master header containing information about the ROM
+including the size, alignment of the components, and the offset of the
+start of the first CBFS component within the ROM.
+
+= Master Header =
+
+The master header contains essential information about the ROM that is
+used by both the CBFS implementation within coreboot at runtime as well
+as host based utilities to create and manage the ROM.  The master header
+will be located somewhere within the bootblock (high end of the ROM).  A
+pointer to the location of the header will be located at offset
+-4 from the end of the ROM.  This translates to address 0xFFFFFFFC on a
+normal x86 system.  The pointer will be to physical memory somewhere
+between - 0xFFFF0000 and 0xFFFFFFF0.  This makes it easier for coreboot
+to locate the header at run time.  Build time utilities will
+need to read the pointer and do the appropriate math to locate the header.
+
+The following is the structure of the master header:
+
+struct cbfs_header {
+	unsigned int magic;
+	unsigned int version; 
+	unsigned int romsize;
+	unsigned int bootblocksize;
+	unsigned int align;
+	unsigned int offset;
+	unsigned int pad[2];
+};
+
+The meaning of each member is as follows:
+
+'magic' is a 32 bit number that identifies the ROM as a CBFS type.  The magic
+number is 0x4F524243, which is 'ORBC' in ASCII. 
+
+'version' is a 32 bit number that identifies the version of CBFS. The current
+version is 0x31313131 ('1111' in ASCII) which is endian-independent. 
+
+'romsize' is the size of the ROM in bytes.  Coreboot will subtract 'size' from
+0xFFFFFFFF to locate the beginning of the ROM in memory.  
+
+'bootblocksize' is the boot block size in bytes. There is no limitation on 
+the boot block size as in v3. 
+
+'align' is the number of bytes that each component is aligned to within the
+ROM.  This is used to make sure that each component is aligned correctly with
+regards to the erase block sizes on the ROM - allowing one to replace a
+component at runtime without disturbing the others.
+
+'offset' is the offset of the the first CBFS component (from the start of
+the ROM).  This is to allow for arbitrary space to be left at the beginning
+of the ROM for things like embedded controller firmware.
+
+'pad' rounds the header to 32 bits and reserves a little room for later use. 
+
+= Bootblock =
+The bootblock is a mandatory component in the ROM.  It is located in the
+last bootblocksize bytes of ROM space, and contains, among other things,
+the location of the master header and the entry point for the loader
+firmware.  The bootblock does not have a component header attached to it.
+
+
+= Components =
+
+CBFS components are placed in the ROM starting at 'offset' specified in
+the master header and ending at the bootblock.  Thus the total size available
+for components in the ROM is (ROM size - bootblocksize - 'offset').  Each CBFS
+component is to be aligned according to the 'align' value in the header.
+Thus, if a component of size 1052 is located at offset 0 with an 'align' value
+of 1024, the next component will be located at offset 2048.
+
+Each CBFS component will be indexed with a unique ASCII string name of
+unlimited size. 
+
+Each CBFS component starts with a header:
+
+struct CBFS_file {
+        char magic[8];
+        unsigned int len;
+        unsigned int type;
+        unsigned int checksum;
+        unsigned int offset;
+};
+
+'magic' is a magic value used to identify the header.  During runtime,
+coreboot will scan the ROM looking for this value.  The default magic is
+the string 'LARCHIVE'.
+
+'len' is the length of the data, not including the size of the header and
+the size of the name.
+
+'type' is a 32 bit number indicating the type of data that is attached.
+The data type is used in a number of ways, as detailed in the section
+below.
+
+'checksum' is a 32bit checksum of the entire component, including the
+header and name.
+
+'offset' is the start of the component data, based off the start of the header.
+The difference between the size of the header and offset is the size of the
+component name. 
+
+Immediately following the header will be the name of the component, which will
+null terminated and 16 byte aligned.   The following picture shows the 
+structure of the header:
+
+/--------\  <- start
+| Header |
+|--------|  <- sizeof(struct cbfs_file)
+| Name   |
+|--------|  <- 'offset'
+| Data   |
+| ...    |
+\--------/  <- start + 'offset' + 'len' 
+
+== Searching Alogrithm ==
+
+To locate a specific component in the ROM, one starts at the 'offset'
+specified in the CBFS master header.  For this example, the offset will
+be 0.  
+
+From that offset, the code should search for the magic string on the
+component, jumping 'align' bytes each time.  So, assuming that 'align' is
+16, the code will search for the string 'LARCHIVE' at offset 0, 16, 32, etc.
+If the offset ever exceeds the allowable range for CBFS components, then no
+component was found.
+
+Upon recognizing a component, the software then has to search for the
+specific name of the component.  This is accomplished by comparing the
+desired name with the string on the component located at
+offset + sizeof(struct cbfs_file).  If the string matches, then the component
+has been located, otherwise the software should add 'offset' + 'len' to
+the offset and resume the search for the magic value.
+
+== Data Types ==
+
+The 'type' member of struct cbfs_file is used to identify the content
+of the component data, and is used by coreboot and other
+run-time entities to make decisions about how to handle the data.
+
+There are three component types that are essential to coreboot, and so
+are defined here.
+
+=== Stages ===
+
+Stages are code loaded by coreboot during the boot process.  They are
+essential to a successful boot.   Stages are comprised of a single blob
+of binary data that is to be loaded into a particular location in memory
+and executed.   The uncompressed header contains information about how
+large the data is, and where it should be placed, and what additional memory
+needs to be cleared.
+
+Stages are assigned a component value of 0x10.  When coreboot sees this
+component type, it knows that it should pass the data to a sub-function
+that will process the stage.
+
+The following is the format of a stage component:
+
+/--------\
+| Header |
+|--------|
+| Binary |
+| ..     |
+\--------/
+
+The header is defined as:
+
+struct cbfs_stage {
+        unsigned int compression;
+        unsigned long long entry;
+        unsigned long long load;
+        unsigned int len;
+        unsigned int memlen;
+};
+
+'compression' is an integer defining how the data is compressed.  There
+are three compression types defined by this version of the standard:
+none (0x0), lzma (0x1), and nrv2b (0x02), though additional types may be
+added assuming that coreboot understands how to handle the scheme.
+
+'entry' is a 64 bit value indicating the location where  the program
+counter should jump following the loading of the stage.  This should be
+an absolute physical memory address.
+
+'load' is a 64 bit value indicating where the subsequent data should be
+loaded.  This should be an absolute physical memory address.
+
+'len' is the length of the compressed data in the component.
+
+'memlen' is the amount of memory that will be used by the component when
+it is loaded.
+
+The component data will start immediately following the header.
+
+When coreboot loads a stage, it will first zero the memory from 'load' to
+'memlen'.  It will then decompress the component data according to the
+specified scheme and place it in memory starting at 'load'.  Following that,
+it will jump execution to the address specified by 'entry'.
+Some components are designed to execute directly from the ROM - coreboot
+knows which components must do that and will act accordingly.
+
+=== Payloads ===
+
+Payloads are loaded by coreboot following the boot process.
+
+Stages are assigned a component value of 0x20.  When coreboot sees this
+component type, it knows that it should pass the data to a sub-function
+that will process the payload.  Furthermore, other run time 
+applications such as 'bayou' may easily index all available payloads
+on the system by searching for the payload type.
+
+
+The following is the format of a stage component:
+
+/-----------\
+| Header    |
+| Segment 1 |
+| Segment 2 |
+| ...       |
+|-----------|
+| Binary    |
+| ..        |
+\-----------/
+
+The header is as follows:
+
+struct cbfs_payload {
+        struct cbfs_payload_segment segments;
+}
+
+The header contains a number of segments corresponding to the segments
+that need to be loaded for the payload.
+
+The following is the structure of each segment header:
+
+struct cbfs_payload_segment {
+        unsigned int type;
+        unsigned int compression;
+        unsigned int offset;
+        unsigned long long load_addr;
+        unsigned int len;
+        unsigned int mem_len;
+};
+
+'type' is the type of segment, one of the following:
+
+PAYLOAD_SEGMENT_CODE   0x45444F43   The segment contains executable code
+PAYLOAD_SEGMENT_DATA   0x41544144   The segment contains data
+PAYLOAD_SEGMENT_BSS    0x20535342   The memory speicfied by the segment 
+                                    should be zeroed
+PAYLOAD_SEGMENT_PARAMS 0x41524150   The segment contains information for
+                                    the payload
+PAYLOAD_SEGMENT_ENTRY  0x52544E45   The segment contains the entry point
+		       		    for the payload
+
+'compression' is the compression scheme for the segment.  Each segment can
+be independently compressed. There are three compression types defined by
+this version of the standard: none (0x0), lzma (0x1), and nrv2b (0x02),
+though additional types may be added assuming that coreboot understands
+how to handle the scheme.
+
+'offset' is the address of the data within the component, starting from
+the component header.
+
+'load_addr' is a 64 bit value indicating where the segment should be placed
+in memory.
+
+'len' is a 32 bit value indicating the size of the segment within the
+component.
+
+'mem_len' is the size of the data when it is placed into memory.
+
+The data will located immediately following the last segment.
+
+=== Option ROMS ===
+
+The third specified component type will be Option ROMs.  Option ROMS will 
+have component type '0x30'.  They will have no additional header, the 
+uncompressed binary data will be located in the data portion of the 
+component.
+
+=== NULL ===
+
+There is a 4th component type ,defined as NULL (0xFFFFFFFF).  This is
+the "don't care" component type.  This can be used when the component
+type is not necessary (such as when the name of the component is unique.
+i.e. option_table).  It is recommended that all components be assigned a
+unique type, but NULL can be used when the type does not matter.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/util/cbfstool/TODO b/util/cbfstool/TODO
new file mode 100644
index 0000000000..0f8ed2718f
--- /dev/null
+++ b/util/cbfstool/TODO
@@ -0,0 +1,4 @@
+Add interactive mode
+Add script mode (./cbfstool [ROM] -s script)
+Support compression for stages and payloads
+Add nrv2b
diff --git a/util/cbfstool/add.c b/util/cbfstool/add.c
new file mode 100644
index 0000000000..642d8ce519
--- /dev/null
+++ b/util/cbfstool/add.c
@@ -0,0 +1,327 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include "cbfstool.h"
+
+#define MAX_PATH 255
+
+static int add_from_fd(struct rom *rom, const char *name, int type, int fd)
+{
+	unsigned char *buffer = malloc(16 * 1024);
+	unsigned char *ptr = buffer;
+
+	int size = 0;
+	int aloc = 16 * 1024;
+	int remain = 16 * 1024;
+	int ret;
+
+	if (buffer == NULL)
+		return -1;
+
+	while (1) {
+		ret = read(fd, ptr, remain);
+
+		if (ret <= 0)
+			break;
+
+		ptr += ret;
+		remain -= ret;
+		size += ret;
+
+		if (remain == 0) {
+			buffer = realloc(buffer, aloc + 16 * 1024);
+
+			if (buffer == NULL) {
+				ret = -1;
+				break;
+			}
+
+			ptr = buffer + size;
+
+			aloc += (16 * 1024);
+			remain = 16 * 1024;
+		}
+	}
+
+	if (ret == -1 || size == 0) {
+
+		if (buffer != NULL)
+			free(buffer);
+
+		return -1;
+	}
+
+	ret = rom_add(rom, name, buffer, size, type);
+	free(buffer);
+
+	return ret;
+}
+
+int fork_tool_and_add(struct rom *rom, const char *tool, const char *input,
+		      const char *name, int type, int argc, char **argv)
+{
+	int output[2];
+	pid_t pid;
+	int ret;
+	int status;
+	char **toolargs;
+	int i;
+
+	/* Create the pipe */
+
+	if (pipe(output)) {
+		ERROR("Couldn't create a pipe: %m\n");
+		return -1;
+	}
+
+	toolargs = (char **)malloc((5 + argc) * sizeof(char *));
+
+	if (toolargs == NULL) {
+		ERROR("Unable to allocate memory: %m\n");
+		return -1;
+	}
+
+	toolargs[0] = (char *)tool;
+
+	/* these are args. So they need a - in front */
+	for (i = 0; i < argc; i++) {
+		/* I wish I had python */
+		char *c = malloc(strlen(argv[i])) + 2;
+		c[0] = '-';
+		strcpy(&c[1], argv[i]);
+		c[strlen(argv[i])+1] = 0;
+		toolargs[1 + i] = c;
+	}
+
+	toolargs[1 + argc] = "-o";
+	toolargs[2 + argc] = "-";
+	toolargs[3 + argc] = (char *)input;
+	toolargs[4 + argc] = NULL;
+
+	pid = fork();
+
+	if (pid == 0) {
+
+		/* Set up stdin/stdout for the child */
+
+		dup2(output[1], STDOUT_FILENO);
+		close(output[0]);
+
+		/* Execute the tool */
+		if (execv(tool, toolargs)) {
+			ERROR("Unable to execute %s: %m\n", tool);
+			exit(-1);
+		}
+
+		exit(0);
+	}
+
+	free(toolargs);
+
+	close(output[1]);
+
+	/* Read from the file */
+	ret = add_from_fd(rom, name, type, output[0]);
+
+	/* Reap the child */
+	waitpid(pid, &status, 0);
+
+	if (WIFSIGNALED(status)) {
+		kill(pid, WTERMSIG(status));
+		ERROR("Error while executing %s\n", tool);
+		return -1;
+	} else if (WEXITSTATUS(status) != 0) {
+		ERROR("Error while executing %s: %d\n", tool,
+		      (int)WEXITSTATUS(status));
+		return -1;
+	}
+
+	return ret;
+}
+
+static int add_blob(struct rom *rom, const char *filename,
+		    const char *name, int type)
+{
+	void *ptr;
+	struct stat s;
+	int fd, ret;
+
+	if (!strcmp(filename, "-"))
+		return add_from_fd(rom, name, type, 0);
+
+	fd = open(filename, O_RDONLY);
+
+	if (fd == -1) {
+		ERROR("Could not open %s: %m\n", filename);
+		return -1;
+	}
+
+	if (fstat(fd, &s)) {
+		ERROR("Could not stat %s: %m\n", filename);
+		close(fd);
+		return -1;
+	}
+
+	ptr = mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0);
+
+	if (ptr == MAP_FAILED) {
+		ERROR("Unable to map %s: %m\n", filename);
+		close(fd);
+		return -1;
+	}
+
+	ret = rom_add(rom, name, ptr, s.st_size, type);
+
+	munmap(ptr, s.st_size);
+	close(fd);
+
+	return ret;
+}
+
+void add_usage(void)
+{
+	printf("add [FILE] [NAME] [TYPE]\tAdd a component\n");
+}
+
+void add_stage_usage(void)
+{
+	printf("add-stage [FILE] [NAME] [OPTIONS]\tAdd a stage to the ROM\n");
+}
+
+void add_payload_usage(void)
+{
+	printf
+	    ("add-payload [FILE] [NAME] [OPTIONS]\tAdd a payload to the ROM\n");
+}
+
+int add_handler(struct rom *rom, int argc, char **argv)
+{
+	unsigned int type = CBFS_COMPONENT_NULL;
+
+	if (argc < 2) {
+		add_usage();
+		return -1;
+	}
+
+	if (!rom_exists(rom)) {
+		ERROR("You need to create the ROM before adding files to it\n");
+		return -1;
+	}
+
+	/* There are two ways to specify the type - a string or a number */
+
+	if (argc == 3) {
+		if (isdigit(*(argv[2])))
+			type = strtoul(argv[2], 0, 0);
+	}
+
+	if (type == CBFS_COMPONENT_NULL)
+		WARN("No file type was given for %s - using default\n",
+		     argv[0]);
+
+	return add_blob(rom, argv[0], argv[1], type);
+}
+
+char *find_tool(char *tool)
+{
+	static char toolpath[MAX_PATH];
+	extern char cbfstool_bindir[];
+
+	snprintf(toolpath, MAX_PATH - 1, "tools/%s", tool);
+	if (!access(toolpath, X_OK))
+		return toolpath;
+
+	snprintf(toolpath, MAX_PATH - 1, "%s/tools/%s", cbfstool_bindir, tool);
+
+	if (!access(toolpath, X_OK))
+		return toolpath;
+
+	snprintf(toolpath, MAX_PATH - 1, "%s/%s", cbfstool_bindir, tool);
+
+	if (!access(toolpath, X_OK))
+		return toolpath;
+
+	strncpy(toolpath, tool, MAX_PATH - 1);
+	return toolpath;
+}
+
+/* Invoke the rom-mkpayload utility */
+
+int add_payload_handler(struct rom *rom, int argc, char **argv)
+{
+	if (argc < 2) {
+		add_payload_usage();
+		return -1;
+	}
+
+	/* Make sure the ROM exists */
+
+	if (!rom_exists(rom)) {
+		ERROR("You need to create the ROM before adding files to it\n");
+		return -1;
+	}
+
+	/* Check that the incoming file exists */
+
+	if (access(argv[0], R_OK)) {
+		ERROR("File %s does not exist\n", argv[0]);
+		return -1;
+	}
+
+	return fork_tool_and_add(rom, find_tool("rom-mkpayload"), argv[0],
+				 argv[1], CBFS_COMPONENT_PAYLOAD, argc - 2,
+				 argc > 2 ? &argv[2] : NULL);
+}
+
+/* Invoke the rom-mkstage utility */
+
+int add_stage_handler(struct rom *rom, int argc, char **argv)
+{
+	if (argc < 2) {
+		add_stage_usage();
+		return -1;
+	}
+
+	/* Make sure the ROM exists */
+
+	if (!rom_exists(rom)) {
+		ERROR("You need to create the ROM before adding files to it\n");
+		return -1;
+	}
+
+	/* Check that the incoming file exists */
+
+	if (access(argv[0], R_OK)) {
+		ERROR("File %s does not exist\n", argv[0]);
+		return -1;
+	}
+
+	return fork_tool_and_add(rom, find_tool("rom-mkstage"), argv[0],
+				 argv[1], CBFS_COMPONENT_STAGE, argc - 2,
+				 argc > 2 ? &argv[2] : NULL);
+}
diff --git a/util/cbfstool/bootblock.c b/util/cbfstool/bootblock.c
new file mode 100644
index 0000000000..11f362c1d2
--- /dev/null
+++ b/util/cbfstool/bootblock.c
@@ -0,0 +1,38 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "cbfstool.h"
+
+void bootblock_usage(void)
+{
+	printf("bootblock [FILE]\t\tAdd a bootblock to the ROM\n");
+}
+
+int bootblock_handler(struct rom *rom, int argc, char **argv)
+{
+	if (argc < 1) {
+		bootblock_usage();
+		return -1;
+	}
+
+	return add_bootblock(rom, argv[0]);
+}
diff --git a/util/cbfstool/cbfs.h b/util/cbfstool/cbfs.h
new file mode 100644
index 0000000000..95159ebaa8
--- /dev/null
+++ b/util/cbfstool/cbfs.h
@@ -0,0 +1,129 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef _CBFS_H_
+#define _CBFS_H_
+
+/** These are standard values for the known compression
+    alogrithms that coreboot knows about for stages and
+    payloads.  Of course, other LAR users can use whatever
+    values they want, as long as they understand them. */
+
+#define CBFS_COMPRESS_NONE  0
+#define CBFS_COMPRESS_LZMA  1
+#define CBFS_COMPRESS_NRV2B 2
+
+/** These are standard component types for well known
+    components (i.e - those that coreboot needs to consume.
+    Users are welcome to use any other value for their
+    components */
+
+#define CBFS_COMPONENT_STAGE     0x10
+#define CBFS_COMPONENT_PAYLOAD   0x20
+#define CBFS_COMPONENT_OPTIONROM 0x30
+
+#define CBFS_COMPONENT_NULL 0xFFFFFFFF
+
+/** this is the master cbfs header - it need to be
+    located somewhere in the bootblock.  Where it
+    actually lives is up to coreboot. A pointer to
+    this header will live at 0xFFFFFFF4, so we can
+    easily find it. */
+
+#define HEADER_MAGIC 0x4F524243
+
+/* this is a version that gives the right answer in any endian-ness */
+#define VERSION1 0x31313131
+
+struct cbfs_header {
+	unsigned int magic;
+	unsigned int version; 
+	unsigned int romsize;
+	unsigned int bootblocksize;
+	unsigned int align;
+	unsigned int offset;
+	unsigned int pad[2];
+} __attribute__ ((packed));
+
+/** This is a component header - every entry in the CBFS
+    will have this header.
+
+    This is how the component is arranged in the ROM:
+
+    --------------   <- 0
+    component header 
+    --------------   <- sizeof(struct component)
+    component name
+    --------------   <- offset
+    data
+    ...
+    --------------   <- offset + len
+*/
+
+#define COMPONENT_MAGIC "LARCHIVE"
+
+struct cbfs_file {
+	char magic[8];
+	unsigned int len;
+	unsigned int type;
+	unsigned int checksum;
+	unsigned int offset;
+} __attribute__ ((packed));
+
+/*** Component sub-headers ***/
+
+/* Following are component sub-headers for the "standard"
+   component types */
+
+/** This is the sub-header for stage components.  Stages are
+    loaded by coreboot during the normal boot process */
+
+struct cbfs_stage {
+	unsigned int compression;  /** Compression type */
+	unsigned long long entry;  /** entry point */
+	unsigned long long load;   /** Where to load in memory */
+	unsigned int len;	   /** length of data to load */
+	unsigned int memlen;	   /** total length of object in memory */
+} __attribute__ ((packed));
+
+/** this is the sub-header for payload components.  Payloads
+    are loaded by coreboot at the end of the boot process */
+
+struct cbfs_payload_segment {
+	unsigned int type;
+	unsigned int compression;
+	unsigned int offset;
+	unsigned long long load_addr;
+	unsigned int len;
+	unsigned int mem_len;
+} __attribute__ ((packed));
+
+struct cbfs_payload {
+	struct cbfs_payload_segment segments;
+};
+
+#define PAYLOAD_SEGMENT_CODE   0x45444F43
+#define PAYLOAD_SEGMENT_DATA   0x41544144
+#define PAYLOAD_SEGMENT_BSS    0x20535342
+#define PAYLOAD_SEGMENT_PARAMS 0x41524150
+#define PAYLOAD_SEGMENT_ENTRY  0x52544E45
+
+#define CBFS_NAME(_c) (((unsigned char *) (_c)) + sizeof(struct cbfs_file))
+
+#endif
diff --git a/util/cbfstool/cbfstool.c b/util/cbfstool/cbfstool.c
new file mode 100644
index 0000000000..b9915e3fac
--- /dev/null
+++ b/util/cbfstool/cbfstool.c
@@ -0,0 +1,157 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+/* v2 compat: First, assumes a 64K bootblock. 
+ * cbfstool coreboot.rom create 0x80000 coreboot.strip 
+ * cbfstool coreboot.rom add-payload /tmp/filo.elf payload 
+ * cbfstool coreboot.rom print
+ */
+
+
+#include <string.h>
+#include <unistd.h>
+#include <libgen.h>
+#include <sys/mman.h>
+#include "cbfstool.h"
+
+extern int create_handler(struct rom *, int, char **);
+extern int bootblock_handler(struct rom *, int, char **);
+extern int print_handler(struct rom *, int, char **);
+extern int add_handler(struct rom *, int, char **);
+extern int delete_handler(struct rom *, int, char **);
+extern int resize_handler(struct rom *, int, char **);
+extern int add_payload_handler(struct rom *, int, char **);
+extern int add_stage_handler(struct rom *, int, char **);
+
+extern void create_usage(void);
+extern void bootblock_usage(void);
+extern void print_usage(void);
+extern void add_usage(void);
+extern void delete_usage(void);
+extern void resize_usage(void);
+extern void add_payload_usage(void);
+extern void add_stage_usage(void);
+
+struct {
+	char *command;
+	int (*handler) (struct rom *, int, char **);
+	void (*help) (void);
+} commands[] = {
+	{
+	"add", add_handler, add_usage}, {
+	"add-payload", add_payload_handler, add_payload_usage}, {
+	"add-stage", add_stage_handler, add_stage_usage}, {
+	"bootblock", bootblock_handler, bootblock_usage}, {
+	"create", create_handler, create_usage}, {
+	"delete", delete_handler, delete_usage}, {
+	"print", print_handler, print_usage}, {
+	"resize", resize_handler, resize_usage}, {
+"", NULL},};
+
+static struct rom rom;
+
+char cbfstool_bindir[255];
+
+void show_help(void)
+{
+	int i;
+
+	printf("cbfstool [OPTION] [[FILE] [COMMAND] [PARAMETERS]...\n");
+	printf("Apply COMMANDS with PARAMETERS to FILE.  If no COMMAND is\n");
+	printf("given, run in interactive mode\n\n");
+	printf("OPTIONs:\n");
+	printf(" -h\t\tDisplay this help message\n");
+	printf(" -C <dir>\tChange to the directory before operating\n\n");
+	printf("COMMANDs:\n");
+
+	for (i = 0; commands[i].handler != NULL; i++)
+		commands[i].help();
+}
+
+int main(int argc, char **argv)
+{
+	char *cdir = NULL;
+	char *rname;
+	char *cmd;
+	int ret = -1, i;
+
+	strncpy(cbfstool_bindir, dirname(argv[0]), 254);
+
+	while (1) {
+		signed ch = getopt(argc, argv, "hC:");
+		if (ch == -1)
+			break;
+		switch (ch) {
+		case 'h':
+			show_help();
+			return -1;
+		case 'C':
+			cdir = optarg;
+			break;
+		}
+	}
+
+	if (optind >= argc) {
+		show_help();
+		return -1;
+	}
+
+	if (cdir != NULL && chdir(cdir)) {
+		ERROR("Unable to switch to %s: %m\n", cdir);
+		return -1;
+	}
+
+	rname = argv[optind];
+	cmd = optind + 1 < argc ? argv[optind + 1] : NULL;
+
+	/* Open the ROM (if it exists) */
+	rom.name = (unsigned char *)strdup(rname);
+
+	if (!access(rname, F_OK)) {
+		if (open_rom(&rom, rname)) {
+			ERROR("Problem while reading the ROM\n");
+			return -1;
+		}
+	}
+
+	if (cmd) {
+		/* Process the incoming comand */
+
+		for (i = 0; commands[i].handler != NULL; i++) {
+			if (!strcmp(commands[i].command, cmd)) {
+				ret = commands[i].handler(&rom,
+							  argc - 3, &argv[3]);
+				goto leave;
+			}
+		}
+
+		ERROR("Command %s not valid\n", cmd);
+	} else {
+		printf("Interactive mode not ready yet!\n");
+	}
+
+leave:
+	if (rom.ptr != NULL && rom.ptr != MAP_FAILED)
+		munmap(rom.ptr, rom.size);
+
+	if (rom.fd > 0)
+		close(rom.fd);
+
+	return ret;
+}
diff --git a/util/cbfstool/cbfstool.h b/util/cbfstool/cbfstool.h
new file mode 100644
index 0000000000..43abb6cb17
--- /dev/null
+++ b/util/cbfstool/cbfstool.h
@@ -0,0 +1,77 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef _ROMTOOL_H_
+#define _ROMTOOL_H_
+
+#include <stdio.h>
+#include <arpa/inet.h>
+#include "cbfs.h"
+
+/* Definitions */
+
+/* Structures */
+
+struct rom {
+	unsigned char *name;
+	unsigned char *ptr;
+
+	int fd;
+	int size;
+	int fssize;
+
+	struct cbfs_header *header;
+};
+
+/* Macros */
+
+#define ROM_OFFSET(_r, _c) ((unsigned int) ((unsigned char *) (_c) - (_r)->ptr))
+
+#define ROM_PTR(_r, _o) ((_r)->ptr + (_o))
+#define ROM_WRITEL(_r, _o, _v) do { *((unsigned int *) ROM_PTR((_r), (_o))) = (_v); } while(0)
+#define ROM_READL(_r, _o) *((unsigned int *) (ROM_PTR((_r), (_o))))
+
+#define ERROR(err, args...) fprintf(stderr, "(cbfstool) E: " err, ##args)
+#define WARN(err, args...) fprintf(stderr, "(cbfstool) W: " err, ##args)
+#define VERBOSE(str, args...) printf(str, ##args)
+
+#define ALIGN(_v, _a) ( ( (_v) + ( (_a) - 1 ) ) & ~( (_a) - 1 ) )
+
+/* Function prototypes */
+
+/* util.c */
+int open_rom(struct rom *rom, const char *filename);
+int create_rom(struct rom *rom, const unsigned char *filename, int size,
+	int bootblocksize,  int align);
+int size_and_open(const char *filename, unsigned int *size);
+int copy_from_fd(int fd, void *ptr, int size);
+int get_size(const char *size);
+int add_bootblock(struct rom *rom, const char *filename);
+
+/* fs.c */
+
+struct cbfs_file *rom_find(struct rom *rom, unsigned int offset);
+struct cbfs_file *rom_find_first(struct rom *);
+struct cbfs_file *rom_find_next(struct rom *, struct cbfs_file *);
+int rom_add(struct rom *rom, const char *name, void *, int size, int type);
+int rom_remove(struct rom *rom, const char *name);
+unsigned int rom_used_space(struct rom *rom);
+int rom_exists(struct rom *rom);
+
+#endif
diff --git a/util/cbfstool/create.c b/util/cbfstool/create.c
new file mode 100644
index 0000000000..23e7850952
--- /dev/null
+++ b/util/cbfstool/create.c
@@ -0,0 +1,69 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "cbfstool.h"
+
+void create_usage(void)
+{
+	printf("create SIZE BOOTBLOCKSIZE [ALIGN] [BOOTBLOCK]\tCreate a ROM file\n");
+}
+
+int create_handler(struct rom *rom, int argc, char **argv)
+{
+	int align = 16, size;
+	char *bootblock = NULL;
+	int bootblocksize;
+
+	if (argc < 2) {
+		create_usage();
+		return -1;
+	}
+
+	size = get_size(argv[0]);
+
+	bootblocksize = get_size(argv[1]);
+
+	if (argc == 3) {
+		bootblock = argv[2];
+	} else if (argc >= 4) {
+		align = strtoul(argv[2], NULL, 0);
+		bootblock = argv[3];
+	}
+
+	if (size < bootblocksize) {
+		ERROR("Cannot create a rom %d smaller then bootblock size %d\n", size, bootblocksize);
+		return -1;
+	}
+
+	if (align == 0) {
+		ERROR("Cannot create with an align size of 0\n");
+		return -1;
+	}
+
+	if (create_rom(rom, rom->name, size, bootblocksize, align))
+		return -1;
+
+	if (bootblock != NULL)
+		return add_bootblock(rom, bootblock);
+
+	return 0;
+}
diff --git a/util/cbfstool/delete.c b/util/cbfstool/delete.c
new file mode 100644
index 0000000000..5185e83060
--- /dev/null
+++ b/util/cbfstool/delete.c
@@ -0,0 +1,44 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "cbfstool.h"
+
+void delete_usage(void)
+{
+	printf("delete [NAME] ...\t\tDelete a component\n");
+}
+
+int delete_handler(struct rom *rom, int argc, char **argv)
+{
+	int i;
+	int ret = 0;
+
+	if (argc < 1) {
+		delete_usage();
+		return -1;
+	}
+
+	for (i = 0; i < argc; i++)
+		ret |= rom_remove(rom, argv[i]);
+
+	return ret;
+}
diff --git a/util/cbfstool/fs.c b/util/cbfstool/fs.c
new file mode 100644
index 0000000000..c5e9892a8e
--- /dev/null
+++ b/util/cbfstool/fs.c
@@ -0,0 +1,168 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+#include "cbfstool.h"
+
+struct cbfs_file *rom_find(struct rom *rom, unsigned int offset)
+{
+	while (offset < rom->fssize) {
+		struct cbfs_file *c =
+		    (struct cbfs_file *)ROM_PTR(rom, offset);
+
+		if (!strcmp(c->magic, COMPONENT_MAGIC))
+			return c;
+
+		offset += ntohl(rom->header->align);
+	}
+
+	return NULL;
+}
+
+struct cbfs_file *rom_find_first(struct rom *rom)
+{
+	return rom_find(rom, ntohl(rom->header->offset));
+}
+
+struct cbfs_file *rom_find_next(struct rom *rom, struct cbfs_file *prev)
+{
+	unsigned int offset = ROM_OFFSET(rom, prev);
+
+	return rom_find(rom, offset +
+			ALIGN(ntohl(prev->offset) + ntohl(prev->len),
+			      ntohl(rom->header->align)));
+}
+
+struct cbfs_file *rom_find_empty(struct rom *rom)
+{
+	unsigned int offset = ntohl(rom->header->offset);
+	unsigned int ret = ntohl(rom->header->offset);
+
+	while (offset < rom->fssize) {
+
+		struct cbfs_file *c =
+		    (struct cbfs_file *)ROM_PTR(rom, offset);
+
+		if (!strcmp(c->magic, COMPONENT_MAGIC)) {
+			offset += ALIGN(ntohl(c->offset) + ntohl(c->len),
+					ntohl(rom->header->align));
+
+			ret = offset;
+		} else
+			offset += ntohl(rom->header->align);
+	}
+
+	return (ret < rom->fssize) ?
+	    (struct cbfs_file *)ROM_PTR(rom, ret) : NULL;
+}
+
+struct cbfs_file *rom_find_by_name(struct rom *rom, const char *name)
+{
+	struct cbfs_file *c = rom_find_first(rom);
+
+	while (c) {
+		if (!strcmp((char *)CBFS_NAME(c), name))
+			return c;
+
+		c = rom_find_next(rom, c);
+	}
+
+	return NULL;
+}
+
+unsigned int rom_used_space(struct rom *rom)
+{
+	struct cbfs_file *c = rom_find_first(rom);
+	unsigned int ret = 0;
+
+	while (c) {
+		ret = ROM_OFFSET(rom, c) + ntohl(c->offset) + ntohl(c->len);
+		c = rom_find_next(rom, c);
+	}
+
+	return ret;
+}
+
+int rom_remove(struct rom *rom, const char *name)
+{
+	struct cbfs_file *c = rom_find_by_name(rom, name);
+	struct cbfs_file *n;
+	int clear;
+
+	if (c == NULL) {
+		ERROR("Component %s does not exist\n", name);
+		return -1;
+	}
+
+	/* Get the next component - and copy it into the current
+	   space */
+
+	n = rom_find_next(rom, c);
+
+	memcpy(c, n, rom->fssize - ROM_OFFSET(rom, n));
+
+	clear = ROM_OFFSET(rom, n) - ROM_OFFSET(rom, c);
+
+	/* Zero the new space */
+	memset(ROM_PTR(rom, rom->fssize - clear), 0, clear);
+	return 0;
+}
+
+int rom_add(struct rom *rom, const char *name, void *buffer, int size, int type)
+{
+	struct cbfs_file *c = rom_find_empty(rom);
+	unsigned int offset;
+	unsigned int csize;
+
+	if (rom_find_by_name(rom, name)) {
+		ERROR("Component %s already exists in this rom\n", name);
+		return -1;
+	}
+
+	if (c == NULL) {
+		ERROR("There is no more room in this ROM\n");
+		return -1;
+	}
+
+	csize = sizeof(struct cbfs_file) + ALIGN(strlen(name), 16) + size;
+
+	offset = ROM_OFFSET(rom, c);
+
+	if (offset + csize >= rom->fssize) {
+		ERROR("There is not enough room in this ROM for this\n");
+		ERROR("component. I need %d bytes, only have %d bytes avail\n",
+		      csize, rom->fssize - offset);
+
+		return -1;
+	}
+
+	strcpy(c->magic, COMPONENT_MAGIC);
+
+	csize = sizeof(struct cbfs_file) + ALIGN(strlen(name) + 1, 16);
+
+	c->len = htonl(size);
+	c->offset = htonl(csize);
+	c->type = htonl(type);
+
+	memset(CBFS_NAME(c), 0, ALIGN(strlen(name) + 1, 16));
+	strcpy((char *)CBFS_NAME(c), name);
+
+	memcpy(((unsigned char *)c) + csize, buffer, size);
+	return 0;
+}
diff --git a/util/cbfstool/print.c b/util/cbfstool/print.c
new file mode 100644
index 0000000000..7eb9ee452c
--- /dev/null
+++ b/util/cbfstool/print.c
@@ -0,0 +1,63 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+#include "cbfstool.h"
+
+void print_usage(void)
+{
+	printf("print\t\t\t\tShow the contents of the ROM\n");
+}
+
+int print_handler(struct rom *rom, int argc, char **argv)
+{
+	printf("%s: %d kB, bootblocksize %d, romsize %d, offset 0x%x\n", rom->name, rom->size / 1024, 
+				ntohl(rom->header->bootblocksize), ntohl(rom->header->romsize), ntohl(rom->header->offset));
+	printf("Alignment: %d bytes\n\n", ntohl(rom->header->align));
+
+	struct cbfs_file *c = rom_find_first(rom);
+
+	printf("%-30s Offset     %-12s Size\n", "Name", "Type");
+
+	while (c) {
+		char type[12];
+
+		switch (htonl(c->type)) {
+		case CBFS_COMPONENT_STAGE:
+			strcpy(type, "stage");
+			break;
+		case CBFS_COMPONENT_PAYLOAD:
+			strcpy(type, "payload");
+			break;
+		case CBFS_COMPONENT_OPTIONROM:
+			strcpy(type, "optionrom");
+			break;
+		default:
+			sprintf(type, "0x%8.8x", htonl(c->type));
+			break;
+		}
+
+		printf("%-30s 0x%-8x %-12s %d\n", CBFS_NAME(c),
+		       ROM_OFFSET(rom, c), type, htonl(c->len));
+
+		c = rom_find_next(rom, c);
+	}
+
+	return 0;
+}
diff --git a/util/cbfstool/resize.c b/util/cbfstool/resize.c
new file mode 100644
index 0000000000..157515619c
--- /dev/null
+++ b/util/cbfstool/resize.c
@@ -0,0 +1,168 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "cbfstool.h"
+
+void resize_usage(void)
+{
+	printf("resize [SIZE] [ERASEBLOCK]\tResize the ROM\n");
+}
+
+int resize_handler(struct rom *rom, int argc, char **argv)
+{
+	unsigned int size, align, offset;
+	char null = '\0';
+	int bootblocksize = ntohl(rom->header->bootblocksize);
+
+	if (argc < 1) {
+		resize_usage();
+		return -1;
+	}
+
+	if (rom->fd <= 0) {
+		ERROR("ROM file %s does not exist\n", rom->name);
+		return -1;
+	}
+
+	align = ntohl(rom->header->align);
+	size = get_size(argv[0]);
+
+	if (argc >= 2)
+		align = strtoul(argv[1], NULL, 0);
+
+	if (size == rom->size && align == ntohl(rom->header->align)) {
+		ERROR("New parameters are the same as the old\n");
+		return 0;
+	}
+
+	if (size < bootblocksize) {
+		ERROR("The new size is smaller then the bootblock size\n");
+		return -1;
+	}
+
+	/* if the current ROM is too big for the new size, then complain */
+
+	if (rom_used_space(rom) > size -  bootblocksize) {
+		ERROR("The new size is too small for the current ROM\n");
+		return -1;
+	}
+
+	/* Grow the rom if we need to */
+
+	if (size > rom->size) {
+		munmap(rom->ptr, rom->size);
+
+		lseek(rom->fd, size - 1, SEEK_SET);
+		write(rom->fd, &null, 1);
+
+		rom->ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+				rom->fd, 0);
+
+		if (rom->ptr == MAP_FAILED) {
+			ERROR("Unable to grow the ROM\n");
+			return -1;
+		}
+	}
+
+	/* We only have to rewrite the entries if the alignment changed */
+
+	if (align != ntohl(rom->header->align)) {
+		struct cbfs_file *c;
+
+		/* The first entry doesn't have to move */
+
+		c = rom_find(rom, rom->header->offset);
+		offset = rom->header->offset;
+
+		while (c) {
+			struct cbfs_file *n = rom_find_next(rom, c);
+			unsigned int next;
+
+			if (n == NULL)
+				break;
+
+			/* Calculate a new location for the entry */
+			next =
+			    ROM_OFFSET(rom,
+				       c) + ALIGN(ntohl(c->offset) +
+						  ntohl(c->len), align);
+
+			/* Copy the next entry there */
+			memmove(ROM_PTR(rom, next), n,
+				ntohl(n->offset) + ntohl(n->len));
+
+			c = (struct cbfs_file *)ROM_PTR(rom, next);
+
+			/* If the previous header wasn't overwritten by the change,
+			   corrupt the header so we don't accidently find it */
+
+			if (ROM_OFFSET(rom, n) >
+			    next + ntohl(c->len) + ntohl(c->offset))
+				memset(n->magic, 0, sizeof(n->magic));
+		}
+	}
+
+	/* Copy the bootblock */
+
+	memmove(rom->ptr + size -  bootblocksize,
+		rom->ptr + rom->size -  bootblocksize,  bootblocksize);
+
+	/* Recacluate the location of the header */
+
+	offset = ROM_READL(rom, size - 12);
+
+	rom->header = (struct cbfs_header *)
+	    ROM_PTR(rom, size - (0xFFFFFFFF - offset) - 1);
+
+	/* Put the new values in the header */
+	rom->header->romsize = htonl(size);
+	rom->header->align = htonl(align);
+
+	/* Truncate the file if we have to */
+
+	if (size < rom->size) {
+		munmap(rom->ptr, rom->size);
+
+		rom->ptr = NULL;
+
+		if (ftruncate(rom->fd, size)) {
+			ERROR("Unable to truncate the ROM\n");
+			return -1;
+		}
+
+		rom->ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+				rom->fd, 0);
+
+		if (rom->ptr == MAP_FAILED) {
+			ERROR("Unable to truncate the ROM\n");
+			return -1;
+		}
+	}
+
+	rom->size = size;
+	rom->fssize = size -  bootblocksize;
+
+	return 0;
+}
diff --git a/util/cbfstool/tools/Makefile b/util/cbfstool/tools/Makefile
new file mode 100644
index 0000000000..bcecf46636
--- /dev/null
+++ b/util/cbfstool/tools/Makefile
@@ -0,0 +1,24 @@
+tobj ?= $(shell pwd)
+tsrc ?= $(shell pwd)
+
+TARGETS += $(tobj)/rom-mkstage $(tobj)/rom-mkpayload
+
+tools: $(tobj)/rom-mkstage $(tobj)/rom-mkpayload
+
+include $(tsrc)/lzma/Makefile
+
+COMMON = common.o compress.o $(LZMA_OBJ)
+
+$(tobj)/rom-mkstage: $(tobj)/rom-mkstage.o $(patsubst %,$(tobj)/%,$(COMMON))
+	$(CXX) $(CFLAGS) -o $@ $^
+
+$(tobj)/rom-mkpayload: $(tobj)/rom-mkpayload.o $(patsubst %,$(tobj)/%,$(COMMON))
+	$(CXX) $(CFLAGS) -o $@ $^
+
+$(tobj)/%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+tools-clean:
+	rm -f $(tobj)/rom-mkpayload.o $(tobj)/rom-mkstage.o $(patsubst %,$(tobj)/%,$(COMMON))
+	rm -f $(tobj)/rom-mkpayload $(tobj)/rom-mkstage
+
diff --git a/util/cbfstool/tools/common.c b/util/cbfstool/tools/common.c
new file mode 100644
index 0000000000..377561bc52
--- /dev/null
+++ b/util/cbfstool/tools/common.c
@@ -0,0 +1,126 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include "elf.h"
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include "common.h"
+
+#define BLOCKSIZE (1024 * 16)
+
+void file_write_from_buffer(int fd, unsigned char *buffer, int size)
+{
+	unsigned char *ptr = buffer;
+
+	while (size) {
+		int ret = write(fd, ptr, size);
+
+		if (ret == -1)
+			break;
+
+		size -= ret;
+		ptr += ret;
+	}
+}
+
+unsigned char *file_read_to_buffer(int fd, int *fsize)
+{
+	unsigned char *buffer = malloc(BLOCKSIZE);
+	unsigned char *ptr = buffer;
+
+	int bsize = BLOCKSIZE;
+	int remain = BLOCKSIZE;
+	int size = 0;
+	int ret;
+
+	if (buffer == NULL)
+		return NULL;
+
+	while (1) {
+		ret = read(fd, ptr, remain);
+
+		if (ret <= 0)
+			break;
+
+		remain -= ret;
+		ptr += ret;
+		size += ret;
+
+		/* Allocate more memory */
+
+		if (remain == 0) {
+			buffer = realloc(buffer, bsize + BLOCKSIZE);
+
+			if (buffer == NULL)
+				return NULL;
+
+			ptr = buffer + size;
+
+			bsize += BLOCKSIZE;
+			remain = BLOCKSIZE;
+		}
+	}
+
+	if (ret == 0) {
+		*fsize = size;
+		return buffer;
+	}
+
+	*fsize = 0;
+	free(buffer);
+	return NULL;
+}
+
+unsigned char *file_read(const char *filename, int *fsize)
+{
+	int fd = open(filename, O_RDONLY);
+	unsigned char *buffer;
+
+	if (fd == -1)
+		return NULL;
+
+	buffer = file_read_to_buffer(fd, fsize);
+	close(fd);
+	return buffer;
+}
+
+void file_write(const char *filename, unsigned char *buffer, int size)
+{
+	int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC,
+		      S_IRUSR | S_IWUSR);
+
+	if (fd == -1) {
+		fprintf(stderr, "E: Could not create %s: %m\n", filename);
+		return;
+	}
+
+	file_write_from_buffer(fd, buffer, size);
+	close(fd);
+}
+
+int iself(unsigned char *input)
+{
+	Elf32_Ehdr *ehdr = (Elf32_Ehdr *) input;
+	return !memcmp(ehdr->e_ident, ELFMAG, 4);
+}
diff --git a/util/cbfstool/tools/common.h b/util/cbfstool/tools/common.h
new file mode 100644
index 0000000000..146c828f6a
--- /dev/null
+++ b/util/cbfstool/tools/common.h
@@ -0,0 +1,34 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+int iself(unsigned char *input);
+unsigned char *file_read(const char *filename, int *fsize);
+void file_write(const char *filename, unsigned char *buffer, int size);
+unsigned char *file_read_to_buffer(int fd, int *fsize);
+void file_write_from_buffer(int fd, unsigned char *buffer, int size);
+
+/* compress.c */
+
+void lzma_compress(char *in, int in_len, char *out, int *out_len);
+void none_compress(char *in, int in_len, char *out, int *out_len);
+
+#endif
diff --git a/util/cbfstool/tools/compress.c b/util/cbfstool/tools/compress.c
new file mode 100644
index 0000000000..fb8fe82931
--- /dev/null
+++ b/util/cbfstool/tools/compress.c
@@ -0,0 +1,33 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+
+extern void do_lzma_compress(char *in, int in_len, char *out, int *out_len);
+
+void lzma_compress(char *in, int in_len, char *out, int *out_len)
+{
+	do_lzma_compress(in, in_len, out, out_len);
+}
+
+void none_compress(char *in, int in_len, char *out, int *out_len)
+{
+	memcpy(out, in, in_len);
+	*out_len = in_len;
+}
diff --git a/util/cbfstool/tools/elf.h b/util/cbfstool/tools/elf.h
new file mode 100644
index 0000000000..bbdce6e83b
--- /dev/null
+++ b/util/cbfstool/tools/elf.h
@@ -0,0 +1,2637 @@
+/* This file defines standard ELF types, structures, and macros.
+   Copyright (C) 1995-2003,2004,2005,2006,2007 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _ELF_H
+#define	_ELF_H 1
+
+#include <stdint.h>
+
+/* Type for a 16-bit quantity.  */
+typedef uint16_t Elf32_Half;
+typedef uint16_t Elf64_Half;
+
+/* Types for signed and unsigned 32-bit quantities.  */
+typedef uint32_t Elf32_Word;
+typedef	int32_t  Elf32_Sword;
+typedef uint32_t Elf64_Word;
+typedef	int32_t  Elf64_Sword;
+
+/* Types for signed and unsigned 64-bit quantities.  */
+typedef uint64_t Elf32_Xword;
+typedef	int64_t  Elf32_Sxword;
+typedef uint64_t Elf64_Xword;
+typedef	int64_t  Elf64_Sxword;
+
+/* Type of addresses.  */
+typedef uint32_t Elf32_Addr;
+typedef uint64_t Elf64_Addr;
+
+/* Type of file offsets.  */
+typedef uint32_t Elf32_Off;
+typedef uint64_t Elf64_Off;
+
+/* Type for section indices, which are 16-bit quantities.  */
+typedef uint16_t Elf32_Section;
+typedef uint16_t Elf64_Section;
+
+/* Type for version symbol information.  */
+typedef Elf32_Half Elf32_Versym;
+typedef Elf64_Half Elf64_Versym;
+
+
+/* The ELF file header.  This appears at the start of every ELF file.  */
+
+#define EI_NIDENT (16)
+
+typedef struct
+{
+  unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
+  Elf32_Half	e_type;			/* Object file type */
+  Elf32_Half	e_machine;		/* Architecture */
+  Elf32_Word	e_version;		/* Object file version */
+  Elf32_Addr	e_entry;		/* Entry point virtual address */
+  Elf32_Off	e_phoff;		/* Program header table file offset */
+  Elf32_Off	e_shoff;		/* Section header table file offset */
+  Elf32_Word	e_flags;		/* Processor-specific flags */
+  Elf32_Half	e_ehsize;		/* ELF header size in bytes */
+  Elf32_Half	e_phentsize;		/* Program header table entry size */
+  Elf32_Half	e_phnum;		/* Program header table entry count */
+  Elf32_Half	e_shentsize;		/* Section header table entry size */
+  Elf32_Half	e_shnum;		/* Section header table entry count */
+  Elf32_Half	e_shstrndx;		/* Section header string table index */
+} Elf32_Ehdr;
+
+typedef struct
+{
+  unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
+  Elf64_Half	e_type;			/* Object file type */
+  Elf64_Half	e_machine;		/* Architecture */
+  Elf64_Word	e_version;		/* Object file version */
+  Elf64_Addr	e_entry;		/* Entry point virtual address */
+  Elf64_Off	e_phoff;		/* Program header table file offset */
+  Elf64_Off	e_shoff;		/* Section header table file offset */
+  Elf64_Word	e_flags;		/* Processor-specific flags */
+  Elf64_Half	e_ehsize;		/* ELF header size in bytes */
+  Elf64_Half	e_phentsize;		/* Program header table entry size */
+  Elf64_Half	e_phnum;		/* Program header table entry count */
+  Elf64_Half	e_shentsize;		/* Section header table entry size */
+  Elf64_Half	e_shnum;		/* Section header table entry count */
+  Elf64_Half	e_shstrndx;		/* Section header string table index */
+} Elf64_Ehdr;
+
+/* Fields in the e_ident array.  The EI_* macros are indices into the
+   array.  The macros under each EI_* macro are the values the byte
+   may have.  */
+
+#define EI_MAG0		0		/* File identification byte 0 index */
+#define ELFMAG0		0x7f		/* Magic number byte 0 */
+
+#define EI_MAG1		1		/* File identification byte 1 index */
+#define ELFMAG1		'E'		/* Magic number byte 1 */
+
+#define EI_MAG2		2		/* File identification byte 2 index */
+#define ELFMAG2		'L'		/* Magic number byte 2 */
+
+#define EI_MAG3		3		/* File identification byte 3 index */
+#define ELFMAG3		'F'		/* Magic number byte 3 */
+
+/* Conglomeration of the identification bytes, for easy testing as a word.  */
+#define	ELFMAG		"\177ELF"
+#define	SELFMAG		4
+
+#define EI_CLASS	4		/* File class byte index */
+#define ELFCLASSNONE	0		/* Invalid class */
+#define ELFCLASS32	1		/* 32-bit objects */
+#define ELFCLASS64	2		/* 64-bit objects */
+#define ELFCLASSNUM	3
+
+#define EI_DATA		5		/* Data encoding byte index */
+#define ELFDATANONE	0		/* Invalid data encoding */
+#define ELFDATA2LSB	1		/* 2's complement, little endian */
+#define ELFDATA2MSB	2		/* 2's complement, big endian */
+#define ELFDATANUM	3
+
+#define EI_VERSION	6		/* File version byte index */
+					/* Value must be EV_CURRENT */
+
+#define EI_OSABI	7		/* OS ABI identification */
+#define ELFOSABI_NONE		0	/* UNIX System V ABI */
+#define ELFOSABI_SYSV		0	/* Alias.  */
+#define ELFOSABI_HPUX		1	/* HP-UX */
+#define ELFOSABI_NETBSD		2	/* NetBSD.  */
+#define ELFOSABI_LINUX		3	/* Linux.  */
+#define ELFOSABI_SOLARIS	6	/* Sun Solaris.  */
+#define ELFOSABI_AIX		7	/* IBM AIX.  */
+#define ELFOSABI_IRIX		8	/* SGI Irix.  */
+#define ELFOSABI_FREEBSD	9	/* FreeBSD.  */
+#define ELFOSABI_TRU64		10	/* Compaq TRU64 UNIX.  */
+#define ELFOSABI_MODESTO	11	/* Novell Modesto.  */
+#define ELFOSABI_OPENBSD	12	/* OpenBSD.  */
+#define ELFOSABI_ARM		97	/* ARM */
+#define ELFOSABI_STANDALONE	255	/* Standalone (embedded) application */
+
+#define EI_ABIVERSION	8		/* ABI version */
+
+#define EI_PAD		9		/* Byte index of padding bytes */
+
+/* Legal values for e_type (object file type).  */
+
+#define ET_NONE		0		/* No file type */
+#define ET_REL		1		/* Relocatable file */
+#define ET_EXEC		2		/* Executable file */
+#define ET_DYN		3		/* Shared object file */
+#define ET_CORE		4		/* Core file */
+#define	ET_NUM		5		/* Number of defined types */
+#define ET_LOOS		0xfe00		/* OS-specific range start */
+#define ET_HIOS		0xfeff		/* OS-specific range end */
+#define ET_LOPROC	0xff00		/* Processor-specific range start */
+#define ET_HIPROC	0xffff		/* Processor-specific range end */
+
+/* Legal values for e_machine (architecture).  */
+
+#define EM_NONE		 0		/* No machine */
+#define EM_M32		 1		/* AT&T WE 32100 */
+#define EM_SPARC	 2		/* SUN SPARC */
+#define EM_386		 3		/* Intel 80386 */
+#define EM_68K		 4		/* Motorola m68k family */
+#define EM_88K		 5		/* Motorola m88k family */
+#define EM_860		 7		/* Intel 80860 */
+#define EM_MIPS		 8		/* MIPS R3000 big-endian */
+#define EM_S370		 9		/* IBM System/370 */
+#define EM_MIPS_RS3_LE	10		/* MIPS R3000 little-endian */
+
+#define EM_PARISC	15		/* HPPA */
+#define EM_VPP500	17		/* Fujitsu VPP500 */
+#define EM_SPARC32PLUS	18		/* Sun's "v8plus" */
+#define EM_960		19		/* Intel 80960 */
+#define EM_PPC		20		/* PowerPC */
+#define EM_PPC64	21		/* PowerPC 64-bit */
+#define EM_S390		22		/* IBM S390 */
+
+#define EM_V800		36		/* NEC V800 series */
+#define EM_FR20		37		/* Fujitsu FR20 */
+#define EM_RH32		38		/* TRW RH-32 */
+#define EM_RCE		39		/* Motorola RCE */
+#define EM_ARM		40		/* ARM */
+#define EM_FAKE_ALPHA	41		/* Digital Alpha */
+#define EM_SH		42		/* Hitachi SH */
+#define EM_SPARCV9	43		/* SPARC v9 64-bit */
+#define EM_TRICORE	44		/* Siemens Tricore */
+#define EM_ARC		45		/* Argonaut RISC Core */
+#define EM_H8_300	46		/* Hitachi H8/300 */
+#define EM_H8_300H	47		/* Hitachi H8/300H */
+#define EM_H8S		48		/* Hitachi H8S */
+#define EM_H8_500	49		/* Hitachi H8/500 */
+#define EM_IA_64	50		/* Intel Merced */
+#define EM_MIPS_X	51		/* Stanford MIPS-X */
+#define EM_COLDFIRE	52		/* Motorola Coldfire */
+#define EM_68HC12	53		/* Motorola M68HC12 */
+#define EM_MMA		54		/* Fujitsu MMA Multimedia Accelerator*/
+#define EM_PCP		55		/* Siemens PCP */
+#define EM_NCPU		56		/* Sony nCPU embeeded RISC */
+#define EM_NDR1		57		/* Denso NDR1 microprocessor */
+#define EM_STARCORE	58		/* Motorola Start*Core processor */
+#define EM_ME16		59		/* Toyota ME16 processor */
+#define EM_ST100	60		/* STMicroelectronic ST100 processor */
+#define EM_TINYJ	61		/* Advanced Logic Corp. Tinyj emb.fam*/
+#define EM_X86_64	62		/* AMD x86-64 architecture */
+#define EM_PDSP		63		/* Sony DSP Processor */
+
+#define EM_FX66		66		/* Siemens FX66 microcontroller */
+#define EM_ST9PLUS	67		/* STMicroelectronics ST9+ 8/16 mc */
+#define EM_ST7		68		/* STmicroelectronics ST7 8 bit mc */
+#define EM_68HC16	69		/* Motorola MC68HC16 microcontroller */
+#define EM_68HC11	70		/* Motorola MC68HC11 microcontroller */
+#define EM_68HC08	71		/* Motorola MC68HC08 microcontroller */
+#define EM_68HC05	72		/* Motorola MC68HC05 microcontroller */
+#define EM_SVX		73		/* Silicon Graphics SVx */
+#define EM_ST19		74		/* STMicroelectronics ST19 8 bit mc */
+#define EM_VAX		75		/* Digital VAX */
+#define EM_CRIS		76		/* Axis Communications 32-bit embedded processor */
+#define EM_JAVELIN	77		/* Infineon Technologies 32-bit embedded processor */
+#define EM_FIREPATH	78		/* Element 14 64-bit DSP Processor */
+#define EM_ZSP		79		/* LSI Logic 16-bit DSP Processor */
+#define EM_MMIX		80		/* Donald Knuth's educational 64-bit processor */
+#define EM_HUANY	81		/* Harvard University machine-independent object files */
+#define EM_PRISM	82		/* SiTera Prism */
+#define EM_AVR		83		/* Atmel AVR 8-bit microcontroller */
+#define EM_FR30		84		/* Fujitsu FR30 */
+#define EM_D10V		85		/* Mitsubishi D10V */
+#define EM_D30V		86		/* Mitsubishi D30V */
+#define EM_V850		87		/* NEC v850 */
+#define EM_M32R		88		/* Mitsubishi M32R */
+#define EM_MN10300	89		/* Matsushita MN10300 */
+#define EM_MN10200	90		/* Matsushita MN10200 */
+#define EM_PJ		91		/* picoJava */
+#define EM_OPENRISC	92		/* OpenRISC 32-bit embedded processor */
+#define EM_ARC_A5	93		/* ARC Cores Tangent-A5 */
+#define EM_XTENSA	94		/* Tensilica Xtensa Architecture */
+#define EM_NUM		95
+
+/* If it is necessary to assign new unofficial EM_* values, please
+   pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the
+   chances of collision with official or non-GNU unofficial values.  */
+
+#define EM_ALPHA	0x9026
+
+/* Legal values for e_version (version).  */
+
+#define EV_NONE		0		/* Invalid ELF version */
+#define EV_CURRENT	1		/* Current version */
+#define EV_NUM		2
+
+/* Section header.  */
+
+typedef struct
+{
+  Elf32_Word	sh_name;		/* Section name (string tbl index) */
+  Elf32_Word	sh_type;		/* Section type */
+  Elf32_Word	sh_flags;		/* Section flags */
+  Elf32_Addr	sh_addr;		/* Section virtual addr at execution */
+  Elf32_Off	sh_offset;		/* Section file offset */
+  Elf32_Word	sh_size;		/* Section size in bytes */
+  Elf32_Word	sh_link;		/* Link to another section */
+  Elf32_Word	sh_info;		/* Additional section information */
+  Elf32_Word	sh_addralign;		/* Section alignment */
+  Elf32_Word	sh_entsize;		/* Entry size if section holds table */
+} Elf32_Shdr;
+
+typedef struct
+{
+  Elf64_Word	sh_name;		/* Section name (string tbl index) */
+  Elf64_Word	sh_type;		/* Section type */
+  Elf64_Xword	sh_flags;		/* Section flags */
+  Elf64_Addr	sh_addr;		/* Section virtual addr at execution */
+  Elf64_Off	sh_offset;		/* Section file offset */
+  Elf64_Xword	sh_size;		/* Section size in bytes */
+  Elf64_Word	sh_link;		/* Link to another section */
+  Elf64_Word	sh_info;		/* Additional section information */
+  Elf64_Xword	sh_addralign;		/* Section alignment */
+  Elf64_Xword	sh_entsize;		/* Entry size if section holds table */
+} Elf64_Shdr;
+
+/* Special section indices.  */
+
+#define SHN_UNDEF	0		/* Undefined section */
+#define SHN_LORESERVE	0xff00		/* Start of reserved indices */
+#define SHN_LOPROC	0xff00		/* Start of processor-specific */
+#define SHN_BEFORE	0xff00		/* Order section before all others
+					   (Solaris).  */
+#define SHN_AFTER	0xff01		/* Order section after all others
+					   (Solaris).  */
+#define SHN_HIPROC	0xff1f		/* End of processor-specific */
+#define SHN_LOOS	0xff20		/* Start of OS-specific */
+#define SHN_HIOS	0xff3f		/* End of OS-specific */
+#define SHN_ABS		0xfff1		/* Associated symbol is absolute */
+#define SHN_COMMON	0xfff2		/* Associated symbol is common */
+#define SHN_XINDEX	0xffff		/* Index is in extra table.  */
+#define SHN_HIRESERVE	0xffff		/* End of reserved indices */
+
+/* Legal values for sh_type (section type).  */
+
+#define SHT_NULL	  0		/* Section header table entry unused */
+#define SHT_PROGBITS	  1		/* Program data */
+#define SHT_SYMTAB	  2		/* Symbol table */
+#define SHT_STRTAB	  3		/* String table */
+#define SHT_RELA	  4		/* Relocation entries with addends */
+#define SHT_HASH	  5		/* Symbol hash table */
+#define SHT_DYNAMIC	  6		/* Dynamic linking information */
+#define SHT_NOTE	  7		/* Notes */
+#define SHT_NOBITS	  8		/* Program space with no data (bss) */
+#define SHT_REL		  9		/* Relocation entries, no addends */
+#define SHT_SHLIB	  10		/* Reserved */
+#define SHT_DYNSYM	  11		/* Dynamic linker symbol table */
+#define SHT_INIT_ARRAY	  14		/* Array of constructors */
+#define SHT_FINI_ARRAY	  15		/* Array of destructors */
+#define SHT_PREINIT_ARRAY 16		/* Array of pre-constructors */
+#define SHT_GROUP	  17		/* Section group */
+#define SHT_SYMTAB_SHNDX  18		/* Extended section indeces */
+#define	SHT_NUM		  19		/* Number of defined types.  */
+#define SHT_LOOS	  0x60000000	/* Start OS-specific.  */
+#define SHT_GNU_HASH	  0x6ffffff6	/* GNU-style hash table.  */
+#define SHT_GNU_LIBLIST	  0x6ffffff7	/* Prelink library list */
+#define SHT_CHECKSUM	  0x6ffffff8	/* Checksum for DSO content.  */
+#define SHT_LOSUNW	  0x6ffffffa	/* Sun-specific low bound.  */
+#define SHT_SUNW_move	  0x6ffffffa
+#define SHT_SUNW_COMDAT   0x6ffffffb
+#define SHT_SUNW_syminfo  0x6ffffffc
+#define SHT_GNU_verdef	  0x6ffffffd	/* Version definition section.  */
+#define SHT_GNU_verneed	  0x6ffffffe	/* Version needs section.  */
+#define SHT_GNU_versym	  0x6fffffff	/* Version symbol table.  */
+#define SHT_HISUNW	  0x6fffffff	/* Sun-specific high bound.  */
+#define SHT_HIOS	  0x6fffffff	/* End OS-specific type */
+#define SHT_LOPROC	  0x70000000	/* Start of processor-specific */
+#define SHT_HIPROC	  0x7fffffff	/* End of processor-specific */
+#define SHT_LOUSER	  0x80000000	/* Start of application-specific */
+#define SHT_HIUSER	  0x8fffffff	/* End of application-specific */
+
+/* Legal values for sh_flags (section flags).  */
+
+#define SHF_WRITE	     (1 << 0)	/* Writable */
+#define SHF_ALLOC	     (1 << 1)	/* Occupies memory during execution */
+#define SHF_EXECINSTR	     (1 << 2)	/* Executable */
+#define SHF_MERGE	     (1 << 4)	/* Might be merged */
+#define SHF_STRINGS	     (1 << 5)	/* Contains nul-terminated strings */
+#define SHF_INFO_LINK	     (1 << 6)	/* `sh_info' contains SHT index */
+#define SHF_LINK_ORDER	     (1 << 7)	/* Preserve order after combining */
+#define SHF_OS_NONCONFORMING (1 << 8)	/* Non-standard OS specific handling
+					   required */
+#define SHF_GROUP	     (1 << 9)	/* Section is member of a group.  */
+#define SHF_TLS		     (1 << 10)	/* Section hold thread-local data.  */
+#define SHF_MASKOS	     0x0ff00000	/* OS-specific.  */
+#define SHF_MASKPROC	     0xf0000000	/* Processor-specific */
+#define SHF_ORDERED	     (1 << 30)	/* Special ordering requirement
+					   (Solaris).  */
+#define SHF_EXCLUDE	     (1 << 31)	/* Section is excluded unless
+					   referenced or allocated (Solaris).*/
+
+/* Section group handling.  */
+#define GRP_COMDAT	0x1		/* Mark group as COMDAT.  */
+
+/* Symbol table entry.  */
+
+typedef struct
+{
+  Elf32_Word	st_name;		/* Symbol name (string tbl index) */
+  Elf32_Addr	st_value;		/* Symbol value */
+  Elf32_Word	st_size;		/* Symbol size */
+  unsigned char	st_info;		/* Symbol type and binding */
+  unsigned char	st_other;		/* Symbol visibility */
+  Elf32_Section	st_shndx;		/* Section index */
+} Elf32_Sym;
+
+typedef struct
+{
+  Elf64_Word	st_name;		/* Symbol name (string tbl index) */
+  unsigned char	st_info;		/* Symbol type and binding */
+  unsigned char st_other;		/* Symbol visibility */
+  Elf64_Section	st_shndx;		/* Section index */
+  Elf64_Addr	st_value;		/* Symbol value */
+  Elf64_Xword	st_size;		/* Symbol size */
+} Elf64_Sym;
+
+/* The syminfo section if available contains additional information about
+   every dynamic symbol.  */
+
+typedef struct
+{
+  Elf32_Half si_boundto;		/* Direct bindings, symbol bound to */
+  Elf32_Half si_flags;			/* Per symbol flags */
+} Elf32_Syminfo;
+
+typedef struct
+{
+  Elf64_Half si_boundto;		/* Direct bindings, symbol bound to */
+  Elf64_Half si_flags;			/* Per symbol flags */
+} Elf64_Syminfo;
+
+/* Possible values for si_boundto.  */
+#define SYMINFO_BT_SELF		0xffff	/* Symbol bound to self */
+#define SYMINFO_BT_PARENT	0xfffe	/* Symbol bound to parent */
+#define SYMINFO_BT_LOWRESERVE	0xff00	/* Beginning of reserved entries */
+
+/* Possible bitmasks for si_flags.  */
+#define SYMINFO_FLG_DIRECT	0x0001	/* Direct bound symbol */
+#define SYMINFO_FLG_PASSTHRU	0x0002	/* Pass-thru symbol for translator */
+#define SYMINFO_FLG_COPY	0x0004	/* Symbol is a copy-reloc */
+#define SYMINFO_FLG_LAZYLOAD	0x0008	/* Symbol bound to object to be lazy
+					   loaded */
+/* Syminfo version values.  */
+#define SYMINFO_NONE		0
+#define SYMINFO_CURRENT		1
+#define SYMINFO_NUM		2
+
+
+/* How to extract and insert information held in the st_info field.  */
+
+#define ELF32_ST_BIND(val)		(((unsigned char) (val)) >> 4)
+#define ELF32_ST_TYPE(val)		((val) & 0xf)
+#define ELF32_ST_INFO(bind, type)	(((bind) << 4) + ((type) & 0xf))
+
+/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field.  */
+#define ELF64_ST_BIND(val)		ELF32_ST_BIND (val)
+#define ELF64_ST_TYPE(val)		ELF32_ST_TYPE (val)
+#define ELF64_ST_INFO(bind, type)	ELF32_ST_INFO ((bind), (type))
+
+/* Legal values for ST_BIND subfield of st_info (symbol binding).  */
+
+#define STB_LOCAL	0		/* Local symbol */
+#define STB_GLOBAL	1		/* Global symbol */
+#define STB_WEAK	2		/* Weak symbol */
+#define	STB_NUM		3		/* Number of defined types.  */
+#define STB_LOOS	10		/* Start of OS-specific */
+#define STB_HIOS	12		/* End of OS-specific */
+#define STB_LOPROC	13		/* Start of processor-specific */
+#define STB_HIPROC	15		/* End of processor-specific */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
+
+#define STT_NOTYPE	0		/* Symbol type is unspecified */
+#define STT_OBJECT	1		/* Symbol is a data object */
+#define STT_FUNC	2		/* Symbol is a code object */
+#define STT_SECTION	3		/* Symbol associated with a section */
+#define STT_FILE	4		/* Symbol's name is file name */
+#define STT_COMMON	5		/* Symbol is a common data object */
+#define STT_TLS		6		/* Symbol is thread-local data object*/
+#define	STT_NUM		7		/* Number of defined types.  */
+#define STT_LOOS	10		/* Start of OS-specific */
+#define STT_HIOS	12		/* End of OS-specific */
+#define STT_LOPROC	13		/* Start of processor-specific */
+#define STT_HIPROC	15		/* End of processor-specific */
+
+
+/* Symbol table indices are found in the hash buckets and chain table
+   of a symbol hash table section.  This special index value indicates
+   the end of a chain, meaning no further symbols are found in that bucket.  */
+
+#define STN_UNDEF	0		/* End of a chain.  */
+
+
+/* How to extract and insert information held in the st_other field.  */
+
+#define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
+
+/* For ELF64 the definitions are the same.  */
+#define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
+
+/* Symbol visibility specification encoded in the st_other field.  */
+#define STV_DEFAULT	0		/* Default symbol visibility rules */
+#define STV_INTERNAL	1		/* Processor specific hidden class */
+#define STV_HIDDEN	2		/* Sym unavailable in other modules */
+#define STV_PROTECTED	3		/* Not preemptible, not exported */
+
+
+/* Relocation table entry without addend (in section of type SHT_REL).  */
+
+typedef struct
+{
+  Elf32_Addr	r_offset;		/* Address */
+  Elf32_Word	r_info;			/* Relocation type and symbol index */
+} Elf32_Rel;
+
+/* I have seen two different definitions of the Elf64_Rel and
+   Elf64_Rela structures, so we'll leave them out until Novell (or
+   whoever) gets their act together.  */
+/* The following, at least, is used on Sparc v9, MIPS, and Alpha.  */
+
+typedef struct
+{
+  Elf64_Addr	r_offset;		/* Address */
+  Elf64_Xword	r_info;			/* Relocation type and symbol index */
+} Elf64_Rel;
+
+/* Relocation table entry with addend (in section of type SHT_RELA).  */
+
+typedef struct
+{
+  Elf32_Addr	r_offset;		/* Address */
+  Elf32_Word	r_info;			/* Relocation type and symbol index */
+  Elf32_Sword	r_addend;		/* Addend */
+} Elf32_Rela;
+
+typedef struct
+{
+  Elf64_Addr	r_offset;		/* Address */
+  Elf64_Xword	r_info;			/* Relocation type and symbol index */
+  Elf64_Sxword	r_addend;		/* Addend */
+} Elf64_Rela;
+
+/* How to extract and insert information held in the r_info field.  */
+
+#define ELF32_R_SYM(val)		((val) >> 8)
+#define ELF32_R_TYPE(val)		((val) & 0xff)
+#define ELF32_R_INFO(sym, type)		(((sym) << 8) + ((type) & 0xff))
+
+#define ELF64_R_SYM(i)			((i) >> 32)
+#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
+#define ELF64_R_INFO(sym,type)		((((Elf64_Xword) (sym)) << 32) + (type))
+
+/* Program segment header.  */
+
+typedef struct
+{
+  Elf32_Word	p_type;			/* Segment type */
+  Elf32_Off	p_offset;		/* Segment file offset */
+  Elf32_Addr	p_vaddr;		/* Segment virtual address */
+  Elf32_Addr	p_paddr;		/* Segment physical address */
+  Elf32_Word	p_filesz;		/* Segment size in file */
+  Elf32_Word	p_memsz;		/* Segment size in memory */
+  Elf32_Word	p_flags;		/* Segment flags */
+  Elf32_Word	p_align;		/* Segment alignment */
+} Elf32_Phdr;
+
+typedef struct
+{
+  Elf64_Word	p_type;			/* Segment type */
+  Elf64_Word	p_flags;		/* Segment flags */
+  Elf64_Off	p_offset;		/* Segment file offset */
+  Elf64_Addr	p_vaddr;		/* Segment virtual address */
+  Elf64_Addr	p_paddr;		/* Segment physical address */
+  Elf64_Xword	p_filesz;		/* Segment size in file */
+  Elf64_Xword	p_memsz;		/* Segment size in memory */
+  Elf64_Xword	p_align;		/* Segment alignment */
+} Elf64_Phdr;
+
+/* Legal values for p_type (segment type).  */
+
+#define	PT_NULL		0		/* Program header table entry unused */
+#define PT_LOAD		1		/* Loadable program segment */
+#define PT_DYNAMIC	2		/* Dynamic linking information */
+#define PT_INTERP	3		/* Program interpreter */
+#define PT_NOTE		4		/* Auxiliary information */
+#define PT_SHLIB	5		/* Reserved */
+#define PT_PHDR		6		/* Entry for header table itself */
+#define PT_TLS		7		/* Thread-local storage segment */
+#define	PT_NUM		8		/* Number of defined types */
+#define PT_LOOS		0x60000000	/* Start of OS-specific */
+#define PT_GNU_EH_FRAME	0x6474e550	/* GCC .eh_frame_hdr segment */
+#define PT_GNU_STACK	0x6474e551	/* Indicates stack executability */
+#define PT_GNU_RELRO	0x6474e552	/* Read-only after relocation */
+#define PT_LOSUNW	0x6ffffffa
+#define PT_SUNWBSS	0x6ffffffa	/* Sun Specific segment */
+#define PT_SUNWSTACK	0x6ffffffb	/* Stack segment */
+#define PT_HISUNW	0x6fffffff
+#define PT_HIOS		0x6fffffff	/* End of OS-specific */
+#define PT_LOPROC	0x70000000	/* Start of processor-specific */
+#define PT_HIPROC	0x7fffffff	/* End of processor-specific */
+
+/* Legal values for p_flags (segment flags).  */
+
+#define PF_X		(1 << 0)	/* Segment is executable */
+#define PF_W		(1 << 1)	/* Segment is writable */
+#define PF_R		(1 << 2)	/* Segment is readable */
+#define PF_MASKOS	0x0ff00000	/* OS-specific */
+#define PF_MASKPROC	0xf0000000	/* Processor-specific */
+
+/* Legal values for note segment descriptor types for core files. */
+
+#define NT_PRSTATUS	1		/* Contains copy of prstatus struct */
+#define NT_FPREGSET	2		/* Contains copy of fpregset struct */
+#define NT_PRPSINFO	3		/* Contains copy of prpsinfo struct */
+#define NT_PRXREG	4		/* Contains copy of prxregset struct */
+#define NT_TASKSTRUCT	4		/* Contains copy of task structure */
+#define NT_PLATFORM	5		/* String from sysinfo(SI_PLATFORM) */
+#define NT_AUXV		6		/* Contains copy of auxv array */
+#define NT_GWINDOWS	7		/* Contains copy of gwindows struct */
+#define NT_ASRS		8		/* Contains copy of asrset struct */
+#define NT_PSTATUS	10		/* Contains copy of pstatus struct */
+#define NT_PSINFO	13		/* Contains copy of psinfo struct */
+#define NT_PRCRED	14		/* Contains copy of prcred struct */
+#define NT_UTSNAME	15		/* Contains copy of utsname struct */
+#define NT_LWPSTATUS	16		/* Contains copy of lwpstatus struct */
+#define NT_LWPSINFO	17		/* Contains copy of lwpinfo struct */
+#define NT_PRFPXREG	20		/* Contains copy of fprxregset struct */
+#define NT_PRXFPREG	0x46e62b7f	/* Contains copy of user_fxsr_struct */
+
+/* Legal values for the note segment descriptor types for object files.  */
+
+#define NT_VERSION	1		/* Contains a version string.  */
+
+
+/* Dynamic section entry.  */
+
+typedef struct
+{
+  Elf32_Sword	d_tag;			/* Dynamic entry type */
+  union
+    {
+      Elf32_Word d_val;			/* Integer value */
+      Elf32_Addr d_ptr;			/* Address value */
+    } d_un;
+} Elf32_Dyn;
+
+typedef struct
+{
+  Elf64_Sxword	d_tag;			/* Dynamic entry type */
+  union
+    {
+      Elf64_Xword d_val;		/* Integer value */
+      Elf64_Addr d_ptr;			/* Address value */
+    } d_un;
+} Elf64_Dyn;
+
+/* Legal values for d_tag (dynamic entry type).  */
+
+#define DT_NULL		0		/* Marks end of dynamic section */
+#define DT_NEEDED	1		/* Name of needed library */
+#define DT_PLTRELSZ	2		/* Size in bytes of PLT relocs */
+#define DT_PLTGOT	3		/* Processor defined value */
+#define DT_HASH		4		/* Address of symbol hash table */
+#define DT_STRTAB	5		/* Address of string table */
+#define DT_SYMTAB	6		/* Address of symbol table */
+#define DT_RELA		7		/* Address of Rela relocs */
+#define DT_RELASZ	8		/* Total size of Rela relocs */
+#define DT_RELAENT	9		/* Size of one Rela reloc */
+#define DT_STRSZ	10		/* Size of string table */
+#define DT_SYMENT	11		/* Size of one symbol table entry */
+#define DT_INIT		12		/* Address of init function */
+#define DT_FINI		13		/* Address of termination function */
+#define DT_SONAME	14		/* Name of shared object */
+#define DT_RPATH	15		/* Library search path (deprecated) */
+#define DT_SYMBOLIC	16		/* Start symbol search here */
+#define DT_REL		17		/* Address of Rel relocs */
+#define DT_RELSZ	18		/* Total size of Rel relocs */
+#define DT_RELENT	19		/* Size of one Rel reloc */
+#define DT_PLTREL	20		/* Type of reloc in PLT */
+#define DT_DEBUG	21		/* For debugging; unspecified */
+#define DT_TEXTREL	22		/* Reloc might modify .text */
+#define DT_JMPREL	23		/* Address of PLT relocs */
+#define	DT_BIND_NOW	24		/* Process relocations of object */
+#define	DT_INIT_ARRAY	25		/* Array with addresses of init fct */
+#define	DT_FINI_ARRAY	26		/* Array with addresses of fini fct */
+#define	DT_INIT_ARRAYSZ	27		/* Size in bytes of DT_INIT_ARRAY */
+#define	DT_FINI_ARRAYSZ	28		/* Size in bytes of DT_FINI_ARRAY */
+#define DT_RUNPATH	29		/* Library search path */
+#define DT_FLAGS	30		/* Flags for the object being loaded */
+#define DT_ENCODING	32		/* Start of encoded range */
+#define DT_PREINIT_ARRAY 32		/* Array with addresses of preinit fct*/
+#define DT_PREINIT_ARRAYSZ 33		/* size in bytes of DT_PREINIT_ARRAY */
+#define	DT_NUM		34		/* Number used */
+#define DT_LOOS		0x6000000d	/* Start of OS-specific */
+#define DT_HIOS		0x6ffff000	/* End of OS-specific */
+#define DT_LOPROC	0x70000000	/* Start of processor-specific */
+#define DT_HIPROC	0x7fffffff	/* End of processor-specific */
+#define	DT_PROCNUM	DT_MIPS_NUM	/* Most used by any processor */
+
+/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
+   Dyn.d_un.d_val field of the Elf*_Dyn structure.  This follows Sun's
+   approach.  */
+#define DT_VALRNGLO	0x6ffffd00
+#define DT_GNU_PRELINKED 0x6ffffdf5	/* Prelinking timestamp */
+#define DT_GNU_CONFLICTSZ 0x6ffffdf6	/* Size of conflict section */
+#define DT_GNU_LIBLISTSZ 0x6ffffdf7	/* Size of library list */
+#define DT_CHECKSUM	0x6ffffdf8
+#define DT_PLTPADSZ	0x6ffffdf9
+#define DT_MOVEENT	0x6ffffdfa
+#define DT_MOVESZ	0x6ffffdfb
+#define DT_FEATURE_1	0x6ffffdfc	/* Feature selection (DTF_*).  */
+#define DT_POSFLAG_1	0x6ffffdfd	/* Flags for DT_* entries, effecting
+					   the following DT_* entry.  */
+#define DT_SYMINSZ	0x6ffffdfe	/* Size of syminfo table (in bytes) */
+#define DT_SYMINENT	0x6ffffdff	/* Entry size of syminfo */
+#define DT_VALRNGHI	0x6ffffdff
+#define DT_VALTAGIDX(tag)	(DT_VALRNGHI - (tag))	/* Reverse order! */
+#define DT_VALNUM 12
+
+/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
+   Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
+
+   If any adjustment is made to the ELF object after it has been
+   built these entries will need to be adjusted.  */
+#define DT_ADDRRNGLO	0x6ffffe00
+#define DT_GNU_HASH	0x6ffffef5	/* GNU-style hash table.  */
+#define DT_TLSDESC_PLT	0x6ffffef6
+#define DT_TLSDESC_GOT	0x6ffffef7
+#define DT_GNU_CONFLICT	0x6ffffef8	/* Start of conflict section */
+#define DT_GNU_LIBLIST	0x6ffffef9	/* Library list */
+#define DT_CONFIG	0x6ffffefa	/* Configuration information.  */
+#define DT_DEPAUDIT	0x6ffffefb	/* Dependency auditing.  */
+#define DT_AUDIT	0x6ffffefc	/* Object auditing.  */
+#define	DT_PLTPAD	0x6ffffefd	/* PLT padding.  */
+#define	DT_MOVETAB	0x6ffffefe	/* Move table.  */
+#define DT_SYMINFO	0x6ffffeff	/* Syminfo table.  */
+#define DT_ADDRRNGHI	0x6ffffeff
+#define DT_ADDRTAGIDX(tag)	(DT_ADDRRNGHI - (tag))	/* Reverse order! */
+#define DT_ADDRNUM 11
+
+/* The versioning entry types.  The next are defined as part of the
+   GNU extension.  */
+#define DT_VERSYM	0x6ffffff0
+
+#define DT_RELACOUNT	0x6ffffff9
+#define DT_RELCOUNT	0x6ffffffa
+
+/* These were chosen by Sun.  */
+#define DT_FLAGS_1	0x6ffffffb	/* State flags, see DF_1_* below.  */
+#define	DT_VERDEF	0x6ffffffc	/* Address of version definition
+					   table */
+#define	DT_VERDEFNUM	0x6ffffffd	/* Number of version definitions */
+#define	DT_VERNEED	0x6ffffffe	/* Address of table with needed
+					   versions */
+#define	DT_VERNEEDNUM	0x6fffffff	/* Number of needed versions */
+#define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))	/* Reverse order! */
+#define DT_VERSIONTAGNUM 16
+
+/* Sun added these machine-independent extensions in the "processor-specific"
+   range.  Be compatible.  */
+#define DT_AUXILIARY    0x7ffffffd      /* Shared object to load before self */
+#define DT_FILTER       0x7fffffff      /* Shared object to get values from */
+#define DT_EXTRATAGIDX(tag)	((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
+#define DT_EXTRANUM	3
+
+/* Values of `d_un.d_val' in the DT_FLAGS entry.  */
+#define DF_ORIGIN	0x00000001	/* Object may use DF_ORIGIN */
+#define DF_SYMBOLIC	0x00000002	/* Symbol resolutions starts here */
+#define DF_TEXTREL	0x00000004	/* Object contains text relocations */
+#define DF_BIND_NOW	0x00000008	/* No lazy binding for this object */
+#define DF_STATIC_TLS	0x00000010	/* Module uses the static TLS model */
+
+/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
+   entry in the dynamic section.  */
+#define DF_1_NOW	0x00000001	/* Set RTLD_NOW for this object.  */
+#define DF_1_GLOBAL	0x00000002	/* Set RTLD_GLOBAL for this object.  */
+#define DF_1_GROUP	0x00000004	/* Set RTLD_GROUP for this object.  */
+#define DF_1_NODELETE	0x00000008	/* Set RTLD_NODELETE for this object.*/
+#define DF_1_LOADFLTR	0x00000010	/* Trigger filtee loading at runtime.*/
+#define DF_1_INITFIRST	0x00000020	/* Set RTLD_INITFIRST for this object*/
+#define DF_1_NOOPEN	0x00000040	/* Set RTLD_NOOPEN for this object.  */
+#define DF_1_ORIGIN	0x00000080	/* $ORIGIN must be handled.  */
+#define DF_1_DIRECT	0x00000100	/* Direct binding enabled.  */
+#define DF_1_TRANS	0x00000200
+#define DF_1_INTERPOSE	0x00000400	/* Object is used to interpose.  */
+#define DF_1_NODEFLIB	0x00000800	/* Ignore default lib search path.  */
+#define DF_1_NODUMP	0x00001000	/* Object can't be dldump'ed.  */
+#define DF_1_CONFALT	0x00002000	/* Configuration alternative created.*/
+#define DF_1_ENDFILTEE	0x00004000	/* Filtee terminates filters search. */
+#define	DF_1_DISPRELDNE	0x00008000	/* Disp reloc applied at build time. */
+#define	DF_1_DISPRELPND	0x00010000	/* Disp reloc applied at run-time.  */
+
+/* Flags for the feature selection in DT_FEATURE_1.  */
+#define DTF_1_PARINIT	0x00000001
+#define DTF_1_CONFEXP	0x00000002
+
+/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry.  */
+#define DF_P1_LAZYLOAD	0x00000001	/* Lazyload following object.  */
+#define DF_P1_GROUPPERM	0x00000002	/* Symbols from next object are not
+					   generally available.  */
+
+/* Version definition sections.  */
+
+typedef struct
+{
+  Elf32_Half	vd_version;		/* Version revision */
+  Elf32_Half	vd_flags;		/* Version information */
+  Elf32_Half	vd_ndx;			/* Version Index */
+  Elf32_Half	vd_cnt;			/* Number of associated aux entries */
+  Elf32_Word	vd_hash;		/* Version name hash value */
+  Elf32_Word	vd_aux;			/* Offset in bytes to verdaux array */
+  Elf32_Word	vd_next;		/* Offset in bytes to next verdef
+					   entry */
+} Elf32_Verdef;
+
+typedef struct
+{
+  Elf64_Half	vd_version;		/* Version revision */
+  Elf64_Half	vd_flags;		/* Version information */
+  Elf64_Half	vd_ndx;			/* Version Index */
+  Elf64_Half	vd_cnt;			/* Number of associated aux entries */
+  Elf64_Word	vd_hash;		/* Version name hash value */
+  Elf64_Word	vd_aux;			/* Offset in bytes to verdaux array */
+  Elf64_Word	vd_next;		/* Offset in bytes to next verdef
+					   entry */
+} Elf64_Verdef;
+
+
+/* Legal values for vd_version (version revision).  */
+#define VER_DEF_NONE	0		/* No version */
+#define VER_DEF_CURRENT	1		/* Current version */
+#define VER_DEF_NUM	2		/* Given version number */
+
+/* Legal values for vd_flags (version information flags).  */
+#define VER_FLG_BASE	0x1		/* Version definition of file itself */
+#define VER_FLG_WEAK	0x2		/* Weak version identifier */
+
+/* Versym symbol index values.  */
+#define	VER_NDX_LOCAL		0	/* Symbol is local.  */
+#define	VER_NDX_GLOBAL		1	/* Symbol is global.  */
+#define	VER_NDX_LORESERVE	0xff00	/* Beginning of reserved entries.  */
+#define	VER_NDX_ELIMINATE	0xff01	/* Symbol is to be eliminated.  */
+
+/* Auxialiary version information.  */
+
+typedef struct
+{
+  Elf32_Word	vda_name;		/* Version or dependency names */
+  Elf32_Word	vda_next;		/* Offset in bytes to next verdaux
+					   entry */
+} Elf32_Verdaux;
+
+typedef struct
+{
+  Elf64_Word	vda_name;		/* Version or dependency names */
+  Elf64_Word	vda_next;		/* Offset in bytes to next verdaux
+					   entry */
+} Elf64_Verdaux;
+
+
+/* Version dependency section.  */
+
+typedef struct
+{
+  Elf32_Half	vn_version;		/* Version of structure */
+  Elf32_Half	vn_cnt;			/* Number of associated aux entries */
+  Elf32_Word	vn_file;		/* Offset of filename for this
+					   dependency */
+  Elf32_Word	vn_aux;			/* Offset in bytes to vernaux array */
+  Elf32_Word	vn_next;		/* Offset in bytes to next verneed
+					   entry */
+} Elf32_Verneed;
+
+typedef struct
+{
+  Elf64_Half	vn_version;		/* Version of structure */
+  Elf64_Half	vn_cnt;			/* Number of associated aux entries */
+  Elf64_Word	vn_file;		/* Offset of filename for this
+					   dependency */
+  Elf64_Word	vn_aux;			/* Offset in bytes to vernaux array */
+  Elf64_Word	vn_next;		/* Offset in bytes to next verneed
+					   entry */
+} Elf64_Verneed;
+
+
+/* Legal values for vn_version (version revision).  */
+#define VER_NEED_NONE	 0		/* No version */
+#define VER_NEED_CURRENT 1		/* Current version */
+#define VER_NEED_NUM	 2		/* Given version number */
+
+/* Auxiliary needed version information.  */
+
+typedef struct
+{
+  Elf32_Word	vna_hash;		/* Hash value of dependency name */
+  Elf32_Half	vna_flags;		/* Dependency specific information */
+  Elf32_Half	vna_other;		/* Unused */
+  Elf32_Word	vna_name;		/* Dependency name string offset */
+  Elf32_Word	vna_next;		/* Offset in bytes to next vernaux
+					   entry */
+} Elf32_Vernaux;
+
+typedef struct
+{
+  Elf64_Word	vna_hash;		/* Hash value of dependency name */
+  Elf64_Half	vna_flags;		/* Dependency specific information */
+  Elf64_Half	vna_other;		/* Unused */
+  Elf64_Word	vna_name;		/* Dependency name string offset */
+  Elf64_Word	vna_next;		/* Offset in bytes to next vernaux
+					   entry */
+} Elf64_Vernaux;
+
+
+/* Legal values for vna_flags.  */
+#define VER_FLG_WEAK	0x2		/* Weak version identifier */
+
+
+/* Auxiliary vector.  */
+
+/* This vector is normally only used by the program interpreter.  The
+   usual definition in an ABI supplement uses the name auxv_t.  The
+   vector is not usually defined in a standard <elf.h> file, but it
+   can't hurt.  We rename it to avoid conflicts.  The sizes of these
+   types are an arrangement between the exec server and the program
+   interpreter, so we don't fully specify them here.  */
+
+typedef struct
+{
+  uint32_t a_type;		/* Entry type */
+  union
+    {
+      uint32_t a_val;		/* Integer value */
+      /* We use to have pointer elements added here.  We cannot do that,
+	 though, since it does not work when using 32-bit definitions
+	 on 64-bit platforms and vice versa.  */
+    } a_un;
+} Elf32_auxv_t;
+
+typedef struct
+{
+  uint64_t a_type;		/* Entry type */
+  union
+    {
+      uint64_t a_val;		/* Integer value */
+      /* We use to have pointer elements added here.  We cannot do that,
+	 though, since it does not work when using 32-bit definitions
+	 on 64-bit platforms and vice versa.  */
+    } a_un;
+} Elf64_auxv_t;
+
+/* Legal values for a_type (entry type).  */
+
+#define AT_NULL		0		/* End of vector */
+#define AT_IGNORE	1		/* Entry should be ignored */
+#define AT_EXECFD	2		/* File descriptor of program */
+#define AT_PHDR		3		/* Program headers for program */
+#define AT_PHENT	4		/* Size of program header entry */
+#define AT_PHNUM	5		/* Number of program headers */
+#define AT_PAGESZ	6		/* System page size */
+#define AT_BASE		7		/* Base address of interpreter */
+#define AT_FLAGS	8		/* Flags */
+#define AT_ENTRY	9		/* Entry point of program */
+#define AT_NOTELF	10		/* Program is not ELF */
+#define AT_UID		11		/* Real uid */
+#define AT_EUID		12		/* Effective uid */
+#define AT_GID		13		/* Real gid */
+#define AT_EGID		14		/* Effective gid */
+#define AT_CLKTCK	17		/* Frequency of times() */
+
+/* Some more special a_type values describing the hardware.  */
+#define AT_PLATFORM	15		/* String identifying platform.  */
+#define AT_HWCAP	16		/* Machine dependent hints about
+					   processor capabilities.  */
+
+/* This entry gives some information about the FPU initialization
+   performed by the kernel.  */
+#define AT_FPUCW	18		/* Used FPU control word.  */
+
+/* Cache block sizes.  */
+#define AT_DCACHEBSIZE	19		/* Data cache block size.  */
+#define AT_ICACHEBSIZE	20		/* Instruction cache block size.  */
+#define AT_UCACHEBSIZE	21		/* Unified cache block size.  */
+
+/* A special ignored value for PPC, used by the kernel to control the
+   interpretation of the AUXV. Must be > 16.  */
+#define AT_IGNOREPPC	22		/* Entry should be ignored.  */
+
+#define	AT_SECURE	23		/* Boolean, was exec setuid-like?  */
+
+/* Pointer to the global system page used for system calls and other
+   nice things.  */
+#define AT_SYSINFO	32
+#define AT_SYSINFO_EHDR	33
+
+/* Shapes of the caches.  Bits 0-3 contains associativity; bits 4-7 contains
+   log2 of line size; mask those to get cache size.  */
+#define AT_L1I_CACHESHAPE	34
+#define AT_L1D_CACHESHAPE	35
+#define AT_L2_CACHESHAPE	36
+#define AT_L3_CACHESHAPE	37
+
+/* Note section contents.  Each entry in the note section begins with
+   a header of a fixed form.  */
+
+typedef struct
+{
+  Elf32_Word n_namesz;			/* Length of the note's name.  */
+  Elf32_Word n_descsz;			/* Length of the note's descriptor.  */
+  Elf32_Word n_type;			/* Type of the note.  */
+} Elf32_Nhdr;
+
+typedef struct
+{
+  Elf64_Word n_namesz;			/* Length of the note's name.  */
+  Elf64_Word n_descsz;			/* Length of the note's descriptor.  */
+  Elf64_Word n_type;			/* Type of the note.  */
+} Elf64_Nhdr;
+
+/* Known names of notes.  */
+
+/* Solaris entries in the note section have this name.  */
+#define ELF_NOTE_SOLARIS	"SUNW Solaris"
+
+/* Note entries for GNU systems have this name.  */
+#define ELF_NOTE_GNU		"GNU"
+
+
+/* Defined types of notes for Solaris.  */
+
+/* Value of descriptor (one word) is desired pagesize for the binary.  */
+#define ELF_NOTE_PAGESIZE_HINT	1
+
+
+/* Defined note types for GNU systems.  */
+
+/* ABI information.  The descriptor consists of words:
+   word 0: OS descriptor
+   word 1: major version of the ABI
+   word 2: minor version of the ABI
+   word 3: subminor version of the ABI
+*/
+#define NT_GNU_ABI_TAG	1
+#define ELF_NOTE_ABI	NT_GNU_ABI_TAG /* Old name.  */
+
+/* Known OSes.  These values can appear in word 0 of an
+   NT_GNU_ABI_TAG note section entry.  */
+#define ELF_NOTE_OS_LINUX	0
+#define ELF_NOTE_OS_GNU		1
+#define ELF_NOTE_OS_SOLARIS2	2
+#define ELF_NOTE_OS_FREEBSD	3
+
+/* Synthetic hwcap information.  The descriptor begins with two words:
+   word 0: number of entries
+   word 1: bitmask of enabled entries
+   Then follow variable-length entries, one byte followed by a
+   '\0'-terminated hwcap name string.  The byte gives the bit
+   number to test if enabled, (1U << bit) & bitmask.  */
+#define NT_GNU_HWCAP	2
+
+/* Build ID bits as generated by ld --build-id.
+   The descriptor consists of any nonzero number of bytes.  */
+#define NT_GNU_BUILD_ID	3
+
+
+/* Move records.  */
+typedef struct
+{
+  Elf32_Xword m_value;		/* Symbol value.  */
+  Elf32_Word m_info;		/* Size and index.  */
+  Elf32_Word m_poffset;		/* Symbol offset.  */
+  Elf32_Half m_repeat;		/* Repeat count.  */
+  Elf32_Half m_stride;		/* Stride info.  */
+} Elf32_Move;
+
+typedef struct
+{
+  Elf64_Xword m_value;		/* Symbol value.  */
+  Elf64_Xword m_info;		/* Size and index.  */
+  Elf64_Xword m_poffset;	/* Symbol offset.  */
+  Elf64_Half m_repeat;		/* Repeat count.  */
+  Elf64_Half m_stride;		/* Stride info.  */
+} Elf64_Move;
+
+/* Macro to construct move records.  */
+#define ELF32_M_SYM(info)	((info) >> 8)
+#define ELF32_M_SIZE(info)	((unsigned char) (info))
+#define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))
+
+#define ELF64_M_SYM(info)	ELF32_M_SYM (info)
+#define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
+#define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)
+
+
+/* Motorola 68k specific definitions.  */
+
+/* Values for Elf32_Ehdr.e_flags.  */
+#define EF_CPU32	0x00810000
+
+/* m68k relocs.  */
+
+#define R_68K_NONE	0		/* No reloc */
+#define R_68K_32	1		/* Direct 32 bit  */
+#define R_68K_16	2		/* Direct 16 bit  */
+#define R_68K_8		3		/* Direct 8 bit  */
+#define R_68K_PC32	4		/* PC relative 32 bit */
+#define R_68K_PC16	5		/* PC relative 16 bit */
+#define R_68K_PC8	6		/* PC relative 8 bit */
+#define R_68K_GOT32	7		/* 32 bit PC relative GOT entry */
+#define R_68K_GOT16	8		/* 16 bit PC relative GOT entry */
+#define R_68K_GOT8	9		/* 8 bit PC relative GOT entry */
+#define R_68K_GOT32O	10		/* 32 bit GOT offset */
+#define R_68K_GOT16O	11		/* 16 bit GOT offset */
+#define R_68K_GOT8O	12		/* 8 bit GOT offset */
+#define R_68K_PLT32	13		/* 32 bit PC relative PLT address */
+#define R_68K_PLT16	14		/* 16 bit PC relative PLT address */
+#define R_68K_PLT8	15		/* 8 bit PC relative PLT address */
+#define R_68K_PLT32O	16		/* 32 bit PLT offset */
+#define R_68K_PLT16O	17		/* 16 bit PLT offset */
+#define R_68K_PLT8O	18		/* 8 bit PLT offset */
+#define R_68K_COPY	19		/* Copy symbol at runtime */
+#define R_68K_GLOB_DAT	20		/* Create GOT entry */
+#define R_68K_JMP_SLOT	21		/* Create PLT entry */
+#define R_68K_RELATIVE	22		/* Adjust by program base */
+/* Keep this the last entry.  */
+#define R_68K_NUM	23
+
+/* Intel 80386 specific definitions.  */
+
+/* i386 relocs.  */
+
+#define R_386_NONE	   0		/* No reloc */
+#define R_386_32	   1		/* Direct 32 bit  */
+#define R_386_PC32	   2		/* PC relative 32 bit */
+#define R_386_GOT32	   3		/* 32 bit GOT entry */
+#define R_386_PLT32	   4		/* 32 bit PLT address */
+#define R_386_COPY	   5		/* Copy symbol at runtime */
+#define R_386_GLOB_DAT	   6		/* Create GOT entry */
+#define R_386_JMP_SLOT	   7		/* Create PLT entry */
+#define R_386_RELATIVE	   8		/* Adjust by program base */
+#define R_386_GOTOFF	   9		/* 32 bit offset to GOT */
+#define R_386_GOTPC	   10		/* 32 bit PC relative offset to GOT */
+#define R_386_32PLT	   11
+#define R_386_TLS_TPOFF	   14		/* Offset in static TLS block */
+#define R_386_TLS_IE	   15		/* Address of GOT entry for static TLS
+					   block offset */
+#define R_386_TLS_GOTIE	   16		/* GOT entry for static TLS block
+					   offset */
+#define R_386_TLS_LE	   17		/* Offset relative to static TLS
+					   block */
+#define R_386_TLS_GD	   18		/* Direct 32 bit for GNU version of
+					   general dynamic thread local data */
+#define R_386_TLS_LDM	   19		/* Direct 32 bit for GNU version of
+					   local dynamic thread local data
+					   in LE code */
+#define R_386_16	   20
+#define R_386_PC16	   21
+#define R_386_8		   22
+#define R_386_PC8	   23
+#define R_386_TLS_GD_32	   24		/* Direct 32 bit for general dynamic
+					   thread local data */
+#define R_386_TLS_GD_PUSH  25		/* Tag for pushl in GD TLS code */
+#define R_386_TLS_GD_CALL  26		/* Relocation for call to
+					   __tls_get_addr() */
+#define R_386_TLS_GD_POP   27		/* Tag for popl in GD TLS code */
+#define R_386_TLS_LDM_32   28		/* Direct 32 bit for local dynamic
+					   thread local data in LE code */
+#define R_386_TLS_LDM_PUSH 29		/* Tag for pushl in LDM TLS code */
+#define R_386_TLS_LDM_CALL 30		/* Relocation for call to
+					   __tls_get_addr() in LDM code */
+#define R_386_TLS_LDM_POP  31		/* Tag for popl in LDM TLS code */
+#define R_386_TLS_LDO_32   32		/* Offset relative to TLS block */
+#define R_386_TLS_IE_32	   33		/* GOT entry for negated static TLS
+					   block offset */
+#define R_386_TLS_LE_32	   34		/* Negated offset relative to static
+					   TLS block */
+#define R_386_TLS_DTPMOD32 35		/* ID of module containing symbol */
+#define R_386_TLS_DTPOFF32 36		/* Offset in TLS block */
+#define R_386_TLS_TPOFF32  37		/* Negated offset in static TLS block */
+/* Keep this the last entry.  */
+#define R_386_NUM	   38
+
+/* SUN SPARC specific definitions.  */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
+
+#define STT_SPARC_REGISTER	13	/* Global register reserved to app. */
+
+/* Values for Elf64_Ehdr.e_flags.  */
+
+#define EF_SPARCV9_MM		3
+#define EF_SPARCV9_TSO		0
+#define EF_SPARCV9_PSO		1
+#define EF_SPARCV9_RMO		2
+#define EF_SPARC_LEDATA		0x800000 /* little endian data */
+#define EF_SPARC_EXT_MASK	0xFFFF00
+#define EF_SPARC_32PLUS		0x000100 /* generic V8+ features */
+#define EF_SPARC_SUN_US1	0x000200 /* Sun UltraSPARC1 extensions */
+#define EF_SPARC_HAL_R1		0x000400 /* HAL R1 extensions */
+#define EF_SPARC_SUN_US3	0x000800 /* Sun UltraSPARCIII extensions */
+
+/* SPARC relocs.  */
+
+#define R_SPARC_NONE		0	/* No reloc */
+#define R_SPARC_8		1	/* Direct 8 bit */
+#define R_SPARC_16		2	/* Direct 16 bit */
+#define R_SPARC_32		3	/* Direct 32 bit */
+#define R_SPARC_DISP8		4	/* PC relative 8 bit */
+#define R_SPARC_DISP16		5	/* PC relative 16 bit */
+#define R_SPARC_DISP32		6	/* PC relative 32 bit */
+#define R_SPARC_WDISP30		7	/* PC relative 30 bit shifted */
+#define R_SPARC_WDISP22		8	/* PC relative 22 bit shifted */
+#define R_SPARC_HI22		9	/* High 22 bit */
+#define R_SPARC_22		10	/* Direct 22 bit */
+#define R_SPARC_13		11	/* Direct 13 bit */
+#define R_SPARC_LO10		12	/* Truncated 10 bit */
+#define R_SPARC_GOT10		13	/* Truncated 10 bit GOT entry */
+#define R_SPARC_GOT13		14	/* 13 bit GOT entry */
+#define R_SPARC_GOT22		15	/* 22 bit GOT entry shifted */
+#define R_SPARC_PC10		16	/* PC relative 10 bit truncated */
+#define R_SPARC_PC22		17	/* PC relative 22 bit shifted */
+#define R_SPARC_WPLT30		18	/* 30 bit PC relative PLT address */
+#define R_SPARC_COPY		19	/* Copy symbol at runtime */
+#define R_SPARC_GLOB_DAT	20	/* Create GOT entry */
+#define R_SPARC_JMP_SLOT	21	/* Create PLT entry */
+#define R_SPARC_RELATIVE	22	/* Adjust by program base */
+#define R_SPARC_UA32		23	/* Direct 32 bit unaligned */
+
+/* Additional Sparc64 relocs.  */
+
+#define R_SPARC_PLT32		24	/* Direct 32 bit ref to PLT entry */
+#define R_SPARC_HIPLT22		25	/* High 22 bit PLT entry */
+#define R_SPARC_LOPLT10		26	/* Truncated 10 bit PLT entry */
+#define R_SPARC_PCPLT32		27	/* PC rel 32 bit ref to PLT entry */
+#define R_SPARC_PCPLT22		28	/* PC rel high 22 bit PLT entry */
+#define R_SPARC_PCPLT10		29	/* PC rel trunc 10 bit PLT entry */
+#define R_SPARC_10		30	/* Direct 10 bit */
+#define R_SPARC_11		31	/* Direct 11 bit */
+#define R_SPARC_64		32	/* Direct 64 bit */
+#define R_SPARC_OLO10		33	/* 10bit with secondary 13bit addend */
+#define R_SPARC_HH22		34	/* Top 22 bits of direct 64 bit */
+#define R_SPARC_HM10		35	/* High middle 10 bits of ... */
+#define R_SPARC_LM22		36	/* Low middle 22 bits of ... */
+#define R_SPARC_PC_HH22		37	/* Top 22 bits of pc rel 64 bit */
+#define R_SPARC_PC_HM10		38	/* High middle 10 bit of ... */
+#define R_SPARC_PC_LM22		39	/* Low miggle 22 bits of ... */
+#define R_SPARC_WDISP16		40	/* PC relative 16 bit shifted */
+#define R_SPARC_WDISP19		41	/* PC relative 19 bit shifted */
+#define R_SPARC_7		43	/* Direct 7 bit */
+#define R_SPARC_5		44	/* Direct 5 bit */
+#define R_SPARC_6		45	/* Direct 6 bit */
+#define R_SPARC_DISP64		46	/* PC relative 64 bit */
+#define R_SPARC_PLT64		47	/* Direct 64 bit ref to PLT entry */
+#define R_SPARC_HIX22		48	/* High 22 bit complemented */
+#define R_SPARC_LOX10		49	/* Truncated 11 bit complemented */
+#define R_SPARC_H44		50	/* Direct high 12 of 44 bit */
+#define R_SPARC_M44		51	/* Direct mid 22 of 44 bit */
+#define R_SPARC_L44		52	/* Direct low 10 of 44 bit */
+#define R_SPARC_REGISTER	53	/* Global register usage */
+#define R_SPARC_UA64		54	/* Direct 64 bit unaligned */
+#define R_SPARC_UA16		55	/* Direct 16 bit unaligned */
+#define R_SPARC_TLS_GD_HI22	56
+#define R_SPARC_TLS_GD_LO10	57
+#define R_SPARC_TLS_GD_ADD	58
+#define R_SPARC_TLS_GD_CALL	59
+#define R_SPARC_TLS_LDM_HI22	60
+#define R_SPARC_TLS_LDM_LO10	61
+#define R_SPARC_TLS_LDM_ADD	62
+#define R_SPARC_TLS_LDM_CALL	63
+#define R_SPARC_TLS_LDO_HIX22	64
+#define R_SPARC_TLS_LDO_LOX10	65
+#define R_SPARC_TLS_LDO_ADD	66
+#define R_SPARC_TLS_IE_HI22	67
+#define R_SPARC_TLS_IE_LO10	68
+#define R_SPARC_TLS_IE_LD	69
+#define R_SPARC_TLS_IE_LDX	70
+#define R_SPARC_TLS_IE_ADD	71
+#define R_SPARC_TLS_LE_HIX22	72
+#define R_SPARC_TLS_LE_LOX10	73
+#define R_SPARC_TLS_DTPMOD32	74
+#define R_SPARC_TLS_DTPMOD64	75
+#define R_SPARC_TLS_DTPOFF32	76
+#define R_SPARC_TLS_DTPOFF64	77
+#define R_SPARC_TLS_TPOFF32	78
+#define R_SPARC_TLS_TPOFF64	79
+/* Keep this the last entry.  */
+#define R_SPARC_NUM		80
+
+/* For Sparc64, legal values for d_tag of Elf64_Dyn.  */
+
+#define DT_SPARC_REGISTER 0x70000001
+#define DT_SPARC_NUM	2
+
+/* Bits present in AT_HWCAP on SPARC.  */
+
+#define HWCAP_SPARC_FLUSH	1	/* The CPU supports flush insn.  */
+#define HWCAP_SPARC_STBAR	2
+#define HWCAP_SPARC_SWAP	4
+#define HWCAP_SPARC_MULDIV	8
+#define HWCAP_SPARC_V9		16	/* The CPU is v9, so v8plus is ok.  */
+#define HWCAP_SPARC_ULTRA3	32
+#define HWCAP_SPARC_BLKINIT	64	/* Sun4v with block-init/load-twin.  */
+
+/* MIPS R3000 specific definitions.  */
+
+/* Legal values for e_flags field of Elf32_Ehdr.  */
+
+#define EF_MIPS_NOREORDER   1		/* A .noreorder directive was used */
+#define EF_MIPS_PIC	    2		/* Contains PIC code */
+#define EF_MIPS_CPIC	    4		/* Uses PIC calling sequence */
+#define EF_MIPS_XGOT	    8
+#define EF_MIPS_64BIT_WHIRL 16
+#define EF_MIPS_ABI2	    32
+#define EF_MIPS_ABI_ON32    64
+#define EF_MIPS_ARCH	    0xf0000000	/* MIPS architecture level */
+
+/* Legal values for MIPS architecture level.  */
+
+#define EF_MIPS_ARCH_1	    0x00000000	/* -mips1 code.  */
+#define EF_MIPS_ARCH_2	    0x10000000	/* -mips2 code.  */
+#define EF_MIPS_ARCH_3	    0x20000000	/* -mips3 code.  */
+#define EF_MIPS_ARCH_4	    0x30000000	/* -mips4 code.  */
+#define EF_MIPS_ARCH_5	    0x40000000	/* -mips5 code.  */
+#define EF_MIPS_ARCH_32	    0x60000000	/* MIPS32 code.  */
+#define EF_MIPS_ARCH_64	    0x70000000	/* MIPS64 code.  */
+
+/* The following are non-official names and should not be used.  */
+
+#define E_MIPS_ARCH_1	  0x00000000	/* -mips1 code.  */
+#define E_MIPS_ARCH_2	  0x10000000	/* -mips2 code.  */
+#define E_MIPS_ARCH_3	  0x20000000	/* -mips3 code.  */
+#define E_MIPS_ARCH_4	  0x30000000	/* -mips4 code.  */
+#define E_MIPS_ARCH_5	  0x40000000	/* -mips5 code.  */
+#define E_MIPS_ARCH_32	  0x60000000	/* MIPS32 code.  */
+#define E_MIPS_ARCH_64	  0x70000000	/* MIPS64 code.  */
+
+/* Special section indices.  */
+
+#define SHN_MIPS_ACOMMON    0xff00	/* Allocated common symbols */
+#define SHN_MIPS_TEXT	    0xff01	/* Allocated test symbols.  */
+#define SHN_MIPS_DATA	    0xff02	/* Allocated data symbols.  */
+#define SHN_MIPS_SCOMMON    0xff03	/* Small common symbols */
+#define SHN_MIPS_SUNDEFINED 0xff04	/* Small undefined symbols */
+
+/* Legal values for sh_type field of Elf32_Shdr.  */
+
+#define SHT_MIPS_LIBLIST       0x70000000 /* Shared objects used in link */
+#define SHT_MIPS_MSYM	       0x70000001
+#define SHT_MIPS_CONFLICT      0x70000002 /* Conflicting symbols */
+#define SHT_MIPS_GPTAB	       0x70000003 /* Global data area sizes */
+#define SHT_MIPS_UCODE	       0x70000004 /* Reserved for SGI/MIPS compilers */
+#define SHT_MIPS_DEBUG	       0x70000005 /* MIPS ECOFF debugging information*/
+#define SHT_MIPS_REGINFO       0x70000006 /* Register usage information */
+#define SHT_MIPS_PACKAGE       0x70000007
+#define SHT_MIPS_PACKSYM       0x70000008
+#define SHT_MIPS_RELD	       0x70000009
+#define SHT_MIPS_IFACE         0x7000000b
+#define SHT_MIPS_CONTENT       0x7000000c
+#define SHT_MIPS_OPTIONS       0x7000000d /* Miscellaneous options.  */
+#define SHT_MIPS_SHDR	       0x70000010
+#define SHT_MIPS_FDESC	       0x70000011
+#define SHT_MIPS_EXTSYM	       0x70000012
+#define SHT_MIPS_DENSE	       0x70000013
+#define SHT_MIPS_PDESC	       0x70000014
+#define SHT_MIPS_LOCSYM	       0x70000015
+#define SHT_MIPS_AUXSYM	       0x70000016
+#define SHT_MIPS_OPTSYM	       0x70000017
+#define SHT_MIPS_LOCSTR	       0x70000018
+#define SHT_MIPS_LINE	       0x70000019
+#define SHT_MIPS_RFDESC	       0x7000001a
+#define SHT_MIPS_DELTASYM      0x7000001b
+#define SHT_MIPS_DELTAINST     0x7000001c
+#define SHT_MIPS_DELTACLASS    0x7000001d
+#define SHT_MIPS_DWARF         0x7000001e /* DWARF debugging information.  */
+#define SHT_MIPS_DELTADECL     0x7000001f
+#define SHT_MIPS_SYMBOL_LIB    0x70000020
+#define SHT_MIPS_EVENTS	       0x70000021 /* Event section.  */
+#define SHT_MIPS_TRANSLATE     0x70000022
+#define SHT_MIPS_PIXIE	       0x70000023
+#define SHT_MIPS_XLATE	       0x70000024
+#define SHT_MIPS_XLATE_DEBUG   0x70000025
+#define SHT_MIPS_WHIRL	       0x70000026
+#define SHT_MIPS_EH_REGION     0x70000027
+#define SHT_MIPS_XLATE_OLD     0x70000028
+#define SHT_MIPS_PDR_EXCEPTION 0x70000029
+
+/* Legal values for sh_flags field of Elf32_Shdr.  */
+
+#define SHF_MIPS_GPREL	 0x10000000	/* Must be part of global data area */
+#define SHF_MIPS_MERGE	 0x20000000
+#define SHF_MIPS_ADDR	 0x40000000
+#define SHF_MIPS_STRINGS 0x80000000
+#define SHF_MIPS_NOSTRIP 0x08000000
+#define SHF_MIPS_LOCAL	 0x04000000
+#define SHF_MIPS_NAMES	 0x02000000
+#define SHF_MIPS_NODUPE	 0x01000000
+
+
+/* Symbol tables.  */
+
+/* MIPS specific values for `st_other'.  */
+#define STO_MIPS_DEFAULT		0x0
+#define STO_MIPS_INTERNAL		0x1
+#define STO_MIPS_HIDDEN			0x2
+#define STO_MIPS_PROTECTED		0x3
+#define STO_MIPS_SC_ALIGN_UNUSED	0xff
+
+/* MIPS specific values for `st_info'.  */
+#define STB_MIPS_SPLIT_COMMON		13
+
+/* Entries found in sections of type SHT_MIPS_GPTAB.  */
+
+typedef union
+{
+  struct
+    {
+      Elf32_Word gt_current_g_value;	/* -G value used for compilation */
+      Elf32_Word gt_unused;		/* Not used */
+    } gt_header;			/* First entry in section */
+  struct
+    {
+      Elf32_Word gt_g_value;		/* If this value were used for -G */
+      Elf32_Word gt_bytes;		/* This many bytes would be used */
+    } gt_entry;				/* Subsequent entries in section */
+} Elf32_gptab;
+
+/* Entry found in sections of type SHT_MIPS_REGINFO.  */
+
+typedef struct
+{
+  Elf32_Word	ri_gprmask;		/* General registers used */
+  Elf32_Word	ri_cprmask[4];		/* Coprocessor registers used */
+  Elf32_Sword	ri_gp_value;		/* $gp register value */
+} Elf32_RegInfo;
+
+/* Entries found in sections of type SHT_MIPS_OPTIONS.  */
+
+typedef struct
+{
+  unsigned char kind;		/* Determines interpretation of the
+				   variable part of descriptor.  */
+  unsigned char size;		/* Size of descriptor, including header.  */
+  Elf32_Section section;	/* Section header index of section affected,
+				   0 for global options.  */
+  Elf32_Word info;		/* Kind-specific information.  */
+} Elf_Options;
+
+/* Values for `kind' field in Elf_Options.  */
+
+#define ODK_NULL	0	/* Undefined.  */
+#define ODK_REGINFO	1	/* Register usage information.  */
+#define ODK_EXCEPTIONS	2	/* Exception processing options.  */
+#define ODK_PAD		3	/* Section padding options.  */
+#define ODK_HWPATCH	4	/* Hardware workarounds performed */
+#define ODK_FILL	5	/* record the fill value used by the linker. */
+#define ODK_TAGS	6	/* reserve space for desktop tools to write. */
+#define ODK_HWAND	7	/* HW workarounds.  'AND' bits when merging. */
+#define ODK_HWOR	8	/* HW workarounds.  'OR' bits when merging.  */
+
+/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries.  */
+
+#define OEX_FPU_MIN	0x1f	/* FPE's which MUST be enabled.  */
+#define OEX_FPU_MAX	0x1f00	/* FPE's which MAY be enabled.  */
+#define OEX_PAGE0	0x10000	/* page zero must be mapped.  */
+#define OEX_SMM		0x20000	/* Force sequential memory mode?  */
+#define OEX_FPDBUG	0x40000	/* Force floating point debug mode?  */
+#define OEX_PRECISEFP	OEX_FPDBUG
+#define OEX_DISMISS	0x80000	/* Dismiss invalid address faults?  */
+
+#define OEX_FPU_INVAL	0x10
+#define OEX_FPU_DIV0	0x08
+#define OEX_FPU_OFLO	0x04
+#define OEX_FPU_UFLO	0x02
+#define OEX_FPU_INEX	0x01
+
+/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry.  */
+
+#define OHW_R4KEOP	0x1	/* R4000 end-of-page patch.  */
+#define OHW_R8KPFETCH	0x2	/* may need R8000 prefetch patch.  */
+#define OHW_R5KEOP	0x4	/* R5000 end-of-page patch.  */
+#define OHW_R5KCVTL	0x8	/* R5000 cvt.[ds].l bug.  clean=1.  */
+
+#define OPAD_PREFIX	0x1
+#define OPAD_POSTFIX	0x2
+#define OPAD_SYMBOL	0x4
+
+/* Entry found in `.options' section.  */
+
+typedef struct
+{
+  Elf32_Word hwp_flags1;	/* Extra flags.  */
+  Elf32_Word hwp_flags2;	/* Extra flags.  */
+} Elf_Options_Hw;
+
+/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries.  */
+
+#define OHWA0_R4KEOP_CHECKED	0x00000001
+#define OHWA1_R4KEOP_CLEAN	0x00000002
+
+/* MIPS relocs.  */
+
+#define R_MIPS_NONE		0	/* No reloc */
+#define R_MIPS_16		1	/* Direct 16 bit */
+#define R_MIPS_32		2	/* Direct 32 bit */
+#define R_MIPS_REL32		3	/* PC relative 32 bit */
+#define R_MIPS_26		4	/* Direct 26 bit shifted */
+#define R_MIPS_HI16		5	/* High 16 bit */
+#define R_MIPS_LO16		6	/* Low 16 bit */
+#define R_MIPS_GPREL16		7	/* GP relative 16 bit */
+#define R_MIPS_LITERAL		8	/* 16 bit literal entry */
+#define R_MIPS_GOT16		9	/* 16 bit GOT entry */
+#define R_MIPS_PC16		10	/* PC relative 16 bit */
+#define R_MIPS_CALL16		11	/* 16 bit GOT entry for function */
+#define R_MIPS_GPREL32		12	/* GP relative 32 bit */
+
+#define R_MIPS_SHIFT5		16
+#define R_MIPS_SHIFT6		17
+#define R_MIPS_64		18
+#define R_MIPS_GOT_DISP		19
+#define R_MIPS_GOT_PAGE		20
+#define R_MIPS_GOT_OFST		21
+#define R_MIPS_GOT_HI16		22
+#define R_MIPS_GOT_LO16		23
+#define R_MIPS_SUB		24
+#define R_MIPS_INSERT_A		25
+#define R_MIPS_INSERT_B		26
+#define R_MIPS_DELETE		27
+#define R_MIPS_HIGHER		28
+#define R_MIPS_HIGHEST		29
+#define R_MIPS_CALL_HI16	30
+#define R_MIPS_CALL_LO16	31
+#define R_MIPS_SCN_DISP		32
+#define R_MIPS_REL16		33
+#define R_MIPS_ADD_IMMEDIATE	34
+#define R_MIPS_PJUMP		35
+#define R_MIPS_RELGOT		36
+#define R_MIPS_JALR		37
+#define R_MIPS_TLS_DTPMOD32	38	/* Module number 32 bit */
+#define R_MIPS_TLS_DTPREL32	39	/* Module-relative offset 32 bit */
+#define R_MIPS_TLS_DTPMOD64	40	/* Module number 64 bit */
+#define R_MIPS_TLS_DTPREL64	41	/* Module-relative offset 64 bit */
+#define R_MIPS_TLS_GD		42	/* 16 bit GOT offset for GD */
+#define R_MIPS_TLS_LDM		43	/* 16 bit GOT offset for LDM */
+#define R_MIPS_TLS_DTPREL_HI16	44	/* Module-relative offset, high 16 bits */
+#define R_MIPS_TLS_DTPREL_LO16	45	/* Module-relative offset, low 16 bits */
+#define R_MIPS_TLS_GOTTPREL	46	/* 16 bit GOT offset for IE */
+#define R_MIPS_TLS_TPREL32	47	/* TP-relative offset, 32 bit */
+#define R_MIPS_TLS_TPREL64	48	/* TP-relative offset, 64 bit */
+#define R_MIPS_TLS_TPREL_HI16	49	/* TP-relative offset, high 16 bits */
+#define R_MIPS_TLS_TPREL_LO16	50	/* TP-relative offset, low 16 bits */
+#define R_MIPS_GLOB_DAT		51
+/* Keep this the last entry.  */
+#define R_MIPS_NUM		52
+
+/* Legal values for p_type field of Elf32_Phdr.  */
+
+#define PT_MIPS_REGINFO	0x70000000	/* Register usage information */
+#define PT_MIPS_RTPROC  0x70000001	/* Runtime procedure table. */
+#define PT_MIPS_OPTIONS 0x70000002
+
+/* Special program header types.  */
+
+#define PF_MIPS_LOCAL	0x10000000
+
+/* Legal values for d_tag field of Elf32_Dyn.  */
+
+#define DT_MIPS_RLD_VERSION  0x70000001	/* Runtime linker interface version */
+#define DT_MIPS_TIME_STAMP   0x70000002	/* Timestamp */
+#define DT_MIPS_ICHECKSUM    0x70000003	/* Checksum */
+#define DT_MIPS_IVERSION     0x70000004	/* Version string (string tbl index) */
+#define DT_MIPS_FLAGS	     0x70000005	/* Flags */
+#define DT_MIPS_BASE_ADDRESS 0x70000006	/* Base address */
+#define DT_MIPS_MSYM	     0x70000007
+#define DT_MIPS_CONFLICT     0x70000008	/* Address of CONFLICT section */
+#define DT_MIPS_LIBLIST	     0x70000009	/* Address of LIBLIST section */
+#define DT_MIPS_LOCAL_GOTNO  0x7000000a	/* Number of local GOT entries */
+#define DT_MIPS_CONFLICTNO   0x7000000b	/* Number of CONFLICT entries */
+#define DT_MIPS_LIBLISTNO    0x70000010	/* Number of LIBLIST entries */
+#define DT_MIPS_SYMTABNO     0x70000011	/* Number of DYNSYM entries */
+#define DT_MIPS_UNREFEXTNO   0x70000012	/* First external DYNSYM */
+#define DT_MIPS_GOTSYM	     0x70000013	/* First GOT entry in DYNSYM */
+#define DT_MIPS_HIPAGENO     0x70000014	/* Number of GOT page table entries */
+#define DT_MIPS_RLD_MAP	     0x70000016	/* Address of run time loader map.  */
+#define DT_MIPS_DELTA_CLASS  0x70000017	/* Delta C++ class definition.  */
+#define DT_MIPS_DELTA_CLASS_NO    0x70000018 /* Number of entries in
+						DT_MIPS_DELTA_CLASS.  */
+#define DT_MIPS_DELTA_INSTANCE    0x70000019 /* Delta C++ class instances.  */
+#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in
+						DT_MIPS_DELTA_INSTANCE.  */
+#define DT_MIPS_DELTA_RELOC  0x7000001b /* Delta relocations.  */
+#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in
+					     DT_MIPS_DELTA_RELOC.  */
+#define DT_MIPS_DELTA_SYM    0x7000001d /* Delta symbols that Delta
+					   relocations refer to.  */
+#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in
+					   DT_MIPS_DELTA_SYM.  */
+#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the
+					     class declaration.  */
+#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in
+						DT_MIPS_DELTA_CLASSSYM.  */
+#define DT_MIPS_CXX_FLAGS    0x70000022 /* Flags indicating for C++ flavor.  */
+#define DT_MIPS_PIXIE_INIT   0x70000023
+#define DT_MIPS_SYMBOL_LIB   0x70000024
+#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
+#define DT_MIPS_LOCAL_GOTIDX 0x70000026
+#define DT_MIPS_HIDDEN_GOTIDX 0x70000027
+#define DT_MIPS_PROTECTED_GOTIDX 0x70000028
+#define DT_MIPS_OPTIONS	     0x70000029 /* Address of .options.  */
+#define DT_MIPS_INTERFACE    0x7000002a /* Address of .interface.  */
+#define DT_MIPS_DYNSTR_ALIGN 0x7000002b
+#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */
+#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve
+						    function stored in GOT.  */
+#define DT_MIPS_PERF_SUFFIX  0x7000002e /* Default suffix of dso to be added
+					   by rld on dlopen() calls.  */
+#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */
+#define DT_MIPS_GP_VALUE     0x70000030 /* GP value for aux GOTs.  */
+#define DT_MIPS_AUX_DYNAMIC  0x70000031 /* Address of aux .dynamic.  */
+#define DT_MIPS_NUM	     0x32
+
+/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry.  */
+
+#define RHF_NONE		   0		/* No flags */
+#define RHF_QUICKSTART		   (1 << 0)	/* Use quickstart */
+#define RHF_NOTPOT		   (1 << 1)	/* Hash size not power of 2 */
+#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2)	/* Ignore LD_LIBRARY_PATH */
+#define RHF_NO_MOVE		   (1 << 3)
+#define RHF_SGI_ONLY		   (1 << 4)
+#define RHF_GUARANTEE_INIT	   (1 << 5)
+#define RHF_DELTA_C_PLUS_PLUS	   (1 << 6)
+#define RHF_GUARANTEE_START_INIT   (1 << 7)
+#define RHF_PIXIE		   (1 << 8)
+#define RHF_DEFAULT_DELAY_LOAD	   (1 << 9)
+#define RHF_REQUICKSTART	   (1 << 10)
+#define RHF_REQUICKSTARTED	   (1 << 11)
+#define RHF_CORD		   (1 << 12)
+#define RHF_NO_UNRES_UNDEF	   (1 << 13)
+#define RHF_RLD_ORDER_SAFE	   (1 << 14)
+
+/* Entries found in sections of type SHT_MIPS_LIBLIST.  */
+
+typedef struct
+{
+  Elf32_Word l_name;		/* Name (string table index) */
+  Elf32_Word l_time_stamp;	/* Timestamp */
+  Elf32_Word l_checksum;	/* Checksum */
+  Elf32_Word l_version;		/* Interface version */
+  Elf32_Word l_flags;		/* Flags */
+} Elf32_Lib;
+
+typedef struct
+{
+  Elf64_Word l_name;		/* Name (string table index) */
+  Elf64_Word l_time_stamp;	/* Timestamp */
+  Elf64_Word l_checksum;	/* Checksum */
+  Elf64_Word l_version;		/* Interface version */
+  Elf64_Word l_flags;		/* Flags */
+} Elf64_Lib;
+
+
+/* Legal values for l_flags.  */
+
+#define LL_NONE		  0
+#define LL_EXACT_MATCH	  (1 << 0)	/* Require exact match */
+#define LL_IGNORE_INT_VER (1 << 1)	/* Ignore interface version */
+#define LL_REQUIRE_MINOR  (1 << 2)
+#define LL_EXPORTS	  (1 << 3)
+#define LL_DELAY_LOAD	  (1 << 4)
+#define LL_DELTA	  (1 << 5)
+
+/* Entries found in sections of type SHT_MIPS_CONFLICT.  */
+
+typedef Elf32_Addr Elf32_Conflict;
+
+
+/* HPPA specific definitions.  */
+
+/* Legal values for e_flags field of Elf32_Ehdr.  */
+
+#define EF_PARISC_TRAPNIL	0x00010000 /* Trap nil pointer dereference.  */
+#define EF_PARISC_EXT		0x00020000 /* Program uses arch. extensions. */
+#define EF_PARISC_LSB		0x00040000 /* Program expects little endian. */
+#define EF_PARISC_WIDE		0x00080000 /* Program expects wide mode.  */
+#define EF_PARISC_NO_KABP	0x00100000 /* No kernel assisted branch
+					      prediction.  */
+#define EF_PARISC_LAZYSWAP	0x00400000 /* Allow lazy swapping.  */
+#define EF_PARISC_ARCH		0x0000ffff /* Architecture version.  */
+
+/* Defined values for `e_flags & EF_PARISC_ARCH' are:  */
+
+#define EFA_PARISC_1_0		    0x020b /* PA-RISC 1.0 big-endian.  */
+#define EFA_PARISC_1_1		    0x0210 /* PA-RISC 1.1 big-endian.  */
+#define EFA_PARISC_2_0		    0x0214 /* PA-RISC 2.0 big-endian.  */
+
+/* Additional section indeces.  */
+
+#define SHN_PARISC_ANSI_COMMON	0xff00	   /* Section for tenatively declared
+					      symbols in ANSI C.  */
+#define SHN_PARISC_HUGE_COMMON	0xff01	   /* Common blocks in huge model.  */
+
+/* Legal values for sh_type field of Elf32_Shdr.  */
+
+#define SHT_PARISC_EXT		0x70000000 /* Contains product specific ext. */
+#define SHT_PARISC_UNWIND	0x70000001 /* Unwind information.  */
+#define SHT_PARISC_DOC		0x70000002 /* Debug info for optimized code. */
+
+/* Legal values for sh_flags field of Elf32_Shdr.  */
+
+#define SHF_PARISC_SHORT	0x20000000 /* Section with short addressing. */
+#define SHF_PARISC_HUGE		0x40000000 /* Section far from gp.  */
+#define SHF_PARISC_SBP		0x80000000 /* Static branch prediction code. */
+
+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
+
+#define STT_PARISC_MILLICODE	13	/* Millicode function entry point.  */
+
+#define STT_HP_OPAQUE		(STT_LOOS + 0x1)
+#define STT_HP_STUB		(STT_LOOS + 0x2)
+
+/* HPPA relocs.  */
+
+#define R_PARISC_NONE		0	/* No reloc.  */
+#define R_PARISC_DIR32		1	/* Direct 32-bit reference.  */
+#define R_PARISC_DIR21L		2	/* Left 21 bits of eff. address.  */
+#define R_PARISC_DIR17R		3	/* Right 17 bits of eff. address.  */
+#define R_PARISC_DIR17F		4	/* 17 bits of eff. address.  */
+#define R_PARISC_DIR14R		6	/* Right 14 bits of eff. address.  */
+#define R_PARISC_PCREL32	9	/* 32-bit rel. address.  */
+#define R_PARISC_PCREL21L	10	/* Left 21 bits of rel. address.  */
+#define R_PARISC_PCREL17R	11	/* Right 17 bits of rel. address.  */
+#define R_PARISC_PCREL17F	12	/* 17 bits of rel. address.  */
+#define R_PARISC_PCREL14R	14	/* Right 14 bits of rel. address.  */
+#define R_PARISC_DPREL21L	18	/* Left 21 bits of rel. address.  */
+#define R_PARISC_DPREL14R	22	/* Right 14 bits of rel. address.  */
+#define R_PARISC_GPREL21L	26	/* GP-relative, left 21 bits.  */
+#define R_PARISC_GPREL14R	30	/* GP-relative, right 14 bits.  */
+#define R_PARISC_LTOFF21L	34	/* LT-relative, left 21 bits.  */
+#define R_PARISC_LTOFF14R	38	/* LT-relative, right 14 bits.  */
+#define R_PARISC_SECREL32	41	/* 32 bits section rel. address.  */
+#define R_PARISC_SEGBASE	48	/* No relocation, set segment base.  */
+#define R_PARISC_SEGREL32	49	/* 32 bits segment rel. address.  */
+#define R_PARISC_PLTOFF21L	50	/* PLT rel. address, left 21 bits.  */
+#define R_PARISC_PLTOFF14R	54	/* PLT rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF_FPTR32	57	/* 32 bits LT-rel. function pointer. */
+#define R_PARISC_LTOFF_FPTR21L	58	/* LT-rel. fct ptr, left 21 bits. */
+#define R_PARISC_LTOFF_FPTR14R	62	/* LT-rel. fct ptr, right 14 bits. */
+#define R_PARISC_FPTR64		64	/* 64 bits function address.  */
+#define R_PARISC_PLABEL32	65	/* 32 bits function address.  */
+#define R_PARISC_PLABEL21L	66	/* Left 21 bits of fdesc address.  */
+#define R_PARISC_PLABEL14R	70	/* Right 14 bits of fdesc address.  */
+#define R_PARISC_PCREL64	72	/* 64 bits PC-rel. address.  */
+#define R_PARISC_PCREL22F	74	/* 22 bits PC-rel. address.  */
+#define R_PARISC_PCREL14WR	75	/* PC-rel. address, right 14 bits.  */
+#define R_PARISC_PCREL14DR	76	/* PC rel. address, right 14 bits.  */
+#define R_PARISC_PCREL16F	77	/* 16 bits PC-rel. address.  */
+#define R_PARISC_PCREL16WF	78	/* 16 bits PC-rel. address.  */
+#define R_PARISC_PCREL16DF	79	/* 16 bits PC-rel. address.  */
+#define R_PARISC_DIR64		80	/* 64 bits of eff. address.  */
+#define R_PARISC_DIR14WR	83	/* 14 bits of eff. address.  */
+#define R_PARISC_DIR14DR	84	/* 14 bits of eff. address.  */
+#define R_PARISC_DIR16F		85	/* 16 bits of eff. address.  */
+#define R_PARISC_DIR16WF	86	/* 16 bits of eff. address.  */
+#define R_PARISC_DIR16DF	87	/* 16 bits of eff. address.  */
+#define R_PARISC_GPREL64	88	/* 64 bits of GP-rel. address.  */
+#define R_PARISC_GPREL14WR	91	/* GP-rel. address, right 14 bits.  */
+#define R_PARISC_GPREL14DR	92	/* GP-rel. address, right 14 bits.  */
+#define R_PARISC_GPREL16F	93	/* 16 bits GP-rel. address.  */
+#define R_PARISC_GPREL16WF	94	/* 16 bits GP-rel. address.  */
+#define R_PARISC_GPREL16DF	95	/* 16 bits GP-rel. address.  */
+#define R_PARISC_LTOFF64	96	/* 64 bits LT-rel. address.  */
+#define R_PARISC_LTOFF14WR	99	/* LT-rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF14DR	100	/* LT-rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF16F	101	/* 16 bits LT-rel. address.  */
+#define R_PARISC_LTOFF16WF	102	/* 16 bits LT-rel. address.  */
+#define R_PARISC_LTOFF16DF	103	/* 16 bits LT-rel. address.  */
+#define R_PARISC_SECREL64	104	/* 64 bits section rel. address.  */
+#define R_PARISC_SEGREL64	112	/* 64 bits segment rel. address.  */
+#define R_PARISC_PLTOFF14WR	115	/* PLT-rel. address, right 14 bits.  */
+#define R_PARISC_PLTOFF14DR	116	/* PLT-rel. address, right 14 bits.  */
+#define R_PARISC_PLTOFF16F	117	/* 16 bits LT-rel. address.  */
+#define R_PARISC_PLTOFF16WF	118	/* 16 bits PLT-rel. address.  */
+#define R_PARISC_PLTOFF16DF	119	/* 16 bits PLT-rel. address.  */
+#define R_PARISC_LTOFF_FPTR64	120	/* 64 bits LT-rel. function ptr.  */
+#define R_PARISC_LTOFF_FPTR14WR	123	/* LT-rel. fct. ptr., right 14 bits. */
+#define R_PARISC_LTOFF_FPTR14DR	124	/* LT-rel. fct. ptr., right 14 bits. */
+#define R_PARISC_LTOFF_FPTR16F	125	/* 16 bits LT-rel. function ptr.  */
+#define R_PARISC_LTOFF_FPTR16WF	126	/* 16 bits LT-rel. function ptr.  */
+#define R_PARISC_LTOFF_FPTR16DF	127	/* 16 bits LT-rel. function ptr.  */
+#define R_PARISC_LORESERVE	128
+#define R_PARISC_COPY		128	/* Copy relocation.  */
+#define R_PARISC_IPLT		129	/* Dynamic reloc, imported PLT */
+#define R_PARISC_EPLT		130	/* Dynamic reloc, exported PLT */
+#define R_PARISC_TPREL32	153	/* 32 bits TP-rel. address.  */
+#define R_PARISC_TPREL21L	154	/* TP-rel. address, left 21 bits.  */
+#define R_PARISC_TPREL14R	158	/* TP-rel. address, right 14 bits.  */
+#define R_PARISC_LTOFF_TP21L	162	/* LT-TP-rel. address, left 21 bits. */
+#define R_PARISC_LTOFF_TP14R	166	/* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP14F	167	/* 14 bits LT-TP-rel. address.  */
+#define R_PARISC_TPREL64	216	/* 64 bits TP-rel. address.  */
+#define R_PARISC_TPREL14WR	219	/* TP-rel. address, right 14 bits.  */
+#define R_PARISC_TPREL14DR	220	/* TP-rel. address, right 14 bits.  */
+#define R_PARISC_TPREL16F	221	/* 16 bits TP-rel. address.  */
+#define R_PARISC_TPREL16WF	222	/* 16 bits TP-rel. address.  */
+#define R_PARISC_TPREL16DF	223	/* 16 bits TP-rel. address.  */
+#define R_PARISC_LTOFF_TP64	224	/* 64 bits LT-TP-rel. address.  */
+#define R_PARISC_LTOFF_TP14WR	227	/* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP14DR	228	/* LT-TP-rel. address, right 14 bits.*/
+#define R_PARISC_LTOFF_TP16F	229	/* 16 bits LT-TP-rel. address.  */
+#define R_PARISC_LTOFF_TP16WF	230	/* 16 bits LT-TP-rel. address.  */
+#define R_PARISC_LTOFF_TP16DF	231	/* 16 bits LT-TP-rel. address.  */
+#define R_PARISC_GNU_VTENTRY	232
+#define R_PARISC_GNU_VTINHERIT	233
+#define R_PARISC_TLS_GD21L	234	/* GD 21-bit left.  */
+#define R_PARISC_TLS_GD14R	235	/* GD 14-bit right.  */
+#define R_PARISC_TLS_GDCALL	236	/* GD call to __t_g_a.  */
+#define R_PARISC_TLS_LDM21L	237	/* LD module 21-bit left.  */
+#define R_PARISC_TLS_LDM14R	238	/* LD module 14-bit right.  */
+#define R_PARISC_TLS_LDMCALL	239	/* LD module call to __t_g_a.  */
+#define R_PARISC_TLS_LDO21L	240	/* LD offset 21-bit left.  */
+#define R_PARISC_TLS_LDO14R	241	/* LD offset 14-bit right.  */
+#define R_PARISC_TLS_DTPMOD32	242	/* DTP module 32-bit.  */
+#define R_PARISC_TLS_DTPMOD64	243	/* DTP module 64-bit.  */
+#define R_PARISC_TLS_DTPOFF32	244	/* DTP offset 32-bit.  */
+#define R_PARISC_TLS_DTPOFF64	245	/* DTP offset 32-bit.  */
+#define R_PARISC_TLS_LE21L	R_PARISC_TPREL21L
+#define R_PARISC_TLS_LE14R	R_PARISC_TPREL14R
+#define R_PARISC_TLS_IE21L	R_PARISC_LTOFF_TP21L
+#define R_PARISC_TLS_IE14R	R_PARISC_LTOFF_TP14R
+#define R_PARISC_TLS_TPREL32	R_PARISC_TPREL32
+#define R_PARISC_TLS_TPREL64	R_PARISC_TPREL64
+#define R_PARISC_HIRESERVE	255
+
+/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr.  */
+
+#define PT_HP_TLS		(PT_LOOS + 0x0)
+#define PT_HP_CORE_NONE		(PT_LOOS + 0x1)
+#define PT_HP_CORE_VERSION	(PT_LOOS + 0x2)
+#define PT_HP_CORE_KERNEL	(PT_LOOS + 0x3)
+#define PT_HP_CORE_COMM		(PT_LOOS + 0x4)
+#define PT_HP_CORE_PROC		(PT_LOOS + 0x5)
+#define PT_HP_CORE_LOADABLE	(PT_LOOS + 0x6)
+#define PT_HP_CORE_STACK	(PT_LOOS + 0x7)
+#define PT_HP_CORE_SHM		(PT_LOOS + 0x8)
+#define PT_HP_CORE_MMF		(PT_LOOS + 0x9)
+#define PT_HP_PARALLEL		(PT_LOOS + 0x10)
+#define PT_HP_FASTBIND		(PT_LOOS + 0x11)
+#define PT_HP_OPT_ANNOT		(PT_LOOS + 0x12)
+#define PT_HP_HSL_ANNOT		(PT_LOOS + 0x13)
+#define PT_HP_STACK		(PT_LOOS + 0x14)
+
+#define PT_PARISC_ARCHEXT	0x70000000
+#define PT_PARISC_UNWIND	0x70000001
+
+/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr.  */
+
+#define PF_PARISC_SBP		0x08000000
+
+#define PF_HP_PAGE_SIZE		0x00100000
+#define PF_HP_FAR_SHARED	0x00200000
+#define PF_HP_NEAR_SHARED	0x00400000
+#define PF_HP_CODE		0x01000000
+#define PF_HP_MODIFY		0x02000000
+#define PF_HP_LAZYSWAP		0x04000000
+#define PF_HP_SBP		0x08000000
+
+
+/* Alpha specific definitions.  */
+
+/* Legal values for e_flags field of Elf64_Ehdr.  */
+
+#define EF_ALPHA_32BIT		1	/* All addresses must be < 2GB.  */
+#define EF_ALPHA_CANRELAX	2	/* Relocations for relaxing exist.  */
+
+/* Legal values for sh_type field of Elf64_Shdr.  */
+
+/* These two are primerily concerned with ECOFF debugging info.  */
+#define SHT_ALPHA_DEBUG		0x70000001
+#define SHT_ALPHA_REGINFO	0x70000002
+
+/* Legal values for sh_flags field of Elf64_Shdr.  */
+
+#define SHF_ALPHA_GPREL		0x10000000
+
+/* Legal values for st_other field of Elf64_Sym.  */
+#define STO_ALPHA_NOPV		0x80	/* No PV required.  */
+#define STO_ALPHA_STD_GPLOAD	0x88	/* PV only used for initial ldgp.  */
+
+/* Alpha relocs.  */
+
+#define R_ALPHA_NONE		0	/* No reloc */
+#define R_ALPHA_REFLONG		1	/* Direct 32 bit */
+#define R_ALPHA_REFQUAD		2	/* Direct 64 bit */
+#define R_ALPHA_GPREL32		3	/* GP relative 32 bit */
+#define R_ALPHA_LITERAL		4	/* GP relative 16 bit w/optimization */
+#define R_ALPHA_LITUSE		5	/* Optimization hint for LITERAL */
+#define R_ALPHA_GPDISP		6	/* Add displacement to GP */
+#define R_ALPHA_BRADDR		7	/* PC+4 relative 23 bit shifted */
+#define R_ALPHA_HINT		8	/* PC+4 relative 16 bit shifted */
+#define R_ALPHA_SREL16		9	/* PC relative 16 bit */
+#define R_ALPHA_SREL32		10	/* PC relative 32 bit */
+#define R_ALPHA_SREL64		11	/* PC relative 64 bit */
+#define R_ALPHA_GPRELHIGH	17	/* GP relative 32 bit, high 16 bits */
+#define R_ALPHA_GPRELLOW	18	/* GP relative 32 bit, low 16 bits */
+#define R_ALPHA_GPREL16		19	/* GP relative 16 bit */
+#define R_ALPHA_COPY		24	/* Copy symbol at runtime */
+#define R_ALPHA_GLOB_DAT	25	/* Create GOT entry */
+#define R_ALPHA_JMP_SLOT	26	/* Create PLT entry */
+#define R_ALPHA_RELATIVE	27	/* Adjust by program base */
+#define R_ALPHA_TLS_GD_HI	28
+#define R_ALPHA_TLSGD		29
+#define R_ALPHA_TLS_LDM		30
+#define R_ALPHA_DTPMOD64	31
+#define R_ALPHA_GOTDTPREL	32
+#define R_ALPHA_DTPREL64	33
+#define R_ALPHA_DTPRELHI	34
+#define R_ALPHA_DTPRELLO	35
+#define R_ALPHA_DTPREL16	36
+#define R_ALPHA_GOTTPREL	37
+#define R_ALPHA_TPREL64		38
+#define R_ALPHA_TPRELHI		39
+#define R_ALPHA_TPRELLO		40
+#define R_ALPHA_TPREL16		41
+/* Keep this the last entry.  */
+#define R_ALPHA_NUM		46
+
+/* Magic values of the LITUSE relocation addend.  */
+#define LITUSE_ALPHA_ADDR	0
+#define LITUSE_ALPHA_BASE	1
+#define LITUSE_ALPHA_BYTOFF	2
+#define LITUSE_ALPHA_JSR	3
+#define LITUSE_ALPHA_TLS_GD	4
+#define LITUSE_ALPHA_TLS_LDM	5
+
+/* Legal values for d_tag of Elf64_Dyn.  */
+#define DT_ALPHA_PLTRO		(DT_LOPROC + 0)
+#define DT_ALPHA_NUM		1
+
+/* PowerPC specific declarations */
+
+/* Values for Elf32/64_Ehdr.e_flags.  */
+#define EF_PPC_EMB		0x80000000	/* PowerPC embedded flag */
+
+/* Cygnus local bits below */
+#define EF_PPC_RELOCATABLE	0x00010000	/* PowerPC -mrelocatable flag*/
+#define EF_PPC_RELOCATABLE_LIB	0x00008000	/* PowerPC -mrelocatable-lib
+						   flag */
+
+/* PowerPC relocations defined by the ABIs */
+#define R_PPC_NONE		0
+#define R_PPC_ADDR32		1	/* 32bit absolute address */
+#define R_PPC_ADDR24		2	/* 26bit address, 2 bits ignored.  */
+#define R_PPC_ADDR16		3	/* 16bit absolute address */
+#define R_PPC_ADDR16_LO		4	/* lower 16bit of absolute address */
+#define R_PPC_ADDR16_HI		5	/* high 16bit of absolute address */
+#define R_PPC_ADDR16_HA		6	/* adjusted high 16bit */
+#define R_PPC_ADDR14		7	/* 16bit address, 2 bits ignored */
+#define R_PPC_ADDR14_BRTAKEN	8
+#define R_PPC_ADDR14_BRNTAKEN	9
+#define R_PPC_REL24		10	/* PC relative 26 bit */
+#define R_PPC_REL14		11	/* PC relative 16 bit */
+#define R_PPC_REL14_BRTAKEN	12
+#define R_PPC_REL14_BRNTAKEN	13
+#define R_PPC_GOT16		14
+#define R_PPC_GOT16_LO		15
+#define R_PPC_GOT16_HI		16
+#define R_PPC_GOT16_HA		17
+#define R_PPC_PLTREL24		18
+#define R_PPC_COPY		19
+#define R_PPC_GLOB_DAT		20
+#define R_PPC_JMP_SLOT		21
+#define R_PPC_RELATIVE		22
+#define R_PPC_LOCAL24PC		23
+#define R_PPC_UADDR32		24
+#define R_PPC_UADDR16		25
+#define R_PPC_REL32		26
+#define R_PPC_PLT32		27
+#define R_PPC_PLTREL32		28
+#define R_PPC_PLT16_LO		29
+#define R_PPC_PLT16_HI		30
+#define R_PPC_PLT16_HA		31
+#define R_PPC_SDAREL16		32
+#define R_PPC_SECTOFF		33
+#define R_PPC_SECTOFF_LO	34
+#define R_PPC_SECTOFF_HI	35
+#define R_PPC_SECTOFF_HA	36
+
+/* PowerPC relocations defined for the TLS access ABI.  */
+#define R_PPC_TLS		67 /* none	(sym+add)@tls */
+#define R_PPC_DTPMOD32		68 /* word32	(sym+add)@dtpmod */
+#define R_PPC_TPREL16		69 /* half16*	(sym+add)@tprel */
+#define R_PPC_TPREL16_LO	70 /* half16	(sym+add)@tprel@l */
+#define R_PPC_TPREL16_HI	71 /* half16	(sym+add)@tprel@h */
+#define R_PPC_TPREL16_HA	72 /* half16	(sym+add)@tprel@ha */
+#define R_PPC_TPREL32		73 /* word32	(sym+add)@tprel */
+#define R_PPC_DTPREL16		74 /* half16*	(sym+add)@dtprel */
+#define R_PPC_DTPREL16_LO	75 /* half16	(sym+add)@dtprel@l */
+#define R_PPC_DTPREL16_HI	76 /* half16	(sym+add)@dtprel@h */
+#define R_PPC_DTPREL16_HA	77 /* half16	(sym+add)@dtprel@ha */
+#define R_PPC_DTPREL32		78 /* word32	(sym+add)@dtprel */
+#define R_PPC_GOT_TLSGD16	79 /* half16*	(sym+add)@got@tlsgd */
+#define R_PPC_GOT_TLSGD16_LO	80 /* half16	(sym+add)@got@tlsgd@l */
+#define R_PPC_GOT_TLSGD16_HI	81 /* half16	(sym+add)@got@tlsgd@h */
+#define R_PPC_GOT_TLSGD16_HA	82 /* half16	(sym+add)@got@tlsgd@ha */
+#define R_PPC_GOT_TLSLD16	83 /* half16*	(sym+add)@got@tlsld */
+#define R_PPC_GOT_TLSLD16_LO	84 /* half16	(sym+add)@got@tlsld@l */
+#define R_PPC_GOT_TLSLD16_HI	85 /* half16	(sym+add)@got@tlsld@h */
+#define R_PPC_GOT_TLSLD16_HA	86 /* half16	(sym+add)@got@tlsld@ha */
+#define R_PPC_GOT_TPREL16	87 /* half16*	(sym+add)@got@tprel */
+#define R_PPC_GOT_TPREL16_LO	88 /* half16	(sym+add)@got@tprel@l */
+#define R_PPC_GOT_TPREL16_HI	89 /* half16	(sym+add)@got@tprel@h */
+#define R_PPC_GOT_TPREL16_HA	90 /* half16	(sym+add)@got@tprel@ha */
+#define R_PPC_GOT_DTPREL16	91 /* half16*	(sym+add)@got@dtprel */
+#define R_PPC_GOT_DTPREL16_LO	92 /* half16*	(sym+add)@got@dtprel@l */
+#define R_PPC_GOT_DTPREL16_HI	93 /* half16*	(sym+add)@got@dtprel@h */
+#define R_PPC_GOT_DTPREL16_HA	94 /* half16*	(sym+add)@got@dtprel@ha */
+
+/* Keep this the last entry.  */
+#define R_PPC_NUM		95
+
+/* The remaining relocs are from the Embedded ELF ABI, and are not
+   in the SVR4 ELF ABI.  */
+#define R_PPC_EMB_NADDR32	101
+#define R_PPC_EMB_NADDR16	102
+#define R_PPC_EMB_NADDR16_LO	103
+#define R_PPC_EMB_NADDR16_HI	104
+#define R_PPC_EMB_NADDR16_HA	105
+#define R_PPC_EMB_SDAI16	106
+#define R_PPC_EMB_SDA2I16	107
+#define R_PPC_EMB_SDA2REL	108
+#define R_PPC_EMB_SDA21		109	/* 16 bit offset in SDA */
+#define R_PPC_EMB_MRKREF	110
+#define R_PPC_EMB_RELSEC16	111
+#define R_PPC_EMB_RELST_LO	112
+#define R_PPC_EMB_RELST_HI	113
+#define R_PPC_EMB_RELST_HA	114
+#define R_PPC_EMB_BIT_FLD	115
+#define R_PPC_EMB_RELSDA	116	/* 16 bit relative offset in SDA */
+
+/* Diab tool relocations.  */
+#define R_PPC_DIAB_SDA21_LO	180	/* like EMB_SDA21, but lower 16 bit */
+#define R_PPC_DIAB_SDA21_HI	181	/* like EMB_SDA21, but high 16 bit */
+#define R_PPC_DIAB_SDA21_HA	182	/* like EMB_SDA21, adjusted high 16 */
+#define R_PPC_DIAB_RELSDA_LO	183	/* like EMB_RELSDA, but lower 16 bit */
+#define R_PPC_DIAB_RELSDA_HI	184	/* like EMB_RELSDA, but high 16 bit */
+#define R_PPC_DIAB_RELSDA_HA	185	/* like EMB_RELSDA, adjusted high 16 */
+
+/* GNU relocs used in PIC code sequences.  */
+#define R_PPC_REL16		249	/* word32   (sym-.) */
+#define R_PPC_REL16_LO		250	/* half16   (sym-.)@l */
+#define R_PPC_REL16_HI		251	/* half16   (sym-.)@h */
+#define R_PPC_REL16_HA		252	/* half16   (sym-.)@ha */
+
+/* This is a phony reloc to handle any old fashioned TOC16 references
+   that may still be in object files.  */
+#define R_PPC_TOC16		255
+
+/* PowerPC specific values for the Dyn d_tag field.  */
+#define DT_PPC_GOT		(DT_LOPROC + 0)
+#define DT_PPC_NUM		1
+
+/* PowerPC64 relocations defined by the ABIs */
+#define R_PPC64_NONE		R_PPC_NONE
+#define R_PPC64_ADDR32		R_PPC_ADDR32 /* 32bit absolute address */
+#define R_PPC64_ADDR24		R_PPC_ADDR24 /* 26bit address, word aligned */
+#define R_PPC64_ADDR16		R_PPC_ADDR16 /* 16bit absolute address */
+#define R_PPC64_ADDR16_LO	R_PPC_ADDR16_LO	/* lower 16bits of address */
+#define R_PPC64_ADDR16_HI	R_PPC_ADDR16_HI	/* high 16bits of address. */
+#define R_PPC64_ADDR16_HA	R_PPC_ADDR16_HA /* adjusted high 16bits.  */
+#define R_PPC64_ADDR14		R_PPC_ADDR14 /* 16bit address, word aligned */
+#define R_PPC64_ADDR14_BRTAKEN	R_PPC_ADDR14_BRTAKEN
+#define R_PPC64_ADDR14_BRNTAKEN	R_PPC_ADDR14_BRNTAKEN
+#define R_PPC64_REL24		R_PPC_REL24 /* PC-rel. 26 bit, word aligned */
+#define R_PPC64_REL14		R_PPC_REL14 /* PC relative 16 bit */
+#define R_PPC64_REL14_BRTAKEN	R_PPC_REL14_BRTAKEN
+#define R_PPC64_REL14_BRNTAKEN	R_PPC_REL14_BRNTAKEN
+#define R_PPC64_GOT16		R_PPC_GOT16
+#define R_PPC64_GOT16_LO	R_PPC_GOT16_LO
+#define R_PPC64_GOT16_HI	R_PPC_GOT16_HI
+#define R_PPC64_GOT16_HA	R_PPC_GOT16_HA
+
+#define R_PPC64_COPY		R_PPC_COPY
+#define R_PPC64_GLOB_DAT	R_PPC_GLOB_DAT
+#define R_PPC64_JMP_SLOT	R_PPC_JMP_SLOT
+#define R_PPC64_RELATIVE	R_PPC_RELATIVE
+
+#define R_PPC64_UADDR32		R_PPC_UADDR32
+#define R_PPC64_UADDR16		R_PPC_UADDR16
+#define R_PPC64_REL32		R_PPC_REL32
+#define R_PPC64_PLT32		R_PPC_PLT32
+#define R_PPC64_PLTREL32	R_PPC_PLTREL32
+#define R_PPC64_PLT16_LO	R_PPC_PLT16_LO
+#define R_PPC64_PLT16_HI	R_PPC_PLT16_HI
+#define R_PPC64_PLT16_HA	R_PPC_PLT16_HA
+
+#define R_PPC64_SECTOFF		R_PPC_SECTOFF
+#define R_PPC64_SECTOFF_LO	R_PPC_SECTOFF_LO
+#define R_PPC64_SECTOFF_HI	R_PPC_SECTOFF_HI
+#define R_PPC64_SECTOFF_HA	R_PPC_SECTOFF_HA
+#define R_PPC64_ADDR30		37 /* word30 (S + A - P) >> 2 */
+#define R_PPC64_ADDR64		38 /* doubleword64 S + A */
+#define R_PPC64_ADDR16_HIGHER	39 /* half16 #higher(S + A) */
+#define R_PPC64_ADDR16_HIGHERA	40 /* half16 #highera(S + A) */
+#define R_PPC64_ADDR16_HIGHEST	41 /* half16 #highest(S + A) */
+#define R_PPC64_ADDR16_HIGHESTA	42 /* half16 #highesta(S + A) */
+#define R_PPC64_UADDR64		43 /* doubleword64 S + A */
+#define R_PPC64_REL64		44 /* doubleword64 S + A - P */
+#define R_PPC64_PLT64		45 /* doubleword64 L + A */
+#define R_PPC64_PLTREL64	46 /* doubleword64 L + A - P */
+#define R_PPC64_TOC16		47 /* half16* S + A - .TOC */
+#define R_PPC64_TOC16_LO	48 /* half16 #lo(S + A - .TOC.) */
+#define R_PPC64_TOC16_HI	49 /* half16 #hi(S + A - .TOC.) */
+#define R_PPC64_TOC16_HA	50 /* half16 #ha(S + A - .TOC.) */
+#define R_PPC64_TOC		51 /* doubleword64 .TOC */
+#define R_PPC64_PLTGOT16	52 /* half16* M + A */
+#define R_PPC64_PLTGOT16_LO	53 /* half16 #lo(M + A) */
+#define R_PPC64_PLTGOT16_HI	54 /* half16 #hi(M + A) */
+#define R_PPC64_PLTGOT16_HA	55 /* half16 #ha(M + A) */
+
+#define R_PPC64_ADDR16_DS	56 /* half16ds* (S + A) >> 2 */
+#define R_PPC64_ADDR16_LO_DS	57 /* half16ds  #lo(S + A) >> 2 */
+#define R_PPC64_GOT16_DS	58 /* half16ds* (G + A) >> 2 */
+#define R_PPC64_GOT16_LO_DS	59 /* half16ds  #lo(G + A) >> 2 */
+#define R_PPC64_PLT16_LO_DS	60 /* half16ds  #lo(L + A) >> 2 */
+#define R_PPC64_SECTOFF_DS	61 /* half16ds* (R + A) >> 2 */
+#define R_PPC64_SECTOFF_LO_DS	62 /* half16ds  #lo(R + A) >> 2 */
+#define R_PPC64_TOC16_DS	63 /* half16ds* (S + A - .TOC.) >> 2 */
+#define R_PPC64_TOC16_LO_DS	64 /* half16ds  #lo(S + A - .TOC.) >> 2 */
+#define R_PPC64_PLTGOT16_DS	65 /* half16ds* (M + A) >> 2 */
+#define R_PPC64_PLTGOT16_LO_DS	66 /* half16ds  #lo(M + A) >> 2 */
+
+/* PowerPC64 relocations defined for the TLS access ABI.  */
+#define R_PPC64_TLS		67 /* none	(sym+add)@tls */
+#define R_PPC64_DTPMOD64	68 /* doubleword64 (sym+add)@dtpmod */
+#define R_PPC64_TPREL16		69 /* half16*	(sym+add)@tprel */
+#define R_PPC64_TPREL16_LO	70 /* half16	(sym+add)@tprel@l */
+#define R_PPC64_TPREL16_HI	71 /* half16	(sym+add)@tprel@h */
+#define R_PPC64_TPREL16_HA	72 /* half16	(sym+add)@tprel@ha */
+#define R_PPC64_TPREL64		73 /* doubleword64 (sym+add)@tprel */
+#define R_PPC64_DTPREL16	74 /* half16*	(sym+add)@dtprel */
+#define R_PPC64_DTPREL16_LO	75 /* half16	(sym+add)@dtprel@l */
+#define R_PPC64_DTPREL16_HI	76 /* half16	(sym+add)@dtprel@h */
+#define R_PPC64_DTPREL16_HA	77 /* half16	(sym+add)@dtprel@ha */
+#define R_PPC64_DTPREL64	78 /* doubleword64 (sym+add)@dtprel */
+#define R_PPC64_GOT_TLSGD16	79 /* half16*	(sym+add)@got@tlsgd */
+#define R_PPC64_GOT_TLSGD16_LO	80 /* half16	(sym+add)@got@tlsgd@l */
+#define R_PPC64_GOT_TLSGD16_HI	81 /* half16	(sym+add)@got@tlsgd@h */
+#define R_PPC64_GOT_TLSGD16_HA	82 /* half16	(sym+add)@got@tlsgd@ha */
+#define R_PPC64_GOT_TLSLD16	83 /* half16*	(sym+add)@got@tlsld */
+#define R_PPC64_GOT_TLSLD16_LO	84 /* half16	(sym+add)@got@tlsld@l */
+#define R_PPC64_GOT_TLSLD16_HI	85 /* half16	(sym+add)@got@tlsld@h */
+#define R_PPC64_GOT_TLSLD16_HA	86 /* half16	(sym+add)@got@tlsld@ha */
+#define R_PPC64_GOT_TPREL16_DS	87 /* half16ds*	(sym+add)@got@tprel */
+#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */
+#define R_PPC64_GOT_TPREL16_HI	89 /* half16	(sym+add)@got@tprel@h */
+#define R_PPC64_GOT_TPREL16_HA	90 /* half16	(sym+add)@got@tprel@ha */
+#define R_PPC64_GOT_DTPREL16_DS	91 /* half16ds*	(sym+add)@got@dtprel */
+#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */
+#define R_PPC64_GOT_DTPREL16_HI	93 /* half16	(sym+add)@got@dtprel@h */
+#define R_PPC64_GOT_DTPREL16_HA	94 /* half16	(sym+add)@got@dtprel@ha */
+#define R_PPC64_TPREL16_DS	95 /* half16ds*	(sym+add)@tprel */
+#define R_PPC64_TPREL16_LO_DS	96 /* half16ds	(sym+add)@tprel@l */
+#define R_PPC64_TPREL16_HIGHER	97 /* half16	(sym+add)@tprel@higher */
+#define R_PPC64_TPREL16_HIGHERA	98 /* half16	(sym+add)@tprel@highera */
+#define R_PPC64_TPREL16_HIGHEST	99 /* half16	(sym+add)@tprel@highest */
+#define R_PPC64_TPREL16_HIGHESTA 100 /* half16	(sym+add)@tprel@highesta */
+#define R_PPC64_DTPREL16_DS	101 /* half16ds* (sym+add)@dtprel */
+#define R_PPC64_DTPREL16_LO_DS	102 /* half16ds	(sym+add)@dtprel@l */
+#define R_PPC64_DTPREL16_HIGHER	103 /* half16	(sym+add)@dtprel@higher */
+#define R_PPC64_DTPREL16_HIGHERA 104 /* half16	(sym+add)@dtprel@highera */
+#define R_PPC64_DTPREL16_HIGHEST 105 /* half16	(sym+add)@dtprel@highest */
+#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16	(sym+add)@dtprel@highesta */
+
+/* Keep this the last entry.  */
+#define R_PPC64_NUM		107
+
+/* PowerPC64 specific values for the Dyn d_tag field.  */
+#define DT_PPC64_GLINK  (DT_LOPROC + 0)
+#define DT_PPC64_OPD	(DT_LOPROC + 1)
+#define DT_PPC64_OPDSZ	(DT_LOPROC + 2)
+#define DT_PPC64_NUM    3
+
+
+/* ARM specific declarations */
+
+/* Processor specific flags for the ELF header e_flags field.  */
+#define EF_ARM_RELEXEC     0x01
+#define EF_ARM_HASENTRY    0x02
+#define EF_ARM_INTERWORK   0x04
+#define EF_ARM_APCS_26     0x08
+#define EF_ARM_APCS_FLOAT  0x10
+#define EF_ARM_PIC         0x20
+#define EF_ARM_ALIGN8      0x40		/* 8-bit structure alignment is in use */
+#define EF_ARM_NEW_ABI     0x80
+#define EF_ARM_OLD_ABI     0x100
+
+/* Other constants defined in the ARM ELF spec. version B-01.  */
+/* NB. These conflict with values defined above.  */
+#define EF_ARM_SYMSARESORTED	0x04
+#define EF_ARM_DYNSYMSUSESEGIDX 0x08
+#define EF_ARM_MAPSYMSFIRST	0x10
+#define EF_ARM_EABIMASK		0XFF000000
+
+#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK)
+#define EF_ARM_EABI_UNKNOWN  0x00000000
+#define EF_ARM_EABI_VER1     0x01000000
+#define EF_ARM_EABI_VER2     0x02000000
+
+/* Additional symbol types for Thumb */
+#define STT_ARM_TFUNC      0xd
+
+/* ARM-specific values for sh_flags */
+#define SHF_ARM_ENTRYSECT  0x10000000   /* Section contains an entry point */
+#define SHF_ARM_COMDEF     0x80000000   /* Section may be multiply defined
+					   in the input to a link step */
+
+/* ARM-specific program header flags */
+#define PF_ARM_SB          0x10000000   /* Segment contains the location
+					   addressed by the static base */
+
+/* Processor specific values for the Phdr p_type field.  */
+#define PT_ARM_EXIDX	0x70000001	/* .ARM.exidx segment */
+
+/* ARM relocs.  */
+
+#define R_ARM_NONE		0	/* No reloc */
+#define R_ARM_PC24		1	/* PC relative 26 bit branch */
+#define R_ARM_ABS32		2	/* Direct 32 bit  */
+#define R_ARM_REL32		3	/* PC relative 32 bit */
+#define R_ARM_PC13		4
+#define R_ARM_ABS16		5	/* Direct 16 bit */
+#define R_ARM_ABS12		6	/* Direct 12 bit */
+#define R_ARM_THM_ABS5		7
+#define R_ARM_ABS8		8	/* Direct 8 bit */
+#define R_ARM_SBREL32		9
+#define R_ARM_THM_PC22		10
+#define R_ARM_THM_PC8		11
+#define R_ARM_AMP_VCALL9	12
+#define R_ARM_SWI24		13
+#define R_ARM_THM_SWI8		14
+#define R_ARM_XPC25		15
+#define R_ARM_THM_XPC22		16
+#define R_ARM_TLS_DTPMOD32	17	/* ID of module containing symbol */
+#define R_ARM_TLS_DTPOFF32	18	/* Offset in TLS block */
+#define R_ARM_TLS_TPOFF32	19	/* Offset in static TLS block */
+#define R_ARM_COPY		20	/* Copy symbol at runtime */
+#define R_ARM_GLOB_DAT		21	/* Create GOT entry */
+#define R_ARM_JUMP_SLOT		22	/* Create PLT entry */
+#define R_ARM_RELATIVE		23	/* Adjust by program base */
+#define R_ARM_GOTOFF		24	/* 32 bit offset to GOT */
+#define R_ARM_GOTPC		25	/* 32 bit PC relative offset to GOT */
+#define R_ARM_GOT32		26	/* 32 bit GOT entry */
+#define R_ARM_PLT32		27	/* 32 bit PLT address */
+#define R_ARM_ALU_PCREL_7_0	32
+#define R_ARM_ALU_PCREL_15_8	33
+#define R_ARM_ALU_PCREL_23_15	34
+#define R_ARM_LDR_SBREL_11_0	35
+#define R_ARM_ALU_SBREL_19_12	36
+#define R_ARM_ALU_SBREL_27_20	37
+#define R_ARM_GNU_VTENTRY	100
+#define R_ARM_GNU_VTINHERIT	101
+#define R_ARM_THM_PC11		102	/* thumb unconditional branch */
+#define R_ARM_THM_PC9		103	/* thumb conditional branch */
+#define R_ARM_TLS_GD32		104	/* PC-rel 32 bit for global dynamic
+					   thread local data */
+#define R_ARM_TLS_LDM32		105	/* PC-rel 32 bit for local dynamic
+					   thread local data */
+#define R_ARM_TLS_LDO32		106	/* 32 bit offset relative to TLS
+					   block */
+#define R_ARM_TLS_IE32		107	/* PC-rel 32 bit for GOT entry of
+					   static TLS block offset */
+#define R_ARM_TLS_LE32		108	/* 32 bit offset relative to static
+					   TLS block */
+#define R_ARM_RXPC25		249
+#define R_ARM_RSBREL32		250
+#define R_ARM_THM_RPC22		251
+#define R_ARM_RREL32		252
+#define R_ARM_RABS22		253
+#define R_ARM_RPC24		254
+#define R_ARM_RBASE		255
+/* Keep this the last entry.  */
+#define R_ARM_NUM		256
+
+/* IA-64 specific declarations.  */
+
+/* Processor specific flags for the Ehdr e_flags field.  */
+#define EF_IA_64_MASKOS		0x0000000f	/* os-specific flags */
+#define EF_IA_64_ABI64		0x00000010	/* 64-bit ABI */
+#define EF_IA_64_ARCH		0xff000000	/* arch. version mask */
+
+/* Processor specific values for the Phdr p_type field.  */
+#define PT_IA_64_ARCHEXT	(PT_LOPROC + 0)	/* arch extension bits */
+#define PT_IA_64_UNWIND		(PT_LOPROC + 1)	/* ia64 unwind bits */
+#define PT_IA_64_HP_OPT_ANOT	(PT_LOOS + 0x12)
+#define PT_IA_64_HP_HSL_ANOT	(PT_LOOS + 0x13)
+#define PT_IA_64_HP_STACK	(PT_LOOS + 0x14)
+
+/* Processor specific flags for the Phdr p_flags field.  */
+#define PF_IA_64_NORECOV	0x80000000	/* spec insns w/o recovery */
+
+/* Processor specific values for the Shdr sh_type field.  */
+#define SHT_IA_64_EXT		(SHT_LOPROC + 0) /* extension bits */
+#define SHT_IA_64_UNWIND	(SHT_LOPROC + 1) /* unwind bits */
+
+/* Processor specific flags for the Shdr sh_flags field.  */
+#define SHF_IA_64_SHORT		0x10000000	/* section near gp */
+#define SHF_IA_64_NORECOV	0x20000000	/* spec insns w/o recovery */
+
+/* Processor specific values for the Dyn d_tag field.  */
+#define DT_IA_64_PLT_RESERVE	(DT_LOPROC + 0)
+#define DT_IA_64_NUM		1
+
+/* IA-64 relocations.  */
+#define R_IA64_NONE		0x00	/* none */
+#define R_IA64_IMM14		0x21	/* symbol + addend, add imm14 */
+#define R_IA64_IMM22		0x22	/* symbol + addend, add imm22 */
+#define R_IA64_IMM64		0x23	/* symbol + addend, mov imm64 */
+#define R_IA64_DIR32MSB		0x24	/* symbol + addend, data4 MSB */
+#define R_IA64_DIR32LSB		0x25	/* symbol + addend, data4 LSB */
+#define R_IA64_DIR64MSB		0x26	/* symbol + addend, data8 MSB */
+#define R_IA64_DIR64LSB		0x27	/* symbol + addend, data8 LSB */
+#define R_IA64_GPREL22		0x2a	/* @gprel(sym + add), add imm22 */
+#define R_IA64_GPREL64I		0x2b	/* @gprel(sym + add), mov imm64 */
+#define R_IA64_GPREL32MSB	0x2c	/* @gprel(sym + add), data4 MSB */
+#define R_IA64_GPREL32LSB	0x2d	/* @gprel(sym + add), data4 LSB */
+#define R_IA64_GPREL64MSB	0x2e	/* @gprel(sym + add), data8 MSB */
+#define R_IA64_GPREL64LSB	0x2f	/* @gprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF22		0x32	/* @ltoff(sym + add), add imm22 */
+#define R_IA64_LTOFF64I		0x33	/* @ltoff(sym + add), mov imm64 */
+#define R_IA64_PLTOFF22		0x3a	/* @pltoff(sym + add), add imm22 */
+#define R_IA64_PLTOFF64I	0x3b	/* @pltoff(sym + add), mov imm64 */
+#define R_IA64_PLTOFF64MSB	0x3e	/* @pltoff(sym + add), data8 MSB */
+#define R_IA64_PLTOFF64LSB	0x3f	/* @pltoff(sym + add), data8 LSB */
+#define R_IA64_FPTR64I		0x43	/* @fptr(sym + add), mov imm64 */
+#define R_IA64_FPTR32MSB	0x44	/* @fptr(sym + add), data4 MSB */
+#define R_IA64_FPTR32LSB	0x45	/* @fptr(sym + add), data4 LSB */
+#define R_IA64_FPTR64MSB	0x46	/* @fptr(sym + add), data8 MSB */
+#define R_IA64_FPTR64LSB	0x47	/* @fptr(sym + add), data8 LSB */
+#define R_IA64_PCREL60B		0x48	/* @pcrel(sym + add), brl */
+#define R_IA64_PCREL21B		0x49	/* @pcrel(sym + add), ptb, call */
+#define R_IA64_PCREL21M		0x4a	/* @pcrel(sym + add), chk.s */
+#define R_IA64_PCREL21F		0x4b	/* @pcrel(sym + add), fchkf */
+#define R_IA64_PCREL32MSB	0x4c	/* @pcrel(sym + add), data4 MSB */
+#define R_IA64_PCREL32LSB	0x4d	/* @pcrel(sym + add), data4 LSB */
+#define R_IA64_PCREL64MSB	0x4e	/* @pcrel(sym + add), data8 MSB */
+#define R_IA64_PCREL64LSB	0x4f	/* @pcrel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_FPTR22	0x52	/* @ltoff(@fptr(s+a)), imm22 */
+#define R_IA64_LTOFF_FPTR64I	0x53	/* @ltoff(@fptr(s+a)), imm64 */
+#define R_IA64_LTOFF_FPTR32MSB	0x54	/* @ltoff(@fptr(s+a)), data4 MSB */
+#define R_IA64_LTOFF_FPTR32LSB	0x55	/* @ltoff(@fptr(s+a)), data4 LSB */
+#define R_IA64_LTOFF_FPTR64MSB	0x56	/* @ltoff(@fptr(s+a)), data8 MSB */
+#define R_IA64_LTOFF_FPTR64LSB	0x57	/* @ltoff(@fptr(s+a)), data8 LSB */
+#define R_IA64_SEGREL32MSB	0x5c	/* @segrel(sym + add), data4 MSB */
+#define R_IA64_SEGREL32LSB	0x5d	/* @segrel(sym + add), data4 LSB */
+#define R_IA64_SEGREL64MSB	0x5e	/* @segrel(sym + add), data8 MSB */
+#define R_IA64_SEGREL64LSB	0x5f	/* @segrel(sym + add), data8 LSB */
+#define R_IA64_SECREL32MSB	0x64	/* @secrel(sym + add), data4 MSB */
+#define R_IA64_SECREL32LSB	0x65	/* @secrel(sym + add), data4 LSB */
+#define R_IA64_SECREL64MSB	0x66	/* @secrel(sym + add), data8 MSB */
+#define R_IA64_SECREL64LSB	0x67	/* @secrel(sym + add), data8 LSB */
+#define R_IA64_REL32MSB		0x6c	/* data 4 + REL */
+#define R_IA64_REL32LSB		0x6d	/* data 4 + REL */
+#define R_IA64_REL64MSB		0x6e	/* data 8 + REL */
+#define R_IA64_REL64LSB		0x6f	/* data 8 + REL */
+#define R_IA64_LTV32MSB		0x74	/* symbol + addend, data4 MSB */
+#define R_IA64_LTV32LSB		0x75	/* symbol + addend, data4 LSB */
+#define R_IA64_LTV64MSB		0x76	/* symbol + addend, data8 MSB */
+#define R_IA64_LTV64LSB		0x77	/* symbol + addend, data8 LSB */
+#define R_IA64_PCREL21BI	0x79	/* @pcrel(sym + add), 21bit inst */
+#define R_IA64_PCREL22		0x7a	/* @pcrel(sym + add), 22bit inst */
+#define R_IA64_PCREL64I		0x7b	/* @pcrel(sym + add), 64bit inst */
+#define R_IA64_IPLTMSB		0x80	/* dynamic reloc, imported PLT, MSB */
+#define R_IA64_IPLTLSB		0x81	/* dynamic reloc, imported PLT, LSB */
+#define R_IA64_COPY		0x84	/* copy relocation */
+#define R_IA64_SUB		0x85	/* Addend and symbol difference */
+#define R_IA64_LTOFF22X		0x86	/* LTOFF22, relaxable.  */
+#define R_IA64_LDXMOV		0x87	/* Use of LTOFF22X.  */
+#define R_IA64_TPREL14		0x91	/* @tprel(sym + add), imm14 */
+#define R_IA64_TPREL22		0x92	/* @tprel(sym + add), imm22 */
+#define R_IA64_TPREL64I		0x93	/* @tprel(sym + add), imm64 */
+#define R_IA64_TPREL64MSB	0x96	/* @tprel(sym + add), data8 MSB */
+#define R_IA64_TPREL64LSB	0x97	/* @tprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_TPREL22	0x9a	/* @ltoff(@tprel(s+a)), imm2 */
+#define R_IA64_DTPMOD64MSB	0xa6	/* @dtpmod(sym + add), data8 MSB */
+#define R_IA64_DTPMOD64LSB	0xa7	/* @dtpmod(sym + add), data8 LSB */
+#define R_IA64_LTOFF_DTPMOD22	0xaa	/* @ltoff(@dtpmod(sym + add)), imm22 */
+#define R_IA64_DTPREL14		0xb1	/* @dtprel(sym + add), imm14 */
+#define R_IA64_DTPREL22		0xb2	/* @dtprel(sym + add), imm22 */
+#define R_IA64_DTPREL64I	0xb3	/* @dtprel(sym + add), imm64 */
+#define R_IA64_DTPREL32MSB	0xb4	/* @dtprel(sym + add), data4 MSB */
+#define R_IA64_DTPREL32LSB	0xb5	/* @dtprel(sym + add), data4 LSB */
+#define R_IA64_DTPREL64MSB	0xb6	/* @dtprel(sym + add), data8 MSB */
+#define R_IA64_DTPREL64LSB	0xb7	/* @dtprel(sym + add), data8 LSB */
+#define R_IA64_LTOFF_DTPREL22	0xba	/* @ltoff(@dtprel(s+a)), imm22 */
+
+/* SH specific declarations */
+
+/* SH relocs.  */
+#define	R_SH_NONE		0
+#define	R_SH_DIR32		1
+#define	R_SH_REL32		2
+#define	R_SH_DIR8WPN		3
+#define	R_SH_IND12W		4
+#define	R_SH_DIR8WPL		5
+#define	R_SH_DIR8WPZ		6
+#define	R_SH_DIR8BP		7
+#define	R_SH_DIR8W		8
+#define	R_SH_DIR8L		9
+#define	R_SH_SWITCH16		25
+#define	R_SH_SWITCH32		26
+#define	R_SH_USES		27
+#define	R_SH_COUNT		28
+#define	R_SH_ALIGN		29
+#define	R_SH_CODE		30
+#define	R_SH_DATA		31
+#define	R_SH_LABEL		32
+#define	R_SH_SWITCH8		33
+#define	R_SH_GNU_VTINHERIT	34
+#define	R_SH_GNU_VTENTRY	35
+#define	R_SH_TLS_GD_32		144
+#define	R_SH_TLS_LD_32		145
+#define	R_SH_TLS_LDO_32		146
+#define	R_SH_TLS_IE_32		147
+#define	R_SH_TLS_LE_32		148
+#define	R_SH_TLS_DTPMOD32	149
+#define	R_SH_TLS_DTPOFF32	150
+#define	R_SH_TLS_TPOFF32	151
+#define	R_SH_GOT32		160
+#define	R_SH_PLT32		161
+#define	R_SH_COPY		162
+#define	R_SH_GLOB_DAT		163
+#define	R_SH_JMP_SLOT		164
+#define	R_SH_RELATIVE		165
+#define	R_SH_GOTOFF		166
+#define	R_SH_GOTPC		167
+/* Keep this the last entry.  */
+#define	R_SH_NUM		256
+
+/* Additional s390 relocs */
+
+#define R_390_NONE		0	/* No reloc.  */
+#define R_390_8			1	/* Direct 8 bit.  */
+#define R_390_12		2	/* Direct 12 bit.  */
+#define R_390_16		3	/* Direct 16 bit.  */
+#define R_390_32		4	/* Direct 32 bit.  */
+#define R_390_PC32		5	/* PC relative 32 bit.	*/
+#define R_390_GOT12		6	/* 12 bit GOT offset.  */
+#define R_390_GOT32		7	/* 32 bit GOT offset.  */
+#define R_390_PLT32		8	/* 32 bit PC relative PLT address.  */
+#define R_390_COPY		9	/* Copy symbol at runtime.  */
+#define R_390_GLOB_DAT		10	/* Create GOT entry.  */
+#define R_390_JMP_SLOT		11	/* Create PLT entry.  */
+#define R_390_RELATIVE		12	/* Adjust by program base.  */
+#define R_390_GOTOFF32		13	/* 32 bit offset to GOT.	 */
+#define R_390_GOTPC		14	/* 32 bit PC relative offset to GOT.  */
+#define R_390_GOT16		15	/* 16 bit GOT offset.  */
+#define R_390_PC16		16	/* PC relative 16 bit.	*/
+#define R_390_PC16DBL		17	/* PC relative 16 bit shifted by 1.  */
+#define R_390_PLT16DBL		18	/* 16 bit PC rel. PLT shifted by 1.  */
+#define R_390_PC32DBL		19	/* PC relative 32 bit shifted by 1.  */
+#define R_390_PLT32DBL		20	/* 32 bit PC rel. PLT shifted by 1.  */
+#define R_390_GOTPCDBL		21	/* 32 bit PC rel. GOT shifted by 1.  */
+#define R_390_64		22	/* Direct 64 bit.  */
+#define R_390_PC64		23	/* PC relative 64 bit.	*/
+#define R_390_GOT64		24	/* 64 bit GOT offset.  */
+#define R_390_PLT64		25	/* 64 bit PC relative PLT address.  */
+#define R_390_GOTENT		26	/* 32 bit PC rel. to GOT entry >> 1. */
+#define R_390_GOTOFF16		27	/* 16 bit offset to GOT. */
+#define R_390_GOTOFF64		28	/* 64 bit offset to GOT. */
+#define R_390_GOTPLT12		29	/* 12 bit offset to jump slot.	*/
+#define R_390_GOTPLT16		30	/* 16 bit offset to jump slot.	*/
+#define R_390_GOTPLT32		31	/* 32 bit offset to jump slot.	*/
+#define R_390_GOTPLT64		32	/* 64 bit offset to jump slot.	*/
+#define R_390_GOTPLTENT		33	/* 32 bit rel. offset to jump slot.  */
+#define R_390_PLTOFF16		34	/* 16 bit offset from GOT to PLT. */
+#define R_390_PLTOFF32		35	/* 32 bit offset from GOT to PLT. */
+#define R_390_PLTOFF64		36	/* 16 bit offset from GOT to PLT. */
+#define R_390_TLS_LOAD		37	/* Tag for load insn in TLS code.  */
+#define R_390_TLS_GDCALL	38	/* Tag for function call in general
+					   dynamic TLS code. */
+#define R_390_TLS_LDCALL	39	/* Tag for function call in local
+					   dynamic TLS code. */
+#define R_390_TLS_GD32		40	/* Direct 32 bit for general dynamic
+					   thread local data.  */
+#define R_390_TLS_GD64		41	/* Direct 64 bit for general dynamic
+					  thread local data.  */
+#define R_390_TLS_GOTIE12	42	/* 12 bit GOT offset for static TLS
+					   block offset.  */
+#define R_390_TLS_GOTIE32	43	/* 32 bit GOT offset for static TLS
+					   block offset.  */
+#define R_390_TLS_GOTIE64	44	/* 64 bit GOT offset for static TLS
+					   block offset. */
+#define R_390_TLS_LDM32		45	/* Direct 32 bit for local dynamic
+					   thread local data in LE code.  */
+#define R_390_TLS_LDM64		46	/* Direct 64 bit for local dynamic
+					   thread local data in LE code.  */
+#define R_390_TLS_IE32		47	/* 32 bit address of GOT entry for
+					   negated static TLS block offset.  */
+#define R_390_TLS_IE64		48	/* 64 bit address of GOT entry for
+					   negated static TLS block offset.  */
+#define R_390_TLS_IEENT		49	/* 32 bit rel. offset to GOT entry for
+					   negated static TLS block offset.  */
+#define R_390_TLS_LE32		50	/* 32 bit negated offset relative to
+					   static TLS block.  */
+#define R_390_TLS_LE64		51	/* 64 bit negated offset relative to
+					   static TLS block.  */
+#define R_390_TLS_LDO32		52	/* 32 bit offset relative to TLS
+					   block.  */
+#define R_390_TLS_LDO64		53	/* 64 bit offset relative to TLS
+					   block.  */
+#define R_390_TLS_DTPMOD	54	/* ID of module containing symbol.  */
+#define R_390_TLS_DTPOFF	55	/* Offset in TLS block.	 */
+#define R_390_TLS_TPOFF		56	/* Negated offset in static TLS
+					   block.  */
+#define R_390_20		57	/* Direct 20 bit.  */
+#define R_390_GOT20		58	/* 20 bit GOT offset.  */
+#define R_390_GOTPLT20		59	/* 20 bit offset to jump slot.  */
+#define R_390_TLS_GOTIE20	60	/* 20 bit GOT offset for static TLS
+					   block offset.  */
+/* Keep this the last entry.  */
+#define R_390_NUM		61
+
+
+/* CRIS relocations.  */
+#define R_CRIS_NONE		0
+#define R_CRIS_8		1
+#define R_CRIS_16		2
+#define R_CRIS_32		3
+#define R_CRIS_8_PCREL		4
+#define R_CRIS_16_PCREL		5
+#define R_CRIS_32_PCREL		6
+#define R_CRIS_GNU_VTINHERIT	7
+#define R_CRIS_GNU_VTENTRY	8
+#define R_CRIS_COPY		9
+#define R_CRIS_GLOB_DAT		10
+#define R_CRIS_JUMP_SLOT	11
+#define R_CRIS_RELATIVE		12
+#define R_CRIS_16_GOT		13
+#define R_CRIS_32_GOT		14
+#define R_CRIS_16_GOTPLT	15
+#define R_CRIS_32_GOTPLT	16
+#define R_CRIS_32_GOTREL	17
+#define R_CRIS_32_PLT_GOTREL	18
+#define R_CRIS_32_PLT_PCREL	19
+
+#define R_CRIS_NUM		20
+
+
+/* AMD x86-64 relocations.  */
+#define R_X86_64_NONE		0	/* No reloc */
+#define R_X86_64_64		1	/* Direct 64 bit  */
+#define R_X86_64_PC32		2	/* PC relative 32 bit signed */
+#define R_X86_64_GOT32		3	/* 32 bit GOT entry */
+#define R_X86_64_PLT32		4	/* 32 bit PLT address */
+#define R_X86_64_COPY		5	/* Copy symbol at runtime */
+#define R_X86_64_GLOB_DAT	6	/* Create GOT entry */
+#define R_X86_64_JUMP_SLOT	7	/* Create PLT entry */
+#define R_X86_64_RELATIVE	8	/* Adjust by program base */
+#define R_X86_64_GOTPCREL	9	/* 32 bit signed PC relative
+					   offset to GOT */
+#define R_X86_64_32		10	/* Direct 32 bit zero extended */
+#define R_X86_64_32S		11	/* Direct 32 bit sign extended */
+#define R_X86_64_16		12	/* Direct 16 bit zero extended */
+#define R_X86_64_PC16		13	/* 16 bit sign extended pc relative */
+#define R_X86_64_8		14	/* Direct 8 bit sign extended  */
+#define R_X86_64_PC8		15	/* 8 bit sign extended pc relative */
+#define R_X86_64_DTPMOD64	16	/* ID of module containing symbol */
+#define R_X86_64_DTPOFF64	17	/* Offset in module's TLS block */
+#define R_X86_64_TPOFF64	18	/* Offset in initial TLS block */
+#define R_X86_64_TLSGD		19	/* 32 bit signed PC relative offset
+					   to two GOT entries for GD symbol */
+#define R_X86_64_TLSLD		20	/* 32 bit signed PC relative offset
+					   to two GOT entries for LD symbol */
+#define R_X86_64_DTPOFF32	21	/* Offset in TLS block */
+#define R_X86_64_GOTTPOFF	22	/* 32 bit signed PC relative offset
+					   to GOT entry for IE symbol */
+#define R_X86_64_TPOFF32	23	/* Offset in initial TLS block */
+
+#define R_X86_64_NUM		24
+
+
+/* AM33 relocations.  */
+#define R_MN10300_NONE		0	/* No reloc.  */
+#define R_MN10300_32		1	/* Direct 32 bit.  */
+#define R_MN10300_16		2	/* Direct 16 bit.  */
+#define R_MN10300_8		3	/* Direct 8 bit.  */
+#define R_MN10300_PCREL32	4	/* PC-relative 32-bit.  */
+#define R_MN10300_PCREL16	5	/* PC-relative 16-bit signed.  */
+#define R_MN10300_PCREL8	6	/* PC-relative 8-bit signed.  */
+#define R_MN10300_GNU_VTINHERIT	7	/* Ancient C++ vtable garbage... */
+#define R_MN10300_GNU_VTENTRY	8	/* ... collection annotation.  */
+#define R_MN10300_24		9	/* Direct 24 bit.  */
+#define R_MN10300_GOTPC32	10	/* 32-bit PCrel offset to GOT.  */
+#define R_MN10300_GOTPC16	11	/* 16-bit PCrel offset to GOT.  */
+#define R_MN10300_GOTOFF32	12	/* 32-bit offset from GOT.  */
+#define R_MN10300_GOTOFF24	13	/* 24-bit offset from GOT.  */
+#define R_MN10300_GOTOFF16	14	/* 16-bit offset from GOT.  */
+#define R_MN10300_PLT32		15	/* 32-bit PCrel to PLT entry.  */
+#define R_MN10300_PLT16		16	/* 16-bit PCrel to PLT entry.  */
+#define R_MN10300_GOT32		17	/* 32-bit offset to GOT entry.  */
+#define R_MN10300_GOT24		18	/* 24-bit offset to GOT entry.  */
+#define R_MN10300_GOT16		19	/* 16-bit offset to GOT entry.  */
+#define R_MN10300_COPY		20	/* Copy symbol at runtime.  */
+#define R_MN10300_GLOB_DAT	21	/* Create GOT entry.  */
+#define R_MN10300_JMP_SLOT	22	/* Create PLT entry.  */
+#define R_MN10300_RELATIVE	23	/* Adjust by program base.  */
+
+#define R_MN10300_NUM		24
+
+
+/* M32R relocs.  */
+#define R_M32R_NONE		0	/* No reloc. */
+#define R_M32R_16		1	/* Direct 16 bit. */
+#define R_M32R_32		2	/* Direct 32 bit. */
+#define R_M32R_24		3	/* Direct 24 bit. */
+#define R_M32R_10_PCREL		4	/* PC relative 10 bit shifted. */
+#define R_M32R_18_PCREL		5	/* PC relative 18 bit shifted. */
+#define R_M32R_26_PCREL		6	/* PC relative 26 bit shifted. */
+#define R_M32R_HI16_ULO		7	/* High 16 bit with unsigned low. */
+#define R_M32R_HI16_SLO		8	/* High 16 bit with signed low. */
+#define R_M32R_LO16		9	/* Low 16 bit. */
+#define R_M32R_SDA16		10	/* 16 bit offset in SDA. */
+#define R_M32R_GNU_VTINHERIT	11
+#define R_M32R_GNU_VTENTRY	12
+/* M32R relocs use SHT_RELA.  */
+#define R_M32R_16_RELA		33	/* Direct 16 bit. */
+#define R_M32R_32_RELA		34	/* Direct 32 bit. */
+#define R_M32R_24_RELA		35	/* Direct 24 bit. */
+#define R_M32R_10_PCREL_RELA	36	/* PC relative 10 bit shifted. */
+#define R_M32R_18_PCREL_RELA	37	/* PC relative 18 bit shifted. */
+#define R_M32R_26_PCREL_RELA	38	/* PC relative 26 bit shifted. */
+#define R_M32R_HI16_ULO_RELA	39	/* High 16 bit with unsigned low */
+#define R_M32R_HI16_SLO_RELA	40	/* High 16 bit with signed low */
+#define R_M32R_LO16_RELA	41	/* Low 16 bit */
+#define R_M32R_SDA16_RELA	42	/* 16 bit offset in SDA */
+#define R_M32R_RELA_GNU_VTINHERIT	43
+#define R_M32R_RELA_GNU_VTENTRY	44
+#define R_M32R_REL32		45	/* PC relative 32 bit.  */
+
+#define R_M32R_GOT24		48	/* 24 bit GOT entry */
+#define R_M32R_26_PLTREL	49	/* 26 bit PC relative to PLT shifted */
+#define R_M32R_COPY		50	/* Copy symbol at runtime */
+#define R_M32R_GLOB_DAT		51	/* Create GOT entry */
+#define R_M32R_JMP_SLOT		52	/* Create PLT entry */
+#define R_M32R_RELATIVE		53	/* Adjust by program base */
+#define R_M32R_GOTOFF		54	/* 24 bit offset to GOT */
+#define R_M32R_GOTPC24		55	/* 24 bit PC relative offset to GOT */
+#define R_M32R_GOT16_HI_ULO	56	/* High 16 bit GOT entry with unsigned
+					   low */
+#define R_M32R_GOT16_HI_SLO	57	/* High 16 bit GOT entry with signed
+					   low */
+#define R_M32R_GOT16_LO		58	/* Low 16 bit GOT entry */
+#define R_M32R_GOTPC_HI_ULO	59	/* High 16 bit PC relative offset to
+					   GOT with unsigned low */
+#define R_M32R_GOTPC_HI_SLO	60	/* High 16 bit PC relative offset to
+					   GOT with signed low */
+#define R_M32R_GOTPC_LO		61	/* Low 16 bit PC relative offset to
+					   GOT */
+#define R_M32R_GOTOFF_HI_ULO	62	/* High 16 bit offset to GOT
+					   with unsigned low */
+#define R_M32R_GOTOFF_HI_SLO	63	/* High 16 bit offset to GOT
+					   with signed low */
+#define R_M32R_GOTOFF_LO	64	/* Low 16 bit offset to GOT */
+#define R_M32R_NUM		256	/* Keep this the last entry. */
+
+
+#endif	/* elf.h */
diff --git a/util/cbfstool/tools/lzma/C/7zip/Common/InBuffer.h b/util/cbfstool/tools/lzma/C/7zip/Common/InBuffer.h
new file mode 100644
index 0000000000..a59ecefacd
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Common/InBuffer.h
@@ -0,0 +1,76 @@
+// InBuffer.h

+

+#ifndef __INBUFFER_H

+#define __INBUFFER_H

+

+#include "../IStream.h"

+#include "../../Common/MyCom.h"

+

+#ifndef _NO_EXCEPTIONS

+class CInBufferException

+{

+public:

+  HRESULT ErrorCode;

+  CInBufferException(HRESULT errorCode): ErrorCode(errorCode) {}

+};

+#endif

+

+class CInBuffer

+{

+  Byte *_buffer;

+  Byte *_bufferLimit;

+  Byte *_bufferBase;

+  CMyComPtr<ISequentialInStream> _stream;

+  UInt64 _processedSize;

+  UInt32 _bufferSize;

+  bool _wasFinished;

+

+  bool ReadBlock();

+  Byte ReadBlock2();

+

+public:

+  #ifdef _NO_EXCEPTIONS

+  HRESULT ErrorCode;

+  #endif

+

+  CInBuffer();

+  ~CInBuffer() { Free(); }

+

+  bool Create(UInt32 bufferSize);

+  void Free();

+  

+  void SetStream(ISequentialInStream *stream);

+  void Init();

+  void ReleaseStream() { _stream.Release(); }

+

+  bool ReadByte(Byte &b)

+  {

+    if(_buffer >= _bufferLimit)

+      if(!ReadBlock())

+        return false;

+    b = *_buffer++;

+    return true;

+  }

+  Byte ReadByte()

+  {

+    if(_buffer >= _bufferLimit)

+      return ReadBlock2();

+    return *_buffer++;

+  }

+  void ReadBytes(void *data, UInt32 size, UInt32 &processedSize)

+  {

+    for(processedSize = 0; processedSize < size; processedSize++)

+      if (!ReadByte(((Byte *)data)[processedSize]))

+        return;

+  }

+  bool ReadBytes(void *data, UInt32 size)

+  {

+    UInt32 processedSize;

+    ReadBytes(data, size, processedSize);

+    return (processedSize == size);

+  }

+  UInt64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }

+  bool WasFinished() const { return _wasFinished; }

+};

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Common/OutBuffer.cpp b/util/cbfstool/tools/lzma/C/7zip/Common/OutBuffer.cpp
new file mode 100644
index 0000000000..45da6d7f00
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Common/OutBuffer.cpp
@@ -0,0 +1,116 @@
+// OutByte.cpp

+

+#include "StdAfx.h"

+

+#include "OutBuffer.h"

+

+#include "../../Common/Alloc.h"

+

+bool COutBuffer::Create(UInt32 bufferSize)

+{

+  const UInt32 kMinBlockSize = 1;

+  if (bufferSize < kMinBlockSize)

+    bufferSize = kMinBlockSize;

+  if (_buffer != 0 && _bufferSize == bufferSize)

+    return true;

+  Free();

+  _bufferSize = bufferSize;

+  _buffer = (Byte *)::MidAlloc(bufferSize);

+  return (_buffer != 0);

+}

+

+void COutBuffer::Free()

+{

+  ::MidFree(_buffer);

+  _buffer = 0;

+}

+

+void COutBuffer::SetStream(ISequentialOutStream *stream)

+{

+  _stream = stream;

+}

+

+void COutBuffer::Init()

+{

+  _streamPos = 0;

+  _limitPos = _bufferSize;

+  _pos = 0;

+  _processedSize = 0;

+  _overDict = false;

+  #ifdef _NO_EXCEPTIONS

+  ErrorCode = S_OK;

+  #endif

+}

+

+UInt64 COutBuffer::GetProcessedSize() const

+{ 

+  UInt64 res = _processedSize + _pos - _streamPos;

+  if (_streamPos > _pos) 

+    res += _bufferSize;

+  return res;

+}

+

+

+HRESULT COutBuffer::FlushPart()

+{

+  // _streamPos < _bufferSize

+  UInt32 size = (_streamPos >= _pos) ? (_bufferSize - _streamPos) : (_pos - _streamPos);

+  HRESULT result = S_OK;

+  #ifdef _NO_EXCEPTIONS

+  result = ErrorCode;

+  #endif

+  if (_buffer2 != 0)

+  {

+    memmove(_buffer2, _buffer + _streamPos, size);

+    _buffer2 += size;

+  }

+

+  if (_stream != 0

+      #ifdef _NO_EXCEPTIONS

+      && (ErrorCode == S_OK)

+      #endif

+     )

+  {

+    UInt32 processedSize = 0;

+    result = _stream->Write(_buffer + _streamPos, size, &processedSize);

+    size = processedSize;

+  }

+  _streamPos += size;

+  if (_streamPos == _bufferSize)

+    _streamPos = 0;

+  if (_pos == _bufferSize)

+  {

+    _overDict = true;

+    _pos = 0;

+  }

+  _limitPos = (_streamPos > _pos) ? _streamPos : _bufferSize;

+  _processedSize += size;

+  return result;

+}

+

+HRESULT COutBuffer::Flush()

+{

+  #ifdef _NO_EXCEPTIONS

+  if (ErrorCode != S_OK)

+    return ErrorCode;

+  #endif

+

+  while(_streamPos != _pos)

+  {

+    HRESULT result = FlushPart();

+    if (result != S_OK)

+      return result;

+  }

+  return S_OK;

+}

+

+void COutBuffer::FlushWithCheck()

+{

+  HRESULT result = FlushPart();

+  #ifdef _NO_EXCEPTIONS

+  ErrorCode = result;

+  #else

+  if (result != S_OK)

+    throw COutBufferException(result);

+  #endif

+}

diff --git a/util/cbfstool/tools/lzma/C/7zip/Common/OutBuffer.h b/util/cbfstool/tools/lzma/C/7zip/Common/OutBuffer.h
new file mode 100644
index 0000000000..37eefbdfcd
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Common/OutBuffer.h
@@ -0,0 +1,64 @@
+// OutBuffer.h

+

+#ifndef __OUTBUFFER_H

+#define __OUTBUFFER_H

+

+#include "../IStream.h"

+#include "../../Common/MyCom.h"

+

+#ifndef _NO_EXCEPTIONS

+struct COutBufferException

+{

+  HRESULT ErrorCode;

+  COutBufferException(HRESULT errorCode): ErrorCode(errorCode) {}

+};

+#endif

+

+class COutBuffer

+{

+protected:

+  Byte *_buffer;

+  UInt32 _pos;

+  UInt32 _limitPos;

+  UInt32 _streamPos;

+  UInt32 _bufferSize;

+  CMyComPtr<ISequentialOutStream> _stream;

+  UInt64 _processedSize;

+  Byte  *_buffer2;

+  bool _overDict;

+

+  HRESULT FlushPart();

+  void FlushWithCheck();

+public:

+  #ifdef _NO_EXCEPTIONS

+  HRESULT ErrorCode;

+  #endif

+

+  COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}

+  ~COutBuffer() { Free(); }

+  

+  bool Create(UInt32 bufferSize);

+  void Free();

+

+  void SetMemStream(Byte *buffer) { _buffer2 = buffer; }

+  void SetStream(ISequentialOutStream *stream);

+  void Init();

+  HRESULT Flush();

+  void ReleaseStream() {  _stream.Release(); }

+

+  void WriteByte(Byte b)

+  {

+    _buffer[_pos++] = b;

+    if(_pos == _limitPos)

+      FlushWithCheck();

+  }

+  void WriteBytes(const void *data, size_t size)

+  {

+    for (size_t i = 0; i < size; i++)

+      WriteByte(((const Byte *)data)[i]);

+  }

+

+  UInt64 GetProcessedSize() const;

+};

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Common/StdAfx.h b/util/cbfstool/tools/lzma/C/7zip/Common/StdAfx.h
new file mode 100644
index 0000000000..d7d9211b09
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Common/StdAfx.h
@@ -0,0 +1,9 @@
+// StdAfx.h

+

+#ifndef __STDAFX_H

+#define __STDAFX_H

+

+#include "../../Common/MyWindows.h"

+#include "../../Common/NewHandler.h"

+

+#endif 

diff --git a/util/cbfstool/tools/lzma/C/7zip/Common/StreamUtils.cpp b/util/cbfstool/tools/lzma/C/7zip/Common/StreamUtils.cpp
new file mode 100644
index 0000000000..712a78585a
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Common/StreamUtils.cpp
@@ -0,0 +1,44 @@
+// StreamUtils.cpp

+

+#include "StdAfx.h"

+

+#include "../../Common/MyCom.h"

+#include "StreamUtils.h"

+

+HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize)

+{

+  if (processedSize != 0)

+    *processedSize = 0;

+  while(size != 0)

+  {

+    UInt32 processedSizeLoc; 

+    HRESULT res = stream->Read(data, size, &processedSizeLoc);

+    if (processedSize != 0)

+      *processedSize += processedSizeLoc;

+    data = (Byte *)((Byte *)data + processedSizeLoc);

+    size -= processedSizeLoc;

+    RINOK(res);

+    if (processedSizeLoc == 0)

+      return S_OK;

+  }

+  return S_OK;

+}

+

+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize)

+{

+  if (processedSize != 0)

+    *processedSize = 0;

+  while(size != 0)

+  {

+    UInt32 processedSizeLoc; 

+    HRESULT res = stream->Write(data, size, &processedSizeLoc);

+    if (processedSize != 0)

+      *processedSize += processedSizeLoc;

+    data = (const void *)((const Byte *)data + processedSizeLoc);

+    size -= processedSizeLoc;

+    RINOK(res);

+    if (processedSizeLoc == 0)

+      break;

+  }

+  return S_OK;

+}

diff --git a/util/cbfstool/tools/lzma/C/7zip/Common/StreamUtils.h b/util/cbfstool/tools/lzma/C/7zip/Common/StreamUtils.h
new file mode 100644
index 0000000000..c8cd8cef1a
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Common/StreamUtils.h
@@ -0,0 +1,11 @@
+// StreamUtils.h

+

+#ifndef __STREAMUTILS_H

+#define __STREAMUTILS_H

+

+#include "../IStream.h"

+

+HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize);

+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize);

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree.h
new file mode 100644
index 0000000000..d464d3b59c
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree.h
@@ -0,0 +1,54 @@
+// BinTree.h

+

+#include "../LZInWindow.h"

+#include "../IMatchFinder.h"

+ 

+namespace BT_NAMESPACE {

+

+typedef UInt32 CIndex;

+const UInt32 kMaxValForNormalize = (UInt32(1) << 31) - 1;

+

+class CMatchFinder: 

+  public IMatchFinder,

+  public CLZInWindow,

+  public CMyUnknownImp,

+  public IMatchFinderSetNumPasses

+{

+  UInt32 _cyclicBufferPos;

+  UInt32 _cyclicBufferSize; // it must be historySize + 1

+  UInt32 _matchMaxLen;

+  CIndex *_hash;

+  CIndex *_son;

+  UInt32 _hashMask;

+  UInt32 _cutValue;

+  UInt32 _hashSizeSum;

+

+  void Normalize();

+  void FreeThisClassMemory();

+  void FreeMemory();

+

+  MY_UNKNOWN_IMP

+

+  STDMETHOD(SetStream)(ISequentialInStream *inStream);

+  STDMETHOD_(void, ReleaseStream)();

+  STDMETHOD(Init)();

+  HRESULT MovePos();

+  STDMETHOD_(Byte, GetIndexByte)(Int32 index);

+  STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 back, UInt32 limit);

+  STDMETHOD_(UInt32, GetNumAvailableBytes)();

+  STDMETHOD_(const Byte *, GetPointerToCurrentPos)();

+  STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes);

+  STDMETHOD_(void, ChangeBufferPos)();

+

+  STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, 

+      UInt32 matchMaxLen, UInt32 keepAddBufferAfter);

+  STDMETHOD(GetMatches)(UInt32 *distances);

+  STDMETHOD(Skip)(UInt32 num);

+

+public:

+  CMatchFinder();

+  virtual ~CMatchFinder();

+  virtual void SetNumPasses(UInt32 numPasses) { _cutValue = numPasses; }

+};

+

+}

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree2.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree2.h
new file mode 100644
index 0000000000..c5b3939e47
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree2.h
@@ -0,0 +1,12 @@
+// BinTree2.h

+

+#ifndef __BINTREE2_H

+#define __BINTREE2_H

+

+#define BT_NAMESPACE NBT2

+

+#include "BinTreeMain.h"

+

+#undef BT_NAMESPACE

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree3.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree3.h
new file mode 100644
index 0000000000..74eb73e293
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree3.h
@@ -0,0 +1,16 @@
+// BinTree3.h

+

+#ifndef __BINTREE3_H

+#define __BINTREE3_H

+

+#define BT_NAMESPACE NBT3

+

+#define HASH_ARRAY_2

+

+#include "BinTreeMain.h"

+

+#undef HASH_ARRAY_2

+

+#undef BT_NAMESPACE

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree4.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree4.h
new file mode 100644
index 0000000000..62fc242aac
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTree4.h
@@ -0,0 +1,18 @@
+// BinTree4.h

+

+#ifndef __BINTREE4_H

+#define __BINTREE4_H

+

+#define BT_NAMESPACE NBT4

+

+#define HASH_ARRAY_2

+#define HASH_ARRAY_3

+

+#include "BinTreeMain.h"

+

+#undef HASH_ARRAY_2

+#undef HASH_ARRAY_3

+

+#undef BT_NAMESPACE

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTreeMain.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTreeMain.h
new file mode 100644
index 0000000000..61d1121043
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/BinTree/BinTreeMain.h
@@ -0,0 +1,531 @@
+// BinTreeMain.h

+

+#include "../../../../Common/Defs.h"

+#include "../../../../Common/CRC.h"

+#include "../../../../Common/Alloc.h"

+

+#include "BinTree.h"

+

+// #include <xmmintrin.h>

+// It's for prefetch

+// But prefetch doesn't give big gain in K8.

+

+namespace BT_NAMESPACE {

+

+#ifdef HASH_ARRAY_2

+  static const UInt32 kHash2Size = 1 << 10;

+  #define kNumHashDirectBytes 0

+  #ifdef HASH_ARRAY_3

+    static const UInt32 kNumHashBytes = 4;

+    static const UInt32 kHash3Size = 1 << 16;

+  #else

+    static const UInt32 kNumHashBytes = 3;

+  #endif

+  static const UInt32 kHashSize = 0;

+  static const UInt32 kMinMatchCheck = kNumHashBytes;

+  static const UInt32 kStartMaxLen = 1;

+#else

+  #ifdef HASH_ZIP 

+    #define kNumHashDirectBytes 0

+    static const UInt32 kNumHashBytes = 3;

+    static const UInt32 kHashSize = 1 << 16;

+    static const UInt32 kMinMatchCheck = kNumHashBytes;

+    static const UInt32 kStartMaxLen = 1;

+  #else

+    #define kNumHashDirectBytes 2

+    static const UInt32 kNumHashBytes = 2;

+    static const UInt32 kHashSize = 1 << (8 * kNumHashBytes);

+    static const UInt32 kMinMatchCheck = kNumHashBytes + 1;

+    static const UInt32 kStartMaxLen = 1;

+  #endif

+#endif

+

+#ifdef HASH_ARRAY_2

+#ifdef HASH_ARRAY_3

+static const UInt32 kHash3Offset = kHash2Size;

+#endif

+#endif

+

+static const UInt32 kFixHashSize = 0

+    #ifdef HASH_ARRAY_2

+    + kHash2Size

+    #ifdef HASH_ARRAY_3

+    + kHash3Size

+    #endif

+    #endif

+    ;

+

+CMatchFinder::CMatchFinder():

+  _hash(0)

+{

+}

+

+void CMatchFinder::FreeThisClassMemory()

+{

+  BigFree(_hash);

+  _hash = 0;

+}

+

+void CMatchFinder::FreeMemory()

+{

+  FreeThisClassMemory();

+  CLZInWindow::Free();

+}

+

+CMatchFinder::~CMatchFinder()

+{ 

+  FreeMemory();

+}

+

+STDMETHODIMP CMatchFinder::Create(UInt32 historySize, UInt32 keepAddBufferBefore, 

+    UInt32 matchMaxLen, UInt32 keepAddBufferAfter)

+{

+  if (historySize > kMaxValForNormalize - 256)

+  {

+    FreeMemory();

+    return E_INVALIDARG;

+  }

+  _cutValue = 

+  #ifdef _HASH_CHAIN

+    8 + (matchMaxLen >> 2);

+  #else

+    16 + (matchMaxLen >> 1);

+  #endif

+  UInt32 sizeReserv = (historySize + keepAddBufferBefore + 

+      matchMaxLen + keepAddBufferAfter) / 2 + 256;

+  if (CLZInWindow::Create(historySize + keepAddBufferBefore, 

+      matchMaxLen + keepAddBufferAfter, sizeReserv))

+  {

+    _matchMaxLen = matchMaxLen;

+    UInt32 newCyclicBufferSize = historySize + 1;

+    if (_hash != 0 && newCyclicBufferSize == _cyclicBufferSize)

+      return S_OK;

+    FreeThisClassMemory();

+    _cyclicBufferSize = newCyclicBufferSize; // don't change it

+

+    UInt32 hs = kHashSize;

+

+    #ifdef HASH_ARRAY_2

+    hs = historySize - 1;

+    hs |= (hs >> 1);

+    hs |= (hs >> 2);

+    hs |= (hs >> 4);

+    hs |= (hs >> 8);

+    hs >>= 1;

+    hs |= 0xFFFF;

+    if (hs > (1 << 24))

+    {

+      #ifdef HASH_ARRAY_3

+      hs >>= 1;

+      #else

+      hs = (1 << 24) - 1;

+      #endif

+    }

+    _hashMask = hs;

+    hs++;

+    #endif

+    _hashSizeSum = hs + kFixHashSize;

+    UInt32 numItems = _hashSizeSum + _cyclicBufferSize

+    #ifndef _HASH_CHAIN

+     * 2

+    #endif

+    ;

+    size_t sizeInBytes = (size_t)numItems * sizeof(CIndex);

+    if (sizeInBytes / sizeof(CIndex) != numItems)

+      return E_OUTOFMEMORY;

+    _hash = (CIndex *)BigAlloc(sizeInBytes);

+    _son = _hash + _hashSizeSum;

+    if (_hash != 0)

+      return S_OK;

+  }

+  FreeMemory();

+  return E_OUTOFMEMORY;

+}

+

+static const UInt32 kEmptyHashValue = 0;

+

+STDMETHODIMP CMatchFinder::SetStream(ISequentialInStream *stream)

+{

+  CLZInWindow::SetStream(stream);

+  return S_OK;

+}

+

+STDMETHODIMP CMatchFinder::Init()

+{

+  RINOK(CLZInWindow::Init());

+  for(UInt32 i = 0; i < _hashSizeSum; i++)

+    _hash[i] = kEmptyHashValue;

+  _cyclicBufferPos = 0;

+  ReduceOffsets(-1);

+  return S_OK;

+}

+

+STDMETHODIMP_(void) CMatchFinder::ReleaseStream()

+{ 

+  // ReleaseStream(); 

+}

+

+#ifdef HASH_ARRAY_2

+#ifdef HASH_ARRAY_3

+

+#define HASH_CALC { \

+  UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \

+  hash2Value = temp & (kHash2Size - 1); \

+  hash3Value = (temp ^ (UInt32(cur[2]) << 8)) & (kHash3Size - 1); \

+  hashValue = (temp ^ (UInt32(cur[2]) << 8) ^ (CCRC::Table[cur[3]] << 5)) & _hashMask; }

+  

+#else // no HASH_ARRAY_3

+#define HASH_CALC { \

+  UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \

+  hash2Value = temp & (kHash2Size - 1); \

+  hashValue = (temp ^ (UInt32(cur[2]) << 8)) & _hashMask; }

+#endif // HASH_ARRAY_3

+#else // no HASH_ARRAY_2

+#ifdef HASH_ZIP 

+inline UInt32 Hash(const Byte *pointer)

+{

+  return ((UInt32(pointer[0]) << 8) ^ CCRC::Table[pointer[1]] ^ pointer[2]) & (kHashSize - 1);

+}

+#else // no HASH_ZIP 

+inline UInt32 Hash(const Byte *pointer)

+{

+  return pointer[0] ^ (UInt32(pointer[1]) << 8);

+}

+#endif // HASH_ZIP

+#endif // HASH_ARRAY_2

+

+STDMETHODIMP CMatchFinder::GetMatches(UInt32 *distances)

+{

+  UInt32 lenLimit;

+  if (_pos + _matchMaxLen <= _streamPos)

+    lenLimit = _matchMaxLen;

+  else

+  {

+    lenLimit = _streamPos - _pos;

+    if(lenLimit < kMinMatchCheck)

+    {

+      distances[0] = 0;

+      return MovePos(); 

+    }

+  }

+

+  int offset = 1;

+

+  UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;

+  const Byte *cur = _buffer + _pos;

+

+  UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;

+

+  #ifdef HASH_ARRAY_2

+  UInt32 hash2Value;

+  #ifdef HASH_ARRAY_3

+  UInt32 hash3Value;

+  #endif

+  UInt32 hashValue;

+  HASH_CALC;

+  #else

+  UInt32 hashValue = Hash(cur);

+  #endif

+

+  UInt32 curMatch = _hash[kFixHashSize + hashValue];

+  #ifdef HASH_ARRAY_2

+  UInt32 curMatch2 = _hash[hash2Value];

+  #ifdef HASH_ARRAY_3

+  UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];

+  #endif

+  _hash[hash2Value] = _pos;

+  if(curMatch2 > matchMinPos)

+    if (_buffer[curMatch2] == cur[0])

+    {

+      distances[offset++] = maxLen = 2;

+      distances[offset++] = _pos - curMatch2 - 1;

+    }

+

+  #ifdef HASH_ARRAY_3

+  _hash[kHash3Offset + hash3Value] = _pos;

+  if(curMatch3 > matchMinPos)

+    if (_buffer[curMatch3] == cur[0])

+    {

+      if (curMatch3 == curMatch2)

+        offset -= 2;

+      distances[offset++] = maxLen = 3;

+      distances[offset++] = _pos - curMatch3 - 1;

+      curMatch2 = curMatch3;

+    }

+  #endif

+  if (offset != 1 && curMatch2 == curMatch)

+  {

+    offset -= 2;

+    maxLen = kStartMaxLen;

+  }

+  #endif

+

+  _hash[kFixHashSize + hashValue] = _pos;

+

+  CIndex *son = _son;

+

+  #ifdef _HASH_CHAIN

+  son[_cyclicBufferPos] = curMatch;

+  #else

+  CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;

+  CIndex *ptr1 = son + (_cyclicBufferPos << 1);

+

+  UInt32 len0, len1;

+  len0 = len1 = kNumHashDirectBytes;

+  #endif

+

+  #if kNumHashDirectBytes != 0

+  if(curMatch > matchMinPos)

+  {

+    if (_buffer[curMatch + kNumHashDirectBytes] != cur[kNumHashDirectBytes])

+    {

+      distances[offset++] = maxLen = kNumHashDirectBytes;

+      distances[offset++] = _pos - curMatch - 1;

+    }

+  }

+  #endif

+  UInt32 count = _cutValue;

+  while(true)

+  {

+    if(curMatch <= matchMinPos || count-- == 0)

+    {

+      #ifndef _HASH_CHAIN

+      *ptr0 = *ptr1 = kEmptyHashValue;

+      #endif

+      break;

+    }

+    UInt32 delta = _pos - curMatch;

+    UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?

+        (_cyclicBufferPos - delta):

+        (_cyclicBufferPos - delta + _cyclicBufferSize);

+    CIndex *pair = son + 

+    #ifdef _HASH_CHAIN

+      cyclicPos;

+    #else

+      (cyclicPos << 1);

+    #endif

+    

+    // _mm_prefetch((const char *)pair, _MM_HINT_T0);

+    

+    const Byte *pb = _buffer + curMatch;

+    UInt32 len = 

+    #ifdef _HASH_CHAIN

+    kNumHashDirectBytes;

+    if (pb[maxLen] == cur[maxLen])

+    #else

+    MyMin(len0, len1);

+    #endif

+    if (pb[len] == cur[len])

+    {

+      while(++len != lenLimit)

+        if (pb[len] != cur[len])

+          break;

+      if (maxLen < len)

+      {

+        distances[offset++] = maxLen = len;

+        distances[offset++] = delta - 1;

+        if (len == lenLimit)

+        {

+          #ifndef _HASH_CHAIN

+          *ptr1 = pair[0];

+          *ptr0 = pair[1];

+          #endif

+          break;

+        }

+      }

+    }

+    #ifdef _HASH_CHAIN

+    curMatch = *pair;

+    #else

+    if (pb[len] < cur[len])

+    {

+      *ptr1 = curMatch;

+      ptr1 = pair + 1;

+      curMatch = *ptr1;

+      len1 = len;

+    }

+    else

+    {

+      *ptr0 = curMatch;

+      ptr0 = pair;

+      curMatch = *ptr0;

+      len0 = len;

+    }

+    #endif

+  }

+  distances[0] = offset - 1;

+  if (++_cyclicBufferPos == _cyclicBufferSize)

+    _cyclicBufferPos = 0;

+  RINOK(CLZInWindow::MovePos());

+  if (_pos == kMaxValForNormalize)

+    Normalize();

+  return S_OK;

+}

+

+STDMETHODIMP CMatchFinder::Skip(UInt32 num)

+{

+  do

+  {

+  #ifdef _HASH_CHAIN

+  if (_streamPos - _pos < kNumHashBytes)

+  {

+    RINOK(MovePos()); 

+    continue;

+  }

+  #else

+  UInt32 lenLimit;

+  if (_pos + _matchMaxLen <= _streamPos)

+    lenLimit = _matchMaxLen;

+  else

+  {

+    lenLimit = _streamPos - _pos;

+    if(lenLimit < kMinMatchCheck)

+    {

+      RINOK(MovePos());

+      continue;

+    }

+  }

+  UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;

+  #endif

+  const Byte *cur = _buffer + _pos;

+

+  #ifdef HASH_ARRAY_2

+  UInt32 hash2Value;

+  #ifdef HASH_ARRAY_3

+  UInt32 hash3Value;

+  UInt32 hashValue;

+  HASH_CALC;

+  _hash[kHash3Offset + hash3Value] = _pos;

+  #else

+  UInt32 hashValue;

+  HASH_CALC;

+  #endif

+  _hash[hash2Value] = _pos;

+  #else

+  UInt32 hashValue = Hash(cur);

+  #endif

+

+  UInt32 curMatch = _hash[kFixHashSize + hashValue];

+  _hash[kFixHashSize + hashValue] = _pos;

+

+  #ifdef _HASH_CHAIN

+  _son[_cyclicBufferPos] = curMatch;

+  #else

+  CIndex *son = _son;

+  CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;

+  CIndex *ptr1 = son + (_cyclicBufferPos << 1);

+

+  UInt32 len0, len1;

+  len0 = len1 = kNumHashDirectBytes;

+  UInt32 count = _cutValue;

+  while(true)

+  {

+    if(curMatch <= matchMinPos || count-- == 0)

+    {

+      *ptr0 = *ptr1 = kEmptyHashValue;

+      break;

+    }

+    

+    UInt32 delta = _pos - curMatch;

+    UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?

+      (_cyclicBufferPos - delta):

+      (_cyclicBufferPos - delta + _cyclicBufferSize);

+    CIndex *pair = son + (cyclicPos << 1);

+    

+    // _mm_prefetch((const char *)pair, _MM_HINT_T0);

+    

+    const Byte *pb = _buffer + curMatch;

+    UInt32 len = MyMin(len0, len1);

+    

+    if (pb[len] == cur[len])

+    {

+      while(++len != lenLimit)

+        if (pb[len] != cur[len])

+          break;

+      if (len == lenLimit)

+      {

+        *ptr1 = pair[0];

+        *ptr0 = pair[1];

+        break;

+      }

+    }

+    if (pb[len] < cur[len])

+    {

+      *ptr1 = curMatch;

+      ptr1 = pair + 1;

+      curMatch = *ptr1;

+      len1 = len;

+    }

+    else

+    {

+      *ptr0 = curMatch;

+      ptr0 = pair;

+      curMatch = *ptr0;

+      len0 = len;

+    }

+  }

+  #endif

+  if (++_cyclicBufferPos == _cyclicBufferSize)

+    _cyclicBufferPos = 0;

+  RINOK(CLZInWindow::MovePos());

+  if (_pos == kMaxValForNormalize)

+    Normalize();

+  }

+  while(--num != 0);

+  return S_OK;

+}

+

+void CMatchFinder::Normalize()

+{

+  UInt32 subValue = _pos - _cyclicBufferSize;

+  CIndex *items = _hash;

+  UInt32 numItems = (_hashSizeSum + _cyclicBufferSize 

+    #ifndef _HASH_CHAIN

+     * 2

+    #endif

+    );

+  for (UInt32 i = 0; i < numItems; i++)

+  {

+    UInt32 value = items[i];

+    if (value <= subValue)

+      value = kEmptyHashValue;

+    else

+      value -= subValue;

+    items[i] = value;

+  }

+  ReduceOffsets(subValue);

+}

+

+HRESULT CMatchFinder::MovePos()

+{

+  if (++_cyclicBufferPos == _cyclicBufferSize)

+    _cyclicBufferPos = 0;

+  RINOK(CLZInWindow::MovePos());

+  if (_pos == kMaxValForNormalize)

+    Normalize();

+  return S_OK;

+}

+

+STDMETHODIMP_(Byte) CMatchFinder::GetIndexByte(Int32 index)

+  { return CLZInWindow::GetIndexByte(index); }

+

+STDMETHODIMP_(UInt32) CMatchFinder::GetMatchLen(Int32 index, 

+    UInt32 back, UInt32 limit)

+  { return CLZInWindow::GetMatchLen(index, back, limit); }

+

+STDMETHODIMP_(UInt32) CMatchFinder::GetNumAvailableBytes()

+  { return CLZInWindow::GetNumAvailableBytes(); }

+

+STDMETHODIMP_(const Byte *) CMatchFinder::GetPointerToCurrentPos()

+  { return CLZInWindow::GetPointerToCurrentPos(); }

+

+STDMETHODIMP_(Int32) CMatchFinder::NeedChangeBufferPos(UInt32 numCheckBytes)

+  { return CLZInWindow::NeedMove(numCheckBytes) ? 1: 0; }

+

+STDMETHODIMP_(void) CMatchFinder::ChangeBufferPos()

+  { CLZInWindow::MoveBlock();}

+

+#undef HASH_CALC

+#undef kNumHashDirectBytes

+ 

+}

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/HashChain/HC4.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/HashChain/HC4.h
new file mode 100644
index 0000000000..949863be5e
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/HashChain/HC4.h
@@ -0,0 +1,19 @@
+// HC4.h

+

+#ifndef __HC4_H

+#define __HC4_H

+

+#define BT_NAMESPACE NHC4

+

+#define HASH_ARRAY_2

+#define HASH_ARRAY_3

+

+#include "HCMain.h"

+

+#undef HASH_ARRAY_2

+#undef HASH_ARRAY_3

+

+#undef BT_NAMESPACE

+

+#endif

+

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/HashChain/HCMain.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/HashChain/HCMain.h
new file mode 100644
index 0000000000..fafce39797
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/HashChain/HCMain.h
@@ -0,0 +1,6 @@
+// HCMain.h

+

+#define _HASH_CHAIN

+#include "../BinTree/BinTreeMain.h"

+#undef _HASH_CHAIN

+

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/IMatchFinder.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/IMatchFinder.h
new file mode 100644
index 0000000000..4bbc14f35a
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/IMatchFinder.h
@@ -0,0 +1,33 @@
+// MatchFinders/IMatchFinder.h

+

+#ifndef __IMATCHFINDER_H

+#define __IMATCHFINDER_H

+

+struct IInWindowStream: public IUnknown

+{

+  STDMETHOD(SetStream)(ISequentialInStream *inStream) PURE;

+  STDMETHOD_(void, ReleaseStream)() PURE;

+  STDMETHOD(Init)() PURE;

+  STDMETHOD_(Byte, GetIndexByte)(Int32 index) PURE;

+  STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 distance, UInt32 limit) PURE;

+  STDMETHOD_(UInt32, GetNumAvailableBytes)() PURE;

+  STDMETHOD_(const Byte *, GetPointerToCurrentPos)() PURE;

+  STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes) PURE;

+  STDMETHOD_(void, ChangeBufferPos)() PURE;

+};

+ 

+struct IMatchFinder: public IInWindowStream

+{

+  STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, 

+      UInt32 matchMaxLen, UInt32 keepAddBufferAfter) PURE;

+  STDMETHOD(GetMatches)(UInt32 *distances) PURE;

+  STDMETHOD(Skip)(UInt32 num) PURE;

+};

+

+struct IMatchFinderSetNumPasses

+{

+  //virtual ~IMatchFinderSetNumPasses(){}

+  virtual void SetNumPasses(UInt32 numPasses) PURE;

+};

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/LZInWindow.cpp b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/LZInWindow.cpp
new file mode 100644
index 0000000000..a0f791173a
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/LZInWindow.cpp
@@ -0,0 +1,105 @@
+// LZInWindow.cpp

+

+#include "StdAfx.h"

+

+#include "LZInWindow.h"

+#include "../../../Common/MyCom.h"

+#include "../../../Common/Alloc.h"

+

+void CLZInWindow::Free()

+{

+  ::BigFree(_bufferBase);

+  _bufferBase = 0;

+}

+

+bool CLZInWindow::Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv)

+{

+  _keepSizeBefore = keepSizeBefore;

+  _keepSizeAfter = keepSizeAfter;

+  UInt32 blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;

+  if (_bufferBase == 0 || _blockSize != blockSize)

+  {

+    Free();

+    _blockSize = blockSize;

+    if (_blockSize != 0)

+      _bufferBase = (Byte *)::BigAlloc(_blockSize);

+  }

+  _pointerToLastSafePosition = _bufferBase + _blockSize - keepSizeAfter;

+  if (_blockSize == 0)

+    return true;

+  return (_bufferBase != 0);

+}

+

+void CLZInWindow::SetStream(ISequentialInStream *stream)

+{

+  _stream = stream;

+}

+

+HRESULT CLZInWindow::Init()

+{

+  _buffer = _bufferBase;

+  _pos = 0;

+  _streamPos = 0;

+  _streamEndWasReached = false;

+  return ReadBlock();

+}

+

+/*

+void CLZInWindow::ReleaseStream()

+{

+  _stream.Release();

+}

+*/

+

+///////////////////////////////////////////

+// ReadBlock

+

+// In State:

+//   (_buffer + _streamPos) <= (_bufferBase + _blockSize)

+// Out State:

+//   _posLimit <= _blockSize - _keepSizeAfter;

+//   if(_streamEndWasReached == false):

+//     _streamPos >= _pos + _keepSizeAfter

+//     _posLimit = _streamPos - _keepSizeAfter;

+//   else

+//          

+  

+HRESULT CLZInWindow::ReadBlock()

+{

+  if(_streamEndWasReached)

+    return S_OK;

+  while(true)

+  {

+    UInt32 size = (UInt32)(_bufferBase - _buffer) + _blockSize - _streamPos;

+    if(size == 0)

+      return S_OK;

+    UInt32 numReadBytes;

+    RINOK(_stream->Read(_buffer + _streamPos, size, &numReadBytes));

+    if(numReadBytes == 0)

+    {

+      _posLimit = _streamPos;

+      const Byte *pointerToPostion = _buffer + _posLimit;

+      if(pointerToPostion > _pointerToLastSafePosition)

+        _posLimit = (UInt32)(_pointerToLastSafePosition - _buffer);

+      _streamEndWasReached = true;

+      return S_OK;

+    }

+    _streamPos += numReadBytes;

+    if(_streamPos >= _pos + _keepSizeAfter)

+    {

+      _posLimit = _streamPos - _keepSizeAfter;

+      return S_OK;

+    }

+  }

+}

+

+void CLZInWindow::MoveBlock()

+{

+  UInt32 offset = (UInt32)(_buffer - _bufferBase) + _pos - _keepSizeBefore;

+  // we need one additional byte, since MovePos moves on 1 byte.

+  if (offset > 0)

+    offset--; 

+  UInt32 numBytes = (UInt32)(_buffer - _bufferBase) + _streamPos -  offset;

+  memmove(_bufferBase, _bufferBase + offset, numBytes);

+  _buffer -= offset;

+}

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/LZInWindow.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/LZInWindow.h
new file mode 100644
index 0000000000..87cb8e94fa
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/LZInWindow.h
@@ -0,0 +1,87 @@
+// LZInWindow.h

+

+#ifndef __LZ_IN_WINDOW_H

+#define __LZ_IN_WINDOW_H

+

+#include "../../IStream.h"

+

+class CLZInWindow

+{

+  Byte *_bufferBase; // pointer to buffer with data

+  ISequentialInStream *_stream;

+  UInt32 _posLimit;  // offset (from _buffer) when new block reading must be done

+  bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream

+  const Byte *_pointerToLastSafePosition;

+protected:

+  Byte  *_buffer;   // Pointer to virtual Buffer begin

+  UInt32 _blockSize;  // Size of Allocated memory block

+  UInt32 _pos;             // offset (from _buffer) of curent byte

+  UInt32 _keepSizeBefore;  // how many BYTEs must be kept in buffer before _pos

+  UInt32 _keepSizeAfter;   // how many BYTEs must be kept buffer after _pos

+  UInt32 _streamPos;   // offset (from _buffer) of first not read byte from Stream

+

+  void MoveBlock();

+  HRESULT ReadBlock();

+  void Free();

+public:

+  CLZInWindow(): _bufferBase(0) {}

+  virtual ~CLZInWindow() { Free(); }

+

+  // keepSizeBefore + keepSizeAfter + keepSizeReserv < 4G)

+  bool Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv = (1<<17));

+

+  void SetStream(ISequentialInStream *stream);

+  HRESULT Init();

+  // void ReleaseStream();

+

+  Byte *GetBuffer() const { return _buffer; }

+

+  const Byte *GetPointerToCurrentPos() const { return _buffer + _pos; }

+

+  HRESULT MovePos()

+  {

+    _pos++;

+    if (_pos > _posLimit)

+    {

+      const Byte *pointerToPostion = _buffer + _pos;

+      if(pointerToPostion > _pointerToLastSafePosition)

+        MoveBlock();

+      return ReadBlock();

+    }

+    else

+      return S_OK;

+  }

+  Byte GetIndexByte(Int32 index) const  {  return _buffer[(size_t)_pos + index]; }

+

+  // index + limit have not to exceed _keepSizeAfter;

+  // -2G <= index < 2G

+  UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit) const

+  {  

+    if(_streamEndWasReached)

+      if ((_pos + index) + limit > _streamPos)

+        limit = _streamPos - (_pos + index);

+    distance++;

+    const Byte *pby = _buffer + (size_t)_pos + index;

+    UInt32 i;

+    for(i = 0; i < limit && pby[i] == pby[(size_t)i - distance]; i++);

+    return i;

+  }

+

+  UInt32 GetNumAvailableBytes() const { return _streamPos - _pos; }

+

+  void ReduceOffsets(Int32 subValue)

+  {

+    _buffer += subValue;

+    _posLimit -= subValue;

+    _pos -= subValue;

+    _streamPos -= subValue;

+  }

+

+  bool NeedMove(UInt32 numCheckBytes)

+  {

+    UInt32 reserv = _pointerToLastSafePosition - (_buffer + _pos);

+    return (reserv <= numCheckBytes);

+  }

+};

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/StdAfx.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/StdAfx.h
new file mode 100644
index 0000000000..3de038a4ff
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZ/StdAfx.h
@@ -0,0 +1,6 @@
+// StdAfx.h

+

+#ifndef __STDAFX_H

+#define __STDAFX_H

+

+#endif 

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMA.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMA.h
new file mode 100644
index 0000000000..d53296ee70
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMA.h
@@ -0,0 +1,82 @@
+// LZMA.h

+

+#ifndef __LZMA_H

+#define __LZMA_H

+

+namespace NCompress {

+namespace NLZMA {

+

+const UInt32 kNumRepDistances = 4;

+

+const int kNumStates = 12;

+

+const Byte kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4,  5,  6,   4, 5};

+const Byte kMatchNextStates[kNumStates]   = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};

+const Byte kRepNextStates[kNumStates]     = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};

+const Byte kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};

+

+class CState

+{

+public:

+  Byte Index;

+  void Init() { Index = 0; }

+  void UpdateChar() { Index = kLiteralNextStates[Index]; }

+  void UpdateMatch() { Index = kMatchNextStates[Index]; }

+  void UpdateRep() { Index = kRepNextStates[Index]; }

+  void UpdateShortRep() { Index = kShortRepNextStates[Index]; }

+  bool IsCharState() const { return Index < 7; }

+};

+

+const int kNumPosSlotBits = 6; 

+const int kDicLogSizeMin = 0; 

+const int kDicLogSizeMax = 32; 

+const int kDistTableSizeMax = kDicLogSizeMax * 2; 

+

+const UInt32 kNumLenToPosStates = 4;

+

+inline UInt32 GetLenToPosState(UInt32 len)

+{

+  len -= 2;

+  if (len < kNumLenToPosStates)

+    return len;

+  return kNumLenToPosStates - 1;

+}

+

+namespace NLength {

+

+const int kNumPosStatesBitsMax = 4;

+const UInt32 kNumPosStatesMax = (1 << kNumPosStatesBitsMax);

+

+const int kNumPosStatesBitsEncodingMax = 4;

+const UInt32 kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);

+

+const int kNumLowBits = 3;

+const int kNumMidBits = 3;

+const int kNumHighBits = 8;

+const UInt32 kNumLowSymbols = 1 << kNumLowBits;

+const UInt32 kNumMidSymbols = 1 << kNumMidBits;

+const UInt32 kNumSymbolsTotal = kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits);

+

+}

+

+const UInt32 kMatchMinLen = 2;

+const UInt32 kMatchMaxLen = kMatchMinLen + NLength::kNumSymbolsTotal - 1;

+

+const int kNumAlignBits = 4;

+const UInt32 kAlignTableSize = 1 << kNumAlignBits;

+const UInt32 kAlignMask = (kAlignTableSize - 1);

+

+const UInt32 kStartPosModelIndex = 4;

+const UInt32 kEndPosModelIndex = 14;

+const UInt32 kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;

+

+const UInt32 kNumFullDistances = 1 << (kEndPosModelIndex / 2);

+

+const int kNumLitPosStatesBitsEncodingMax = 4;

+const int kNumLitContextBitsMax = 8;

+

+const int kNumMoveBits = 5;

+

+}}

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMAEncoder.cpp b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMAEncoder.cpp
new file mode 100644
index 0000000000..b6a2f7d591
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMAEncoder.cpp
@@ -0,0 +1,1564 @@
+// LZMA/Encoder.cpp

+

+#include "StdAfx.h"

+

+#include "../../../Common/Defs.h"

+#include "../../Common/StreamUtils.h"

+

+#include "LZMAEncoder.h"

+

+// for minimal compressing code size define these:

+// #define COMPRESS_MF_BT

+// #define COMPRESS_MF_BT4

+

+#if !defined(COMPRESS_MF_BT) && !defined(COMPRESS_MF_HC)

+#define COMPRESS_MF_BT

+#define COMPRESS_MF_HC

+#endif

+

+#ifdef COMPRESS_MF_BT

+#if !defined(COMPRESS_MF_BT2) && !defined(COMPRESS_MF_BT3) && !defined(COMPRESS_MF_BT4)

+#define COMPRESS_MF_BT2

+#define COMPRESS_MF_BT3

+#define COMPRESS_MF_BT4

+#endif

+#ifdef COMPRESS_MF_BT2

+#include "../LZ/BinTree/BinTree2.h"

+#endif

+#ifdef COMPRESS_MF_BT3

+#include "../LZ/BinTree/BinTree3.h"

+#endif

+#ifdef COMPRESS_MF_BT4

+#include "../LZ/BinTree/BinTree4.h"

+#endif

+#endif

+

+#ifdef COMPRESS_MF_HC

+#include "../LZ/HashChain/HC4.h"

+#endif

+

+#ifdef COMPRESS_MF_MT

+#include "../LZ/MT/MT.h"

+#endif

+

+namespace NCompress {

+namespace NLZMA {

+

+const int kDefaultDictionaryLogSize = 22;

+const UInt32 kNumFastBytesDefault = 0x20;

+

+enum 

+{

+  kBT2,

+  kBT3,

+  kBT4,

+  kHC4

+};

+

+static const wchar_t *kMatchFinderIDs[] = 

+{

+  L"BT2",

+  L"BT3",

+  L"BT4",

+  L"HC4"

+};

+

+Byte g_FastPos[1 << 11];

+

+class CFastPosInit

+{

+public:

+  CFastPosInit() { Init(); }

+  void Init()

+  {

+    const Byte kFastSlots = 22;

+    int c = 2;

+    g_FastPos[0] = 0;

+    g_FastPos[1] = 1;

+

+    for (Byte slotFast = 2; slotFast < kFastSlots; slotFast++)

+    {

+      UInt32 k = (1 << ((slotFast >> 1) - 1));

+      for (UInt32 j = 0; j < k; j++, c++)

+        g_FastPos[c] = slotFast;

+    }

+  }

+} g_FastPosInit;

+

+

+void CLiteralEncoder2::Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol)

+{

+  UInt32 context = 1;

+  int i = 8;

+  do 

+  {

+    i--;

+    UInt32 bit = (symbol >> i) & 1;

+    _encoders[context].Encode(rangeEncoder, bit);

+    context = (context << 1) | bit;

+  }

+  while(i != 0);

+}

+

+void CLiteralEncoder2::EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, 

+    Byte matchByte, Byte symbol)

+{

+  UInt32 context = 1;

+  int i = 8;

+  do 

+  {

+    i--;

+    UInt32 bit = (symbol >> i) & 1;

+    UInt32 matchBit = (matchByte >> i) & 1;

+    _encoders[0x100 + (matchBit << 8) + context].Encode(rangeEncoder, bit);

+    context = (context << 1) | bit;

+    if (matchBit != bit)

+    {

+      while(i != 0)

+      {

+        i--;

+        UInt32 bit = (symbol >> i) & 1;

+        _encoders[context].Encode(rangeEncoder, bit);

+        context = (context << 1) | bit;

+      }

+      break;

+    }

+  }

+  while(i != 0);

+}

+

+UInt32 CLiteralEncoder2::GetPrice(bool matchMode, Byte matchByte, Byte symbol) const

+{

+  UInt32 price = 0;

+  UInt32 context = 1;

+  int i = 8;

+  if (matchMode)

+  {

+    do 

+    {

+      i--;

+      UInt32 matchBit = (matchByte >> i) & 1;

+      UInt32 bit = (symbol >> i) & 1;

+      price += _encoders[0x100 + (matchBit << 8) + context].GetPrice(bit);

+      context = (context << 1) | bit;

+      if (matchBit != bit)

+        break;

+    }

+    while (i != 0);

+  }

+  while(i != 0)

+  {

+    i--;

+    UInt32 bit = (symbol >> i) & 1;

+    price += _encoders[context].GetPrice(bit);

+    context = (context << 1) | bit;

+  }

+  return price;

+};

+

+

+namespace NLength {

+

+void CEncoder::Init(UInt32 numPosStates)

+{

+  _choice.Init();

+  _choice2.Init();

+  for (UInt32 posState = 0; posState < numPosStates; posState++)

+  {

+    _lowCoder[posState].Init();

+    _midCoder[posState].Init();

+  }

+  _highCoder.Init();

+}

+

+void CEncoder::Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState)

+{

+  if(symbol < kNumLowSymbols)

+  {

+    _choice.Encode(rangeEncoder, 0);

+    _lowCoder[posState].Encode(rangeEncoder, symbol);

+  }

+  else

+  {

+    _choice.Encode(rangeEncoder, 1);

+    if(symbol < kNumLowSymbols + kNumMidSymbols)

+    {

+      _choice2.Encode(rangeEncoder, 0);

+      _midCoder[posState].Encode(rangeEncoder, symbol - kNumLowSymbols);

+    }

+    else

+    {

+      _choice2.Encode(rangeEncoder, 1);

+      _highCoder.Encode(rangeEncoder, symbol - kNumLowSymbols - kNumMidSymbols);

+    }

+  }

+}

+

+void CEncoder::SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const

+{

+  UInt32 a0 = _choice.GetPrice0();

+  UInt32 a1 = _choice.GetPrice1();

+  UInt32 b0 = a1 + _choice2.GetPrice0();

+  UInt32 b1 = a1 + _choice2.GetPrice1();

+  UInt32 i = 0;

+  for (i = 0; i < kNumLowSymbols; i++)

+  {

+    if (i >= numSymbols)

+      return;

+    prices[i] = a0 + _lowCoder[posState].GetPrice(i);

+  }

+  for (; i < kNumLowSymbols + kNumMidSymbols; i++)

+  {

+    if (i >= numSymbols)

+      return;

+    prices[i] = b0 + _midCoder[posState].GetPrice(i - kNumLowSymbols);

+  }

+  for (; i < numSymbols; i++)

+    prices[i] = b1 + _highCoder.GetPrice(i - kNumLowSymbols - kNumMidSymbols);

+}

+

+}

+CEncoder::CEncoder():

+  _numFastBytes(kNumFastBytesDefault),

+  _distTableSize(kDefaultDictionaryLogSize * 2),

+  _posStateBits(2),

+  _posStateMask(4 - 1),

+  _numLiteralPosStateBits(0),

+  _numLiteralContextBits(3),

+  _dictionarySize(1 << kDefaultDictionaryLogSize),

+  _dictionarySizePrev(UInt32(-1)),

+  _numFastBytesPrev(UInt32(-1)),

+  _matchFinderCycles(0),

+  _matchFinderIndex(kBT4),

+   #ifdef COMPRESS_MF_MT

+  _multiThread(false),

+   #endif

+  _writeEndMark(false),

+  setMfPasses(0)

+{

+  // _maxMode = false;

+  _fastMode = false;

+}

+

+HRESULT CEncoder::Create()

+{

+  if (!_rangeEncoder.Create(1 << 20))

+    return E_OUTOFMEMORY;

+  if (!_matchFinder)

+  {

+    switch(_matchFinderIndex)

+    {

+      #ifdef COMPRESS_MF_BT

+      #ifdef COMPRESS_MF_BT2

+      case kBT2:

+      {

+        NBT2::CMatchFinder *mfSpec = new NBT2::CMatchFinder;

+        setMfPasses = mfSpec;

+        _matchFinder = mfSpec;

+        break;

+      }

+      #endif

+      #ifdef COMPRESS_MF_BT3

+      case kBT3:

+      {

+        NBT3::CMatchFinder *mfSpec = new NBT3::CMatchFinder;

+        setMfPasses = mfSpec;

+        _matchFinder = mfSpec;

+        break;

+      }

+      #endif

+      #ifdef COMPRESS_MF_BT4

+      case kBT4:

+      {

+        NBT4::CMatchFinder *mfSpec = new NBT4::CMatchFinder;

+        setMfPasses = mfSpec;

+        _matchFinder = mfSpec;

+        break;

+      }

+      #endif

+      #endif

+      

+      #ifdef COMPRESS_MF_HC

+      case kHC4:

+      {

+        NHC4::CMatchFinder *mfSpec = new NHC4::CMatchFinder;

+        setMfPasses = mfSpec;

+        _matchFinder = mfSpec;

+        break;

+      }

+      #endif

+    }

+    if (_matchFinder == 0)

+      return E_OUTOFMEMORY;

+

+    #ifdef COMPRESS_MF_MT

+    if (_multiThread && !(_fastMode && (_matchFinderIndex == kHC4)))

+    {

+      CMatchFinderMT *mfSpec = new CMatchFinderMT;

+      if (mfSpec == 0)

+        return E_OUTOFMEMORY;

+      CMyComPtr<IMatchFinder> mf = mfSpec;

+      RINOK(mfSpec->SetMatchFinder(_matchFinder));

+      _matchFinder.Release();

+      _matchFinder = mf;

+    }

+    #endif

+  }

+  

+  if (!_literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits))

+    return E_OUTOFMEMORY;

+

+  if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)

+    return S_OK;

+  RINOK(_matchFinder->Create(_dictionarySize, kNumOpts, _numFastBytes, kMatchMaxLen + 1)); // actually it's + _numFastBytes - _numFastBytes

+  if (_matchFinderCycles != 0 && setMfPasses != 0)

+    setMfPasses->SetNumPasses(_matchFinderCycles);

+  _dictionarySizePrev = _dictionarySize;

+  _numFastBytesPrev = _numFastBytes;

+  return S_OK;

+}

+

+static bool AreStringsEqual(const wchar_t *base, const wchar_t *testString)

+{

+  while (true)

+  {

+    wchar_t c = *testString;

+    if (c >= 'a' && c <= 'z')

+      c -= 0x20;

+    if (*base != c)

+      return false;

+    if (c == 0)

+      return true;

+    base++;

+    testString++;

+  }

+}

+

+static int FindMatchFinder(const wchar_t *s)

+{

+  for (int m = 0; m < (int)(sizeof(kMatchFinderIDs) / sizeof(kMatchFinderIDs[0])); m++)

+    if (AreStringsEqual(kMatchFinderIDs[m], s))

+      return m;

+  return -1;

+}

+

+STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, 

+    const PROPVARIANT *properties, UInt32 numProperties)

+{

+  for (UInt32 i = 0; i < numProperties; i++)

+  {

+    const PROPVARIANT &prop = properties[i];

+    switch(propIDs[i])

+    {

+      case NCoderPropID::kNumFastBytes:

+      {

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        UInt32 numFastBytes = prop.ulVal;

+        if(numFastBytes < 5 || numFastBytes > kMatchMaxLen)

+          return E_INVALIDARG;

+        _numFastBytes = numFastBytes;

+        break;

+      }

+      case NCoderPropID::kMatchFinderCycles:

+      {

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        _matchFinderCycles = prop.ulVal;

+        break;

+      }

+      case NCoderPropID::kAlgorithm:

+      {

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        UInt32 maximize = prop.ulVal;

+        _fastMode = (maximize == 0); 

+        // _maxMode = (maximize >= 2);

+        break;

+      }

+      case NCoderPropID::kMatchFinder:

+      {

+        if (prop.vt != VT_BSTR)

+          return E_INVALIDARG;

+        int matchFinderIndexPrev = _matchFinderIndex;

+        int m = FindMatchFinder(prop.bstrVal);

+        if (m < 0)

+          return E_INVALIDARG;

+        _matchFinderIndex = m;

+        if (_matchFinder && matchFinderIndexPrev != _matchFinderIndex)

+        {

+          _dictionarySizePrev = (UInt32)-1;

+          ReleaseMatchFinder();

+        }

+        break;

+      }

+      #ifdef COMPRESS_MF_MT

+      case NCoderPropID::kMultiThread:

+      {

+        if (prop.vt != VT_BOOL)

+          return E_INVALIDARG;

+        bool newMultiThread = (prop.boolVal == VARIANT_TRUE);

+        if (newMultiThread != _multiThread)

+        {

+          _dictionarySizePrev = (UInt32)-1;

+          ReleaseMatchFinder();

+          _multiThread = newMultiThread;

+        }

+        break;

+      }

+      case NCoderPropID::kNumThreads:

+      {

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        bool newMultiThread = (prop.ulVal > 1);

+        if (newMultiThread != _multiThread)

+        {

+          _dictionarySizePrev = (UInt32)-1;

+          ReleaseMatchFinder();

+          _multiThread = newMultiThread;

+        }

+        break;

+      }

+      #endif

+      case NCoderPropID::kDictionarySize:

+      {

+        const int kDicLogSizeMaxCompress = 30;

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        UInt32 dictionarySize = prop.ulVal;

+        if (dictionarySize < UInt32(1 << kDicLogSizeMin) ||

+            dictionarySize > UInt32(1 << kDicLogSizeMaxCompress))

+          return E_INVALIDARG;

+        _dictionarySize = dictionarySize;

+        UInt32 dicLogSize;

+        for(dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++)

+          if (dictionarySize <= (UInt32(1) << dicLogSize))

+            break;

+        _distTableSize = dicLogSize * 2;

+        break;

+      }

+      case NCoderPropID::kPosStateBits:

+      {

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        UInt32 value = prop.ulVal;

+        if (value > (UInt32)NLength::kNumPosStatesBitsEncodingMax)

+          return E_INVALIDARG;

+        _posStateBits = value;

+        _posStateMask = (1 << _posStateBits) - 1;

+        break;

+      }

+      case NCoderPropID::kLitPosBits:

+      {

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        UInt32 value = prop.ulVal;

+        if (value > (UInt32)kNumLitPosStatesBitsEncodingMax)

+          return E_INVALIDARG;

+        _numLiteralPosStateBits = value;

+        break;

+      }

+      case NCoderPropID::kLitContextBits:

+      {

+        if (prop.vt != VT_UI4)

+          return E_INVALIDARG;

+        UInt32 value = prop.ulVal;

+        if (value > (UInt32)kNumLitContextBitsMax)

+          return E_INVALIDARG;

+        _numLiteralContextBits = value;

+        break;

+      }

+      case NCoderPropID::kEndMarker:

+      {

+        if (prop.vt != VT_BOOL)

+          return E_INVALIDARG;

+        SetWriteEndMarkerMode(prop.boolVal == VARIANT_TRUE);

+        break;

+      }

+      default:

+        return E_INVALIDARG;

+    }

+  }

+  return S_OK;

+}

+

+STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)

+{ 

+  const UInt32 kPropSize = 5;

+  Byte properties[kPropSize];

+  properties[0] = (_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits;

+  for (int i = 0; i < 4; i++)

+    properties[1 + i] = Byte(_dictionarySize >> (8 * i));

+  return WriteStream(outStream, properties, kPropSize, NULL);

+}

+

+STDMETHODIMP CEncoder::SetOutStream(ISequentialOutStream *outStream)

+{

+  _rangeEncoder.SetStream(outStream);

+  return S_OK;

+}

+

+STDMETHODIMP CEncoder::ReleaseOutStream()

+{

+  _rangeEncoder.ReleaseStream();

+  return S_OK;

+}

+

+HRESULT CEncoder::Init()

+{

+  CBaseState::Init();

+

+  // RINOK(_matchFinder->Init(inStream));

+  _rangeEncoder.Init();

+

+  for(int i = 0; i < kNumStates; i++)

+  {

+    for (UInt32 j = 0; j <= _posStateMask; j++)

+    {

+      _isMatch[i][j].Init();

+      _isRep0Long[i][j].Init();

+    }

+    _isRep[i].Init();

+    _isRepG0[i].Init();

+    _isRepG1[i].Init();

+    _isRepG2[i].Init();

+  }

+

+  _literalEncoder.Init();

+

+  {

+    for(UInt32 i = 0; i < kNumLenToPosStates; i++)

+      _posSlotEncoder[i].Init();

+  }

+  {

+    for(UInt32 i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)

+      _posEncoders[i].Init();

+  }

+

+  _lenEncoder.Init(1 << _posStateBits);

+  _repMatchLenEncoder.Init(1 << _posStateBits);

+

+  _posAlignEncoder.Init();

+

+  _longestMatchWasFound = false;

+  _optimumEndIndex = 0;

+  _optimumCurrentIndex = 0;

+  _additionalOffset = 0;

+

+  return S_OK;

+}

+

+HRESULT CEncoder::MovePos(UInt32 num)

+{

+  if (num == 0)

+    return S_OK;

+  _additionalOffset += num;

+  return _matchFinder->Skip(num);

+}

+

+UInt32 CEncoder::Backward(UInt32 &backRes, UInt32 cur)

+{

+  _optimumEndIndex = cur;

+  UInt32 posMem = _optimum[cur].PosPrev;

+  UInt32 backMem = _optimum[cur].BackPrev;

+  do

+  {

+    if (_optimum[cur].Prev1IsChar)

+    {

+      _optimum[posMem].MakeAsChar();

+      _optimum[posMem].PosPrev = posMem - 1;

+      if (_optimum[cur].Prev2)

+      {

+        _optimum[posMem - 1].Prev1IsChar = false;

+        _optimum[posMem - 1].PosPrev = _optimum[cur].PosPrev2;

+        _optimum[posMem - 1].BackPrev = _optimum[cur].BackPrev2;

+      }

+    }

+    UInt32 posPrev = posMem;

+    UInt32 backCur = backMem;

+

+    backMem = _optimum[posPrev].BackPrev;

+    posMem = _optimum[posPrev].PosPrev;

+

+    _optimum[posPrev].BackPrev = backCur;

+    _optimum[posPrev].PosPrev = cur;

+    cur = posPrev;

+  }

+  while(cur != 0);

+  backRes = _optimum[0].BackPrev;

+  _optimumCurrentIndex  = _optimum[0].PosPrev;

+  return _optimumCurrentIndex; 

+}

+

+/*

+Out:

+  (lenRes == 1) && (backRes == 0xFFFFFFFF) means Literal

+*/

+

+HRESULT CEncoder::GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes)

+{

+  if(_optimumEndIndex != _optimumCurrentIndex)

+  {

+    const COptimal &optimum = _optimum[_optimumCurrentIndex];

+    lenRes = optimum.PosPrev - _optimumCurrentIndex;

+    backRes = optimum.BackPrev;

+    _optimumCurrentIndex = optimum.PosPrev;

+    return S_OK;

+  }

+  _optimumCurrentIndex = _optimumEndIndex = 0;

+  

+  UInt32 lenMain, numDistancePairs;

+  if (!_longestMatchWasFound)

+  {

+    RINOK(ReadMatchDistances(lenMain, numDistancePairs));

+  }

+  else

+  {

+    lenMain = _longestMatchLength;

+    numDistancePairs = _numDistancePairs;

+    _longestMatchWasFound = false;

+  }

+

+  const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;

+  UInt32 numAvailableBytes = _matchFinder->GetNumAvailableBytes() + 1;

+  if (numAvailableBytes < 2)

+  {

+    backRes = (UInt32)(-1);

+    lenRes = 1;

+    return S_OK;

+  }

+  if (numAvailableBytes > kMatchMaxLen)

+    numAvailableBytes = kMatchMaxLen;

+

+  UInt32 reps[kNumRepDistances];

+  UInt32 repLens[kNumRepDistances];

+  UInt32 repMaxIndex = 0;

+  UInt32 i;

+  for(i = 0; i < kNumRepDistances; i++)

+  {

+    reps[i] = _repDistances[i];

+    UInt32 backOffset = reps[i] + 1;

+    if (data[0] != data[(size_t)0 - backOffset] || data[1] != data[(size_t)1 - backOffset])

+    {

+      repLens[i] = 0;

+      continue;

+    }

+    UInt32 lenTest;

+    for (lenTest = 2; lenTest < numAvailableBytes && 

+        data[lenTest] == data[(size_t)lenTest - backOffset]; lenTest++);

+    repLens[i] = lenTest;

+    if (lenTest > repLens[repMaxIndex])

+      repMaxIndex = i;

+  }

+  if(repLens[repMaxIndex] >= _numFastBytes)

+  {

+    backRes = repMaxIndex;

+    lenRes = repLens[repMaxIndex];

+    return MovePos(lenRes - 1);

+  }

+

+  UInt32 *matchDistances = _matchDistances + 1;

+  if(lenMain >= _numFastBytes)

+  {

+    backRes = matchDistances[numDistancePairs - 1] + kNumRepDistances; 

+    lenRes = lenMain;

+    return MovePos(lenMain - 1);

+  }

+  Byte currentByte = *data;

+  Byte matchByte = data[(size_t)0 - reps[0] - 1];

+

+  if(lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2)

+  {

+    backRes = (UInt32)-1;

+    lenRes = 1;

+    return S_OK;

+  }

+

+  _optimum[0].State = _state;

+

+  UInt32 posState = (position & _posStateMask);

+

+  _optimum[1].Price = _isMatch[_state.Index][posState].GetPrice0() + 

+      _literalEncoder.GetSubCoder(position, _previousByte)->GetPrice(!_state.IsCharState(), matchByte, currentByte);

+  _optimum[1].MakeAsChar();

+

+  UInt32 matchPrice = _isMatch[_state.Index][posState].GetPrice1();

+  UInt32 repMatchPrice = matchPrice + _isRep[_state.Index].GetPrice1();

+

+  if(matchByte == currentByte)

+  {

+    UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);

+    if(shortRepPrice < _optimum[1].Price)

+    {

+      _optimum[1].Price = shortRepPrice;

+      _optimum[1].MakeAsShortRep();

+    }

+  }

+  UInt32 lenEnd = ((lenMain >= repLens[repMaxIndex]) ? lenMain : repLens[repMaxIndex]);

+

+  if(lenEnd < 2)

+  {

+    backRes = _optimum[1].BackPrev;

+    lenRes = 1;

+    return S_OK;

+  }

+

+  _optimum[1].PosPrev = 0;

+  for (i = 0; i < kNumRepDistances; i++)

+    _optimum[0].Backs[i] = reps[i];

+

+  UInt32 len = lenEnd;

+  do

+    _optimum[len--].Price = kIfinityPrice;

+  while (len >= 2);

+

+  for(i = 0; i < kNumRepDistances; i++)

+  {

+    UInt32 repLen = repLens[i];

+    if (repLen < 2)

+      continue;

+    UInt32 price = repMatchPrice + GetPureRepPrice(i, _state, posState);

+    do

+    {

+      UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(repLen - 2, posState);

+      COptimal &optimum = _optimum[repLen];

+      if (curAndLenPrice < optimum.Price) 

+      {

+        optimum.Price = curAndLenPrice;

+        optimum.PosPrev = 0;

+        optimum.BackPrev = i;

+        optimum.Prev1IsChar = false;

+      }

+    }

+    while(--repLen >= 2);

+  }

+

+  UInt32 normalMatchPrice = matchPrice + _isRep[_state.Index].GetPrice0();

+

+  len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);

+  if (len <= lenMain)

+  {

+    UInt32 offs = 0;

+    while (len > matchDistances[offs])

+      offs += 2;

+    for(; ; len++)

+    {

+      UInt32 distance = matchDistances[offs + 1];

+      UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(distance, len, posState);

+      COptimal &optimum = _optimum[len];

+      if (curAndLenPrice < optimum.Price) 

+      {

+        optimum.Price = curAndLenPrice;

+        optimum.PosPrev = 0;

+        optimum.BackPrev = distance + kNumRepDistances;

+        optimum.Prev1IsChar = false;

+      }

+      if (len == matchDistances[offs])

+      {

+        offs += 2;

+        if (offs == numDistancePairs)

+          break;

+      }

+    }

+  }

+

+  UInt32 cur = 0;

+

+  while(true)

+  {

+    cur++;

+    if(cur == lenEnd)

+    {

+      lenRes = Backward(backRes, cur);

+      return S_OK;

+    }

+    UInt32 newLen, numDistancePairs;

+    RINOK(ReadMatchDistances(newLen, numDistancePairs));

+    if(newLen >= _numFastBytes)

+    {

+      _numDistancePairs = numDistancePairs;

+      _longestMatchLength = newLen;

+      _longestMatchWasFound = true;

+      lenRes = Backward(backRes, cur);

+      return S_OK;

+    }

+    position++;

+    COptimal &curOptimum = _optimum[cur];

+    UInt32 posPrev = curOptimum.PosPrev;

+    CState state;

+    if (curOptimum.Prev1IsChar)

+    {

+      posPrev--;

+      if (curOptimum.Prev2)

+      {

+        state = _optimum[curOptimum.PosPrev2].State;

+        if (curOptimum.BackPrev2 < kNumRepDistances)

+          state.UpdateRep();

+        else

+          state.UpdateMatch();

+      }

+      else

+        state = _optimum[posPrev].State;

+      state.UpdateChar();

+    }

+    else

+      state = _optimum[posPrev].State;

+    if (posPrev == cur - 1)

+    {

+      if (curOptimum.IsShortRep())

+        state.UpdateShortRep();

+      else

+        state.UpdateChar();

+    }

+    else

+    {

+      UInt32 pos;

+      if (curOptimum.Prev1IsChar && curOptimum.Prev2)

+      {

+        posPrev = curOptimum.PosPrev2;

+        pos = curOptimum.BackPrev2;

+        state.UpdateRep();

+      }

+      else

+      {

+        pos = curOptimum.BackPrev;

+        if (pos < kNumRepDistances)

+          state.UpdateRep();

+        else

+          state.UpdateMatch();

+      }

+      const COptimal &prevOptimum = _optimum[posPrev];

+      if (pos < kNumRepDistances)

+      {

+        reps[0] = prevOptimum.Backs[pos];

+    		UInt32 i;

+        for(i = 1; i <= pos; i++)

+          reps[i] = prevOptimum.Backs[i - 1];

+        for(; i < kNumRepDistances; i++)

+          reps[i] = prevOptimum.Backs[i];

+      }

+      else

+      {

+        reps[0] = (pos - kNumRepDistances);

+        for(UInt32 i = 1; i < kNumRepDistances; i++)

+          reps[i] = prevOptimum.Backs[i - 1];

+      }

+    }

+    curOptimum.State = state;

+    for(UInt32 i = 0; i < kNumRepDistances; i++)

+      curOptimum.Backs[i] = reps[i];

+    UInt32 curPrice = curOptimum.Price; 

+    const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;

+    const Byte currentByte = *data;

+    const Byte matchByte = data[(size_t)0 - reps[0] - 1];

+

+    UInt32 posState = (position & _posStateMask);

+

+    UInt32 curAnd1Price = curPrice +

+        _isMatch[state.Index][posState].GetPrice0() +

+        _literalEncoder.GetSubCoder(position, data[(size_t)0 - 1])->GetPrice(!state.IsCharState(), matchByte, currentByte);

+

+    COptimal &nextOptimum = _optimum[cur + 1];

+

+    bool nextIsChar = false;

+    if (curAnd1Price < nextOptimum.Price) 

+    {

+      nextOptimum.Price = curAnd1Price;

+      nextOptimum.PosPrev = cur;

+      nextOptimum.MakeAsChar();

+      nextIsChar = true;

+    }

+

+    UInt32 matchPrice = curPrice + _isMatch[state.Index][posState].GetPrice1();

+    UInt32 repMatchPrice = matchPrice + _isRep[state.Index].GetPrice1();

+    

+    if(matchByte == currentByte &&

+        !(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))

+    {

+      UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);

+      if(shortRepPrice <= nextOptimum.Price)

+      {

+        nextOptimum.Price = shortRepPrice;

+        nextOptimum.PosPrev = cur;

+        nextOptimum.MakeAsShortRep();

+        nextIsChar = true;

+      }

+    }

+    /*

+    if(newLen == 2 && matchDistances[2] >= kDistLimit2) // test it maybe set 2000 ?

+      continue;

+    */

+

+    UInt32 numAvailableBytesFull = _matchFinder->GetNumAvailableBytes() + 1;

+    numAvailableBytesFull = MyMin(kNumOpts - 1 - cur, numAvailableBytesFull);

+    UInt32 numAvailableBytes = numAvailableBytesFull;

+

+    if (numAvailableBytes < 2)

+      continue;

+    if (numAvailableBytes > _numFastBytes)

+      numAvailableBytes = _numFastBytes;

+    if (!nextIsChar && matchByte != currentByte) // speed optimization

+    {

+      // try Literal + rep0

+      UInt32 backOffset = reps[0] + 1;

+      UInt32 limit = MyMin(numAvailableBytesFull, _numFastBytes + 1);

+      UInt32 temp;

+      for (temp = 1; temp < limit && 

+          data[temp] == data[(size_t)temp - backOffset]; temp++);

+      UInt32 lenTest2 = temp - 1;

+      if (lenTest2 >= 2)

+      {

+        CState state2 = state;

+        state2.UpdateChar();

+        UInt32 posStateNext = (position + 1) & _posStateMask;

+        UInt32 nextRepMatchPrice = curAnd1Price + 

+            _isMatch[state2.Index][posStateNext].GetPrice1() +

+            _isRep[state2.Index].GetPrice1();

+        // for (; lenTest2 >= 2; lenTest2--)

+        {

+          UInt32 offset = cur + 1 + lenTest2;

+          while(lenEnd < offset)

+            _optimum[++lenEnd].Price = kIfinityPrice;

+          UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(

+              0, lenTest2, state2, posStateNext);

+          COptimal &optimum = _optimum[offset];

+          if (curAndLenPrice < optimum.Price) 

+          {

+            optimum.Price = curAndLenPrice;

+            optimum.PosPrev = cur + 1;

+            optimum.BackPrev = 0;

+            optimum.Prev1IsChar = true;

+            optimum.Prev2 = false;

+          }

+        }

+      }

+    }

+    

+    UInt32 startLen = 2; // speed optimization 

+    for(UInt32 repIndex = 0; repIndex < kNumRepDistances; repIndex++)

+    {

+      // UInt32 repLen = _matchFinder->GetMatchLen(0 - 1, reps[repIndex], newLen); // test it;

+      UInt32 backOffset = reps[repIndex] + 1;

+      if (data[0] != data[(size_t)0 - backOffset] ||

+          data[1] != data[(size_t)1 - backOffset])

+        continue;

+      UInt32 lenTest;

+      for (lenTest = 2; lenTest < numAvailableBytes && 

+          data[lenTest] == data[(size_t)lenTest - backOffset]; lenTest++);

+      while(lenEnd < cur + lenTest)

+        _optimum[++lenEnd].Price = kIfinityPrice;

+      UInt32 lenTestTemp = lenTest;

+      UInt32 price = repMatchPrice + GetPureRepPrice(repIndex, state, posState);

+      do

+      {

+        UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(lenTest - 2, posState);

+        COptimal &optimum = _optimum[cur + lenTest];

+        if (curAndLenPrice < optimum.Price) 

+        {

+          optimum.Price = curAndLenPrice;

+          optimum.PosPrev = cur;

+          optimum.BackPrev = repIndex;

+          optimum.Prev1IsChar = false;

+        }

+      }

+      while(--lenTest >= 2);

+      lenTest = lenTestTemp;

+      

+      if (repIndex == 0)

+        startLen = lenTest + 1;

+        

+      // if (_maxMode)

+        {

+          UInt32 lenTest2 = lenTest + 1;

+          UInt32 limit = MyMin(numAvailableBytesFull, lenTest2 + _numFastBytes);

+          for (; lenTest2 < limit && 

+              data[lenTest2] == data[(size_t)lenTest2 - backOffset]; lenTest2++);

+          lenTest2 -= lenTest + 1;

+          if (lenTest2 >= 2)

+          {

+            CState state2 = state;

+            state2.UpdateRep();

+            UInt32 posStateNext = (position + lenTest) & _posStateMask;

+            UInt32 curAndLenCharPrice = 

+                price + _repMatchLenEncoder.GetPrice(lenTest - 2, posState) + 

+                _isMatch[state2.Index][posStateNext].GetPrice0() +

+                _literalEncoder.GetSubCoder(position + lenTest, data[(size_t)lenTest - 1])->GetPrice(

+                true, data[(size_t)lenTest - backOffset], data[lenTest]);

+            state2.UpdateChar();

+            posStateNext = (position + lenTest + 1) & _posStateMask;

+            UInt32 nextRepMatchPrice = curAndLenCharPrice + 

+                _isMatch[state2.Index][posStateNext].GetPrice1() +

+                _isRep[state2.Index].GetPrice1();

+            

+            // for(; lenTest2 >= 2; lenTest2--)

+            {

+              UInt32 offset = cur + lenTest + 1 + lenTest2;

+              while(lenEnd < offset)

+                _optimum[++lenEnd].Price = kIfinityPrice;

+              UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(

+                  0, lenTest2, state2, posStateNext);

+              COptimal &optimum = _optimum[offset];

+              if (curAndLenPrice < optimum.Price) 

+              {

+                optimum.Price = curAndLenPrice;

+                optimum.PosPrev = cur + lenTest + 1;

+                optimum.BackPrev = 0;

+                optimum.Prev1IsChar = true;

+                optimum.Prev2 = true;

+                optimum.PosPrev2 = cur;

+                optimum.BackPrev2 = repIndex;

+              }

+            }

+          }

+        }

+      }

+    

+    //    for(UInt32 lenTest = 2; lenTest <= newLen; lenTest++)

+    if (newLen > numAvailableBytes)

+    {

+      newLen = numAvailableBytes;

+      for (numDistancePairs = 0; newLen > matchDistances[numDistancePairs]; numDistancePairs += 2);

+      matchDistances[numDistancePairs] = newLen;

+      numDistancePairs += 2;

+    }

+    if (newLen >= startLen)

+    {

+      UInt32 normalMatchPrice = matchPrice + _isRep[state.Index].GetPrice0();

+      while(lenEnd < cur + newLen)

+        _optimum[++lenEnd].Price = kIfinityPrice;

+

+      UInt32 offs = 0;

+      while(startLen > matchDistances[offs])

+        offs += 2;

+      UInt32 curBack = matchDistances[offs + 1];

+      UInt32 posSlot = GetPosSlot2(curBack);

+      for(UInt32 lenTest = /*2*/ startLen; ; lenTest++)

+      {

+        UInt32 curAndLenPrice = normalMatchPrice;

+        UInt32 lenToPosState = GetLenToPosState(lenTest);

+        if (curBack < kNumFullDistances)

+          curAndLenPrice += _distancesPrices[lenToPosState][curBack];

+        else

+          curAndLenPrice += _posSlotPrices[lenToPosState][posSlot] + _alignPrices[curBack & kAlignMask];

+  

+        curAndLenPrice += _lenEncoder.GetPrice(lenTest - kMatchMinLen, posState);

+        

+        COptimal &optimum = _optimum[cur + lenTest];

+        if (curAndLenPrice < optimum.Price) 

+        {

+          optimum.Price = curAndLenPrice;

+          optimum.PosPrev = cur;

+          optimum.BackPrev = curBack + kNumRepDistances;

+          optimum.Prev1IsChar = false;

+        }

+

+        if (/*_maxMode && */lenTest == matchDistances[offs])

+        {

+          // Try Match + Literal + Rep0

+          UInt32 backOffset = curBack + 1;

+          UInt32 lenTest2 = lenTest + 1;

+          UInt32 limit = MyMin(numAvailableBytesFull, lenTest2 + _numFastBytes);

+          for (; lenTest2 < limit && 

+              data[lenTest2] == data[(size_t)lenTest2 - backOffset]; lenTest2++);

+          lenTest2 -= lenTest + 1;

+          if (lenTest2 >= 2)

+          {

+            CState state2 = state;

+            state2.UpdateMatch();

+            UInt32 posStateNext = (position + lenTest) & _posStateMask;

+            UInt32 curAndLenCharPrice = curAndLenPrice + 

+                _isMatch[state2.Index][posStateNext].GetPrice0() +

+                _literalEncoder.GetSubCoder(position + lenTest, data[(size_t)lenTest - 1])->GetPrice( 

+                true, data[(size_t)lenTest - backOffset], data[lenTest]);

+            state2.UpdateChar();

+            posStateNext = (posStateNext + 1) & _posStateMask;

+            UInt32 nextRepMatchPrice = curAndLenCharPrice + 

+                _isMatch[state2.Index][posStateNext].GetPrice1() +

+                _isRep[state2.Index].GetPrice1();

+            

+            // for(; lenTest2 >= 2; lenTest2--)

+            {

+              UInt32 offset = cur + lenTest + 1 + lenTest2;

+              while(lenEnd < offset)

+                _optimum[++lenEnd].Price = kIfinityPrice;

+              UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);

+              COptimal &optimum = _optimum[offset];

+              if (curAndLenPrice < optimum.Price) 

+              {

+                optimum.Price = curAndLenPrice;

+                optimum.PosPrev = cur + lenTest + 1;

+                optimum.BackPrev = 0;

+                optimum.Prev1IsChar = true;

+                optimum.Prev2 = true;

+                optimum.PosPrev2 = cur;

+                optimum.BackPrev2 = curBack + kNumRepDistances;

+              }

+            }

+          }

+          offs += 2;

+          if (offs == numDistancePairs)

+            break;

+          curBack = matchDistances[offs + 1];

+          if (curBack >= kNumFullDistances)

+            posSlot = GetPosSlot2(curBack);

+        }

+      }

+    }

+  }

+}

+

+static inline bool ChangePair(UInt32 smallDist, UInt32 bigDist)

+{

+  return ((bigDist >> 7) > smallDist);

+}

+

+

+HRESULT CEncoder::ReadMatchDistances(UInt32 &lenRes, UInt32 &numDistancePairs)

+{

+  lenRes = 0;

+  RINOK(_matchFinder->GetMatches(_matchDistances));

+  numDistancePairs = _matchDistances[0];

+  if (numDistancePairs > 0)

+  {

+    lenRes = _matchDistances[1 + numDistancePairs - 2];

+    if (lenRes == _numFastBytes)

+      lenRes += _matchFinder->GetMatchLen(lenRes - 1, _matchDistances[1 + numDistancePairs - 1], 

+          kMatchMaxLen - lenRes);

+  }

+  _additionalOffset++;

+  return S_OK;

+}

+

+HRESULT CEncoder::GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes)

+{

+  UInt32 lenMain, numDistancePairs;

+  if (!_longestMatchWasFound)

+  {

+    RINOK(ReadMatchDistances(lenMain, numDistancePairs));

+  }

+  else

+  {

+    lenMain = _longestMatchLength;

+    numDistancePairs = _numDistancePairs;

+    _longestMatchWasFound = false;

+  }

+

+  const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;

+  UInt32 numAvailableBytes = _matchFinder->GetNumAvailableBytes() + 1;

+  if (numAvailableBytes > kMatchMaxLen)

+    numAvailableBytes = kMatchMaxLen;

+  if (numAvailableBytes < 2)

+  {

+    backRes = (UInt32)(-1);

+    lenRes = 1;

+    return S_OK;

+  }

+

+  UInt32 repLens[kNumRepDistances];

+  UInt32 repMaxIndex = 0;

+

+  for(UInt32 i = 0; i < kNumRepDistances; i++)

+  {

+    UInt32 backOffset = _repDistances[i] + 1;

+    if (data[0] != data[(size_t)0 - backOffset] || data[1] != data[(size_t)1 - backOffset])

+    {

+      repLens[i] = 0;

+      continue;

+    }

+    UInt32 len;

+    for (len = 2; len < numAvailableBytes && data[len] == data[(size_t)len - backOffset]; len++);

+    if(len >= _numFastBytes)

+    {

+      backRes = i;

+      lenRes = len;

+      return MovePos(lenRes - 1);

+    }

+    repLens[i] = len;

+    if (len > repLens[repMaxIndex])

+      repMaxIndex = i;

+  }

+  UInt32 *matchDistances = _matchDistances + 1;

+  if(lenMain >= _numFastBytes)

+  {

+    backRes = matchDistances[numDistancePairs - 1] + kNumRepDistances; 

+    lenRes = lenMain;

+    return MovePos(lenMain - 1);

+  }

+

+  UInt32 backMain = 0;

+  if (lenMain >= 2)

+  {

+    backMain = matchDistances[numDistancePairs - 1];

+    while (numDistancePairs > 2 && lenMain == matchDistances[numDistancePairs - 4] + 1)

+    {

+      if (!ChangePair(matchDistances[numDistancePairs - 3], backMain))

+        break;

+      numDistancePairs -= 2;

+      lenMain = matchDistances[numDistancePairs - 2];

+      backMain = matchDistances[numDistancePairs - 1];

+    }

+    if (lenMain == 2 && backMain >= 0x80)

+      lenMain = 1;

+  }

+

+  if (repLens[repMaxIndex] >= 2)

+  {

+    if (repLens[repMaxIndex] + 1 >= lenMain || 

+        repLens[repMaxIndex] + 2 >= lenMain && (backMain > (1 << 9)) ||

+        repLens[repMaxIndex] + 3 >= lenMain && (backMain > (1 << 15)))

+    {

+      backRes = repMaxIndex;

+      lenRes = repLens[repMaxIndex];

+      return MovePos(lenRes - 1);

+    }

+  }

+  

+  if (lenMain >= 2 && numAvailableBytes > 2)

+  {

+    RINOK(ReadMatchDistances(_longestMatchLength, _numDistancePairs));

+    if (_longestMatchLength >= 2)

+    {

+      UInt32 newDistance = matchDistances[_numDistancePairs - 1];

+      if (_longestMatchLength >= lenMain && newDistance < backMain || 

+          _longestMatchLength == lenMain + 1 && !ChangePair(backMain, newDistance) ||

+          _longestMatchLength > lenMain + 1 ||

+          _longestMatchLength + 1 >= lenMain && lenMain >= 3 && ChangePair(newDistance, backMain))

+      {

+        _longestMatchWasFound = true;

+        backRes = UInt32(-1);

+        lenRes = 1;

+        return S_OK;

+      }

+    }

+    data++;

+    numAvailableBytes--;

+    for(UInt32 i = 0; i < kNumRepDistances; i++)

+    {

+      UInt32 backOffset = _repDistances[i] + 1;

+      if (data[1] != data[(size_t)1 - backOffset] || data[2] != data[(size_t)2 - backOffset])

+      {

+        repLens[i] = 0;

+        continue;

+      }

+      UInt32 len;

+      for (len = 2; len < numAvailableBytes && data[len] == data[(size_t)len - backOffset]; len++);

+      if (len + 1 >= lenMain)

+      {

+        _longestMatchWasFound = true;

+        backRes = UInt32(-1);

+        lenRes = 1;

+        return S_OK;

+      }

+    }

+    backRes = backMain + kNumRepDistances; 

+    lenRes = lenMain;

+    return MovePos(lenMain - 2);

+  }

+  backRes = UInt32(-1);

+  lenRes = 1;

+  return S_OK;

+}

+

+HRESULT CEncoder::Flush(UInt32 nowPos)

+{

+  ReleaseMFStream();

+  WriteEndMarker(nowPos & _posStateMask);

+  _rangeEncoder.FlushData();

+  return _rangeEncoder.FlushStream();

+}

+

+void CEncoder::WriteEndMarker(UInt32 posState)

+{

+  // This function for writing End Mark for stream version of LZMA. 

+  // In current version this feature is not used.

+  if (!_writeEndMark)

+    return;

+

+  _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);

+  _isRep[_state.Index].Encode(&_rangeEncoder, 0);

+  _state.UpdateMatch();

+  UInt32 len = kMatchMinLen; // kMatchMaxLen;

+  _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);

+  UInt32 posSlot = (1 << kNumPosSlotBits)  - 1;

+  UInt32 lenToPosState = GetLenToPosState(len);

+  _posSlotEncoder[lenToPosState].Encode(&_rangeEncoder, posSlot);

+  UInt32 footerBits = 30;

+  UInt32 posReduced = (UInt32(1) << footerBits) - 1;

+  _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);

+  _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);

+}

+

+HRESULT CEncoder::CodeReal(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, 

+      const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress)

+{

+  _needReleaseMFStream = false;

+  CCoderReleaser coderReleaser(this);

+  RINOK(SetStreams(inStream, outStream, inSize, outSize));

+  while(true)

+  {

+    UInt64 processedInSize;

+    UInt64 processedOutSize;

+    Int32 finished;

+    RINOK(CodeOneBlock(&processedInSize, &processedOutSize, &finished));

+    if (finished != 0)

+      return S_OK;

+    if (progress != 0)

+    {

+      RINOK(progress->SetRatioInfo(&processedInSize, &processedOutSize));

+    }

+  }

+}

+

+HRESULT CEncoder::SetStreams(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, 

+      const UInt64 *inSize, const UInt64 *outSize)

+{

+  _inStream = inStream;

+  _finished = false;

+  RINOK(Create());

+  RINOK(SetOutStream(outStream));

+  RINOK(Init());

+  

+  // CCoderReleaser releaser(this);

+

+  /*

+  if (_matchFinder->GetNumAvailableBytes() == 0)

+    return Flush();

+  */

+

+  if (!_fastMode)

+  {

+    FillDistancesPrices();

+    FillAlignPrices();

+  }

+

+  _lenEncoder.SetTableSize(_numFastBytes + 1 - kMatchMinLen);

+  _lenEncoder.UpdateTables(1 << _posStateBits);

+  _repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - kMatchMinLen);

+  _repMatchLenEncoder.UpdateTables(1 << _posStateBits);

+

+  nowPos64 = 0;

+  return S_OK;

+}

+

+HRESULT CEncoder::CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished)

+{

+  if (_inStream != 0)

+  {

+    RINOK(_matchFinder->SetStream(_inStream));

+    RINOK(_matchFinder->Init());

+    _needReleaseMFStream = true;

+    _inStream = 0;

+  }

+

+

+  *finished = 1;

+  if (_finished)

+    return S_OK;

+  _finished = true;

+

+  if (nowPos64 == 0)

+  {

+    if (_matchFinder->GetNumAvailableBytes() == 0)

+      return Flush(UInt32(nowPos64));

+    UInt32 len, numDistancePairs;

+    RINOK(ReadMatchDistances(len, numDistancePairs));

+    UInt32 posState = UInt32(nowPos64) & _posStateMask;

+    _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);

+    _state.UpdateChar();

+    Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);

+    _literalEncoder.GetSubCoder(UInt32(nowPos64), _previousByte)->Encode(&_rangeEncoder, curByte);

+    _previousByte = curByte;

+    _additionalOffset--;

+    nowPos64++;

+  }

+

+  UInt32 nowPos32 = (UInt32)nowPos64;

+  UInt32 progressPosValuePrev = nowPos32;

+

+  if (_matchFinder->GetNumAvailableBytes() == 0)

+    return Flush(nowPos32);

+

+  while(true)

+  {

+    #ifdef _NO_EXCEPTIONS

+    if (_rangeEncoder.Stream.ErrorCode != S_OK)

+      return _rangeEncoder.Stream.ErrorCode;

+    #endif

+    UInt32 pos, len;

+    HRESULT result;

+    if (_fastMode)

+      result = GetOptimumFast(nowPos32, pos, len);

+    else

+      result = GetOptimum(nowPos32, pos, len);

+    RINOK(result);

+

+    UInt32 posState = nowPos32 & _posStateMask;

+    if(len == 1 && pos == 0xFFFFFFFF)

+    {

+      _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);

+      Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);

+      CLiteralEncoder2 *subCoder = _literalEncoder.GetSubCoder(nowPos32, _previousByte);

+      if(_state.IsCharState())

+        subCoder->Encode(&_rangeEncoder, curByte);

+      else

+      {

+        Byte matchByte = _matchFinder->GetIndexByte(0 - _repDistances[0] - 1 - _additionalOffset);

+        subCoder->EncodeMatched(&_rangeEncoder, matchByte, curByte);

+      }

+      _state.UpdateChar();

+      _previousByte = curByte;

+    }

+    else

+    {

+      _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);

+      if(pos < kNumRepDistances)

+      {

+        _isRep[_state.Index].Encode(&_rangeEncoder, 1);

+        if(pos == 0)

+        {

+          _isRepG0[_state.Index].Encode(&_rangeEncoder, 0);

+          _isRep0Long[_state.Index][posState].Encode(&_rangeEncoder, ((len == 1) ? 0 : 1));

+        }

+        else

+        {

+          UInt32 distance = _repDistances[pos];

+          _isRepG0[_state.Index].Encode(&_rangeEncoder, 1);

+          if (pos == 1)

+            _isRepG1[_state.Index].Encode(&_rangeEncoder, 0);

+          else

+          {

+            _isRepG1[_state.Index].Encode(&_rangeEncoder, 1);

+            _isRepG2[_state.Index].Encode(&_rangeEncoder, pos - 2);

+            if (pos == 3)

+              _repDistances[3] = _repDistances[2];

+            _repDistances[2] = _repDistances[1];

+          }

+          _repDistances[1] = _repDistances[0];

+          _repDistances[0] = distance;

+        }

+        if (len == 1)

+          _state.UpdateShortRep();

+        else

+        {

+          _repMatchLenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);

+          _state.UpdateRep();

+        }

+      }

+      else

+      {

+        _isRep[_state.Index].Encode(&_rangeEncoder, 0);

+        _state.UpdateMatch();

+        _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState, !_fastMode);

+        pos -= kNumRepDistances;

+        UInt32 posSlot = GetPosSlot(pos);

+        _posSlotEncoder[GetLenToPosState(len)].Encode(&_rangeEncoder, posSlot);

+        

+        if (posSlot >= kStartPosModelIndex)

+        {

+          UInt32 footerBits = ((posSlot >> 1) - 1);

+          UInt32 base = ((2 | (posSlot & 1)) << footerBits);

+          UInt32 posReduced = pos - base;

+

+          if (posSlot < kEndPosModelIndex)

+            NRangeCoder::ReverseBitTreeEncode(_posEncoders + base - posSlot - 1, 

+                &_rangeEncoder, footerBits, posReduced);

+          else

+          {

+            _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);

+            _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);

+            _alignPriceCount++;

+          }

+        }

+        _repDistances[3] = _repDistances[2];

+        _repDistances[2] = _repDistances[1];

+        _repDistances[1] = _repDistances[0];

+        _repDistances[0] = pos;

+        _matchPriceCount++;

+      }

+      _previousByte = _matchFinder->GetIndexByte(len - 1 - _additionalOffset);

+    }

+    _additionalOffset -= len;

+    nowPos32 += len;

+    if (_additionalOffset == 0)

+    {

+      if (!_fastMode)

+      {

+        if (_matchPriceCount >= (1 << 7))

+          FillDistancesPrices();

+        if (_alignPriceCount >= kAlignTableSize)

+          FillAlignPrices();

+      }

+      if (_matchFinder->GetNumAvailableBytes() == 0)

+        return Flush(nowPos32);

+      if (nowPos32 - progressPosValuePrev >= (1 << 14))

+      {

+        nowPos64 += nowPos32 - progressPosValuePrev;

+        *inSize = nowPos64;

+        *outSize = _rangeEncoder.GetProcessedSize();

+        _finished = false;

+        *finished = 0;

+        return S_OK;

+      }

+    }

+  }

+}

+

+STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream,

+    ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,

+    ICompressProgressInfo *progress)

+{

+  #ifndef _NO_EXCEPTIONS

+  try 

+  { 

+  #endif

+    return CodeReal(inStream, outStream, inSize, outSize, progress); 

+  #ifndef _NO_EXCEPTIONS

+  }

+  catch(const COutBufferException &e) { return e.ErrorCode; }

+  catch(...) { return E_FAIL; }

+  #endif

+}

+  

+void CEncoder::FillDistancesPrices()

+{

+  UInt32 tempPrices[kNumFullDistances];

+  for (UInt32 i = kStartPosModelIndex; i < kNumFullDistances; i++)

+  { 

+    UInt32 posSlot = GetPosSlot(i);

+    UInt32 footerBits = ((posSlot >> 1) - 1);

+    UInt32 base = ((2 | (posSlot & 1)) << footerBits);

+    tempPrices[i] = NRangeCoder::ReverseBitTreeGetPrice(_posEncoders + 

+      base - posSlot - 1, footerBits, i - base);

+  }

+

+  for (UInt32 lenToPosState = 0; lenToPosState < kNumLenToPosStates; lenToPosState++)

+  {

+	  UInt32 posSlot;

+    NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> &encoder = _posSlotEncoder[lenToPosState];

+    UInt32 *posSlotPrices = _posSlotPrices[lenToPosState];

+    for (posSlot = 0; posSlot < _distTableSize; posSlot++)

+      posSlotPrices[posSlot] = encoder.GetPrice(posSlot);

+    for (posSlot = kEndPosModelIndex; posSlot < _distTableSize; posSlot++)

+      posSlotPrices[posSlot] += ((((posSlot >> 1) - 1) - kNumAlignBits) << NRangeCoder::kNumBitPriceShiftBits);

+

+    UInt32 *distancesPrices = _distancesPrices[lenToPosState];

+	  UInt32 i;

+    for (i = 0; i < kStartPosModelIndex; i++)

+      distancesPrices[i] = posSlotPrices[i];

+    for (; i < kNumFullDistances; i++)

+      distancesPrices[i] = posSlotPrices[GetPosSlot(i)] + tempPrices[i];

+  }

+  _matchPriceCount = 0;

+}

+

+void CEncoder::FillAlignPrices()

+{

+  for (UInt32 i = 0; i < kAlignTableSize; i++)

+    _alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);

+  _alignPriceCount = 0;

+}

+

+}}

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMAEncoder.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMAEncoder.h
new file mode 100644
index 0000000000..55ac80c07c
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/LZMAEncoder.h
@@ -0,0 +1,411 @@
+// LZMA/Encoder.h

+

+#ifndef __LZMA_ENCODER_H

+#define __LZMA_ENCODER_H

+

+#include "../../../Common/MyCom.h"

+#include "../../../Common/Alloc.h"

+#include "../../ICoder.h"

+#include "../LZ/IMatchFinder.h"

+#include "../RangeCoder/RangeCoderBitTree.h"

+

+#include "LZMA.h"

+

+namespace NCompress {

+namespace NLZMA {

+

+typedef NRangeCoder::CBitEncoder<kNumMoveBits> CMyBitEncoder;

+

+class CBaseState

+{

+protected:

+  CState _state;

+  Byte _previousByte;

+  UInt32 _repDistances[kNumRepDistances];

+  void Init()

+  {

+    _state.Init();

+    _previousByte = 0;

+    for(UInt32 i = 0 ; i < kNumRepDistances; i++)

+      _repDistances[i] = 0;

+  }

+};

+

+struct COptimal

+{

+  CState State;

+

+  bool Prev1IsChar;

+  bool Prev2;

+

+  UInt32 PosPrev2;

+  UInt32 BackPrev2;     

+

+  UInt32 Price;    

+  UInt32 PosPrev;         // posNext;

+  UInt32 BackPrev;     

+  UInt32 Backs[kNumRepDistances];

+  void MakeAsChar() { BackPrev = UInt32(-1); Prev1IsChar = false; }

+  void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }

+  bool IsShortRep() { return (BackPrev == 0); }

+};

+

+

+extern Byte g_FastPos[1 << 11];

+inline UInt32 GetPosSlot(UInt32 pos)

+{

+  if (pos < (1 << 11))

+    return g_FastPos[pos];

+  if (pos < (1 << 21))

+    return g_FastPos[pos >> 10] + 20;

+  return g_FastPos[pos >> 20] + 40;

+}

+

+inline UInt32 GetPosSlot2(UInt32 pos)

+{

+  if (pos < (1 << 17))

+    return g_FastPos[pos >> 6] + 12;

+  if (pos < (1 << 27))

+    return g_FastPos[pos >> 16] + 32;

+  return g_FastPos[pos >> 26] + 52;

+}

+

+const UInt32 kIfinityPrice = 0xFFFFFFF;

+

+const UInt32 kNumOpts = 1 << 12;

+

+

+class CLiteralEncoder2

+{

+  CMyBitEncoder _encoders[0x300];

+public:

+  void Init()

+  {

+    for (int i = 0; i < 0x300; i++)

+      _encoders[i].Init();

+  }

+  void Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol);

+  void EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, Byte matchByte, Byte symbol);

+  UInt32 GetPrice(bool matchMode, Byte matchByte, Byte symbol) const;

+};

+

+class CLiteralEncoder

+{

+  CLiteralEncoder2 *_coders;

+  int _numPrevBits;

+  int _numPosBits;

+  UInt32 _posMask;

+public:

+  CLiteralEncoder(): _coders(0) {}

+  ~CLiteralEncoder()  { Free(); }

+  void Free()

+  { 

+    MyFree(_coders);

+    _coders = 0;

+  }

+  bool Create(int numPosBits, int numPrevBits)

+  {

+    if (_coders == 0 || (numPosBits + numPrevBits) != (_numPrevBits + _numPosBits))

+    {

+      Free();

+      UInt32 numStates = 1 << (numPosBits + numPrevBits);

+      _coders = (CLiteralEncoder2 *)MyAlloc(numStates * sizeof(CLiteralEncoder2));

+    }

+    _numPosBits = numPosBits;

+    _posMask = (1 << numPosBits) - 1;

+    _numPrevBits = numPrevBits;

+    return (_coders != 0);

+  }

+  void Init()

+  {

+    UInt32 numStates = 1 << (_numPrevBits + _numPosBits);

+    for (UInt32 i = 0; i < numStates; i++)

+      _coders[i].Init();

+  }

+  CLiteralEncoder2 *GetSubCoder(UInt32 pos, Byte prevByte)

+    { return &_coders[((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits))]; }

+};

+

+namespace NLength {

+

+class CEncoder

+{

+  CMyBitEncoder _choice;

+  CMyBitEncoder _choice2;

+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumLowBits> _lowCoder[kNumPosStatesEncodingMax];

+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumMidBits> _midCoder[kNumPosStatesEncodingMax];

+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumHighBits> _highCoder;

+public:

+  void Init(UInt32 numPosStates);

+  void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState);

+  void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const;

+};

+

+const UInt32 kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols;

+

+class CPriceTableEncoder: public CEncoder

+{

+  UInt32 _prices[kNumPosStatesEncodingMax][kNumSymbolsTotal];

+  UInt32 _tableSize;

+  UInt32 _counters[kNumPosStatesEncodingMax];

+public:

+  void SetTableSize(UInt32 tableSize) { _tableSize = tableSize;  }

+  UInt32 GetPrice(UInt32 symbol, UInt32 posState) const { return _prices[posState][symbol]; }

+  void UpdateTable(UInt32 posState)

+  {

+    SetPrices(posState, _tableSize, _prices[posState]);

+    _counters[posState] = _tableSize;

+  }

+  void UpdateTables(UInt32 numPosStates)

+  {

+    for (UInt32 posState = 0; posState < numPosStates; posState++)

+      UpdateTable(posState);

+  }

+  void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState, bool updatePrice)

+  {

+    CEncoder::Encode(rangeEncoder, symbol, posState);

+    if (updatePrice)

+      if (--_counters[posState] == 0)

+        UpdateTable(posState);

+  }

+};

+

+}

+

+class CEncoder : 

+  public ICompressCoder,

+  public ICompressSetOutStream,

+  public ICompressSetCoderProperties,

+  public ICompressWriteCoderProperties,

+  public CBaseState,

+  public CMyUnknownImp

+{

+  COptimal _optimum[kNumOpts];

+  CMyComPtr<IMatchFinder> _matchFinder; // test it

+  NRangeCoder::CEncoder _rangeEncoder;

+

+  CMyBitEncoder _isMatch[kNumStates][NLength::kNumPosStatesEncodingMax];

+  CMyBitEncoder _isRep[kNumStates];

+  CMyBitEncoder _isRepG0[kNumStates];

+  CMyBitEncoder _isRepG1[kNumStates];

+  CMyBitEncoder _isRepG2[kNumStates];

+  CMyBitEncoder _isRep0Long[kNumStates][NLength::kNumPosStatesEncodingMax];

+

+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> _posSlotEncoder[kNumLenToPosStates];

+

+  CMyBitEncoder _posEncoders[kNumFullDistances - kEndPosModelIndex];

+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumAlignBits> _posAlignEncoder;

+  

+  NLength::CPriceTableEncoder _lenEncoder;

+  NLength::CPriceTableEncoder _repMatchLenEncoder;

+

+  CLiteralEncoder _literalEncoder;

+

+  UInt32 _matchDistances[kMatchMaxLen * 2 + 2 + 1];

+

+  bool _fastMode;

+  // bool _maxMode;

+  UInt32 _numFastBytes;

+  UInt32 _longestMatchLength;    

+  UInt32 _numDistancePairs;

+

+  UInt32 _additionalOffset;

+

+  UInt32 _optimumEndIndex;

+  UInt32 _optimumCurrentIndex;

+

+  bool _longestMatchWasFound;

+

+  UInt32 _posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];

+  

+  UInt32 _distancesPrices[kNumLenToPosStates][kNumFullDistances];

+

+  UInt32 _alignPrices[kAlignTableSize];

+  UInt32 _alignPriceCount;

+

+  UInt32 _distTableSize;

+

+  UInt32 _posStateBits;

+  UInt32 _posStateMask;

+  UInt32 _numLiteralPosStateBits;

+  UInt32 _numLiteralContextBits;

+

+  UInt32 _dictionarySize;

+

+  UInt32 _dictionarySizePrev;

+  UInt32 _numFastBytesPrev;

+

+  UInt32 _matchPriceCount;

+  UInt64 nowPos64;

+  bool _finished;

+  ISequentialInStream *_inStream;

+

+  UInt32 _matchFinderCycles;

+  int _matchFinderIndex;

+  #ifdef COMPRESS_MF_MT

+  bool _multiThread;

+  #endif

+

+  bool _writeEndMark;

+

+  bool _needReleaseMFStream;

+

+  IMatchFinderSetNumPasses *setMfPasses;

+

+  void ReleaseMatchFinder()

+  {

+    setMfPasses = 0;

+    _matchFinder.Release();

+  }

+  

+  HRESULT ReadMatchDistances(UInt32 &len, UInt32 &numDistancePairs);

+

+  HRESULT MovePos(UInt32 num);

+  UInt32 GetRepLen1Price(CState state, UInt32 posState) const

+  {

+    return _isRepG0[state.Index].GetPrice0() +

+        _isRep0Long[state.Index][posState].GetPrice0();

+  }

+  

+  UInt32 GetPureRepPrice(UInt32 repIndex, CState state, UInt32 posState) const

+  {

+    UInt32 price;

+    if(repIndex == 0)

+    {

+      price = _isRepG0[state.Index].GetPrice0();

+      price += _isRep0Long[state.Index][posState].GetPrice1();

+    }

+    else

+    {

+      price = _isRepG0[state.Index].GetPrice1();

+      if (repIndex == 1)

+        price += _isRepG1[state.Index].GetPrice0();

+      else

+      {

+        price += _isRepG1[state.Index].GetPrice1();

+        price += _isRepG2[state.Index].GetPrice(repIndex - 2);

+      }

+    }

+    return price;

+  }

+  UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, CState state, UInt32 posState) const

+  {

+    return _repMatchLenEncoder.GetPrice(len - kMatchMinLen, posState) +

+        GetPureRepPrice(repIndex, state, posState);

+  }

+  /*

+  UInt32 GetPosLen2Price(UInt32 pos, UInt32 posState) const

+  {

+    if (pos >= kNumFullDistances)

+      return kIfinityPrice;

+    return _distancesPrices[0][pos] + _lenEncoder.GetPrice(0, posState);

+  }

+  UInt32 GetPosLen3Price(UInt32 pos, UInt32 len, UInt32 posState) const

+  {

+    UInt32 price;

+    UInt32 lenToPosState = GetLenToPosState(len);

+    if (pos < kNumFullDistances)

+      price = _distancesPrices[lenToPosState][pos];

+    else

+      price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + 

+          _alignPrices[pos & kAlignMask];

+    return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);

+  }

+  */

+  UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState) const

+  {

+    UInt32 price;

+    UInt32 lenToPosState = GetLenToPosState(len);

+    if (pos < kNumFullDistances)

+      price = _distancesPrices[lenToPosState][pos];

+    else

+      price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + 

+          _alignPrices[pos & kAlignMask];

+    return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);

+  }

+

+  UInt32 Backward(UInt32 &backRes, UInt32 cur);

+  HRESULT GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes);

+  HRESULT GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes);

+

+  void FillDistancesPrices();

+  void FillAlignPrices();

+    

+  void ReleaseMFStream()

+  {

+    if (_matchFinder && _needReleaseMFStream)

+    {

+      _matchFinder->ReleaseStream();

+      _needReleaseMFStream = false;

+    }

+  }

+

+  void ReleaseStreams()

+  {

+    ReleaseMFStream();

+    ReleaseOutStream();

+  }

+

+  HRESULT Flush(UInt32 nowPos);

+  class CCoderReleaser

+  {

+    CEncoder *_coder;

+  public:

+    CCoderReleaser(CEncoder *coder): _coder(coder) {}

+    ~CCoderReleaser()

+    {

+      _coder->ReleaseStreams();

+    }

+  };

+  friend class CCoderReleaser;

+

+  void WriteEndMarker(UInt32 posState);

+

+public:

+  CEncoder();

+  void SetWriteEndMarkerMode(bool writeEndMarker)

+    { _writeEndMark= writeEndMarker; }

+

+  HRESULT Create();

+

+  MY_UNKNOWN_IMP3(

+      ICompressSetOutStream,

+      ICompressSetCoderProperties,

+      ICompressWriteCoderProperties

+      )

+    

+  HRESULT Init();

+  

+  // ICompressCoder interface

+  HRESULT SetStreams(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream,

+      const UInt64 *inSize, const UInt64 *outSize);

+  HRESULT CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished);

+

+  HRESULT CodeReal(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, 

+      const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress);

+

+  // ICompressCoder interface

+  STDMETHOD(Code)(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, 

+      const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress);

+

+  // ICompressSetCoderProperties2

+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, 

+      const PROPVARIANT *properties, UInt32 numProperties);

+  

+  // ICompressWriteCoderProperties

+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);

+

+  STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);

+  STDMETHOD(ReleaseOutStream)();

+

+  virtual ~CEncoder() {}

+};

+

+}}

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/StdAfx.h b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/StdAfx.h
new file mode 100644
index 0000000000..83fdd22d58
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/LZMA/StdAfx.h
@@ -0,0 +1,8 @@
+// StdAfx.h

+

+#ifndef __STDAFX_H

+#define __STDAFX_H

+

+#include "../../../Common/MyWindows.h"

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoder.h b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoder.h
new file mode 100644
index 0000000000..9828bc4b94
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoder.h
@@ -0,0 +1,205 @@
+// Compress/RangeCoder/RangeCoder.h

+

+#ifndef __COMPRESS_RANGECODER_H

+#define __COMPRESS_RANGECODER_H

+

+#include "../../Common/InBuffer.h"

+#include "../../Common/OutBuffer.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+const int kNumTopBits = 24;

+const UInt32 kTopValue = (1 << kNumTopBits);

+

+class CEncoder

+{

+  UInt32 _cacheSize;

+  Byte _cache;

+public:

+  UInt64 Low;

+  UInt32 Range;

+  COutBuffer Stream;

+  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }

+

+  void SetStream(ISequentialOutStream *stream) { Stream.SetStream(stream); }

+  void Init()

+  {

+    Stream.Init();

+    Low = 0;

+    Range = 0xFFFFFFFF;

+    _cacheSize = 1;

+    _cache = 0;

+  }

+

+  void FlushData()

+  {

+    // Low += 1; 

+    for(int i = 0; i < 5; i++)

+      ShiftLow();

+  }

+

+  HRESULT FlushStream() { return Stream.Flush();  }

+

+  void ReleaseStream() { Stream.ReleaseStream(); }

+

+  void Encode(UInt32 start, UInt32 size, UInt32 total)

+  {

+    Low += start * (Range /= total);

+    Range *= size;

+    while (Range < kTopValue)

+    {

+      Range <<= 8;

+      ShiftLow();

+    }

+  }

+

+  void ShiftLow()

+  {

+    if ((UInt32)Low < (UInt32)0xFF000000 || (int)(Low >> 32) != 0) 

+    {

+      Byte temp = _cache;

+      do

+      {

+        Stream.WriteByte((Byte)(temp + (Byte)(Low >> 32)));

+        temp = 0xFF;

+      }

+      while(--_cacheSize != 0);

+      _cache = (Byte)((UInt32)Low >> 24);                      

+    } 

+    _cacheSize++;                               

+    Low = (UInt32)Low << 8;                           

+  }

+  

+  void EncodeDirectBits(UInt32 value, int numTotalBits)

+  {

+    for (int i = numTotalBits - 1; i >= 0; i--)

+    {

+      Range >>= 1;

+      if (((value >> i) & 1) == 1)

+        Low += Range;

+      if (Range < kTopValue)

+      {

+        Range <<= 8;

+        ShiftLow();

+      }

+    }

+  }

+

+  void EncodeBit(UInt32 size0, UInt32 numTotalBits, UInt32 symbol)

+  {

+    UInt32 newBound = (Range >> numTotalBits) * size0;

+    if (symbol == 0)

+      Range = newBound;

+    else

+    {

+      Low += newBound;

+      Range -= newBound;

+    }

+    while (Range < kTopValue)

+    {

+      Range <<= 8;

+      ShiftLow();

+    }

+  }

+

+  UInt64 GetProcessedSize() {  return Stream.GetProcessedSize() + _cacheSize + 4; }

+};

+

+class CDecoder

+{

+public:

+  CInBuffer Stream;

+  UInt32 Range;

+  UInt32 Code;

+  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }

+

+  void Normalize()

+  {

+    while (Range < kTopValue)

+    {

+      Code = (Code << 8) | Stream.ReadByte();

+      Range <<= 8;

+    }

+  }

+  

+  void SetStream(ISequentialInStream *stream) { Stream.SetStream(stream); }

+  void Init()

+  {

+    Stream.Init();

+    Code = 0;

+    Range = 0xFFFFFFFF;

+    for(int i = 0; i < 5; i++)

+      Code = (Code << 8) | Stream.ReadByte();

+  }

+

+  void ReleaseStream() { Stream.ReleaseStream(); }

+

+  UInt32 GetThreshold(UInt32 total)

+  {

+    return (Code) / ( Range /= total);

+  }

+

+  void Decode(UInt32 start, UInt32 size)

+  {

+    Code -= start * Range;

+    Range *= size;

+    Normalize();

+  }

+

+  UInt32 DecodeDirectBits(int numTotalBits)

+  {

+    UInt32 range = Range;

+    UInt32 code = Code;        

+    UInt32 result = 0;

+    for (int i = numTotalBits; i != 0; i--)

+    {

+      range >>= 1;

+      /*

+      result <<= 1;

+      if (code >= range)

+      {

+        code -= range;

+        result |= 1;

+      }

+      */

+      UInt32 t = (code - range) >> 31;

+      code -= range & (t - 1);

+      result = (result << 1) | (1 - t);

+

+      if (range < kTopValue)

+      {

+        code = (code << 8) | Stream.ReadByte();

+        range <<= 8; 

+      }

+    }

+    Range = range;

+    Code = code;

+    return result;

+  }

+

+  UInt32 DecodeBit(UInt32 size0, UInt32 numTotalBits)

+  {

+    UInt32 newBound = (Range >> numTotalBits) * size0;

+    UInt32 symbol;

+    if (Code < newBound)

+    {

+      symbol = 0;

+      Range = newBound;

+    }

+    else

+    {

+      symbol = 1;

+      Code -= newBound;

+      Range -= newBound;

+    }

+    Normalize();

+    return symbol;

+  }

+

+  UInt64 GetProcessedSize() {return Stream.GetProcessedSize(); }

+};

+

+}}

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.cpp b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.cpp
new file mode 100644
index 0000000000..8d273c8f93
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.cpp
@@ -0,0 +1,80 @@
+// Compress/RangeCoder/RangeCoderBit.cpp

+

+#include "StdAfx.h"

+

+#include "RangeCoderBit.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+UInt32 CPriceTables::ProbPrices[kBitModelTotal >> kNumMoveReducingBits];

+static CPriceTables g_PriceTables;

+

+CPriceTables::CPriceTables() { Init(); }

+

+void CPriceTables::Init()

+{

+  const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);

+  for(int i = kNumBits - 1; i >= 0; i--)

+  {

+    UInt32 start = 1 << (kNumBits - i - 1);

+    UInt32 end = 1 << (kNumBits - i);

+    for (UInt32 j = start; j < end; j++)

+      ProbPrices[j] = (i << kNumBitPriceShiftBits) + 

+          (((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));

+  }

+

+  /*

+  // simplest: bad solution

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+    ProbPrices[i] = kBitPrice;

+  */

+  

+  /*

+  const double kDummyMultMid = (1.0 / kBitPrice) / 2;

+  const double kDummyMultMid = 0;

+  // float solution

+  double ln2 = log(double(2));

+  double lnAll = log(double(kBitModelTotal >> kNumMoveReducingBits));

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+    ProbPrices[i] = UInt32((fabs(lnAll - log(double(i))) / ln2 + kDummyMultMid) * kBitPrice);

+  */

+  

+  /*

+  // experimental, slow, solution:

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+  {

+    const int kCyclesBits = 5;

+    const UInt32 kCycles = (1 << kCyclesBits);

+

+    UInt32 range = UInt32(-1);

+    UInt32 bitCount = 0;

+    for (UInt32 j = 0; j < kCycles; j++)

+    {

+      range >>= (kNumBitModelTotalBits - kNumMoveReducingBits);

+      range *= i;

+      while(range < (1 << 31))

+      {

+        range <<= 1;

+        bitCount++;

+      }

+    }

+    bitCount <<= kNumBitPriceShiftBits;

+    range -= (1 << 31);

+    for (int k = kNumBitPriceShiftBits - 1; k >= 0; k--)

+    {

+      range <<= 1;

+      if (range > (1 << 31))

+      {

+        bitCount += (1 << k);

+        range -= (1 << 31);

+      }

+    }

+    ProbPrices[i] = (bitCount 

+      // + (1 << (kCyclesBits - 1))

+      ) >> kCyclesBits;

+  }

+  */

+}

+

+}}

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.h b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.h
new file mode 100644
index 0000000000..64538e6879
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.h
@@ -0,0 +1,120 @@
+// Compress/RangeCoder/RangeCoderBit.h

+

+#ifndef __COMPRESS_RANGECODER_BIT_H

+#define __COMPRESS_RANGECODER_BIT_H

+

+#include "RangeCoder.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+const int kNumBitModelTotalBits  = 11;

+const UInt32 kBitModelTotal = (1 << kNumBitModelTotalBits);

+

+const int kNumMoveReducingBits = 2;

+

+const int kNumBitPriceShiftBits = 6;

+const UInt32 kBitPrice = 1 << kNumBitPriceShiftBits;

+

+class CPriceTables

+{

+public:

+  static UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];

+  static void Init();

+  CPriceTables();

+};

+

+template <int numMoveBits>

+class CBitModel

+{

+public:

+  UInt32 Prob;

+  void UpdateModel(UInt32 symbol)

+  {

+    /*

+    Prob -= (Prob + ((symbol - 1) & ((1 << numMoveBits) - 1))) >> numMoveBits;

+    Prob += (1 - symbol) << (kNumBitModelTotalBits - numMoveBits);

+    */

+    if (symbol == 0)

+      Prob += (kBitModelTotal - Prob) >> numMoveBits;

+    else

+      Prob -= (Prob) >> numMoveBits;

+  }

+public:

+  void Init() { Prob = kBitModelTotal / 2; }

+};

+

+template <int numMoveBits>

+class CBitEncoder: public CBitModel<numMoveBits>

+{

+public:

+  void Encode(CEncoder *encoder, UInt32 symbol)

+  {

+    /*

+    encoder->EncodeBit(this->Prob, kNumBitModelTotalBits, symbol);

+    this->UpdateModel(symbol);

+    */

+    UInt32 newBound = (encoder->Range >> kNumBitModelTotalBits) * this->Prob;

+    if (symbol == 0)

+    {

+      encoder->Range = newBound;

+      this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;

+    }

+    else

+    {

+      encoder->Low += newBound;

+      encoder->Range -= newBound;

+      this->Prob -= (this->Prob) >> numMoveBits;

+    }

+    if (encoder->Range < kTopValue)

+    {

+      encoder->Range <<= 8;

+      encoder->ShiftLow();

+    }

+  }

+  UInt32 GetPrice(UInt32 symbol) const

+  {

+    return CPriceTables::ProbPrices[

+      (((this->Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];

+  }

+  UInt32 GetPrice0() const { return CPriceTables::ProbPrices[this->Prob >> kNumMoveReducingBits]; }

+  UInt32 GetPrice1() const { return CPriceTables::ProbPrices[(kBitModelTotal - this->Prob) >> kNumMoveReducingBits]; }

+};

+

+

+template <int numMoveBits>

+class CBitDecoder: public CBitModel<numMoveBits>

+{

+public:

+  UInt32 Decode(CDecoder *decoder)

+  {

+    UInt32 newBound = (decoder->Range >> kNumBitModelTotalBits) * this->Prob;

+    if (decoder->Code < newBound)

+    {

+      decoder->Range = newBound;

+      this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;

+      if (decoder->Range < kTopValue)

+      {

+        decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();

+        decoder->Range <<= 8;

+      }

+      return 0;

+    }

+    else

+    {

+      decoder->Range -= newBound;

+      decoder->Code -= newBound;

+      this->Prob -= (this->Prob) >> numMoveBits;

+      if (decoder->Range < kTopValue)

+      {

+        decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();

+        decoder->Range <<= 8;

+      }

+      return 1;

+    }

+  }

+};

+

+}}

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBitTree.h b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBitTree.h
new file mode 100644
index 0000000000..1fa023f3b8
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderBitTree.h
@@ -0,0 +1,161 @@
+// Compress/RangeCoder/RangeCoderBitTree.h

+

+#ifndef __COMPRESS_RANGECODER_BIT_TREE_H

+#define __COMPRESS_RANGECODER_BIT_TREE_H

+

+#include "RangeCoderBit.h"

+#include "RangeCoderOpt.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+template <int numMoveBits, int NumBitLevels>

+class CBitTreeEncoder

+{

+  CBitEncoder<numMoveBits> Models[1 << NumBitLevels];

+public:

+  void Init()

+  {

+    for(UInt32 i = 1; i < (1 << NumBitLevels); i++)

+      Models[i].Init();

+  }

+  void Encode(CEncoder *rangeEncoder, UInt32 symbol)

+  {

+    UInt32 modelIndex = 1;

+    for (int bitIndex = NumBitLevels; bitIndex != 0 ;)

+    {

+      bitIndex--;

+      UInt32 bit = (symbol >> bitIndex) & 1;

+      Models[modelIndex].Encode(rangeEncoder, bit);

+      modelIndex = (modelIndex << 1) | bit;

+    }

+  };

+  void ReverseEncode(CEncoder *rangeEncoder, UInt32 symbol)

+  {

+    UInt32 modelIndex = 1;

+    for (int i = 0; i < NumBitLevels; i++)

+    {

+      UInt32 bit = symbol & 1;

+      Models[modelIndex].Encode(rangeEncoder, bit);

+      modelIndex = (modelIndex << 1) | bit;

+      symbol >>= 1;

+    }

+  }

+  UInt32 GetPrice(UInt32 symbol) const

+  {

+    symbol |= (1 << NumBitLevels);

+    UInt32 price = 0;

+    while (symbol != 1)

+    {

+      price += Models[symbol >> 1].GetPrice(symbol & 1);

+      symbol >>= 1;

+    }

+    return price;

+  }

+  UInt32 ReverseGetPrice(UInt32 symbol) const

+  {

+    UInt32 price = 0;

+    UInt32 modelIndex = 1;

+    for (int i = NumBitLevels; i != 0; i--)

+    {

+      UInt32 bit = symbol & 1;

+      symbol >>= 1;

+      price += Models[modelIndex].GetPrice(bit);

+      modelIndex = (modelIndex << 1) | bit;

+    }

+    return price;

+  }

+};

+

+template <int numMoveBits, int NumBitLevels>

+class CBitTreeDecoder

+{

+  CBitDecoder<numMoveBits> Models[1 << NumBitLevels];

+public:

+  void Init()

+  {

+    for(UInt32 i = 1; i < (1 << NumBitLevels); i++)

+      Models[i].Init();

+  }

+  UInt32 Decode(CDecoder *rangeDecoder)

+  {

+    UInt32 modelIndex = 1;

+    RC_INIT_VAR

+    for(int bitIndex = NumBitLevels; bitIndex != 0; bitIndex--)

+    {

+      // modelIndex = (modelIndex << 1) + Models[modelIndex].Decode(rangeDecoder);

+      RC_GETBIT(numMoveBits, Models[modelIndex].Prob, modelIndex)

+    }

+    RC_FLUSH_VAR

+    return modelIndex - (1 << NumBitLevels);

+  };

+  UInt32 ReverseDecode(CDecoder *rangeDecoder)

+  {

+    UInt32 modelIndex = 1;

+    UInt32 symbol = 0;

+    RC_INIT_VAR

+    for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)

+    {

+      // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);

+      // modelIndex <<= 1;

+      // modelIndex += bit;

+      // symbol |= (bit << bitIndex);

+      RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))

+    }

+    RC_FLUSH_VAR

+    return symbol;

+  }

+};

+

+template <int numMoveBits>

+void ReverseBitTreeEncode(CBitEncoder<numMoveBits> *Models, 

+    CEncoder *rangeEncoder, int NumBitLevels, UInt32 symbol)

+{

+  UInt32 modelIndex = 1;

+  for (int i = 0; i < NumBitLevels; i++)

+  {

+    UInt32 bit = symbol & 1;

+    Models[modelIndex].Encode(rangeEncoder, bit);

+    modelIndex = (modelIndex << 1) | bit;

+    symbol >>= 1;

+  }

+}

+

+template <int numMoveBits>

+UInt32 ReverseBitTreeGetPrice(CBitEncoder<numMoveBits> *Models, 

+    UInt32 NumBitLevels, UInt32 symbol)

+{

+  UInt32 price = 0;

+  UInt32 modelIndex = 1;

+  for (int i = NumBitLevels; i != 0; i--)

+  {

+    UInt32 bit = symbol & 1;

+    symbol >>= 1;

+    price += Models[modelIndex].GetPrice(bit);

+    modelIndex = (modelIndex << 1) | bit;

+  }

+  return price;

+}

+

+template <int numMoveBits>

+UInt32 ReverseBitTreeDecode(CBitDecoder<numMoveBits> *Models, 

+    CDecoder *rangeDecoder, int NumBitLevels)

+{

+  UInt32 modelIndex = 1;

+  UInt32 symbol = 0;

+  RC_INIT_VAR

+  for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)

+  {

+    // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);

+    // modelIndex <<= 1;

+    // modelIndex += bit;

+    // symbol |= (bit << bitIndex);

+    RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))

+  }

+  RC_FLUSH_VAR

+  return symbol;

+}

+

+}}

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderOpt.h b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderOpt.h
new file mode 100644
index 0000000000..829fc83d77
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/RangeCoderOpt.h
@@ -0,0 +1,31 @@
+// Compress/RangeCoder/RangeCoderOpt.h

+

+#ifndef __COMPRESS_RANGECODER_OPT_H

+#define __COMPRESS_RANGECODER_OPT_H

+

+#define RC_INIT_VAR \

+  UInt32 range = rangeDecoder->Range; \

+  UInt32 code = rangeDecoder->Code;        

+

+#define RC_FLUSH_VAR \

+  rangeDecoder->Range = range; \

+  rangeDecoder->Code = code;

+

+#define RC_NORMALIZE \

+  if (range < NCompress::NRangeCoder::kTopValue) \

+    { code = (code << 8) | rangeDecoder->Stream.ReadByte(); range <<= 8; }

+

+#define RC_GETBIT2(numMoveBits, prob, mi, A0, A1) \

+  { UInt32 bound = (range >> NCompress::NRangeCoder::kNumBitModelTotalBits) * prob; \

+  if (code < bound) \

+  { A0; range = bound; \

+    prob += (NCompress::NRangeCoder::kBitModelTotal - prob) >> numMoveBits; \

+    mi <<= 1; } \

+  else \

+  { A1; range -= bound; code -= bound; prob -= (prob) >> numMoveBits; \

+    mi = (mi + mi) + 1; }} \

+  RC_NORMALIZE

+

+#define RC_GETBIT(numMoveBits, prob, mi) RC_GETBIT2(numMoveBits, prob, mi, ; , ;)

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/StdAfx.h b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/StdAfx.h
new file mode 100644
index 0000000000..21c2fd780c
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Compress/RangeCoder/StdAfx.h
@@ -0,0 +1,6 @@
+// StdAfx.h

+

+#ifndef __STDAFX_H

+#define __STDAFX_H

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/Decompress/LzmaDecode.c b/util/cbfstool/tools/lzma/C/7zip/Decompress/LzmaDecode.c
new file mode 100644
index 0000000000..21bf40bde0
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Decompress/LzmaDecode.c
@@ -0,0 +1,588 @@
+/*
+  LzmaDecode.c
+  LZMA Decoder (optimized for Speed version)
+  
+  LZMA SDK 4.22 Copyright (c) 1999-2005 Igor Pavlov (2005-06-10)
+  http://www.7-zip.org/
+
+  LZMA SDK is licensed under two licenses:
+  1) GNU Lesser General Public License (GNU LGPL)
+  2) Common Public License (CPL)
+  It means that you can select one of these two licenses and 
+  follow rules of that license.
+
+  SPECIAL EXCEPTION:
+  Igor Pavlov, as the author of this Code, expressly permits you to 
+  statically or dynamically link your Code (or bind by name) to the 
+  interfaces of this file without subjecting your linked Code to the 
+  terms of the CPL or GNU LGPL. Any modifications or additions 
+  to this file, however, are subject to the LGPL or CPL terms.
+*/
+
+#include "LzmaDecode.h"
+
+#ifndef Byte
+#define Byte unsigned char
+#endif
+
+#define kNumTopBits 24
+#define kTopValue ((UInt32)1 << kNumTopBits)
+
+#define kNumBitModelTotalBits 11
+#define kBitModelTotal (1 << kNumBitModelTotalBits)
+#define kNumMoveBits 5
+
+#define RC_READ_BYTE (*Buffer++)
+
+#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \
+  { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}
+
+#ifdef _LZMA_IN_CB
+
+#define RC_TEST { if (Buffer == BufferLim) \
+  { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \
+  BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}
+
+#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
+
+#else
+
+#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }
+
+#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2
+ 
+#endif
+
+#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }
+
+#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)
+#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;
+#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;
+
+#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \
+  { UpdateBit0(p); mi <<= 1; A0; } else \
+  { UpdateBit1(p); mi = (mi + mi) + 1; A1; } 
+  
+#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;)               
+
+#define RangeDecoderBitTreeDecode(probs, numLevels, res) \
+  { int i = numLevels; res = 1; \
+  do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \
+  res -= (1 << numLevels); }
+
+
+#define kNumPosBitsMax 4
+#define kNumPosStatesMax (1 << kNumPosBitsMax)
+
+#define kLenNumLowBits 3
+#define kLenNumLowSymbols (1 << kLenNumLowBits)
+#define kLenNumMidBits 3
+#define kLenNumMidSymbols (1 << kLenNumMidBits)
+#define kLenNumHighBits 8
+#define kLenNumHighSymbols (1 << kLenNumHighBits)
+
+#define LenChoice 0
+#define LenChoice2 (LenChoice + 1)
+#define LenLow (LenChoice2 + 1)
+#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
+#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
+#define kNumLenProbs (LenHigh + kLenNumHighSymbols) 
+
+
+#define kNumStates 12
+#define kNumLitStates 7
+
+#define kStartPosModelIndex 4
+#define kEndPosModelIndex 14
+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
+
+#define kNumPosSlotBits 6
+#define kNumLenToPosStates 4
+
+#define kNumAlignBits 4
+#define kAlignTableSize (1 << kNumAlignBits)
+
+#define kMatchMinLen 2
+
+#define IsMatch 0
+#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
+#define IsRepG0 (IsRep + kNumStates)
+#define IsRepG1 (IsRepG0 + kNumStates)
+#define IsRepG2 (IsRepG1 + kNumStates)
+#define IsRep0Long (IsRepG2 + kNumStates)
+#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
+#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
+#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
+#define LenCoder (Align + kAlignTableSize)
+#define RepLenCoder (LenCoder + kNumLenProbs)
+#define Literal (RepLenCoder + kNumLenProbs)
+
+#if Literal != LZMA_BASE_SIZE
+StopCompilingDueBUG
+#endif
+
+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
+{
+  unsigned char prop0;
+  if (size < LZMA_PROPERTIES_SIZE)
+    return LZMA_RESULT_DATA_ERROR;
+  prop0 = propsData[0];
+  if (prop0 >= (9 * 5 * 5))
+    return LZMA_RESULT_DATA_ERROR;
+  {
+    for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));
+    for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);
+    propsRes->lc = prop0;
+    /*
+    unsigned char remainder = (unsigned char)(prop0 / 9);
+    propsRes->lc = prop0 % 9;
+    propsRes->pb = remainder / 5;
+    propsRes->lp = remainder % 5;
+    */
+  }
+
+  #ifdef _LZMA_OUT_READ
+  {
+    int i;
+    propsRes->DictionarySize = 0;
+    for (i = 0; i < 4; i++)
+      propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);
+    if (propsRes->DictionarySize == 0)
+      propsRes->DictionarySize = 1;
+  }
+  #endif
+  return LZMA_RESULT_OK;
+}
+
+#define kLzmaStreamWasFinishedId (-1)
+
+int LzmaDecode(CLzmaDecoderState *vs,
+    #ifdef _LZMA_IN_CB
+    ILzmaInCallback *InCallback,
+    #else
+    const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
+    #endif
+    unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)
+{
+  CProb *p = vs->Probs;
+  SizeT nowPos = 0;
+  Byte previousByte = 0;
+  UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;
+  UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;
+  int lc = vs->Properties.lc;
+
+  #ifdef _LZMA_OUT_READ
+  
+  UInt32 Range = vs->Range;
+  UInt32 Code = vs->Code;
+  #ifdef _LZMA_IN_CB
+  const Byte *Buffer = vs->Buffer;
+  const Byte *BufferLim = vs->BufferLim;
+  #else
+  const Byte *Buffer = inStream;
+  const Byte *BufferLim = inStream + inSize;
+  #endif
+  int state = vs->State;
+  UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
+  int len = vs->RemainLen;
+  UInt32 globalPos = vs->GlobalPos;
+  UInt32 distanceLimit = vs->DistanceLimit;
+
+  Byte *dictionary = vs->Dictionary;
+  UInt32 dictionarySize = vs->Properties.DictionarySize;
+  UInt32 dictionaryPos = vs->DictionaryPos;
+
+  Byte tempDictionary[4];
+
+  #ifndef _LZMA_IN_CB
+  *inSizeProcessed = 0;
+  #endif
+  *outSizeProcessed = 0;
+  if (len == kLzmaStreamWasFinishedId)
+    return LZMA_RESULT_OK;
+
+  if (dictionarySize == 0)
+  {
+    dictionary = tempDictionary;
+    dictionarySize = 1;
+    tempDictionary[0] = vs->TempDictionary[0];
+  }
+
+  if (len == kLzmaNeedInitId)
+  {
+    {
+      UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
+      UInt32 i;
+      for (i = 0; i < numProbs; i++)
+        p[i] = kBitModelTotal >> 1; 
+      rep0 = rep1 = rep2 = rep3 = 1;
+      state = 0;
+      globalPos = 0;
+      distanceLimit = 0;
+      dictionaryPos = 0;
+      dictionary[dictionarySize - 1] = 0;
+      #ifdef _LZMA_IN_CB
+      RC_INIT;
+      #else
+      RC_INIT(inStream, inSize);
+      #endif
+    }
+    len = 0;
+  }
+  while(len != 0 && nowPos < outSize)
+  {
+    UInt32 pos = dictionaryPos - rep0;
+    if (pos >= dictionarySize)
+      pos += dictionarySize;
+    outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
+    if (++dictionaryPos == dictionarySize)
+      dictionaryPos = 0;
+    len--;
+  }
+  if (dictionaryPos == 0)
+    previousByte = dictionary[dictionarySize - 1];
+  else
+    previousByte = dictionary[dictionaryPos - 1];
+
+  #else /* if !_LZMA_OUT_READ */
+
+  int state = 0;
+  UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
+  int len = 0;
+  const Byte *Buffer;
+  const Byte *BufferLim;
+  UInt32 Range;
+  UInt32 Code;
+
+  #ifndef _LZMA_IN_CB
+  *inSizeProcessed = 0;
+  #endif
+  *outSizeProcessed = 0;
+
+  {
+    UInt32 i;
+    UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
+    for (i = 0; i < numProbs; i++)
+      p[i] = kBitModelTotal >> 1;
+  }
+  
+  #ifdef _LZMA_IN_CB
+  RC_INIT;
+  #else
+  RC_INIT(inStream, inSize);
+  #endif
+
+  #endif /* _LZMA_OUT_READ */
+
+  while(nowPos < outSize)
+  {
+    CProb *prob;
+    UInt32 bound;
+    int posState = (int)(
+        (nowPos 
+        #ifdef _LZMA_OUT_READ
+        + globalPos
+        #endif
+        )
+        & posStateMask);
+
+    prob = p + IsMatch + (state << kNumPosBitsMax) + posState;
+    IfBit0(prob)
+    {
+      int symbol = 1;
+      UpdateBit0(prob)
+      prob = p + Literal + (LZMA_LIT_SIZE * 
+        (((
+        (nowPos 
+        #ifdef _LZMA_OUT_READ
+        + globalPos
+        #endif
+        )
+        & literalPosMask) << lc) + (previousByte >> (8 - lc))));
+
+      if (state >= kNumLitStates)
+      {
+        int matchByte;
+        #ifdef _LZMA_OUT_READ
+        UInt32 pos = dictionaryPos - rep0;
+        if (pos >= dictionarySize)
+          pos += dictionarySize;
+        matchByte = dictionary[pos];
+        #else
+        matchByte = outStream[nowPos - rep0];
+        #endif
+        do
+        {
+          int bit;
+          CProb *probLit;
+          matchByte <<= 1;
+          bit = (matchByte & 0x100);
+          probLit = prob + 0x100 + bit + symbol;
+          RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)
+        }
+        while (symbol < 0x100);
+      }
+      while (symbol < 0x100)
+      {
+        CProb *probLit = prob + symbol;
+        RC_GET_BIT(probLit, symbol)
+      }
+      previousByte = (Byte)symbol;
+
+      outStream[nowPos++] = previousByte;
+      #ifdef _LZMA_OUT_READ
+      if (distanceLimit < dictionarySize)
+        distanceLimit++;
+
+      dictionary[dictionaryPos] = previousByte;
+      if (++dictionaryPos == dictionarySize)
+        dictionaryPos = 0;
+      #endif
+      if (state < 4) state = 0;
+      else if (state < 10) state -= 3;
+      else state -= 6;
+    }
+    else             
+    {
+      UpdateBit1(prob);
+      prob = p + IsRep + state;
+      IfBit0(prob)
+      {
+        UpdateBit0(prob);
+        rep3 = rep2;
+        rep2 = rep1;
+        rep1 = rep0;
+        state = state < kNumLitStates ? 0 : 3;
+        prob = p + LenCoder;
+      }
+      else
+      {
+        UpdateBit1(prob);
+        prob = p + IsRepG0 + state;
+        IfBit0(prob)
+        {
+          UpdateBit0(prob);
+          prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;
+          IfBit0(prob)
+          {
+            #ifdef _LZMA_OUT_READ
+            UInt32 pos;
+            #endif
+            UpdateBit0(prob);
+            
+            #ifdef _LZMA_OUT_READ
+            if (distanceLimit == 0)
+            #else
+            if (nowPos == 0)
+            #endif
+              return LZMA_RESULT_DATA_ERROR;
+            
+            state = state < kNumLitStates ? 9 : 11;
+            #ifdef _LZMA_OUT_READ
+            pos = dictionaryPos - rep0;
+            if (pos >= dictionarySize)
+              pos += dictionarySize;
+            previousByte = dictionary[pos];
+            dictionary[dictionaryPos] = previousByte;
+            if (++dictionaryPos == dictionarySize)
+              dictionaryPos = 0;
+            #else
+            previousByte = outStream[nowPos - rep0];
+            #endif
+            outStream[nowPos++] = previousByte;
+            #ifdef _LZMA_OUT_READ
+            if (distanceLimit < dictionarySize)
+              distanceLimit++;
+            #endif
+
+            continue;
+          }
+          else
+          {
+            UpdateBit1(prob);
+          }
+        }
+        else
+        {
+          UInt32 distance;
+          UpdateBit1(prob);
+          prob = p + IsRepG1 + state;
+          IfBit0(prob)
+          {
+            UpdateBit0(prob);
+            distance = rep1;
+          }
+          else 
+          {
+            UpdateBit1(prob);
+            prob = p + IsRepG2 + state;
+            IfBit0(prob)
+            {
+              UpdateBit0(prob);
+              distance = rep2;
+            }
+            else
+            {
+              UpdateBit1(prob);
+              distance = rep3;
+              rep3 = rep2;
+            }
+            rep2 = rep1;
+          }
+          rep1 = rep0;
+          rep0 = distance;
+        }
+        state = state < kNumLitStates ? 8 : 11;
+        prob = p + RepLenCoder;
+      }
+      {
+        int numBits, offset;
+        CProb *probLen = prob + LenChoice;
+        IfBit0(probLen)
+        {
+          UpdateBit0(probLen);
+          probLen = prob + LenLow + (posState << kLenNumLowBits);
+          offset = 0;
+          numBits = kLenNumLowBits;
+        }
+        else
+        {
+          UpdateBit1(probLen);
+          probLen = prob + LenChoice2;
+          IfBit0(probLen)
+          {
+            UpdateBit0(probLen);
+            probLen = prob + LenMid + (posState << kLenNumMidBits);
+            offset = kLenNumLowSymbols;
+            numBits = kLenNumMidBits;
+          }
+          else
+          {
+            UpdateBit1(probLen);
+            probLen = prob + LenHigh;
+            offset = kLenNumLowSymbols + kLenNumMidSymbols;
+            numBits = kLenNumHighBits;
+          }
+        }
+        RangeDecoderBitTreeDecode(probLen, numBits, len);
+        len += offset;
+      }
+
+      if (state < 4)
+      {
+        int posSlot;
+        state += kNumLitStates;
+        prob = p + PosSlot +
+            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << 
+            kNumPosSlotBits);
+        RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);
+        if (posSlot >= kStartPosModelIndex)
+        {
+          int numDirectBits = ((posSlot >> 1) - 1);
+          rep0 = (2 | ((UInt32)posSlot & 1));
+          if (posSlot < kEndPosModelIndex)
+          {
+            rep0 <<= numDirectBits;
+            prob = p + SpecPos + rep0 - posSlot - 1;
+          }
+          else
+          {
+            numDirectBits -= kNumAlignBits;
+            do
+            {
+              RC_NORMALIZE
+              Range >>= 1;
+              rep0 <<= 1;
+              if (Code >= Range)
+              {
+                Code -= Range;
+                rep0 |= 1;
+              }
+            }
+            while (--numDirectBits != 0);
+            prob = p + Align;
+            rep0 <<= kNumAlignBits;
+            numDirectBits = kNumAlignBits;
+          }
+          {
+            int i = 1;
+            int mi = 1;
+            do
+            {
+              CProb *prob3 = prob + mi;
+              RC_GET_BIT2(prob3, mi, ; , rep0 |= i);
+              i <<= 1;
+            }
+            while(--numDirectBits != 0);
+          }
+        }
+        else
+          rep0 = posSlot;
+        if (++rep0 == (UInt32)(0))
+        {
+          /* it's for stream version */
+          len = kLzmaStreamWasFinishedId;
+          break;
+        }
+      }
+
+      len += kMatchMinLen;
+      #ifdef _LZMA_OUT_READ
+      if (rep0 > distanceLimit) 
+      #else
+      if (rep0 > nowPos)
+      #endif
+        return LZMA_RESULT_DATA_ERROR;
+
+      #ifdef _LZMA_OUT_READ
+      if (dictionarySize - distanceLimit > (UInt32)len)
+        distanceLimit += len;
+      else
+        distanceLimit = dictionarySize;
+      #endif
+
+      do
+      {
+        #ifdef _LZMA_OUT_READ
+        UInt32 pos = dictionaryPos - rep0;
+        if (pos >= dictionarySize)
+          pos += dictionarySize;
+        previousByte = dictionary[pos];
+        dictionary[dictionaryPos] = previousByte;
+        if (++dictionaryPos == dictionarySize)
+          dictionaryPos = 0;
+        #else
+        previousByte = outStream[nowPos - rep0];
+        #endif
+        len--;
+        outStream[nowPos++] = previousByte;
+      }
+      while(len != 0 && nowPos < outSize);
+    }
+  }
+  RC_NORMALIZE;
+
+  #ifdef _LZMA_OUT_READ
+  vs->Range = Range;
+  vs->Code = Code;
+  vs->DictionaryPos = dictionaryPos;
+  vs->GlobalPos = globalPos + (UInt32)nowPos;
+  vs->DistanceLimit = distanceLimit;
+  vs->Reps[0] = rep0;
+  vs->Reps[1] = rep1;
+  vs->Reps[2] = rep2;
+  vs->Reps[3] = rep3;
+  vs->State = state;
+  vs->RemainLen = len;
+  vs->TempDictionary[0] = tempDictionary[0];
+  #endif
+
+  #ifdef _LZMA_IN_CB
+  vs->Buffer = Buffer;
+  vs->BufferLim = BufferLim;
+  #else
+  *inSizeProcessed = (SizeT)(Buffer - inStream);
+  #endif
+  *outSizeProcessed = nowPos;
+  return LZMA_RESULT_OK;
+}
diff --git a/util/cbfstool/tools/lzma/C/7zip/Decompress/LzmaDecode.h b/util/cbfstool/tools/lzma/C/7zip/Decompress/LzmaDecode.h
new file mode 100644
index 0000000000..213062af12
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/Decompress/LzmaDecode.h
@@ -0,0 +1,131 @@
+/* 
+  LzmaDecode.h
+  LZMA Decoder interface
+
+  LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)
+  http://www.7-zip.org/
+
+  LZMA SDK is licensed under two licenses:
+  1) GNU Lesser General Public License (GNU LGPL)
+  2) Common Public License (CPL)
+  It means that you can select one of these two licenses and 
+  follow rules of that license.
+
+  SPECIAL EXCEPTION:
+  Igor Pavlov, as the author of this code, expressly permits you to 
+  statically or dynamically link your code (or bind by name) to the 
+  interfaces of this file without subjecting your linked code to the 
+  terms of the CPL or GNU LGPL. Any modifications or additions 
+  to this file, however, are subject to the LGPL or CPL terms.
+*/
+
+#ifndef __LZMADECODE_H
+#define __LZMADECODE_H
+
+/* #define _LZMA_IN_CB */
+/* Use callback for input data */
+
+/* #define _LZMA_OUT_READ */
+/* Use read function for output data */
+
+/* #define _LZMA_PROB32 */
+/* It can increase speed on some 32-bit CPUs, 
+   but memory usage will be doubled in that case */
+
+/* #define _LZMA_LOC_OPT */
+/* Enable local speed optimizations inside code */
+
+/* #define _LZMA_SYSTEM_SIZE_T */
+/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/
+
+#ifndef UInt32
+#ifdef _LZMA_UINT32_IS_ULONG
+#define UInt32 unsigned long
+#else
+#define UInt32 unsigned int
+#endif
+#endif
+
+#ifndef SizeT
+#ifdef _LZMA_SYSTEM_SIZE_T
+#include <stddef.h>
+#define SizeT size_t
+#else
+#define SizeT UInt32
+#endif
+#endif
+
+#ifdef _LZMA_PROB32
+#define CProb UInt32
+#else
+#define CProb unsigned short
+#endif
+
+#define LZMA_RESULT_OK 0
+#define LZMA_RESULT_DATA_ERROR 1
+
+#ifdef _LZMA_IN_CB
+typedef struct _ILzmaInCallback
+{
+  int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);
+} ILzmaInCallback;
+#endif
+
+#define LZMA_BASE_SIZE 1846
+#define LZMA_LIT_SIZE 768
+
+#define LZMA_PROPERTIES_SIZE 5
+
+typedef struct _CLzmaProperties
+{
+  int lc;
+  int lp;
+  int pb;
+  #ifdef _LZMA_OUT_READ
+  UInt32 DictionarySize;
+  #endif
+}CLzmaProperties;
+
+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);
+
+#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
+
+#define kLzmaNeedInitId (-2)
+
+typedef struct _CLzmaDecoderState
+{
+  CLzmaProperties Properties;
+  CProb *Probs;
+
+  #ifdef _LZMA_IN_CB
+  const unsigned char *Buffer;
+  const unsigned char *BufferLim;
+  #endif
+
+  #ifdef _LZMA_OUT_READ
+  unsigned char *Dictionary;
+  UInt32 Range;
+  UInt32 Code;
+  UInt32 DictionaryPos;
+  UInt32 GlobalPos;
+  UInt32 DistanceLimit;
+  UInt32 Reps[4];
+  int State;
+  int RemainLen;
+  unsigned char TempDictionary[4];
+  #endif
+} CLzmaDecoderState;
+
+#ifdef _LZMA_OUT_READ
+#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }
+#endif
+
+int LzmaDecode(CLzmaDecoderState *vs,
+    #ifdef _LZMA_IN_CB
+    ILzmaInCallback *inCallback,
+    #else
+    const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
+    #endif
+    unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);
+
+#endif
diff --git a/util/cbfstool/tools/lzma/C/7zip/ICoder.h b/util/cbfstool/tools/lzma/C/7zip/ICoder.h
new file mode 100644
index 0000000000..508dac3fd0
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/ICoder.h
@@ -0,0 +1,163 @@
+// ICoder.h

+

+#ifndef __ICODER_H

+#define __ICODER_H

+

+#include "IStream.h"

+

+// "23170F69-40C1-278A-0000-000400xx0000"

+#define CODER_INTERFACE(i, x) \

+DEFINE_GUID(IID_ ## i, \

+0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x04, 0x00, x, 0x00, 0x00); \

+struct i: public IUnknown

+

+CODER_INTERFACE(ICompressProgressInfo, 0x04)

+{

+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) PURE;

+};

+

+CODER_INTERFACE(ICompressCoder, 0x05)

+{

+  STDMETHOD(Code)(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, 

+      const UInt64 *inSize, 

+      const UInt64 *outSize,

+      ICompressProgressInfo *progress) PURE;

+};

+

+CODER_INTERFACE(ICompressCoder2, 0x18)

+{

+  STDMETHOD(Code)(ISequentialInStream **inStreams,

+      const UInt64 **inSizes, 

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams, 

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress) PURE;

+};

+

+namespace NCoderPropID

+{

+  enum EEnum

+  {

+    kDictionarySize = 0x400,

+    kUsedMemorySize,

+    kOrder,

+    kPosStateBits = 0x440,

+    kLitContextBits,

+    kLitPosBits,

+    kNumFastBytes = 0x450,

+    kMatchFinder,

+    kMatchFinderCycles,

+    kNumPasses = 0x460, 

+    kAlgorithm = 0x470,

+    kMultiThread = 0x480,

+    kNumThreads,

+    kEndMarker = 0x490

+  };

+}

+

+CODER_INTERFACE(ICompressSetCoderProperties, 0x20)

+{

+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, 

+      const PROPVARIANT *properties, UInt32 numProperties) PURE;

+};

+

+/*

+CODER_INTERFACE(ICompressSetCoderProperties, 0x21)

+{

+  STDMETHOD(SetDecoderProperties)(ISequentialInStream *inStream) PURE;

+};

+*/

+

+CODER_INTERFACE(ICompressSetDecoderProperties2, 0x22)

+{

+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size) PURE;

+};

+

+CODER_INTERFACE(ICompressWriteCoderProperties, 0x23)

+{

+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStreams) PURE;

+};

+

+CODER_INTERFACE(ICompressGetInStreamProcessedSize, 0x24)

+{

+  STDMETHOD(GetInStreamProcessedSize)(UInt64 *value) PURE;

+};

+

+CODER_INTERFACE(ICompressSetCoderMt, 0x25)

+{

+  STDMETHOD(SetNumberOfThreads)(UInt32 numThreads) PURE;

+};

+

+CODER_INTERFACE(ICompressGetSubStreamSize, 0x30)

+{

+  STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value) PURE;

+};

+

+CODER_INTERFACE(ICompressSetInStream, 0x31)

+{

+  STDMETHOD(SetInStream)(ISequentialInStream *inStream) PURE;

+  STDMETHOD(ReleaseInStream)() PURE;

+};

+

+CODER_INTERFACE(ICompressSetOutStream, 0x32)

+{

+  STDMETHOD(SetOutStream)(ISequentialOutStream *outStream) PURE;

+  STDMETHOD(ReleaseOutStream)() PURE;

+};

+

+CODER_INTERFACE(ICompressSetInStreamSize, 0x33)

+{

+  STDMETHOD(SetInStreamSize)(const UInt64 *inSize) PURE;

+};

+

+CODER_INTERFACE(ICompressSetOutStreamSize, 0x34)

+{

+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize) PURE;

+};

+

+CODER_INTERFACE(ICompressFilter, 0x40)

+{

+  STDMETHOD(Init)() PURE;

+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) PURE;

+  // Filter return outSize (UInt32)

+  // if (outSize <= size): Filter have converted outSize bytes

+  // if (outSize > size): Filter have not converted anything.

+  //      and it needs at least outSize bytes to convert one block 

+  //      (it's for crypto block algorithms).

+};

+

+CODER_INTERFACE(ICryptoProperties, 0x80)

+{

+  STDMETHOD(SetKey)(const Byte *data, UInt32 size) PURE;

+  STDMETHOD(SetInitVector)(const Byte *data, UInt32 size) PURE;

+};

+

+CODER_INTERFACE(ICryptoSetPassword, 0x90)

+{

+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size) PURE;

+};

+

+CODER_INTERFACE(ICryptoSetCRC, 0xA0)

+{

+  STDMETHOD(CryptoSetCRC)(UInt32 crc) PURE;

+};

+

+//////////////////////

+// It's for DLL file

+namespace NMethodPropID

+{

+  enum EEnum

+  {

+    kID,

+    kName,

+    kDecoder,

+    kEncoder,

+    kInStreams,

+    kOutStreams,

+    kDescription

+  };

+}

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/7zip/IStream.h b/util/cbfstool/tools/lzma/C/7zip/IStream.h
new file mode 100644
index 0000000000..d92b89aa70
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/7zip/IStream.h
@@ -0,0 +1,62 @@
+// IStream.h

+

+#ifndef __ISTREAM_H

+#define __ISTREAM_H

+

+#include "../Common/MyUnknown.h"

+#include "../Common/Types.h"

+

+// "23170F69-40C1-278A-0000-000300xx0000"

+

+#define STREAM_INTERFACE_SUB(i, b, x) \

+DEFINE_GUID(IID_ ## i, \

+0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x03, 0x00, x, 0x00, 0x00); \

+struct i: public b

+

+#define STREAM_INTERFACE(i, x) STREAM_INTERFACE_SUB(i, IUnknown, x)

+

+STREAM_INTERFACE(ISequentialInStream, 0x01)

+{

+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) PURE;

+  /*

+  Out: if size != 0, return_value = S_OK and (*processedSize == 0),

+    then there are no more bytes in stream.

+  if (size > 0) && there are bytes in stream, 

+  this function must read at least 1 byte.

+  This function is allowed to read less than number of remaining bytes in stream.

+  You must call Read function in loop, if you need exact amount of data

+  */

+};

+

+STREAM_INTERFACE(ISequentialOutStream, 0x02)

+{

+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;

+  /*

+  if (size > 0) this function must write at least 1 byte.

+  This function is allowed to write less than "size".

+  You must call Write function in loop, if you need to write exact amount of data

+  */

+};

+

+STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)

+{

+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;

+};

+

+STREAM_INTERFACE_SUB(IOutStream, ISequentialOutStream, 0x04)

+{

+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;

+  STDMETHOD(SetSize)(Int64 newSize) PURE;

+};

+

+STREAM_INTERFACE(IStreamGetSize, 0x06)

+{

+  STDMETHOD(GetSize)(UInt64 *size) PURE;

+};

+

+STREAM_INTERFACE(IOutStreamFlush, 0x07)

+{

+  STDMETHOD(Flush)() PURE;

+};

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/Alloc.cpp b/util/cbfstool/tools/lzma/C/Common/Alloc.cpp
new file mode 100644
index 0000000000..dcb331ee9f
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/Alloc.cpp
@@ -0,0 +1,118 @@
+// Common/Alloc.cpp

+

+#include "StdAfx.h"

+

+#ifdef _WIN32

+#include "MyWindows.h"

+#else

+#include <stdlib.h>

+#endif

+

+#include "Alloc.h"

+

+/* #define _SZ_ALLOC_DEBUG */

+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */

+#ifdef _SZ_ALLOC_DEBUG

+#include <stdio.h>

+int g_allocCount = 0;

+int g_allocCountMid = 0;

+int g_allocCountBig = 0;

+#endif

+

+void *MyAlloc(size_t size) throw()

+{

+  if (size == 0)

+    return 0;

+  #ifdef _SZ_ALLOC_DEBUG

+  fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount++);

+  #endif

+  return ::malloc(size);

+}

+

+void MyFree(void *address) throw()

+{

+  #ifdef _SZ_ALLOC_DEBUG

+  if (address != 0)

+    fprintf(stderr, "\nFree; count = %10d", --g_allocCount);

+  #endif

+  

+  ::free(address);

+}

+

+#ifdef _WIN32

+

+void *MidAlloc(size_t size) throw()

+{

+  if (size == 0)

+    return 0;

+  #ifdef _SZ_ALLOC_DEBUG

+  fprintf(stderr, "\nAlloc_Mid %10d bytes;  count = %10d", size, g_allocCountMid++);

+  #endif

+  return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);

+}

+

+void MidFree(void *address) throw()

+{

+  #ifdef _SZ_ALLOC_DEBUG

+  if (address != 0)

+    fprintf(stderr, "\nFree_Mid; count = %10d", --g_allocCountMid);

+  #endif

+  if (address == 0)

+    return;

+  ::VirtualFree(address, 0, MEM_RELEASE);

+}

+

+static SIZE_T g_LargePageSize = 

+    #ifdef _WIN64

+    (1 << 21);

+    #else

+    (1 << 22);

+    #endif

+

+typedef SIZE_T (WINAPI *GetLargePageMinimumP)();

+

+bool SetLargePageSize()

+{

+  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)

+        ::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");

+  if (largePageMinimum == 0)

+    return false;

+  SIZE_T size = largePageMinimum();

+  if (size == 0 || (size & (size - 1)) != 0)

+    return false;

+  g_LargePageSize = size;

+  return true;

+}

+

+

+void *BigAlloc(size_t size) throw()

+{

+  if (size == 0)

+    return 0;

+  #ifdef _SZ_ALLOC_DEBUG

+  fprintf(stderr, "\nAlloc_Big %10d bytes;  count = %10d", size, g_allocCountBig++);

+  #endif

+  

+  if (size >= (1 << 18))

+  {

+    void *res = ::VirtualAlloc(0, (size + g_LargePageSize - 1) & (~(g_LargePageSize - 1)), 

+        MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);

+    if (res != 0)

+      return res;

+  }

+  return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);

+}

+

+void BigFree(void *address) throw()

+{

+  #ifdef _SZ_ALLOC_DEBUG

+  if (address != 0)

+    fprintf(stderr, "\nFree_Big; count = %10d", --g_allocCountBig);

+  #endif

+  

+  if (address == 0)

+    return;

+  ::VirtualFree(address, 0, MEM_RELEASE);

+}

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/Alloc.h b/util/cbfstool/tools/lzma/C/Common/Alloc.h
new file mode 100644
index 0000000000..2ae3891de6
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/Alloc.h
@@ -0,0 +1,29 @@
+// Common/Alloc.h

+

+#ifndef __COMMON_ALLOC_H

+#define __COMMON_ALLOC_H

+

+#include <stddef.h>

+

+void *MyAlloc(size_t size) throw();

+void MyFree(void *address) throw();

+

+#ifdef _WIN32

+

+bool SetLargePageSize();

+

+void *MidAlloc(size_t size) throw();

+void MidFree(void *address) throw();

+void *BigAlloc(size_t size) throw();

+void BigFree(void *address) throw();

+

+#else

+

+#define MidAlloc(size) MyAlloc(size)

+#define MidFree(address) MyFree(address)

+#define BigAlloc(size) MyAlloc(size)

+#define BigFree(address) MyFree(address)

+

+#endif

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/CRC.cpp b/util/cbfstool/tools/lzma/C/Common/CRC.cpp
new file mode 100644
index 0000000000..92bc009c2f
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/CRC.cpp
@@ -0,0 +1,61 @@
+// Common/CRC.cpp

+

+#include "StdAfx.h"

+

+#include "CRC.h"

+

+static const UInt32 kCRCPoly = 0xEDB88320;

+

+UInt32 CCRC::Table[256];

+

+void CCRC::InitTable()

+{

+  for (UInt32 i = 0; i < 256; i++)

+  {

+    UInt32 r = i;

+    for (int j = 0; j < 8; j++)

+      if (r & 1) 

+        r = (r >> 1) ^ kCRCPoly;

+      else     

+        r >>= 1;

+    CCRC::Table[i] = r;

+  }

+}

+

+class CCRCTableInit

+{

+public:

+  CCRCTableInit() { CCRC::InitTable(); }

+} g_CRCTableInit;

+

+void CCRC::UpdateByte(Byte b)

+{

+  _value = Table[((Byte)(_value)) ^ b] ^ (_value >> 8);

+}

+

+void CCRC::UpdateUInt16(UInt16 v)

+{

+  UpdateByte(Byte(v));

+  UpdateByte(Byte(v >> 8));

+}

+

+void CCRC::UpdateUInt32(UInt32 v)

+{

+  for (int i = 0; i < 4; i++)

+    UpdateByte((Byte)(v >> (8 * i)));

+}

+

+void CCRC::UpdateUInt64(UInt64 v)

+{

+  for (int i = 0; i < 8; i++)

+    UpdateByte((Byte)(v >> (8 * i)));

+}

+

+void CCRC::Update(const void *data, size_t size)

+{

+  UInt32 v = _value;

+  const Byte *p = (const Byte *)data;

+  for (; size > 0 ; size--, p++)

+    v = Table[((Byte)(v)) ^ *p] ^ (v >> 8);

+  _value = v;

+}

diff --git a/util/cbfstool/tools/lzma/C/Common/CRC.h b/util/cbfstool/tools/lzma/C/Common/CRC.h
new file mode 100644
index 0000000000..c9d43d0055
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/CRC.h
@@ -0,0 +1,36 @@
+// Common/CRC.h

+

+#ifndef __COMMON_CRC_H

+#define __COMMON_CRC_H

+

+#include <stddef.h>

+#include "Types.h"

+

+class CCRC

+{

+  UInt32 _value;

+public:

+	static UInt32 Table[256];

+	static void InitTable();

+

+  CCRC():  _value(0xFFFFFFFF){};

+  void Init() { _value = 0xFFFFFFFF; }

+  void UpdateByte(Byte v);

+  void UpdateUInt16(UInt16 v);

+  void UpdateUInt32(UInt32 v);

+  void UpdateUInt64(UInt64 v);

+  void Update(const void *data, size_t size);

+  UInt32 GetDigest() const { return _value ^ 0xFFFFFFFF; } 

+  static UInt32 CalculateDigest(const void *data, size_t size)

+  {

+    CCRC crc;

+    crc.Update(data, size);

+    return crc.GetDigest();

+  }

+  static bool VerifyDigest(UInt32 digest, const void *data, size_t size)

+  {

+    return (CalculateDigest(data, size) == digest);

+  }

+};

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/Defs.h b/util/cbfstool/tools/lzma/C/Common/Defs.h
new file mode 100644
index 0000000000..69b8ecea82
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/Defs.h
@@ -0,0 +1,20 @@
+// Common/Defs.h

+

+#ifndef __COMMON_DEFS_H

+#define __COMMON_DEFS_H

+

+template <class T> inline T MyMin(T a, T b)

+  {  return a < b ? a : b; }

+template <class T> inline T MyMax(T a, T b)

+  {  return a > b ? a : b; }

+

+template <class T> inline int MyCompare(T a, T b)

+  {  return a < b ? -1 : (a == b ? 0 : 1); }

+

+inline int BoolToInt(bool value)

+  { return (value ? 1: 0); }

+

+inline bool IntToBool(int value)

+  { return (value != 0); }

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/MyCom.h b/util/cbfstool/tools/lzma/C/Common/MyCom.h
new file mode 100644
index 0000000000..8476b57282
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/MyCom.h
@@ -0,0 +1,203 @@
+// MyCom.h

+

+#ifndef __MYCOM_H

+#define __MYCOM_H

+

+#include "MyWindows.h"

+

+#define RINOK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }

+

+template <class T>

+class CMyComPtr

+{

+  T* _p;

+public:

+  // typedef T _PtrClass;

+  CMyComPtr() { _p = NULL;}

+  CMyComPtr(T* p) {if ((_p = p) != NULL) p->AddRef(); }

+  CMyComPtr(const CMyComPtr<T>& lp)

+  {

+    if ((_p = lp._p) != NULL)

+      _p->AddRef();

+  }

+  ~CMyComPtr() { if (_p) _p->Release(); }

+  void Release() { if (_p) { _p->Release(); _p = NULL; } }

+  operator T*() const {  return (T*)_p;  }

+  // T& operator*() const {  return *_p; }

+  T** operator&() { return &_p; }

+  T* operator->() const { return _p; }

+  T* operator=(T* p) 

+  { 

+    if (p != 0)

+      p->AddRef();

+    if (_p) 

+      _p->Release();

+    _p = p;

+    return p;

+  }

+  T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }

+  bool operator!() const { return (_p == NULL); }

+  // bool operator==(T* pT) const {  return _p == pT; }

+  // Compare two objects for equivalence

+  void Attach(T* p2)

+  {

+    Release();

+    _p = p2;

+  }

+  T* Detach()

+  {

+    T* pt = _p;

+    _p = NULL;

+    return pt;

+  }

+  #ifdef _WIN32

+  HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)

+  {

+    return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);

+  }

+  #endif

+  /*

+  HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)

+  {

+    CLSID clsid;

+    HRESULT hr = CLSIDFromProgID(szProgID, &clsid);

+    ATLASSERT(_p == NULL);

+    if (SUCCEEDED(hr))

+      hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);

+    return hr;

+  }

+  */

+  template <class Q>

+  HRESULT QueryInterface(REFGUID iid, Q** pp) const

+  {

+    return _p->QueryInterface(iid, (void**)pp);

+  }

+};

+

+//////////////////////////////////////////////////////////

+

+class CMyComBSTR

+{

+public:

+  BSTR m_str;

+  CMyComBSTR() { m_str = NULL; }

+  CMyComBSTR(LPCOLESTR pSrc) {  m_str = ::SysAllocString(pSrc);  }

+  // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }

+  // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize);  }

+  CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }

+  /*

+  CMyComBSTR(REFGUID src)

+  {

+    LPOLESTR szGuid;

+    StringFromCLSID(src, &szGuid);

+    m_str = ::SysAllocString(szGuid);

+    CoTaskMemFree(szGuid);

+  }

+  */

+  ~CMyComBSTR() { ::SysFreeString(m_str); }

+  CMyComBSTR& operator=(const CMyComBSTR& src)

+  {

+    if (m_str != src.m_str)

+    {

+      if (m_str)

+        ::SysFreeString(m_str);

+      m_str = src.MyCopy();

+    }

+    return *this;

+  }

+  CMyComBSTR& operator=(LPCOLESTR pSrc)

+  {

+    ::SysFreeString(m_str);

+    m_str = ::SysAllocString(pSrc);

+    return *this;

+  }

+  unsigned int Length() const { return ::SysStringLen(m_str); }

+  operator BSTR() const { return m_str; }

+  BSTR* operator&() { return &m_str; }

+  BSTR MyCopy() const 

+  { 

+    int byteLen = ::SysStringByteLen(m_str);

+    BSTR res = ::SysAllocStringByteLen(NULL, byteLen);

+    memmove(res, m_str, byteLen);

+    return res;

+  }

+  void Attach(BSTR src) {  m_str = src; }

+  BSTR Detach()

+  {

+    BSTR s = m_str;

+    m_str = NULL;

+    return s;

+  }

+  void Empty()

+  {

+    ::SysFreeString(m_str);

+    m_str = NULL;

+  }

+  bool operator!() const {  return (m_str == NULL); }

+};

+

+

+//////////////////////////////////////////////////////////

+

+class CMyUnknownImp

+{

+public:

+  ULONG __m_RefCount;

+  CMyUnknownImp(): __m_RefCount(0) {}

+};

+

+#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \

+    (REFGUID iid, void **outObject) { 

+

+#define MY_QUERYINTERFACE_ENTRY(i) if (iid == IID_ ## i) \

+    { *outObject = (void *)(i *)this; AddRef(); return S_OK; }

+

+#define MY_QUERYINTERFACE_END return E_NOINTERFACE; }

+

+#define MY_ADDREF_RELEASE \

+STDMETHOD_(ULONG, AddRef)() { return ++__m_RefCount; } \

+STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0)  \

+  return __m_RefCount; delete this; return 0; }

+

+#define MY_UNKNOWN_IMP_SPEC(i) \

+  MY_QUERYINTERFACE_BEGIN \

+  i \

+  MY_QUERYINTERFACE_END \

+  MY_ADDREF_RELEASE

+

+

+#define MY_UNKNOWN_IMP STDMETHOD(QueryInterface)(REFGUID, void **) { \

+  MY_QUERYINTERFACE_END \

+  MY_ADDREF_RELEASE

+

+#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i) \

+  )

+

+#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  )

+

+#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  MY_QUERYINTERFACE_ENTRY(i3) \

+  )

+

+#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  MY_QUERYINTERFACE_ENTRY(i3) \

+  MY_QUERYINTERFACE_ENTRY(i4) \

+  )

+

+#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  MY_QUERYINTERFACE_ENTRY(i3) \

+  MY_QUERYINTERFACE_ENTRY(i4) \

+  MY_QUERYINTERFACE_ENTRY(i5) \

+  )

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/MyGuidDef.h b/util/cbfstool/tools/lzma/C/Common/MyGuidDef.h
new file mode 100644
index 0000000000..889ea417b0
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/MyGuidDef.h
@@ -0,0 +1,54 @@
+// Common/MyGuidDef.h

+

+#ifndef GUID_DEFINED

+#define GUID_DEFINED

+

+#include "Types.h"

+

+typedef struct {

+  UInt32 Data1;

+  UInt16 Data2;

+  UInt16 Data3;

+  unsigned char Data4[8];

+} GUID;

+

+#ifdef __cplusplus

+#define REFGUID const GUID &

+#else

+#define REFGUID const GUID *

+#endif

+

+#define REFCLSID REFGUID

+#define REFIID REFGUID

+

+#ifdef __cplusplus

+inline bool operator==(REFGUID g1, REFGUID g2)

+{ 

+  for (int i = 0; i < (int)sizeof(g1); i++)

+    if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])

+      return false;

+  return true;

+}

+inline bool operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }

+#endif

+

+#ifdef __cplusplus

+  #define MY_EXTERN_C extern "C"

+#else

+  #define MY_EXTERN_C extern

+#endif

+

+#endif // GUID_DEFINED

+

+

+#ifdef DEFINE_GUID

+#undef DEFINE_GUID

+#endif

+

+#ifdef INITGUID

+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

+    MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }

+#else

+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

+    MY_EXTERN_C const GUID name

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/MyInitGuid.h b/util/cbfstool/tools/lzma/C/Common/MyInitGuid.h
new file mode 100644
index 0000000000..53b0f03428
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/MyInitGuid.h
@@ -0,0 +1,13 @@
+// Common/MyInitGuid.h

+

+#ifndef __COMMON_MYINITGUID_H

+#define __COMMON_MYINITGUID_H

+

+#ifdef _WIN32

+#include <initguid.h>

+#else

+#define INITGUID

+#include "MyGuidDef.h"

+#endif

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/MyUnknown.h b/util/cbfstool/tools/lzma/C/Common/MyUnknown.h
new file mode 100644
index 0000000000..6cd32caddb
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/MyUnknown.h
@@ -0,0 +1,24 @@
+// MyUnknown.h

+

+#ifndef __MYUNKNOWN_H

+#define __MYUNKNOWN_H

+

+#ifdef _WIN32

+

+#ifdef _WIN32_WCE

+#if (_WIN32_WCE > 300)

+#include <basetyps.h>

+#else

+#define MIDL_INTERFACE(x) struct 

+#endif

+#else

+#include <basetyps.h>

+#endif

+

+#include <unknwn.h>

+

+#else 

+#include "MyWindows.h"

+#endif

+  

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/MyWindows.h b/util/cbfstool/tools/lzma/C/Common/MyWindows.h
new file mode 100644
index 0000000000..2929be7c30
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/MyWindows.h
@@ -0,0 +1,201 @@
+// MyWindows.h

+

+#ifndef __MYWINDOWS_H

+#define __MYWINDOWS_H

+

+#ifdef _WIN32

+

+#include <windows.h>

+

+#define CHAR_PATH_SEPARATOR '\\'

+#define WCHAR_PATH_SEPARATOR L'\\'

+#define STRING_PATH_SEPARATOR "\\"

+#define WSTRING_PATH_SEPARATOR L"\\"

+

+#else

+

+#define CHAR_PATH_SEPARATOR '/'

+#define WCHAR_PATH_SEPARATOR L'/'

+#define STRING_PATH_SEPARATOR "/"

+#define WSTRING_PATH_SEPARATOR L"/"

+

+#include <stddef.h> // for wchar_t

+#include <string.h>

+

+#include "MyGuidDef.h"

+

+typedef char CHAR;

+typedef unsigned char UCHAR;

+

+#undef BYTE

+typedef unsigned char BYTE;

+

+typedef short SHORT;

+typedef unsigned short USHORT;

+

+#undef WORD

+typedef unsigned short WORD;

+typedef short VARIANT_BOOL;

+

+typedef int INT;

+typedef Int32 INT32;

+typedef unsigned int UINT;

+typedef UInt32 UINT32;

+typedef INT32 LONG;   // LONG, ULONG and DWORD must be 32-bit

+typedef UINT32 ULONG;

+

+#undef DWORD

+typedef UINT32 DWORD;

+

+typedef Int64 LONGLONG;

+typedef UInt64 ULONGLONG;

+

+typedef struct LARGE_INTEGER { LONGLONG QuadPart; }LARGE_INTEGER;

+typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart;} ULARGE_INTEGER;

+

+typedef const CHAR *LPCSTR;

+typedef CHAR TCHAR;

+typedef const TCHAR *LPCTSTR;

+typedef wchar_t WCHAR;

+typedef WCHAR OLECHAR;

+typedef const WCHAR *LPCWSTR;

+typedef OLECHAR *BSTR;

+typedef const OLECHAR *LPCOLESTR;

+typedef OLECHAR *LPOLESTR;

+

+typedef struct _FILETIME

+{

+  DWORD dwLowDateTime;

+  DWORD dwHighDateTime;

+}FILETIME;

+

+#define HRESULT LONG

+#define FAILED(Status) ((HRESULT)(Status)<0)

+typedef ULONG PROPID;

+typedef LONG SCODE;

+

+#define S_OK    ((HRESULT)0x00000000L)

+#define S_FALSE ((HRESULT)0x00000001L)

+#define E_NOTIMPL ((HRESULT)0x80004001L)

+#define E_NOINTERFACE ((HRESULT)0x80004002L)

+#define E_ABORT ((HRESULT)0x80004004L)

+#define E_FAIL ((HRESULT)0x80004005L)

+#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)

+#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)

+#define E_INVALIDARG ((HRESULT)0x80070057L)

+

+#ifdef _MSC_VER

+#define STDMETHODCALLTYPE __stdcall 

+#else

+#define STDMETHODCALLTYPE 

+#endif

+

+#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f

+#define STDMETHOD(f) STDMETHOD_(HRESULT, f)

+#define STDMETHODIMP_(type) type STDMETHODCALLTYPE

+#define STDMETHODIMP STDMETHODIMP_(HRESULT)

+

+#define PURE = 0

+

+#define MIDL_INTERFACE(x) struct 

+

+struct IUnknown

+{

+  //virtual ~IUnknown() {}

+  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;

+  STDMETHOD_(ULONG, AddRef)() PURE;

+  STDMETHOD_(ULONG, Release)() PURE;

+};

+

+typedef IUnknown *LPUNKNOWN;

+

+#define VARIANT_TRUE ((VARIANT_BOOL)-1)

+#define VARIANT_FALSE ((VARIANT_BOOL)0)

+

+enum VARENUM

+{	

+  VT_EMPTY	= 0,

+	VT_NULL	= 1,

+	VT_I2	= 2,

+	VT_I4	= 3,

+	VT_R4	= 4,

+	VT_R8	= 5,

+	VT_CY	= 6,

+	VT_DATE	= 7,

+	VT_BSTR	= 8,

+	VT_DISPATCH	= 9,

+	VT_ERROR	= 10,

+	VT_BOOL	= 11,

+	VT_VARIANT	= 12,

+	VT_UNKNOWN	= 13,

+	VT_DECIMAL	= 14,

+	VT_I1	= 16,

+	VT_UI1	= 17,

+	VT_UI2	= 18,

+	VT_UI4	= 19,

+	VT_I8	= 20,

+	VT_UI8	= 21,

+	VT_INT	= 22,

+	VT_UINT	= 23,

+	VT_VOID	= 24,

+	VT_HRESULT	= 25,

+	VT_FILETIME	= 64

+};

+

+typedef unsigned short VARTYPE;

+typedef WORD PROPVAR_PAD1;

+typedef WORD PROPVAR_PAD2;

+typedef WORD PROPVAR_PAD3;

+

+typedef struct tagPROPVARIANT

+{

+  VARTYPE vt;

+  PROPVAR_PAD1 wReserved1;

+  PROPVAR_PAD2 wReserved2;

+  PROPVAR_PAD3 wReserved3;

+  union 

+  {

+    CHAR cVal;

+    UCHAR bVal;

+    SHORT iVal;

+    USHORT uiVal;

+    LONG lVal;

+    ULONG ulVal;

+    INT intVal;

+    UINT uintVal;

+    LARGE_INTEGER hVal;

+    ULARGE_INTEGER uhVal;

+    VARIANT_BOOL boolVal;

+    SCODE scode;

+    FILETIME filetime;

+    BSTR bstrVal;

+  };

+} PROPVARIANT;

+

+typedef PROPVARIANT tagVARIANT;

+typedef tagVARIANT VARIANT;

+typedef VARIANT VARIANTARG;

+

+MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);

+MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);

+MY_EXTERN_C void SysFreeString(BSTR bstr);

+MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);

+MY_EXTERN_C UINT SysStringLen(BSTR bstr);

+

+MY_EXTERN_C DWORD GetLastError();

+MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);

+MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);

+MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);

+

+#define CP_ACP    0

+#define CP_OEMCP  1

+

+typedef enum tagSTREAM_SEEK

+{	

+  STREAM_SEEK_SET	= 0,

+  STREAM_SEEK_CUR	= 1,

+  STREAM_SEEK_END	= 2

+} STREAM_SEEK;

+

+#endif

+#endif

diff --git a/util/cbfstool/tools/lzma/C/Common/NewHandler.h b/util/cbfstool/tools/lzma/C/Common/NewHandler.h
new file mode 100644
index 0000000000..4c1727f824
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/NewHandler.h
@@ -0,0 +1,16 @@
+// Common/NewHandler.h

+

+#ifndef __COMMON_NEWHANDLER_H

+#define __COMMON_NEWHANDLER_H

+

+class CNewException {};

+

+#ifdef _WIN32

+void 

+#ifdef _MSC_VER

+__cdecl 

+#endif

+operator delete(void *p) throw();

+#endif 

+

+#endif 

diff --git a/util/cbfstool/tools/lzma/C/Common/StdAfx.h b/util/cbfstool/tools/lzma/C/Common/StdAfx.h
new file mode 100644
index 0000000000..2547611bd7
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/StdAfx.h
@@ -0,0 +1,9 @@
+// StdAfx.h

+

+#ifndef __STDAFX_H

+#define __STDAFX_H

+

+// #include "MyWindows.h"

+#include "NewHandler.h"

+

+#endif 

diff --git a/util/cbfstool/tools/lzma/C/Common/Types.h b/util/cbfstool/tools/lzma/C/Common/Types.h
new file mode 100644
index 0000000000..52d07081e8
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/Common/Types.h
@@ -0,0 +1,19 @@
+// Common/Types.h

+

+#ifndef __COMMON_TYPES_H

+#define __COMMON_TYPES_H

+

+typedef unsigned char Byte;

+typedef short Int16;

+typedef unsigned short UInt16;

+typedef int Int32;

+typedef unsigned int UInt32;

+#ifdef _MSC_VER

+typedef __int64 Int64;

+typedef unsigned __int64 UInt64;

+#else

+typedef long long int Int64;

+typedef unsigned long long int UInt64;

+#endif

+

+#endif

diff --git a/util/cbfstool/tools/lzma/C/LGPL.txt b/util/cbfstool/tools/lzma/C/LGPL.txt
new file mode 100644
index 0000000000..f3926a6155
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/LGPL.txt
@@ -0,0 +1,504 @@
+      GNU LESSER GENERAL PUBLIC LICENSE

+           Version 2.1, February 1999

+

+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.

+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ Everyone is permitted to copy and distribute verbatim copies

+ of this license document, but changing it is not allowed.

+

+[This is the first released version of the Lesser GPL.  It also counts

+ as the successor of the GNU Library Public License, version 2, hence

+ the version number 2.1.]

+

+          Preamble

+

+  The licenses for most software are designed to take away your

+freedom to share and change it.  By contrast, the GNU General Public

+Licenses are intended to guarantee your freedom to share and change

+free software--to make sure the software is free for all its users.

+

+  This license, the Lesser General Public License, applies to some

+specially designated software packages--typically libraries--of the

+Free Software Foundation and other authors who decide to use it.  You

+can use it too, but we suggest you first think carefully about whether

+this license or the ordinary General Public License is the better

+strategy to use in any particular case, based on the explanations below.

+

+  When we speak of free software, we are referring to freedom of use,

+not price.  Our General Public Licenses are designed to make sure that

+you have the freedom to distribute copies of free software (and charge

+for this service if you wish); that you receive source code or can get

+it if you want it; that you can change the software and use pieces of

+it in new free programs; and that you are informed that you can do

+these things.

+

+  To protect your rights, we need to make restrictions that forbid

+distributors to deny you these rights or to ask you to surrender these

+rights.  These restrictions translate to certain responsibilities for

+you if you distribute copies of the library or if you modify it.

+

+  For example, if you distribute copies of the library, whether gratis

+or for a fee, you must give the recipients all the rights that we gave

+you.  You must make sure that they, too, receive or can get the source

+code.  If you link other code with the library, you must provide

+complete object files to the recipients, so that they can relink them

+with the library after making changes to the library and recompiling

+it.  And you must show them these terms so they know their rights.

+

+  We protect your rights with a two-step method: (1) we copyright the

+library, and (2) we offer you this license, which gives you legal

+permission to copy, distribute and/or modify the library.

+

+  To protect each distributor, we want to make it very clear that

+there is no warranty for the free library.  Also, if the library is

+modified by someone else and passed on, the recipients should know

+that what they have is not the original version, so that the original

+author's reputation will not be affected by problems that might be

+introduced by others.

+

+  Finally, software patents pose a constant threat to the existence of

+any free program.  We wish to make sure that a company cannot

+effectively restrict the users of a free program by obtaining a

+restrictive license from a patent holder.  Therefore, we insist that

+any patent license obtained for a version of the library must be

+consistent with the full freedom of use specified in this license.

+

+  Most GNU software, including some libraries, is covered by the

+ordinary GNU General Public License.  This license, the GNU Lesser

+General Public License, applies to certain designated libraries, and

+is quite different from the ordinary General Public License.  We use

+this license for certain libraries in order to permit linking those

+libraries into non-free programs.

+

+  When a program is linked with a library, whether statically or using

+a shared library, the combination of the two is legally speaking a

+combined work, a derivative of the original library.  The ordinary

+General Public License therefore permits such linking only if the

+entire combination fits its criteria of freedom.  The Lesser General

+Public License permits more lax criteria for linking other code with

+the library.

+

+  We call this license the "Lesser" General Public License because it

+does Less to protect the user's freedom than the ordinary General

+Public License.  It also provides other free software developers Less

+of an advantage over competing non-free programs.  These disadvantages

+are the reason we use the ordinary General Public License for many

+libraries.  However, the Lesser license provides advantages in certain

+special circumstances.

+

+  For example, on rare occasions, there may be a special need to

+encourage the widest possible use of a certain library, so that it becomes

+a de-facto standard.  To achieve this, non-free programs must be

+allowed to use the library.  A more frequent case is that a free

+library does the same job as widely used non-free libraries.  In this

+case, there is little to gain by limiting the free library to free

+software only, so we use the Lesser General Public License.

+

+  In other cases, permission to use a particular library in non-free

+programs enables a greater number of people to use a large body of

+free software.  For example, permission to use the GNU C Library in

+non-free programs enables many more people to use the whole GNU

+operating system, as well as its variant, the GNU/Linux operating

+system.

+

+  Although the Lesser General Public License is Less protective of the

+users' freedom, it does ensure that the user of a program that is

+linked with the Library has the freedom and the wherewithal to run

+that program using a modified version of the Library.

+

+  The precise terms and conditions for copying, distribution and

+modification follow.  Pay close attention to the difference between a

+"work based on the library" and a "work that uses the library".  The

+former contains code derived from the library, whereas the latter must

+be combined with the library in order to run.

+

+      GNU LESSER GENERAL PUBLIC LICENSE

+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

+

+  0. This License Agreement applies to any software library or other

+program which contains a notice placed by the copyright holder or

+other authorized party saying it may be distributed under the terms of

+this Lesser General Public License (also called "this License").

+Each licensee is addressed as "you".

+

+  A "library" means a collection of software functions and/or data

+prepared so as to be conveniently linked with application programs

+(which use some of those functions and data) to form executables.

+

+  The "Library", below, refers to any such software library or work

+which has been distributed under these terms.  A "work based on the

+Library" means either the Library or any derivative work under

+copyright law: that is to say, a work containing the Library or a

+portion of it, either verbatim or with modifications and/or translated

+straightforwardly into another language.  (Hereinafter, translation is

+included without limitation in the term "modification".)

+

+  "Source code" for a work means the preferred form of the work for

+making modifications to it.  For a library, complete source code means

+all the source code for all modules it contains, plus any associated

+interface definition files, plus the scripts used to control compilation

+and installation of the library.

+

+  Activities other than copying, distribution and modification are not

+covered by this License; they are outside its scope.  The act of

+running a program using the Library is not restricted, and output from

+such a program is covered only if its contents constitute a work based

+on the Library (independent of the use of the Library in a tool for

+writing it).  Whether that is true depends on what the Library does

+and what the program that uses the Library does.

+  

+  1. You may copy and distribute verbatim copies of the Library's

+complete source code as you receive it, in any medium, provided that

+you conspicuously and appropriately publish on each copy an

+appropriate copyright notice and disclaimer of warranty; keep intact

+all the notices that refer to this License and to the absence of any

+warranty; and distribute a copy of this License along with the

+Library.

+

+  You may charge a fee for the physical act of transferring a copy,

+and you may at your option offer warranty protection in exchange for a

+fee.

+

+  2. You may modify your copy or copies of the Library or any portion

+of it, thus forming a work based on the Library, and copy and

+distribute such modifications or work under the terms of Section 1

+above, provided that you also meet all of these conditions:

+

+    a) The modified work must itself be a software library.

+

+    b) You must cause the files modified to carry prominent notices

+    stating that you changed the files and the date of any change.

+

+    c) You must cause the whole of the work to be licensed at no

+    charge to all third parties under the terms of this License.

+

+    d) If a facility in the modified Library refers to a function or a

+    table of data to be supplied by an application program that uses

+    the facility, other than as an argument passed when the facility

+    is invoked, then you must make a good faith effort to ensure that,

+    in the event an application does not supply such function or

+    table, the facility still operates, and performs whatever part of

+    its purpose remains meaningful.

+

+    (For example, a function in a library to compute square roots has

+    a purpose that is entirely well-defined independent of the

+    application.  Therefore, Subsection 2d requires that any

+    application-supplied function or table used by this function must

+    be optional: if the application does not supply it, the square

+    root function must still compute square roots.)

+

+These requirements apply to the modified work as a whole.  If

+identifiable sections of that work are not derived from the Library,

+and can be reasonably considered independent and separate works in

+themselves, then this License, and its terms, do not apply to those

+sections when you distribute them as separate works.  But when you

+distribute the same sections as part of a whole which is a work based

+on the Library, the distribution of the whole must be on the terms of

+this License, whose permissions for other licensees extend to the

+entire whole, and thus to each and every part regardless of who wrote

+it.

+

+Thus, it is not the intent of this section to claim rights or contest

+your rights to work written entirely by you; rather, the intent is to

+exercise the right to control the distribution of derivative or

+collective works based on the Library.

+

+In addition, mere aggregation of another work not based on the Library

+with the Library (or with a work based on the Library) on a volume of

+a storage or distribution medium does not bring the other work under

+the scope of this License.

+

+  3. You may opt to apply the terms of the ordinary GNU General Public

+License instead of this License to a given copy of the Library.  To do

+this, you must alter all the notices that refer to this License, so

+that they refer to the ordinary GNU General Public License, version 2,

+instead of to this License.  (If a newer version than version 2 of the

+ordinary GNU General Public License has appeared, then you can specify

+that version instead if you wish.)  Do not make any other change in

+these notices.

+

+  Once this change is made in a given copy, it is irreversible for

+that copy, so the ordinary GNU General Public License applies to all

+subsequent copies and derivative works made from that copy.

+

+  This option is useful when you wish to copy part of the code of

+the Library into a program that is not a library.

+

+  4. You may copy and distribute the Library (or a portion or

+derivative of it, under Section 2) in object code or executable form

+under the terms of Sections 1 and 2 above provided that you accompany

+it with the complete corresponding machine-readable source code, which

+must be distributed under the terms of Sections 1 and 2 above on a

+medium customarily used for software interchange.

+

+  If distribution of object code is made by offering access to copy

+from a designated place, then offering equivalent access to copy the

+source code from the same place satisfies the requirement to

+distribute the source code, even though third parties are not

+compelled to copy the source along with the object code.

+

+  5. A program that contains no derivative of any portion of the

+Library, but is designed to work with the Library by being compiled or

+linked with it, is called a "work that uses the Library".  Such a

+work, in isolation, is not a derivative work of the Library, and

+therefore falls outside the scope of this License.

+

+  However, linking a "work that uses the Library" with the Library

+creates an executable that is a derivative of the Library (because it

+contains portions of the Library), rather than a "work that uses the

+library".  The executable is therefore covered by this License.

+Section 6 states terms for distribution of such executables.

+

+  When a "work that uses the Library" uses material from a header file

+that is part of the Library, the object code for the work may be a

+derivative work of the Library even though the source code is not.

+Whether this is true is especially significant if the work can be

+linked without the Library, or if the work is itself a library.  The

+threshold for this to be true is not precisely defined by law.

+

+  If such an object file uses only numerical parameters, data

+structure layouts and accessors, and small macros and small inline

+functions (ten lines or less in length), then the use of the object

+file is unrestricted, regardless of whether it is legally a derivative

+work.  (Executables containing this object code plus portions of the

+Library will still fall under Section 6.)

+

+  Otherwise, if the work is a derivative of the Library, you may

+distribute the object code for the work under the terms of Section 6.

+Any executables containing that work also fall under Section 6,

+whether or not they are linked directly with the Library itself.

+

+  6. As an exception to the Sections above, you may also combine or

+link a "work that uses the Library" with the Library to produce a

+work containing portions of the Library, and distribute that work

+under terms of your choice, provided that the terms permit

+modification of the work for the customer's own use and reverse

+engineering for debugging such modifications.

+

+  You must give prominent notice with each copy of the work that the

+Library is used in it and that the Library and its use are covered by

+this License.  You must supply a copy of this License.  If the work

+during execution displays copyright notices, you must include the

+copyright notice for the Library among them, as well as a reference

+directing the user to the copy of this License.  Also, you must do one

+of these things:

+

+    a) Accompany the work with the complete corresponding

+    machine-readable source code for the Library including whatever

+    changes were used in the work (which must be distributed under

+    Sections 1 and 2 above); and, if the work is an executable linked

+    with the Library, with the complete machine-readable "work that

+    uses the Library", as object code and/or source code, so that the

+    user can modify the Library and then relink to produce a modified

+    executable containing the modified Library.  (It is understood

+    that the user who changes the contents of definitions files in the

+    Library will not necessarily be able to recompile the application

+    to use the modified definitions.)

+

+    b) Use a suitable shared library mechanism for linking with the

+    Library.  A suitable mechanism is one that (1) uses at run time a

+    copy of the library already present on the user's computer system,

+    rather than copying library functions into the executable, and (2)

+    will operate properly with a modified version of the library, if

+    the user installs one, as long as the modified version is

+    interface-compatible with the version that the work was made with.

+

+    c) Accompany the work with a written offer, valid for at

+    least three years, to give the same user the materials

+    specified in Subsection 6a, above, for a charge no more

+    than the cost of performing this distribution.

+

+    d) If distribution of the work is made by offering access to copy

+    from a designated place, offer equivalent access to copy the above

+    specified materials from the same place.

+

+    e) Verify that the user has already received a copy of these

+    materials or that you have already sent this user a copy.

+

+  For an executable, the required form of the "work that uses the

+Library" must include any data and utility programs needed for

+reproducing the executable from it.  However, as a special exception,

+the materials to be distributed need not include anything that is

+normally distributed (in either source or binary form) with the major

+components (compiler, kernel, and so on) of the operating system on

+which the executable runs, unless that component itself accompanies

+the executable.

+

+  It may happen that this requirement contradicts the license

+restrictions of other proprietary libraries that do not normally

+accompany the operating system.  Such a contradiction means you cannot

+use both them and the Library together in an executable that you

+distribute.

+

+  7. You may place library facilities that are a work based on the

+Library side-by-side in a single library together with other library

+facilities not covered by this License, and distribute such a combined

+library, provided that the separate distribution of the work based on

+the Library and of the other library facilities is otherwise

+permitted, and provided that you do these two things:

+

+    a) Accompany the combined library with a copy of the same work

+    based on the Library, uncombined with any other library

+    facilities.  This must be distributed under the terms of the

+    Sections above.

+

+    b) Give prominent notice with the combined library of the fact

+    that part of it is a work based on the Library, and explaining

+    where to find the accompanying uncombined form of the same work.

+

+  8. You may not copy, modify, sublicense, link with, or distribute

+the Library except as expressly provided under this License.  Any

+attempt otherwise to copy, modify, sublicense, link with, or

+distribute the Library is void, and will automatically terminate your

+rights under this License.  However, parties who have received copies,

+or rights, from you under this License will not have their licenses

+terminated so long as such parties remain in full compliance.

+

+  9. You are not required to accept this License, since you have not

+signed it.  However, nothing else grants you permission to modify or

+distribute the Library or its derivative works.  These actions are

+prohibited by law if you do not accept this License.  Therefore, by

+modifying or distributing the Library (or any work based on the

+Library), you indicate your acceptance of this License to do so, and

+all its terms and conditions for copying, distributing or modifying

+the Library or works based on it.

+

+  10. Each time you redistribute the Library (or any work based on the

+Library), the recipient automatically receives a license from the

+original licensor to copy, distribute, link with or modify the Library

+subject to these terms and conditions.  You may not impose any further

+restrictions on the recipients' exercise of the rights granted herein.

+You are not responsible for enforcing compliance by third parties with

+this License.

+

+  11. If, as a consequence of a court judgment or allegation of patent

+infringement or for any other reason (not limited to patent issues),

+conditions are imposed on you (whether by court order, agreement or

+otherwise) that contradict the conditions of this License, they do not

+excuse you from the conditions of this License.  If you cannot

+distribute so as to satisfy simultaneously your obligations under this

+License and any other pertinent obligations, then as a consequence you

+may not distribute the Library at all.  For example, if a patent

+license would not permit royalty-free redistribution of the Library by

+all those who receive copies directly or indirectly through you, then

+the only way you could satisfy both it and this License would be to

+refrain entirely from distribution of the Library.

+

+If any portion of this section is held invalid or unenforceable under any

+particular circumstance, the balance of the section is intended to apply,

+and the section as a whole is intended to apply in other circumstances.

+

+It is not the purpose of this section to induce you to infringe any

+patents or other property right claims or to contest validity of any

+such claims; this section has the sole purpose of protecting the

+integrity of the free software distribution system which is

+implemented by public license practices.  Many people have made

+generous contributions to the wide range of software distributed

+through that system in reliance on consistent application of that

+system; it is up to the author/donor to decide if he or she is willing

+to distribute software through any other system and a licensee cannot

+impose that choice.

+

+This section is intended to make thoroughly clear what is believed to

+be a consequence of the rest of this License.

+

+  12. If the distribution and/or use of the Library is restricted in

+certain countries either by patents or by copyrighted interfaces, the

+original copyright holder who places the Library under this License may add

+an explicit geographical distribution limitation excluding those countries,

+so that distribution is permitted only in or among countries not thus

+excluded.  In such case, this License incorporates the limitation as if

+written in the body of this License.

+

+  13. The Free Software Foundation may publish revised and/or new

+versions of the Lesser General Public License from time to time.

+Such new versions will be similar in spirit to the present version,

+but may differ in detail to address new problems or concerns.

+

+Each version is given a distinguishing version number.  If the Library

+specifies a version number of this License which applies to it and

+"any later version", you have the option of following the terms and

+conditions either of that version or of any later version published by

+the Free Software Foundation.  If the Library does not specify a

+license version number, you may choose any version ever published by

+the Free Software Foundation.

+

+  14. If you wish to incorporate parts of the Library into other free

+programs whose distribution conditions are incompatible with these,

+write to the author to ask for permission.  For software which is

+copyrighted by the Free Software Foundation, write to the Free

+Software Foundation; we sometimes make exceptions for this.  Our

+decision will be guided by the two goals of preserving the free status

+of all derivatives of our free software and of promoting the sharing

+and reuse of software generally.

+

+          NO WARRANTY

+

+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO

+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.

+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR

+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY

+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE

+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE

+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME

+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

+

+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN

+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY

+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU

+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR

+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE

+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING

+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A

+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF

+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

+DAMAGES.

+

+         END OF TERMS AND CONDITIONS

+

+           How to Apply These Terms to Your New Libraries

+

+  If you develop a new library, and you want it to be of the greatest

+possible use to the public, we recommend making it free software that

+everyone can redistribute and change.  You can do so by permitting

+redistribution under these terms (or, alternatively, under the terms of the

+ordinary General Public License).

+

+  To apply these terms, attach the following notices to the library.  It is

+safest to attach them to the start of each source file to most effectively

+convey the exclusion of warranty; and each file should have at least the

+"copyright" line and a pointer to where the full notice is found.

+

+    <one line to give the library's name and a brief idea of what it does.>

+    Copyright (C) <year>  <name of author>

+

+    This library is free software; you can redistribute it and/or

+    modify it under the terms of the GNU Lesser General Public

+    License as published by the Free Software Foundation; either

+    version 2.1 of the License, or (at your option) any later version.

+

+    This library is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+    Lesser General Public License for more details.

+

+    You should have received a copy of the GNU Lesser General Public

+    License along with this library; if not, write to the Free Software

+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+

+Also add information on how to contact you by electronic and paper mail.

+

+You should also get your employer (if you work as a programmer) or your

+school, if any, to sign a "copyright disclaimer" for the library, if

+necessary.  Here is a sample; alter the names:

+

+  Yoyodyne, Inc., hereby disclaims all copyright interest in the

+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.

+

+  <signature of Ty Coon>, 1 April 1990

+  Ty Coon, President of Vice

+

+That's all there is to it!

+

+

diff --git a/util/cbfstool/tools/lzma/C/ORIGIN b/util/cbfstool/tools/lzma/C/ORIGIN
new file mode 100644
index 0000000000..d631056762
--- /dev/null
+++ b/util/cbfstool/tools/lzma/C/ORIGIN
@@ -0,0 +1,3 @@
+The contents of this directory are extracted from
+the official LZMA SDK, version lzma442.tar.bz2 ,
+for the use in mkccbfs.
diff --git a/util/cbfstool/tools/lzma/Makefile b/util/cbfstool/tools/lzma/Makefile
new file mode 100644
index 0000000000..9ac4ca2ff6
--- /dev/null
+++ b/util/cbfstool/tools/lzma/Makefile
@@ -0,0 +1,50 @@
+##
+## This file is part of the coreboot project.
+##
+## Copyright (C) 2007 coresystems GmbH
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 2 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+##
+
+LZMA_OBJ := lzma/LZMAEncoder.o lzma/LZInWindow.o
+LZMA_OBJ += lzma/RangeCoderBit.o lzma/StreamUtils.o
+LZMA_OBJ += lzma/OutBuffer.o lzma/Alloc.o
+LZMA_OBJ += lzma/CRC.o
+LZMA_OBJ += lzma/lzma-compress.o
+
+$(tobj)/lzma/lzma-compress.o: $(tsrc)/lzma/minilzma.cc
+	$(CXX) $(CFLAGS) -o $@ -c -DCOMPACT $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/LZMA/%.cpp
+	$(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/LZ/%.cpp
+	$(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Compress/RangeCoder/%.cpp
+	$(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Decompress/%.cpp
+	$(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/7zip/Common/%.cpp
+	$(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/C/Common/%.cpp
+	$(CXX) $(CFLAGS) -o $@ -c $<
+
+$(tobj)/lzma/%.o: $(tsrc)/lzma/%.cc
+	$(CXX) $(CFLAGS) -o $@ -c $<
+
diff --git a/util/cbfstool/tools/lzma/minilzma.cc b/util/cbfstool/tools/lzma/minilzma.cc
new file mode 100644
index 0000000000..7610910a19
--- /dev/null
+++ b/util/cbfstool/tools/lzma/minilzma.cc
@@ -0,0 +1,318 @@
+/*
+ * minimal lzma implementation
+ *
+ * Copyright (C) 2002 Eric Biederman
+ * Copyright (C) 2005 Joel Yliluoma
+ * Copyright (C) 2007 coresystems GmbH
+ * (Adapted by Stefan Reinauer <stepan@coresystems.de> for coresystems GmbH)
+ * Copyright (C) 2007 Patrick Georgi <patrick@georgi-clan.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include "C/Common/MyInitGuid.h"
+#include "C/7zip/Compress/LZMA/LZMAEncoder.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <cctype>
+
+#include <vector>
+#include <algorithm>
+#include <stdint.h>
+
+const std::vector<unsigned char> LZMACompress
+    (const std::vector<unsigned char>& buf);
+
+const std::vector<unsigned char> LZMADeCompress
+    (const std::vector<unsigned char>& buf);
+
+static inline uint16_t R16(const void* p)
+{
+    const unsigned char* data = (const unsigned char*)p;
+    return (data[0] << 0)  | (data[1] << 8);
+}
+static inline uint32_t R32(const void* p)
+{
+    const unsigned char* data = (const unsigned char*)p;
+    return R16(data) | (R16(data+2) << 16);
+}
+
+#define L (uint64_t)
+
+static inline uint64_t R64(const void* p)
+{
+    const unsigned char* data = (const unsigned char*)p;
+    return (L R32(data)) | ((L R32(data+4)) << 32);
+}
+
+#undef L
+
+static UInt32 SelectDictionarySizeFor(unsigned datasize)
+{
+   #if 1
+    return datasize;
+   #else
+#ifdef __GNUC__
+    /* gnu c can optimize this switch statement into a fast binary
+     * search, but it cannot do so for the list of the if statements.
+     */
+    switch(datasize)
+    {
+        case 0 ... 512 : return 512;
+        case 513 ... 1024: return 2048;
+        case 1025 ... 4096: return 8192;
+        case 4097 ... 16384: return 32768;
+        case 16385 ... 65536: return 528288;
+        case 65537 ... 528288: return 1048576*4;
+        case 528289 ... 786432: return 1048576*16;
+        default: return 1048576*32;
+    }
+#else
+    if(datasize <= 512) return 512;
+    if(datasize <= 1024) return 1024;
+    if(datasize <= 4096) return 4096;
+    if(datasize <= 16384) return 32768; 
+    if(datasize <= 65536) return 528288;
+    if(datasize <= 528288) return 1048576*4;
+    if(datasize <= 786432) reutrn 1048576*16;
+    return 32*1048576;
+#endif
+   #endif
+}
+
+
+class CInStreamRam: public ISequentialInStream, public CMyUnknownImp
+{
+    const std::vector<unsigned char>& input;
+    size_t Pos;
+public:
+    MY_UNKNOWN_IMP
+  
+    CInStreamRam(const std::vector<unsigned char>& buf) : input(buf), Pos(0)
+    {
+    }
+    virtual ~CInStreamRam() {}
+  
+    STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+};
+
+STDMETHODIMP CInStreamRam::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+    UInt32 remain = input.size() - Pos;
+    if (size > remain) size = remain;
+  
+    std::memcpy(data, &input[Pos], size);
+    Pos += size;
+    
+    if(processedSize != NULL) *processedSize = size;
+    
+    return S_OK;
+}
+
+class COutStreamRam: public ISequentialOutStream, public CMyUnknownImp
+{
+    std::vector<Byte> result;
+    size_t Pos;
+public:
+    MY_UNKNOWN_IMP
+    
+    COutStreamRam(): result(), Pos(0) { }
+    virtual ~COutStreamRam() { }
+    
+    void Reserve(unsigned n) { result.reserve(n); }
+    const std::vector<Byte>& Get() const { return result; }
+  
+    HRESULT WriteByte(Byte b)
+    {
+        if(Pos >= result.size()) result.resize(Pos+1);
+        result[Pos++] = b;
+        return S_OK;
+    }
+  
+    STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+STDMETHODIMP COutStreamRam::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+    if(Pos+size > result.size()) result.resize(Pos+size);
+    
+    std::memcpy(&result[Pos], data, size);
+    if(processedSize != NULL) *processedSize = size;
+    Pos += size;
+    return S_OK;
+}
+
+const std::vector<unsigned char> LZMACompress(const std::vector<unsigned char>& buf)
+{
+    if(buf.empty()) return buf;
+    
+    const UInt32 dictionarysize = SelectDictionarySizeFor(buf.size());
+    
+    NCompress::NLZMA::CEncoder *encoderSpec = new NCompress::NLZMA::CEncoder;
+    CMyComPtr<ICompressCoder> encoder = encoderSpec;
+    const PROPID propIDs[] = 
+    {
+        NCoderPropID::kAlgorithm,
+        NCoderPropID::kDictionarySize,  
+        NCoderPropID::kNumFastBytes,
+    };
+    const unsigned kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
+    PROPVARIANT properties[kNumProps];
+    properties[0].vt = VT_UI4; properties[0].ulVal = (UInt32)2;
+    properties[1].vt = VT_UI4; properties[1].ulVal = (UInt32)dictionarysize;
+    properties[2].vt = VT_UI4; properties[2].ulVal = (UInt32)64;
+
+    if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
+    {
+    Error:
+        return std::vector<unsigned char> ();
+    }
+    
+    COutStreamRam *const outStreamSpec = new COutStreamRam;
+    CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
+    CInStreamRam *const inStreamSpec = new CInStreamRam(buf);
+    CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
+    
+    outStreamSpec->Reserve(buf.size());
+
+    if (encoderSpec->WriteCoderProperties(outStream) != S_OK) goto Error;
+    
+    for (unsigned i = 0; i < 8; i++)
+    {
+        UInt64 t = (UInt64)buf.size();
+        outStreamSpec->WriteByte((Byte)((t) >> (8 * i)));
+    }
+
+    HRESULT lzmaResult = encoder->Code(inStream, outStream, 0, 0, 0);
+    if (lzmaResult != S_OK) goto Error;
+    
+    return outStreamSpec->Get();
+}
+
+#undef RC_NORMALIZE
+
+#include "C/7zip/Decompress/LzmaDecode.h"
+#include "C/7zip/Decompress/LzmaDecode.c"
+
+const std::vector<unsigned char> LZMADeCompress
+    (const std::vector<unsigned char>& buf)
+{
+    if(buf.size() <= 5+8) return std::vector<unsigned char> ();
+    
+    uint_least64_t out_sizemax = R64(&buf[5]);
+    
+    std::vector<unsigned char> result(out_sizemax);
+    
+    CLzmaDecoderState state;
+    LzmaDecodeProperties(&state.Properties, &buf[0], LZMA_PROPERTIES_SIZE);
+    state.Probs = new CProb[LzmaGetNumProbs(&state.Properties)];
+    
+    SizeT in_done;
+    SizeT out_done;
+    LzmaDecode(&state, &buf[13], buf.size()-13, &in_done,
+               &result[0], result.size(), &out_done);
+    
+    delete[] state.Probs;
+    
+    result.resize(out_done);
+    return result;
+}
+
+#ifndef COMPACT
+int main(int argc, char *argv[])
+{
+	char  *s;
+	FILE  *f, *infile, *outfile;
+	int    c;
+	
+	if (argc != 4) {
+		std::fprintf(stderr, "'lzma e file1 file2' encodes file1 into file2.\n"
+			"'lzma d file2 file1' decodes file2 into file1.\n");
+
+		return EXIT_FAILURE;
+	}
+	if (argc == 4) {
+		if ((s = argv[1], s[1] || strpbrk(s, "DEde") == NULL)
+			|| (s = argv[2], (infile  = fopen(s, "rb")) == NULL)
+			|| (s = argv[3], (outfile = fopen(s, "wb")) == NULL)) {
+			std::fprintf(stderr, "??? %s\n", s);
+			return EXIT_FAILURE;
+		}
+	}
+
+	struct stat fs;
+	int si;
+	if (fstat(fileno(infile), &fs)) {
+		std::perror(strerror(errno));
+		return EXIT_FAILURE;
+	}
+	si=fs.st_size;
+
+	char *Buf=(char *)malloc(si);
+	fread(Buf,si, 1, infile);
+
+	std::vector<unsigned char> result;
+	if (toupper(*argv[1]) == 'E') 
+		result = LZMACompress(std::vector<unsigned char>(Buf,Buf+si));
+	else	
+		result = LZMADeCompress(std::vector<unsigned char>(Buf,Buf+si));
+
+	fwrite(&result[0], result.size(), 1, outfile);
+	fclose(infile);
+	fclose(outfile);
+	return EXIT_SUCCESS;
+}
+#else
+extern "C" {
+
+/**
+ * Compress a buffer with lzma
+ * Don't copy the result back if it is too large.
+ * @param in a pointer to the buffer
+ * @param in_len the length in bytes
+ * @param out a pointer to a buffer of at least size in_len
+ * @param out_len a pointer to the compressed length of in 
+ */
+
+void do_lzma_compress(char *in, int in_len, char *out, int *out_len) {
+	std::vector<unsigned char> result;
+	result = LZMACompress(std::vector<unsigned char>(in, in + in_len));
+	*out_len = result.size();
+	if (*out_len < in_len)
+		std::memcpy(out, &result[0], *out_len);
+}
+
+void do_lzma_uncompress(char *dst, int dst_len, char *src, int src_len) {
+	std::vector<unsigned char> result;
+	result = LZMADeCompress(std::vector<unsigned char>(src, src + src_len));
+	if (result.size() <= dst_len)
+		std::memcpy(dst, &result[0], result.size());
+	else
+	{
+		fprintf(stderr, "Not copying %d bytes to %d-byte buffer!\n",
+			result.size(), dst_len);
+		exit(1);
+	}
+}
+
+}
+#endif
+
diff --git a/util/cbfstool/tools/rom-mkpayload.c b/util/cbfstool/tools/rom-mkpayload.c
new file mode 100644
index 0000000000..4466cc1254
--- /dev/null
+++ b/util/cbfstool/tools/rom-mkpayload.c
@@ -0,0 +1,269 @@
+/*
+ * rom-mkpayload
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "elf.h"
+#include <fcntl.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+
+#include "common.h"
+#include "../cbfs.h"
+
+int parse_elf(unsigned char *input, unsigned char **output, int algo,
+	      void (*compress) (char *, int, char *, int *))
+{
+	Elf32_Phdr *phdr;
+	Elf32_Ehdr *ehdr;
+	Elf32_Shdr *shdr;
+	char *header;
+	char *strtab;
+	unsigned char *sptr;
+	int headers;
+	int segments = 1;
+	int isize = 0, osize = 0;
+	int doffset = 0;
+	struct cbfs_payload_segment *segs;
+	int i;
+
+	ehdr = (Elf32_Ehdr *) input;
+	headers = ehdr->e_phnum;
+	header = (char *)ehdr;
+
+	phdr = (Elf32_Phdr *) & (header[ehdr->e_phoff]);
+	shdr = (Elf32_Shdr *) & (header[ehdr->e_shoff]);
+
+	strtab = &header[shdr[ehdr->e_shstrndx].sh_offset];
+
+	/* Count the number of headers - look for the .notes.pinfo
+	 * section */
+
+	for (i = 0; i < ehdr->e_shnum; i++) {
+		char *name;
+
+		if (i == ehdr->e_shstrndx)
+			continue;
+
+		if (shdr[i].sh_size == 0)
+			continue;
+
+		name = (char *)(strtab + shdr[i].sh_name);
+
+		if (!strcmp(name, ".note.pinfo"))
+			segments++;
+	}
+
+	/* Now, regular headers - we only care about PT_LOAD headers,
+	 * because thats what we're actually going to load
+	 */
+
+	for (i = 0; i < headers; i++) {
+		if (phdr[i].p_type != PT_LOAD)
+			continue;
+
+		/* Empty segments are never interesting */
+		if (phdr[i].p_memsz == 0)
+			continue;
+
+		isize += phdr[i].p_filesz;
+
+		segments++;
+	}
+
+	/* Allocate a block of memory to store the data in */
+
+	sptr =
+	    calloc((segments * sizeof(struct cbfs_payload_segment)) + isize,
+		   1);
+	doffset = (segments * sizeof(struct cbfs_payload_segment));
+
+	if (sptr == NULL)
+		goto err;
+
+	segs = (struct cbfs_payload_segment *)sptr;
+	segments = 0;
+
+	for (i = 0; i < ehdr->e_shnum; i++) {
+		char *name;
+
+		if (i == ehdr->e_shstrndx)
+			continue;
+
+		if (shdr[i].sh_size == 0)
+			continue;
+
+		name = (char *)(strtab + shdr[i].sh_name);
+
+		if (!strcmp(name, ".note.pinfo")) {
+			segs[segments].type = PAYLOAD_SEGMENT_PARAMS;
+			segs[segments].load_addr = 0;
+			segs[segments].len = (unsigned int)shdr[i].sh_size;
+			segs[segments].offset = doffset;
+
+			memcpy((unsigned long *)(sptr + doffset),
+			       &header[shdr[i].sh_offset], shdr[i].sh_size);
+
+			doffset += segs[segments].len;
+			osize += segs[segments].len;
+
+			segments++;
+		}
+	}
+
+	for (i = 0; i < headers; i++) {
+		if (phdr[i].p_type != PT_LOAD)
+			continue;
+
+		if (phdr[i].p_memsz == 0)
+			continue;
+
+		if (phdr[i].p_filesz == 0) {
+			segs[segments].type = PAYLOAD_SEGMENT_BSS;
+			segs[segments].load_addr =
+			    (unsigned long long)htonl(phdr[i].p_paddr);
+			segs[segments].mem_len = (unsigned int)htonl(phdr[i].p_memsz);
+			segs[segments].offset = htonl(doffset);
+
+			segments++;
+			continue;
+		}
+
+		segs[segments].type = PAYLOAD_SEGMENT_DATA;
+		segs[segments].load_addr = (unsigned int)htonl(phdr[i].p_paddr);
+		segs[segments].mem_len = (unsigned int)htonl(phdr[i].p_memsz);
+		segs[segments].compression = htonl(algo);
+		segs[segments].offset = htonl(doffset);
+
+		int len;
+		compress((char *)&header[phdr[i].p_offset],
+			 phdr[i].p_filesz,
+			 (char *)(sptr + doffset), &len);
+		segs[segments].len = htonl(len);
+
+		/* If the compressed section is larger, then use the
+		   original stuff */
+
+		if ((unsigned int)len > phdr[i].p_filesz) {
+			segs[segments].compression = 0;
+			segs[segments].len = htonl(phdr[i].p_filesz);
+
+			memcpy((char *)(sptr + doffset),
+			       &header[phdr[i].p_offset], phdr[i].p_filesz);
+		}
+
+		doffset += ntohl(segs[segments].len);
+		osize += ntohl(segs[segments].len);
+
+		segments++;
+	}
+
+	segs[segments].type = PAYLOAD_SEGMENT_ENTRY;
+	segs[segments++].load_addr = (unsigned long long)htonl(ehdr->e_entry);
+
+	*output = sptr;
+
+	return (segments * sizeof(struct cbfs_payload_segment)) + osize;
+
+err:
+	return -1;
+}
+
+int main(int argc, char **argv)
+{
+	void (*compress) (char *, int, char *, int *);
+	int algo;
+
+	char *output = NULL;
+	char *input = NULL;
+
+	unsigned char *buffer, *obuffer;
+	int size, osize;
+
+	while (1) {
+		int option_index;
+		static struct option longopt[] = {
+			{"output", 1, 0, 'o'},
+			{"lzma", 0, 0, 'l'},
+			{"nocompress", 0, 0, 'n'},
+		};
+
+		signed char ch = getopt_long(argc, argv, "o:ln",
+					     longopt, &option_index);
+
+		if (ch == -1)
+			break;
+
+		switch (ch) {
+		case 'o':
+			output = optarg;
+			break;
+		case 'l':
+			algo = CBFS_COMPRESS_LZMA;
+			break;
+		case 'n':
+			algo = CBFS_COMPRESS_NONE;
+			break;
+		default:
+			//usage();
+			return -1;
+		}
+	}
+
+	if (optind < argc)
+		input = argv[optind];
+
+	if (input == NULL || !strcmp(input, "-"))
+		buffer = file_read_to_buffer(STDIN_FILENO, &size);
+	else {
+		printf("Reading from %s\n", input);
+		buffer = file_read(input, &size);
+	}
+
+	if (!iself(buffer)) {
+		fprintf(stderr, "E:  This does not appear to be an ELF file\n");
+		return -1;
+	}
+
+	switch (algo) {
+	case CBFS_COMPRESS_NONE:
+		compress = none_compress;
+		break;
+	case CBFS_COMPRESS_LZMA:
+		compress = lzma_compress;
+		break;
+	}
+
+	osize = parse_elf(buffer, &obuffer, algo, compress);
+
+	if (osize == -1) {
+		fprintf(stderr, "E:  Error while converting the payload\n");
+		return -1;
+	}
+
+	if (output == NULL || !strcmp(output, "-"))
+		file_write_from_buffer(STDOUT_FILENO, obuffer, osize);
+	else
+		file_write(output, obuffer, osize);
+
+	return 0;
+}
diff --git a/util/cbfstool/tools/rom-mkstage.c b/util/cbfstool/tools/rom-mkstage.c
new file mode 100644
index 0000000000..ff43e774fc
--- /dev/null
+++ b/util/cbfstool/tools/rom-mkstage.c
@@ -0,0 +1,209 @@
+/*
+ * rom-mkstage
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "elf.h"
+#include <fcntl.h>
+#include <getopt.h>
+#include <sys/stat.h>
+
+#include "common.h"
+#include "../cbfs.h"
+
+int parse_elf(unsigned char *input, unsigned char **output,
+	      int mode, void (*compress) (char *, int, char *, int *))
+{
+	Elf32_Phdr *phdr;
+	Elf32_Ehdr *ehdr = (Elf32_Ehdr *) input;
+	Elf32_Shdr *shdr;
+	char *header, *buffer;
+	unsigned char *out;
+
+	int headers;
+	int i;
+	struct cbfs_stage *stage;
+	unsigned int data_start, data_end, mem_end;
+
+	headers = ehdr->e_phnum;
+	header = (char *)ehdr;
+
+	phdr = (Elf32_Phdr *) & (header[ehdr->e_phoff]);
+	shdr = (Elf32_Shdr *) & (header[ehdr->e_shoff]);
+
+	/* Now, regular headers - we only care about PT_LOAD headers,
+	 * because thats what we're actually going to load
+	 */
+
+	data_start = 0xFFFFFFFF;
+	data_end = 0;
+	mem_end = 0;
+
+	for (i = 0; i < headers; i++) {
+		unsigned int start, mend, rend;
+
+		if (phdr[i].p_type != PT_LOAD)
+			continue;
+
+		/* Empty segments are never interesting */
+		if (phdr[i].p_memsz == 0)
+			continue;
+
+		/* BSS */
+
+		start = phdr[i].p_paddr;
+
+		mend = start + phdr[i].p_memsz;
+		rend = start + phdr[i].p_filesz;
+
+		if (start < data_start)
+			data_start = start;
+
+		if (rend > data_end)
+			data_end = rend;
+
+		if (mend > mem_end)
+			mem_end = mend;
+	}
+
+	/* allocate an intermediate buffer for the data */
+	buffer = calloc(data_end - data_start, 1);
+
+	if (buffer == NULL) {
+		fprintf(stderr, "E: Unable to allocate memory: %m\n");
+		return -1;
+	}
+
+	/* Copy the file data into the buffer */
+
+	for (i = 0; i < headers; i++) {
+
+		if (phdr[i].p_type != PT_LOAD)
+			continue;
+
+		if (phdr[i].p_memsz == 0)
+			continue;
+
+		memcpy(buffer + (phdr[i].p_paddr - data_start),
+		       &header[phdr[i].p_offset], phdr[i].p_filesz);
+	}
+
+	/* Now make the output buffer */
+	out = calloc(sizeof(struct cbfs_stage) + data_end - data_start, 1);
+
+	if (out == NULL) {
+		fprintf(stderr, "E: Unable to allocate memory: %m\n");
+		return -1;
+	}
+
+	stage = (struct cbfs_stage *)out;
+
+	stage->load = data_start;
+	stage->memlen = mem_end - data_start;
+	stage->compression = mode;
+	stage->entry = ehdr->e_entry;
+
+	compress(buffer, data_end - data_start,
+		 (char *)(out + sizeof(struct cbfs_stage)),
+		 (int *)&stage->len);
+
+	*output = out;
+
+	return sizeof(struct cbfs_stage) + stage->len;
+}
+
+int main(int argc, char **argv)
+{
+	void (*compress) (char *, int, char *, int *);
+	int algo = CBFS_COMPRESS_LZMA;
+
+	char *output = NULL;
+	char *input = NULL;
+
+	unsigned char *buffer, *obuffer;
+	int size, osize;
+
+	while (1) {
+		int option_index;
+		static struct option longopt[] = {
+			{"output", 1, 0, 'o'},
+			{"lzma", 0, 0, 'l'},
+			{"nocompress", 0, 0, 'n'},
+		};
+
+		signed char ch = getopt_long(argc, argv, "o:ln",
+					     longopt, &option_index);
+
+		if (ch == -1)
+			break;
+
+		switch (ch) {
+		case 'o':
+			output = optarg;
+			break;
+		case 'l':
+			algo = CBFS_COMPRESS_LZMA;
+			break;
+		case 'n':
+			algo = CBFS_COMPRESS_NONE;
+			break;
+		default:
+			//usage();
+			return -1;
+		}
+	}
+
+	if (optind < argc)
+		input = argv[optind];
+
+	if (input == NULL || !strcmp(input, "-"))
+		buffer = file_read_to_buffer(STDIN_FILENO, &size);
+	else
+		buffer = file_read(input, &size);
+
+	if (!iself(buffer)) {
+		fprintf(stderr, "E:  The incoming file is not an ELF\n");
+		return -1;
+	}
+
+	switch (algo) {
+	case CBFS_COMPRESS_NONE:
+		compress = none_compress;
+		break;
+	case CBFS_COMPRESS_LZMA:
+		compress = lzma_compress;
+		break;
+	}
+
+	osize = parse_elf(buffer, &obuffer, algo, compress);
+
+	if (osize == -1) {
+		fprintf(stderr, "E:  Error while converting the ELF\n");
+		return -1;
+	}
+
+	if (output == NULL || !strcmp(output, "-"))
+		file_write_from_buffer(STDOUT_FILENO, obuffer, osize);
+	else
+		file_write(output, obuffer, osize);
+
+	return 0;
+}
diff --git a/util/cbfstool/types.c b/util/cbfstool/types.c
new file mode 100644
index 0000000000..88b4ea70b9
--- /dev/null
+++ b/util/cbfstool/types.c
@@ -0,0 +1,84 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <string.h>
+#include "cbfstool.h"
+
+static const struct {
+	char *type;
+	unsigned int value;
+	int (*detect) (const char *filename);
+	int (*handler) (const char *filename, const char *name);
+} component_types[] = {
+	{
+NULL, 0xFF, NULL, NULL},};
+
+int parse_type(const char *str, unsigned int *type)
+{
+	int i;
+	for (i = 0; component_types[i].type != NULL; i++) {
+		if (!strncmp(str, component_types[i].type,
+			     strlen(compoent_types[i].type))) {
+			*type = component_types[i].value;
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+int detect_type(const char *filename)
+{
+
+	int i;
+
+	for (i = 0; component_types[i].type != NULL; i++) {
+		if (component_types[i].detect &&
+		    !component_types[i].detect(filename))
+			return component_types[i].value;
+
+	}
+}
+
+int handle_type(const char *filename, int type, int *ret)
+{
+	/* Now send the file to the required handler */
+	for (i = 0; component_types[i].type != NULL; i++) {
+		if (type == component_types[i].value) {
+			*ret = component_types[i].handler(config,
+							  argv[0], argv[1]);
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+void get_type(int type, char *buffer, int len)
+{
+	for (i = 0; component_types[i].type != NULL; i++) {
+		if (type == component_types[i].value) {
+			strncpy(buffer, component_types[i].type, len - 1);
+			buffer[len - 1] = '\0';
+			return;
+		}
+	}
+
+	snprintf(buffer, len, "%x\n", type);
+}
diff --git a/util/cbfstool/util.c b/util/cbfstool/util.c
new file mode 100644
index 0000000000..51905a6d60
--- /dev/null
+++ b/util/cbfstool/util.c
@@ -0,0 +1,282 @@
+/*
+ * cbfstool
+ *
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include "cbfstool.h"
+
+int get_size(const char *size)
+{
+	char *next;
+	int val = strtoul(size, &next, 0);
+
+	/* Support modifiers for the size kK and mM for kbytes and 
+	   mbytes respectfully */
+
+	if (next != NULL) {
+		if (*next == 'k' || *next == 'K')
+			val *= 1024;
+		else if (*next == 'm' || *next == 'M')
+			val *= (1024 * 1024);
+	}
+
+	return val;
+}
+
+int copy_from_fd(int fd, void *ptr, int size)
+{
+	unsigned char *p = ptr;
+
+	while (size > 0) {
+		int ret = read(fd, p, size);
+
+		if (ret == -1) {
+			ERROR("Error while reading: %m\n");
+			return -1;
+		}
+
+		if (ret == 0) {
+			ERROR("Unexpected end of file\n");
+			return -1;
+		}
+
+		p += ret;
+		size -= ret;
+	}
+
+	return 0;
+}
+
+int size_and_open(const char *filename, unsigned int *size)
+{
+	struct stat s;
+
+	int fd = open(filename, O_RDONLY);
+
+	if (fd == -1) {
+		ERROR("Unable to open %s: %m\n", filename);
+		return -1;
+	}
+
+	if (fstat(fd, &s)) {
+		ERROR("Unable to stat %s: %m\n", filename);
+		close(fd);
+		return -1;
+	}
+
+	*size = s.st_size;
+	return fd;
+}
+
+int map_rom(struct rom *rom, int size)
+{
+	rom->ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+			rom->fd, 0);
+
+	if (rom->ptr == MAP_FAILED) {
+		ERROR("Could not map the rom: %m\n");
+		rom->ptr = NULL;
+		return -1;
+	}
+
+	return 0;
+}
+
+int open_rom(struct rom *rom, const char *filename)
+{
+	struct stat s;
+	unsigned long offset;
+
+	if (stat(filename, &s)) {
+		ERROR("Could not stat %s: %m\n", filename);
+		return -1;
+	}
+
+	rom->fd = open(filename, O_RDWR);
+
+	if (rom->fd == -1) {
+		ERROR("Could not open %s: %m\n", filename);
+		rom->fd = 0;
+		return -1;
+	}
+
+	if (map_rom(rom, s.st_size))
+		goto err;
+
+	/* Find the master header */
+
+	offset = ROM_READL(rom, s.st_size - 4);
+
+	rom->header = (struct cbfs_header *)
+	    ROM_PTR(rom, s.st_size - (0xFFFFFFFF - offset) - 1);
+
+	if (ntohl(rom->header->magic) != HEADER_MAGIC) {
+		ERROR("This does not appear to be a valid ROM\n");
+		goto err;
+	}
+
+	/* Check that the alignment is correct */
+	if (ntohl(rom->header->align) == 0) {
+		ERROR("The alignment in the ROM is 0 - probably malformed\n");
+		goto err;
+	}
+
+	/* Sanity check that the size matches the file size */
+
+	if (ntohl(rom->header->romsize) != s.st_size) {
+		ERROR("The ROM size in the header does not match the file\n");
+		ERROR("ROM size is %d bytes, file size is %d bytes\n",
+		      ntohl(rom->header->romsize), (unsigned int)s.st_size);
+		goto err;
+	}
+
+	rom->size = ntohl(rom->header->romsize);
+	rom->fssize = rom->size - ntohl(rom->header->bootblocksize);
+
+	return 0;
+
+err:
+	if (rom->ptr != NULL)
+		munmap(rom->ptr, s.st_size);
+
+	if (rom->fd > 0)
+		close(rom->fd);
+
+	rom->ptr = NULL;
+	rom->fd = 0;
+	return -1;
+}
+
+int create_rom(struct rom *rom, const unsigned char *filename,
+	       int romsize, int bootblocksize, int align)
+{
+	unsigned char null = '\0';
+
+	if (rom->fd != 0) {
+		ERROR("%s already exists - cannot create\n", filename);
+		return -1;
+	}
+
+	/* Remember the size of the entire ROM */
+	rom->size = romsize;
+
+	/* The size of the archive section is everything but the bootblock */
+	rom->fssize = romsize - bootblocksize;
+
+	/* Open the file descriptor */
+
+	rom->fd = open((char *)filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+
+	if (rom->fd == -1) {
+		ERROR("Could not create %s: %m\n", filename);
+		return -1;
+	}
+
+	/* Size the new file appropriately */
+	lseek(rom->fd, romsize - 1, SEEK_SET);
+	write(rom->fd, &null, 1);
+
+	if (map_rom(rom, romsize)) {
+		close(rom->fd);
+		return -1;
+	}
+
+	/* Clear the reset vector */
+	memset(rom->ptr + rom->size - 16, 0, 16);
+
+	ROM_WRITEL(rom, rom->size - 4,
+		   0xFFFFFFF0 - sizeof(struct cbfs_header));
+
+	/* This is a pointer to the header for easy access */
+	rom->header = (struct cbfs_header *)
+	    ROM_PTR(rom, rom->size - 16 - sizeof(struct cbfs_header));
+
+	rom->header->magic = htonl(HEADER_MAGIC);
+	rom->header->romsize = htonl(romsize);
+	rom->header->bootblocksize = htonl(bootblocksize);
+	rom->header->align = htonl(align);
+	rom->header->offset = htonl(0);
+
+	return 0;
+}
+
+int add_bootblock(struct rom *rom, const char *filename)
+{
+	unsigned int size;
+	//unsigned int offset;
+	int fd = size_and_open(filename, &size);
+	int ret;
+	struct cbfs_header tmp;
+
+	if (fd == -1)
+		return -1;
+
+	if (size > ntohl(rom->header->bootblocksize)) {
+		ERROR("The bootblock size is not correct (%d vs %d)\n",
+		      size, ntohl(rom->header->bootblocksize));
+		return -1;
+	}
+
+	/* Copy the current header into a temporary buffer */
+	memcpy(&tmp, rom->header, sizeof(struct cbfs_header));
+
+	/* Copy the bootblock into place at the end of the file */
+
+	ret = copy_from_fd(fd, ROM_PTR(rom, rom->size - ntohl(rom->header->bootblocksize)), size);
+
+	close(fd);
+
+	if (ret) {
+		ERROR("Unable to add %s to the bootblock\n", filename);
+		return -1;
+	}
+
+	/* FIXME: This should point to a location defined by coreboot */
+
+	ROM_WRITEL(rom, rom->size - 4,
+		   0xFFFFFFF0 - sizeof(struct cbfs_header));
+
+	/* This is a pointer to the header for easy access */
+	rom->header = (struct cbfs_header *)
+	    ROM_PTR(rom, rom->size - 16 - sizeof(struct cbfs_header));
+
+#if 0
+	/* Figure out the new location for the header */
+	offset = ROM_READL(rom, rom->size - 4);
+
+	rom->header = (struct cbfs_header *)
+	    ROM_PTR(rom, offset - (0xFFFFFFFF - rom->size));
+#endif
+
+	/* Replace the LAR header */
+	memcpy(rom->header, &tmp, sizeof(struct cbfs_header));
+
+	return 0;
+}
+
+int rom_exists(struct rom *rom)
+{
+	if (rom->fd <= 0)
+		return 0;
+	return 1;
+}