@@ -20,63 +20,79 @@ - Save directory of last loaded file
  - Support BPS patches
  - Automatically detect and optimize out idle loops
  - Configurable game overrides
+ - Support loading 7-Zip files
+ - Drag and drop game loading
 Bugfixes:
- - Qt: Fix issue with set frame sizes being the wrong height
- - Qt: Fix emulator crashing when full screen if a game is not running
- - GBA Thread: Allow halted games to exit cleanly
- - GBA BIOS: Fix HLE Lz77 and RL functions to properly account for width and invalid addresses
- - ARM7: Fix LDM writeback to a register already written
- - GBA Memory: Don't call into GPIO write calls if GPIO devices are absent
  - ARM7: Extend prefetch by one stage
- - GBA BIOS: Fix BIOS prefetch after returning from a SWI
- - Debugger: Negative PC-relative loads now properly subtract the offset
- - Qt: Fix window focus issues
  - GBA Audio: Support 16-bit writes to FIFO audio
- - GBA Memory: Properly initialize 1 Mb flash, and add debug logging
- - Qt: Properly set default video recording settings
- - GBA Audio: Make larger buffer sizes than 2048 actually work properly
  - GBA Audio: Audio buffer sizes are now correct sizes for both sample rates
+ - GBA BIOS: Fix BIOS prefetch after returning from an IRQ
+ - GBA BIOS: Fix BIOS prefetch after reset
+ - GBA Memory: Fix alignment of open bus 8- and 16-bit loads
+ - GBA Thread: Fix possible hang when loading an archive
+ - Perf: Fix crash when the GBA thread fails to start
+ - SDL: Properly clean up if a game doesn't launch
+ - Debugger: Disassembly now lists PSR bitmasks (fixes #191)
+Misc:
+ - GBA Audio: Change internal audio sample buffer from 32-bit to 16-bit samples
+ - GBA Memory: Simplify memory API and use fixed bus width
+ - GBA Video: Start video at the last scanline instead of the first
+ - Debugger: Watchpoints now work on STM/LDM instructions
+ - GBA: Improve accuracy of event timing
+ - Debugger: Clean up GDB stub network interfacing
+ - Debugger: Simplify debugger state machine to play nicer with the GBA thread loop
+ - Debugger: Merge Thumb BL instructions when disassembling
+ - Debugger: Clean up debugger interface, removing obsolete state (fixes #67)
+ - Debugger: Watchpoints now report address watched (fixes #68)
+
+0.1.1: (2015-01-24)
+Bugfixes:
+ - ARM7: Fix LDM writeback to a register already written
+ - GBA: Fix timers 2 and 3 updating incorrectly
+ - GBA Audio: Make larger buffer sizes than 2048 actually work properly
+ - GBA Audio: Fix GB audio channels being too quiet (fixes #159)
+ - GBA Audio: Properly initialize audio FIFO channels
+ - GBA BIOS: Fix HLE Lz77 and RL functions to properly account for width and invalid addresses
+ - GBA BIOS: Fix BIOS prefetch after returning from a SWI
+ - GBA BIOS: Fix LZ77UnCompVram to use 16-bit loads from decompressed memory
+ - GBA BIOS: Fix HuffUnComp to work when games pass an invalid bit length
+ - GBA BIOS: Fix GetBiosChecksum to return the value of a real GBA, regardless of used BIOS
+ - GBA BIOS: Fix HuffUnComp boundary conditions
+ - GBA Memory: Don't call into GPIO write calls if GPIO devices are absent
+ - GBA Memory: Properly initialize 1 Mb flash, and add debug logging
+ - GBA Memory: Filter out top nybble of DMA addresses
+ - GBA Memory: Properly bounds-check VRAM accesses
+ - GBA Memory: Fix initial DMA state
+ - GBA Thread: Allow halted games to exit cleanly
  - GBA Video: Fix blend issues with obscured middle layers
- - Video: Ensure FFmpeg encoder has audio frames
- - Video: Fix uncompressed PCM audio recording
  - GBA Video: Fix windows not disabling target 1 appropriately (fixes #161)
- - Debugger: Align PC-relative loads in Thumb
- - Debugger: Fix watchpoints triggering too late
  - GBA Video: Fix sprite mis-ordering behavior in some cases (fixes #168)
  - GBA Video: Fix window interactions with 16-color mode 0 mosaic
  - GBA Video: Fix sprite boundary conditions with mosaic
- - Video: Fix FFmpeg crashing when the file extension is wrong
- - GBA Audio: Fix GB audio channels being too quiet (fixes #159)
+ - GBA Video: Fix mode 0 being able to read tiles above appropriate tile range
+ - Qt: Fix issue with set frame sizes being the wrong height
+ - Qt: Fix emulator crashing when full screen if a game is not running
+ - Qt: Fix window focus issues
+ - Qt: Properly set default video recording settings
  - Qt: Fix a race condition when a game crashes immediately
  - Qt: Fix some cases where key mapping can break if focus is adjusted
- - GBA Memory: Filter out top nybble of DMA addresses
+ - Qt: Fix crash if a game pauses before any frames are shown
+ - Debugger: Negative PC-relative loads now properly subtract the offset
+ - Debugger: Align PC-relative loads in Thumb
+ - Debugger: Fix watchpoints triggering too late
  - Debugger: Fix binary print putting spaces between digits
- - GBA BIOS: Fix LZ77UnCompVram to use 16-bit loads from decompressed memory
- - GBA BIOS: Fix HuffUnComp to work when games pass an invalid bit length
- - GBA BIOS: Fix GetBiosChecksum to return the value of a real GBA, regardless of used BIOS
- - GBA Memory: Properly bounds-check VRAM accesses
- - GBA Memory: Fix initial DMA state
- - GBA BIOS: Fix BIOS prefetch after returning from an IRQ
- - GBA BIOS: Fix BIOS prefetch after reset
- - GBA Memory: Fix alignment of open bus 8- and 16-bit loads
- - GBA BIOS: Fix HuffUnComp boundary conditions
- - GBA Video: Fix mode 0 being able to read tiles above appropriate tile range
- - GBA Audio: Properly initialize audio FIFO channels
+ - Video: Ensure FFmpeg encoder has audio frames
+ - Video: Fix uncompressed PCM audio recording
+ - Video: Fix FFmpeg crashing when the file extension is wrong
  - Util: Fix SOCKET_FAILED macro
 Misc:
- - Qt: Disable sync to video by default
  - GBA: Exit cleanly on FATAL if the port supports it
+ - GBA Memory: Implement 16- and 32-bit loads from SRAM
+ - Qt: Disable sync to video by default
  - Qt: Handle a game crash without crashing
- - GBA Audio: Change internal audio sample buffer from 32-bit to 16-bit samples
  - Qt: Set default log level to FATAL, ERROR and WARN
  - Qt: Clarify some phrasing in the menus
- - GBA Memory: Implement 16- and 32-bit loads from SRAM
  - Qt: Clear active buttons when focus is lost
- - GBA Memory: Simplify memory API and use fixed bus width
- - GBA Video: Start video at the last scanline instead of the first
- - Debugger: Watchpoints now work on STM/LDM instructions
- - GBA: Improve accuracy of event timing
- - Debugger: Clean up GDB stub network interfacing
 
 0.1.0: (2014-12-13)
  - Initial release

@@ -9,6 +9,7 @@ set(USE_PNG ON CACHE BOOL "Whether or not to enable PNG support")
 set(USE_LIBZIP ON CACHE BOOL "Whether or not to enable ZIP support")
 set(USE_MAGICK ON CACHE BOOL "Whether or not to enable ImageMagick support")
 set(USE_BLIP ON CACHE BOOL "Whether or not to enable blip_buf support")
+set(USE_LZMA ON CACHE BOOL "Whether or not to enable 7-Zip support")
 set(BUILD_QT ON CACHE BOOL "Build Qt frontend")
 set(BUILD_SDL ON CACHE BOOL "Build SDL frontend")
 set(BUILD_PERF OFF CACHE BOOL "Build performance profiling tool")
@@ -204,6 +205,32 @@ add_definitions(-DENABLE_LIBZIP)
 	set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS},libzip2")
 endif()
 
+if (USE_LZMA)
+	include_directories(AFTER ${CMAKE_SOURCE_DIR}/third-party/lzma)
+	add_definitions(-D_7ZIP_PPMD_SUPPPORT)
+	set(LZMA_SRC
+		${CMAKE_SOURCE_DIR}/src/util/vfs/vfs-lzma.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zAlloc.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zArcIn.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zBuf.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zBuf2.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zCrc.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zCrcOpt.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zDec.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/CpuArch.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/LzmaDec.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/Lzma2Dec.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/Bra.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/Bra86.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/Bcj2.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/Ppmd7.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/Ppmd7Dec.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zFile.c
+		${CMAKE_SOURCE_DIR}/src/third-party/lzma/7zStream.c)
+	list(APPEND UTIL_SRC ${LZMA_SRC})
+	add_definitions(-DENABLE_LZMA)
+endif()
+
 # Binaries
 add_library(${BINARY_NAME} SHARED
 	${ARM_SRC}
@@ -263,6 +290,7 @@ message(STATUS "	Video recording: ${USE_FFMPEG}")
 message(STATUS "	GIF recording: ${USE_MAGICK}")
 message(STATUS "	Screenshot/advanced savestate support: ${USE_PNG}")
 message(STATUS "	ZIP support: ${USE_LIBZIP}")
+message(STATUS "	7-Zip support: ${USE_LZMA}")
 message(STATUS "	Better audio resampling: ${USE_BLIP}")
 message(STATUS "Frontend summary:")
 message(STATUS "	Qt: ${BUILD_QT}")

@@ -20,8 +20,8 @@ - Screenshot support.
 - 9 savestate slots. Savestates are also viewable as screenshots.
 - Video and GIF recording.
 - Remappable controls for both keyboards and gamepads.
-- Loading from ZIP files.
-- IPS and UPS patch support.
+- Loading from ZIP and 7z files.
+- IPS, UPS and BPS patch support.
 - Game debugging via a command-line interface (not available with Qt port) and GDB remote support.
 - Configurable emulation rewinding.
 
@@ -99,7 +99,7 @@ <a name="missing">[1]</a> Currently missing features are
 
 - OBJ window for modes 3, 4 and 5 ([Bug #5](https://endrift.com/mgba/bugs/show_bug.cgi?id=5))
 - Mosaic for transformed OBJs ([Bug #9](https://endrift.com/mgba/bugs/show_bug.cgi?id=9))
-- BIOS call RegisterRamReset is currently stubbed out ([Bug #141](https://endrift.com/mgba/bugs/show_bug.cgi?id=141))
+- BIOS call RegisterRamReset is partially stubbed out ([Bug #141](https://endrift.com/mgba/bugs/show_bug.cgi?id=141))
 - Audio channel reset flags ([Bug #142](https://endrift.com/mgba/bugs/show_bug.cgi?id=142))
 
 <a name="flashdetect">[2]</a> Flash memory size detection does not work in some cases, and may require overrides, which are not yet user configurable. Filing a bug is recommended if such a case is encountered.
@@ -112,6 +112,6 @@
 Copyright
 ---------
 
-mGBA is Copyright © 2013 – 2014 Jeffrey Pfau. It is distributed under the [Mozilla Public License version 2.0](https://www.mozilla.org/MPL/2.0/). A copy of the license is available in the distributed LICENSE file.
+mGBA is Copyright © 2013 – 2015 Jeffrey Pfau. It is distributed under the [Mozilla Public License version 2.0](https://www.mozilla.org/MPL/2.0/). A copy of the license is available in the distributed LICENSE file.
 
 mGBA contains [inih](https://code.google.com/p/inih/), which is copyright © 2009 Brush Technology and used under a BSD 3-clause license; and [blip-buf](https://code.google.com/p/blip-buf/), which is copyright © 2003 – 2009 Shay Green and used under a Lesser GNU Public License.

@@ -386,6 +386,7 @@
 DEFINE_DECODER_ARM(MSR, MSR,
 	info->affectsCPSR = 1;
 	info->op1.reg = ARM_CPSR;
+	info->op1.psrBits = (opcode >> 16) & ARM_PSR_MASK;
 	info->op2.reg = opcode & 0x0000000F;
 	info->operandFormat = ARM_OPERAND_REGISTER_1 |
 		ARM_OPERAND_AFFECTED_1 |
@@ -393,42 +394,45 @@ ARM_OPERAND_REGISTER_2;)
 
 DEFINE_DECODER_ARM(MSRR, MSR,
 	info->op1.reg = ARM_SPSR;
+	info->op1.psrBits = (opcode >> 16) & ARM_PSR_MASK;
 	info->op2.reg = opcode & 0x0000000F;
 	info->operandFormat = ARM_OPERAND_REGISTER_1 |
 		ARM_OPERAND_AFFECTED_1 |
 		ARM_OPERAND_REGISTER_2;)
 
-DEFINE_DECODER_ARM(MRS, MRS, info->affectsCPSR = 1;
+DEFINE_DECODER_ARM(MRS, MRS,
 	info->affectsCPSR = 1;
 	info->op1.reg = (opcode >> 12) & 0xF;
 	info->op2.reg = ARM_CPSR;
+	info->op2.psrBits = 0;
 	info->operandFormat = ARM_OPERAND_REGISTER_1 |
 		ARM_OPERAND_AFFECTED_1 |
 		ARM_OPERAND_REGISTER_2;)
 
-DEFINE_DECODER_ARM(MRSR, MRS, info->affectsCPSR = 1;
-	info->affectsCPSR = 1;
+DEFINE_DECODER_ARM(MRSR, MRS,
 	info->op1.reg = (opcode >> 12) & 0xF;
 	info->op2.reg = ARM_SPSR;
+	info->op2.psrBits = 0;
 	info->operandFormat = ARM_OPERAND_REGISTER_1 |
 		ARM_OPERAND_AFFECTED_1 |
 		ARM_OPERAND_REGISTER_2;)
 
-DEFINE_DECODER_ARM(MSRI, MSR, info->affectsCPSR = 1;
+DEFINE_DECODER_ARM(MSRI, MSR,
 	int rotate = (opcode & 0x00000F00) >> 7;
 	int32_t operand = ROR(opcode & 0x000000FF, rotate);
 	info->affectsCPSR = 1;
 	info->op1.reg = ARM_CPSR;
+	info->op1.psrBits = (opcode >> 16) & ARM_PSR_MASK;
 	info->op2.immediate = operand;
 	info->operandFormat = ARM_OPERAND_REGISTER_1 |
 		ARM_OPERAND_AFFECTED_1 |
 		ARM_OPERAND_IMMEDIATE_2;)
 
-DEFINE_DECODER_ARM(MSRRI, MSR, info->affectsCPSR = 1;
+DEFINE_DECODER_ARM(MSRRI, MSR,
 	int rotate = (opcode & 0x00000F00) >> 7;
 	int32_t operand = ROR(opcode & 0x000000FF, rotate);
-	info->affectsCPSR = 1;
 	info->op1.reg = ARM_SPSR;
+	info->op1.psrBits = (opcode >> 16) & ARM_PSR_MASK;
 	info->op2.immediate = operand;
 	info->operandFormat = ARM_OPERAND_REGISTER_1 |
 		ARM_OPERAND_AFFECTED_1 |

@@ -290,14 +290,21 @@ info->op1.immediate = (((int32_t) immediate) >> 4);
 	info->operandFormat = ARM_OPERAND_IMMEDIATE_1;
 	info->branchType = ARM_BRANCH;)
 
-DEFINE_THUMB_DECODER(BL1, BLH,
+DEFINE_THUMB_DECODER(BL1, BL,
 	int16_t immediate = (opcode & 0x07FF) << 5;
-	info->op1.immediate = (((int32_t) immediate) << 7);
-	info->operandFormat = ARM_OPERAND_IMMEDIATE_1;)
+	info->op1.reg = ARM_LR;
+	info->op2.reg = ARM_PC;
+	info->op3.immediate = (((int32_t) immediate) << 7);
+	info->operandFormat = ARM_OPERAND_REGISTER_1 | ARM_OPERAND_AFFECTED_1 |
+		ARM_OPERAND_REGISTER_2 | ARM_OPERAND_AFFECTED_2 |
+		ARM_OPERAND_IMMEDIATE_3;)
 
 DEFINE_THUMB_DECODER(BL2, BL,
-	info->op1.immediate = (opcode & 0x07FF) << 1;
-	info->operandFormat = ARM_OPERAND_IMMEDIATE_1;
+	info->op1.reg = ARM_PC;
+	info->op2.reg = ARM_LR;
+	info->op3.immediate = (opcode & 0x07FF) << 1;
+	info->operandFormat = ARM_OPERAND_REGISTER_1 | ARM_OPERAND_AFFECTED_1 |
+		ARM_OPERAND_REGISTER_2 | ARM_OPERAND_IMMEDIATE_3;
 	info->branchType = ARM_BRANCH_LINKED;)
 
 DEFINE_THUMB_DECODER(BX, BX,
@@ -332,3 +339,33 @@ info->cCycles = 0;
 	ThumbDecoder decoder = _thumbDecoderTable[opcode >> 6];
 	decoder(opcode, info);
 }
+
+bool ARMDecodeThumbCombine(struct ARMInstructionInfo* info1, struct ARMInstructionInfo* info2, struct ARMInstructionInfo* out) {
+	if (info1->execMode != MODE_THUMB || info1->mnemonic != ARM_MN_BL) {
+		return false;
+	}
+	if (info2->execMode != MODE_THUMB || info2->mnemonic != ARM_MN_BL) {
+		return false;
+	}
+	if (info1->op1.reg != ARM_LR || info1->op2.reg != ARM_PC) {
+		return false;
+	}
+	if (info2->op1.reg != ARM_PC || info2->op2.reg != ARM_LR) {
+		return false;
+	}
+	out->op1.immediate = info1->op3.immediate | info2->op3.immediate;
+	out->operandFormat = ARM_OPERAND_IMMEDIATE_1;
+	out->execMode = MODE_THUMB;
+	out->mnemonic = ARM_MN_BL;
+	out->branchType = ARM_BRANCH_LINKED;
+	out->traps = 0;
+	out->affectsCPSR = 0;
+	out->condition = ARM_CONDITION_AL;
+	out->sDataCycles = 0;
+	out->nDataCycles = 0;
+	out->sInstructionCycles = 2;
+	out->nInstructionCycles = 0;
+	out->iCycles = 0;
+	out->cCycles = 0;
+	return true;
+}

@@ -18,6 +18,7 @@ blen -= AMOUNT;
 
 static int _decodeRegister(int reg, char* buffer, int blen);
 static int _decodeRegisterList(int list, char* buffer, int blen);
+static int _decodePSR(int bits, char* buffer, int blen);
 static int _decodePCRelative(uint32_t address, uint32_t pc, char* buffer, int blen);
 static int _decodeMemory(struct ARMMemoryAccess memory, int pc, char* buffer, int blen);
 static int _decodeShift(union ARMOperand operand, bool reg, char* buffer, int blen);
@@ -113,6 +114,32 @@ ADVANCE(1);
 	return total;
 }
 
+static int _decodePSR(int psrBits, char* buffer, int blen) {
+	if (!psrBits) {
+		return 0;
+	}
+	int total = 0;
+	strncpy(buffer, "_", blen - 1);
+	ADVANCE(1);
+	if (psrBits & ARM_PSR_C) {
+		strncpy(buffer, "c", blen - 1);
+		ADVANCE(1);
+	}
+	if (psrBits & ARM_PSR_X) {
+		strncpy(buffer, "x", blen - 1);
+		ADVANCE(1);
+	}
+	if (psrBits & ARM_PSR_S) {
+		strncpy(buffer, "s", blen - 1);
+		ADVANCE(1);
+	}
+	if (psrBits & ARM_PSR_F) {
+		strncpy(buffer, "f", blen - 1);
+		ADVANCE(1);
+	}
+	return total;
+}
+
 static int _decodePCRelative(uint32_t address, uint32_t pc, char* buffer, int blen) {
 	return snprintf(buffer, blen - 1, "$%08X", address + pc);
 }
@@ -223,7 +250,6 @@ "b",
 	"bic",
 	"bkpt",
 	"bl",
-	"blh",
 	"bx",
 	"cmn",
 	"cmp",
@@ -355,8 +381,11 @@ ADVANCE(1);
 		}
 		break;
 	case ARM_MN_B:
-		written = _decodePCRelative(info->op1.immediate, pc, buffer, blen);
-		ADVANCE(written);
+	case ARM_MN_BL:
+		if (info->operandFormat & ARM_OPERAND_IMMEDIATE_1) {
+			written = _decodePCRelative(info->op1.immediate, pc, buffer, blen);
+			ADVANCE(written);
+		}
 		break;
 	default:
 		if (info->operandFormat & ARM_OPERAND_IMMEDIATE_1) {
@@ -368,6 +397,10 @@ ADVANCE(written);
 		} else if (info->operandFormat & ARM_OPERAND_REGISTER_1) {
 			written = _decodeRegister(info->op1.reg, buffer, blen);
 			ADVANCE(written);
+			if (info->op1.reg > ARM_PC) {
+				written = _decodePSR(info->op1.psrBits, buffer, blen);
+				ADVANCE(written);
+			}
 		}
 		if (info->operandFormat & ARM_OPERAND_SHIFT_REGISTER_1) {
 			written = _decodeShift(info->op1, true, buffer, blen);

@@ -62,6 +62,12 @@ #define ARM_MEMORY_DECREMENT_BEFORE  0x0200
 #define ARM_MEMORY_INCREMENT_BEFORE  0x0300
 #define ARM_MEMORY_SPSR_SWAP         0x0400
 
+#define ARM_PSR_C 1
+#define ARM_PSR_X 2
+#define ARM_PSR_S 4
+#define ARM_PSR_F 8
+#define ARM_PSR_MASK 0xF
+
 #define MEMORY_FORMAT_TO_DIRECTION(F) (((F) >> 8) & 0x3)
 
 enum ARMCondition {
@@ -99,6 +105,7 @@ uint8_t shifterOp;
 		union {
 			uint8_t shifterReg;
 			uint8_t shifterImm;
+			uint8_t psrBits;
 		};
 	};
 	int32_t immediate;
@@ -138,7 +145,6 @@ ARM_MN_B,
 	ARM_MN_BIC,
 	ARM_MN_BKPT,
 	ARM_MN_BL,
-	ARM_MN_BLH,
 	ARM_MN_BX,
 	ARM_MN_CMN,
 	ARM_MN_CMP,
@@ -203,6 +209,7 @@ };
 
 void ARMDecodeARM(uint32_t opcode, struct ARMInstructionInfo* info);
 void ARMDecodeThumb(uint16_t opcode, struct ARMInstructionInfo* info);
+bool ARMDecodeThumbCombine(struct ARMInstructionInfo* info1, struct ARMInstructionInfo* info2, struct ARMInstructionInfo* out);
 int ARMDisassemble(struct ARMInstructionInfo* info, uint32_t pc, char* buffer, int blen);
 
 #endif

@@ -43,7 +43,7 @@ static void _writeWord(struct CLIDebugger*, struct CLIDebugVector*);
 
 static void _breakIntoDefault(int signal);
 static void _disassembleMode(struct CLIDebugger*, struct CLIDebugVector*, enum ExecutionMode mode);
-static void _printLine(struct CLIDebugger* debugger, uint32_t address, enum ExecutionMode mode);
+static uint32_t _printLine(struct CLIDebugger* debugger, uint32_t address, enum ExecutionMode mode);
 
 static struct CLIDebuggerCommandSummary _debuggerCommands[] = {
 	{ "b", _setBreakpoint, CLIDVParse, "Set a breakpoint" },
@@ -172,8 +172,7 @@ }
 
 	int i;
 	for (i = 0; i < size; ++i) {
-		_printLine(debugger, address, mode);
-		address += wordSize;
+		address += _printLine(debugger, address, mode);;
 	}
 }
 
@@ -238,7 +237,7 @@ }
 	}
 }
 
-static inline void _printLine(struct CLIDebugger* debugger, uint32_t address, enum ExecutionMode mode) {
+static inline uint32_t _printLine(struct CLIDebugger* debugger, uint32_t address, enum ExecutionMode mode) {
 	char disassembly[48];
 	struct ARMInstructionInfo info;
 	printf("%08X:  ", address);
@@ -247,11 +246,23 @@ uint32_t instruction = debugger->d.cpu->memory.load32(debugger->d.cpu, address, 0);
 		ARMDecodeARM(instruction, &info);
 		ARMDisassemble(&info, address + WORD_SIZE_ARM * 2, disassembly, sizeof(disassembly));
 		printf("%08X\t%s\n", instruction, disassembly);
+		return WORD_SIZE_ARM;
 	} else {
+		struct ARMInstructionInfo info2;
+		struct ARMInstructionInfo combined;
 		uint16_t instruction = debugger->d.cpu->memory.load16(debugger->d.cpu, address, 0);
+		uint16_t instruction2 = debugger->d.cpu->memory.load16(debugger->d.cpu, address + WORD_SIZE_THUMB, 0);
 		ARMDecodeThumb(instruction, &info);
-		ARMDisassemble(&info, address + WORD_SIZE_THUMB * 2, disassembly, sizeof(disassembly));
-		printf("%04X\t%s\n", instruction, disassembly);
+		ARMDecodeThumb(instruction2, &info2);
+		if (ARMDecodeThumbCombine(&info, &info2, &combined)) {
+			ARMDisassemble(&combined, address + WORD_SIZE_THUMB * 2, disassembly, sizeof(disassembly));
+			printf("%04X %04X\t%s\n", instruction, instruction2, disassembly);
+			return WORD_SIZE_THUMB * 2;
+		} else {
+			ARMDisassemble(&info, address + WORD_SIZE_THUMB * 2, disassembly, sizeof(disassembly));
+			printf("%04X     \t%s\n", instruction, disassembly);
+			return WORD_SIZE_THUMB;
+		}
 	}
 }
 
@@ -396,7 +407,7 @@ }
 
 static void _breakIntoDefault(int signal) {
 	UNUSED(signal);
-	ARMDebuggerEnter(&_activeDebugger->d, DEBUGGER_ENTER_MANUAL);
+	ARMDebuggerEnter(&_activeDebugger->d, DEBUGGER_ENTER_MANUAL, 0);
 }
 
 static uint32_t _performOperation(enum Operation operation, uint32_t current, uint32_t next, struct CLIDebugVector* dv) {
@@ -629,7 +640,6 @@ HistEvent ev;
 	while (debugger->state == DEBUGGER_PAUSED) {
 		line = el_gets(cliDebugger->elstate, &count);
 		if (!line) {
-			debugger->state = DEBUGGER_EXITING;
 			return;
 		}
 		if (line[0] == '\n') {
@@ -643,20 +653,32 @@ }
 	}
 }
 
-static void _reportEntry(struct ARMDebugger* debugger, enum DebuggerEntryReason reason) {
+static void _reportEntry(struct ARMDebugger* debugger, enum DebuggerEntryReason reason, struct DebuggerEntryInfo* info) {
 	UNUSED(debugger);
 	switch (reason) {
 	case DEBUGGER_ENTER_MANUAL:
 	case DEBUGGER_ENTER_ATTACHED:
 		break;
 	case DEBUGGER_ENTER_BREAKPOINT:
-		printf("Hit breakpoint\n");
+		if (info) {
+			printf("Hit breakpoint at 0x%08X\n", info->address);
+		} else {
+			printf("Hit breakpoint\n");
+		}
 		break;
 	case DEBUGGER_ENTER_WATCHPOINT:
-		printf("Hit watchpoint\n");
+		if (info) {
+			printf("Hit watchpoint at 0x%08X: (old value = 0x%08X)\n", info->address, info->oldValue);
+		} else {
+			printf("Hit watchpoint\n");
+		}
 		break;
 	case DEBUGGER_ENTER_ILLEGAL_OP:
-		printf("Hit illegal opcode\n");
+		if (info) {
+			printf("Hit illegal opcode at 0x%08X: 0x%08X\n", info->address, info->opcode);
+		} else {
+			printf("Hit illegal opcode\n");
+		}
 		break;
 	}
 }

@@ -22,7 +22,10 @@ instructionLength = WORD_SIZE_THUMB;
 	}
 	for (breakpoint = debugger->breakpoints; breakpoint; breakpoint = breakpoint->next) {
 		if (breakpoint->address + instructionLength == (uint32_t) debugger->cpu->gprs[ARM_PC]) {
-			ARMDebuggerEnter(debugger, DEBUGGER_ENTER_BREAKPOINT);
+			struct DebuggerEntryInfo info = {
+				.address = breakpoint->address
+			};
+			ARMDebuggerEnter(debugger, DEBUGGER_ENTER_BREAKPOINT, &info);
 			break;
 		}
 	}
@@ -55,52 +58,36 @@ debugger->deinit(debugger);
 }
 
 void ARMDebuggerRun(struct ARMDebugger* debugger) {
-	if (debugger->state == DEBUGGER_EXITING) {
-		debugger->state = DEBUGGER_RUNNING;
-	}
-	while (debugger->state < DEBUGGER_EXITING) {
+	switch (debugger->state) {
+	case DEBUGGER_RUNNING:
 		if (!debugger->breakpoints && !debugger->watchpoints) {
-			while (debugger->state == DEBUGGER_RUNNING) {
-				ARMRunLoop(debugger->cpu);
-			}
-		} else if (!debugger->breakpoints) {
-			while (debugger->state == DEBUGGER_RUNNING) {
-				ARMRun(debugger->cpu);
-			}
+			ARMRunLoop(debugger->cpu);
 		} else {
-			while (debugger->state == DEBUGGER_RUNNING) {
-				ARMRun(debugger->cpu);
-				_checkBreakpoints(debugger);
-			}
+			ARMRun(debugger->cpu);
+			_checkBreakpoints(debugger);
 		}
-		switch (debugger->state) {
-		case DEBUGGER_RUNNING:
-			break;
-		case DEBUGGER_CUSTOM:
-			while (debugger->state == DEBUGGER_CUSTOM) {
-				ARMRun(debugger->cpu);
-				_checkBreakpoints(debugger);
-				debugger->custom(debugger);
-			}
-			break;
-		case DEBUGGER_PAUSED:
-			if (debugger->paused) {
-				debugger->paused(debugger);
-			} else {
-				debugger->state = DEBUGGER_RUNNING;
-			}
-			break;
-		case DEBUGGER_EXITING:
-		case DEBUGGER_SHUTDOWN:
-			return;
+		break;
+	case DEBUGGER_CUSTOM:
+		ARMRun(debugger->cpu);
+		_checkBreakpoints(debugger);
+		debugger->custom(debugger);
+		break;
+	case DEBUGGER_PAUSED:
+		if (debugger->paused) {
+			debugger->paused(debugger);
+		} else {
+			debugger->state = DEBUGGER_RUNNING;
 		}
+		break;
+	case DEBUGGER_SHUTDOWN:
+		return;
 	}
 }
 
-void ARMDebuggerEnter(struct ARMDebugger* debugger, enum DebuggerEntryReason reason) {
+void ARMDebuggerEnter(struct ARMDebugger* debugger, enum DebuggerEntryReason reason, struct DebuggerEntryInfo* info) {
 	debugger->state = DEBUGGER_PAUSED;
 	if (debugger->entered) {
-		debugger->entered(debugger, reason);
+		debugger->entered(debugger, reason, info);
 	}
 }
 
@@ -126,15 +113,15 @@ void ARMDebuggerSetWatchpoint(struct ARMDebugger* debugger, uint32_t address) {
 	if (!debugger->watchpoints) {
 		ARMDebuggerInstallMemoryShim(debugger);
 	}
-	struct DebugBreakpoint* watchpoint = malloc(sizeof(struct DebugBreakpoint));
+	struct DebugWatchpoint* watchpoint = malloc(sizeof(struct DebugWatchpoint));
 	watchpoint->address = address;
 	watchpoint->next = debugger->watchpoints;
 	debugger->watchpoints = watchpoint;
 }
 
 void ARMDebuggerClearWatchpoint(struct ARMDebugger* debugger, uint32_t address) {
-	struct DebugBreakpoint** previous = &debugger->watchpoints;
-	struct DebugBreakpoint* breakpoint;
+	struct DebugWatchpoint** previous = &debugger->watchpoints;
+	struct DebugWatchpoint* breakpoint;
 	for (; (breakpoint = *previous); previous = &breakpoint->next) {
 		if (breakpoint->address == address) {
 			*previous = breakpoint->next;

@@ -16,7 +16,6 @@ enum DebuggerState {
 	DEBUGGER_PAUSED,
 	DEBUGGER_RUNNING,
 	DEBUGGER_CUSTOM,
-	DEBUGGER_EXITING,
 	DEBUGGER_SHUTDOWN
 };
 
@@ -25,6 +24,18 @@ struct DebugBreakpoint* next;
 	uint32_t address;
 };
 
+enum WatchpointType {
+	WATCHPOINT_WRITE = 1,
+	WATCHPOINT_READ = 2,
+	WATCHPOINT_RW = 3
+};
+
+struct DebugWatchpoint {
+	struct DebugWatchpoint* next;
+	uint32_t address;
+	enum WatchpointType type;
+};
+
 enum DebuggerEntryReason {
 	DEBUGGER_ENTER_MANUAL,
 	DEBUGGER_ENTER_ATTACHED,
@@ -33,6 +44,20 @@ DEBUGGER_ENTER_WATCHPOINT,
 	DEBUGGER_ENTER_ILLEGAL_OP
 };
 
+struct DebuggerEntryInfo {
+	uint32_t address;
+	union {
+		struct {
+			uint32_t oldValue;
+			enum WatchpointType watchType;
+		};
+
+		struct {
+			uint32_t opcode;
+		};
+	};
+};
+
 enum DebuggerLogLevel {
 	DEBUGGER_LOG_DEBUG = 0x01,
 	DEBUGGER_LOG_INFO = 0x02,
@@ -46,13 +71,13 @@ enum DebuggerState state;
 	struct ARMCore* cpu;
 
 	struct DebugBreakpoint* breakpoints;
-	struct DebugBreakpoint* watchpoints;
+	struct DebugWatchpoint* watchpoints;
 	struct ARMMemory originalMemory;
 
 	void (*init)(struct ARMDebugger*);
 	void (*deinit)(struct ARMDebugger*);
 	void (*paused)(struct ARMDebugger*);
-	void (*entered)(struct ARMDebugger*, enum DebuggerEntryReason);
+	void (*entered)(struct ARMDebugger*, enum DebuggerEntryReason, struct DebuggerEntryInfo*);
 	void (*custom)(struct ARMDebugger*);
 
 	__attribute__((format (printf, 3, 4)))
@@ -61,7 +86,7 @@ };
 
 void ARMDebuggerCreate(struct ARMDebugger*);
 void ARMDebuggerRun(struct ARMDebugger*);
-void ARMDebuggerEnter(struct ARMDebugger*, enum DebuggerEntryReason);
+void ARMDebuggerEnter(struct ARMDebugger*, enum DebuggerEntryReason, struct DebuggerEntryInfo*);
 void ARMDebuggerSetBreakpoint(struct ARMDebugger* debugger, uint32_t address);
 void ARMDebuggerClearBreakpoint(struct ARMDebugger* debugger, uint32_t address);
 void ARMDebuggerSetWatchpoint(struct ARMDebugger* debugger, uint32_t address);

@@ -12,6 +12,8 @@ #ifndef SIGTRAP
 #define SIGTRAP 5 /* Win32 Signals do not include SIGTRAP */
 #endif
 
+#define SOCKET_TIMEOUT 50
+
 enum GDBError {
 	GDB_NO_ERROR = 0x00,
 	GDB_BAD_ARGUMENTS = 0x06,
@@ -32,16 +34,34 @@ GDBStubShutdown(stub);
 	}
 }
 
-static void _gdbStubEntered(struct ARMDebugger* debugger, enum DebuggerEntryReason reason) {
+static void _gdbStubEntered(struct ARMDebugger* debugger, enum DebuggerEntryReason reason, struct DebuggerEntryInfo* info) {
 	struct GDBStub* stub = (struct GDBStub*) debugger;
 	switch (reason) {
 	case DEBUGGER_ENTER_MANUAL:
 		snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "S%02x", SIGINT);
 		break;
 	case DEBUGGER_ENTER_BREAKPOINT:
-	case DEBUGGER_ENTER_WATCHPOINT: // TODO: Make watchpoints raise with address
 		snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "S%02x", SIGTRAP);
 		break;
+	case DEBUGGER_ENTER_WATCHPOINT: // TODO: Make watchpoints raise with address
+		if (info) {
+			const char* type = 0;
+			switch (info->watchType) {
+			case WATCHPOINT_WRITE:
+				type = "watch";
+				break;
+			case WATCHPOINT_READ:
+				type = "rwatch";
+				break;
+			case WATCHPOINT_RW:
+				type = "awatch";
+				break;
+			}
+			snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "T%02x%s:%08X", SIGTRAP, type, info->address);
+		} else {
+			snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "S%02x", SIGTRAP);
+		}
+		break;
 	case DEBUGGER_ENTER_ILLEGAL_OP:
 		snprintf(stub->outgoing, GDB_STUB_MAX_LINE - 4, "S%02x", SIGILL);
 		break;
@@ -58,33 +78,13 @@ if (stub->untilPoll > 0) {
 		return;
 	}
 	stub->untilPoll = GDB_STUB_INTERVAL;
-	if (stub->shouldBlock) {
-		stub->shouldBlock = false;
-		if (!SocketSetBlocking(stub->socket, false)) {
-			GDBStubHangup(stub);
-			return;
-		}
-		if (!SOCKET_FAILED(stub->connection) && !SocketSetBlocking(stub->connection, false)) {
-			GDBStubHangup(stub);
-			return;
-		}
-	}
+	stub->shouldBlock = false;
 	GDBStubUpdate(stub);
 }
 
 static void _gdbStubWait(struct ARMDebugger* debugger) {
 	struct GDBStub* stub = (struct GDBStub*) debugger;
-	if (!stub->shouldBlock) {
-		stub->shouldBlock = true;
-		if (!SocketSetBlocking(stub->socket, true)) {
-			GDBStubHangup(stub);
-			return;
-		}
-		if (!SOCKET_FAILED(stub->connection) && !SocketSetBlocking(stub->connection, true)) {
-			GDBStubHangup(stub);
-			return;
-		}
-	}
+	stub->shouldBlock = true;
 	GDBStubUpdate(stub);
 }
 
@@ -195,12 +195,6 @@
 static void _continue(struct GDBStub* stub, const char* message) {
 	stub->d.state = DEBUGGER_CUSTOM;
 	stub->untilPoll = GDB_STUB_INTERVAL;
-	if (!SOCKET_FAILED(stub->connection)) {
-		if (!SocketSetBlocking(stub->connection, 0)) {
-			GDBStubHangup(stub);
-			return;
-		}
-	}
 	// TODO: parse message
 	UNUSED(message);
 }
@@ -303,7 +297,7 @@ static void _processVReadCommand(struct GDBStub* stub, const char* message) {
 	stub->outgoing[0] = '\0';
 	if (!strncmp("Attach", message, 6)) {
 		strncpy(stub->outgoing, "1", GDB_STUB_MAX_LINE - 4);
-		ARMDebuggerEnter(&stub->d, DEBUGGER_ENTER_MANUAL);
+		ARMDebuggerEnter(&stub->d, DEBUGGER_ENTER_MANUAL, 0);
 	}
 	_sendMessage(stub);
 }
@@ -372,7 +366,7 @@ case '$':
 		++message;
 		break;
 	case '\x03':
-		ARMDebuggerEnter(&stub->d, DEBUGGER_ENTER_MANUAL);
+		ARMDebuggerEnter(&stub->d, DEBUGGER_ENTER_MANUAL, 0);
 		return parsed;
 	default:
 		_nak(stub);
@@ -473,7 +467,7 @@ stub->d.log = 0;
 	stub->untilPoll = GDB_STUB_INTERVAL;
 }
 
-int GDBStubListen(struct GDBStub* stub, int port, const struct Address* bindAddress) {
+bool GDBStubListen(struct GDBStub* stub, int port, const struct Address* bindAddress) {
 	if (!SOCKET_FAILED(stub->socket)) {
 		GDBStubShutdown(stub);
 	}
@@ -482,28 +476,31 @@ if (SOCKET_FAILED(stub->socket)) {
 		if (stub->d.log) {
 			stub->d.log(&stub->d, DEBUGGER_LOG_ERROR, "Couldn't open socket");
 		}
-		return 0;
+		return false;
+	}
+	if (!SocketSetBlocking(stub->socket, false)) {
+		goto cleanup;
 	}
 	int err = SocketListen(stub->socket, 1);
 	if (err) {
 		goto cleanup;
 	}
 
-	return 1;
+	return true;
 
 cleanup:
 	if (stub->d.log) {
 		stub->d.log(&stub->d, DEBUGGER_LOG_ERROR, "Couldn't listen on port");
 	}
 	SocketClose(stub->socket);
-	stub->socket = -1;
-	return 0;
+	stub->socket = INVALID_SOCKET;
+	return false;
 }
 
 void GDBStubHangup(struct GDBStub* stub) {
 	if (!SOCKET_FAILED(stub->connection)) {
 		SocketClose(stub->connection);
-		stub->connection = -1;
+		stub->connection = INVALID_SOCKET;
 	}
 	if (stub->d.state == DEBUGGER_PAUSED) {
 		stub->d.state = DEBUGGER_RUNNING;
@@ -514,18 +511,28 @@ void GDBStubShutdown(struct GDBStub* stub) {
 	GDBStubHangup(stub);
 	if (!SOCKET_FAILED(stub->socket)) {
 		SocketClose(stub->socket);
-		stub->socket = -1;
+		stub->socket = INVALID_SOCKET;
 	}
 }
 
 void GDBStubUpdate(struct GDBStub* stub) {
 	if (stub->socket == INVALID_SOCKET) {
+		if (stub->d.state == DEBUGGER_PAUSED) {
+			stub->d.state = DEBUGGER_RUNNING;
+		}
 		return;
 	}
 	if (stub->connection == INVALID_SOCKET) {
+		if (stub->shouldBlock) {
+			Socket reads = stub->socket;
+			SocketPoll(1, &reads, 0, 0, SOCKET_TIMEOUT);
+		}
 		stub->connection = SocketAccept(stub->socket, 0);
 		if (!SOCKET_FAILED(stub->connection)) {
-			ARMDebuggerEnter(&stub->d, DEBUGGER_ENTER_ATTACHED);
+			if (!SocketSetBlocking(stub->connection, false)) {
+				goto connectionLost;
+			}
+			ARMDebuggerEnter(&stub->d, DEBUGGER_ENTER_ATTACHED, 0);
 		} else if (errno == EWOULDBLOCK || errno == EAGAIN) {
 			return;
 		} else {
@@ -533,6 +540,10 @@ goto connectionLost;
 		}
 	}
 	while (true) {
+		if (stub->shouldBlock) {
+			Socket reads = stub->connection;
+			SocketPoll(1, &reads, 0, 0, SOCKET_TIMEOUT);
+		}
 		ssize_t messageLen = SocketRecv(stub->connection, stub->line, GDB_STUB_MAX_LINE - 1);
 		if (messageLen == 0) {
 			goto connectionLost;

@@ -37,7 +37,7 @@ int untilPoll;
 };
 
 void GDBStubCreate(struct GDBStub*);
-int GDBStubListen(struct GDBStub*, int port, const struct Address* bindAddress);
+bool GDBStubListen(struct GDBStub*, int port, const struct Address* bindAddress);
 
 void GDBStubHangup(struct GDBStub*);
 void GDBStubShutdown(struct GDBStub*);

@@ -9,7 +9,8 @@ #include "debugger.h"
 
 #include <string.h>
 
-static bool _checkWatchpoints(struct DebugBreakpoint* watchpoints, uint32_t address, int width);
+static bool _checkWatchpoints(struct ARMDebugger* debugger, uint32_t address, struct DebuggerEntryInfo* info, int width);
+
 static uint32_t _popcount32(unsigned bits) {
 	bits = bits - ((bits >> 1) & 0x55555555);
 	bits = (bits & 0x33333333) + ((bits >> 2) & 0x33333333);
@@ -39,8 +40,9 @@ #define CREATE_WATCHPOINT_SHIM(NAME, WIDTH, RETURN, TYPES, ARGS...) \
 	static RETURN ARMDebuggerShim_ ## NAME TYPES { \
 		struct ARMDebugger* debugger; \
 		FIND_DEBUGGER(debugger, cpu); \
-		if (_checkWatchpoints(debugger->watchpoints, address, WIDTH)) { \
-			ARMDebuggerEnter(debugger, DEBUGGER_ENTER_WATCHPOINT); \
+		struct DebuggerEntryInfo info = { }; \
+		if (_checkWatchpoints(debugger, address, &info, WIDTH)) { \
+			ARMDebuggerEnter(debugger, DEBUGGER_ENTER_WATCHPOINT, &info); \
 		} \
 		return debugger->originalMemory.NAME(cpu, ARGS); \
 	}
@@ -61,8 +63,9 @@ base += offset; \
 		} \
 		unsigned i; \
 		for (i = 0; i < popcount; ++i) { \
-			if (_checkWatchpoints(debugger->watchpoints, base + 4 * i, 4)) { \
-				ARMDebuggerEnter(debugger, DEBUGGER_ENTER_WATCHPOINT); \
+			struct DebuggerEntryInfo info = { }; \
+			if (_checkWatchpoints(debugger, base + 4 * i, &info, 4)) { \
+				ARMDebuggerEnter(debugger, DEBUGGER_ENTER_WATCHPOINT, &info); \
 			} \
 		} \
 		return debugger->originalMemory.NAME(cpu, address, mask, direction, cycleCounter); \
@@ -78,10 +81,24 @@ CREATE_MULTIPLE_WATCHPOINT_SHIM(loadMultiple)
 CREATE_MULTIPLE_WATCHPOINT_SHIM(storeMultiple)
 CREATE_SHIM(setActiveRegion, void, (struct ARMCore* cpu, uint32_t address), address)
 
-static bool _checkWatchpoints(struct DebugBreakpoint* watchpoints, uint32_t address, int width) {
-	width -= 1;
-	for (; watchpoints; watchpoints = watchpoints->next) {
+static bool _checkWatchpoints(struct ARMDebugger* debugger, uint32_t address, struct DebuggerEntryInfo* info, int width) {
+	--width;
+	struct DebugWatchpoint* watchpoints;
+	for (watchpoints = debugger->watchpoints; watchpoints; watchpoints = watchpoints->next) {
 		if (!((watchpoints->address ^ address) & ~width)) {
+			switch (width + 1) {
+			case 1:
+				info->oldValue = debugger->originalMemory.load8(debugger->cpu, address, 0);
+				break;
+			case 2:
+				info->oldValue = debugger->originalMemory.load16(debugger->cpu, address, 0);
+				break;
+			case 4:
+				info->oldValue = debugger->originalMemory.load32(debugger->cpu, address, 0);
+				break;
+			}
+			info->address = address;
+			info->watchType = watchpoints->type;
 			return true;
 		}
 	}

@@ -66,12 +66,12 @@ static bool _GBACLIDebuggerCustom(struct CLIDebuggerSystem* debugger) {
 	struct GBACLIDebugger* gbaDebugger = (struct GBACLIDebugger*) debugger;
 
 	if (gbaDebugger->frameAdvance) {
-		if (!gbaDebugger->inVblank && GBARegisterDISPSTATIsInVblank(gbaDebugger->context->gba->video.dispstat)) {
-			ARMDebuggerEnter(&gbaDebugger->d.p->d, DEBUGGER_ENTER_BREAKPOINT);
+		if (!gbaDebugger->inVblank && GBARegisterDISPSTATIsInVblank(gbaDebugger->context->gba->memory.io[REG_DISPSTAT >> 1])) {
+			ARMDebuggerEnter(&gbaDebugger->d.p->d, DEBUGGER_ENTER_MANUAL, 0);
 			gbaDebugger->frameAdvance = false;
 			return false;
 		}
-		gbaDebugger->inVblank = GBARegisterDISPSTATGetInVblank(gbaDebugger->context->gba->video.dispstat);
+		gbaDebugger->inVblank = GBARegisterDISPSTATGetInVblank(gbaDebugger->context->gba->memory.io[REG_DISPSTAT >> 1]);
 		return true;
 	}
 	return false;
@@ -96,7 +96,7 @@ debugger->d.state = DEBUGGER_CUSTOM;
 
 	struct GBACLIDebugger* gbaDebugger = (struct GBACLIDebugger*) debugger->system;
 	gbaDebugger->frameAdvance = true;
-	gbaDebugger->inVblank = GBARegisterDISPSTATGetInVblank(gbaDebugger->context->gba->video.dispstat);
+	gbaDebugger->inVblank = GBARegisterDISPSTATGetInVblank(gbaDebugger->context->gba->memory.io[REG_DISPSTAT >> 1]);
 }
 
 static void _load(struct CLIDebugger* debugger, struct CLIDebugVector* dv) {

@@ -38,9 +38,13 @@ 0 // Empty
 };
 
 void GBAGPIOInit(struct GBACartridgeGPIO* gpio, uint16_t* base) {
+	gpio->gpioBase = base;
+	GBAGPIOClear(gpio);
+}
+
+void GBAGPIOClear(struct GBACartridgeGPIO* gpio) {
 	gpio->gpioDevices = GPIO_NONE;
 	gpio->direction = GPIO_WRITE_ONLY;
-	gpio->gpioBase = base;
 	gpio->pinState = 0;
 	gpio->direction = 0;
 }

@@ -11,6 +11,7 @@
 #define IS_GPIO_REGISTER(reg) ((reg) == GPIO_REG_DATA || (reg) == GPIO_REG_DIRECTION || (reg) == GPIO_REG_CONTROL)
 
 enum GPIODevice {
+	GPIO_NO_OVERRIDE = 0x8000,
 	GPIO_NONE = 0,
 	GPIO_RTC = 1,
 	GPIO_RUMBLE = 2,
@@ -114,6 +115,7 @@ int tiltState;
 };
 
 void GBAGPIOInit(struct GBACartridgeGPIO* gpio, uint16_t* gpioBase);
+void GBAGPIOClear(struct GBACartridgeGPIO* gpio);
 void GBAGPIOWrite(struct GBACartridgeGPIO* gpio, uint32_t address, uint16_t value);
 
 void GBAGPIOInitRTC(struct GBACartridgeGPIO* gpio);

@@ -195,6 +195,21 @@
 	ConfigurationSetValue(config, sectionName, keyKey, keyValue);
 }
 
+static void _clearAxis(uint32_t type, struct Configuration* config, const char* axisName) {
+	char sectionName[SECTION_NAME_MAX];
+	snprintf(sectionName, SECTION_NAME_MAX, "input.%c%c%c%c", type >> 24, type >> 16, type >> 8, type);
+	sectionName[SECTION_NAME_MAX - 1] = '\0';
+
+	char axisKey[KEY_NAME_MAX];
+	snprintf(axisKey, KEY_NAME_MAX, "axis%sValue", axisName);
+	axisKey[KEY_NAME_MAX - 1] = '\0';
+	ConfigurationClearValue(config, sectionName, axisKey);
+
+	snprintf(axisKey, KEY_NAME_MAX, "axis%sAxis", axisName);
+	axisKey[KEY_NAME_MAX - 1] = '\0';
+	ConfigurationClearValue(config, sectionName, axisKey);
+}
+
 static void _saveAxis(uint32_t axis, void* dp, void* up) {
 	struct GBAAxisSave* user = up;
 	const struct GBAAxis* description = dp;
@@ -244,6 +259,18 @@ const struct GBAAxis* description = dp;
 	enumUser->handler(axis, description, enumUser->user);
 }
 
+void _unbindAxis(uint32_t axis, void* dp, void* user) {
+	UNUSED(axis);
+	enum GBAKey* key = user;
+	struct GBAAxis* description = dp;
+	if (description->highDirection == *key) {
+		description->highDirection = GBA_KEY_NONE;
+	}
+	if (description->lowDirection == *key) {
+		description->lowDirection = GBA_KEY_NONE;
+	}
+}
+
 void GBAInputMapInit(struct GBAInputMap* map) {
 	map->maps = 0;
 	map->numMaps = 0;
@@ -279,14 +306,19 @@ }
 
 void GBAInputBindKey(struct GBAInputMap* map, uint32_t type, int key, enum GBAKey input) {
 	struct GBAInputMapImpl* impl = _guaranteeMap(map, type);
+	GBAInputUnbindKey(map, type, input);
 	impl->map[input] = key;
 }
 
 void GBAInputUnbindKey(struct GBAInputMap* map, uint32_t type, enum GBAKey input) {
 	struct GBAInputMapImpl* impl = _lookupMap(map, type);
+	if (input < 0 || input >= GBA_KEY_MAX) {
+		return;
+	}
 	if (impl) {
 		impl->map[input] = GBA_NO_MAPPING;
 	}
+	TableEnumerate(&impl->axes, _unbindAxis, &input);
 }
 
 int GBAInputQueryBinding(const struct GBAInputMap* map, uint32_t type, enum GBAKey input) {
@@ -341,6 +373,8 @@
 void GBAInputBindAxis(struct GBAInputMap* map, uint32_t type, int axis, const struct GBAAxis* description) {
 	struct GBAInputMapImpl* impl = _guaranteeMap(map, type);
 	struct GBAAxis* dup = malloc(sizeof(struct GBAAxis));
+	GBAInputUnbindKey(map, type, description->lowDirection);
+	GBAInputUnbindKey(map, type, description->highDirection);
 	*dup = *description;
 	TableInsert(&impl->axes, axis, dup);
 }
@@ -391,6 +425,12 @@ _loadKey(map, type, config, GBA_KEY_DOWN, "Down");
 	_loadKey(map, type, config, GBA_KEY_LEFT, "Left");
 	_loadKey(map, type, config, GBA_KEY_RIGHT, "Right");
 
+	_loadAxis(map, type, config, GBA_KEY_A, "A");
+	_loadAxis(map, type, config, GBA_KEY_B, "B");
+	_loadAxis(map, type, config, GBA_KEY_L, "L");
+	_loadAxis(map, type, config, GBA_KEY_R, "R");
+	_loadAxis(map, type, config, GBA_KEY_START, "Start");
+	_loadAxis(map, type, config, GBA_KEY_SELECT, "Select");
 	_loadAxis(map, type, config, GBA_KEY_UP, "Up");
 	_loadAxis(map, type, config, GBA_KEY_DOWN, "Down");
 	_loadAxis(map, type, config, GBA_KEY_LEFT, "Left");
@@ -408,6 +448,17 @@ _saveKey(map, type, config, GBA_KEY_UP, "Up");
 	_saveKey(map, type, config, GBA_KEY_DOWN, "Down");
 	_saveKey(map, type, config, GBA_KEY_LEFT, "Left");
 	_saveKey(map, type, config, GBA_KEY_RIGHT, "Right");
+
+	_clearAxis(type, config, "A");
+	_clearAxis(type, config, "B");
+	_clearAxis(type, config, "L");
+	_clearAxis(type, config, "R");
+	_clearAxis(type, config, "Start");
+	_clearAxis(type, config, "Select");
+	_clearAxis(type, config, "Up");
+	_clearAxis(type, config, "Down");
+	_clearAxis(type, config, "Left");
+	_clearAxis(type, config, "Right");
 
 	const struct GBAInputMapImpl* impl = _lookupMapConst(map, type);
 	if (!impl) {

@@ -366,11 +366,23 @@ case REG_WAVE_RAM3_HI:
 			GBAIOWrite32(gba, address - 2, gba->memory.io[(address >> 1) - 1] | (value << 16));
 			break;
 
+		// TODO: Confirm this behavior on real hardware
 		case REG_FIFO_A_LO:
 		case REG_FIFO_B_LO:
+			if (gba->performingDMA) {
+				GBAAudioWriteFIFO16(&gba->audio, address, value);
+			} else {
+				GBAIOWrite32(gba, address, (gba->memory.io[(address >> 1) + 1] << 16) | value);
+			}
+			break;
+
 		case REG_FIFO_A_HI:
 		case REG_FIFO_B_HI:
-			GBAAudioWriteFIFO16(&gba->audio, address, value);
+			if (gba->performingDMA) {
+				GBAAudioWriteFIFO16(&gba->audio, address, value);
+			} else {
+				GBAIOWrite32(gba, address - 2, gba->memory.io[(address >> 1) - 1] | (value << 16));
+			}
 			break;
 
 		// DMA

@@ -275,7 +275,7 @@ }
 
 #define LOAD_BAD \
 	GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load32: 0x%08X", address); \
-	if (cpu->cycles >= cpu->nextEvent) { \
+	if (gba->performingDMA) { \
 		value = gba->bus; \
 	} else { \
 		value = cpu->prefetch[1]; \
@@ -404,10 +404,14 @@ LOAD_16(value, address & 2, &memory->biosPrefetch);
 			}
 		} else {
 			GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load16: 0x%08X", address);
-			if (cpu->cycles >= cpu->nextEvent) {
+			if (gba->performingDMA) {
 				LOAD_16(value, address & 2, &gba->bus);
 			} else {
-				LOAD_16(value, address & 2, &cpu->prefetch[1]);
+				uint32_t prefetch = cpu->prefetch[1];
+				if (cpu->executionMode == MODE_THUMB) {
+					prefetch |= prefetch << 16;
+				}
+				LOAD_16(value, address & 2, &prefetch);
 			}
 		}
 		break;
@@ -466,10 +470,14 @@ value |= value << 8;
 		break;
 	default:
 		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load16: 0x%08X", address);
-		if (cpu->cycles >= cpu->nextEvent) {
+		if (gba->performingDMA) {
 			LOAD_16(value, address & 2, &gba->bus);
 		} else {
-			LOAD_16(value, address & 2, &cpu->prefetch[1]);
+			uint32_t prefetch = cpu->prefetch[1];
+			if (cpu->executionMode == MODE_THUMB) {
+				prefetch |= prefetch << 16;
+			}
+			LOAD_16(value, address & 2, &prefetch);
 		}
 		break;
 	}
@@ -499,10 +507,14 @@ value = ((uint8_t*) &memory->biosPrefetch)[address & 3];
 			}
 		} else {
 			GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load8: 0x%08x", address);
-			if (cpu->cycles >= cpu->nextEvent) {
+			if (gba->performingDMA) {
 				value = ((uint8_t*) &gba->bus)[address & 3];
 			} else {
-				value = ((uint8_t*) &cpu->prefetch[1])[address & 3];
+				uint32_t prefetch = cpu->prefetch[1];
+				if (cpu->executionMode == MODE_THUMB) {
+					prefetch |= prefetch << 16;
+				}
+				value = ((uint8_t*) &prefetch)[address & 3];
 			}
 		}
 		break;
@@ -563,10 +575,14 @@ }
 		break;
 	default:
 		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load8: 0x%08x", address);
-		if (cpu->cycles >= cpu->nextEvent) {
+		if (gba->performingDMA) {
 			value = ((uint8_t*) &gba->bus)[address & 3];
 		} else {
-			value = ((uint8_t*) &cpu->prefetch[1])[address & 3];
+			uint32_t prefetch = cpu->prefetch[1];
+			if (cpu->executionMode == MODE_THUMB) {
+				prefetch |= prefetch << 16;
+			}
+			value = ((uint8_t*) &prefetch)[address & 3];
 		}
 		break;
 	}
@@ -1241,6 +1257,7 @@ cycles += memory->waitstatesSeq16[sourceRegion] + memory->waitstatesSeq16[destRegion];
 		}
 	}
 
+	gba->performingDMA = true;
 	int32_t word;
 	if (width == 4) {
 		word = cpu->memory.load32(cpu, source, 0);
@@ -1277,6 +1294,7 @@ dest += destOffset;
 			--wordsRemaining;
 		}
 	}
+	gba->performingDMA = false;
 
 	if (!wordsRemaining) {
 		if (!GBADMARegisterIsRepeat(info->reg) || GBADMARegisterGetTiming(info->reg) == DMA_TIMING_NOW) {

@@ -172,31 +172,77 @@ }
 	return found;
 }
 
-void GBAOverrideApply(struct GBA* gba, const struct GBACartridgeOverride* override) {
-	GBASavedataForceType(&gba->memory.savedata, override->savetype);
-
-	if (override->hardware & GPIO_RTC) {
-		GBAGPIOInitRTC(&gba->memory.gpio);
+void GBAOverrideSave(struct Configuration* config, const struct GBACartridgeOverride* override) {
+	char sectionName[16];
+	snprintf(sectionName, sizeof(sectionName), "override.%c%c%c%c", override->id[0], override->id[1], override->id[2], override->id[3]);
+	const char* savetype = 0;
+	switch (override->savetype) {
+	case SAVEDATA_SRAM:
+		savetype = "SRAM";
+		break;
+	case SAVEDATA_EEPROM:
+		savetype = "EEPROM";
+		break;
+	case SAVEDATA_FLASH512:
+		savetype = "FLASH512";
+		break;
+	case SAVEDATA_FLASH1M:
+		savetype = "FLASH1M";
+		break;
+	case SAVEDATA_FORCE_NONE:
+		savetype = "NONE";
+		break;
+	case SAVEDATA_AUTODETECT:
+		break;
 	}
+	ConfigurationSetValue(config, sectionName, "savetype", savetype);
 
-	if (override->hardware & GPIO_GYRO) {
-		GBAGPIOInitGyro(&gba->memory.gpio);
+	if (override->hardware != GPIO_NO_OVERRIDE) {
+		ConfigurationSetIntValue(config, sectionName, "hardware", override->hardware);
+	} else {
+		ConfigurationClearValue(config, sectionName, "hardware");
 	}
 
-	if (override->hardware & GPIO_RUMBLE) {
-		GBAGPIOInitRumble(&gba->memory.gpio);
+	if (override->idleLoop != 0xFFFFFFFF) {
+		ConfigurationSetUIntValue(config, sectionName, "idleLoop", override->idleLoop);
+	} else {
+		ConfigurationClearValue(config, sectionName, "idleLoop");
 	}
+}
 
-	if (override->hardware & GPIO_LIGHT_SENSOR) {
-		GBAGPIOInitLightSensor(&gba->memory.gpio);
+void GBAOverrideApply(struct GBA* gba, const struct GBACartridgeOverride* override) {
+	if (override->savetype != SAVEDATA_AUTODETECT) {
+		GBASavedataForceType(&gba->memory.savedata, override->savetype);
 	}
 
-	if (override->hardware & GPIO_TILT) {
-		GBAGPIOInitTilt(&gba->memory.gpio);
+	if (override->hardware != GPIO_NO_OVERRIDE) {
+		GBAGPIOClear(&gba->memory.gpio);
+
+		if (override->hardware & GPIO_RTC) {
+			GBAGPIOInitRTC(&gba->memory.gpio);
+		}
+
+		if (override->hardware & GPIO_GYRO) {
+			GBAGPIOInitGyro(&gba->memory.gpio);
+		}
+
+		if (override->hardware & GPIO_RUMBLE) {
+			GBAGPIOInitRumble(&gba->memory.gpio);
+		}
+
+		if (override->hardware & GPIO_LIGHT_SENSOR) {
+			GBAGPIOInitLightSensor(&gba->memory.gpio);
+		}
+
+		if (override->hardware & GPIO_TILT) {
+			GBAGPIOInitTilt(&gba->memory.gpio);
+		}
 	}
 
-	gba->idleLoop = override->idleLoop;
-	if (override->idleLoop != 0xFFFFFFFF && gba->idleOptimization == IDLE_LOOP_DETECT) {
-		gba->idleOptimization = IDLE_LOOP_REMOVE;
+	if (override->idleLoop != 0xFFFFFFFF) {
+		gba->idleLoop = override->idleLoop;
+		if (gba->idleOptimization == IDLE_LOOP_DETECT) {
+			gba->idleOptimization = IDLE_LOOP_REMOVE;
+		}
 	}
 }

@@ -19,7 +19,7 @@ };
 
 struct Configuration;
 bool GBAOverrideFind(const struct Configuration*, struct GBACartridgeOverride* override);
-bool GBAOverrideSave(struct Configuration*, const struct GBACartridgeOverride* override);
+void GBAOverrideSave(struct Configuration*, const struct GBACartridgeOverride* override);
 
 struct GBA;
 void GBAOverrideApply(struct GBA*, const struct GBACartridgeOverride*);

@@ -113,6 +113,11 @@ return true;
 }
 
 void GBASavedataForceType(struct GBASavedata* savedata, enum SavedataType type) {
+	if (savedata->type != SAVEDATA_AUTODETECT) {
+		struct VFile* vf = savedata->vf;
+		GBASavedataDeinit(savedata);
+		GBASavedataInit(savedata, vf);
+	}
 	switch (type) {
 	case SAVEDATA_FLASH512:
 	case SAVEDATA_FLASH1M:

@@ -8,7 +8,6 @@
 #include "arm.h"
 #include "gba.h"
 #include "gba-config.h"
-#include "gba-overrides.h"
 #include "gba-serialize.h"
 
 #include "debugger/debugger.h"
@@ -77,9 +76,6 @@ }
 }
 
 static void _pauseThread(struct GBAThread* threadContext, bool onThread) {
-	if (threadContext->debugger && threadContext->debugger->state == DEBUGGER_RUNNING) {
-		threadContext->debugger->state = DEBUGGER_EXITING;
-	}
 	threadContext->state = THREAD_PAUSING;
 	if (!onThread) {
 		_waitUntilNotState(threadContext, THREAD_PAUSING);
@@ -150,6 +146,9 @@ memcpy(override.id, &cart->id, sizeof(override.id));
 		if (GBAOverrideFind(threadContext->overrides, &override)) {
 			GBAOverrideApply(&gba, &override);
 		}
+		if (threadContext->hasOverride) {
+			GBAOverrideApply(&gba, &threadContext->override);
+		}
 
 		if (threadContext->bios && GBAIsBIOS(threadContext->bios)) {
 			GBALoadBIOS(&gba, threadContext->bios);
@@ -168,7 +167,7 @@
 	if (threadContext->debugger) {
 		threadContext->debugger->log = GBADebuggerLogShim;
 		GBAAttachDebugger(&gba, threadContext->debugger);
-		ARMDebuggerEnter(threadContext->debugger, DEBUGGER_ENTER_ATTACHED);
+		ARMDebuggerEnter(threadContext->debugger, DEBUGGER_ENTER_ATTACHED, 0);
 	}
 
 	GBASIOSetDriverSet(&gba.sio, &threadContext->sioDrivers);
@@ -272,8 +271,16 @@ threadContext->gameDir = VDirOpen(args->fname);
 		threadContext->stateDir = threadContext->gameDir;
 	} else {
 		threadContext->rom = VFileOpen(args->fname, O_RDONLY);
+		threadContext->gameDir = 0;
 #if ENABLE_LIBZIP
-		threadContext->gameDir = VDirOpenZip(args->fname, 0);
+		if (!threadContext->gameDir) {
+			threadContext->gameDir = VDirOpenZip(args->fname, 0);
+		}
+#endif
+#if ENABLE_LZMA
+		if (!threadContext->gameDir) {
+			threadContext->gameDir = VDirOpen7z(args->fname, 0);
+		}
 #endif
 	}
 	threadContext->fname = args->fname;
@@ -310,6 +317,7 @@ while (dirent) {
 			struct Patch patchTemp;
 			struct VFile* vf = threadContext->gameDir->openFile(threadContext->gameDir, dirent->name(dirent), O_RDONLY);
 			if (!vf) {
+				dirent = threadContext->gameDir->listNext(threadContext->gameDir);
 				continue;
 			}
 			if (!threadContext->rom && GBAIsROM(vf)) {
@@ -386,9 +394,7 @@ }
 
 void GBAThreadEnd(struct GBAThread* threadContext) {
 	MutexLock(&threadContext->stateMutex);
-	if (threadContext->debugger && threadContext->debugger->state == DEBUGGER_RUNNING) {
-		threadContext->debugger->state = DEBUGGER_EXITING;
-	}
+	_waitOnInterrupt(threadContext);
 	threadContext->state = THREAD_EXITING;
 	if (threadContext->gba) {
 		threadContext->gba->cpu->halted = false;
@@ -488,9 +494,7 @@ }
 	threadContext->savedState = threadContext->state;
 	_waitOnInterrupt(threadContext);
 	threadContext->state = THREAD_INTERRUPTING;
-	if (threadContext->debugger && threadContext->debugger->state == DEBUGGER_RUNNING) {
-		threadContext->debugger->state = DEBUGGER_EXITING;
-	}
+	threadContext->gba->cpu->nextEvent = 0;
 	ConditionWake(&threadContext->stateCond);
 	_waitUntilNotState(threadContext, THREAD_INTERRUPTING);
 	MutexUnlock(&threadContext->stateMutex);
@@ -618,25 +622,6 @@ }
 		} while (sync->videoFrameWait && sync->videoFramePending);
 	}
 	MutexUnlock(&sync->videoFrameMutex);
-
-	struct GBAThread* thread = GBAThreadGetContext();
-	if (!thread) {
-		return;
-	}
-
-	if (thread->rewindBuffer) {
-		--thread->rewindBufferNext;
-		if (thread->rewindBufferNext <= 0) {
-			thread->rewindBufferNext = thread->rewindBufferInterval;
-			GBARecordFrame(thread);
-		}
-	}
-	if (thread->stream) {
-		thread->stream->postVideoFrame(thread->stream, thread->renderer);
-	}
-	if (thread->frameCallback) {
-		thread->frameCallback(thread);
-	}
 }
 
 bool GBASyncWaitFrameStart(struct GBASync* sync, int frameskip) {

@@ -10,6 +10,7 @@ #include "util/common.h"
 
 #include "gba.h"
 #include "gba-input.h"
+#include "gba-overrides.h"
 
 #include "util/threading.h"
 
@@ -72,6 +73,9 @@ int activeKeys;
 	struct GBAAVStream* stream;
 	struct Configuration* overrides;
 	enum GBAIdleLoopOptimization idleOptimization;
+
+	bool hasOverride;
+	struct GBACartridgeOverride override;
 
 	// Run-time options
 	int frameskip;

@@ -41,7 +41,6 @@ video->vram = 0;
 }
 
 void GBAVideoReset(struct GBAVideo* video) {
-	video->dispstat = 0;
 	video->vcount = VIDEO_VERTICAL_TOTAL_PIXELS - 1;
 
 	video->lastHblank = 0;
@@ -96,53 +95,57 @@ video->lastHblank -= video->eventDiff;
 		video->nextHblank -= video->eventDiff;
 		video->nextHblankIRQ -= video->eventDiff;
 		video->nextVcounterIRQ -= video->eventDiff;
+		video->eventDiff = 0;
+		uint16_t dispstat = video->p->memory.io[REG_DISPSTAT >> 1];
 
-		if (GBARegisterDISPSTATIsInHblank(video->dispstat)) {
+		if (GBARegisterDISPSTATIsInHblank(dispstat)) {
 			// End Hblank
-			video->dispstat = GBARegisterDISPSTATClearInHblank(video->dispstat);
+			dispstat = GBARegisterDISPSTATClearInHblank(dispstat);
 			video->nextEvent = video->nextHblank;
 
 			++video->vcount;
+			if (video->vcount == VIDEO_VERTICAL_TOTAL_PIXELS) {
+				video->vcount = 0;
+			}
 			video->p->memory.io[REG_VCOUNT >> 1] = video->vcount;
 
+			if (video->vcount == GBARegisterDISPSTATGetVcountSetting(dispstat)) {
+				dispstat = GBARegisterDISPSTATFillVcounter(dispstat);
+				if (GBARegisterDISPSTATIsVcounterIRQ(dispstat)) {
+					GBARaiseIRQ(video->p, IRQ_VCOUNTER);
+					video->nextVcounterIRQ += VIDEO_TOTAL_LENGTH;
+				}
+			} else {
+				dispstat = GBARegisterDISPSTATClearVcounter(dispstat);
+			}
+			video->p->memory.io[REG_DISPSTAT >> 1] = dispstat;
+
+			// Note: state may be recorded during callbacks, so ensure it is consistent!
 			switch (video->vcount) {
+			case 0:
+				GBAFrameStarted(video->p);
+				break;
 			case VIDEO_VERTICAL_PIXELS:
-				video->dispstat = GBARegisterDISPSTATFillInVblank(video->dispstat);
+				video->p->memory.io[REG_DISPSTAT >> 1] = GBARegisterDISPSTATFillInVblank(dispstat);
 				if (GBASyncDrawingFrame(video->p->sync)) {
 					video->renderer->finishFrame(video->renderer);
 				}
 				video->nextVblankIRQ = video->nextEvent + VIDEO_TOTAL_LENGTH;
 				GBAMemoryRunVblankDMAs(video->p, lastEvent);
-				if (GBARegisterDISPSTATIsVblankIRQ(video->dispstat)) {
+				if (GBARegisterDISPSTATIsVblankIRQ(dispstat)) {
 					GBARaiseIRQ(video->p, IRQ_VBLANK);
 				}
+				GBAFrameEnded(video->p);
 				GBASyncPostFrame(video->p->sync);
 				++video->frameCounter;
 				break;
 			case VIDEO_VERTICAL_TOTAL_PIXELS - 1:
-				if (video->p->rr) {
-					GBARRNextFrame(video->p->rr);
-				}
-				video->dispstat = GBARegisterDISPSTATClearInVblank(video->dispstat);
-				break;
-			case VIDEO_VERTICAL_TOTAL_PIXELS:
-				video->vcount = 0;
-				video->p->memory.io[REG_VCOUNT >> 1] = 0;
+				video->p->memory.io[REG_DISPSTAT >> 1] = GBARegisterDISPSTATClearInVblank(dispstat);
 				break;
 			}
-
-			if (video->vcount == GBARegisterDISPSTATGetVcountSetting(video->dispstat)) {
-				video->dispstat = GBARegisterDISPSTATFillVcounter(video->dispstat);
-				if (GBARegisterDISPSTATIsVcounterIRQ(video->dispstat)) {
-					GBARaiseIRQ(video->p, IRQ_VCOUNTER);
-					video->nextVcounterIRQ += VIDEO_TOTAL_LENGTH;
-				}
-			} else {
-				video->dispstat = GBARegisterDISPSTATClearVcounter(video->dispstat);
-			}
 		} else {
 			// Begin Hblank
-			video->dispstat = GBARegisterDISPSTATFillInHblank(video->dispstat);
+			dispstat = GBARegisterDISPSTATFillInHblank(dispstat);
 			video->lastHblank = video->nextHblank;
 			video->nextEvent = video->lastHblank + VIDEO_HBLANK_LENGTH;
 			video->nextHblank = video->nextEvent + VIDEO_HDRAW_LENGTH;
@@ -155,25 +158,24 @@
 			if (video->vcount < VIDEO_VERTICAL_PIXELS) {
 				GBAMemoryRunHblankDMAs(video->p, lastEvent);
 			}
-			if (GBARegisterDISPSTATIsHblankIRQ(video->dispstat)) {
+			if (GBARegisterDISPSTATIsHblankIRQ(dispstat)) {
 				GBARaiseIRQ(video->p, IRQ_HBLANK);
 			}
+			video->p->memory.io[REG_DISPSTAT >> 1] = dispstat;
 		}
-
-		video->eventDiff = 0;
 	}
-	video->p->memory.io[REG_DISPSTAT >> 1] &= 0xFFF8;
-	video->p->memory.io[REG_DISPSTAT >> 1] |= video->dispstat & 0x7;
 	return video->nextEvent;
 }
 
 void GBAVideoWriteDISPSTAT(struct GBAVideo* video, uint16_t value) {
-	video->dispstat &= 0x7;
-	video->dispstat |= value & 0xFFF8;
+	video->p->memory.io[REG_DISPSTAT >> 1] &= 0x7;
+	video->p->memory.io[REG_DISPSTAT >> 1] |= value & 0xFFF8;
+
+	uint16_t dispstat = video->p->memory.io[REG_DISPSTAT >> 1];
 
-	if (GBARegisterDISPSTATIsVcounterIRQ(video->dispstat)) {
+	if (GBARegisterDISPSTATIsVcounterIRQ(dispstat)) {
 		// FIXME: this can be too late if we're in the middle of an Hblank
-		video->nextVcounterIRQ = video->nextHblank + VIDEO_HBLANK_LENGTH + (GBARegisterDISPSTATGetVcountSetting(video->dispstat) - video->vcount) * VIDEO_HORIZONTAL_LENGTH;
+		video->nextVcounterIRQ = video->nextHblank + VIDEO_HBLANK_LENGTH + (GBARegisterDISPSTATGetVcountSetting(dispstat) - video->vcount) * VIDEO_HORIZONTAL_LENGTH;
 		if (video->nextVcounterIRQ < video->nextEvent) {
 			video->nextVcounterIRQ += VIDEO_TOTAL_LENGTH;
 		}
@@ -237,7 +239,6 @@ void GBAVideoSerialize(struct GBAVideo* video, struct GBASerializedState* state) {
 	memcpy(state->vram, video->renderer->vram, SIZE_VRAM);
 	memcpy(state->oam, video->oam.raw, SIZE_OAM);
 	memcpy(state->pram, video->palette, SIZE_PALETTE_RAM);
-	state->io[REG_DISPSTAT >> 1] = video->dispstat;
 	state->video.nextEvent = video->nextEvent;
 	state->video.eventDiff = video->eventDiff;
 	state->video.lastHblank = video->lastHblank;
@@ -257,7 +258,6 @@ }
 	for (i = 0; i < SIZE_PALETTE_RAM; i += 2) {
 		GBAStore16(video->p->cpu, BASE_PALETTE_RAM | i, state->pram[i >> 1], 0);
 	}
-	video->dispstat = state->io[REG_DISPSTAT >> 1];
 	video->nextEvent = state->video.nextEvent;
 	video->eventDiff = state->video.eventDiff;
 	video->lastHblank = state->video.lastHblank;

@@ -173,8 +173,6 @@ struct GBAVideo {
 	struct GBA* p;
 	struct GBAVideoRenderer* renderer;
 
-	GBARegisterDISPSTAT dispstat;
-
 	// VCOUNT
 	int vcount;
 

@@ -8,6 +8,7 @@
 #include "gba-bios.h"
 #include "gba-io.h"
 #include "gba-rr.h"
+#include "gba-serialize.h"
 #include "gba-sio.h"
 #include "gba-thread.h"
 
@@ -80,6 +81,7 @@ gba->idleLoop = -1;
 	gba->lastJump = 0;
 	gba->idleDetectionStep = 0;
 	gba->idleDetectionFailures = 0;
+	gba->performingDMA = false;
 }
 
 void GBADestroy(struct GBA* gba) {
@@ -280,7 +282,6 @@ timer = &gba->timers[2];
 		if (timer->enable) {
 			timer->nextEvent -= cycles;
 			timer->lastEvent -= cycles;
-			nextEvent = timer->nextEvent;
 			if (timer->nextEvent <= 0) {
 				timer->lastEvent = timer->nextEvent;
 				timer->nextEvent += timer->overflowInterval;
@@ -312,7 +313,6 @@ timer = &gba->timers[3];
 		if (timer->enable) {
 			timer->nextEvent -= cycles;
 			timer->lastEvent -= cycles;
-			nextEvent = timer->nextEvent;
 			if (timer->nextEvent <= 0) {
 				timer->lastEvent = timer->nextEvent;
 				timer->nextEvent += timer->overflowInterval;
@@ -627,7 +627,11 @@ struct GBA* gba = (struct GBA*) cpu->master;
 	enum GBALogLevel level = GBA_LOG_FATAL;
 	if (gba->debugger) {
 		level = GBA_LOG_STUB;
-		ARMDebuggerEnter(gba->debugger, DEBUGGER_ENTER_ILLEGAL_OP);
+		struct DebuggerEntryInfo info = {
+			.address = cpu->gprs[ARM_PC],
+			.opcode = opcode
+		};
+		ARMDebuggerEnter(gba->debugger, DEBUGGER_ENTER_ILLEGAL_OP, &info);
 	}
 	GBALog(gba, level, "Stub opcode: %08x", opcode);
 }
@@ -636,6 +640,46 @@ void GBAIllegal(struct ARMCore* cpu, uint32_t opcode) {
 	struct GBA* gba = (struct GBA*) cpu->master;
 	GBALog(gba, GBA_LOG_WARN, "Illegal opcode: %08x", opcode);
 	if (gba->debugger) {
-		ARMDebuggerEnter(gba->debugger, DEBUGGER_ENTER_ILLEGAL_OP);
+		struct DebuggerEntryInfo info = {
+			.address = cpu->gprs[ARM_PC],
+			.opcode = opcode
+		};
+		ARMDebuggerEnter(gba->debugger, DEBUGGER_ENTER_ILLEGAL_OP, &info);
+	}
+}
+
+void GBAFrameStarted(struct GBA* gba) {
+	UNUSED(gba);
+
+	struct GBAThread* thread = GBAThreadGetContext();
+	if (!thread) {
+		return;
+	}
+
+	if (thread->rewindBuffer) {
+		--thread->rewindBufferNext;
+		if (thread->rewindBufferNext <= 0) {
+			thread->rewindBufferNext = thread->rewindBufferInterval;
+			GBARecordFrame(thread);
+		}
+	}
+}
+
+void GBAFrameEnded(struct GBA* gba) {
+	if (gba->rr) {
+		GBARRNextFrame(gba->rr);
+	}
+
+	struct GBAThread* thread = GBAThreadGetContext();
+	if (!thread) {
+		return;
+	}
+
+	if (thread->stream) {
+		thread->stream->postVideoFrame(thread->stream, thread->renderer);
+	}
+
+	if (thread->frameCallback) {
+		thread->frameCallback(thread);
 	}
 }

@@ -118,6 +118,7 @@
 	struct ARMDebugger* debugger;
 
 	uint32_t bus;
+	bool performingDMA;
 
 	int timersEnabled;
 	struct GBATimer timers[4];
@@ -192,6 +193,9 @@ bool GBAIsROM(struct VFile* vf);
 bool GBAIsBIOS(struct VFile* vf);
 void GBAGetGameCode(struct GBA* gba, char* out);
 void GBAGetGameTitle(struct GBA* gba, char* out);
+
+void GBAFrameStarted(struct GBA* gba);
+void GBAFrameEnded(struct GBA* gba);
 
 __attribute__((format (printf, 3, 4)))
 void GBALog(struct GBA* gba, enum GBALogLevel level, const char* format, ...);

@@ -90,7 +90,11 @@ opts.videoSync = false;
 	GBAMapArgumentsToContext(&args, &context);
 	GBAMapOptionsToContext(&opts, &context);
 
-	GBAThreadStart(&context);
+	int didStart = GBAThreadStart(&context);
+
+	if (!didStart) {
+		goto cleanup;
+	}
 	GBAGetGameCode(context.gba, gameCode);
 
 	int frames = perfOpts.frames;
@@ -106,12 +110,6 @@ uint64_t end = 1000000LL * tv.tv_sec + tv.tv_usec;
 	uint64_t duration = end - start;
 
 	GBAThreadJoin(&context);
-	GBAConfigFreeOpts(&opts);
-	freeArguments(&args);
-	GBAConfigDeinit(&config);
-	free(context.debugger);
-
-	free(renderer.outputBuffer);
 
 	float scaledFrames = frames * 1000000.f;
 	if (perfOpts.csv) {
@@ -127,7 +125,14 @@ } else {
 		printf("%u frames in %" PRIu64 " microseconds: %g fps (%gx)\n", frames, duration, scaledFrames / duration, scaledFrames / (duration * 60.f));
 	}
 
-	return GBAThreadHasCrashed(&context);
+cleanup:
+	GBAConfigFreeOpts(&opts);
+	freeArguments(&args);
+	GBAConfigDeinit(&config);
+	free(context.debugger);
+	free(renderer.outputBuffer);
+
+	return !didStart || GBAThreadHasCrashed(&context);
 }
 
 static void _GBAPerfRunloop(struct GBAThread* context, int* frames, bool quiet) {

@@ -12,6 +12,7 @@ #include <QDir>
 #include <QMenu>
 
 extern "C" {
+#include "gba-overrides.h"
 #include "platform/commandline.h"
 }
 
@@ -155,6 +156,11 @@ if (!group.isNull()) {
 		m_settings->endGroup();
 	}
 	return value;
+}
+
+void ConfigController::saveOverride(const GBACartridgeOverride& override) {
+	GBAOverrideSave(overrides(), &override);
+	write();
 }
 
 void ConfigController::setOption(const char* key, bool value) {

@@ -22,6 +22,7 @@ class QAction;
 class QMenu;
 
 struct GBAArguments;
+struct GBACartridgeOverride;
 
 namespace QGBA {
 
@@ -76,6 +77,7 @@ QList<QString> getMRU() const;
 	void setMRU(const QList<QString>& mru);
 
 	Configuration* overrides() { return &m_config.configTable; } // TODO: Make this not return the whole table
+	void saveOverride(const GBACartridgeOverride&);
 
 public slots:
 	void setOption(const char* key, bool value);

@@ -23,18 +23,24 @@ #ifdef BUILD_SDL
 	SDL_Init(SDL_INIT_NOPARACHUTE);
 #endif
 
-    QApplication::setApplicationName(PROJECT_NAME);
-    QApplication::setApplicationVersion(PROJECT_VERSION);
+	QApplication::setApplicationName(PROJECT_NAME);
+	QApplication::setApplicationVersion(PROJECT_VERSION);
 
-    m_window.show();
+#ifndef Q_OS_MAC
+	m_window.show();
+#endif
 
 	GBAArguments args = {};
-    if (m_configController.parseArguments(&args, argc, argv)) {
+	if (m_configController.parseArguments(&args, argc, argv)) {
 		m_window.argumentsPassed(&args);
-    } else {
+	} else {
 		m_window.loadConfig();
-    }
+	}
 	freeArguments(&args);
+
+#ifdef Q_OS_MAC
+	m_window.show();
+#endif
 }
 
 bool GBAApp::event(QEvent* event) {

@@ -40,13 +40,13 @@ if (isAttached()) {
 		return;
 	}
 	m_gameController->setDebugger(&m_gdbStub.d);
+	ARMDebuggerEnter(&m_gdbStub.d, DEBUGGER_ENTER_ATTACHED, 0);
 }
 
 void GDBController::detach() {
 	if (!isAttached()) {
 		return;
 	}
-	disconnect(m_gameController, SIGNAL(frameAvailable(const uint32_t*)), this, SLOT(updateGDB()));
 	m_gameController->threadInterrupt();
 	GDBStubShutdown(&m_gdbStub);
 	m_gameController->setDebugger(nullptr);
@@ -58,13 +58,11 @@ m_gameController->threadInterrupt();
 	if (!isAttached()) {
 		attach();
 	}
-	connect(m_gameController, SIGNAL(frameAvailable(const uint32_t*)), this, SLOT(updateGDB()));
-	GDBStubListen(&m_gdbStub, m_port, &m_bindAddress);
-	m_gameController->threadContinue();
-}
-
-void GDBController::updateGDB() {
-	m_gameController->threadInterrupt();
-	GDBStubUpdate(&m_gdbStub);
+	if (GDBStubListen(&m_gdbStub, m_port, &m_bindAddress)) {
+		emit listening();
+	} else {
+		detach();
+		emit listenFailed();
+	}
 	m_gameController->threadContinue();
 }

@@ -35,8 +35,9 @@ void attach();
 	void detach();
 	void listen();
 
-private slots:
-	void updateGDB();
+signals:
+	void listening();
+	void listenFailed();
 
 private:
 	GDBStub m_gdbStub;

@@ -9,6 +9,7 @@ #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QLineEdit>
+#include <QMessageBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
@@ -46,6 +47,9 @@ settingsGrid->addWidget(m_bindAddressEdit, 1, 1, Qt::AlignLeft);
 
 	m_startStopButton = new QPushButton;
 	mainSegment->addWidget(m_startStopButton);
+	connect(m_gdbController, SIGNAL(listening()), this, SLOT(started()));
+	connect(m_gdbController, SIGNAL(listenFailed()), this, SLOT(failed()));
+
 	if (m_gdbController->isAttached()) {
 		started();
 	} else {
@@ -88,7 +92,6 @@ m_portEdit->setEnabled(false);
 	m_bindAddressEdit->setEnabled(false);
 	m_startStopButton->setText(tr("Stop"));
 	disconnect(m_startStopButton, SIGNAL(clicked()), m_gdbController, SLOT(listen()));
-	disconnect(m_startStopButton, SIGNAL(clicked()), this, SLOT(started()));
 	connect(m_startStopButton, SIGNAL(clicked()), m_gdbController, SLOT(detach()));
 	connect(m_startStopButton, SIGNAL(clicked()), this, SLOT(stopped()));
 }
@@ -100,5 +103,12 @@ m_startStopButton->setText(tr("Start"));
 	disconnect(m_startStopButton, SIGNAL(clicked()), m_gdbController, SLOT(detach()));
 	disconnect(m_startStopButton, SIGNAL(clicked()), this, SLOT(stopped()));
 	connect(m_startStopButton, SIGNAL(clicked()), m_gdbController, SLOT(listen()));
-	connect(m_startStopButton, SIGNAL(clicked()), this, SLOT(started()));
+}
+
+void GDBWindow::failed() {
+	QMessageBox* failure = new QMessageBox(QMessageBox::Warning, tr("Crash"),
+		tr("Could not start GDB server"),
+		QMessageBox::Ok, this,  Qt::Sheet);
+	failure->setAttribute(Qt::WA_DeleteOnClose);
+	failure->show();
 }

@@ -28,6 +28,8 @@
 	void started();
 	void stopped();
 
+	void failed();
+
 private:
 	GDBController* m_gdbController;
 

@@ -24,6 +24,8 @@
 using namespace QGBA;
 using namespace std;
 
+const int GameController::LUX_LEVELS[10] = { 5, 11, 18, 27, 42, 62, 84, 109, 139, 183 };
+
 GameController::GameController(QObject* parent)
 	: QObject(parent)
 	, m_drawContext(new uint32_t[256 * 256])
@@ -62,6 +64,7 @@ m_lux.readLuminance = [] (GBALuminanceSource* context) {
 		GameControllerLux* lux = static_cast<GameControllerLux*>(context);
 		return lux->value;
 	};
+	setLuminanceLevel(0);
 
 	m_rtc.p = this;
 	m_rtc.override = GameControllerRTC::NO_OVERRIDE;
@@ -137,6 +140,11 @@ delete m_renderer;
 	delete[] m_drawContext;
 }
 
+void GameController::setOverride(const GBACartridgeOverride& override) {
+	m_threadContext.override = override;
+	m_threadContext.hasOverride = true;
+}
+
 #ifdef USE_GDB_STUB
 ARMDebugger* GameController::debugger() {
 	return m_threadContext.debugger;
@@ -183,6 +191,7 @@ m_threadContext.sync.videoFrameWait = m_videoSync;
 		m_threadContext.sync.audioWait = m_audioSync;
 	}
 
+	m_threadContext.gameDir = 0;
 	m_threadContext.fname = strdup(m_fname.toLocal8Bit().constData());
 	if (m_dirmode) {
 		m_threadContext.gameDir = VDirOpen(m_threadContext.fname);
@@ -190,7 +199,14 @@ m_threadContext.stateDir = m_threadContext.gameDir;
 	} else {
 		m_threadContext.rom = VFileOpen(m_threadContext.fname, O_RDONLY);
 #if ENABLE_LIBZIP
-		m_threadContext.gameDir = VDirOpenZip(m_threadContext.fname, 0);
+		if (!m_threadContext.gameDir) {
+			m_threadContext.gameDir = VDirOpenZip(m_threadContext.fname, 0);
+		}
+#endif
+#if ENABLE_LZMA
+		if (!m_threadContext.gameDir) {
+			m_threadContext.gameDir = VDirOpen7z(m_threadContext.fname, 0);
+		}
 #endif
 	}
 
@@ -417,6 +433,27 @@ void GameController::clearAVStream() {
 	threadInterrupt();
 	m_threadContext.stream = nullptr;
 	threadContinue();
+}
+
+void GameController::setLuminanceValue(uint8_t value) {
+	m_luxValue = value;
+	value = std::max<int>(value - 0x16, 0);
+	m_luxLevel = 10;
+	for (int i = 0; i < 10; ++i) {
+		if (value < LUX_LEVELS[i]) {
+			m_luxLevel = i;
+			break;
+		}
+	}
+}
+
+void GameController::setLuminanceLevel(int level) {
+	int value = 0x16;
+	level = std::max(0, std::min(10, level));
+	if (level > 0) {
+		value += LUX_LEVELS[level - 1];
+	}
+	setLuminanceValue(value);
 }
 
 void GameController::setRealTime() {

@@ -56,6 +56,9 @@
 	void setInputController(InputController* controller) { m_inputController = controller; }
 	void setOverrides(Configuration* overrides) { m_threadContext.overrides = overrides; }
 
+	void setOverride(const GBACartridgeOverride& override);
+	void clearOverride() { m_threadContext.hasOverride = false; }
+
 #ifdef USE_GDB_STUB
 	ARMDebugger* debugger();
 	void setDebugger(ARMDebugger*);
@@ -98,7 +101,11 @@ void setFrameskip(int);
 	void setTurbo(bool, bool forced = true);
 	void setAVStream(GBAAVStream*);
 	void clearAVStream();
-	void setLuminanceValue(uint8_t value) { m_luxValue = value; }
+
+	void setLuminanceValue(uint8_t value);
+	void setLuminanceLevel(int level);
+	void increaseLuminanceLevel() { setLuminanceLevel(m_luxLevel + 1); }
+	void decreaseLuminanceLevel() { setLuminanceLevel(m_luxLevel - 1); }
 
 	void setRealTime();
 	void setFixedTime(const QDateTime& time);
@@ -154,6 +161,9 @@ GameController* p;
 		uint8_t value;
 	} m_lux;
 	uint8_t m_luxValue;
+	int m_luxLevel;
+
+	static const int LUX_LEVELS[10];
 
 	struct GameControllerRTC : GBARTCSource {
 		GameController* p;

@@ -5,6 +5,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "GamePakView.h"
 
+#include "ConfigController.h"
 #include "GameController.h"
 
 extern "C" {
@@ -13,9 +14,10 @@ }
 
 using namespace QGBA;
 
-GamePakView::GamePakView(GameController* controller, QWidget* parent)
+GamePakView::GamePakView(GameController* controller, ConfigController* config, QWidget* parent)
 	: QWidget(parent)
 	, m_controller(controller)
+	, m_config(config)
 {
 	m_ui.setupUi(this);
 
@@ -38,46 +40,116 @@ connect(m_ui.timeNow, &QPushButton::clicked, [controller, this] () {
 		m_ui.time->setDateTime(QDateTime::currentDateTime());
 	});
 
+	connect(m_ui.hwAutodetect, &QAbstractButton::toggled, [this] (bool enabled) {
+		m_ui.hwRTC->setEnabled(!enabled);
+		m_ui.hwGyro->setEnabled(!enabled);
+		m_ui.hwLight->setEnabled(!enabled);
+		m_ui.hwTilt->setEnabled(!enabled);
+		m_ui.hwRumble->setEnabled(!enabled);
+	});
+
+	connect(m_ui.savetype, SIGNAL(currentIndexChanged(int)), this, SLOT(updateOverrides()));
+	connect(m_ui.hwAutodetect, SIGNAL(clicked()), this, SLOT(updateOverrides()));
+	connect(m_ui.hwRTC, SIGNAL(clicked()), this, SLOT(updateOverrides()));
+	connect(m_ui.hwGyro, SIGNAL(clicked()), this, SLOT(updateOverrides()));
+	connect(m_ui.hwLight, SIGNAL(clicked()), this, SLOT(updateOverrides()));
+	connect(m_ui.hwTilt, SIGNAL(clicked()), this, SLOT(updateOverrides()));
+	connect(m_ui.hwRumble, SIGNAL(clicked()), this, SLOT(updateOverrides()));
+
+	connect(m_ui.save, SIGNAL(clicked()), this, SLOT(saveOverride()));
+
 	if (controller->isLoaded()) {
 		gameStarted(controller->thread());
 	}
 }
 
-void GamePakView::gameStarted(GBAThread* thread) {
-	if (!thread->gba) {
-		gameStopped();
+void GamePakView::saveOverride() {
+	if (!m_config) {
 		return;
 	}
-	SavedataType savetype = thread->gba->memory.savedata.type;
-	if (m_ui.savetype->currentIndex() > 0) {
-		if (savetype > SAVEDATA_FORCE_NONE) {
-			VFile* vf = thread->gba->memory.savedata.vf;
-			GBASavedataDeinit(&thread->gba->memory.savedata);
-			GBASavedataInit(&thread->gba->memory.savedata, vf);
+	m_config->saveOverride(m_override);
+}
+
+void GamePakView::updateOverrides() {
+	m_override = (GBACartridgeOverride) {
+		"",
+		static_cast<SavedataType>(m_ui.savetype->currentIndex() - 1),
+		GPIO_NO_OVERRIDE,
+		0xFFFFFFFF
+	};
+
+	if (!m_ui.hwAutodetect->isChecked()) {
+		m_override.hardware = GPIO_NONE;
+		if (m_ui.hwRTC->isChecked()) {
+			m_override.hardware |= GPIO_RTC;
 		}
-		savetype = static_cast<SavedataType>(m_ui.savetype->currentIndex() - 1);
-		GBASavedataForceType(&thread->gba->memory.savedata, savetype);
+		if (m_ui.hwGyro->isChecked()) {
+			m_override.hardware |= GPIO_GYRO;
+		}
+		if (m_ui.hwLight->isChecked()) {
+			m_override.hardware |= GPIO_LIGHT_SENSOR;
+		}
+		if (m_ui.hwTilt->isChecked()) {
+			m_override.hardware |= GPIO_TILT;
+		}
+		if (m_ui.hwRumble->isChecked()) {
+			m_override.hardware |= GPIO_RUMBLE;
+		}
 	}
 
-	if (savetype > SAVEDATA_AUTODETECT) {
-		m_ui.savetype->setCurrentIndex(savetype + 1);
+	if (m_override.savetype != SAVEDATA_AUTODETECT || m_override.hardware != GPIO_NO_OVERRIDE) {
+		m_controller->setOverride(m_override);
+	} else {
+		m_controller->clearOverride();
+	}
+}
+
+void GamePakView::gameStarted(GBAThread* thread) {
+	if (!thread->gba) {
+		gameStopped();
+		return;
 	}
+	m_ui.savetype->setCurrentIndex(thread->gba->memory.savedata.type + 1);
 	m_ui.savetype->setEnabled(false);
 
-	m_ui.sensorRTC->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_RTC);
-	m_ui.sensorGyro->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_GYRO);
-	m_ui.sensorLight->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_LIGHT_SENSOR);
-	m_ui.sensorTilt->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_TILT);
+	m_ui.hwAutodetect->setEnabled(false);
+	m_ui.hwRTC->setEnabled(false);
+	m_ui.hwGyro->setEnabled(false);
+	m_ui.hwLight->setEnabled(false);
+	m_ui.hwTilt->setEnabled(false);
+	m_ui.hwRumble->setEnabled(false);
+
+	m_ui.hwRTC->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_RTC);
+	m_ui.hwGyro->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_GYRO);
+	m_ui.hwLight->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_LIGHT_SENSOR);
+	m_ui.hwTilt->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_TILT);
+	m_ui.hwRumble->setChecked(thread->gba->memory.gpio.gpioDevices & GPIO_RUMBLE);
+
+	GBAGetGameCode(thread->gba, m_override.id);
+	m_override.hardware = thread->gba->memory.gpio.gpioDevices;
+	m_override.savetype = thread->gba->memory.savedata.type;
+
+	m_ui.save->setEnabled(m_config);
 }
 
 void GamePakView::gameStopped() {	
 	m_ui.savetype->setCurrentIndex(0);
 	m_ui.savetype->setEnabled(true);
 
-	m_ui.sensorRTC->setChecked(false);
-	m_ui.sensorGyro->setChecked(false);
-	m_ui.sensorLight->setChecked(false);
-	m_ui.sensorTilt->setChecked(false);
+	m_ui.hwAutodetect->setEnabled(true);
+	m_ui.hwRTC->setEnabled(!m_ui.hwAutodetect->isChecked());
+	m_ui.hwGyro->setEnabled(!m_ui.hwAutodetect->isChecked());
+	m_ui.hwLight->setEnabled(!m_ui.hwAutodetect->isChecked());
+	m_ui.hwTilt->setEnabled(!m_ui.hwAutodetect->isChecked());
+	m_ui.hwRumble->setEnabled(!m_ui.hwAutodetect->isChecked());
+
+	m_ui.hwRTC->setChecked(false);
+	m_ui.hwGyro->setChecked(false);
+	m_ui.hwLight->setChecked(false);
+	m_ui.hwTilt->setChecked(false);
+	m_ui.hwRumble->setChecked(false);
+
+	m_ui.save->setEnabled(false);
 }
 
 void GamePakView::setLuminanceValue(int value) {

@@ -10,19 +10,28 @@ #include <QWidget>
 
 #include "ui_GamePakView.h"
 
+extern "C" {
+#include "gba-overrides.h"
+}
+
 struct GBAThread;
 
 namespace QGBA {
 
+class ConfigController;
 class GameController;
 
 class GamePakView : public QWidget {
 Q_OBJECT
 
 public:
-	GamePakView(GameController* controller, QWidget* parent = nullptr);
+	GamePakView(GameController* controller, ConfigController* config, QWidget* parent = nullptr);
+
+public slots:
+	void saveOverride();
 
 private slots:
+	void updateOverrides();
 	void gameStarted(GBAThread*);
 	void gameStopped();
 	void setLuminanceValue(int);
@@ -31,6 +40,8 @@ private:
 	Ui::GamePakView m_ui;
 
 	GameController* m_controller;
+	ConfigController* m_config;
+	GBACartridgeOverride m_override;
 };
 
 }

@@ -6,8 +6,8 @@ <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>259</width>
-    <height>373</height>
+    <width>251</width>
+    <height>433</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -29,6 +29,47 @@ <layout class="QFormLayout" name="formLayout">
       <property name="fieldGrowthPolicy">
        <enum>QFormLayout::FieldsStayAtSizeHint</enum>
       </property>
+      <item row="0" column="0">
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>Save type</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QComboBox" name="savetype">
+        <item>
+         <property name="text">
+          <string>Autodetect</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>None</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>SRAM</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Flash 512kb</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Flash 1Mb</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>EEPROM</string>
+         </property>
+        </item>
+       </widget>
+      </item>
       <item row="1" column="0" colspan="2">
        <widget class="Line" name="line">
         <property name="orientation">
@@ -39,15 +80,12 @@ </item>
       <item row="2" column="0">
        <widget class="QLabel" name="label_2">
         <property name="text">
-         <string>Sensors</string>
+         <string>Hardware</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
-       <widget class="QCheckBox" name="sensorAutodetect">
-        <property name="enabled">
-         <bool>false</bool>
-        </property>
+       <widget class="QCheckBox" name="hwAutodetect">
         <property name="text">
          <string>Autodetect</string>
         </property>
@@ -57,7 +95,7 @@ </property>
        </widget>
       </item>
       <item row="3" column="1">
-       <widget class="QCheckBox" name="sensorRTC">
+       <widget class="QCheckBox" name="hwRTC">
         <property name="enabled">
          <bool>false</bool>
         </property>
@@ -67,7 +105,7 @@ </property>
        </widget>
       </item>
       <item row="4" column="1">
-       <widget class="QCheckBox" name="sensorGyro">
+       <widget class="QCheckBox" name="hwGyro">
         <property name="enabled">
          <bool>false</bool>
         </property>
@@ -77,7 +115,7 @@ </property>
        </widget>
       </item>
       <item row="5" column="1">
-       <widget class="QCheckBox" name="sensorTilt">
+       <widget class="QCheckBox" name="hwTilt">
         <property name="enabled">
          <bool>false</bool>
         </property>
@@ -87,7 +125,7 @@ </property>
        </widget>
       </item>
       <item row="6" column="1">
-       <widget class="QCheckBox" name="sensorLight">
+       <widget class="QCheckBox" name="hwLight">
         <property name="enabled">
          <bool>false</bool>
         </property>
@@ -96,46 +134,55 @@ <string>Light sensor</string>
         </property>
        </widget>
       </item>
-      <item row="0" column="1">
-       <widget class="QComboBox" name="savetype">
-        <item>
-         <property name="text">
-          <string>Autodetect</string>
-         </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>None</string>
-         </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>SRAM</string>
-         </property>
-        </item>
+      <item row="7" column="1">
+       <widget class="QCheckBox" name="hwRumble">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="text">
+         <string>Rumble</string>
+        </property>
+       </widget>
+      </item>
+      <item row="8" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
         <item>
-         <property name="text">
-          <string>Flash 512kb</string>
-         </property>
+         <spacer name="horizontalSpacer_2">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
         </item>
         <item>
-         <property name="text">
-          <string>Flash 1Mb</string>
-         </property>
+         <widget class="QPushButton" name="save">
+          <property name="enabled">
+           <bool>false</bool>
+          </property>
+          <property name="text">
+           <string>Save overrides</string>
+          </property>
+         </widget>
         </item>
         <item>
-         <property name="text">
-          <string>EEPROM</string>
-         </property>
+         <spacer name="horizontalSpacer">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
         </item>
-       </widget>
-      </item>
-      <item row="0" column="0">
-       <widget class="QLabel" name="label">
-        <property name="text">
-         <string>Save type</string>
-        </property>
-       </widget>
+       </layout>
       </item>
      </layout>
     </widget>

@@ -11,6 +11,7 @@ #include <QKeyEvent>
 #include <QKeySequence>
 #include <QMenuBar>
 #include <QMessageBox>
+#include <QMimeData>
 #include <QStackedLayout>
 
 #include "ConfigController.h"
@@ -54,6 +55,7 @@ , m_shortcutController(new ShortcutController(this))
 {
 	setWindowTitle(PROJECT_NAME);
 	setFocusPolicy(Qt::StrongFocus);
+	setAcceptDrops(true);
 	m_controller = new GameController(this);
 	m_controller->setInputController(&m_inputController);
 	m_controller->setOverrides(m_config->overrides());
@@ -227,7 +229,7 @@ shortcutView->show();
 }
 
 void Window::openGamePakWindow() {
-	GamePakView* gamePakWindow = new GamePakView(m_controller);
+	GamePakView* gamePakWindow = new GamePakView(m_controller, m_config);
 	connect(this, SIGNAL(shutdown()), gamePakWindow, SLOT(close()));
 	gamePakWindow->setAttribute(Qt::WA_DeleteOnClose);
 	gamePakWindow->show();
@@ -276,6 +278,8 @@ if (!m_gdbController) {
 		m_gdbController = new GDBController(m_controller, this);
 	}
 	GDBWindow* window = new GDBWindow(m_gdbController);
+	connect(this, SIGNAL(shutdown()), window, SLOT(close()));
+	window->setAttribute(Qt::WA_DeleteOnClose);
 	window->show();
 }
 #endif
@@ -324,6 +328,28 @@ m_controller->setTurbo(false, false);
 	m_controller->clearKeys();
 }
 
+void Window::dragEnterEvent(QDragEnterEvent* event) {
+	if (event->mimeData()->hasFormat("text/uri-list")) {
+		event->acceptProposedAction();
+	}
+}
+
+void Window::dropEvent(QDropEvent* event) {
+	QString uris = event->mimeData()->data("text/uri-list");
+	uris = uris.trimmed();
+	if (uris.contains("\n")) {
+		// Only one file please
+		return;
+	}
+	QUrl url(uris);
+	if (!url.isLocalFile()) {
+		// No remote loading
+		return;
+	}
+	event->accept();
+	m_controller->loadGame(url.path());
+}
+
 void Window::toggleFullScreen() {
 	if (isFullScreen()) {
 		showNormal();
@@ -411,11 +437,15 @@ }
 }
 
 void Window::showFPS() {
+	char title[13] = { '\0' };
+	GBAGetGameTitle(m_controller->thread()->gba, title);
+	if (m_frameList.isEmpty()) {
+		setWindowTitle(tr(PROJECT_NAME " - %1").arg(title));
+		return;
+	}
 	qint64 interval = m_frameList.first().msecsTo(m_frameList.last());
 	float fps = (m_frameList.count() - 1) * 10000.f / interval;
 	fps = round(fps) / 10.f;
-	char title[13] = { '\0' };
-	GBAGetGameTitle(m_controller->thread()->gba, title);
 	setWindowTitle(tr(PROJECT_NAME " - %1 (%2 fps)").arg(title).arg(fps));
 }
 
@@ -651,6 +681,23 @@ QAction* gdbWindow = new QAction(tr("Start &GDB server..."), toolsMenu);
 	connect(gdbWindow, SIGNAL(triggered()), this, SLOT(gdbOpen()));
 	addControlledAction(toolsMenu, gdbWindow, "gdbWindow");
 #endif
+
+	toolsMenu->addSeparator();
+	QAction* solarIncrease = new QAction(tr("Increase solar level"), toolsMenu);
+	connect(solarIncrease, SIGNAL(triggered()), m_controller, SLOT(increaseLuminanceLevel()));
+	addControlledAction(toolsMenu, solarIncrease, "increaseLuminanceLevel");
+
+	QAction* solarDecrease = new QAction(tr("Decrease solar level"), toolsMenu);
+	connect(solarDecrease, SIGNAL(triggered()), m_controller, SLOT(decreaseLuminanceLevel()));
+	addControlledAction(toolsMenu, solarDecrease, "decreaseLuminanceLevel");
+
+	QAction* maxSolar = new QAction(tr("Brightest solar level"), toolsMenu);
+	connect(maxSolar, &QAction::triggered, [this]() { m_controller->setLuminanceLevel(10); });
+	addControlledAction(toolsMenu, maxSolar, "maxLuminanceLevel");
+
+	QAction* minSolar = new QAction(tr("Darkest solar level"), toolsMenu);
+	connect(minSolar, &QAction::triggered, [this]() { m_controller->setLuminanceLevel(0); });
+	addControlledAction(toolsMenu, minSolar, "minLuminanceLevel");
 
 	toolsMenu->addSeparator();
 	addControlledAction(toolsMenu, toolsMenu->addAction(tr("Settings..."), this, SLOT(openSettingsWindow())), "settings");

@@ -91,6 +91,8 @@ virtual void keyReleaseEvent(QKeyEvent* event) override;
 	virtual void resizeEvent(QResizeEvent*) override;
 	virtual void closeEvent(QCloseEvent*) override;
 	virtual void focusOutEvent(QFocusEvent*) override;
+	virtual void dragEnterEvent(QDragEnterEvent*) override;
+	virtual void dropEvent(QDropEvent*) override;
 
 private slots:
 	void gameStarted(GBAThread*);

@@ -59,8 +59,8 @@ SDL_SetVideoMode(renderer->viewportWidth, renderer->viewportHeight, 32, SDL_OPENGL);
 #endif
 #endif
 
-	renderer->d.outputBuffer = malloc(256 * 256 * 4);
-	renderer->d.outputBufferStride = 256;
+	renderer->d.outputBuffer = malloc(VIDEO_HORIZONTAL_PIXELS * VIDEO_VERTICAL_PIXELS * 4);
+	renderer->d.outputBufferStride = VIDEO_HORIZONTAL_PIXELS;
 	glGenTextures(1, &renderer->tex);
 	glBindTexture(GL_TEXTURE_2D, renderer->tex);
 	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
@@ -75,6 +75,17 @@ #ifndef _WIN32
 	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 #endif
+
+#ifdef COLOR_16_BIT
+#ifdef COLOR_5_6_5
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0);
+#else
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0);
+#endif
+#else
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+#endif
+
 
 	glViewport(0, 0, renderer->viewportWidth, renderer->viewportHeight);
 
@@ -109,12 +120,12 @@ if (GBASyncWaitFrameStart(&context->sync, context->frameskip)) {
 			glBindTexture(GL_TEXTURE_2D, renderer->tex);
 #ifdef COLOR_16_BIT
 #ifdef COLOR_5_6_5
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, renderer->d.outputBuffer);
+			glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, renderer->d.outputBuffer);
 #else
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, renderer->d.outputBuffer);
+			glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, renderer->d.outputBuffer);
 #endif
 #else
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, renderer->d.outputBuffer);
+			glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, GL_RGBA, GL_UNSIGNED_BYTE, renderer->d.outputBuffer);
 #endif
 			if (context->sync.videoFrameWait) {
 				glFlush();

@@ -105,12 +105,17 @@ GBASDLInitEvents(&renderer.events);
 	GBASDLEventsLoadConfig(&renderer.events, &config.configTable); // TODO: Don't use this directly
 	context.overrides = &config.configTable;
 
-	GBAThreadStart(&context);
-
-	GBASDLRunloop(&context, &renderer);
+	int didFail = 0;
+	if (GBAThreadStart(&context)) {
+		GBASDLRunloop(&context, &renderer);
+		GBAThreadJoin(&context);
+	} else {
+		didFail = 1;
+		printf("Could not run game. Are you sure the file exists and is a Game Boy Advance game?\n");
+	}
 
-	GBAThreadJoin(&context);
 	if (GBAThreadHasCrashed(&context)) {
+		didFail = 1;
 		printf("The game crashed!\n");
 	}
 	freeArguments(&args);
@@ -121,7 +126,7 @@ GBAInputMapDeinit(&inputMap);
 
 	_GBASDLDeinit(&renderer);
 
-	return 0;
+	return didFail;
 }
 
 static bool _GBASDLInit(struct SDLSoftwareRenderer* renderer) {

@@ -120,7 +120,7 @@ if (event->type == SDL_KEYDOWN) {
 		switch (event->keysym.sym) {
 		case SDLK_F11:
 			if (context->debugger) {
-				ARMDebuggerEnter(context->debugger, DEBUGGER_ENTER_MANUAL);
+				ARMDebuggerEnter(context->debugger, DEBUGGER_ENTER_MANUAL, 0);
 			}
 			return;
 #ifdef USE_PNG

@@ -0,0 +1,216 @@
+/* 7z.h -- 7z interface
+2013-01-18 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_H
+#define __7Z_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define k7zStartHeaderSize 0x20
+#define k7zSignatureSize 6
+
+extern Byte k7zSignature[k7zSignatureSize];
+
+typedef struct
+{
+  const Byte *Data;
+  size_t Size;
+} CSzData;
+
+/* CSzCoderInfo & CSzFolder support only default methods */
+
+typedef struct
+{
+  size_t PropsOffset;
+  UInt32 MethodID;
+  Byte NumInStreams;
+  Byte NumOutStreams;
+  Byte PropsSize;
+} CSzCoderInfo;
+
+typedef struct
+{
+  UInt32 InIndex;
+  UInt32 OutIndex;
+} CSzBindPair;
+
+#define SZ_NUM_CODERS_IN_FOLDER_MAX 4
+#define SZ_NUM_BINDS_IN_FOLDER_MAX 3
+#define SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX 4
+#define SZ_NUM_CODERS_OUT_STREAMS_IN_FOLDER_MAX 4
+
+typedef struct
+{
+  UInt32 NumCoders;
+  UInt32 NumBindPairs;
+  UInt32 NumPackStreams;
+  UInt32 MainOutStream;
+  UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];
+  CSzBindPair BindPairs[SZ_NUM_BINDS_IN_FOLDER_MAX];
+  CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX];
+  UInt64 CodersUnpackSizes[SZ_NUM_CODERS_OUT_STREAMS_IN_FOLDER_MAX];
+} CSzFolder;
+
+/*
+typedef struct
+{
+  size_t CodersDataOffset;
+  size_t UnpackSizeDataOffset;
+  // UInt32 StartCoderUnpackSizesIndex;
+  UInt32 StartPackStreamIndex;
+  // UInt32 IndexOfMainOutStream;
+} CSzFolder2;
+*/
+
+SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd, CSzData *sdSizes);
+
+typedef struct
+{
+  UInt32 Low;
+  UInt32 High;
+} CNtfsFileTime;
+
+typedef struct
+{
+  Byte *Defs; /* MSB 0 bit numbering */
+  UInt32 *Vals;
+} CSzBitUi32s;
+
+typedef struct
+{
+  Byte *Defs; /* MSB 0 bit numbering */
+  // UInt64 *Vals;
+  CNtfsFileTime *Vals;
+} CSzBitUi64s;
+
+#define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
+
+#define SzBitWithVals_Check(p, i) ((p)->Defs && ((p)->Defs[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
+
+typedef struct
+{
+  UInt32 NumPackStreams;
+  UInt32 NumFolders;
+
+  UInt64 *PackPositions; // NumPackStreams + 1
+  CSzBitUi32s FolderCRCs;
+
+  size_t *FoCodersOffsets;
+  size_t *FoSizesOffsets;
+  // UInt32 StartCoderUnpackSizesIndex;
+  UInt32 *FoStartPackStreamIndex;
+
+  // CSzFolder2 *Folders;  // +1 item for sum values
+  Byte *CodersData;
+  Byte *UnpackSizesData;
+  size_t UnpackSizesDataSize;
+  // UInt64 *CoderUnpackSizes;
+} CSzAr;
+
+
+SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
+    ILookInStream *stream, UInt64 startPos,
+    Byte *outBuffer, size_t outSize,
+    ISzAlloc *allocMain);
+
+/*
+  SzExtract extracts file from archive
+
+  *outBuffer must be 0 before first call for each new archive.
+
+  Extracting cache:
+    If you need to decompress more than one file, you can send
+    these values from previous call:
+      *blockIndex,
+      *outBuffer,
+      *outBufferSize
+    You can consider "*outBuffer" as cache of solid block. If your archive is solid,
+    it will increase decompression speed.
+  
+    If you use external function, you can declare these 3 cache variables
+    (blockIndex, outBuffer, outBufferSize) as static in that external function.
+    
+    Free *outBuffer and set *outBuffer to 0, if you want to flush cache.
+*/
+
+typedef struct
+{
+  CSzAr db;
+
+  UInt64 startPosAfterHeader;
+  UInt64 dataPos;
+  
+  UInt32 NumFiles;
+
+  UInt64 *UnpackPositions;
+  // Byte *IsEmptyFiles;
+  Byte *IsDirs;
+  CSzBitUi32s CRCs;
+
+  CSzBitUi32s Attribs;
+  // CSzBitUi32s Parents;
+  CSzBitUi64s MTime;
+  CSzBitUi64s CTime;
+
+  // UInt32 *FolderStartPackStreamIndex;
+  UInt32 *FolderStartFileIndex; // + 1
+  UInt32 *FileIndexToFolderIndexMap;
+
+  size_t *FileNameOffsets; /* in 2-byte steps */
+  Byte *FileNames;  /* UTF-16-LE */
+} CSzArEx;
+
+#define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i))
+
+#define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i])
+
+void SzArEx_Init(CSzArEx *p);
+void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc);
+UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
+int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
+
+/*
+if dest == NULL, the return value specifies the required size of the buffer,
+  in 16-bit characters, including the null-terminating character.
+if dest != NULL, the return value specifies the number of 16-bit characters that
+  are written to the dest, including the null-terminating character. */
+
+size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
+
+/*
+size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);
+UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
+*/
+
+SRes SzArEx_Extract(
+    const CSzArEx *db,
+    ILookInStream *inStream,
+    UInt32 fileIndex,         /* index of file */
+    UInt32 *blockIndex,       /* index of solid block */
+    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
+    size_t *outBufferSize,    /* buffer size for output buffer */
+    size_t *offset,           /* offset of stream for required file in *outBuffer */
+    size_t *outSizeProcessed, /* size of file in *outBuffer */
+    ISzAlloc *allocMain,
+    ISzAlloc *allocTemp);
+
+
+/*
+SzArEx_Open Errors:
+SZ_ERROR_NO_ARCHIVE
+SZ_ERROR_ARCHIVE
+SZ_ERROR_UNSUPPORTED
+SZ_ERROR_MEM
+SZ_ERROR_CRC
+SZ_ERROR_INPUT_EOF
+SZ_ERROR_FAIL
+*/
+
+SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
+    ISzAlloc *allocMain, ISzAlloc *allocTemp);
+
+EXTERN_C_END
+
+#endif

@@ -0,0 +1,78 @@
+/* 7zAlloc.c -- Allocation functions
+2010-10-29 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "7zAlloc.h"
+
+/* #define _SZ_ALLOC_DEBUG */
+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
+
+#ifdef _SZ_ALLOC_DEBUG
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include <stdio.h>
+int g_allocCount = 0;
+int g_allocCountTemp = 0;
+
+#endif
+
+void *SzAlloc(void *p, size_t size)
+{
+  (void) p;
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount);
+  g_allocCount++;
+  #endif
+  return malloc(size);
+}
+
+void SzFree(void *p, void *address)
+{
+  (void) p;
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+  {
+    g_allocCount--;
+    fprintf(stderr, "\nFree; count = %10d", g_allocCount);
+  }
+  #endif
+  free(address);
+}
+
+void *SzAllocTemp(void *p, size_t size)
+{
+  (void) p;
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_temp %10d bytes;  count = %10d", size, g_allocCountTemp);
+  g_allocCountTemp++;
+  #ifdef _WIN32
+  return HeapAlloc(GetProcessHeap(), 0, size);
+  #endif
+  #endif
+  return malloc(size);
+}
+
+void SzFreeTemp(void *p, void *address)
+{
+  (void) p;
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+  {
+    g_allocCountTemp--;
+    fprintf(stderr, "\nFree_temp; count = %10d", g_allocCountTemp);
+  }
+  #ifdef _WIN32
+  HeapFree(GetProcessHeap(), 0, address);
+  return;
+  #endif
+  #endif
+  free(address);
+}

@@ -0,0 +1,15 @@
+/* 7zAlloc.h -- Allocation functions
+2010-10-29 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_ALLOC_H
+#define __7Z_ALLOC_H
+
+#include <stdlib.h>
+
+void *SzAlloc(void *p, size_t size);
+void SzFree(void *p, void *address);
+
+void *SzAllocTemp(void *p, size_t size);
+void SzFreeTemp(void *p, void *address);
+
+#endif

@@ -0,0 +1,1839 @@
+/* 7zArcIn.c -- 7z Input functions
+2014-06-16 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "7z.h"
+#include "7zBuf.h"
+#include "7zCrc.h"
+#include "CpuArch.h"
+
+#define MY_ALLOC(T, p, size, alloc) { if ((size) == 0) p = 0; else \
+  if ((p = (T *)IAlloc_Alloc(alloc, (size) * sizeof(T))) == 0) return SZ_ERROR_MEM; }
+
+#define k7zMajorVersion 0
+
+enum EIdEnum
+{
+  k7zIdEnd,
+  k7zIdHeader,
+  k7zIdArchiveProperties,
+  k7zIdAdditionalStreamsInfo,
+  k7zIdMainStreamsInfo,
+  k7zIdFilesInfo,
+  k7zIdPackInfo,
+  k7zIdUnpackInfo,
+  k7zIdSubStreamsInfo,
+  k7zIdSize,
+  k7zIdCRC,
+  k7zIdFolder,
+  k7zIdCodersUnpackSize,
+  k7zIdNumUnpackStream,
+  k7zIdEmptyStream,
+  k7zIdEmptyFile,
+  k7zIdAnti,
+  k7zIdName,
+  k7zIdCTime,
+  k7zIdATime,
+  k7zIdMTime,
+  k7zIdWinAttrib,
+  k7zIdComment,
+  k7zIdEncodedHeader,
+  k7zIdStartPos,
+  k7zIdDummy
+  // k7zNtSecure,
+  // k7zParent,
+  // k7zIsReal
+};
+
+Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
+
+#define NUM_FOLDER_CODERS_MAX 32
+#define NUM_CODER_STREAMS_MAX 32
+
+/*
+static int SzFolder_FindBindPairForInStream(const CSzFolder *p, UInt32 inStreamIndex)
+{
+  UInt32 i;
+  for (i = 0; i < p->NumBindPairs; i++)
+    if (p->BindPairs[i].InIndex == inStreamIndex)
+      return i;
+  return -1;
+}
+*/
+
+#define SzBitUi32s_Init(p) { (p)->Defs = 0; (p)->Vals = 0; }
+
+static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAlloc *alloc)
+{
+  MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc);
+  MY_ALLOC(UInt32, p->Vals, num, alloc);
+  return SZ_OK;
+}
+
+void SzBitUi32s_Free(CSzBitUi32s *p, ISzAlloc *alloc)
+{
+  IAlloc_Free(alloc, p->Defs); p->Defs = 0;
+  IAlloc_Free(alloc, p->Vals); p->Vals = 0;
+}
+
+#define SzBitUi64s_Init(p) { (p)->Defs = 0; (p)->Vals = 0; }
+
+void SzBitUi64s_Free(CSzBitUi64s *p, ISzAlloc *alloc)
+{
+  IAlloc_Free(alloc, p->Defs); p->Defs = 0;
+  IAlloc_Free(alloc, p->Vals); p->Vals = 0;
+}
+
+static void SzAr_Init(CSzAr *p)
+{
+  p->NumPackStreams = 0;
+  p->NumFolders = 0;
+  p->PackPositions = 0;
+  SzBitUi32s_Init(&p->FolderCRCs);
+  // p->Folders = 0;
+  p->FoCodersOffsets = 0;
+  p->FoSizesOffsets = 0;
+  p->FoStartPackStreamIndex = 0;
+
+  p->CodersData = 0;
+  // p->CoderUnpackSizes = 0;
+  p->UnpackSizesData = 0;
+}
+
+static void SzAr_Free(CSzAr *p, ISzAlloc *alloc)
+{
+  IAlloc_Free(alloc, p->UnpackSizesData);
+  IAlloc_Free(alloc, p->CodersData);
+  // IAlloc_Free(alloc, p->CoderUnpackSizes);
+
+  IAlloc_Free(alloc, p->PackPositions);
+ 
+  // IAlloc_Free(alloc, p->Folders);
+  IAlloc_Free(alloc, p->FoCodersOffsets);
+  IAlloc_Free(alloc, p->FoSizesOffsets);
+  IAlloc_Free(alloc, p->FoStartPackStreamIndex);
+  
+  SzBitUi32s_Free(&p->FolderCRCs, alloc);
+
+  SzAr_Init(p);
+}
+
+
+void SzArEx_Init(CSzArEx *p)
+{
+  SzAr_Init(&p->db);
+  p->NumFiles = 0;
+  p->dataPos = 0;
+  // p->Files = 0;
+  p->UnpackPositions = 0;
+  // p->IsEmptyFiles = 0;
+  p->IsDirs = 0;
+  // p->FolderStartPackStreamIndex = 0;
+  // p->PackStreamStartPositions = 0;
+  p->FolderStartFileIndex = 0;
+  p->FileIndexToFolderIndexMap = 0;
+  p->FileNameOffsets = 0;
+  p->FileNames = 0;
+  SzBitUi32s_Init(&p->CRCs);
+  SzBitUi32s_Init(&p->Attribs);
+  // SzBitUi32s_Init(&p->Parents);
+  SzBitUi64s_Init(&p->MTime);
+  SzBitUi64s_Init(&p->CTime);
+}
+
+void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc)
+{
+  // IAlloc_Free(alloc, p->FolderStartPackStreamIndex);
+  // IAlloc_Free(alloc, p->PackStreamStartPositions);
+  IAlloc_Free(alloc, p->FolderStartFileIndex);
+  IAlloc_Free(alloc, p->FileIndexToFolderIndexMap);
+
+  IAlloc_Free(alloc, p->FileNameOffsets);
+  IAlloc_Free(alloc, p->FileNames);
+
+  SzBitUi64s_Free(&p->CTime, alloc);
+  SzBitUi64s_Free(&p->MTime, alloc);
+  SzBitUi32s_Free(&p->CRCs, alloc);
+  // SzBitUi32s_Free(&p->Parents, alloc);
+  SzBitUi32s_Free(&p->Attribs, alloc);
+  IAlloc_Free(alloc, p->IsDirs);
+  // IAlloc_Free(alloc, p->IsEmptyFiles);
+  IAlloc_Free(alloc, p->UnpackPositions);
+  // IAlloc_Free(alloc, p->Files);
+
+  SzAr_Free(&p->db, alloc);
+  SzArEx_Init(p);
+}
+
+static int TestSignatureCandidate(Byte *testBytes)
+{
+  size_t i;
+  for (i = 0; i < k7zSignatureSize; i++)
+    if (testBytes[i] != k7zSignature[i])
+      return 0;
+  return 1;
+}
+
+#define SzData_Clear(p) { (p)->Data = 0; (p)->Size = 0; }
+
+static SRes SzReadByte(CSzData *sd, Byte *b)
+{
+  if (sd->Size == 0)
+    return SZ_ERROR_ARCHIVE;
+  sd->Size--;
+  *b = *sd->Data++;
+  return SZ_OK;
+}
+
+#define SZ_READ_BYTE_SD(_sd_, dest) if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; (_sd_)->Size--; dest = *(_sd_)->Data++;
+#define SZ_READ_BYTE(dest) SZ_READ_BYTE_SD(sd, dest)
+#define SZ_READ_BYTE_2(dest) if (sd.Size == 0) return SZ_ERROR_ARCHIVE; sd.Size--; dest = *sd.Data++;
+
+#define SKIP_DATA(sd, size) { sd->Size -= (size_t)(size); sd->Data += (size_t)(size); }
+#define SKIP_DATA2(sd, size) { sd.Size -= (size_t)(size); sd.Data += (size_t)(size); }
+
+#define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \
+   dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4);
+
+static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
+{
+  Byte firstByte, mask;
+  unsigned i;
+  UInt32 v;
+
+  SZ_READ_BYTE(firstByte);
+  if ((firstByte & 0x80) == 0)
+  {
+    *value = firstByte;
+    return SZ_OK;
+  }
+  SZ_READ_BYTE(v);
+  if ((firstByte & 0x40) == 0)
+  {
+    *value = (((UInt32)firstByte & 0x3F) << 8) | v;
+    return SZ_OK;
+  }
+  SZ_READ_BYTE(mask);
+  *value = v | ((UInt32)mask << 8);
+  mask = 0x20;
+  for (i = 2; i < 8; i++)
+  {
+    Byte b;
+    if ((firstByte & mask) == 0)
+    {
+      UInt64 highPart = firstByte & (mask - 1);
+      *value |= (highPart << (8 * i));
+      return SZ_OK;
+    }
+    SZ_READ_BYTE(b);
+    *value |= ((UInt64)b << (8 * i));
+    mask >>= 1;
+  }
+  return SZ_OK;
+}
+
+/*
+static MY_NO_INLINE const Byte *SzReadNumbers(const Byte *data, const Byte *dataLim, UInt64 *values, UInt32 num)
+{
+  for (; num != 0; num--)
+  {
+    Byte firstByte;
+    Byte mask;
+
+    unsigned i;
+    UInt32 v;
+    UInt64 value;
+   
+    if (data == dataLim)
+      return NULL;
+    firstByte = *data++;
+
+    if ((firstByte & 0x80) == 0)
+    {
+      *values++ = firstByte;
+      continue;
+    }
+    if (data == dataLim)
+      return NULL;
+    v = *data++;
+    if ((firstByte & 0x40) == 0)
+    {
+      *values++ = (((UInt32)firstByte & 0x3F) << 8) | v;
+      continue;
+    }
+    if (data == dataLim)
+      return NULL;
+    value = v | ((UInt32)*data++ << 8);
+    mask = 0x20;
+    for (i = 2; i < 8; i++)
+    {
+      if ((firstByte & mask) == 0)
+      {
+        UInt64 highPart = firstByte & (mask - 1);
+        value |= (highPart << (8 * i));
+        break;
+      }
+      if (data == dataLim)
+        return NULL;
+      value |= ((UInt64)*data++ << (8 * i));
+      mask >>= 1;
+    }
+    *values++ = value;
+  }
+  return data;
+}
+*/
+
+static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
+{
+  Byte firstByte;
+  UInt64 value64;
+  if (sd->Size == 0)
+    return SZ_ERROR_ARCHIVE;
+  firstByte = *sd->Data;
+  if ((firstByte & 0x80) == 0)
+  {
+    *value = firstByte;
+    sd->Data++;
+    sd->Size--;
+    return SZ_OK;
+  }
+  RINOK(ReadNumber(sd, &value64));
+  if (value64 >= (UInt32)0x80000000 - 1)
+    return SZ_ERROR_UNSUPPORTED;
+  if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4)))
+    return SZ_ERROR_UNSUPPORTED;
+  *value = (UInt32)value64;
+  return SZ_OK;
+}
+
+#define ReadID(sd, value) ReadNumber(sd, value)
+
+static SRes SkipData(CSzData *sd)
+{
+  UInt64 size;
+  RINOK(ReadNumber(sd, &size));
+  if (size > sd->Size)
+    return SZ_ERROR_ARCHIVE;
+  SKIP_DATA(sd, size);
+  return SZ_OK;
+}
+
+static SRes WaitId(CSzData *sd, UInt64 id)
+{
+  for (;;)
+  {
+    UInt64 type;
+    RINOK(ReadID(sd, &type));
+    if (type == id)
+      return SZ_OK;
+    if (type == k7zIdEnd)
+      return SZ_ERROR_ARCHIVE;
+    RINOK(SkipData(sd));
+  }
+}
+
+static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)
+{
+  UInt32 numBytes = (numItems + 7) >> 3;
+  if (numBytes > sd->Size)
+    return SZ_ERROR_ARCHIVE;
+  *v = sd->Data;
+  SKIP_DATA(sd, numBytes);
+  return SZ_OK;
+}
+
+static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
+{
+  Byte b = 0;
+  unsigned m = 0;
+  UInt32 sum = 0;
+  for (; numItems != 0; numItems--)
+  {
+    if (m == 0)
+    {
+      b = *bits++;
+      m = 8;
+    }
+    m--;
+    sum += ((b >> m) & 1);
+  }
+  return sum ;
+}
+
+static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAlloc *alloc)
+{
+  Byte allAreDefined;
+  UInt32 i;
+  Byte *v2;
+  UInt32 numBytes = (numItems + 7) >> 3;
+  RINOK(SzReadByte(sd, &allAreDefined));
+  if (allAreDefined == 0)
+  {
+    if (numBytes > sd->Size)
+      return SZ_ERROR_ARCHIVE;
+    MY_ALLOC(Byte, *v, numBytes, alloc);
+    memcpy(*v, sd->Data, numBytes);
+    SKIP_DATA(sd, numBytes);
+    return SZ_OK;
+  }
+  MY_ALLOC(Byte, *v, numBytes, alloc);
+  v2 = *v;
+  for (i = 0; i < numBytes; i++)
+    v2[i] = 0xFF;
+  {
+    unsigned numBits = (unsigned)numItems & 7;
+    if (numBits != 0)
+      v2[numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));
+  }
+  return SZ_OK;
+}
+
+static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)
+{
+  UInt32 i;
+  CSzData sd;
+  UInt32 *vals;
+  const Byte *defs;
+  MY_ALLOC(UInt32, crcs->Vals, numItems, alloc);
+  sd = *sd2;
+  defs = crcs->Defs;
+  vals = crcs->Vals;
+  for (i = 0; i < numItems; i++)
+    if (SzBitArray_Check(defs, i))
+    {
+      SZ_READ_32(vals[i]);
+    }
+    else
+      vals[i] = 0;
+  *sd2 = sd;
+  return SZ_OK;
+}
+
+static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)
+{
+  SzBitUi32s_Free(crcs, alloc);
+  RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc));
+  return ReadUi32s(sd, numItems, crcs, alloc);
+}
+
+static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
+{
+  Byte allAreDefined;
+  UInt32 numDefined = numItems;
+  RINOK(SzReadByte(sd, &allAreDefined));
+  if (!allAreDefined)
+  {
+    size_t numBytes = (numItems + 7) >> 3;
+    if (numBytes > sd->Size)
+      return SZ_ERROR_ARCHIVE;
+    numDefined = CountDefinedBits(sd->Data, numItems);
+    SKIP_DATA(sd, numBytes);
+  }
+  if (numDefined > (sd->Size >> 2))
+    return SZ_ERROR_ARCHIVE;
+  SKIP_DATA(sd, (size_t)numDefined * 4);
+  return SZ_OK;
+}
+
+static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAlloc *alloc)
+{
+  RINOK(SzReadNumber32(sd, &p->NumPackStreams));
+
+  RINOK(WaitId(sd, k7zIdSize));
+  MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc);
+  {
+    UInt64 sum = 0;
+    UInt32 i;
+    UInt32 numPackStreams = p->NumPackStreams;
+    for (i = 0; i < numPackStreams; i++)
+    {
+      UInt64 packSize;
+      p->PackPositions[i] = sum;
+      RINOK(ReadNumber(sd, &packSize));
+      sum += packSize;
+      if (sum < packSize)
+        return SZ_ERROR_ARCHIVE;
+    }
+    p->PackPositions[i] = sum;
+  }
+
+  for (;;)
+  {
+    UInt64 type;
+    RINOK(ReadID(sd, &type));
+    if (type == k7zIdEnd)
+      return SZ_OK;
+    if (type == k7zIdCRC)
+    {
+      /* CRC of packed streams is unused now */
+      RINOK(SkipBitUi32s(sd, p->NumPackStreams));
+      continue;
+    }
+    RINOK(SkipData(sd));
+  }
+}
+
+/*
+static SRes SzReadSwitch(CSzData *sd)
+{
+  Byte external;
+  RINOK(SzReadByte(sd, &external));
+  return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;
+}
+*/
+
+#define SZ_NUM_IN_STREAMS_IN_FOLDER_MAX 16
+
+SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd, CSzData *sdSizes)
+{
+  UInt32 numCoders, numBindPairs, numPackStreams, i;
+  UInt32 numInStreams = 0, numOutStreams = 0;
+  const Byte *dataStart = sd->Data;
+  Byte inStreamUsed[SZ_NUM_IN_STREAMS_IN_FOLDER_MAX];
+  
+  RINOK(SzReadNumber32(sd, &numCoders));
+  if (numCoders > SZ_NUM_CODERS_IN_FOLDER_MAX)
+    return SZ_ERROR_UNSUPPORTED;
+  f->NumCoders = numCoders;
+  
+  for (i = 0; i < numCoders; i++)
+  {
+    Byte mainByte;
+    CSzCoderInfo *coder = f->Coders + i;
+    unsigned idSize, j;
+    UInt64 id;
+    RINOK(SzReadByte(sd, &mainByte));
+    if ((mainByte & 0xC0) != 0)
+      return SZ_ERROR_UNSUPPORTED;
+    idSize = (unsigned)(mainByte & 0xF);
+    if (idSize > sizeof(id))
+      return SZ_ERROR_UNSUPPORTED;
+    if (idSize > sd->Size)
+      return SZ_ERROR_ARCHIVE;
+    id = 0;
+    for (j = 0; j < idSize; j++)
+    {
+      id = ((id << 8) | *sd->Data);
+      sd->Data++;
+      sd->Size--;
+    }
+    if (id > (UInt32)0xFFFFFFFF)
+      return SZ_ERROR_UNSUPPORTED;
+    coder->MethodID = (UInt32)id;
+    
+    coder->NumInStreams = 1;
+    coder->NumOutStreams = 1;
+    coder->PropsOffset = 0;
+    coder->PropsSize = 0;
+    
+    if ((mainByte & 0x10) != 0)
+    {
+      UInt32 numStreams;
+      RINOK(SzReadNumber32(sd, &numStreams));
+      if (numStreams > NUM_CODER_STREAMS_MAX)
+        return SZ_ERROR_UNSUPPORTED;
+      coder->NumInStreams = (Byte)numStreams;
+      RINOK(SzReadNumber32(sd, &numStreams));
+      if (numStreams > NUM_CODER_STREAMS_MAX)
+        return SZ_ERROR_UNSUPPORTED;
+      coder->NumOutStreams = (Byte)numStreams;
+    }
+    if ((mainByte & 0x20) != 0)
+    {
+      UInt32 propsSize = 0;
+      RINOK(SzReadNumber32(sd, &propsSize));
+      if (propsSize >= 0x40)
+        return SZ_ERROR_UNSUPPORTED;
+      if (propsSize > sd->Size)
+        return SZ_ERROR_ARCHIVE;
+      coder->PropsOffset = sd->Data - dataStart;
+      coder->PropsSize = (Byte)propsSize;
+      sd->Data += (size_t)propsSize;
+      sd->Size -= (size_t)propsSize;
+    }
+    numInStreams += coder->NumInStreams;
+    numOutStreams += coder->NumOutStreams;
+  }
+
+  if (numOutStreams == 0)
+    return SZ_ERROR_UNSUPPORTED;
+
+  f->NumBindPairs = numBindPairs = numOutStreams - 1;
+  if (numInStreams < numBindPairs)
+    return SZ_ERROR_ARCHIVE;
+  if (numInStreams > SZ_NUM_IN_STREAMS_IN_FOLDER_MAX)
+    return SZ_ERROR_UNSUPPORTED;
+  f->MainOutStream = 0;
+  f->NumPackStreams = numPackStreams = numInStreams - numBindPairs;
+  if (numPackStreams > SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)
+    return SZ_ERROR_UNSUPPORTED;
+  for (i = 0; i < numInStreams; i++)
+    inStreamUsed[i] = False;
+  if (numBindPairs != 0)
+  {
+    Byte outStreamUsed[SZ_NUM_CODERS_OUT_STREAMS_IN_FOLDER_MAX];
+
+    if (numBindPairs > SZ_NUM_BINDS_IN_FOLDER_MAX)
+      return SZ_ERROR_UNSUPPORTED;
+
+    for (i = 0; i < numOutStreams; i++)
+      outStreamUsed[i] = False;
+
+    for (i = 0; i < numBindPairs; i++)
+    {
+      CSzBindPair *bp = f->BindPairs + i;
+      RINOK(SzReadNumber32(sd, &bp->InIndex));
+      if (bp->InIndex >= numInStreams)
+        return SZ_ERROR_ARCHIVE;
+      inStreamUsed[bp->InIndex] = True;
+      RINOK(SzReadNumber32(sd, &bp->OutIndex));
+      if (bp->OutIndex >= numInStreams)
+        return SZ_ERROR_ARCHIVE;
+      outStreamUsed[bp->OutIndex] = True;
+    }
+    for (i = 0; i < numOutStreams; i++)
+      if (!outStreamUsed[i])
+      {
+        f->MainOutStream = i;
+        break;
+      }
+    if (i == numOutStreams)
+      return SZ_ERROR_ARCHIVE;
+  }
+
+  if (numPackStreams == 1)
+  {
+    for (i = 0; i < numInStreams; i++)
+      if (!inStreamUsed[i])
+        break;
+    if (i == numInStreams)
+      return SZ_ERROR_ARCHIVE;
+    f->PackStreams[0] = i;
+  }
+  else
+    for (i = 0; i < numPackStreams; i++)
+    {
+      RINOK(SzReadNumber32(sd, f->PackStreams + i));
+    }
+
+  for (i = 0; i < numOutStreams; i++)
+  {
+    RINOK(ReadNumber(sdSizes, f->CodersUnpackSizes + i));
+  }
+  
+  return SZ_OK;
+}
+
+static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
+{
+  CSzData sd;
+  sd = *sd2;
+  for (; num != 0; num--)
+  {
+    Byte firstByte, mask;
+    unsigned i;
+    SZ_READ_BYTE_2(firstByte);
+    if ((firstByte & 0x80) == 0)
+      continue;
+    if ((firstByte & 0x40) == 0)
+    {
+      if (sd.Size == 0)
+        return SZ_ERROR_ARCHIVE;
+      sd.Size--;
+      sd.Data++;
+      continue;
+    }
+    mask = 0x20;
+    for (i = 2; i < 8 && (firstByte & mask) != 0; i++)
+      mask >>= 1;
+    if (i > sd.Size)
+      return SZ_ERROR_ARCHIVE;
+    SKIP_DATA2(sd, i);
+  }
+  *sd2 = sd;
+  return SZ_OK;
+}
+
+#define k_InStreamUsed_MAX 64
+#define k_OutStreamUsed_MAX 64
+
+static SRes ReadUnpackInfo(CSzAr *p,
+    CSzData *sd2,
+    UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,
+    ISzAlloc *alloc)
+{
+  CSzData sd;
+  Byte inStreamUsed[k_InStreamUsed_MAX];
+  Byte outStreamUsed[k_OutStreamUsed_MAX];
+  UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;
+  const Byte *startBufPtr;
+  Byte external;
+  
+  RINOK(WaitId(sd2, k7zIdFolder));
+  RINOK(SzReadNumber32(sd2, &numFolders));
+  if (p->NumFolders > numFoldersMax)
+    return SZ_ERROR_UNSUPPORTED;
+  p->NumFolders = numFolders;
+
+  SZ_READ_BYTE_SD(sd2, external);
+  if (external == 0)
+    sd = *sd2;
+  else
+  {
+    UInt32 index;
+    SzReadNumber32(sd2, &index);
+    if (index >= numTempBufs)
+      return SZ_ERROR_ARCHIVE;
+    sd.Data = tempBufs[index].data;
+    sd.Size = tempBufs[index].size;
+  }
+  
+  MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc);
+  MY_ALLOC(size_t, p->FoSizesOffsets, (size_t)numFolders + 1, alloc);
+  MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc);
+  
+  startBufPtr = sd.Data;
+  
+  packStreamIndex = 0;
+  numCodersOutStreams = 0;
+
+  for (fo = 0; fo < numFolders; fo++)
+  {
+    UInt32 numCoders, ci, numInStreams = 0, numOutStreams = 0;
+    
+    p->FoCodersOffsets[fo] = sd.Data - startBufPtr;
+    RINOK(SzReadNumber32(&sd, &numCoders));
+    if (numCoders > NUM_FOLDER_CODERS_MAX)
+      return SZ_ERROR_UNSUPPORTED;
+    
+    for (ci = 0; ci < numCoders; ci++)
+    {
+      Byte mainByte;
+      unsigned idSize;
+      UInt32 coderInStreams, coderOutStreams;
+      
+      SZ_READ_BYTE_2(mainByte);
+      if ((mainByte & 0xC0) != 0)
+        return SZ_ERROR_UNSUPPORTED;
+      idSize = (mainByte & 0xF);
+      if (idSize > 8)
+        return SZ_ERROR_UNSUPPORTED;
+      if (idSize > sd.Size)
+        return SZ_ERROR_ARCHIVE;
+      SKIP_DATA2(sd, idSize);
+      
+      coderInStreams = 1;
+      coderOutStreams = 1;
+      if ((mainByte & 0x10) != 0)
+      {
+        RINOK(SzReadNumber32(&sd, &coderInStreams));
+        RINOK(SzReadNumber32(&sd, &coderOutStreams));
+        if (coderInStreams > NUM_CODER_STREAMS_MAX ||
+            coderOutStreams > NUM_CODER_STREAMS_MAX)
+          return SZ_ERROR_UNSUPPORTED;
+      }
+      numInStreams += coderInStreams;
+      numOutStreams += coderOutStreams;
+      if ((mainByte & 0x20) != 0)
+      {
+        UInt32 propsSize;
+        RINOK(SzReadNumber32(&sd, &propsSize));
+        if (propsSize > sd.Size)
+          return SZ_ERROR_ARCHIVE;
+        SKIP_DATA2(sd, propsSize);
+      }
+    }
+    
+    {
+      UInt32 indexOfMainStream = 0;
+      UInt32 numPackStreams = 1;
+      if (numOutStreams != 1 || numInStreams != 1)
+      {
+        UInt32 i;
+        UInt32 numBindPairs = numOutStreams - 1;
+        if (numOutStreams == 0 || numInStreams < numBindPairs)
+          return SZ_ERROR_ARCHIVE;
+        
+        if (numInStreams > k_InStreamUsed_MAX ||
+            numOutStreams > k_OutStreamUsed_MAX)
+          return SZ_ERROR_UNSUPPORTED;
+        
+        for (i = 0; i < numInStreams; i++)
+          inStreamUsed[i] = False;
+        for (i = 0; i < numOutStreams; i++)
+          outStreamUsed[i] = False;
+        
+        for (i = 0; i < numBindPairs; i++)
+        {
+          UInt32 index;
+          RINOK(SzReadNumber32(&sd, &index));
+          if (index >= numInStreams || inStreamUsed[index])
+            return SZ_ERROR_ARCHIVE;
+          inStreamUsed[index] = True;
+          RINOK(SzReadNumber32(&sd, &index));
+          if (index >= numInStreams || outStreamUsed[index])
+            return SZ_ERROR_ARCHIVE;
+          outStreamUsed[index] = True;
+        }
+        
+        numPackStreams = numInStreams - numBindPairs;
+        
+        if (numPackStreams != 1)
+          for (i = 0; i < numPackStreams; i++)
+          {
+            UInt32 temp;
+            RINOK(SzReadNumber32(&sd, &temp));
+            if (temp >= numInStreams)
+              return SZ_ERROR_ARCHIVE;
+          }
+          
+        for (i = 0; i < numOutStreams; i++)
+          if (!outStreamUsed[i])
+          {
+            indexOfMainStream = i;
+            break;
+          }
+ 
+        if (i == numOutStreams)
+          return SZ_ERROR_ARCHIVE;
+      }
+      p->FoStartPackStreamIndex[fo] = packStreamIndex;
+      p->FoSizesOffsets[fo] = (numOutStreams << 8) | indexOfMainStream;
+      numCodersOutStreams += numOutStreams;
+      if (numCodersOutStreams < numOutStreams)
+        return SZ_ERROR_UNSUPPORTED;
+      packStreamIndex += numPackStreams;
+      if (packStreamIndex < numPackStreams)
+        return SZ_ERROR_UNSUPPORTED;
+      if (packStreamIndex > p->NumPackStreams)
+        return SZ_ERROR_ARCHIVE;
+    }
+  }
+  
+  {
+    size_t dataSize = sd.Data - startBufPtr;
+    p->FoStartPackStreamIndex[fo] = packStreamIndex;
+    p->FoCodersOffsets[fo] = dataSize;
+    MY_ALLOC(Byte, p->CodersData, dataSize, alloc);
+    memcpy(p->CodersData, startBufPtr, dataSize);
+  }
+  
+  if (external != 0)
+  {
+    if (sd.Size != 0)
+      return SZ_ERROR_ARCHIVE;
+    sd = *sd2;
+  }
+  
+  RINOK(WaitId(&sd, k7zIdCodersUnpackSize));
+  
+  // MY_ALLOC(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc);
+  {
+    size_t dataSize = sd.Size;
+    /*
+    UInt32 i;
+    for (i = 0; i < numCodersOutStreams; i++)
+    {
+    RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i));
+    }
+    */
+    RINOK(SkipNumbers(&sd, numCodersOutStreams));
+    dataSize -= sd.Size;
+    MY_ALLOC(Byte, p->UnpackSizesData, dataSize, alloc);
+    memcpy(p->UnpackSizesData, sd.Data - dataSize, dataSize);
+    p->UnpackSizesDataSize = dataSize;
+    /*
+    const Byte *data = SzReadNumbers(sd.Data, sd.Data + sd.Size, p->CoderUnpackSizes, numCodersOutStreams);
+    if (data == NULL)
+    return SZ_ERROR_ARCHIVE;
+    sd.Size = sd.Data + sd.Size - data;
+    sd.Data = data;
+    */
+  }
+
+  for (;;)
+  {
+    UInt64 type;
+    RINOK(ReadID(&sd, &type));
+    if (type == k7zIdEnd)
+    {
+      *sd2 = sd;
+      return SZ_OK;
+    }
+    if (type == k7zIdCRC)
+    {
+      RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc));
+      continue;
+    }
+    RINOK(SkipData(&sd));
+  }
+}
+
+typedef struct
+{
+  UInt32 NumTotalSubStreams;
+  UInt32 NumSubDigests;
+  CSzData sdNumSubStreams;
+  CSzData sdSizes;
+  CSzData sdCRCs;
+} CSubStreamInfo;
+
+#define SzUi32IndexMax (((UInt32)1 << 31) - 2)
+
+static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
+{
+  UInt64 type = 0;
+  UInt32 i;
+  UInt32 numSubDigests = 0;
+  UInt32 numFolders = p->NumFolders;
+  UInt32 numUnpackStreams = numFolders;
+  UInt32 numUnpackSizesInData = 0;
+
+  for (;;)
+  {
+    RINOK(ReadID(sd, &type));
+    if (type == k7zIdNumUnpackStream)
+    {
+      ssi->sdNumSubStreams.Data = sd->Data;
+      numUnpackStreams = 0;
+      numSubDigests = 0;
+      for (i = 0; i < numFolders; i++)
+      {
+        UInt32 numStreams;
+        RINOK(SzReadNumber32(sd, &numStreams));
+        if (numUnpackStreams > numUnpackStreams + numStreams)
+          return SZ_ERROR_UNSUPPORTED;
+        numUnpackStreams += numStreams;
+        if (numStreams != 0)
+          numUnpackSizesInData += (numStreams - 1);
+        if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i))
+          numSubDigests += numStreams;
+      }
+      ssi->sdNumSubStreams.Size = sd->Data - ssi->sdNumSubStreams.Data;
+      continue;
+    }
+    if (type == k7zIdCRC || type == k7zIdSize || type == k7zIdEnd)
+      break;
+    RINOK(SkipData(sd));
+  }
+
+  if (!ssi->sdNumSubStreams.Data)
+  {
+    numSubDigests = numFolders;
+    if (p->FolderCRCs.Defs)
+      numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);
+  }
+  
+  ssi->NumTotalSubStreams = numUnpackStreams;
+  ssi->NumSubDigests = numSubDigests;
+
+  if (type == k7zIdSize)
+  {
+    ssi->sdSizes.Data = sd->Data;
+    RINOK(SkipNumbers(sd, numUnpackSizesInData));
+    ssi->sdSizes.Size = sd->Data - ssi->sdSizes.Data;
+    RINOK(ReadID(sd, &type));
+  }
+
+  for (;;)
+  {
+    if (type == k7zIdEnd)
+      return SZ_OK;
+    if (type == k7zIdCRC)
+    {
+      ssi->sdCRCs.Data = sd->Data;
+      RINOK(SkipBitUi32s(sd, numSubDigests));
+      ssi->sdCRCs.Size = sd->Data - ssi->sdCRCs.Data;
+    }
+    else
+    {
+      RINOK(SkipData(sd));
+    }
+    RINOK(ReadID(sd, &type));
+  }
+}
+
+static SRes SzReadStreamsInfo(CSzAr *p,
+    CSzData *sd,
+    UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,
+    UInt64 *dataOffset,
+    CSubStreamInfo *ssi,
+    ISzAlloc *alloc)
+{
+  UInt64 type;
+
+  SzData_Clear(&ssi->sdSizes);
+  SzData_Clear(&ssi->sdCRCs);
+  SzData_Clear(&ssi->sdNumSubStreams);
+
+  *dataOffset = 0;
+  RINOK(ReadID(sd, &type));
+  if (type == k7zIdPackInfo)
+  {
+    RINOK(ReadNumber(sd, dataOffset));
+    RINOK(ReadPackInfo(p, sd, alloc));
+    RINOK(ReadID(sd, &type));
+  }
+  if (type == k7zIdUnpackInfo)
+  {
+    RINOK(ReadUnpackInfo(p, sd, numFoldersMax, tempBufs, numTempBufs, alloc));
+    RINOK(ReadID(sd, &type));
+  }
+  if (type == k7zIdSubStreamsInfo)
+  {
+    RINOK(ReadSubStreamsInfo(p, sd, ssi));
+    RINOK(ReadID(sd, &type));
+  }
+  else
+  {
+    ssi->NumTotalSubStreams = p->NumFolders;
+    // ssi->NumSubDigests = 0;
+  }
+
+  return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED);
+}
+
+static SRes SzReadAndDecodePackedStreams(
+    ILookInStream *inStream,
+    CSzData *sd,
+    CBuf *tempBufs,
+    UInt32 numFoldersMax,
+    UInt64 baseOffset,
+    CSzAr *p,
+    ISzAlloc *allocTemp)
+{
+  UInt64 dataStartPos;
+  UInt32 fo;
+  CSubStreamInfo ssi;
+  CSzData sdCodersUnpSizes;
+
+  RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp));
+  
+  dataStartPos += baseOffset;
+  if (p->NumFolders == 0)
+    return SZ_ERROR_ARCHIVE;
+ 
+  sdCodersUnpSizes.Data = p->UnpackSizesData;
+  sdCodersUnpSizes.Size = p->UnpackSizesDataSize;
+  for (fo = 0; fo < p->NumFolders; fo++)
+    Buf_Init(tempBufs + fo);
+  for (fo = 0; fo < p->NumFolders; fo++)
+  {
+    CBuf *tempBuf = tempBufs + fo;
+    // folder = p->Folders;
+    // unpackSize = SzAr_GetFolderUnpackSize(p, 0);
+    UInt32 mix = (UInt32)p->FoSizesOffsets[fo];
+    UInt32 mainIndex = mix & 0xFF;
+    UInt32 numOutStreams = mix >> 8;
+    UInt32 si;
+    UInt64 unpackSize = 0;
+    p->FoSizesOffsets[fo] = sdCodersUnpSizes.Data - p->UnpackSizesData;
+    for (si = 0; si < numOutStreams; si++)
+    {
+      UInt64 curSize;
+      RINOK(ReadNumber(&sdCodersUnpSizes, &curSize));
+      if (si == mainIndex)
+      {
+        unpackSize = curSize;
+        break;
+      }
+    }
+    if (si == numOutStreams)
+      return SZ_ERROR_FAIL;
+    if ((size_t)unpackSize != unpackSize)
+      return SZ_ERROR_MEM;
+    if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp))
+      return SZ_ERROR_MEM;
+  }
+  p->FoSizesOffsets[fo] = sdCodersUnpSizes.Data - p->UnpackSizesData;
+    
+  for (fo = 0; fo < p->NumFolders; fo++)
+  {
+    const CBuf *tempBuf = tempBufs + fo;
+    RINOK(LookInStream_SeekTo(inStream, dataStartPos));
+    RINOK(SzAr_DecodeFolder(p, fo, inStream, dataStartPos, tempBuf->data, tempBuf->size, allocTemp));
+    if (SzBitWithVals_Check(&p->FolderCRCs, fo))
+      if (CrcCalc(tempBuf->data, tempBuf->size) != p->FolderCRCs.Vals[fo])
+        return SZ_ERROR_CRC;
+  }
+  return SZ_OK;
+}
+
+static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets)
+{
+  size_t pos = 0;
+  *offsets++ = 0;
+  if (numFiles == 0)
+    return (size == 0) ? SZ_OK : SZ_ERROR_ARCHIVE;
+  if (data[size - 2] != 0 || data[size - 1] != 0)
+    return SZ_ERROR_ARCHIVE;
+  do
+  {
+    const Byte *p;
+    if (pos == size)
+      return SZ_ERROR_ARCHIVE;
+    for (p = data + pos;
+      #ifdef _WIN32
+      *(const UInt16 *)p != 0
+      #else
+      p[0] != 0 || p[1] != 0
+      #endif
+      ; p += 2);
+    pos = p - data + 2;
+    *offsets++ = (pos >> 1);
+  }
+  while (--numFiles);
+  return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
+}
+
+static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,
+    CSzData *sd2,
+    const CBuf *tempBufs, UInt32 numTempBufs,
+    ISzAlloc *alloc)
+{
+  CSzData sd;
+  UInt32 i;
+  CNtfsFileTime *vals;
+  Byte *defs;
+  Byte external;
+  RINOK(ReadBitVector(sd2, num, &p->Defs, alloc));
+  RINOK(SzReadByte(sd2, &external));
+  if (external == 0)
+    sd = *sd2;
+  else
+  {
+    UInt32 index;
+    SzReadNumber32(sd2, &index);
+    if (index >= numTempBufs)
+      return SZ_ERROR_ARCHIVE;
+    sd.Data = tempBufs[index].data;
+    sd.Size = tempBufs[index].size;
+  }
+  MY_ALLOC(CNtfsFileTime, p->Vals, num, alloc);
+  vals = p->Vals;
+  defs = p->Defs;
+  for (i = 0; i < num; i++)
+    if (SzBitArray_Check(defs, i))
+    {
+      if (sd.Size < 8)
+        return SZ_ERROR_ARCHIVE;
+      vals[i].Low = GetUi32(sd.Data);
+      vals[i].High = GetUi32(sd.Data + 4);
+      SKIP_DATA2(sd, 8);
+    }
+    else
+      vals[i].High = vals[i].Low = 0;
+  if (external == 0)
+    *sd2 = sd;
+  return SZ_OK;
+}
+
+#define NUM_ADDITIONAL_STREAMS_MAX 8
+
+static SRes SzReadHeader2(
+    CSzArEx *p,   /* allocMain */
+    CSzData *sd,
+    // Byte **emptyStreamVector, /* allocTemp */
+    // Byte **emptyFileVector,   /* allocTemp */
+    // Byte **lwtVector,         /* allocTemp */
+    ILookInStream *inStream,
+    CBuf *tempBufs,
+    UInt32 *numTempBufs,
+    ISzAlloc *allocMain,
+    ISzAlloc *allocTemp
+    )
+{
+  UInt64 type;
+  UInt32 numFiles = 0;
+  UInt32 numEmptyStreams = 0;
+  UInt32 i;
+  CSubStreamInfo ssi;
+  const Byte *emptyStreams = 0;
+  const Byte *emptyFiles = 0;
+
+  SzData_Clear(&ssi.sdSizes);
+  SzData_Clear(&ssi.sdCRCs);
+  SzData_Clear(&ssi.sdNumSubStreams);
+
+  ssi.NumSubDigests = 0;
+  ssi.NumTotalSubStreams = 0;
+
+  RINOK(ReadID(sd, &type));
+
+  if (type == k7zIdArchiveProperties)
+  {
+    for (;;)
+    {
+      UInt64 type;
+      RINOK(ReadID(sd, &type));
+      if (type == k7zIdEnd)
+        break;
+      RINOK(SkipData(sd));
+    }
+    RINOK(ReadID(sd, &type));
+  }
+
+  // if (type == k7zIdAdditionalStreamsInfo)     return SZ_ERROR_UNSUPPORTED;
+
+  if (type == k7zIdAdditionalStreamsInfo)
+  {
+    CSzAr tempAr;
+    SRes res;
+    UInt32 numTempFolders;
+    
+    SzAr_Init(&tempAr);
+    res = SzReadAndDecodePackedStreams(inStream, sd, tempBufs, NUM_ADDITIONAL_STREAMS_MAX,
+        p->startPosAfterHeader, &tempAr, allocTemp);
+    numTempFolders = tempAr.NumFolders;
+    SzAr_Free(&tempAr, allocTemp);
+    if (res != SZ_OK)
+      return res;
+    *numTempBufs = numTempFolders;
+    RINOK(ReadID(sd, &type));
+  }
+
+  if (type == k7zIdMainStreamsInfo)
+  {
+    RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs,
+        &p->dataPos, &ssi, allocMain));
+    p->dataPos += p->startPosAfterHeader;
+    RINOK(ReadID(sd, &type));
+  }
+
+  if (type == k7zIdEnd)
+  {
+    // *sd2 = sd;
+    return SZ_OK;
+  }
+  if (type != k7zIdFilesInfo)
+    return SZ_ERROR_ARCHIVE;
+  
+  RINOK(SzReadNumber32(sd, &numFiles));
+  p->NumFiles = numFiles;
+
+  for (;;)
+  {
+    UInt64 type;
+    UInt64 size;
+    RINOK(ReadID(sd, &type));
+    if (type == k7zIdEnd)
+      break;
+    RINOK(ReadNumber(sd, &size));
+    if (size > sd->Size)
+      return SZ_ERROR_ARCHIVE;
+    if ((UInt64)(int)type != type)
+    {
+      SKIP_DATA(sd, size);
+    }
+    else switch((int)type)
+    {
+      case k7zIdName:
+      {
+        size_t namesSize;
+        const Byte *namesData;
+        Byte external;
+
+        SZ_READ_BYTE(external);
+        if (external == 0)
+        {
+          namesSize = (size_t)size - 1;
+          namesData = sd->Data;
+        }
+        else
+        {
+          UInt32 index;
+          SzReadNumber32(sd, &index);
+          if (index >= *numTempBufs)
+            return SZ_ERROR_ARCHIVE;
+          namesData = (tempBufs)[index].data;
+          namesSize = (tempBufs)[index].size;
+        }
+
+        if ((namesSize & 1) != 0)
+          return SZ_ERROR_ARCHIVE;
+        MY_ALLOC(Byte, p->FileNames, namesSize, allocMain);
+        MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain);
+        memcpy(p->FileNames, namesData, namesSize);
+        RINOK(SzReadFileNames(p->FileNames, namesSize, numFiles, p->FileNameOffsets))
+        if (external == 0)
+        {
+          SKIP_DATA(sd, namesSize);
+        }
+        break;
+      }
+      case k7zIdEmptyStream:
+      {
+        RINOK(RememberBitVector(sd, numFiles, &emptyStreams));
+        numEmptyStreams = CountDefinedBits(emptyStreams, numFiles);
+        break;
+      }
+      case k7zIdEmptyFile:
+      {
+        RINOK(RememberBitVector(sd, numEmptyStreams, &emptyFiles));
+        break;
+      }
+      case k7zIdWinAttrib:
+      {
+        Byte external;
+        CSzData sdSwitch;
+        CSzData *sdPtr;
+        SzBitUi32s_Free(&p->Attribs, allocMain);
+        RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain));
+
+        SZ_READ_BYTE(external);
+        if (external == 0)
+          sdPtr = sd;
+        else
+        {
+          UInt32 index;
+          SzReadNumber32(sd, &index);
+          if (index >= *numTempBufs)
+            return SZ_ERROR_ARCHIVE;
+          sdSwitch.Data = (tempBufs)[index].data;
+          sdSwitch.Size = (tempBufs)[index].size;
+          sdPtr = &sdSwitch;
+        }
+        RINOK(ReadUi32s(sdPtr, numFiles, &p->Attribs, allocMain));
+        break;
+      }
+      /*
+      case k7zParent:
+      {
+        SzBitUi32s_Free(&p->Parents, allocMain);
+        RINOK(ReadBitVector(sd, numFiles, &p->Parents.Defs, allocMain));
+        RINOK(SzReadSwitch(sd));
+        RINOK(ReadUi32s(sd, numFiles, &p->Parents, allocMain));
+        break;
+      }
+      */
+      case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
+      case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
+      default:
+      {
+        SKIP_DATA(sd, size);
+      }
+    }
+  }
+
+  if (numFiles - numEmptyStreams != ssi.NumTotalSubStreams)
+    return SZ_ERROR_ARCHIVE;
+
+  for (;;)
+  {
+    UInt64 type;
+    RINOK(ReadID(sd, &type));
+    if (type == k7zIdEnd)
+      break;
+    RINOK(SkipData(sd));
+  }
+
+  {
+    UInt32 emptyFileIndex = 0;
+
+    UInt32 folderIndex = 0;
+    UInt32 indexInFolder = 0;
+    UInt64 unpackPos = 0;
+    const Byte *digestsDefs = 0;
+    const Byte *digestsVals = 0;
+    UInt32 digestsValsIndex = 0;
+    UInt32 digestIndex;
+    Byte allDigestsDefined = 0;
+    UInt32 curNumSubStreams = (UInt32)(Int32)-1;
+    Byte isDirMask = 0;
+    Byte crcMask = 0;
+    Byte mask = 0x80;
+    // size_t unpSizesOffset = 0;
+    CSzData sdCodersUnpSizes;
+    sdCodersUnpSizes.Data = p->db.UnpackSizesData;
+    sdCodersUnpSizes.Size = p->db.UnpackSizesDataSize;
+    
+    MY_ALLOC(UInt32, p->FolderStartFileIndex, p->db.NumFolders + 1, allocMain);
+    MY_ALLOC(UInt32, p->FileIndexToFolderIndexMap, p->NumFiles, allocMain);
+    MY_ALLOC(UInt64, p->UnpackPositions, p->NumFiles + 1, allocMain);
+    MY_ALLOC(Byte, p->IsDirs, (p->NumFiles + 7) >> 3, allocMain);
+
+    RINOK(SzBitUi32s_Alloc(&p->CRCs, p->NumFiles, allocMain));
+
+    if (ssi.sdCRCs.Size != 0)
+    {
+      RINOK(SzReadByte(&ssi.sdCRCs, &allDigestsDefined));
+      if (allDigestsDefined)
+        digestsVals = ssi.sdCRCs.Data;
+      else
+      {
+        size_t numBytes = (ssi.NumSubDigests + 7) >> 3;
+        digestsDefs = ssi.sdCRCs.Data;
+        digestsVals = digestsDefs + numBytes;
+      }
+    }
+
+    digestIndex = 0;
+    for (i = 0; i < numFiles; i++, mask >>= 1)
+    {
+      if (mask == 0)
+      {
+        UInt32 byteIndex = (i - 1) >> 3;
+        p->IsDirs[byteIndex] = isDirMask;
+        p->CRCs.Defs[byteIndex] = crcMask;
+        isDirMask = 0;
+        crcMask = 0;
+        mask = 0x80;
+      }
+
+      p->UnpackPositions[i] = unpackPos;
+      p->CRCs.Vals[i] = 0;
+      // p->CRCs.Defs[i] = 0;
+      if (emptyStreams && SzBitArray_Check(emptyStreams , i))
+      {
+        if (!emptyFiles || !SzBitArray_Check(emptyFiles, emptyFileIndex))
+          isDirMask |= mask;
+        emptyFileIndex++;
+        if (indexInFolder == 0)
+        {
+          p->FileIndexToFolderIndexMap[i] = (UInt32)-1;
+          continue;
+        }
+      }
+      if (indexInFolder == 0)
+      {
+        /*
+        v3.13 incorrectly worked with empty folders
+        v4.07: Loop for skipping empty folders
+        */
+        for (;;)
+        {
+          if (folderIndex >= p->db.NumFolders)
+            return SZ_ERROR_ARCHIVE;
+          p->FolderStartFileIndex[folderIndex] = i;
+          if (curNumSubStreams == (UInt32)(Int32)-1)
+          {
+            curNumSubStreams = 1;
+            if (ssi.sdNumSubStreams.Data != 0)
+            {
+              RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &curNumSubStreams));
+            }
+          }
+          if (curNumSubStreams != 0)
+            break;
+          curNumSubStreams = (UInt32)(Int32)-1;
+          folderIndex++; // check it
+        }
+      }
+      p->FileIndexToFolderIndexMap[i] = folderIndex;
+      if (emptyStreams && SzBitArray_Check(emptyStreams , i))
+        continue;
+      
+      indexInFolder++;
+      if (indexInFolder >= curNumSubStreams)
+      {
+        UInt64 folderUnpackSize = 0;
+        UInt64 startFolderUnpackPos;
+        {
+          UInt32 mix = (UInt32)p->db.FoSizesOffsets[folderIndex];
+          UInt32 mainIndex = mix & 0xFF;
+          UInt32 numOutStreams = mix >> 8;
+          UInt32 si;
+          p->db.FoSizesOffsets[folderIndex] = sdCodersUnpSizes.Data - p->db.UnpackSizesData;
+          for (si = 0; si < numOutStreams; si++)
+          {
+            UInt64 curSize;
+            RINOK(ReadNumber(&sdCodersUnpSizes, &curSize));
+            if (si == mainIndex)
+            {
+              folderUnpackSize = curSize;
+              break;
+            }
+          }
+          if (si == numOutStreams)
+            return SZ_ERROR_FAIL;
+        }
+
+        // UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
+        startFolderUnpackPos = p->UnpackPositions[p->FolderStartFileIndex[folderIndex]];
+        if (folderUnpackSize < unpackPos - startFolderUnpackPos)
+          return SZ_ERROR_ARCHIVE;
+        unpackPos = startFolderUnpackPos + folderUnpackSize;
+
+        if (curNumSubStreams == 1 && SzBitWithVals_Check(&p->db.FolderCRCs, i))
+        {
+          p->CRCs.Vals[i] = p->db.FolderCRCs.Vals[folderIndex];
+          crcMask |= mask;
+        }
+        else if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
+        {
+          p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
+          digestsValsIndex++;
+          crcMask |= mask;
+        }
+        folderIndex++;
+        indexInFolder = 0;
+      }
+      else
+      {
+        UInt64 v;
+        RINOK(ReadNumber(&ssi.sdSizes, &v));
+        unpackPos += v;
+        if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
+        {
+          p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
+          digestsValsIndex++;
+          crcMask |= mask;
+        }
+      }
+    }
+    if (mask != 0x80)
+    {
+      UInt32 byteIndex = (i - 1) >> 3;
+      p->IsDirs[byteIndex] = isDirMask;
+      p->CRCs.Defs[byteIndex] = crcMask;
+    }
+    p->UnpackPositions[i] = unpackPos;
+    p->FolderStartFileIndex[folderIndex] = i;
+    p->db.FoSizesOffsets[folderIndex] = sdCodersUnpSizes.Data - p->db.UnpackSizesData;
+  }
+  return SZ_OK;
+}
+
+static SRes SzReadHeader(
+    CSzArEx *p,
+    CSzData *sd,
+    ILookInStream *inStream,
+    ISzAlloc *allocMain
+    ,ISzAlloc *allocTemp
+    )
+{
+  // Byte *emptyStreamVector = 0;
+  // Byte *emptyFileVector = 0;
+  // Byte *lwtVector = 0;
+  UInt32 i;
+  UInt32 numTempBufs = 0;
+  SRes res;
+  CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX];
+
+  for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)
+    Buf_Init(tempBufs + i);
+  // SzBitUi32s_Init(&digests);
+  
+  res = SzReadHeader2(p, sd,
+      // &emptyStreamVector,
+      // &emptyFileVector,
+      // &lwtVector,
+      inStream,
+      tempBufs, &numTempBufs,
+      allocMain, allocTemp
+      );
+  
+  for (i = 0; i < numTempBufs; i++)
+    Buf_Free(tempBufs + i, allocTemp);
+
+  // IAlloc_Free(allocTemp, emptyStreamVector);
+  // IAlloc_Free(allocTemp, emptyFileVector);
+  // IAlloc_Free(allocTemp, lwtVector);
+
+  RINOK(res);
+  {
+    if (sd->Size != 0)
+      return SZ_ERROR_FAIL;
+  }
+
+  return res;
+}
+
+/*
+static UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)
+{
+  const CSzFolder2 *f = p->Folders + folderIndex;
+
+  // return p->CoderUnpackSizes[f->StartCoderUnpackSizesIndex + f->IndexOfMainOutStream];
+
+  UInt32 si;
+  CSzData sdCodersUnpSizes;
+  sdCodersUnpSizes.Data = p->UnpackSizesData + f->UnpackSizeDataOffset;
+  sdCodersUnpSizes.Size = p->UnpackSizesDataSize - f->UnpackSizeDataOffset;
+  for (si = 0; si < numOutStreams; si++)
+  {
+    UInt64 curSize;
+    ReadNumber(&sdCodersUnpSizes, &curSize);
+    if (si == mainIndex)
+      return curSize;
+  }
+  return 0;
+}
+*/
+
+static SRes SzArEx_Open2(
+    CSzArEx *p,
+    ILookInStream *inStream,
+    ISzAlloc *allocMain,
+    ISzAlloc *allocTemp)
+{
+  Byte header[k7zStartHeaderSize];
+  Int64 startArcPos;
+  UInt64 nextHeaderOffset, nextHeaderSize;
+  size_t nextHeaderSizeT;
+  UInt32 nextHeaderCRC;
+  CBuf buf;
+  SRes res;
+
+  startArcPos = 0;
+  RINOK(inStream->Seek(inStream, &startArcPos, SZ_SEEK_CUR));
+
+  RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE));
+
+  if (!TestSignatureCandidate(header))
+    return SZ_ERROR_NO_ARCHIVE;
+  if (header[6] != k7zMajorVersion)
+    return SZ_ERROR_UNSUPPORTED;
+
+  nextHeaderOffset = GetUi64(header + 12);
+  nextHeaderSize = GetUi64(header + 20);
+  nextHeaderCRC = GetUi32(header + 28);
+
+  p->startPosAfterHeader = startArcPos + k7zStartHeaderSize;
+  
+  if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
+    return SZ_ERROR_CRC;
+
+  nextHeaderSizeT = (size_t)nextHeaderSize;
+  if (nextHeaderSizeT != nextHeaderSize)
+    return SZ_ERROR_MEM;
+  if (nextHeaderSizeT == 0)
+    return SZ_OK;
+  if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||
+      nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)
+    return SZ_ERROR_NO_ARCHIVE;
+
+  {
+    Int64 pos = 0;
+    RINOK(inStream->Seek(inStream, &pos, SZ_SEEK_END));
+    if ((UInt64)pos < startArcPos + nextHeaderOffset ||
+        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
+        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
+      return SZ_ERROR_INPUT_EOF;
+  }
+
+  RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset));
+
+  if (!Buf_Create(&buf, nextHeaderSizeT, allocTemp))
+    return SZ_ERROR_MEM;
+
+  res = LookInStream_Read(inStream, buf.data, nextHeaderSizeT);
+  if (res == SZ_OK)
+  {
+    res = SZ_ERROR_ARCHIVE;
+    if (CrcCalc(buf.data, nextHeaderSizeT) == nextHeaderCRC)
+    {
+      CSzData sd;
+      UInt64 type;
+      sd.Data = buf.data;
+      sd.Size = buf.size;
+      res = ReadID(&sd, &type);
+      if (res == SZ_OK && type == k7zIdEncodedHeader)
+      {
+        CSzAr tempAr;
+        CBuf tempBuf;
+        Buf_Init(&tempBuf);
+        
+        SzAr_Init(&tempAr);
+        res = SzReadAndDecodePackedStreams(inStream, &sd, &tempBuf, 1, p->startPosAfterHeader, &tempAr, allocTemp);
+        SzAr_Free(&tempAr, allocTemp);
+       
+        if (res != SZ_OK)
+        {
+          Buf_Free(&tempBuf, allocTemp);
+        }
+        else
+        {
+          Buf_Free(&buf, allocTemp);
+          buf.data = tempBuf.data;
+          buf.size = tempBuf.size;
+          sd.Data = buf.data;
+          sd.Size = buf.size;
+          res = ReadID(&sd, &type);
+        }
+      }
+      if (res == SZ_OK)
+      {
+        if (type == k7zIdHeader)
+        {
+          CSzData sd2;
+          int ttt;
+          for (ttt = 0; ttt < 1; ttt++)
+          // for (ttt = 0; ttt < 40000; ttt++)
+          {
+            SzArEx_Free(p, allocMain);
+            sd2 = sd;
+            res = SzReadHeader(p, &sd2, inStream, allocMain, allocTemp
+              );
+            if (res != SZ_OK)
+              break;
+          }
+
+          // res = SzReadHeader(p, &sd, allocMain, allocTemp);
+        }
+        else
+          res = SZ_ERROR_UNSUPPORTED;
+      }
+    }
+  }
+  Buf_Free(&buf, allocTemp);
+  return res;
+}
+
+// #include <stdio.h>
+
+SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
+    ISzAlloc *allocMain, ISzAlloc *allocTemp)
+{
+  SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);
+  if (res != SZ_OK)
+    SzArEx_Free(p, allocMain);
+  // printf ("\nrrr=%d\n", rrr);
+  return res;
+}
+
+SRes SzArEx_Extract(
+    const CSzArEx *p,
+    ILookInStream *inStream,
+    UInt32 fileIndex,
+    UInt32 *blockIndex,
+    Byte **tempBuf,
+    size_t *outBufferSize,
+    size_t *offset,
+    size_t *outSizeProcessed,
+    ISzAlloc *allocMain,
+    ISzAlloc *allocTemp)
+{
+  UInt32 folderIndex = p->FileIndexToFolderIndexMap[fileIndex];
+  SRes res = SZ_OK;
+  *offset = 0;
+  *outSizeProcessed = 0;
+  if (folderIndex == (UInt32)-1)
+  {
+    IAlloc_Free(allocMain, *tempBuf);
+    *blockIndex = folderIndex;
+    *tempBuf = 0;
+    *outBufferSize = 0;
+    return SZ_OK;
+  }
+
+  if (*tempBuf == 0 || *blockIndex != folderIndex)
+  {
+    // UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
+    UInt64 unpackSizeSpec =
+        p->UnpackPositions[p->FolderStartFileIndex[folderIndex + 1]] -
+        p->UnpackPositions[p->FolderStartFileIndex[folderIndex]];
+    size_t unpackSize = (size_t)unpackSizeSpec;
+
+    if (unpackSize != unpackSizeSpec)
+      return SZ_ERROR_MEM;
+    *blockIndex = folderIndex;
+    IAlloc_Free(allocMain, *tempBuf);
+    *tempBuf = 0;
+    
+    // RINOK(LookInStream_SeekTo(inStream, startOffset));
+    
+    if (res == SZ_OK)
+    {
+      *outBufferSize = unpackSize;
+      if (unpackSize != 0)
+      {
+        *tempBuf = (Byte *)IAlloc_Alloc(allocMain, unpackSize);
+        if (*tempBuf == 0)
+          res = SZ_ERROR_MEM;
+      }
+      if (res == SZ_OK)
+      {
+        res = SzAr_DecodeFolder(&p->db, folderIndex,
+          inStream,
+          p->dataPos,
+          *tempBuf, unpackSize, allocTemp);
+        if (res == SZ_OK)
+        {
+          if (SzBitWithVals_Check(&p->db.FolderCRCs, folderIndex))
+          {
+            if (CrcCalc(*tempBuf, unpackSize) != p->db.FolderCRCs.Vals[folderIndex])
+              res = SZ_ERROR_CRC;
+          }
+        }
+      }
+    }
+  }
+  if (res == SZ_OK)
+  {
+    UInt64 unpackPos = p->UnpackPositions[fileIndex];
+    *offset = (size_t)(unpackPos - p->UnpackPositions[p->FolderStartFileIndex[folderIndex]]);
+    *outSizeProcessed = (size_t)(p->UnpackPositions[fileIndex + 1] - unpackPos);
+    if (*offset + *outSizeProcessed > *outBufferSize)
+      return SZ_ERROR_FAIL;
+    if (SzBitWithVals_Check(&p->CRCs, fileIndex) && CrcCalc(*tempBuf + *offset, *outSizeProcessed) != p->CRCs.Vals[fileIndex])
+      res = SZ_ERROR_CRC;
+  }
+  return res;
+}
+
+
+size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
+{
+  size_t offs = p->FileNameOffsets[fileIndex];
+  size_t len = p->FileNameOffsets[fileIndex + 1] - offs;
+  if (dest != 0)
+  {
+    size_t i;
+    const Byte *src = p->FileNames + offs * 2;
+    for (i = 0; i < len; i++)
+      dest[i] = GetUi16(src + i * 2);
+  }
+  return len;
+}
+
+/*
+size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex)
+{
+  size_t len;
+  if (!p->FileNameOffsets)
+    return 1;
+  len = 0;
+  for (;;)
+  {
+    UInt32 parent = (UInt32)(Int32)-1;
+    len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
+    if SzBitWithVals_Check(&p->Parents, fileIndex)
+      parent = p->Parents.Vals[fileIndex];
+    if (parent == (UInt32)(Int32)-1)
+      return len;
+    fileIndex = parent;
+  }
+}
+
+UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
+{
+  Bool needSlash;
+  if (!p->FileNameOffsets)
+  {
+    *(--dest) = 0;
+    return dest;
+  }
+  needSlash = False;
+  for (;;)
+  {
+    UInt32 parent = (UInt32)(Int32)-1;
+    size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
+    SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen);
+    if (needSlash)
+      *(dest - 1) = '/';
+    needSlash = True;
+    dest -= curLen;
+
+    if SzBitWithVals_Check(&p->Parents, fileIndex)
+      parent = p->Parents.Vals[fileIndex];
+    if (parent == (UInt32)(Int32)-1)
+      return dest;
+    fileIndex = parent;
+  }
+}
+*/

@@ -0,0 +1,36 @@
+/* 7zBuf.c -- Byte Buffer
+2013-01-21 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "7zBuf.h"
+
+void Buf_Init(CBuf *p)
+{
+  p->data = 0;
+  p->size = 0;
+}
+
+int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc)
+{
+  p->size = 0;
+  if (size == 0)
+  {
+    p->data = 0;
+    return 1;
+  }
+  p->data = (Byte *)alloc->Alloc(alloc, size);
+  if (p->data != 0)
+  {
+    p->size = size;
+    return 1;
+  }
+  return 0;
+}
+
+void Buf_Free(CBuf *p, ISzAlloc *alloc)
+{
+  alloc->Free(alloc, p->data);
+  p->data = 0;
+  p->size = 0;
+}

@@ -0,0 +1,35 @@
+/* 7zBuf.h -- Byte Buffer
+2013-01-18 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_BUF_H
+#define __7Z_BUF_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+typedef struct
+{
+  Byte *data;
+  size_t size;
+} CBuf;
+
+void Buf_Init(CBuf *p);
+int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc);
+void Buf_Free(CBuf *p, ISzAlloc *alloc);
+
+typedef struct
+{
+  Byte *data;
+  size_t size;
+  size_t pos;
+} CDynBuf;
+
+void DynBuf_Construct(CDynBuf *p);
+void DynBuf_SeekToBeg(CDynBuf *p);
+int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc);
+void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc);
+
+EXTERN_C_END
+
+#endif

@@ -0,0 +1,48 @@
+/* 7zBuf2.c -- Byte Buffer
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "7zBuf.h"
+
+void DynBuf_Construct(CDynBuf *p)
+{
+  p->data = 0;
+  p->size = 0;
+  p->pos = 0;
+}
+
+void DynBuf_SeekToBeg(CDynBuf *p)
+{
+  p->pos = 0;
+}
+
+int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc)
+{
+  if (size > p->size - p->pos)
+  {
+    size_t newSize = p->pos + size;
+    Byte *data;
+    newSize += newSize / 4;
+    data = (Byte *)alloc->Alloc(alloc, newSize);
+    if (data == 0)
+      return 0;
+    p->size = newSize;
+    memcpy(data, p->data, p->pos);
+    alloc->Free(alloc, p->data);
+    p->data = data;
+  }
+  memcpy(p->data + p->pos, buf, size);
+  p->pos += size;
+  return 1;
+}
+
+void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc)
+{
+  alloc->Free(alloc, p->data);
+  p->data = 0;
+  p->size = 0;
+  p->pos = 0;
+}

@@ -0,0 +1,85 @@
+/* 7zCrc.c -- CRC32 init
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "7zCrc.h"
+#include "CpuArch.h"
+
+#define kCrcPoly 0xEDB88320
+
+#ifdef MY_CPU_X86_OR_AMD64
+  #define CRC_NUM_TABLES 8
+  UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
+#elif defined(MY_CPU_LE)
+  #define CRC_NUM_TABLES 4
+#else
+  #define CRC_NUM_TABLES 5
+  #define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
+  UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
+#endif
+
+#ifndef MY_CPU_BE
+  UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
+#endif
+
+typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
+
+CRC_FUNC g_CrcUpdate;
+UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
+
+UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)
+{
+  return g_CrcUpdate(v, data, size, g_CrcTable);
+}
+
+UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size)
+{
+  return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL;
+}
+
+void MY_FAST_CALL CrcGenerateTable()
+{
+  UInt32 i;
+  for (i = 0; i < 256; i++)
+  {
+    UInt32 r = i;
+    unsigned j;
+    for (j = 0; j < 8; j++)
+      r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
+    g_CrcTable[i] = r;
+  }
+  for (; i < 256 * CRC_NUM_TABLES; i++)
+  {
+    UInt32 r = g_CrcTable[i - 256];
+    g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
+  }
+  
+  #ifdef MY_CPU_LE
+
+  g_CrcUpdate = CrcUpdateT4;
+  
+  #if CRC_NUM_TABLES == 8
+  if (!CPU_Is_InOrder())
+    g_CrcUpdate = CrcUpdateT8;
+  #endif
+
+  #else
+  {
+    #ifndef MY_CPU_BE
+    UInt32 k = 1;
+    if (*(const Byte *)&k == 1)
+      g_CrcUpdate = CrcUpdateT4;
+    else
+    #endif
+    {
+      for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
+      {
+        UInt32 x = g_CrcTable[i - 256];
+        g_CrcTable[i] = CRC_UINT32_SWAP(x);
+      }
+      g_CrcUpdate = CrcUpdateT1_BeT4;
+    }
+  }
+  #endif
+}

@@ -0,0 +1,25 @@
+/* 7zCrc.h -- CRC32 calculation
+2013-01-18 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_CRC_H
+#define __7Z_CRC_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+extern UInt32 g_CrcTable[];
+
+/* Call CrcGenerateTable one time before other CRC functions */
+void MY_FAST_CALL CrcGenerateTable(void);
+
+#define CRC_INIT_VAL 0xFFFFFFFF
+#define CRC_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL)
+#define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+UInt32 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size);
+UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size);
+
+EXTERN_C_END
+
+#endif

@@ -0,0 +1,66 @@
+/* 7zCrcOpt.c -- CRC32 calculation
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "CpuArch.h"
+
+#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+#ifndef MY_CPU_BE
+
+UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
+{
+  const Byte *p = (const Byte *)data;
+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  for (; size >= 4; size -= 4, p += 4)
+  {
+    v ^= *(const UInt32 *)p;
+    v =
+      table[0x300 + (v & 0xFF)] ^
+      table[0x200 + ((v >> 8) & 0xFF)] ^
+      table[0x100 + ((v >> 16) & 0xFF)] ^
+      table[0x000 + ((v >> 24))];
+  }
+  for (; size > 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  return v;
+}
+
+UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
+{
+  return CrcUpdateT4(v, data, size, table);
+}
+
+#endif
+
+
+#ifndef MY_CPU_LE
+
+#define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
+
+UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
+{
+  const Byte *p = (const Byte *)data;
+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  v = CRC_UINT32_SWAP(v);
+  table += 0x100;
+  for (; size >= 4; size -= 4, p += 4)
+  {
+    v ^= *(const UInt32 *)p;
+    v =
+      table[0x000 + (v & 0xFF)] ^
+      table[0x100 + ((v >> 8) & 0xFF)] ^
+      table[0x200 + ((v >> 16) & 0xFF)] ^
+      table[0x300 + ((v >> 24))];
+  }
+  table -= 0x100;
+  v = CRC_UINT32_SWAP(v);
+  for (; size > 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  return v;
+}
+
+#endif

@@ -0,0 +1,493 @@
+/* 7zDec.c -- Decoding from 7z folder
+2014-06-16 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+/* #define _7ZIP_PPMD_SUPPPORT */
+
+#include "7z.h"
+
+#include "Bcj2.h"
+#include "Bra.h"
+#include "CpuArch.h"
+#include "LzmaDec.h"
+#include "Lzma2Dec.h"
+#ifdef _7ZIP_PPMD_SUPPPORT
+#include "Ppmd7.h"
+#endif
+
+#define k_Copy 0
+#define k_LZMA2 0x21
+#define k_LZMA  0x30101
+#define k_BCJ   0x03030103
+#define k_PPC   0x03030205
+#define k_ARM   0x03030501
+#define k_ARMT  0x03030701
+#define k_SPARC 0x03030805
+#define k_BCJ2  0x0303011B
+
+#ifdef _7ZIP_PPMD_SUPPPORT
+
+#define k_PPMD 0x30401
+
+typedef struct
+{
+  IByteIn p;
+  const Byte *cur;
+  const Byte *end;
+  const Byte *begin;
+  UInt64 processed;
+  Bool extra;
+  SRes res;
+  ILookInStream *inStream;
+} CByteInToLook;
+
+static Byte ReadByte(void *pp)
+{
+  CByteInToLook *p = (CByteInToLook *)pp;
+  if (p->cur != p->end)
+    return *p->cur++;
+  if (p->res == SZ_OK)
+  {
+    size_t size = p->cur - p->begin;
+    p->processed += size;
+    p->res = p->inStream->Skip(p->inStream, size);
+    size = (1 << 25);
+    p->res = p->inStream->Look(p->inStream, (const void **)&p->begin, &size);
+    p->cur = p->begin;
+    p->end = p->begin + size;
+    if (size != 0)
+      return *p->cur++;;
+  }
+  p->extra = True;
+  return 0;
+}
+
+static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
+    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)
+{
+  CPpmd7 ppmd;
+  CByteInToLook s;
+  SRes res = SZ_OK;
+
+  s.p.Read = ReadByte;
+  s.inStream = inStream;
+  s.begin = s.end = s.cur = NULL;
+  s.extra = False;
+  s.res = SZ_OK;
+  s.processed = 0;
+
+  if (propsSize != 5)
+    return SZ_ERROR_UNSUPPORTED;
+
+  {
+    unsigned order = props[0];
+    UInt32 memSize = GetUi32(props + 1);
+    if (order < PPMD7_MIN_ORDER ||
+        order > PPMD7_MAX_ORDER ||
+        memSize < PPMD7_MIN_MEM_SIZE ||
+        memSize > PPMD7_MAX_MEM_SIZE)
+      return SZ_ERROR_UNSUPPORTED;
+    Ppmd7_Construct(&ppmd);
+    if (!Ppmd7_Alloc(&ppmd, memSize, allocMain))
+      return SZ_ERROR_MEM;
+    Ppmd7_Init(&ppmd, order);
+  }
+  {
+    CPpmd7z_RangeDec rc;
+    Ppmd7z_RangeDec_CreateVTable(&rc);
+    rc.Stream = &s.p;
+    if (!Ppmd7z_RangeDec_Init(&rc))
+      res = SZ_ERROR_DATA;
+    else if (s.extra)
+      res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
+    else
+    {
+      SizeT i;
+      for (i = 0; i < outSize; i++)
+      {
+        int sym = Ppmd7_DecodeSymbol(&ppmd, &rc.p);
+        if (s.extra || sym < 0)
+          break;
+        outBuffer[i] = (Byte)sym;
+      }
+      if (i != outSize)
+        res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
+      else if (s.processed + (s.cur - s.begin) != inSize || !Ppmd7z_RangeDec_IsFinishedOK(&rc))
+        res = SZ_ERROR_DATA;
+    }
+  }
+  Ppmd7_Free(&ppmd, allocMain);
+  return res;
+}
+
+#endif
+
+
+static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
+    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)
+{
+  CLzmaDec state;
+  SRes res = SZ_OK;
+
+  LzmaDec_Construct(&state);
+  RINOK(LzmaDec_AllocateProbs(&state, props, propsSize, allocMain));
+  state.dic = outBuffer;
+  state.dicBufSize = outSize;
+  LzmaDec_Init(&state);
+
+  for (;;)
+  {
+    Byte *inBuf = NULL;
+    size_t lookahead = (1 << 18);
+    if (lookahead > inSize)
+      lookahead = (size_t)inSize;
+    res = inStream->Look((void *)inStream, (const void **)&inBuf, &lookahead);
+    if (res != SZ_OK)
+      break;
+
+    {
+      SizeT inProcessed = (SizeT)lookahead, dicPos = state.dicPos;
+      ELzmaStatus status;
+      res = LzmaDec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);
+      lookahead -= inProcessed;
+      inSize -= inProcessed;
+      if (res != SZ_OK)
+        break;
+      if (state.dicPos == state.dicBufSize || (inProcessed == 0 && dicPos == state.dicPos))
+      {
+        if (state.dicBufSize != outSize || lookahead != 0 ||
+            (status != LZMA_STATUS_FINISHED_WITH_MARK &&
+             status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK))
+          res = SZ_ERROR_DATA;
+        break;
+      }
+      res = inStream->Skip((void *)inStream, inProcessed);
+      if (res != SZ_OK)
+        break;
+    }
+  }
+
+  LzmaDec_FreeProbs(&state, allocMain);
+  return res;
+}
+
+static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
+    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)
+{
+  CLzma2Dec state;
+  SRes res = SZ_OK;
+
+  Lzma2Dec_Construct(&state);
+  if (propsSize != 1)
+    return SZ_ERROR_DATA;
+  RINOK(Lzma2Dec_AllocateProbs(&state, props[0], allocMain));
+  state.decoder.dic = outBuffer;
+  state.decoder.dicBufSize = outSize;
+  Lzma2Dec_Init(&state);
+
+  for (;;)
+  {
+    Byte *inBuf = NULL;
+    size_t lookahead = (1 << 18);
+    if (lookahead > inSize)
+      lookahead = (size_t)inSize;
+    res = inStream->Look((void *)inStream, (const void **)&inBuf, &lookahead);
+    if (res != SZ_OK)
+      break;
+
+    {
+      SizeT inProcessed = (SizeT)lookahead, dicPos = state.decoder.dicPos;
+      ELzmaStatus status;
+      res = Lzma2Dec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);
+      lookahead -= inProcessed;
+      inSize -= inProcessed;
+      if (res != SZ_OK)
+        break;
+      if (state.decoder.dicPos == state.decoder.dicBufSize || (inProcessed == 0 && dicPos == state.decoder.dicPos))
+      {
+        if (state.decoder.dicBufSize != outSize || lookahead != 0 ||
+            (status != LZMA_STATUS_FINISHED_WITH_MARK))
+          res = SZ_ERROR_DATA;
+        break;
+      }
+      res = inStream->Skip((void *)inStream, inProcessed);
+      if (res != SZ_OK)
+        break;
+    }
+  }
+
+  Lzma2Dec_FreeProbs(&state, allocMain);
+  return res;
+}
+
+static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer)
+{
+  while (inSize > 0)
+  {
+    void *inBuf;
+    size_t curSize = (1 << 18);
+    if (curSize > inSize)
+      curSize = (size_t)inSize;
+    RINOK(inStream->Look((void *)inStream, (const void **)&inBuf, &curSize));
+    if (curSize == 0)
+      return SZ_ERROR_INPUT_EOF;
+    memcpy(outBuffer, inBuf, curSize);
+    outBuffer += curSize;
+    inSize -= curSize;
+    RINOK(inStream->Skip((void *)inStream, curSize));
+  }
+  return SZ_OK;
+}
+
+static Bool IS_MAIN_METHOD(UInt32 m)
+{
+  switch (m)
+  {
+    case k_Copy:
+    case k_LZMA:
+    case k_LZMA2:
+    #ifdef _7ZIP_PPMD_SUPPPORT
+    case k_PPMD:
+    #endif
+      return True;
+  }
+  return False;
+}
+
+static Bool IS_SUPPORTED_CODER(const CSzCoderInfo *c)
+{
+  return
+      c->NumInStreams == 1 &&
+      c->NumOutStreams == 1 &&
+      /* c->MethodID <= (UInt32)0xFFFFFFFF && */
+      IS_MAIN_METHOD((UInt32)c->MethodID);
+}
+
+#define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumInStreams == 4 && (c)->NumOutStreams == 1)
+
+static SRes CheckSupportedFolder(const CSzFolder *f)
+{
+  if (f->NumCoders < 1 || f->NumCoders > 4)
+    return SZ_ERROR_UNSUPPORTED;
+  if (!IS_SUPPORTED_CODER(&f->Coders[0]))
+    return SZ_ERROR_UNSUPPORTED;
+  if (f->NumCoders == 1)
+  {
+    if (f->NumPackStreams != 1 || f->PackStreams[0] != 0 || f->NumBindPairs != 0)
+      return SZ_ERROR_UNSUPPORTED;
+    return SZ_OK;
+  }
+  if (f->NumCoders == 2)
+  {
+    const CSzCoderInfo *c = &f->Coders[1];
+    if (
+        /* c->MethodID > (UInt32)0xFFFFFFFF || */
+        c->NumInStreams != 1 ||
+        c->NumOutStreams != 1 ||
+        f->NumPackStreams != 1 ||
+        f->PackStreams[0] != 0 ||
+        f->NumBindPairs != 1 ||
+        f->BindPairs[0].InIndex != 1 ||
+        f->BindPairs[0].OutIndex != 0)
+      return SZ_ERROR_UNSUPPORTED;
+    switch ((UInt32)c->MethodID)
+    {
+      case k_BCJ:
+      case k_ARM:
+        break;
+      default:
+        return SZ_ERROR_UNSUPPORTED;
+    }
+    return SZ_OK;
+  }
+  if (f->NumCoders == 4)
+  {
+    if (!IS_SUPPORTED_CODER(&f->Coders[1]) ||
+        !IS_SUPPORTED_CODER(&f->Coders[2]) ||
+        !IS_BCJ2(&f->Coders[3]))
+      return SZ_ERROR_UNSUPPORTED;
+    if (f->NumPackStreams != 4 ||
+        f->PackStreams[0] != 2 ||
+        f->PackStreams[1] != 6 ||
+        f->PackStreams[2] != 1 ||
+        f->PackStreams[3] != 0 ||
+        f->NumBindPairs != 3 ||
+        f->BindPairs[0].InIndex != 5 || f->BindPairs[0].OutIndex != 0 ||
+        f->BindPairs[1].InIndex != 4 || f->BindPairs[1].OutIndex != 1 ||
+        f->BindPairs[2].InIndex != 3 || f->BindPairs[2].OutIndex != 2)
+      return SZ_ERROR_UNSUPPORTED;
+    return SZ_OK;
+  }
+  return SZ_ERROR_UNSUPPORTED;
+}
+
+#define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break;
+
+static SRes SzFolder_Decode2(const CSzFolder *folder,
+    const Byte *propsData,
+    const UInt64 *unpackSizes,
+    const UInt64 *packPositions,
+    ILookInStream *inStream, UInt64 startPos,
+    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain,
+    Byte *tempBuf[])
+{
+  UInt32 ci;
+  SizeT tempSizes[3] = { 0, 0, 0};
+  SizeT tempSize3 = 0;
+  Byte *tempBuf3 = 0;
+
+  RINOK(CheckSupportedFolder(folder));
+
+  for (ci = 0; ci < folder->NumCoders; ci++)
+  {
+    const CSzCoderInfo *coder = &folder->Coders[ci];
+
+    if (IS_MAIN_METHOD((UInt32)coder->MethodID))
+    {
+      UInt32 si = 0;
+      UInt64 offset;
+      UInt64 inSize;
+      Byte *outBufCur = outBuffer;
+      SizeT outSizeCur = outSize;
+      if (folder->NumCoders == 4)
+      {
+        UInt32 indices[] = { 3, 2, 0 };
+        UInt64 unpackSize = unpackSizes[ci];
+        si = indices[ci];
+        if (ci < 2)
+        {
+          Byte *temp;
+          outSizeCur = (SizeT)unpackSize;
+          if (outSizeCur != unpackSize)
+            return SZ_ERROR_MEM;
+          temp = (Byte *)IAlloc_Alloc(allocMain, outSizeCur);
+          if (temp == 0 && outSizeCur != 0)
+            return SZ_ERROR_MEM;
+          outBufCur = tempBuf[1 - ci] = temp;
+          tempSizes[1 - ci] = outSizeCur;
+        }
+        else if (ci == 2)
+        {
+          if (unpackSize > outSize) /* check it */
+            return SZ_ERROR_PARAM;
+          tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize);
+          tempSize3 = outSizeCur = (SizeT)unpackSize;
+        }
+        else
+          return SZ_ERROR_UNSUPPORTED;
+      }
+      offset = packPositions[si];
+      inSize = packPositions[si + 1] - offset;
+      RINOK(LookInStream_SeekTo(inStream, startPos + offset));
+
+      if (coder->MethodID == k_Copy)
+      {
+        if (inSize != outSizeCur) /* check it */
+          return SZ_ERROR_DATA;
+        RINOK(SzDecodeCopy(inSize, inStream, outBufCur));
+      }
+      else if (coder->MethodID == k_LZMA)
+      {
+        RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
+      }
+      else if (coder->MethodID == k_LZMA2)
+      {
+        RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
+      }
+      else
+      {
+        #ifdef _7ZIP_PPMD_SUPPPORT
+        RINOK(SzDecodePpmd(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
+        #else
+        return SZ_ERROR_UNSUPPORTED;
+        #endif
+      }
+    }
+    else if (coder->MethodID == k_BCJ2)
+    {
+      UInt64 offset = packPositions[1];
+      UInt64 s3Size = packPositions[2] - offset;
+      SRes res;
+      if (ci != 3)
+        return SZ_ERROR_UNSUPPORTED;
+      RINOK(LookInStream_SeekTo(inStream, startPos + offset));
+      tempSizes[2] = (SizeT)s3Size;
+      if (tempSizes[2] != s3Size)
+        return SZ_ERROR_MEM;
+      tempBuf[2] = (Byte *)IAlloc_Alloc(allocMain, tempSizes[2]);
+      if (tempBuf[2] == 0 && tempSizes[2] != 0)
+        return SZ_ERROR_MEM;
+      res = SzDecodeCopy(s3Size, inStream, tempBuf[2]);
+      RINOK(res)
+
+      res = Bcj2_Decode(
+          tempBuf3, tempSize3,
+          tempBuf[0], tempSizes[0],
+          tempBuf[1], tempSizes[1],
+          tempBuf[2], tempSizes[2],
+          outBuffer, outSize);
+      RINOK(res)
+    }
+    else
+    {
+      if (ci != 1)
+        return SZ_ERROR_UNSUPPORTED;
+      switch (coder->MethodID)
+      {
+        case k_BCJ:
+        {
+          UInt32 state;
+          x86_Convert_Init(state);
+          x86_Convert(outBuffer, outSize, 0, &state, 0);
+          break;
+        }
+        CASE_BRA_CONV(ARM)
+        default:
+          return SZ_ERROR_UNSUPPORTED;
+      }
+    }
+  }
+  return SZ_OK;
+}
+
+SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
+    ILookInStream *inStream, UInt64 startPos,
+    Byte *outBuffer, size_t outSize,
+    ISzAlloc *allocMain)
+{
+  SRes res;
+  CSzFolder folder;
+  CSzData sd;
+  CSzData sdSizes;
+  
+  const Byte *data = p->CodersData + p->FoCodersOffsets[folderIndex];
+  sd.Data = data;
+  sd.Size = p->FoCodersOffsets[folderIndex + 1] - p->FoCodersOffsets[folderIndex];
+  
+  sdSizes.Data = p->UnpackSizesData + p->FoSizesOffsets[folderIndex];
+  sdSizes.Size =
+      p->FoSizesOffsets[folderIndex + 1] -
+      p->FoSizesOffsets[folderIndex];
+
+  res = SzGetNextFolderItem(&folder, &sd, &sdSizes);
+  
+  if (res != SZ_OK)
+    return res;
+
+  if (sd.Size != 0 || outSize != folder.CodersUnpackSizes[folder.MainOutStream])
+    return SZ_ERROR_FAIL;
+  {
+    int i;
+    Byte *tempBuf[3] = { 0, 0, 0};
+    res = SzFolder_Decode2(&folder, data, folder.CodersUnpackSizes,
+        p->PackPositions + p->FoStartPackStreamIndex[folderIndex],
+        inStream, startPos,
+        outBuffer, (SizeT)outSize, allocMain, tempBuf);
+    for (i = 0; i < 3; i++)
+      IAlloc_Free(allocMain, tempBuf[i]);
+    return res;
+  }
+}

@@ -0,0 +1,286 @@
+/* 7zFile.c -- File IO
+2009-11-24 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "7zFile.h"
+
+#ifndef USE_WINDOWS_FILE
+
+#ifndef UNDER_CE
+#include <errno.h>
+#endif
+
+#else
+
+/*
+   ReadFile and WriteFile functions in Windows have BUG:
+   If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)
+   from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES
+   (Insufficient system resources exist to complete the requested service).
+   Probably in some version of Windows there are problems with other sizes:
+   for 32 MB (maybe also for 16 MB).
+   And message can be "Network connection was lost"
+*/
+
+#define kChunkSizeMax (1 << 22)
+
+#endif
+
+void File_Construct(CSzFile *p)
+{
+  #ifdef USE_WINDOWS_FILE
+  p->handle = INVALID_HANDLE_VALUE;
+  #else
+  p->file = NULL;
+  #endif
+}
+
+#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
+static WRes File_Open(CSzFile *p, const char *name, int writeMode)
+{
+  #ifdef USE_WINDOWS_FILE
+  p->handle = CreateFileA(name,
+      writeMode ? GENERIC_WRITE : GENERIC_READ,
+      FILE_SHARE_READ, NULL,
+      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,
+      FILE_ATTRIBUTE_NORMAL, NULL);
+  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
+  #else
+  p->file = fopen(name, writeMode ? "wb+" : "rb");
+  return (p->file != 0) ? 0 :
+    #ifdef UNDER_CE
+    2; /* ENOENT */
+    #else
+    errno;
+    #endif
+  #endif
+}
+
+WRes InFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 0); }
+WRes OutFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 1); }
+#endif
+
+#ifdef USE_WINDOWS_FILE
+static WRes File_OpenW(CSzFile *p, const WCHAR *name, int writeMode)
+{
+  p->handle = CreateFileW(name,
+      writeMode ? GENERIC_WRITE : GENERIC_READ,
+      FILE_SHARE_READ, NULL,
+      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,
+      FILE_ATTRIBUTE_NORMAL, NULL);
+  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
+}
+WRes InFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 0); }
+WRes OutFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 1); }
+#endif
+
+WRes File_Close(CSzFile *p)
+{
+  #ifdef USE_WINDOWS_FILE
+  if (p->handle != INVALID_HANDLE_VALUE)
+  {
+    if (!CloseHandle(p->handle))
+      return GetLastError();
+    p->handle = INVALID_HANDLE_VALUE;
+  }
+  #else
+  if (p->file != NULL)
+  {
+    int res = fclose(p->file);
+    if (res != 0)
+      return res;
+    p->file = NULL;
+  }
+  #endif
+  return 0;
+}
+
+WRes File_Read(CSzFile *p, void *data, size_t *size)
+{
+  size_t originalSize = *size;
+  if (originalSize == 0)
+    return 0;
+
+  #ifdef USE_WINDOWS_FILE
+
+  *size = 0;
+  do
+  {
+    DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
+    DWORD processed = 0;
+    BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);
+    data = (void *)((Byte *)data + processed);
+    originalSize -= processed;
+    *size += processed;
+    if (!res)
+      return GetLastError();
+    if (processed == 0)
+      break;
+  }
+  while (originalSize > 0);
+  return 0;
+
+  #else
+  
+  *size = fread(data, 1, originalSize, p->file);
+  if (*size == originalSize)
+    return 0;
+  return ferror(p->file);
+  
+  #endif
+}
+
+WRes File_Write(CSzFile *p, const void *data, size_t *size)
+{
+  size_t originalSize = *size;
+  if (originalSize == 0)
+    return 0;
+  
+  #ifdef USE_WINDOWS_FILE
+
+  *size = 0;
+  do
+  {
+    DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
+    DWORD processed = 0;
+    BOOL res = WriteFile(p->handle, data, curSize, &processed, NULL);
+    data = (void *)((Byte *)data + processed);
+    originalSize -= processed;
+    *size += processed;
+    if (!res)
+      return GetLastError();
+    if (processed == 0)
+      break;
+  }
+  while (originalSize > 0);
+  return 0;
+
+  #else
+
+  *size = fwrite(data, 1, originalSize, p->file);
+  if (*size == originalSize)
+    return 0;
+  return ferror(p->file);
+  
+  #endif
+}
+
+WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
+{
+  #ifdef USE_WINDOWS_FILE
+
+  LARGE_INTEGER value;
+  DWORD moveMethod;
+  value.LowPart = (DWORD)*pos;
+  value.HighPart = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */
+  switch (origin)
+  {
+    case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;
+    case SZ_SEEK_CUR: moveMethod = FILE_CURRENT; break;
+    case SZ_SEEK_END: moveMethod = FILE_END; break;
+    default: return ERROR_INVALID_PARAMETER;
+  }
+  value.LowPart = SetFilePointer(p->handle, value.LowPart, &value.HighPart, moveMethod);
+  if (value.LowPart == 0xFFFFFFFF)
+  {
+    WRes res = GetLastError();
+    if (res != NO_ERROR)
+      return res;
+  }
+  *pos = ((Int64)value.HighPart << 32) | value.LowPart;
+  return 0;
+
+  #else
+  
+  int moveMethod;
+  int res;
+  switch (origin)
+  {
+    case SZ_SEEK_SET: moveMethod = SEEK_SET; break;
+    case SZ_SEEK_CUR: moveMethod = SEEK_CUR; break;
+    case SZ_SEEK_END: moveMethod = SEEK_END; break;
+    default: return 1;
+  }
+  res = fseek(p->file, (long)*pos, moveMethod);
+  *pos = ftell(p->file);
+  return res;
+  
+  #endif
+}
+
+WRes File_GetLength(CSzFile *p, UInt64 *length)
+{
+  #ifdef USE_WINDOWS_FILE
+  
+  DWORD sizeHigh;
+  DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);
+  if (sizeLow == 0xFFFFFFFF)
+  {
+    DWORD res = GetLastError();
+    if (res != NO_ERROR)
+      return res;
+  }
+  *length = (((UInt64)sizeHigh) << 32) + sizeLow;
+  return 0;
+  
+  #else
+  
+  long pos = ftell(p->file);
+  int res = fseek(p->file, 0, SEEK_END);
+  *length = ftell(p->file);
+  fseek(p->file, pos, SEEK_SET);
+  return res;
+  
+  #endif
+}
+
+
+/* ---------- FileSeqInStream ---------- */
+
+static SRes FileSeqInStream_Read(void *pp, void *buf, size_t *size)
+{
+  CFileSeqInStream *p = (CFileSeqInStream *)pp;
+  return File_Read(&p->file, buf, size) == 0 ? SZ_OK : SZ_ERROR_READ;
+}
+
+void FileSeqInStream_CreateVTable(CFileSeqInStream *p)
+{
+  p->s.Read = FileSeqInStream_Read;
+}
+
+
+/* ---------- FileInStream ---------- */
+
+static SRes FileInStream_Read(void *pp, void *buf, size_t *size)
+{
+  CFileInStream *p = (CFileInStream *)pp;
+  return (File_Read(&p->file, buf, size) == 0) ? SZ_OK : SZ_ERROR_READ;
+}
+
+static SRes FileInStream_Seek(void *pp, Int64 *pos, ESzSeek origin)
+{
+  CFileInStream *p = (CFileInStream *)pp;
+  return File_Seek(&p->file, pos, origin);
+}
+
+void FileInStream_CreateVTable(CFileInStream *p)
+{
+  p->s.Read = FileInStream_Read;
+  p->s.Seek = FileInStream_Seek;
+}
+
+
+/* ---------- FileOutStream ---------- */
+
+static size_t FileOutStream_Write(void *pp, const void *data, size_t size)
+{
+  CFileOutStream *p = (CFileOutStream *)pp;
+  File_Write(&p->file, data, &size);
+  return size;
+}
+
+void FileOutStream_CreateVTable(CFileOutStream *p)
+{
+  p->s.Write = FileOutStream_Write;
+}

@@ -0,0 +1,83 @@
+/* 7zFile.h -- File IO
+2013-01-18 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_FILE_H
+#define __7Z_FILE_H
+
+#ifdef _WIN32
+#define USE_WINDOWS_FILE
+#endif
+
+#ifdef USE_WINDOWS_FILE
+#include <windows.h>
+#else
+#include <stdio.h>
+#endif
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+/* ---------- File ---------- */
+
+typedef struct
+{
+  #ifdef USE_WINDOWS_FILE
+  HANDLE handle;
+  #else
+  FILE *file;
+  #endif
+} CSzFile;
+
+void File_Construct(CSzFile *p);
+#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
+WRes InFile_Open(CSzFile *p, const char *name);
+WRes OutFile_Open(CSzFile *p, const char *name);
+#endif
+#ifdef USE_WINDOWS_FILE
+WRes InFile_OpenW(CSzFile *p, const WCHAR *name);
+WRes OutFile_OpenW(CSzFile *p, const WCHAR *name);
+#endif
+WRes File_Close(CSzFile *p);
+
+/* reads max(*size, remain file's size) bytes */
+WRes File_Read(CSzFile *p, void *data, size_t *size);
+
+/* writes *size bytes */
+WRes File_Write(CSzFile *p, const void *data, size_t *size);
+
+WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin);
+WRes File_GetLength(CSzFile *p, UInt64 *length);
+
+
+/* ---------- FileInStream ---------- */
+
+typedef struct
+{
+  ISeqInStream s;
+  CSzFile file;
+} CFileSeqInStream;
+
+void FileSeqInStream_CreateVTable(CFileSeqInStream *p);
+
+
+typedef struct
+{
+  ISeekInStream s;
+  CSzFile file;
+} CFileInStream;
+
+void FileInStream_CreateVTable(CFileInStream *p);
+
+
+typedef struct
+{
+  ISeqOutStream s;
+  CSzFile file;
+} CFileOutStream;
+
+void FileOutStream_CreateVTable(CFileOutStream *p);
+
+EXTERN_C_END
+
+#endif

@@ -0,0 +1,171 @@
+/* 7zStream.c -- 7z Stream functions
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "7zTypes.h"
+
+SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType)
+{
+  while (size != 0)
+  {
+    size_t processed = size;
+    RINOK(stream->Read(stream, buf, &processed));
+    if (processed == 0)
+      return errorType;
+    buf = (void *)((Byte *)buf + processed);
+    size -= processed;
+  }
+  return SZ_OK;
+}
+
+SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size)
+{
+  return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
+}
+
+SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf)
+{
+  size_t processed = 1;
+  RINOK(stream->Read(stream, buf, &processed));
+  return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;
+}
+
+SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset)
+{
+  Int64 t = offset;
+  return stream->Seek(stream, &t, SZ_SEEK_SET);
+}
+
+SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size)
+{
+  const void *lookBuf;
+  if (*size == 0)
+    return SZ_OK;
+  RINOK(stream->Look(stream, &lookBuf, size));
+  memcpy(buf, lookBuf, *size);
+  return stream->Skip(stream, *size);
+}
+
+SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType)
+{
+  while (size != 0)
+  {
+    size_t processed = size;
+    RINOK(stream->Read(stream, buf, &processed));
+    if (processed == 0)
+      return errorType;
+    buf = (void *)((Byte *)buf + processed);
+    size -= processed;
+  }
+  return SZ_OK;
+}
+
+SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size)
+{
+  return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
+}
+
+static SRes LookToRead_Look_Lookahead(void *pp, const void **buf, size_t *size)
+{
+  SRes res = SZ_OK;
+  CLookToRead *p = (CLookToRead *)pp;
+  size_t size2 = p->size - p->pos;
+  if (size2 == 0 && *size > 0)
+  {
+    p->pos = 0;
+    size2 = LookToRead_BUF_SIZE;
+    res = p->realStream->Read(p->realStream, p->buf, &size2);
+    p->size = size2;
+  }
+  if (size2 < *size)
+    *size = size2;
+  *buf = p->buf + p->pos;
+  return res;
+}
+
+static SRes LookToRead_Look_Exact(void *pp, const void **buf, size_t *size)
+{
+  SRes res = SZ_OK;
+  CLookToRead *p = (CLookToRead *)pp;
+  size_t size2 = p->size - p->pos;
+  if (size2 == 0 && *size > 0)
+  {
+    p->pos = 0;
+    if (*size > LookToRead_BUF_SIZE)
+      *size = LookToRead_BUF_SIZE;
+    res = p->realStream->Read(p->realStream, p->buf, size);
+    size2 = p->size = *size;
+  }
+  if (size2 < *size)
+    *size = size2;
+  *buf = p->buf + p->pos;
+  return res;
+}
+
+static SRes LookToRead_Skip(void *pp, size_t offset)
+{
+  CLookToRead *p = (CLookToRead *)pp;
+  p->pos += offset;
+  return SZ_OK;
+}
+
+static SRes LookToRead_Read(void *pp, void *buf, size_t *size)
+{
+  CLookToRead *p = (CLookToRead *)pp;
+  size_t rem = p->size - p->pos;
+  if (rem == 0)
+    return p->realStream->Read(p->realStream, buf, size);
+  if (rem > *size)
+    rem = *size;
+  memcpy(buf, p->buf + p->pos, rem);
+  p->pos += rem;
+  *size = rem;
+  return SZ_OK;
+}
+
+static SRes LookToRead_Seek(void *pp, Int64 *pos, ESzSeek origin)
+{
+  CLookToRead *p = (CLookToRead *)pp;
+  p->pos = p->size = 0;
+  return p->realStream->Seek(p->realStream, pos, origin);
+}
+
+void LookToRead_CreateVTable(CLookToRead *p, int lookahead)
+{
+  p->s.Look = lookahead ?
+      LookToRead_Look_Lookahead :
+      LookToRead_Look_Exact;
+  p->s.Skip = LookToRead_Skip;
+  p->s.Read = LookToRead_Read;
+  p->s.Seek = LookToRead_Seek;
+}
+
+void LookToRead_Init(CLookToRead *p)
+{
+  p->pos = p->size = 0;
+}
+
+static SRes SecToLook_Read(void *pp, void *buf, size_t *size)
+{
+  CSecToLook *p = (CSecToLook *)pp;
+  return LookInStream_LookRead(p->realStream, buf, size);
+}
+
+void SecToLook_CreateVTable(CSecToLook *p)
+{
+  p->s.Read = SecToLook_Read;
+}
+
+static SRes SecToRead_Read(void *pp, void *buf, size_t *size)
+{
+  CSecToRead *p = (CSecToRead *)pp;
+  return p->realStream->Read(p->realStream, buf, size);
+}
+
+void SecToRead_CreateVTable(CSecToRead *p)
+{
+  p->s.Read = SecToRead_Read;
+}

@@ -0,0 +1,256 @@
+/* 7zTypes.h -- Basic types
+2013-11-12 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_TYPES_H
+#define __7Z_TYPES_H
+
+#ifdef _WIN32
+/* #include <windows.h> */
+#endif
+
+#include <stddef.h>
+
+#ifndef EXTERN_C_BEGIN
+#ifdef __cplusplus
+#define EXTERN_C_BEGIN extern "C" {
+#define EXTERN_C_END }
+#else
+#define EXTERN_C_BEGIN
+#define EXTERN_C_END
+#endif
+#endif
+
+EXTERN_C_BEGIN
+
+#define SZ_OK 0
+
+#define SZ_ERROR_DATA 1
+#define SZ_ERROR_MEM 2
+#define SZ_ERROR_CRC 3
+#define SZ_ERROR_UNSUPPORTED 4
+#define SZ_ERROR_PARAM 5
+#define SZ_ERROR_INPUT_EOF 6
+#define SZ_ERROR_OUTPUT_EOF 7
+#define SZ_ERROR_READ 8
+#define SZ_ERROR_WRITE 9
+#define SZ_ERROR_PROGRESS 10
+#define SZ_ERROR_FAIL 11
+#define SZ_ERROR_THREAD 12
+
+#define SZ_ERROR_ARCHIVE 16
+#define SZ_ERROR_NO_ARCHIVE 17
+
+typedef int SRes;
+
+#ifdef _WIN32
+/* typedef DWORD WRes; */
+typedef unsigned WRes;
+#else
+typedef int WRes;
+#endif
+
+#ifndef RINOK
+#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }
+#endif
+
+typedef unsigned char Byte;
+typedef short Int16;
+typedef unsigned short UInt16;
+
+#ifdef _LZMA_UINT32_IS_ULONG
+typedef long Int32;
+typedef unsigned long UInt32;
+#else
+typedef int Int32;
+typedef unsigned int UInt32;
+#endif
+
+#ifdef _SZ_NO_INT_64
+
+/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers.
+   NOTES: Some code will work incorrectly in that case! */
+
+typedef long Int64;
+typedef unsigned long UInt64;
+
+#else
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef __int64 Int64;
+typedef unsigned __int64 UInt64;
+#define UINT64_CONST(n) n
+#else
+typedef long long int Int64;
+typedef unsigned long long int UInt64;
+#define UINT64_CONST(n) n ## ULL
+#endif
+
+#endif
+
+#ifdef _LZMA_NO_SYSTEM_SIZE_T
+typedef UInt32 SizeT;
+#else
+typedef size_t SizeT;
+#endif
+
+typedef int Bool;
+#define True 1
+#define False 0
+
+
+#ifdef _WIN32
+#define MY_STD_CALL __stdcall
+#else
+#define MY_STD_CALL
+#endif
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1300
+#define MY_NO_INLINE __declspec(noinline)
+#else
+#define MY_NO_INLINE
+#endif
+
+#define MY_CDECL __cdecl
+#define MY_FAST_CALL __fastcall
+
+#else
+
+#define MY_NO_INLINE
+#define MY_CDECL
+#define MY_FAST_CALL
+
+#endif
+
+
+/* The following interfaces use first parameter as pointer to structure */
+
+typedef struct
+{
+  Byte (*Read)(void *p); /* reads one byte, returns 0 in case of EOF or error */
+} IByteIn;
+
+typedef struct
+{
+  void (*Write)(void *p, Byte b);
+} IByteOut;
+
+typedef struct
+{
+  SRes (*Read)(void *p, void *buf, size_t *size);
+    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
+       (output(*size) < input(*size)) is allowed */
+} ISeqInStream;
+
+/* it can return SZ_ERROR_INPUT_EOF */
+SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size);
+SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType);
+SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf);
+
+typedef struct
+{
+  size_t (*Write)(void *p, const void *buf, size_t size);
+    /* Returns: result - the number of actually written bytes.
+       (result < size) means error */
+} ISeqOutStream;
+
+typedef enum
+{
+  SZ_SEEK_SET = 0,
+  SZ_SEEK_CUR = 1,
+  SZ_SEEK_END = 2
+} ESzSeek;
+
+typedef struct
+{
+  SRes (*Read)(void *p, void *buf, size_t *size);  /* same as ISeqInStream::Read */
+  SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
+} ISeekInStream;
+
+typedef struct
+{
+  SRes (*Look)(void *p, const void **buf, size_t *size);
+    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
+       (output(*size) > input(*size)) is not allowed
+       (output(*size) < input(*size)) is allowed */
+  SRes (*Skip)(void *p, size_t offset);
+    /* offset must be <= output(*size) of Look */
+
+  SRes (*Read)(void *p, void *buf, size_t *size);
+    /* reads directly (without buffer). It's same as ISeqInStream::Read */
+  SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
+} ILookInStream;
+
+SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size);
+SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset);
+
+/* reads via ILookInStream::Read */
+SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType);
+SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size);
+
+#define LookToRead_BUF_SIZE (1 << 14)
+
+typedef struct
+{
+  ILookInStream s;
+  ISeekInStream *realStream;
+  size_t pos;
+  size_t size;
+  Byte buf[LookToRead_BUF_SIZE];
+} CLookToRead;
+
+void LookToRead_CreateVTable(CLookToRead *p, int lookahead);
+void LookToRead_Init(CLookToRead *p);
+
+typedef struct
+{
+  ISeqInStream s;
+  ILookInStream *realStream;
+} CSecToLook;
+
+void SecToLook_CreateVTable(CSecToLook *p);
+
+typedef struct
+{
+  ISeqInStream s;
+  ILookInStream *realStream;
+} CSecToRead;
+
+void SecToRead_CreateVTable(CSecToRead *p);
+
+typedef struct
+{
+  SRes (*Progress)(void *p, UInt64 inSize, UInt64 outSize);
+    /* Returns: result. (result != SZ_OK) means break.
+       Value (UInt64)(Int64)-1 for size means unknown value. */
+} ICompressProgress;
+
+typedef struct
+{
+  void *(*Alloc)(void *p, size_t size);
+  void (*Free)(void *p, void *address); /* address can be 0 */
+} ISzAlloc;
+
+#define IAlloc_Alloc(p, size) (p)->Alloc((p), size)
+#define IAlloc_Free(p, a) (p)->Free((p), a)
+
+#ifdef _WIN32
+
+#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"/"
+
+#endif
+
+EXTERN_C_END
+
+#endif

@@ -0,0 +1,10 @@
+#define MY_VER_MAJOR 9
+#define MY_VER_MINOR 38
+#define MY_VER_BUILD 00
+#define MY_VERSION "9.38 beta"
+// #define MY_7ZIP_VERSION "9.38"
+#define MY_DATE "2015-01-03"
+#undef MY_COPYRIGHT
+#undef MY_VERSION_COPYRIGHT_DATE
+#define MY_COPYRIGHT ": Igor Pavlov : Public domain"
+#define MY_VERSION_COPYRIGHT_DATE MY_VERSION " " MY_COPYRIGHT " : " MY_DATE

@@ -0,0 +1,55 @@
+#define MY_VS_FFI_FILEFLAGSMASK  0x0000003FL
+#define MY_VOS_NT_WINDOWS32  0x00040004L
+#define MY_VOS_CE_WINDOWS32  0x00050004L
+
+#define MY_VFT_APP  0x00000001L
+#define MY_VFT_DLL  0x00000002L
+
+// #include <WinVer.h>
+
+#ifndef MY_VERSION
+#include "7zVersion.h"
+#endif
+
+#define MY_VER MY_VER_MAJOR,MY_VER_MINOR,MY_VER_BUILD,0
+
+#ifdef DEBUG
+#define DBG_FL VS_FF_DEBUG
+#else
+#define DBG_FL 0
+#endif
+
+#define MY_VERSION_INFO(fileType, descr, intName, origName)  \
+LANGUAGE 9, 1 \
+1 VERSIONINFO \
+  FILEVERSION MY_VER \
+  PRODUCTVERSION MY_VER \
+  FILEFLAGSMASK MY_VS_FFI_FILEFLAGSMASK \
+  FILEFLAGS DBG_FL \
+  FILEOS MY_VOS_NT_WINDOWS32 \
+  FILETYPE fileType \
+  FILESUBTYPE 0x0L \
+BEGIN \
+    BLOCK "StringFileInfo" \
+    BEGIN  \
+        BLOCK "040904b0" \
+        BEGIN \
+            VALUE "CompanyName", "Igor Pavlov" \
+            VALUE "FileDescription", descr \
+            VALUE "FileVersion", MY_VERSION  \
+            VALUE "InternalName", intName \
+            VALUE "LegalCopyright", MY_COPYRIGHT \
+            VALUE "OriginalFilename", origName \
+            VALUE "ProductName", "7-Zip" \
+            VALUE "ProductVersion", MY_VERSION \
+        END \
+    END \
+    BLOCK "VarFileInfo" \
+    BEGIN \
+        VALUE "Translation", 0x409, 1200 \
+    END \
+END
+
+#define MY_VERSION_INFO_APP(descr, intName) MY_VERSION_INFO(MY_VFT_APP, descr, intName, intName ".exe")
+
+#define MY_VERSION_INFO_DLL(descr, intName) MY_VERSION_INFO(MY_VFT_DLL, descr, intName, intName ".dll")

@@ -0,0 +1,284 @@
+/* Aes.c -- AES encryption / decryption
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Aes.h"
+#include "CpuArch.h"
+
+static UInt32 T[256 * 4];
+static Byte Sbox[256] = {
+  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};
+
+void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
+
+void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
+
+AES_CODE_FUNC g_AesCbc_Encode;
+AES_CODE_FUNC g_AesCbc_Decode;
+AES_CODE_FUNC g_AesCtr_Code;
+
+static UInt32 D[256 * 4];
+static Byte InvS[256];
+
+static Byte Rcon[11] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
+
+#define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)
+
+#define Ui32(a0, a1, a2, a3) ((UInt32)(a0) | ((UInt32)(a1) << 8) | ((UInt32)(a2) << 16) | ((UInt32)(a3) << 24))
+
+#define gb0(x) ( (x)          & 0xFF)
+#define gb1(x) (((x) >> ( 8)) & 0xFF)
+#define gb2(x) (((x) >> (16)) & 0xFF)
+#define gb3(x) (((x) >> (24)) & 0xFF)
+
+void AesGenTables(void)
+{
+  unsigned i;
+  for (i = 0; i < 256; i++)
+    InvS[Sbox[i]] = (Byte)i;
+  for (i = 0; i < 256; i++)
+  {
+    {
+      UInt32 a1 = Sbox[i];
+      UInt32 a2 = xtime(a1);
+      UInt32 a3 = a2 ^ a1;
+      T[        i] = Ui32(a2, a1, a1, a3);
+      T[0x100 + i] = Ui32(a3, a2, a1, a1);
+      T[0x200 + i] = Ui32(a1, a3, a2, a1);
+      T[0x300 + i] = Ui32(a1, a1, a3, a2);
+    }
+    {
+      UInt32 a1 = InvS[i];
+      UInt32 a2 = xtime(a1);
+      UInt32 a4 = xtime(a2);
+      UInt32 a8 = xtime(a4);
+      UInt32 a9 = a8 ^ a1;
+      UInt32 aB = a8 ^ a2 ^ a1;
+      UInt32 aD = a8 ^ a4 ^ a1;
+      UInt32 aE = a8 ^ a4 ^ a2;
+      D[        i] = Ui32(aE, a9, aD, aB);
+      D[0x100 + i] = Ui32(aB, aE, a9, aD);
+      D[0x200 + i] = Ui32(aD, aB, aE, a9);
+      D[0x300 + i] = Ui32(a9, aD, aB, aE);
+    }
+  }
+  g_AesCbc_Encode = AesCbc_Encode;
+  g_AesCbc_Decode = AesCbc_Decode;
+  g_AesCtr_Code = AesCtr_Code;
+  #ifdef MY_CPU_X86_OR_AMD64
+  if (CPU_Is_Aes_Supported())
+  {
+    g_AesCbc_Encode = AesCbc_Encode_Intel;
+    g_AesCbc_Decode = AesCbc_Decode_Intel;
+    g_AesCtr_Code = AesCtr_Code_Intel;
+  }
+  #endif
+}
+
+#define HT(i, x, s) (T + (x << 8))[gb ## x(s[(i + x) & 3])]
+#define HT4(m, i, s, p) m[i] = \
+    HT(i, 0, s) ^ \
+    HT(i, 1, s) ^ \
+    HT(i, 2, s) ^ \
+    HT(i, 3, s) ^ w[p + i]
+/* such order (2031) in HT16 is for VC6/K8 speed optimization) */
+#define HT16(m, s, p) \
+    HT4(m, 2, s, p); \
+    HT4(m, 0, s, p); \
+    HT4(m, 3, s, p); \
+    HT4(m, 1, s, p); \
+
+#define FT(i, x) Sbox[gb ## x(m[(i + x) & 3])]
+#define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];
+
+#define HD(i, x, s) (D + (x << 8))[gb ## x(s[(i - x) & 3])]
+#define HD4(m, i, s, p) m[i] = \
+    HD(i, 0, s) ^ \
+    HD(i, 1, s) ^ \
+    HD(i, 2, s) ^ \
+    HD(i, 3, s) ^ w[p + i];
+/* such order (0231) in HD16 is for VC6/K8 speed optimization) */
+#define HD16(m, s, p) \
+    HD4(m, 0, s, p); \
+    HD4(m, 2, s, p); \
+    HD4(m, 3, s, p); \
+    HD4(m, 1, s, p); \
+
+#define FD(i, x) InvS[gb ## x(m[(i - x) & 3])]
+#define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];
+
+void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *w, const Byte *key, unsigned keySize)
+{
+  unsigned i, wSize;
+  wSize = keySize + 28;
+  keySize /= 4;
+  w[0] = ((UInt32)keySize / 2) + 3;
+  w += 4;
+
+  for (i = 0; i < keySize; i++, key += 4)
+    w[i] = GetUi32(key);
+
+  for (; i < wSize; i++)
+  {
+    UInt32 t = w[i - 1];
+    unsigned rem = i % keySize;
+    if (rem == 0)
+      t = Ui32(Sbox[gb1(t)] ^ Rcon[i / keySize], Sbox[gb2(t)], Sbox[gb3(t)], Sbox[gb0(t)]);
+    else if (keySize > 6 && rem == 4)
+      t = Ui32(Sbox[gb0(t)], Sbox[gb1(t)], Sbox[gb2(t)], Sbox[gb3(t)]);
+    w[i] = w[i - keySize] ^ t;
+  }
+}
+
+void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)
+{
+  unsigned i, num;
+  Aes_SetKey_Enc(w, key, keySize);
+  num = keySize + 20;
+  w += 8;
+  for (i = 0; i < num; i++)
+  {
+    UInt32 r = w[i];
+    w[i] =
+      D[        Sbox[gb0(r)]] ^
+      D[0x100 + Sbox[gb1(r)]] ^
+      D[0x200 + Sbox[gb2(r)]] ^
+      D[0x300 + Sbox[gb3(r)]];
+  }
+}
+
+/* Aes_Encode and Aes_Decode functions work with little-endian words.
+  src and dest are pointers to 4 UInt32 words.
+  arc and dest can point to same block */
+
+static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
+{
+  UInt32 s[4];
+  UInt32 m[4];
+  UInt32 numRounds2 = w[0];
+  w += 4;
+  s[0] = src[0] ^ w[0];
+  s[1] = src[1] ^ w[1];
+  s[2] = src[2] ^ w[2];
+  s[3] = src[3] ^ w[3];
+  w += 4;
+  for (;;)
+  {
+    HT16(m, s, 0);
+    if (--numRounds2 == 0)
+      break;
+    HT16(s, m, 4);
+    w += 8;
+  }
+  w += 4;
+  FT4(0); FT4(1); FT4(2); FT4(3);
+}
+
+static void Aes_Decode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
+{
+  UInt32 s[4];
+  UInt32 m[4];
+  UInt32 numRounds2 = w[0];
+  w += 4 + numRounds2 * 8;
+  s[0] = src[0] ^ w[0];
+  s[1] = src[1] ^ w[1];
+  s[2] = src[2] ^ w[2];
+  s[3] = src[3] ^ w[3];
+  for (;;)
+  {
+    w -= 8;
+    HD16(m, s, 4);
+    if (--numRounds2 == 0)
+      break;
+    HD16(s, m, 0);
+  }
+  FD4(0); FD4(1); FD4(2); FD4(3);
+}
+
+void AesCbc_Init(UInt32 *p, const Byte *iv)
+{
+  unsigned i;
+  for (i = 0; i < 4; i++)
+    p[i] = GetUi32(iv + i * 4);
+}
+
+void MY_FAST_CALL AesCbc_Encode(UInt32 *p, Byte *data, size_t numBlocks)
+{
+  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
+  {
+    p[0] ^= GetUi32(data);
+    p[1] ^= GetUi32(data + 4);
+    p[2] ^= GetUi32(data + 8);
+    p[3] ^= GetUi32(data + 12);
+    
+    Aes_Encode(p + 4, p, p);
+    
+    SetUi32(data,      p[0]);
+    SetUi32(data + 4,  p[1]);
+    SetUi32(data + 8,  p[2]);
+    SetUi32(data + 12, p[3]);
+  }
+}
+
+void MY_FAST_CALL AesCbc_Decode(UInt32 *p, Byte *data, size_t numBlocks)
+{
+  UInt32 in[4], out[4];
+  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
+  {
+    in[0] = GetUi32(data);
+    in[1] = GetUi32(data + 4);
+    in[2] = GetUi32(data + 8);
+    in[3] = GetUi32(data + 12);
+
+    Aes_Decode(p + 4, out, in);
+
+    SetUi32(data,      p[0] ^ out[0]);
+    SetUi32(data + 4,  p[1] ^ out[1]);
+    SetUi32(data + 8,  p[2] ^ out[2]);
+    SetUi32(data + 12, p[3] ^ out[3]);
+    
+    p[0] = in[0];
+    p[1] = in[1];
+    p[2] = in[2];
+    p[3] = in[3];
+  }
+}
+
+void MY_FAST_CALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)
+{
+  for (; numBlocks != 0; numBlocks--)
+  {
+    UInt32 temp[4];
+    Byte buf[16];
+    int i;
+    if (++p[0] == 0)
+      p[1]++;
+    Aes_Encode(p + 4, temp, p);
+    SetUi32(buf,      temp[0]);
+    SetUi32(buf + 4,  temp[1]);
+    SetUi32(buf + 8,  temp[2]);
+    SetUi32(buf + 12, temp[3]);
+    for (i = 0; i < 16; i++)
+      *data++ ^= buf[i];
+  }
+}

@@ -0,0 +1,38 @@
+/* Aes.h -- AES encryption / decryption
+2013-01-18 : Igor Pavlov : Public domain */
+
+#ifndef __AES_H
+#define __AES_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define AES_BLOCK_SIZE 16
+
+/* Call AesGenTables one time before other AES functions */
+void AesGenTables(void);
+
+/* UInt32 pointers must be 16-byte aligned */
+
+/* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */
+#define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4)
+
+/* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */
+/* keySize = 16 or 24 or 32 (bytes) */
+typedef void (MY_FAST_CALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize);
+void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize);
+void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize);
+
+/* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */
+void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */
+/* data - 16-byte aligned pointer to data */
+/* numBlocks - the number of 16-byte blocks in data array */
+typedef void (MY_FAST_CALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks);
+extern AES_CODE_FUNC g_AesCbc_Encode;
+extern AES_CODE_FUNC g_AesCbc_Decode;
+extern AES_CODE_FUNC g_AesCtr_Code;
+
+EXTERN_C_END
+
+#endif

@@ -0,0 +1,184 @@
+/* AesOpt.c -- Intel's AES
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "CpuArch.h"
+
+#ifdef MY_CPU_X86_OR_AMD64
+#if _MSC_VER >= 1500
+#define USE_INTEL_AES
+#endif
+#endif
+
+#ifdef USE_INTEL_AES
+
+#include <wmmintrin.h>
+
+void MY_FAST_CALL AesCbc_Encode_Intel(__m128i *p, __m128i *data, size_t numBlocks)
+{
+  __m128i m = *p;
+  for (; numBlocks != 0; numBlocks--, data++)
+  {
+    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
+    const __m128i *w = p + 3;
+    m = _mm_xor_si128(m, *data);
+    m = _mm_xor_si128(m, p[2]);
+    do
+    {
+      m = _mm_aesenc_si128(m, w[0]);
+      m = _mm_aesenc_si128(m, w[1]);
+      w += 2;
+    }
+    while (--numRounds2 != 0);
+    m = _mm_aesenc_si128(m, w[0]);
+    m = _mm_aesenclast_si128(m, w[1]);
+    *data = m;
+  }
+  *p = m;
+}
+
+#define NUM_WAYS 3
+
+#define AES_OP_W(op, n) { \
+    const __m128i t = w[n]; \
+    m0 = op(m0, t); \
+    m1 = op(m1, t); \
+    m2 = op(m2, t); \
+    }
+
+#define AES_DEC(n) AES_OP_W(_mm_aesdec_si128, n)
+#define AES_DEC_LAST(n) AES_OP_W(_mm_aesdeclast_si128, n)
+#define AES_ENC(n) AES_OP_W(_mm_aesenc_si128, n)
+#define AES_ENC_LAST(n) AES_OP_W(_mm_aesenclast_si128, n)
+
+void MY_FAST_CALL AesCbc_Decode_Intel(__m128i *p, __m128i *data, size_t numBlocks)
+{
+  __m128i iv = *p;
+  for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)
+  {
+    UInt32 numRounds2 = *(const UInt32 *)(p + 1);
+    const __m128i *w = p + numRounds2 * 2;
+    __m128i m0, m1, m2;
+    {
+      const __m128i t = w[2];
+      m0 = _mm_xor_si128(t, data[0]);
+      m1 = _mm_xor_si128(t, data[1]);
+      m2 = _mm_xor_si128(t, data[2]);
+    }
+    numRounds2--;
+    do
+    {
+      AES_DEC(1)
+      AES_DEC(0)
+      w -= 2;
+    }
+    while (--numRounds2 != 0);
+    AES_DEC(1)
+    AES_DEC_LAST(0)
+
+    {
+      __m128i t;
+      t = _mm_xor_si128(m0, iv); iv = data[0]; data[0] = t;
+      t = _mm_xor_si128(m1, iv); iv = data[1]; data[1] = t;
+      t = _mm_xor_si128(m2, iv); iv = data[2]; data[2] = t;
+    }
+  }
+  for (; numBlocks != 0; numBlocks--, data++)
+  {
+    UInt32 numRounds2 = *(const UInt32 *)(p + 1);
+    const __m128i *w = p + numRounds2 * 2;
+    __m128i m = _mm_xor_si128(w[2], *data);
+    numRounds2--;
+    do
+    {
+      m = _mm_aesdec_si128(m, w[1]);
+      m = _mm_aesdec_si128(m, w[0]);
+      w -= 2;
+    }
+    while (--numRounds2 != 0);
+    m = _mm_aesdec_si128(m, w[1]);
+    m = _mm_aesdeclast_si128(m, w[0]);
+
+    m = _mm_xor_si128(m, iv);
+    iv = *data;
+    *data = m;
+  }
+  *p = iv;
+}
+
+void MY_FAST_CALL AesCtr_Code_Intel(__m128i *p, __m128i *data, size_t numBlocks)
+{
+  __m128i ctr = *p;
+  __m128i one;
+  one.m128i_u64[0] = 1;
+  one.m128i_u64[1] = 0;
+  for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)
+  {
+    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
+    const __m128i *w = p;
+    __m128i m0, m1, m2;
+    {
+      const __m128i t = w[2];
+      ctr = _mm_add_epi64(ctr, one); m0 = _mm_xor_si128(ctr, t);
+      ctr = _mm_add_epi64(ctr, one); m1 = _mm_xor_si128(ctr, t);
+      ctr = _mm_add_epi64(ctr, one); m2 = _mm_xor_si128(ctr, t);
+    }
+    w += 3;
+    do
+    {
+      AES_ENC(0)
+      AES_ENC(1)
+      w += 2;
+    }
+    while (--numRounds2 != 0);
+    AES_ENC(0)
+    AES_ENC_LAST(1)
+    data[0] = _mm_xor_si128(data[0], m0);
+    data[1] = _mm_xor_si128(data[1], m1);
+    data[2] = _mm_xor_si128(data[2], m2);
+  }
+  for (; numBlocks != 0; numBlocks--, data++)
+  {
+    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
+    const __m128i *w = p;
+    __m128i m;
+    ctr = _mm_add_epi64(ctr, one);
+    m = _mm_xor_si128(ctr, p[2]);
+    w += 3;
+    do
+    {
+      m = _mm_aesenc_si128(m, w[0]);
+      m = _mm_aesenc_si128(m, w[1]);
+      w += 2;
+    }
+    while (--numRounds2 != 0);
+    m = _mm_aesenc_si128(m, w[0]);
+    m = _mm_aesenclast_si128(m, w[1]);
+    *data = _mm_xor_si128(*data, m);
+  }
+  *p = ctr;
+}
+
+#else
+
+void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
+void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
+
+void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *p, Byte *data, size_t numBlocks)
+{
+  AesCbc_Encode(p, data, numBlocks);
+}
+
+void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *p, Byte *data, size_t numBlocks)
+{
+  AesCbc_Decode(p, data, numBlocks);
+}
+
+void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *p, Byte *data, size_t numBlocks)
+{
+  AesCtr_Code(p, data, numBlocks);
+}
+
+#endif

@@ -0,0 +1,127 @@
+/* Alloc.c -- Memory allocation functions
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#include <stdlib.h>
+
+#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)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  {
+    void *p = malloc(size);
+    fprintf(stderr, "\nAlloc %10d bytes, count = %10d,  addr = %8X", size, g_allocCount++, (unsigned)p);
+    return p;
+  }
+  #else
+  return malloc(size);
+  #endif
+}
+
+void MyFree(void *address)
+{
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+    fprintf(stderr, "\nFree; count = %10d,  addr = %8X", --g_allocCount, (unsigned)address);
+  #endif
+  free(address);
+}
+
+#ifdef _WIN32
+
+void *MidAlloc(size_t size)
+{
+  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)
+{
+  #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);
+}
+
+#ifndef MEM_LARGE_PAGES
+#undef _7ZIP_LARGE_PAGES
+#endif
+
+#ifdef _7ZIP_LARGE_PAGES
+SIZE_T g_LargePageSize = 0;
+typedef SIZE_T (WINAPI *GetLargePageMinimumP)();
+#endif
+
+void SetLargePageSize()
+{
+  #ifdef _7ZIP_LARGE_PAGES
+  SIZE_T size = 0;
+  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)
+        GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");
+  if (largePageMinimum == 0)
+    return;
+  size = largePageMinimum();
+  if (size == 0 || (size & (size - 1)) != 0)
+    return;
+  g_LargePageSize = size;
+  #endif
+}
+
+
+void *BigAlloc(size_t size)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_Big %10d bytes;  count = %10d", size, g_allocCountBig++);
+  #endif
+  
+  #ifdef _7ZIP_LARGE_PAGES
+  if (g_LargePageSize != 0 && g_LargePageSize <= (1 << 30) && 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;
+  }
+  #endif
+  return VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);
+}
+
+void BigFree(void *address)
+{
+  #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