diff --git a/bsnes.cfg b/bsnes.cfg
index 78af5efa..23359e55 100644
--- a/bsnes.cfg
+++ b/bsnes.cfg
@@ -13,127 +13,190 @@ snes.video_color_curve = true
 snes.video_color_adjust_mode = 0
 
 # Mutes SNES audio output when enabled
-# (default = true)
+# (default = false)
 snes.mute = false
 
 # Regulate speed to 60hz (NTSC) / 50hz (PAL)
 # (default = true)
 system.regulate_speed = true
 
-# Video mode
-#   0 = 256x224w
-#   1 = 512x448w
-#   2 = 960x720w
-#   3 = 640x480f
-#   4 = 1024x768f
-# (default = 1)
-video.mode = 1
+# Slowest speed setting (in hz)
+# (default = 16000)
+system.speed_slowest = 16000
+
+# Slow speed setting
+# (default = 24000)
+system.speed_slow = 24000
+
+# Normal speed setting
+# (default = 32000)
+system.speed_normal = 32000
+
+# Fast speed setting
+# (default = 48000)
+system.speed_fast = 48000
+
+# Fastest speed setting
+# (default = 64000)
+system.speed_fastest = 64000
+
+# Video mode at startup
+# (default = 2)
+video.mode = 2
+
+# Video mode 0 (windowed)
+# (default = "256x223")
+video.mode_0 = "256x223"
+
+# Video mode 1 (windowed)
+# (default = "512x446")
+video.mode_1 = "512x446"
+
+# Video mode 2 (windowed)
+# (default = "640x480")
+video.mode_2 = "640x480"
+
+# Video mode 3 (windowed)
+# (default = "960x720")
+video.mode_3 = "960x720"
+
+# Video mode 4 (windowed)
+# (default = "1152x864")
+video.mode_4 = "1152x864"
+
+# Video mode 5 (fullscreen)
+# (default = "640x480@60:640x480")
+video.mode_5 = "640x480@60:640x480"
+
+# Video mode 6 (fullscreen)
+# (default = "800x600@60:800x600")
+video.mode_6 = "800x600@60:800x600"
+
+# Video mode 7 (fullscreen)
+# (default = "1024x768@60:1024x768")
+video.mode_7 = "1024x768@60:1024x768"
+
+# Video mode 8 (fullscreen)
+# (default = "1280x960@60:1280x960")
+video.mode_8 = "1280x960@60:1280x960"
+
+# Video mode 9 (fullscreen)
+# (default = "1600x1200@60:1600x1200")
+video.mode_9 = "1600x1200@60:1600x1200"
 
 # Use Video RAM instead of System RAM
 # (default = true)
 video.use_vram = true
 
-# Wait for vertical retrace when updating screen
+# Use triple buffering
 # (default = false)
-video.vblank = false
+video.triple_buffering = false
 
 # Show framerate in window title
 # (default = true)
 gui.show_fps = true
 
+# Allow "impossible" key combinations for joypad 1 (not recommended)
+# (default = false)
+input.joypad1.allow_invalid_input = false
+
 # Joypad1 up
-# (default = 0x26)
-input.joypad1.up = 0x26
+# (default = 0x80c8)
+input.joypad1.up = 0x80c8
 
 # Joypad1 down
-# (default = 0x28)
-input.joypad1.down = 0x28
+# (default = 0x81d0)
+input.joypad1.down = 0x81d0
 
 # Joypad1 left
-# (default = 0x25)
-input.joypad1.left = 0x25
+# (default = 0x82cb)
+input.joypad1.left = 0x82cb
 
 # Joypad1 right
-# (default = 0x27)
-input.joypad1.right = 0x27
+# (default = 0x83cd)
+input.joypad1.right = 0x83cd
 
 # Joypad1 A
-# (default = 0x58)
-input.joypad1.a = 0x58
+# (default = 0x42d)
+input.joypad1.a = 0x42d
 
 # Joypad1 B
-# (default = 0x5a)
-input.joypad1.b = 0x5a
+# (default = 0x32c)
+input.joypad1.b = 0x32c
 
 # Joypad1 X
-# (default = 0x53)
-input.joypad1.x = 0x53
+# (default = 0x11f)
+input.joypad1.x = 0x11f
 
 # Joypad1 Y
-# (default = 0x41)
-input.joypad1.y = 0x41
+# (default = 0x1e)
+input.joypad1.y = 0x1e
 
 # Joypad1 L
-# (default = 0x44)
-input.joypad1.l = 0x44
+# (default = 0x620)
+input.joypad1.l = 0x620
 
 # Joypad1 R
-# (default = 0x43)
-input.joypad1.r = 0x43
+# (default = 0x72e)
+input.joypad1.r = 0x72e
 
 # Joypad1 select
-# (default = 0x10)
-input.joypad1.select = 0x10
+# (default = 0x836)
+input.joypad1.select = 0x836
 
 # Joypad1 start
-# (default = 0xd)
-input.joypad1.start = 0xd
+# (default = 0x91c)
+input.joypad1.start = 0x91c
+
+# Allow "impossible" key combinations for joypad 2 (not recommended)
+# (default = false)
+input.joypad2.allow_invalid_input = false
 
 # Joypad2 up
-# (default = 0x54)
-input.joypad2.up = 0x54
+# (default = 0xff14)
+input.joypad2.up = 0xff14
 
 # Joypad2 down
-# (default = 0x47)
-input.joypad2.down = 0x47
+# (default = 0xff22)
+input.joypad2.down = 0xff22
 
 # Joypad2 left
-# (default = 0x46)
-input.joypad2.left = 0x46
+# (default = 0xff21)
+input.joypad2.left = 0xff21
 
 # Joypad2 right
-# (default = 0x48)
-input.joypad2.right = 0x48
+# (default = 0xff23)
+input.joypad2.right = 0xff23
 
 # Joypad2 A
-# (default = 0x4b)
-input.joypad2.a = 0x4b
+# (default = 0xff25)
+input.joypad2.a = 0xff25
 
 # Joypad2 B
-# (default = 0x4a)
-input.joypad2.b = 0x4a
+# (default = 0xff24)
+input.joypad2.b = 0xff24
 
 # Joypad2 X
-# (default = 0x49)
-input.joypad2.x = 0x49
+# (default = 0xff17)
+input.joypad2.x = 0xff17
 
 # Joypad2 Y
-# (default = 0x55)
-input.joypad2.y = 0x55
+# (default = 0xff16)
+input.joypad2.y = 0xff16
 
 # Joypad2 L
-# (default = 0x4f)
-input.joypad2.l = 0x4f
+# (default = 0xff18)
+input.joypad2.l = 0xff18
 
 # Joypad2 R
-# (default = 0x4c)
-input.joypad2.r = 0x4c
+# (default = 0xff26)
+input.joypad2.r = 0xff26
 
 # Joypad2 select
-# (default = 0x5b)
-input.joypad2.select = 0x5b
+# (default = 0xff1a)
+input.joypad2.select = 0xff1a
 
 # Joypad2 start
-# (default = 0x5d)
-input.joypad2.start = 0x5d
+# (default = 0xff1b)
+input.joypad2.start = 0xff1b
 
diff --git a/bsnes.exe b/bsnes.exe
index 8514825d..dff32fcc 100644
Binary files a/bsnes.exe and b/bsnes.exe differ
diff --git a/src/apu/apu.h b/src/apu/apu.h
index 8645248f..4071fe6d 100644
--- a/src/apu/apu.h
+++ b/src/apu/apu.h
@@ -27,4 +27,7 @@ static const uint8 iplrom[64];
   virtual bool in_opcode();
   void disassemble_opcode(char *output);
   inline uint16 __relb(int8 offset, int op_len);
+
+  APU() {}
+  virtual ~APU() {}
 };
diff --git a/src/apu/bapu/bapu_op_fn.cpp b/src/apu/bapu/bapu_op_fn.cpp
index 4819c448..71476382 100644
--- a/src/apu/bapu/bapu_op_fn.cpp
+++ b/src/apu/bapu/bapu_op_fn.cpp
@@ -9,12 +9,11 @@ int16 r = x + y + regs.p.c;
 }
 
 uint16 bAPU::op_addw(uint16 x, uint16 y) {
-int32 r = x + y;
-  regs.p.n = !!(r & 0x8000);
-  regs.p.v = !!(~(x ^ y) & (y ^ (uint16)r) & 0x8000);
-  regs.p.h = !!((x ^ y ^ (uint16)r) & 0x10);
+int16 r;
+  regs.p.c = 0;
+  r  = op_adc(x, y);
+  r |= op_adc(x >> 8, y >> 8) << 8;
   regs.p.z = ((uint16)r == 0);
-  regs.p.c = (r > 0xffff);
   return r;
 }
 
@@ -66,12 +65,11 @@ int16 r = x - y - !regs.p.c;
 }
 
 uint16 bAPU::op_subw(uint16 x, uint16 y) {
-int32 r = x - y;
-  regs.p.n = !!(r & 0x8000);
-  regs.p.v = !!((x ^ y) & (x ^ (uint16)r) & 0x8000);
-  regs.p.h = !((x ^ y ^ (uint16)r) & 0x10);
+int16 r;
+  regs.p.c = 1;
+  r  = op_sbc(x, y);
+  r |= op_sbc(x >> 8, y >> 8) << 8;
   regs.p.z = ((uint16)r == 0);
-  regs.p.c = (r >= 0);
   return r;
 }
 
diff --git a/src/base.h b/src/base.h
index 7e00bb59..5edbe715 100644
--- a/src/base.h
+++ b/src/base.h
@@ -1,6 +1,16 @@
+//debugging extensions (~10% speed hit)
 //#define DEBUGGER
+
+//snes core polymorphism (allow mem/cpu/apu/ppu overriding,
+//~10% speed hit)
 //#define POLYMORPHISM
 
+//enable GZ, ZIP format support
+#define GZIP_SUPPORT
+
+//enable JMA support
+#define JMA_SUPPORT
+
 //this should be declared in the port-specific makefiles
 //#define ARCH_LSB
 //#define ARCH_MSB
diff --git a/src/cart/cart.cpp b/src/cart/cart.cpp
new file mode 100644
index 00000000..e3c729d7
--- /dev/null
+++ b/src/cart/cart.cpp
@@ -0,0 +1,243 @@
+#include "../base.h"
+
+void Cartridge::read_header() {
+  cart.srtc = false;
+  cart.sdd1 = false;
+  cart.c4   = false;
+
+  if(cart.header_index == 0x7fc0 && cart.rom_size >= 0x401000) {
+    cart.mapper = EXLOROM;
+  } else if(cart.header_index == 0x7fc0 && rom[cart.header_index + MAPPER] == 0x32) {
+    cart.mapper = EXLOROM;
+  } else if(cart.header_index == 0x7fc0) {
+    cart.mapper = LOROM;
+  } else if(cart.header_index == 0xffc0) {
+    cart.mapper = HIROM;
+  } else { //cart.header_index == 0x40ffc0
+    cart.mapper = EXHIROM;
+  }
+
+uint8 mapper   = rom[cart.header_index + MAPPER];
+uint8 rom_type = rom[cart.header_index + ROM_TYPE];
+  if(mapper == 0x35 && rom_type == 0x55) {
+    cart.srtc = true;
+  }
+
+  if(mapper == 0x32 && (rom_type == 0x43 || rom_type == 0x45)) {
+    cart.sdd1 = true;
+  }
+
+  if(mapper == 0x20 && rom_type == 0xf3) {
+    cart.c4 = true;
+  }
+
+  if(rom[cart.header_index + SRAM_SIZE] & 7) {
+    cart.sram_size = 1024 << (rom[cart.header_index + SRAM_SIZE] & 7);
+  } else {
+    cart.sram_size = 0;
+  }
+
+  cart.region = (rom[cart.header_index + REGION] < 2) ? NTSC : PAL;
+
+  memcpy(&cart.name, &rom[cart.header_index + CART_NAME], 21);
+  cart.name[21] = 0;
+
+  for(int i=0;i<22;i++) {
+    if(cart.name[i] & 0x80) {
+      cart.name[i] = '?';
+    }
+  }
+}
+
+void Cartridge::find_header() {
+int32 score_lo = 0,
+      score_hi = 0,
+      score_ex = 0;
+
+  if(rom_size < 0x010000) {
+  //cart too small to be anything else
+    cart.header_index = 0x007fc0;
+    return;
+  }
+
+  if((rom[0x7fc0 + MAPPER] & ~0x10) == 0x20)score_lo++;
+  if((rom[0xffc0 + MAPPER] & ~0x10) == 0x21)score_hi++;
+
+  if(rom[0x7fc0 + ROM_TYPE] < 0x08)score_lo++;
+  if(rom[0xffc0 + ROM_TYPE] < 0x08)score_hi++;
+
+  if(rom[0x7fc0 + ROM_SIZE] < 0x10)score_lo++;
+  if(rom[0xffc0 + ROM_SIZE] < 0x10)score_hi++;
+
+  if(rom[0x7fc0 + SRAM_SIZE] < 0x08)score_lo++;
+  if(rom[0xffc0 + SRAM_SIZE] < 0x08)score_hi++;
+
+  if(rom[0x7fc0 + REGION] < 14)score_lo++;
+  if(rom[0xffc0 + REGION] < 14)score_hi++;
+
+  if(rom[0x7fc0 + LICENSE] < 3)score_lo++;
+  if(rom[0xffc0 + LICENSE] < 3)score_hi++;
+
+uint16 cksum, icksum;
+  cksum  = rom[0x7fc0 +  CKSUM] | (rom[0x7fc0 +  CKSUM + 1] << 8);
+  icksum = rom[0x7fc0 + ICKSUM] | (rom[0x7fc0 + ICKSUM + 1] << 8);
+  if((cksum + icksum) == 0xffff)score_lo += 8;
+  cksum  = rom[0xffc0 +  CKSUM] | (rom[0xffc0 +  CKSUM + 1] << 8);
+  icksum = rom[0xffc0 + ICKSUM] | (rom[0xffc0 + ICKSUM + 1] << 8);
+  if((cksum + icksum) == 0xffff)score_hi += 8;
+
+  if(rom_size < 0x401000) {
+    score_ex = 0;
+  } else {
+    if(rom[0x7fc0 + MAPPER] == 0x32)score_lo++;
+    else score_ex += 16;
+  }
+
+  if(score_lo >= score_hi && score_lo >= score_ex) {
+    cart.header_index = 0x007fc0;
+  } else if(score_hi >= score_ex) {
+    cart.header_index = 0x00ffc0;
+  } else {
+    cart.header_index = 0x40ffc0;
+  }
+}
+
+void Cartridge::load_sram() {
+  if(cart.sram_size == 0) {
+    sram = 0;
+    return;
+  }
+
+FileReader ff;
+  if(!ff.open(sram_fn)) {
+    sram = (uint8*)malloc(cart.sram_size);
+    memset(sram, 0, cart.sram_size);
+    return;
+  }
+
+  sram = ff.read(cart.sram_size);
+  ff.close();
+}
+
+void Cartridge::save_sram() {
+  if(cart.sram_size == 0)return;
+
+FileWriter ff;
+  if(!ff.open(sram_fn))return;
+
+  ff.write(sram, cart.sram_size);
+  ff.close();
+}
+
+void Cartridge::load_rom(Reader *rf) {
+  base_rom = rf->read();
+  rom_size = rf->size();
+
+  if((rom_size & 0x7fff) == 0x0200) {
+    rom = base_rom + 512;
+    rom_size -= 512;
+  } else {
+    rom = base_rom;
+  }
+
+  cart.rom_size = rom_size;
+}
+
+bool Cartridge::load(const char *fn) {
+  if(cart_loaded == true)return false;
+  if(strlen(fn) < 3)return false;
+
+  dprintf("* Loading \"%s\"...", fn);
+
+  strcpy(rom_fn, fn);
+
+  switch(Reader::detect(rom_fn)) {
+  case Reader::RF_NORMAL: {
+  FileReader ff;
+    if(!ff.open(rom_fn)) {
+      alert("Error loading image file (%s)!", rom_fn);
+      return false;
+    }
+    load_rom(static_cast<Reader*>(&ff));
+    ff.close();
+    break;
+  }
+#ifdef GZIP_SUPPORT
+  case Reader::RF_GZ: {
+  GZReader gf;
+    if(!gf.open(rom_fn)) {
+      alert("Error loading image file (%s)!", rom_fn);
+      return false;
+    }
+    load_rom(static_cast<Reader*>(&gf));
+    gf.close();
+    break;
+  }
+  case Reader::RF_ZIP: {
+  ZipReader zf(rom_fn);
+    load_rom(static_cast<Reader*>(&zf));
+    break;
+  }
+#endif
+#ifdef JMA_SUPPORT
+  case Reader::RF_JMA: {
+    try {
+    JMAReader jf(rom_fn);
+      load_rom(static_cast<Reader*>(&jf));
+    } catch(JMA::jma_errors jma_error) {
+      alert("Error loading image file (%s)!", rom_fn);
+      return false;
+    }
+    break;
+  }
+#endif
+  }
+
+int i;
+  strcpy(sram_fn, fn);
+  for(i=strlen(fn)-1;i>=0;i--) {
+    if(fn[i] == '.')break;
+  }
+  if(i != 0)sram_fn[i] = 0;
+  strcat(sram_fn, ".srm");
+
+  find_header();
+  read_header();
+  load_sram();
+  cart_loaded = true;
+  r_mem->load_cart();
+  return true;
+}
+
+bool Cartridge::unload() {
+  if(cart_loaded == false)return false;
+
+  r_mem->unload_cart();
+
+  if(base_rom) {
+    zerofree(base_rom);
+  }
+
+  if(sram) {
+    save_sram();
+    zerofree(sram);
+  }
+
+  cart_loaded = false;
+  return true;
+}
+
+Cartridge::Cartridge() {
+  cart_loaded = false;
+
+  base_rom = 0;
+  rom      = 0;
+  sram     = 0;
+  rom_size = 0;
+}
+
+Cartridge::~Cartridge() {
+  if(cart_loaded == true) {
+    unload();
+  }
+}
diff --git a/src/cart/cart.h b/src/cart/cart.h
new file mode 100644
index 00000000..c8da8554
--- /dev/null
+++ b/src/cart/cart.h
@@ -0,0 +1,59 @@
+class Cartridge {
+public:
+bool cart_loaded;
+char rom_fn[4096], sram_fn[4096];
+
+uint8 *base_rom, *rom, *sram;
+uint32 rom_size;
+
+enum {
+//header fields
+  CART_NAME = 0x00,
+  MAPPER    = 0x15,
+  ROM_TYPE  = 0x16,
+  ROM_SIZE  = 0x17,
+  SRAM_SIZE = 0x18,
+  REGION    = 0x19,
+  LICENSE   = 0x1a,
+  VERSION   = 0x1b,
+  ICKSUM    = 0x1c,
+  CKSUM     = 0x1e,
+
+//regions
+  NTSC = 0,
+  PAL  = 1,
+
+//memory mappers
+  LOROM   = 0x20,
+  HIROM   = 0x21,
+  EXLOROM = 0x22,
+  EXHIROM = 0x25,
+};
+
+struct {
+  uint32 header_index;
+
+  char   name[32];
+  uint32 rom_size;
+  uint32 sram_size;
+  bool   region;
+
+  uint32 mapper;
+  bool   srtc;
+  bool   sdd1;
+  bool   c4;
+} cart;
+
+  void load_rom(Reader *rf);
+  void load_sram();
+  void save_sram();
+  void find_header();
+  void read_header();
+  bool load(const char *fn);
+  bool unload();
+
+  Cartridge();
+  ~Cartridge();
+};
+
+extern Cartridge cartridge;
diff --git a/src/chip/c4/c4.cpp b/src/chip/c4/c4.cpp
new file mode 100644
index 00000000..d979fbf1
--- /dev/null
+++ b/src/chip/c4/c4.cpp
@@ -0,0 +1,197 @@
+/*
+  C4 emulation
+
+  Used in Rockman X2/X3 (Megaman X2/X3)
+  Portions (c) anomie, Overload, zsKnight, Nach, byuu
+*/
+
+#include "../../base.h"
+
+#include "c4data.cpp"
+#include "c4fn.cpp"
+#include "c4oam.cpp"
+#include "c4ops.cpp"
+
+void C4::init() {}
+void C4::enable() {}
+
+uint32 C4::ldr(uint8 r) {
+uint16 addr = 0x0080 + (r * 3);
+  return (reg[addr]) | (reg[addr + 1] << 8) | (reg[addr + 2] << 16);
+}
+
+void C4::str(uint8 r, uint32 data) {
+uint16 addr = 0x0080 + (r * 3);
+  reg[addr    ] = (data);
+  reg[addr + 1] = (data >> 8);
+  reg[addr + 2] = (data >> 16);
+}
+
+void C4::mul(uint32 x, uint32 y, uint32 &rl, uint32 &rh) {
+int64 rx = x & 0xffffff;
+int64 ry = y & 0xffffff;
+  if(rx & 0x800000)rx |= ~0x7fffff;
+  if(ry & 0x800000)ry |= ~0x7fffff;
+
+  rx *= ry;
+
+  rl = (rx)       & 0xffffff;
+  rh = (rx >> 24) & 0xffffff;
+}
+
+uint32 C4::sin(uint32 rx) {
+  r0 = rx & 0x1ff;
+  if(r0 & 0x100)r0 ^= 0x1ff;
+  if(r0 & 0x080)r0 ^= 0x0ff;
+  if(rx & 0x100) {
+    return sin_table[r0 + 0x80];
+  } else {
+    return sin_table[r0];
+  }
+}
+
+uint32 C4::cos(uint32 rx) {
+  return sin(rx + 0x080);
+}
+
+void C4::immediate_reg(uint32 start) {
+  r0 = ldr(0);
+  for(uint32 i=start;i<48;i++) {
+    if((r0 & 0x0fff) < 0x0c00) {
+      ram[r0 & 0x0fff] = immediate_data[i];
+    }
+    r0++;
+  }
+  str(0, r0);
+}
+
+void C4::transfer_data() {
+uint32 src;
+uint16 dest, count;
+  src   = (reg[0x40]) | (reg[0x41] << 8) | (reg[0x42] << 16);
+  count = (reg[0x43]) | (reg[0x44] << 8);
+  dest  = (reg[0x45]) | (reg[0x46] << 8);
+
+  for(uint32 i=0;i<count;i++) {
+    write(dest++, r_mem->read(src++));
+  }
+}
+
+void C4::write(uint16 addr, uint8 data) {
+  addr &= 0x1fff;
+
+  if(addr < 0x0c00) {
+  //ram
+    ram[addr] = data;
+    return;
+  }
+
+  if(addr < 0x1f00) {
+  //unmapped
+    return;
+  }
+
+//command register
+  reg[addr & 0xff] = data;
+
+  if(addr == 0x1f47) {
+  //memory transfer
+    transfer_data();
+    return;
+  }
+
+  if(addr == 0x1f4f) {
+  //c4 command
+    if(reg[0x4d] == 0x0e && !(data & 0xc3)) {
+    //c4 test command
+      reg[0x80] = data >> 2;
+      return;
+    }
+
+    switch(data) {
+    case 0x00:op00();break;
+    case 0x01:op01();break;
+    case 0x05:op05();break;
+    case 0x0d:op0d();break;
+    case 0x10:op10();break;
+    case 0x13:op13();break;
+    case 0x15:op15();break;
+    case 0x1f:op1f();break;
+    case 0x22:op22();break;
+    case 0x25:op25();break;
+    case 0x2d:op2d();break;
+    case 0x40:op40();break;
+    case 0x54:op54();break;
+    case 0x5c:op5c();break;
+    case 0x5e:op5e();break;
+    case 0x60:op60();break;
+    case 0x62:op62();break;
+    case 0x64:op64();break;
+    case 0x66:op66();break;
+    case 0x68:op68();break;
+    case 0x6a:op6a();break;
+    case 0x6c:op6c();break;
+    case 0x6e:op6e();break;
+    case 0x70:op70();break;
+    case 0x72:op72();break;
+    case 0x74:op74();break;
+    case 0x76:op76();break;
+    case 0x78:op78();break;
+    case 0x7a:op7a();break;
+    case 0x7c:op7c();break;
+    case 0x89:op89();break;
+    }
+  }
+}
+
+void C4::writeb(uint16 addr, uint8 data) {
+  write(addr,     data);
+}
+
+void C4::writew(uint16 addr, uint16 data) {
+  write(addr,     data);
+  write(addr + 1, data >> 8);
+}
+
+void C4::writel(uint16 addr, uint32 data) {
+  write(addr,     data);
+  write(addr + 1, data >>  8);
+  write(addr + 2, data >> 16);
+}
+
+uint8 C4::read(uint16 addr) {
+  addr &= 0x1fff;
+
+  if(addr < 0x0c00) {
+    return ram[addr];
+  }
+
+  if(addr >= 0x1f00) {
+    return reg[addr & 0xff];
+  }
+
+  return r_cpu->regs.mdr;
+}
+
+uint8 C4::readb(uint16 addr) {
+  return read(addr);
+}
+
+uint16 C4::readw(uint16 addr) {
+  return read(addr) | (read(addr + 1) << 8);
+}
+
+uint32 C4::readl(uint16 addr) {
+  return read(addr) | (read(addr + 1) << 8) + (read(addr + 2) << 16);
+}
+
+void C4::power() {
+  reset();
+}
+
+void C4::reset() {
+  memset(ram, 0, 0x0c00);
+  memset(reg, 0, 0x0100);
+}
+
+C4::C4() {}
diff --git a/src/chip/c4/c4.h b/src/chip/c4/c4.h
new file mode 100644
index 00000000..6adac97c
--- /dev/null
+++ b/src/chip/c4/c4.h
@@ -0,0 +1,94 @@
+class C4 {
+private:
+uint8  ram[0x0c00];
+uint8  reg[0x0100];
+uint32 r0, r1, r2,  r3,  r4,  r5,  r6,  r7,
+       r8, r9, r10, r11, r12, r13, r14, r15;
+
+static const uint8  immediate_data[48];
+static const uint16 wave_data[40];
+static const uint32 sin_table[256];
+
+static const int16 SinTable[512];
+static const int16 CosTable[512];
+
+int16 C4WFXVal, C4WFYVal, C4WFZVal, C4WFX2Val, C4WFY2Val, C4WFDist, C4WFScale;
+int16 C41FXVal, C41FYVal, C41FAngleRes, C41FDist, C41FDistVal;
+
+double tanval;
+double c4x,c4y,c4z, c4x2,c4y2,c4z2;
+
+void C4TransfWireFrame();
+void C4TransfWireFrame2();
+void C4CalcWireFrame();
+void C4DrawLine(int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2, uint8 Color);
+void C4DrawWireFrame();
+void C4DoScaleRotate(int row_padding);
+
+public:
+  uint32 ldr(uint8 r);
+  void   str(uint8 r, uint32 data);
+  void   mul(uint32 x, uint32 y, uint32 &rl, uint32 &rh);
+  uint32 sin(uint32 rx);
+  uint32 cos(uint32 rx);
+
+  void   transfer_data();
+  void   immediate_reg(uint32 num);
+
+  void   op00_00();
+  void   op00_03();
+  void   op00_05();
+  void   op00_07();
+  void   op00_08();
+  void   op00_0b();
+  void   op00_0c();
+
+  void   op00();
+  void   op01();
+  void   op05();
+  void   op0d();
+  void   op10();
+  void   op13();
+  void   op15();
+  void   op1f();
+  void   op22();
+  void   op25();
+  void   op2d();
+  void   op40();
+  void   op54();
+  void   op5c();
+  void   op5e();
+  void   op60();
+  void   op62();
+  void   op64();
+  void   op66();
+  void   op68();
+  void   op6a();
+  void   op6c();
+  void   op6e();
+  void   op70();
+  void   op72();
+  void   op74();
+  void   op76();
+  void   op78();
+  void   op7a();
+  void   op7c();
+  void   op89();
+
+  void   init();
+  void   enable();
+  void   power();
+  void   reset();
+
+  void   write (uint16 addr, uint8 data);
+  void   writeb(uint16 addr, uint8 data);
+  void   writew(uint16 addr, uint16 data);
+  void   writel(uint16 addr, uint32 data);
+
+  uint8  read (uint16 addr);
+  uint8  readb(uint16 addr);
+  uint16 readw(uint16 addr);
+  uint32 readl(uint16 addr);
+
+  C4();
+};
diff --git a/src/chip/c4/c4data.cpp b/src/chip/c4/c4data.cpp
new file mode 100644
index 00000000..b831f72b
--- /dev/null
+++ b/src/chip/c4/c4data.cpp
@@ -0,0 +1,183 @@
+const uint8 C4::immediate_data[48] = {
+  0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff,
+  0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f,
+  0x00, 0x80, 0x00, 0xff, 0x7f, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0xff,
+  0x00, 0x00, 0x01, 0xff, 0xff, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xfe, 0x00
+};
+
+const uint16 C4::wave_data[40] = {
+  0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000a, 0x000c, 0x000e,
+  0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a, 0x020c, 0x020e,
+  0x0400, 0x0402, 0x0404, 0x0406, 0x0408, 0x040a, 0x040c, 0x040e,
+  0x0600, 0x0602, 0x0604, 0x0606, 0x0608, 0x060a, 0x060c, 0x060e,
+  0x0800, 0x0802, 0x0804, 0x0806, 0x0808, 0x080a, 0x080c, 0x080e
+};
+
+const uint32 C4::sin_table[256] = {
+  0x000000, 0x000324, 0x000648, 0x00096c, 0x000c8f, 0x000fb2, 0x0012d5, 0x0015f6,
+  0x001917, 0x001c37, 0x001f56, 0x002273, 0x002590, 0x0028aa, 0x002bc4, 0x002edb,
+  0x0031f1, 0x003505, 0x003817, 0x003b26, 0x003e33, 0x00413e, 0x004447, 0x00474d,
+  0x004a50, 0x004d50, 0x00504d, 0x005347, 0x00563e, 0x005931, 0x005c22, 0x005f0e,
+  0x0061f7, 0x0064dc, 0x0067bd, 0x006a9b, 0x006d74, 0x007049, 0x007319, 0x0075e5,
+  0x0078ad, 0x007b70, 0x007e2e, 0x0080e7, 0x00839c, 0x00864b, 0x0088f5, 0x008b9a,
+  0x008e39, 0x0090d3, 0x009368, 0x0095f6, 0x00987f, 0x009b02, 0x009d7f, 0x009ff6,
+  0x00a267, 0x00a4d2, 0x00a736, 0x00a994, 0x00abeb, 0x00ae3b, 0x00b085, 0x00b2c8,
+  0x00b504, 0x00b73a, 0x00b968, 0x00bb8f, 0x00bdae, 0x00bfc7, 0x00c1d8, 0x00c3e2,
+  0x00c5e4, 0x00c7de, 0x00c9d1, 0x00cbbb, 0x00cd9f, 0x00cf7a, 0x00d14d, 0x00d318,
+  0x00d4db, 0x00d695, 0x00d848, 0x00d9f2, 0x00db94, 0x00dd2d, 0x00debe, 0x00e046,
+  0x00e1c5, 0x00e33c, 0x00e4aa, 0x00e60f, 0x00e76b, 0x00e8bf, 0x00ea09, 0x00eb4b,
+  0x00ec83, 0x00edb2, 0x00eed8, 0x00eff5, 0x00f109, 0x00f213, 0x00f314, 0x00f40b,
+  0x00f4fa, 0x00f5de, 0x00f6ba, 0x00f78b, 0x00f853, 0x00f912, 0x00f9c7, 0x00fa73,
+  0x00fb14, 0x00fbac, 0x00fc3b, 0x00fcbf, 0x00fd3a, 0x00fdab, 0x00fe13, 0x00fe70,
+  0x00fec4, 0x00ff0e, 0x00ff4e, 0x00ff84, 0x00ffb1, 0x00ffd3, 0x00ffec, 0x00fffb,
+  0x000000, 0xfffcdb, 0xfff9b7, 0xfff693, 0xfff370, 0xfff04d, 0xffed2a, 0xffea09,
+  0xffe6e8, 0xffe3c8, 0xffe0a9, 0xffdd8c, 0xffda6f, 0xffd755, 0xffd43b, 0xffd124,
+  0xffce0e, 0xffcafa, 0xffc7e8, 0xffc4d9, 0xffc1cc, 0xffbec1, 0xffbbb8, 0xffb8b2,
+  0xffb5af, 0xffb2af, 0xffafb2, 0xffacb8, 0xffa9c1, 0xffa6ce, 0xffa3dd, 0xffa0f1,
+  0xff9e08, 0xff9b23, 0xff9842, 0xff9564, 0xff928b, 0xff8fb6, 0xff8ce6, 0xff8a1a,
+  0xff8752, 0xff848f, 0xff81d1, 0xff7f18, 0xff7c63, 0xff79b4, 0xff770a, 0xff7465,
+  0xff71c6, 0xff6f2c, 0xff6c97, 0xff6a09, 0xff6780, 0xff64fd, 0xff6280, 0xff6009,
+  0xff5d98, 0xff5b2d, 0xff58c9, 0xff566b, 0xff5414, 0xff51c4, 0xff4f7a, 0xff4d37,
+  0xff4afb, 0xff48c5, 0xff4697, 0xff4470, 0xff4251, 0xff4038, 0xff3e27, 0xff3c1e,
+  0xff3a1b, 0xff3821, 0xff362e, 0xff3444, 0xff3260, 0xff3085, 0xff2eb2, 0xff2ce7,
+  0xff2b24, 0xff296a, 0xff27b7, 0xff260d, 0xff246b, 0xff22d2, 0xff2141, 0xff1fb9,
+  0xff1e3a, 0xff1cc3, 0xff1b55, 0xff19f0, 0xff1894, 0xff1740, 0xff15f6, 0xff14b4,
+  0xff137c, 0xff124d, 0xff1127, 0xff100a, 0xff0ef6, 0xff0dec, 0xff0ceb, 0xff0bf4,
+  0xff0b05, 0xff0a21, 0xff0945, 0xff0874, 0xff07ac, 0xff06ed, 0xff0638, 0xff058d,
+  0xff04eb, 0xff0453, 0xff03c4, 0xff0340, 0xff02c5, 0xff0254, 0xff01ec, 0xff018f,
+  0xff013b, 0xff00f1, 0xff00b1, 0xff007b, 0xff004e, 0xff002c, 0xff0013, 0xff0004
+};
+
+const int16 C4::SinTable[512] = {
+       0,    402,    804,   1206,   1607,   2009,   2410,   2811,
+    3211,   3611,   4011,   4409,   4808,   5205,   5602,   5997,
+    6392,   6786,   7179,   7571,   7961,   8351,   8739,   9126,
+    9512,   9896,  10278,  10659,  11039,  11416,  11793,  12167,
+   12539,  12910,  13278,  13645,  14010,  14372,  14732,  15090,
+   15446,  15800,  16151,  16499,  16846,  17189,  17530,  17869,
+   18204,  18537,  18868,  19195,  19519,  19841,  20159,  20475,
+   20787,  21097,  21403,  21706,  22005,  22301,  22594,  22884,
+   23170,  23453,  23732,  24007,  24279,  24547,  24812,  25073,
+   25330,  25583,  25832,  26077,  26319,  26557,  26790,  27020,
+   27245,  27466,  27684,  27897,  28106,  28310,  28511,  28707,
+   28898,  29086,  29269,  29447,  29621,  29791,  29956,  30117,
+   30273,  30425,  30572,  30714,  30852,  30985,  31114,  31237,
+   31357,  31471,  31581,  31685,  31785,  31881,  31971,  32057,
+   32138,  32214,  32285,  32351,  32413,  32469,  32521,  32568,
+   32610,  32647,  32679,  32706,  32728,  32745,  32758,  32765,
+   32767,  32765,  32758,  32745,  32728,  32706,  32679,  32647,
+   32610,  32568,  32521,  32469,  32413,  32351,  32285,  32214,
+   32138,  32057,  31971,  31881,  31785,  31685,  31581,  31471,
+   31357,  31237,  31114,  30985,  30852,  30714,  30572,  30425,
+   30273,  30117,  29956,  29791,  29621,  29447,  29269,  29086,
+   28898,  28707,  28511,  28310,  28106,  27897,  27684,  27466,
+   27245,  27020,  26790,  26557,  26319,  26077,  25832,  25583,
+   25330,  25073,  24812,  24547,  24279,  24007,  23732,  23453,
+   23170,  22884,  22594,  22301,  22005,  21706,  21403,  21097,
+   20787,  20475,  20159,  19841,  19519,  19195,  18868,  18537,
+   18204,  17869,  17530,  17189,  16846,  16499,  16151,  15800,
+   15446,  15090,  14732,  14372,  14010,  13645,  13278,  12910,
+   12539,  12167,  11793,  11416,  11039,  10659,  10278,   9896,
+    9512,   9126,   8739,   8351,   7961,   7571,   7179,   6786,
+    6392,   5997,   5602,   5205,   4808,   4409,   4011,   3611,
+    3211,   2811,   2410,   2009,   1607,   1206,    804,    402,
+       0,   -402,   -804,  -1206,  -1607,  -2009,  -2410,  -2811,
+   -3211,  -3611,  -4011,  -4409,  -4808,  -5205,  -5602,  -5997,
+   -6392,  -6786,  -7179,  -7571,  -7961,  -8351,  -8739,  -9126,
+   -9512,  -9896, -10278, -10659, -11039, -11416, -11793, -12167,
+  -12539, -12910, -13278, -13645, -14010, -14372, -14732, -15090,
+  -15446, -15800, -16151, -16499, -16846, -17189, -17530, -17869,
+  -18204, -18537, -18868, -19195, -19519, -19841, -20159, -20475,
+  -20787, -21097, -21403, -21706, -22005, -22301, -22594, -22884,
+  -23170, -23453, -23732, -24007, -24279, -24547, -24812, -25073,
+  -25330, -25583, -25832, -26077, -26319, -26557, -26790, -27020,
+  -27245, -27466, -27684, -27897, -28106, -28310, -28511, -28707,
+  -28898, -29086, -29269, -29447, -29621, -29791, -29956, -30117,
+  -30273, -30425, -30572, -30714, -30852, -30985, -31114, -31237,
+  -31357, -31471, -31581, -31685, -31785, -31881, -31971, -32057,
+  -32138, -32214, -32285, -32351, -32413, -32469, -32521, -32568,
+  -32610, -32647, -32679, -32706, -32728, -32745, -32758, -32765,
+  -32767, -32765, -32758, -32745, -32728, -32706, -32679, -32647,
+  -32610, -32568, -32521, -32469, -32413, -32351, -32285, -32214,
+  -32138, -32057, -31971, -31881, -31785, -31685, -31581, -31471,
+  -31357, -31237, -31114, -30985, -30852, -30714, -30572, -30425,
+  -30273, -30117, -29956, -29791, -29621, -29447, -29269, -29086,
+  -28898, -28707, -28511, -28310, -28106, -27897, -27684, -27466,
+  -27245, -27020, -26790, -26557, -26319, -26077, -25832, -25583,
+  -25330, -25073, -24812, -24547, -24279, -24007, -23732, -23453,
+  -23170, -22884, -22594, -22301, -22005, -21706, -21403, -21097,
+  -20787, -20475, -20159, -19841, -19519, -19195, -18868, -18537,
+  -18204, -17869, -17530, -17189, -16846, -16499, -16151, -15800,
+  -15446, -15090, -14732, -14372, -14010, -13645, -13278, -12910,
+  -12539, -12167, -11793, -11416, -11039, -10659, -10278,  -9896,
+   -9512,  -9126,  -8739,  -8351,  -7961,  -7571,  -7179,  -6786,
+   -6392,  -5997,  -5602,  -5205,  -4808,  -4409,  -4011,  -3611,
+   -3211,  -2811,  -2410,  -2009,  -1607,  -1206,   -804,   -402
+};
+
+const int16 C4::CosTable[512] = {
+   32767,  32765,  32758,  32745,  32728,  32706,  32679,  32647,
+   32610,  32568,  32521,  32469,  32413,  32351,  32285,  32214,
+   32138,  32057,  31971,  31881,  31785,  31685,  31581,  31471,
+   31357,  31237,  31114,  30985,  30852,  30714,  30572,  30425,
+   30273,  30117,  29956,  29791,  29621,  29447,  29269,  29086,
+   28898,  28707,  28511,  28310,  28106,  27897,  27684,  27466,
+   27245,  27020,  26790,  26557,  26319,  26077,  25832,  25583,
+   25330,  25073,  24812,  24547,  24279,  24007,  23732,  23453,
+   23170,  22884,  22594,  22301,  22005,  21706,  21403,  21097,
+   20787,  20475,  20159,  19841,  19519,  19195,  18868,  18537,
+   18204,  17869,  17530,  17189,  16846,  16499,  16151,  15800,
+   15446,  15090,  14732,  14372,  14010,  13645,  13278,  12910,
+   12539,  12167,  11793,  11416,  11039,  10659,  10278,   9896,
+    9512,   9126,   8739,   8351,   7961,   7571,   7179,   6786,
+    6392,   5997,   5602,   5205,   4808,   4409,   4011,   3611,
+    3211,   2811,   2410,   2009,   1607,   1206,    804,    402,
+       0,   -402,   -804,  -1206,  -1607,  -2009,  -2410,  -2811,
+   -3211,  -3611,  -4011,  -4409,  -4808,  -5205,  -5602,  -5997,
+   -6392,  -6786,  -7179,  -7571,  -7961,  -8351,  -8739,  -9126,
+   -9512,  -9896, -10278, -10659, -11039, -11416, -11793, -12167,
+  -12539, -12910, -13278, -13645, -14010, -14372, -14732, -15090,
+  -15446, -15800, -16151, -16499, -16846, -17189, -17530, -17869,
+  -18204, -18537, -18868, -19195, -19519, -19841, -20159, -20475,
+  -20787, -21097, -21403, -21706, -22005, -22301, -22594, -22884,
+  -23170, -23453, -23732, -24007, -24279, -24547, -24812, -25073,
+  -25330, -25583, -25832, -26077, -26319, -26557, -26790, -27020,
+  -27245, -27466, -27684, -27897, -28106, -28310, -28511, -28707,
+  -28898, -29086, -29269, -29447, -29621, -29791, -29956, -30117,
+  -30273, -30425, -30572, -30714, -30852, -30985, -31114, -31237,
+  -31357, -31471, -31581, -31685, -31785, -31881, -31971, -32057,
+  -32138, -32214, -32285, -32351, -32413, -32469, -32521, -32568,
+  -32610, -32647, -32679, -32706, -32728, -32745, -32758, -32765,
+  -32767, -32765, -32758, -32745, -32728, -32706, -32679, -32647,
+  -32610, -32568, -32521, -32469, -32413, -32351, -32285, -32214,
+  -32138, -32057, -31971, -31881, -31785, -31685, -31581, -31471,
+  -31357, -31237, -31114, -30985, -30852, -30714, -30572, -30425,
+  -30273, -30117, -29956, -29791, -29621, -29447, -29269, -29086,
+  -28898, -28707, -28511, -28310, -28106, -27897, -27684, -27466,
+  -27245, -27020, -26790, -26557, -26319, -26077, -25832, -25583,
+  -25330, -25073, -24812, -24547, -24279, -24007, -23732, -23453,
+  -23170, -22884, -22594, -22301, -22005, -21706, -21403, -21097,
+  -20787, -20475, -20159, -19841, -19519, -19195, -18868, -18537,
+  -18204, -17869, -17530, -17189, -16846, -16499, -16151, -15800,
+  -15446, -15090, -14732, -14372, -14010, -13645, -13278, -12910,
+  -12539, -12167, -11793, -11416, -11039, -10659, -10278,  -9896,
+   -9512,  -9126,  -8739,  -8351,  -7961,  -7571,  -7179,  -6786,
+   -6392,  -5997,  -5602,  -5205,  -4808,  -4409,  -4011,  -3611,
+   -3211,  -2811,  -2410,  -2009,  -1607,  -1206,   -804,   -402,
+       0,    402,    804,   1206,   1607,   2009,   2410,   2811,
+    3211,   3611,   4011,   4409,   4808,   5205,   5602,   5997,
+    6392,   6786,   7179,   7571,   7961,   8351,   8739,   9126,
+    9512,   9896,  10278,  10659,  11039,  11416,  11793,  12167,
+   12539,  12910,  13278,  13645,  14010,  14372,  14732,  15090,
+   15446,  15800,  16151,  16499,  16846,  17189,  17530,  17869,
+   18204,  18537,  18868,  19195,  19519,  19841,  20159,  20475,
+   20787,  21097,  21403,  21706,  22005,  22301,  22594,  22884,
+   23170,  23453,  23732,  24007,  24279,  24547,  24812,  25073,
+   25330,  25583,  25832,  26077,  26319,  26557,  26790,  27020,
+   27245,  27466,  27684,  27897,  28106,  28310,  28511,  28707,
+   28898,  29086,  29269,  29447,  29621,  29791,  29956,  30117,
+   30273,  30425,  30572,  30714,  30852,  30985,  31114,  31237,
+   31357,  31471,  31581,  31685,  31785,  31881,  31971,  32057,
+   32138,  32214,  32285,  32351,  32413,  32469,  32521,  32568,
+   32610,  32647,  32679,  32706,  32728,  32745,  32758,  32765
+};
diff --git a/src/chip/c4/c4fn.cpp b/src/chip/c4/c4fn.cpp
new file mode 100644
index 00000000..f5545ec6
--- /dev/null
+++ b/src/chip/c4/c4fn.cpp
@@ -0,0 +1,242 @@
+#include <math.h>
+#define Tan(a) (CosTable[a] ? ((((int32)SinTable[a]) << 16) / CosTable[a]) : 0x80000000)
+#define sar(b, n) ((b) >> (n))
+#ifdef PI
+#undef PI
+#endif
+#define PI 3.1415926535897932384626433832795
+
+//Wireframe Helpers
+void C4::C4TransfWireFrame() {
+  c4x = (double)C4WFXVal;
+  c4y = (double)C4WFYVal;
+  c4z = (double)C4WFZVal - 0x95;
+
+//Rotate X
+  tanval = -(double)C4WFX2Val * PI * 2 / 128;
+  c4y2   = c4y * ::cos(tanval) - c4z * ::sin(tanval);
+  c4z2   = c4y * ::sin(tanval) + c4z * ::cos(tanval);
+
+//Rotate Y
+  tanval = -(double)C4WFY2Val * PI * 2 / 128;
+  c4x2   = c4x * ::cos(tanval)  + c4z2 * ::sin(tanval);
+  c4z    = c4x * -::sin(tanval) + c4z2 * ::cos(tanval);
+
+//Rotate Z
+  tanval = -(double)C4WFDist * PI * 2 / 128;
+  c4x    = c4x2 * ::cos(tanval) - c4y2 * ::sin(tanval);
+  c4y    = c4x2 * ::sin(tanval) + c4y2 * ::cos(tanval);
+
+//Scale
+  C4WFXVal = (int16)(c4x * C4WFScale / (0x90 * (c4z + 0x95)) * 0x95);
+  C4WFYVal = (int16)(c4y * C4WFScale / (0x90 * (c4z + 0x95)) * 0x95);
+}
+
+void C4::C4CalcWireFrame() {
+  C4WFXVal = C4WFX2Val - C4WFXVal;
+  C4WFYVal = C4WFY2Val - C4WFYVal;
+
+  if(abs(C4WFXVal) > abs(C4WFYVal)) {
+    C4WFDist = abs(C4WFXVal) + 1;
+    C4WFYVal = (256 * (long)C4WFYVal) / abs(C4WFXVal);
+    C4WFXVal = (C4WFXVal < 0) ? -256 : 256;
+  } else if(C4WFYVal != 0) {
+    C4WFDist = abs(C4WFYVal) + 1;
+    C4WFXVal = (256 * (long)C4WFXVal) / abs(C4WFYVal);
+    C4WFYVal = (C4WFYVal < 0) ? -256 : 256;
+  } else {
+    C4WFDist = 0;
+  }
+}
+
+void C4::C4TransfWireFrame2() {
+  c4x = (double)C4WFXVal;
+  c4y = (double)C4WFYVal;
+  c4z = (double)C4WFZVal;
+
+//Rotate X
+  tanval = -(double)C4WFX2Val * PI * 2 / 128;
+  c4y2   = c4y * ::cos(tanval) - c4z * ::sin(tanval);
+  c4z2   = c4y * ::sin(tanval) + c4z * ::cos(tanval);
+
+//Rotate Y
+  tanval = -(double)C4WFY2Val * PI * 2 / 128;
+  c4x2   = c4x * ::cos(tanval)  + c4z2 * ::sin(tanval);
+  c4z    = c4x * -::sin(tanval) + c4z2 * ::cos(tanval);
+
+//Rotate Z
+  tanval = -(double)C4WFDist * PI * 2 / 128;
+  c4x    = c4x2 * ::cos(tanval) - c4y2 * ::sin(tanval);
+  c4y    = c4x2 * ::sin(tanval) + c4y2 * ::cos(tanval);
+
+//Scale
+  C4WFXVal = (int16)(c4x * C4WFScale / 0x100);
+  C4WFYVal = (int16)(c4y * C4WFScale / 0x100);
+}
+
+void C4::C4DrawWireFrame() {
+uint32 line = readl(0x1f80);
+uint32 point1, point2;
+int16 X1, Y1, Z1;
+int16 X2, Y2, Z2;
+uint8 Color;
+  for(int32 i = ram[0x0295]; i > 0; i--, line += 5) {
+    if(r_mem->read(line) == 0xff && r_mem->read(line + 1) == 0xff) {
+    int32 tmp = line - 5;
+      while(r_mem->read(tmp + 2) == 0xff && r_mem->read(tmp + 3) == 0xff && (tmp + 2) >= 0) { tmp -= 5; }
+      point1 = (read(0x1f82) << 16) | (r_mem->read(tmp + 2) << 8) | r_mem->read(tmp + 3);
+    } else {
+      point1 = (read(0x1f82) << 16) | (r_mem->read(line) << 8) | r_mem->read(line + 1);
+    }
+    point2 = (read(0x1f82) << 16) | (r_mem->read(line + 2) << 8) | r_mem->read(line + 3);
+
+    X1=(r_mem->read(point1 + 0) << 8) | r_mem->read(point1 + 1);
+    Y1=(r_mem->read(point1 + 2) << 8) | r_mem->read(point1 + 3);
+    Z1=(r_mem->read(point1 + 4) << 8) | r_mem->read(point1 + 5);
+    X2=(r_mem->read(point2 + 0) << 8) | r_mem->read(point2 + 1);
+    Y2=(r_mem->read(point2 + 2) << 8) | r_mem->read(point2 + 3);
+    Z2=(r_mem->read(point2 + 4) << 8) | r_mem->read(point2 + 5);
+    Color = r_mem->read(line + 4);
+    C4DrawLine(X1, Y1, Z1, X2, Y2, Z2, Color);
+  }
+}
+
+void C4::C4DrawLine(int32 X1, int32 Y1, int16 Z1, int32 X2, int32 Y2, int16 Z2, uint8 Color) {
+//Transform coordinates
+  C4WFXVal  = (int16)X1;
+  C4WFYVal  = (int16)Y1;
+  C4WFZVal  = Z1;
+  C4WFScale = read(0x1f90);
+  C4WFX2Val = read(0x1f86);
+  C4WFY2Val = read(0x1f87);
+  C4WFDist  = read(0x1f88);
+  C4TransfWireFrame2();
+  X1 = (C4WFXVal + 48) << 8;
+  Y1 = (C4WFYVal + 48) << 8;
+
+  C4WFXVal = (int16)X2;
+  C4WFYVal = (int16)Y2;
+  C4WFZVal = Z2;
+  C4TransfWireFrame2();
+  X2 = (C4WFXVal + 48) << 8;
+  Y2 = (C4WFYVal + 48) << 8;
+
+//Get line info
+  C4WFXVal  = (int16)(X1 >> 8);
+  C4WFYVal  = (int16)(Y1 >> 8);
+  C4WFX2Val = (int16)(X2 >> 8);
+  C4WFY2Val = (int16)(Y2 >> 8);
+  C4CalcWireFrame();
+  X2 = (int16)C4WFXVal;
+  Y2 = (int16)C4WFYVal;
+
+//Render line
+  for(int32 i = C4WFDist ? C4WFDist : 1; i > 0; i--) {
+    if(X1 > 0xff && Y1 > 0xff && X1 < 0x6000 && Y1 < 0x6000) {
+    uint16 addr = (((Y1 >> 8) >> 3) << 8) - (((Y1 >> 8) >> 3) << 6) + (((X1 >> 8) >> 3) << 4) + ((Y1 >> 8) & 7) * 2;
+    uint8 bit = 0x80 >> ((X1 >> 8) & 7);
+      ram[addr + 0x300] &= ~bit;
+      ram[addr + 0x301] &= ~bit;
+      if(Color & 1) { ram[addr + 0x300] |= bit; }
+      if(Color & 2) { ram[addr + 0x301] |= bit; }
+    }
+    X1 += X2;
+    Y1 += Y2;
+  }
+}
+
+void C4::C4DoScaleRotate(int row_padding) {
+int16 A, B, C, D;
+
+//Calculate matrix
+int32 XScale = readw(0x1f8f);
+int32 YScale = readw(0x1f92);
+  if(XScale & 0x8000)XScale = 0x7fff;
+  if(YScale & 0x8000)YScale = 0x7fff;
+
+  if(readw(0x1f80) == 0) { //no rotation
+    A = (int16)XScale;
+    B = 0;
+    C = 0;
+    D = (int16)YScale;
+  } else if(readw(0x1f80) == 128) { //90 degree rotation
+    A = 0;
+    B = (int16)(-YScale);
+    C = (int16)XScale;
+    D = 0;
+  } else if(readw(0x1f80) == 256) { //180 degree rotation
+    A = (int16)(-XScale);
+    B = 0;
+    C = 0;
+    D = (int16)(-YScale);
+  } else if(readw(0x1f80) == 384) { //270 degree rotation
+    A = 0;
+    B = (int16)YScale;
+    C = (int16)(-XScale);
+    D = 0;
+  } else {
+    A = (int16)  sar(CosTable[readw(0x1f80) & 0x1ff] * XScale, 15);
+    B = (int16)(-sar(SinTable[readw(0x1f80) & 0x1ff] * YScale, 15));
+    C = (int16)  sar(SinTable[readw(0x1f80) & 0x1ff] * XScale, 15);
+    D = (int16)  sar(CosTable[readw(0x1f80) & 0x1ff] * YScale, 15);
+  }
+
+//Calculate Pixel Resolution
+uint8 w = read(0x1f89) & ~7;
+uint8 h = read(0x1f8c) & ~7;
+
+//Clear the output RAM
+  memset(ram, 0, (w + row_padding / 4) * h / 2);
+
+int32 Cx = (int16)readw(0x1f83);
+int32 Cy = (int16)readw(0x1f86);
+
+//Calculate start position (i.e. (Ox, Oy) = (0, 0))
+//The low 12 bits are fractional, so (Cx<<12) gives us the Cx we want in
+//the function. We do Cx*A etc normally because the matrix parameters
+//already have the fractional parts.
+int32 LineX = (Cx << 12) - Cx * A - Cx * B;
+int32 LineY = (Cy << 12) - Cy * C - Cy * D;
+
+//Start loop
+uint32 X, Y;
+uint8 byte;
+int32 outidx = 0;
+uint8 bit    = 0x80;
+  for(int32 y = 0; y < h; y++) {
+    X = LineX;
+    Y = LineY;
+    for(int32 x = 0; x < w; x++) {
+      if((X >> 12) >= w || (Y >> 12) >= h) {
+        byte = 0;
+      } else {
+      uint32 addr = (Y >> 12) * w + (X >> 12);
+        byte = read(0x600 + (addr >> 1));
+        if(addr & 1) { byte >>= 4; }
+      }
+
+    //De-bitplanify
+      if(byte & 1) { ram[outidx     ] |= bit; }
+      if(byte & 2) { ram[outidx +  1] |= bit; }
+      if(byte & 4) { ram[outidx + 16] |= bit; }
+      if(byte & 8) { ram[outidx + 17] |= bit; }
+
+      bit >>= 1;
+      if(!bit) {
+        bit     = 0x80;
+        outidx += 32;
+      }
+
+      X += A; //Add 1 to output x => add an A and a C
+      Y += C;
+    }
+    outidx += 2 + row_padding;
+    if(outidx & 0x10) {
+      outidx &= ~0x10;
+    } else {
+      outidx -= w * 4 + row_padding;
+    }
+    LineX += B; //Add 1 to output y => add a B and a D
+    LineY += D;
+  }
+}
diff --git a/src/chip/c4/c4oam.cpp b/src/chip/c4/c4oam.cpp
new file mode 100644
index 00000000..ef253216
--- /dev/null
+++ b/src/chip/c4/c4oam.cpp
@@ -0,0 +1,224 @@
+//Build OAM
+void C4::op00_00() {
+uint32 oamptr = ram[0x626] << 2;
+  for(int32 i=0x1fd;i>oamptr && i>=0;i-=4) {
+  //clear oam-to-be
+    if(i >= 0)ram[i] = 0xe0;
+  }
+
+uint16 globalx, globaly;
+uint32 oamptr2;
+int16  sprx, spry;
+uint8  sprname, sprattr;
+uint8  sprcount;
+  globalx = readw(0x621);
+  globaly = readw(0x623);
+  oamptr2 = 0x200 + (ram[0x626] >> 2);
+
+  if(!ram[0x620])return;
+
+  sprcount = 128 - ram[0x626];
+uint8 offset = (ram[0x626] & 3) * 2;
+  for(int pri=0x30;pri>=0;pri-=0x10) {
+  uint32 srcptr = 0x220;
+    for(int i=ram[0x620];i>0 && sprcount>0;i--, srcptr+=16) {
+      if((ram[srcptr + 4] & 0x30) != pri)continue;
+      sprx = readw(srcptr)     - globalx;
+      spry = readw(srcptr + 2) - globaly;
+      sprname = ram[srcptr + 5];
+      sprattr = ram[srcptr + 4] | ram[srcptr + 6];
+
+    uint32 spraddr = readl(srcptr + 7);
+      if(r_mem->read(spraddr)) {
+      int16 x, y;
+        for(int sprcnt=r_mem->read(spraddr++);sprcnt>0 && sprcount>0;sprcnt--, spraddr+=4) {
+          x = (int8)r_mem->read(spraddr + 1);
+          if(sprattr & 0x40) {
+            x = -x - ((r_mem->read(spraddr) & 0x20) ? 16 : 8);
+          }
+          x += sprx;
+          if(x >= -16 && x <= 272) {
+            y = (int8)r_mem->read(spraddr + 2);
+            if(sprattr & 0x80) {
+              y = -y - ((r_mem->read(spraddr) & 0x20) ? 16 : 8);
+            }
+            y += spry;
+            if(y >= -16 && y <= 224) {
+              ram[oamptr    ] = (uint8)x;
+              ram[oamptr + 1] = (uint8)y;
+              ram[oamptr + 2] = sprname + r_mem->read(spraddr + 3);
+              ram[oamptr + 3] = sprattr ^ (r_mem->read(spraddr) & 0xc0);
+              ram[oamptr2] &= ~(3 << offset);
+              if(x & 0x100)ram[oamptr2] |= 1 << offset;
+              if(r_mem->read(spraddr) & 0x20)ram[oamptr2] |= 2 << offset;
+              oamptr += 4;
+              sprcount--;
+              offset = (offset + 2) & 6;
+              if(!offset)oamptr2++;
+            }
+          }
+        }
+      } else if(sprcount > 0) {
+        ram[oamptr    ] = (uint8)sprx;
+        ram[oamptr + 1] = (uint8)spry;
+        ram[oamptr + 2] = sprname;
+        ram[oamptr + 3] = sprattr;
+        ram[oamptr2] &= ~(3 << offset);
+        if(sprx & 0x100)ram[oamptr2] |= 3 << offset;
+        else ram[oamptr2] |= 2 << offset;
+        oamptr += 4;
+        sprcount--;
+        offset = (offset + 2) & 6;
+        if(!offset)oamptr2++;
+      }
+    }
+  }
+}
+
+//Scale and Rotate
+void C4::op00_03() {
+  C4DoScaleRotate(0);
+}
+
+//Transform Lines
+void C4::op00_05() {
+  C4WFX2Val = read(0x1f83);
+  C4WFY2Val = read(0x1f86);
+  C4WFDist  = read(0x1f89);
+  C4WFScale = read(0x1f8c);
+
+//Transform Vertices
+uint32 ptr = 0;
+  for(int32 i = readw(0x1f80); i > 0; i--, ptr += 0x10) {
+    C4WFXVal = readw(ptr + 1);
+    C4WFYVal = readw(ptr + 5);
+    C4WFZVal = readw(ptr + 9);
+    C4TransfWireFrame();
+
+  //Displace
+    writew(ptr + 1, C4WFXVal + 0x80);
+    writew(ptr + 5, C4WFYVal + 0x50);
+  }
+
+  writew(0x600,     23);
+  writew(0x602,     0x60);
+  writew(0x605,     0x40);
+  writew(0x600 + 8, 23);
+  writew(0x602 + 8, 0x60);
+  writew(0x605 + 8, 0x40);
+
+  ptr = 0xb02;
+uint32 ptr2 = 0;
+  for(int32 i = readw(0xb00); i > 0; i--, ptr += 2, ptr2 += 8) {
+    C4WFXVal  = readw((read(ptr + 0) << 4) + 1);
+    C4WFYVal  = readw((read(ptr + 0) << 4) + 5);
+    C4WFX2Val = readw((read(ptr + 1) << 4) + 1);
+    C4WFY2Val = readw((read(ptr + 1) << 4) + 5);
+    C4CalcWireFrame();
+    writew(ptr2 + 0x600, C4WFDist ? C4WFDist : 1);
+    writew(ptr2 + 0x602, C4WFXVal);
+    writew(ptr2 + 0x605, C4WFYVal);
+  }
+}
+
+//Scale and Rotate
+void C4::op00_07() {
+  C4DoScaleRotate(64);
+}
+
+//Draw Wireframe
+void C4::op00_08() {
+  C4DrawWireFrame();
+}
+
+//Disintegrate
+void C4::op00_0b() {
+uint8  width, height;
+uint32 startx, starty;
+uint32 srcptr;
+uint32 x, y;
+int32  scalex, scaley;
+int32  cx, cy;
+int32  i, j;
+  width  = read(0x1f89);
+  height = read(0x1f8c);
+  cx     = readw(0x1f80);
+  cy     = readw(0x1f83);
+
+  scalex = (int16)readw(0x1f86);
+  scaley = (int16)readw(0x1f8f);
+  startx = -cx * scalex + (cx << 8);
+  starty = -cy * scaley + (cy << 8);
+  srcptr = 0x600;
+
+  for(i = 0; i < (width * height) >> 1; i++) {
+    write(i, 0);
+  }
+
+  for(y = starty, i = 0;i < height; i++, y += scaley) {
+    for(x = startx, j = 0;j < width; j++, x += scalex) {
+      if((x >> 8) < width && (y >> 8) < height && (y >> 8) * width + (x >> 8) < 0x2000) {
+      uint8 pixel = (j & 1) ? (ram[srcptr] >> 4) : (ram[srcptr]);
+      int32 index = (y >> 11) * width * 4 + (x >> 11) * 32 + ((y >> 8) & 7) * 2;
+      uint8 mask = 0x80 >> ((x >> 8) & 7);
+        if(pixel & 1)ram[index     ] |= mask;
+        if(pixel & 2)ram[index +  1] |= mask;
+        if(pixel & 4)ram[index + 16] |= mask;
+        if(pixel & 8)ram[index + 17] |= mask;
+      }
+      if(j & 1)srcptr++;
+    }
+  }
+}
+
+//Bitplane Wave
+void C4::op00_0c() {
+uint32 destptr = 0;
+uint32 waveptr = read(0x1f83);
+uint16 mask1   = 0xc0c0;
+uint16 mask2   = 0x3f3f;
+
+int32 i, j;
+int16 height, temp;
+  for(j = 0; j < 0x10; j++) {
+    do {
+      height = -((int8)ram[waveptr + 0xb00]) - 16;
+      for(i = 0; i < 40; i++) {
+        temp = readw(destptr + wave_data[i]) & mask2;
+        if(height >= 0) {
+          if(height < 8) {
+            temp |= mask1 & readw(0xa00 + height * 2);
+          } else {
+            temp |= mask1 & 0xff00;
+          }
+        }
+        writew(destptr + wave_data[i], temp);
+        height++;
+      }
+      waveptr = (waveptr + 1) & 0x7f;
+      mask1   = (mask1 >> 2) | (mask1 << 6);
+      mask2   = (mask2 >> 2) | (mask2 << 6);
+    } while(mask1 != 0xc0c0);
+    destptr += 16;
+
+    do {
+      height = -((int8)ram[waveptr + 0xb00]) - 16;
+      for(i = 0; i < 40; i++) {
+        temp = readw(destptr + wave_data[i]) & mask2;
+        if(height >= 0) {
+          if(height < 8) {
+            temp |= mask1 & readw(0xa10 + height * 2);
+          } else {
+            temp |= mask1 & 0xff00;
+          }
+          writew(destptr + wave_data[i], temp);
+          height++;
+        }
+        waveptr = (waveptr + 1) & 0x7f;
+        mask1   = (mask1 >> 2) | (mask1 << 6);
+        mask2   = (mask2 >> 2) | (mask2 << 6);
+      }
+    } while(mask1 != 0xc0c0);
+    destptr += 16;
+  }
+}
diff --git a/src/chip/c4/c4ops.cpp b/src/chip/c4/c4ops.cpp
new file mode 100644
index 00000000..05b7ece4
--- /dev/null
+++ b/src/chip/c4/c4ops.cpp
@@ -0,0 +1,222 @@
+//Sprite Functions
+void C4::op00() {
+  switch(reg[0x4d]) {
+  case 0x00:op00_00();break;
+  case 0x03:op00_03();break;
+  case 0x05:op00_05();break;
+  case 0x07:op00_07();break;
+  case 0x08:op00_08();break;
+  case 0x0b:op00_0b();break;
+  case 0x0c:op00_0c();break;
+  }
+}
+
+//Draw Wireframe
+void C4::op01() {
+  memset(ram + 0x300, 0, 2304);
+  C4DrawWireFrame();
+}
+
+//Propulsion
+void C4::op05() {
+int32 temp = 0x10000;
+  if(readw(0x1f83)) {
+    temp = sar((temp / readw(0x1f83)) * readw(0x1f81), 8);
+  }
+  writew(0x1f80, temp);
+}
+
+//Set Vector length
+void C4::op0d() {
+  C41FXVal    = readw(0x1f80);
+  C41FYVal    = readw(0x1f83);
+  C41FDistVal = readw(0x1f86);
+  tanval = sqrt(((double)C41FYVal) * ((double)C41FYVal) + ((double)C41FXVal) * ((double)C41FXVal));
+  tanval = (double)C41FDistVal / tanval;
+  C41FYVal = (int16)(((double)C41FYVal * tanval) * 0.99);
+  C41FXVal = (int16)(((double)C41FXVal * tanval) * 0.98);
+  writew(0x1f89, C41FXVal);
+  writew(0x1f8c, C41FYVal);
+}
+
+//Triangle
+void C4::op10() {
+  r0 = ldr(0);
+  r1 = ldr(1);
+
+  r4 = r0 & 0x1ff;
+  if(r1 & 0x8000)r1 |= ~0x7fff;
+
+  mul(cos(r4), r1, r5, r2);
+  r5 = (r5 >> 16) & 0xff;
+  r2 = (r2 << 8) + r5;
+
+  mul(sin(r4), r1, r5, r3);
+  r5 = (r5 >> 16) & 0xff;
+  r3 = (r3 << 8) + r5;
+
+  str(0, r0);
+  str(1, r1);
+  str(2, r2);
+  str(3, r3);
+  str(4, r4);
+  str(5, r5);
+}
+
+//Triangle
+void C4::op13() {
+  r0 = ldr(0);
+  r1 = ldr(1);
+
+  r4 = r0 & 0x1ff;
+
+  mul(cos(r4), r1, r5, r2);
+  r5 = (r5 >> 8) & 0xffff;
+  r2 = (r2 << 16) + r5;
+
+  mul(sin(r4), r1, r5, r3);
+  r5 = (r5 >> 8) & 0xffff;
+  r3 = (r3 << 16) + r5;
+
+  str(0, r0);
+  str(1, r1);
+  str(2, r2);
+  str(3, r3);
+  str(4, r4);
+  str(5, r5);
+}
+
+//Pythagorean
+void C4::op15() {
+  C41FXVal = readw(0x1f80);
+  C41FYVal = readw(0x1f83);
+  C41FDist = (int16)sqrt((double)C41FXVal * (double)C41FXVal + (double)C41FYVal * (double)C41FYVal);
+  writew(0x1f80, C41FDist);
+}
+
+//Calculate distance
+void C4::op1f() {
+  C41FXVal = readw(0x1f80);
+  C41FYVal = readw(0x1f83);
+  if(!C41FXVal) {
+    C41FAngleRes = (C41FYVal > 0) ? 0x080 : 0x180;
+  } else {
+    tanval = ((double)C41FYVal) / ((double)C41FXVal);
+    C41FAngleRes = (short)(atan(tanval) / (PI * 2) * 512);
+    C41FAngleRes = C41FAngleRes;
+    if(C41FXVal < 0) {
+      C41FAngleRes += 0x100;
+    }
+    C41FAngleRes &= 0x1ff;
+  }
+  writew(0x1f86, C41FAngleRes);
+}
+
+//Trapezoid
+void C4::op22() {
+int16 angle1 = readw(0x1f8c) & 0x1ff;
+int16 angle2 = readw(0x1f8f) & 0x1ff;
+int32 tan1 = Tan(angle1);
+int32 tan2 = Tan(angle2);
+int16 y = readw(0x1f83) - readw(0x1f89);
+int16 left, right;
+  for(int32 j = 0; j < 225; j++, y++) {
+    if(y >= 0) {
+      left  = sar((int32)tan1 * y, 16) - readw(0x1f80) + readw(0x1f86);
+      right = sar((int32)tan2 * y, 16) - readw(0x1f80) + readw(0x1f86) + readw(0x1f93);
+
+      if(left < 0 && right < 0) {
+        left  = 1;
+        right = 0;
+      } else if(left < 0) {
+        left  = 0;
+      } else if(right < 0) {
+        right = 0;
+      }
+
+      if(left > 255 && right > 255) {
+        left  = 255;
+        right = 254;
+      } else if(left > 255) {
+        left  = 255;
+      } else if(right > 255) {
+        right = 255;
+      }
+    } else {
+      left  = 1;
+      right = 0;
+    }
+    ram[j + 0x800] = (uint8)left;
+    ram[j + 0x900] = (uint8)right;
+  }
+}
+
+//Multiply
+void C4::op25() {
+  r0 = ldr(0);
+  r1 = ldr(1);
+  mul(r0, r1, r0, r1);
+  str(0, r0);
+  str(1, r1);
+}
+
+//Transform Coords
+void C4::op2d() {
+  C4WFXVal  = readw(0x1f81);
+  C4WFYVal  = readw(0x1f84);
+  C4WFZVal  = readw(0x1f87);
+  C4WFX2Val = read (0x1f89);
+  C4WFY2Val = read (0x1f8a);
+  C4WFDist  = read (0x1f8b);
+  C4WFScale = readw(0x1f90);
+  C4TransfWireFrame2();
+  writew(0x1f80, C4WFXVal);
+  writew(0x1f83, C4WFYVal);
+}
+
+//Sum
+void C4::op40() {
+  r0 = 0;
+  for(uint32 i=0;i<0x800;i++) {
+    r0 += ram[i];
+  }
+  str(0, r0);
+}
+
+//Square
+void C4::op54() {
+  r0 = ldr(0);
+  mul(r0, r0, r1, r2);
+  str(1, r1);
+  str(2, r2);
+}
+
+//Immediate Register
+void C4::op5c() {
+  str(0, 0x000000);
+  immediate_reg(0);
+}
+
+//Immediate Register (Multiple)
+void C4::op5e() { immediate_reg( 0); }
+void C4::op60() { immediate_reg( 3); }
+void C4::op62() { immediate_reg( 6); }
+void C4::op64() { immediate_reg( 9); }
+void C4::op66() { immediate_reg(12); }
+void C4::op68() { immediate_reg(15); }
+void C4::op6a() { immediate_reg(18); }
+void C4::op6c() { immediate_reg(21); }
+void C4::op6e() { immediate_reg(24); }
+void C4::op70() { immediate_reg(27); }
+void C4::op72() { immediate_reg(30); }
+void C4::op74() { immediate_reg(33); }
+void C4::op76() { immediate_reg(36); }
+void C4::op78() { immediate_reg(39); }
+void C4::op7a() { immediate_reg(42); }
+void C4::op7c() { immediate_reg(45); }
+
+//Immediate ROM
+void C4::op89() {
+  str(0, 0x054336);
+  str(1, 0xffffff);
+}
diff --git a/src/chip/sdd1/sdd1.cpp b/src/chip/sdd1/sdd1.cpp
index e7e16098..29a0a4a9 100644
--- a/src/chip/sdd1/sdd1.cpp
+++ b/src/chip/sdd1/sdd1.cpp
@@ -1,8 +1,7 @@
 #include "../../base.h"
 #include "sdd1emu.cpp"
 
-void SDD1::init() {
-}
+void SDD1::init() {}
 
 void SDD1::enable() {
   for(int i=0x4800;i<=0x4807;i++) {
diff --git a/src/chip/srtc/srtc.cpp b/src/chip/srtc/srtc.cpp
index aa59e006..79dc999a 100644
--- a/src/chip/srtc/srtc.cpp
+++ b/src/chip/srtc/srtc.cpp
@@ -74,8 +74,7 @@ tm *t;
   srtc.data[12] = t->tm_wday;
 }
 
-void SRTC::init() {
-}
+void SRTC::init() {}
 
 void SRTC::enable() {
   r_mem->set_mmio_mapper(0x2800, mmio);
diff --git a/src/config/config.cpp b/src/config/config.cpp
index a3d82316..4da22045 100644
--- a/src/config/config.cpp
+++ b/src/config/config.cpp
@@ -21,8 +21,24 @@ void SNES::VideoColorAdjust::set(uint32 _data) {
   ::snes->update_color_lookup_table();
 }
 
-Setting SNES::mute(&config_file, "snes.mute",
-  "Mutes SNES audio output when enabled",
-  true, Setting::TRUE_FALSE);
+Setting SNES::mute(&config_file, "snes.mute", "Mutes SNES audio output when enabled",
+  false, Setting::TRUE_FALSE);
+
+//do not save these settings to config_file
+Setting CPU::hdma_enable(0, "cpu.hdma_enable", "Enable HDMA effects", true, Setting::TRUE_FALSE);
+Setting PPU::opt_enable(0, "ppu.opt_enable", "Enable offset-per-tile effects", true, Setting::TRUE_FALSE);
+
+Setting PPU::bg1_pri0_enable(0, "ppu.bg1_pri0_enable", "Enable BG1 Priority 0", true, Setting::TRUE_FALSE);
+Setting PPU::bg1_pri1_enable(0, "ppu.bg1_pri1_enable", "Enable BG1 Priority 1", true, Setting::TRUE_FALSE);
+Setting PPU::bg2_pri0_enable(0, "ppu.bg2_pri0_enable", "Enable BG2 Priority 0", true, Setting::TRUE_FALSE);
+Setting PPU::bg2_pri1_enable(0, "ppu.bg2_pri1_enable", "Enable BG2 Priority 1", true, Setting::TRUE_FALSE);
+Setting PPU::bg3_pri0_enable(0, "ppu.bg3_pri0_enable", "Enable BG3 Priority 0", true, Setting::TRUE_FALSE);
+Setting PPU::bg3_pri1_enable(0, "ppu.bg3_pri1_enable", "Enable BG3 Priority 1", true, Setting::TRUE_FALSE);
+Setting PPU::bg4_pri0_enable(0, "ppu.bg4_pri0_enable", "Enable BG4 Priority 0", true, Setting::TRUE_FALSE);
+Setting PPU::bg4_pri1_enable(0, "ppu.bg4_pri1_enable", "Enable BG4 Priority 1", true, Setting::TRUE_FALSE);
+Setting PPU::oam_pri0_enable(0, "ppu.oam_pri0_enable", "Enable OAM Priority 0", true, Setting::TRUE_FALSE);
+Setting PPU::oam_pri1_enable(0, "ppu.oam_pri1_enable", "Enable OAM Priority 1", true, Setting::TRUE_FALSE);
+Setting PPU::oam_pri2_enable(0, "ppu.oam_pri2_enable", "Enable OAM Priority 2", true, Setting::TRUE_FALSE);
+Setting PPU::oam_pri3_enable(0, "ppu.oam_pri3_enable", "Enable OAM Priority 3", true, Setting::TRUE_FALSE);
 
 };
diff --git a/src/config/config.h b/src/config/config.h
index 9933d6c8..31cfd305 100644
--- a/src/config/config.h
+++ b/src/config/config.h
@@ -12,4 +12,19 @@ extern struct SNES {
   static Setting mute;
 } snes;
 
+extern struct CPU {
+  static Setting hdma_enable;
+} cpu;
+
+extern struct PPU {
+  static Setting opt_enable;
+
+  static Setting bg1_pri0_enable, bg1_pri1_enable;
+  static Setting bg2_pri0_enable, bg2_pri1_enable;
+  static Setting bg3_pri0_enable, bg3_pri1_enable;
+  static Setting bg4_pri0_enable, bg4_pri1_enable;
+  static Setting oam_pri0_enable, oam_pri1_enable;
+  static Setting oam_pri2_enable, oam_pri3_enable;
+} ppu;
+
 };
diff --git a/src/cpu/bcpu/bcpu_dma.cpp b/src/cpu/bcpu/bcpu_dma.cpp
index 2fad96eb..8580dc48 100644
--- a/src/cpu/bcpu/bcpu_dma.cpp
+++ b/src/cpu/bcpu/bcpu_dma.cpp
@@ -122,12 +122,17 @@ uint8 bCPU::hdma_read(uint8 i) {
 }
 
 void bCPU::hdma_write(uint8 i, uint8 x) {
+uint32 addr;
   if(channel[i].direction == DMA_CPUTOMMIO) {
-    r_mem->write(hdma_mmio(i), x);
+    addr = hdma_mmio(i);
   } else if(!channel[i].hdma_indirect) {
-    r_mem->write(hdma_addr(i), x);
+    addr = hdma_addr(i);
   } else {
-    r_mem->write(hdma_iaddr(i), x);
+    addr = hdma_iaddr(i);
+  }
+
+  if((bool)config::cpu.hdma_enable == true) {
+    r_mem->write(addr, x);
   }
 
   add_cycles(8);
diff --git a/src/cpu/bcpu/bcpu_opfn.cpp b/src/cpu/bcpu/bcpu_opfn.cpp
index b6f13563..18eb3d42 100644
--- a/src/cpu/bcpu/bcpu_opfn.cpp
+++ b/src/cpu/bcpu/bcpu_opfn.cpp
@@ -1,31 +1,75 @@
 //op_read
 inline void bCPU::op_adc_b() {
 int32 r = regs.a.l + rd.l + regs.p.c;
-//bcd
   if(regs.p.d) {
-    if(((r     ) & 15) > 9)r += 6;
-    if(((r >> 4) & 15) > 9)r += 6 << 4;
+  uint8 n0 = (regs.a.l     ) & 15;
+  uint8 n1 = (regs.a.l >> 4) & 15;
+    n0 += ((rd.l) & 15) + regs.p.c;
+    if(n0 > 9) {
+      n0 -= 10;
+      n0 &= 15;
+      n1++;
+    }
+    n1 += ((rd.l >> 4) & 15);
+    if(n1 > 9) {
+      n1 -= 10;
+      n1 &= 15;
+      regs.p.c = 1;
+    } else {
+      regs.p.c = 0;
+    }
+    r = (n1 << 4) | (n0);
+  } else {
+    r = regs.a.l + rd.l + regs.p.c;
+    regs.p.c = (r > 0xff);
   }
   regs.p.n = !!(r & 0x80);
   regs.p.v = !!(~(regs.a.l ^ rd.l) & (regs.a.l ^ r) & 0x80);
   regs.p.z = ((uint8)r == 0);
-  regs.p.c = (r > 0xff);
   regs.a.l = r;
 }
 
 inline void bCPU::op_adc_w() {
-int32 r = regs.a.w + rd.w + regs.p.c;
-//bcd
+int32 r;
   if(regs.p.d) {
-    if(((r      ) & 15) > 9)r += 6;
-    if(((r >>  4) & 15) > 9)r += 6 <<  4;
-    if(((r >>  8) & 15) > 9)r += 6 <<  8;
-    if(((r >> 12) & 15) > 9)r += 6 << 12;
+  uint8 n0 = (regs.a.w      ) & 15;
+  uint8 n1 = (regs.a.w >>  4) & 15;
+  uint8 n2 = (regs.a.w >>  8) & 15;
+  uint8 n3 = (regs.a.w >> 12) & 15;
+    n0 += ((rd.w) & 15) + regs.p.c;
+    if(n0 > 9) {
+      n0 -= 10;
+      n0 &= 15;
+      n1++;
+    }
+    n1 += ((rd.w >> 4) & 15);
+    if(n1 > 9) {
+      n1 -= 10;
+      n1 &= 15;
+      n2++;
+    }
+    n2 += ((rd.w >> 8) & 15);
+    if(n2 > 9) {
+      n2 -= 10;
+      n2 &= 15;
+      n3++;
+    }
+    n3 += ((rd.w >> 12) & 15);
+    if(n3 > 9) {
+      n3 -= 10;
+      n3 &= 15;
+      regs.p.c = 1;
+    } else {
+      regs.p.c = 0;
+    }
+    r = (n3 << 12) | (n2 << 8) | (n1 << 4) | (n0);
+  } else {
+    r = regs.a.w + rd.w + regs.p.c;
+    regs.p.c = (r > 0xffff);
   }
   regs.p.n = !!(r & 0x8000);
   regs.p.v = !!(~(regs.a.w ^ rd.w) & (regs.a.w ^ r) & 0x8000);
   regs.p.z = ((uint16)r == 0);
-  regs.p.c = (r > 0xffff);
   regs.a.w = r;
 }
 
@@ -156,32 +200,70 @@ inline void bCPU::op_ora_w() {
 }
 
 inline void bCPU::op_sbc_b() {
-int32 r = regs.a.l - rd.l - !regs.p.c;
-//bcd
+int32 r;
   if(regs.p.d) {
-    if(((r     ) & 15) > 9)r -= 6;
-    if(((r >> 4) & 15) > 9)r -= 6 << 4;
+  uint8 n0 = (regs.a.l     ) & 15;
+  uint8 n1 = (regs.a.l >> 4) & 15;
+    n0 -= ((rd.l     ) & 15) + !regs.p.c;
+    n1 -= ((rd.l >> 4) & 15);
+    if(n0 > 9) {
+      n0 += 10;
+      n1--;
+    }
+    if(n1 > 9) {
+      n1 += 10;
+      regs.p.c = 0;
+    } else {
+      regs.p.c = 1;
+    }
+    r = (n1 << 4) | (n0);
+  } else {
+    r = regs.a.l - rd.l - !regs.p.c;
+    regs.p.c = (r >= 0);
   }
   regs.p.n = !!(r & 0x80);
   regs.p.v = !!((regs.a.l ^ rd.l) & (regs.a.l ^ r) & 0x80);
-  regs.p.z = ((byte)r == 0);
-  regs.p.c = (r >= 0);
+  regs.p.z = ((uint8)r == 0);
   regs.a.l = r;
 }
 
 inline void bCPU::op_sbc_w() {
-int32 r = regs.a.w - rd.w - !regs.p.c;
-//bcd
+int32 r;
   if(regs.p.d) {
-    if(((r      ) & 15) > 9)r -= 6;
-    if(((r >>  4) & 15) > 9)r -= 6 <<  4;
-    if(((r >>  8) & 15) > 9)r -= 6 <<  8;
-    if(((r >> 12) & 15) > 9)r -= 6 << 12;
+  uint8 n0 = (regs.a.w      ) & 15;
+  uint8 n1 = (regs.a.w >>  4) & 15;
+  uint8 n2 = (regs.a.w >>  8) & 15;
+  uint8 n3 = (regs.a.w >> 12) & 15;
+    n0 -= ((rd.w      ) & 15) + !regs.p.c;
+    n1 -= ((rd.w >>  4) & 15);
+    n2 -= ((rd.w >>  8) & 15);
+    n3 -= ((rd.w >> 12) & 15);
+    if(n0 > 9) {
+      n0 += 10;
+      n1--;
+    }
+    if(n1 > 9) {
+      n1 += 10;
+      n2--;
+    }
+    if(n2 > 9) {
+      n2 += 10;
+      n3--;
+    }
+    if(n3 > 9) {
+      n3 += 10;
+      regs.p.c = 0;
+    } else {
+      regs.p.c = 1;
+    }
+    r = (n3 << 12) | (n2 << 8) | (n1 << 4) | (n0);
+  } else {
+    r = regs.a.w - rd.w - !regs.p.c;
+    regs.p.c = (r >= 0);
   }
   regs.p.n = !!(r & 0x8000);
   regs.p.v = !!((regs.a.w ^ rd.w) & (regs.a.w ^ r) & 0x8000);
-  regs.p.z = ((word)r == 0);
-  regs.p.c = (r >= 0);
+  regs.p.z = ((uint16)r == 0);
   regs.a.w = r;
 }
 
diff --git a/src/cpu/cpu.h b/src/cpu/cpu.h
index 77e60098..cffc3ba5 100644
--- a/src/cpu/cpu.h
+++ b/src/cpu/cpu.h
@@ -70,4 +70,5 @@ enum {
   uint16 __relw(int16 offset);
 
   CPU();
+  virtual ~CPU() {}
 };
diff --git a/src/dsp/bdsp/bdsp.cpp b/src/dsp/bdsp/bdsp.cpp
index 18a91872..4a3d77d1 100644
--- a/src/dsp/bdsp/bdsp.cpp
+++ b/src/dsp/bdsp/bdsp.cpp
@@ -1,10 +1,22 @@
 #include "../../base.h"
 #include "bdsp_tables.cpp"
 
-uint8  bDSP::read_8  (uint16 addr) { return (spcram[addr]); }
-uint16 bDSP::read_16 (uint16 addr) { return (spcram[(addr + 1) & 0xffff] << 8) + (spcram[addr]); }
-void   bDSP::write_8 (uint16 addr, uint8 data)  { spcram[addr] = data; }
-void   bDSP::write_16(uint16 addr, uint16 data) { spcram[addr++] = data; spcram[addr] = data >> 8; }
+uint8  bDSP::readb(uint16 addr) {
+  return spcram[addr];
+}
+
+void bDSP::writeb(uint16 addr, uint8 data) {
+  spcram[addr] = data;
+}
+
+uint16 bDSP::readw(uint16 addr) {
+  return (readb(addr)) | (readb(addr + 1) << 8);
+}
+
+void bDSP::writew(uint16 addr, uint16 data) {
+  writeb(addr,     data);
+  writeb(addr + 1, data >> 8);
+}
 
 uint8 bDSP::read(uint8 addr) {
 int i, v, n;
@@ -98,12 +110,14 @@ int i, v, n;
     break;
   case 0x04:case 0x14:case 0x24:case 0x34:
   case 0x44:case 0x54:case 0x64:case 0x74:
-  //voice[v].SRCN = data;
+    voice[v].SRCN = data;
+    break;
   //below is anomie's code, but TRAC says writing SRCN doesn't affect anything until a
   //BRR-with-end block is encountered, where it loads the loop address from the new SRCN
+  //anomie's code breaks MK2 sound completely...
     if(voice[v].SRCN != data) {
-      voice[v].SRCN = data;
-      voice[v].brr_ptr   = read_16((status.DIR << 8) + (voice[v].SRCN << 2) + ((voice[v].brr_looped)?2:0));
+      voice[v].SRCN      = data;
+      voice[v].brr_ptr   = readw((status.DIR << 8) + (voice[v].SRCN << 2) + ((voice[v].brr_looped) ? 2 : 0));
       voice[v].brr_index = 0;
     }
     break;
@@ -144,18 +158,18 @@ int i, v, n;
   case 0x3c:status.EVOLR = data;break;
 
   case 0x4c:
-    status.KON = data;
-//  status.kon = data;
+    status.KON      = data;
+    status.kon      = data;
     status.key_flag = true;
     break;
 
   case 0x5c:
-    status.KOFF = data;
+    status.KOFF     = data;
     status.key_flag = true;
     break;
 
   case 0x6c:
-    status.FLG = data;
+    status.FLG        = data;
     status.key_flag   = true;
     status.noise_rate = RateTable[data & 0x1f];
     break;
@@ -165,15 +179,15 @@ int i, v, n;
     status.ENDX = 0;
     break;
 
-  case 0x0d:status.EFB   = data;break;
-  case 0x2d:status.PMON  = data;break;
-  case 0x3d:status.NON   = data;break;
-  case 0x4d:status.EON   = data;break;
-  case 0x5d:status.DIR   = data;break;
-  case 0x6d:status.ESA   = data;break;
+  case 0x0d:status.EFB  = data;break;
+  case 0x2d:status.PMON = data;break;
+  case 0x3d:status.NON  = data;break;
+  case 0x4d:status.EON  = data;break;
+  case 0x5d:status.DIR  = data;break;
+  case 0x6d:status.ESA  = data;break;
 
   case 0x7d:
-    status.EDL = data;
+    status.EDL       = data;
     status.echo_size = (data & 0x0f) << 11;
     break;
   }
@@ -221,7 +235,7 @@ int v;
   status.KOFF  = 0x00;
   status.FLG  |= 0xe0;
 
-//status.kon      = 0x00;
+  status.kon      = 0x00;
   status.key_flag = false;
 
   status.noise_ctr    = 0;
@@ -238,7 +252,7 @@ int v;
     voice[v].pitch_ctr = 0;
 
     voice[v].brr_index      = 0;
-    voice[v].brr_ptr        = read_16((status.DIR << 8) + (voice[v].SRCN << 2));
+    voice[v].brr_ptr        = readw((status.DIR << 8) + (voice[v].SRCN << 2));
     voice[v].brr_looped     = false;
     voice[v].brr_data[0]    = 0;
     voice[v].brr_data[1]    = 0;
@@ -288,7 +302,9 @@ int32 esamplel, esampler;
 int32 fir_samplel, fir_sampler;
   pmon = status.PMON & ~status.NON & ~1;
 
-  if(!(dsp_counter++ & 1) && status.key_flag) {
+//if(!(dsp_counter++ & 1) && status.key_flag) {
+//TRAC believes KON/KOFF is polled every sample. further testing is needed
+  if(status.key_flag) {
     for(v=0;v<8;v++) {
     uint8 mask = 1 << v;
       if(status.soft_reset()) {
@@ -301,10 +317,12 @@ int32 fir_samplel, fir_sampler;
           voice[v].env_state = RELEASE;
           voice[v].AdjustEnvelope();
         }
-      } else if(status.KON & mask) { //status.kon
-        status.KON  &= ~mask; //new code
-        status.ENDX &= ~mask; //new code
-        voice[v].brr_ptr     = read_16((status.DIR << 8) + (voice[v].SRCN << 2));
+      } else if(status.kon & mask) {
+      //new KON code
+        status.ENDX &= ~mask;
+        status.kon  &= ~mask;
+
+        voice[v].brr_ptr     = readw((status.DIR << 8) + (voice[v].SRCN << 2));
         voice[v].brr_index   = -9;
         voice[v].brr_looped  = false;
         voice[v].brr_data[0] = 0;
@@ -316,7 +334,8 @@ int32 fir_samplel, fir_sampler;
         voice[v].AdjustEnvelope();
       }
     }
-//  status.ENDX &= ~status.kon;
+//old KON code, breaks sound effects in DL / SFA2
+//  status.ENDX    &= ~status.kon;
 //  status.kon      = 0;
     status.key_flag = false;
   }
@@ -359,7 +378,7 @@ int32 fir_samplel, fir_sampler;
       voice[v].brr_data_index &= 3;
 
       if(voice[v].brr_index == 0) {
-        voice[v].brr_header = read_8(voice[v].brr_ptr);
+        voice[v].brr_header = readb(voice[v].brr_ptr);
 
         if(voice[v].brr_header_flags() & BRR_END) {
           status.ENDX |= (1 << v);
@@ -373,7 +392,7 @@ int32 fir_samplel, fir_sampler;
 
 #define S(x) voice[v].brr_data[(voice[v].brr_data_index + (x)) & 3]
       if(voice[v].env_state != SILENCE) {
-        sample = read_8(voice[v].brr_ptr + 1 + (voice[v].brr_index >> 1));
+        sample = readb(voice[v].brr_ptr + 1 + (voice[v].brr_index >> 1));
         if(voice[v].brr_index & 1) {
           sample = clip(4, sample);
         } else {
@@ -410,7 +429,7 @@ int32 fir_samplel, fir_sampler;
       if(++voice[v].brr_index > 15) {
         voice[v].brr_index = 0;
         if(voice[v].brr_header_flags() & BRR_END) {
-          voice[v].brr_ptr    = read_16((status.DIR << 8) + (voice[v].SRCN << 2) + 2);
+          voice[v].brr_ptr    = readw((status.DIR << 8) + (voice[v].SRCN << 2) + 2);
           voice[v].brr_looped = true;
         } else {
           voice[v].brr_ptr   += 9;
@@ -496,7 +515,7 @@ int32 fir_samplel, fir_sampler;
 
   //gaussian interpolation / noise
     if(status.NON & (1 << v)) {
-      sample = status.noise_sample;
+      sample  = clip(15, status.noise_sample);
     } else {
       d = voice[v].pitch_ctr >> 4; //-256 <= sample <= -1
       sample  = ((GaussTable[ -1-d] * S(-3)) >> 11);
@@ -527,8 +546,8 @@ int32 fir_samplel, fir_sampler;
 //echo (FIR) adjust
 #define F(c,x) status.fir_buffer[c][(status.fir_buffer_index+(x)) & 7]
   status.fir_buffer_index++;
-  F(0,0) = read_16((status.ESA << 8) + status.echo_index);
-  F(1,0) = read_16((status.ESA << 8) + status.echo_index + 2);
+  F(0,0) = readw((status.ESA << 8) + status.echo_index);
+  F(1,0) = readw((status.ESA << 8) + status.echo_index + 2);
 
   fir_samplel = (F(0,-0) * status.FIR[7] +
                  F(0,-1) * status.FIR[6] +
@@ -557,8 +576,8 @@ int32 fir_samplel, fir_sampler;
     esamplel = clamp(16, esamplel);
     esampler = clamp(16, esampler);
 
-    write_16((status.ESA << 8) + status.echo_index,     esamplel);
-    write_16((status.ESA << 8) + status.echo_index + 2, esampler);
+    writew((status.ESA << 8) + status.echo_index,     esamplel);
+    writew((status.ESA << 8) + status.echo_index + 2, esampler);
   }
 
   status.echo_index += 4;
diff --git a/src/dsp/bdsp/bdsp.h b/src/dsp/bdsp/bdsp.h
index dfed7bac..bc07632a 100644
--- a/src/dsp/bdsp/bdsp.h
+++ b/src/dsp/bdsp/bdsp.h
@@ -10,10 +10,10 @@ enum {
   BRR_LOOP = 2
 };
 
-uint8  read_8  (uint16 addr);
-uint16 read_16 (uint16 addr);
-void   write_8 (uint16 addr, uint8 data);
-void   write_16(uint16 addr, uint16 data);
+uint8  readb (uint16 addr);
+uint16 readw (uint16 addr);
+void   writeb(uint16 addr, uint8  data);
+void   writew(uint16 addr, uint16 data);
 
 public:
 static const uint16 RateTable[32];
@@ -63,7 +63,7 @@ struct Status {
   int8   FIR[8];
 
 //internal variables
-//uint8  kon;
+  uint8  kon;
   bool   key_flag;
 
   int16  noise_ctr, noise_rate;
diff --git a/src/dsp/dsp.h b/src/dsp/dsp.h
index af495adb..892a4ac1 100644
--- a/src/dsp/dsp.h
+++ b/src/dsp/dsp.h
@@ -6,4 +6,7 @@ public:
   virtual void   power() = 0;
   virtual void   reset() = 0;
   virtual uint32 run()   = 0;
+
+  DSP() {}
+  virtual ~DSP() {}
 };
diff --git a/src/interface.h b/src/interface.h
index 28fc434a..d15ed2fb 100644
--- a/src/interface.h
+++ b/src/interface.h
@@ -1,4 +1,4 @@
-#define BSNES_VERSION "0.014"
+#define BSNES_VERSION "0.015"
 #define BSNES_TITLE "bsnes v" BSNES_VERSION
 
 #ifdef POLYMORPHISM
@@ -15,6 +15,7 @@
 #define r_ppu ref(deref(ppu))
 
 #include "reader/reader.h"
+#include "cart/cart.h"
 
 #include "memory/memory.h"
 #include "memory/bmemory/bmemory.h"
@@ -35,6 +36,7 @@
 
 #include "chip/srtc/srtc.h"
 #include "chip/sdd1/sdd1.h"
+#include "chip/c4/c4.h"
 
 extern MMIO mmio_unmapped;
 #ifdef POLYMORPHISM
@@ -54,10 +56,12 @@ extern SNES *snes;
 
 extern SRTC *srtc;
 extern SDD1 *sdd1;
+extern C4   *c4;
 
 #include "config/config.h"
 
 #ifdef INTERFACE_MAIN
+Cartridge cartridge;
 
 #include "config/config.cpp"
 #ifdef POLYMORPHISM
@@ -77,5 +81,6 @@ SNES *snes;
 
 SRTC *srtc;
 SDD1 *sdd1;
+C4   *c4;
 
 #endif
diff --git a/src/lib/libbase.h b/src/lib/libbase.h
index b203d073..2bfbed6b 100644
--- a/src/lib/libbase.h
+++ b/src/lib/libbase.h
@@ -20,20 +20,23 @@
 
 #define zerofree(__n) if(__n) { free(__n); __n = 0; }
 
-typedef unsigned int   uint;
+typedef unsigned int       uint;
 
-typedef unsigned char  byte;
-typedef unsigned short word;
-typedef unsigned long  ulong;
+typedef unsigned char      byte;
+typedef unsigned short     word;
+typedef unsigned long      ulong;
+typedef unsigned long long uquad;
 
-typedef unsigned char  bool8;
-typedef unsigned char  uint8;
-typedef unsigned short uint16;
-typedef unsigned long  uint32;
+typedef unsigned char      bool8;
+typedef unsigned char      uint8;
+typedef unsigned short     uint16;
+typedef unsigned long      uint32;
+typedef unsigned long long uint64;
 
-typedef signed char    int8;
-typedef signed short   int16;
-typedef signed long    int32;
+typedef signed char        int8;
+typedef signed short       int16;
+typedef signed long        int32;
+typedef signed long long   int64;
 
 #ifdef null
 #undef null
diff --git a/src/lib/libconfig.cpp b/src/lib/libconfig.cpp
index f772619e..08157d98 100644
--- a/src/lib/libconfig.cpp
+++ b/src/lib/libconfig.cpp
@@ -19,6 +19,15 @@ void Setting::set(uint _data) {
   }
 }
 
+char *Setting::sget() {
+  return strptr(char_data);
+}
+
+void Setting::sset(const char *_data) {
+  strcpy(char_data, _data);
+  strunquote(char_data);
+}
+
 Setting::Setting(Config *_parent, char *_name, char *_desc, uint _data, uint _type) {
 int s;
   if(_parent) {
@@ -43,28 +52,53 @@ int s;
   type = _type;
 }
 
+Setting::Setting(Config *_parent, char *_name, char *_desc, char *_data) {
+int s;
+  if(_parent) {
+    _parent->add(this);
+  }
+
+  s = strlen(_name);
+  name = (char*)malloc(s + 1);
+  strcpy(name, _name);
+
+  if(_desc) {
+    s = strlen(_desc);
+    desc = (char*)malloc(s + 1);
+    strcpy(desc, _desc);
+  } else {
+    desc = (char*)malloc(1);
+    *desc = 0;
+  }
+
+  strcpy(char_data, _data);
+  strcpy(char_def,  _data);
+
+  type = STR;
+}
+
 void Config::add(Setting *setting) {
   list[list_count++] = setting;
 }
 
 uint Config::string_to_uint(uint type, char *input) {
-  if(!strcmp(input, "true") ||
-     !strcmp(input, "enabled") ||
-     !strcmp(input, "on") ||
-     !strcmp(input, "yes")
+  if(strmatch(input, "true") ||
+     strmatch(input, "enabled") ||
+     strmatch(input, "on") ||
+     strmatch(input, "yes")
   ) {
     return (uint)true;
   }
 
-  if(!strcmp(input, "false") ||
-     !strcmp(input, "disabled") ||
-     !strcmp(input, "off") ||
-     !strcmp(input, "no")
+  if(strmatch(input, "false") ||
+     strmatch(input, "disabled") ||
+     strmatch(input, "off") ||
+     strmatch(input, "no")
   ) {
     return (uint)false;
   }
 
-  if(!strbegin(input, "0x")) {
+  if(strbegin(input, "0x")) {
     return strhex(input + 2);
   }
 
@@ -75,16 +109,16 @@ char *Config::uint_to_string(uint type, uint input) {
 static char output[512];
   switch(type) {
   case Setting::TRUE_FALSE:
-    sprintf(output, "%s", (input & 1)?"true":"false");
+    sprintf(output, "%s", (input & 1) ? "true" : "false");
     break;
   case Setting::ENABLED_DISABLED:
-    sprintf(output, "%s", (input & 1)?"enabled":"disabled");
+    sprintf(output, "%s", (input & 1) ? "enabled" : "disabled");
     break;
   case Setting::ON_OFF:
-    sprintf(output, "%s", (input & 1)?"on":"off");
+    sprintf(output, "%s", (input & 1) ? "on" : "off");
     break;
   case Setting::YES_NO:
-    sprintf(output, "%s", (input & 1)?"yes":"no");
+    sprintf(output, "%s", (input & 1) ? "yes" : "no");
     break;
   case Setting::DEC:
     sprintf(output, "%d", input);
@@ -119,14 +153,18 @@ char *buffer = (char*)malloc(fsize + 1);
   qreplace(data, " ", "");
   split(line, "\n", data);
 
-  for(int i=0;i<count(line);i++) {
+  for(int i = 0; i < count(line); i++) {
     if(strlen(line[i]) == 0)continue;
     if(*strptr(line[i]) == '#')continue;
 
-    split(part, "=", line[i]);
-    for(int l=0;l<list_count;l++) {
-      if(!strcmp(list[l]->name, part[0])) {
-        list[l]->set(string_to_uint(list[l]->type, strptr(part[1])));
+    qsplit(part, "=", line[i]);
+    for(int l = 0; l < list_count; l++) {
+      if(strmatch(list[l]->name, part[0])) {
+        if(list[l]->type != Setting::STR) {
+          list[l]->set(string_to_uint(list[l]->type, strptr(part[1])));
+        } else {
+          list[l]->sset(strptr(part[1]));
+        }
       }
     }
   }
@@ -140,15 +178,20 @@ FILE *fp;
   fp = fopen(fn, "wb");
   if(!fp)return false;
 
-  for(int i=0;i<list_count;i++) {
+  for(int i = 0; i < list_count; i++) {
     strcpy(data, list[i]->desc);
     replace(data, "\r\n", "\n");
     split(line, "\n", data);
-    for(int l=0;l<count(line);l++) {
+    for(int l = 0; l < count(line); l++) {
       fprintf(fp, "# %s\r\n", strptr(line[l]));
     }
-    fprintf(fp, "# (default = %s)\r\n", uint_to_string(list[i]->type, list[i]->def));
-    fprintf(fp, "%s = %s\r\n\r\n", list[i]->name, uint_to_string(list[i]->type, list[i]->data));
+    if(list[i]->type != Setting::STR) {
+      fprintf(fp, "# (default = %s)\r\n", uint_to_string(list[i]->type, list[i]->def));
+      fprintf(fp, "%s = %s\r\n\r\n", list[i]->name, uint_to_string(list[i]->type, list[i]->data));
+    } else {
+      fprintf(fp, "# (default = \"%s\")\r\n", strptr(list[i]->char_def));
+      fprintf(fp, "%s = \"%s\"\r\n\r\n", list[i]->name, strptr(list[i]->char_data));
+    }
   }
 
   return true;
diff --git a/src/lib/libconfig.h b/src/lib/libconfig.h
index bec3ef9c..2cb2316a 100644
--- a/src/lib/libconfig.h
+++ b/src/lib/libconfig.h
@@ -1,5 +1,5 @@
 /*
-  libconfig : version 0.05 ~byuu (09/13/05)
+  libconfig : version 0.05 ~byuu (10/30/05)
 */
 
 #ifndef __LIBCONFIG
@@ -28,6 +28,8 @@ class Config;
   inline __name &operator=(const int8   _data) { set(_data); return *this; } \
   inline __name &operator=(const int16  _data) { set(_data); return *this; } \
   inline __name &operator=(const int32  _data) { set(_data); return *this; } \
+  inline __name &operator=(const float  _data) { set((uint)_data); return *this; } \
+  inline __name &operator=(const double _data) { set((uint)_data); return *this; } \
   void toggle() { data ^= 1; set(data); } \
   __name(Config *_parent, char *_name, char *_desc = 0, uint _data = 0, uint _type = Setting::DEC) : \
   Setting(_parent, _name, _desc, _data, _type) {}
@@ -46,14 +48,20 @@ enum {
   YES_NO,
   BOOL,
   DEC,
-  HEX
+  HEX,
+  STR
 };
 char *name, *desc;
-  virtual void toggle();
-  virtual uint get();
-  virtual void set(uint _data);
+substring char_data, char_def;
+  virtual void  toggle();
+  virtual uint  get();
+  virtual void  set(uint _data);
 
-  Setting(Config *_parent, char *_name, char *_desc = 0, uint _data = 0, uint _type = DEC);
+  virtual char *sget();
+  virtual void  sset(const char *_data);
+
+  Setting(Config *_parent, char *_name, char *_desc, uint  _data, uint _type);
+  Setting(Config *_parent, char *_name, char *_desc, char *_data);
 
   inline operator bool()   { return (bool)get(); }
   inline operator uint()   { return get(); }
@@ -64,6 +72,8 @@ char *name, *desc;
   inline operator int8()   { return get(); }
   inline operator int16()  { return get(); }
   inline operator int32()  { return get(); }
+  inline operator float()  { return (float) get(); }
+  inline operator double() { return (double)get(); }
 
   inline Setting &operator=(const bool   _data) { set((uint)_data); return *this; }
   inline Setting &operator=(const uint   _data) { set(_data); return *this; }
@@ -74,6 +84,8 @@ char *name, *desc;
   inline Setting &operator=(const int8   _data) { set(_data); return *this; }
   inline Setting &operator=(const int16  _data) { set(_data); return *this; }
   inline Setting &operator=(const int32  _data) { set(_data); return *this; }
+  inline Setting &operator=(const float  _data) { set((uint)_data); return *this; }
+  inline Setting &operator=(const double _data) { set((uint)_data); return *this; }
 };
 
 class Config {
diff --git a/src/lib/libstring.cpp b/src/lib/libstring.cpp
index 288541d9..1a193684 100644
--- a/src/lib/libstring.cpp
+++ b/src/lib/libstring.cpp
@@ -64,6 +64,28 @@ int strcmp(substring &dest, const char *src) { return strcmp(strptr(dest), src);
 int strcmp(const char *dest, substring &src) { return strcmp(dest, strptr(src)); }
 int strcmp(substring &dest, substring &src) { return strcmp(strptr(dest), strptr(src)); }
 
+int __stricmp(const char *dest, const char *src) {
+  while(*dest && *src) {
+    if(chrlower(*dest) != chrlower(*src))break;
+    dest++;
+    src++;
+  }
+  return (int)chrlower(*dest) - (int)chrlower(*src);
+}
+int stricmp(substring &dest, const char *src) { return __stricmp(strptr(dest), src); }
+int stricmp(const char *dest, substring &src) { return __stricmp(dest, strptr(src)); }
+int stricmp(substring &dest, substring &src) { return __stricmp(strptr(dest), strptr(src)); }
+
+bool strmatch(const char *dest, const char *src) { return !strcmp(dest, src); }
+bool strmatch(substring &dest, const char *src) { return strmatch(strptr(dest), src); }
+bool strmatch(const char *dest, substring &src) { return strmatch(dest, strptr(src)); }
+bool strmatch(substring &dest, substring &src) { return strmatch(strptr(dest), strptr(src)); }
+
+bool strimatch(const char *dest, const char *src) { return !stricmp(dest, src); }
+bool strimatch(substring &dest, const char *src) { return strimatch(strptr(dest), src); }
+bool strimatch(const char *dest, substring &src) { return strimatch(dest, strptr(src)); }
+bool strimatch(substring &dest, substring &src) { return strimatch(strptr(dest), strptr(src)); }
+
 void strcpy(substring &dest, const char *src) {
 int srclen = strlen(src);
   if(srclen > dest.size) { strresize(dest, srclen); }
@@ -109,18 +131,6 @@ int i, sl = strlen(dest.s);
   s[i] = 0;
 }
 
-int __stricmp(const char *dest, const char *src) {
-  while(*dest && *src) {
-    if(chrlower(*dest) != chrlower(*src))break;
-    dest++;
-    src++;
-  }
-  return (int)chrlower(*dest) - (int)chrlower(*src);
-}
-int stricmp(substring &dest, const char *src) { return __stricmp(strptr(dest), src); }
-int stricmp(const char *dest, substring &src) { return __stricmp(dest, strptr(src)); }
-int stricmp(substring &dest, substring &src) { return __stricmp(strptr(dest), strptr(src)); }
-
 void strlower(char *str) {
   while(*str) {
     *str = chrlower(*str);
@@ -137,40 +147,44 @@ void strupper(char *str) {
 }
 void strupper(substring &str) { strupper(strptr(str)); }
 
-uint strpos(const char *str, const char *key) {
+bool strpos(const char *str, const char *key, uint &pos) {
 int i, ssl = strlen(str), ksl = strlen(key);
-  if(ksl > ssl)return null;
-  for(i=0;i<=ssl-ksl;i++) {
-    if(!memcmp(str+i, key, ksl))return i;
+  if(ksl > ssl)return false;
+  for(i = 0; i <= ssl - ksl; i++) {
+    if(!memcmp(str + i, key, ksl)) {
+      pos = i;
+      return true;
+    }
   }
-  return null;
+  return false;
 }
-uint strpos(substring &str, const char *key) { return strpos(strptr(str), key); }
-uint strpos(const char *str, substring &key) { return strpos(str, strptr(key)); }
-uint strpos(substring &str, substring &key) { return strpos(strptr(str), strptr(key)); }
+bool strpos(substring &str, const char *key, uint &pos) { return strpos(strptr(str), key, pos); }
+bool strpos(const char *str, substring &key, uint &pos) { return strpos(str, strptr(key), pos); }
+bool strpos(substring &str, substring &key, uint &pos) { return strpos(strptr(str), strptr(key), pos); }
 
-uint qstrpos(const char *str, const char *key) {
+bool qstrpos(const char *str, const char *key, uint &pos) {
 int i, z, ssl = strlen(str), ksl = strlen(key);
 uint8 x;
-  if(ksl > ssl)return null;
-  for(i=0;i<=ssl-ksl;) {
+  if(ksl > ssl)return false;
+  for(i = 0; i <= ssl - ksl;) {
     x = str[i];
     if(x == '\"' || x == '\'') {
       z = i++;
       while(str[i] != x && i < ssl)i++;
       if(i >= ssl)i = z;
     }
-    if(!memcmp(str+i, key, ksl)) {
-      return i;
+    if(!memcmp(str + i, key, ksl)) {
+      pos = i;
+      return true;
     } else {
       i++;
     }
   }
-  return null;
+  return false;
 }
-uint qstrpos(substring &str, const char *key) { return qstrpos(strptr(str), key); }
-uint qstrpos(const char *str, substring &key) { return qstrpos(str, strptr(key)); }
-uint qstrpos(substring &str, substring &key) { return qstrpos(strptr(str), strptr(key)); }
+bool qstrpos(substring &str, const char *key, uint &pos) { return qstrpos(strptr(str), key, pos); }
+bool qstrpos(const char *str, substring &key, uint &pos) { return qstrpos(str, strptr(key), pos); }
+bool qstrpos(substring &str, substring &key, uint &pos) { return qstrpos(strptr(str), strptr(key), pos); }
 
 void strtr(char *dest, const char *before, const char *after) {
 int i, l, sl = strlen(dest), bsl = strlen(before), asl = strlen(after);
@@ -183,53 +197,51 @@ int i, l, sl = strlen(dest), bsl = strlen(before), asl = strlen(after);
 }
 void strtr(substring &dest, const char *before, const char *after) { strtr(strptr(dest), before, after); }
 
-uint strbegin(const char *str, const char *key) {
+bool strbegin(const char *str, const char *key) {
 int i, ssl = strlen(str), ksl = strlen(key);
-  if(ksl > ssl)return 1;
-  if(!memcmp(str, key, ksl))return 0;
-  return 1;
+  if(ksl > ssl)return false;
+  return (!memcmp(str, key, ksl));
 }
-uint strbegin(substring &str, const char *key) { return strbegin(strptr(str), key); }
+bool strbegin(substring &str, const char *key) { return strbegin(strptr(str), key); }
 
-uint stribegin(const char *str, const char *key) {
+bool stribegin(const char *str, const char *key) {
 int i, ssl = strlen(str), ksl = strlen(key);
-  if(ksl > ssl)return 1;
+  if(ksl > ssl)return false;
   for(i=0;i<ksl;i++) {
     if(str[i] >= 'A' && str[i] <= 'Z') {
-      if(str[i] != key[i] && str[i]+0x20 != key[i])return 1;
+      if(str[i] != key[i] && str[i]+0x20 != key[i])return false;
     } else if(str[i] >= 'a' && str[i] <= 'z') {
-      if(str[i] != key[i] && str[i]-0x20 != key[i])return 1;
+      if(str[i] != key[i] && str[i]-0x20 != key[i])return false;
     } else {
-      if(str[i] != key[i])return 1;
+      if(str[i] != key[i])return false;
     }
   }
-  return 0;
+  return true;
 }
-uint stribegin(substring &str, const char *key) { return stribegin(strptr(str), key); }
+bool stribegin(substring &str, const char *key) { return stribegin(strptr(str), key); }
 
-uint strend(const char *str, const char *key) {
+bool strend(const char *str, const char *key) {
 int i, ssl = strlen(str), ksl = strlen(key);
-  if(ksl > ssl)return 1;
-  if(!memcmp(str + ssl - ksl, key, ksl))return 0;
-  return 1;
+  if(ksl > ssl)return false;
+  return (!memcmp(str + ssl - ksl, key, ksl));
 }
-uint strend(substring &str, const char *key) { return strend(strptr(str), key); }
+bool strend(substring &str, const char *key) { return strend(strptr(str), key); }
 
-uint striend(const char *str, const char *key) {
+bool striend(const char *str, const char *key) {
 int i, z, ssl = strlen(str), ksl = strlen(key);
-  if(ksl > ssl)return 1;
+  if(ksl > ssl)return false;
   for(i=ssl-ksl, z=0;i<ssl;i++, z++) {
     if(str[i] >= 'A' && str[i] <= 'Z') {
-      if(str[i] != key[z] && str[i]+0x20 != key[z])return 1;
+      if(str[i] != key[z] && str[i]+0x20 != key[z])return false;
     } else if(str[i] >= 'a' && str[i] <= 'z') {
-      if(str[i] != key[z] && str[i]-0x20 != key[z])return 1;
+      if(str[i] != key[z] && str[i]-0x20 != key[z])return false;
     } else {
-      if(str[i] != key[z])return 1;
+      if(str[i] != key[z])return false;
     }
   }
-  return 0;
+  return true;
 }
-uint striend(substring &str, const char *key) { return striend(strptr(str), key); }
+bool striend(substring &str, const char *key) { return striend(strptr(str), key); }
 
 void strltrim(char *str, const char *key) {
 int i, ssl = strlen(str), ksl = strlen(key);
diff --git a/src/lib/libstring.h b/src/lib/libstring.h
index 508662a6..0348d22d 100644
--- a/src/lib/libstring.h
+++ b/src/lib/libstring.h
@@ -1,5 +1,5 @@
 /*
-  libstring : version 0.06a ~byuu (08/22/05)
+  libstring : version 0.07 ~byuu (11/30/05)
 */
 
 #ifndef __LIBSTRING
@@ -25,6 +25,25 @@ int   strcmp(substring &dest, const char *src);
 int   strcmp(const char *dest, substring &src);
 int   strcmp(substring &dest, substring &src);
 
+//vc6/win32 and gcc/dos only support stricmp, whereas
+//gcc/unix only supports strcasecmp. this is an attempt
+//to avoid platform-specific defines...
+#define stricmp __stricmp
+int   __stricmp(const char *dest, const char *src);
+int   stricmp(substring &dest, const char *src);
+int   stricmp(const char *dest, substring &src);
+int   stricmp(substring &dest, substring &src);
+
+bool  strmatch(const char *dest, const char *src);
+bool  strmatch(substring &dest, const char *src);
+bool  strmatch(const char *dest, substring &src);
+bool  strmatch(substring &dest, substring &src);
+
+bool  strimatch(const char *dest, const char *src);
+bool  strimatch(substring &dest, const char *src);
+bool  strimatch(const char *dest, substring &src);
+bool  strimatch(substring &dest, substring &src);
+
 void  strcpy(substring &dest, const char *src);
 void  strcpy(substring &dest, substring &src);
 
@@ -38,45 +57,36 @@ void  strinsert(substring &dest, substring &src, uint pos);
 
 void  strremove(substring &dest, uint start, uint length = 0);
 
-//vc6/win32 and gcc/dos only support stricmp, whereas
-//gcc/unix only supports strcasecmp. this is an attempt
-//to avoid platform-specific defines...
-#define stricmp __stricmp
-int   __stricmp(const char *dest, const char *src);
-int   stricmp(substring &dest, const char *src);
-int   stricmp(const char *dest, substring &src);
-int   stricmp(substring &dest, substring &src);
-
 void  strlower(char *str);
 void  strlower(substring &str);
 
 void  strupper(char *str);
 void  strupper(substring &str);
 
-uint  strpos(const char *str, const char *key);
-uint  strpos(substring &str, const char *key);
-uint  strpos(const char *str, substring &key);
-uint  strpos(substring &str, substring &key);
+bool  strpos(const char *str, const char *key, uint &pos);
+bool  strpos(substring &str, const char *key, uint &pos);
+bool  strpos(const char *str, substring &key, uint &pos);
+bool  strpos(substring &str, substring &key, uint &pos);
 
-uint  qstrpos(const char *str, const char *key);
-uint  qstrpos(substring &str, const char *key);
-uint  qstrpos(const char *str, substring &key);
-uint  qstrpos(substring &str, substring &key);
+bool  qstrpos(const char *str, const char *key, uint &pos);
+bool  qstrpos(substring &str, const char *key, uint &pos);
+bool  qstrpos(const char *str, substring &key, uint &pos);
+bool  qstrpos(substring &str, substring &key, uint &pos);
 
 void  strtr(char *dest, const char *before, const char *after);
 void  strtr(substring &dest, const char *before, const char *after);
 
-uint  strbegin(const char *str, const char *key);
-uint  strbegin(substring &str, const char *key);
+bool  strbegin(const char *str, const char *key);
+bool  strbegin(substring &str, const char *key);
 
-uint  stribegin(const char *str, const char *key);
-uint  stribegin(substring &str, const char *key);
+bool  stribegin(const char *str, const char *key);
+bool  stribegin(substring &str, const char *key);
 
-uint  strend(const char *str, const char *key);
-uint  strend(substring &str, const char *key);
+bool  strend(const char *str, const char *key);
+bool  strend(substring &str, const char *key);
 
-uint  striend(const char *str, const char *key);
-uint  striend(substring &str, const char *key);
+bool  striend(const char *str, const char *key);
+bool  striend(substring &str, const char *key);
 
 void  strltrim(char *str, const char *key);
 void  strltrim(substring &str, const char *key);
diff --git a/src/memory/bmemory/bcart_lorom.cpp b/src/memory/bmemory/bcart_lorom.cpp
index 59e43946..c195837b 100644
--- a/src/memory/bmemory/bcart_lorom.cpp
+++ b/src/memory/bmemory/bcart_lorom.cpp
@@ -6,6 +6,12 @@ uint32 b, w;
   b = (addr >> 16);
   w = (addr & 0xffff);
 
+  if(cartridge.cart.c4) {
+    if(!(b & 0x40) && w >= 0x6000 && w <= 0x7fff) {
+      return c4->read(w);
+    }
+  }
+
 //SRAM Region A
   if((b & 0x7f) >= 0x30 && (b & 0x7f) <= 0x3f && (w & 0xe000) == 0x6000) {
     b &= 0x7f;
@@ -57,6 +63,13 @@ uint32 b, w;
   b = (addr >> 16);
   w = (addr & 0xffff);
 
+  if(cartridge.cart.c4) {
+    if(!(b & 0x40) && w >= 0x6000 && w <= 0x7fff) {
+      c4->write(w, value);
+      return;
+    }
+  }
+
 //SRAM Region A
   if((b & 0x7f) >= 0x30 && (b & 0x7f) <= 0x3f && (w & 0xe000) == 0x6000) {
     b &= 0x7f;
diff --git a/src/memory/bmemory/bmemory.cpp b/src/memory/bmemory/bmemory.cpp
index de003674..da4f816b 100644
--- a/src/memory/bmemory/bmemory.cpp
+++ b/src/memory/bmemory/bmemory.cpp
@@ -4,82 +4,15 @@
 #include "bcart_exlorom.cpp"
 #include "bcart_exhirom.cpp"
 
-bool bMemBus::load_cart(Reader *rf) {
-uint32 cksum, icksum, index;
-char   cart_title[24];
-uint8  mapper, region;
-  if(rom_loaded == true)return false;
+void bMemBus::load_cart() {
+  if(rom_loaded == true)return;
 
-  rf->read(&rom_image);
-  rom = rom_image;
-  rom_size = rf->size();
-
-  if(rom_size < 32768) {
-    zerofree(rom_image);
-    return false;
-  }
-
-//check for ROM header (currently unused)
-  if((rom_size & 0x1fff) == 0x0200) {
-    rom_size -= 512;
-    rom += 512;
-  }
-
-  if(rom_size >= 0x410000) {
-    if(rom[0x7fd5] == 0x32) {
-      mapper = EXLOROM;
-    } else {
-      mapper = EXHIROM;
-    }
-    goto end;
-  }
-
-  if(rom_size < 65536) {
-    mapper = LOROM;
-    goto end;
-  }
-
-  cksum  = rom[0xffdc] | (rom[0xffdd] << 8);
-  icksum = rom[0xffde] | (rom[0xffdf] << 8);
-  if(cksum + icksum == 0xffff) {
-    mapper = HIROM;
-  } else {
-    mapper = LOROM;
-  }
-
-  if(rom[0x7fd5] == 0x32 && rom[0xffd5] == 0x32) {
-  //SFA2 detected
-    mapper = EXLOROM;
-    goto end;
-  }
-
-end:
-  switch(mapper) {
-  case LOROM:  index = 0x007fc0;break;
-  case HIROM:  index = 0x00ffc0;break;
-  case EXLOROM:index = 0x007fc0;break;
-  case EXHIROM:index = 0x40ffc0;break;
-  }
-  memcpy(cart_title, (char*)rom + index, 21);
-  cart_title[21] = 0;
-
-  switch(rom[index + 0x18] & 7) {
-  case 0:sram_size =   0;       break;
-  case 1:sram_size =   2 * 1024;break;
-  case 2:sram_size =   4 * 1024;break;
-  case 3:sram_size =   8 * 1024;break;
-  case 4:sram_size =  16 * 1024;break;
-  case 5:sram_size =  32 * 1024;break;
-  case 6:sram_size =  64 * 1024;break;
-  case 7:sram_size = 128 * 1024;break;
-  }
-
-  region = rom[index + 0x19];
-
-  dprintf("* Image Name : \"%s\"", cart_title);
-  dprintf("* Region     : %s", (region <= 1) ? "NTSC" : "PAL");
-  dprintf("* MAD        : %0.2x", mapper);
-  dprintf("* SRAM Size  : %dkb", sram_size / 1024);
+uint8 *rom   = cartridge.rom;
+uint16 index = cartridge.cart.header_index;
+  dprintf("* Image Name : \"%s\"", cartridge.cart.name);
+  dprintf("* Region     : %s", (cartridge.cart.region == Cartridge::NTSC) ? "NTSC" : "PAL");
+  dprintf("* MAD        : %0.2x", cartridge.cart.mapper);
+  dprintf("* SRAM Size  : %dkb", cartridge.cart.sram_size / 1024);
   dprintf("* Reset:%0.4x NMI:%0.4x IRQ:%0.4x BRK[n]:%0.4x COP[n]:%0.4x BRK[e]:%0.4x COP[e]:%0.4x",
     rom[index + 0x3c] | (rom[index + 0x3d] << 8), //Reset
     rom[index + 0x2a] | (rom[index + 0x2b] << 8), //NMI
@@ -92,66 +25,42 @@ end:
   dprintf("");
 
 CartInfo ci;
-  ci.rom       = rom;
-  ci.sram      = sram;
-  ci.rom_size  = rom_size;
-  ci.sram_size = sram_size;
+  ci.rom       = cartridge.rom;
+  ci.sram      = cartridge.sram;
+  ci.rom_size  = cartridge.cart.rom_size;
+  ci.sram_size = cartridge.cart.sram_size;
 
-  switch(mapper) {
-  case LOROM:  cart = new bCartLoROM();  break;
-  case HIROM:  cart = new bCartHiROM();  break;
-  case EXLOROM:cart = new bCartExLoROM();break;
-  case EXHIROM:cart = new bCartExHiROM();break;
-  default:return false;
+  switch(cartridge.cart.mapper) {
+  case Cartridge::LOROM:  cart = new bCartLoROM();  break;
+  case Cartridge::HIROM:  cart = new bCartHiROM();  break;
+  case Cartridge::EXLOROM:cart = new bCartExLoROM();break;
+  case Cartridge::EXHIROM:cart = new bCartExHiROM();break;
+  default:return;
   }
 
   cart->set_cartinfo(&ci);
-  rom_loaded = true;
 
-  if(region == 0 || region == 1) {
+  if(cartridge.cart.region == Cartridge::NTSC) {
     snes->set_region(SNES::NTSC);
   } else {
     snes->set_region(SNES::PAL);
   }
 
-  return true;
-}
-
-bool bMemBus::load_sram(Reader *rf) {
-  if(rom_loaded == false || sram_size == 0)return false;
-  rf->read(&sram, sram_size);
-
-CartInfo ci;
-  ci.rom       = rom;
-  ci.sram      = sram;
-  ci.rom_size  = rom_size;
-  ci.sram_size = sram_size;
-  cart->set_cartinfo(&ci);
-
-  return true;
-}
-
-bool bMemBus::save_sram(Writer *wf) {
-  if(rom_loaded == false || sram_size == 0)return false;
-  wf->write(sram, sram_size);
-  return true;
+  rom_loaded = true;
 }
 
 void bMemBus::unload_cart() {
   if(rom_loaded == false)return;
 
-  if(rom_image)free(rom_image);
-  if(sram)free(sram);
   delete(cart);
-
   rom_loaded = false;
 }
 
 void bMemBus::get_cartinfo(CartInfo *ci) {
-  ci->rom       = rom;
-  ci->sram      = sram;
-  ci->rom_size  = rom_size;
-  ci->sram_size = sram_size;
+  ci->rom       = cartridge.rom;
+  ci->sram      = cartridge.sram;
+  ci->rom_size  = cartridge.cart.rom_size;
+  ci->sram_size = cartridge.cart.sram_size;
 }
 
 /***********************
@@ -171,7 +80,7 @@ void bMemBus::get_cartinfo(CartInfo *ci) {
  ***************************************/
 
 uint8 bMemBus::read(uint32 addr) {
-static uint32 r;
+uint8 r;
   switch(addr & 0xc00000) {
   case 0x400000:
     if((addr & 0xfe0000) == 0x7e0000) {
diff --git a/src/memory/bmemory/bmemory.h b/src/memory/bmemory/bmemory.h
index 992ac956..2469946e 100644
--- a/src/memory/bmemory/bmemory.h
+++ b/src/memory/bmemory/bmemory.h
@@ -11,8 +11,7 @@ public:
 //just a pointer to rom_image (with no header), or
 //rom_image + 512 (if a header is present).
 //rom should never be allocated or released directly.
-uint8 *rom_image, *rom, *sram, *wram;
-uint32 rom_size, sram_size;
+uint8 *wram;
 
 bool rom_loaded;
 enum { LOROM = 0x20, HIROM = 0x21, EXLOROM = 0x22, EXHIROM = 0x25 };
@@ -20,10 +19,9 @@ enum { LOROM = 0x20, HIROM = 0x21, EXLOROM = 0x22, EXHIROM = 0x25 };
   uint8 read (uint32 addr);
   void  write(uint32 addr, uint8 value);
 
-  bool load_cart(Reader *rf);
-  bool load_sram(Reader *rf);
-  bool save_sram(Writer *wf);
+  void load_cart();
   void unload_cart();
+  bool cart_loaded() { return rom_loaded; }
   void get_cartinfo(CartInfo *ci);
 
   void power();
diff --git a/src/memory/memory.cpp b/src/memory/memory.cpp
index c305ac2d..d2e8f8c4 100644
--- a/src/memory/memory.cpp
+++ b/src/memory/memory.cpp
@@ -127,5 +127,3 @@ int i;
   }
   speed_table = (uint8*)speed_table_slowrom;
 }
-
-MemBus::~MemBus() {}
diff --git a/src/memory/memory.h b/src/memory/memory.h
index 7c195169..0d0ab80d 100644
--- a/src/memory/memory.h
+++ b/src/memory/memory.h
@@ -48,15 +48,14 @@ public:
   }
   void set_speed(bool fast);
 
-  virtual bool load_cart(Reader *rf) = 0;
-  virtual bool load_sram(Reader *rf) = 0;
-  virtual bool save_sram(Writer *wf) = 0;
+  virtual void load_cart() = 0;
   virtual void unload_cart() = 0;
+  virtual bool cart_loaded() = 0;
   virtual void get_cartinfo(CartInfo *ci) = 0;
 
   virtual void power() = 0;
   virtual void reset() = 0;
 
   MemBus();
-  ~MemBus();
+  virtual ~MemBus() {}
 };
diff --git a/src/ppu/bppu/Copy of bppu_render_addsub.cpp b/src/ppu/bppu/Copy of bppu_render_addsub.cpp
deleted file mode 100644
index 2a216632..00000000
--- a/src/ppu/bppu/Copy of bppu_render_addsub.cpp	
+++ /dev/null
@@ -1,64 +0,0 @@
-inline uint16 bPPU::addsub_pixels(uint32 cdest, uint32 csrc) {
-  if(!regs.color_mode) {
-  //add
-    cdest = ((cdest << 16) | cdest) & 0x03e07c1f;
-    csrc  = ((csrc  << 16) | csrc)  & 0x03e07c1f;
-    cdest += csrc;
-
-    if(regs.color_halve) {
-      cdest >>= 1;
-    } else {
-      if(cdest & 0x04000000)cdest |= 0x03e00000;
-      if(cdest & 0x00008000)cdest |= 0x00007c00;
-      if(cdest & 0x00000020)cdest |= 0x0000001f;
-    }
-
-    cdest &= 0x03e07c1f;
-    return (cdest >> 16) | cdest;
-  } else {
-  //subtract
-    if((cdest & 0x7c00) < (csrc & 0x7c00))cdest &= ~0x7c00;
-    else cdest -= (csrc & 0x7c00);
-    if((cdest & 0x03e0) < (csrc & 0x03e0))cdest &= ~0x03e0;
-    else cdest -= (csrc & 0x03e0);
-    if((cdest & 0x001f) < (csrc & 0x001f))cdest &= ~0x001f;
-    else cdest -= (csrc & 0x001f);
-
-    return (!regs.color_halve) ? cdest : ((cdest & 0x7bde) >> 1);
-  }
-}
-
-inline uint16 bPPU::addsub_pixel(uint32 cdest) {
-uint32 csrc = regs.color_rgb;
-  if(!regs.color_mode) {
-  //add
-    cdest = ((cdest << 16) | cdest) & 0x03e07c1f;
-    csrc  = ((csrc  << 16) | csrc)  & 0x03e07c1f;
-    cdest += csrc;
-
-    if(regs.color_halve && !regs.addsub_mode) {
-      cdest >>= 1;
-    } else {
-      if(cdest & 0x04000000)cdest |= 0x03e00000;
-      if(cdest & 0x00008000)cdest |= 0x00007c00;
-      if(cdest & 0x00000020)cdest |= 0x0000001f;
-    }
-
-    cdest &= 0x03e07c1f;
-    return (cdest >> 16) | cdest;
-  } else {
-  //subtract
-    if((cdest & 0x7c00) < (csrc & 0x7c00))cdest &= ~0x7c00;
-    else cdest -= (csrc & 0x7c00);
-    if((cdest & 0x03e0) < (csrc & 0x03e0))cdest &= ~0x03e0;
-    else cdest -= (csrc & 0x03e0);
-    if((cdest & 0x001f) < (csrc & 0x001f))cdest &= ~0x001f;
-    else cdest -= (csrc & 0x001f);
-
-    if(regs.color_halve && !regs.addsub_mode) {
-      return (cdest & 0x7bde) >> 1;
-    }
-
-    return cdest;
-  }
-}
diff --git a/src/ppu/bppu/Copy of bppu_render_line.cpp b/src/ppu/bppu/Copy of bppu_render_line.cpp
deleted file mode 100644
index 58ac93f8..00000000
--- a/src/ppu/bppu/Copy of bppu_render_line.cpp	
+++ /dev/null
@@ -1,82 +0,0 @@
-inline uint16 bPPU::get_palette(uint8 index) {
-  return read16(cgram, index << 1);
-}
-
-inline uint16 bPPU::get_direct_color(uint8 p, uint8 t) {
-//p = 00000bgr <palette data>
-//t = BBGGGRRR <tilemap data>
-//r = 0BBb00GGGg0RRRr0 <return data>
-  return ((t & 7) << 2) | ((p & 1) << 1) |
-    (((t >> 3) & 7) << 7) | (((p >> 1) & 1) << 6) |
-    ((t >> 6) << 13) | ((p >> 2) << 12);
-}
-
-inline uint16 bPPU::get_pixel(int x) {
-_pixel *p = &pixel_cache[x];
-uint16 r, src_back = get_palette(0);
-  if(p->bg_main && p->bg_sub) {
-    if(!p->color_exempt && regs.color_enabled[p->bg_main & 0x7f] && window_cache[COL].sub[x]) {
-      if(regs.addsub_mode) {
-        r = addsub_pixels(p->src_main, p->src_sub);
-      } else {
-        r = addsub_pixel(p->src_main);
-      }
-    } else {
-      r = p->src_main;
-    }
-  } else if(p->bg_main) {
-    if(!p->color_exempt && regs.color_enabled[p->bg_main & 0x7f] && window_cache[COL].sub[x]) {
-      r = addsub_pixel(p->src_main);
-    } else {
-      r = p->src_main;
-    }
-  } else if(p->bg_sub) {
-    if(regs.color_enabled[BACK]) {
-      if(window_cache[COL].sub[x]) {
-        if(regs.addsub_mode) {
-          r = addsub_pixels(src_back, p->src_sub);
-        } else {
-          r = addsub_pixel(src_back);
-        }
-      } else {
-        r = src_back;
-      }
-    } else {
-      r = src_back; //was 0x0000 -- possibly another condition here?
-    }
-  } else {
-    if(window_cache[COL].main[x]) {
-      if(regs.color_enabled[BACK] && window_cache[COL].sub[x]) {
-        r = addsub_pixel(src_back);
-      } else {
-        r = src_back;
-      }
-    } else {
-      if(regs.color_enabled[BACK] && window_cache[COL].sub[x]) {
-        r = (!regs.color_mode) ? regs.color_rgb : 0x0000;
-      } else {
-        r = 0x0000;
-      }
-    }
-  }
-  return r;
-}
-
-inline void bPPU::render_line_output() {
-uint16 r, x;
-uint16 *ptr    = (uint16*)output + (line.y * 1024) +
-                 ((line.interlace && line.interlace_field) ? 512 : 0);
-uint16 *ltable = (uint16*)light_table + (regs.display_brightness << 15);
-
-  if(line.width == 256) {
-    for(x=0;x<256;x++) {
-      r = get_pixel(x);
-      *ptr++ = *(ltable + r);
-    }
-  } else {
-    for(x=0;x<512;x++) {
-      r = get_pixel(x);
-      *ptr++ = *(ltable + r);
-    }
-  }
-}
diff --git a/src/ppu/bppu/bppu.cpp b/src/ppu/bppu/bppu.cpp
index b0d1af9b..cddab1fd 100644
--- a/src/ppu/bppu/bppu.cpp
+++ b/src/ppu/bppu/bppu.cpp
@@ -6,8 +6,7 @@ void bPPU::run() {}
 
 void bPPU::scanline() {
   line.y               = r_cpu->vcounter();
-  line.width           = (regs.bg_mode == 5 || regs.bg_mode == 6) ? 512 : 256;
-  line.hires           = (regs.bg_mode == 5 || regs.bg_mode == 6);
+  line.width           = (regs.hires) ? 512 : 256;
   line.interlace       = r_cpu->interlace();
   line.interlace_field = r_cpu->interlace_field();
 
@@ -17,6 +16,28 @@ void bPPU::scanline() {
     regs.range_over = false;
   }
 
+int32 bg;
+  if(line.y == 1) {
+  //mosaic reset
+    for(bg=BG1;bg<=BG4;bg++) {
+      regs.bg_y[bg] = 1;
+    }
+
+    regs.mosaic_countdown = regs.mosaic_size + 1;
+    regs.mosaic_countdown--;
+  } else {
+    for(bg=BG1;bg<=BG4;bg++) {
+      if(!regs.mosaic_enabled[bg] || !regs.mosaic_countdown) {
+        regs.bg_y[bg] = line.y;
+      }
+    }
+
+    if(!regs.mosaic_countdown) {
+      regs.mosaic_countdown = regs.mosaic_size + 1;
+    }
+    regs.mosaic_countdown--;
+  }
+
   if(line.y == 1) {
   //OAM FirstSprite priority set
     if(regs.oam_priority == true) {
@@ -66,6 +87,12 @@ void bPPU::reset() {
   regs.ppu1_mdr = 0xff;
   regs.ppu2_mdr = 0xff;
 
+//bg line counters
+  regs.bg_y[0] = 0;
+  regs.bg_y[1] = 0;
+  regs.bg_y[2] = 0;
+  regs.bg_y[3] = 0;
+
 //$2100
   regs.display_disabled   = 0;
   regs.display_brightness = 0;
@@ -90,13 +117,15 @@ void bPPU::reset() {
   regs.bg_tilesize[BG4] = 0;
   regs.bg3_priority     = 0;
   regs.bg_mode          = 0;
+  regs.hires            = false;
 
 //$2106
-  regs.mosaic_size         = 0;
-  regs.mosaic_enabled[BG1] = false;
-  regs.mosaic_enabled[BG2] = false;
-  regs.mosaic_enabled[BG3] = false;
-  regs.mosaic_enabled[BG4] = false;
+  regs.mosaic_size          = 0;
+  regs.mosaic_enabled[BG1]  = false;
+  regs.mosaic_enabled[BG2]  = false;
+  regs.mosaic_enabled[BG3]  = false;
+  regs.mosaic_enabled[BG4]  = false;
+  regs.mosaic_countdown     = 0;
 
 //$2107-$210a
   regs.bg_scaddr[BG1] = 0x0000;
@@ -236,11 +265,12 @@ void bPPU::reset() {
   regs.color_rgb = 0x0000;
 
 //$2133
-  regs.mode7_extbg = false;
-  regs.overscan    = false;
-  regs.scanlines   = 224;
-  regs.oam_halve   = false;
-  regs.interlace   = false;
+  regs.mode7_extbg  = false;
+  regs.pseudo_hires = false;
+  regs.overscan     = false;
+  regs.scanlines    = 224;
+  regs.oam_halve    = false;
+  regs.interlace    = false;
 
 //$2137
   regs.hcounter         = 0;
diff --git a/src/ppu/bppu/bppu.h b/src/ppu/bppu/bppu.h
index 6223b8db..f79d6e85 100644
--- a/src/ppu/bppu/bppu.h
+++ b/src/ppu/bppu/bppu.h
@@ -20,7 +20,6 @@ enum { SC_32x32 = 0, SC_64x32 = 1, SC_32x64 = 2, SC_64x64 = 3 };
 struct {
   uint32 y;
   uint32 width;
-  bool   hires;
   bool   interlace;
   bool   interlace_field;
 } line;
@@ -39,6 +38,9 @@ struct {
 //open bus support
   uint8 ppu1_mdr, ppu2_mdr;
 
+//bg line counters
+  uint16 bg_y[4];
+
 //$2100
   bool   display_disabled;
   uint8  display_brightness;
@@ -59,10 +61,12 @@ struct {
   bool   bg_tilesize[4];
   bool   bg3_priority;
   uint8  bg_mode;
+  bool   hires;
 
 //$2106
   uint8  mosaic_size;
   bool   mosaic_enabled[4];
+  uint16 mosaic_countdown;
 
 //$2107-$210a
   uint16 bg_scaddr[4];
@@ -131,6 +135,7 @@ struct {
 
 //$2133
   bool   mode7_extbg;
+  bool   pseudo_hires;
   bool   overscan;
   uint16 scanlines;
   bool   oam_halve;
@@ -246,7 +251,7 @@ uint16 *mosaic_table[16];
   void   power();
   void   reset();
 
-  bool   scanline_is_hires() { return (regs.bg_mode == 5 || regs.bg_mode == 6); }
+  bool   scanline_is_hires() { return (regs.hires); }
 
   bPPU();
   ~bPPU();
diff --git a/src/ppu/bppu/bppu_mmio.cpp b/src/ppu/bppu/bppu_mmio.cpp
index fcd3ddbb..8f53f005 100644
--- a/src/ppu/bppu/bppu_mmio.cpp
+++ b/src/ppu/bppu/bppu_mmio.cpp
@@ -117,6 +117,7 @@ void bPPU::mmio_w2105(uint8 value) {
   regs.bg_tilesize[BG1] = !!(value & 0x10);
   regs.bg3_priority     = !!(value & 0x08);
   regs.bg_mode          = (value & 7);
+  regs.hires            = (regs.bg_mode == 5 || regs.bg_mode == 6);
 
   window_cache[BG1].main_dirty = window_cache[BG1].sub_dirty = true;
   window_cache[BG2].main_dirty = window_cache[BG2].sub_dirty = true;
@@ -548,11 +549,12 @@ void bPPU::mmio_w2132(uint8 value) {
 
 //SETINI
 void bPPU::mmio_w2133(uint8 value) {
-  regs.mode7_extbg = !!(value & 0x40);
-  regs.overscan    = !!(value & 0x04);
-  regs.scanlines   = (value & 0x04)?239:224;
-  regs.oam_halve   = !!(value & 0x02);
-  regs.interlace   = !!(value & 0x01);
+  regs.mode7_extbg  = !!(value & 0x40);
+  regs.pseudo_hires = !!(value & 0x08);
+  regs.overscan     = !!(value & 0x04);
+  regs.scanlines    = (value & 0x04)?239:224;
+  regs.oam_halve    = !!(value & 0x02);
+  regs.interlace    = !!(value & 0x01);
 
   r_cpu->set_overscan(regs.overscan);
   r_cpu->set_interlace(regs.interlace);
diff --git a/src/ppu/bppu/bppu_render.cpp b/src/ppu/bppu/bppu_render.cpp
index 8edac47c..5cde2785 100644
--- a/src/ppu/bppu/bppu_render.cpp
+++ b/src/ppu/bppu/bppu_render.cpp
@@ -6,6 +6,40 @@
 #include "bppu_render_addsub.cpp"
 #include "bppu_render_line.cpp"
 
+bool bPPU::render_enabled(uint8 bg, uint8 pri) {
+  switch(bg) {
+  case BG1:
+    switch(pri) {
+    case 0: return config::ppu.bg1_pri0_enable;
+    case 1: return config::ppu.bg1_pri1_enable;
+    } break;
+  case BG2:
+    switch(pri) {
+    case 0: return config::ppu.bg2_pri0_enable;
+    case 1: return config::ppu.bg2_pri1_enable;
+    } break;
+  case BG3:
+    switch(pri) {
+    case 0: return config::ppu.bg3_pri0_enable;
+    case 1: return config::ppu.bg3_pri1_enable;
+    } break;
+  case BG4:
+    switch(pri) {
+    case 0: return config::ppu.bg4_pri0_enable;
+    case 1: return config::ppu.bg4_pri1_enable;
+    } break;
+  case OAM:
+    switch(pri) {
+    case 0: return config::ppu.oam_pri0_enable;
+    case 1: return config::ppu.oam_pri1_enable;
+    case 2: return config::ppu.oam_pri2_enable;
+    case 3: return config::ppu.oam_pri3_enable;
+    } break;
+  }
+
+  return true;
+}
+
 /*
 Mode 0: ->
      1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12
diff --git a/src/ppu/bppu/bppu_render.h b/src/ppu/bppu/bppu_render.h
index 0e9b3c24..7085f8b6 100644
--- a/src/ppu/bppu/bppu_render.h
+++ b/src/ppu/bppu/bppu_render.h
@@ -1,4 +1,5 @@
 //bppu_render.cpp
+inline bool render_enabled(uint8 bg, uint8 pri);
 inline void render_line_mode0();
 inline void render_line_mode1();
 inline void render_line_mode2();
@@ -12,19 +13,18 @@ inline void render_line_mode7();
 enum { COLORDEPTH_4 = 0, COLORDEPTH_16 = 1, COLORDEPTH_256 = 2 };
 enum { TILE_2BIT = 0, TILE_4BIT = 1, TILE_8BIT = 2 };
 
-enum { PC_BG1 = 0x80, PC_BG2 = 0x81, PC_BG3 = 0x82, PC_BG4 = 0x83, PC_OAM = 0x84, PC_BACK = 0x00 };
 struct _pixel {
 //bgr555 color data for main/subscreen pixels: 0x0000 = transparent / use palette color # 0
 //needs to be bgr555 instead of palette index for direct color mode ($2130 bit 0) to work
 uint16 src_main, src_sub;
 //indicates source of palette # for main/subscreen (BG1-4, OAM, or back)
 uint8  bg_main,  bg_sub;
-//true when bg_main == OAM && palette index >= 192, disables color add/sub effects
-uint8  color_exempt;
+//color_exemption -- true when bg == OAM && palette index >= 192, disables color add/sub effects
+uint8  ce_main,  ce_sub;
 //priority level of src_n. to set src_n,
 //the priority of the pixel must be >pri_n
 uint8  pri_main, pri_sub;
-} pixel_cache[512];
+} pixel_cache[256];
 
 uint8 *bg_tiledata[3];
 uint8 *bg_tiledata_state[3];
@@ -37,7 +37,7 @@ inline void clear_tiledata_cache();
 //bppu_render_windows.cpp
 struct _window {
   bool  main_dirty, sub_dirty;
-  uint8 main[512],  sub[512];
+  uint8 main[256],  sub[256];
 } window_cache[6];
 
 void build_window_table(uint8 bg, bool mainscreen);
@@ -71,18 +71,20 @@ void load_oam_tiles();
 void render_oam_tile(int tile_num);
 void render_line_oam(uint8 pri0_pos, uint8 pri1_pos, uint8 pri2_pos, uint8 pri3_pos);
 void render_line_oam_lores(uint8 pri0_pos, uint8 pri1_pos, uint8 pri2_pos, uint8 pri3_pos);
-void render_line_oam_hires(uint8 pri0_pos, uint8 pri1_pos, uint8 pri2_pos, uint8 pri3_pos);
 
 //bppu_render_mode7.cpp
 void render_line_mode7(uint8 bg, uint8 pri0_pos, uint8 pri1_pos);
 
 //bppu_render_addsub.cpp
-inline uint16 addsub_pixels(uint32 x);
+inline uint16 addsub_pixels(uint32 x, uint32 cdest, uint32 csrc, bool halve);
 
 //bppu_render_line.cpp
 enum { BLENDTYPE_BACK = 0, BLENDTYPE_MAIN = 1, BLENDTYPE_SUB = 2, BLENDTYPE_COMBINE = 3 };
 
 inline uint16 get_palette(uint8 index);
 inline uint16 get_direct_color(uint8 p, uint8 t);
-inline uint16 get_pixel(uint32 x);
+inline uint16 get_pixel_normal(uint32 x);
+inline uint16 get_pixel_swap(uint32 x);
+inline uint16 get_pixel_lores(uint32 x);
+inline uint16 get_pixel_hires(uint32 x);
 inline void render_line_output();
diff --git a/src/ppu/bppu/bppu_render_addsub.cpp b/src/ppu/bppu/bppu_render_addsub.cpp
index 835d4d8a..18a276f3 100644
--- a/src/ppu/bppu/bppu_render_addsub.cpp
+++ b/src/ppu/bppu/bppu_render_addsub.cpp
@@ -1,14 +1,4 @@
-inline uint16 bPPU::addsub_pixels(uint32 x) {
-uint32 cdest = pixel_cache[x].src_main,
-       csrc  = pixel_cache[x].src_sub;
-bool   halve = false;
-  if(regs.color_halve && window_cache[COL].main[x]) {
-    if(regs.addsub_mode && pixel_cache[x].bg_sub == BACK);
-    else {
-      halve = true;
-    }
-  }
-
+inline uint16 bPPU::addsub_pixels(uint32 x, uint32 cdest, uint32 csrc, bool halve) {
   if(!regs.color_mode) {
   //add
     cdest = ((cdest << 16) | cdest) & 0x03e07c1f;
diff --git a/src/ppu/bppu/bppu_render_bg.cpp b/src/ppu/bppu/bppu_render_bg.cpp
index 9b0bd8d6..d44fc3f3 100644
--- a/src/ppu/bppu/bppu_render_bg.cpp
+++ b/src/ppu/bppu/bppu_render_bg.cpp
@@ -1,8 +1,8 @@
 //called once at the start of every rendered scanline
 void bPPU::update_bg_info() {
-  for(int bg=0;bg<4;bg++) {
+  for(int bg = 0; bg < 4; bg++) {
     bg_info[bg].th = (regs.bg_tilesize[bg]) ? 4 : 3;
-    bg_info[bg].tw = (line.hires) ? 4 : bg_info[bg].th;
+    bg_info[bg].tw = (regs.hires) ? 4 : bg_info[bg].th;
     bg_info[bg].mx = (bg_info[bg].th == 4) ? (line.width << 1) : line.width;
     bg_info[bg].my = bg_info[bg].mx;
     if(regs.bg_scsize[bg] & 0x01)bg_info[bg].mx <<= 1;
@@ -13,22 +13,17 @@ void bPPU::update_bg_info() {
 }
 
 uint16 bPPU::bg_get_tile(uint8 bg, uint16 x, uint16 y) {
-uint16 map_index, pos;
+uint16 pos;
   x &= bg_info[bg].mx;
   y &= bg_info[bg].my;
 
-//32 = SC width, height; tilemap data is stored as uint16
-//width(32) * height(32) * sizeof(uint16) = 2048
-  switch(regs.bg_scsize[bg]) {
-  case SC_32x32:map_index = 0; break;
-  case SC_64x32:map_index = ((x >> bg_info[bg].th) / 32) * 2048; break;
-  case SC_32x64:map_index = ((y >> bg_info[bg].th) / 32) * 2048; break;
-  case SC_64x64:map_index = ((x >> bg_info[bg].th) / 32) * 2048 +
-                            ((y >> bg_info[bg].th) / 32) * 4096; break;
-  }
+  x >>= bg_info[bg].tw;
+  y >>= bg_info[bg].th;
 
-  pos = ((((y >> bg_info[bg].th) & 31) * 32) + ((x >> bg_info[bg].tw) & 31)) << 1;
-  return read16(vram, regs.bg_scaddr[bg] + map_index + pos);
+  pos  = (regs.bg_scsize[bg] & 2) ? ((y & 0x20) << ((regs.bg_scsize[bg] & 1) ? 6 : 5)) : 0;
+  pos += (regs.bg_scsize[bg] & 1) ? ((x & 0x20) << 5) : 0;
+  pos += ((y & 31) << 5) + (x & 31);
+  return read16(vram, regs.bg_scaddr[bg] + (pos << 1));
 }
 
 void bPPU::render_line_bg(uint8 bg, uint8 color_depth, uint8 pri0_pos, uint8 pri1_pos) {
@@ -36,6 +31,12 @@ void bPPU::render_line_bg(uint8 bg, uint8 color_depth, uint8 pri0_pos, uint8 pri
     return;
   }
 
+//are layers disabled by user?
+  if(render_enabled(bg, 0) == false)pri0_pos = 0;
+  if(render_enabled(bg, 1) == false)pri1_pos = 0;
+//nothing to render?
+  if(!pri0_pos && !pri1_pos)return;
+
 bool   bg_enabled     = regs.bg_enabled[bg];
 bool   bgsub_enabled  = regs.bgsub_enabled[bg];
 
@@ -57,13 +58,13 @@ uint16 mask_x         = bg_info[bg].mx; //screen width  mask
 uint16 mask_y         = bg_info[bg].my; //screen height mask
 
 uint x = 0;
-uint y = line.y;
-  if(line.interlace && line.hires) {
+uint y = regs.bg_y[bg];
+  if(line.interlace && regs.hires) {
     y = (y << 1) + line.interlace_field;
   }
 
-uint16 hscroll = (line.hires) ? (regs.bg_hofs[bg] << 1) : regs.bg_hofs[bg];
-uint16 vscroll = (line.interlace && line.hires) ? (regs.bg_vofs[bg] << 1) : regs.bg_vofs[bg];
+uint16 hscroll = (regs.hires) ? (regs.bg_hofs[bg] << 1) : regs.bg_hofs[bg];
+uint16 vscroll = (line.interlace && regs.hires) ? (regs.bg_vofs[bg] << 1) : regs.bg_vofs[bg];
   hscroll &= mask_x;
   vscroll &= mask_y;
 
@@ -78,14 +79,14 @@ uint8 *tile_ptr;
 uint   xpos, ypos;
 uint16 hoffset, voffset, opt_x, col;
 bool   mirror_x, mirror_y;
-bool   is_opt_mode = (regs.bg_mode == 2 || regs.bg_mode == 4 || regs.bg_mode == 6);
+bool   is_opt_mode = (config::ppu.opt_enable) && (regs.bg_mode == 2 || regs.bg_mode == 4 || regs.bg_mode == 6);
 
   build_window_tables(bg);
 uint8 *wt_main = window_cache[bg].main;
 uint8 *wt_sub  = window_cache[bg].sub;
 
 int32 prev_x = -1, prev_y = -1;
-  for(x=0;x<line.width;x++) {
+  for(x = 0; x < line.width; x++) {
     hoffset = x + hscroll;
     voffset = y + vscroll;
 
@@ -122,7 +123,7 @@ int32 prev_x = -1, prev_y = -1;
     }
 
     mosaic_x = mtable[hoffset & mask_x];
-    mosaic_y = mtable[voffset & mask_y];
+    mosaic_y = voffset & mask_y;
 
     if((mosaic_x >> 3) != prev_x || (mosaic_y >> 3) != prev_y) {
       prev_x = (mosaic_x >> 3);
@@ -171,21 +172,35 @@ int32 prev_x = -1, prev_y = -1;
         col = get_palette(col + pal_index);
       }
 
-      if(bg_enabled == true && !wt_main[x]) {
-        if(pixel_cache[x].pri_main < tile_pri) {
-          pixel_cache[x].pri_main = tile_pri;
-          pixel_cache[x].bg_main  = 0x80 | bg;
-          pixel_cache[x].src_main = col;
-          pixel_cache[x].color_exempt = false;
-        }
-      }
-      if(bgsub_enabled == true && !wt_sub[x]) {
-        if(pixel_cache[x].pri_sub < tile_pri) {
-          pixel_cache[x].pri_sub = tile_pri;
-          pixel_cache[x].bg_sub  = 0x80 | bg;
-          pixel_cache[x].src_sub = col;
+    #define setpixel_main(x) \
+      if(pixel_cache[x].pri_main < tile_pri) { \
+        pixel_cache[x].pri_main = tile_pri; \
+        pixel_cache[x].bg_main  = bg; \
+        pixel_cache[x].src_main = col; \
+        pixel_cache[x].ce_main  = false; \
+      }
+    #define setpixel_sub(x) \
+      if(pixel_cache[x].pri_sub < tile_pri) { \
+        pixel_cache[x].pri_sub = tile_pri; \
+        pixel_cache[x].bg_sub  = bg; \
+        pixel_cache[x].src_sub = col; \
+        pixel_cache[x].ce_sub  = false; \
+      }
+
+      if(!regs.hires) {
+        if(bg_enabled    == true && !wt_main[x]) { setpixel_main(x); }
+        if(bgsub_enabled == true && !wt_sub[x])  { setpixel_sub(x);  }
+      } else {
+      int hx = x >> 1;
+        if(x & 1) {
+          if(bg_enabled    == true && !wt_main[hx]) { setpixel_main(hx); }
+        } else {
+          if(bgsub_enabled == true && !wt_sub[hx])  { setpixel_sub(hx);  }
         }
       }
+
+    #undef setpixel_main
+    #undef setpixel_sub
     }
   }
 }
diff --git a/src/ppu/bppu/bppu_render_cache.cpp b/src/ppu/bppu/bppu_render_cache.cpp
index 0557f711..dbc8ac4d 100644
--- a/src/ppu/bppu/bppu_render_cache.cpp
+++ b/src/ppu/bppu/bppu_render_cache.cpp
@@ -103,7 +103,19 @@ uint8 *dest;
 #undef render_bg_tile_line_256
 
 inline void bPPU::clear_pixel_cache() {
-  memset(pixel_cache, 0, sizeof(pixel_cache));
+uint16 main = get_palette(0);
+uint16 sub  = (regs.pseudo_hires || regs.hires) ? main : regs.color_rgb;
+uint32 i    = 255;
+  do {
+    pixel_cache[i].src_main = main;
+    pixel_cache[i].src_sub  = sub;
+    pixel_cache[i].bg_main  = BACK;
+    pixel_cache[i].bg_sub   = BACK;
+    pixel_cache[i].ce_main  = false;
+    pixel_cache[i].ce_sub   = false;
+    pixel_cache[i].pri_main = 0;
+    pixel_cache[i].pri_sub  = 0;
+  } while(i--);
 }
 
 void bPPU::init_tiledata_cache() {
diff --git a/src/ppu/bppu/bppu_render_line.cpp b/src/ppu/bppu/bppu_render_line.cpp
index 3e254660..8cfafced 100644
--- a/src/ppu/bppu/bppu_render_line.cpp
+++ b/src/ppu/bppu/bppu_render_line.cpp
@@ -11,59 +11,109 @@ inline uint16 bPPU::get_direct_color(uint8 p, uint8 t) {
     ((t >> 6) << 13) | ((p >> 2) << 12);
 }
 
-inline uint16 bPPU::get_pixel(uint32 x) {
+inline uint16 bPPU::get_pixel_normal(uint32 x) {
 _pixel *p = &pixel_cache[x];
-  if(!p->bg_main) {
-    p->bg_main      = BACK;
-    p->src_main     = get_palette(0);
-    p->color_exempt = false;
-  } else {
-    p->bg_main &= 0x7f;
-  }
-
-  if(!p->bg_sub) {
-    p->bg_sub  = BACK;
-    p->src_sub = regs.color_rgb;
-  } else {
-    p->bg_sub &= 0x7f;
-  }
+uint16 src_main, src_sub;
+uint8  bg_sub;
+  src_main = p->src_main;
 
   if(!regs.addsub_mode) {
-    p->bg_sub  = BACK;
-    p->src_sub = regs.color_rgb;
+    bg_sub  = BACK;
+    src_sub = regs.color_rgb;
+  } else {
+    bg_sub  = p->bg_sub;
+    src_sub = p->src_sub;
   }
 
   if(!window_cache[COL].main[x]) {
     if(!window_cache[COL].sub[x]) {
       return 0x0000;
     }
-  //p->bg_main remains the same, even when the main color window
-  //masks out the color. this is needed for regs.color_enabled[p->bg_main]
-  //test below. illusion of gaia relies on this behavior for its load menu.
-    p->src_main = 0x0000;
+    src_main = 0x0000;
   }
 
-  if(!p->color_exempt && regs.color_enabled[p->bg_main] && window_cache[COL].sub[x]) {
-    return addsub_pixels(x);
+  if(!p->ce_main && regs.color_enabled[p->bg_main] && window_cache[COL].sub[x]) {
+  bool halve = false;
+    if(regs.color_halve && window_cache[COL].main[x]) {
+      if(regs.addsub_mode && bg_sub == BACK);
+      else {
+        halve = true;
+      }
+    }
+    return addsub_pixels(x, src_main, src_sub, halve);
+  }
+
+  return src_main;
+}
+
+inline uint16 bPPU::get_pixel_swap(uint32 x) {
+_pixel *p = &pixel_cache[x];
+uint16 src_main, src_sub;
+uint8  bg_sub;
+  src_main = p->src_sub;
+
+  if(!regs.addsub_mode) {
+    bg_sub  = BACK;
+    src_sub = regs.color_rgb;
+  } else {
+    bg_sub  = p->bg_main;
+    src_sub = p->src_main;
+  }
+
+  if(!window_cache[COL].main[x]) {
+    if(!window_cache[COL].sub[x]) {
+      return 0x0000;
+    }
+    src_main = 0x0000;
+  }
+
+  if(!p->ce_sub && regs.color_enabled[p->bg_sub] && window_cache[COL].sub[x]) {
+  bool halve = false;
+    if(regs.color_halve && window_cache[COL].main[x]) {
+      if(regs.addsub_mode && bg_sub == BACK);
+      else {
+        halve = true;
+      }
+    }
+    return addsub_pixels(x, src_main, src_sub, halve);
+  }
+
+  return src_main;
+}
+
+inline uint16 bPPU::get_pixel_lores(uint32 x) {
+  return get_pixel_normal(x);
+}
+
+inline uint16 bPPU::get_pixel_hires(uint32 x) {
+  if(x & 1) {
+    return get_pixel_normal(x >> 1);
+  } else {
+    return get_pixel_swap(x >> 1);
   }
-  return p->src_main;
 }
 
 inline void bPPU::render_line_output() {
-uint16 r, x;
+uint32 r, x;
 uint16 *ptr    = (uint16*)output + (line.y * 1024) +
                  ((line.interlace && line.interlace_field) ? 512 : 0);
 uint16 *ltable = (uint16*)light_table + (regs.display_brightness << 15);
 
-  if(line.width == 256) {
+  if(!regs.pseudo_hires && !regs.hires) {
     for(x=0;x<256;x++) {
-      r = get_pixel(x);
+      r = get_pixel_lores(x);
       *ptr++ = *(ltable + r);
     }
   } else {
     for(x=0;x<512;x++) {
-      r = get_pixel(x);
+      r = get_pixel_hires(x);
       *ptr++ = *(ltable + r);
     }
+    if(regs.pseudo_hires && !regs.hires) {
+      ptr -= 512;
+      for(x=0;x<256;x++) {
+        *(ptr + x) = ((ptr[x << 1] & 0x7bde) >> 1) + ((ptr[(x << 1) + 1] & 0x7bde) >> 1);
+      }
+    }
   }
 }
diff --git a/src/ppu/bppu/bppu_render_mode7.cpp b/src/ppu/bppu/bppu_render_mode7.cpp
index 6e0797eb..9c0bdc52 100644
--- a/src/ppu/bppu/bppu_render_mode7.cpp
+++ b/src/ppu/bppu/bppu_render_mode7.cpp
@@ -17,6 +17,12 @@
 void bPPU::render_line_mode7(uint8 bg, uint8 pri0_pos, uint8 pri1_pos) {
   if(regs.bg_enabled[bg] == false && regs.bgsub_enabled[bg] == false)return;
 
+//are layers disabled by user?
+  if(render_enabled(bg, 0) == false)pri0_pos = 0;
+  if(render_enabled(bg, 1) == false)pri1_pos = 0;
+//nothing to render?
+  if(!pri0_pos && !pri1_pos);
+
 int32 x, y;
 int32 a, b, c, d, cx, cy;
 int32 hofs, vofs;
@@ -131,16 +137,17 @@ int32 psy = ((c * CLIP(hofs - cx)) & ~63) + ((d * CLIP(vofs - cy)) & ~63) + ((d
     if(regs.bg_enabled[bg] == true && !wt_main[_x]) {
       if(pixel_cache[_x].pri_main < _pri) {
         pixel_cache[_x].pri_main = _pri;
-        pixel_cache[_x].bg_main  = 0x80 | bg;
+        pixel_cache[_x].bg_main  = bg;
         pixel_cache[_x].src_main = col;
-        pixel_cache[_x].color_exempt = false;
+        pixel_cache[_x].ce_main  = false;
       }
     }
     if(regs.bgsub_enabled[bg] == true && !wt_sub[_x]) {
       if(pixel_cache[_x].pri_sub < _pri) {
         pixel_cache[_x].pri_sub = _pri;
-        pixel_cache[_x].bg_sub  = 0x80 | bg;
+        pixel_cache[_x].bg_sub  = bg;
         pixel_cache[_x].src_sub = col;
+        pixel_cache[_x].ce_sub  = false;
       }
     }
   }
diff --git a/src/ppu/bppu/bppu_render_oam.cpp b/src/ppu/bppu/bppu_render_oam.cpp
index a1177b40..1ff23631 100644
--- a/src/ppu/bppu/bppu_render_oam.cpp
+++ b/src/ppu/bppu/bppu_render_oam.cpp
@@ -220,13 +220,32 @@ int s;
 
   if(regs.bg_enabled[OAM] == false && regs.bgsub_enabled[OAM] == false)return;
 
-  if(line.width == 256) {
-    render_line_oam_lores(pri0_pos, pri1_pos, pri2_pos, pri3_pos);
-  } else {
-    render_line_oam_hires(pri0_pos, pri1_pos, pri2_pos, pri3_pos);
-  }
+//are layers disabled by user?
+  if(render_enabled(OAM, 0) == false)pri0_pos = 0;
+  if(render_enabled(OAM, 1) == false)pri1_pos = 0;
+  if(render_enabled(OAM, 2) == false)pri2_pos = 0;
+  if(render_enabled(OAM, 3) == false)pri3_pos = 0;
+//nothing to render?
+  if(!pri0_pos && !pri1_pos && !pri2_pos && !pri3_pos)return;
+
+  render_line_oam_lores(pri0_pos, pri1_pos, pri2_pos, pri3_pos);
 }
 
+#define setpixel_main(x) \
+  if(pixel_cache[x].pri_main < pri) { \
+    pixel_cache[x].pri_main = pri; \
+    pixel_cache[x].bg_main  = OAM; \
+    pixel_cache[x].src_main = get_palette(oam_line_pal[x]); \
+    pixel_cache[x].ce_main  = (oam_line_pal[x] < 192); \
+  }
+#define setpixel_sub(x) \
+  if(pixel_cache[x].pri_sub < pri) { \
+    pixel_cache[x].pri_sub = pri; \
+    pixel_cache[x].bg_sub  = OAM; \
+    pixel_cache[x].src_sub = get_palette(oam_line_pal[x]); \
+    pixel_cache[x].ce_sub  = (oam_line_pal[x] < 192); \
+  }
+
 void bPPU::render_line_oam_lores(uint8 pri0_pos, uint8 pri1_pos, uint8 pri2_pos, uint8 pri3_pos) {
 bool bg_enabled    = regs.bg_enabled[OAM];
 bool bgsub_enabled = regs.bgsub_enabled[OAM];
@@ -246,78 +265,10 @@ int pri;
     case 3:pri = pri3_pos;break;
     }
 
-    if(bg_enabled == true && !wt_main[x]) {
-      if(pixel_cache[x].pri_main < pri) {
-        pixel_cache[x].pri_main = pri;
-        pixel_cache[x].bg_main  = PC_OAM;
-        pixel_cache[x].src_main = get_palette(oam_line_pal[x]);
-        pixel_cache[x].color_exempt = (oam_line_pal[x] < 192);
-      }
-    }
-
-    if(bgsub_enabled == true && !wt_sub[x]) {
-      if(pixel_cache[x].pri_sub < pri) {
-        pixel_cache[x].pri_sub = pri;
-        pixel_cache[x].bg_sub  = PC_OAM;
-        pixel_cache[x].src_sub = get_palette(oam_line_pal[x]);
-      }
-    }
+    if(bg_enabled    == true && !wt_main[x]) { setpixel_main(x); }
+    if(bgsub_enabled == true && !wt_sub[x])  { setpixel_sub(x); }
   }
 }
 
-void bPPU::render_line_oam_hires(uint8 pri0_pos, uint8 pri1_pos, uint8 pri2_pos, uint8 pri3_pos) {
-bool bg_enabled    = regs.bg_enabled[OAM];
-bool bgsub_enabled = regs.bgsub_enabled[OAM];
-
-  build_window_tables(OAM);
-uint8 *wt_main = window_cache[OAM].main;
-uint8 *wt_sub  = window_cache[OAM].sub;
-
-int pri, sx;
-  for(int x=0;x<256;x++) {
-    if(oam_line_pri[x] == OAM_PRI_NONE)continue;
-
-    switch(oam_line_pri[x]) {
-    case 0:pri = pri0_pos;break;
-    case 1:pri = pri1_pos;break;
-    case 2:pri = pri2_pos;break;
-    case 3:pri = pri3_pos;break;
-    }
-
-    sx = x << 1;
-    if(bg_enabled == true && !wt_main[sx]) {
-      if(pixel_cache[sx].pri_main < pri) {
-        pixel_cache[sx].pri_main = pri;
-        pixel_cache[sx].bg_main  = PC_OAM;
-        pixel_cache[sx].src_main = get_palette(oam_line_pal[x]);
-        pixel_cache[sx].color_exempt = (oam_line_pal[x] < 192);
-      }
-    }
-
-    if(bgsub_enabled == true && !wt_sub[sx]) {
-      if(pixel_cache[sx].pri_sub < pri) {
-        pixel_cache[sx].pri_sub = pri;
-        pixel_cache[sx].bg_sub  = PC_OAM;
-        pixel_cache[sx].src_sub = get_palette(oam_line_pal[x]);
-      }
-    }
-
-    sx++;
-    if(bg_enabled == true && !wt_main[sx]) {
-      if(pixel_cache[sx].pri_main < pri) {
-        pixel_cache[sx].pri_main = pri;
-        pixel_cache[sx].bg_main  = PC_OAM;
-        pixel_cache[sx].src_main = get_palette(oam_line_pal[x]);
-        pixel_cache[sx].color_exempt = (oam_line_pal[x] < 192);
-      }
-    }
-
-    if(bgsub_enabled == true && !wt_sub[sx]) {
-      if(pixel_cache[sx].pri_sub < pri) {
-        pixel_cache[sx].pri_sub = pri;
-        pixel_cache[sx].bg_sub  = PC_OAM;
-        pixel_cache[sx].src_sub = get_palette(oam_line_pal[x]);
-      }
-    }
-  }
-}
+#undef setpixel_main
+#undef setpixel_sub
diff --git a/src/ppu/bppu/bppu_render_windows.cpp b/src/ppu/bppu/bppu_render_windows.cpp
index 5791fe89..084c1130 100644
--- a/src/ppu/bppu/bppu_render_windows.cpp
+++ b/src/ppu/bppu/bppu_render_windows.cpp
@@ -9,11 +9,11 @@ uint8 *wtbl;
 
   if(bg != COL) {
     if(mainscreen == true && regs.window_enabled[bg] == false) {
-      memset(wtbl, 0, line.width);
+      memset(wtbl, 0, 256);
       return;
     }
     if(mainscreen == false && regs.sub_window_enabled[bg] == false) {
-      memset(wtbl, 0, line.width);
+      memset(wtbl, 0, 256);
       return;
     }
   } else {
@@ -26,13 +26,13 @@ uint8 *wtbl;
 
     if(mask == 0) {
     //always
-      memset(wtbl, 1, line.width);
+      memset(wtbl, 1, 256);
       return;
     }
 
     if(mask == 3) {
     //never
-      memset(wtbl, 0, line.width);
+      memset(wtbl, 0, 256);
       return;
     }
 
@@ -56,37 +56,30 @@ bool   r;
   window2_left  = regs.window2_left;
   window2_right = regs.window2_right;
 
-  if(line.width == 512) {
-    window1_left  <<= 1;
-    window1_right <<= 1;
-    window2_left  <<= 1;
-    window2_right <<= 1;
-  }
-
   if(regs.window1_enabled[bg] == false && regs.window2_enabled[bg] == false) {
-    memset(wtbl, clr, line.width);
+    memset(wtbl, clr, 256);
   } else if(regs.window1_enabled[bg] == true && regs.window2_enabled[bg] == false) {
     if(regs.window1_invert[bg] == false) {
-      for(x=0;x<line.width;x++) {
+      for(x = 0; x < 256; x++) {
         wtbl[x] = (x >= window1_left && x <= window1_right) ? set : clr;
       }
     } else {
-      for(x=0;x<line.width;x++) {
+      for(x = 0; x < 256; x++) {
         wtbl[x] = (x <  window1_left || x >  window1_right) ? set : clr;
       }
     }
   } else if(regs.window1_enabled[bg] == false && regs.window2_enabled[bg] == true) {
     if(regs.window2_invert[bg] == false) {
-      for(x=0;x<line.width;x++) {
+      for(x = 0; x < 256; x++) {
         wtbl[x] = (x >= window2_left && x <= window2_right) ? set : clr;
       }
     } else {
-      for(x=0;x<line.width;x++) {
+      for(x = 0; x < 256; x++) {
         wtbl[x] = (x <  window2_left || x >  window2_right) ? set : clr;
       }
     }
   } else { //if(regs.window1_enabled[bg] == true && regs.window2_enabled[bg] == true) {
-    for(x=0;x<line.width;x++) {
+    for(x = 0; x < 256; x++) {
       if(regs.window1_invert[bg] == false) {
         w1_mask = (x >= window1_left && x <= window1_right);
       } else {
diff --git a/src/ppu/ppu.h b/src/ppu/ppu.h
index 6def0e52..af65e132 100644
--- a/src/ppu/ppu.h
+++ b/src/ppu/ppu.h
@@ -51,5 +51,5 @@ struct scanline_info {
   virtual bool  renderer_enabled();
 
   PPU();
-  ~PPU();
+  virtual ~PPU();
 };
diff --git a/src/reader/filereader.cpp b/src/reader/filereader.cpp
index 26f796f2..41864921 100644
--- a/src/reader/filereader.cpp
+++ b/src/reader/filereader.cpp
@@ -6,7 +6,7 @@ uint32 FileReader::size() {
 //This is needed so that when SRAM files do not exist, the
 //memory for the SRAM data will be allocated still.
 //The memory is flushed to 0x00 when no file is opened.
-void FileReader::read(uint8 **buffer, uint32 length) {
+uint8 *FileReader::read(uint32 length) {
 uint8 *data;
   if(length == 0) {
   //read the entire file into RAM
@@ -24,7 +24,7 @@ uint8 *data;
     memset(data, 0, length);
     if(fp)fread(data, 1, length, fp);
   }
-  *buffer = data;
+  return data;
 }
 
 bool FileReader::open(char *fn) {
diff --git a/src/reader/filereader.h b/src/reader/filereader.h
index aab88908..c195ff25 100644
--- a/src/reader/filereader.h
+++ b/src/reader/filereader.h
@@ -5,7 +5,7 @@ uint32 fsize;
 
 public:
   uint32 size();
-  void   read(uint8 **buffer, uint32 length = 0);
+  uint8 *read(uint32 length = 0);
   bool   open(char *fn);
   void   close();
 
diff --git a/src/reader/gzreader.cpp b/src/reader/gzreader.cpp
new file mode 100644
index 00000000..7a66ce43
--- /dev/null
+++ b/src/reader/gzreader.cpp
@@ -0,0 +1,76 @@
+uint32 GZReader::size() {
+  return fsize;
+}
+
+//This function will allocate memory even if open() fails.
+//This is needed so that when SRAM files do not exist, the
+//memory for the SRAM data will be allocated still.
+//The memory is flushed to 0x00 when no file is opened.
+uint8 *GZReader::read(uint32 length) {
+uint8 *data;
+  if(length == 0) {
+  //read the entire file into RAM
+    data = (uint8*)memalloc(fsize);
+    memset(data, 0, fsize);
+    if(gp)gzread(gp, data, fsize);
+  } else if(length > fsize) {
+  //read the entire file into RAM, pad the rest with 0x00s
+    data = (uint8*)memalloc(length);
+    memset(data, 0, length);
+    if(gp)gzread(gp, data, fsize);
+  } else { //fsize >= length
+  //read only what was requested
+    data = (uint8*)memalloc(length);
+    memset(data, 0, length);
+    if(gp)gzread(gp, data, length);
+  }
+  return data;
+}
+
+bool GZReader::open(char *fn) {
+FILE *fp;
+  fp = fopen(fn, "rb");
+  if(!fp)return false;
+
+  fseek(fp, 0, SEEK_END);
+  fsize = ftell(fp);
+
+  if(fsize < 4) {
+    fclose(fp);
+    fp = 0;
+    return false;
+  }
+
+uint32 gzsize;
+  fseek(fp, -4, SEEK_END); //jump to 4 bytes before end
+  gzsize  = fgetc(fp);
+  gzsize |= fgetc(fp) <<  8;
+  gzsize |= fgetc(fp) << 16;
+  gzsize |= fgetc(fp) << 24;
+
+  fclose(fp);
+  fp = 0;
+
+  gp = gzopen(fn, "rb");
+  if(!gp)return false;
+
+  if(!gzdirect(gp)) {
+    fsize = gzsize;
+  }
+
+//empty file?
+  if(fsize == 0) {
+    gzclose(gp);
+    gp = 0;
+    return false;
+  }
+
+  return true;
+}
+
+void GZReader::close() {
+  if(gp) {
+    gzclose(gp);
+    gp = 0;
+  }
+}
diff --git a/src/reader/gzreader.h b/src/reader/gzreader.h
new file mode 100644
index 00000000..308717af
--- /dev/null
+++ b/src/reader/gzreader.h
@@ -0,0 +1,16 @@
+#include "zlib/zlib.h"
+
+class GZReader : public Reader {
+private:
+gzFile gp;
+uint32 fsize;
+
+public:
+  uint32 size();
+  uint8 *read(uint32 length = 0);
+  bool   open(char *fn);
+  void   close();
+
+  GZReader() { gp = 0; fsize = 0; }
+  ~GZReader() { if(gp)gzclose(gp); }
+};
diff --git a/src/reader/jma/7z.h b/src/reader/jma/7z.h
new file mode 100644
index 00000000..e91ee55e
--- /dev/null
+++ b/src/reader/jma/7z.h
@@ -0,0 +1,29 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __7Z_H
+#define __7Z_H
+
+#include "iiostrm.h"
+
+bool decompress_lzma_7z(ISequentialInStream& in, unsigned in_size, ISequentialOutStream& out, unsigned out_size) throw ();
+bool decompress_lzma_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) throw ();
+
+#endif
+
diff --git a/src/reader/jma/7zlzma.cpp b/src/reader/jma/7zlzma.cpp
new file mode 100644
index 00000000..fae93f45
--- /dev/null
+++ b/src/reader/jma/7zlzma.cpp
@@ -0,0 +1,51 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "7z.h"
+
+#include "lzmadec.h"
+
+bool decompress_lzma_7z(ISequentialInStream& in, unsigned in_size, ISequentialOutStream& out, unsigned out_size) throw ()
+{
+  try
+  {
+    NCompress::NLZMA::CDecoder cc;
+
+    UINT64 in_size_l = in_size;
+    UINT64 out_size_l = out_size;
+
+    if (cc.ReadCoderProperties(&in) != S_OK)                 { return(false); }
+    if (cc.Code(&in, &out, &in_size_l, &out_size_l) != S_OK) { return(false); }
+    if (out.size_get() != out_size || out.overflow_get())    { return(false); }
+
+    return(true);
+  }
+  catch (...)
+  {
+    return(false);
+  }
+}
+
+bool decompress_lzma_7z(const unsigned char* in_data, unsigned int in_size, unsigned char* out_data, unsigned int out_size) throw ()
+{
+  ISequentialInStream_Array in(reinterpret_cast<const char*>(in_data), in_size);
+  ISequentialOutStream_Array out(reinterpret_cast<char*>(out_data), out_size);
+
+  return(decompress_lzma_7z(in, in_size, out, out_size));
+}
diff --git a/src/reader/jma/aribitcd.h b/src/reader/jma/aribitcd.h
new file mode 100644
index 00000000..1fb421ba
--- /dev/null
+++ b/src/reader/jma/aribitcd.h
@@ -0,0 +1,73 @@
+#ifndef __COMPRESSION_BITCODER_H
+#define __COMPRESSION_BITCODER_H
+
+#include "rngcoder.h"
+
+namespace NCompression {
+namespace NArithmetic {
+
+const int kNumBitModelTotalBits  = 11;
+const UINT32 kBitModelTotal = (1 << kNumBitModelTotalBits);
+
+const int kNumMoveReducingBits = 2;
+
+/////////////////////////////
+// CBitModel
+
+template <int aNumMoveBits>
+class CBitModel
+{
+public:
+  UINT32 m_Probability;
+  void UpdateModel(UINT32 aSymbol)
+  {
+    /*
+    m_Probability -= (m_Probability + ((aSymbol - 1) & ((1 << aNumMoveBits) - 1))) >> aNumMoveBits;
+    m_Probability += (1 - aSymbol) << (kNumBitModelTotalBits - aNumMoveBits);
+    */
+    if (aSymbol == 0)
+      m_Probability += (kBitModelTotal - m_Probability) >> aNumMoveBits;
+    else
+      m_Probability -= (m_Probability) >> aNumMoveBits;
+  }
+public:
+  void Init() { m_Probability = kBitModelTotal / 2; }
+};
+
+template <int aNumMoveBits>
+class CBitDecoder: public CBitModel<aNumMoveBits>
+{
+public:
+  UINT32 Decode(CRangeDecoder *aRangeDecoder)
+  {
+    UINT32 aNewBound = (aRangeDecoder->m_Range >> kNumBitModelTotalBits) * CBitModel<aNumMoveBits>::m_Probability;
+    if (aRangeDecoder->m_Code < aNewBound)
+    {
+      aRangeDecoder->m_Range = aNewBound;
+      CBitModel<aNumMoveBits>::m_Probability += (kBitModelTotal - CBitModel<aNumMoveBits>::m_Probability) >> aNumMoveBits;
+      if (aRangeDecoder->m_Range < kTopValue)
+      {
+        aRangeDecoder->m_Code = (aRangeDecoder->m_Code << 8) | aRangeDecoder->m_Stream.ReadByte();
+        aRangeDecoder->m_Range <<= 8;
+      }
+      return 0;
+    }
+    else
+    {
+      aRangeDecoder->m_Range -= aNewBound;
+      aRangeDecoder->m_Code -= aNewBound;
+      CBitModel<aNumMoveBits>::m_Probability -= (CBitModel<aNumMoveBits>::m_Probability) >> aNumMoveBits;
+      if (aRangeDecoder->m_Range < kTopValue)
+      {
+        aRangeDecoder->m_Code = (aRangeDecoder->m_Code << 8) | aRangeDecoder->m_Stream.ReadByte();
+        aRangeDecoder->m_Range <<= 8;
+      }
+      return 1;
+    }
+  }
+};
+
+}}
+
+
+#endif
diff --git a/src/reader/jma/ariconst.h b/src/reader/jma/ariconst.h
new file mode 100644
index 00000000..8cb0ead6
--- /dev/null
+++ b/src/reader/jma/ariconst.h
@@ -0,0 +1,30 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __ARICONST_H
+#define __ARICONST_H
+
+#include "aribitcd.h"
+
+
+typedef NCompression::NArithmetic::CRangeDecoder CMyRangeDecoder;
+template <int aNumMoveBits> class CMyBitDecoder:
+    public NCompression::NArithmetic::CBitDecoder<aNumMoveBits> {};
+
+#endif
diff --git a/src/reader/jma/ariprice.h b/src/reader/jma/ariprice.h
new file mode 100644
index 00000000..ccc398e1
--- /dev/null
+++ b/src/reader/jma/ariprice.h
@@ -0,0 +1,12 @@
+#ifndef __COMPRESSION_ARIPRICE_H
+#define __COMPRESSION_ARIPRICE_H
+
+namespace NCompression {
+namespace NArithmetic {
+
+const UINT32 kNumBitPriceShiftBits = 6;
+const UINT32 kBitPrice = 1 << kNumBitPriceShiftBits;
+
+}}
+
+#endif
diff --git a/src/reader/jma/btreecd.h b/src/reader/jma/btreecd.h
new file mode 100644
index 00000000..85f89b29
--- /dev/null
+++ b/src/reader/jma/btreecd.h
@@ -0,0 +1,127 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __BITTREECODER_H
+#define __BITTREECODER_H
+
+#include "aribitcd.h"
+#include "rcdefs.h"
+
+
+//////////////////////////
+// CBitTreeDecoder
+
+template <int aNumMoveBits, UINT32 m_NumBitLevels>
+class CBitTreeDecoder
+{
+  CMyBitDecoder<aNumMoveBits> m_Models[1 << m_NumBitLevels];
+public:
+  void Init()
+  {
+    for(UINT32 i = 1; i < (1 << m_NumBitLevels); i++)
+      m_Models[i].Init();
+  }
+  UINT32 Decode(CMyRangeDecoder *aRangeDecoder)
+  {
+    UINT32 aModelIndex = 1;
+    RC_INIT_VAR
+    for(UINT32 aBitIndex = m_NumBitLevels; aBitIndex > 0; aBitIndex--)
+    {
+      // aModelIndex = (aModelIndex << 1) + m_Models[aModelIndex].Decode(aRangeDecoder);
+      RC_GETBIT(aNumMoveBits, m_Models[aModelIndex].m_Probability, aModelIndex)
+    }
+    RC_FLUSH_VAR
+    return aModelIndex - (1 << m_NumBitLevels);
+  };
+};
+
+////////////////////////////////
+// CReverseBitTreeDecoder
+
+template <int aNumMoveBits>
+class CReverseBitTreeDecoder2
+{
+  CMyBitDecoder<aNumMoveBits> *m_Models;
+  UINT32 m_NumBitLevels;
+public:
+  CReverseBitTreeDecoder2(): m_Models(0) { }
+  ~CReverseBitTreeDecoder2() { delete []m_Models; }
+  bool Create(UINT32 aNumBitLevels)
+  {
+    m_NumBitLevels = aNumBitLevels;
+    m_Models = new CMyBitDecoder<aNumMoveBits>[1 << aNumBitLevels];
+    return (m_Models != 0);
+  }
+  void Init()
+  {
+    UINT32 aNumModels = 1 << m_NumBitLevels;
+    for(UINT32 i = 1; i < aNumModels; i++)
+      m_Models[i].Init();
+  }
+  UINT32 Decode(CMyRangeDecoder *aRangeDecoder)
+  {
+    UINT32 aModelIndex = 1;
+    UINT32 aSymbol = 0;
+    RC_INIT_VAR
+    for(UINT32 aBitIndex = 0; aBitIndex < m_NumBitLevels; aBitIndex++)
+    {
+      // UINT32 aBit = m_Models[aModelIndex].Decode(aRangeDecoder);
+      // aModelIndex <<= 1;
+      // aModelIndex += aBit;
+      // aSymbol |= (aBit << aBitIndex);
+      RC_GETBIT2(aNumMoveBits, m_Models[aModelIndex].m_Probability, aModelIndex, ; , aSymbol |= (1 << aBitIndex))
+    }
+    RC_FLUSH_VAR
+    return aSymbol;
+  };
+};
+////////////////////////////
+// CReverseBitTreeDecoder2
+
+template <int aNumMoveBits, UINT32 m_NumBitLevels>
+class CReverseBitTreeDecoder
+{
+  CMyBitDecoder<aNumMoveBits> m_Models[1 << m_NumBitLevels];
+public:
+  void Init()
+  {
+    for(UINT32 i = 1; i < (1 << m_NumBitLevels); i++)
+      m_Models[i].Init();
+  }
+  UINT32 Decode(CMyRangeDecoder *aRangeDecoder)
+  {
+    UINT32 aModelIndex = 1;
+    UINT32 aSymbol = 0;
+    RC_INIT_VAR
+    for(UINT32 aBitIndex = 0; aBitIndex < m_NumBitLevels; aBitIndex++)
+    {
+      // UINT32 aBit = m_Models[aModelIndex].Decode(aRangeDecoder);
+      // aModelIndex <<= 1;
+      // aModelIndex += aBit;
+      // aSymbol |= (aBit << aBitIndex);
+      RC_GETBIT2(aNumMoveBits, m_Models[aModelIndex].m_Probability, aModelIndex, ; , aSymbol |= (1 << aBitIndex))
+    }
+    RC_FLUSH_VAR
+    return aSymbol;
+  }
+};
+
+
+
+#endif
diff --git a/src/reader/jma/crc32.h b/src/reader/jma/crc32.h
new file mode 100644
index 00000000..c760dc7b
--- /dev/null
+++ b/src/reader/jma/crc32.h
@@ -0,0 +1,29 @@
+/*
+Copyright (C) 2004 NSRT Team ( http://nsrt.edgeemu.com )
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef CRC32_H
+#define CRC32_H
+
+namespace CRC32lib
+{
+  unsigned int CRC32(const unsigned char *, size_t, register unsigned int crc32 = 0xFFFFFFFF);
+  unsigned short SUM_CRC32(const unsigned char *, size_t, unsigned int &crc32);
+}
+
+#endif
diff --git a/src/reader/jma/iiostrm.cpp b/src/reader/jma/iiostrm.cpp
new file mode 100644
index 00000000..66cefb0c
--- /dev/null
+++ b/src/reader/jma/iiostrm.cpp
@@ -0,0 +1,133 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "portable.h"
+#include "iiostrm.h"
+#include "crc32.h"
+
+HRESULT ISequentialInStream_Array::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  if (aSize > size)
+  {
+    aSize = size;
+  }
+
+  *aProcessedSize = aSize;
+  memcpy(aData, data, aSize);
+  size -= aSize;
+  data += aSize;
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStream_Array::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  if (aSize > size)
+  {
+    overflow = true;
+    aSize = size;
+  }
+
+  *aProcessedSize = aSize;
+  memcpy(data, aData, aSize);
+  size -= aSize;
+  data += aSize;
+  total += aSize;
+  return(S_OK);
+}
+
+HRESULT ISequentialInStream_String::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  if (aSize > data.size())
+  {
+    aSize = data.size();
+  }
+
+  *aProcessedSize = aSize;
+  memcpy(aData, data.c_str(), aSize);
+  data.erase(0, aSize);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStream_String::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  *aProcessedSize = aSize;
+  data.append((const char *)aData, aSize);
+  total += aSize;
+  return(S_OK);
+}
+
+HRESULT ISequentialInStream_Istream::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  data.read((char *)aData, aSize);
+  *aProcessedSize = data.gcount();
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStream_Ostream::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  *aProcessedSize = aSize;
+  data.write((char *)aData, aSize);
+  total += aSize;
+  return(S_OK);
+}
+
+
+
+HRESULT ISequentialInStreamCRC32_Array::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialInStream_Array::Read(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStreamCRC32_Array::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialOutStream_Array::Write(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialInStreamCRC32_String::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialInStream_String::Read(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStreamCRC32_String::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialOutStream_String::Write(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialInStreamCRC32_Istream::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialInStream_Istream::Read(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStreamCRC32_Ostream::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialOutStream_Ostream::Write(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
diff --git a/src/reader/jma/iiostrm.h b/src/reader/jma/iiostrm.h
new file mode 100644
index 00000000..a5cb19ce
--- /dev/null
+++ b/src/reader/jma/iiostrm.h
@@ -0,0 +1,211 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __IINOUTSTREAMS_H
+#define __IINOUTSTREAMS_H
+
+#include <string>
+#include <fstream>
+
+#include "portable.h"
+
+
+class ISequentialInStream
+{
+public:
+  virtual HRESULT Read(void *, UINT32, UINT32 *) = 0;
+
+  virtual ~ISequentialInStream() {}
+};
+
+
+class ISequentialInStream_Array : public ISequentialInStream
+{
+  const char *data;
+  unsigned int size;
+public:
+  ISequentialInStream_Array(const char *Adata, unsigned Asize) : data(Adata), size(Asize) { }
+
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialInStream_Array() {}
+};
+
+class ISequentialInStream_String : public ISequentialInStream
+{
+  std::string& data;
+public:
+  ISequentialInStream_String(std::string& Adata) : data(Adata) { }
+
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialInStream_String() {}
+};
+
+class ISequentialInStream_Istream : public ISequentialInStream
+{
+  std::istream& data;
+public:
+  ISequentialInStream_Istream(std::istream& Adata) : data(Adata) { }
+
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialInStream_Istream() {}
+};
+
+
+
+class ISequentialOutStream
+{
+public:
+  virtual bool overflow_get() const = 0;
+  virtual unsigned int size_get() const = 0;
+
+  virtual HRESULT Write(const void *, UINT32, UINT32 *) = 0;
+
+  virtual ~ISequentialOutStream() {}
+};
+
+
+class ISequentialOutStream_Array : public ISequentialOutStream
+{
+  char *data;
+  unsigned int size;
+  bool overflow;
+  unsigned int total;
+public:
+  ISequentialOutStream_Array(char *Adata, unsigned Asize) : data(Adata), size(Asize), overflow(false), total(0) { }
+
+  bool overflow_get() const { return(overflow); }
+  unsigned int size_get() const { return(total); }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialOutStream_Array() {}
+};
+
+class ISequentialOutStream_String : public ISequentialOutStream
+{
+  std::string& data;
+  unsigned int total;
+public:
+  ISequentialOutStream_String(std::string& Adata) : data(Adata), total(0) { }
+
+  bool overflow_get() const { return(false); }
+  unsigned int size_get() const { return(total); }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialOutStream_String() {}
+};
+
+
+class ISequentialOutStream_Ostream : public ISequentialOutStream
+{
+  std::ostream& data;
+  unsigned int total;
+public:
+  ISequentialOutStream_Ostream(std::ostream& Adata) : data(Adata), total(0) { }
+
+  bool overflow_get() const { return(false); }
+  unsigned int size_get() const { return(total); }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialOutStream_Ostream() {}
+};
+
+
+
+class ISequentialStreamCRC32
+{
+protected:
+  unsigned int crc32;
+public:
+  ISequentialStreamCRC32() : crc32(0) {}
+  unsigned int crc32_get() const { return(crc32); }
+
+  virtual ~ISequentialStreamCRC32() {}
+};
+
+
+class ISequentialInStreamCRC32_Array : public ISequentialInStream_Array, public ISequentialStreamCRC32
+{
+public:
+  ISequentialInStreamCRC32_Array(const char *Adata, unsigned Asize) : ISequentialInStream_Array(Adata, Asize) { }
+
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialInStreamCRC32_Array() {}
+};
+
+class ISequentialInStreamCRC32_String : public ISequentialInStream_String, public ISequentialStreamCRC32
+{
+public:
+  ISequentialInStreamCRC32_String(std::string& Adata) : ISequentialInStream_String(Adata) { }
+
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialInStreamCRC32_String() {}
+};
+
+class ISequentialInStreamCRC32_Istream : public ISequentialInStream_Istream, public ISequentialStreamCRC32
+{
+public:
+  ISequentialInStreamCRC32_Istream(std::istream& Adata) : ISequentialInStream_Istream(Adata) { }
+
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialInStreamCRC32_Istream() {}
+};
+
+
+class ISequentialOutStreamCRC32_Array : public ISequentialOutStream_Array, public ISequentialStreamCRC32
+{
+public:
+  ISequentialOutStreamCRC32_Array(char *Adata, unsigned Asize) : ISequentialOutStream_Array(Adata, Asize) { }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialOutStreamCRC32_Array() {}
+};
+
+class ISequentialOutStreamCRC32_String : public ISequentialOutStream_String, public ISequentialStreamCRC32
+{
+public:
+  ISequentialOutStreamCRC32_String(std::string& Adata) : ISequentialOutStream_String(Adata) { }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialOutStreamCRC32_String() {}
+};
+
+
+class ISequentialOutStreamCRC32_Ostream : public ISequentialOutStream_Ostream, public ISequentialStreamCRC32
+{
+public:
+  ISequentialOutStreamCRC32_Ostream(std::ostream& Adata) : ISequentialOutStream_Ostream(Adata) { }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+
+  virtual ~ISequentialOutStreamCRC32_Ostream() {}
+};
+
+#endif
diff --git a/src/reader/jma/inbyte.cpp b/src/reader/jma/inbyte.cpp
new file mode 100644
index 00000000..436309e2
--- /dev/null
+++ b/src/reader/jma/inbyte.cpp
@@ -0,0 +1,61 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "inbyte.h"
+
+namespace NStream{
+
+CInByte::CInByte(UINT32 aBufferSize):
+  m_BufferBase(0),
+  m_BufferSize(aBufferSize)
+{
+  m_BufferBase = new BYTE[m_BufferSize];
+}
+
+CInByte::~CInByte()
+{
+  delete []m_BufferBase;
+}
+
+void CInByte::Init(ISequentialInStream *aStream)
+{
+  m_Stream = aStream;
+  m_ProcessedSize = 0;
+  m_Buffer = m_BufferBase;
+  m_BufferLimit = m_Buffer;
+  m_StreamWasExhausted = false;
+}
+
+bool CInByte::ReadBlock()
+{
+  if (m_StreamWasExhausted)
+    return false;
+  m_ProcessedSize += (m_Buffer - m_BufferBase);
+  UINT32 aNumProcessedBytes;
+  HRESULT aResult = m_Stream->Read(m_BufferBase, m_BufferSize, &aNumProcessedBytes);
+  if (aResult != S_OK)
+    throw aResult;
+  m_Buffer = m_BufferBase;
+  m_BufferLimit = m_Buffer + aNumProcessedBytes;
+  m_StreamWasExhausted = (aNumProcessedBytes == 0);
+  return (!m_StreamWasExhausted);
+}
+
+}
diff --git a/src/reader/jma/inbyte.h b/src/reader/jma/inbyte.h
new file mode 100644
index 00000000..705065fe
--- /dev/null
+++ b/src/reader/jma/inbyte.h
@@ -0,0 +1,77 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __STREAM_INBYTE_H
+#define __STREAM_INBYTE_H
+
+#include "iiostrm.h"
+
+namespace NStream {
+
+class CInByte
+{
+  UINT64 m_ProcessedSize;
+  BYTE *m_BufferBase;
+  UINT32 m_BufferSize;
+  BYTE *m_Buffer;
+  BYTE *m_BufferLimit;
+  ISequentialInStream* m_Stream;
+  bool m_StreamWasExhausted;
+
+  bool ReadBlock();
+
+public:
+  CInByte(UINT32 aBufferSize = 0x100000);
+  ~CInByte();
+
+  void Init(ISequentialInStream *aStream);
+
+  bool ReadByte(BYTE &aByte)
+    {
+      if(m_Buffer >= m_BufferLimit)
+        if(!ReadBlock())
+          return false;
+      aByte = *m_Buffer++;
+      return true;
+    }
+  BYTE ReadByte()
+    {
+      if(m_Buffer >= m_BufferLimit)
+        if(!ReadBlock())
+          return 0x0;
+      return *m_Buffer++;
+    }
+  void ReadBytes(void *aData, UINT32 aSize, UINT32 &aProcessedSize)
+    {
+      for(aProcessedSize = 0; aProcessedSize < aSize; aProcessedSize++)
+        if (!ReadByte(((BYTE *)aData)[aProcessedSize]))
+          return;
+    }
+  bool ReadBytes(void *aData, UINT32 aSize)
+    {
+      UINT32 aProcessedSize;
+      ReadBytes(aData, aSize, aProcessedSize);
+      return (aProcessedSize == aSize);
+    }
+  UINT64 GetProcessedSize() const { return m_ProcessedSize + (m_Buffer - m_BufferBase); }
+};
+
+}
+
+#endif
diff --git a/src/reader/jma/jcrc32.cpp b/src/reader/jma/jcrc32.cpp
new file mode 100644
index 00000000..efa92680
--- /dev/null
+++ b/src/reader/jma/jcrc32.cpp
@@ -0,0 +1,82 @@
+/*
+Copyright (C) 2004 NSRT Team ( http://nsrt.edgeemu.com )
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <stdlib.h>
+
+namespace CRC32lib
+{
+  //Don't ask questions, this is the PKZip CRC32 table
+  const unsigned int crc32Table[256] = {
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+  0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+  0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+  0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+  0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+  0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+  0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+  0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+  0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+  0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+  0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+  0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+  0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+  0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+  0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+  0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+  0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+  0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+  0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+  0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+  0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+  0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d };
+
+
+  //CRC32 for char arrays
+  unsigned int CRC32(const unsigned char *array, size_t size, register unsigned int crc32)
+  {
+    const unsigned char *end_p = array+size;
+    for (register const unsigned char *p = array; p < end_p; p++)
+    {
+      crc32 = ((crc32 >> 8) & 0x00FFFFFF) ^ crc32Table[(crc32 ^ *p) & 0xFF];
+    }
+
+    return(~crc32);
+  }
+}
diff --git a/src/reader/jma/jma.cpp b/src/reader/jma/jma.cpp
new file mode 100644
index 00000000..be2f00c1
--- /dev/null
+++ b/src/reader/jma/jma.cpp
@@ -0,0 +1,552 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <sstream>
+#include "jma.h"
+using namespace std;
+
+#include "portable.h"
+#include "7z.h"
+#include "crc32.h"
+
+namespace JMA
+{
+  const char jma_magic[] = { 'J', 'M', 'A', 0, 'N' };
+  const unsigned int jma_header_length = 5;
+  const unsigned char jma_version = 1;
+  const unsigned int jma_version_length = 1;
+  const unsigned int jma_total_header_length = jma_header_length + jma_version_length + UINT_SIZE;
+
+  //Convert DOS/zip/JMA integer time to to time_t
+  time_t uint_to_time(unsigned short date, unsigned short time)
+  {
+    tm formatted_time;
+
+    formatted_time.tm_mday = date & 0x1F;
+    formatted_time.tm_mon  = ((date >> 5) & 0xF) - 1;
+    formatted_time.tm_year = ((date >> 9) & 0x7f) + 80;
+    formatted_time.tm_sec  = (time & 0x1F) * 2;
+    formatted_time.tm_min  = (time >> 5) & 0x3F;
+    formatted_time.tm_hour = (time >> 11) & 0x1F;
+
+    return(mktime(&formatted_time));
+  }
+
+
+  //Retreive the file block, what else?
+  void jma_open::retrieve_file_block() throw(jma_errors)
+  {
+    unsigned char uint_buffer[UINT_SIZE];
+    unsigned char ushort_buffer[USHORT_SIZE];
+
+    //File block size is the last UINT in the file
+    stream.seekg(-UINT_SIZE,ios::end);
+    stream.read((char *)uint_buffer, UINT_SIZE);
+    size_t file_block_size = charp_to_uint(uint_buffer);
+
+    //Currently at the end of the file, so that's the file size
+    size_t jma_file_size = stream.tellg();
+
+    //The file block can't be larger than the JMA file without it's header.
+    //This if can probably be improved
+    if (file_block_size >= jma_file_size-jma_total_header_length)
+    {
+      throw(JMA_BAD_FILE);
+    }
+
+    //Seek to before file block so we can read the file block
+    stream.seekg(-((int)file_block_size+UINT_SIZE),ios::end);
+
+    //This is needed if the file block is compressed
+    stringstream decompressed_file_block;
+    //Pointer to where to read file block from (file or decompressed buffer)
+    istream *file_block_stream;
+
+    //Setup file info buffer and byte to read with
+    jma_file_info file_info;
+    char byte;
+
+    stream.get(byte);
+    if (!byte) //If file block is compressed
+    {
+      //Compressed size isn't counting the byte we just read or the UINT for compressed size
+      size_t compressed_size = file_block_size - (1+UINT_SIZE);
+
+      //Read decompressed size / true file block size
+      stream.read((char *)uint_buffer, UINT_SIZE);
+      file_block_size = charp_to_uint(uint_buffer);
+
+      //Setup access methods for decompression
+      ISequentialInStream_Istream compressed_data(stream);
+      ISequentialOutStream_Ostream decompressed_data(decompressed_file_block);
+
+      //Decompress the data
+      if (!decompress_lzma_7z(compressed_data, compressed_size, decompressed_data, file_block_size))
+      {
+        throw(JMA_DECOMPRESS_FAILED);
+      }
+
+      //Go to beginning, setup pointer to buffer
+      decompressed_file_block.seekg(0, ios::beg);
+      file_block_stream = &decompressed_file_block;
+    }
+    else
+    {
+      stream.putback(byte); //Putback byte, byte is part of filename, not compressed indicator
+      file_block_stream = &stream;
+    }
+
+
+    //Minimum file name length is 2 bytes, a char and a null
+    //Minimum comment length is 1 byte, a null
+    //There are currently 2 UINTs and 2 USHORTs per file
+    while (file_block_size >= 2+1+UINT_SIZE*2+USHORT_SIZE*2) //This does allow for a gap, but that's okay
+    {
+      //First stored in the file block is the file name null terminated
+      file_info.name = "";
+
+      file_block_stream->get(byte);
+      while (byte)
+      {
+        file_info.name += byte;
+        file_block_stream->get(byte);
+      }
+
+      //There must be a file name or the file is bad
+      if (!file_info.name.length())
+      {
+        throw(JMA_BAD_FILE);
+      }
+
+      //Same trick as above for the comment
+      file_info.comment = "";
+
+      file_block_stream->get(byte);
+      while (byte)
+      {
+        file_info.comment += byte;
+        file_block_stream->get(byte);
+      }
+
+      //Next is a UINT representing the file's size
+      file_block_stream->read((char *)uint_buffer, UINT_SIZE);
+      file_info.size = charp_to_uint(uint_buffer);
+
+      //Followed by CRC32
+      file_block_stream->read((char *)uint_buffer, UINT_SIZE);
+      file_info.crc32 = charp_to_uint(uint_buffer);
+
+      //Special USHORT representation of file's date
+      file_block_stream->read((char *)ushort_buffer, USHORT_SIZE);
+      file_info.date = charp_to_ushort(ushort_buffer);
+
+      //Special USHORT representation of file's time
+      file_block_stream->read((char *)ushort_buffer, USHORT_SIZE);
+      file_info.time = charp_to_ushort(ushort_buffer);
+
+      file_info.buffer = 0; //Pointing to null till we decompress files
+
+      files.push_back(file_info); //Put file info into our structure
+
+      //Subtract size of the file info we just read
+      file_block_size -= file_info.name.length()+file_info.comment.length()+2+UINT_SIZE*2+USHORT_SIZE*2;
+    }
+  }
+
+  //Constructor for opening JMA files for reading
+  jma_open::jma_open(const char *compressed_file_name) throw (jma_errors)
+  {
+    decompressed_buffer = 0;
+    compressed_buffer = 0;
+
+    stream.open(compressed_file_name, ios::in | ios::binary);
+    if (!stream.is_open())
+    {
+      throw(JMA_NO_OPEN);
+    }
+
+    //Header is "JMA\0N"
+    unsigned char header[jma_header_length];
+    stream.read((char *)header, jma_header_length);
+    if (memcmp(jma_magic, header, jma_header_length))
+    {
+      throw(JMA_BAD_FILE);
+    }
+
+    //Not the cleanest code but logical
+    stream.read((char *)header, 5);
+    if (*header <= jma_version)
+    {
+      chunk_size = charp_to_uint(header+1); //Chunk size is a UINT that follows version #
+      retrieve_file_block();
+    }
+    else
+    {
+      throw(JMA_UNSUPPORTED_VERSION);
+    }
+  }
+
+  //Destructor only has to close the stream if neccesary
+  jma_open::~jma_open()
+  {
+    if (stream.is_open())
+    {
+      stream.close();
+    }
+  }
+
+  //Return a vector containing useful info about the files in the JMA
+  vector<jma_public_file_info> jma_open::get_files_info()
+  {
+    vector<jma_public_file_info> file_info_vector;
+    jma_public_file_info file_info;
+
+    for (vector<jma_file_info>::iterator i = files.begin(); i != files.end(); i++)
+    {
+      file_info.name = i->name;
+      file_info.comment = i->comment;
+      file_info.size = i->size;
+      file_info.datetime = uint_to_time(i->date, i->time);
+      file_info.crc32 = i->crc32;
+      file_info_vector.push_back(file_info);
+    }
+
+    return(file_info_vector);
+  }
+
+  //Skip forward a given number of chunks
+  void jma_open::chunk_seek(unsigned int chunk_num) throw(jma_errors)
+  {
+    //Check the stream is open
+    if (!stream.is_open())
+    {
+      throw(JMA_NO_OPEN);
+    }
+
+    //Clear possible errors so the seek will work
+    stream.clear();
+
+    //Move forward over header
+    stream.seekg(jma_total_header_length, ios::beg);
+
+    unsigned char int4_buffer[UINT_SIZE];
+
+    while (chunk_num--)
+    {
+      //Read in size of chunk
+      stream.read((char *)int4_buffer, UINT_SIZE);
+
+      //Skip chunk plus it's CRC32
+      stream.seekg(charp_to_uint(int4_buffer)+UINT_SIZE, ios::cur);
+    }
+  }
+
+  //Return a vector of pointers to each file in the JMA, the buffer to hold all the files
+  //must be initilized outside.
+  vector<unsigned char *> jma_open::get_all_files(unsigned char *buffer) throw(jma_errors)
+  {
+    //If there's no stream we can't read from it, so exit
+    if (!stream.is_open())
+    {
+      throw(JMA_NO_OPEN);
+    }
+
+    //Seek to the first chunk
+    chunk_seek(0);
+
+    //Set the buffer that decompressed data goes to
+    decompressed_buffer = buffer;
+
+    //If the JMA is not solid
+    if (chunk_size)
+    {
+      unsigned char int4_buffer[UINT_SIZE];
+      size_t size = get_total_size(files);
+
+      //For each chunk in the file...
+      for (size_t remaining_size = size; remaining_size; remaining_size -= chunk_size)
+      {
+        //Read the compressed size
+        stream.read((char *)int4_buffer, UINT_SIZE);
+        size_t compressed_size = charp_to_uint(int4_buffer);
+
+        //Allocate memory of the correct size to hold the compressed data in the JMA
+        //Throw error on failure as that is unrecoverable from
+        try
+        {
+          compressed_buffer = new unsigned char[compressed_size];
+        }
+        catch (bad_alloc xa)
+        {
+          throw(JMA_NO_MEM_ALLOC);
+        }
+
+        //Read all the compressed data in
+        stream.read((char *)compressed_buffer, compressed_size);
+
+        //Read the expected CRC of compressed data from the file
+        stream.read((char *)int4_buffer, UINT_SIZE);
+
+        //If it doesn't match, throw error and cleanup memory
+        if (CRC32lib::CRC32(compressed_buffer, compressed_size) != charp_to_uint(int4_buffer))
+        {
+          delete[] compressed_buffer;
+          throw(JMA_BAD_FILE);
+        }
+
+        //Decompress the data, cleanup memory on failure
+        if (!decompress_lzma_7z(compressed_buffer, compressed_size,
+                                decompressed_buffer+size-remaining_size,
+                                (remaining_size > chunk_size) ? chunk_size : remaining_size))
+        {
+          delete[] compressed_buffer;
+          throw(JMA_DECOMPRESS_FAILED);
+        }
+        delete[] compressed_buffer;
+
+        if (remaining_size <= chunk_size) //If we just decompressed the remainder
+        {
+          break;
+        }
+      }
+    }
+    else //Solidly compressed JMA
+    {
+      unsigned char int4_buffer[UINT_SIZE];
+
+      //Read the size of the compressed data
+      stream.read((char *)int4_buffer, UINT_SIZE);
+      size_t compressed_size = charp_to_uint(int4_buffer);
+
+      //Get decompressed size
+      size_t size = get_total_size(files);
+
+      //Setup access methods for decompression
+      ISequentialInStream_Istream compressed_data(stream);
+      ISequentialOutStream_Array decompressed_data(reinterpret_cast<char*>(decompressed_buffer), size);
+
+      //Decompress the data
+      if (!decompress_lzma_7z(compressed_data, compressed_size, decompressed_data, size))
+      {
+        throw(JMA_DECOMPRESS_FAILED);
+      }
+
+      /*
+      //Allocate memory of the right size to hold the compressed data in the JMA
+      try
+      {
+        compressed_buffer = new unsigned char[compressed_size];
+      }
+      catch (bad_alloc xa)
+      {
+        throw(JMA_NO_MEM_ALLOC);
+      }
+
+      //Copy the compressed data into memory
+      stream.read((char *)compressed_buffer, compressed_size);
+      size_t size = get_total_size(files);
+
+      //Read the CRC of the compressed data
+      stream.read((char *)int4_buffer, UINT_SIZE);
+
+      //If it doesn't match, complain
+      if (CRC32lib::CRC32(compressed_buffer, compressed_size) != charp_to_uint(int4_buffer))
+      {
+        delete[] compressed_buffer;
+        throw(JMA_BAD_FILE);
+      }
+
+      //Decompress the data
+      if (!decompress_lzma_7z(compressed_buffer, compressed_size, decompressed_buffer, size))
+      {
+        delete[] compressed_buffer;
+        throw(JMA_DECOMPRESS_FAILED);
+      }
+      delete[] compressed_buffer;
+      */
+    }
+
+    vector<unsigned char *> file_pointers;
+    size_t size = 0;
+
+    //For each file, add it's pointer to the vector, size is pointer offset in the buffer
+    for (vector<jma_file_info>::iterator i = files.begin(); i != files.end(); i++)
+    {
+      i->buffer = decompressed_buffer+size;
+      file_pointers.push_back(decompressed_buffer+size);
+      size += i->size;
+    }
+
+    //Return the vector of pointers
+    return(file_pointers);
+  }
+
+  //Extracts the file with a given name found in the archive to the given buffer
+  void jma_open::extract_file(string& name, unsigned char *buffer) throw(jma_errors)
+  {
+    if (!stream.is_open())
+    {
+      throw(JMA_NO_OPEN);
+    }
+
+    size_t size_to_skip = 0;
+    size_t our_file_size = 0;
+
+    //Search through the vector of file information
+    for (vector<jma_file_info>::iterator i = files.begin(); i != files.end(); i++)
+    {
+      if (i->name == name)
+      {
+        //Set the variable so we can tell we found it
+        our_file_size = i->size;
+        break;
+      }
+
+      //Keep a running total of size
+      size_to_skip += i->size;
+    }
+
+    if (!our_file_size) //File with the specified name was not found in the archive
+    {
+      throw(JMA_FILE_NOT_FOUND);
+    }
+
+    //If the JMA only contains one file, we can skip a lot of overhead
+    if (files.size() == 1)
+    {
+      get_all_files(buffer);
+      return;
+    }
+
+    if (chunk_size) //we are using non-solid archive..
+    {
+      unsigned int chunks_to_skip = size_to_skip / chunk_size;
+
+      //skip over requisite number of chunks
+      chunk_seek(chunks_to_skip);
+
+      //Allocate memory for compressed and decompressed data
+      unsigned char *comp_buffer = 0, *decomp_buffer = 0;
+      try
+      {
+        //Compressed data size is <= non compressed size
+        unsigned char *combined_buffer = new unsigned char[chunk_size*2];
+        comp_buffer = combined_buffer;
+        decomp_buffer = combined_buffer+chunk_size;
+      }
+      catch (bad_alloc xa)
+      {
+        throw(JMA_NO_MEM_ALLOC);
+      }
+
+      size_t first_chunk_offset = size_to_skip % chunk_size;
+      unsigned char int4_buffer[UINT_SIZE];
+      for (size_t i = 0; i < our_file_size;)
+      {
+        //Get size
+        stream.read((char *)int4_buffer, UINT_SIZE);
+        size_t compressed_size = charp_to_uint(int4_buffer);
+
+        //Read all the compressed data in
+        stream.read((char *)comp_buffer, compressed_size);
+
+        //Read the CRC of the compressed data
+        stream.read((char *)int4_buffer, UINT_SIZE);
+
+        //If it doesn't match, complain
+        if (CRC32lib::CRC32(comp_buffer, compressed_size) != charp_to_uint(int4_buffer))
+        {
+          delete[] comp_buffer;
+          throw(JMA_BAD_FILE);
+        }
+
+        //Decompress chunk
+        if (!decompress_lzma_7z(comp_buffer, compressed_size, decomp_buffer, chunk_size))
+        {
+          delete[] comp_buffer;
+          throw(JMA_DECOMPRESS_FAILED);
+        }
+
+        size_t copy_amount = our_file_size-i > chunk_size-first_chunk_offset ? chunk_size-first_chunk_offset : our_file_size-i;
+
+        memcpy(buffer+i, decomp_buffer+first_chunk_offset, copy_amount);
+        first_chunk_offset = 0; //Set to zero since this is only for the first iteration
+        i += copy_amount;
+      }
+      delete[] comp_buffer;
+    }
+    else //Solid JMA
+    {
+      unsigned char *decomp_buffer = 0;
+      try
+      {
+        decomp_buffer = new unsigned char[get_total_size(files)];
+      }
+      catch (bad_alloc xa)
+      {
+        throw(JMA_NO_MEM_ALLOC);
+      }
+
+      get_all_files(decomp_buffer);
+
+      memcpy(buffer, decomp_buffer+size_to_skip, our_file_size);
+
+      delete[] decomp_buffer;
+    }
+  }
+
+  bool jma_open::is_solid()
+  {
+    return(chunk_size ? false : true);
+  }
+
+  const char *jma_error_text(jma_errors error)
+  {
+    switch (error)
+    {
+      case JMA_NO_CREATE:
+        return("JMA could not be created");
+
+      case JMA_NO_MEM_ALLOC:
+        return("Memory for JMA could be allocated");
+
+      case JMA_NO_OPEN:
+        return("JMA could not be opened");
+
+      case JMA_BAD_FILE:
+        return("Invalid/Corrupt JMA");
+
+      case JMA_UNSUPPORTED_VERSION:
+        return("JMA version not supported");
+
+      case JMA_COMPRESS_FAILED:
+        return("JMA compression failed");
+
+      case JMA_DECOMPRESS_FAILED:
+        return("JMA decompression failed");
+
+      case JMA_FILE_NOT_FOUND:
+        return("File not found in JMA");
+    }
+    return("Unknown error");
+  }
+
+}
+
+
diff --git a/src/reader/jma/jma.h b/src/reader/jma/jma.h
new file mode 100644
index 00000000..d5268721
--- /dev/null
+++ b/src/reader/jma/jma.h
@@ -0,0 +1,90 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef JMA_H
+#define JMA_H
+
+#include <string>
+#include <fstream>
+#include <vector>
+#include <time.h>
+
+namespace JMA
+{
+  enum jma_errors { JMA_NO_CREATE, JMA_NO_MEM_ALLOC, JMA_NO_OPEN, JMA_BAD_FILE,
+                    JMA_UNSUPPORTED_VERSION, JMA_COMPRESS_FAILED, JMA_DECOMPRESS_FAILED,
+                    JMA_FILE_NOT_FOUND };
+
+  struct jma_file_info_base
+  {
+    std::string name;
+    std::string comment;
+    size_t size;
+    unsigned int crc32;
+  };
+
+  struct jma_public_file_info : jma_file_info_base
+  {
+    time_t datetime;
+  };
+
+  struct jma_file_info : jma_file_info_base
+  {
+    unsigned short date;
+    unsigned short time;
+    const unsigned char *buffer;
+  };
+
+  template<class jma_file_type>
+  inline size_t get_total_size(std::vector<jma_file_type>& files)
+  {
+    size_t size = 0;
+    for (typename std::vector<jma_file_type>::iterator i = files.begin(); i != files.end(); i++)
+    {
+      size += i->size; //We do have a problem if this wraps around
+    }
+
+    return(size);
+  }
+
+  class jma_open
+  {
+    public:
+    jma_open(const char *) throw(jma_errors);
+    ~jma_open();
+
+    std::vector<jma_public_file_info> get_files_info();
+    std::vector<unsigned char *> get_all_files(unsigned char *) throw(jma_errors);
+    void extract_file(std::string& name, unsigned char *) throw(jma_errors);
+    bool is_solid();
+
+    private:
+    std::ifstream stream;
+    std::vector<jma_file_info> files;
+    size_t chunk_size;
+    unsigned char *decompressed_buffer;
+    unsigned char *compressed_buffer;
+
+    void chunk_seek(unsigned int) throw(jma_errors);
+    void retrieve_file_block() throw(jma_errors);
+  };
+
+  const char *jma_error_text(jma_errors);
+}
+#endif
diff --git a/src/reader/jma/lencoder.h b/src/reader/jma/lencoder.h
new file mode 100644
index 00000000..5fe9cc63
--- /dev/null
+++ b/src/reader/jma/lencoder.h
@@ -0,0 +1,94 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __LENCODER_H
+#define __LENCODER_H
+
+#include "btreecd.h"
+
+namespace NLength {
+
+const UINT32 kNumPosStatesBitsMax = 4;
+const int kNumPosStatesMax = (1 << kNumPosStatesBitsMax);
+
+
+const int kNumPosStatesBitsEncodingMax = 4;
+const int kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);
+
+
+const int kNumMoveBits = 5;
+
+const int kNumLenBits = 3;
+const int kNumLowSymbols = 1 << kNumLenBits;
+const int kNumMidBits = 3;
+const int kNumMidSymbols = 1 << kNumMidBits;
+
+const int kNumHighBits = 8;
+
+const int kNumSymbolsTotal = kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits);
+
+const int kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols;
+
+class CDecoder
+{
+  CMyBitDecoder<kNumMoveBits> m_Choice;
+  CBitTreeDecoder<kNumMoveBits, kNumLenBits>  m_LowCoder[kNumPosStatesMax];
+  CMyBitDecoder<kNumMoveBits> m_Choice2;
+  CBitTreeDecoder<kNumMoveBits, kNumMidBits>  m_MidCoder[kNumPosStatesMax];
+  CBitTreeDecoder<kNumMoveBits, kNumHighBits> m_HighCoder;
+  UINT32 m_NumPosStates;
+public:
+  void Create(UINT32 aNumPosStates)
+    { m_NumPosStates = aNumPosStates; }
+  void Init()
+  {
+    m_Choice.Init();
+    for (UINT32 aPosState = 0; aPosState < m_NumPosStates; aPosState++)
+    {
+      m_LowCoder[aPosState].Init();
+      m_MidCoder[aPosState].Init();
+    }
+    m_Choice2.Init();
+    m_HighCoder.Init();
+  }
+  UINT32 Decode(CMyRangeDecoder *aRangeDecoder, UINT32 aPosState)
+  {
+    if(m_Choice.Decode(aRangeDecoder) == 0)
+      return m_LowCoder[aPosState].Decode(aRangeDecoder);
+    else
+    {
+      UINT32 aSymbol = kNumLowSymbols;
+      if(m_Choice2.Decode(aRangeDecoder) == 0)
+        aSymbol += m_MidCoder[aPosState].Decode(aRangeDecoder);
+      else
+      {
+        aSymbol += kNumMidSymbols;
+        aSymbol += m_HighCoder.Decode(aRangeDecoder);
+      }
+      return aSymbol;
+    }
+  }
+
+};
+
+}
+
+
+#endif
diff --git a/src/reader/jma/litcoder.h b/src/reader/jma/litcoder.h
new file mode 100644
index 00000000..c5ad476f
--- /dev/null
+++ b/src/reader/jma/litcoder.h
@@ -0,0 +1,123 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __LITERALCODER_H
+#define __LITERALCODER_H
+
+#include "aribitcd.h"
+#include "rcdefs.h"
+
+namespace NLiteral {
+
+const int kNumMoveBits = 5;
+
+class CDecoder2
+{
+  CMyBitDecoder<kNumMoveBits> m_Decoders[3][1 << 8];
+public:
+  void Init()
+  {
+    for (int i = 0; i < 3; i++)
+      for (int j = 1; j < (1 << 8); j++)
+        m_Decoders[i][j].Init();
+  }
+
+  BYTE DecodeNormal(CMyRangeDecoder *aRangeDecoder)
+  {
+    UINT32 aSymbol = 1;
+    RC_INIT_VAR
+    do
+    {
+      // aSymbol = (aSymbol << 1) | m_Decoders[0][aSymbol].Decode(aRangeDecoder);
+      RC_GETBIT(kNumMoveBits, m_Decoders[0][aSymbol].m_Probability, aSymbol)
+    }
+    while (aSymbol < 0x100);
+    RC_FLUSH_VAR
+    return aSymbol;
+  }
+
+  BYTE DecodeWithMatchByte(CMyRangeDecoder *aRangeDecoder, BYTE aMatchByte)
+  {
+    UINT32 aSymbol = 1;
+    RC_INIT_VAR
+    do
+    {
+      UINT32 aMatchBit = (aMatchByte >> 7) & 1;
+      aMatchByte <<= 1;
+      // UINT32 aBit = m_Decoders[1 + aMatchBit][aSymbol].Decode(aRangeDecoder);
+      // aSymbol = (aSymbol << 1) | aBit;
+      UINT32 aBit;
+      RC_GETBIT2(kNumMoveBits, m_Decoders[1 + aMatchBit][aSymbol].m_Probability, aSymbol,
+          aBit = 0, aBit = 1)
+      if (aMatchBit != aBit)
+      {
+        while (aSymbol < 0x100)
+        {
+          // aSymbol = (aSymbol << 1) | m_Decoders[0][aSymbol].Decode(aRangeDecoder);
+          RC_GETBIT(kNumMoveBits, m_Decoders[0][aSymbol].m_Probability, aSymbol)
+        }
+        break;
+      }
+    }
+    while (aSymbol < 0x100);
+    RC_FLUSH_VAR
+    return aSymbol;
+  }
+};
+
+class CDecoder
+{
+  CDecoder2 *m_Coders;
+  UINT32 m_NumPrevBits;
+  UINT32 m_NumPosBits;
+  UINT32 m_PosMask;
+public:
+  CDecoder(): m_Coders(0) {}
+  ~CDecoder()  { Free(); }
+  void Free()
+  {
+    delete []m_Coders;
+    m_Coders = 0;
+  }
+  void Create(UINT32 aNumPosBits, UINT32 aNumPrevBits)
+  {
+    Free();
+    m_NumPosBits = aNumPosBits;
+    m_PosMask = (1 << aNumPosBits) - 1;
+    m_NumPrevBits = aNumPrevBits;
+    UINT32 aNumStates = 1 << (m_NumPrevBits + m_NumPosBits);
+    m_Coders = new CDecoder2[aNumStates];
+  }
+  void Init()
+  {
+    UINT32 aNumStates = 1 << (m_NumPrevBits + m_NumPosBits);
+    for (UINT32 i = 0; i < aNumStates; i++)
+      m_Coders[i].Init();
+  }
+  UINT32 GetState(UINT32 aPos, BYTE aPrevByte) const
+    { return ((aPos & m_PosMask) << m_NumPrevBits) + (aPrevByte >> (8 - m_NumPrevBits)); }
+  BYTE DecodeNormal(CMyRangeDecoder *aRangeDecoder, UINT32 aPos, BYTE aPrevByte)
+    { return m_Coders[GetState(aPos, aPrevByte)].DecodeNormal(aRangeDecoder); }
+  BYTE DecodeWithMatchByte(CMyRangeDecoder *aRangeDecoder, UINT32 aPos, BYTE aPrevByte, BYTE aMatchByte)
+    { return m_Coders[GetState(aPos, aPrevByte)].DecodeWithMatchByte(aRangeDecoder, aMatchByte); }
+};
+
+}
+
+#endif
diff --git a/src/reader/jma/lzma.cpp b/src/reader/jma/lzma.cpp
new file mode 100644
index 00000000..d994be5f
--- /dev/null
+++ b/src/reader/jma/lzma.cpp
@@ -0,0 +1,42 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "lzma.h"
+
+namespace NCompress {
+namespace NLZMA {
+
+UINT32 kDistStart[kDistTableSizeMax];
+
+static class CConstInit
+{
+public:
+  CConstInit()
+  {
+    UINT32 aStartValue = 0;
+    int i;
+    for (i = 0; i < kDistTableSizeMax; i++)
+    {
+      kDistStart[i] = aStartValue;
+      aStartValue += (1 << kDistDirectBits[i]);
+    }
+  }
+} g_ConstInit;
+
+}}
diff --git a/src/reader/jma/lzma.h b/src/reader/jma/lzma.h
new file mode 100644
index 00000000..fc6a2fd7
--- /dev/null
+++ b/src/reader/jma/lzma.h
@@ -0,0 +1,125 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "lencoder.h"
+
+#ifndef __LZMA_H
+#define __LZMA_H
+
+namespace NCompress {
+namespace NLZMA {
+
+const UINT32 kNumRepDistances = 4;
+
+const BYTE kNumStates = 12;
+
+const BYTE kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4,  5,  6,   4, 5};
+const BYTE kMatchNextStates[kNumStates]   = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
+const BYTE kRepNextStates[kNumStates]     = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
+const BYTE kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
+
+class CState
+{
+public:
+  BYTE m_Index;
+  void Init()
+    { m_Index = 0; }
+  void UpdateChar()
+    { m_Index = kLiteralNextStates[m_Index]; }
+  void UpdateMatch()
+    { m_Index = kMatchNextStates[m_Index]; }
+  void UpdateRep()
+    { m_Index = kRepNextStates[m_Index]; }
+  void UpdateShortRep()
+    { m_Index = kShortRepNextStates[m_Index]; }
+};
+
+class CBaseCoder
+{
+protected:
+  CState m_State;
+  BYTE m_PreviousByte;
+  bool m_PeviousIsMatch;
+  UINT32 m_RepDistances[kNumRepDistances];
+  void Init()
+  {
+    m_State.Init();
+    m_PreviousByte = 0;
+    m_PeviousIsMatch = false;
+    for(UINT32 i = 0 ; i < kNumRepDistances; i++)
+      m_RepDistances[i] = 0;
+  }
+};
+
+const int kNumPosSlotBits = 6;
+const int kDicLogSizeMax = 28;
+const int kDistTableSizeMax = kDicLogSizeMax * 2;
+
+extern UINT32 kDistStart[kDistTableSizeMax];
+const BYTE kDistDirectBits[kDistTableSizeMax] =
+{
+  0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
+  10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19,
+  20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26
+};
+
+const UINT32 kNumLenToPosStates = 4;
+inline UINT32 GetLenToPosState(UINT32 aLen)
+{
+  aLen -= 2;
+  if (aLen < kNumLenToPosStates)
+    return aLen;
+  return kNumLenToPosStates - 1;
+}
+
+const int kMatchMinLen = 2;
+
+const int kMatchMaxLen = kMatchMinLen + NLength::kNumSymbolsTotal - 1;
+
+const int kNumAlignBits = 4;
+const int kAlignTableSize = 1 << kNumAlignBits;
+const UINT32 kAlignMask = (kAlignTableSize - 1);
+
+const int kStartPosModelIndex = 4;
+const int kEndPosModelIndex = 14;
+const int kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
+
+const int kNumFullDistances = 1 << (kEndPosModelIndex / 2);
+
+
+const int kMainChoiceLiteralIndex = 0;
+const int kMainChoiceMatchIndex = 1;
+
+const int kMatchChoiceDistanceIndex= 0;
+const int kMatchChoiceRepetitionIndex = 1;
+
+const int kNumMoveBitsForMainChoice = 5;
+const int kNumMoveBitsForPosCoders = 5;
+
+const int kNumMoveBitsForAlignCoders = 5;
+
+const int kNumMoveBitsForPosSlotCoder = 5;
+
+const int kNumLitPosStatesBitsEncodingMax = 4;
+const int kNumLitContextBitsMax = 8;
+
+}}
+
+#endif
diff --git a/src/reader/jma/lzmadec.cpp b/src/reader/jma/lzmadec.cpp
new file mode 100644
index 00000000..2cc75a03
--- /dev/null
+++ b/src/reader/jma/lzmadec.cpp
@@ -0,0 +1,299 @@
+/*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "portable.h"
+#include "lzmadec.h"
+
+#define RETURN_E_OUTOFMEMORY_IF_FALSE(x) { if (!(x)) return E_OUTOFMEMORY; }
+
+namespace NCompress {
+namespace NLZMA {
+
+HRESULT CDecoder::SetDictionarySize(UINT32 aDictionarySize)
+{
+  if (aDictionarySize > (1 << kDicLogSizeMax))
+    return E_INVALIDARG;
+
+  UINT32 aWindowReservSize = MyMax(aDictionarySize, UINT32(1 << 21));
+
+  if (m_DictionarySize != aDictionarySize)
+  {
+    m_OutWindowStream.Create(aDictionarySize, kMatchMaxLen, aWindowReservSize);
+    m_DictionarySize = aDictionarySize;
+  }
+  return S_OK;
+}
+
+HRESULT CDecoder::SetLiteralProperties(
+    UINT32 aLiteralPosStateBits, UINT32 aLiteralContextBits)
+{
+  if (aLiteralPosStateBits > 8)
+    return E_INVALIDARG;
+  if (aLiteralContextBits > 8)
+    return E_INVALIDARG;
+  m_LiteralDecoder.Create(aLiteralPosStateBits, aLiteralContextBits);
+  return S_OK;
+}
+
+HRESULT CDecoder::SetPosBitsProperties(UINT32 aNumPosStateBits)
+{
+  if (aNumPosStateBits > NLength::kNumPosStatesBitsMax)
+    return E_INVALIDARG;
+  UINT32 aNumPosStates = 1 << aNumPosStateBits;
+  m_LenDecoder.Create(aNumPosStates);
+  m_RepMatchLenDecoder.Create(aNumPosStates);
+  m_PosStateMask = aNumPosStates - 1;
+  return S_OK;
+}
+
+CDecoder::CDecoder():
+  m_DictionarySize((UINT32)-1)
+{
+  Create();
+}
+
+HRESULT CDecoder::Create()
+{
+  for(int i = 0; i < kNumPosModels; i++)
+  {
+    RETURN_E_OUTOFMEMORY_IF_FALSE(
+        m_PosDecoders[i].Create(kDistDirectBits[kStartPosModelIndex + i]));
+  }
+  return S_OK;
+}
+
+
+HRESULT CDecoder::Init(ISequentialInStream *anInStream,
+    ISequentialOutStream *anOutStream)
+{
+  m_RangeDecoder.Init(anInStream);
+
+  m_OutWindowStream.Init(anOutStream);
+
+  int i;
+  for(i = 0; i < kNumStates; i++)
+  {
+    for (UINT32 j = 0; j <= m_PosStateMask; j++)
+    {
+      m_MainChoiceDecoders[i][j].Init();
+      m_MatchRepShortChoiceDecoders[i][j].Init();
+    }
+    m_MatchChoiceDecoders[i].Init();
+    m_MatchRepChoiceDecoders[i].Init();
+    m_MatchRep1ChoiceDecoders[i].Init();
+    m_MatchRep2ChoiceDecoders[i].Init();
+  }
+
+  m_LiteralDecoder.Init();
+
+  // m_RepMatchLenDecoder.Init();
+
+  for (i = 0; (UINT32) i < kNumLenToPosStates; i++)
+    m_PosSlotDecoder[i].Init();
+
+  for(i = 0; i < kNumPosModels; i++)
+    m_PosDecoders[i].Init();
+
+  m_LenDecoder.Init();
+  m_RepMatchLenDecoder.Init();
+
+  m_PosAlignDecoder.Init();
+  return S_OK;
+
+}
+
+HRESULT CDecoder::CodeReal(ISequentialInStream *anInStream,
+    ISequentialOutStream *anOutStream,
+    const UINT64 *anInSize, const UINT64 *anOutSize)
+{
+  if (anOutSize == NULL)
+    return E_INVALIDARG;
+
+  Init(anInStream, anOutStream);
+
+  CState aState;
+  aState.Init();
+  bool aPeviousIsMatch = false;
+  BYTE aPreviousByte = 0;
+  UINT32 aRepDistances[kNumRepDistances];
+  for(UINT32 i = 0 ; i < kNumRepDistances; i++)
+    aRepDistances[i] = 0;
+
+  UINT64 aNowPos64 = 0;
+  UINT64 aSize = *anOutSize;
+  while(aNowPos64 < aSize)
+  {
+    UINT64 aNext = MyMin(aNowPos64 + (1 << 18), aSize);
+    while(aNowPos64 < aNext)
+    {
+      UINT32 aPosState = UINT32(aNowPos64) & m_PosStateMask;
+      if (m_MainChoiceDecoders[aState.m_Index][aPosState].Decode(&m_RangeDecoder) == (UINT32) kMainChoiceLiteralIndex)
+      {
+        // aCounts[0]++;
+        aState.UpdateChar();
+        if(aPeviousIsMatch)
+        {
+          BYTE aMatchByte = m_OutWindowStream.GetOneByte(0 - aRepDistances[0] - 1);
+          aPreviousByte = m_LiteralDecoder.DecodeWithMatchByte(&m_RangeDecoder,
+              UINT32(aNowPos64), aPreviousByte, aMatchByte);
+          aPeviousIsMatch = false;
+        }
+        else
+          aPreviousByte = m_LiteralDecoder.DecodeNormal(&m_RangeDecoder,
+              UINT32(aNowPos64), aPreviousByte);
+        m_OutWindowStream.PutOneByte(aPreviousByte);
+        aNowPos64++;
+      }
+      else
+      {
+        aPeviousIsMatch = true;
+        UINT32 aDistance, aLen;
+        if(m_MatchChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) ==
+            (UINT32) kMatchChoiceRepetitionIndex)
+        {
+          if(m_MatchRepChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0)
+          {
+            if(m_MatchRepShortChoiceDecoders[aState.m_Index][aPosState].Decode(&m_RangeDecoder) == 0)
+            {
+              aState.UpdateShortRep();
+              aPreviousByte = m_OutWindowStream.GetOneByte(0 - aRepDistances[0] - 1);
+              m_OutWindowStream.PutOneByte(aPreviousByte);
+              aNowPos64++;
+              // aCounts[3 + 4]++;
+              continue;
+            }
+            // aCounts[3 + 0]++;
+            aDistance = aRepDistances[0];
+          }
+          else
+          {
+            if(m_MatchRep1ChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0)
+            {
+              aDistance = aRepDistances[1];
+              aRepDistances[1] = aRepDistances[0];
+              // aCounts[3 + 1]++;
+            }
+            else
+            {
+              if (m_MatchRep2ChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0)
+              {
+                // aCounts[3 + 2]++;
+                aDistance = aRepDistances[2];
+              }
+              else
+              {
+                // aCounts[3 + 3]++;
+                aDistance = aRepDistances[3];
+                aRepDistances[3] = aRepDistances[2];
+              }
+              aRepDistances[2] = aRepDistances[1];
+              aRepDistances[1] = aRepDistances[0];
+            }
+            aRepDistances[0] = aDistance;
+          }
+          aLen = m_RepMatchLenDecoder.Decode(&m_RangeDecoder, aPosState) + kMatchMinLen;
+          // aCounts[aLen]++;
+          aState.UpdateRep();
+        }
+        else
+        {
+          aLen = kMatchMinLen + m_LenDecoder.Decode(&m_RangeDecoder, aPosState);
+          aState.UpdateMatch();
+          UINT32 aPosSlot = m_PosSlotDecoder[GetLenToPosState(aLen)].Decode(&m_RangeDecoder);
+          // aCounts[aPosSlot]++;
+          if (aPosSlot >= (UINT32) kStartPosModelIndex)
+          {
+            aDistance = kDistStart[aPosSlot];
+            if (aPosSlot < (UINT32) kEndPosModelIndex)
+              aDistance += m_PosDecoders[aPosSlot - kStartPosModelIndex].Decode(&m_RangeDecoder);
+            else
+            {
+              aDistance += (m_RangeDecoder.DecodeDirectBits(kDistDirectBits[aPosSlot] -
+                  kNumAlignBits) << kNumAlignBits);
+              aDistance += m_PosAlignDecoder.Decode(&m_RangeDecoder);
+            }
+          }
+          else
+            aDistance = aPosSlot;
+
+
+          aRepDistances[3] = aRepDistances[2];
+          aRepDistances[2] = aRepDistances[1];
+          aRepDistances[1] = aRepDistances[0];
+
+          aRepDistances[0] = aDistance;
+          // UpdateStat(aLen, aPosSlot);
+        }
+        if (aDistance >= aNowPos64)
+          throw E_INVALIDDATA;
+        m_OutWindowStream.CopyBackBlock(aDistance, aLen);
+        aNowPos64 += aLen;
+        aPreviousByte = m_OutWindowStream.GetOneByte(0 - 1);
+      }
+    }
+  }
+  return Flush();
+}
+
+HRESULT CDecoder::Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize)
+{
+  try {
+     return CodeReal(anInStream, anOutStream, anInSize, anOutSize);
+  } catch (HRESULT& e) {
+     return e;
+  } catch (...) {
+     return E_FAIL;
+  }
+}
+
+HRESULT CDecoder::ReadCoderProperties(ISequentialInStream *anInStream)
+{
+  UINT32 aNumPosStateBits;
+  UINT32 aLiteralPosStateBits;
+  UINT32 aLiteralContextBits;
+  UINT32 aDictionarySize;
+
+   UINT32 aProcessesedSize;
+
+  BYTE aByte;
+  RETURN_IF_NOT_S_OK(anInStream->Read(&aByte, sizeof(aByte), &aProcessesedSize));
+  if (aProcessesedSize != sizeof(aByte))
+    return E_INVALIDARG;
+
+  aLiteralContextBits = aByte % 9;
+  BYTE aRemainder = aByte / 9;
+  aLiteralPosStateBits = aRemainder % 5;
+  aNumPosStateBits = aRemainder / 5;
+
+  UINT8 uint_buffer[UINT_SIZE];
+  RETURN_IF_NOT_S_OK(anInStream->Read(uint_buffer, sizeof(aDictionarySize), &aProcessesedSize));
+  aDictionarySize = charp_to_uint(uint_buffer);
+
+  if (aProcessesedSize != sizeof(aDictionarySize))
+    return E_INVALIDARG;
+
+  RETURN_IF_NOT_S_OK(SetDictionarySize(aDictionarySize));
+  RETURN_IF_NOT_S_OK(SetLiteralProperties(aLiteralPosStateBits, aLiteralContextBits));
+  RETURN_IF_NOT_S_OK(SetPosBitsProperties(aNumPosStateBits));
+
+  return S_OK;
+}
+
+}}
diff --git a/src/reader/jma/lzmadec.h b/src/reader/jma/lzmadec.h
new file mode 100644
index 00000000..88234448
--- /dev/null
+++ b/src/reader/jma/lzmadec.h
@@ -0,0 +1,83 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __LZARITHMETIC_DECODER_H
+#define __LZARITHMETIC_DECODER_H
+
+#include "winout.h"
+#include "lzma.h"
+#include "lencoder.h"
+#include "litcoder.h"
+
+namespace NCompress {
+namespace NLZMA {
+
+typedef CMyBitDecoder<kNumMoveBitsForMainChoice> CMyBitDecoder2;
+
+class CDecoder
+{
+  NStream::NWindow::COut m_OutWindowStream;
+  CMyRangeDecoder m_RangeDecoder;
+
+  CMyBitDecoder2 m_MainChoiceDecoders[kNumStates][NLength::kNumPosStatesMax];
+  CMyBitDecoder2 m_MatchChoiceDecoders[kNumStates];
+  CMyBitDecoder2 m_MatchRepChoiceDecoders[kNumStates];
+  CMyBitDecoder2 m_MatchRep1ChoiceDecoders[kNumStates];
+  CMyBitDecoder2 m_MatchRep2ChoiceDecoders[kNumStates];
+  CMyBitDecoder2 m_MatchRepShortChoiceDecoders[kNumStates][NLength::kNumPosStatesMax];
+
+  CBitTreeDecoder<kNumMoveBitsForPosSlotCoder, kNumPosSlotBits> m_PosSlotDecoder[kNumLenToPosStates];
+
+  CReverseBitTreeDecoder2<kNumMoveBitsForPosCoders> m_PosDecoders[kNumPosModels];
+  CReverseBitTreeDecoder<kNumMoveBitsForAlignCoders, kNumAlignBits> m_PosAlignDecoder;
+  // CBitTreeDecoder2<kNumMoveBitsForPosCoders> m_PosDecoders[kNumPosModels];
+  // CBitTreeDecoder<kNumMoveBitsForAlignCoders, kNumAlignBits> m_PosAlignDecoder;
+
+  NLength::CDecoder m_LenDecoder;
+  NLength::CDecoder m_RepMatchLenDecoder;
+
+  NLiteral::CDecoder m_LiteralDecoder;
+
+  UINT32 m_DictionarySize;
+
+  UINT32 m_PosStateMask;
+
+  HRESULT Create();
+
+  HRESULT Init(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream);
+
+  HRESULT Flush() {  return m_OutWindowStream.Flush(); }
+
+  HRESULT CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize);
+
+public:
+
+  CDecoder();
+
+  HRESULT Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize);
+  HRESULT ReadCoderProperties(ISequentialInStream *anInStream);
+
+  HRESULT SetDictionarySize(UINT32 aDictionarySize);
+  HRESULT SetLiteralProperties(UINT32 aLiteralPosStateBits, UINT32 aLiteralContextBits);
+  HRESULT SetPosBitsProperties(UINT32 aNumPosStateBits);
+};
+
+}}
+
+#endif
diff --git a/src/reader/jma/portable.h b/src/reader/jma/portable.h
new file mode 100644
index 00000000..1ed1fb50
--- /dev/null
+++ b/src/reader/jma/portable.h
@@ -0,0 +1,85 @@
+/*
+Copyright (C) 2004 NSRT Team ( http://nsrt.edgeemu.com )
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __PORTABLE_H
+#define __PORTABLE_H
+
+#include <string.h>
+
+typedef signed char INT8;
+typedef unsigned char UINT8;
+typedef short INT16;
+typedef unsigned short UINT16;
+typedef long INT32;
+typedef unsigned long UINT32;
+typedef long long INT64;
+typedef unsigned long long UINT64;
+
+typedef UINT8 BYTE;
+typedef UINT16 WORD;
+typedef UINT32 DWORD;
+
+typedef unsigned UINT_PTR;
+
+typedef int BOOL;
+#define FALSE 0
+#define TRUE 1
+
+#define HRESULT int
+#define S_OK 0
+#define E_INVALIDARG -1
+#define E_OUTOFMEMORY -2
+#define E_FAIL -3
+#define E_INTERNAL_ERROR -4
+#define E_INVALIDDATA -5
+
+template <class T> inline T MyMin(T a, T b) {
+	return a < b ? a : b;
+}
+
+template <class T> inline T MyMax(T a, T b) {
+	return a > b ? a : b;
+}
+
+#define RETURN_IF_NOT_S_OK(x) { HRESULT __aResult_ = (x); if(__aResult_ != S_OK) return __aResult_; }
+
+
+#define UINT_SIZE (4)
+#define USHORT_SIZE (2)
+
+//Convert an array of 4 bytes back into an integer
+inline unsigned int charp_to_uint(const unsigned char buffer[UINT_SIZE])
+{
+  unsigned int num = (unsigned int)buffer[3];
+  num |= ((unsigned int)buffer[2]) << 8;
+  num |= ((unsigned int)buffer[1]) << 16;
+  num |= ((unsigned int)buffer[0]) << 24;
+  return(num);
+}
+
+//Convert an array of 2 bytes back into a short integer
+inline unsigned short charp_to_ushort(const unsigned char buffer[USHORT_SIZE])
+{
+  unsigned short num = (unsigned short)buffer[1];
+  num |= ((unsigned short)buffer[0]) << 8;
+  return(num);
+}
+
+#endif
diff --git a/src/reader/jma/rcdefs.h b/src/reader/jma/rcdefs.h
new file mode 100644
index 00000000..46df11f9
--- /dev/null
+++ b/src/reader/jma/rcdefs.h
@@ -0,0 +1,61 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __RCDEFS_H
+#define __RCDEFS_H
+
+#include "aribitcd.h"
+#include "ariconst.h"
+
+#define RC_INIT_VAR                            \
+  UINT32 aRange = aRangeDecoder->m_Range;      \
+  UINT32 aCode = aRangeDecoder->m_Code;
+
+#define RC_FLUSH_VAR                          \
+  aRangeDecoder->m_Range = aRange;            \
+  aRangeDecoder->m_Code = aCode;
+
+#define RC_NORMALIZE                                    \
+    if (aRange < NCompression::NArithmetic::kTopValue)               \
+    {                                                              \
+      aCode = (aCode << 8) | aRangeDecoder->m_Stream.ReadByte();   \
+      aRange <<= 8; }
+
+#define RC_GETBIT2(aNumMoveBits, aProb, aModelIndex, Action0, Action1)                        \
+    {UINT32 aNewBound = (aRange >> NCompression::NArithmetic::kNumBitModelTotalBits) * aProb; \
+    if (aCode < aNewBound)                               \
+    {                                                             \
+      Action0;                                                    \
+      aRange = aNewBound;                                         \
+      aProb += (NCompression::NArithmetic::kBitModelTotal - aProb) >> aNumMoveBits;          \
+      aModelIndex <<= 1;                                          \
+    }                                                             \
+    else                                                          \
+    {                                                             \
+      Action1;                                                    \
+      aRange -= aNewBound;                                        \
+      aCode -= aNewBound;                                          \
+      aProb -= (aProb) >> aNumMoveBits;                           \
+      aModelIndex = (aModelIndex << 1) + 1;                       \
+    }}                                                             \
+    RC_NORMALIZE
+
+#define RC_GETBIT(aNumMoveBits, aProb, aModelIndex) RC_GETBIT2(aNumMoveBits, aProb, aModelIndex, ; , ;)
+
+#endif
diff --git a/src/reader/jma/rngcoder.h b/src/reader/jma/rngcoder.h
new file mode 100644
index 00000000..59118580
--- /dev/null
+++ b/src/reader/jma/rngcoder.h
@@ -0,0 +1,144 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __COMPRESSION_RANGECODER_H
+#define __COMPRESSION_RANGECODER_H
+
+#include "inbyte.h"
+
+namespace NCompression {
+namespace NArithmetic {
+
+const UINT32 kNumTopBits = 24;
+const UINT32 kTopValue = (1 << kNumTopBits);
+
+class CRangeDecoder
+{
+public:
+  NStream::CInByte m_Stream;
+  UINT32 m_Range;
+  UINT32 m_Code;
+  UINT32 m_Word;
+  void Normalize()
+  {
+    while (m_Range < kTopValue)
+    {
+      m_Code = (m_Code << 8) | m_Stream.ReadByte();
+      m_Range <<= 8;
+    }
+  }
+
+  void Init(ISequentialInStream *aStream)
+  {
+    m_Stream.Init(aStream);
+    m_Code = 0;
+    m_Range = UINT32(-1);
+    for(int i = 0; i < 5; i++)
+      m_Code = (m_Code << 8) | m_Stream.ReadByte();
+  }
+
+  UINT32 GetThreshold(UINT32 aTotal)
+  {
+    return (m_Code) / ( m_Range /= aTotal);
+  }
+
+  void Decode(UINT32 aStart, UINT32 aSize, UINT32 aTotal)
+  {
+    m_Code -= aStart * m_Range;
+    m_Range *= aSize;
+    Normalize();
+  }
+
+  /*
+  UINT32 DecodeDirectBitsDiv(UINT32 aNumTotalBits)
+  {
+    m_Range >>= aNumTotalBits;
+    UINT32 aThreshold = m_Code / m_Range;
+    m_Code -= aThreshold * m_Range;
+
+    Normalize();
+    return aThreshold;
+  }
+
+  UINT32 DecodeDirectBitsDiv2(UINT32 aNumTotalBits)
+  {
+    if (aNumTotalBits <= kNumBottomBits)
+      return DecodeDirectBitsDiv(aNumTotalBits);
+    UINT32 aResult = DecodeDirectBitsDiv(aNumTotalBits - kNumBottomBits) << kNumBottomBits;
+    return (aResult | DecodeDirectBitsDiv(kNumBottomBits));
+  }
+  */
+
+  UINT32 DecodeDirectBits(UINT32 aNumTotalBits)
+  {
+    UINT32 aRange = m_Range;
+    UINT32 aCode = m_Code;
+    UINT32 aResult = 0;
+    for (UINT32 i = aNumTotalBits; i > 0; i--)
+    {
+      aRange >>= 1;
+      /*
+      aResult <<= 1;
+      if (aCode >= aRange)
+      {
+        aCode -= aRange;
+        aResult |= 1;
+      }
+      */
+      UINT32 t = (aCode - aRange) >> 31;
+      aCode -= aRange & (t - 1);
+      // aRange = aRangeTmp + ((aRange & 1) & (1 - t));
+      aResult = (aResult << 1) | (1 - t);
+
+      if (aRange < kTopValue)
+      {
+        aCode = (aCode << 8) | m_Stream.ReadByte();
+        aRange <<= 8;
+      }
+    }
+    m_Range = aRange;
+    m_Code = aCode;
+    return aResult;
+  }
+
+  UINT32 DecodeBit(UINT32 aSize0, UINT32 aNumTotalBits)
+  {
+    UINT32 aNewBound = (m_Range >> aNumTotalBits) * aSize0;
+    UINT32 aSymbol;
+    if (m_Code < aNewBound)
+    {
+      aSymbol = 0;
+      m_Range = aNewBound;
+    }
+    else
+    {
+      aSymbol = 1;
+      m_Code -= aNewBound;
+      m_Range -= aNewBound;
+    }
+    Normalize();
+    return aSymbol;
+  }
+
+  UINT64 GetProcessedSize() {return m_Stream.GetProcessedSize(); }
+};
+
+}}
+
+#endif
diff --git a/src/reader/jma/winout.cpp b/src/reader/jma/winout.cpp
new file mode 100644
index 00000000..61e9a652
--- /dev/null
+++ b/src/reader/jma/winout.cpp
@@ -0,0 +1,90 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "winout.h"
+
+namespace NStream {
+namespace NWindow {
+
+void COut::Create(UINT32 aKeepSizeBefore, UINT32 aKeepSizeAfter, UINT32 aKeepSizeReserv)
+{
+  m_Pos = 0;
+  m_PosLimit = aKeepSizeReserv + aKeepSizeBefore;
+  m_KeepSizeBefore = aKeepSizeBefore;
+  m_KeepSizeAfter = aKeepSizeAfter;
+  m_KeepSizeReserv = aKeepSizeReserv;
+  m_StreamPos = 0;
+  m_MoveFrom = m_KeepSizeReserv;
+  m_WindowSize = aKeepSizeBefore;
+  UINT32 aBlockSize = m_KeepSizeBefore + m_KeepSizeAfter + m_KeepSizeReserv;
+  delete []m_Buffer;
+  m_Buffer = new BYTE[aBlockSize];
+}
+
+COut::~COut()
+{
+  delete []m_Buffer;
+}
+
+void COut::SetWindowSize(UINT32 aWindowSize)
+{
+  m_WindowSize = aWindowSize;
+  m_MoveFrom = m_KeepSizeReserv + m_KeepSizeBefore - aWindowSize;
+}
+
+void COut::Init(ISequentialOutStream *aStream, bool aSolid)
+{
+  m_Stream = aStream;
+
+  if(aSolid)
+    m_StreamPos = m_Pos;
+  else
+  {
+    m_Pos = 0;
+    m_PosLimit = m_KeepSizeReserv + m_KeepSizeBefore;
+    m_StreamPos = 0;
+  }
+}
+
+HRESULT COut::Flush()
+{
+  UINT32 aSize = m_Pos - m_StreamPos;
+  if(aSize == 0)
+    return S_OK;
+  UINT32 aProcessedSize;
+  HRESULT aResult = m_Stream->Write(m_Buffer + m_StreamPos, aSize, &aProcessedSize);
+  if (aResult != S_OK)
+    return aResult;
+  if (aSize != aProcessedSize)
+    return E_FAIL;
+  m_StreamPos = m_Pos;
+  return S_OK;
+}
+
+void COut::MoveBlockBackward()
+{
+  HRESULT aResult = Flush();
+  if (aResult != S_OK)
+    throw aResult;
+  memmove(m_Buffer, m_Buffer + m_MoveFrom, m_WindowSize + m_KeepSizeAfter);
+  m_Pos -= m_MoveFrom;
+  m_StreamPos -= m_MoveFrom;
+}
+
+}}
diff --git a/src/reader/jma/winout.h b/src/reader/jma/winout.h
new file mode 100644
index 00000000..1e64e2e8
--- /dev/null
+++ b/src/reader/jma/winout.h
@@ -0,0 +1,90 @@
+/*
+Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
+Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __STREAM_WINDOWOUT_H
+#define __STREAM_WINDOWOUT_H
+
+#include "iiostrm.h"
+
+namespace NStream {
+namespace NWindow {
+
+// m_KeepSizeBefore: how mach BYTEs must be in buffer before m_Pos;
+// m_KeepSizeAfter: how mach BYTEs must be in buffer after m_Pos;
+// m_KeepSizeReserv: how mach BYTEs must be in buffer for Moving Reserv;
+//                    must be >= aKeepSizeAfter; // test it
+
+class COut
+{
+  BYTE  *m_Buffer;
+  UINT32 m_Pos;
+  UINT32 m_PosLimit;
+  UINT32 m_KeepSizeBefore;
+  UINT32 m_KeepSizeAfter;
+  UINT32 m_KeepSizeReserv;
+  UINT32 m_StreamPos;
+
+  UINT32 m_WindowSize;
+  UINT32 m_MoveFrom;
+
+  ISequentialOutStream *m_Stream;
+
+  virtual void MoveBlockBackward();
+public:
+  COut(): m_Buffer(0), m_Stream(0) {}
+  virtual ~COut();
+  void Create(UINT32 aKeepSizeBefore,
+      UINT32 aKeepSizeAfter, UINT32 aKeepSizeReserv = (1<<17));
+  void SetWindowSize(UINT32 aWindowSize);
+
+  void Init(ISequentialOutStream *aStream, bool aSolid = false);
+  HRESULT Flush();
+
+  UINT32 GetCurPos() const { return m_Pos; }
+  const BYTE *GetPointerToCurrentPos() const { return m_Buffer + m_Pos;};
+
+  void CopyBackBlock(UINT32 aDistance, UINT32 aLen)
+  {
+    if (m_Pos >= m_PosLimit)
+      MoveBlockBackward();
+    BYTE *p = m_Buffer + m_Pos;
+    aDistance++;
+    for(UINT32 i = 0; i < aLen; i++)
+      p[i] = p[i - aDistance];
+    m_Pos += aLen;
+  }
+
+  void PutOneByte(BYTE aByte)
+  {
+    if (m_Pos >= m_PosLimit)
+      MoveBlockBackward();
+    m_Buffer[m_Pos++] = aByte;
+  }
+
+  BYTE GetOneByte(UINT32 anIndex) const
+  {
+    return m_Buffer[m_Pos + anIndex];
+  }
+
+  BYTE *GetBuffer() const { return m_Buffer; }
+};
+
+}}
+
+#endif
diff --git a/src/reader/jmareader.cpp b/src/reader/jmareader.cpp
new file mode 100644
index 00000000..ea5db124
--- /dev/null
+++ b/src/reader/jmareader.cpp
@@ -0,0 +1,43 @@
+//created by Nach
+
+//#include "jma/jma.h"
+
+uint32 JMAReader::size() {
+  return fsize;
+}
+
+#define MAXROM 0x800000
+
+uint8 *JMAReader::read(uint32 length)
+{
+  uint8 *data;
+  if (!fsize) { return 0; }
+  if (length <= fsize)
+  {
+    //read the entire file into RAM
+    data = (uint8*)memalloc(fsize);
+    JMAFile.extract_file(cname, data);
+  }
+  else if (length > fsize)
+  {
+    //read the entire file into RAM, pad the rest with 0x00s
+    data = (uint8*)memalloc(length);
+    memset(data, 0, length);
+    JMAFile.extract_file(cname, data);
+  }
+  return data;
+}
+
+JMAReader::JMAReader(char *fn) : JMAFile(fn), fsize(0)
+{
+  std::vector<JMA::jma_public_file_info> file_info = JMAFile.get_files_info();
+  for (std::vector<JMA::jma_public_file_info>::iterator i = file_info.begin(); i != file_info.end(); i++)
+  {
+    //Check for valid ROM based on size
+    if ((i->size <= MAXROM+512) && (i->size > fsize))
+    {
+      cname = i->name;
+      fsize = i->size;
+    }
+  }
+}
diff --git a/src/reader/jmareader.h b/src/reader/jmareader.h
new file mode 100644
index 00000000..7fc0d4f9
--- /dev/null
+++ b/src/reader/jmareader.h
@@ -0,0 +1,17 @@
+//created by Nach
+
+#include "jma/jma.h"
+
+class JMAReader : public Reader {
+private:
+JMA::jma_open JMAFile;
+uint32 fsize;
+std::string cname;
+
+public:
+  uint32 size();
+  uint8 *read(uint32 length = 0);
+
+  JMAReader(char *fn);
+  ~JMAReader() { }
+};
diff --git a/src/reader/reader.cpp b/src/reader/reader.cpp
index 68985773..1d44af80 100644
--- a/src/reader/reader.cpp
+++ b/src/reader/reader.cpp
@@ -1,2 +1,22 @@
 #include "../base.h"
 #include "filereader.cpp"
+#ifdef GZIP_SUPPORT
+  #include "gzreader.cpp"
+  #include "zipreader.cpp"
+#endif
+#ifdef JMA_SUPPORT
+  #include "jmareader.cpp"
+#endif
+
+uint32 Reader::detect(char *fn) {
+int len = strlen(fn);
+  if(len >= 4 && !stricmp(fn + len - 3, ".gz")) {
+    return RF_GZ;
+  } else if(len >= 5 && !stricmp(fn + len - 4, ".zip")) {
+    return RF_ZIP;
+  } else if(len >= 5 && !stricmp(fn + len - 4, ".jma")) {
+    return RF_JMA;
+  } else {
+    return RF_NORMAL;
+  }
+}
diff --git a/src/reader/reader.h b/src/reader/reader.h
index 695f989c..c545a2d3 100644
--- a/src/reader/reader.h
+++ b/src/reader/reader.h
@@ -1,7 +1,17 @@
 class Reader {
 public:
+enum {
+  RF_NORMAL = 0,
+  RF_GZ     = 1,
+  RF_ZIP    = 2,
+  RF_JMA    = 3
+};
+//attemps to determine filetype by extension,
+//RF_NORMAL is returned on failure as a failsafe
+  static uint32 detect(char *fn);
   virtual uint32 size() = 0;
-  virtual void   read(uint8 **buffer, uint32 length = 0) = 0;
+//return is 0 on failure, caller must deallocate memory manually
+  virtual uint8 *read(uint32 length = 0) = 0;
 };
 
 class Writer {
@@ -10,3 +20,10 @@ public:
 };
 
 #include "filereader.h"
+#ifdef GZIP_SUPPORT
+  #include "gzreader.h"
+  #include "zipreader.h"
+#endif
+#ifdef JMA_SUPPORT
+  #include "jmareader.h"
+#endif
diff --git a/src/reader/zipreader.cpp b/src/reader/zipreader.cpp
new file mode 100644
index 00000000..c6218d2d
--- /dev/null
+++ b/src/reader/zipreader.cpp
@@ -0,0 +1,54 @@
+//created by Nach
+
+uint32 ZipReader::size() {
+  return fsize;
+}
+
+#define MAXROM 0x800000
+
+uint8 *ZipReader::read(uint32 length)
+{
+  uint8 *data;
+  if (!fsize) { return 0; }
+  if (length <= fsize)
+  {
+    //read the entire file into RAM
+    data = (uint8*)memalloc(fsize);
+    unzReadCurrentFile(zipfile, data, fsize);
+  }
+  else if (length > fsize)
+  {
+    //read the entire file into RAM, pad the rest with 0x00s
+    data = (uint8*)memalloc(length);
+    memset(data, 0, length);
+    unzReadCurrentFile(zipfile, data, fsize);
+  }
+  return data;
+}
+
+ZipReader::ZipReader(char *fn) : fsize(0)
+{
+  unz_file_info cFileInfo; //Create variable to hold info for a compressed file
+  char cFileName[sizeof(cname)];
+
+  if (zipfile = unzOpen(fn)) //Open zip file
+  {
+    for (int cFile = unzGoToFirstFile(zipfile); cFile == UNZ_OK; cFile = unzGoToNextFile(zipfile))
+    {
+      //Gets info on current file, and places it in cFileInfo
+      unzGetCurrentFileInfo(zipfile, &cFileInfo, cFileName, sizeof(cname), 0, 0, 0, 0);
+
+      if ((cFileInfo.uncompressed_size <= MAXROM+512) && (cFileInfo.uncompressed_size > fsize))
+      {
+        strcpy(cname, cFileName);
+        fsize = cFileInfo.uncompressed_size;
+      }
+    }
+
+    if (fsize)
+    {
+      unzLocateFile(zipfile, cname, 1);
+      unzOpenCurrentFile(zipfile);
+    }
+  }
+}
diff --git a/src/reader/zipreader.h b/src/reader/zipreader.h
new file mode 100644
index 00000000..14eacd58
--- /dev/null
+++ b/src/reader/zipreader.h
@@ -0,0 +1,27 @@
+//created by Nach
+
+#include "zlib/unzip.h"
+
+//Could be up to 65536
+#define ZIP_MAX_FILE_NAME 4096
+
+class ZipReader : public Reader {
+private:
+unzFile zipfile;
+uint32 fsize;
+char cname[4096];
+
+public:
+  uint32 size();
+  uint8 *read(uint32 length = 0);
+
+  ZipReader(char *fn);
+  ~ZipReader()
+  {
+    if (zipfile)
+    {
+      unzCloseCurrentFile(zipfile);
+      unzClose(zipfile);
+    }
+  }
+};
diff --git a/src/reader/zlib/adler32.c b/src/reader/zlib/adler32.c
new file mode 100644
index 00000000..58cdf069
--- /dev/null
+++ b/src/reader/zlib/adler32.c
@@ -0,0 +1,149 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: adler32.c,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#define BASE 65521UL    /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware */
+#ifdef NO_DIVIDE
+#  define MOD(a) \
+    do { \
+        if (a >= (BASE << 16)) a -= (BASE << 16); \
+        if (a >= (BASE << 15)) a -= (BASE << 15); \
+        if (a >= (BASE << 14)) a -= (BASE << 14); \
+        if (a >= (BASE << 13)) a -= (BASE << 13); \
+        if (a >= (BASE << 12)) a -= (BASE << 12); \
+        if (a >= (BASE << 11)) a -= (BASE << 11); \
+        if (a >= (BASE << 10)) a -= (BASE << 10); \
+        if (a >= (BASE << 9)) a -= (BASE << 9); \
+        if (a >= (BASE << 8)) a -= (BASE << 8); \
+        if (a >= (BASE << 7)) a -= (BASE << 7); \
+        if (a >= (BASE << 6)) a -= (BASE << 6); \
+        if (a >= (BASE << 5)) a -= (BASE << 5); \
+        if (a >= (BASE << 4)) a -= (BASE << 4); \
+        if (a >= (BASE << 3)) a -= (BASE << 3); \
+        if (a >= (BASE << 2)) a -= (BASE << 2); \
+        if (a >= (BASE << 1)) a -= (BASE << 1); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#  define MOD4(a) \
+    do { \
+        if (a >= (BASE << 4)) a -= (BASE << 4); \
+        if (a >= (BASE << 3)) a -= (BASE << 3); \
+        if (a >= (BASE << 2)) a -= (BASE << 2); \
+        if (a >= (BASE << 1)) a -= (BASE << 1); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#else
+#  define MOD(a) a %= BASE
+#  define MOD4(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    unsigned long sum2;
+    unsigned n;
+
+    /* split Adler-32 into component sums */
+    sum2 = (adler >> 16) & 0xffff;
+    adler &= 0xffff;
+
+    /* in case user likes doing a byte at a time, keep it fast */
+    if (len == 1) {
+        adler += buf[0];
+        if (adler >= BASE)
+            adler -= BASE;
+        sum2 += adler;
+        if (sum2 >= BASE)
+            sum2 -= BASE;
+        return adler | (sum2 << 16);
+    }
+
+    /* initial Adler-32 value (deferred check for len == 1 speed) */
+    if (buf == Z_NULL)
+        return 1L;
+
+    /* in case short lengths are provided, keep it somewhat fast */
+    if (len < 16) {
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        if (adler >= BASE)
+            adler -= BASE;
+        MOD4(sum2);             /* only added so many BASE's */
+        return adler | (sum2 << 16);
+    }
+
+    /* do length NMAX blocks -- requires just one modulo operation */
+    while (len >= NMAX) {
+        len -= NMAX;
+        n = NMAX / 16;          /* NMAX is divisible by 16 */
+        do {
+            DO16(buf);          /* 16 sums unrolled */
+            buf += 16;
+        } while (--n);
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* do remaining bytes (less than NMAX, still just one modulo) */
+    if (len) {                  /* avoid modulos if none remaining */
+        while (len >= 16) {
+            len -= 16;
+            DO16(buf);
+            buf += 16;
+        }
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* return recombined sums */
+    return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off_t len2;
+{
+    unsigned long sum1;
+    unsigned long sum2;
+    unsigned rem;
+
+    /* the derivation of this formula is left as an exercise for the reader */
+    rem = (unsigned)(len2 % BASE);
+    sum1 = adler1 & 0xffff;
+    sum2 = rem * sum1;
+    MOD(sum2);
+    sum1 += (adler2 & 0xffff) + BASE - 1;
+    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+    if (sum1 > BASE) sum1 -= BASE;
+    if (sum1 > BASE) sum1 -= BASE;
+    if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
+    if (sum2 > BASE) sum2 -= BASE;
+    return sum1 | (sum2 << 16);
+}
diff --git a/src/reader/zlib/compress.c b/src/reader/zlib/compress.c
new file mode 100644
index 00000000..1b7f07ad
--- /dev/null
+++ b/src/reader/zlib/compress.c
@@ -0,0 +1,79 @@
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2003 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: compress.c,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+    int level;
+{
+    z_stream stream;
+    int err;
+
+    stream.next_in = (Bytef*)source;
+    stream.avail_in = (uInt)sourceLen;
+#ifdef MAXSEG_64K
+    /* Check for source > 64K on 16-bit machine: */
+    if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+#endif
+    stream.next_out = dest;
+    stream.avail_out = (uInt)*destLen;
+    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+    stream.opaque = (voidpf)0;
+
+    err = deflateInit(&stream, level);
+    if (err != Z_OK) return err;
+
+    err = deflate(&stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        deflateEnd(&stream);
+        return err == Z_OK ? Z_BUF_ERROR : err;
+    }
+    *destLen = stream.total_out;
+
+    err = deflateEnd(&stream);
+    return err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+{
+    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+/* ===========================================================================
+     If the default memLevel or windowBits for deflateInit() is changed, then
+   this function needs to be updated.
+ */
+uLong ZEXPORT compressBound (sourceLen)
+    uLong sourceLen;
+{
+    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
+}
diff --git a/src/reader/zlib/crc32.c b/src/reader/zlib/crc32.c
new file mode 100644
index 00000000..fe16f0cb
--- /dev/null
+++ b/src/reader/zlib/crc32.c
@@ -0,0 +1,423 @@
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors.  This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+/* @(#) $Id: crc32.c,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+/*
+  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+  protection on the static variables used to control the first-use generation
+  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+  first call get_crc_table() to initialize the tables before allowing more than
+  one thread to use crc32().
+ */
+
+#ifdef MAKECRCH
+#  include <stdio.h>
+#  ifndef DYNAMIC_CRC_TABLE
+#    define DYNAMIC_CRC_TABLE
+#  endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h"      /* for STDC and FAR definitions */
+
+#define local static
+
+/* Find a four-byte integer type for crc32_little() and crc32_big(). */
+#ifndef NOBYFOUR
+#  ifdef STDC           /* need ANSI C limits.h to determine sizes */
+#    include <limits.h>
+#    define BYFOUR
+#    if (UINT_MAX == 0xffffffffUL)
+       typedef unsigned int u4;
+#    else
+#      if (ULONG_MAX == 0xffffffffUL)
+         typedef unsigned long u4;
+#      else
+#        if (USHRT_MAX == 0xffffffffUL)
+           typedef unsigned short u4;
+#        else
+#          undef BYFOUR     /* can't find a four-byte integer type! */
+#        endif
+#      endif
+#    endif
+#  endif /* STDC */
+#endif /* !NOBYFOUR */
+
+/* Definitions for doing the crc four data bytes at a time. */
+#ifdef BYFOUR
+#  define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \
+                (((w)&0xff00)<<8)+(((w)&0xff)<<24))
+   local unsigned long crc32_little OF((unsigned long,
+                        const unsigned char FAR *, unsigned));
+   local unsigned long crc32_big OF((unsigned long,
+                        const unsigned char FAR *, unsigned));
+#  define TBLS 8
+#else
+#  define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+                                         unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local volatile int crc_table_empty = 1;
+local unsigned long FAR crc_table[TBLS][256];
+local void make_crc_table OF((void));
+#ifdef MAKECRCH
+   local void write_table OF((FILE *, const unsigned long FAR *));
+#endif /* MAKECRCH */
+/*
+  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+  Polynomials over GF(2) are represented in binary, one bit per coefficient,
+  with the lowest powers in the most significant bit.  Then adding polynomials
+  is just exclusive-or, and multiplying a polynomial by x is a right shift by
+  one.  If we call the above polynomial p, and represent a byte as the
+  polynomial q, also with the lowest power in the most significant bit (so the
+  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+  where a mod b means the remainder after dividing a by b.
+
+  This calculation is done using the shift-register method of multiplying and
+  taking the remainder.  The register is initialized to zero, and for each
+  incoming bit, x^32 is added mod p to the register if the bit is a one (where
+  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+  x (which is shifting right by one and adding x^32 mod p if the bit shifted
+  out is a one).  We start with the highest power (least significant bit) of
+  q and repeat for all eight bits of q.
+
+  The first table is simply the CRC of all possible eight bit values.  This is
+  all the information needed to generate CRCs on data a byte at a time for all
+  combinations of CRC register values and incoming bytes.  The remaining tables
+  allow for word-at-a-time CRC calculation for both big-endian and little-
+  endian machines, where a word is four bytes.
+*/
+local void make_crc_table()
+{
+    unsigned long c;
+    int n, k;
+    unsigned long poly;                 /* polynomial exclusive-or pattern */
+    /* terms of polynomial defining this crc (except x^32): */
+    static volatile int first = 1;      /* flag to limit concurrent making */
+    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+    /* See if another task is already doing this (not thread-safe, but better
+       than nothing -- significantly reduces duration of vulnerability in
+       case the advice about DYNAMIC_CRC_TABLE is ignored) */
+    if (first) {
+        first = 0;
+
+        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
+        poly = 0UL;
+        for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
+            poly |= 1UL << (31 - p[n]);
+
+        /* generate a crc for every 8-bit value */
+        for (n = 0; n < 256; n++) {
+            c = (unsigned long)n;
+            for (k = 0; k < 8; k++)
+                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+            crc_table[0][n] = c;
+        }
+
+#ifdef BYFOUR
+        /* generate crc for each value followed by one, two, and three zeros,
+           and then the byte reversal of those as well as the first table */
+        for (n = 0; n < 256; n++) {
+            c = crc_table[0][n];
+            crc_table[4][n] = REV(c);
+            for (k = 1; k < 4; k++) {
+                c = crc_table[0][c & 0xff] ^ (c >> 8);
+                crc_table[k][n] = c;
+                crc_table[k + 4][n] = REV(c);
+            }
+        }
+#endif /* BYFOUR */
+
+        crc_table_empty = 0;
+    }
+    else {      /* not first */
+        /* wait for the other guy to finish (not efficient, but rare) */
+        while (crc_table_empty)
+            ;
+    }
+
+#ifdef MAKECRCH
+    /* write out CRC tables to crc32.h */
+    {
+        FILE *out;
+
+        out = fopen("crc32.h", "w");
+        if (out == NULL) return;
+        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
+        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
+        fprintf(out, "local const unsigned long FAR ");
+        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
+        write_table(out, crc_table[0]);
+#  ifdef BYFOUR
+        fprintf(out, "#ifdef BYFOUR\n");
+        for (k = 1; k < 8; k++) {
+            fprintf(out, "  },\n  {\n");
+            write_table(out, crc_table[k]);
+        }
+        fprintf(out, "#endif\n");
+#  endif /* BYFOUR */
+        fprintf(out, "  }\n};\n");
+        fclose(out);
+    }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+local void write_table(out, table)
+    FILE *out;
+    const unsigned long FAR *table;
+{
+    int n;
+
+    for (n = 0; n < 256; n++)
+        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ", table[n],
+                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
+}
+#endif /* MAKECRCH */
+
+#else /* !DYNAMIC_CRC_TABLE */
+/* ========================================================================
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
+ */
+#include "crc32.h"
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const unsigned long FAR * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+    return (const unsigned long FAR *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+    if (sizeof(void *) == sizeof(ptrdiff_t)) {
+        u4 endian;
+
+        endian = 1;
+        if (*((unsigned char *)(&endian)))
+            return crc32_little(crc, buf, len);
+        else
+            return crc32_big(crc, buf, len);
+    }
+#endif /* BYFOUR */
+    crc = crc ^ 0xffffffffUL;
+    while (len >= 8) {
+        DO8;
+        len -= 8;
+    }
+    if (len) do {
+        DO1;
+    } while (--len);
+    return crc ^ 0xffffffffUL;
+}
+
+#ifdef BYFOUR
+
+/* ========================================================================= */
+#define DOLIT4 c ^= *buf4++; \
+        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
+            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+
+/* ========================================================================= */
+local unsigned long crc32_little(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    register u4 c;
+    register const u4 FAR *buf4;
+
+    c = (u4)crc;
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+        len--;
+    }
+
+    buf4 = (const u4 FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOLIT32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOLIT4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)c;
+}
+
+/* ========================================================================= */
+#define DOBIG4 c ^= *++buf4; \
+        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
+            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+
+/* ========================================================================= */
+local unsigned long crc32_big(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    register u4 c;
+    register const u4 FAR *buf4;
+
+    c = REV((u4)crc);
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+        len--;
+    }
+
+    buf4 = (const u4 FAR *)(const void FAR *)buf;
+    buf4--;
+    while (len >= 32) {
+        DOBIG32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOBIG4;
+        len -= 4;
+    }
+    buf4++;
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)(REV(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+    unsigned long *mat;
+    unsigned long vec;
+{
+    unsigned long sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+    unsigned long *square;
+    unsigned long *mat;
+{
+    int n;
+
+    for (n = 0; n < GF2_DIM; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off_t len2;
+{
+    int n;
+    unsigned long row;
+    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
+    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
+
+    /* degenerate case */
+    if (len2 == 0)
+        return crc1;
+
+    /* put operator for one zero bit in odd */
+    odd[0] = 0xedb88320L;           /* CRC-32 polynomial */
+    row = 1;
+    for (n = 1; n < GF2_DIM; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* put operator for two zero bits in even */
+    gf2_matrix_square(even, odd);
+
+    /* put operator for four zero bits in odd */
+    gf2_matrix_square(odd, even);
+
+    /* apply len2 zeros to crc1 (first square will put the operator for one
+       zero byte, eight zero bits, in even) */
+    do {
+        /* apply zeros operator for this bit of len2 */
+        gf2_matrix_square(even, odd);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(even, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+        if (len2 == 0)
+            break;
+
+        /* another iteration of the loop with odd and even swapped */
+        gf2_matrix_square(odd, even);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(odd, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+    } while (len2 != 0);
+
+    /* return combined crc */
+    crc1 ^= crc2;
+    return crc1;
+}
diff --git a/src/reader/zlib/crc32.h b/src/reader/zlib/crc32.h
new file mode 100644
index 00000000..8053b611
--- /dev/null
+++ b/src/reader/zlib/crc32.h
@@ -0,0 +1,441 @@
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const unsigned long FAR crc_table[TBLS][256] =
+{
+  {
+    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+    0x2d02ef8dUL
+#ifdef BYFOUR
+  },
+  {
+    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+    0x9324fd72UL
+  },
+  {
+    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+    0xbe9834edUL
+  },
+  {
+    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+    0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+    0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+    0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+    0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+    0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+    0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+    0xde0506f1UL
+  },
+  {
+    0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+    0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+    0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+    0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+    0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+    0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+    0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+    0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+    0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+    0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+    0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+    0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+    0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+    0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+    0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+    0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+    0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+    0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+    0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+    0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+    0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+    0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+    0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+    0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+    0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+    0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+    0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+    0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+    0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+    0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+    0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+    0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+    0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+    0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+    0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+    0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+    0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+    0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+    0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+    0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+    0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+    0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+    0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+    0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+    0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+    0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+    0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+    0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+    0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+    0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+    0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+    0x8def022dUL
+  },
+  {
+    0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+    0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+    0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+    0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+    0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+    0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+    0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+    0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+    0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+    0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+    0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+    0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+    0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+    0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+    0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+    0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+    0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+    0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+    0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+    0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+    0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+    0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+    0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+    0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+    0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+    0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+    0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+    0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+    0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+    0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+    0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+    0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+    0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+    0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+    0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+    0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+    0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+    0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+    0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+    0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+    0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+    0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+    0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+    0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+    0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+    0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+    0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+    0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+    0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+    0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+    0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+    0x72fd2493UL
+  },
+  {
+    0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+    0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+    0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+    0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+    0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+    0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+    0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+    0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+    0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+    0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+    0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+    0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+    0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+    0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+    0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+    0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+    0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+    0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+    0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+    0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+    0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+    0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+    0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+    0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+    0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+    0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+    0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+    0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+    0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+    0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+    0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+    0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+    0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+    0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+    0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+    0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+    0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+    0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+    0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+    0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+    0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+    0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+    0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+    0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+    0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+    0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+    0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+    0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+    0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+    0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+    0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+    0xed3498beUL
+  },
+  {
+    0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+    0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+    0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+    0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+    0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+    0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+    0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+    0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+    0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+    0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+    0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+    0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+    0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+    0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+    0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+    0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+    0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+    0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+    0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+    0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+    0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+    0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+    0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+    0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+    0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+    0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+    0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+    0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+    0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+    0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+    0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+    0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+    0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+    0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+    0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+    0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+    0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+    0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+    0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+    0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+    0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+    0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+    0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+    0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+    0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+    0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+    0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+    0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+    0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+    0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+    0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+    0xf10605deUL
+#endif
+  }
+};
diff --git a/src/reader/zlib/crypt.h b/src/reader/zlib/crypt.h
new file mode 100644
index 00000000..622f4bc2
--- /dev/null
+++ b/src/reader/zlib/crypt.h
@@ -0,0 +1,132 @@
+/* crypt.h -- base code for crypt/uncrypt ZIPfile
+
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   This code is a modified version of crypting code in Infozip distribution
+
+   The encryption/decryption parts of this source code (as opposed to the
+   non-echoing password parts) were originally written in Europe.  The
+   whole source package can be freely distributed, including from the USA.
+   (Prior to January 2000, re-export from the US was a violation of US law.)
+
+   This encryption code is a direct transcription of the algorithm from
+   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
+   file (appnote.txt) is distributed with the PKZIP program (even in the
+   version without encryption capabilities).
+
+   If you don't need crypting in your application, just define symbols
+   NOCRYPT and NOUNCRYPT.
+
+   This code support the "Traditional PKWARE Encryption".
+
+   The new AES encryption added on Zip format by Winzip (see the page
+   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
+   Encryption is not supported.
+*/
+
+#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+
+/***********************************************************************
+ * Return the next byte in the pseudo-random sequence
+ */
+static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
+{
+    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
+                     * unpredictable manner on 16-bit systems; not a problem
+                     * with any known compiler so far, though */
+
+    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
+    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
+}
+
+/***********************************************************************
+ * Update the encryption keys with the next byte of plain text
+ */
+static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
+{
+    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
+    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
+    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
+    {
+      register int keyshift = (int)((*(pkeys+1)) >> 24);
+      (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
+    }
+    return c;
+}
+
+
+/***********************************************************************
+ * Initialize the encryption keys and the random header according to
+ * the given password.
+ */
+static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
+{
+    *(pkeys+0) = 305419896L;
+    *(pkeys+1) = 591751049L;
+    *(pkeys+2) = 878082192L;
+    while (*passwd != '\0') {
+        update_keys(pkeys,pcrc_32_tab,(int)*passwd);
+        passwd++;
+    }
+}
+
+#define zdecode(pkeys,pcrc_32_tab,c) \
+    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
+
+#define zencode(pkeys,pcrc_32_tab,c,t) \
+    (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
+
+#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+
+#define RAND_HEAD_LEN  12
+   /* "last resort" source for second part of crypt seed pattern */
+#  ifndef ZCR_SEED2
+#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
+#  endif
+
+static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
+    const char *passwd;         /* password string */
+    unsigned char *buf;         /* where to write header */
+    int bufSize;
+    unsigned long* pkeys;
+    const unsigned long* pcrc_32_tab;
+    unsigned long crcForCrypting;
+{
+    int n;                       /* index in random header */
+    int t;                       /* temporary */
+    int c;                       /* random byte */
+    unsigned char header[RAND_HEAD_LEN-2]; /* random header */
+    static unsigned calls = 0;   /* ensure different random header each time */
+
+    if (bufSize<RAND_HEAD_LEN)
+      return 0;
+
+    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
+     * output of rand() to get less predictability, since rand() is
+     * often poorly implemented.
+     */
+    if (++calls == 1)
+    {
+        srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+    }
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        c = (rand() >> 7) & 0xff;
+        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
+    }
+    /* Encrypt random header (last two bytes is high word of crc) */
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
+    }
+    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
+    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
+    return n;
+}
+
+#endif
diff --git a/src/reader/zlib/deflate.c b/src/reader/zlib/deflate.c
new file mode 100644
index 00000000..d08ce26a
--- /dev/null
+++ b/src/reader/zlib/deflate.c
@@ -0,0 +1,1736 @@
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process depends on being able to identify portions
+ *      of the input text which are identical to earlier input (within a
+ *      sliding window trailing behind the input currently being processed).
+ *
+ *      The most straightforward technique turns out to be the fastest for
+ *      most input files: try all possible matches and select the longest.
+ *      The key feature of this algorithm is that insertions into the string
+ *      dictionary are very simple and thus fast, and deletions are avoided
+ *      completely. Insertions are performed at each input character, whereas
+ *      string matches are performed only when the previous match ends. So it
+ *      is preferable to spend more time in matches to allow very fast string
+ *      insertions and avoid deletions. The matching algorithm for small
+ *      strings is inspired from that of Rabin & Karp. A brute force approach
+ *      is used to find longer strings when a small match has been found.
+ *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ *      (by Leonid Broukhis).
+ *         A previous version of this file used a more sophisticated algorithm
+ *      (by Fiala and Greene) which is guaranteed to run in linear amortized
+ *      time, but has a larger average cost, uses more memory and is patented.
+ *      However the F&G algorithm may be faster for some highly redundant
+ *      files if the parameter max_chain_length (described below) is too large.
+ *
+ *  ACKNOWLEDGEMENTS
+ *
+ *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ *      I found it in 'freeze' written by Leonid Broukhis.
+ *      Thanks to many people for bug reports and testing.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+ *      Available in http://www.ietf.org/rfc/rfc1951.txt
+ *
+ *      A description of the Rabin and Karp algorithm is given in the book
+ *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ *      Fiala,E.R., and Greene,D.H.
+ *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ */
+
+/* @(#) $Id: deflate.c,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#include "deflate.h"
+
+const char deflate_copyright[] =
+   " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/* ===========================================================================
+ *  Function prototypes.
+ */
+typedef enum {
+    need_more,      /* block not completed, need more input or more output */
+    block_done,     /* block flush performed */
+    finish_started, /* finish started, need only more output at next deflate */
+    finish_done     /* finish done, accept no more input or output */
+} block_state;
+
+typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+/* Compression function. Returns the block state after the call. */
+
+local void fill_window    OF((deflate_state *s));
+local block_state deflate_stored OF((deflate_state *s, int flush));
+local block_state deflate_fast   OF((deflate_state *s, int flush));
+#ifndef FASTEST
+local block_state deflate_slow   OF((deflate_state *s, int flush));
+#endif
+local void lm_init        OF((deflate_state *s));
+local void putShortMSB    OF((deflate_state *s, uInt b));
+local void flush_pending  OF((z_streamp strm));
+local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
+#ifndef FASTEST
+#ifdef ASMV
+      void match_init OF((void)); /* asm code initialization */
+      uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#else
+local uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#endif
+#endif
+local uInt longest_match_fast OF((deflate_state *s, IPos cur_match));
+
+#ifdef DEBUG
+local  void check_match OF((deflate_state *s, IPos start, IPos match,
+                            int length));
+#endif
+
+/* ===========================================================================
+ * Local data
+ */
+
+#define NIL 0
+/* Tail of hash chains */
+
+#ifndef TOO_FAR
+#  define TOO_FAR 4096
+#endif
+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+typedef struct config_s {
+   ush good_length; /* reduce lazy search above this match length */
+   ush max_lazy;    /* do not perform lazy search above this match length */
+   ush nice_length; /* quit search above this match length */
+   ush max_chain;
+   compress_func func;
+} config;
+
+#ifdef FASTEST
+local const config configuration_table[2] = {
+/*      good lazy nice chain */
+/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
+/* 1 */ {4,    4,  8,    4, deflate_fast}}; /* max speed, no lazy matches */
+#else
+local const config configuration_table[10] = {
+/*      good lazy nice chain */
+/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
+/* 1 */ {4,    4,  8,    4, deflate_fast}, /* max speed, no lazy matches */
+/* 2 */ {4,    5, 16,    8, deflate_fast},
+/* 3 */ {4,    6, 32,   32, deflate_fast},
+
+/* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
+/* 5 */ {8,   16, 32,   32, deflate_slow},
+/* 6 */ {8,   16, 128, 128, deflate_slow},
+/* 7 */ {8,   32, 128, 256, deflate_slow},
+/* 8 */ {32, 128, 258, 1024, deflate_slow},
+/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
+#endif
+
+/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+ * meaning.
+ */
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+#ifndef NO_DUMMY_DECL
+struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
+#endif
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
+ *    input characters, so that a running hash key can be computed from the
+ *    previous key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
+
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * If this file is compiled with -DFASTEST, the compression level is forced
+ * to 1, and no hash chains are maintained.
+ * IN  assertion: all calls to to INSERT_STRING are made with consecutive
+ *    input characters and the first MIN_MATCH bytes of str are valid
+ *    (except for the last MIN_MATCH-1 bytes of the input file).
+ */
+#ifdef FASTEST
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    match_head = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#else
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#endif
+
+/* ===========================================================================
+ * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
+ * prev[] will be initialized on the fly.
+ */
+#define CLEAR_HASH(s) \
+    s->head[s->hash_size-1] = NIL; \
+    zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+
+/* ========================================================================= */
+int ZEXPORT deflateInit_(strm, level, version, stream_size)
+    z_streamp strm;
+    int level;
+    const char *version;
+    int stream_size;
+{
+    return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
+                         Z_DEFAULT_STRATEGY, version, stream_size);
+    /* To do: ignore strm->next_in if we use it as window */
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+                  version, stream_size)
+    z_streamp strm;
+    int  level;
+    int  method;
+    int  windowBits;
+    int  memLevel;
+    int  strategy;
+    const char *version;
+    int stream_size;
+{
+    deflate_state *s;
+    int wrap = 1;
+    static const char my_version[] = ZLIB_VERSION;
+
+    ushf *overlay;
+    /* We overlay pending_buf and d_buf+l_buf. This works since the average
+     * output size for (length,distance) codes is <= 24 bits.
+     */
+
+    if (version == Z_NULL || version[0] != my_version[0] ||
+        stream_size != sizeof(z_stream)) {
+        return Z_VERSION_ERROR;
+    }
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+
+    strm->msg = Z_NULL;
+    if (strm->zalloc == (alloc_func)0) {
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+    }
+    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+
+#ifdef FASTEST
+    if (level != 0) level = 1;
+#else
+    if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+
+    if (windowBits < 0) { /* suppress zlib wrapper */
+        wrap = 0;
+        windowBits = -windowBits;
+    }
+#ifdef GZIP
+    else if (windowBits > 15) {
+        wrap = 2;       /* write gzip wrapper instead */
+        windowBits -= 16;
+    }
+#endif
+    if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
+        windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
+        strategy < 0 || strategy > Z_FIXED) {
+        return Z_STREAM_ERROR;
+    }
+    if (windowBits == 8) windowBits = 9;  /* until 256-byte window bug fixed */
+    s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
+    if (s == Z_NULL) return Z_MEM_ERROR;
+    strm->state = (struct internal_state FAR *)s;
+    s->strm = strm;
+
+    s->wrap = wrap;
+    s->gzhead = Z_NULL;
+    s->w_bits = windowBits;
+    s->w_size = 1 << s->w_bits;
+    s->w_mask = s->w_size - 1;
+
+    s->hash_bits = memLevel + 7;
+    s->hash_size = 1 << s->hash_bits;
+    s->hash_mask = s->hash_size - 1;
+    s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
+
+    s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
+    s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
+    s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
+
+    s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
+
+    overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
+    s->pending_buf = (uchf *) overlay;
+    s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
+
+    if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
+        s->pending_buf == Z_NULL) {
+        s->status = FINISH_STATE;
+        strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
+        deflateEnd (strm);
+        return Z_MEM_ERROR;
+    }
+    s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
+    s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
+
+    s->level = level;
+    s->strategy = strategy;
+    s->method = (Byte)method;
+
+    return deflateReset(strm);
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+    z_streamp strm;
+    const Bytef *dictionary;
+    uInt  dictLength;
+{
+    deflate_state *s;
+    uInt length = dictLength;
+    uInt n;
+    IPos hash_head = 0;
+
+    if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
+        strm->state->wrap == 2 ||
+        (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
+        return Z_STREAM_ERROR;
+
+    s = strm->state;
+    if (s->wrap)
+        strm->adler = adler32(strm->adler, dictionary, dictLength);
+
+    if (length < MIN_MATCH) return Z_OK;
+    if (length > MAX_DIST(s)) {
+        length = MAX_DIST(s);
+        dictionary += dictLength - length; /* use the tail of the dictionary */
+    }
+    zmemcpy(s->window, dictionary, length);
+    s->strstart = length;
+    s->block_start = (long)length;
+
+    /* Insert all strings in the hash table (except for the last two bytes).
+     * s->lookahead stays null, so s->ins_h will be recomputed at the next
+     * call of fill_window.
+     */
+    s->ins_h = s->window[0];
+    UPDATE_HASH(s, s->ins_h, s->window[1]);
+    for (n = 0; n <= length - MIN_MATCH; n++) {
+        INSERT_STRING(s, n, hash_head);
+    }
+    if (hash_head) hash_head = 0;  /* to make compiler happy */
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateReset (strm)
+    z_streamp strm;
+{
+    deflate_state *s;
+
+    if (strm == Z_NULL || strm->state == Z_NULL ||
+        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
+        return Z_STREAM_ERROR;
+    }
+
+    strm->total_in = strm->total_out = 0;
+    strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
+    strm->data_type = Z_UNKNOWN;
+
+    s = (deflate_state *)strm->state;
+    s->pending = 0;
+    s->pending_out = s->pending_buf;
+
+    if (s->wrap < 0) {
+        s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
+    }
+    s->status = s->wrap ? INIT_STATE : BUSY_STATE;
+    strm->adler =
+#ifdef GZIP
+        s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
+#endif
+        adler32(0L, Z_NULL, 0);
+    s->last_flush = Z_NO_FLUSH;
+
+    _tr_init(s);
+    lm_init(s);
+
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetHeader (strm, head)
+    z_streamp strm;
+    gz_headerp head;
+{
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    if (strm->state->wrap != 2) return Z_STREAM_ERROR;
+    strm->state->gzhead = head;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflatePrime (strm, bits, value)
+    z_streamp strm;
+    int bits;
+    int value;
+{
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    strm->state->bi_valid = bits;
+    strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateParams(strm, level, strategy)
+    z_streamp strm;
+    int level;
+    int strategy;
+{
+    deflate_state *s;
+    compress_func func;
+    int err = Z_OK;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    s = strm->state;
+
+#ifdef FASTEST
+    if (level != 0) level = 1;
+#else
+    if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
+        return Z_STREAM_ERROR;
+    }
+    func = configuration_table[s->level].func;
+
+    if (func != configuration_table[level].func && strm->total_in != 0) {
+        /* Flush the last buffer: */
+        err = deflate(strm, Z_PARTIAL_FLUSH);
+    }
+    if (s->level != level) {
+        s->level = level;
+        s->max_lazy_match   = configuration_table[level].max_lazy;
+        s->good_match       = configuration_table[level].good_length;
+        s->nice_match       = configuration_table[level].nice_length;
+        s->max_chain_length = configuration_table[level].max_chain;
+    }
+    s->strategy = strategy;
+    return err;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
+    z_streamp strm;
+    int good_length;
+    int max_lazy;
+    int nice_length;
+    int max_chain;
+{
+    deflate_state *s;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    s = strm->state;
+    s->good_match = good_length;
+    s->max_lazy_match = max_lazy;
+    s->nice_match = nice_length;
+    s->max_chain_length = max_chain;
+    return Z_OK;
+}
+
+/* =========================================================================
+ * For the default windowBits of 15 and memLevel of 8, this function returns
+ * a close to exact, as well as small, upper bound on the compressed size.
+ * They are coded as constants here for a reason--if the #define's are
+ * changed, then this function needs to be changed as well.  The return
+ * value for 15 and 8 only works for those exact settings.
+ *
+ * For any setting other than those defaults for windowBits and memLevel,
+ * the value returned is a conservative worst case for the maximum expansion
+ * resulting from using fixed blocks instead of stored blocks, which deflate
+ * can emit on compressed data for some combinations of the parameters.
+ *
+ * This function could be more sophisticated to provide closer upper bounds
+ * for every combination of windowBits and memLevel, as well as wrap.
+ * But even the conservative upper bound of about 14% expansion does not
+ * seem onerous for output buffer allocation.
+ */
+uLong ZEXPORT deflateBound(strm, sourceLen)
+    z_streamp strm;
+    uLong sourceLen;
+{
+    deflate_state *s;
+    uLong destLen;
+
+    /* conservative upper bound */
+    destLen = sourceLen +
+              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11;
+
+    /* if can't get parameters, return conservative bound */
+    if (strm == Z_NULL || strm->state == Z_NULL)
+        return destLen;
+
+    /* if not default parameters, return conservative bound */
+    s = strm->state;
+    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
+        return destLen;
+
+    /* default settings: return tight bound for that case */
+    return compressBound(sourceLen);
+}
+
+/* =========================================================================
+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.
+ * IN assertion: the stream state is correct and there is enough room in
+ * pending_buf.
+ */
+local void putShortMSB (s, b)
+    deflate_state *s;
+    uInt b;
+{
+    put_byte(s, (Byte)(b >> 8));
+    put_byte(s, (Byte)(b & 0xff));
+}
+
+/* =========================================================================
+ * Flush as much pending output as possible. All deflate() output goes
+ * through this function so some applications may wish to modify it
+ * to avoid allocating a large strm->next_out buffer and copying into it.
+ * (See also read_buf()).
+ */
+local void flush_pending(strm)
+    z_streamp strm;
+{
+    unsigned len = strm->state->pending;
+
+    if (len > strm->avail_out) len = strm->avail_out;
+    if (len == 0) return;
+
+    zmemcpy(strm->next_out, strm->state->pending_out, len);
+    strm->next_out  += len;
+    strm->state->pending_out  += len;
+    strm->total_out += len;
+    strm->avail_out  -= len;
+    strm->state->pending -= len;
+    if (strm->state->pending == 0) {
+        strm->state->pending_out = strm->state->pending_buf;
+    }
+}
+
+/* ========================================================================= */
+int ZEXPORT deflate (strm, flush)
+    z_streamp strm;
+    int flush;
+{
+    int old_flush; /* value of flush param for previous deflate call */
+    deflate_state *s;
+
+    if (strm == Z_NULL || strm->state == Z_NULL ||
+        flush > Z_FINISH || flush < 0) {
+        return Z_STREAM_ERROR;
+    }
+    s = strm->state;
+
+    if (strm->next_out == Z_NULL ||
+        (strm->next_in == Z_NULL && strm->avail_in != 0) ||
+        (s->status == FINISH_STATE && flush != Z_FINISH)) {
+        ERR_RETURN(strm, Z_STREAM_ERROR);
+    }
+    if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
+
+    s->strm = strm; /* just in case */
+    old_flush = s->last_flush;
+    s->last_flush = flush;
+
+    /* Write the header */
+    if (s->status == INIT_STATE) {
+#ifdef GZIP
+        if (s->wrap == 2) {
+            strm->adler = crc32(0L, Z_NULL, 0);
+            put_byte(s, 31);
+            put_byte(s, 139);
+            put_byte(s, 8);
+            if (s->gzhead == NULL) {
+                put_byte(s, 0);
+                put_byte(s, 0);
+                put_byte(s, 0);
+                put_byte(s, 0);
+                put_byte(s, 0);
+                put_byte(s, s->level == 9 ? 2 :
+                            (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+                             4 : 0));
+                put_byte(s, OS_CODE);
+                s->status = BUSY_STATE;
+            }
+            else {
+                put_byte(s, (s->gzhead->text ? 1 : 0) +
+                            (s->gzhead->hcrc ? 2 : 0) +
+                            (s->gzhead->extra == Z_NULL ? 0 : 4) +
+                            (s->gzhead->name == Z_NULL ? 0 : 8) +
+                            (s->gzhead->comment == Z_NULL ? 0 : 16)
+                        );
+                put_byte(s, (Byte)(s->gzhead->time & 0xff));
+                put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
+                put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
+                put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
+                put_byte(s, s->level == 9 ? 2 :
+                            (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+                             4 : 0));
+                put_byte(s, s->gzhead->os & 0xff);
+                if (s->gzhead->extra != NULL) {
+                    put_byte(s, s->gzhead->extra_len & 0xff);
+                    put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
+                }
+                if (s->gzhead->hcrc)
+                    strm->adler = crc32(strm->adler, s->pending_buf,
+                                        s->pending);
+                s->gzindex = 0;
+                s->status = EXTRA_STATE;
+            }
+        }
+        else
+#endif
+        {
+            uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+            uInt level_flags;
+
+            if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
+                level_flags = 0;
+            else if (s->level < 6)
+                level_flags = 1;
+            else if (s->level == 6)
+                level_flags = 2;
+            else
+                level_flags = 3;
+            header |= (level_flags << 6);
+            if (s->strstart != 0) header |= PRESET_DICT;
+            header += 31 - (header % 31);
+
+            s->status = BUSY_STATE;
+            putShortMSB(s, header);
+
+            /* Save the adler32 of the preset dictionary: */
+            if (s->strstart != 0) {
+                putShortMSB(s, (uInt)(strm->adler >> 16));
+                putShortMSB(s, (uInt)(strm->adler & 0xffff));
+            }
+            strm->adler = adler32(0L, Z_NULL, 0);
+        }
+    }
+#ifdef GZIP
+    if (s->status == EXTRA_STATE) {
+        if (s->gzhead->extra != NULL) {
+            uInt beg = s->pending;  /* start of bytes to update crc */
+
+            while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
+                if (s->pending == s->pending_buf_size) {
+                    if (s->gzhead->hcrc && s->pending > beg)
+                        strm->adler = crc32(strm->adler, s->pending_buf + beg,
+                                            s->pending - beg);
+                    flush_pending(strm);
+                    beg = s->pending;
+                    if (s->pending == s->pending_buf_size)
+                        break;
+                }
+                put_byte(s, s->gzhead->extra[s->gzindex]);
+                s->gzindex++;
+            }
+            if (s->gzhead->hcrc && s->pending > beg)
+                strm->adler = crc32(strm->adler, s->pending_buf + beg,
+                                    s->pending - beg);
+            if (s->gzindex == s->gzhead->extra_len) {
+                s->gzindex = 0;
+                s->status = NAME_STATE;
+            }
+        }
+        else
+            s->status = NAME_STATE;
+    }
+    if (s->status == NAME_STATE) {
+        if (s->gzhead->name != NULL) {
+            uInt beg = s->pending;  /* start of bytes to update crc */
+            int val;
+
+            do {
+                if (s->pending == s->pending_buf_size) {
+                    if (s->gzhead->hcrc && s->pending > beg)
+                        strm->adler = crc32(strm->adler, s->pending_buf + beg,
+                                            s->pending - beg);
+                    flush_pending(strm);
+                    beg = s->pending;
+                    if (s->pending == s->pending_buf_size) {
+                        val = 1;
+                        break;
+                    }
+                }
+                val = s->gzhead->name[s->gzindex++];
+                put_byte(s, val);
+            } while (val != 0);
+            if (s->gzhead->hcrc && s->pending > beg)
+                strm->adler = crc32(strm->adler, s->pending_buf + beg,
+                                    s->pending - beg);
+            if (val == 0) {
+                s->gzindex = 0;
+                s->status = COMMENT_STATE;
+            }
+        }
+        else
+            s->status = COMMENT_STATE;
+    }
+    if (s->status == COMMENT_STATE) {
+        if (s->gzhead->comment != NULL) {
+            uInt beg = s->pending;  /* start of bytes to update crc */
+            int val;
+
+            do {
+                if (s->pending == s->pending_buf_size) {
+                    if (s->gzhead->hcrc && s->pending > beg)
+                        strm->adler = crc32(strm->adler, s->pending_buf + beg,
+                                            s->pending - beg);
+                    flush_pending(strm);
+                    beg = s->pending;
+                    if (s->pending == s->pending_buf_size) {
+                        val = 1;
+                        break;
+                    }
+                }
+                val = s->gzhead->comment[s->gzindex++];
+                put_byte(s, val);
+            } while (val != 0);
+            if (s->gzhead->hcrc && s->pending > beg)
+                strm->adler = crc32(strm->adler, s->pending_buf + beg,
+                                    s->pending - beg);
+            if (val == 0)
+                s->status = HCRC_STATE;
+        }
+        else
+            s->status = HCRC_STATE;
+    }
+    if (s->status == HCRC_STATE) {
+        if (s->gzhead->hcrc) {
+            if (s->pending + 2 > s->pending_buf_size)
+                flush_pending(strm);
+            if (s->pending + 2 <= s->pending_buf_size) {
+                put_byte(s, (Byte)(strm->adler & 0xff));
+                put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+                strm->adler = crc32(0L, Z_NULL, 0);
+                s->status = BUSY_STATE;
+            }
+        }
+        else
+            s->status = BUSY_STATE;
+    }
+#endif
+
+    /* Flush as much pending output as possible */
+    if (s->pending != 0) {
+        flush_pending(strm);
+        if (strm->avail_out == 0) {
+            /* Since avail_out is 0, deflate will be called again with
+             * more output space, but possibly with both pending and
+             * avail_in equal to zero. There won't be anything to do,
+             * but this is not an error situation so make sure we
+             * return OK instead of BUF_ERROR at next call of deflate:
+             */
+            s->last_flush = -1;
+            return Z_OK;
+        }
+
+    /* Make sure there is something to do and avoid duplicate consecutive
+     * flushes. For repeated and useless calls with Z_FINISH, we keep
+     * returning Z_STREAM_END instead of Z_BUF_ERROR.
+     */
+    } else if (strm->avail_in == 0 && flush <= old_flush &&
+               flush != Z_FINISH) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* User must not provide more input after the first FINISH: */
+    if (s->status == FINISH_STATE && strm->avail_in != 0) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* Start a new block or continue the current one.
+     */
+    if (strm->avail_in != 0 || s->lookahead != 0 ||
+        (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
+        block_state bstate;
+
+        bstate = (*(configuration_table[s->level].func))(s, flush);
+
+        if (bstate == finish_started || bstate == finish_done) {
+            s->status = FINISH_STATE;
+        }
+        if (bstate == need_more || bstate == finish_started) {
+            if (strm->avail_out == 0) {
+                s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
+            }
+            return Z_OK;
+            /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
+             * of deflate should use the same flush parameter to make sure
+             * that the flush is complete. So we don't have to output an
+             * empty block here, this will be done at next call. This also
+             * ensures that for a very small output buffer, we emit at most
+             * one empty block.
+             */
+        }
+        if (bstate == block_done) {
+            if (flush == Z_PARTIAL_FLUSH) {
+                _tr_align(s);
+            } else { /* FULL_FLUSH or SYNC_FLUSH */
+                _tr_stored_block(s, (char*)0, 0L, 0);
+                /* For a full flush, this empty block will be recognized
+                 * as a special marker by inflate_sync().
+                 */
+                if (flush == Z_FULL_FLUSH) {
+                    CLEAR_HASH(s);             /* forget history */
+                }
+            }
+            flush_pending(strm);
+            if (strm->avail_out == 0) {
+              s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
+              return Z_OK;
+            }
+        }
+    }
+    Assert(strm->avail_out > 0, "bug2");
+
+    if (flush != Z_FINISH) return Z_OK;
+    if (s->wrap <= 0) return Z_STREAM_END;
+
+    /* Write the trailer */
+#ifdef GZIP
+    if (s->wrap == 2) {
+        put_byte(s, (Byte)(strm->adler & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
+        put_byte(s, (Byte)(strm->total_in & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
+    }
+    else
+#endif
+    {
+        putShortMSB(s, (uInt)(strm->adler >> 16));
+        putShortMSB(s, (uInt)(strm->adler & 0xffff));
+    }
+    flush_pending(strm);
+    /* If avail_out is zero, the application will call deflate again
+     * to flush the rest.
+     */
+    if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
+    return s->pending != 0 ? Z_OK : Z_STREAM_END;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateEnd (strm)
+    z_streamp strm;
+{
+    int status;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+
+    status = strm->state->status;
+    if (status != INIT_STATE &&
+        status != EXTRA_STATE &&
+        status != NAME_STATE &&
+        status != COMMENT_STATE &&
+        status != HCRC_STATE &&
+        status != BUSY_STATE &&
+        status != FINISH_STATE) {
+      return Z_STREAM_ERROR;
+    }
+
+    /* Deallocate in reverse order of allocations: */
+    TRY_FREE(strm, strm->state->pending_buf);
+    TRY_FREE(strm, strm->state->head);
+    TRY_FREE(strm, strm->state->prev);
+    TRY_FREE(strm, strm->state->window);
+
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+
+    return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
+}
+
+/* =========================================================================
+ * Copy the source state to the destination state.
+ * To simplify the source, this is not supported for 16-bit MSDOS (which
+ * doesn't have enough memory anyway to duplicate compression states).
+ */
+int ZEXPORT deflateCopy (dest, source)
+    z_streamp dest;
+    z_streamp source;
+{
+#ifdef MAXSEG_64K
+    return Z_STREAM_ERROR;
+#else
+    deflate_state *ds;
+    deflate_state *ss;
+    ushf *overlay;
+
+
+    if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
+        return Z_STREAM_ERROR;
+    }
+
+    ss = source->state;
+
+    zmemcpy(dest, source, sizeof(z_stream));
+
+    ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
+    if (ds == Z_NULL) return Z_MEM_ERROR;
+    dest->state = (struct internal_state FAR *) ds;
+    zmemcpy(ds, ss, sizeof(deflate_state));
+    ds->strm = dest;
+
+    ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
+    ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
+    ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
+    overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
+    ds->pending_buf = (uchf *) overlay;
+
+    if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
+        ds->pending_buf == Z_NULL) {
+        deflateEnd (dest);
+        return Z_MEM_ERROR;
+    }
+    /* following zmemcpy do not work for 16-bit MSDOS */
+    zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
+    zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
+    zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
+    zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+
+    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+    ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
+    ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
+
+    ds->l_desc.dyn_tree = ds->dyn_ltree;
+    ds->d_desc.dyn_tree = ds->dyn_dtree;
+    ds->bl_desc.dyn_tree = ds->bl_tree;
+
+    return Z_OK;
+#endif /* MAXSEG_64K */
+}
+
+/* ===========================================================================
+ * Read a new buffer from the current input stream, update the adler32
+ * and total number of bytes read.  All deflate() input goes through
+ * this function so some applications may wish to modify it to avoid
+ * allocating a large strm->next_in buffer and copying from it.
+ * (See also flush_pending()).
+ */
+local int read_buf(strm, buf, size)
+    z_streamp strm;
+    Bytef *buf;
+    unsigned size;
+{
+    unsigned len = strm->avail_in;
+
+    if (len > size) len = size;
+    if (len == 0) return 0;
+
+    strm->avail_in  -= len;
+
+    if (strm->state->wrap == 1) {
+        strm->adler = adler32(strm->adler, strm->next_in, len);
+    }
+#ifdef GZIP
+    else if (strm->state->wrap == 2) {
+        strm->adler = crc32(strm->adler, strm->next_in, len);
+    }
+#endif
+    zmemcpy(buf, strm->next_in, len);
+    strm->next_in  += len;
+    strm->total_in += len;
+
+    return (int)len;
+}
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new zlib stream
+ */
+local void lm_init (s)
+    deflate_state *s;
+{
+    s->window_size = (ulg)2L*s->w_size;
+
+    CLEAR_HASH(s);
+
+    /* Set the default configuration parameters:
+     */
+    s->max_lazy_match   = configuration_table[s->level].max_lazy;
+    s->good_match       = configuration_table[s->level].good_length;
+    s->nice_match       = configuration_table[s->level].nice_length;
+    s->max_chain_length = configuration_table[s->level].max_chain;
+
+    s->strstart = 0;
+    s->block_start = 0L;
+    s->lookahead = 0;
+    s->match_length = s->prev_length = MIN_MATCH-1;
+    s->match_available = 0;
+    s->ins_h = 0;
+#ifndef FASTEST
+#ifdef ASMV
+    match_init(); /* initialize the asm code */
+#endif
+#endif
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ * OUT assertion: the match length is not greater than s->lookahead.
+ */
+#ifndef ASMV
+/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
+ * match.S. The code will be functionally equivalent.
+ */
+local uInt longest_match(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    unsigned chain_length = s->max_chain_length;/* max hash chain length */
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                       /* matched string */
+    register int len;                           /* length of current match */
+    int best_len = s->prev_length;              /* best match length so far */
+    int nice_match = s->nice_match;             /* stop if match long enough */
+    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+        s->strstart - (IPos)MAX_DIST(s) : NIL;
+    /* Stop when cur_match becomes <= limit. To simplify the code,
+     * we prevent matches with the string of window index 0.
+     */
+    Posf *prev = s->prev;
+    uInt wmask = s->w_mask;
+
+#ifdef UNALIGNED_OK
+    /* Compare two bytes at a time. Note: this is not always beneficial.
+     * Try with and without -DUNALIGNED_OK to check.
+     */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+    register ush scan_start = *(ushf*)scan;
+    register ush scan_end   = *(ushf*)(scan+best_len-1);
+#else
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    register Byte scan_end1  = scan[best_len-1];
+    register Byte scan_end   = scan[best_len];
+#endif
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    /* Do not waste too much time if we already have a good match: */
+    if (s->prev_length >= s->good_match) {
+        chain_length >>= 2;
+    }
+    /* Do not look for matches beyond the end of the input. This is necessary
+     * to make deflate deterministic.
+     */
+    if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    do {
+        Assert(cur_match < s->strstart, "no future");
+        match = s->window + cur_match;
+
+        /* Skip to next match if the match length cannot increase
+         * or if the match length is less than 2.  Note that the checks below
+         * for insufficient lookahead only occur occasionally for performance
+         * reasons.  Therefore uninitialized memory will be accessed, and
+         * conditional jumps will be made that depend on those values.
+         * However the length of the match is limited to the lookahead, so
+         * the output of deflate is not affected by the uninitialized values.
+         */
+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
+        /* This code assumes sizeof(unsigned short) == 2. Do not use
+         * UNALIGNED_OK if your compiler uses a different size.
+         */
+        if (*(ushf*)(match+best_len-1) != scan_end ||
+            *(ushf*)match != scan_start) continue;
+
+        /* It is not necessary to compare scan[2] and match[2] since they are
+         * always equal when the other bytes match, given that the hash keys
+         * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
+         * strstart+3, +5, ... up to strstart+257. We check for insufficient
+         * lookahead only every 4th comparison; the 128th check will be made
+         * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
+         * necessary to put more guard bytes at the end of the window, or
+         * to check more often for insufficient lookahead.
+         */
+        Assert(scan[2] == match[2], "scan[2]?");
+        scan++, match++;
+        do {
+        } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 scan < strend);
+        /* The funny "do {}" generates better code on most compilers */
+
+        /* Here, scan <= window+strstart+257 */
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+        if (*scan == *match) scan++;
+
+        len = (MAX_MATCH - 1) - (int)(strend-scan);
+        scan = strend - (MAX_MATCH-1);
+
+#else /* UNALIGNED_OK */
+
+        if (match[best_len]   != scan_end  ||
+            match[best_len-1] != scan_end1 ||
+            *match            != *scan     ||
+            *++match          != scan[1])      continue;
+
+        /* The check at best_len-1 can be removed because it will be made
+         * again later. (This heuristic is not always a win.)
+         * It is not necessary to compare scan[2] and match[2] since they
+         * are always equal when the other bytes match, given that
+         * the hash keys are equal and that HASH_BITS >= 8.
+         */
+        scan += 2, match++;
+        Assert(*scan == *match, "match[2]?");
+
+        /* We check for insufficient lookahead only every 8th comparison;
+         * the 256th check will be made at strstart+258.
+         */
+        do {
+        } while (*++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 scan < strend);
+
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+        len = MAX_MATCH - (int)(strend - scan);
+        scan = strend - MAX_MATCH;
+
+#endif /* UNALIGNED_OK */
+
+        if (len > best_len) {
+            s->match_start = cur_match;
+            best_len = len;
+            if (len >= nice_match) break;
+#ifdef UNALIGNED_OK
+            scan_end = *(ushf*)(scan+best_len-1);
+#else
+            scan_end1  = scan[best_len-1];
+            scan_end   = scan[best_len];
+#endif
+        }
+    } while ((cur_match = prev[cur_match & wmask]) > limit
+             && --chain_length != 0);
+
+    if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+    return s->lookahead;
+}
+#endif /* ASMV */
+#endif /* FASTEST */
+
+/* ---------------------------------------------------------------------------
+ * Optimized version for level == 1 or strategy == Z_RLE only
+ */
+local uInt longest_match_fast(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                       /* matched string */
+    register int len;                           /* length of current match */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    Assert(cur_match < s->strstart, "no future");
+
+    match = s->window + cur_match;
+
+    /* Return failure if the match length is less than 2:
+     */
+    if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
+
+    /* The check at best_len-1 can be removed because it will be made
+     * again later. (This heuristic is not always a win.)
+     * It is not necessary to compare scan[2] and match[2] since they
+     * are always equal when the other bytes match, given that
+     * the hash keys are equal and that HASH_BITS >= 8.
+     */
+    scan += 2, match += 2;
+    Assert(*scan == *match, "match[2]?");
+
+    /* We check for insufficient lookahead only every 8th comparison;
+     * the 256th check will be made at strstart+258.
+     */
+    do {
+    } while (*++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             scan < strend);
+
+    Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+    len = MAX_MATCH - (int)(strend - scan);
+
+    if (len < MIN_MATCH) return MIN_MATCH - 1;
+
+    s->match_start = cur_match;
+    return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
+}
+
+#ifdef DEBUG
+/* ===========================================================================
+ * Check that the match at match_start is indeed a match.
+ */
+local void check_match(s, start, match, length)
+    deflate_state *s;
+    IPos start, match;
+    int length;
+{
+    /* check that the match is indeed a match */
+    if (zmemcmp(s->window + match,
+                s->window + start, length) != EQUAL) {
+        fprintf(stderr, " start %u, match %u, length %d\n",
+                start, match, length);
+        do {
+            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
+        } while (--length != 0);
+        z_error("invalid match");
+    }
+    if (z_verbose > 1) {
+        fprintf(stderr,"\\[%d,%d]", start-match, length);
+        do { putc(s->window[start++], stderr); } while (--length != 0);
+    }
+}
+#else
+#  define check_match(s, start, match, length)
+#endif /* DEBUG */
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead.
+ *
+ * IN assertion: lookahead < MIN_LOOKAHEAD
+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ *    At least one byte has been read, or avail_in == 0; reads are
+ *    performed for at least two bytes (required for the zip translate_eol
+ *    option -- not supported here).
+ */
+local void fill_window(s)
+    deflate_state *s;
+{
+    register unsigned n, m;
+    register Posf *p;
+    unsigned more;    /* Amount of free space at the end of the window. */
+    uInt wsize = s->w_size;
+
+    do {
+        more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
+
+        /* Deal with !@#$% 64K limit: */
+        if (sizeof(int) <= 2) {
+            if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
+                more = wsize;
+
+            } else if (more == (unsigned)(-1)) {
+                /* Very unlikely, but possible on 16 bit machine if
+                 * strstart == 0 && lookahead == 1 (input done a byte at time)
+                 */
+                more--;
+            }
+        }
+
+        /* If the window is almost full and there is insufficient lookahead,
+         * move the upper half to the lower one to make room in the upper half.
+         */
+        if (s->strstart >= wsize+MAX_DIST(s)) {
+
+            zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
+            s->match_start -= wsize;
+            s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
+            s->block_start -= (long) wsize;
+
+            /* Slide the hash table (could be avoided with 32 bit values
+               at the expense of memory usage). We slide even when level == 0
+               to keep the hash table consistent if we switch back to level > 0
+               later. (Using level 0 permanently is not an optimal usage of
+               zlib, so we don't care about this pathological case.)
+             */
+            /* %%% avoid this when Z_RLE */
+            n = s->hash_size;
+            p = &s->head[n];
+            do {
+                m = *--p;
+                *p = (Pos)(m >= wsize ? m-wsize : NIL);
+            } while (--n);
+
+            n = wsize;
+#ifndef FASTEST
+            p = &s->prev[n];
+            do {
+                m = *--p;
+                *p = (Pos)(m >= wsize ? m-wsize : NIL);
+                /* If n is not on any hash chain, prev[n] is garbage but
+                 * its value will never be used.
+                 */
+            } while (--n);
+#endif
+            more += wsize;
+        }
+        if (s->strm->avail_in == 0) return;
+
+        /* If there was no sliding:
+         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+         *    more == window_size - lookahead - strstart
+         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+         * => more >= window_size - 2*WSIZE + 2
+         * In the BIG_MEM or MMAP case (not yet supported),
+         *   window_size == input_size + MIN_LOOKAHEAD  &&
+         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+         * Otherwise, window_size == 2*WSIZE so more >= 2.
+         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+         */
+        Assert(more >= 2, "more < 2");
+
+        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
+        s->lookahead += n;
+
+        /* Initialize the hash value now that we have some input: */
+        if (s->lookahead >= MIN_MATCH) {
+            s->ins_h = s->window[s->strstart];
+            UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+            Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+        }
+        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+         * but this is not important since only literal bytes will be emitted.
+         */
+
+    } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
+}
+
+/* ===========================================================================
+ * Flush the current block, with given end-of-file flag.
+ * IN assertion: strstart is set to the end of the current match.
+ */
+#define FLUSH_BLOCK_ONLY(s, eof) { \
+   _tr_flush_block(s, (s->block_start >= 0L ? \
+                   (charf *)&s->window[(unsigned)s->block_start] : \
+                   (charf *)Z_NULL), \
+                (ulg)((long)s->strstart - s->block_start), \
+                (eof)); \
+   s->block_start = s->strstart; \
+   flush_pending(s->strm); \
+   Tracev((stderr,"[FLUSH]")); \
+}
+
+/* Same but force premature exit if necessary. */
+#define FLUSH_BLOCK(s, eof) { \
+   FLUSH_BLOCK_ONLY(s, eof); \
+   if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
+}
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ * This function does not insert new strings in the dictionary since
+ * uncompressible data is probably not useful. This function is used
+ * only for the level=0 compression option.
+ * NOTE: this function should be optimized to avoid extra copying from
+ * window to pending_buf.
+ */
+local block_state deflate_stored(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
+     * to pending_buf_size, and each stored block has a 5 byte header:
+     */
+    ulg max_block_size = 0xffff;
+    ulg max_start;
+
+    if (max_block_size > s->pending_buf_size - 5) {
+        max_block_size = s->pending_buf_size - 5;
+    }
+
+    /* Copy as much as possible from input to output: */
+    for (;;) {
+        /* Fill the window as much as possible: */
+        if (s->lookahead <= 1) {
+
+            Assert(s->strstart < s->w_size+MAX_DIST(s) ||
+                   s->block_start >= (long)s->w_size, "slide too late");
+
+            fill_window(s);
+            if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
+
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+        Assert(s->block_start >= 0L, "block gone");
+
+        s->strstart += s->lookahead;
+        s->lookahead = 0;
+
+        /* Emit a stored block if pending_buf will be full: */
+        max_start = s->block_start + max_block_size;
+        if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
+            /* strstart == 0 is possible when wraparound on 16-bit machine */
+            s->lookahead = (uInt)(s->strstart - max_start);
+            s->strstart = (uInt)max_start;
+            FLUSH_BLOCK(s, 0);
+        }
+        /* Flush if we may have to slide, otherwise block_start may become
+         * negative and the data will be gone:
+         */
+        if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
+            FLUSH_BLOCK(s, 0);
+        }
+    }
+    FLUSH_BLOCK(s, flush == Z_FINISH);
+    return flush == Z_FINISH ? finish_done : block_done;
+}
+
+/* ===========================================================================
+ * Compress as much as possible from the input stream, return the current
+ * block state.
+ * This function does not perform lazy evaluation of matches and inserts
+ * new strings in the dictionary only for unmatched strings or for short
+ * matches. It is used only for the fast compression options.
+ */
+local block_state deflate_fast(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head = NIL; /* head of the hash chain */
+    int bflush;           /* set if current block must be flushed */
+
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         * At this point we have always match_length < MIN_MATCH
+         */
+        if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+#ifdef FASTEST
+            if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) ||
+                (s->strategy == Z_RLE && s->strstart - hash_head == 1)) {
+                s->match_length = longest_match_fast (s, hash_head);
+            }
+#else
+            if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
+                s->match_length = longest_match (s, hash_head);
+            } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
+                s->match_length = longest_match_fast (s, hash_head);
+            }
+#endif
+            /* longest_match() or longest_match_fast() sets match_start */
+        }
+        if (s->match_length >= MIN_MATCH) {
+            check_match(s, s->strstart, s->match_start, s->match_length);
+
+            _tr_tally_dist(s, s->strstart - s->match_start,
+                           s->match_length - MIN_MATCH, bflush);
+
+            s->lookahead -= s->match_length;
+
+            /* Insert new strings in the hash table only if the match length
+             * is not too large. This saves time but degrades compression.
+             */
+#ifndef FASTEST
+            if (s->match_length <= s->max_insert_length &&
+                s->lookahead >= MIN_MATCH) {
+                s->match_length--; /* string at strstart already in table */
+                do {
+                    s->strstart++;
+                    INSERT_STRING(s, s->strstart, hash_head);
+                    /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+                     * always MIN_MATCH bytes ahead.
+                     */
+                } while (--s->match_length != 0);
+                s->strstart++;
+            } else
+#endif
+            {
+                s->strstart += s->match_length;
+                s->match_length = 0;
+                s->ins_h = s->window[s->strstart];
+                UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+                Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+                /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                 * matter since it will be recomputed at next deflate call.
+                 */
+            }
+        } else {
+            /* No match, output a literal byte */
+            Tracevv((stderr,"%c", s->window[s->strstart]));
+            _tr_tally_lit (s, s->window[s->strstart], bflush);
+            s->lookahead--;
+            s->strstart++;
+        }
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    FLUSH_BLOCK(s, flush == Z_FINISH);
+    return flush == Z_FINISH ? finish_done : block_done;
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+local block_state deflate_slow(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head = NIL;    /* head of hash chain */
+    int bflush;              /* set if current block must be flushed */
+
+    /* Process the input block. */
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         */
+        s->prev_length = s->match_length, s->prev_match = s->match_start;
+        s->match_length = MIN_MATCH-1;
+
+        if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
+            s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+            if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
+                s->match_length = longest_match (s, hash_head);
+            } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
+                s->match_length = longest_match_fast (s, hash_head);
+            }
+            /* longest_match() or longest_match_fast() sets match_start */
+
+            if (s->match_length <= 5 && (s->strategy == Z_FILTERED
+#if TOO_FAR <= 32767
+                || (s->match_length == MIN_MATCH &&
+                    s->strstart - s->match_start > TOO_FAR)
+#endif
+                )) {
+
+                /* If prev_match is also MIN_MATCH, match_start is garbage
+                 * but we will ignore the current match anyway.
+                 */
+                s->match_length = MIN_MATCH-1;
+            }
+        }
+        /* If there was a match at the previous step and the current
+         * match is not better, output the previous match:
+         */
+        if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
+            uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
+            /* Do not insert strings in hash table beyond this. */
+
+            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+
+            _tr_tally_dist(s, s->strstart -1 - s->prev_match,
+                           s->prev_length - MIN_MATCH, bflush);
+
+            /* Insert in hash table all strings up to the end of the match.
+             * strstart-1 and strstart are already inserted. If there is not
+             * enough lookahead, the last two strings are not inserted in
+             * the hash table.
+             */
+            s->lookahead -= s->prev_length-1;
+            s->prev_length -= 2;
+            do {
+                if (++s->strstart <= max_insert) {
+                    INSERT_STRING(s, s->strstart, hash_head);
+                }
+            } while (--s->prev_length != 0);
+            s->match_available = 0;
+            s->match_length = MIN_MATCH-1;
+            s->strstart++;
+
+            if (bflush) FLUSH_BLOCK(s, 0);
+
+        } else if (s->match_available) {
+            /* If there was no match at the previous position, output a
+             * single literal. If there was a match but the current match
+             * is longer, truncate the previous match to a single literal.
+             */
+            Tracevv((stderr,"%c", s->window[s->strstart-1]));
+            _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+            if (bflush) {
+                FLUSH_BLOCK_ONLY(s, 0);
+            }
+            s->strstart++;
+            s->lookahead--;
+            if (s->strm->avail_out == 0) return need_more;
+        } else {
+            /* There is no previous match to compare with, wait for
+             * the next step to decide.
+             */
+            s->match_available = 1;
+            s->strstart++;
+            s->lookahead--;
+        }
+    }
+    Assert (flush != Z_NO_FLUSH, "no flush?");
+    if (s->match_available) {
+        Tracevv((stderr,"%c", s->window[s->strstart-1]));
+        _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+        s->match_available = 0;
+    }
+    FLUSH_BLOCK(s, flush == Z_FINISH);
+    return flush == Z_FINISH ? finish_done : block_done;
+}
+#endif /* FASTEST */
+
+#if 0
+/* ===========================================================================
+ * For Z_RLE, simply look for runs of bytes, generate matches only of distance
+ * one.  Do not maintain a hash table.  (It will be regenerated if this run of
+ * deflate switches away from Z_RLE.)
+ */
+local block_state deflate_rle(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    int bflush;         /* set if current block must be flushed */
+    uInt run;           /* length of run */
+    uInt max;           /* maximum length of run */
+    uInt prev;          /* byte at distance one to match */
+    Bytef *scan;        /* scan for end of run */
+
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the longest encodable run.
+         */
+        if (s->lookahead < MAX_MATCH) {
+            fill_window(s);
+            if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* See how many times the previous byte repeats */
+        run = 0;
+        if (s->strstart > 0) {      /* if there is a previous byte, that is */
+            max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
+            scan = s->window + s->strstart - 1;
+            prev = *scan++;
+            do {
+                if (*scan++ != prev)
+                    break;
+            } while (++run < max);
+        }
+
+        /* Emit match if have run of MIN_MATCH or longer, else emit literal */
+        if (run >= MIN_MATCH) {
+            check_match(s, s->strstart, s->strstart - 1, run);
+            _tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
+            s->lookahead -= run;
+            s->strstart += run;
+        } else {
+            /* No match, output a literal byte */
+            Tracevv((stderr,"%c", s->window[s->strstart]));
+            _tr_tally_lit (s, s->window[s->strstart], bflush);
+            s->lookahead--;
+            s->strstart++;
+        }
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    FLUSH_BLOCK(s, flush == Z_FINISH);
+    return flush == Z_FINISH ? finish_done : block_done;
+}
+#endif
diff --git a/src/reader/zlib/deflate.h b/src/reader/zlib/deflate.h
new file mode 100644
index 00000000..be7b1682
--- /dev/null
+++ b/src/reader/zlib/deflate.h
@@ -0,0 +1,331 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2004 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: deflate.h,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip encoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define INIT_STATE    42
+#define EXTRA_STATE   69
+#define NAME_STATE    73
+#define COMMENT_STATE 91
+#define HCRC_STATE   103
+#define BUSY_STATE   113
+#define FINISH_STATE 666
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+    union {
+        ush  freq;       /* frequency count */
+        ush  code;       /* bit string */
+    } fc;
+    union {
+        ush  dad;        /* father node in Huffman tree */
+        ush  len;        /* length of bit string */
+    } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+typedef struct static_tree_desc_s  static_tree_desc;
+
+typedef struct tree_desc_s {
+    ct_data *dyn_tree;           /* the dynamic tree */
+    int     max_code;            /* largest code with non zero frequency */
+    static_tree_desc *stat_desc; /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+    z_streamp strm;      /* pointer back to this zlib stream */
+    int   status;        /* as the name implies */
+    Bytef *pending_buf;  /* output still pending */
+    ulg   pending_buf_size; /* size of pending_buf */
+    Bytef *pending_out;  /* next pending byte to output to the stream */
+    uInt   pending;      /* nb of bytes in the pending buffer */
+    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
+    gz_headerp  gzhead;  /* gzip header information to write */
+    uInt   gzindex;      /* where in extra, name, or comment */
+    Byte  method;        /* STORED (for zip only) or DEFLATED */
+    int   last_flush;    /* value of flush param for previous deflate call */
+
+                /* used by deflate.c: */
+
+    uInt  w_size;        /* LZ77 window size (32K by default) */
+    uInt  w_bits;        /* log2(w_size)  (8..16) */
+    uInt  w_mask;        /* w_size - 1 */
+
+    Bytef *window;
+    /* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+    ulg window_size;
+    /* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+    Posf *prev;
+    /* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+    Posf *head; /* Heads of the hash chains or NIL. */
+
+    uInt  ins_h;          /* hash index of string to be inserted */
+    uInt  hash_size;      /* number of elements in hash table */
+    uInt  hash_bits;      /* log2(hash_size) */
+    uInt  hash_mask;      /* hash_size-1 */
+
+    uInt  hash_shift;
+    /* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+    long block_start;
+    /* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+    uInt match_length;           /* length of best match */
+    IPos prev_match;             /* previous match */
+    int match_available;         /* set if previous match exists */
+    uInt strstart;               /* start of string to insert */
+    uInt match_start;            /* start of matching string */
+    uInt lookahead;              /* number of valid bytes ahead in window */
+
+    uInt prev_length;
+    /* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+    uInt max_chain_length;
+    /* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+    uInt max_lazy_match;
+    /* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#   define max_insert_length  max_lazy_match
+    /* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+    int level;    /* compression level (1..9) */
+    int strategy; /* favor or force Huffman coding*/
+
+    uInt good_match;
+    /* Use a faster search when the previous match is longer than this */
+
+    int nice_match; /* Stop searching when current match exceeds this */
+
+                /* used by trees.c: */
+    /* Didn't use ct_data typedef below to supress compiler warning */
+    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+
+    struct tree_desc_s l_desc;               /* desc. for literal tree */
+    struct tree_desc_s d_desc;               /* desc. for distance tree */
+    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
+
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap_len;               /* number of elements in the heap */
+    int heap_max;               /* element of largest frequency */
+    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+    uch depth[2*L_CODES+1];
+    /* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+    uchf *l_buf;          /* buffer for literals or lengths */
+
+    uInt  lit_bufsize;
+    /* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+    uInt last_lit;      /* running index in l_buf */
+
+    ushf *d_buf;
+    /* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+    ulg opt_len;        /* bit length of current block with optimal trees */
+    ulg static_len;     /* bit length of current block with static trees */
+    uInt matches;       /* number of string matches in current block */
+    int last_eob_len;   /* bit length of EOB code for last block */
+
+#ifdef DEBUG
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+    ush bi_buf;
+    /* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+    int bi_valid;
+    /* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+        /* in trees.c */
+void _tr_init         OF((deflate_state *s));
+int  _tr_tally        OF((deflate_state *s, unsigned dist, unsigned lc));
+void _tr_flush_block  OF((deflate_state *s, charf *buf, ulg stored_len,
+                          int eof));
+void _tr_align        OF((deflate_state *s));
+void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
+                          int eof));
+
+#define d_code(dist) \
+   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+  extern uch _length_code[];
+  extern uch _dist_code[];
+#else
+  extern const uch _length_code[];
+  extern const uch _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+  { uch cc = (c); \
+    s->d_buf[s->last_lit] = 0; \
+    s->l_buf[s->last_lit++] = cc; \
+    s->dyn_ltree[cc].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+   }
+# define _tr_tally_dist(s, distance, length, flush) \
+  { uch len = (length); \
+    ush dist = (distance); \
+    s->d_buf[s->last_lit] = dist; \
+    s->l_buf[s->last_lit++] = len; \
+    dist--; \
+    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+    s->dyn_dtree[d_code(dist)].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+  }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+              flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */
diff --git a/src/reader/zlib/gzio.c b/src/reader/zlib/gzio.c
new file mode 100644
index 00000000..6538d6ce
--- /dev/null
+++ b/src/reader/zlib/gzio.c
@@ -0,0 +1,1026 @@
+/* gzio.c -- IO on .gz files
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
+ */
+
+/* @(#) $Id: gzio.c,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#include <stdio.h>
+
+#include "zutil.h"
+
+#ifdef NO_DEFLATE       /* for compatibility with old definition */
+#  define NO_GZCOMPRESS
+#endif
+
+#ifndef NO_DUMMY_DECL
+struct internal_state {int dummy;}; /* for buggy compilers */
+#endif
+
+#ifndef Z_BUFSIZE
+#  ifdef MAXSEG_64K
+#    define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
+#  else
+#    define Z_BUFSIZE 16384
+#  endif
+#endif
+#ifndef Z_PRINTF_BUFSIZE
+#  define Z_PRINTF_BUFSIZE 4096
+#endif
+
+#ifdef __MVS__
+#  pragma map (fdopen , "\174\174FDOPEN")
+   FILE *fdopen(int, const char *);
+#endif
+
+#ifndef STDC
+extern voidp  malloc OF((uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+#define ALLOC(size) malloc(size)
+#define TRYFREE(p) {if (p) free(p);}
+
+static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
+
+/* gzip flag byte */
+#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
+#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
+#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
+#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
+#define COMMENT      0x10 /* bit 4 set: file comment present */
+#define RESERVED     0xE0 /* bits 5..7: reserved */
+
+typedef struct gz_stream {
+    z_stream stream;
+    int      z_err;   /* error code for last stream operation */
+    int      z_eof;   /* set if end of input file */
+    FILE     *file;   /* .gz file */
+    Byte     *inbuf;  /* input buffer */
+    Byte     *outbuf; /* output buffer */
+    uLong    crc;     /* crc32 of uncompressed data */
+    char     *msg;    /* error message */
+    char     *path;   /* path name for debugging only */
+    int      transparent; /* 1 if input file is not a .gz file */
+    char     mode;    /* 'w' or 'r' */
+    z_off_t  start;   /* start of compressed data in file (header skipped) */
+    z_off_t  in;      /* bytes into deflate or inflate */
+    z_off_t  out;     /* bytes out of deflate or inflate */
+    int      back;    /* one character push-back */
+    int      last;    /* true if push-back is last character */
+} gz_stream;
+
+
+local gzFile gz_open      OF((const char *path, const char *mode, int  fd));
+local int do_flush        OF((gzFile file, int flush));
+local int    get_byte     OF((gz_stream *s));
+local void   check_header OF((gz_stream *s));
+local int    destroy      OF((gz_stream *s));
+local void   putLong      OF((FILE *file, uLong x));
+local uLong  getLong      OF((gz_stream *s));
+
+/* ===========================================================================
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb"). The file is given either by file descriptor
+   or path name (if fd == -1).
+     gz_open returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).
+*/
+local gzFile gz_open (path, mode, fd)
+    const char *path;
+    const char *mode;
+    int  fd;
+{
+    int err;
+    int level = Z_DEFAULT_COMPRESSION; /* compression level */
+    int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
+    char *p = (char*)mode;
+    gz_stream *s;
+    char fmode[80]; /* copy of mode, without the compression level */
+    char *m = fmode;
+
+    if (!path || !mode) return Z_NULL;
+
+    s = (gz_stream *)ALLOC(sizeof(gz_stream));
+    if (!s) return Z_NULL;
+
+    s->stream.zalloc = (alloc_func)0;
+    s->stream.zfree = (free_func)0;
+    s->stream.opaque = (voidpf)0;
+    s->stream.next_in = s->inbuf = Z_NULL;
+    s->stream.next_out = s->outbuf = Z_NULL;
+    s->stream.avail_in = s->stream.avail_out = 0;
+    s->file = NULL;
+    s->z_err = Z_OK;
+    s->z_eof = 0;
+    s->in = 0;
+    s->out = 0;
+    s->back = EOF;
+    s->crc = crc32(0L, Z_NULL, 0);
+    s->msg = NULL;
+    s->transparent = 0;
+
+    s->path = (char*)ALLOC(strlen(path)+1);
+    if (s->path == NULL) {
+        return destroy(s), (gzFile)Z_NULL;
+    }
+    strcpy(s->path, path); /* do this early for debugging */
+
+    s->mode = '\0';
+    do {
+        if (*p == 'r') s->mode = 'r';
+        if (*p == 'w' || *p == 'a') s->mode = 'w';
+        if (*p >= '0' && *p <= '9') {
+            level = *p - '0';
+        } else if (*p == 'f') {
+          strategy = Z_FILTERED;
+        } else if (*p == 'h') {
+          strategy = Z_HUFFMAN_ONLY;
+        } else if (*p == 'R') {
+          strategy = Z_RLE;
+        } else {
+            *m++ = *p; /* copy the mode */
+        }
+    } while (*p++ && m != fmode + sizeof(fmode));
+    if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
+
+    if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+        err = Z_STREAM_ERROR;
+#else
+        err = deflateInit2(&(s->stream), level,
+                           Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
+        /* windowBits is passed < 0 to suppress zlib header */
+
+        s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+#endif
+        if (err != Z_OK || s->outbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
+    } else {
+        s->stream.next_in  = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
+
+        err = inflateInit2(&(s->stream), -MAX_WBITS);
+        /* windowBits is passed < 0 to tell that there is no zlib header.
+         * Note that in this case inflate *requires* an extra "dummy" byte
+         * after the compressed stream in order to complete decompression and
+         * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
+         * present after the compressed stream.
+         */
+        if (err != Z_OK || s->inbuf == Z_NULL) {
+            return destroy(s), (gzFile)Z_NULL;
+        }
+    }
+    s->stream.avail_out = Z_BUFSIZE;
+
+    errno = 0;
+    s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
+
+    if (s->file == NULL) {
+        return destroy(s), (gzFile)Z_NULL;
+    }
+    if (s->mode == 'w') {
+        /* Write a very simple .gz header:
+         */
+        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
+             Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
+        s->start = 10L;
+        /* We use 10L instead of ftell(s->file) to because ftell causes an
+         * fflush on some systems. This version of the library doesn't use
+         * start anyway in write mode, so this initialization is not
+         * necessary.
+         */
+    } else {
+        check_header(s); /* skip the .gz header */
+        s->start = ftell(s->file) - s->stream.avail_in;
+    }
+
+    return (gzFile)s;
+}
+
+/* ===========================================================================
+     Opens a gzip (.gz) file for reading or writing.
+*/
+gzFile ZEXPORT gzopen (path, mode)
+    const char *path;
+    const char *mode;
+{
+    return gz_open (path, mode, -1);
+}
+
+/* ===========================================================================
+     Associate a gzFile with the file descriptor fd. fd is not dup'ed here
+   to mimic the behavio(u)r of fdopen.
+*/
+gzFile ZEXPORT gzdopen (fd, mode)
+    int fd;
+    const char *mode;
+{
+    char name[46];      /* allow for up to 128-bit integers */
+
+    if (fd < 0) return (gzFile)Z_NULL;
+    sprintf(name, "<fd:%d>", fd); /* for debugging */
+
+    return gz_open (name, mode, fd);
+}
+
+/* ===========================================================================
+ * Update the compression level and strategy
+ */
+int ZEXPORT gzsetparams (file, level, strategy)
+    gzFile file;
+    int level;
+    int strategy;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+    /* Make room to allow flushing */
+    if (s->stream.avail_out == 0) {
+
+        s->stream.next_out = s->outbuf;
+        if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+            s->z_err = Z_ERRNO;
+        }
+        s->stream.avail_out = Z_BUFSIZE;
+    }
+
+    return deflateParams (&(s->stream), level, strategy);
+}
+
+/* ===========================================================================
+     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+   for end of file.
+   IN assertion: the stream s has been sucessfully opened for reading.
+*/
+local int get_byte(s)
+    gz_stream *s;
+{
+    if (s->z_eof) return EOF;
+    if (s->stream.avail_in == 0) {
+        errno = 0;
+        s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+        if (s->stream.avail_in == 0) {
+            s->z_eof = 1;
+            if (ferror(s->file)) s->z_err = Z_ERRNO;
+            return EOF;
+        }
+        s->stream.next_in = s->inbuf;
+    }
+    s->stream.avail_in--;
+    return *(s->stream.next_in)++;
+}
+
+/* ===========================================================================
+      Check the gzip header of a gz_stream opened for reading. Set the stream
+    mode to transparent if the gzip magic header is not present; set s->err
+    to Z_DATA_ERROR if the magic header is present but the rest of the header
+    is incorrect.
+    IN assertion: the stream s has already been created sucessfully;
+       s->stream.avail_in is zero for the first time, but may be non-zero
+       for concatenated .gz files.
+*/
+local void check_header(s)
+    gz_stream *s;
+{
+    int method; /* method byte */
+    int flags;  /* flags byte */
+    uInt len;
+    int c;
+
+    /* Assure two bytes in the buffer so we can peek ahead -- handle case
+       where first byte of header is at the end of the buffer after the last
+       gzip segment */
+    len = s->stream.avail_in;
+    if (len < 2) {
+        if (len) s->inbuf[0] = s->stream.next_in[0];
+        errno = 0;
+        len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
+        if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
+        s->stream.avail_in += len;
+        s->stream.next_in = s->inbuf;
+        if (s->stream.avail_in < 2) {
+            s->transparent = s->stream.avail_in;
+            return;
+        }
+    }
+
+    /* Peek ahead to check the gzip magic header */
+    if (s->stream.next_in[0] != gz_magic[0] ||
+        s->stream.next_in[1] != gz_magic[1]) {
+        s->transparent = 1;
+        return;
+    }
+    s->stream.avail_in -= 2;
+    s->stream.next_in += 2;
+
+    /* Check the rest of the gzip header */
+    method = get_byte(s);
+    flags = get_byte(s);
+    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
+        s->z_err = Z_DATA_ERROR;
+        return;
+    }
+
+    /* Discard time, xflags and OS code: */
+    for (len = 0; len < 6; len++) (void)get_byte(s);
+
+    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+        len  =  (uInt)get_byte(s);
+        len += ((uInt)get_byte(s))<<8;
+        /* len is garbage if EOF but the loop below will quit anyway */
+        while (len-- != 0 && get_byte(s) != EOF) ;
+    }
+    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+        while ((c = get_byte(s)) != 0 && c != EOF) ;
+    }
+    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
+        while ((c = get_byte(s)) != 0 && c != EOF) ;
+    }
+    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
+        for (len = 0; len < 2; len++) (void)get_byte(s);
+    }
+    s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
+}
+
+ /* ===========================================================================
+ * Cleanup then free the given gz_stream. Return a zlib error code.
+   Try freeing in the reverse order of allocations.
+ */
+local int destroy (s)
+    gz_stream *s;
+{
+    int err = Z_OK;
+
+    if (!s) return Z_STREAM_ERROR;
+
+    TRYFREE(s->msg);
+
+    if (s->stream.state != NULL) {
+        if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+            err = Z_STREAM_ERROR;
+#else
+            err = deflateEnd(&(s->stream));
+#endif
+        } else if (s->mode == 'r') {
+            err = inflateEnd(&(s->stream));
+        }
+    }
+    if (s->file != NULL && fclose(s->file)) {
+#ifdef ESPIPE
+        if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
+#endif
+            err = Z_ERRNO;
+    }
+    if (s->z_err < 0) err = s->z_err;
+
+    TRYFREE(s->inbuf);
+    TRYFREE(s->outbuf);
+    TRYFREE(s->path);
+    TRYFREE(s);
+    return err;
+}
+
+/* ===========================================================================
+     Reads the given number of uncompressed bytes from the compressed file.
+   gzread returns the number of bytes actually read (0 for end of file).
+*/
+int ZEXPORT gzread (file, buf, len)
+    gzFile file;
+    voidp buf;
+    unsigned len;
+{
+    gz_stream *s = (gz_stream*)file;
+    Bytef *start = (Bytef*)buf; /* starting point for crc computation */
+    Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
+
+    if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
+
+    if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
+    if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
+
+    next_out = (Byte*)buf;
+    s->stream.next_out = (Bytef*)buf;
+    s->stream.avail_out = len;
+
+    if (s->stream.avail_out && s->back != EOF) {
+        *next_out++ = s->back;
+        s->stream.next_out++;
+        s->stream.avail_out--;
+        s->back = EOF;
+        s->out++;
+        start++;
+        if (s->last) {
+            s->z_err = Z_STREAM_END;
+            return 1;
+        }
+    }
+
+    while (s->stream.avail_out != 0) {
+
+        if (s->transparent) {
+            /* Copy first the lookahead bytes: */
+            uInt n = s->stream.avail_in;
+            if (n > s->stream.avail_out) n = s->stream.avail_out;
+            if (n > 0) {
+                zmemcpy(s->stream.next_out, s->stream.next_in, n);
+                next_out += n;
+                s->stream.next_out = next_out;
+                s->stream.next_in   += n;
+                s->stream.avail_out -= n;
+                s->stream.avail_in  -= n;
+            }
+            if (s->stream.avail_out > 0) {
+                s->stream.avail_out -=
+                    (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
+            }
+            len -= s->stream.avail_out;
+            s->in  += len;
+            s->out += len;
+            if (len == 0) s->z_eof = 1;
+            return (int)len;
+        }
+        if (s->stream.avail_in == 0 && !s->z_eof) {
+
+            errno = 0;
+            s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+            if (s->stream.avail_in == 0) {
+                s->z_eof = 1;
+                if (ferror(s->file)) {
+                    s->z_err = Z_ERRNO;
+                    break;
+                }
+            }
+            s->stream.next_in = s->inbuf;
+        }
+        s->in += s->stream.avail_in;
+        s->out += s->stream.avail_out;
+        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
+        s->in -= s->stream.avail_in;
+        s->out -= s->stream.avail_out;
+
+        if (s->z_err == Z_STREAM_END) {
+            /* Check CRC and original size */
+            s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+            start = s->stream.next_out;
+
+            if (getLong(s) != s->crc) {
+                s->z_err = Z_DATA_ERROR;
+            } else {
+                (void)getLong(s);
+                /* The uncompressed length returned by above getlong() may be
+                 * different from s->out in case of concatenated .gz files.
+                 * Check for such files:
+                 */
+                check_header(s);
+                if (s->z_err == Z_OK) {
+                    inflateReset(&(s->stream));
+                    s->crc = crc32(0L, Z_NULL, 0);
+                }
+            }
+        }
+        if (s->z_err != Z_OK || s->z_eof) break;
+    }
+    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+
+    if (len == s->stream.avail_out &&
+        (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
+        return -1;
+    return (int)(len - s->stream.avail_out);
+}
+
+
+/* ===========================================================================
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+int ZEXPORT gzgetc(file)
+    gzFile file;
+{
+    unsigned char c;
+
+    return gzread(file, &c, 1) == 1 ? c : -1;
+}
+
+
+/* ===========================================================================
+      Push one byte back onto the stream.
+*/
+int ZEXPORT gzungetc(c, file)
+    int c;
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
+    s->back = c;
+    s->out--;
+    s->last = (s->z_err == Z_STREAM_END);
+    if (s->last) s->z_err = Z_OK;
+    s->z_eof = 0;
+    return c;
+}
+
+
+/* ===========================================================================
+      Reads bytes from the compressed file until len-1 characters are
+   read, or a newline character is read and transferred to buf, or an
+   end-of-file condition is encountered.  The string is then terminated
+   with a null character.
+      gzgets returns buf, or Z_NULL in case of error.
+
+      The current implementation is not optimized at all.
+*/
+char * ZEXPORT gzgets(file, buf, len)
+    gzFile file;
+    char *buf;
+    int len;
+{
+    char *b = buf;
+    if (buf == Z_NULL || len <= 0) return Z_NULL;
+
+    while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
+    *buf = '\0';
+    return b == buf && len > 0 ? Z_NULL : b;
+}
+
+
+#ifndef NO_GZCOMPRESS
+/* ===========================================================================
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of bytes actually written (0 in case of error).
+*/
+int ZEXPORT gzwrite (file, buf, len)
+    gzFile file;
+    voidpc buf;
+    unsigned len;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+    s->stream.next_in = (Bytef*)buf;
+    s->stream.avail_in = len;
+
+    while (s->stream.avail_in != 0) {
+
+        if (s->stream.avail_out == 0) {
+
+            s->stream.next_out = s->outbuf;
+            if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+                s->z_err = Z_ERRNO;
+                break;
+            }
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        s->in += s->stream.avail_in;
+        s->out += s->stream.avail_out;
+        s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
+        s->in -= s->stream.avail_in;
+        s->out -= s->stream.avail_out;
+        if (s->z_err != Z_OK) break;
+    }
+    s->crc = crc32(s->crc, (const Bytef *)buf, len);
+
+    return (int)(len - s->stream.avail_in);
+}
+
+
+/* ===========================================================================
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+#ifdef STDC
+#include <stdarg.h>
+
+int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
+{
+    char buf[Z_PRINTF_BUFSIZE];
+    va_list va;
+    int len;
+
+    buf[sizeof(buf) - 1] = 0;
+    va_start(va, format);
+#ifdef NO_vsnprintf
+#  ifdef HAS_vsprintf_void
+    (void)vsprintf(buf, format, va);
+    va_end(va);
+    for (len = 0; len < sizeof(buf); len++)
+        if (buf[len] == 0) break;
+#  else
+    len = vsprintf(buf, format, va);
+    va_end(va);
+#  endif
+#else
+#  ifdef HAS_vsnprintf_void
+    (void)vsnprintf(buf, sizeof(buf), format, va);
+    va_end(va);
+    len = strlen(buf);
+#  else
+    len = vsnprintf(buf, sizeof(buf), format, va);
+    va_end(va);
+#  endif
+#endif
+    if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+        return 0;
+    return gzwrite(file, buf, (unsigned)len);
+}
+#else /* not ANSI C */
+
+int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+                       a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
+    gzFile file;
+    const char *format;
+    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
+{
+    char buf[Z_PRINTF_BUFSIZE];
+    int len;
+
+    buf[sizeof(buf) - 1] = 0;
+#ifdef NO_snprintf
+#  ifdef HAS_sprintf_void
+    sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+            a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+    for (len = 0; len < sizeof(buf); len++)
+        if (buf[len] == 0) break;
+#  else
+    len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+                a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#  endif
+#else
+#  ifdef HAS_snprintf_void
+    snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+    len = strlen(buf);
+#  else
+    len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+                 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+#  endif
+#endif
+    if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+        return 0;
+    return gzwrite(file, buf, len);
+}
+#endif
+
+/* ===========================================================================
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+int ZEXPORT gzputc(file, c)
+    gzFile file;
+    int c;
+{
+    unsigned char cc = (unsigned char) c; /* required for big endian systems */
+
+    return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
+}
+
+
+/* ===========================================================================
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+int ZEXPORT gzputs(file, s)
+    gzFile file;
+    const char *s;
+{
+    return gzwrite(file, (char*)s, (unsigned)strlen(s));
+}
+
+
+/* ===========================================================================
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function.
+*/
+local int do_flush (file, flush)
+    gzFile file;
+    int flush;
+{
+    uInt len;
+    int done = 0;
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+    s->stream.avail_in = 0; /* should be zero already anyway */
+
+    for (;;) {
+        len = Z_BUFSIZE - s->stream.avail_out;
+
+        if (len != 0) {
+            if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
+                s->z_err = Z_ERRNO;
+                return Z_ERRNO;
+            }
+            s->stream.next_out = s->outbuf;
+            s->stream.avail_out = Z_BUFSIZE;
+        }
+        if (done) break;
+        s->out += s->stream.avail_out;
+        s->z_err = deflate(&(s->stream), flush);
+        s->out -= s->stream.avail_out;
+
+        /* Ignore the second of two consecutive flushes: */
+        if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
+
+        /* deflate has finished flushing only when it hasn't used up
+         * all the available space in the output buffer:
+         */
+        done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
+
+        if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
+    }
+    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+
+int ZEXPORT gzflush (file, flush)
+     gzFile file;
+     int flush;
+{
+    gz_stream *s = (gz_stream*)file;
+    int err = do_flush (file, flush);
+
+    if (err) return err;
+    fflush(s->file);
+    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+#endif /* NO_GZCOMPRESS */
+
+/* ===========================================================================
+      Sets the starting position for the next gzread or gzwrite on the given
+   compressed file. The offset represents a number of bytes in the
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error.
+      SEEK_END is not implemented, returns error.
+      In this version of the library, gzseek can be extremely slow.
+*/
+z_off_t ZEXPORT gzseek (file, offset, whence)
+    gzFile file;
+    z_off_t offset;
+    int whence;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || whence == SEEK_END ||
+        s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
+        return -1L;
+    }
+
+    if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+        return -1L;
+#else
+        if (whence == SEEK_SET) {
+            offset -= s->in;
+        }
+        if (offset < 0) return -1L;
+
+        /* At this point, offset is the number of zero bytes to write. */
+        if (s->inbuf == Z_NULL) {
+            s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
+            if (s->inbuf == Z_NULL) return -1L;
+            zmemzero(s->inbuf, Z_BUFSIZE);
+        }
+        while (offset > 0)  {
+            uInt size = Z_BUFSIZE;
+            if (offset < Z_BUFSIZE) size = (uInt)offset;
+
+            size = gzwrite(file, s->inbuf, size);
+            if (size == 0) return -1L;
+
+            offset -= size;
+        }
+        return s->in;
+#endif
+    }
+    /* Rest of function is for reading only */
+
+    /* compute absolute position */
+    if (whence == SEEK_CUR) {
+        offset += s->out;
+    }
+    if (offset < 0) return -1L;
+
+    if (s->transparent) {
+        /* map to fseek */
+        s->back = EOF;
+        s->stream.avail_in = 0;
+        s->stream.next_in = s->inbuf;
+        if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
+
+        s->in = s->out = offset;
+        return offset;
+    }
+
+    /* For a negative seek, rewind and use positive seek */
+    if (offset >= s->out) {
+        offset -= s->out;
+    } else if (gzrewind(file) < 0) {
+        return -1L;
+    }
+    /* offset is now the number of bytes to skip. */
+
+    if (offset != 0 && s->outbuf == Z_NULL) {
+        s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+        if (s->outbuf == Z_NULL) return -1L;
+    }
+    if (offset && s->back != EOF) {
+        s->back = EOF;
+        s->out++;
+        offset--;
+        if (s->last) s->z_err = Z_STREAM_END;
+    }
+    while (offset > 0)  {
+        int size = Z_BUFSIZE;
+        if (offset < Z_BUFSIZE) size = (int)offset;
+
+        size = gzread(file, s->outbuf, (uInt)size);
+        if (size <= 0) return -1L;
+        offset -= size;
+    }
+    return s->out;
+}
+
+/* ===========================================================================
+     Rewinds input file.
+*/
+int ZEXPORT gzrewind (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'r') return -1;
+
+    s->z_err = Z_OK;
+    s->z_eof = 0;
+    s->back = EOF;
+    s->stream.avail_in = 0;
+    s->stream.next_in = s->inbuf;
+    s->crc = crc32(0L, Z_NULL, 0);
+    if (!s->transparent) (void)inflateReset(&s->stream);
+    s->in = 0;
+    s->out = 0;
+    return fseek(s->file, s->start, SEEK_SET);
+}
+
+/* ===========================================================================
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+*/
+z_off_t ZEXPORT gztell (file)
+    gzFile file;
+{
+    return gzseek(file, 0L, SEEK_CUR);
+}
+
+/* ===========================================================================
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+int ZEXPORT gzeof (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    /* With concatenated compressed files that can have embedded
+     * crc trailers, z_eof is no longer the only/best indicator of EOF
+     * on a gz_stream. Handle end-of-stream error explicitly here.
+     */
+    if (s == NULL || s->mode != 'r') return 0;
+    if (s->z_eof) return 1;
+    return s->z_err == Z_STREAM_END;
+}
+
+/* ===========================================================================
+     Returns 1 if reading and doing so transparently, otherwise zero.
+*/
+int ZEXPORT gzdirect (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL || s->mode != 'r') return 0;
+    return s->transparent;
+}
+
+/* ===========================================================================
+   Outputs a long in LSB order to the given file
+*/
+local void putLong (file, x)
+    FILE *file;
+    uLong x;
+{
+    int n;
+    for (n = 0; n < 4; n++) {
+        fputc((int)(x & 0xff), file);
+        x >>= 8;
+    }
+}
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets z_err in case
+   of error.
+*/
+local uLong getLong (s)
+    gz_stream *s;
+{
+    uLong x = (uLong)get_byte(s);
+    int c;
+
+    x += ((uLong)get_byte(s))<<8;
+    x += ((uLong)get_byte(s))<<16;
+    c = get_byte(s);
+    if (c == EOF) s->z_err = Z_DATA_ERROR;
+    x += ((uLong)c)<<24;
+    return x;
+}
+
+/* ===========================================================================
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state.
+*/
+int ZEXPORT gzclose (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL) return Z_STREAM_ERROR;
+
+    if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+        return Z_STREAM_ERROR;
+#else
+        if (do_flush (file, Z_FINISH) != Z_OK)
+            return destroy((gz_stream*)file);
+
+        putLong (s->file, s->crc);
+        putLong (s->file, (uLong)(s->in & 0xffffffff));
+#endif
+    }
+    return destroy((gz_stream*)file);
+}
+
+#ifdef STDC
+#  define zstrerror(errnum) strerror(errnum)
+#else
+#  define zstrerror(errnum) ""
+#endif
+
+/* ===========================================================================
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+const char * ZEXPORT gzerror (file, errnum)
+    gzFile file;
+    int *errnum;
+{
+    char *m;
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL) {
+        *errnum = Z_STREAM_ERROR;
+        return (const char*)ERR_MSG(Z_STREAM_ERROR);
+    }
+    *errnum = s->z_err;
+    if (*errnum == Z_OK) return (const char*)"";
+
+    m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
+
+    if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
+
+    TRYFREE(s->msg);
+    s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
+    if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
+    strcpy(s->msg, s->path);
+    strcat(s->msg, ": ");
+    strcat(s->msg, m);
+    return (const char*)s->msg;
+}
+
+/* ===========================================================================
+     Clear the error and end-of-file flags, and do the same for the real file.
+*/
+void ZEXPORT gzclearerr (file)
+    gzFile file;
+{
+    gz_stream *s = (gz_stream*)file;
+
+    if (s == NULL) return;
+    if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
+    s->z_eof = 0;
+    clearerr(s->file);
+}
diff --git a/src/reader/zlib/inffast.c b/src/reader/zlib/inffast.c
new file mode 100644
index 00000000..de927350
--- /dev/null
+++ b/src/reader/zlib/inffast.c
@@ -0,0 +1,724 @@
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef __i386__
+
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    struct inffast_ar {
+      void *esp;                  /* esp save */
+      unsigned char FAR *in;      /* local strm->next_in */
+      unsigned char FAR *last;    /* while in < last, enough input available */
+      unsigned char FAR *out;     /* local strm->next_out */
+      unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
+      unsigned char FAR *end;     /* while out < end, enough space available */
+      unsigned wsize;             /* window size or zero if not using window */
+      unsigned write;             /* window write index */
+      unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
+      unsigned long hold;         /* local strm->hold */
+      unsigned bits;              /* local strm->bits */
+      code const FAR *lcode;      /* local strm->lencode */
+      code const FAR *dcode;      /* local strm->distcode */
+      unsigned lmask;             /* mask for first level of length codes */
+      unsigned dmask;             /* mask for first level of distance codes */
+      unsigned len;               /* match length, unused bytes */
+      unsigned dist;              /* match distance */
+      unsigned status;            /* this is set when state changes */
+    } ar;
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+    ar.in = strm->next_in;
+    ar.last = ar.in + (strm->avail_in - 5);
+    ar.out = strm->next_out;
+    ar.beg = ar.out - (start - strm->avail_out);
+    ar.end = ar.out + (strm->avail_out - 257);
+    ar.wsize = state->wsize;
+    ar.write = state->write;
+    ar.window = state->window;
+    ar.hold = state->hold;
+    ar.bits = state->bits;
+    ar.lcode = state->lencode;
+    ar.dcode = state->distcode;
+    ar.lmask = (1U << state->lenbits) - 1;
+    ar.dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+
+    /* align in on 2 byte boundary */
+    if (((unsigned long)(void *)ar.in & 0x1) != 0) {
+        ar.hold += (unsigned long)*ar.in++ << ar.bits;
+        ar.bits += 8;
+    }
+
+        __asm__ __volatile__ (
+"        leal    %0, %%eax\n"
+"        pushf\n"
+"        pushl   %%ebp\n"
+"        movl    %%esp, (%%eax)\n"
+"        movl    %%eax, %%esp\n"
+"        movl    4(%%esp), %%esi\n"       /* esi = in */
+"        movl    12(%%esp), %%edi\n"      /* edi = out */
+"        movl    36(%%esp), %%edx\n"      /* edx = hold */
+"        movl    40(%%esp), %%ebx\n"      /* ebx = bits */
+"        movl    44(%%esp), %%ebp\n"      /* ebp = lcode */
+
+"        cld\n"
+"        jmp     .L_do_loop\n"
+
+".L_while_test:\n"
+"        cmpl    %%edi, 20(%%esp)\n"
+"        jbe     .L_break_loop\n"
+"        cmpl    %%esi, 8(%%esp)\n"
+"        jbe     .L_break_loop\n"
+
+".L_do_loop:\n"
+"        cmpb    $15, %%bl\n"
+"        ja      .L_get_length_code\n"    /* if (15 < bits) */
+
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"        /* hold |= *((ushort *)in)++ << bits */
+
+".L_get_length_code:\n"
+"        movl    52(%%esp), %%eax\n"      /* eax = lmask */
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        movl    (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[hold & lmask] */
+
+".L_dolen:\n"
+"        movb    %%ah, %%cl\n"            /* cl = this.bits */
+"        subb    %%ah, %%bl\n"            /* bits -= this.bits */
+"        shrl    %%cl, %%edx\n"           /* hold >>= this.bits */
+
+"        testb   %%al, %%al\n"
+"        jnz     .L_test_for_length_base\n" /* if (op != 0) 45.7% */
+
+"        shrl    $16, %%eax\n"            /* output this.val char */
+"        stosb\n"
+"        jmp     .L_while_test\n"
+
+".L_test_for_length_base:\n"
+"        movl    %%eax, %%ecx\n"          /* len = this */
+"        shrl    $16, %%ecx\n"            /* len = this.val */
+"        movl    %%ecx, 60(%%esp)\n"      /* len = this */
+"        movb    %%al, %%cl\n"
+
+"        testb   $16, %%al\n"
+"        jz      .L_test_for_second_level_length\n" /* if ((op & 16) == 0) 8% */
+"        andb    $15, %%cl\n"             /* op &= 15 */
+"        jz      .L_decode_distance\n"    /* if (!op) */
+"        cmpb    %%cl, %%bl\n"
+"        jae     .L_add_bits_to_len\n"    /* if (op <= bits) */
+
+"        movb    %%cl, %%ch\n"            /* stash op in ch, freeing cl */
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"         /* hold |= *((ushort *)in)++ << bits */
+"        movb    %%ch, %%cl\n"            /* move op back to ecx */
+
+".L_add_bits_to_len:\n"
+"        movl    $1, %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        subb    %%cl, %%bl\n"
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        shrl    %%cl, %%edx\n"
+"        addl    %%eax, 60(%%esp)\n"      /* len += hold & mask[op] */
+
+".L_decode_distance:\n"
+"        cmpb    $15, %%bl\n"
+"        ja      .L_get_distance_code\n"  /* if (15 < bits) */
+
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"         /* hold |= *((ushort *)in)++ << bits */
+
+".L_get_distance_code:\n"
+"        movl    56(%%esp), %%eax\n"      /* eax = dmask */
+"        movl    48(%%esp), %%ecx\n"      /* ecx = dcode */
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        movl    (%%ecx,%%eax,4), %%eax\n"/* eax = dcode[hold & dmask] */
+
+".L_dodist:\n"
+"        movl    %%eax, %%ebp\n"          /* dist = this */
+"        shrl    $16, %%ebp\n"            /* dist = this.val */
+"        movb    %%ah, %%cl\n"
+"        subb    %%ah, %%bl\n"            /* bits -= this.bits */
+"        shrl    %%cl, %%edx\n"           /* hold >>= this.bits */
+"        movb    %%al, %%cl\n"            /* cl = this.op */
+
+"        testb   $16, %%al\n"             /* if ((op & 16) == 0) */
+"        jz      .L_test_for_second_level_dist\n"
+"        andb    $15, %%cl\n"             /* op &= 15 */
+"        jz      .L_check_dist_one\n"
+"        cmpb    %%cl, %%bl\n"
+"        jae     .L_add_bits_to_dist\n"   /* if (op <= bits) 97.6% */
+
+"        movb    %%cl, %%ch\n"            /* stash op in ch, freeing cl */
+"        xorl    %%eax, %%eax\n"
+"        lodsw\n"                         /* al = *(ushort *)in++ */
+"        movb    %%bl, %%cl\n"            /* cl = bits, needs it for shifting */
+"        addb    $16, %%bl\n"             /* bits += 16 */
+"        shll    %%cl, %%eax\n"
+"        orl     %%eax, %%edx\n"        /* hold |= *((ushort *)in)++ << bits */
+"        movb    %%ch, %%cl\n"            /* move op back to ecx */
+
+".L_add_bits_to_dist:\n"
+"        movl    $1, %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"                 /* (1 << op) - 1 */
+"        subb    %%cl, %%bl\n"
+"        andl    %%edx, %%eax\n"          /* eax &= hold */
+"        shrl    %%cl, %%edx\n"
+"        addl    %%eax, %%ebp\n"          /* dist += hold & ((1 << op) - 1) */
+
+".L_check_window:\n"
+"        movl    %%esi, 4(%%esp)\n"       /* save in so from can use it's reg */
+"        movl    %%edi, %%eax\n"
+"        subl    16(%%esp), %%eax\n"      /* nbytes = out - beg */
+
+"        cmpl    %%ebp, %%eax\n"
+"        jb      .L_clip_window\n"        /* if (dist > nbytes) 4.2% */
+
+"        movl    60(%%esp), %%ecx\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"          /* from = out - dist */
+
+"        subl    $3, %%ecx\n"             /* copy from to out */
+"        movb    (%%esi), %%al\n"
+"        movb    %%al, (%%edi)\n"
+"        movb    1(%%esi), %%al\n"
+"        movb    2(%%esi), %%ah\n"
+"        addl    $3, %%esi\n"
+"        movb    %%al, 1(%%edi)\n"
+"        movb    %%ah, 2(%%edi)\n"
+"        addl    $3, %%edi\n"
+"        rep     movsb\n"
+
+"        movl    4(%%esp), %%esi\n"      /* move in back to %esi, toss from */
+"        movl    44(%%esp), %%ebp\n"     /* ebp = lcode */
+"        jmp     .L_while_test\n"
+
+".L_check_dist_one:\n"
+"        cmpl    $1, %%ebp\n"            /* if dist 1, is a memset */
+"        jne     .L_check_window\n"
+"        cmpl    %%edi, 16(%%esp)\n"
+"        je      .L_check_window\n"
+
+"        decl    %%edi\n"
+"        movl    60(%%esp), %%ecx\n"
+"        movb    (%%edi), %%al\n"
+"        subl    $3, %%ecx\n"
+
+"        movb    %%al, 1(%%edi)\n"       /* memset out with from[-1] */
+"        movb    %%al, 2(%%edi)\n"
+"        movb    %%al, 3(%%edi)\n"
+"        addl    $4, %%edi\n"
+"        rep     stosb\n"
+"        movl    44(%%esp), %%ebp\n"      /* ebp = lcode */
+"        jmp     .L_while_test\n"
+
+".L_test_for_second_level_length:\n"
+"        testb   $64, %%al\n"
+"        jnz     .L_test_for_end_of_block\n" /* if ((op & 64) != 0) */
+
+"        movl    $1, %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"         /* eax &= hold */
+"        addl    60(%%esp), %%eax\n"     /* eax += this.val */
+"        movl    (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[val+(hold&mask[op])]*/
+"        jmp     .L_dolen\n"
+
+".L_test_for_second_level_dist:\n"
+"        testb   $64, %%al\n"
+"        jnz     .L_invalid_distance_code\n" /* if ((op & 64) != 0) */
+
+"        movl    $1, %%eax\n"
+"        shll    %%cl, %%eax\n"
+"        decl    %%eax\n"
+"        andl    %%edx, %%eax\n"         /* eax &= hold */
+"        addl    %%ebp, %%eax\n"         /* eax += this.val */
+"        movl    48(%%esp), %%ecx\n"     /* ecx = dcode */
+"        movl    (%%ecx,%%eax,4), %%eax\n" /* eax = dcode[val+(hold&mask[op])]*/
+"        jmp     .L_dodist\n"
+
+".L_clip_window:\n"
+"        movl    %%eax, %%ecx\n"
+"        movl    24(%%esp), %%eax\n"     /* prepare for dist compare */
+"        negl    %%ecx\n"                /* nbytes = -nbytes */
+"        movl    32(%%esp), %%esi\n"     /* from = window */
+
+"        cmpl    %%ebp, %%eax\n"
+"        jb      .L_invalid_distance_too_far\n" /* if (dist > wsize) */
+
+"        addl    %%ebp, %%ecx\n"         /* nbytes = dist - nbytes */
+"        cmpl    $0, 28(%%esp)\n"
+"        jne     .L_wrap_around_window\n" /* if (write != 0) */
+
+"        subl    %%ecx, %%eax\n"
+"        addl    %%eax, %%esi\n"         /* from += wsize - nbytes */
+
+"        movl    60(%%esp), %%eax\n"
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy1\n"          /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"         /* from = out - dist */
+"        jmp     .L_do_copy1\n"
+
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy1\n"          /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"         /* from = out - dist */
+"        jmp     .L_do_copy1\n"
+
+".L_wrap_around_window:\n"
+"        movl    28(%%esp), %%eax\n"
+"        cmpl    %%eax, %%ecx\n"
+"        jbe     .L_contiguous_in_window\n" /* if (write >= nbytes) */
+
+"        addl    24(%%esp), %%esi\n"
+"        addl    %%eax, %%esi\n"
+"        subl    %%ecx, %%esi\n"         /* from += wsize + write - nbytes */
+"        subl    %%eax, %%ecx\n"         /* nbytes -= write */
+
+"        movl    60(%%esp), %%eax\n"
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy1\n"          /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    32(%%esp), %%esi\n"     /* from = window */
+"        movl    28(%%esp), %%ecx\n"     /* nbytes = write */
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy1\n"          /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"         /* from = out - dist */
+"        jmp     .L_do_copy1\n"
+
+".L_contiguous_in_window:\n"
+"        addl    %%eax, %%esi\n"
+"        subl    %%ecx, %%esi\n"         /* from += write - nbytes */
+
+"        movl    60(%%esp), %%eax\n"
+"        cmpl    %%ecx, %%eax\n"
+"        jbe     .L_do_copy1\n"          /* if (nbytes >= len) */
+
+"        subl    %%ecx, %%eax\n"         /* len -= nbytes */
+"        rep     movsb\n"
+"        movl    %%edi, %%esi\n"
+"        subl    %%ebp, %%esi\n"         /* from = out - dist */
+
+".L_do_copy1:\n"
+"        movl    %%eax, %%ecx\n"
+"        rep     movsb\n"
+
+"        movl    4(%%esp), %%esi\n"      /* move in back to %esi, toss from */
+"        movl    44(%%esp), %%ebp\n"     /* ebp = lcode */
+"        jmp     .L_while_test\n"
+
+".L_test_for_end_of_block:\n"
+"        testb   $32, %%al\n"
+"        jz      .L_invalid_literal_length_code\n"
+"        movl    $1, 68(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_literal_length_code:\n"
+"        movl    $2, 68(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_distance_code:\n"
+"        movl    $3, 68(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_invalid_distance_too_far:\n"
+"        movl    4(%%esp), %%esi\n"
+"        movl    $4, 68(%%esp)\n"
+"        jmp     .L_break_loop_with_status\n"
+
+".L_break_loop:\n"
+"        movl    $0, 68(%%esp)\n"
+
+".L_break_loop_with_status:\n"
+/* put in, out, bits, and hold back into ar and pop esp */
+"        movl    %%esi, 4(%%esp)\n"
+"        movl    %%edi, 12(%%esp)\n"
+"        movl    %%ebx, 40(%%esp)\n"
+"        movl    %%edx, 36(%%esp)\n"
+"        movl    (%%esp), %%esp\n"
+"        popl    %%ebp\n"
+"        popf\n"
+          :
+          : "m" (ar)
+          : "memory", "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"
+    );
+
+
+    if (ar.status > 1) {
+        if (ar.status == 2)
+            strm->msg = "invalid literal/length code";
+        else if (ar.status == 3)
+            strm->msg = "invalid distance code";
+        else
+            strm->msg = "invalid distance too far back";
+        state->mode = BAD;
+    }
+    else if ( ar.status == 1 ) {
+        state->mode = TYPE;
+    }
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    ar.len = ar.bits >> 3;
+    ar.in -= ar.len;
+    ar.bits -= ar.len << 3;
+    ar.hold &= (1U << ar.bits) - 1;
+
+    /* update state and return */
+    strm->next_in = ar.in;
+    strm->next_out = ar.out;
+    strm->avail_in = (unsigned)(ar.in < ar.last ? 5 + (ar.last - ar.in) :
+                                                  5 - (ar.in - ar.last));
+    strm->avail_out = (unsigned)(ar.out < ar.end ? 257 + (ar.end - ar.out) :
+                                                   257 - (ar.out - ar.end));
+    state->hold = ar.hold;
+    state->bits = ar.bits;
+    return;
+}
+
+#else
+
+/* Allow machine dependent optimization for post-increment or pre-increment.
+   Based on testing to date,
+   Pre-increment preferred for:
+   - PowerPC G3 (Adler)
+   - MIPS R5000 (Randers-Pehrson)
+   Post-increment preferred for:
+   - none
+   No measurable difference:
+   - Pentium III (Anderson)
+   - M68060 (Nikl)
+ */
+#ifdef POSTINC
+#  define OFF 0
+#  define PUP(a) *(a)++
+#else
+#  define OFF 1
+#  define PUP(a) *++(a)
+#endif
+
+/*
+   Decode literal, length, and distance codes and write out the resulting
+   literal and match bytes until either not enough input or output is
+   available, an end-of-block is encountered, or a data error is encountered.
+   When large enough input and output buffers are supplied to inflate(), for
+   example, a 16K input buffer and a 64K output buffer, more than 95% of the
+   inflate execution time is spent in this routine.
+
+   Entry assumptions:
+
+        state->mode == LEN
+        strm->avail_in >= 6
+        strm->avail_out >= 258
+        start >= strm->avail_out
+        state->bits < 8
+
+   On return, state->mode is one of:
+
+        LEN -- ran out of enough output space or enough available input
+        TYPE -- reached end of block code, inflate() to interpret next block
+        BAD -- error in block data
+
+   Notes:
+
+    - The maximum input bits used by a length/distance pair is 15 bits for the
+      length code, 5 bits for the length extra, 15 bits for the distance code,
+      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
+      Therefore if strm->avail_in >= 6, then there is enough input to avoid
+      checking for available input while decoding.
+
+    - The maximum bytes that a single length/distance pair can output is 258
+      bytes, which is the maximum length that can be coded.  inflate_fast()
+      requires strm->avail_out >= 258 for each loop to avoid checking for
+      output space.
+ */
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    unsigned char FAR *in;      /* local strm->next_in */
+    unsigned char FAR *last;    /* while in < last, enough input available */
+    unsigned char FAR *out;     /* local strm->next_out */
+    unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
+    unsigned char FAR *end;     /* while out < end, enough space available */
+#ifdef INFLATE_STRICT
+    unsigned dmax;              /* maximum distance from zlib header */
+#endif
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned write;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
+    unsigned long hold;         /* local strm->hold */
+    unsigned bits;              /* local strm->bits */
+    code const FAR *lcode;      /* local strm->lencode */
+    code const FAR *dcode;      /* local strm->distcode */
+    unsigned lmask;             /* mask for first level of length codes */
+    unsigned dmask;             /* mask for first level of distance codes */
+    code this;                  /* retrieved table entry */
+    unsigned op;                /* code bits, operation, extra bits, or */
+                                /*  window position, window bytes to copy */
+    unsigned len;               /* match length, unused bytes */
+    unsigned dist;              /* match distance */
+    unsigned char FAR *from;    /* where to copy match from */
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+    in = strm->next_in - OFF;
+    last = in + (strm->avail_in - 5);
+    out = strm->next_out - OFF;
+    beg = out - (start - strm->avail_out);
+    end = out + (strm->avail_out - 257);
+#ifdef INFLATE_STRICT
+    dmax = state->dmax;
+#endif
+    wsize = state->wsize;
+    whave = state->whave;
+    write = state->write;
+    window = state->window;
+    hold = state->hold;
+    bits = state->bits;
+    lcode = state->lencode;
+    dcode = state->distcode;
+    lmask = (1U << state->lenbits) - 1;
+    dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+    do {
+        if (bits < 15) {
+            hold += (unsigned long)(PUP(in)) << bits;
+            bits += 8;
+            hold += (unsigned long)(PUP(in)) << bits;
+            bits += 8;
+        }
+        this = lcode[hold & lmask];
+      dolen:
+        op = (unsigned)(this.bits);
+        hold >>= op;
+        bits -= op;
+        op = (unsigned)(this.op);
+        if (op == 0) {                          /* literal */
+            Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+                    "inflate:         literal '%c'\n" :
+                    "inflate:         literal 0x%02x\n", this.val));
+            PUP(out) = (unsigned char)(this.val);
+        }
+        else if (op & 16) {                     /* length base */
+            len = (unsigned)(this.val);
+            op &= 15;                           /* number of extra bits */
+            if (op) {
+                if (bits < op) {
+                    hold += (unsigned long)(PUP(in)) << bits;
+                    bits += 8;
+                }
+                len += (unsigned)hold & ((1U << op) - 1);
+                hold >>= op;
+                bits -= op;
+            }
+            Tracevv((stderr, "inflate:         length %u\n", len));
+            if (bits < 15) {
+                hold += (unsigned long)(PUP(in)) << bits;
+                bits += 8;
+                hold += (unsigned long)(PUP(in)) << bits;
+                bits += 8;
+            }
+            this = dcode[hold & dmask];
+          dodist:
+            op = (unsigned)(this.bits);
+            hold >>= op;
+            bits -= op;
+            op = (unsigned)(this.op);
+            if (op & 16) {                      /* distance base */
+                dist = (unsigned)(this.val);
+                op &= 15;                       /* number of extra bits */
+                if (bits < op) {
+                    hold += (unsigned long)(PUP(in)) << bits;
+                    bits += 8;
+                    if (bits < op) {
+                        hold += (unsigned long)(PUP(in)) << bits;
+                        bits += 8;
+                    }
+                }
+                dist += (unsigned)hold & ((1U << op) - 1);
+#ifdef INFLATE_STRICT
+                if (dist > dmax) {
+                    strm->msg = (char *)"invalid distance too far back";
+                    state->mode = BAD;
+                    break;
+                }
+#endif
+                hold >>= op;
+                bits -= op;
+                Tracevv((stderr, "inflate:         distance %u\n", dist));
+                op = (unsigned)(out - beg);     /* max distance in output */
+                if (dist > op) {                /* see if copy from window */
+                    op = dist - op;             /* distance back in window */
+                    if (op > whave) {
+                        strm->msg = (char *)"invalid distance too far back";
+                        state->mode = BAD;
+                        break;
+                    }
+                    from = window - OFF;
+                    if (write == 0) {           /* very common case */
+                        from += wsize - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                PUP(out) = PUP(from);
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    else if (write < op) {      /* wrap around window */
+                        from += wsize + write - op;
+                        op -= write;
+                        if (op < len) {         /* some from end of window */
+                            len -= op;
+                            do {
+                                PUP(out) = PUP(from);
+                            } while (--op);
+                            from = window - OFF;
+                            if (write < len) {  /* some from start of window */
+                                op = write;
+                                len -= op;
+                                do {
+                                    PUP(out) = PUP(from);
+                                } while (--op);
+                                from = out - dist;      /* rest from output */
+                            }
+                        }
+                    }
+                    else {                      /* contiguous in window */
+                        from += write - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                PUP(out) = PUP(from);
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    while (len > 2) {
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        len -= 3;
+                    }
+                    if (len) {
+                        PUP(out) = PUP(from);
+                        if (len > 1)
+                            PUP(out) = PUP(from);
+                    }
+                }
+                else {
+                    from = out - dist;          /* copy direct from output */
+                    do {                        /* minimum length is three */
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        len -= 3;
+                    } while (len > 2);
+                    if (len) {
+                        PUP(out) = PUP(from);
+                        if (len > 1)
+                            PUP(out) = PUP(from);
+                    }
+                }
+            }
+            else if ((op & 64) == 0) {          /* 2nd level distance code */
+                this = dcode[this.val + (hold & ((1U << op) - 1))];
+                goto dodist;
+            }
+            else {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+        }
+        else if ((op & 64) == 0) {              /* 2nd level length code */
+            this = lcode[this.val + (hold & ((1U << op) - 1))];
+            goto dolen;
+        }
+        else if (op & 32) {                     /* end-of-block */
+            Tracevv((stderr, "inflate:         end of block\n"));
+            state->mode = TYPE;
+            break;
+        }
+        else {
+            strm->msg = (char *)"invalid literal/length code";
+            state->mode = BAD;
+            break;
+        }
+    } while (in < last && out < end);
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    len = bits >> 3;
+    in -= len;
+    bits -= len << 3;
+    hold &= (1U << bits) - 1;
+
+    /* update state and return */
+    strm->next_in = in + OFF;
+    strm->next_out = out + OFF;
+    strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
+    strm->avail_out = (unsigned)(out < end ?
+                                 257 + (end - out) : 257 - (out - end));
+    state->hold = hold;
+    state->bits = bits;
+    return;
+}
+
+/*
+   inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
+   - Using bit fields for code structure
+   - Different op definition to avoid & for extra bits (do & for table bits)
+   - Three separate decoding do-loops for direct, window, and write == 0
+   - Special case for distance > 1 copies to do overlapped load and store copy
+   - Explicit branch predictions (based on measured branch probabilities)
+   - Deferring match copy and interspersed it with decoding subsequent codes
+   - Swapping literal/length else
+   - Swapping window/direct else
+   - Larger unrolled copy loops (three is about right)
+   - Moving len -= 3 statement into middle of loop
+ */
+
+#endif /* !i386 */
diff --git a/src/reader/zlib/inffast.h b/src/reader/zlib/inffast.h
new file mode 100644
index 00000000..1e88d2d9
--- /dev/null
+++ b/src/reader/zlib/inffast.h
@@ -0,0 +1,11 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+void inflate_fast OF((z_streamp strm, unsigned start));
diff --git a/src/reader/zlib/inffixed.h b/src/reader/zlib/inffixed.h
new file mode 100644
index 00000000..75ed4b59
--- /dev/null
+++ b/src/reader/zlib/inffixed.h
@@ -0,0 +1,94 @@
+    /* inffixed.h -- table for decoding fixed codes
+     * Generated automatically by makefixed().
+     */
+
+    /* WARNING: this file should *not* be used by applications. It
+       is part of the implementation of the compression library and
+       is subject to change. Applications should only use zlib.h.
+     */
+
+    static const code lenfix[512] = {
+        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+        {0,9,255}
+    };
+
+    static const code distfix[32] = {
+        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+        {22,5,193},{64,5,0}
+    };
diff --git a/src/reader/zlib/inflate.c b/src/reader/zlib/inflate.c
new file mode 100644
index 00000000..792fdee8
--- /dev/null
+++ b/src/reader/zlib/inflate.c
@@ -0,0 +1,1368 @@
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * Change history:
+ *
+ * 1.2.beta0    24 Nov 2002
+ * - First version -- complete rewrite of inflate to simplify code, avoid
+ *   creation of window when not needed, minimize use of window when it is
+ *   needed, make inffast.c even faster, implement gzip decoding, and to
+ *   improve code readability and style over the previous zlib inflate code
+ *
+ * 1.2.beta1    25 Nov 2002
+ * - Use pointers for available input and output checking in inffast.c
+ * - Remove input and output counters in inffast.c
+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
+ * - Remove unnecessary second byte pull from length extra in inffast.c
+ * - Unroll direct copy to three copies per loop in inffast.c
+ *
+ * 1.2.beta2    4 Dec 2002
+ * - Change external routine names to reduce potential conflicts
+ * - Correct filename to inffixed.h for fixed tables in inflate.c
+ * - Make hbuf[] unsigned char to match parameter type in inflate.c
+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
+ *   to avoid negation problem on Alphas (64 bit) in inflate.c
+ *
+ * 1.2.beta3    22 Dec 2002
+ * - Add comments on state->bits assertion in inffast.c
+ * - Add comments on op field in inftrees.h
+ * - Fix bug in reuse of allocated window after inflateReset()
+ * - Remove bit fields--back to byte structure for speed
+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
+ * - Use local copies of stream next and avail values, as well as local bit
+ *   buffer and bit count in inflate()--for speed when inflate_fast() not used
+ *
+ * 1.2.beta4    1 Jan 2003
+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
+ * - Move a comment on output buffer sizes from inffast.c to inflate.c
+ * - Add comments in inffast.c to introduce the inflate_fast() routine
+ * - Rearrange window copies in inflate_fast() for speed and simplification
+ * - Unroll last copy for window match in inflate_fast()
+ * - Use local copies of window variables in inflate_fast() for speed
+ * - Pull out common write == 0 case for speed in inflate_fast()
+ * - Make op and len in inflate_fast() unsigned for consistency
+ * - Add FAR to lcode and dcode declarations in inflate_fast()
+ * - Simplified bad distance check in inflate_fast()
+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
+ *   source file infback.c to provide a call-back interface to inflate for
+ *   programs like gzip and unzip -- uses window as output buffer to avoid
+ *   window copying
+ *
+ * 1.2.beta5    1 Jan 2003
+ * - Improved inflateBack() interface to allow the caller to provide initial
+ *   input in strm.
+ * - Fixed stored blocks bug in inflateBack()
+ *
+ * 1.2.beta6    4 Jan 2003
+ * - Added comments in inffast.c on effectiveness of POSTINC
+ * - Typecasting all around to reduce compiler warnings
+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to
+ *   make compilers happy
+ * - Changed type of window in inflateBackInit() to unsigned char *
+ *
+ * 1.2.beta7    27 Jan 2003
+ * - Changed many types to unsigned or unsigned short to avoid warnings
+ * - Added inflateCopy() function
+ *
+ * 1.2.0        9 Mar 2003
+ * - Changed inflateBack() interface to provide separate opaque descriptors
+ *   for the in() and out() functions
+ * - Changed inflateBack() argument and in_func typedef to swap the length
+ *   and buffer address return values for the input function
+ * - Check next_in and next_out for Z_NULL on entry to inflate()
+ *
+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef MAKEFIXED
+#  ifndef BUILDFIXED
+#    define BUILDFIXED
+#  endif
+#endif
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+local int updatewindow OF((z_streamp strm, unsigned out));
+#ifdef BUILDFIXED
+   void makefixed OF((void));
+#endif
+local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
+                              unsigned len));
+
+int ZEXPORT inflateReset(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    strm->total_in = strm->total_out = state->total = 0;
+    strm->msg = Z_NULL;
+    strm->adler = 1;        /* to support ill-conceived Java test suite */
+    state->mode = HEAD;
+    state->last = 0;
+    state->havedict = 0;
+    state->dmax = 32768U;
+    state->head = Z_NULL;
+    state->wsize = 0;
+    state->whave = 0;
+    state->write = 0;
+    state->hold = 0;
+    state->bits = 0;
+    state->lencode = state->distcode = state->next = state->codes;
+    Tracev((stderr, "inflate: reset\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflatePrime(strm, bits, value)
+z_streamp strm;
+int bits;
+int value;
+{
+    struct inflate_state FAR *state;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
+    value &= (1L << bits) - 1;
+    state->hold += value << state->bits;
+    state->bits += bits;
+    return Z_OK;
+}
+
+int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+z_streamp strm;
+int windowBits;
+const char *version;
+int stream_size;
+{
+    struct inflate_state FAR *state;
+
+    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+        stream_size != (int)(sizeof(z_stream)))
+        return Z_VERSION_ERROR;
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+    strm->msg = Z_NULL;                 /* in case we return an error */
+    if (strm->zalloc == (alloc_func)0) {
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+    }
+    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+    state = (struct inflate_state FAR *)
+            ZALLOC(strm, 1, sizeof(struct inflate_state));
+    if (state == Z_NULL) return Z_MEM_ERROR;
+    Tracev((stderr, "inflate: allocated\n"));
+    strm->state = (struct internal_state FAR *)state;
+    if (windowBits < 0) {
+        state->wrap = 0;
+        windowBits = -windowBits;
+    }
+    else {
+        state->wrap = (windowBits >> 4) + 1;
+#ifdef GUNZIP
+        if (windowBits < 48) windowBits &= 15;
+#endif
+    }
+    if (windowBits < 8 || windowBits > 15) {
+        ZFREE(strm, state);
+        strm->state = Z_NULL;
+        return Z_STREAM_ERROR;
+    }
+    state->wbits = (unsigned)windowBits;
+    state->window = Z_NULL;
+    return inflateReset(strm);
+}
+
+int ZEXPORT inflateInit_(strm, version, stream_size)
+z_streamp strm;
+const char *version;
+int stream_size;
+{
+    return inflateInit2_(strm, DEF_WBITS, version, stream_size);
+}
+
+/*
+   Return state with length and distance decoding tables and index sizes set to
+   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
+   If BUILDFIXED is defined, then instead this routine builds the tables the
+   first time it's called, and returns those tables the first time and
+   thereafter.  This reduces the size of the code by about 2K bytes, in
+   exchange for a little execution time.  However, BUILDFIXED should not be
+   used for threaded applications, since the rewriting of the tables and virgin
+   may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+    static int virgin = 1;
+    static code *lenfix, *distfix;
+    static code fixed[544];
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        unsigned sym, bits;
+        static code *next;
+
+        /* literal/length table */
+        sym = 0;
+        while (sym < 144) state->lens[sym++] = 8;
+        while (sym < 256) state->lens[sym++] = 9;
+        while (sym < 280) state->lens[sym++] = 7;
+        while (sym < 288) state->lens[sym++] = 8;
+        next = fixed;
+        lenfix = next;
+        bits = 9;
+        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+        /* distance table */
+        sym = 0;
+        while (sym < 32) state->lens[sym++] = 5;
+        distfix = next;
+        bits = 5;
+        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+        /* do this just once */
+        virgin = 0;
+    }
+#else /* !BUILDFIXED */
+#   include "inffixed.h"
+#endif /* BUILDFIXED */
+    state->lencode = lenfix;
+    state->lenbits = 9;
+    state->distcode = distfix;
+    state->distbits = 5;
+}
+
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+/*
+   Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
+   defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
+   those tables to stdout, which would be piped to inffixed.h.  A small program
+   can simply call makefixed to do this:
+
+    void makefixed(void);
+
+    int main(void)
+    {
+        makefixed();
+        return 0;
+    }
+
+   Then that can be linked with zlib built with MAKEFIXED defined and run:
+
+    a.out > inffixed.h
+ */
+void makefixed()
+{
+    unsigned low, size;
+    struct inflate_state state;
+
+    fixedtables(&state);
+    puts("    /* inffixed.h -- table for decoding fixed codes");
+    puts("     * Generated automatically by makefixed().");
+    puts("     */");
+    puts("");
+    puts("    /* WARNING: this file should *not* be used by applications.");
+    puts("       It is part of the implementation of this library and is");
+    puts("       subject to change. Applications should only use zlib.h.");
+    puts("     */");
+    puts("");
+    size = 1U << 9;
+    printf("    static const code lenfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 7) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
+               state.lencode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+    size = 1U << 5;
+    printf("\n    static const code distfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 6) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
+               state.distcode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+}
+#endif /* MAKEFIXED */
+
+/*
+   Update the window with the last wsize (normally 32K) bytes written before
+   returning.  If window does not exist yet, create it.  This is only called
+   when a window is already in use, or when output has been written during this
+   inflate call, but the end of the deflate stream has not been reached yet.
+   It is also called to create a window for dictionary data when a dictionary
+   is loaded.
+
+   Providing output buffers larger than 32K to inflate() should provide a speed
+   advantage, since only the last 32K of output is copied to the sliding window
+   upon return from inflate(), and since all distances after the first 32K of
+   output will fall in the output data, making match copies simpler and faster.
+   The advantage may be dependent on the size of the processor's data caches.
+ */
+local int updatewindow(strm, out)
+z_streamp strm;
+unsigned out;
+{
+    struct inflate_state FAR *state;
+    unsigned copy, dist;
+
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* if it hasn't been done already, allocate space for the window */
+    if (state->window == Z_NULL) {
+        state->window = (unsigned char FAR *)
+                        ZALLOC(strm, 1U << state->wbits,
+                               sizeof(unsigned char));
+        if (state->window == Z_NULL) return 1;
+    }
+
+    /* if window not in use yet, initialize */
+    if (state->wsize == 0) {
+        state->wsize = 1U << state->wbits;
+        state->write = 0;
+        state->whave = 0;
+    }
+
+    /* copy state->wsize or less output bytes into the circular window */
+    copy = out - strm->avail_out;
+    if (copy >= state->wsize) {
+        zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
+        state->write = 0;
+        state->whave = state->wsize;
+    }
+    else {
+        dist = state->wsize - state->write;
+        if (dist > copy) dist = copy;
+        zmemcpy(state->window + state->write, strm->next_out - copy, dist);
+        copy -= dist;
+        if (copy) {
+            zmemcpy(state->window, strm->next_out - copy, copy);
+            state->write = copy;
+            state->whave = state->wsize;
+        }
+        else {
+            state->write += dist;
+            if (state->write == state->wsize) state->write = 0;
+            if (state->whave < state->wsize) state->whave += dist;
+        }
+    }
+    return 0;
+}
+
+/* Macros for inflate(): */
+
+/* check function to use adler32() for zlib or crc32() for gzip */
+#ifdef GUNZIP
+#  define UPDATE(check, buf, len) \
+    (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
+#else
+#  define UPDATE(check, buf, len) adler32(check, buf, len)
+#endif
+
+/* check macros for header crc */
+#ifdef GUNZIP
+#  define CRC2(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        check = crc32(check, hbuf, 2); \
+    } while (0)
+
+#  define CRC4(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        hbuf[2] = (unsigned char)((word) >> 16); \
+        hbuf[3] = (unsigned char)((word) >> 24); \
+        check = crc32(check, hbuf, 4); \
+    } while (0)
+#endif
+
+/* Load registers with state in inflate() for speed */
+#define LOAD() \
+    do { \
+        put = strm->next_out; \
+        left = strm->avail_out; \
+        next = strm->next_in; \
+        have = strm->avail_in; \
+        hold = state->hold; \
+        bits = state->bits; \
+    } while (0)
+
+/* Restore state from registers in inflate() */
+#define RESTORE() \
+    do { \
+        strm->next_out = put; \
+        strm->avail_out = left; \
+        strm->next_in = next; \
+        strm->avail_in = have; \
+        state->hold = hold; \
+        state->bits = bits; \
+    } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+    do { \
+        hold = 0; \
+        bits = 0; \
+    } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflate()
+   if there is no input available. */
+#define PULLBYTE() \
+    do { \
+        if (have == 0) goto inf_leave; \
+        have--; \
+        hold += (unsigned long)(*next++) << bits; \
+        bits += 8; \
+    } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator.  If there is
+   not enough available input to do that, then return from inflate(). */
+#define NEEDBITS(n) \
+    do { \
+        while (bits < (unsigned)(n)) \
+            PULLBYTE(); \
+    } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+    ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+    do { \
+        hold >>= (n); \
+        bits -= (unsigned)(n); \
+    } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+    do { \
+        hold >>= bits & 7; \
+        bits -= bits & 7; \
+    } while (0)
+
+/* Reverse the bytes in a 32-bit value */
+#define REVERSE(q) \
+    ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+     (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+/*
+   inflate() uses a state machine to process as much input data and generate as
+   much output data as possible before returning.  The state machine is
+   structured roughly as follows:
+
+    for (;;) switch (state) {
+    ...
+    case STATEn:
+        if (not enough input data or output space to make progress)
+            return;
+        ... make progress ...
+        state = STATEm;
+        break;
+    ...
+    }
+
+   so when inflate() is called again, the same case is attempted again, and
+   if the appropriate resources are provided, the machine proceeds to the
+   next state.  The NEEDBITS() macro is usually the way the state evaluates
+   whether it can proceed or should return.  NEEDBITS() does the return if
+   the requested bits are not available.  The typical use of the BITS macros
+   is:
+
+        NEEDBITS(n);
+        ... do something with BITS(n) ...
+        DROPBITS(n);
+
+   where NEEDBITS(n) either returns from inflate() if there isn't enough
+   input left to load n bits into the accumulator, or it continues.  BITS(n)
+   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
+   the low n bits off the accumulator.  INITBITS() clears the accumulator
+   and sets the number of available bits to zero.  BYTEBITS() discards just
+   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
+   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
+
+   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
+   if there is no input available.  The decoding of variable length codes uses
+   PULLBYTE() directly in order to pull just enough bytes to decode the next
+   code, and no more.
+
+   Some states loop until they get enough input, making sure that enough
+   state information is maintained to continue the loop where it left off
+   if NEEDBITS() returns in the loop.  For example, want, need, and keep
+   would all have to actually be part of the saved state in case NEEDBITS()
+   returns:
+
+    case STATEw:
+        while (want < need) {
+            NEEDBITS(n);
+            keep[want++] = BITS(n);
+            DROPBITS(n);
+        }
+        state = STATEx;
+    case STATEx:
+
+   As shown above, if the next state is also the next case, then the break
+   is omitted.
+
+   A state may also return if there is not enough output space available to
+   complete that state.  Those states are copying stored data, writing a
+   literal byte, and copying a matching string.
+
+   When returning, a "goto inf_leave" is used to update the total counters,
+   update the check value, and determine whether any progress has been made
+   during that inflate() call in order to return the proper return code.
+   Progress is defined as a change in either strm->avail_in or strm->avail_out.
+   When there is a window, goto inf_leave will update the window with the last
+   output written.  If a goto inf_leave occurs in the middle of decompression
+   and there is no window currently, goto inf_leave will create one and copy
+   output to the window for the next call of inflate().
+
+   In this implementation, the flush parameter of inflate() only affects the
+   return code (per zlib.h).  inflate() always writes as much as possible to
+   strm->next_out, given the space available and the provided input--the effect
+   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
+   the allocation of and copying into a sliding window until necessary, which
+   provides the effect documented in zlib.h for Z_FINISH when the entire input
+   stream available.  So the only thing the flush parameter actually does is:
+   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
+   will return Z_BUF_ERROR if it has not reached the end of the stream.
+ */
+
+int ZEXPORT inflate(strm, flush)
+z_streamp strm;
+int flush;
+{
+    struct inflate_state FAR *state;
+    unsigned char FAR *next;    /* next input */
+    unsigned char FAR *put;     /* next output */
+    unsigned have, left;        /* available input and output */
+    unsigned long hold;         /* bit buffer */
+    unsigned bits;              /* bits in bit buffer */
+    unsigned in, out;           /* save starting available input and output */
+    unsigned copy;              /* number of stored or match bytes to copy */
+    unsigned char FAR *from;    /* where to copy match bytes from */
+    code this;                  /* current decoding table entry */
+    code last;                  /* parent table entry */
+    unsigned len;               /* length to copy for repeats, bits to drop */
+    int ret;                    /* return code */
+#ifdef GUNZIP
+    unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
+#endif
+    static const unsigned short order[19] = /* permutation of code lengths */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
+        (strm->next_in == Z_NULL && strm->avail_in != 0))
+        return Z_STREAM_ERROR;
+
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
+    LOAD();
+    in = have;
+    out = left;
+    ret = Z_OK;
+    for (;;)
+        switch (state->mode) {
+        case HEAD:
+            if (state->wrap == 0) {
+                state->mode = TYPEDO;
+                break;
+            }
+            NEEDBITS(16);
+#ifdef GUNZIP
+            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
+                state->check = crc32(0L, Z_NULL, 0);
+                CRC2(state->check, hold);
+                INITBITS();
+                state->mode = FLAGS;
+                break;
+            }
+            state->flags = 0;           /* expect zlib header */
+            if (state->head != Z_NULL)
+                state->head->done = -1;
+            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
+#else
+            if (
+#endif
+                ((BITS(8) << 8) + (hold >> 8)) % 31) {
+                strm->msg = (char *)"incorrect header check";
+                state->mode = BAD;
+                break;
+            }
+            if (BITS(4) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            DROPBITS(4);
+            len = BITS(4) + 8;
+            if (len > state->wbits) {
+                strm->msg = (char *)"invalid window size";
+                state->mode = BAD;
+                break;
+            }
+            state->dmax = 1U << len;
+            Tracev((stderr, "inflate:   zlib header ok\n"));
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = hold & 0x200 ? DICTID : TYPE;
+            INITBITS();
+            break;
+#ifdef GUNZIP
+        case FLAGS:
+            NEEDBITS(16);
+            state->flags = (int)(hold);
+            if ((state->flags & 0xff) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            if (state->flags & 0xe000) {
+                strm->msg = (char *)"unknown header flags set";
+                state->mode = BAD;
+                break;
+            }
+            if (state->head != Z_NULL)
+                state->head->text = (int)((hold >> 8) & 1);
+            if (state->flags & 0x0200) CRC2(state->check, hold);
+            INITBITS();
+            state->mode = TIME;
+        case TIME:
+            NEEDBITS(32);
+            if (state->head != Z_NULL)
+                state->head->time = hold;
+            if (state->flags & 0x0200) CRC4(state->check, hold);
+            INITBITS();
+            state->mode = OS;
+        case OS:
+            NEEDBITS(16);
+            if (state->head != Z_NULL) {
+                state->head->xflags = (int)(hold & 0xff);
+                state->head->os = (int)(hold >> 8);
+            }
+            if (state->flags & 0x0200) CRC2(state->check, hold);
+            INITBITS();
+            state->mode = EXLEN;
+        case EXLEN:
+            if (state->flags & 0x0400) {
+                NEEDBITS(16);
+                state->length = (unsigned)(hold);
+                if (state->head != Z_NULL)
+                    state->head->extra_len = (unsigned)hold;
+                if (state->flags & 0x0200) CRC2(state->check, hold);
+                INITBITS();
+            }
+            else if (state->head != Z_NULL)
+                state->head->extra = Z_NULL;
+            state->mode = EXTRA;
+        case EXTRA:
+            if (state->flags & 0x0400) {
+                copy = state->length;
+                if (copy > have) copy = have;
+                if (copy) {
+                    if (state->head != Z_NULL &&
+                        state->head->extra != Z_NULL) {
+                        len = state->head->extra_len - state->length;
+                        zmemcpy(state->head->extra + len, next,
+                                len + copy > state->head->extra_max ?
+                                state->head->extra_max - len : copy);
+                    }
+                    if (state->flags & 0x0200)
+                        state->check = crc32(state->check, next, copy);
+                    have -= copy;
+                    next += copy;
+                    state->length -= copy;
+                }
+                if (state->length) goto inf_leave;
+            }
+            state->length = 0;
+            state->mode = NAME;
+        case NAME:
+            if (state->flags & 0x0800) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->name != Z_NULL &&
+                            state->length < state->head->name_max)
+                        state->head->name[state->length++] = len;
+                } while (len && copy < have);
+                if (state->flags & 0x0200)
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->name = Z_NULL;
+            state->length = 0;
+            state->mode = COMMENT;
+        case COMMENT:
+            if (state->flags & 0x1000) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->comment != Z_NULL &&
+                            state->length < state->head->comm_max)
+                        state->head->comment[state->length++] = len;
+                } while (len && copy < have);
+                if (state->flags & 0x0200)
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->comment = Z_NULL;
+            state->mode = HCRC;
+        case HCRC:
+            if (state->flags & 0x0200) {
+                NEEDBITS(16);
+                if (hold != (state->check & 0xffff)) {
+                    strm->msg = (char *)"header crc mismatch";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+            }
+            if (state->head != Z_NULL) {
+                state->head->hcrc = (int)((state->flags >> 9) & 1);
+                state->head->done = 1;
+            }
+            strm->adler = state->check = crc32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+            break;
+#endif
+        case DICTID:
+            NEEDBITS(32);
+            strm->adler = state->check = REVERSE(hold);
+            INITBITS();
+            state->mode = DICT;
+        case DICT:
+            if (state->havedict == 0) {
+                RESTORE();
+                return Z_NEED_DICT;
+            }
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+        case TYPE:
+            if (flush == Z_BLOCK) goto inf_leave;
+        case TYPEDO:
+            if (state->last) {
+                BYTEBITS();
+                state->mode = CHECK;
+                break;
+            }
+            NEEDBITS(3);
+            state->last = BITS(1);
+            DROPBITS(1);
+            switch (BITS(2)) {
+            case 0:                             /* stored block */
+                Tracev((stderr, "inflate:     stored block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = STORED;
+                break;
+            case 1:                             /* fixed block */
+                fixedtables(state);
+                Tracev((stderr, "inflate:     fixed codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = LEN;              /* decode codes */
+                break;
+            case 2:                             /* dynamic block */
+                Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = TABLE;
+                break;
+            case 3:
+                strm->msg = (char *)"invalid block type";
+                state->mode = BAD;
+            }
+            DROPBITS(2);
+            break;
+        case STORED:
+            BYTEBITS();                         /* go to byte boundary */
+            NEEDBITS(32);
+            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+                strm->msg = (char *)"invalid stored block lengths";
+                state->mode = BAD;
+                break;
+            }
+            state->length = (unsigned)hold & 0xffff;
+            Tracev((stderr, "inflate:       stored length %u\n",
+                    state->length));
+            INITBITS();
+            state->mode = COPY;
+        case COPY:
+            copy = state->length;
+            if (copy) {
+                if (copy > have) copy = have;
+                if (copy > left) copy = left;
+                if (copy == 0) goto inf_leave;
+                zmemcpy(put, next, copy);
+                have -= copy;
+                next += copy;
+                left -= copy;
+                put += copy;
+                state->length -= copy;
+                break;
+            }
+            Tracev((stderr, "inflate:       stored end\n"));
+            state->mode = TYPE;
+            break;
+        case TABLE:
+            NEEDBITS(14);
+            state->nlen = BITS(5) + 257;
+            DROPBITS(5);
+            state->ndist = BITS(5) + 1;
+            DROPBITS(5);
+            state->ncode = BITS(4) + 4;
+            DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+            if (state->nlen > 286 || state->ndist > 30) {
+                strm->msg = (char *)"too many length or distance symbols";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracev((stderr, "inflate:       table sizes ok\n"));
+            state->have = 0;
+            state->mode = LENLENS;
+        case LENLENS:
+            while (state->have < state->ncode) {
+                NEEDBITS(3);
+                state->lens[order[state->have++]] = (unsigned short)BITS(3);
+                DROPBITS(3);
+            }
+            while (state->have < 19)
+                state->lens[order[state->have++]] = 0;
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 7;
+            ret = inflate_table(CODES, state->lens, 19, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid code lengths set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       code lengths ok\n"));
+            state->have = 0;
+            state->mode = CODELENS;
+        case CODELENS:
+            while (state->have < state->nlen + state->ndist) {
+                for (;;) {
+                    this = state->lencode[BITS(state->lenbits)];
+                    if ((unsigned)(this.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                if (this.val < 16) {
+                    NEEDBITS(this.bits);
+                    DROPBITS(this.bits);
+                    state->lens[state->have++] = this.val;
+                }
+                else {
+                    if (this.val == 16) {
+                        NEEDBITS(this.bits + 2);
+                        DROPBITS(this.bits);
+                        if (state->have == 0) {
+                            strm->msg = (char *)"invalid bit length repeat";
+                            state->mode = BAD;
+                            break;
+                        }
+                        len = state->lens[state->have - 1];
+                        copy = 3 + BITS(2);
+                        DROPBITS(2);
+                    }
+                    else if (this.val == 17) {
+                        NEEDBITS(this.bits + 3);
+                        DROPBITS(this.bits);
+                        len = 0;
+                        copy = 3 + BITS(3);
+                        DROPBITS(3);
+                    }
+                    else {
+                        NEEDBITS(this.bits + 7);
+                        DROPBITS(this.bits);
+                        len = 0;
+                        copy = 11 + BITS(7);
+                        DROPBITS(7);
+                    }
+                    if (state->have + copy > state->nlen + state->ndist) {
+                        strm->msg = (char *)"invalid bit length repeat";
+                        state->mode = BAD;
+                        break;
+                    }
+                    while (copy--)
+                        state->lens[state->have++] = (unsigned short)len;
+                }
+            }
+
+            /* handle error breaks in while */
+            if (state->mode == BAD) break;
+
+            /* build code tables */
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 9;
+            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid literal/lengths set";
+                state->mode = BAD;
+                break;
+            }
+            state->distcode = (code const FAR *)(state->next);
+            state->distbits = 6;
+            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+                            &(state->next), &(state->distbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid distances set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       codes ok\n"));
+            state->mode = LEN;
+        case LEN:
+            if (have >= 6 && left >= 258) {
+                RESTORE();
+                inflate_fast(strm, out);
+                LOAD();
+                break;
+            }
+            for (;;) {
+                this = state->lencode[BITS(state->lenbits)];
+                if ((unsigned)(this.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if (this.op && (this.op & 0xf0) == 0) {
+                last = this;
+                for (;;) {
+                    this = state->lencode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + this.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(this.bits);
+            state->length = (unsigned)this.val;
+            if ((int)(this.op) == 0) {
+                Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+                        "inflate:         literal '%c'\n" :
+                        "inflate:         literal 0x%02x\n", this.val));
+                state->mode = LIT;
+                break;
+            }
+            if (this.op & 32) {
+                Tracevv((stderr, "inflate:         end of block\n"));
+                state->mode = TYPE;
+                break;
+            }
+            if (this.op & 64) {
+                strm->msg = (char *)"invalid literal/length code";
+                state->mode = BAD;
+                break;
+            }
+            state->extra = (unsigned)(this.op) & 15;
+            state->mode = LENEXT;
+        case LENEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->length += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+            Tracevv((stderr, "inflate:         length %u\n", state->length));
+            state->mode = DIST;
+        case DIST:
+            for (;;) {
+                this = state->distcode[BITS(state->distbits)];
+                if ((unsigned)(this.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if ((this.op & 0xf0) == 0) {
+                last = this;
+                for (;;) {
+                    this = state->distcode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + this.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(this.bits);
+            if (this.op & 64) {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+            state->offset = (unsigned)this.val;
+            state->extra = (unsigned)(this.op) & 15;
+            state->mode = DISTEXT;
+        case DISTEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->offset += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+#ifdef INFLATE_STRICT
+            if (state->offset > state->dmax) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            if (state->offset > state->whave + out - left) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+            state->mode = MATCH;
+        case MATCH:
+            if (left == 0) goto inf_leave;
+            copy = out - left;
+            if (state->offset > copy) {         /* copy from window */
+                copy = state->offset - copy;
+                if (copy > state->write) {
+                    copy -= state->write;
+                    from = state->window + (state->wsize - copy);
+                }
+                else
+                    from = state->window + (state->write - copy);
+                if (copy > state->length) copy = state->length;
+            }
+            else {                              /* copy from output */
+                from = put - state->offset;
+                copy = state->length;
+            }
+            if (copy > left) copy = left;
+            left -= copy;
+            state->length -= copy;
+            do {
+                *put++ = *from++;
+            } while (--copy);
+            if (state->length == 0) state->mode = LEN;
+            break;
+        case LIT:
+            if (left == 0) goto inf_leave;
+            *put++ = (unsigned char)(state->length);
+            left--;
+            state->mode = LEN;
+            break;
+        case CHECK:
+            if (state->wrap) {
+                NEEDBITS(32);
+                out -= left;
+                strm->total_out += out;
+                state->total += out;
+                if (out)
+                    strm->adler = state->check =
+                        UPDATE(state->check, put - out, out);
+                out = left;
+                if ((
+#ifdef GUNZIP
+                     state->flags ? hold :
+#endif
+                     REVERSE(hold)) != state->check) {
+                    strm->msg = (char *)"incorrect data check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   check matches trailer\n"));
+            }
+#ifdef GUNZIP
+            state->mode = LENGTH;
+        case LENGTH:
+            if (state->wrap && state->flags) {
+                NEEDBITS(32);
+                if (hold != (state->total & 0xffffffffUL)) {
+                    strm->msg = (char *)"incorrect length check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   length matches trailer\n"));
+            }
+#endif
+            state->mode = DONE;
+        case DONE:
+            ret = Z_STREAM_END;
+            goto inf_leave;
+        case BAD:
+            ret = Z_DATA_ERROR;
+            goto inf_leave;
+        case MEM:
+            return Z_MEM_ERROR;
+        case SYNC:
+        default:
+            return Z_STREAM_ERROR;
+        }
+
+    /*
+       Return from inflate(), updating the total counts and the check value.
+       If there was no progress during the inflate() call, return a buffer
+       error.  Call updatewindow() to create and/or update the window state.
+       Note: a memory error from inflate() is non-recoverable.
+     */
+  inf_leave:
+    RESTORE();
+    if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
+        if (updatewindow(strm, out)) {
+            state->mode = MEM;
+            return Z_MEM_ERROR;
+        }
+    in -= strm->avail_in;
+    out -= strm->avail_out;
+    strm->total_in += in;
+    strm->total_out += out;
+    state->total += out;
+    if (state->wrap && out)
+        strm->adler = state->check =
+            UPDATE(state->check, strm->next_out - out, out);
+    strm->data_type = state->bits + (state->last ? 64 : 0) +
+                      (state->mode == TYPE ? 128 : 0);
+    if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
+        ret = Z_BUF_ERROR;
+    return ret;
+}
+
+int ZEXPORT inflateEnd(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->window != Z_NULL) ZFREE(strm, state->window);
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+    Tracev((stderr, "inflate: end\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+const Bytef *dictionary;
+uInt dictLength;
+{
+    struct inflate_state FAR *state;
+    unsigned long id;
+
+    /* check state */
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->wrap != 0 && state->mode != DICT)
+        return Z_STREAM_ERROR;
+
+    /* check for correct dictionary id */
+    if (state->mode == DICT) {
+        id = adler32(0L, Z_NULL, 0);
+        id = adler32(id, dictionary, dictLength);
+        if (id != state->check)
+            return Z_DATA_ERROR;
+    }
+
+    /* copy dictionary to window */
+    if (updatewindow(strm, strm->avail_out)) {
+        state->mode = MEM;
+        return Z_MEM_ERROR;
+    }
+    if (dictLength > state->wsize) {
+        zmemcpy(state->window, dictionary + dictLength - state->wsize,
+                state->wsize);
+        state->whave = state->wsize;
+    }
+    else {
+        zmemcpy(state->window + state->wsize - dictLength, dictionary,
+                dictLength);
+        state->whave = dictLength;
+    }
+    state->havedict = 1;
+    Tracev((stderr, "inflate:   dictionary set\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateGetHeader(strm, head)
+z_streamp strm;
+gz_headerp head;
+{
+    struct inflate_state FAR *state;
+
+    /* check state */
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
+
+    /* save header structure */
+    state->head = head;
+    head->done = 0;
+    return Z_OK;
+}
+
+/*
+   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
+   or when out of input.  When called, *have is the number of pattern bytes
+   found in order so far, in 0..3.  On return *have is updated to the new
+   state.  If on return *have equals four, then the pattern was found and the
+   return value is how many bytes were read including the last byte of the
+   pattern.  If *have is less than four, then the pattern has not been found
+   yet and the return value is len.  In the latter case, syncsearch() can be
+   called again with more data and the *have state.  *have is initialized to
+   zero for the first call.
+ */
+local unsigned syncsearch(have, buf, len)
+unsigned FAR *have;
+unsigned char FAR *buf;
+unsigned len;
+{
+    unsigned got;
+    unsigned next;
+
+    got = *have;
+    next = 0;
+    while (next < len && got < 4) {
+        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
+            got++;
+        else if (buf[next])
+            got = 0;
+        else
+            got = 4 - got;
+        next++;
+    }
+    *have = got;
+    return next;
+}
+
+int ZEXPORT inflateSync(strm)
+z_streamp strm;
+{
+    unsigned len;               /* number of bytes to look at or looked at */
+    unsigned long in, out;      /* temporary to save total_in and total_out */
+    unsigned char buf[4];       /* to restore bit buffer to byte string */
+    struct inflate_state FAR *state;
+
+    /* check parameters */
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
+
+    /* if first time, start search in bit buffer */
+    if (state->mode != SYNC) {
+        state->mode = SYNC;
+        state->hold <<= state->bits & 7;
+        state->bits -= state->bits & 7;
+        len = 0;
+        while (state->bits >= 8) {
+            buf[len++] = (unsigned char)(state->hold);
+            state->hold >>= 8;
+            state->bits -= 8;
+        }
+        state->have = 0;
+        syncsearch(&(state->have), buf, len);
+    }
+
+    /* search available input */
+    len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
+    strm->avail_in -= len;
+    strm->next_in += len;
+    strm->total_in += len;
+
+    /* return no joy or set up to restart inflate() on a new block */
+    if (state->have != 4) return Z_DATA_ERROR;
+    in = strm->total_in;  out = strm->total_out;
+    inflateReset(strm);
+    strm->total_in = in;  strm->total_out = out;
+    state->mode = TYPE;
+    return Z_OK;
+}
+
+/*
+   Returns true if inflate is currently at the end of a block generated by
+   Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+   implementation to provide an additional safety check. PPP uses
+   Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
+   block. When decompressing, PPP checks that at the end of input packet,
+   inflate is waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    return state->mode == STORED && state->bits == 0;
+}
+
+int ZEXPORT inflateCopy(dest, source)
+z_streamp dest;
+z_streamp source;
+{
+    struct inflate_state FAR *state;
+    struct inflate_state FAR *copy;
+    unsigned char FAR *window;
+    unsigned wsize;
+
+    /* check input */
+    if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
+        source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)source->state;
+
+    /* allocate space */
+    copy = (struct inflate_state FAR *)
+           ZALLOC(source, 1, sizeof(struct inflate_state));
+    if (copy == Z_NULL) return Z_MEM_ERROR;
+    window = Z_NULL;
+    if (state->window != Z_NULL) {
+        window = (unsigned char FAR *)
+                 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+        if (window == Z_NULL) {
+            ZFREE(source, copy);
+            return Z_MEM_ERROR;
+        }
+    }
+
+    /* copy state */
+    zmemcpy(dest, source, sizeof(z_stream));
+    zmemcpy(copy, state, sizeof(struct inflate_state));
+    if (state->lencode >= state->codes &&
+        state->lencode <= state->codes + ENOUGH - 1) {
+        copy->lencode = copy->codes + (state->lencode - state->codes);
+        copy->distcode = copy->codes + (state->distcode - state->codes);
+    }
+    copy->next = copy->codes + (state->next - state->codes);
+    if (window != Z_NULL) {
+        wsize = 1U << state->wbits;
+        zmemcpy(window, state->window, wsize);
+    }
+    copy->window = window;
+    dest->state = (struct internal_state FAR *)copy;
+    return Z_OK;
+}
diff --git a/src/reader/zlib/inflate.h b/src/reader/zlib/inflate.h
new file mode 100644
index 00000000..07bd3e78
--- /dev/null
+++ b/src/reader/zlib/inflate.h
@@ -0,0 +1,115 @@
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip decoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+    HEAD,       /* i: waiting for magic header */
+    FLAGS,      /* i: waiting for method and flags (gzip) */
+    TIME,       /* i: waiting for modification time (gzip) */
+    OS,         /* i: waiting for extra flags and operating system (gzip) */
+    EXLEN,      /* i: waiting for extra length (gzip) */
+    EXTRA,      /* i: waiting for extra bytes (gzip) */
+    NAME,       /* i: waiting for end of file name (gzip) */
+    COMMENT,    /* i: waiting for end of comment (gzip) */
+    HCRC,       /* i: waiting for header crc (gzip) */
+    DICTID,     /* i: waiting for dictionary check value */
+    DICT,       /* waiting for inflateSetDictionary() call */
+        TYPE,       /* i: waiting for type bits, including last-flag bit */
+        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
+        STORED,     /* i: waiting for stored size (length and complement) */
+        COPY,       /* i/o: waiting for input or output to copy stored block */
+        TABLE,      /* i: waiting for dynamic block table lengths */
+        LENLENS,    /* i: waiting for code length code lengths */
+        CODELENS,   /* i: waiting for length/lit and distance code lengths */
+            LEN,        /* i: waiting for length/lit code */
+            LENEXT,     /* i: waiting for length extra bits */
+            DIST,       /* i: waiting for distance code */
+            DISTEXT,    /* i: waiting for distance extra bits */
+            MATCH,      /* o: waiting for output space to copy string */
+            LIT,        /* o: waiting for output space to write literal */
+    CHECK,      /* i: waiting for 32-bit check value */
+    LENGTH,     /* i: waiting for 32-bit length (gzip) */
+    DONE,       /* finished check, done -- remain here until reset */
+    BAD,        /* got a data error -- remain here until reset */
+    MEM,        /* got an inflate() memory error -- remain here until reset */
+    SYNC        /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+    State transitions between above modes -
+
+    (most modes can go to the BAD or MEM mode -- not shown for clarity)
+
+    Process header:
+        HEAD -> (gzip) or (zlib)
+        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
+        NAME -> COMMENT -> HCRC -> TYPE
+        (zlib) -> DICTID or TYPE
+        DICTID -> DICT -> TYPE
+    Read deflate blocks:
+            TYPE -> STORED or TABLE or LEN or CHECK
+            STORED -> COPY -> TYPE
+            TABLE -> LENLENS -> CODELENS -> LEN
+    Read deflate codes:
+                LEN -> LENEXT or LIT or TYPE
+                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+                LIT -> LEN
+    Process trailer:
+        CHECK -> LENGTH -> DONE
+ */
+
+/* state maintained between inflate() calls.  Approximately 7K bytes. */
+struct inflate_state {
+    inflate_mode mode;          /* current inflate mode */
+    int last;                   /* true if processing last block */
+    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip */
+    int havedict;               /* true if dictionary provided */
+    int flags;                  /* gzip header method and flags (0 if zlib) */
+    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
+    unsigned long check;        /* protected copy of check value */
+    unsigned long total;        /* protected copy of output count */
+    gz_headerp head;            /* where to save gzip header information */
+        /* sliding window */
+    unsigned wbits;             /* log base 2 of requested window size */
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned write;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if needed */
+        /* bit accumulator */
+    unsigned long hold;         /* input bit accumulator */
+    unsigned bits;              /* number of bits in "in" */
+        /* for string and stored block copying */
+    unsigned length;            /* literal or length of data to copy */
+    unsigned offset;            /* distance back to copy string from */
+        /* for table and code decoding */
+    unsigned extra;             /* extra bits needed */
+        /* fixed and dynamic code tables */
+    code const FAR *lencode;    /* starting table for length/literal codes */
+    code const FAR *distcode;   /* starting table for distance codes */
+    unsigned lenbits;           /* index bits for lencode */
+    unsigned distbits;          /* index bits for distcode */
+        /* dynamic table building */
+    unsigned ncode;             /* number of code length code lengths */
+    unsigned nlen;              /* number of length code lengths */
+    unsigned ndist;             /* number of distance code lengths */
+    unsigned have;              /* number of code lengths in lens[] */
+    code FAR *next;             /* next available space in codes[] */
+    unsigned short lens[320];   /* temporary storage for code lengths */
+    unsigned short work[288];   /* work area for code table building */
+    code codes[ENOUGH];         /* space for code tables */
+};
diff --git a/src/reader/zlib/inftrees.c b/src/reader/zlib/inftrees.c
new file mode 100644
index 00000000..8a9c13ff
--- /dev/null
+++ b/src/reader/zlib/inftrees.c
@@ -0,0 +1,329 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#define MAXBITS 15
+
+const char inflate_copyright[] =
+   " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/*
+   Build a set of tables to decode the provided canonical Huffman code.
+   The code lengths are lens[0..codes-1].  The result starts at *table,
+   whose indices are 0..2^bits-1.  work is a writable array of at least
+   lens shorts, which is used as a work area.  type is the type of code
+   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
+   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
+   on return points to the next available entry's address.  bits is the
+   requested root table index bits, and on return it is the actual root
+   table index bits.  It will differ if the request is greater than the
+   longest code or if it is less than the shortest code.
+ */
+int inflate_table(type, lens, codes, table, bits, work)
+codetype type;
+unsigned short FAR *lens;
+unsigned codes;
+code FAR * FAR *table;
+unsigned FAR *bits;
+unsigned short FAR *work;
+{
+    unsigned len;               /* a code's length in bits */
+    unsigned sym;               /* index of code symbols */
+    unsigned min, max;          /* minimum and maximum code lengths */
+    unsigned root;              /* number of index bits for root table */
+    unsigned curr;              /* number of index bits for current table */
+    unsigned drop;              /* code bits to drop for sub-table */
+    int left;                   /* number of prefix codes available */
+    unsigned used;              /* code entries in table used */
+    unsigned huff;              /* Huffman code */
+    unsigned incr;              /* for incrementing code, index */
+    unsigned fill;              /* index for replicating entries */
+    unsigned low;               /* low bits for current root entry */
+    unsigned mask;              /* mask for low root bits */
+    code this;                  /* table entry for duplication */
+    code FAR *next;             /* next available space in table */
+    const unsigned short FAR *base;     /* base value table to use */
+    const unsigned short FAR *extra;    /* extra bits table to use */
+    int end;                    /* use base and extra for symbol > end */
+    unsigned short count[MAXBITS+1];    /* number of codes of each length */
+    unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
+    static const unsigned short lbase[31] = { /* Length codes 257..285 base */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
+    static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577, 0, 0};
+    static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
+        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+        28, 28, 29, 29, 64, 64};
+
+    /*
+       Process a set of code lengths to create a canonical Huffman code.  The
+       code lengths are lens[0..codes-1].  Each length corresponds to the
+       symbols 0..codes-1.  The Huffman code is generated by first sorting the
+       symbols by length from short to long, and retaining the symbol order
+       for codes with equal lengths.  Then the code starts with all zero bits
+       for the first code of the shortest length, and the codes are integer
+       increments for the same length, and zeros are appended as the length
+       increases.  For the deflate format, these bits are stored backwards
+       from their more natural integer increment ordering, and so when the
+       decoding tables are built in the large loop below, the integer codes
+       are incremented backwards.
+
+       This routine assumes, but does not check, that all of the entries in
+       lens[] are in the range 0..MAXBITS.  The caller must assure this.
+       1..MAXBITS is interpreted as that code length.  zero means that that
+       symbol does not occur in this code.
+
+       The codes are sorted by computing a count of codes for each length,
+       creating from that a table of starting indices for each length in the
+       sorted table, and then entering the symbols in order in the sorted
+       table.  The sorted table is work[], with that space being provided by
+       the caller.
+
+       The length counts are used for other purposes as well, i.e. finding
+       the minimum and maximum length codes, determining if there are any
+       codes at all, checking for a valid set of lengths, and looking ahead
+       at length counts to determine sub-table sizes when building the
+       decoding tables.
+     */
+
+    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+    for (len = 0; len <= MAXBITS; len++)
+        count[len] = 0;
+    for (sym = 0; sym < codes; sym++)
+        count[lens[sym]]++;
+
+    /* bound code lengths, force root to be within code lengths */
+    root = *bits;
+    for (max = MAXBITS; max >= 1; max--)
+        if (count[max] != 0) break;
+    if (root > max) root = max;
+    if (max == 0) {                     /* no symbols to code at all */
+        this.op = (unsigned char)64;    /* invalid code marker */
+        this.bits = (unsigned char)1;
+        this.val = (unsigned short)0;
+        *(*table)++ = this;             /* make a table to force an error */
+        *(*table)++ = this;
+        *bits = 1;
+        return 0;     /* no symbols, but wait for decoding to report error */
+    }
+    for (min = 1; min <= MAXBITS; min++)
+        if (count[min] != 0) break;
+    if (root < min) root = min;
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1;
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1;
+        left -= count[len];
+        if (left < 0) return -1;        /* over-subscribed */
+    }
+    if (left > 0 && (type == CODES || max != 1))
+        return -1;                      /* incomplete set */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + count[len];
+
+    /* sort symbols by length, by symbol order within each length */
+    for (sym = 0; sym < codes; sym++)
+        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+
+    /*
+       Create and fill in decoding tables.  In this loop, the table being
+       filled is at next and has curr index bits.  The code being used is huff
+       with length len.  That code is converted to an index by dropping drop
+       bits off of the bottom.  For codes where len is less than drop + curr,
+       those top drop + curr - len bits are incremented through all values to
+       fill the table with replicated entries.
+
+       root is the number of index bits for the root table.  When len exceeds
+       root, sub-tables are created pointed to by the root entry with an index
+       of the low root bits of huff.  This is saved in low to check for when a
+       new sub-table should be started.  drop is zero when the root table is
+       being filled, and drop is root when sub-tables are being filled.
+
+       When a new sub-table is needed, it is necessary to look ahead in the
+       code lengths to determine what size sub-table is needed.  The length
+       counts are used for this, and so count[] is decremented as codes are
+       entered in the tables.
+
+       used keeps track of how many table entries have been allocated from the
+       provided *table space.  It is checked when a LENS table is being made
+       against the space in *table, ENOUGH, minus the maximum space needed by
+       the worst case distance code, MAXD.  This should never happen, but the
+       sufficiency of ENOUGH has not been proven exhaustively, hence the check.
+       This assumes that when type == LENS, bits == 9.
+
+       sym increments through all symbols, and the loop terminates when
+       all codes of length max, i.e. all codes, have been processed.  This
+       routine permits incomplete codes, so another loop after this one fills
+       in the rest of the decoding tables with invalid code markers.
+     */
+
+    /* set up for code type */
+    switch (type) {
+    case CODES:
+        base = extra = work;    /* dummy value--not used */
+        end = 19;
+        break;
+    case LENS:
+        base = lbase;
+        base -= 257;
+        extra = lext;
+        extra -= 257;
+        end = 256;
+        break;
+    default:            /* DISTS */
+        base = dbase;
+        extra = dext;
+        end = -1;
+    }
+
+    /* initialize state for loop */
+    huff = 0;                   /* starting code */
+    sym = 0;                    /* starting code symbol */
+    len = min;                  /* starting code length */
+    next = *table;              /* current table to fill in */
+    curr = root;                /* current table index bits */
+    drop = 0;                   /* current bits to drop from code for index */
+    low = (unsigned)(-1);       /* trigger new sub-table when len > root */
+    used = 1U << root;          /* use root table entries */
+    mask = used - 1;            /* mask for comparing low */
+
+    /* check available table space */
+    if (type == LENS && used >= ENOUGH - MAXD)
+        return 1;
+
+    /* process all codes and make table entries */
+    for (;;) {
+        /* create table entry */
+        this.bits = (unsigned char)(len - drop);
+        if ((int)(work[sym]) < end) {
+            this.op = (unsigned char)0;
+            this.val = work[sym];
+        }
+        else if ((int)(work[sym]) > end) {
+            this.op = (unsigned char)(extra[work[sym]]);
+            this.val = base[work[sym]];
+        }
+        else {
+            this.op = (unsigned char)(32 + 64);         /* end of block */
+            this.val = 0;
+        }
+
+        /* replicate for those indices with low len bits equal to huff */
+        incr = 1U << (len - drop);
+        fill = 1U << curr;
+        min = fill;                 /* save offset to next table */
+        do {
+            fill -= incr;
+            next[(huff >> drop) + fill] = this;
+        } while (fill != 0);
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+
+        /* go to next symbol, update count, len */
+        sym++;
+        if (--(count[len]) == 0) {
+            if (len == max) break;
+            len = lens[work[sym]];
+        }
+
+        /* create new sub-table if needed */
+        if (len > root && (huff & mask) != low) {
+            /* if first time, transition to sub-tables */
+            if (drop == 0)
+                drop = root;
+
+            /* increment past last table */
+            next += min;            /* here min is 1 << curr */
+
+            /* determine length of next table */
+            curr = len - drop;
+            left = (int)(1 << curr);
+            while (curr + drop < max) {
+                left -= count[curr + drop];
+                if (left <= 0) break;
+                curr++;
+                left <<= 1;
+            }
+
+            /* check for enough space */
+            used += 1U << curr;
+            if (type == LENS && used >= ENOUGH - MAXD)
+                return 1;
+
+            /* point entry in root table to sub-table */
+            low = huff & mask;
+            (*table)[low].op = (unsigned char)curr;
+            (*table)[low].bits = (unsigned char)root;
+            (*table)[low].val = (unsigned short)(next - *table);
+        }
+    }
+
+    /*
+       Fill in rest of table for incomplete codes.  This loop is similar to the
+       loop above in incrementing huff for table indices.  It is assumed that
+       len is equal to curr + drop, so there is no loop needed to increment
+       through high index bits.  When the current sub-table is filled, the loop
+       drops back to the root table to fill in any remaining entries there.
+     */
+    this.op = (unsigned char)64;                /* invalid code marker */
+    this.bits = (unsigned char)(len - drop);
+    this.val = (unsigned short)0;
+    while (huff != 0) {
+        /* when done with sub-table, drop back to root table */
+        if (drop != 0 && (huff & mask) != low) {
+            drop = 0;
+            len = root;
+            next = *table;
+            this.bits = (unsigned char)len;
+        }
+
+        /* put invalid code marker in table */
+        next[huff >> drop] = this;
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+    }
+
+    /* set return parameters */
+    *table += used;
+    *bits = root;
+    return 0;
+}
diff --git a/src/reader/zlib/inftrees.h b/src/reader/zlib/inftrees.h
new file mode 100644
index 00000000..b1104c87
--- /dev/null
+++ b/src/reader/zlib/inftrees.h
@@ -0,0 +1,55 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables.  Each entry provides either the
+   information needed to do the operation requested by the code that
+   indexed that table entry, or it provides a pointer to another
+   table that indexes more bits of the code.  op indicates whether
+   the entry is a pointer to another table, a literal, a length or
+   distance, an end-of-block, or an invalid code.  For a table
+   pointer, the low four bits of op is the number of index bits of
+   that table.  For a length or distance, the low four bits of op
+   is the number of extra bits to get after the code.  bits is
+   the number of bits in this code or part of the code to drop off
+   of the bit buffer.  val is the actual byte to output in the case
+   of a literal, the base length or distance, or the offset from
+   the current table to the next table.  Each entry is four bytes. */
+typedef struct {
+    unsigned char op;           /* operation, extra bits, table bits */
+    unsigned char bits;         /* bits in this part of the code */
+    unsigned short val;         /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+    00000000 - literal
+    0000tttt - table link, tttt != 0 is the number of table index bits
+    0001eeee - length or distance, eeee is the number of extra bits
+    01100000 - end of block
+    01000000 - invalid code
+ */
+
+/* Maximum size of dynamic tree.  The maximum found in a long but non-
+   exhaustive search was 1444 code structures (852 for length/literals
+   and 592 for distances, the latter actually the result of an
+   exhaustive search).  The true maximum is not known, but the value
+   below is more than safe. */
+#define ENOUGH 2048
+#define MAXD 592
+
+/* Type of code to build for inftable() */
+typedef enum {
+    CODES,
+    LENS,
+    DISTS
+} codetype;
+
+extern int inflate_table OF((codetype type, unsigned short FAR *lens,
+                             unsigned codes, code FAR * FAR *table,
+                             unsigned FAR *bits, unsigned short FAR *work));
diff --git a/src/reader/zlib/ioapi.c b/src/reader/zlib/ioapi.c
new file mode 100644
index 00000000..f1bee23e
--- /dev/null
+++ b/src/reader/zlib/ioapi.c
@@ -0,0 +1,177 @@
+/* ioapi.c -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+
+
+
+/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
+
+#ifndef SEEK_CUR
+#define SEEK_CUR    1
+#endif
+
+#ifndef SEEK_END
+#define SEEK_END    2
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET    0
+#endif
+
+voidpf ZCALLBACK fopen_file_func OF((
+   voidpf opaque,
+   const char* filename,
+   int mode));
+
+uLong ZCALLBACK fread_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   void* buf,
+   uLong size));
+
+uLong ZCALLBACK fwrite_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   const void* buf,
+   uLong size));
+
+long ZCALLBACK ftell_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+long ZCALLBACK fseek_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   uLong offset,
+   int origin));
+
+int ZCALLBACK fclose_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+int ZCALLBACK ferror_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+
+voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
+   voidpf opaque;
+   const char* filename;
+   int mode;
+{
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen(filename, mode_fopen);
+    return file;
+}
+
+
+uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   void* buf;
+   uLong size;
+{
+    uLong ret;
+    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+
+uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   const void* buf;
+   uLong size;
+{
+    uLong ret;
+    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK ftell_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    long ret;
+    ret = ftell((FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
+   voidpf opaque;
+   voidpf stream;
+   uLong offset;
+   int origin;
+{
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+    fseek((FILE *)stream, offset, fseek_origin);
+    return ret;
+}
+
+int ZCALLBACK fclose_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    int ret;
+    ret = fclose((FILE *)stream);
+    return ret;
+}
+
+int ZCALLBACK ferror_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    int ret;
+    ret = ferror((FILE *)stream);
+    return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell_file = ftell_file_func;
+    pzlib_filefunc_def->zseek_file = fseek_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
diff --git a/src/reader/zlib/ioapi.h b/src/reader/zlib/ioapi.h
new file mode 100644
index 00000000..7d457baa
--- /dev/null
+++ b/src/reader/zlib/ioapi.h
@@ -0,0 +1,75 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+*/
+
+#ifndef _ZLIBIOAPI_H
+#define _ZLIBIOAPI_H
+
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ      (1)
+#define ZLIB_FILEFUNC_MODE_WRITE     (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
+
+#define ZLIB_FILEFUNC_MODE_EXISTING (4)
+#define ZLIB_FILEFUNC_MODE_CREATE   (8)
+
+
+#ifndef ZCALLBACK
+
+#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+#define ZCALLBACK CALLBACK
+#else
+#define ZCALLBACK
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
+typedef uLong  (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+typedef uLong  (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+typedef long   (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
+typedef long   (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+typedef int    (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
+typedef int    (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+typedef struct zlib_filefunc_def_s
+{
+    open_file_func      zopen_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell_file_func      ztell_file;
+    seek_file_func      zseek_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc_def;
+
+
+
+void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+
+#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
+#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
+#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
+#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
+#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
+#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/src/reader/zlib/trees.c b/src/reader/zlib/trees.c
new file mode 100644
index 00000000..ecd62b51
--- /dev/null
+++ b/src/reader/zlib/trees.c
@@ -0,0 +1,1219 @@
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2005 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process uses several Huffman trees. The more
+ *      common source values are represented by shorter bit sequences.
+ *
+ *      Each code tree is stored in a compressed form which is itself
+ * a Huffman encoding of the lengths of all the code strings (in
+ * ascending order by source values).  The actual code strings are
+ * reconstructed from the lengths in the inflate process, as described
+ * in the deflate specification.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
+ *      Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
+ *
+ *      Storer, James A.
+ *          Data Compression:  Methods and Theory, pp. 49-50.
+ *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
+ *
+ *      Sedgewick, R.
+ *          Algorithms, p290.
+ *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
+ */
+
+/* @(#) $Id: trees.c,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+/* #define GEN_TREES_H */
+
+#include "deflate.h"
+
+#ifdef DEBUG
+#  include <ctype.h>
+#endif
+
+/* ===========================================================================
+ * Constants
+ */
+
+#define MAX_BL_BITS 7
+/* Bit length codes must not exceed MAX_BL_BITS bits */
+
+#define END_BLOCK 256
+/* end of block literal code */
+
+#define REP_3_6      16
+/* repeat previous bit length 3-6 times (2 bits of repeat count) */
+
+#define REPZ_3_10    17
+/* repeat a zero length 3-10 times  (3 bits of repeat count) */
+
+#define REPZ_11_138  18
+/* repeat a zero length 11-138 times  (7 bits of repeat count) */
+
+local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
+   = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
+
+local const int extra_dbits[D_CODES] /* extra bits for each distance code */
+   = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
+   = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
+
+local const uch bl_order[BL_CODES]
+   = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
+/* The lengths of the bit length codes are sent in order of decreasing
+ * probability, to avoid transmitting the lengths for unused bit length codes.
+ */
+
+#define Buf_size (8 * 2*sizeof(char))
+/* Number of bits used within bi_buf. (bi_buf might be implemented on
+ * more than 16 bits on some systems.)
+ */
+
+/* ===========================================================================
+ * Local data. These are initialized only once.
+ */
+
+#define DIST_CODE_LEN  512 /* see definition of array dist_code below */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+/* non ANSI compilers may not accept trees.h */
+
+local ct_data static_ltree[L_CODES+2];
+/* The static literal tree. Since the bit lengths are imposed, there is no
+ * need for the L_CODES extra codes used during heap construction. However
+ * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+ * below).
+ */
+
+local ct_data static_dtree[D_CODES];
+/* The static distance tree. (Actually a trivial tree since all codes use
+ * 5 bits.)
+ */
+
+uch _dist_code[DIST_CODE_LEN];
+/* Distance codes. The first 256 values correspond to the distances
+ * 3 .. 258, the last 256 values correspond to the top 8 bits of
+ * the 15 bit distances.
+ */
+
+uch _length_code[MAX_MATCH-MIN_MATCH+1];
+/* length code for each normalized match length (0 == MIN_MATCH) */
+
+local int base_length[LENGTH_CODES];
+/* First normalized length for each code (0 = MIN_MATCH) */
+
+local int base_dist[D_CODES];
+/* First normalized distance for each code (0 = distance of 1) */
+
+#else
+#  include "trees.h"
+#endif /* GEN_TREES_H */
+
+struct static_tree_desc_s {
+    const ct_data *static_tree;  /* static tree or NULL */
+    const intf *extra_bits;      /* extra bits for each code or NULL */
+    int     extra_base;          /* base index for extra_bits */
+    int     elems;               /* max number of elements in the tree */
+    int     max_length;          /* max bit length for the codes */
+};
+
+local static_tree_desc  static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local static_tree_desc  static_d_desc =
+{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};
+
+local static_tree_desc  static_bl_desc =
+{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};
+
+/* ===========================================================================
+ * Local (static) routines in this file.
+ */
+
+local void tr_static_init OF((void));
+local void init_block     OF((deflate_state *s));
+local void pqdownheap     OF((deflate_state *s, ct_data *tree, int k));
+local void gen_bitlen     OF((deflate_state *s, tree_desc *desc));
+local void gen_codes      OF((ct_data *tree, int max_code, ushf *bl_count));
+local void build_tree     OF((deflate_state *s, tree_desc *desc));
+local void scan_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local void send_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local int  build_bl_tree  OF((deflate_state *s));
+local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
+                              int blcodes));
+local void compress_block OF((deflate_state *s, ct_data *ltree,
+                              ct_data *dtree));
+local void set_data_type  OF((deflate_state *s));
+local unsigned bi_reverse OF((unsigned value, int length));
+local void bi_windup      OF((deflate_state *s));
+local void bi_flush       OF((deflate_state *s));
+local void copy_block     OF((deflate_state *s, charf *buf, unsigned len,
+                              int header));
+
+#ifdef GEN_TREES_H
+local void gen_trees_header OF((void));
+#endif
+
+#ifndef DEBUG
+#  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
+   /* Send a code of the given tree. c and tree must not have side effects */
+
+#else /* DEBUG */
+#  define send_code(s, c, tree) \
+     { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
+       send_bits(s, tree[c].Code, tree[c].Len); }
+#endif
+
+/* ===========================================================================
+ * Output a short LSB first on the stream.
+ * IN assertion: there is enough room in pendingBuf.
+ */
+#define put_short(s, w) { \
+    put_byte(s, (uch)((w) & 0xff)); \
+    put_byte(s, (uch)((ush)(w) >> 8)); \
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef DEBUG
+local void send_bits      OF((deflate_state *s, int value, int length));
+
+local void send_bits(s, value, length)
+    deflate_state *s;
+    int value;  /* value to send */
+    int length; /* number of bits */
+{
+    Tracevv((stderr," l %2d v %4x ", length, value));
+    Assert(length > 0 && length <= 15, "invalid length");
+    s->bits_sent += (ulg)length;
+
+    /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+     * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+     * unused bits in value.
+     */
+    if (s->bi_valid > (int)Buf_size - length) {
+        s->bi_buf |= (value << s->bi_valid);
+        put_short(s, s->bi_buf);
+        s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
+        s->bi_valid += length - Buf_size;
+    } else {
+        s->bi_buf |= value << s->bi_valid;
+        s->bi_valid += length;
+    }
+}
+#else /* !DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+  if (s->bi_valid > (int)Buf_size - len) {\
+    int val = value;\
+    s->bi_buf |= (val << s->bi_valid);\
+    put_short(s, s->bi_buf);\
+    s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
+    s->bi_valid += len - Buf_size;\
+  } else {\
+    s->bi_buf |= (value) << s->bi_valid;\
+    s->bi_valid += len;\
+  }\
+}
+#endif /* DEBUG */
+
+
+/* the arguments must not have side effects */
+
+/* ===========================================================================
+ * Initialize the various 'constant' tables.
+ */
+local void tr_static_init()
+{
+#if defined(GEN_TREES_H) || !defined(STDC)
+    static int static_init_done = 0;
+    int n;        /* iterates over tree elements */
+    int bits;     /* bit counter */
+    int length;   /* length value */
+    int code;     /* code value */
+    int dist;     /* distance index */
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    if (static_init_done) return;
+
+    /* For some embedded targets, global variables are not initialized: */
+    static_l_desc.static_tree = static_ltree;
+    static_l_desc.extra_bits = extra_lbits;
+    static_d_desc.static_tree = static_dtree;
+    static_d_desc.extra_bits = extra_dbits;
+    static_bl_desc.extra_bits = extra_blbits;
+
+    /* Initialize the mapping length (0..255) -> length code (0..28) */
+    length = 0;
+    for (code = 0; code < LENGTH_CODES-1; code++) {
+        base_length[code] = length;
+        for (n = 0; n < (1<<extra_lbits[code]); n++) {
+            _length_code[length++] = (uch)code;
+        }
+    }
+    Assert (length == 256, "tr_static_init: length != 256");
+    /* Note that the length 255 (match length 258) can be represented
+     * in two different ways: code 284 + 5 bits or code 285, so we
+     * overwrite length_code[255] to use the best encoding:
+     */
+    _length_code[length-1] = (uch)code;
+
+    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+    dist = 0;
+    for (code = 0 ; code < 16; code++) {
+        base_dist[code] = dist;
+        for (n = 0; n < (1<<extra_dbits[code]); n++) {
+            _dist_code[dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: dist != 256");
+    dist >>= 7; /* from now on, all distances are divided by 128 */
+    for ( ; code < D_CODES; code++) {
+        base_dist[code] = dist << 7;
+        for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
+            _dist_code[256 + dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: 256+dist != 512");
+
+    /* Construct the codes of the static literal tree */
+    for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
+    n = 0;
+    while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
+    while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
+    while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
+    while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
+    /* Codes 286 and 287 do not exist, but we must include them in the
+     * tree construction to get a canonical Huffman tree (longest code
+     * all ones)
+     */
+    gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
+
+    /* The static distance tree is trivial: */
+    for (n = 0; n < D_CODES; n++) {
+        static_dtree[n].Len = 5;
+        static_dtree[n].Code = bi_reverse((unsigned)n, 5);
+    }
+    static_init_done = 1;
+
+#  ifdef GEN_TREES_H
+    gen_trees_header();
+#  endif
+#endif /* defined(GEN_TREES_H) || !defined(STDC) */
+}
+
+/* ===========================================================================
+ * Genererate the file trees.h describing the static trees.
+ */
+#ifdef GEN_TREES_H
+#  ifndef DEBUG
+#    include <stdio.h>
+#  endif
+
+#  define SEPARATOR(i, last, width) \
+      ((i) == (last)? "\n};\n\n" :    \
+       ((i) % (width) == (width)-1 ? ",\n" : ", "))
+
+void gen_trees_header()
+{
+    FILE *header = fopen("trees.h", "w");
+    int i;
+
+    Assert (header != NULL, "Can't open trees.h");
+    fprintf(header,
+            "/* header created automatically with -DGEN_TREES_H */\n\n");
+
+    fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
+    for (i = 0; i < L_CODES+2; i++) {
+        fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
+                static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
+    }
+
+    fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+        fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
+                static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
+    }
+
+    fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n");
+    for (i = 0; i < DIST_CODE_LEN; i++) {
+        fprintf(header, "%2u%s", _dist_code[i],
+                SEPARATOR(i, DIST_CODE_LEN-1, 20));
+    }
+
+    fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
+    for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
+        fprintf(header, "%2u%s", _length_code[i],
+                SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
+    }
+
+    fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
+    for (i = 0; i < LENGTH_CODES; i++) {
+        fprintf(header, "%1u%s", base_length[i],
+                SEPARATOR(i, LENGTH_CODES-1, 20));
+    }
+
+    fprintf(header, "local const int base_dist[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+        fprintf(header, "%5u%s", base_dist[i],
+                SEPARATOR(i, D_CODES-1, 10));
+    }
+
+    fclose(header);
+}
+#endif /* GEN_TREES_H */
+
+/* ===========================================================================
+ * Initialize the tree data structures for a new zlib stream.
+ */
+void _tr_init(s)
+    deflate_state *s;
+{
+    tr_static_init();
+
+    s->l_desc.dyn_tree = s->dyn_ltree;
+    s->l_desc.stat_desc = &static_l_desc;
+
+    s->d_desc.dyn_tree = s->dyn_dtree;
+    s->d_desc.stat_desc = &static_d_desc;
+
+    s->bl_desc.dyn_tree = s->bl_tree;
+    s->bl_desc.stat_desc = &static_bl_desc;
+
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+    s->last_eob_len = 8; /* enough lookahead for inflate */
+#ifdef DEBUG
+    s->compressed_len = 0L;
+    s->bits_sent = 0L;
+#endif
+
+    /* Initialize the first block of the first file: */
+    init_block(s);
+}
+
+/* ===========================================================================
+ * Initialize a new block.
+ */
+local void init_block(s)
+    deflate_state *s;
+{
+    int n; /* iterates over tree elements */
+
+    /* Initialize the trees. */
+    for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;
+    for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;
+    for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
+
+    s->dyn_ltree[END_BLOCK].Freq = 1;
+    s->opt_len = s->static_len = 0L;
+    s->last_lit = s->matches = 0;
+}
+
+#define SMALLEST 1
+/* Index within the heap array of least frequent node in the Huffman tree */
+
+
+/* ===========================================================================
+ * Remove the smallest element from the heap and recreate the heap with
+ * one less element. Updates heap and heap_len.
+ */
+#define pqremove(s, tree, top) \
+{\
+    top = s->heap[SMALLEST]; \
+    s->heap[SMALLEST] = s->heap[s->heap_len--]; \
+    pqdownheap(s, tree, SMALLEST); \
+}
+
+/* ===========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+#define smaller(tree, n, m, depth) \
+   (tree[n].Freq < tree[m].Freq || \
+   (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
+/* ===========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+local void pqdownheap(s, tree, k)
+    deflate_state *s;
+    ct_data *tree;  /* the tree to restore */
+    int k;               /* node to move down */
+{
+    int v = s->heap[k];
+    int j = k << 1;  /* left son of k */
+    while (j <= s->heap_len) {
+        /* Set j to the smallest of the two sons: */
+        if (j < s->heap_len &&
+            smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
+            j++;
+        }
+        /* Exit if v is smaller than both sons */
+        if (smaller(tree, v, s->heap[j], s->depth)) break;
+
+        /* Exchange v with the smallest son */
+        s->heap[k] = s->heap[j];  k = j;
+
+        /* And continue down the tree, setting j to the left son of k */
+        j <<= 1;
+    }
+    s->heap[k] = v;
+}
+
+/* ===========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ *    above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ *     array bl_count contains the frequencies for each bit length.
+ *     The length opt_len is updated; static_len is also updated if stree is
+ *     not null.
+ */
+local void gen_bitlen(s, desc)
+    deflate_state *s;
+    tree_desc *desc;    /* the tree descriptor */
+{
+    ct_data *tree        = desc->dyn_tree;
+    int max_code         = desc->max_code;
+    const ct_data *stree = desc->stat_desc->static_tree;
+    const intf *extra    = desc->stat_desc->extra_bits;
+    int base             = desc->stat_desc->extra_base;
+    int max_length       = desc->stat_desc->max_length;
+    int h;              /* heap index */
+    int n, m;           /* iterate over the tree elements */
+    int bits;           /* bit length */
+    int xbits;          /* extra bits */
+    ush f;              /* frequency */
+    int overflow = 0;   /* number of elements with bit length too large */
+
+    for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
+
+    /* In a first pass, compute the optimal bit lengths (which may
+     * overflow in the case of the bit length tree).
+     */
+    tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
+
+    for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
+        n = s->heap[h];
+        bits = tree[tree[n].Dad].Len + 1;
+        if (bits > max_length) bits = max_length, overflow++;
+        tree[n].Len = (ush)bits;
+        /* We overwrite tree[n].Dad which is no longer needed */
+
+        if (n > max_code) continue; /* not a leaf node */
+
+        s->bl_count[bits]++;
+        xbits = 0;
+        if (n >= base) xbits = extra[n-base];
+        f = tree[n].Freq;
+        s->opt_len += (ulg)f * (bits + xbits);
+        if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
+    }
+    if (overflow == 0) return;
+
+    Trace((stderr,"\nbit length overflow\n"));
+    /* This happens for example on obj2 and pic of the Calgary corpus */
+
+    /* Find the first bit length which could increase: */
+    do {
+        bits = max_length-1;
+        while (s->bl_count[bits] == 0) bits--;
+        s->bl_count[bits]--;      /* move one leaf down the tree */
+        s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
+        s->bl_count[max_length]--;
+        /* The brother of the overflow item also moves one step up,
+         * but this does not affect bl_count[max_length]
+         */
+        overflow -= 2;
+    } while (overflow > 0);
+
+    /* Now recompute all bit lengths, scanning in increasing frequency.
+     * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+     * lengths instead of fixing only the wrong ones. This idea is taken
+     * from 'ar' written by Haruhiko Okumura.)
+     */
+    for (bits = max_length; bits != 0; bits--) {
+        n = s->bl_count[bits];
+        while (n != 0) {
+            m = s->heap[--h];
+            if (m > max_code) continue;
+            if ((unsigned) tree[m].Len != (unsigned) bits) {
+                Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+                s->opt_len += ((long)bits - (long)tree[m].Len)
+                              *(long)tree[m].Freq;
+                tree[m].Len = (ush)bits;
+            }
+            n--;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Generate the codes for a given tree and bit counts (which need not be
+ * optimal).
+ * IN assertion: the array bl_count contains the bit length statistics for
+ * the given tree and the field len is set for all tree elements.
+ * OUT assertion: the field code is set for all tree elements of non
+ *     zero code length.
+ */
+local void gen_codes (tree, max_code, bl_count)
+    ct_data *tree;             /* the tree to decorate */
+    int max_code;              /* largest code with non zero frequency */
+    ushf *bl_count;            /* number of codes at each bit length */
+{
+    ush next_code[MAX_BITS+1]; /* next code value for each bit length */
+    ush code = 0;              /* running code value */
+    int bits;                  /* bit index */
+    int n;                     /* code index */
+
+    /* The distribution counts are first used to generate the code values
+     * without bit reversal.
+     */
+    for (bits = 1; bits <= MAX_BITS; bits++) {
+        next_code[bits] = code = (code + bl_count[bits-1]) << 1;
+    }
+    /* Check that the bit counts in bl_count are consistent. The last code
+     * must be all ones.
+     */
+    Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+            "inconsistent bit counts");
+    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+    for (n = 0;  n <= max_code; n++) {
+        int len = tree[n].Len;
+        if (len == 0) continue;
+        /* Now reverse the bits */
+        tree[n].Code = bi_reverse(next_code[len]++, len);
+
+        Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
+             n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
+    }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ *     and corresponding code. The length opt_len is updated; static_len is
+ *     also updated if stree is not null. The field max_code is set.
+ */
+local void build_tree(s, desc)
+    deflate_state *s;
+    tree_desc *desc; /* the tree descriptor */
+{
+    ct_data *tree         = desc->dyn_tree;
+    const ct_data *stree  = desc->stat_desc->static_tree;
+    int elems             = desc->stat_desc->elems;
+    int n, m;          /* iterate over heap elements */
+    int max_code = -1; /* largest code with non zero frequency */
+    int node;          /* new node being created */
+
+    /* Construct the initial heap, with least frequent element in
+     * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+     * heap[0] is not used.
+     */
+    s->heap_len = 0, s->heap_max = HEAP_SIZE;
+
+    for (n = 0; n < elems; n++) {
+        if (tree[n].Freq != 0) {
+            s->heap[++(s->heap_len)] = max_code = n;
+            s->depth[n] = 0;
+        } else {
+            tree[n].Len = 0;
+        }
+    }
+
+    /* The pkzip format requires that at least one distance code exists,
+     * and that at least one bit should be sent even if there is only one
+     * possible code. So to avoid special checks later on we force at least
+     * two codes of non zero frequency.
+     */
+    while (s->heap_len < 2) {
+        node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
+        tree[node].Freq = 1;
+        s->depth[node] = 0;
+        s->opt_len--; if (stree) s->static_len -= stree[node].Len;
+        /* node is 0 or 1 so it does not have extra bits */
+    }
+    desc->max_code = max_code;
+
+    /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+     * establish sub-heaps of increasing lengths:
+     */
+    for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
+
+    /* Construct the Huffman tree by repeatedly combining the least two
+     * frequent nodes.
+     */
+    node = elems;              /* next internal node of the tree */
+    do {
+        pqremove(s, tree, n);  /* n = node of least frequency */
+        m = s->heap[SMALLEST]; /* m = node of next least frequency */
+
+        s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
+        s->heap[--(s->heap_max)] = m;
+
+        /* Create a new node father of n and m */
+        tree[node].Freq = tree[n].Freq + tree[m].Freq;
+        s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
+                                s->depth[n] : s->depth[m]) + 1);
+        tree[n].Dad = tree[m].Dad = (ush)node;
+#ifdef DUMP_BL_TREE
+        if (tree == s->bl_tree) {
+            fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
+                    node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
+        }
+#endif
+        /* and insert the new node in the heap */
+        s->heap[SMALLEST] = node++;
+        pqdownheap(s, tree, SMALLEST);
+
+    } while (s->heap_len >= 2);
+
+    s->heap[--(s->heap_max)] = s->heap[SMALLEST];
+
+    /* At this point, the fields freq and dad are set. We can now
+     * generate the bit lengths.
+     */
+    gen_bitlen(s, (tree_desc *)desc);
+
+    /* The field len is now set, we can generate the bit codes */
+    gen_codes ((ct_data *)tree, max_code, s->bl_count);
+}
+
+/* ===========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree.
+ */
+local void scan_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree;   /* the tree to be scanned */
+    int max_code;    /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    if (nextlen == 0) max_count = 138, min_count = 3;
+    tree[max_code+1].Len = (ush)0xffff; /* guard */
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            s->bl_tree[curlen].Freq += count;
+        } else if (curlen != 0) {
+            if (curlen != prevlen) s->bl_tree[curlen].Freq++;
+            s->bl_tree[REP_3_6].Freq++;
+        } else if (count <= 10) {
+            s->bl_tree[REPZ_3_10].Freq++;
+        } else {
+            s->bl_tree[REPZ_11_138].Freq++;
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Send a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+local void send_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree; /* the tree to be scanned */
+    int max_code;       /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    /* tree[max_code+1].Len = -1; */  /* guard already set */
+    if (nextlen == 0) max_count = 138, min_count = 3;
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
+
+        } else if (curlen != 0) {
+            if (curlen != prevlen) {
+                send_code(s, curlen, s->bl_tree); count--;
+            }
+            Assert(count >= 3 && count <= 6, " 3_6?");
+            send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
+
+        } else if (count <= 10) {
+            send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
+
+        } else {
+            send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+local int build_bl_tree(s)
+    deflate_state *s;
+{
+    int max_blindex;  /* index of last bit length code of non zero freq */
+
+    /* Determine the bit length frequencies for literal and distance trees */
+    scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
+    scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
+
+    /* Build the bit length tree: */
+    build_tree(s, (tree_desc *)(&(s->bl_desc)));
+    /* opt_len now includes the length of the tree representations, except
+     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+     */
+
+    /* Determine the number of bit length codes to send. The pkzip format
+     * requires that at least 4 bit length codes be sent. (appnote.txt says
+     * 3 but the actual value used is 4.)
+     */
+    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
+        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
+    }
+    /* Update opt_len to include the bit length tree and counts */
+    s->opt_len += 3*(max_blindex+1) + 5+5+4;
+    Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+            s->opt_len, s->static_len));
+
+    return max_blindex;
+}
+
+/* ===========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+local void send_all_trees(s, lcodes, dcodes, blcodes)
+    deflate_state *s;
+    int lcodes, dcodes, blcodes; /* number of codes for each tree */
+{
+    int rank;                    /* index in bl_order */
+
+    Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+    Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+            "too many codes");
+    Tracev((stderr, "\nbl counts: "));
+    send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
+    send_bits(s, dcodes-1,   5);
+    send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
+    for (rank = 0; rank < blcodes; rank++) {
+        Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+        send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
+    }
+    Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
+    Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
+    Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
+}
+
+/* ===========================================================================
+ * Send a stored block
+ */
+void _tr_stored_block(s, buf, stored_len, eof)
+    deflate_state *s;
+    charf *buf;       /* input block */
+    ulg stored_len;   /* length of input block */
+    int eof;          /* true if this is the last block for a file */
+{
+    send_bits(s, (STORED_BLOCK<<1)+eof, 3);  /* send block type */
+#ifdef DEBUG
+    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+    s->compressed_len += (stored_len + 4) << 3;
+#endif
+    copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
+}
+
+/* ===========================================================================
+ * Send one empty static block to give enough lookahead for inflate.
+ * This takes 10 bits, of which 7 may remain in the bit buffer.
+ * The current inflate code requires 9 bits of lookahead. If the
+ * last two codes for the previous block (real code plus EOB) were coded
+ * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
+ * the last real code. In this case we send two empty static blocks instead
+ * of one. (There are no problems if the previous block is stored or fixed.)
+ * To simplify the code, we assume the worst case of last real code encoded
+ * on one bit only.
+ */
+void _tr_align(s)
+    deflate_state *s;
+{
+    send_bits(s, STATIC_TREES<<1, 3);
+    send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
+    bi_flush(s);
+    /* Of the 10 bits for the empty block, we have already sent
+     * (10 - bi_valid) bits. The lookahead for the last real code (before
+     * the EOB of the previous block) was thus at least one plus the length
+     * of the EOB plus what we have just sent of the empty static block.
+     */
+    if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
+        send_bits(s, STATIC_TREES<<1, 3);
+        send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+        s->compressed_len += 10L;
+#endif
+        bi_flush(s);
+    }
+    s->last_eob_len = 7;
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and output the encoded block to the zip file.
+ */
+void _tr_flush_block(s, buf, stored_len, eof)
+    deflate_state *s;
+    charf *buf;       /* input block, or NULL if too old */
+    ulg stored_len;   /* length of input block */
+    int eof;          /* true if this is the last block for a file */
+{
+    ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
+    int max_blindex = 0;  /* index of last bit length code of non zero freq */
+
+    /* Build the Huffman trees unless a stored block is forced */
+    if (s->level > 0) {
+
+        /* Check if the file is binary or text */
+        if (stored_len > 0 && s->strm->data_type == Z_UNKNOWN)
+            set_data_type(s);
+
+        /* Construct the literal and distance trees */
+        build_tree(s, (tree_desc *)(&(s->l_desc)));
+        Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));
+
+        build_tree(s, (tree_desc *)(&(s->d_desc)));
+        Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));
+        /* At this point, opt_len and static_len are the total bit lengths of
+         * the compressed block data, excluding the tree representations.
+         */
+
+        /* Build the bit length tree for the above two trees, and get the index
+         * in bl_order of the last bit length code to send.
+         */
+        max_blindex = build_bl_tree(s);
+
+        /* Determine the best encoding. Compute the block lengths in bytes. */
+        opt_lenb = (s->opt_len+3+7)>>3;
+        static_lenb = (s->static_len+3+7)>>3;
+
+        Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+                opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
+                s->last_lit));
+
+        if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+
+    } else {
+        Assert(buf != (char*)0, "lost buf");
+        opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
+    }
+
+#ifdef FORCE_STORED
+    if (buf != (char*)0) { /* force stored block */
+#else
+    if (stored_len+4 <= opt_lenb && buf != (char*)0) {
+                       /* 4: two words for the lengths */
+#endif
+        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+         * Otherwise we can't have processed more than WSIZE input bytes since
+         * the last block flush, because compression would have been
+         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+         * transform a block into a stored block.
+         */
+        _tr_stored_block(s, buf, stored_len, eof);
+
+#ifdef FORCE_STATIC
+    } else if (static_lenb >= 0) { /* force static trees */
+#else
+    } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
+#endif
+        send_bits(s, (STATIC_TREES<<1)+eof, 3);
+        compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
+#ifdef DEBUG
+        s->compressed_len += 3 + s->static_len;
+#endif
+    } else {
+        send_bits(s, (DYN_TREES<<1)+eof, 3);
+        send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
+                       max_blindex+1);
+        compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
+#ifdef DEBUG
+        s->compressed_len += 3 + s->opt_len;
+#endif
+    }
+    Assert (s->compressed_len == s->bits_sent, "bad compressed size");
+    /* The above check is made mod 2^32, for files larger than 512 MB
+     * and uLong implemented on 32 bits.
+     */
+    init_block(s);
+
+    if (eof) {
+        bi_windup(s);
+#ifdef DEBUG
+        s->compressed_len += 7;  /* align on byte boundary */
+#endif
+    }
+    Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
+           s->compressed_len-7*eof));
+}
+
+/* ===========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+int _tr_tally (s, dist, lc)
+    deflate_state *s;
+    unsigned dist;  /* distance of matched string */
+    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
+{
+    s->d_buf[s->last_lit] = (ush)dist;
+    s->l_buf[s->last_lit++] = (uch)lc;
+    if (dist == 0) {
+        /* lc is the unmatched char */
+        s->dyn_ltree[lc].Freq++;
+    } else {
+        s->matches++;
+        /* Here, lc is the match length - MIN_MATCH */
+        dist--;             /* dist = match distance - 1 */
+        Assert((ush)dist < (ush)MAX_DIST(s) &&
+               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
+
+        s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
+        s->dyn_dtree[d_code(dist)].Freq++;
+    }
+
+#ifdef TRUNCATE_BLOCK
+    /* Try to guess if it is profitable to stop the current block here */
+    if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
+        /* Compute an upper bound for the compressed length */
+        ulg out_length = (ulg)s->last_lit*8L;
+        ulg in_length = (ulg)((long)s->strstart - s->block_start);
+        int dcode;
+        for (dcode = 0; dcode < D_CODES; dcode++) {
+            out_length += (ulg)s->dyn_dtree[dcode].Freq *
+                (5L+extra_dbits[dcode]);
+        }
+        out_length >>= 3;
+        Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
+               s->last_lit, in_length, out_length,
+               100L - out_length*100L/in_length));
+        if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
+    }
+#endif
+    return (s->last_lit == s->lit_bufsize-1);
+    /* We avoid equality with lit_bufsize because of wraparound at 64K
+     * on 16 bit machines and because stored blocks are restricted to
+     * 64K-1 bytes.
+     */
+}
+
+/* ===========================================================================
+ * Send the block data compressed using the given Huffman trees
+ */
+local void compress_block(s, ltree, dtree)
+    deflate_state *s;
+    ct_data *ltree; /* literal tree */
+    ct_data *dtree; /* distance tree */
+{
+    unsigned dist;      /* distance of matched string */
+    int lc;             /* match length or unmatched char (if dist == 0) */
+    unsigned lx = 0;    /* running index in l_buf */
+    unsigned code;      /* the code to send */
+    int extra;          /* number of extra bits to send */
+
+    if (s->last_lit != 0) do {
+        dist = s->d_buf[lx];
+        lc = s->l_buf[lx++];
+        if (dist == 0) {
+            send_code(s, lc, ltree); /* send a literal byte */
+            Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+        } else {
+            /* Here, lc is the match length - MIN_MATCH */
+            code = _length_code[lc];
+            send_code(s, code+LITERALS+1, ltree); /* send the length code */
+            extra = extra_lbits[code];
+            if (extra != 0) {
+                lc -= base_length[code];
+                send_bits(s, lc, extra);       /* send the extra length bits */
+            }
+            dist--; /* dist is now the match distance - 1 */
+            code = d_code(dist);
+            Assert (code < D_CODES, "bad d_code");
+
+            send_code(s, code, dtree);       /* send the distance code */
+            extra = extra_dbits[code];
+            if (extra != 0) {
+                dist -= base_dist[code];
+                send_bits(s, dist, extra);   /* send the extra distance bits */
+            }
+        } /* literal or match pair ? */
+
+        /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
+        Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
+               "pendingBuf overflow");
+
+    } while (lx < s->last_lit);
+
+    send_code(s, END_BLOCK, ltree);
+    s->last_eob_len = ltree[END_BLOCK].Len;
+}
+
+/* ===========================================================================
+ * Set the data type to BINARY or TEXT, using a crude approximation:
+ * set it to Z_TEXT if all symbols are either printable characters (33 to 255)
+ * or white spaces (9 to 13, or 32); or set it to Z_BINARY otherwise.
+ * IN assertion: the fields Freq of dyn_ltree are set.
+ */
+local void set_data_type(s)
+    deflate_state *s;
+{
+    int n;
+
+    for (n = 0; n < 9; n++)
+        if (s->dyn_ltree[n].Freq != 0)
+            break;
+    if (n == 9)
+        for (n = 14; n < 32; n++)
+            if (s->dyn_ltree[n].Freq != 0)
+                break;
+    s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;
+}
+
+/* ===========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+local unsigned bi_reverse(code, len)
+    unsigned code; /* the value to invert */
+    int len;       /* its bit length */
+{
+    register unsigned res = 0;
+    do {
+        res |= code & 1;
+        code >>= 1, res <<= 1;
+    } while (--len > 0);
+    return res >> 1;
+}
+
+/* ===========================================================================
+ * Flush the bit buffer, keeping at most 7 bits in it.
+ */
+local void bi_flush(s)
+    deflate_state *s;
+{
+    if (s->bi_valid == 16) {
+        put_short(s, s->bi_buf);
+        s->bi_buf = 0;
+        s->bi_valid = 0;
+    } else if (s->bi_valid >= 8) {
+        put_byte(s, (Byte)s->bi_buf);
+        s->bi_buf >>= 8;
+        s->bi_valid -= 8;
+    }
+}
+
+/* ===========================================================================
+ * Flush the bit buffer and align the output on a byte boundary
+ */
+local void bi_windup(s)
+    deflate_state *s;
+{
+    if (s->bi_valid > 8) {
+        put_short(s, s->bi_buf);
+    } else if (s->bi_valid > 0) {
+        put_byte(s, (Byte)s->bi_buf);
+    }
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+#ifdef DEBUG
+    s->bits_sent = (s->bits_sent+7) & ~7;
+#endif
+}
+
+/* ===========================================================================
+ * Copy a stored block, storing first the length and its
+ * one's complement if requested.
+ */
+local void copy_block(s, buf, len, header)
+    deflate_state *s;
+    charf    *buf;    /* the input data */
+    unsigned len;     /* its length */
+    int      header;  /* true if block header must be written */
+{
+    bi_windup(s);        /* align on byte boundary */
+    s->last_eob_len = 8; /* enough lookahead for inflate */
+
+    if (header) {
+        put_short(s, (ush)len);
+        put_short(s, (ush)~len);
+#ifdef DEBUG
+        s->bits_sent += 2*16;
+#endif
+    }
+#ifdef DEBUG
+    s->bits_sent += (ulg)len<<3;
+#endif
+    while (len--) {
+        put_byte(s, *buf++);
+    }
+}
diff --git a/src/reader/zlib/trees.h b/src/reader/zlib/trees.h
new file mode 100644
index 00000000..72facf90
--- /dev/null
+++ b/src/reader/zlib/trees.h
@@ -0,0 +1,128 @@
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
+{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
+{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
+{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
+{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
+{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
+{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
+{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
+{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
+{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
+{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
+{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
+{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
+{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
+{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
+{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
+{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
+{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
+{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
+{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
+{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
+{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
+{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
+{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
+{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
+{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
+{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
+{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
+{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
+{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
+{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
+{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
+{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
+{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
+{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
+{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
+{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
+{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
+{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
+{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
+{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
+{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
+{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
+{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
+{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
+{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
+{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
+{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
+{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
+{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
+{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
+{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
+{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
+{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
+{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
+{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
+{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
+{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch _dist_code[DIST_CODE_LEN] = {
+ 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+ 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+
diff --git a/src/reader/zlib/unzip.c b/src/reader/zlib/unzip.c
new file mode 100644
index 00000000..1e05038b
--- /dev/null
+++ b/src/reader/zlib/unzip.c
@@ -0,0 +1,1605 @@
+/* unzip.c -- IO for uncompress .zip files using zlib
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   Read unzip.h for more info
+*/
+
+/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
+compatibility with older software. The following is from the original crypt.c. Code
+woven in by Terry Thorsen 1/2003.
+*/
+/*
+  Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
+
+  See the accompanying file LICENSE, version 2000-Apr-09 or later
+  (the contents of which are also included in zip.h) for terms of use.
+  If, for some reason, all these files are missing, the Info-ZIP license
+  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
+*/
+/*
+  crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
+
+  The encryption/decryption parts of this source code (as opposed to the
+  non-echoing password parts) were originally written in Europe.  The
+  whole source package can be freely distributed, including from the USA.
+  (Prior to January 2000, re-export from the US was a violation of US law.)
+ */
+
+/*
+  This encryption code is a direct transcription of the algorithm from
+  Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
+  file (appnote.txt) is distributed with the PKZIP program (even in the
+  version without encryption capabilities).
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "zlib.h"
+#include "unzip.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+
+#ifndef CASESENSITIVITYDEFAULT_NO
+#  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
+#    define CASESENSITIVITYDEFAULT_NO
+#  endif
+#endif
+
+
+#ifndef UNZ_BUFSIZE
+#define UNZ_BUFSIZE (16384)
+#endif
+
+#ifndef UNZ_MAXFILENAMEINZIP
+#define UNZ_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+
+
+
+
+const char unz_copyright[] =
+   " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+/* unz_file_info_interntal contain internal info about a file in zipfile*/
+typedef struct unz_file_info_internal_s
+{
+    uLong offset_curfile;/* relative offset of local header 4 bytes */
+} unz_file_info_internal;
+
+
+/* file_in_zip_read_info_s contain internal information about a file in zipfile,
+    when reading and decompress it */
+typedef struct
+{
+    char  *read_buffer;         /* internal buffer for compressed data */
+    z_stream stream;            /* zLib stream structure for inflate */
+
+    uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
+    uLong stream_initialised;   /* flag set if stream structure is initialised*/
+
+    uLong offset_local_extrafield;/* offset of the local extra field */
+    uInt  size_local_extrafield;/* size of the local extra field */
+    uLong pos_local_extrafield;   /* position in the local extra field in read*/
+
+    uLong crc32;                /* crc32 of all data uncompressed */
+    uLong crc32_wait;           /* crc32 we must obtain after decompress all */
+    uLong rest_read_compressed; /* number of byte to be decompressed */
+    uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
+    zlib_filefunc_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    uLong compression_method;   /* compression method (0==store) */
+    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+    int   raw;
+} file_in_zip_read_info_s;
+
+
+/* unz_s contain internal information about the zipfile
+*/
+typedef struct
+{
+    zlib_filefunc_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    unz_global_info gi;       /* public global information */
+    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+    uLong num_file;             /* number of the current file in the zipfile*/
+    uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
+    uLong current_file_ok;      /* flag about the usability of the current file*/
+    uLong central_pos;          /* position of the beginning of the central dir*/
+
+    uLong size_central_dir;     /* size of the central directory  */
+    uLong offset_central_dir;   /* offset of start of central directory with
+                                   respect to the starting disk number */
+
+    unz_file_info cur_file_info; /* public info about the current file in zip*/
+    unz_file_info_internal cur_file_info_internal; /* private info about it*/
+    file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
+                                        file if we are decompressing it */
+    int encrypted;
+#    ifndef NOUNCRYPT
+    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
+    const unsigned long* pcrc_32_tab;
+#    endif
+} unz_s;
+
+
+#ifndef NOUNCRYPT
+#include "crypt.h"
+#endif
+
+/* ===========================================================================
+     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+   for end of file.
+   IN assertion: the stream s has been sucessfully opened for reading.
+*/
+
+
+local int unzlocal_getByte OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    int *pi));
+
+local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    int *pi;
+{
+    unsigned char c;
+    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
+    if (err==1)
+    {
+        *pi = (int)c;
+        return UNZ_OK;
+    }
+    else
+    {
+        if (ZERROR(*pzlib_filefunc_def,filestream))
+            return UNZ_ERRNO;
+        else
+            return UNZ_EOF;
+    }
+}
+
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int unzlocal_getShort OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x ;
+    int i = 0;
+    int err;
+
+    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==UNZ_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int unzlocal_getLong OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x ;
+    int i = 0;
+    int err;
+
+    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<16;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<24;
+
+    if (err==UNZ_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+
+/* My own strcmpi / strcasecmp */
+local int strcmpcasenosensitive_internal (fileName1,fileName2)
+    const char* fileName1;
+    const char* fileName2;
+{
+    for (;;)
+    {
+        char c1=*(fileName1++);
+        char c2=*(fileName2++);
+        if ((c1>='a') && (c1<='z'))
+            c1 -= 0x20;
+        if ((c2>='a') && (c2<='z'))
+            c2 -= 0x20;
+        if (c1=='\0')
+            return ((c2=='\0') ? 0 : -1);
+        if (c2=='\0')
+            return 1;
+        if (c1<c2)
+            return -1;
+        if (c1>c2)
+            return 1;
+    }
+}
+
+
+#ifdef  CASESENSITIVITYDEFAULT_NO
+#define CASESENSITIVITYDEFAULTVALUE 2
+#else
+#define CASESENSITIVITYDEFAULTVALUE 1
+#endif
+
+#ifndef STRCMPCASENOSENTIVEFUNCTION
+#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
+#endif
+
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+        (like 1 on Unix, 2 on Windows)
+
+*/
+extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
+    const char* fileName1;
+    const char* fileName2;
+    int iCaseSensitivity;
+{
+    if (iCaseSensitivity==0)
+        iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
+
+    if (iCaseSensitivity==1)
+        return strcmp(fileName1,fileName2);
+
+    return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+local uLong unzlocal_SearchCentralDir OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream));
+
+local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+{
+    unsigned char* buf;
+    uLong uSizeFile;
+    uLong uBackRead;
+    uLong uMaxBack=0xffff; /* maximum size of global comment */
+    uLong uPosFound=0;
+
+    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+        return 0;
+
+
+    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
+
+    if (uMaxBack>uSizeFile)
+        uMaxBack = uSizeFile;
+
+    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+    if (buf==NULL)
+        return 0;
+
+    uBackRead = 4;
+    while (uBackRead<uMaxBack)
+    {
+        uLong uReadSize,uReadPos ;
+        int i;
+        if (uBackRead+BUFREADCOMMENT>uMaxBack)
+            uBackRead = uMaxBack;
+        else
+            uBackRead+=BUFREADCOMMENT;
+        uReadPos = uSizeFile-uBackRead ;
+
+        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
+        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            break;
+
+        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+            break;
+
+        for (i=(int)uReadSize-3; (i--)>0;)
+            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+            {
+                uPosFound = uReadPos+i;
+                break;
+            }
+
+        if (uPosFound!=0)
+            break;
+    }
+    TRYFREE(buf);
+    return uPosFound;
+}
+
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
+     "zlib/zlib114.zip".
+     If the zipfile cannot be opened (file doesn't exist or in not valid), the
+       return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+       of this unzip package.
+*/
+extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
+    const char *path;
+    zlib_filefunc_def* pzlib_filefunc_def;
+{
+    unz_s us;
+    unz_s *s;
+    uLong central_pos,uL;
+
+    uLong number_disk;          /* number of the current dist, used for
+                                   spaning ZIP, unsupported, always 0*/
+    uLong number_disk_with_CD;  /* number the the disk with central dir, used
+                                   for spaning ZIP, unsupported, always 0*/
+    uLong number_entry_CD;      /* total number of entries in
+                                   the central dir
+                                   (same than number_entry on nospan) */
+
+    int err=UNZ_OK;
+
+    if (unz_copyright[0]!=' ')
+        return NULL;
+
+    if (pzlib_filefunc_def==NULL)
+        fill_fopen_filefunc(&us.z_filefunc);
+    else
+        us.z_filefunc = *pzlib_filefunc_def;
+
+    us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
+                                                 path,
+                                                 ZLIB_FILEFUNC_MODE_READ |
+                                                 ZLIB_FILEFUNC_MODE_EXISTING);
+    if (us.filestream==NULL)
+        return NULL;
+
+    central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
+    if (central_pos==0)
+        err=UNZ_ERRNO;
+
+    if (ZSEEK(us.z_filefunc, us.filestream,
+                                      central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        err=UNZ_ERRNO;
+
+    /* the signature, already checked */
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* number of this disk */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* number of the disk with the start of the central directory */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* total number of entries in the central dir on this disk */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* total number of entries in the central dir */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if ((number_entry_CD!=us.gi.number_entry) ||
+        (number_disk_with_CD!=0) ||
+        (number_disk!=0))
+        err=UNZ_BADZIPFILE;
+
+    /* size of the central directory */
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* offset of start of central directory with respect to the
+          starting disk number */
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* zipfile comment length */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
+        (err==UNZ_OK))
+        err=UNZ_BADZIPFILE;
+
+    if (err!=UNZ_OK)
+    {
+        ZCLOSE(us.z_filefunc, us.filestream);
+        return NULL;
+    }
+
+    us.byte_before_the_zipfile = central_pos -
+                            (us.offset_central_dir+us.size_central_dir);
+    us.central_pos = central_pos;
+    us.pfile_in_zip_read = NULL;
+    us.encrypted = 0;
+
+
+    s=(unz_s*)ALLOC(sizeof(unz_s));
+    *s=us;
+    unzGoToFirstFile((unzFile)s);
+    return (unzFile)s;
+}
+
+
+extern unzFile ZEXPORT unzOpen (path)
+    const char *path;
+{
+    return unzOpen2(path, NULL);
+}
+
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzClose (file)
+    unzFile file;
+{
+    unz_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    if (s->pfile_in_zip_read!=NULL)
+        unzCloseCurrentFile(file);
+
+    ZCLOSE(s->z_filefunc, s->filestream);
+    TRYFREE(s);
+    return UNZ_OK;
+}
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
+    unzFile file;
+    unz_global_info *pglobal_info;
+{
+    unz_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    *pglobal_info=s->gi;
+    return UNZ_OK;
+}
+
+
+/*
+   Translate date/time from Dos format to tm_unz (readable more easilty)
+*/
+local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
+    uLong ulDosDate;
+    tm_unz* ptm;
+{
+    uLong uDate;
+    uDate = (uLong)(ulDosDate>>16);
+    ptm->tm_mday = (uInt)(uDate&0x1f) ;
+    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
+    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
+
+    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
+    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
+    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
+}
+
+/*
+  Get Info about the current file in the zipfile, with internal only info
+*/
+local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
+                                                  unz_file_info *pfile_info,
+                                                  unz_file_info_internal
+                                                  *pfile_info_internal,
+                                                  char *szFileName,
+                                                  uLong fileNameBufferSize,
+                                                  void *extraField,
+                                                  uLong extraFieldBufferSize,
+                                                  char *szComment,
+                                                  uLong commentBufferSize));
+
+local int unzlocal_GetCurrentFileInfoInternal (file,
+                                              pfile_info,
+                                              pfile_info_internal,
+                                              szFileName, fileNameBufferSize,
+                                              extraField, extraFieldBufferSize,
+                                              szComment,  commentBufferSize)
+    unzFile file;
+    unz_file_info *pfile_info;
+    unz_file_info_internal *pfile_info_internal;
+    char *szFileName;
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
+{
+    unz_s* s;
+    unz_file_info file_info;
+    unz_file_info_internal file_info_internal;
+    int err=UNZ_OK;
+    uLong uMagic;
+    long lSeek=0;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (ZSEEK(s->z_filefunc, s->filestream,
+              s->pos_in_central_dir+s->byte_before_the_zipfile,
+              ZLIB_FILEFUNC_SEEK_SET)!=0)
+        err=UNZ_ERRNO;
+
+
+    /* we check the magic */
+    if (err==UNZ_OK)
+    {
+        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+            err=UNZ_ERRNO;
+        else if (uMagic!=0x02014b50)
+            err=UNZ_BADZIPFILE;
+    }
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    lSeek+=file_info.size_filename;
+    if ((err==UNZ_OK) && (szFileName!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_filename<fileNameBufferSize)
+        {
+            *(szFileName+file_info.size_filename)='\0';
+            uSizeRead = file_info.size_filename;
+        }
+        else
+            uSizeRead = fileNameBufferSize;
+
+        if ((file_info.size_filename>0) && (fileNameBufferSize>0))
+            if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek -= uSizeRead;
+    }
+
+
+    if ((err==UNZ_OK) && (extraField!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_file_extra<extraFieldBufferSize)
+            uSizeRead = file_info.size_file_extra;
+        else
+            uSizeRead = extraFieldBufferSize;
+
+        if (lSeek!=0)
+        {
+            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+                lSeek=0;
+            else
+                err=UNZ_ERRNO;
+        }
+        if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
+            if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek += file_info.size_file_extra - uSizeRead;
+    }
+    else
+        lSeek+=file_info.size_file_extra;
+
+
+    if ((err==UNZ_OK) && (szComment!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_file_comment<commentBufferSize)
+        {
+            *(szComment+file_info.size_file_comment)='\0';
+            uSizeRead = file_info.size_file_comment;
+        }
+        else
+            uSizeRead = commentBufferSize;
+
+        if (lSeek!=0)
+        {
+            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+                lSeek=0;
+            else
+                err=UNZ_ERRNO;
+        }
+        if ((file_info.size_file_comment>0) && (commentBufferSize>0))
+            if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek+=file_info.size_file_comment - uSizeRead;
+    }
+    else
+        lSeek+=file_info.size_file_comment;
+
+    if ((err==UNZ_OK) && (pfile_info!=NULL))
+        *pfile_info=file_info;
+
+    if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
+        *pfile_info_internal=file_info_internal;
+
+    return err;
+}
+
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem.
+*/
+extern int ZEXPORT unzGetCurrentFileInfo (file,
+                                          pfile_info,
+                                          szFileName, fileNameBufferSize,
+                                          extraField, extraFieldBufferSize,
+                                          szComment,  commentBufferSize)
+    unzFile file;
+    unz_file_info *pfile_info;
+    char *szFileName;
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
+{
+    return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
+                                                szFileName,fileNameBufferSize,
+                                                extraField,extraFieldBufferSize,
+                                                szComment,commentBufferSize);
+}
+
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+extern int ZEXPORT unzGoToFirstFile (file)
+    unzFile file;
+{
+    int err=UNZ_OK;
+    unz_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    s->pos_in_central_dir=s->offset_central_dir;
+    s->num_file=0;
+    err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                             &s->cur_file_info_internal,
+                                             NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+extern int ZEXPORT unzGoToNextFile (file)
+    unzFile file;
+{
+    unz_s* s;
+    int err;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+    if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
+      if (s->num_file+1==s->gi.number_entry)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+            s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
+    s->num_file++;
+    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                               &s->cur_file_info_internal,
+                                               NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzipStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
+    unzFile file;
+    const char *szFileName;
+    int iCaseSensitivity;
+{
+    unz_s* s;
+    int err;
+
+    /* We remember the 'current' position in the file so that we can jump
+     * back there if we fail.
+     */
+    unz_file_info cur_file_infoSaved;
+    unz_file_info_internal cur_file_info_internalSaved;
+    uLong num_fileSaved;
+    uLong pos_in_central_dirSaved;
+
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+
+    if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
+        return UNZ_PARAMERROR;
+
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    /* Save the current state */
+    num_fileSaved = s->num_file;
+    pos_in_central_dirSaved = s->pos_in_central_dir;
+    cur_file_infoSaved = s->cur_file_info;
+    cur_file_info_internalSaved = s->cur_file_info_internal;
+
+    err = unzGoToFirstFile(file);
+
+    while (err == UNZ_OK)
+    {
+        char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
+        err = unzGetCurrentFileInfo(file,NULL,
+                                    szCurrentFileName,sizeof(szCurrentFileName)-1,
+                                    NULL,0,NULL,0);
+        if (err == UNZ_OK)
+        {
+            if (unzStringFileNameCompare(szCurrentFileName,
+                                            szFileName,iCaseSensitivity)==0)
+                return UNZ_OK;
+            err = unzGoToNextFile(file);
+        }
+    }
+
+    /* We failed, so restore the state of the 'current file' to where we
+     * were.
+     */
+    s->num_file = num_fileSaved ;
+    s->pos_in_central_dir = pos_in_central_dirSaved ;
+    s->cur_file_info = cur_file_infoSaved;
+    s->cur_file_info_internal = cur_file_info_internalSaved;
+    return err;
+}
+
+
+/*
+///////////////////////////////////////////
+// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
+// I need random access
+//
+// Further optimization could be realized by adding an ability
+// to cache the directory in memory. The goal being a single
+// comprehensive file read to put the file I need in a memory.
+*/
+
+/*
+typedef struct unz_file_pos_s
+{
+    uLong pos_in_zip_directory;   // offset in file
+    uLong num_of_file;            // # of file
+} unz_file_pos;
+*/
+
+extern int ZEXPORT unzGetFilePos(file, file_pos)
+    unzFile file;
+    unz_file_pos* file_pos;
+{
+    unz_s* s;
+
+    if (file==NULL || file_pos==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
+    file_pos->num_of_file           = s->num_file;
+
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzGoToFilePos(file, file_pos)
+    unzFile file;
+    unz_file_pos* file_pos;
+{
+    unz_s* s;
+    int err;
+
+    if (file==NULL || file_pos==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    /* jump to the right spot */
+    s->pos_in_central_dir = file_pos->pos_in_zip_directory;
+    s->num_file           = file_pos->num_of_file;
+
+    /* set the current file */
+    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                               &s->cur_file_info_internal,
+                                               NULL,0,NULL,0,NULL,0);
+    /* return results */
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+/*
+// Unzip Helper Functions - should be here?
+///////////////////////////////////////////
+*/
+
+/*
+  Read the local header of the current zipfile
+  Check the coherency of the local header and info in the end of central
+        directory about this file
+  store in *piSizeVar the size of extra info in local header
+        (filename and size of extra field data)
+*/
+local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
+                                                    poffset_local_extrafield,
+                                                    psize_local_extrafield)
+    unz_s* s;
+    uInt* piSizeVar;
+    uLong *poffset_local_extrafield;
+    uInt  *psize_local_extrafield;
+{
+    uLong uMagic,uData,uFlags;
+    uLong size_filename;
+    uLong size_extra_field;
+    int err=UNZ_OK;
+
+    *piSizeVar = 0;
+    *poffset_local_extrafield = 0;
+    *psize_local_extrafield = 0;
+
+    if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
+                                s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+
+    if (err==UNZ_OK)
+    {
+        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+            err=UNZ_ERRNO;
+        else if (uMagic!=0x04034b50)
+            err=UNZ_BADZIPFILE;
+    }
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+        err=UNZ_ERRNO;
+/*
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
+        err=UNZ_BADZIPFILE;
+*/
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
+        err=UNZ_BADZIPFILE;
+
+    if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
+                         (s->cur_file_info.compression_method!=Z_DEFLATED))
+        err=UNZ_BADZIPFILE;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
+                              ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
+                              ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
+                              ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
+        err=UNZ_BADZIPFILE;
+
+    *piSizeVar += (uInt)size_filename;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
+        err=UNZ_ERRNO;
+    *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
+                                    SIZEZIPLOCALHEADER + size_filename;
+    *psize_local_extrafield = (uInt)size_extra_field;
+
+    *piSizeVar += (uInt)size_extra_field;
+
+    return err;
+}
+
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error and the file is opened, the return value is UNZ_OK.
+*/
+extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
+    unzFile file;
+    int* method;
+    int* level;
+    int raw;
+    const char* password;
+{
+    int err=UNZ_OK;
+    uInt iSizeVar;
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    uLong offset_local_extrafield;  /* offset of the local extra field */
+    uInt  size_local_extrafield;    /* size of the local extra field */
+#    ifndef NOUNCRYPT
+    char source[12];
+#    else
+    if (password != NULL)
+        return UNZ_PARAMERROR;
+#    endif
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_PARAMERROR;
+
+    if (s->pfile_in_zip_read != NULL)
+        unzCloseCurrentFile(file);
+
+    if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
+                &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
+        return UNZ_BADZIPFILE;
+
+    pfile_in_zip_read_info = (file_in_zip_read_info_s*)
+                                        ALLOC(sizeof(file_in_zip_read_info_s));
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_INTERNALERROR;
+
+    pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
+    pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
+    pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
+    pfile_in_zip_read_info->pos_local_extrafield=0;
+    pfile_in_zip_read_info->raw=raw;
+
+    if (pfile_in_zip_read_info->read_buffer==NULL)
+    {
+        TRYFREE(pfile_in_zip_read_info);
+        return UNZ_INTERNALERROR;
+    }
+
+    pfile_in_zip_read_info->stream_initialised=0;
+
+    if (method!=NULL)
+        *method = (int)s->cur_file_info.compression_method;
+
+    if (level!=NULL)
+    {
+        *level = 6;
+        switch (s->cur_file_info.flag & 0x06)
+        {
+          case 6 : *level = 1; break;
+          case 4 : *level = 2; break;
+          case 2 : *level = 9; break;
+        }
+    }
+
+    if ((s->cur_file_info.compression_method!=0) &&
+        (s->cur_file_info.compression_method!=Z_DEFLATED))
+        err=UNZ_BADZIPFILE;
+
+    pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
+    pfile_in_zip_read_info->crc32=0;
+    pfile_in_zip_read_info->compression_method =
+            s->cur_file_info.compression_method;
+    pfile_in_zip_read_info->filestream=s->filestream;
+    pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
+    pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
+
+    pfile_in_zip_read_info->stream.total_out = 0;
+
+    if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
+        (!raw))
+    {
+      pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+      pfile_in_zip_read_info->stream.zfree = (free_func)0;
+      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
+      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
+      pfile_in_zip_read_info->stream.avail_in = 0;
+
+      err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
+      if (err == Z_OK)
+        pfile_in_zip_read_info->stream_initialised=1;
+      else
+      {
+        TRYFREE(pfile_in_zip_read_info);
+        return err;
+      }
+        /* windowBits is passed < 0 to tell that there is no zlib header.
+         * Note that in this case inflate *requires* an extra "dummy" byte
+         * after the compressed stream in order to complete decompression and
+         * return Z_STREAM_END.
+         * In unzip, i don't wait absolutely Z_STREAM_END because I known the
+         * size of both compressed and uncompressed data
+         */
+    }
+    pfile_in_zip_read_info->rest_read_compressed =
+            s->cur_file_info.compressed_size ;
+    pfile_in_zip_read_info->rest_read_uncompressed =
+            s->cur_file_info.uncompressed_size ;
+
+
+    pfile_in_zip_read_info->pos_in_zipfile =
+            s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
+              iSizeVar;
+
+    pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+
+    s->pfile_in_zip_read = pfile_in_zip_read_info;
+
+#    ifndef NOUNCRYPT
+    if (password != NULL)
+    {
+        int i;
+        s->pcrc_32_tab = get_crc_table();
+        init_keys(password,s->keys,s->pcrc_32_tab);
+        if (ZSEEK(s->z_filefunc, s->filestream,
+                  s->pfile_in_zip_read->pos_in_zipfile +
+                     s->pfile_in_zip_read->byte_before_the_zipfile,
+                  SEEK_SET)!=0)
+            return UNZ_INTERNALERROR;
+        if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
+            return UNZ_INTERNALERROR;
+
+        for (i = 0; i<12; i++)
+            zdecode(s->keys,s->pcrc_32_tab,source[i]);
+
+        s->pfile_in_zip_read->pos_in_zipfile+=12;
+        s->encrypted=1;
+    }
+#    endif
+
+
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzOpenCurrentFile (file)
+    unzFile file;
+{
+    return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
+}
+
+extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
+    unzFile file;
+    const char* password;
+{
+    return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
+}
+
+extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
+    unzFile file;
+    int* method;
+    int* level;
+    int raw;
+{
+    return unzOpenCurrentFile3(file, method, level, raw, NULL);
+}
+
+/*
+  Read bytes from the current file.
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
+    unzFile file;
+    voidp buf;
+    unsigned len;
+{
+    int err=UNZ_OK;
+    uInt iRead = 0;
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+
+    if ((pfile_in_zip_read_info->read_buffer == NULL))
+        return UNZ_END_OF_LIST_OF_FILE;
+    if (len==0)
+        return 0;
+
+    pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
+
+    pfile_in_zip_read_info->stream.avail_out = (uInt)len;
+
+    if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
+        (!(pfile_in_zip_read_info->raw)))
+        pfile_in_zip_read_info->stream.avail_out =
+            (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
+
+    if ((len>pfile_in_zip_read_info->rest_read_compressed+
+           pfile_in_zip_read_info->stream.avail_in) &&
+         (pfile_in_zip_read_info->raw))
+        pfile_in_zip_read_info->stream.avail_out =
+            (uInt)pfile_in_zip_read_info->rest_read_compressed+
+            pfile_in_zip_read_info->stream.avail_in;
+
+    while (pfile_in_zip_read_info->stream.avail_out>0)
+    {
+        if ((pfile_in_zip_read_info->stream.avail_in==0) &&
+            (pfile_in_zip_read_info->rest_read_compressed>0))
+        {
+            uInt uReadThis = UNZ_BUFSIZE;
+            if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
+                uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
+            if (uReadThis == 0)
+                return UNZ_EOF;
+            if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->pos_in_zipfile +
+                         pfile_in_zip_read_info->byte_before_the_zipfile,
+                         ZLIB_FILEFUNC_SEEK_SET)!=0)
+                return UNZ_ERRNO;
+            if (ZREAD(pfile_in_zip_read_info->z_filefunc,
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->read_buffer,
+                      uReadThis)!=uReadThis)
+                return UNZ_ERRNO;
+
+
+#            ifndef NOUNCRYPT
+            if(s->encrypted)
+            {
+                uInt i;
+                for(i=0;i<uReadThis;i++)
+                  pfile_in_zip_read_info->read_buffer[i] =
+                      zdecode(s->keys,s->pcrc_32_tab,
+                              pfile_in_zip_read_info->read_buffer[i]);
+            }
+#            endif
+
+
+            pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
+
+            pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
+
+            pfile_in_zip_read_info->stream.next_in =
+                (Bytef*)pfile_in_zip_read_info->read_buffer;
+            pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+        }
+
+        if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
+        {
+            uInt uDoCopy,i ;
+
+            if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
+                (pfile_in_zip_read_info->rest_read_compressed == 0))
+                return (iRead==0) ? UNZ_EOF : iRead;
+
+            if (pfile_in_zip_read_info->stream.avail_out <
+                            pfile_in_zip_read_info->stream.avail_in)
+                uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+            else
+                uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+
+            for (i=0;i<uDoCopy;i++)
+                *(pfile_in_zip_read_info->stream.next_out+i) =
+                        *(pfile_in_zip_read_info->stream.next_in+i);
+
+            pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
+                                pfile_in_zip_read_info->stream.next_out,
+                                uDoCopy);
+            pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
+            pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
+            pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
+            pfile_in_zip_read_info->stream.next_out += uDoCopy;
+            pfile_in_zip_read_info->stream.next_in += uDoCopy;
+            pfile_in_zip_read_info->stream.total_out += uDoCopy;
+            iRead += uDoCopy;
+        }
+        else
+        {
+            uLong uTotalOutBefore,uTotalOutAfter;
+            const Bytef *bufBefore;
+            uLong uOutThis;
+            int flush=Z_SYNC_FLUSH;
+
+            uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
+            bufBefore = pfile_in_zip_read_info->stream.next_out;
+
+            /*
+            if ((pfile_in_zip_read_info->rest_read_uncompressed ==
+                     pfile_in_zip_read_info->stream.avail_out) &&
+                (pfile_in_zip_read_info->rest_read_compressed == 0))
+                flush = Z_FINISH;
+            */
+            err=inflate(&pfile_in_zip_read_info->stream,flush);
+
+            if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
+              err = Z_DATA_ERROR;
+
+            uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
+            uOutThis = uTotalOutAfter-uTotalOutBefore;
+
+            pfile_in_zip_read_info->crc32 =
+                crc32(pfile_in_zip_read_info->crc32,bufBefore,
+                        (uInt)(uOutThis));
+
+            pfile_in_zip_read_info->rest_read_uncompressed -=
+                uOutThis;
+
+            iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+
+            if (err==Z_STREAM_END)
+                return (iRead==0) ? UNZ_EOF : iRead;
+            if (err!=Z_OK)
+                break;
+        }
+    }
+
+    if (err==Z_OK)
+        return iRead;
+    return err;
+}
+
+
+/*
+  Give the current position in uncompressed data
+*/
+extern z_off_t ZEXPORT unztell (file)
+    unzFile file;
+{
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    return (z_off_t)pfile_in_zip_read_info->stream.total_out;
+}
+
+
+/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+extern int ZEXPORT unzeof (file)
+    unzFile file;
+{
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+        return 1;
+    else
+        return 0;
+}
+
+
+
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field that can be read
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+    buf.
+  the return value is the number of bytes copied in buf, or (if <0)
+    the error code
+*/
+extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
+    unzFile file;
+    voidp buf;
+    unsigned len;
+{
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    uInt read_now;
+    uLong size_to_read;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
+                pfile_in_zip_read_info->pos_local_extrafield);
+
+    if (buf==NULL)
+        return (int)size_to_read;
+
+    if (len>size_to_read)
+        read_now = (uInt)size_to_read;
+    else
+        read_now = (uInt)len ;
+
+    if (read_now==0)
+        return 0;
+
+    if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
+              pfile_in_zip_read_info->filestream,
+              pfile_in_zip_read_info->offset_local_extrafield +
+              pfile_in_zip_read_info->pos_local_extrafield,
+              ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+    if (ZREAD(pfile_in_zip_read_info->z_filefunc,
+              pfile_in_zip_read_info->filestream,
+              buf,read_now)!=read_now)
+        return UNZ_ERRNO;
+
+    return (int)read_now;
+}
+
+/*
+  Close the file in zip opened with unzipOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+extern int ZEXPORT unzCloseCurrentFile (file)
+    unzFile file;
+{
+    int err=UNZ_OK;
+
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+
+    if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
+        (!pfile_in_zip_read_info->raw))
+    {
+        if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
+            err=UNZ_CRCERROR;
+    }
+
+
+    TRYFREE(pfile_in_zip_read_info->read_buffer);
+    pfile_in_zip_read_info->read_buffer = NULL;
+    if (pfile_in_zip_read_info->stream_initialised)
+        inflateEnd(&pfile_in_zip_read_info->stream);
+
+    pfile_in_zip_read_info->stream_initialised = 0;
+    TRYFREE(pfile_in_zip_read_info);
+
+    s->pfile_in_zip_read=NULL;
+
+    return err;
+}
+
+
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
+    unzFile file;
+    char *szComment;
+    uLong uSizeBuf;
+{
+    unz_s* s;
+    uLong uReadThis ;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    uReadThis = uSizeBuf;
+    if (uReadThis>s->gi.size_comment)
+        uReadThis = s->gi.size_comment;
+
+    if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+    if (uReadThis>0)
+    {
+      *szComment='\0';
+      if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
+        return UNZ_ERRNO;
+    }
+
+    if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
+        *(szComment+s->gi.size_comment)='\0';
+    return (int)uReadThis;
+}
+
+/* Additions by RX '2004 */
+extern uLong ZEXPORT unzGetOffset (file)
+    unzFile file;
+{
+    unz_s* s;
+
+    if (file==NULL)
+          return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+      return 0;
+    if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
+      if (s->num_file==s->gi.number_entry)
+         return 0;
+    return s->pos_in_central_dir;
+}
+
+extern int ZEXPORT unzSetOffset (file, pos)
+        unzFile file;
+        uLong pos;
+{
+    unz_s* s;
+    int err;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    s->pos_in_central_dir = pos;
+    s->num_file = s->gi.number_entry;      /* hack */
+    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                              &s->cur_file_info_internal,
+                                              NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
diff --git a/src/reader/zlib/unzip.h b/src/reader/zlib/unzip.h
new file mode 100644
index 00000000..b247937c
--- /dev/null
+++ b/src/reader/zlib/unzip.h
@@ -0,0 +1,354 @@
+/* unzip.h -- IO for uncompress .zip files using zlib
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
+     WinZip, InfoZip tools and compatible.
+
+   Multi volume ZipFile (span) are not supported.
+   Encryption compatible with pkzip 2.04g only supported
+   Old compressions used by old PKZip 1.x are not supported
+
+
+   I WAIT FEEDBACK at mail info@winimage.com
+   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+
+*/
+
+/* for more info about .ZIP format, see
+      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
+      http://www.info-zip.org/pub/infozip/doc/
+   PkWare has also a specification at :
+      ftp://ftp.pkware.com/probdesc.zip
+*/
+
+#ifndef _unz_H
+#define _unz_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagunzFile__ { int unused; } unzFile__;
+typedef unzFile__ *unzFile;
+#else
+typedef voidp unzFile;
+#endif
+
+
+#define UNZ_OK                          (0)
+#define UNZ_END_OF_LIST_OF_FILE         (-100)
+#define UNZ_ERRNO                       (Z_ERRNO)
+#define UNZ_EOF                         (0)
+#define UNZ_PARAMERROR                  (-102)
+#define UNZ_BADZIPFILE                  (-103)
+#define UNZ_INTERNALERROR               (-104)
+#define UNZ_CRCERROR                    (-105)
+
+/* tm_unz contain date/time info */
+typedef struct tm_unz_s
+{
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
+    uInt tm_hour;           /* hours since midnight - [0,23] */
+    uInt tm_mday;           /* day of the month - [1,31] */
+    uInt tm_mon;            /* months since January - [0,11] */
+    uInt tm_year;           /* years - [1980..2044] */
+} tm_unz;
+
+/* unz_global_info structure contain global data about the ZIPfile
+   These data comes from the end of central dir */
+typedef struct unz_global_info_s
+{
+    uLong number_entry;         /* total number of entries in
+                       the central dir on this disk */
+    uLong size_comment;         /* size of the global comment of the zipfile */
+} unz_global_info;
+
+
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info_s
+{
+    uLong version;              /* version made by                 2 bytes */
+    uLong version_needed;       /* version needed to extract       2 bytes */
+    uLong flag;                 /* general purpose bit flag        2 bytes */
+    uLong compression_method;   /* compression method              2 bytes */
+    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
+    uLong crc;                  /* crc-32                          4 bytes */
+    uLong compressed_size;      /* compressed size                 4 bytes */
+    uLong uncompressed_size;    /* uncompressed size               4 bytes */
+    uLong size_filename;        /* filename length                 2 bytes */
+    uLong size_file_extra;      /* extra field length              2 bytes */
+    uLong size_file_comment;    /* file comment length             2 bytes */
+
+    uLong disk_num_start;       /* disk number start               2 bytes */
+    uLong internal_fa;          /* internal file attributes        2 bytes */
+    uLong external_fa;          /* external file attributes        4 bytes */
+
+    tm_unz tmu_date;
+} unz_file_info;
+
+extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
+                                                 const char* fileName2,
+                                                 int iCaseSensitivity));
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+    (like 1 on Unix, 2 on Windows)
+*/
+
+
+extern unzFile ZEXPORT unzOpen OF((const char *path));
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
+     "zlib/zlib113.zip".
+     If the zipfile cannot be opened (file don't exist or in not valid), the
+       return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+       of this unzip package.
+*/
+
+extern unzFile ZEXPORT unzOpen2 OF((const char *path,
+                                    zlib_filefunc_def* pzlib_filefunc_def));
+/*
+   Open a Zip file, like unzOpen, but provide a set of file low level API
+      for read/write the zip file (see ioapi.h)
+*/
+
+extern int ZEXPORT unzClose OF((unzFile file));
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+
+extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
+                                        unz_global_info *pglobal_info));
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+
+
+extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
+                                           char *szComment,
+                                           uLong uSizeBuf));
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+
+
+/***************************************************************************/
+/* Unzip package allow you browse the directory of the zipfile */
+
+extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+
+extern int ZEXPORT unzGoToNextFile OF((unzFile file));
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+
+extern int ZEXPORT unzLocateFile OF((unzFile file,
+                     const char *szFileName,
+                     int iCaseSensitivity));
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+
+/* ****************************************** */
+/* Ryan supplied functions */
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_pos_s
+{
+    uLong pos_in_zip_directory;   /* offset in zip file directory */
+    uLong num_of_file;            /* # of file */
+} unz_file_pos;
+
+extern int ZEXPORT unzGetFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+extern int ZEXPORT unzGoToFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+/* ****************************************** */
+
+extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
+                         unz_file_info *pfile_info,
+                         char *szFileName,
+                         uLong fileNameBufferSize,
+                         void *extraField,
+                         uLong extraFieldBufferSize,
+                         char *szComment,
+                         uLong commentBufferSize));
+/*
+  Get Info about the current file
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+        the current file
+  if szFileName!=NULL, the filemane string will be copied in szFileName
+            (fileNameBufferSize is the size of the buffer)
+  if extraField!=NULL, the extra field information will be copied in extraField
+            (extraFieldBufferSize is the size of the buffer).
+            This is the Central-header version of the extra field
+  if szComment!=NULL, the comment string of the file will be copied in szComment
+            (commentBufferSize is the size of the buffer)
+*/
+
+/***************************************************************************/
+/* for reading the content of the current zipfile, you can open it, read data
+   from it, and close it (you can close it before reading all the file)
+   */
+
+extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
+                                                  const char* password));
+/*
+  Open for reading data the current file in the zipfile.
+  password is a crypting password
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw));
+/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw,
+                                           const char* password));
+/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+
+extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
+/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
+                      voidp buf,
+                      unsigned len));
+/*
+  Read bytes from the current file (opened by unzOpenCurrentFile)
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+extern z_off_t ZEXPORT unztell OF((unzFile file));
+/*
+  Give the current position in uncompressed data
+*/
+
+extern int ZEXPORT unzeof OF((unzFile file));
+/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+
+extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
+                                             voidp buf,
+                                             unsigned len));
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+    buf.
+  the return value is the number of bytes copied in buf, or (if <0)
+    the error code
+*/
+
+/***************************************************************************/
+
+/* Get the current file offset */
+extern uLong ZEXPORT unzGetOffset (unzFile file);
+
+/* Set the current file offset */
+extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _unz_H */
diff --git a/src/reader/zlib/zconf.h b/src/reader/zlib/zconf.h
new file mode 100644
index 00000000..eb5a9ce2
--- /dev/null
+++ b/src/reader/zlib/zconf.h
@@ -0,0 +1,332 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: zconf.h,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_          z_deflateInit_
+#  define deflate               z_deflate
+#  define deflateEnd            z_deflateEnd
+#  define inflateInit_          z_inflateInit_
+#  define inflate               z_inflate
+#  define inflateEnd            z_inflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateCopy           z_deflateCopy
+#  define deflateReset          z_deflateReset
+#  define deflateParams         z_deflateParams
+#  define deflateBound          z_deflateBound
+#  define deflatePrime          z_deflatePrime
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateCopy           z_inflateCopy
+#  define inflateReset          z_inflateReset
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define compress              z_compress
+#  define compress2             z_compress2
+#  define compressBound         z_compressBound
+#  define uncompress            z_uncompress
+#  define adler32               z_adler32
+#  define crc32                 z_crc32
+#  define get_crc_table         z_get_crc_table
+#  define zError                z_zError
+
+#  define alloc_func            z_alloc_func
+#  define free_func             z_free_func
+#  define in_func               z_in_func
+#  define out_func              z_out_func
+#  define Byte                  z_Byte
+#  define uInt                  z_uInt
+#  define uLong                 z_uLong
+#  define Bytef                 z_Bytef
+#  define charf                 z_charf
+#  define intf                  z_intf
+#  define uIntf                 z_uIntf
+#  define uLongf                z_uLongf
+#  define voidpf                z_voidpf
+#  define voidp                 z_voidp
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if 0           /* HAVE_UNISTD_H -- this line is updated by ./configure */
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  ifdef VMS
+#    include <unixio.h>   /* for off_t */
+#  endif
+#  define z_off_t off_t
+#endif
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if defined(__OS400__)
+#  define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+#  define NO_vsnprintf
+#  ifdef FAR
+#    undef FAR
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(deflateBound,"DEBND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(compressBound,"CMBND")
+#   pragma map(inflate_table,"INTABL")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/src/reader/zlib/zip.c b/src/reader/zlib/zip.c
new file mode 100644
index 00000000..2dc74dfc
--- /dev/null
+++ b/src/reader/zlib/zip.c
@@ -0,0 +1,1220 @@
+/* zip.c -- IO on .zip files using zlib
+   Version 1.01e, February 12th, 2005
+
+   27 Dec 2004 Rolf Kalbermatter
+   Modification to zipOpen2 to support globalComment retrieval.
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   Read zip.h for more info
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "zlib.h"
+#include "zip.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+#ifndef VERSIONMADEBY
+# define VERSIONMADEBY   (0x0) /* platform depedent */
+#endif
+
+#ifndef Z_BUFSIZE
+#define Z_BUFSIZE (16384)
+#endif
+
+#ifndef Z_MAXFILENAMEINZIP
+#define Z_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+/*
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+*/
+
+/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
+
+#ifndef SEEK_CUR
+#define SEEK_CUR    1
+#endif
+
+#ifndef SEEK_END
+#define SEEK_END    2
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET    0
+#endif
+
+#ifndef DEF_MEM_LEVEL
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+#endif
+const char zip_copyright[] =
+   " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+
+#define SIZEDATA_INDATABLOCK (4096-(4*4))
+
+#define LOCALHEADERMAGIC    (0x04034b50)
+#define CENTRALHEADERMAGIC  (0x02014b50)
+#define ENDHEADERMAGIC      (0x06054b50)
+
+#define FLAG_LOCALHEADER_OFFSET (0x06)
+#define CRC_LOCALHEADER_OFFSET  (0x0e)
+
+#define SIZECENTRALHEADER (0x2e) /* 46 */
+
+typedef struct linkedlist_datablock_internal_s
+{
+  struct linkedlist_datablock_internal_s* next_datablock;
+  uLong  avail_in_this_block;
+  uLong  filled_in_this_block;
+  uLong  unused; /* for future use and alignement */
+  unsigned char data[SIZEDATA_INDATABLOCK];
+} linkedlist_datablock_internal;
+
+typedef struct linkedlist_data_s
+{
+    linkedlist_datablock_internal* first_block;
+    linkedlist_datablock_internal* last_block;
+} linkedlist_data;
+
+
+typedef struct
+{
+    z_stream stream;            /* zLib stream structure for inflate */
+    int  stream_initialised;    /* 1 is stream is initialised */
+    uInt pos_in_buffered_data;  /* last written byte in buffered_data */
+
+    uLong pos_local_header;     /* offset of the local header of the file
+                                     currenty writing */
+    char* central_header;       /* central header data for the current file */
+    uLong size_centralheader;   /* size of the central header for cur file */
+    uLong flag;                 /* flag of the file currently writing */
+
+    int  method;                /* compression method of file currenty wr.*/
+    int  raw;                   /* 1 for directly writing raw data */
+    Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
+    uLong dosDate;
+    uLong crc32;
+    int  encrypt;
+#ifndef NOCRYPT
+    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
+    const unsigned long* pcrc_32_tab;
+    int crypt_header_size;
+#endif
+} curfile_info;
+
+typedef struct
+{
+    zlib_filefunc_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    linkedlist_data central_dir;/* datablock with central dir in construction*/
+    int  in_opened_file_inzip;  /* 1 if a file in the zip is currently writ.*/
+    curfile_info ci;            /* info on the file curretly writing */
+
+    uLong begin_pos;            /* position of the beginning of the zipfile */
+    uLong add_position_when_writting_offset;
+    uLong number_entry;
+#ifndef NO_ADDFILEINEXISTINGZIP
+    char *globalcomment;
+#endif
+} zip_internal;
+
+
+
+#ifndef NOCRYPT
+#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+#include "crypt.h"
+#endif
+
+local linkedlist_datablock_internal* allocate_new_datablock()
+{
+    linkedlist_datablock_internal* ldi;
+    ldi = (linkedlist_datablock_internal*)
+                 ALLOC(sizeof(linkedlist_datablock_internal));
+    if (ldi!=NULL)
+    {
+        ldi->next_datablock = NULL ;
+        ldi->filled_in_this_block = 0 ;
+        ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
+    }
+    return ldi;
+}
+
+local void free_datablock(ldi)
+    linkedlist_datablock_internal* ldi;
+{
+    while (ldi!=NULL)
+    {
+        linkedlist_datablock_internal* ldinext = ldi->next_datablock;
+        TRYFREE(ldi);
+        ldi = ldinext;
+    }
+}
+
+local void init_linkedlist(ll)
+    linkedlist_data* ll;
+{
+    ll->first_block = ll->last_block = NULL;
+}
+
+/*
+local void free_linkedlist(ll)
+    linkedlist_data* ll;
+{
+    free_datablock(ll->first_block);
+    ll->first_block = ll->last_block = NULL;
+}
+*/
+
+local int add_data_in_datablock(ll,buf,len)
+    linkedlist_data* ll;
+    const void* buf;
+    uLong len;
+{
+    linkedlist_datablock_internal* ldi;
+    const unsigned char* from_copy;
+
+    if (ll==NULL)
+        return ZIP_INTERNALERROR;
+
+    if (ll->last_block == NULL)
+    {
+        ll->first_block = ll->last_block = allocate_new_datablock();
+        if (ll->first_block == NULL)
+            return ZIP_INTERNALERROR;
+    }
+
+    ldi = ll->last_block;
+    from_copy = (unsigned char*)buf;
+
+    while (len>0)
+    {
+        uInt copy_this;
+        uInt i;
+        unsigned char* to_copy;
+
+        if (ldi->avail_in_this_block==0)
+        {
+            ldi->next_datablock = allocate_new_datablock();
+            if (ldi->next_datablock == NULL)
+                return ZIP_INTERNALERROR;
+            ldi = ldi->next_datablock ;
+            ll->last_block = ldi;
+        }
+
+        if (ldi->avail_in_this_block < len)
+            copy_this = (uInt)ldi->avail_in_this_block;
+        else
+            copy_this = (uInt)len;
+
+        to_copy = &(ldi->data[ldi->filled_in_this_block]);
+
+        for (i=0;i<copy_this;i++)
+            *(to_copy+i)=*(from_copy+i);
+
+        ldi->filled_in_this_block += copy_this;
+        ldi->avail_in_this_block -= copy_this;
+        from_copy += copy_this ;
+        len -= copy_this;
+    }
+    return ZIP_OK;
+}
+
+
+
+/****************************************************************************/
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+/* ===========================================================================
+   Inputs a long in LSB order to the given file
+   nbByte == 1, 2 or 4 (byte, short or long)
+*/
+
+local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
+                                voidpf filestream, uLong x, int nbByte));
+local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong x;
+    int nbByte;
+{
+    unsigned char buf[4];
+    int n;
+    for (n = 0; n < nbByte; n++)
+    {
+        buf[n] = (unsigned char)(x & 0xff);
+        x >>= 8;
+    }
+    if (x != 0)
+      {     /* data overflow - hack for ZIP64 (X Roche) */
+      for (n = 0; n < nbByte; n++)
+        {
+          buf[n] = 0xff;
+        }
+      }
+
+    if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
+        return ZIP_ERRNO;
+    else
+        return ZIP_OK;
+}
+
+local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
+local void ziplocal_putValue_inmemory (dest, x, nbByte)
+    void* dest;
+    uLong x;
+    int nbByte;
+{
+    unsigned char* buf=(unsigned char*)dest;
+    int n;
+    for (n = 0; n < nbByte; n++) {
+        buf[n] = (unsigned char)(x & 0xff);
+        x >>= 8;
+    }
+
+    if (x != 0)
+    {     /* data overflow - hack for ZIP64 */
+       for (n = 0; n < nbByte; n++)
+       {
+          buf[n] = 0xff;
+       }
+    }
+}
+
+/****************************************************************************/
+
+
+local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
+    const tm_zip* ptm;
+    uLong dosDate;
+{
+    uLong year = (uLong)ptm->tm_year;
+    if (year>1980)
+        year-=1980;
+    else if (year>80)
+        year-=80;
+    return
+      (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
+        ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
+}
+
+
+/****************************************************************************/
+
+local int ziplocal_getByte OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    int *pi));
+
+local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    int *pi;
+{
+    unsigned char c;
+    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
+    if (err==1)
+    {
+        *pi = (int)c;
+        return ZIP_OK;
+    }
+    else
+    {
+        if (ZERROR(*pzlib_filefunc_def,filestream))
+            return ZIP_ERRNO;
+        else
+            return ZIP_EOF;
+    }
+}
+
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int ziplocal_getShort OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x;
+    int i = 0;
+    int err;
+
+    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==ZIP_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int ziplocal_getLong OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x = 0;
+    int i = 0;
+    int err;
+
+    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<16;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<24;
+
+    if (err==ZIP_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+local uLong ziplocal_SearchCentralDir OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream));
+
+local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+{
+    unsigned char* buf;
+    uLong uSizeFile;
+    uLong uBackRead;
+    uLong uMaxBack=0xffff; /* maximum size of global comment */
+    uLong uPosFound=0;
+
+    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+        return 0;
+
+
+    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
+
+    if (uMaxBack>uSizeFile)
+        uMaxBack = uSizeFile;
+
+    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+    if (buf==NULL)
+        return 0;
+
+    uBackRead = 4;
+    while (uBackRead<uMaxBack)
+    {
+        uLong uReadSize,uReadPos ;
+        int i;
+        if (uBackRead+BUFREADCOMMENT>uMaxBack)
+            uBackRead = uMaxBack;
+        else
+            uBackRead+=BUFREADCOMMENT;
+        uReadPos = uSizeFile-uBackRead ;
+
+        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
+        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            break;
+
+        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+            break;
+
+        for (i=(int)uReadSize-3; (i--)>0;)
+            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+            {
+                uPosFound = uReadPos+i;
+                break;
+            }
+
+        if (uPosFound!=0)
+            break;
+    }
+    TRYFREE(buf);
+    return uPosFound;
+}
+#endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+/************************************************************/
+extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
+    const char *pathname;
+    int append;
+    zipcharpc* globalcomment;
+    zlib_filefunc_def* pzlib_filefunc_def;
+{
+    zip_internal ziinit;
+    zip_internal* zi;
+    int err=ZIP_OK;
+
+
+    if (pzlib_filefunc_def==NULL)
+        fill_fopen_filefunc(&ziinit.z_filefunc);
+    else
+        ziinit.z_filefunc = *pzlib_filefunc_def;
+
+    ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
+                 (ziinit.z_filefunc.opaque,
+                  pathname,
+                  (append == APPEND_STATUS_CREATE) ?
+                  (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
+                    (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
+
+    if (ziinit.filestream == NULL)
+        return NULL;
+    ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
+    ziinit.in_opened_file_inzip = 0;
+    ziinit.ci.stream_initialised = 0;
+    ziinit.number_entry = 0;
+    ziinit.add_position_when_writting_offset = 0;
+    init_linkedlist(&(ziinit.central_dir));
+
+
+    zi = (zip_internal*)ALLOC(sizeof(zip_internal));
+    if (zi==NULL)
+    {
+        ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
+        return NULL;
+    }
+
+    /* now we add file in a zipfile */
+#    ifndef NO_ADDFILEINEXISTINGZIP
+    ziinit.globalcomment = NULL;
+    if (append == APPEND_STATUS_ADDINZIP)
+    {
+        uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+
+        uLong size_central_dir;     /* size of the central directory  */
+        uLong offset_central_dir;   /* offset of start of central directory */
+        uLong central_pos,uL;
+
+        uLong number_disk;          /* number of the current dist, used for
+                                    spaning ZIP, unsupported, always 0*/
+        uLong number_disk_with_CD;  /* number the the disk with central dir, used
+                                    for spaning ZIP, unsupported, always 0*/
+        uLong number_entry;
+        uLong number_entry_CD;      /* total number of entries in
+                                    the central dir
+                                    (same than number_entry on nospan) */
+        uLong size_comment;
+
+        central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
+        if (central_pos==0)
+            err=ZIP_ERRNO;
+
+        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
+                                        central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err=ZIP_ERRNO;
+
+        /* the signature, already checked */
+        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* number of this disk */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* number of the disk with the start of the central directory */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* total number of entries in the central dir on this disk */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* total number of entries in the central dir */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        if ((number_entry_CD!=number_entry) ||
+            (number_disk_with_CD!=0) ||
+            (number_disk!=0))
+            err=ZIP_BADZIPFILE;
+
+        /* size of the central directory */
+        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* offset of start of central directory with respect to the
+            starting disk number */
+        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* zipfile global comment length */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        if ((central_pos<offset_central_dir+size_central_dir) &&
+            (err==ZIP_OK))
+            err=ZIP_BADZIPFILE;
+
+        if (err!=ZIP_OK)
+        {
+            ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
+            return NULL;
+        }
+
+        if (size_comment>0)
+        {
+            ziinit.globalcomment = ALLOC(size_comment+1);
+            if (ziinit.globalcomment)
+            {
+               size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
+               ziinit.globalcomment[size_comment]=0;
+            }
+        }
+
+        byte_before_the_zipfile = central_pos -
+                                (offset_central_dir+size_central_dir);
+        ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
+
+        {
+            uLong size_central_dir_to_read = size_central_dir;
+            size_t buf_size = SIZEDATA_INDATABLOCK;
+            void* buf_read = (void*)ALLOC(buf_size);
+            if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
+                  offset_central_dir + byte_before_the_zipfile,
+                  ZLIB_FILEFUNC_SEEK_SET) != 0)
+                  err=ZIP_ERRNO;
+
+            while ((size_central_dir_to_read>0) && (err==ZIP_OK))
+            {
+                uLong read_this = SIZEDATA_INDATABLOCK;
+                if (read_this > size_central_dir_to_read)
+                    read_this = size_central_dir_to_read;
+                if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
+                    err=ZIP_ERRNO;
+
+                if (err==ZIP_OK)
+                    err = add_data_in_datablock(&ziinit.central_dir,buf_read,
+                                                (uLong)read_this);
+                size_central_dir_to_read-=read_this;
+            }
+            TRYFREE(buf_read);
+        }
+        ziinit.begin_pos = byte_before_the_zipfile;
+        ziinit.number_entry = number_entry_CD;
+
+        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
+                  offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err=ZIP_ERRNO;
+    }
+
+    if (globalcomment)
+    {
+      *globalcomment = ziinit.globalcomment;
+    }
+#    endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+    if (err != ZIP_OK)
+    {
+#    ifndef NO_ADDFILEINEXISTINGZIP
+        TRYFREE(ziinit.globalcomment);
+#    endif /* !NO_ADDFILEINEXISTINGZIP*/
+        TRYFREE(zi);
+        return NULL;
+    }
+    else
+    {
+        *zi = ziinit;
+        return (zipFile)zi;
+    }
+}
+
+extern zipFile ZEXPORT zipOpen (pathname, append)
+    const char *pathname;
+    int append;
+{
+    return zipOpen2(pathname,append,NULL,NULL);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
+                                         extrafield_local, size_extrafield_local,
+                                         extrafield_global, size_extrafield_global,
+                                         comment, method, level, raw,
+                                         windowBits, memLevel, strategy,
+                                         password, crcForCrypting)
+    zipFile file;
+    const char* filename;
+    const zip_fileinfo* zipfi;
+    const void* extrafield_local;
+    uInt size_extrafield_local;
+    const void* extrafield_global;
+    uInt size_extrafield_global;
+    const char* comment;
+    int method;
+    int level;
+    int raw;
+    int windowBits;
+    int memLevel;
+    int strategy;
+    const char* password;
+    uLong crcForCrypting;
+{
+    zip_internal* zi;
+    uInt size_filename;
+    uInt size_comment;
+    uInt i;
+    int err = ZIP_OK;
+
+#    ifdef NOCRYPT
+    if (password != NULL)
+        return ZIP_PARAMERROR;
+#    endif
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    if ((method!=0) && (method!=Z_DEFLATED))
+        return ZIP_PARAMERROR;
+
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 1)
+    {
+        err = zipCloseFileInZip (file);
+        if (err != ZIP_OK)
+            return err;
+    }
+
+
+    if (filename==NULL)
+        filename="-";
+
+    if (comment==NULL)
+        size_comment = 0;
+    else
+        size_comment = (uInt)strlen(comment);
+
+    size_filename = (uInt)strlen(filename);
+
+    if (zipfi == NULL)
+        zi->ci.dosDate = 0;
+    else
+    {
+        if (zipfi->dosDate != 0)
+            zi->ci.dosDate = zipfi->dosDate;
+        else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
+    }
+
+    zi->ci.flag = 0;
+    if ((level==8) || (level==9))
+      zi->ci.flag |= 2;
+    if ((level==2))
+      zi->ci.flag |= 4;
+    if ((level==1))
+      zi->ci.flag |= 6;
+    if (password != NULL)
+      zi->ci.flag |= 1;
+
+    zi->ci.crc32 = 0;
+    zi->ci.method = method;
+    zi->ci.encrypt = 0;
+    zi->ci.stream_initialised = 0;
+    zi->ci.pos_in_buffered_data = 0;
+    zi->ci.raw = raw;
+    zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
+    zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
+                                      size_extrafield_global + size_comment;
+    zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
+
+    ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
+    /* version info */
+    ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
+    ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
+
+    if (zipfi==NULL)
+        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
+    else
+        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
+
+    if (zipfi==NULL)
+        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
+    else
+        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
+
+    ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
+
+    for (i=0;i<size_filename;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
+
+    for (i=0;i<size_extrafield_global;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
+              *(((const char*)extrafield_global)+i);
+
+    for (i=0;i<size_comment;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
+              size_extrafield_global+i) = *(comment+i);
+    if (zi->ci.central_header == NULL)
+        return ZIP_INTERNALERROR;
+
+    /* write the local header */
+    err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
+
+    if ((err==ZIP_OK) && (size_filename>0))
+        if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
+                err = ZIP_ERRNO;
+
+    if ((err==ZIP_OK) && (size_extrafield_local>0))
+        if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
+                                                                           !=size_extrafield_local)
+                err = ZIP_ERRNO;
+
+    zi->ci.stream.avail_in = (uInt)0;
+    zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+    zi->ci.stream.next_out = zi->ci.buffered_data;
+    zi->ci.stream.total_in = 0;
+    zi->ci.stream.total_out = 0;
+
+    if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+    {
+        zi->ci.stream.zalloc = (alloc_func)0;
+        zi->ci.stream.zfree = (free_func)0;
+        zi->ci.stream.opaque = (voidpf)0;
+
+        if (windowBits>0)
+            windowBits = -windowBits;
+
+        err = deflateInit2(&zi->ci.stream, level,
+               Z_DEFLATED, windowBits, memLevel, strategy);
+
+        if (err==Z_OK)
+            zi->ci.stream_initialised = 1;
+    }
+#    ifndef NOCRYPT
+    zi->ci.crypt_header_size = 0;
+    if ((err==Z_OK) && (password != NULL))
+    {
+        unsigned char bufHead[RAND_HEAD_LEN];
+        unsigned int sizeHead;
+        zi->ci.encrypt = 1;
+        zi->ci.pcrc_32_tab = get_crc_table();
+        /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
+
+        sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
+        zi->ci.crypt_header_size = sizeHead;
+
+        if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
+                err = ZIP_ERRNO;
+    }
+#    endif
+
+    if (err==Z_OK)
+        zi->in_opened_file_inzip = 1;
+    return err;
+}
+
+extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
+                                        extrafield_local, size_extrafield_local,
+                                        extrafield_global, size_extrafield_global,
+                                        comment, method, level, raw)
+    zipFile file;
+    const char* filename;
+    const zip_fileinfo* zipfi;
+    const void* extrafield_local;
+    uInt size_extrafield_local;
+    const void* extrafield_global;
+    uInt size_extrafield_global;
+    const char* comment;
+    int method;
+    int level;
+    int raw;
+{
+    return zipOpenNewFileInZip3 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, raw,
+                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+                                 NULL, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
+                                        extrafield_local, size_extrafield_local,
+                                        extrafield_global, size_extrafield_global,
+                                        comment, method, level)
+    zipFile file;
+    const char* filename;
+    const zip_fileinfo* zipfi;
+    const void* extrafield_local;
+    uInt size_extrafield_local;
+    const void* extrafield_global;
+    uInt size_extrafield_global;
+    const char* comment;
+    int method;
+    int level;
+{
+    return zipOpenNewFileInZip2 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, 0);
+}
+
+local int zipFlushWriteBuffer(zi)
+  zip_internal* zi;
+{
+    int err=ZIP_OK;
+
+    if (zi->ci.encrypt != 0)
+    {
+#ifndef NOCRYPT
+        uInt i;
+        int t;
+        for (i=0;i<zi->ci.pos_in_buffered_data;i++)
+            zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
+                                       zi->ci.buffered_data[i],t);
+#endif
+    }
+    if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
+                                                                    !=zi->ci.pos_in_buffered_data)
+      err = ZIP_ERRNO;
+    zi->ci.pos_in_buffered_data = 0;
+    return err;
+}
+
+extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
+    zipFile file;
+    const void* buf;
+    unsigned len;
+{
+    zip_internal* zi;
+    int err=ZIP_OK;
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 0)
+        return ZIP_PARAMERROR;
+
+    zi->ci.stream.next_in = (void*)buf;
+    zi->ci.stream.avail_in = len;
+    zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
+
+    while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
+    {
+        if (zi->ci.stream.avail_out == 0)
+        {
+            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
+                err = ZIP_ERRNO;
+            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+            zi->ci.stream.next_out = zi->ci.buffered_data;
+        }
+
+
+        if(err != ZIP_OK)
+            break;
+
+        if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+        {
+            uLong uTotalOutBefore = zi->ci.stream.total_out;
+            err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
+            zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+
+        }
+        else
+        {
+            uInt copy_this,i;
+            if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
+                copy_this = zi->ci.stream.avail_in;
+            else
+                copy_this = zi->ci.stream.avail_out;
+            for (i=0;i<copy_this;i++)
+                *(((char*)zi->ci.stream.next_out)+i) =
+                    *(((const char*)zi->ci.stream.next_in)+i);
+            {
+                zi->ci.stream.avail_in -= copy_this;
+                zi->ci.stream.avail_out-= copy_this;
+                zi->ci.stream.next_in+= copy_this;
+                zi->ci.stream.next_out+= copy_this;
+                zi->ci.stream.total_in+= copy_this;
+                zi->ci.stream.total_out+= copy_this;
+                zi->ci.pos_in_buffered_data += copy_this;
+            }
+        }
+    }
+
+    return err;
+}
+
+extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
+    zipFile file;
+    uLong uncompressed_size;
+    uLong crc32;
+{
+    zip_internal* zi;
+    uLong compressed_size;
+    int err=ZIP_OK;
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 0)
+        return ZIP_PARAMERROR;
+    zi->ci.stream.avail_in = 0;
+
+    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+        while (err==ZIP_OK)
+    {
+        uLong uTotalOutBefore;
+        if (zi->ci.stream.avail_out == 0)
+        {
+            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
+                err = ZIP_ERRNO;
+            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+            zi->ci.stream.next_out = zi->ci.buffered_data;
+        }
+        uTotalOutBefore = zi->ci.stream.total_out;
+        err=deflate(&zi->ci.stream,  Z_FINISH);
+        zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+    }
+
+    if (err==Z_STREAM_END)
+        err=ZIP_OK; /* this is normal */
+
+    if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
+        if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
+            err = ZIP_ERRNO;
+
+    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+    {
+        err=deflateEnd(&zi->ci.stream);
+        zi->ci.stream_initialised = 0;
+    }
+
+    if (!zi->ci.raw)
+    {
+        crc32 = (uLong)zi->ci.crc32;
+        uncompressed_size = (uLong)zi->ci.stream.total_in;
+    }
+    compressed_size = (uLong)zi->ci.stream.total_out;
+#    ifndef NOCRYPT
+    compressed_size += zi->ci.crypt_header_size;
+#    endif
+
+    ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+20,
+                                compressed_size,4); /*compr size*/
+    if (zi->ci.stream.data_type == Z_ASCII)
+        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+24,
+                                uncompressed_size,4); /*uncompr size*/
+
+    if (err==ZIP_OK)
+        err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
+                                       (uLong)zi->ci.size_centralheader);
+    free(zi->ci.central_header);
+
+    if (err==ZIP_OK)
+    {
+        long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
+        if (ZSEEK(zi->z_filefunc,zi->filestream,
+                  zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err = ZIP_ERRNO;
+
+        if (err==ZIP_OK)
+            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
+
+        if (err==ZIP_OK) /* compressed size, unknown */
+            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
+
+        if (err==ZIP_OK) /* uncompressed size, unknown */
+            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
+
+        if (ZSEEK(zi->z_filefunc,zi->filestream,
+                  cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err = ZIP_ERRNO;
+    }
+
+    zi->number_entry ++;
+    zi->in_opened_file_inzip = 0;
+
+    return err;
+}
+
+extern int ZEXPORT zipCloseFileInZip (file)
+    zipFile file;
+{
+    return zipCloseFileInZipRaw (file,0,0);
+}
+
+extern int ZEXPORT zipClose (file, global_comment)
+    zipFile file;
+    const char* global_comment;
+{
+    zip_internal* zi;
+    int err = 0;
+    uLong size_centraldir = 0;
+    uLong centraldir_pos_inzip;
+    uInt size_global_comment;
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 1)
+    {
+        err = zipCloseFileInZip (file);
+    }
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+    if (global_comment==NULL)
+        global_comment = zi->globalcomment;
+#endif
+    if (global_comment==NULL)
+        size_global_comment = 0;
+    else
+        size_global_comment = (uInt)strlen(global_comment);
+
+    centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
+    if (err==ZIP_OK)
+    {
+        linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
+        while (ldi!=NULL)
+        {
+            if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
+                if (ZWRITE(zi->z_filefunc,zi->filestream,
+                           ldi->data,ldi->filled_in_this_block)
+                              !=ldi->filled_in_this_block )
+                    err = ZIP_ERRNO;
+
+            size_centraldir += ldi->filled_in_this_block;
+            ldi = ldi->next_datablock;
+        }
+    }
+    free_datablock(zi->central_dir.first_block);
+
+    if (err==ZIP_OK) /* Magic End */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
+
+    if (err==ZIP_OK) /* number of this disk */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+    if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+
+    if (err==ZIP_OK) /* total number of entries in the central dir */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+
+    if (err==ZIP_OK) /* size of the central directory */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
+
+    if (err==ZIP_OK) /* offset of start of central directory with respect to the
+                            starting disk number */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
+                                (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
+
+    if (err==ZIP_OK) /* zipfile comment length */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
+
+    if ((err==ZIP_OK) && (size_global_comment>0))
+        if (ZWRITE(zi->z_filefunc,zi->filestream,
+                   global_comment,size_global_comment) != size_global_comment)
+                err = ZIP_ERRNO;
+
+    if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
+        if (err == ZIP_OK)
+            err = ZIP_ERRNO;
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+    TRYFREE(zi->globalcomment);
+#endif
+    TRYFREE(zi);
+
+    return err;
+}
diff --git a/src/reader/zlib/zip.h b/src/reader/zlib/zip.h
new file mode 100644
index 00000000..acacce83
--- /dev/null
+++ b/src/reader/zlib/zip.h
@@ -0,0 +1,235 @@
+/* zip.h -- IO for compress .zip files using zlib
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
+     WinZip, InfoZip tools and compatible.
+   Multi volume ZipFile (span) are not supported.
+   Encryption compatible with pkzip 2.04g only supported
+   Old compressions used by old PKZip 1.x are not supported
+
+  For uncompress .zip file, look at unzip.h
+
+
+   I WAIT FEEDBACK at mail info@winimage.com
+   Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+
+*/
+
+/* for more info about .ZIP format, see
+      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
+      http://www.info-zip.org/pub/infozip/doc/
+   PkWare has also a specification at :
+      ftp://ftp.pkware.com/probdesc.zip
+*/
+
+#ifndef _zip_H
+#define _zip_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagzipFile__ { int unused; } zipFile__;
+typedef zipFile__ *zipFile;
+#else
+typedef voidp zipFile;
+#endif
+
+#define ZIP_OK                          (0)
+#define ZIP_EOF                         (0)
+#define ZIP_ERRNO                       (Z_ERRNO)
+#define ZIP_PARAMERROR                  (-102)
+#define ZIP_BADZIPFILE                  (-103)
+#define ZIP_INTERNALERROR               (-104)
+
+#ifndef DEF_MEM_LEVEL
+#  if MAX_MEM_LEVEL >= 8
+#    define DEF_MEM_LEVEL 8
+#  else
+#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#  endif
+#endif
+/* default memLevel */
+
+/* tm_zip contain date/time info */
+typedef struct tm_zip_s
+{
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
+    uInt tm_hour;           /* hours since midnight - [0,23] */
+    uInt tm_mday;           /* day of the month - [1,31] */
+    uInt tm_mon;            /* months since January - [0,11] */
+    uInt tm_year;           /* years - [1980..2044] */
+} tm_zip;
+
+typedef struct
+{
+    tm_zip      tmz_date;       /* date in understandable format           */
+    uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
+/*    uLong       flag;        */   /* general purpose bit flag        2 bytes */
+
+    uLong       internal_fa;    /* internal file attributes        2 bytes */
+    uLong       external_fa;    /* external file attributes        4 bytes */
+} zip_fileinfo;
+
+typedef const char* zipcharpc;
+
+
+#define APPEND_STATUS_CREATE        (0)
+#define APPEND_STATUS_CREATEAFTER   (1)
+#define APPEND_STATUS_ADDINZIP      (2)
+
+extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
+/*
+  Create a zipfile.
+     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
+       an Unix computer "zlib/zlib113.zip".
+     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
+       will be created at the end of the file.
+         (useful if the file contain a self extractor code)
+     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
+       add files in existing zip (be sure you don't add file that doesn't exist)
+     If the zipfile cannot be opened, the return value is NULL.
+     Else, the return value is a zipFile Handle, usable with other function
+       of this zip package.
+*/
+
+/* Note : there is no delete function into a zipfile.
+   If you want delete file into a zipfile, you must open a zipfile, and create another
+   Of couse, you can use RAW reading and writing to copy the file you did not want delte
+*/
+
+extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
+                                   int append,
+                                   zipcharpc* globalcomment,
+                                   zlib_filefunc_def* pzlib_filefunc_def));
+
+extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
+                       const char* filename,
+                       const zip_fileinfo* zipfi,
+                       const void* extrafield_local,
+                       uInt size_extrafield_local,
+                       const void* extrafield_global,
+                       uInt size_extrafield_global,
+                       const char* comment,
+                       int method,
+                       int level));
+/*
+  Open a file in the ZIP for writing.
+  filename : the filename in zip (if NULL, '-' without quote will be used
+  *zipfi contain supplemental information
+  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
+    contains the extrafield data the the local header
+  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
+    contains the extrafield data the the local header
+  if comment != NULL, comment contain the comment string
+  method contain the compression method (0 for store, Z_DEFLATED for deflate)
+  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
+*/
+
+
+extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw));
+
+/*
+  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
+ */
+
+extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCtypting));
+
+/*
+  Same than zipOpenNewFileInZip2, except
+    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
+    password : crypting password (NULL for no crypting)
+    crcForCtypting : crc of file to compress (needed for crypting)
+ */
+
+
+extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
+                       const void* buf,
+                       unsigned len));
+/*
+  Write data in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
+/*
+  Close the current file in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
+                                            uLong uncompressed_size,
+                                            uLong crc32));
+/*
+  Close the current file in the zipfile, for fiel opened with
+    parameter raw=1 in zipOpenNewFileInZip2
+  uncompressed_size and crc32 are value for the uncompressed size
+*/
+
+extern int ZEXPORT zipClose OF((zipFile file,
+                const char* global_comment));
+/*
+  Close the zipfile
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _zip_H */
diff --git a/src/reader/zlib/zlib.h b/src/reader/zlib/zlib.h
new file mode 100644
index 00000000..02281792
--- /dev/null
+++ b/src/reader/zlib/zlib.h
@@ -0,0 +1,1357 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.3, July 18th, 2005
+
+  Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.3"
+#define ZLIB_VERNUM 0x1230
+
+/*
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+     This library can optionally read and write gzip streams in memory as well.
+
+     The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumualte before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  the value returned by deflateBound (see below). If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
+  fatal, and deflate() can be called again with more input and more output
+  space to continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
+  Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer. Z_BLOCK requests that inflate() stop
+  if and when it gets to the next deflate block boundary. When decoding the
+  zlib or gzip format, this will cause inflate() to return immediately after
+  the header and before the first block. When doing a raw inflate, inflate()
+  will go ahead and process the first block, and will return when it gets to
+  the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  Also to assist in this, on return inflate() will set strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64
+  if inflate() is currently decoding the last block in the deflate stream,
+  plus 128 if inflate() returned immediately after decoding an end-of-block
+  code or decoding the complete header up to just before the first byte of the
+  deflate stream. The end-of-block will not be indicated until all of the
+  uncompressed data from that block has been written to strm->next_out.  The
+  number of unused bits may in general be greater than seven, except when
+  bit 7 of data_type is set, in which case the number of unused bits will be
+  less than eight.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster approach
+  may be used for the single inflate() call.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call. So the only effect of the flush parameter in this implementation
+  is on the return value of inflate(), as noted below, or when it returns early
+  because Z_BLOCK is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the adler32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below. At the end of the stream, inflate() checks that its computed adler32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() will decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically.  Any information
+  contained in the gzip header is not retained, so applications that need that
+  information should instead use raw inflate, see inflateInit2() below, or
+  inflateBack() and perform their own processing of the gzip header and
+  trailer.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
+  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+  output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing. If Z_DATA_ERROR is returned, the application may then
+  call inflateSync() to look for a good compression block if a partial recovery
+  of the data is desired.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer). It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
+   determines the window size. deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute an adler32 check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding. Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper. The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero),
+   no header crc, and the operating system will be set to 255 (unknown).  If a
+   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding). Filtered data consists mostly of small values with a somewhat
+   random distribution. In this case, the compression algorithm is tuned to
+   compress them better. The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
+   Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy
+   parameter only affects the compression ratio but not the correctness of the
+   compressed output even if it is not set appropriately.  Z_FIXED prevents the
+   use of dynamic Huffman codes, allowing for a simpler decoder for special
+   applications.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front. In addition, the
+   current implementation of deflate will use at most the window size minus
+   262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   adler32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit()
+   or deflateInit2().  This would be used to allocate an output buffer
+   for deflation in a single pass, and so would be called before deflate().
+*/
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+  is that this function is used to start off the deflate output with the
+  bits leftover from a previous deflate stream when appending to it.  As such,
+  this function can only be used for raw deflate, and must be used before the
+  first deflate() call after a deflateInit2() or deflateReset().  bits must be
+  less than or equal to 16, and that many of the least significant bits of
+  value will be inserted in the output.
+
+      deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+      deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+      If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+      deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used. If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
+   determines the window size. inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream. This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values. If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an adler32 or a crc32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is. Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding. Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
+   a crc32 instead of an adler32.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
+   is set to null if there is no error message.  inflateInit2 does not perform
+   any decompression apart from reading the zlib header if present: this will
+   be done by inflate(). (So next_in and avail_in may be modified, but next_out
+   and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the adler32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called
+   immediately after inflateInit2() or inflateReset() and before any call of
+   inflate() to set the dictionary.  The application must insure that the
+   dictionary that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     This function inserts bits in the inflate input stream.  The intent is
+  that this function is used to start inflating at a bit position in the
+  middle of a byte.  The provided bits will be used before any bytes are used
+  from next_in.  This function should only be used with raw inflate, and
+  should be used before the first inflate() call after inflateInit2() or
+  inflateReset().  bits must be less than or equal to 16, and that many of the
+  least significant bits of value will be inserted in the input.
+
+      inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+      inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK can be used to
+   force inflate() to return immediately after header processing is complete
+   and before any actual data is decompressed.
+
+      The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.)  If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When
+   any of extra, name, or comment are not Z_NULL and the respective field is
+   not present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+      If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+      inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the paramaters are invalid, Z_MEM_ERROR if the internal state could not
+   be allocated, or Z_VERSION_ERROR if the version of the library does not
+   match the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is more efficient than inflate() for
+   file i/o applications in that it avoids copying between the output and the
+   sliding window by simply making the window itself the output buffer.  This
+   function trusts the application to not change the output buffer passed by
+   the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free
+   the allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects
+   only the raw deflate stream to decompress.  This is different from the
+   normal behavior of inflate(), which expects either a zlib or gzip header and
+   trailer around the deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero--buf is ignored in that
+   case--and inflateBack() will return a buffer error.  inflateBack() will call
+   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
+   should return zero on success, or non-zero on failure.  If out() returns
+   non-zero, inflateBack() will return with an error.  Neither in() nor out()
+   are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 .. strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format
+   error in the deflate stream (in which case strm->msg is set to indicate the
+   nature of the error), or Z_STREAM_ERROR if the stream was not properly
+   initialized.  In the case of Z_BUF_ERROR, an input or output error can be
+   distinguished using strm->next_in which will be Z_NULL only if in() returned
+   an error.  If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to
+   out() returning non-zero.  (in() will always be called before out(), so
+   strm->next_in is assured to be defined if out() returns non-zero.)  Note
+   that inflateBack() cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the
+   basic stream-oriented functions. To simplify the interface, some
+   default options are assumed (compression level and memory usage,
+   standard memory allocation functions). The source code of these
+   utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be at least the value returned
+   by compressBound(sourceLen). Upon exit, destLen is the actual size of the
+   compressed buffer.
+     This function can be used to compress a whole file at once if the
+   input file is mmap'ed.
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen). Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before
+   a compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h", or 'R' for run-length encoding
+   as in "wb1R". (See the description of deflateInit2 for more information
+   about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file,
+                                   voidpc buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).  The number of
+   uncompressed bytes written is limited to 4095. The caller should assure that
+   this limit is not exceeded. If it is exceeded, then gzprintf() will return
+   return an error (0) with nothing written. In this case, there may also be a
+   buffer overflow with unpredictable consequences, which is possible only if
+   zlib was compiled with the insecure functions sprintf() or vsprintf()
+   because the secure snprintf() or vsnprintf() functions were not available.
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT    gzungetc OF((int c, gzFile file));
+/*
+      Push one character back onto the stream to be read again later.
+   Only one character of push-back is allowed.  gzungetc() returns the
+   character pushed, or -1 on failure.  gzungetc() will fail if a
+   character has been pushed but not read yet, or if c is -1. The pushed
+   character will be discarded if the stream is repositioned with gzseek()
+   or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+                                      z_off_t offset, int whence));
+/*
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+     Returns 1 if file is being read directly without decompression, otherwise
+   zero.
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+     Clears the error and end-of-file flags for file. This is analogous to the
+   clearerr() function in stdio. This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the
+   compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+/*
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32. If buf is NULL, this function returns the required initial
+   value for the for the crc. Pre- and post-conditioning (one's complement) is
+   performed within this function so it shouldn't be done by the application.
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+/*
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+        inflateBackInit_((strm), (windowBits), (window), \
+        ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/src/reader/zlib/zutil.c b/src/reader/zlib/zutil.c
new file mode 100644
index 00000000..8b278e31
--- /dev/null
+++ b/src/reader/zlib/zutil.c
@@ -0,0 +1,318 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: zutil.c,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#include "zutil.h"
+
+#ifndef NO_DUMMY_DECL
+struct internal_state      {int dummy;}; /* for buggy compilers */
+#endif
+
+const char * const z_errmsg[10] = {
+"need dictionary",     /* Z_NEED_DICT       2  */
+"stream end",          /* Z_STREAM_END      1  */
+"",                    /* Z_OK              0  */
+"file error",          /* Z_ERRNO         (-1) */
+"stream error",        /* Z_STREAM_ERROR  (-2) */
+"data error",          /* Z_DATA_ERROR    (-3) */
+"insufficient memory", /* Z_MEM_ERROR     (-4) */
+"buffer error",        /* Z_BUF_ERROR     (-5) */
+"incompatible version",/* Z_VERSION_ERROR (-6) */
+""};
+
+
+const char * ZEXPORT zlibVersion()
+{
+    return ZLIB_VERSION;
+}
+
+uLong ZEXPORT zlibCompileFlags()
+{
+    uLong flags;
+
+    flags = 0;
+    switch (sizeof(uInt)) {
+    case 2:     break;
+    case 4:     flags += 1;     break;
+    case 8:     flags += 2;     break;
+    default:    flags += 3;
+    }
+    switch (sizeof(uLong)) {
+    case 2:     break;
+    case 4:     flags += 1 << 2;        break;
+    case 8:     flags += 2 << 2;        break;
+    default:    flags += 3 << 2;
+    }
+    switch (sizeof(voidpf)) {
+    case 2:     break;
+    case 4:     flags += 1 << 4;        break;
+    case 8:     flags += 2 << 4;        break;
+    default:    flags += 3 << 4;
+    }
+    switch (sizeof(z_off_t)) {
+    case 2:     break;
+    case 4:     flags += 1 << 6;        break;
+    case 8:     flags += 2 << 6;        break;
+    default:    flags += 3 << 6;
+    }
+#ifdef DEBUG
+    flags += 1 << 8;
+#endif
+#if defined(ASMV) || defined(ASMINF)
+    flags += 1 << 9;
+#endif
+#ifdef ZLIB_WINAPI
+    flags += 1 << 10;
+#endif
+#ifdef BUILDFIXED
+    flags += 1 << 12;
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+    flags += 1 << 13;
+#endif
+#ifdef NO_GZCOMPRESS
+    flags += 1L << 16;
+#endif
+#ifdef NO_GZIP
+    flags += 1L << 17;
+#endif
+#ifdef PKZIP_BUG_WORKAROUND
+    flags += 1L << 20;
+#endif
+#ifdef FASTEST
+    flags += 1L << 21;
+#endif
+#ifdef STDC
+#  ifdef NO_vsnprintf
+        flags += 1L << 25;
+#    ifdef HAS_vsprintf_void
+        flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_vsnprintf_void
+        flags += 1L << 26;
+#    endif
+#  endif
+#else
+        flags += 1L << 24;
+#  ifdef NO_snprintf
+        flags += 1L << 25;
+#    ifdef HAS_sprintf_void
+        flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_snprintf_void
+        flags += 1L << 26;
+#    endif
+#  endif
+#endif
+    return flags;
+}
+
+#ifdef DEBUG
+
+#  ifndef verbose
+#    define verbose 0
+#  endif
+int z_verbose = verbose;
+
+void z_error (m)
+    char *m;
+{
+    fprintf(stderr, "%s\n", m);
+    exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+    int err;
+{
+    return ERR_MSG(err);
+}
+
+#if defined(_WIN32_WCE)
+    /* The Microsoft C Run-Time Library for Windows CE doesn't have
+     * errno.  We define it as a global variable to simplify porting.
+     * Its value is always 0 and should not be used.
+     */
+    int errno = 0;
+#endif
+
+#ifndef HAVE_MEMCPY
+
+void zmemcpy(dest, source, len)
+    Bytef* dest;
+    const Bytef* source;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = *source++; /* ??? to be unrolled */
+    } while (--len != 0);
+}
+
+int zmemcmp(s1, s2, len)
+    const Bytef* s1;
+    const Bytef* s2;
+    uInt  len;
+{
+    uInt j;
+
+    for (j = 0; j < len; j++) {
+        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+    }
+    return 0;
+}
+
+void zmemzero(dest, len)
+    Bytef* dest;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = 0;  /* ??? to be unrolled */
+    } while (--len != 0);
+}
+#endif
+
+
+#ifdef SYS16BIT
+
+#ifdef __TURBOC__
+/* Turbo C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+    voidpf org_ptr;
+    voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    voidpf buf = opaque; /* just to make some compilers happy */
+    ulg bsize = (ulg)items*size;
+
+    /* If we allocate less than 65520 bytes, we assume that farmalloc
+     * will return a usable pointer which doesn't have to be normalized.
+     */
+    if (bsize < 65520L) {
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
+    } else {
+        buf = farmalloc(bsize + 16L);
+    }
+    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+    table[next_ptr].org_ptr = buf;
+
+    /* Normalize the pointer to seg:0 */
+    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+    *(ush*)&buf = 0;
+    table[next_ptr++].new_ptr = buf;
+    return buf;
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    int n;
+    if (*(ush*)&ptr != 0) { /* object < 64K */
+        farfree(ptr);
+        return;
+    }
+    /* Find the original pointer */
+    for (n = 0; n < next_ptr; n++) {
+        if (ptr != table[n].new_ptr) continue;
+
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
+    }
+    ptr = opaque; /* just to make some compilers happy */
+    Assert(0, "zcfree: ptr not found");
+}
+
+#endif /* __TURBOC__ */
+
+
+#ifdef M_I86
+/* Microsoft C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+#  define _halloc  halloc
+#  define _hfree   hfree
+#endif
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    return _halloc((long)items, size);
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    _hfree(ptr);
+}
+
+#endif /* M_I86 */
+
+#endif /* SYS16BIT */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp  malloc OF((uInt size));
+extern voidp  calloc OF((uInt items, uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+voidpf zcalloc (opaque, items, size)
+    voidpf opaque;
+    unsigned items;
+    unsigned size;
+{
+    if (opaque) items += size - size; /* make compiler happy */
+    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+                              (voidpf)calloc(items, size);
+}
+
+void  zcfree (opaque, ptr)
+    voidpf opaque;
+    voidpf ptr;
+{
+    free(ptr);
+    if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */
diff --git a/src/reader/zlib/zutil.h b/src/reader/zlib/zutil.h
new file mode 100644
index 00000000..c7ad800a
--- /dev/null
+++ b/src/reader/zlib/zutil.h
@@ -0,0 +1,269 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: zutil.h,v 1.3 2005/07/27 18:15:11 nach Exp $ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#ifdef STDC
+#  ifndef _WIN32_WCE
+#    include <stddef.h>
+#  endif
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+#   ifdef _WIN32_WCE
+      /* The Microsoft C Run-Time Library for Windows CE doesn't have
+       * errno.  We define it as a global variable to simplify porting.
+       * Its value is always 0 and should not be used.  We rename it to
+       * avoid conflict with other libraries that use the same workaround.
+       */
+#     define errno z_errno
+#   endif
+    extern int errno;
+#else
+#  ifndef _WIN32_WCE
+#    include <errno.h>
+#  endif
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#  define OS_CODE  0x00
+#  if defined(__TURBOC__) || defined(__BORLANDC__)
+#    if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+       /* Allow compilation with ANSI keywords only enabled */
+       void _Cdecl farfree( void *block );
+       void *_Cdecl farmalloc( unsigned long nbytes );
+#    else
+#      include <alloc.h>
+#    endif
+#  else /* MSC or DJGPP */
+#    include <malloc.h>
+#  endif
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  0x02
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  0x05
+#endif
+
+#ifdef OS2
+#  define OS_CODE  0x06
+#  ifdef M_I86
+     #include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  0x07
+#  if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#    include <unix.h> /* for fdopen */
+#  else
+#    ifndef fdopen
+#      define fdopen(fd,mode) NULL /* No fdopen() */
+#    endif
+#  endif
+#endif
+
+#ifdef TOPS20
+#  define OS_CODE  0x0a
+#endif
+
+#ifdef WIN32
+#  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
+#    define OS_CODE  0x0b
+#  endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#  define OS_CODE  0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
+#  if defined(_WIN32_WCE)
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#    ifndef _PTRDIFF_T_DEFINED
+       typedef int ptrdiff_t;
+#      define _PTRDIFF_T_DEFINED
+#    endif
+#  else
+#    define fdopen(fd,type)  _fdopen(fd,type)
+#  endif
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+#if defined(__CYGWIN__)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+#ifndef HAVE_VSNPRINTF
+#  ifdef MSDOS
+     /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+        but for now we just assume it doesn't. */
+#    define NO_vsnprintf
+#  endif
+#  ifdef __TURBOC__
+#    define NO_vsnprintf
+#  endif
+#  ifdef WIN32
+     /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
+#      define vsnprintf _vsnprintf
+#    endif
+#  endif
+#  ifdef __SASC
+#    define NO_vsnprintf
+#  endif
+#endif
+#ifdef VMS
+#  define NO_vsnprintf
+#endif
+
+#if defined(pyr)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
+   extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
+   extern void zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#  include <stdio.h>
+   extern int z_verbose;
+   extern void z_error    OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+
+voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+void   zcfree  OF((voidpf opaque, voidpf ptr));
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* ZUTIL_H */
diff --git a/src/sdl/Makefile b/src/sdl/Makefile
index c80c0168..c76e8fca 100644
--- a/src/sdl/Makefile
+++ b/src/sdl/Makefile
@@ -1,18 +1,23 @@
-CC = c++
+CC = cc
+CXX = c++
 CFLAGS = -O3 -fomit-frame-pointer -ffast-math
+CXXFLAGS = $(CFLAGS) -fno-rtti
 OBJS = sdlmain.o \
        libstring.o libconfig.o \
-       reader.o \
+       reader.o cart.o \
        memory.o bmemory.o \
        cpu.o bcpu.o \
        apu.o bapu.o \
        bdsp.o \
        ppu.o bppu.o \
        snes.o \
-       srtc.o sdd1.o
+       srtc.o sdd1.o c4.o \
+       adler32.o compress.o crc32.o deflate.o gzio.o inffast.o \
+       inflate.o inftrees.o ioapi.o trees.o unzip.o zip.o zutil.o \
+       jma.o jcrc32.o lzmadec.o 7zlzma.o iiostrm.o inbyte.o lzma.o winout.o
 
 all: $(OBJS)
-	$(CC) $(CFLAGS) $(OBJS) `sdl11-config --cflags --libs` -o bsnes_sdl
+	$(CXX) $(CXXFLAGS) $(OBJS) `sdl11-config --cflags --libs` -o bsnes_sdl
 
 clean:
 	rm *.o
@@ -21,78 +26,93 @@ clean:
 ### sdl-specific ###
 ####################
 sdlmain.o: *.cpp *.h
-	$(CC) $(CFLAGS) -c sdlmain.cpp `sdl11-config --cflags`
+	$(CXX) $(CXXFLAGS) -c sdlmain.cpp `sdl11-config --cflags`
 
 #################
 ### libraries ###
 #################
 libstring.o: ../lib/*.cpp ../lib/*.h
-	$(CC) $(CFLAGS) -c ../lib/libstring.cpp
+	$(CXX) $(CXXFLAGS) -c ../lib/libstring.cpp
 libconfig.o: ../lib/*.cpp ../lib/*.h
-	$(CC) $(CFLAGS) -c ../lib/libconfig.cpp
+	$(CXX) $(CXXFLAGS) -c ../lib/libconfig.cpp
 
 ##############
 ### memory ###
 ##############
 memory.o: ../memory/memory.cpp ../memory/memory.h
-	$(CC) $(CFLAGS) -c ../memory/memory.cpp
+	$(CXX) $(CXXFLAGS) -c ../memory/memory.cpp
 
 bmemory.o: ../memory/bmemory/*
-	$(CC) $(CFLAGS) -c ../memory/bmemory/bmemory.cpp
+	$(CXX) $(CXXFLAGS) -c ../memory/bmemory/bmemory.cpp
 
 ###########
 ### cpu ###
 ###########
 cpu.o: ../cpu/*.cpp ../cpu/*.h
-	$(CC) $(CFLAGS) -c ../cpu/cpu.cpp
+	$(CXX) $(CXXFLAGS) -c ../cpu/cpu.cpp
 
 bcpu.o: ../cpu/bcpu/*
-	$(CC) $(CFLAGS) -c ../cpu/bcpu/bcpu.cpp
+	$(CXX) $(CXXFLAGS) -c ../cpu/bcpu/bcpu.cpp
 
 ###########
 ### apu ###
 ###########
 apu.o: ../apu/*
-	$(CC) $(CFLAGS) -c ../apu/apu.cpp
+	$(CXX) $(CXXFLAGS) -c ../apu/apu.cpp
 
 bapu.o: ../apu/bapu/*
-	$(CC) $(CFLAGS) -c ../apu/bapu/bapu.cpp
+	$(CXX) $(CXXFLAGS) -c ../apu/bapu/bapu.cpp
 
 ###########
 ### dsp ###
 ###########
 bdsp.o: ../dsp/bdsp/*
-	$(CC) $(CFLAGS) -c ../dsp/bdsp/bdsp.cpp
+	$(CXX) $(CXXFLAGS) -c ../dsp/bdsp/bdsp.cpp
 
 ###########
 ### ppu ###
 ###########
 ppu.o: ../ppu/*.cpp ../ppu/*.h
-	$(CC) $(CFLAGS) -c ../ppu/ppu.cpp
+	$(CXX) $(CXXFLAGS) -c ../ppu/ppu.cpp
 
 bppu.o: ../ppu/bppu/*
-	$(CC) $(CFLAGS) -c ../ppu/bppu/bppu.cpp
+	$(CXX) $(CXXFLAGS) -c ../ppu/bppu/bppu.cpp
 
-##############
-### reader ###
-##############
+#################
+### utilities ###
+#################
 reader.o: ../reader/*.cpp ../reader/*.h
-	$(CC) $(CFLAGS) -c ../reader/reader.cpp
+	$(CXX) $(CXXFLAGS) -c ../reader/reader.cpp
+
+cart.o: ../cart/*.cpp ../cart/*.h
+	$(CXX) $(CXXFLAGS) -c ../cart/cart.cpp
 
 ############
 ### snes ###
 ############
 snes.o: ../snes/*.cpp ../snes/*.h
-	$(CC) $(CFLAGS) -c ../snes/snes.cpp
+	$(CXX) $(CXXFLAGS) -c ../snes/snes.cpp
 
-############
-### srtc ###
-############
+#####################
+### special chips ###
+#####################
 srtc.o: ../chip/srtc/*.cpp ../chip/srtc/*.h
-	$(CC) $(CFLAGS) -c ../chip/srtc/srtc.cpp
+	$(CXX) $(CXXFLAGS) -c ../chip/srtc/srtc.cpp
+
+sdd1.o: ../chip/sdd1/*.cpp ../chip/sdd1/*.h
+	$(CXX) $(CXXFLAGS) -c ../chip/sdd1/sdd1.cpp
+
+c4.o: ../chip/c4/*.cpp ../chip/c4/*.h
+	$(CXX) $(CXXFLAGS) -c ../chip/c4/c4.cpp
 
 ############
-### sdd1 ###
+### zlib ###
 ############
-sdd1.o: ../chip/sdd1/*.cpp ../chip/sdd1/*.h
-	$(CC) $(CFLAGS) -c ../chip/sdd1/sdd1.cpp
+adler32.o: ../reader/zlib/*.c ../reader/zlib/*.h
+	$(CC) $(CFLAGS) -c ../reader/zlib/*.c
+
+###########
+### jma ###
+###########
+jma.o: ../reader/jma/*.cpp ../reader/jma/*.h
+	$(CXX) $(CXXFLAGS) -c ../reader/jma/*.cpp
diff --git a/src/sdl/Makefile.win32 b/src/sdl/Makefile.win32
index 3f83052b..e49473fb 100644
--- a/src/sdl/Makefile.win32
+++ b/src/sdl/Makefile.win32
@@ -1,15 +1,18 @@
 CC = cl
-CFLAGS = /nologo /O2 /wd4996
+CFLAGS = /nologo /O2 /EHsc /wd4996
 OBJS = sdlmain.obj \
        libstring.obj libconfig.obj \
-       reader.obj \
+       reader.obj cart.obj \
        memory.obj bmemory.obj \
        cpu.obj bcpu.obj \
        apu.obj bapu.obj \
        bdsp.obj \
        ppu.obj bppu.obj \
        snes.obj \
-       srtc.obj sdd1.obj
+       srtc.obj sdd1.obj c4.obj
+#      adler32.obj compress.obj crc32.obj deflate.obj gzio.obj inffast.obj \
+#      inflate.obj inftrees.obj ioapi.obj trees.obj unzip.obj zip.obj zutil.obj \
+#      jma.obj jcrc32.obj lzmadec.obj 7zlzma.obj iiostrm.obj inbyte.obj lzma.obj winout.obj
 LIBS = kernel32.lib user32.lib gdi32.lib sdlmain.lib sdl.lib
 
 all: $(OBJS)
@@ -74,26 +77,41 @@ ppu.obj: ../ppu/*.cpp ../ppu/*.h
 bppu.obj: ../ppu/bppu/*
 	$(CC) $(CFLAGS) /c ../ppu/bppu/bppu.cpp
 
-##############
-### reader ###
-##############
+#################
+### utilities ###
+#################
 reader.obj: ../reader/*.cpp ../reader/*.h
 	$(CC) $(CFLAGS) /c ../reader/reader.cpp
 
+cart.obj: ../cart/*.cpp ../cart/*.h
+	$(CC) $(CFLAGS) /c ../cart/cart.cpp
+
 ############
 ### snes ###
 ############
 snes.obj: ../snes/*.cpp ../snes/*.h
 	$(CC) $(CFLAGS) /c ../snes/snes.cpp
 
-############
-### srtc ###
-############
+#####################
+### special chips ###
+#####################
 srtc.obj: ../chip/srtc/*.cpp ../chip/srtc/*.h
 	$(CC) $(CFLAGS) /c ../chip/srtc/srtc.cpp
 
-############
-### sdd1 ###
-############
 sdd1.obj: ../chip/sdd1/*.cpp ../chip/sdd1/*.h
 	$(CC) $(CFLAGS) /c ../chip/sdd1/sdd1.cpp
+
+c4.obj: ../chip/c4/*.cpp ../chip/c4/*.h
+	$(CC) $(CFLAGS) /c ../chip/c4/c4.cpp
+
+############
+### zlib ###
+############
+adler32.obj: ../reader/zlib/*.c ../reader/zlib/*.h
+	$(CC) $(CFLAGS) /c ../reader/zlib/*.c
+
+###########
+### jma ###
+###########
+jma.obj: ../reader/jma/*.cpp ../reader/jma/*.h
+	$(CC) $(CFLAGS) /c ../reader/jma/*.cpp
diff --git a/src/sdl/bsnes.cpp b/src/sdl/bsnes.cpp
index 11188844..ca29091f 100644
--- a/src/sdl/bsnes.cpp
+++ b/src/sdl/bsnes.cpp
@@ -2,8 +2,6 @@ void   bSNES::set_status(uint32 new_status) { run_status = new_status; }
 uint32 bSNES::get_status()                  { return run_status; }
 
 void bSNES::run() {
-  if(!rom_image->loaded())return;
-
   switch(run_status) {
   case RUN:
     SNES::runtoframe();
diff --git a/src/sdl/bsnes_sdl.cfg b/src/sdl/bsnes_sdl.cfg
index 5a6ac037..7009e0a4 100644
--- a/src/sdl/bsnes_sdl.cfg
+++ b/src/sdl/bsnes_sdl.cfg
@@ -13,7 +13,7 @@ snes.video_color_curve = true
 snes.video_color_adjust_mode = 0
 
 # Mutes SNES audio output when enabled
-# (default = true)
+# (default = false)
 snes.mute = true
 
 # Enable fullscreen mode at startup
diff --git a/src/sdl/rom.cpp b/src/sdl/rom.cpp
deleted file mode 100644
index 46897fcb..00000000
--- a/src/sdl/rom.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-class ROMImage {
-private:
-char rom_fn[4096];
-char sram_fn[4096];
-bool file_loaded;
-
-public:
-  bool loaded();
-  bool load();
-  void unload();
-  void select(char *fn);
-  ROMImage();
-  ~ROMImage();
-};
-
-bool ROMImage::loaded() {
-  return file_loaded;
-}
-
-bool ROMImage::load() {
-  if(file_loaded == true)return false;
-
-  dprintf("* Loading \"%s\"...", rom_fn);
-
-FileReader *rf = new FileReader();
-  if(!rf->open(rom_fn)) {
-    alert("Error loading image file [%s]!", rom_fn);
-    return false;
-  }
-  r_mem->load_cart(static_cast<Reader*>(rf));
-  rf->close();
-
-CartInfo ci;
-  r_mem->get_cartinfo(&ci);
-  if(ci.sram_size != 0) {
-    rf->open(sram_fn);
-    r_mem->load_sram(static_cast<Reader*>(rf));
-    rf->close();
-  }
-
-  delete(rf);
-
-  file_loaded = true;
-  return true;
-}
-
-void ROMImage::unload() {
-  if(file_loaded == false)return;
-
-FileWriter *wf;
-CartInfo ci;
-  r_mem->get_cartinfo(&ci);
-  if(ci.sram_size != 0) {
-    wf = new FileWriter();
-    wf->open(sram_fn);
-    r_mem->save_sram(static_cast<Writer*>(wf));
-    wf->close();
-    delete(wf);
-  }
-
-  file_loaded = false;
-
-  r_mem->unload_cart();
-}
-
-void ROMImage::select(char *fn) {
-int i;
-  if(file_loaded == true)return;
-
-//remove quotes
-  if(fn[0] == '\"') {
-    strcpy(rom_fn, fn + 1);
-    rom_fn[strlen(rom_fn) - 1] = 0;
-  } else {
-    strcpy(rom_fn, fn);
-  }
-
-  for(i=strlen(rom_fn)-1;i>=0;i--) {
-    if(rom_fn[i] == '.')break;
-  }
-
-  strcpy(sram_fn, rom_fn);
-  if(rom_fn[i] == '.')sram_fn[i] = 0;
-  strcat(sram_fn, ".srm");
-}
-
-ROMImage::ROMImage() {
-  *rom_fn  = 0;
-  *sram_fn = 0;
-  file_loaded = false;
-}
-
-ROMImage::~ROMImage() {
-  if(file_loaded == true) {
-    unload();
-  }
-}
-
-ROMImage *rom_image;
diff --git a/src/sdl/sdlmain.cpp b/src/sdl/sdlmain.cpp
index d371da97..19f483ba 100644
--- a/src/sdl/sdlmain.cpp
+++ b/src/sdl/sdlmain.cpp
@@ -9,7 +9,6 @@ HWND hwnd;
 #endif
 
 #include "bsnes.h"
-#include "rom.cpp"
 #include "render.cpp"
 #include "bsnes.cpp"
 
@@ -66,13 +65,13 @@ void init_snes() {
 void term_snes() {
   snes->term();
 #ifdef POLYMORPHISM
-  if(deref(mem)) { delete static_cast<bMemBus*>(deref(mem)); deref(mem) = 0; }
-  if(deref(cpu)) { delete static_cast<bCPU*>   (deref(cpu)); deref(cpu) = 0; }
-  if(deref(apu)) { delete static_cast<bAPU*>   (deref(apu)); deref(apu) = 0; }
-  if(deref(dsp)) { delete static_cast<bDSP*>   (deref(dsp)); deref(dsp) = 0; }
-  if(deref(ppu)) { delete static_cast<bPPU*>   (deref(ppu)); deref(ppu) = 0; }
+  if(deref(mem)) { delete deref(mem); deref(mem) = 0; }
+  if(deref(cpu)) { delete deref(cpu); deref(cpu) = 0; }
+  if(deref(apu)) { delete deref(apu); deref(apu) = 0; }
+  if(deref(dsp)) { delete deref(dsp); deref(dsp) = 0; }
+  if(deref(ppu)) { delete deref(ppu); deref(ppu) = 0; }
 #endif
-  if(snes) { delete(static_cast<bSNES*>(snes)); snes = 0; }
+  if(snes) { delete(snes); snes = 0; }
 }
 
 void center_window() {
@@ -120,13 +119,9 @@ SDL_Event event;
 
   config_file.load("bsnes_sdl.cfg");
 
-  rom_image = new ROMImage();
   init_snes();
 
-  rom_image->select(argv[1]);
-  rom_image->load();
-
-  if(rom_image->loaded() == false) {
+  if(cartridge.load(argv[1]) == false) {
     alert("Failed to load image. Usage: bsnes_sdl <filename.smc>");
     goto _end;
   }
@@ -178,6 +173,7 @@ int cursor_status;
 
 _end:
   config_file.save("bsnes_sdl.cfg");
+  cartridge.unload();
   term_snes();
 
   return 0;
diff --git a/src/sdl/sdlrun.bat b/src/sdl/sdlrun.bat
index d397c2f2..aa59b644 100644
--- a/src/sdl/sdlrun.bat
+++ b/src/sdl/sdlrun.bat
@@ -1 +1 @@
-bsnes_sdl c:\root\bsnes_testrom\zelda_us.smc
\ No newline at end of file
+bsnes_sdl c:\root\bsnes_testrom\zelda_us.smc
diff --git a/src/snes/snes.cpp b/src/snes/snes.cpp
index 04ca776e..e30de1f1 100644
--- a/src/snes/snes.cpp
+++ b/src/snes/snes.cpp
@@ -33,9 +33,11 @@ void SNES::runtoframe() {
 void SNES::init() {
   srtc = new SRTC();
   sdd1 = new SDD1();
+  c4   = new C4();
 
   srtc->init();
   sdd1->init();
+  c4->init();
 
   video_init();
   audio_init();
@@ -52,8 +54,9 @@ void SNES::power() {
   r_ppu->power();
   r_mem->power();
 
-  srtc->power();
-  sdd1->power();
+  if(cartridge.cart.srtc)srtc->power();
+  if(cartridge.cart.sdd1)sdd1->power();
+  if(cartridge.cart.c4)  c4->power();
 
 int i;
   r_mem->flush_mmio_mappers();
@@ -66,8 +69,9 @@ int i;
   for(i=0x4200;i<=0x421f;i++)r_mem->set_mmio_mapper(i, r_cpu->mmio);
   for(i=0x4300;i<=0x437f;i++)r_mem->set_mmio_mapper(i, r_cpu->mmio);
 
-  srtc->enable();
-  sdd1->enable();
+  if(cartridge.cart.srtc)srtc->enable();
+  if(cartridge.cart.sdd1)sdd1->enable();
+  if(cartridge.cart.c4)  c4->enable();
 
   video_update();
 }
@@ -81,8 +85,9 @@ void SNES::reset() {
   r_ppu->reset();
   r_mem->reset();
 
-  srtc->reset();
-  sdd1->reset();
+  if(cartridge.cart.srtc)srtc->reset();
+  if(cartridge.cart.sdd1)sdd1->reset();
+  if(cartridge.cart.c4)  c4->reset();
 
   video_update();
 }
diff --git a/src/snes/snes.h b/src/snes/snes.h
index db2a31f5..cf838a82 100644
--- a/src/snes/snes.h
+++ b/src/snes/snes.h
@@ -56,4 +56,5 @@ enum {
   virtual void notify(uint32 message, uint32 param1 = 0, uint32 param2 = 0);
 
   SNES();
+  virtual ~SNES() {}
 };
diff --git a/src/win/Makefile b/src/win/Makefile
index ec12082c..ef0efb61 100644
--- a/src/win/Makefile
+++ b/src/win/Makefile
@@ -1,32 +1,37 @@
 CC = cl
-CFLAGS = /nologo /O2 /wd4996
-OBJS = winmain.obj \
+CFLAGS = /nologo /O2 /EHsc /wd4996
+OBJS = main.obj \
        libstring.obj libconfig.obj \
-       reader.obj \
+       reader.obj cart.obj \
        memory.obj bmemory.obj \
        cpu.obj bcpu.obj \
        apu.obj bapu.obj \
        bdsp.obj \
        ppu.obj bppu.obj \
        snes.obj \
-       srtc.obj sdd1.obj
-LIBS = kernel32.lib user32.lib gdi32.lib comdlg32.lib ddraw.lib dsound.lib dxguid.lib
+       srtc.obj sdd1.obj c4.obj \
+       adler32.obj compress.obj crc32.obj deflate.obj gzio.obj inffast.obj \
+       inflate.obj inftrees.obj ioapi.obj trees.obj unzip.obj zip.obj zutil.obj \
+       jma.obj jcrc32.obj lzmadec.obj 7zlzma.obj iiostrm.obj inbyte.obj lzma.obj winout.obj
+LIBS = kernel32.lib user32.lib gdi32.lib comdlg32.lib ddraw.lib dsound.lib dinput8.lib dxguid.lib
 
 all: $(OBJS)
 	rc /r /fobsnes.res bsnes.rc
 	$(CC) /Febsnes.exe $(CFLAGS) $(OBJS) bsnes.res $(LIBS)
-#/link /PGD:bsnes.pgd /LTCG:PGOPTIMIZE
+#/link /PGD:bsnes.pgd /LTCG:PGINSTRUMENT
 
 clean:
 	del *.obj
 	del *.pgd
 	del *.pgc
+	del *.ilk
+	del *.pdb
 
 ######################
 ### win32-specific ###
 ######################
-winmain.obj: *.cpp *.h ../config/*
-	$(CC) $(CFLAGS) /c winmain.cpp
+main.obj: *.cpp *.h video/* audio/* input/* ../config/*
+	$(CC) $(CFLAGS) /c main.cpp
 
 #################
 ### libraries ###
@@ -78,26 +83,41 @@ ppu.obj: ../ppu/*.cpp ../ppu/*.h
 bppu.obj: ../ppu/bppu/*
 	$(CC) $(CFLAGS) /c ../ppu/bppu/bppu.cpp
 
-##############
-### reader ###
-##############
+#################
+### utilities ###
+#################
 reader.obj: ../reader/*.cpp ../reader/*.h
 	$(CC) $(CFLAGS) /c ../reader/reader.cpp
 
+cart.obj: ../cart/*.cpp ../cart/*.h
+	$(CC) $(CFLAGS) /c ../cart/cart.cpp
+
 ############
 ### snes ###
 ############
 snes.obj: ../snes/*.cpp ../snes/*.h
 	$(CC) $(CFLAGS) /c ../snes/snes.cpp
 
-############
-### srtc ###
-############
+#####################
+### special chips ###
+#####################
 srtc.obj: ../chip/srtc/*.cpp ../chip/srtc/*.h
 	$(CC) $(CFLAGS) /c ../chip/srtc/srtc.cpp
 
-############
-### sdd1 ###
-############
 sdd1.obj: ../chip/sdd1/*.cpp ../chip/sdd1/*.h
 	$(CC) $(CFLAGS) /c ../chip/sdd1/sdd1.cpp
+
+c4.obj: ../chip/c4/*.cpp ../chip/c4/*.h
+	$(CC) $(CFLAGS) /c ../chip/c4/c4.cpp
+
+############
+### zlib ###
+############
+adler32.obj: ../reader/zlib/*.c ../reader/zlib/*.h
+	$(CC) $(CFLAGS) /c ../reader/zlib/*.c
+
+###########
+### jma ###
+###########
+jma.obj: ../reader/jma/*.cpp ../reader/jma/*.h
+	$(CC) $(CFLAGS) /c ../reader/jma/*.cpp
diff --git a/src/win/audio/audio.h b/src/win/audio/audio.h
new file mode 100644
index 00000000..3d0b0d55
--- /dev/null
+++ b/src/win/audio/audio.h
@@ -0,0 +1,13 @@
+class Audio {
+public:
+uint32 frequency;
+  virtual void run(uint32 sample) = 0;
+  virtual void set_frequency(uint32 new_freq) = 0;
+  virtual void clear_audio() = 0;
+  virtual void init() = 0;
+  virtual void term() = 0;
+
+  Audio() { frequency = 32000; }
+};
+
+#include "dsound.h"
diff --git a/src/win/audio/dsound.cpp b/src/win/audio/dsound.cpp
new file mode 100644
index 00000000..6ebf5f1b
--- /dev/null
+++ b/src/win/audio/dsound.cpp
@@ -0,0 +1,108 @@
+void AudioDS::run(uint32 sample) {
+  data.buffer[data.buffer_pos++] = sample;
+
+  if(data.buffer_pos >= data.samples_per_frame) {
+  uint32 pos, size;
+  void  *buffer;
+    if((bool)config::system.regulate_speed == true) {
+      do {
+      //see if video refresh is needed
+        uiVideo->scanline();
+        dsb_b->GetCurrentPosition(&pos, 0);
+        data.read_buffer = pos / data.buffer_size;
+      } while(data.read_buffer == data.prev_buffer);
+    }
+
+    data.prev_buffer = data.read_buffer;
+    data.read_buffer++;
+    data.read_buffer &= 7;
+
+    pos = (data.read_buffer + 1) & 7;
+
+    if(dsb_b->Lock(pos * data.buffer_size,
+    data.buffer_size, &buffer, &size, 0, 0, 0) == DS_OK) {
+      memcpy(buffer, data.buffer, data.buffer_size);
+      dsb_b->Unlock(buffer, size, 0, 0);
+    }
+
+    data.buffer_pos = 0;
+  }
+}
+
+void AudioDS::set_frequency(uint32 new_freq) {
+  frequency = new_freq;
+  init();
+}
+
+void AudioDS::clear_audio() {
+  data.read_buffer = 0;
+  data.prev_buffer = 0;
+  data.buffer_pos  = 0;
+  memset(data.buffer, 0, 2048 * 4);
+
+  if(!dsb_b)return;
+
+  dsb_b->Stop();
+  dsb_b->SetCurrentPosition(0);
+
+uint32 size;
+void  *buffer;
+  dsb_b->Lock(0, data.buffer_size * 8, &buffer, &size, 0, 0, 0);
+  memset(buffer, 0, data.buffer_size * 8);
+  dsb_b->Unlock(buffer, size, 0, 0);
+
+  dsb_b->Play(0, 0, DSBPLAY_LOOPING);
+}
+
+void AudioDS::init() {
+  clear_audio();
+  term();
+
+  data.samples_per_frame = frequency / ((snes->region() == SNES::NTSC) ? 60 : 50);
+  data.buffer_size       = data.samples_per_frame * 4;
+
+  DirectSoundCreate(0, &ds, 0);
+  ds->SetCooperativeLevel(wMain.hwnd, DSSCL_PRIORITY);
+
+  memset(&dsbd, 0, sizeof(dsbd));
+  dsbd.dwSize        = sizeof(dsbd);
+  dsbd.dwFlags       = DSBCAPS_PRIMARYBUFFER;
+  dsbd.dwBufferBytes = 0;
+  dsbd.lpwfxFormat   = 0;
+  ds->CreateSoundBuffer(&dsbd, &dsb_p, 0);
+
+  memset(&wfx, 0, sizeof(wfx));
+  wfx.wFormatTag      = WAVE_FORMAT_PCM;
+  wfx.nChannels       = 2;
+  wfx.nSamplesPerSec  = frequency;
+  wfx.wBitsPerSample  = 16;
+  wfx.nBlockAlign     = wfx.wBitsPerSample / 8 * wfx.nChannels;
+  wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
+  dsb_p->SetFormat(&wfx);
+
+  memset(&dsbd, 0, sizeof(dsbd));
+  dsbd.dwSize          = sizeof(dsbd);
+  dsbd.dwFlags         = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_CTRLFREQUENCY |
+                         DSBCAPS_GLOBALFOCUS | DSBCAPS_LOCSOFTWARE;
+  dsbd.dwBufferBytes   = data.buffer_size * 8;
+  dsbd.guid3DAlgorithm = GUID_NULL;
+  dsbd.lpwfxFormat     = &wfx;
+  ds->CreateSoundBuffer(&dsbd, &dsb_b, 0);
+  dsb_b->SetFrequency(frequency);
+  dsb_b->SetCurrentPosition(0);
+
+uint32 size;
+void  *buffer;
+  dsb_b->Lock(0, data.buffer_size * 8, &buffer, &size, 0, 0, 0);
+  memset(buffer, 0, data.buffer_size * 8);
+  dsb_b->Unlock(buffer, size, 0, 0);
+
+  data.read_buffer = 0;
+  dsb_b->Play(0, 0, DSBPLAY_LOOPING);
+}
+
+void AudioDS::term() {
+  if(dsb_b) { dsb_b->Stop(); dsb_b->Release(); dsb_b = 0; }
+  if(dsb_p) { dsb_p->Stop(); dsb_p->Release(); dsb_p = 0; }
+  if(ds) { ds->Release(); ds = 0; }
+}
diff --git a/src/win/audio/dsound.h b/src/win/audio/dsound.h
new file mode 100644
index 00000000..aaf20d8e
--- /dev/null
+++ b/src/win/audio/dsound.h
@@ -0,0 +1,32 @@
+#include <dsound.h>
+
+class AudioDS : public Audio {
+public:
+LPDIRECTSOUND ds;
+LPDIRECTSOUNDBUFFER dsb_p, dsb_b;
+DSBUFFERDESC dsbd;
+WAVEFORMATEX wfx;
+uint32 buffer_size;
+
+struct {
+  uint32 buffer[16384];
+  uint8  read_buffer, prev_buffer;
+  uint32 buffer_pos, buffer_size;
+
+  uint32 samples_per_frame;
+} data;
+  void run(uint32 sample);
+  void set_frequency(uint32 new_freq);
+  void clear_audio();
+  void init();
+  void term();
+
+  AudioDS() {
+    ds          = 0;
+    dsb_p       = 0;
+    dsb_b       = 0;
+    buffer_size = 0;
+  }
+
+  ~AudioDS() { term(); }
+};
diff --git a/src/win/bsnes.cpp b/src/win/bsnes.cpp
index 826e1128..bea4bb18 100644
--- a/src/win/bsnes.cpp
+++ b/src/win/bsnes.cpp
@@ -1,5 +1,7 @@
+uint32 bSNES::get_state() { return state; }
+void bSNES::set_state(uint32 new_state) { state = new_state; }
+
 void bSNES::power() {
-  ds_sound->init();
   SNES::power();
 }
 
@@ -7,116 +9,18 @@ void bSNES::reset() {
   SNES::reset();
 }
 
-void bSNES::set_status(uint32 new_status) {
-uint8 cpu_op;
-  run_status = new_status;
-
-  switch(new_status) {
-  case STOP:
-    w_console->is_running(false);
-    w_console->update_status();
-    w_memory->refresh();
-    break;
-  case RUNTOCPUSTEP:
-    status.cpu_ran = false;
-    break;
-  case RUNTOCPUPROCEED:
-    cpu_op = r_mem->read(r_cpu->regs.pc.d);
-
-    if(cpu_op == 0x10 || //bpl rel
-       cpu_op == 0x30 || //bmi rel
-       cpu_op == 0x50 || //bvc rel
-       cpu_op == 0x70 || //bvs rel
-       cpu_op == 0x90 || //bcc rel
-       cpu_op == 0xb0 || //bcs rel
-       cpu_op == 0xd0 || //bne rel
-       cpu_op == 0xf0 || //beq rel
-       cpu_op == 0x20 || //jsr addr
-       cpu_op == 0x22 || //jsl long
-       cpu_op == 0xfc    //jsr (addr,x)
-    ) {
-      w_console->is_running(true);
-      status.cpu_stop_pos = (r_cpu->regs.pc.b << 16) | ((r_cpu->regs.pc.d + r_cpu->opcode_length()) & 0xffff);
-    } else {
-      status.cpu_ran = false;
-      run_status     = RUNTOCPUSTEP;
-    }
-    break;
-  case RUNTOAPUSTEP:
-    status.apu_ran = false;
-    break;
-  }
-}
-
-uint32 bSNES::get_status() {
-  return run_status;
+void bSNES::scanline() {
+  SNES::scanline();
+  uiVideo->scanline();
 }
 
 void bSNES::run() {
-  if(!rom_image->loaded())return;
-
-  switch(run_status) {
-  case RUN:
-    SNES::runtoframe();
+  if(!r_mem->cart_loaded() || state == PAUSE) {
+    Sleep(1);
     return;
-  case STOP:
-    break;
-  case RUNONCE:
-    SNES::run();
-    set_status(STOP);
-    break;
-  case RUNTOSIGNAL:
-    SNES::run();
-    if(w_bp->hit() == true) {
-      set_status(STOP);
-      disassemble_bp_op();
-    }
-    break;
-  case RUNTOFRAME:
-    SNES::run();
-    if(r_ppu->status.frame_executed == true) {
-      r_ppu->status.frame_executed = false;
-      set_status(STOP);
-      disassemble_apu_op();
-      disassemble_cpu_op();
-    } else if(w_bp->hit() == true) {
-      set_status(STOP);
-      disassemble_bp_op();
-    }
-    return;
-  case RUNTOCPUSTEP:
-    SNES::run();
-    if(status.cpu_ran == true) {
-      set_status(STOP);
-    } else if(w_bp->hit() == true) {
-      set_status(STOP);
-      disassemble_bp_op();
-    }
-    break;
-  case RUNTOCPUPROCEED:
-    SNES::run();
-    if(r_cpu->in_opcode() == false && status.cpu_stop_pos == r_cpu->regs.pc.d) {
-      set_status(STOP);
-      disassemble_cpu_op();
-    } else if(w_bp->hit() == true) {
-      set_status(STOP);
-      disassemble_bp_op();
-    }
-    break;
-  case RUNTOCPUTRACE:
-    SNES::run();
-    if(status.cpu_trace_pos >= status.cpu_trace_stop) {
-      set_status(STOP);
-      disassemble_cpu_op();
-    }
-    break;
-  case RUNTOAPUSTEP:
-    SNES::run();
-    if(status.apu_ran == true || w_bp->hit() == true) {
-      set_status(STOP);
-    }
-    break;
   }
+
+  SNES::runtoframe();
 }
 
 void bSNES::video_run() {
@@ -125,446 +29,60 @@ void bSNES::video_run() {
     r_ppu->status.frames_updated = false;
     if((bool)config::gui.show_fps == true) {
       sprintf(s, "%s : %d fps", BSNES_TITLE, r_ppu->status.frames_executed);
-      if(w_main->frameskip != 0) {
+      if(wMain.frameskip != 0) {
         sprintf(t, " (%d frames)", r_ppu->status.frames_rendered);
         strcat(s, t);
       }
-      SetWindowText(w_main->hwnd, s);
+      SetWindowText(wMain.hwnd, s);
     }
   }
 
-  w_main->frameskip_pos++;
-  w_main->frameskip_pos %= (w_main->frameskip + 1);
-  if(r_ppu->renderer_enabled())dd_renderer->update();
-  r_ppu->enable_renderer(w_main->frameskip_pos == 0);
+  wMain.frameskip_pos++;
+  wMain.frameskip_pos %= (wMain.frameskip + 1);
+  if(r_ppu->renderer_enabled())uiVideo->update();
+  r_ppu->enable_renderer(wMain.frameskip_pos == 0);
 }
 
 void bSNES::sound_run(uint32 data) {
-  ds_sound->run(data);
+  uiAudio->run(data);
 }
 
-/***********************
- *** Video functions ***
- ***********************/
 uint16 *bSNES::video_lock(uint32 &pitch) {
-  return dd_renderer->lock(pitch);
+  return uiVideo->lock(pitch);
 }
 
 void bSNES::video_unlock() {
-  dd_renderer->unlock();
-}
-
-/***********************
- *** Input functions ***
- ***********************/
-void bSNES::clear_input() {
-  joypad1.up     = joypad2.up =
-  joypad1.down   = joypad2.down =
-  joypad1.left   = joypad2.left =
-  joypad1.right  = joypad2.right =
-  joypad1.a      = joypad2.a =
-  joypad1.b      = joypad2.b =
-  joypad1.x      = joypad2.x =
-  joypad1.y      = joypad2.y =
-  joypad1.l      = joypad2.l =
-  joypad1.r      = joypad2.r =
-  joypad1.select = joypad2.select =
-  joypad1.start  = joypad2.start = 0;
+  uiVideo->unlock();
 }
 
 void bSNES::poll_input(uint8 type) {
-//only capture input when main window has focus
-  if(GetForegroundWindow() == w_main->hwnd) {
-    switch(type) {
-    case SNES::DEV_JOYPAD1:
-      joypad1.up     = KeyDown(config::input.joypad1.up);
-      joypad1.down   = KeyDown(config::input.joypad1.down);
-      joypad1.left   = KeyDown(config::input.joypad1.left);
-      joypad1.right  = KeyDown(config::input.joypad1.right);
-      joypad1.select = KeyDown(config::input.joypad1.select);
-      joypad1.start  = KeyDown(config::input.joypad1.start);
-      joypad1.y      = KeyDown(config::input.joypad1.y);
-      joypad1.b      = KeyDown(config::input.joypad1.b);
-      joypad1.x      = KeyDown(config::input.joypad1.x);
-      joypad1.a      = KeyDown(config::input.joypad1.a);
-      joypad1.l      = KeyDown(config::input.joypad1.l);
-      joypad1.r      = KeyDown(config::input.joypad1.r);
-      break;
-    case SNES::DEV_JOYPAD2:
-      joypad2.up     = KeyDown(config::input.joypad2.up);
-      joypad2.down   = KeyDown(config::input.joypad2.down);
-      joypad2.left   = KeyDown(config::input.joypad2.left);
-      joypad2.right  = KeyDown(config::input.joypad2.right);
-      joypad2.select = KeyDown(config::input.joypad2.select);
-      joypad2.start  = KeyDown(config::input.joypad2.start);
-      joypad2.y      = KeyDown(config::input.joypad2.y);
-      joypad2.b      = KeyDown(config::input.joypad2.b);
-      joypad2.x      = KeyDown(config::input.joypad2.x);
-      joypad2.a      = KeyDown(config::input.joypad2.a);
-      joypad2.l      = KeyDown(config::input.joypad2.l);
-      joypad2.r      = KeyDown(config::input.joypad2.r);
-      break;
+  uiInput->poll(type);
+
+  if((bool)config::input.joypad1.allow_invalid_input == false) {
+    if(uiInput->get_status(DEV_JOYPAD1, JOYPAD_UP) &&
+       uiInput->get_status(DEV_JOYPAD1, JOYPAD_DOWN)) {
+      uiInput->set_status(DEV_JOYPAD1, JOYPAD_DOWN, false);
     }
-  } else {
-    switch(type) {
-    case SNES::DEV_JOYPAD1:
-      joypad1.up = joypad1.down = joypad1.left = joypad1.right =
-      joypad1.select = joypad1.start =
-      joypad1.y = joypad1.b = joypad1.x = joypad1.a =
-      joypad1.l = joypad1.r = 0;
-      break;
-    case SNES::DEV_JOYPAD2:
-      joypad2.up = joypad2.down = joypad2.left = joypad2.right =
-      joypad2.select = joypad2.start =
-      joypad2.y = joypad2.b = joypad2.x = joypad2.a =
-      joypad1.l = joypad2.r = 0;
-      break;
+
+    if(uiInput->get_status(DEV_JOYPAD1, JOYPAD_LEFT) &&
+       uiInput->get_status(DEV_JOYPAD1, JOYPAD_RIGHT)) {
+      uiInput->set_status(DEV_JOYPAD1, JOYPAD_RIGHT, false);
     }
   }
 
-//check for debugger-based key locks
-  if(is_debugger_enabled == true && type == SNES::DEV_JOYPAD1) {
-    if(w_console->joypad_lock.up    )joypad1.up     = true;
-    if(w_console->joypad_lock.down  )joypad1.down   = true;
-    if(w_console->joypad_lock.left  )joypad1.left   = true;
-    if(w_console->joypad_lock.right )joypad1.right  = true;
-    if(w_console->joypad_lock.a     )joypad1.a      = true;
-    if(w_console->joypad_lock.b     )joypad1.b      = true;
-    if(w_console->joypad_lock.x     )joypad1.x      = true;
-    if(w_console->joypad_lock.y     )joypad1.y      = true;
-    if(w_console->joypad_lock.l     )joypad1.l      = true;
-    if(w_console->joypad_lock.r     )joypad1.r      = true;
-    if(w_console->joypad_lock.select)joypad1.select = true;
-    if(w_console->joypad_lock.start )joypad1.start  = true;
+  if((bool)config::input.joypad2.allow_invalid_input == false) {
+    if(uiInput->get_status(DEV_JOYPAD2, JOYPAD_UP) &&
+       uiInput->get_status(DEV_JOYPAD2, JOYPAD_DOWN)) {
+      uiInput->set_status(DEV_JOYPAD2, JOYPAD_DOWN, false);
+    }
+
+    if(uiInput->get_status(DEV_JOYPAD2, JOYPAD_LEFT) &&
+       uiInput->get_status(DEV_JOYPAD2, JOYPAD_RIGHT)) {
+      uiInput->set_status(DEV_JOYPAD2, JOYPAD_RIGHT, false);
+    }
   }
-
-//it's impossible to hold both up+down, or left+right down
-//at the same time on a directional pad; and besides, allowing
-//this to happen causes glitches in many SNES games.
-  if(joypad1.up)  joypad1.down  = 0;
-  if(joypad1.left)joypad1.right = 0;
-
-  if(joypad2.up)  joypad2.down  = 0;
-  if(joypad2.left)joypad2.right = 0;
 }
 
 bool bSNES::get_input_status(uint8 device, uint8 button) {
-  switch(device) {
-  case DEV_JOYPAD1:
-    switch(button) {
-    case JOYPAD_UP:    return joypad1.up;
-    case JOYPAD_DOWN:  return joypad1.down;
-    case JOYPAD_LEFT:  return joypad1.left;
-    case JOYPAD_RIGHT: return joypad1.right;
-    case JOYPAD_A:     return joypad1.a;
-    case JOYPAD_B:     return joypad1.b;
-    case JOYPAD_X:     return joypad1.x;
-    case JOYPAD_Y:     return joypad1.y;
-    case JOYPAD_L:     return joypad1.l;
-    case JOYPAD_R:     return joypad1.r;
-    case JOYPAD_SELECT:return joypad1.select;
-    case JOYPAD_START: return joypad1.start;
-    }
-    break;
-  case DEV_JOYPAD2:
-    switch(button) {
-    case JOYPAD_UP:    return joypad2.up;
-    case JOYPAD_DOWN:  return joypad2.down;
-    case JOYPAD_LEFT:  return joypad2.left;
-    case JOYPAD_RIGHT: return joypad2.right;
-    case JOYPAD_A:     return joypad2.a;
-    case JOYPAD_B:     return joypad2.b;
-    case JOYPAD_X:     return joypad2.x;
-    case JOYPAD_Y:     return joypad2.y;
-    case JOYPAD_L:     return joypad2.l;
-    case JOYPAD_R:     return joypad2.r;
-    case JOYPAD_SELECT:return joypad2.select;
-    case JOYPAD_START: return joypad2.start;
-    }
-    break;
-  }
-
-  return 0;
-}
-
-bJoypad::bJoypad() {
-  up = down = left = right = false;
-  a = b = x = y = false;
-  l = r = select = start = false;
-}
-
-/***************************
- *** Debugging functions ***
- ***************************/
-uint8 bSNES::read(uint8 type, uint32 addr) {
-uint32 bank, a;
-uint8  r = 0x00;
-  debug_command = true;
-  switch(type) {
-  case DRAM:
-    addr &= 0xffffff;
-    bank = (addr >> 16) & 0xff;
-    a = addr & 0xffff;
-    if((bank >= 0x00 && bank <= 0x3f) ||
-       (bank >= 0x80 && bank <= 0xbf)) {
-    //don't let the debugger poll MMIO ports
-      if(a >= 0x2000 && a <= 0x5fff) {
-        r = 0x00;
-      } else {
-        r = r_mem->read(addr);
-      }
-    } else {
-      r = r_mem->read(addr);
-    }
-    break;
-  case SPCRAM:
-    addr &= 0xffff;
-    r = r_apu->spcram_read(addr);
-    break;
-  case VRAM:
-    addr &= 0xffff;
-    r = r_ppu->vram_read(addr);
-    break;
-  case OAM:
-    addr &= 0x03ff;
-    r = r_ppu->oam_read(addr);
-    break;
-  case CGRAM:
-    addr &= 0x01ff;
-    r = r_ppu->cgram_read(addr);
-    break;
-  }
-  debug_command = false;
-  return r;
-}
-
-void bSNES::write(uint8 type, uint32 addr, uint8 value) {
-  debug_command = true;
-  switch(type) {
-  case DRAM:
-    addr &= 0xffffff;
-    r_mem->cart->write_protect(false);
-    r_mem->write(addr, value);
-    r_mem->cart->write_protect(true);
-    break;
-  case SPCRAM:
-    addr &= 0xffff;
-    r_apu->spcram_write(addr, value);
-    break;
-  case VRAM:
-    addr &= 0xffff;
-    r_ppu->vram_write(addr, value);
-    break;
-  case OAM:
-    addr &= 0x03ff;
-    r_ppu->oam_write(addr, value);
-    break;
-  case CGRAM:
-    addr &= 0x01ff;
-    r_ppu->cgram_write(addr, value);
-    break;
-  }
-  debug_command = false;
-}
-
-void bSNES::notify(uint32 message, uint32 param1, uint32 param2) {
-//debugging messages
-  if(is_debugger_enabled == false)return;
-
-  switch(message) {
-  case CPU_EXEC_OPCODE_BEGIN:
-    break;
-  case CPU_EXEC_OPCODE_END:
-    status.cpu_ran = true;
-    status.cpu_trace_pos++;
-  //test next opcode for breakpoint
-    w_bp->test(message, r_cpu->regs.pc.d, 0);
-    disassemble_cpu_op();
-    break;
-  case APU_EXEC_OPCODE_BEGIN:
-    break;
-  case APU_EXEC_OPCODE_END:
-    status.apu_ran = true;
-    w_bp->test(message, r_apu->regs.pc, 0);
-    disassemble_apu_op();
-    break;
-  case MEM_READ:
-  case SPCRAM_READ:
-  case VRAM_READ:
-  case OAM_READ:
-  case CGRAM_READ:
-    if(debug_command == false) {
-      w_bp->test(message, param1, param2);
-    }
-    break;
-  case MEM_WRITE:
-  case SPCRAM_WRITE:
-  case VRAM_WRITE:
-  case OAM_WRITE:
-  case CGRAM_WRITE:
-    if(debug_command == false) {
-      w_bp->test(message, param1, param2);
-    }
-  //this needs to be called after the breakpoint test,
-  //as it will access read() and clear debug_command
-    w_memory->refresh(message, param1);
-    break;
-  }
-}
-
-void bSNES::disassemble_cpu_op() {
-char t[512];
-//don't disassemble opcodes when no ROM is loaded
-  if(is_debugger_activated == false)return;
-
-//don't disassemble opcodes that won't be printed to console/traced to log anyway
-  if(!w_console->can_write(Console::CPU_MESSAGE) && !w_console->tracing_enabled)return;
-
-  r_cpu->disassemble_opcode(t);
-  w_console->write(t, Console::CPU_MESSAGE);
-}
-
-void bSNES::disassemble_apu_op() {
-char t[512];
-  if(is_debugger_activated == false)return;
-
-  if(!w_console->can_write(Console::APU_MESSAGE) && !w_console->tracing_enabled)return;
-
-  r_apu->disassemble_opcode(t);
-  w_console->write(t, Console::APU_MESSAGE);
-}
-
-void bSNES::disassemble_bp_op() {
-  if(w_bp->bp[w_bp->bp_hit_num].source == SPCRAM) {
-    disassemble_apu_op();
-  } else {
-    disassemble_cpu_op();
-  }
-}
-
-bool bSNES::debugger_enabled() {
-  return is_debugger_enabled;
-}
-
-void bSNES::debugger_enable() {
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_DEBUGGER, MF_CHECKED);
-  set_status(bSNES::STOP);
-
-  w_console->is_running(false);
-  w_console->update_status();
-  w_console->show();
-
-  w_bp->refresh();
-  w_bp->show();
-
-  w_memory->edit_mode = MemoryEditor::MODE_DRAM;
-  w_memory->edit_addr = 0x7e0000;
-  w_memory->edit_mask = 0xffffff;
-  SendDlgItemMessage(w_memory->hwnd, MEMORYEDITOR_MODE, CB_SETCURSEL, 0, 0);
-  w_memory->refresh();
-  w_memory->show();
-
-  debugger_update();
-  is_debugger_enabled = true;
-}
-
-void bSNES::debugger_disable() {
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_DEBUGGER, MF_UNCHECKED);
-  w_console->hide();
-  w_bp->hide();
-  w_memory->hide();
-  is_debugger_enabled = false;
-  set_status(bSNES::RUN);
-}
-
-void bSNES::debugger_update() {
-  w_console->update_status();
-  w_bp->refresh();
-  w_memory->refresh();
-  disassemble_apu_op();
-  disassemble_cpu_op();
-}
-
-bool bSNES::debugger_activated() {
-  return is_debugger_activated;
-}
-
-void bSNES::debugger_activate() {
-HWND hwnd;
-uint32 i, style;
-  for(i=0;i<100;i++) {
-    if(w_console->ctl_disabled[i] == true)continue;
-    hwnd = GetDlgItem(w_console->hwnd, i + 100);
-    if(!hwnd)continue;
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    style &= ~WS_DISABLED;
-    SetWindowLong(hwnd, GWL_STYLE, style);
-  }
-  InvalidateRect(w_console->hwnd, 0, TRUE);
-
-  for(i=0;i<100;i++) {
-    if(w_bp->ctl_disabled[i] == true)continue;
-    hwnd = GetDlgItem(w_bp->hwnd, i + 100);
-    if(!hwnd)continue;
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    style &= ~WS_DISABLED;
-    SetWindowLong(hwnd, GWL_STYLE, style);
-  }
-  InvalidateRect(w_bp->hwnd, 0, TRUE);
-
-  for(i=0;i<100;i++) {
-    if(w_memory->ctl_disabled[i] == true)continue;
-    hwnd = GetDlgItem(w_memory->hwnd, i + 100);
-    if(!hwnd)continue;
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    style &= ~WS_DISABLED;
-    SetWindowLong(hwnd, GWL_STYLE, style);
-  }
-  InvalidateRect(w_memory->hwnd, 0, TRUE);
-
-  is_debugger_activated = true;
-}
-
-void bSNES::debugger_deactivate() {
-HWND hwnd;
-uint32 i, style;
-  for(i=0;i<100;i++) {
-    hwnd = GetDlgItem(w_console->hwnd, i + 100);
-    if(!hwnd)continue;
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    style |= WS_DISABLED;
-    SetWindowLong(hwnd, GWL_STYLE, style);
-  }
-  w_console->clear();
-  InvalidateRect(w_console->hwnd, 0, TRUE);
-
-  for(i=0;i<100;i++) {
-    hwnd = GetDlgItem(w_bp->hwnd, i + 100);
-    if(!hwnd)continue;
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    style |= WS_DISABLED;
-    SetWindowLong(hwnd, GWL_STYLE, style);
-  }
-  w_bp->clear();
-  InvalidateRect(w_bp->hwnd, 0, TRUE);
-
-
-  for(i=0;i<100;i++) {
-    hwnd = GetDlgItem(w_memory->hwnd, i + 100);
-    if(!hwnd)continue;
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    style |= WS_DISABLED;
-    SetWindowLong(hwnd, GWL_STYLE, style);
-  }
-  w_memory->clear();
-  InvalidateRect(w_memory->hwnd, 0, TRUE);
-
-  is_debugger_activated = false;
-}
-
-bSNES::bSNES() {
-  run_status    = STOP;
-  debug_command = false;
-
-  debugger_disable();
+  return uiInput->get_status(device, button);
 }
diff --git a/src/win/bsnes.h b/src/win/bsnes.h
index 054246ca..c9cd3bdc 100644
--- a/src/win/bsnes.h
+++ b/src/win/bsnes.h
@@ -1,83 +1,30 @@
-class bJoypad {
-public:
-bool up, down, left, right;
-bool a, b, x, y;
-bool l, r, select, start;
-  bJoypad();
-};
-
 class bSNES : public SNES {
-private:
-//If true, indicates a ROM is loaded and debugger output
-//is possible.
-bool is_debugger_activated;
-
-//When true, notify() ignores read/write requests, as they
-//have been generated by the debugging interface and not by
-//the emulator.
-bool debug_command;
-uint32 run_status;
-
-bJoypad joypad1, joypad2;
-
 public:
+uint32 state;
 enum {
-  STOP = 0,
-  RUN,
-  RUNONCE,
-  RUNTOSIGNAL,
-  RUNTOFRAME,
-  RUNTOCPUSTEP,
-  RUNTOCPUPROCEED,
-  RUNTOCPUTRACE,
-  RUNTOAPUSTEP
+  RUN, PAUSE
 };
-enum { DRAM = 0, SPCRAM = 1, VRAM = 2, OAM = 3, CGRAM = 4 };
-  void   power();
-  void   reset();
+  uint32  get_state();
+  void    set_state(uint32 new_state);
 
-  void   run();
-  void   video_run();
-  void   sound_run(uint32 data);
+  void    power();
+  void    reset();
 
-  void   set_status(uint32 new_status);
-  uint32 get_status();
+  void    scanline();
+
+  void    run();
+  void    video_run();
+  void    sound_run(uint32 data);
 
 //video functions
   uint16 *video_lock(uint32 &pitch);
   void    video_unlock();
 
 //input functions
-  void clear_input();
-  void poll_input(uint8 type);
-  bool get_input_status(uint8 device, uint8 button);
+  void    poll_input(uint8 type);
+  bool    get_input_status(uint8 device, uint8 button);
 
-//debugging functions
-struct {
-  uint32 cpu_stop_pos;
-  uint32 cpu_trace_pos, cpu_trace_stop;
-  bool   cpu_ran, apu_ran;
-}status;
-  uint8 read (uint8 type, uint32 addr);
-  void  write(uint8 type, uint32 addr, uint8 value);
-  void  notify(uint32 message, uint32 param1 = 0, uint32 param2 = 0);
-  void  disassemble_cpu_op();
-  void  disassemble_apu_op();
-  void  disassemble_bp_op();
-
-//whether or not the user requests the debugger open
-  bool  debugger_enabled();
-  void  debugger_enable();
-  void  debugger_disable();
-  void  debugger_update();
-
-//whether or not the debugger *can* be used
-//e.g., debugger cannot be used without ROM loaded
-  bool  debugger_activated();
-  void  debugger_activate();
-  void  debugger_deactivate();
-
-  bSNES();
+  bSNES() { state = RUN; }
 };
 
 bSNES *bsnes;
diff --git a/src/win/bsnes.lnk b/src/win/bsnes.lnk
index b3f084ab..d997f525 100644
Binary files a/src/win/bsnes.lnk and b/src/win/bsnes.lnk differ
diff --git a/src/win/bsnes.rc b/src/win/bsnes.rc
index 08f24c00..54c6ab71 100644
--- a/src/win/bsnes.rc
+++ b/src/win/bsnes.rc
@@ -1,5 +1,3 @@
-#define IDB_SNES_CONTROLLER 100
-#define IDI_APP_ICON        101
+#define IDI_APP_ICON 100
 
-IDB_SNES_CONTROLLER BITMAP DISCARDABLE "snes_controller.bmp"
-IDI_APP_ICON        ICON   DISCARDABLE "bsnes.ico"
+IDI_APP_ICON  ICON  DISCARDABLE  "bsnes.ico"
diff --git a/src/win/bsnes.res b/src/win/bsnes.res
deleted file mode 100644
index 412d6082..00000000
Binary files a/src/win/bsnes.res and /dev/null differ
diff --git a/src/win/config.cpp b/src/win/config.cpp
index 8d238f06..b63dd7bc 100644
--- a/src/win/config.cpp
+++ b/src/win/config.cpp
@@ -2,22 +2,34 @@ namespace config {
 
 struct System {
   static Setting regulate_speed;
+  static Setting speed_slowest, speed_slow, speed_normal, speed_fast, speed_fastest;
 } system;
 Setting System::regulate_speed(&config_file, "system.regulate_speed", "Regulate speed to 60hz (NTSC) / 50hz (PAL)", true, Setting::TRUE_FALSE);
+Setting System::speed_slowest(&config_file, "system.speed_slowest", "Slowest speed setting (in hz)", 16000, Setting::DEC);
+Setting System::speed_slow   (&config_file, "system.speed_slow",    "Slow speed setting",            24000, Setting::DEC);
+Setting System::speed_normal (&config_file, "system.speed_normal",  "Normal speed setting",          32000, Setting::DEC);
+Setting System::speed_fast   (&config_file, "system.speed_fast",    "Fast speed setting",            48000, Setting::DEC);
+Setting System::speed_fastest(&config_file, "system.speed_fastest", "Fastest speed setting",         64000, Setting::DEC);
 
 struct Video {
-  static Setting mode, use_vram, vblank;
+  static Setting mode;
+  static Setting mode0, mode1, mode2, mode3, mode4;
+  static Setting mode5, mode6, mode7, mode8, mode9;
+  static Setting use_vram, triple_buffering;
 } video;
-Setting Video::mode(&config_file, "video.mode",
-  "Video mode\n"
-  "  0 = 256x224w\n"
-  "  1 = 512x448w\n"
-  "  2 = 960x720w\n"
-  "  3 = 640x480f\n"
-  "  4 = 1024x768f",
-  1, Setting::DEC);
+Setting Video::mode(&config_file, "video.mode", "Video mode at startup", 2, Setting::DEC);
+Setting Video::mode0(&config_file, "video.mode_0", "Video mode 0 (windowed)",   "256x223");
+Setting Video::mode1(&config_file, "video.mode_1", "Video mode 1 (windowed)",   "512x446");
+Setting Video::mode2(&config_file, "video.mode_2", "Video mode 2 (windowed)",   "640x480");
+Setting Video::mode3(&config_file, "video.mode_3", "Video mode 3 (windowed)",   "960x720");
+Setting Video::mode4(&config_file, "video.mode_4", "Video mode 4 (windowed)",   "1152x864");
+Setting Video::mode5(&config_file, "video.mode_5", "Video mode 5 (fullscreen)", "640x480@60:640x480");
+Setting Video::mode6(&config_file, "video.mode_6", "Video mode 6 (fullscreen)", "800x600@60:800x600");
+Setting Video::mode7(&config_file, "video.mode_7", "Video mode 7 (fullscreen)", "1024x768@60:1024x768");
+Setting Video::mode8(&config_file, "video.mode_8", "Video mode 8 (fullscreen)", "1280x960@60:1280x960");
+Setting Video::mode9(&config_file, "video.mode_9", "Video mode 9 (fullscreen)", "1600x1200@60:1600x1200");
 Setting Video::use_vram(&config_file, "video.use_vram", "Use Video RAM instead of System RAM", true, Setting::TRUE_FALSE);
-Setting Video::vblank(&config_file, "video.vblank", "Wait for vertical retrace when updating screen", false, Setting::TRUE_FALSE);
+Setting Video::triple_buffering(&config_file, "video.triple_buffering", "Use triple buffering", false, Setting::TRUE_FALSE);
 
 struct GUI {
   static Setting show_fps;
@@ -26,35 +38,43 @@ Setting GUI::show_fps(&config_file, "gui.show_fps", "Show framerate in window ti
 
 struct Input {
   struct Joypad1 {
+    static Setting allow_invalid_input;
     static Setting up, down, left, right, a, b, x, y, l, r, select, start;
   } joypad1;
   struct Joypad2 {
+    static Setting allow_invalid_input;
     static Setting up, down, left, right, a, b, x, y, l, r, select, start;
   } joypad2;
 } input;
-Setting Input::Joypad1::up    (&config_file, "input.joypad1.up",     "Joypad1 up",     VK_UP,     Setting::HEX);
-Setting Input::Joypad1::down  (&config_file, "input.joypad1.down",   "Joypad1 down",   VK_DOWN,   Setting::HEX);
-Setting Input::Joypad1::left  (&config_file, "input.joypad1.left",   "Joypad1 left",   VK_LEFT,   Setting::HEX);
-Setting Input::Joypad1::right (&config_file, "input.joypad1.right",  "Joypad1 right",  VK_RIGHT,  Setting::HEX);
-Setting Input::Joypad1::a     (&config_file, "input.joypad1.a",      "Joypad1 A",      'X',       Setting::HEX);
-Setting Input::Joypad1::b     (&config_file, "input.joypad1.b",      "Joypad1 B",      'Z',       Setting::HEX);
-Setting Input::Joypad1::x     (&config_file, "input.joypad1.x",      "Joypad1 X",      'S',       Setting::HEX);
-Setting Input::Joypad1::y     (&config_file, "input.joypad1.y",      "Joypad1 Y",      'A',       Setting::HEX);
-Setting Input::Joypad1::l     (&config_file, "input.joypad1.l",      "Joypad1 L",      'D',       Setting::HEX);
-Setting Input::Joypad1::r     (&config_file, "input.joypad1.r",      "Joypad1 R",      'C',       Setting::HEX);
-Setting Input::Joypad1::select(&config_file, "input.joypad1.select", "Joypad1 select", VK_SHIFT,  Setting::HEX);
-Setting Input::Joypad1::start (&config_file, "input.joypad1.start",  "Joypad1 start",  VK_RETURN, Setting::HEX);
 
-Setting Input::Joypad2::up    (&config_file, "input.joypad2.up",     "Joypad2 up",     'T', Setting::HEX);
-Setting Input::Joypad2::down  (&config_file, "input.joypad2.down",   "Joypad2 down",   'G', Setting::HEX);
-Setting Input::Joypad2::left  (&config_file, "input.joypad2.left",   "Joypad2 left",   'F', Setting::HEX);
-Setting Input::Joypad2::right (&config_file, "input.joypad2.right",  "Joypad2 right",  'H', Setting::HEX);
-Setting Input::Joypad2::a     (&config_file, "input.joypad2.a",      "Joypad2 A",      'K', Setting::HEX);
-Setting Input::Joypad2::b     (&config_file, "input.joypad2.b",      "Joypad2 B",      'J', Setting::HEX);
-Setting Input::Joypad2::x     (&config_file, "input.joypad2.x",      "Joypad2 X",      'I', Setting::HEX);
-Setting Input::Joypad2::y     (&config_file, "input.joypad2.y",      "Joypad2 Y",      'U', Setting::HEX);
-Setting Input::Joypad2::l     (&config_file, "input.joypad2.l",      "Joypad2 L",      'O', Setting::HEX);
-Setting Input::Joypad2::r     (&config_file, "input.joypad2.r",      "Joypad2 R",      'L', Setting::HEX);
-Setting Input::Joypad2::select(&config_file, "input.joypad2.select", "Joypad2 select", '[', Setting::HEX);
-Setting Input::Joypad2::start (&config_file, "input.joypad2.start",  "Joypad2 start",  ']', Setting::HEX);
+Setting Input::Joypad1::allow_invalid_input(&config_file, "input.joypad1.allow_invalid_input",
+  "Allow \"impossible\" key combinations for joypad 1 (not recommended)", false, Setting::TRUE_FALSE);
+Setting Input::Joypad1::up    (&config_file, "input.joypad1.up",     "Joypad1 up",     0x80c8, Setting::HEX);
+Setting Input::Joypad1::down  (&config_file, "input.joypad1.down",   "Joypad1 down",   0x81d0, Setting::HEX);
+Setting Input::Joypad1::left  (&config_file, "input.joypad1.left",   "Joypad1 left",   0x82cb, Setting::HEX);
+Setting Input::Joypad1::right (&config_file, "input.joypad1.right",  "Joypad1 right",  0x83cd, Setting::HEX);
+Setting Input::Joypad1::a     (&config_file, "input.joypad1.a",      "Joypad1 A",      0x042d, Setting::HEX);
+Setting Input::Joypad1::b     (&config_file, "input.joypad1.b",      "Joypad1 B",      0x032c, Setting::HEX);
+Setting Input::Joypad1::x     (&config_file, "input.joypad1.x",      "Joypad1 X",      0x011f, Setting::HEX);
+Setting Input::Joypad1::y     (&config_file, "input.joypad1.y",      "Joypad1 Y",      0x001e, Setting::HEX);
+Setting Input::Joypad1::l     (&config_file, "input.joypad1.l",      "Joypad1 L",      0x0620, Setting::HEX);
+Setting Input::Joypad1::r     (&config_file, "input.joypad1.r",      "Joypad1 R",      0x072e, Setting::HEX);
+Setting Input::Joypad1::select(&config_file, "input.joypad1.select", "Joypad1 select", 0x0836, Setting::HEX);
+Setting Input::Joypad1::start (&config_file, "input.joypad1.start",  "Joypad1 start",  0x091c, Setting::HEX);
+
+Setting Input::Joypad2::allow_invalid_input(&config_file, "input.joypad2.allow_invalid_input",
+  "Allow \"impossible\" key combinations for joypad 2 (not recommended)", false, Setting::TRUE_FALSE);
+Setting Input::Joypad2::up    (&config_file, "input.joypad2.up",     "Joypad2 up",     0xff14, Setting::HEX);
+Setting Input::Joypad2::down  (&config_file, "input.joypad2.down",   "Joypad2 down",   0xff22, Setting::HEX);
+Setting Input::Joypad2::left  (&config_file, "input.joypad2.left",   "Joypad2 left",   0xff21, Setting::HEX);
+Setting Input::Joypad2::right (&config_file, "input.joypad2.right",  "Joypad2 right",  0xff23, Setting::HEX);
+Setting Input::Joypad2::a     (&config_file, "input.joypad2.a",      "Joypad2 A",      0xff25, Setting::HEX);
+Setting Input::Joypad2::b     (&config_file, "input.joypad2.b",      "Joypad2 B",      0xff24, Setting::HEX);
+Setting Input::Joypad2::x     (&config_file, "input.joypad2.x",      "Joypad2 X",      0xff17, Setting::HEX);
+Setting Input::Joypad2::y     (&config_file, "input.joypad2.y",      "Joypad2 Y",      0xff16, Setting::HEX);
+Setting Input::Joypad2::l     (&config_file, "input.joypad2.l",      "Joypad2 L",      0xff18, Setting::HEX);
+Setting Input::Joypad2::r     (&config_file, "input.joypad2.r",      "Joypad2 R",      0xff26, Setting::HEX);
+Setting Input::Joypad2::select(&config_file, "input.joypad2.select", "Joypad2 select", 0xff1a, Setting::HEX);
+Setting Input::Joypad2::start (&config_file, "input.joypad2.start",  "Joypad2 start",  0xff1b, Setting::HEX);
+
 };
diff --git a/src/win/input/dinput.cpp b/src/win/input/dinput.cpp
new file mode 100644
index 00000000..43ddf966
--- /dev/null
+++ b/src/win/input/dinput.cpp
@@ -0,0 +1,222 @@
+void InputDI::poll_devices() {
+HRESULT hr;
+DIJOYSTATE2 js;
+  memset(keystate, 0, 256);
+  if(di_key) {
+    hr = di_key->GetDeviceState(256, keystate);
+    if(FAILED(hr)) {
+      di_key->Acquire();
+      di_key->GetDeviceState(256, keystate);
+    }
+  }
+
+  memset(joystate, 0, 256);
+  memset(js.rgbButtons, 0, 128);
+  if(di_joy) {
+    hr = di_joy->Poll();
+    if(FAILED(hr)) {
+      di_joy->Acquire();
+      di_joy->Poll();
+    }
+    di_joy->GetDeviceState(sizeof(DIJOYSTATE2), &js);
+    memcpy(joystate, js.rgbButtons, 128);
+
+  //map d-pad axes to joystate[128 - 131]
+    joystate[128] = (js.lY == 0x0000) ? 0x80 : 0x00;
+    joystate[129] = (js.lY == 0xffff) ? 0x80 : 0x00;
+    joystate[130] = (js.lX == 0x0000) ? 0x80 : 0x00;
+    joystate[131] = (js.lX == 0xffff) ? 0x80 : 0x00;
+  }
+}
+
+uint32 InputDI::poll() {
+  if(GetForegroundWindow() != wInputCfg.hwnd)return 0xffff;
+
+  poll_devices();
+  for(int i = 0; i < 256; i++) {
+    if(joystate[i] & 0x80)return (i << 8) | 0xff;
+  }
+  for(int i = 0; i < 256; i++) {
+    if(keystate[i] & 0x80)return 0xff00 | (i);
+  }
+
+  return 0xffff;
+}
+
+void InputDI::poll(uint8 type) {
+HWND fw = GetForegroundWindow();
+  poll_devices();
+
+#define poll_key(__key) \
+  __key = 0; \
+  if(fw == wMain.hwnd) { \
+    if(di_joy && ((uint16)config::input.##__key## & 0xff00) != 0xff00) { \
+      __key |= !!(joystate[(((uint16)config::input.##__key##) >> 8) & 0xff] & 0x80); \
+    } \
+    if(di_key && ((uint16)config::input.##__key## & 0x00ff) != 0x00ff) { \
+      __key |= !!(keystate[((uint16)config::input.##__key##) & 0xff] & 0x80); \
+    } \
+  }
+
+  switch(type) {
+  case SNES::DEV_JOYPAD1:
+    poll_key(joypad1.up);
+    poll_key(joypad1.down);
+    poll_key(joypad1.left);
+    poll_key(joypad1.right);
+    poll_key(joypad1.a);
+    poll_key(joypad1.b);
+    poll_key(joypad1.x);
+    poll_key(joypad1.y);
+    poll_key(joypad1.l);
+    poll_key(joypad1.r);
+    poll_key(joypad1.select);
+    poll_key(joypad1.start);
+    break;
+  case SNES::DEV_JOYPAD2:
+    poll_key(joypad2.up);
+    poll_key(joypad2.down);
+    poll_key(joypad2.left);
+    poll_key(joypad2.right);
+    poll_key(joypad2.a);
+    poll_key(joypad2.b);
+    poll_key(joypad2.x);
+    poll_key(joypad2.y);
+    poll_key(joypad2.l);
+    poll_key(joypad2.r);
+    poll_key(joypad2.select);
+    poll_key(joypad2.start);
+    break;
+  }
+#undef poll_key
+}
+
+bool InputDI::get_status(uint8 device, uint8 button) {
+  switch(device) {
+  case SNES::DEV_JOYPAD1:
+    switch(button) {
+    case SNES::JOYPAD_UP:     return joypad1.up;
+    case SNES::JOYPAD_DOWN:   return joypad1.down;
+    case SNES::JOYPAD_LEFT:   return joypad1.left;
+    case SNES::JOYPAD_RIGHT:  return joypad1.right;
+    case SNES::JOYPAD_A:      return joypad1.a;
+    case SNES::JOYPAD_B:      return joypad1.b;
+    case SNES::JOYPAD_X:      return joypad1.x;
+    case SNES::JOYPAD_Y:      return joypad1.y;
+    case SNES::JOYPAD_L:      return joypad1.l;
+    case SNES::JOYPAD_R:      return joypad1.r;
+    case SNES::JOYPAD_SELECT: return joypad1.select;
+    case SNES::JOYPAD_START:  return joypad1.start;
+    }
+    break;
+  case SNES::DEV_JOYPAD2:
+    switch(button) {
+    case SNES::JOYPAD_UP:     return joypad2.up;
+    case SNES::JOYPAD_DOWN:   return joypad2.down;
+    case SNES::JOYPAD_LEFT:   return joypad2.left;
+    case SNES::JOYPAD_RIGHT:  return joypad2.right;
+    case SNES::JOYPAD_A:      return joypad2.a;
+    case SNES::JOYPAD_B:      return joypad2.b;
+    case SNES::JOYPAD_X:      return joypad2.x;
+    case SNES::JOYPAD_Y:      return joypad2.y;
+    case SNES::JOYPAD_L:      return joypad2.l;
+    case SNES::JOYPAD_R:      return joypad2.r;
+    case SNES::JOYPAD_SELECT: return joypad2.select;
+    case SNES::JOYPAD_START:  return joypad2.start;
+    }
+    break;
+  }
+
+  return false;
+}
+
+void InputDI::set_status(uint8 device, uint8 button, bool status) {
+  switch(device) {
+  case SNES::DEV_JOYPAD1:
+    switch(button) {
+    case SNES::JOYPAD_UP:     joypad1.up     = status; break;
+    case SNES::JOYPAD_DOWN:   joypad1.down   = status; break;
+    case SNES::JOYPAD_LEFT:   joypad1.left   = status; break;
+    case SNES::JOYPAD_RIGHT:  joypad1.right  = status; break;
+    case SNES::JOYPAD_A:      joypad1.a      = status; break;
+    case SNES::JOYPAD_B:      joypad1.b      = status; break;
+    case SNES::JOYPAD_X:      joypad1.x      = status; break;
+    case SNES::JOYPAD_Y:      joypad1.y      = status; break;
+    case SNES::JOYPAD_L:      joypad1.l      = status; break;
+    case SNES::JOYPAD_R:      joypad1.r      = status; break;
+    case SNES::JOYPAD_SELECT: joypad1.select = status; break;
+    case SNES::JOYPAD_START:  joypad1.start  = status; break;
+    }
+    break;
+  case SNES::DEV_JOYPAD2:
+    switch(button) {
+    case SNES::JOYPAD_UP:     joypad2.up     = status; break;
+    case SNES::JOYPAD_DOWN:   joypad2.down   = status; break;
+    case SNES::JOYPAD_LEFT:   joypad2.left   = status; break;
+    case SNES::JOYPAD_RIGHT:  joypad2.right  = status; break;
+    case SNES::JOYPAD_A:      joypad2.a      = status; break;
+    case SNES::JOYPAD_B:      joypad2.b      = status; break;
+    case SNES::JOYPAD_X:      joypad2.x      = status; break;
+    case SNES::JOYPAD_Y:      joypad2.y      = status; break;
+    case SNES::JOYPAD_L:      joypad2.l      = status; break;
+    case SNES::JOYPAD_R:      joypad2.r      = status; break;
+    case SNES::JOYPAD_SELECT: joypad2.select = status; break;
+    case SNES::JOYPAD_START:  joypad2.start  = status; break;
+    }
+    break;
+  }
+}
+
+void InputDI::clear_input() {
+  joypad1.up     = joypad2.up     =
+  joypad1.down   = joypad2.down   =
+  joypad1.left   = joypad2.left   =
+  joypad1.right  = joypad2.right  =
+  joypad1.a      = joypad2.a      =
+  joypad1.b      = joypad2.b      =
+  joypad1.x      = joypad2.x      =
+  joypad1.y      = joypad2.y      =
+  joypad1.l      = joypad2.l      =
+  joypad1.r      = joypad2.r      =
+  joypad1.select = joypad2.select =
+  joypad1.start  = joypad2.start  = false;
+}
+
+BOOL CALLBACK DI_EnumJoypadsCallback(const DIDEVICEINSTANCE *instance, void *context) {
+  return static_cast<InputDI*>(uiInput)->enum_joypads(instance);
+}
+
+bool InputDI::enum_joypads(const DIDEVICEINSTANCE *instance) {
+HRESULT hr;
+  hr = di->CreateDevice(instance->guidInstance, &di_joy, 0);
+  if(FAILED(hr))return DIENUM_CONTINUE;
+  return DIENUM_STOP;
+}
+
+void InputDI::init() {
+HRESULT hr;
+  term();
+  clear_input();
+
+  DirectInput8Create(GetModuleHandle(0), DIRECTINPUT_VERSION,
+    IID_IDirectInput8, (void**)&di, 0);
+  di->CreateDevice(GUID_SysKeyboard, &di_key, 0);
+
+  di_key->SetDataFormat(&c_dfDIKeyboard);
+  di_key->SetCooperativeLevel(wMain.hwnd, DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
+  di_key->Acquire();
+
+  hr = di->EnumDevices(DI8DEVCLASS_GAMECTRL, DI_EnumJoypadsCallback,
+    0, DIEDFL_ATTACHEDONLY);
+
+  if(!di_joy)return;
+
+  di_joy->SetDataFormat(&c_dfDIJoystick2);
+  di_joy->SetCooperativeLevel(wMain.hwnd, DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
+}
+
+void InputDI::term() {
+  if(di_key) { di_key->Unacquire(); di_key->Release(); di_key = 0; }
+  if(di_joy) { di_joy->Unacquire(); di_joy->Release(); di_joy = 0; }
+  if(di) { di->Release(); di = 0; }
+}
diff --git a/src/win/input/dinput.h b/src/win/input/dinput.h
new file mode 100644
index 00000000..e02529bb
--- /dev/null
+++ b/src/win/input/dinput.h
@@ -0,0 +1,34 @@
+#define DIRECTINPUT_VERSION 0x0800
+#include <dinput.h>
+
+class InputDI : public Input {
+public:
+LPDIRECTINPUT8       di;
+LPDIRECTINPUTDEVICE8 di_key, di_joy;
+uint8 keystate[256], joystate[256];
+
+struct joypad {
+  bool up, down, left, right;
+  bool a, b, x, y, l, r;
+  bool select, start;
+} joypad1, joypad2;
+
+  void   poll_devices();
+  uint32 poll();
+
+  void   poll(uint8 type);
+  bool   get_status(uint8 device, uint8 button);
+  void   set_status(uint8 device, uint8 button, bool status);
+  void   clear_input();
+  bool   enum_joypads(const DIDEVICEINSTANCE *instance);
+  void   init();
+  void   term();
+
+  InputDI() {
+    di     = 0;
+    di_key = 0;
+    di_joy = 0;
+  }
+
+  ~InputDI() { term(); }
+};
diff --git a/src/win/input/input.h b/src/win/input/input.h
new file mode 100644
index 00000000..fc0d3cc4
--- /dev/null
+++ b/src/win/input/input.h
@@ -0,0 +1,14 @@
+class Input {
+public:
+//used by GUI for controller configuration
+  virtual uint32 poll() = 0;
+
+  virtual void   poll(uint8 type) = 0;
+  virtual bool   get_status(uint8 device, uint8 button) = 0;
+  virtual void   set_status(uint8 device, uint8 button, bool status) = 0;
+  virtual void   clear_input() = 0;
+  virtual void   init() = 0;
+  virtual void   term() = 0;
+};
+
+#include "dinput.h"
diff --git a/src/win/main.cpp b/src/win/main.cpp
new file mode 100644
index 00000000..10104511
--- /dev/null
+++ b/src/win/main.cpp
@@ -0,0 +1,104 @@
+#define INTERFACE_MAIN
+
+#include "../base.h"
+#include "main.h"
+
+#include "config.cpp"
+
+#include "bsnes.h"
+#include "ui.h"
+
+#include "bsnes.cpp"
+#include "ui.cpp"
+
+void *memalloc(uint32 size, char *name, ...) {
+  return (void*)malloc(size);
+}
+
+void memfree(void *mem, char *name, ...) {
+  free(mem);
+}
+
+void alert(char *s, ...) {
+char str[4096];
+va_list args;
+  va_start(args, s);
+  vsprintf(str, s, args);
+  va_end(args);
+  MessageBox(0, str, "bsnes", MB_OK);
+}
+
+void dprintf(char *s, ...) {
+char str[4096];
+va_list args;
+  va_start(args, s);
+  vsprintf(str, s, args);
+  va_end(args);
+  fprintf(stdout, "%s\r\n", str);
+}
+
+void init_snes() {
+#ifdef POLYMORPHISM
+  deref(mem) = new bMemBus();
+  deref(cpu) = new bCPU();
+  deref(apu) = new bAPU();
+  deref(dsp) = new bDSP();
+  deref(ppu) = new bPPU();
+#endif
+  snes  = new bSNES();
+  bsnes = static_cast<bSNES*>(snes);
+
+  snes->init();
+}
+
+void term_snes() {
+  snes->term();
+#ifdef POLYMORPHISM
+  if(deref(mem)) { delete deref(mem); deref(mem) = 0; }
+  if(deref(cpu)) { delete deref(cpu); deref(cpu) = 0; }
+  if(deref(apu)) { delete deref(apu); deref(apu) = 0; }
+  if(deref(dsp)) { delete deref(dsp); deref(dsp) = 0; }
+  if(deref(ppu)) { delete deref(ppu); deref(ppu) = 0; }
+#endif
+  if(snes) { delete(snes); snes = 0; }
+}
+
+void get_config_fn(string &str) {
+char *t = (char*)malloc(4096);
+  _getcwd(t, 4095);
+  strcpy(str, t);
+  free(t);
+  strcat(str, "\\bsnes.cfg");
+}
+
+int __stdcall WinMain(HINSTANCE hinstance, HINSTANCE hprevinstance, LPSTR lpcmdline, int ncmdshow) {
+MSG msg;
+string cfg_fn;
+  get_config_fn(cfg_fn);
+  config_file.load(cfg_fn);
+  init_snes();
+  init_ui();
+
+int argc    = __argc;
+char **argv = __argv;
+  if(argc >= 2) {
+    if(cartridge.load(argv[1]) == true) {
+      snes->power();
+    }
+  }
+
+  while(1) {
+    while(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
+      if(msg.message == WM_QUIT)goto _end;
+      TranslateMessage(&msg);
+      DispatchMessage(&msg);
+    }
+    bsnes->run();
+  }
+
+_end:
+  term_snes();
+  cartridge.unload();
+  config_file.save(cfg_fn);
+  return 0;
+}
diff --git a/src/win/main.h b/src/win/main.h
new file mode 100644
index 00000000..5b8c3d58
--- /dev/null
+++ b/src/win/main.h
@@ -0,0 +1,8 @@
+#define WINVER       0x0501
+#define _WIN32_WINNT 0x0501
+#include <windows.h>
+#include <direct.h>
+#include "../lib/libbase.h"
+#include "../lib/libvector.h"
+#include "../lib/libstring.h"
+#include "../lib/libconfig.h"
diff --git a/src/win/rom.cpp b/src/win/rom.cpp
deleted file mode 100644
index 7057affd..00000000
--- a/src/win/rom.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-class ROMImage {
-private:
-char rom_fn[4096];
-char sram_fn[4096];
-bool file_loaded;
-
-public:
-  bool loaded();
-  bool load();
-  void unload();
-  void select(char *fn);
-  ROMImage();
-  ~ROMImage();
-};
-
-bool ROMImage::loaded() {
-  return file_loaded;
-}
-
-bool ROMImage::load() {
-  if(file_loaded == true)return false;
-
-  dprintf("* Loading \"%s\"...", rom_fn);
-
-FileReader *rf = new FileReader();
-  if(!rf->open(rom_fn)) {
-    alert("Error loading image file [%s]!", rom_fn);
-    return false;
-  }
-  r_mem->load_cart(static_cast<Reader*>(rf));
-  rf->close();
-
-CartInfo ci;
-  r_mem->get_cartinfo(&ci);
-  if(ci.sram_size != 0) {
-    rf->open(sram_fn);
-    r_mem->load_sram(static_cast<Reader*>(rf));
-    rf->close();
-  }
-
-  delete(rf);
-
-  file_loaded = true;
-  bsnes->debugger_activate();
-  return true;
-}
-
-void ROMImage::unload() {
-  if(file_loaded == false)return;
-
-FileWriter *wf;
-CartInfo ci;
-  r_mem->get_cartinfo(&ci);
-  if(ci.sram_size != 0) {
-    wf = new FileWriter();
-    wf->open(sram_fn);
-    r_mem->save_sram(static_cast<Writer*>(wf));
-    wf->close();
-    delete(wf);
-  }
-
-  file_loaded = false;
-  bsnes->debugger_deactivate();
-
-  r_mem->unload_cart();
-}
-
-void ROMImage::select(char *fn) {
-int i;
-  if(file_loaded == true)return;
-
-/* Remove quotes */
-  if(fn[0] == '\"') {
-    strcpy(rom_fn, fn + 1);
-    rom_fn[strlen(rom_fn) - 1] = 0;
-  } else {
-    strcpy(rom_fn, fn);
-  }
-
-  for(i=strlen(rom_fn)-1;i>=0;i--) {
-    if(rom_fn[i] == '.')break;
-  }
-
-  strcpy(sram_fn, rom_fn);
-  if(rom_fn[i] == '.')sram_fn[i] = 0;
-  strcat(sram_fn, ".srm");
-}
-
-ROMImage::ROMImage() {
-  *rom_fn  = 0;
-  *sram_fn = 0;
-  file_loaded = false;
-}
-
-ROMImage::~ROMImage() {
-  if(file_loaded == true) {
-    unload();
-  }
-}
-
-ROMImage *rom_image;
diff --git a/src/win/snes_controller.bmp b/src/win/snes_controller.bmp
deleted file mode 100644
index 90b6265e..00000000
Binary files a/src/win/snes_controller.bmp and /dev/null differ
diff --git a/src/win/ui.cpp b/src/win/ui.cpp
index d48ca202..0994c0a9 100644
--- a/src/win/ui.cpp
+++ b/src/win/ui.cpp
@@ -1,63 +1,39 @@
-HFONT hFont, hMonofont;
-HBRUSH hbr_backbrush;
+#include "video/ddraw.cpp"
+#include "audio/dsound.cpp"
+#include "input/dinput.cpp"
 
-#include "dd_renderer.cpp"
-#include "ds_sound.cpp"
-#include "uictl_editex.cpp"
 #include "ui_window.cpp"
 #include "ui_main.cpp"
-#include "ui_console.cpp"
-#include "ui_bp.cpp"
-#include "ui_memory.cpp"
-#include "ui_inputconfig.cpp"
-#include "ui_about.cpp"
+#include "ui_inputcfg.cpp"
+#include "ui_ppucfg.cpp"
 
-void CreateFonts() {
-HDC hdc;
-long height;
-  hdc = GetDC(0);
-  height = -MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72);
+void init_ui() {
+HDC  hdc    = GetDC(0);
+long height = -MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72);
   ReleaseDC(0, hdc);
-  hFont = CreateFont(height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "Tahoma");
+  global::vwf = CreateFont(height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "Tahoma");
+  global::fwf = CreateFont(height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "Courier New");
 
-  hdc = GetDC(0);
-  height = -MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72);
-  ReleaseDC(0, hdc);
-  hMonofont = CreateFont(height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "Courier New");
-}
-
-void CreateWindows() {
-  LoadLibrary("riched20.dll");
-  hbr_backbrush = CreateSolidBrush(RGB(32, 32, 32));
-  w_main->create();
-  w_console->create();
-  w_bp->create();
-  w_memory->create();
-  w_inputconfig->create();
-  w_about->create();
-}
-
-void init_ui0() {
-  dd_renderer   = new DDRenderer();
-  ds_sound      = new DSSound();
-  w_main        = new MainWindow();
-  w_console     = new Console();
-  w_bp          = new BreakpointEditor();
-  w_memory      = new MemoryEditor();
-  w_inputconfig = new InputConfig();
-  w_about       = new AboutWindow();
-}
-
-void init_ui1() {
-  CreateFonts();
-  CreateWindows();
-  SetFocus(w_main->hwnd);
-  dd_renderer->set_window(w_main->hwnd);
-  dd_renderer->to_windowed();
-
-  w_main->show_menu();
-  w_main->set_video_mode(config::video.mode);
-  w_main->set_frameskip(0);
-
-  bsnes->debugger_deactivate();
+  global::black_brush  = (HBRUSH)CreateSolidBrush(RGB(0, 0, 0));
+  global::window_brush = (HBRUSH)COLOR_WINDOW;
+
+  wMain.init("bsnes", BSNES_TITLE,
+    256, 223, global::black_brush,  Window::WF_CENTER);
+  wInputCfg.init("bsnes_inputcfg", "bsnes Input Configuration",
+    355, 145, global::window_brush, Window::WF_CENTER | Window::WF_TOPMOST);
+  wPPUCfg.init("bsnes_ppucfg", "bsnes PPU Configuration",
+    250, 165, global::window_brush, Window::WF_CENTER | Window::WF_TOPMOST);
+
+  uiVideo = new VideoDD();
+  uiAudio = new AudioDS();
+  uiInput = new InputDI();
+  uiVideo->init();
+  uiAudio->init();
+  uiInput->init();
+
+  wMain.setup();
+  wInputCfg.setup();
+  wPPUCfg.setup();
+
+  wMain.show();
 }
diff --git a/src/win/ui.h b/src/win/ui.h
index 8ca69fc5..8ed0c439 100644
--- a/src/win/ui.h
+++ b/src/win/ui.h
@@ -1,281 +1,210 @@
-#define KeyDown(key) ((GetAsyncKeyState(key) & 0x8000)?1:0)
+#define KeyDown(__key) ((GetAsyncKeyState(__key) & 0x8000) ? 1 : 0)
 
-enum {
-  VIDEOMODE_256x224w = 0,
-  VIDEOMODE_512x448w,
-  VIDEOMODE_960x720w,
-  VIDEOMODE_640x480f,
-  VIDEOMODE_1024x768f
+#include "video/video.h"
+#include "audio/audio.h"
+#include "input/input.h"
+Video *uiVideo;
+Audio *uiAudio;
+Input *uiInput;
+
+namespace global {
+HFONT  vwf, fwf;
+HBRUSH black_brush, window_brush;
+bool   cursor_visible = true;
 };
 
-enum {
-  MENU_FILE_LOAD = 100,
-  MENU_FILE_UNLOAD,
-  MENU_FILE_RESET,
-  MENU_FILE_POWER,
-  MENU_FILE_EXIT,
-  MENU_SETTINGS_REGULATE_SPEED,
-  MENU_SETTINGS_FRAMESKIP_OFF,
-  MENU_SETTINGS_FRAMESKIP_1,
-  MENU_SETTINGS_FRAMESKIP_2,
-  MENU_SETTINGS_FRAMESKIP_3,
-  MENU_SETTINGS_FRAMESKIP_4,
-  MENU_SETTINGS_FRAMESKIP_5,
-  MENU_SETTINGS_FRAMESKIP_6,
-  MENU_SETTINGS_FRAMESKIP_7,
-  MENU_SETTINGS_FRAMESKIP_8,
-  MENU_SETTINGS_FRAMESKIP_9,
-  MENU_SETTINGS_VIDEOMODE_256x224w,
-  MENU_SETTINGS_VIDEOMODE_512x448w,
-  MENU_SETTINGS_VIDEOMODE_960x720w,
-  MENU_SETTINGS_VIDEOMODE_640x480f,
-  MENU_SETTINGS_VIDEOMODE_1024x768f,
-  MENU_SETTINGS_COLORADJUST_COLORCURVE,
-  MENU_SETTINGS_COLORADJUST_NORMAL,
-  MENU_SETTINGS_COLORADJUST_GRAYSCALE,
-  MENU_SETTINGS_COLORADJUST_VGA,
-  MENU_SETTINGS_COLORADJUST_GENESIS,
-  MENU_SETTINGS_USEVRAM,
-  MENU_SETTINGS_VBLANK,
-  MENU_SETTINGS_SHOWFPS,
-  MENU_SETTINGS_MUTE,
-  MENU_SETTINGS_INPUTCFG_JOYPAD1,
-  MENU_SETTINGS_INPUTCFG_JOYPAD2,
-  MENU_SETTINGS_DEBUGGER,
-  MENU_MISC_SCREENSHOT,
-  MENU_MISC_LOGAUDIO,
-  MENU_MISC_ABOUT
-};
-
-enum {
-  CONSOLE_OUTPUT = 100,
-  CONSOLE_STATUS,
-
-  CONSOLE_CPUGROUP,
-  CONSOLE_CPUSTEP,
-  CONSOLE_CPUPROCEED,
-  CONSOLE_CPUSKIP,
-  CONSOLE_CPUTRACENUM,
-  CONSOLE_CPUTRACE,
-  CONSOLE_CPUDISABLE,
-
-  CONSOLE_APUGROUP,
-  CONSOLE_APUSTEP,
-  CONSOLE_APUPROCEED,
-  CONSOLE_APUSKIP,
-  CONSOLE_APUTRACENUM,
-  CONSOLE_APUTRACE,
-  CONSOLE_APUDISABLE,
-
-  CONSOLE_SYSGROUP,
-  CONSOLE_SYSRUN,
-  CONSOLE_SYSRUNTOFRAME,
-  CONSOLE_SYSRUNTONMI,
-
-  CONSOLE_CFGGROUP,
-  CONSOLE_CFGOUTPUTCPU,
-  CONSOLE_CFGOUTPUTAPU,
-  CONSOLE_CFGOUTPUTDBG,
-  CONSOLE_CFGTRACE,
-  CONSOLE_CFGREGTYPE,
-  CONSOLE_CFGREGNUM,
-  CONSOLE_CFGREGVAL,
-  CONSOLE_CFGREGSET,
-  CONSOLE_CFGLOCK,
-  CONSOLE_CFGLOCKUP,
-  CONSOLE_CFGLOCKDOWN,
-  CONSOLE_CFGLOCKLEFT,
-  CONSOLE_CFGLOCKRIGHT,
-  CONSOLE_CFGLOCKA,
-  CONSOLE_CFGLOCKB,
-  CONSOLE_CFGLOCKX,
-  CONSOLE_CFGLOCKY,
-  CONSOLE_CFGLOCKL,
-  CONSOLE_CFGLOCKR,
-  CONSOLE_CFGLOCKSELECT,
-  CONSOLE_CFGLOCKSTART
-};
-
-enum {
-  BREAKPOINT_LIST = 100,
-  BREAKPOINT_STATIC1,
-  BREAKPOINT_NUM,
-  BREAKPOINT_OFFSET,
-  BREAKPOINT_R,
-  BREAKPOINT_W,
-  BREAKPOINT_X,
-  BREAKPOINT_V,
-  BREAKPOINT_STATIC2,
-  BREAKPOINT_VALUE,
-  BREAKPOINT_SOURCE,
-  BREAKPOINT_SET,
-  BREAKPOINT_CLEAR,
-  BREAKPOINT_ENABLE,
-  BREAKPOINT_CLEARALL,
-  BREAKPOINT_EXPORT,
-  BREAKPOINT_IMPORT
-};
-
-enum {
-  MEMORYEDITOR_VIEW = 100,
-
-  MEMORYEDITOR_MODE,
-  MEMORYEDITOR_GOTOADDR,
-  MEMORYEDITOR_GOTO,
-
-  MEMORYEDITOR_STATIC1,
-  MEMORYEDITOR_OFFSET,
-  MEMORYEDITOR_VALUE,
-  MEMORYEDITOR_EDIT,
-
-  MEMORYEDITOR_FSOURCE,
-  MEMORYEDITOR_FEXPORT,
-
-  MEMORYEDITOR_UPDATE,
-  MEMORYEDITOR_AUTOUPDATE
-};
-
-enum {
-  ABOUT_STATIC = 100,
-  ABOUT_OK
-};
+long __stdcall window_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
 
 class Window {
 public:
 HWND  hwnd;
-HMENU hmenu;
-bool fullscreen, visible, cursor_visible;
-RECT workarea, wa_offset;
-struct { int width, height; }window;
-  void resize(int width, int height);
-  void center();
-  void show_menu();
-  void hide_menu();
-  void show();
-  void hide();
+HMENU menu;
 
-  void to_left(HWND _hwnd = 0);
-  void to_center();
-  void to_right();
-  void to_top();
-  void to_middle();
-  void to_bottom(HWND _hwnd = 0);
+enum {
+  IDTYPE_UNKNOWN,
+  IDTYPE_MENU,
+  IDTYPE_BUTTON
+};
+
+enum {
+  WF_NONE    = 0,
+  WF_CENTER  = 1,
+  WF_TOPMOST = 2,
+};
+
+struct {
+  bool  visible;
+  bool  fullscreen;
+  bool  center;
+  int   width, height;
+} settings;
+
+  virtual void   hide();
+  virtual void   show();
+  virtual bool   visible();
+  virtual void   hide_menu();
+  virtual void   show_menu();
+  virtual uint32 get_id_type(uint32 id);
+  virtual void   check(uint32 id, bool state);
+  virtual bool   checked(uint32 id);
+  virtual void   check_toggle(uint32 id);
+  virtual void   check(uint32 id);
+  virtual void   uncheck(uint32 id);
+  virtual void   resize(int width, int height, bool fullscreen = false);
+  virtual void   center();
+
+  virtual void   set_text(uint32 id, const char *text, ...);
+  virtual void   control(const char *classname, const char *text, uint32 flags, int x, int y, int width, int height, uint32 id);
+  virtual long   wndproc(UINT msg, WPARAM wparam, LPARAM lparam);
+  virtual void   init(const char *classname, const char *title, int width, int height, HBRUSH hbr, uint32 flags = WF_NONE);
 
   Window();
 };
 
+enum {
+MENU_FILE = 100,
+  MENU_FILE_LOAD,
+  MENU_FILE_UNLOAD,
+  MENU_FILE_RESET,
+  MENU_FILE_POWER,
+  MENU_FILE_EXIT,
+
+MENU_SETTINGS,
+  MENU_SETTINGS_VIDEOMODE,
+    MENU_SETTINGS_VIDEOMODE_0,
+    MENU_SETTINGS_VIDEOMODE_1,
+    MENU_SETTINGS_VIDEOMODE_2,
+    MENU_SETTINGS_VIDEOMODE_3,
+    MENU_SETTINGS_VIDEOMODE_4,
+  //---
+    MENU_SETTINGS_VIDEOMODE_5,
+    MENU_SETTINGS_VIDEOMODE_6,
+    MENU_SETTINGS_VIDEOMODE_7,
+    MENU_SETTINGS_VIDEOMODE_8,
+    MENU_SETTINGS_VIDEOMODE_9,
+  MENU_SETTINGS_FRAMESKIP,
+    MENU_SETTINGS_FRAMESKIP_0,
+  //---
+    MENU_SETTINGS_FRAMESKIP_1,
+    MENU_SETTINGS_FRAMESKIP_2,
+    MENU_SETTINGS_FRAMESKIP_3,
+    MENU_SETTINGS_FRAMESKIP_4,
+    MENU_SETTINGS_FRAMESKIP_5,
+    MENU_SETTINGS_FRAMESKIP_6,
+    MENU_SETTINGS_FRAMESKIP_7,
+    MENU_SETTINGS_FRAMESKIP_8,
+    MENU_SETTINGS_FRAMESKIP_9,
+  MENU_SETTINGS_COLORADJUST,
+    MENU_SETTINGS_COLORADJUST_COLORCURVE,
+    MENU_SETTINGS_COLORADJUST_NORMAL,
+    MENU_SETTINGS_COLORADJUST_GRAYSCALE,
+    MENU_SETTINGS_COLORADJUST_VGA,
+    MENU_SETTINGS_COLORADJUST_GENESIS,
+  MENU_SETTINGS_VIDEO_OPTIONS,
+    MENU_SETTINGS_VIDEO_OPTIONS_USEVRAM,
+    MENU_SETTINGS_VIDEO_OPTIONS_TRIPLEBUF,
+    MENU_SETTINGS_VIDEO_OPTIONS_SHOWFPS,
+  //---
+    MENU_SETTINGS_VIDEO_OPTIONS_PPUCFG,
+//---
+  MENU_SETTINGS_MUTE,
+//---
+  MENU_SETTINGS_INPUTCFG,
+    MENU_SETTINGS_INPUTCFG_JOYPAD1,
+    MENU_SETTINGS_INPUTCFG_JOYPAD2,
+//---
+  MENU_SETTINGS_SPEED_REGULATION,
+    MENU_SETTINGS_SPEED_REGULATION_ENABLE,
+  //---
+    MENU_SETTINGS_SPEED_REGULATION_SLOWEST,
+    MENU_SETTINGS_SPEED_REGULATION_SLOW,
+    MENU_SETTINGS_SPEED_REGULATION_NORMAL,
+    MENU_SETTINGS_SPEED_REGULATION_FAST,
+    MENU_SETTINGS_SPEED_REGULATION_FASTEST,
+
+MENU_MISC,
+  MENU_MISC_SCREENSHOT,
+  MENU_MISC_LOGAUDIO,
+//---
+  MENU_MISC_ABOUT,
+};
+
 class MainWindow : public Window {
 public:
 uint8 frameskip, frameskip_pos;
-int width, height;
-  void create();
-  void to_fullscreen();
-  void to_windowed();
-  void set_frameskip(uint8 fs);
-  void adjust_video_mode(bool fullscreen_mode);
+uint8 regulation_speed;
+
+struct {
+  bool   fullscreen;
+  uint32 x, y, refresh_rate;
+  uint32 width, height;
+} vi;
+  void get_video_mode_info(uint8 mode);
   void set_video_mode(uint8 mode);
+  void set_frameskip(uint8 fs);
+  void set_regulation_speed(uint8 speed);
   void menu_load();
   void menu_unload();
-}*w_main = 0;
 
-#define CONSOLE_LINES 240
-class Console : public Window {
-private:
-bool _is_running; //used to swap "Run"/"Stop" text on console window
+  long wndproc(UINT msg, WPARAM wparam, LPARAM lparam);
+  void setup();
 
-public:
-bool ctl_disabled[100];
-bool outputcpu, outputapu, outputdbg;
+  MainWindow() { frameskip = frameskip_pos = 0; }
+} wMain;
 
-enum { DEBUG_MESSAGE = 0, CPU_MESSAGE, APU_MESSAGE };
-enum { REGTYPE_CPU = 0, REGTYPE_APU };
-char  output_line[CONSOLE_LINES][128];
-uint8 output_linecol[CONSOLE_LINES];
-char  output_data[CONSOLE_LINES * 128];
-FILE *log_fp;
-bool tracing_enabled;
-
-struct {
-  bool up, down, left, right;
-  bool a, b, x, y;
-  bool l, r, select, start;
-}joypad_lock;
-
-  void create();
-  long wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
-  void clear();
-  void update_status();
-  void set_reg_list_type(uint8 list_type);
-  bool can_write(uint32 message_type);
-  void write(char *s, uint32 message_type = DEBUG_MESSAGE);
-  void is_running(bool n); //API access to _is_running
-
-  Console();
-}*w_console = 0;
-
-class BreakpointEditor : public Window {
-public:
-bool ctl_disabled[100];
-
-enum { DRAM = 0, SPCRAM = 1, VRAM = 2, OAM = 3, CGRAM = 4 };
-enum { FLAG_NONE = 0, FLAG_R = 1, FLAG_W = 2, FLAG_X = 4, FLAG_V = 8 };
-struct {
-  uint32 addr;
-  uint8  value;
-  uint8  source;
-  uint8  flags;
-  uint32 hit_count;
-  bool   set;
-}bp[16];
-bool  bp_enabled, bp_hit;
-//indicates which breakpoint was hit, used to tell whether to disassemble
-//a cpu or apu opcode once the emulation status is set to stop.
-uint8 bp_hit_num;
-  void clear();
-  void create();
-  bool hit();
-  void test(uint32 message, uint32 addr, uint32 value);
-  void refresh();
-
-  BreakpointEditor();
-}*w_bp = 0;
-
-class MemoryEditor : public Window {
-public:
-bool ctl_disabled[100];
-
-enum { MODE_DRAM = 0, MODE_ROM, MODE_SRAM, MODE_SPCRAM, MODE_VRAM, MODE_OAM, MODE_CGRAM };
-uint32 edit_mode, edit_addr, edit_mask;
-bool   auto_update; //update memory window whenever visible value is written to when true
-  void  clear();
-  void  create();
-  uint8 read_byte(uint32 addr);
-  void  write_byte(uint32 addr, uint8 value);
-  void  refresh(uint32 type = null, uint32 addr = 0);
-  void  export_data(uint32 type);
-}*w_memory = 0;
-
-class InputConfig : public Window {
-public:
 enum {
-  JOYPAD1 = 0,
-  JOYPAD2
+  INPUTCFG_TEXT = 100,
+  INPUTCFG_UP,
+  INPUTCFG_DOWN,
+  INPUTCFG_LEFT,
+  INPUTCFG_RIGHT,
+  INPUTCFG_A,
+  INPUTCFG_B,
+  INPUTCFG_X,
+  INPUTCFG_Y,
+  INPUTCFG_L,
+  INPUTCFG_R,
+  INPUTCFG_SELECT,
+  INPUTCFG_START,
+  INPUTCFG_ALLOW_INVALID_INPUT,
 };
-enum {
-  ID_COMMAND = 100
-};
-int config_type, config_pos;
-bool polling;
-  long wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
-  void update_polling(int key);
-  void update_command();
-  void set_text(char *str);
-  void begin_config(int type);
-  void create();
-}*w_inputconfig = 0;
 
-class AboutWindow : public Window {
+class InputCfgWindow : public Window {
 public:
-  long wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
-  void create();
-}*w_about = 0;
+bool   update_active;
+uint32 key_to_update, dev_to_update;
+  void timer_key_update();
+  void begin_key_update(uint32 key);
+  void end_key_update();
+
+  void show();
+  void hide();
+  long wndproc(UINT msg, WPARAM wparam, LPARAM lparam);
+  void setup();
+} wInputCfg;
+
+enum {
+  PPUCFG_STATIC0,
+  PPUCFG_BG1_PRI0,
+  PPUCFG_BG1_PRI1,
+  PPUCFG_BG2_PRI0,
+  PPUCFG_BG2_PRI1,
+  PPUCFG_BG3_PRI0,
+  PPUCFG_BG3_PRI1,
+  PPUCFG_BG4_PRI0,
+  PPUCFG_BG4_PRI1,
+  PPUCFG_OAM_PRI0,
+  PPUCFG_OAM_PRI1,
+  PPUCFG_OAM_PRI2,
+  PPUCFG_OAM_PRI3,
+
+  PPUCFG_STATIC1,
+  PPUCFG_HDMA_ENABLE,
+  PPUCFG_OPT_ENABLE,
+};
+
+class PPUCfgWindow : public Window {
+public:
+  long wndproc(UINT msg, WPARAM wparam, LPARAM lparam);
+  void setup();
+} wPPUCfg;
diff --git a/src/win/ui_inputcfg.cpp b/src/win/ui_inputcfg.cpp
new file mode 100644
index 00000000..2be022d2
--- /dev/null
+++ b/src/win/ui_inputcfg.cpp
@@ -0,0 +1,219 @@
+void CALLBACK InputCfgTimerProc(HWND hwnd, UINT msg, UINT event, DWORD time) {
+  wInputCfg.timer_key_update();
+}
+
+void InputCfgWindow::timer_key_update() {
+uint32 r, n;
+  r = uiInput->poll();
+  if(r == 0xffff)return;
+
+  end_key_update();
+
+//dev_to_update is set by ui_main.cpp
+  switch(dev_to_update) {
+  case SNES::DEV_JOYPAD1:
+    switch(key_to_update) {
+    case INPUTCFG_UP:     n = config::input.joypad1.up;     break;
+    case INPUTCFG_DOWN:   n = config::input.joypad1.down;   break;
+    case INPUTCFG_LEFT:   n = config::input.joypad1.left;   break;
+    case INPUTCFG_RIGHT:  n = config::input.joypad1.right;  break;
+    case INPUTCFG_A:      n = config::input.joypad1.a;      break;
+    case INPUTCFG_B:      n = config::input.joypad1.b;      break;
+    case INPUTCFG_X:      n = config::input.joypad1.x;      break;
+    case INPUTCFG_Y:      n = config::input.joypad1.y;      break;
+    case INPUTCFG_L:      n = config::input.joypad1.l;      break;
+    case INPUTCFG_R:      n = config::input.joypad1.r;      break;
+    case INPUTCFG_SELECT: n = config::input.joypad1.select; break;
+    case INPUTCFG_START:  n = config::input.joypad1.start;  break;
+    }
+    break;
+  case SNES::DEV_JOYPAD2:
+    switch(key_to_update) {
+    case INPUTCFG_UP:     n = config::input.joypad2.up;     break;
+    case INPUTCFG_DOWN:   n = config::input.joypad2.down;   break;
+    case INPUTCFG_LEFT:   n = config::input.joypad2.left;   break;
+    case INPUTCFG_RIGHT:  n = config::input.joypad2.right;  break;
+    case INPUTCFG_A:      n = config::input.joypad2.a;      break;
+    case INPUTCFG_B:      n = config::input.joypad2.b;      break;
+    case INPUTCFG_X:      n = config::input.joypad2.x;      break;
+    case INPUTCFG_Y:      n = config::input.joypad2.y;      break;
+    case INPUTCFG_L:      n = config::input.joypad2.l;      break;
+    case INPUTCFG_R:      n = config::input.joypad2.r;      break;
+    case INPUTCFG_SELECT: n = config::input.joypad2.select; break;
+    case INPUTCFG_START:  n = config::input.joypad2.start;  break;
+    }
+    break;
+  }
+
+  if(r == 0xff01) {
+  //escape key was pressed, clear key
+    n = 0xffff;
+  } else if((r & 0xff00) != 0xff00) {
+  //joy update
+    n = (r & 0xff00) | (n & 0x00ff);
+  } else if((r & 0x00ff) != 0x00ff) {
+  //key update
+    n = (n & 0xff00) | (r & 0x00ff);
+  }
+
+  switch(dev_to_update) {
+  case SNES::DEV_JOYPAD1:
+    switch(key_to_update) {
+    case INPUTCFG_UP:     config::input.joypad1.up     = n; break;
+    case INPUTCFG_DOWN:   config::input.joypad1.down   = n; break;
+    case INPUTCFG_LEFT:   config::input.joypad1.left   = n; break;
+    case INPUTCFG_RIGHT:  config::input.joypad1.right  = n; break;
+    case INPUTCFG_A:      config::input.joypad1.a      = n; break;
+    case INPUTCFG_B:      config::input.joypad1.b      = n; break;
+    case INPUTCFG_X:      config::input.joypad1.x      = n; break;
+    case INPUTCFG_Y:      config::input.joypad1.y      = n; break;
+    case INPUTCFG_L:      config::input.joypad1.l      = n; break;
+    case INPUTCFG_R:      config::input.joypad1.r      = n; break;
+    case INPUTCFG_SELECT: config::input.joypad1.select = n; break;
+    case INPUTCFG_START:  config::input.joypad1.start  = n; break;
+    }
+    break;
+  case SNES::DEV_JOYPAD2:
+    switch(key_to_update) {
+    case INPUTCFG_UP:     config::input.joypad2.up     = n; break;
+    case INPUTCFG_DOWN:   config::input.joypad2.down   = n; break;
+    case INPUTCFG_LEFT:   config::input.joypad2.left   = n; break;
+    case INPUTCFG_RIGHT:  config::input.joypad2.right  = n; break;
+    case INPUTCFG_A:      config::input.joypad2.a      = n; break;
+    case INPUTCFG_B:      config::input.joypad2.b      = n; break;
+    case INPUTCFG_X:      config::input.joypad2.x      = n; break;
+    case INPUTCFG_Y:      config::input.joypad2.y      = n; break;
+    case INPUTCFG_L:      config::input.joypad2.l      = n; break;
+    case INPUTCFG_R:      config::input.joypad2.r      = n; break;
+    case INPUTCFG_SELECT: config::input.joypad2.select = n; break;
+    case INPUTCFG_START:  config::input.joypad2.start  = n; break;
+    }
+    break;
+  }
+}
+
+void InputCfgWindow::begin_key_update(uint32 key) {
+  if(update_active == true)return;
+
+  update_active = true;
+  key_to_update = key;
+
+char t[512];
+  strcpy(t, "Press button or key for '");
+  switch(key) {
+  case INPUTCFG_UP:     strcat(t, "Up");     break;
+  case INPUTCFG_DOWN:   strcat(t, "Down");   break;
+  case INPUTCFG_LEFT:   strcat(t, "Left");   break;
+  case INPUTCFG_RIGHT:  strcat(t, "Right");  break;
+  case INPUTCFG_A:      strcat(t, "A");      break;
+  case INPUTCFG_B:      strcat(t, "B");      break;
+  case INPUTCFG_X:      strcat(t, "X");      break;
+  case INPUTCFG_Y:      strcat(t, "Y");      break;
+  case INPUTCFG_L:      strcat(t, "L");      break;
+  case INPUTCFG_R:      strcat(t, "R");      break;
+  case INPUTCFG_SELECT: strcat(t, "Select"); break;
+  case INPUTCFG_START:  strcat(t, "Start");  break;
+  }
+  strcat(t, "', or press Esc to clear.");
+  set_text(INPUTCFG_TEXT, t);
+
+  SetTimer(hwnd, 1000, 50, InputCfgTimerProc);
+}
+
+void InputCfgWindow::end_key_update() {
+  update_active = false;
+  KillTimer(hwnd, 1000);
+  set_text(INPUTCFG_TEXT, "Key updated. Select button to update.");
+}
+
+long InputCfgWindow::wndproc(UINT msg, WPARAM wparam, LPARAM lparam) {
+  switch(msg) {
+  case WM_COMMAND:
+    switch(LOWORD(wparam)) {
+    case INPUTCFG_UP:
+    case INPUTCFG_DOWN:
+    case INPUTCFG_LEFT:
+    case INPUTCFG_RIGHT:
+    case INPUTCFG_A:
+    case INPUTCFG_B:
+    case INPUTCFG_X:
+    case INPUTCFG_Y:
+    case INPUTCFG_L:
+    case INPUTCFG_R:
+    case INPUTCFG_SELECT:
+    case INPUTCFG_START:
+      begin_key_update(LOWORD(wparam));
+      break;
+    case INPUTCFG_ALLOW_INVALID_INPUT:
+      switch(dev_to_update) {
+      case SNES::DEV_JOYPAD1:
+        config::input.joypad1.allow_invalid_input.toggle();
+        check(INPUTCFG_ALLOW_INVALID_INPUT, (bool)config::input.joypad1.allow_invalid_input);
+        break;
+      case SNES::DEV_JOYPAD2:
+        config::input.joypad2.allow_invalid_input.toggle();
+        check(INPUTCFG_ALLOW_INVALID_INPUT, (bool)config::input.joypad2.allow_invalid_input);
+        break;
+      }
+      break;
+    }
+    break;
+  case WM_CLOSE:
+    hide();
+    return 0;
+  }
+
+  return DefWindowProc(hwnd, msg, wparam, lparam);
+}
+
+void InputCfgWindow::show() {
+  if(visible()) {
+    SetFocus(hwnd);
+    return;
+  }
+
+  switch(dev_to_update) {
+  case SNES::DEV_JOYPAD1:
+    SetWindowText(hwnd, "bsnes Input Configuration (Joypad 1)");
+    check(INPUTCFG_ALLOW_INVALID_INPUT, config::input.joypad1.allow_invalid_input);
+    break;
+  case SNES::DEV_JOYPAD2:
+    SetWindowText(hwnd, "bsnes Input Configuration (Joypad 2)");
+    check(INPUTCFG_ALLOW_INVALID_INPUT, config::input.joypad2.allow_invalid_input);
+    break;
+  default:
+    return;
+  }
+
+  update_active = false;
+  set_text(INPUTCFG_TEXT, "Select button to update.");
+  Window::show();
+}
+
+void InputCfgWindow::hide() {
+  Window::hide();
+  end_key_update();
+}
+
+void InputCfgWindow::setup() {
+  control("STATIC", "",       WS_VISIBLE,   5,   5, 335,  20, INPUTCFG_TEXT);
+
+  control("BUTTON", "L",      WS_VISIBLE, 105,  30,  40,  25, INPUTCFG_L);
+  control("BUTTON", "R",      WS_VISIBLE, 210,  30,  40,  25, INPUTCFG_R);
+
+  control("BUTTON", "Up",     WS_VISIBLE,  45,  45,  40,  25, INPUTCFG_UP);
+  control("BUTTON", "Left",   WS_VISIBLE,   5,  70,  40,  25, INPUTCFG_LEFT);
+  control("BUTTON", "Right",  WS_VISIBLE,  85,  70,  40,  25, INPUTCFG_RIGHT);
+  control("BUTTON", "Down",   WS_VISIBLE,  45,  95,  40,  25, INPUTCFG_DOWN);
+
+  control("BUTTON", "Select", WS_VISIBLE, 135,  85,  40,  25, INPUTCFG_SELECT);
+  control("BUTTON", "Start",  WS_VISIBLE, 180,  85,  40,  25, INPUTCFG_START);
+
+  control("BUTTON", "X",      WS_VISIBLE, 270,  45,  40,  25, INPUTCFG_X);
+  control("BUTTON", "Y",      WS_VISIBLE, 230,  70,  40,  25, INPUTCFG_Y);
+  control("BUTTON", "A",      WS_VISIBLE, 310,  70,  40,  25, INPUTCFG_A);
+  control("BUTTON", "B",      WS_VISIBLE, 270,  95,  40,  25, INPUTCFG_B);
+
+  control("BUTTON", "Allow invalid input (not recommended)",
+    WS_VISIBLE | BS_CHECKBOX, 5, 125, 335, 20, INPUTCFG_ALLOW_INVALID_INPUT);
+}
diff --git a/src/win/ui_main.cpp b/src/win/ui_main.cpp
index 142aa3cd..7486931b 100644
--- a/src/win/ui_main.cpp
+++ b/src/win/ui_main.cpp
@@ -1,102 +1,88 @@
-void MainWindow::set_frameskip(uint8 fs) {
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_OFF, MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_1,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_2,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_3,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_4,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_5,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_6,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_7,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_8,   MF_UNCHECKED);
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_9,   MF_UNCHECKED);
+void MainWindow::get_video_mode_info(uint8 mode) {
+string t;
+  if(mode > 9)mode = 0;
 
-  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_OFF + fs, MF_CHECKED);
-  w_main->frameskip     = fs;
-  w_main->frameskip_pos = 0;
-}
-
-void MainWindow::to_fullscreen() {
-  if(bsnes->debugger_enabled() == true) {
-    bsnes->debugger_disable();
-  }
-  SetWindowLong(hwnd, GWL_STYLE,   WS_POPUP);
-  SetWindowLong(hwnd, GWL_EXSTYLE, WS_EX_TOPMOST);
-  SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, width, height, 0);
-  dd_renderer->to_fullscreen(width, height);
-  hide_menu();
-}
-
-void MainWindow::to_windowed() {
-  SetWindowLong(hwnd, GWL_STYLE,   WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
-  SetWindowLong(hwnd, GWL_EXSTYLE, 0);
-//always call in case the video mode change is simply changing
-//the backbuffer from a VRAM surface to a DRAM surface.
-  dd_renderer->to_windowed();
-  if(dd_renderer->fullscreen == true) {
-    show_menu();
-  }
-}
-
-void MainWindow::adjust_video_mode(bool fullscreen_mode) {
-  fullscreen = fullscreen_mode;
-
-  if(fullscreen == true) {
-    to_fullscreen();
-  } else {
-    to_windowed();
+  switch(mode) {
+  case 0: strcpy(t, config::video.mode0.sget()); break;
+  case 1: strcpy(t, config::video.mode1.sget()); break;
+  case 2: strcpy(t, config::video.mode2.sget()); break;
+  case 3: strcpy(t, config::video.mode3.sget()); break;
+  case 4: strcpy(t, config::video.mode4.sget()); break;
+  case 5: strcpy(t, config::video.mode5.sget()); break;
+  case 6: strcpy(t, config::video.mode6.sget()); break;
+  case 7: strcpy(t, config::video.mode7.sget()); break;
+  case 8: strcpy(t, config::video.mode8.sget()); break;
+  case 9: strcpy(t, config::video.mode9.sget()); break;
   }
 
-  resize(width, height);
-  if(fullscreen == false)center();
-
-  if(bsnes->debugger_enabled() == true) {
-    to_bottom();
-    to_right();
-  }
+  vi.fullscreen = (mode >= 5);
+char *p = strptr(t);
+  vi.x = strdec(p);
+  while(*p && *p != 'x')p++;
+  vi.y = strdec(++p);
+  if(mode < 5)return;
+  while(*p && *p != '@')p++;
+  vi.refresh_rate = strdec(++p);
+  while(*p && *p != ':')p++;
+  vi.width = strdec(++p);
+  while(*p && *p != 'x')p++;
+  vi.height = strdec(++p);
 }
 
 void MainWindow::set_video_mode(uint8 mode) {
-  hide();
-  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_256x224w,  MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_512x448w,  MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_960x720w,  MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_640x480f,  MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_1024x768f, MF_UNCHECKED);
-  switch(mode) {
-  case VIDEOMODE_256x224w:
-    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_256x224w, MF_CHECKED);
-    width  =  256;
-    height =  223;
-    adjust_video_mode(false);
-    break;
-  case VIDEOMODE_512x448w:
-    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_512x448w, MF_CHECKED);
-    width  =  512;
-    height =  446;
-    adjust_video_mode(false);
-    break;
-  case VIDEOMODE_960x720w:
-    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_960x720w, MF_CHECKED);
-    width  =  960;
-    height =  720;
-    adjust_video_mode(false);
-    break;
-  case VIDEOMODE_640x480f:
-    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_640x480f, MF_CHECKED);
-    width  =  640;
-    height =  480;
-    adjust_video_mode(true);
-    break;
-  case VIDEOMODE_1024x768f:
-    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_1024x768f, MF_CHECKED);
-    width  = 1024;
-    height =  768;
-    adjust_video_mode(true);
-    break;
-  }
+  if(mode > 9)mode = 0;
+  get_video_mode_info(mode);
 
   config::video.mode = mode;
-  show();
+
+  uiVideo->set_video_mode(vi.x, vi.y, vi.fullscreen,
+    vi.refresh_rate, vi.width, vi.height);
+
+  check(MENU_SETTINGS_VIDEOMODE_0, mode == 0);
+  check(MENU_SETTINGS_VIDEOMODE_1, mode == 1);
+  check(MENU_SETTINGS_VIDEOMODE_2, mode == 2);
+  check(MENU_SETTINGS_VIDEOMODE_3, mode == 3);
+  check(MENU_SETTINGS_VIDEOMODE_4, mode == 4);
+  check(MENU_SETTINGS_VIDEOMODE_5, mode == 5);
+  check(MENU_SETTINGS_VIDEOMODE_6, mode == 6);
+  check(MENU_SETTINGS_VIDEOMODE_7, mode == 7);
+  check(MENU_SETTINGS_VIDEOMODE_8, mode == 8);
+  check(MENU_SETTINGS_VIDEOMODE_9, mode == 9);
+}
+
+void MainWindow::set_frameskip(uint8 fs) {
+  frameskip     = fs % 10;
+  frameskip_pos = 0;
+
+  check(MENU_SETTINGS_FRAMESKIP_0, fs == 0);
+  check(MENU_SETTINGS_FRAMESKIP_1, fs == 1);
+  check(MENU_SETTINGS_FRAMESKIP_2, fs == 2);
+  check(MENU_SETTINGS_FRAMESKIP_3, fs == 3);
+  check(MENU_SETTINGS_FRAMESKIP_4, fs == 4);
+  check(MENU_SETTINGS_FRAMESKIP_5, fs == 5);
+  check(MENU_SETTINGS_FRAMESKIP_6, fs == 6);
+  check(MENU_SETTINGS_FRAMESKIP_7, fs == 7);
+  check(MENU_SETTINGS_FRAMESKIP_8, fs == 8);
+  check(MENU_SETTINGS_FRAMESKIP_9, fs == 9);
+}
+
+void MainWindow::set_regulation_speed(uint8 speed) {
+  speed %= 5;
+  regulation_speed = speed;
+
+  switch(speed) {
+  case 0: uiAudio->set_frequency(config::system.speed_slowest); break;
+  case 1: uiAudio->set_frequency(config::system.speed_slow);    break;
+  case 2: uiAudio->set_frequency(config::system.speed_normal);  break;
+  case 3: uiAudio->set_frequency(config::system.speed_fast);    break;
+  case 4: uiAudio->set_frequency(config::system.speed_fastest); break;
+  }
+
+  check(MENU_SETTINGS_SPEED_REGULATION_SLOWEST, speed == 0);
+  check(MENU_SETTINGS_SPEED_REGULATION_SLOW,    speed == 1);
+  check(MENU_SETTINGS_SPEED_REGULATION_NORMAL,  speed == 2);
+  check(MENU_SETTINGS_SPEED_REGULATION_FAST,    speed == 3);
+  check(MENU_SETTINGS_SPEED_REGULATION_FASTEST, speed == 4);
 }
 
 void MainWindow::menu_load() {
@@ -107,8 +93,22 @@ char t[4096];
 
   ofn.lStructSize = sizeof(ofn);
   ofn.hwndOwner   = hwnd;
-  ofn.lpstrFilter = "SNES ROM Images (*.smc;*.sfc;*.swc;*.fig;*.ufo;*.gd3;*.078)\0"
-                      "*.smc;*.sfc;*.swc;*.fig;*.ufo;*.gd3;*.078\0"
+  ofn.lpstrFilter = "SNES ROM Images (*.smc;*.sfc;*.swc;*.fig;*.ufo;*.gd3;*.078"
+#ifdef GZIP_SUPPORT
+                      ";.gz;.z;.zip"
+#endif
+#ifdef JMA_SUPPORT
+                      ";.jma"
+#endif
+                      ")\0"
+                      "*.smc;*.sfc;*.swc;*.fig;*.ufo;*.gd3;*.078"
+#ifdef GZIP_SUPPORT
+                      ";*.gz;*.z;*.zip"
+#endif
+#ifdef JMA_SUPPORT
+                      ";*.jma"
+#endif
+                      "\0"
                     "All Files (*.*)\0"
                       "*.*\0";
   ofn.lpstrFile   = t;
@@ -118,72 +118,101 @@ char t[4096];
 
   if(!GetOpenFileName(&ofn))return;
 
-  rom_image->unload();
+  cartridge.unload();
   dprintf("");
-  rom_image->select(t);
-  rom_image->load();
+  cartridge.load(t);
 
-  snes->power();
-  bsnes->debugger_update();
+  bsnes->power();
 }
 
 void MainWindow::menu_unload() {
-  rom_image->unload();
+  cartridge.unload();
+  uiVideo->clear_video();
+  uiAudio->clear_audio();
+  uiInput->clear_input();
+  SetWindowText(hwnd, BSNES_TITLE);
 }
 
-long __stdcall wndproc_main(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
-time_t timeout;
-int i;
+long MainWindow::wndproc(UINT msg, WPARAM wparam, LPARAM lparam) {
   switch(msg) {
   case WM_ENTERMENULOOP:
-    ds_sound->clear();
+    uiAudio->clear_audio();
     break;
-  case WM_EXITMENULOOP:
-    timeout = time(0);
+  case WM_EXITMENULOOP: {
+  time_t timeout = time(0);
     while(difftime(time(0), timeout) < 3) {
       if(!KeyDown(VK_RETURN))break;
     }
-    bsnes->clear_input();
+    uiInput->clear_input();
     break;
+  }
   case WM_KEYDOWN:
     if(wparam == VK_ESCAPE) {
-      if(GetMenu(w_main->hwnd) == NULL) {
-        w_main->show_menu();
+      if(GetMenu(hwnd) == NULL) {
+        show_menu();
       } else {
-        w_main->hide_menu();
+        hide_menu();
       }
-      w_main->center();
+      center();
+    } else if(wparam == VK_PAUSE) {
+      if(bsnes->get_state() == bSNES::RUN) {
+        uiAudio->clear_audio();
+        bsnes->set_state(bSNES::PAUSE);
+        SetWindowText(hwnd, BSNES_TITLE " (Paused)");
+      } else if(bsnes->get_state() == bSNES::PAUSE) {
+        bsnes->set_state(bSNES::RUN);
+      }
+    } else if(wparam >= '0' && wparam <= '9' && KeyDown(VK_CONTROL)) {
+      set_video_mode((wparam != '0') ? (wparam - '0' - 1) : 9);
+    } else if(wparam == VK_SUBTRACT || (wparam == VK_OEM_MINUS && !KeyDown(VK_CONTROL))) {
+      if(frameskip > 0)set_frameskip(frameskip - 1);
+    } else if(wparam == VK_ADD || (wparam == VK_OEM_PLUS && !KeyDown(VK_CONTROL))) {
+      if(frameskip < 9)set_frameskip(frameskip + 1);
+    } else if(wparam == VK_OEM_MINUS && KeyDown(VK_CONTROL)) {
+      if(regulation_speed > 0)set_regulation_speed(regulation_speed - 1);
+    } else if(wparam == VK_OEM_PLUS && KeyDown(VK_CONTROL)) {
+      if(regulation_speed < 4)set_regulation_speed(regulation_speed + 1);
+    }
+    break;
+  case WM_PAINT:
+    if(r_mem->cart_loaded() == true) {
+      uiVideo->redraw();
+    } else {
+      uiVideo->clear_video();
     }
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)) {
     case MENU_FILE_LOAD:
-      w_main->menu_load();
+      menu_load();
       break;
     case MENU_FILE_UNLOAD:
-      w_main->menu_unload();
+      menu_unload();
       break;
     case MENU_FILE_RESET:
-      if(rom_image->loaded() == false)break;
-      dprintf("* Soft Reset");
-      snes->reset();
-      bsnes->debugger_update();
+      bsnes->reset();
+      dprintf("* Reset");
       break;
     case MENU_FILE_POWER:
-      if(rom_image->loaded() == false)break;
-      dprintf("* Power (Hard Reset)");
-      snes->power();
-      bsnes->debugger_update();
+      bsnes->power();
+      dprintf("* Power");
       break;
     case MENU_FILE_EXIT:
       PostQuitMessage(0);
       break;
-    case MENU_SETTINGS_REGULATE_SPEED:
-      config::system.regulate_speed.toggle();
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_REGULATE_SPEED,
-        (config::system.regulate_speed)?MF_CHECKED:MF_UNCHECKED);
+    case MENU_SETTINGS_VIDEOMODE_0:
+    case MENU_SETTINGS_VIDEOMODE_1:
+    case MENU_SETTINGS_VIDEOMODE_2:
+    case MENU_SETTINGS_VIDEOMODE_3:
+    case MENU_SETTINGS_VIDEOMODE_4:
+    case MENU_SETTINGS_VIDEOMODE_5:
+    case MENU_SETTINGS_VIDEOMODE_6:
+    case MENU_SETTINGS_VIDEOMODE_7:
+    case MENU_SETTINGS_VIDEOMODE_8:
+    case MENU_SETTINGS_VIDEOMODE_9:
+      set_video_mode(LOWORD(wparam) - MENU_SETTINGS_VIDEOMODE_0);
       break;
-    case MENU_SETTINGS_FRAMESKIP_OFF:
+    case MENU_SETTINGS_FRAMESKIP_0:
     case MENU_SETTINGS_FRAMESKIP_1:
     case MENU_SETTINGS_FRAMESKIP_2:
     case MENU_SETTINGS_FRAMESKIP_3:
@@ -193,201 +222,206 @@ int i;
     case MENU_SETTINGS_FRAMESKIP_7:
     case MENU_SETTINGS_FRAMESKIP_8:
     case MENU_SETTINGS_FRAMESKIP_9:
-      w_main->set_frameskip(LOWORD(wparam) - MENU_SETTINGS_FRAMESKIP_OFF);
-      break;
-    case MENU_SETTINGS_VIDEOMODE_256x224w:
-      w_main->set_video_mode(VIDEOMODE_256x224w);
-      break;
-    case MENU_SETTINGS_VIDEOMODE_512x448w:
-      w_main->set_video_mode(VIDEOMODE_512x448w);
-      break;
-    case MENU_SETTINGS_VIDEOMODE_960x720w:
-      w_main->set_video_mode(VIDEOMODE_960x720w);
-      break;
-    case MENU_SETTINGS_VIDEOMODE_640x480f:
-      w_main->set_video_mode(VIDEOMODE_640x480f);
-      break;
-    case MENU_SETTINGS_VIDEOMODE_1024x768f:
-      w_main->set_video_mode(VIDEOMODE_1024x768f);
+      set_frameskip(LOWORD(wparam) - MENU_SETTINGS_FRAMESKIP_0);
       break;
     case MENU_SETTINGS_COLORADJUST_COLORCURVE:
       config::snes.video_color_curve.toggle();
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_COLORCURVE,
-        (config::snes.video_color_curve)?MF_CHECKED:MF_UNCHECKED);
+      check(MENU_SETTINGS_COLORADJUST_COLORCURVE, config::snes.video_color_curve);
       break;
     case MENU_SETTINGS_COLORADJUST_NORMAL:
     case MENU_SETTINGS_COLORADJUST_GRAYSCALE:
     case MENU_SETTINGS_COLORADJUST_VGA:
-    case MENU_SETTINGS_COLORADJUST_GENESIS:
-      i = LOWORD(wparam) - MENU_SETTINGS_COLORADJUST_NORMAL;
+    case MENU_SETTINGS_COLORADJUST_GENESIS: {
+    uint32 i = LOWORD(wparam) - MENU_SETTINGS_COLORADJUST_NORMAL;
       config::snes.video_color_adjust_mode = i;
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_NORMAL,    (i == 0)?MF_CHECKED:MF_UNCHECKED);
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_GRAYSCALE, (i == 1)?MF_CHECKED:MF_UNCHECKED);
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_VGA,       (i == 2)?MF_CHECKED:MF_UNCHECKED);
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_GENESIS,   (i == 3)?MF_CHECKED:MF_UNCHECKED);
+      check(MENU_SETTINGS_COLORADJUST_NORMAL,    i == 0);
+      check(MENU_SETTINGS_COLORADJUST_GRAYSCALE, i == 1);
+      check(MENU_SETTINGS_COLORADJUST_VGA,       i == 2);
+      check(MENU_SETTINGS_COLORADJUST_GENESIS,   i == 3);
       break;
-    case MENU_SETTINGS_USEVRAM:
+    }
+    case MENU_SETTINGS_VIDEO_OPTIONS_USEVRAM:
       config::video.use_vram.toggle();
-      w_main->set_video_mode(config::video.mode);
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_USEVRAM, (config::video.use_vram)?MF_CHECKED:MF_UNCHECKED);
+      set_video_mode(config::video.mode);
+      check(MENU_SETTINGS_VIDEO_OPTIONS_USEVRAM, config::video.use_vram);
       break;
-    case MENU_SETTINGS_VBLANK:
-      config::video.vblank.toggle();
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VBLANK, (config::video.vblank)?MF_CHECKED:MF_UNCHECKED);
+    case MENU_SETTINGS_VIDEO_OPTIONS_TRIPLEBUF:
+      config::video.triple_buffering.toggle();
+      check(MENU_SETTINGS_VIDEO_OPTIONS_TRIPLEBUF, config::video.triple_buffering);
       break;
-    case MENU_SETTINGS_SHOWFPS:
+    case MENU_SETTINGS_VIDEO_OPTIONS_SHOWFPS:
       config::gui.show_fps.toggle();
-      SetWindowText(w_main->hwnd, BSNES_TITLE);
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_SHOWFPS, (config::gui.show_fps)?MF_CHECKED:MF_UNCHECKED);
+      SetWindowText(hwnd, BSNES_TITLE);
+      check(MENU_SETTINGS_VIDEO_OPTIONS_SHOWFPS, config::gui.show_fps);
+      break;
+    case MENU_SETTINGS_VIDEO_OPTIONS_PPUCFG:
+      wPPUCfg.show();
       break;
     case MENU_SETTINGS_MUTE:
       config::snes.mute.toggle();
-      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_MUTE, (config::snes.mute)?MF_CHECKED:MF_UNCHECKED);
+      check(MENU_SETTINGS_MUTE, config::snes.mute);
       break;
     case MENU_SETTINGS_INPUTCFG_JOYPAD1:
-      w_inputconfig->begin_config(InputConfig::JOYPAD1);
+      wInputCfg.dev_to_update = SNES::DEV_JOYPAD1;
+      wInputCfg.show();
       break;
     case MENU_SETTINGS_INPUTCFG_JOYPAD2:
-      w_inputconfig->begin_config(InputConfig::JOYPAD2);
+      wInputCfg.dev_to_update = SNES::DEV_JOYPAD2;
+      wInputCfg.show();
       break;
-    case MENU_SETTINGS_DEBUGGER:
-      if(bsnes->debugger_enabled() == true) {
-        bsnes->debugger_disable();
-      } else {
-        bsnes->debugger_enable();
-        w_main->set_video_mode(VIDEOMODE_256x224w);
-      }
+    case MENU_SETTINGS_SPEED_REGULATION_ENABLE:
+      config::system.regulate_speed.toggle();
+      check(MENU_SETTINGS_SPEED_REGULATION_ENABLE, config::system.regulate_speed);
+      break;
+    case MENU_SETTINGS_SPEED_REGULATION_SLOWEST:
+    case MENU_SETTINGS_SPEED_REGULATION_SLOW:
+    case MENU_SETTINGS_SPEED_REGULATION_NORMAL:
+    case MENU_SETTINGS_SPEED_REGULATION_FAST:
+    case MENU_SETTINGS_SPEED_REGULATION_FASTEST:
+      set_regulation_speed(LOWORD(wparam) - MENU_SETTINGS_SPEED_REGULATION_SLOWEST);
       break;
     case MENU_MISC_SCREENSHOT:
       snes->capture_screenshot();
       break;
-    case MENU_MISC_LOGAUDIO:
-      i = CheckMenuItem(w_main->hmenu, MENU_MISC_LOGAUDIO, 0);
-      if(i == MF_UNCHECKED) {
-        CheckMenuItem(w_main->hmenu, MENU_MISC_LOGAUDIO, MF_CHECKED);
+    case MENU_MISC_LOGAUDIO: {
+      if(!checked(MENU_MISC_LOGAUDIO)) {
+        check(MENU_MISC_LOGAUDIO);
         snes->log_audio_enable();
       } else {
-        CheckMenuItem(w_main->hmenu, MENU_MISC_LOGAUDIO, MF_UNCHECKED);
+        uncheck(MENU_MISC_LOGAUDIO);
         snes->log_audio_disable();
       }
       break;
+    }
     case MENU_MISC_ABOUT:
-      w_about->center();
-      w_about->show();
-      SetFocus(w_about->hwnd);
+      alert(BSNES_TITLE "\n" "Written by: byuu");
       break;
     }
     break;
   case WM_DESTROY:
     PostQuitMessage(0);
     break;
-  case WM_PAINT:
-    dd_renderer->redraw();
-    break;
   }
+
   return DefWindowProc(hwnd, msg, wparam, lparam);
 }
 
-void MainWindow::create() {
-WNDCLASS wc;
-int i;
-  wc.cbClsExtra    = 0;
-  wc.cbWndExtra    = 0;
-  wc.hbrBackground = CreateSolidBrush(RGB(0, 0, 0));
-  wc.hCursor       = LoadCursor(0, IDC_ARROW);
-  wc.hIcon         = LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(101));
-  wc.hInstance     = GetModuleHandle(0);
-  wc.lpfnWndProc   = wndproc_main;
-  wc.lpszClassName = "bsnes";
-  wc.lpszMenuName  = 0;
-  wc.style         = CS_HREDRAW | CS_VREDRAW;
-  RegisterClass(&wc);
+void MainWindow::setup() {
+HMENU submenu, branchmenu;
+  menu = CreateMenu();
 
-  hwnd = CreateWindowEx(0, "bsnes", BSNES_TITLE,
-    WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
-    0, 0, 512, 446,
-    0, 0, GetModuleHandle(0), 0);
+  submenu = CreatePopupMenu();
+  AppendMenu(submenu, MF_STRING, MENU_FILE_LOAD,   "&Load ROM");
+  AppendMenu(submenu, MF_STRING, MENU_FILE_UNLOAD, "&Unload ROM");
+  AppendMenu(submenu, MF_SEPARATOR, 0, "");
+  AppendMenu(submenu, MF_STRING, MENU_FILE_RESET,  "&Reset");
+  AppendMenu(submenu, MF_STRING, MENU_FILE_POWER,  "&Power (Hard Reset)");
+  AppendMenu(submenu, MF_SEPARATOR, 0, "");
+  AppendMenu(submenu, MF_STRING, MENU_FILE_EXIT,   "E&xit");
+  AppendMenu(menu, MF_STRING | MF_POPUP, (uint)submenu, "&File");
 
-HMENU hsubmenu, hbranchmenu;
-  hmenu = CreateMenu();
+  submenu = CreatePopupMenu();
 
-  hsubmenu = CreatePopupMenu();
-  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_LOAD, "&Load ROM");
-  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_UNLOAD, "&Unload ROM");
-  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
-  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_RESET, "&Reset");
-  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_POWER, "&Power (Hard Reset)");
-  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
-  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_EXIT, "E&xit");
-  AppendMenu(hmenu, MF_STRING | MF_POPUP, (unsigned int)hsubmenu, "&File");
+  branchmenu = CreatePopupMenu();
+char v[512];
+  for(int i = 0; i <= 4; i++) {
+    get_video_mode_info(i);
+    sprintf(v, "%d. %dx%d", i + 1, vi.x, vi.y);
+    AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_0 + i, v);
+  }
+  AppendMenu(branchmenu, MF_SEPARATOR, 0, "");
+  for(int i = 5; i <= 9; i++) {
+    get_video_mode_info(i);
+    sprintf(v, "%d. %dx%d@%dhz <%dx%d>", (i + 1) % 10, vi.x, vi.y, vi.refresh_rate, vi.width, vi.height);
+    AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_0 + i, v);
+  }
+  AppendMenu(submenu, MF_STRING | MF_POPUP, (uint)branchmenu, "&Video Mode");
 
-  hsubmenu = CreatePopupMenu();
-  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_REGULATE_SPEED, "&Regulate Speed");
+  branchmenu = CreatePopupMenu();
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_0, "Off");
+  AppendMenu(branchmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_1, "1");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_2, "2");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_3, "3");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_4, "4");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_5, "5");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_6, "6");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_7, "7");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_8, "8");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_9, "9");
+  AppendMenu(submenu, MF_STRING | MF_POPUP, (uint)branchmenu, "&Frameskip");
 
-  hbranchmenu = CreatePopupMenu();
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_OFF, "Off");
-  AppendMenu(hbranchmenu, MF_SEPARATOR, 0, "");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_1, "1");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_2, "2");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_3, "3");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_4, "4");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_5, "5");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_6, "6");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_7, "7");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_8, "8");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_9, "9");
-  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Frameskip");
+  branchmenu = CreatePopupMenu();
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_COLORCURVE, "Use &Color Curve");
+  AppendMenu(branchmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_NORMAL,    "Normal (RGB555)");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_GRAYSCALE, "Grayscale Mode (L5)");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_VGA,       "VGA Mode (RGB332)");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_GENESIS,   "Genesis Mode (RGB333)");
+  AppendMenu(submenu, MF_STRING | MF_POPUP, (uint)branchmenu, "&Color Adjust");
 
-  hbranchmenu = CreatePopupMenu();
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_256x224w,  "256x224 Windowed (16:15)");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_512x448w,  "512x448 Windowed (16:15)");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_960x720w,  "960x720 Windowed (4:3)");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_640x480f,  "640x480 Fullscreen (16:15)");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_1024x768f, "1024x768 Fullscreen (4:3)");
-  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Video Mode");
+  branchmenu = CreatePopupMenu();
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_VIDEO_OPTIONS_USEVRAM,   "Use &Video Memory Surface");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_VIDEO_OPTIONS_TRIPLEBUF, "Use &Triple Buffering");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_VIDEO_OPTIONS_SHOWFPS,   "&Show FPS");
+  AppendMenu(branchmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_VIDEO_OPTIONS_PPUCFG,    "&PPU Configuration");
+  AppendMenu(submenu, MF_STRING | MF_POPUP, (uint)branchmenu, "&Video Options");
+  AppendMenu(submenu, MF_SEPARATOR, 0, "");
+  AppendMenu(submenu, MF_STRING, MENU_SETTINGS_MUTE, "&Mute Sound Output");
+  AppendMenu(submenu, MF_SEPARATOR, 0, "");
 
-  hbranchmenu = CreatePopupMenu();
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_COLORCURVE, "Use &Color Curve");
-  AppendMenu(hbranchmenu, MF_SEPARATOR, 0, "");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_NORMAL,    "Normal (RGB555)");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_GRAYSCALE, "Grayscale Mode (L5)");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_VGA,       "VGA Mode (RGB332)");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_GENESIS,   "Genesis Mode (RGB333)");
-  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Color Adjust");
+  branchmenu = CreatePopupMenu();
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_INPUTCFG_JOYPAD1, "Joypad 1");
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_INPUTCFG_JOYPAD2, "Joypad 2");
+  AppendMenu(submenu, MF_STRING | MF_POPUP, (uint)branchmenu, "Configure &Input Devices");
 
-  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_USEVRAM, "Use &Video Memory Surface");
-  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_VBLANK,  "&Wait For Vertical Retrace");
-  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_SHOWFPS, "&Show FPS");
-  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_MUTE,    "&Mute Sound Output");
+  AppendMenu(submenu, MF_SEPARATOR, 0, "");
 
-  hbranchmenu = CreatePopupMenu();
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_INPUTCFG_JOYPAD1, "Joypad 1");
-  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_INPUTCFG_JOYPAD2, "Joypad 2");
-  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Configure Input Devices");
+  branchmenu = CreatePopupMenu();
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_SPEED_REGULATION_ENABLE, "&Enable");
+  AppendMenu(branchmenu, MF_SEPARATOR, 0, "");
+  sprintf(v, "&Slowest (%d%%, %dhz)", uint(100.0 * ((double)config::system.speed_slowest / 32000.0)),
+    (uint)config::system.speed_slowest);
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_SPEED_REGULATION_SLOWEST, v);
+  sprintf(v, "&Slow (%d%%, %dhz)", uint(100.0 * ((double)config::system.speed_slow / 32000.0)),
+    (uint)config::system.speed_slow);
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_SPEED_REGULATION_SLOW, v);
+  sprintf(v, "&Normal (%d%%, %dhz)", uint(100.0 * ((double)config::system.speed_normal / 32000.0)),
+    (uint)config::system.speed_normal);
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_SPEED_REGULATION_NORMAL, v);
+  sprintf(v, "&Fast (%d%%, %dhz)", uint(100.0 * ((double)config::system.speed_fast / 32000.0)),
+    (uint)config::system.speed_fast);
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_SPEED_REGULATION_FAST, v);
+  sprintf(v, "&Fastest (%d%%, %dhz)", uint(100.0 * ((double)config::system.speed_fastest / 32000.0)),
+    (uint)config::system.speed_fastest);
+  AppendMenu(branchmenu, MF_STRING, MENU_SETTINGS_SPEED_REGULATION_FASTEST, v);
+  AppendMenu(submenu, MF_STRING | MF_POPUP, (uint)branchmenu, "&Speed Regulation");
 
-#ifdef DEBUGGER
-  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
-  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_DEBUGGER, "&Debugger");
-#endif
+  AppendMenu(menu, MF_STRING | MF_POPUP, (uint)submenu, "&Settings");
 
-  AppendMenu(hmenu, MF_STRING | MF_POPUP, (unsigned int)hsubmenu, "&Settings");
+  submenu = CreatePopupMenu();
+  AppendMenu(submenu, MF_STRING, MENU_MISC_SCREENSHOT, "&Capture Screenshot");
+  AppendMenu(submenu, MF_STRING, MENU_MISC_LOGAUDIO,   "&Log Audio Data");
+  AppendMenu(submenu, MF_SEPARATOR, 0, "");
+  AppendMenu(submenu, MF_STRING, MENU_MISC_ABOUT, "&About");
+  AppendMenu(menu, MF_STRING | MF_POPUP, (uint)submenu, "&Misc");
 
-  hsubmenu = CreatePopupMenu();
-  AppendMenu(hsubmenu, MF_STRING, MENU_MISC_SCREENSHOT, "&Capture Screenshot");
-  AppendMenu(hsubmenu, MF_STRING, MENU_MISC_LOGAUDIO,   "&Log Audio Data");
-  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
-  AppendMenu(hsubmenu, MF_STRING, MENU_MISC_ABOUT, "&About...");
-  AppendMenu(hmenu, MF_STRING | MF_POPUP, (unsigned int)hsubmenu, "&Misc");
+  show_menu();
 
-  CheckMenuItem(hmenu, MENU_SETTINGS_REGULATE_SPEED, (config::system.regulate_speed)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_USEVRAM,    (config::video.use_vram)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_VBLANK,     (config::video.vblank)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_COLORCURVE, (config::snes.video_color_curve)?MF_CHECKED:MF_UNCHECKED);
-  i = config::snes.video_color_adjust_mode;
-  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_NORMAL,     (i == 0)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_GRAYSCALE,  (i == 1)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_VGA,        (i == 2)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_GENESIS,    (i == 3)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_SHOWFPS, (config::gui.show_fps)?MF_CHECKED:MF_UNCHECKED);
-  CheckMenuItem(hmenu, MENU_SETTINGS_MUTE,    (config::snes.mute)   ?MF_CHECKED:MF_UNCHECKED);
+  check(MENU_SETTINGS_COLORADJUST_COLORCURVE,  config::snes.video_color_curve);
+int32 i = config::snes.video_color_adjust_mode;
+  check(MENU_SETTINGS_COLORADJUST_NORMAL,      i == 0);
+  check(MENU_SETTINGS_COLORADJUST_GRAYSCALE,   i == 1);
+  check(MENU_SETTINGS_COLORADJUST_VGA,         i == 2);
+  check(MENU_SETTINGS_COLORADJUST_GENESIS,     i == 3);
+  check(MENU_SETTINGS_VIDEO_OPTIONS_USEVRAM,   config::video.use_vram);
+  check(MENU_SETTINGS_VIDEO_OPTIONS_TRIPLEBUF, config::video.triple_buffering);
+  check(MENU_SETTINGS_VIDEO_OPTIONS_SHOWFPS,   config::gui.show_fps);
+  check(MENU_SETTINGS_MUTE,                    config::snes.mute);
+  check(MENU_SETTINGS_SPEED_REGULATION_ENABLE, config::system.regulate_speed);
+
+  set_video_mode(config::video.mode);
+  set_frameskip(0);
+  set_regulation_speed(2);
 }
diff --git a/src/win/ui_ppucfg.cpp b/src/win/ui_ppucfg.cpp
new file mode 100644
index 00000000..28a13b87
--- /dev/null
+++ b/src/win/ui_ppucfg.cpp
@@ -0,0 +1,72 @@
+long PPUCfgWindow::wndproc(UINT msg, WPARAM wparam, LPARAM lparam) {
+
+#define toggle(id) \
+  config::##id##_enable.toggle(); \
+  check(LOWORD(wparam), config::##id##_enable)
+
+  switch(msg) {
+  case WM_COMMAND:
+    switch(LOWORD(wparam)) {
+    case PPUCFG_BG1_PRI0:    toggle(ppu.bg1_pri0); break;
+    case PPUCFG_BG1_PRI1:    toggle(ppu.bg1_pri1); break;
+    case PPUCFG_BG2_PRI0:    toggle(ppu.bg2_pri0); break;
+    case PPUCFG_BG2_PRI1:    toggle(ppu.bg2_pri1); break;
+    case PPUCFG_BG3_PRI0:    toggle(ppu.bg3_pri0); break;
+    case PPUCFG_BG3_PRI1:    toggle(ppu.bg3_pri1); break;
+    case PPUCFG_BG4_PRI0:    toggle(ppu.bg4_pri0); break;
+    case PPUCFG_BG4_PRI1:    toggle(ppu.bg4_pri1); break;
+    case PPUCFG_OAM_PRI0:    toggle(ppu.oam_pri0); break;
+    case PPUCFG_OAM_PRI1:    toggle(ppu.oam_pri1); break;
+    case PPUCFG_OAM_PRI2:    toggle(ppu.oam_pri2); break;
+    case PPUCFG_OAM_PRI3:    toggle(ppu.oam_pri3); break;
+    case PPUCFG_HDMA_ENABLE: toggle(cpu.hdma);     break;
+    case PPUCFG_OPT_ENABLE:  toggle(ppu.opt);      break;
+    } break;
+  case WM_CLOSE:
+    hide();
+    return 0;
+  }
+
+#undef toggle
+
+  return DefWindowProc(hwnd, msg, wparam, lparam);
+}
+
+void PPUCfgWindow::setup() {
+  control("STATIC", "BG / OAM display toggles:",    WS_VISIBLE,   5,   5, 200,  15, PPUCFG_STATIC0);
+
+  control("BUTTON", "BG1 Priority 0", BS_CHECKBOX | WS_VISIBLE,   5,  20,  95,  15, PPUCFG_BG1_PRI0);
+  control("BUTTON", "BG1 Priority 1", BS_CHECKBOX | WS_VISIBLE, 105,  20,  95,  15, PPUCFG_BG1_PRI1);
+  control("BUTTON", "BG2 Priority 0", BS_CHECKBOX | WS_VISIBLE,   5,  35,  95,  15, PPUCFG_BG2_PRI0);
+  control("BUTTON", "BG2 Priority 1", BS_CHECKBOX | WS_VISIBLE, 105,  35,  95,  15, PPUCFG_BG2_PRI1);
+  control("BUTTON", "BG3 Priority 0", BS_CHECKBOX | WS_VISIBLE,   5,  50,  95,  15, PPUCFG_BG3_PRI0);
+  control("BUTTON", "BG3 Priority 1", BS_CHECKBOX | WS_VISIBLE, 105,  50,  95,  15, PPUCFG_BG3_PRI1);
+  control("BUTTON", "BG4 Priority 0", BS_CHECKBOX | WS_VISIBLE,   5,  65,  95,  15, PPUCFG_BG4_PRI0);
+  control("BUTTON", "BG4 Priority 1", BS_CHECKBOX | WS_VISIBLE, 105,  65,  95,  15, PPUCFG_BG4_PRI1);
+  control("BUTTON", "OAM Priority 0", BS_CHECKBOX | WS_VISIBLE,   5,  80,  95,  15, PPUCFG_OAM_PRI0);
+  control("BUTTON", "OAM Priority 1", BS_CHECKBOX | WS_VISIBLE, 105,  80,  95,  15, PPUCFG_OAM_PRI1);
+  control("BUTTON", "OAM Priority 2", BS_CHECKBOX | WS_VISIBLE,   5,  95,  95,  15, PPUCFG_OAM_PRI2);
+  control("BUTTON", "OAM Priority 3", BS_CHECKBOX | WS_VISIBLE, 105,  95,  95,  15, PPUCFG_OAM_PRI3);
+
+  control("STATIC", "Misc. video options:",         WS_VISIBLE,   5, 115, 200,  15, PPUCFG_STATIC1);
+  control("BUTTON", "Enable HDMA (affects CPU)",
+                                      BS_CHECKBOX | WS_VISIBLE,   5, 130, 200,  15, PPUCFG_HDMA_ENABLE);
+  control("BUTTON", "Enable offset-per-tile mode effects",
+                                      BS_CHECKBOX | WS_VISIBLE,   5, 145, 200,  15, PPUCFG_OPT_ENABLE);
+
+  check(PPUCFG_BG1_PRI0, config::ppu.bg1_pri0_enable);
+  check(PPUCFG_BG1_PRI1, config::ppu.bg1_pri1_enable);
+  check(PPUCFG_BG2_PRI0, config::ppu.bg2_pri0_enable);
+  check(PPUCFG_BG2_PRI1, config::ppu.bg2_pri1_enable);
+  check(PPUCFG_BG3_PRI0, config::ppu.bg3_pri0_enable);
+  check(PPUCFG_BG3_PRI1, config::ppu.bg3_pri1_enable);
+  check(PPUCFG_BG4_PRI0, config::ppu.bg4_pri0_enable);
+  check(PPUCFG_BG4_PRI1, config::ppu.bg4_pri1_enable);
+  check(PPUCFG_OAM_PRI0, config::ppu.oam_pri0_enable);
+  check(PPUCFG_OAM_PRI1, config::ppu.oam_pri1_enable);
+  check(PPUCFG_OAM_PRI2, config::ppu.oam_pri2_enable);
+  check(PPUCFG_OAM_PRI3, config::ppu.oam_pri3_enable);
+
+  check(PPUCFG_HDMA_ENABLE, config::cpu.hdma_enable);
+  check(PPUCFG_OPT_ENABLE,  config::ppu.opt_enable);
+}
diff --git a/src/win/ui_window.cpp b/src/win/ui_window.cpp
index 14695fe2..c4cddb74 100644
--- a/src/win/ui_window.cpp
+++ b/src/win/ui_window.cpp
@@ -1,167 +1,216 @@
-void Window::resize(int width, int height) {
-int style;
-  window.width  = width;
-  window.height = height;
+long __stdcall window_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
+  if(hwnd == wMain.hwnd)     { return wMain.wndproc(msg, wparam, lparam);     }
+  if(hwnd == wInputCfg.hwnd) { return wInputCfg.wndproc(msg, wparam, lparam); }
+  if(hwnd == wPPUCfg.hwnd)   { return wPPUCfg.wndproc(msg, wparam, lparam);   }
 
-  style = GetWindowLong(hwnd, GWL_STYLE);
-  if(style & WS_CAPTION) {
-    width  += GetSystemMetrics(SM_CXFIXEDFRAME) << 1;
-    height += GetSystemMetrics(SM_CYFIXEDFRAME) << 1;
-    height += GetSystemMetrics(SM_CYCAPTION);
-  }
+  return DefWindowProc(hwnd, msg, wparam, lparam);
+}
 
-  if(width == GetSystemMetrics(SM_CXSCREEN) && height == GetSystemMetrics(SM_CYSCREEN)) {
-    fullscreen = true;
-  } else {
-    fullscreen = false;
-  }
+void Window::hide() {
+  ShowWindow(hwnd, SW_HIDE);
+  settings.visible = false;
+}
 
-  if(fullscreen == false) {
-    if(GetMenu(hwnd) != 0) {
-      height += GetSystemMetrics(SM_CYMENU);
+void Window::show() {
+  ShowWindow(hwnd, SW_NORMAL);
+  SetFocus(hwnd);
+  settings.visible = true;
+}
+
+bool Window::visible() {
+  return settings.visible;
+}
+
+void Window::hide_menu() {
+  if(GetMenu(hwnd) == NULL)return;
+  SetMenu(hwnd, NULL);
+
+  if(settings.fullscreen == true) {
+    if(global::cursor_visible == true) {
+      ShowCursor(FALSE);
+      global::cursor_visible = false;
     }
-    SetWindowPos(hwnd, 0, 0, 0, width, height, SWP_NOZORDER | SWP_NOMOVE);
-  } else {
-    SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, width, height, 0);
+    return;
+  }
+
+  resize(settings.width, settings.height);
+}
+
+void Window::show_menu() {
+  if(GetMenu(hwnd) != NULL)return;
+  SetMenu(hwnd, menu);
+
+  if(global::cursor_visible == false) {
+    ShowCursor(TRUE);
+    global::cursor_visible = true;
+  }
+
+  if(settings.fullscreen == true)return;
+  resize(settings.width, settings.height);
+}
+
+//determine if id belongs to a menu, button, etc.
+//used by check() routines
+uint32 Window::get_id_type(uint32 id) {
+HWND ctl = GetDlgItem(hwnd, id);
+  if(!ctl)return IDTYPE_MENU;
+
+char t[256];
+  GetClassName(GetDlgItem(hwnd, id), t, 255);
+  if(strimatch(t, "button"))return IDTYPE_BUTTON;
+
+  return IDTYPE_UNKNOWN;
+}
+
+void Window::check(uint32 id, bool state) {
+  switch(get_id_type(id)) {
+  case IDTYPE_MENU:
+    CheckMenuItem(menu, id, (state) ? MF_CHECKED : MF_UNCHECKED);
+    break;
+  case IDTYPE_BUTTON:
+    SendDlgItemMessage(hwnd, id, BM_SETCHECK, (WPARAM)state, 0);
+    break;
   }
 }
 
+void Window::check_toggle(uint32 id) {
+  switch(get_id_type(id)) {
+  case IDTYPE_MENU:
+    CheckMenuItem(menu, id, (checked(id)) ? MF_UNCHECKED : MF_CHECKED);
+    break;
+  case IDTYPE_BUTTON:
+    SendDlgItemMessage(hwnd, id, BM_SETCHECK,
+      (WPARAM)SendDlgItemMessage(hwnd, id, BM_GETCHECK, 0, 0), 0);
+    break;
+  }
+}
+
+bool Window::checked(uint32 id) {
+  switch(get_id_type(id)) {
+  case IDTYPE_MENU:   return CheckMenuItem(menu, id, 0);
+  case IDTYPE_BUTTON: return SendDlgItemMessage(hwnd, id, BM_GETCHECK, 0, 0);
+  }
+  return false;
+}
+
+void Window::check(uint32 id) {
+  switch(get_id_type(id)) {
+  case IDTYPE_MENU:   CheckMenuItem(menu, id, MF_CHECKED); break;
+  case IDTYPE_BUTTON: SendDlgItemMessage(hwnd, id, BM_SETCHECK, (WPARAM)TRUE, 0); break;
+  }
+}
+
+void Window::uncheck(uint32 id) {
+  switch(get_id_type(id)) {
+  case IDTYPE_MENU:   CheckMenuItem(menu, id, MF_UNCHECKED); break;
+  case IDTYPE_BUTTON: SendDlgItemMessage(hwnd, id, BM_SETCHECK, (WPARAM)FALSE, 0); break;
+  }
+}
+
+void Window::resize(int width, int height, bool fullscreen) {
+int style   = GetWindowLong(hwnd, GWL_STYLE);
+bool old_fs = settings.fullscreen;
+  settings.width      = width;
+  settings.height     = height;
+  settings.fullscreen = fullscreen;
+
+  if(fullscreen == false) {
+    if(old_fs == true) {
+      style |=  WS_CAPTION;
+      style |=  WS_SYSMENU;
+      style |=  WS_MINIMIZEBOX;
+      SetWindowLong(hwnd, GWL_STYLE, style);
+      show_menu();
+    }
+
+  //add window borders + menu to size
+    width  += GetSystemMetrics(SM_CXFIXEDFRAME) << 1;
+    height += GetSystemMetrics(SM_CYFIXEDFRAME) << 1;
+    height += GetSystemMetrics(SM_CYCAPTION);
+    if(GetMenu(hwnd) != 0) {
+      height += GetSystemMetrics(SM_CYMENU);
+    }
+  } else {
+    if(old_fs == false) {
+      style &= ~WS_CAPTION;
+      style &= ~WS_SYSMENU;
+      style &= ~WS_MINIMIZEBOX;
+      SetWindowLong(hwnd, GWL_STYLE, style);
+      hide_menu();
+    }
+  }
+
+  if(fullscreen == false) {
+    SetWindowPos(hwnd, 0, 0, 0, width, height, SWP_NOZORDER | SWP_NOMOVE);
+  } else {
+    SetWindowPos(hwnd, 0, 0, 0,
+      GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), SWP_NOZORDER);
+  }
+
+  if(settings.center == true)center();
+}
+
 void Window::center() {
+  if(settings.fullscreen == true)return;
+
 RECT rc;
 POINT p;
-  if(fullscreen == true) {
-    SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, window.width, window.height, 0);
-    return;
-  }
   GetWindowRect(hwnd, &rc);
   p.x = p.y = 0;
   ClientToScreen(hwnd, &p);
   OffsetRect(&rc, p.x, p.y);
 int sw = GetSystemMetrics(SM_CXSCREEN),
     sh = GetSystemMetrics(SM_CYSCREEN);
-int x = (sw - (rc.right - rc.left)) >> 1,
-    y = (sh - (rc.bottom - rc.top)) >> 1;
+int x = (sw - (rc.right - rc.left)) / 2,
+    y = (sh - (rc.bottom - rc.top)) / 2;
   SetWindowPos(hwnd, 0, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
 }
 
-void Window::show_menu() {
-RECT rc;
-int width, height;
-  if(GetMenu(hwnd) != NULL)return;
-
-  SetMenu(hwnd, hmenu);
-  if(cursor_visible == false) {
-    ShowCursor(TRUE);
-    cursor_visible = true;
-  }
-  if(fullscreen == true) {
-    return;
-  }
-
-  resize(window.width, window.height);
+void Window::set_text(uint32 id, const char *text, ...) {
+  SetDlgItemText(hwnd, id, text);
 }
 
-void Window::hide_menu() {
-RECT rc;
-int width, height;
-  if(GetMenu(hwnd) == NULL)return;
-
-  SetMenu(hwnd, NULL);
-  if(fullscreen == true) {
-    if(cursor_visible == true) {
-      ShowCursor(FALSE);
-      cursor_visible = false;
-    }
-    return;
-  }
-
-  resize(window.width, window.height);
+void Window::control(const char *classname, const char *text, uint32 flags, int x, int y, int width, int height, uint32 id) {
+  CreateWindow(classname, text, flags | WS_CHILD, x, y, width, height, hwnd, (HMENU)id, GetModuleHandle(0), 0);
+  SendDlgItemMessage(hwnd, id, WM_SETFONT, (WPARAM)global::vwf, 0);
 }
 
-void Window::show() {
-int style;
-  visible = true;
-  style = GetWindowLong(hwnd, GWL_STYLE);
-  if(style & WS_VISIBLE)return;
-  ShowWindow(hwnd, SW_NORMAL);
+long Window::wndproc(UINT msg, WPARAM wparam, LPARAM lparam) {
+  return DefWindowProc(hwnd, msg, wparam, lparam);
 }
 
-void Window::hide() {
-int style;
-  visible = false;
-  style = GetWindowLong(hwnd, GWL_STYLE);
-  if(!(style & WS_VISIBLE))return;
-  ShowWindow(hwnd, SW_HIDE);
-}
+void Window::init(const char *classname, const char *title, int width, int height, HBRUSH hbr, uint32 flags) {
+WNDCLASS wc;
+  wc.cbClsExtra    = 0;
+  wc.cbWndExtra    = 0;
+  wc.hbrBackground = (HBRUSH)hbr;
+  wc.hCursor       = LoadCursor(0, IDC_ARROW);
+  wc.hIcon         = LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(100));
+  wc.hInstance     = GetModuleHandle(0);
+  wc.lpfnWndProc   = window_wndproc;
+  wc.lpszClassName = classname;
+  wc.lpszMenuName  = 0;
+  wc.style         = CS_HREDRAW | CS_VREDRAW;
+  RegisterClass(&wc);
 
-void Window::to_left(HWND _hwnd) {
-RECT rc;
-int offset = 0;
-  if(_hwnd) {
-    GetWindowRect(_hwnd, &rc);
-    offset = rc.right;
-  } else {
-    offset = wa_offset.left;
-  }
-  GetWindowRect(hwnd, &rc);
-  rc.left = offset;
-  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
-}
+  hwnd = CreateWindowEx((flags & WF_TOPMOST) ? WS_EX_TOPMOST : 0, classname, title,
+    WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
+    64, 64, width, height,
+    0, 0, wc.hInstance, 0);
 
-void Window::to_center() {
-RECT rc;
-  GetWindowRect(hwnd, &rc);
-  rc.left = (GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2;
-  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
-}
-
-void Window::to_right() {
-RECT rc;
-  GetWindowRect(hwnd, &rc);
-  rc.left = GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left);
-  rc.left -= wa_offset.right;
-  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
-}
-
-void Window::to_top() {
-RECT rc;
-  GetWindowRect(hwnd, &rc);
-  rc.top = wa_offset.top;
-  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
-}
-
-void Window::to_middle() {
-RECT rc;
-  GetWindowRect(hwnd, &rc);
-  rc.top = (GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2;
-  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
-}
-
-void Window::to_bottom(HWND _hwnd) {
-RECT rc;
-int offset = 0;
-  if(_hwnd) {
-    GetWindowRect(_hwnd, &rc);
-    offset = rc.bottom - rc.top;
-  }
-  GetWindowRect(hwnd, &rc);
-  rc.top = GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top) - offset;
-  rc.top -= wa_offset.bottom;
-  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+  settings.visible = false;
+  settings.width   = width;
+  settings.height  = height;
+  settings.center  = !!(flags & WF_CENTER);
+  resize(width, height);
 }
 
 Window::Window() {
-  fullscreen     = false;
-  visible        = false;
-  cursor_visible = true;
-  hmenu          = NULL;
+  hwnd = 0;
+  menu = 0;
 
-  SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea, 0);
-int sw = GetSystemMetrics(SM_CXSCREEN),
-    sh = GetSystemMetrics(SM_CYSCREEN);
-
-  wa_offset.left   = workarea.left;
-  wa_offset.top    = workarea.top;
-  wa_offset.right  = sw - workarea.right;
-  wa_offset.bottom = sh - workarea.bottom;
+  settings.fullscreen = false;
+  settings.center     = false;
+  settings.width      = 320;
+  settings.height     = 240;
 }
diff --git a/src/win/video/ddraw.cpp b/src/win/video/ddraw.cpp
new file mode 100644
index 00000000..622e47be
--- /dev/null
+++ b/src/win/video/ddraw.cpp
@@ -0,0 +1,232 @@
+void VideoDD::create_surface(uint8 i) {
+int depth;
+  lpdds->GetSurfaceDesc(&ddsd);
+  depth = ddsd.ddpfPixelFormat.dwRGBBitCount;
+  if(depth == 15 || depth == 16 || (bool)config::video.use_vram == false) {
+    goto try_native_surface;
+  }
+
+  memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
+  ddsd.dwSize = sizeof(DDSURFACEDESC2);
+  ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+  if((bool)config::video.use_vram == true) {
+    ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
+  } else {
+    ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
+  }
+
+  ddsd.dwWidth  = 512 + 4;
+  ddsd.dwHeight = 480 + 4;
+
+  ddsd.ddpfPixelFormat.dwSize        = sizeof(DDPIXELFORMAT);
+  ddsd.ddpfPixelFormat.dwFlags       = DDPF_RGB;
+  ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
+  ddsd.ddpfPixelFormat.dwRBitMask    = 0xf800;
+  ddsd.ddpfPixelFormat.dwGBitMask    = 0x07e0;
+  ddsd.ddpfPixelFormat.dwBBitMask    = 0x001f;
+
+  if(lpdd7->CreateSurface(&ddsd, &surface[i].lpdds, 0) == DD_OK)goto clear_surface;
+
+try_native_surface:
+  memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
+  ddsd.dwSize = sizeof(DDSURFACEDESC2);
+  ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+  if((bool)config::video.use_vram == true) {
+    ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
+  } else {
+    ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
+  }
+
+  ddsd.dwWidth  = 512 + 4;
+  ddsd.dwHeight = 480 + 4;
+
+  lpdd7->CreateSurface(&ddsd, &surface[i].lpdds, 0);
+
+clear_surface:
+  if(!surface[i].lpdds) {
+    alert("Error: Failed to create DirectDraw backbuffer, cannot continue");
+    exit(0);
+  }
+
+DDBLTFX fx;
+  fx.dwSize = sizeof(DDBLTFX);
+  fx.dwFillColor = 0x00000000;
+  surface[i].lpdds->Blt(0, 0, 0, DDBLT_WAIT | DDBLT_COLORFILL, &fx);
+
+  surface[i].valid = false;
+}
+
+void VideoDD::clear_video() {
+DDBLTFX fx;
+  fx.dwSize = sizeof(DDBLTFX);
+  fx.dwFillColor = 0x00000000;
+  lpdds->Blt(0, 0, 0, DDBLT_WAIT | DDBLT_COLORFILL, &fx);
+}
+
+void VideoDD::set_mode_windowed() {
+  settings.fullscreen = false;
+  DirectDrawCreate(0, &lpdd, 0);
+  lpdd->QueryInterface(IID_IDirectDraw7, (void**)&lpdd7);
+  lpdd->Release();
+  lpdd = 0;
+  lpdd7->SetCooperativeLevel(wMain.hwnd, DDSCL_NORMAL);
+}
+
+void VideoDD::set_mode_fullscreen() {
+  settings.fullscreen = true;
+  DirectDrawCreate(0, &lpdd, 0);
+  lpdd->QueryInterface(IID_IDirectDraw7, (void**)&lpdd7);
+  lpdd->Release();
+  lpdd = 0;
+
+  lpdd7->SetCooperativeLevel(wMain.hwnd, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE);
+  lpdd7->SetDisplayMode(settings.width, settings.height, 16, settings.refresh_rate, 0);
+}
+
+void VideoDD::set_source_window() {
+//skip first scanline
+int i = (vi.height == 224) ? 1 : 2;
+  SetRect(&lpddrc, 0, i, vi.width, vi.height);
+}
+
+void VideoDD::redraw() {
+RECT rd;
+  if(settings.fullscreen == false) {
+  POINT p = { 0, 0 };
+    ClientToScreen(wMain.hwnd, &p);
+    GetClientRect(wMain.hwnd, &rd);
+    OffsetRect(&rd, p.x, p.y);
+  } else {
+  int rx = (settings.width  - settings.output_width)  >> 1;
+  int ry = (settings.height - settings.output_height) >> 1;
+    SetRect(&rd, rx, ry, rx + settings.output_width, ry + settings.output_height);
+  }
+
+HRESULT hr = lpdds->Blt(&rd, surface[active_surface ^ 1].lpdds, &lpddrc, DDBLT_WAIT, 0);
+  if(hr == DDERR_SURFACELOST) {
+    lpdds->Restore();
+    surface[0].lpdds->Restore();
+    surface[1].lpdds->Restore();
+  }
+
+  surface[active_surface ^ 1].valid = false;
+}
+
+uint16 *VideoDD::lock(uint32 &pitch) {
+  if(surface[active_surface].lpdds->Lock(0, &ddsd, DDLOCK_WAIT, 0) != DD_OK)return 0;
+  pitch = ddsd.lPitch;
+  return (uint16*)ddsd.lpSurface;
+}
+
+void VideoDD::unlock() {
+  surface[active_surface].lpdds->Unlock(0);
+}
+
+/*
+  Run periodically to see if the screen needs to be refreshed due to entering
+  vblank period. This will only happen when triple buffering is enabled.
+*/
+void VideoDD::scanline() {
+  if((bool)config::video.triple_buffering == false)return;
+
+#if 1
+uint32 current_scanline;
+  lpdd7->GetScanLine(&current_scanline);
+
+  if(current_scanline >= settings.screen_height && last_scanline < settings.screen_height) {
+    if(surface[active_surface ^ 1].valid == true) {
+      redraw();
+    }
+  }
+
+  last_scanline = current_scanline;
+#else
+BOOL status;
+bool vblank_status;
+  lpdd7->GetVerticalBlankStatus(&status);
+  vblank_status = (status == TRUE);
+
+  if(vblank_status == true && in_vblank == false) {
+    if(surface[active_surface ^ 1].valid == true) {
+      redraw();
+    }
+  }
+
+  in_vblank = vblank_status;
+#endif
+}
+
+void VideoDD::update() {
+  snes->get_video_info(&vi);
+  set_source_window();
+
+  surface[active_surface].valid = true;
+  active_surface ^= 1;
+
+  if((bool)config::video.triple_buffering == false)redraw();
+}
+
+bool VideoDD::set_video_mode(int width, int height, bool fullscreen,
+int refresh_rate, int output_width, int output_height) {
+  settings.width         = width;
+  settings.height        = height;
+  settings.output_width  = output_width;
+  settings.output_height = output_height;
+  settings.fullscreen    = fullscreen;
+  settings.refresh_rate  = refresh_rate;
+
+  term();
+
+  if(settings.fullscreen) {
+    set_mode_fullscreen();
+  } else {
+    set_mode_windowed();
+  }
+
+  wMain.hide();
+  wMain.resize(width, height, fullscreen);
+  wMain.show();
+
+  settings.screen_height = GetSystemMetrics(SM_CYSCREEN);
+
+  memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
+  ddsd.dwSize         = sizeof(DDSURFACEDESC2);
+  ddsd.dwFlags        = DDSD_CAPS;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+  lpdd7->CreateSurface(&ddsd, &lpdds, 0);
+
+  lpdd7->CreateClipper(0, &lpddc, 0);
+  lpddc->SetHWnd(0, wMain.hwnd);
+  lpdds->SetClipper(lpddc);
+
+  active_surface = 0;
+  last_scanline  = 0;
+  in_vblank      = false;
+  create_surface(0);
+  create_surface(1);
+  clear_video();
+
+  return true;
+}
+
+void VideoDD::init() {}
+
+void VideoDD::term() {
+  if(lpddc) { lpddc->Release(); lpddc = 0; }
+  if(surface[0].lpdds) { surface[0].lpdds->Release(); surface[0].lpdds = 0; }
+  if(surface[1].lpdds) { surface[1].lpdds->Release(); surface[1].lpdds = 0; }
+  if(lpdds) { lpdds->Release(); lpdds = 0; }
+  if(lpdd7) { lpdd7->Release(); lpdd7 = 0; }
+  if(lpdd)  { lpdd->Release();  lpdd  = 0; }
+}
+
+VideoDD::VideoDD() {
+  lpdd             = 0;
+  lpdd7            = 0;
+  lpdds            = 0;
+  surface[0].lpdds = 0;
+  surface[1].lpdds = 0;
+  lpddc            = 0;
+}
diff --git a/src/win/video/ddraw.h b/src/win/video/ddraw.h
new file mode 100644
index 00000000..9a523d03
--- /dev/null
+++ b/src/win/video/ddraw.h
@@ -0,0 +1,43 @@
+#include <ddraw.h>
+
+class VideoDD : public Video {
+private:
+LPDIRECTDRAW         lpdd;
+LPDIRECTDRAW7        lpdd7;
+LPDIRECTDRAWSURFACE7 lpdds;
+LPDIRECTDRAWCLIPPER  lpddc;
+
+struct {
+  LPDIRECTDRAWSURFACE7 lpdds;
+  bool valid;
+} surface[2];
+uint8  active_surface;
+bool   in_vblank;
+uint32 last_scanline;
+
+DDSURFACEDESC2 ddsd;
+DDSCAPS        ddscaps;
+
+RECT lpddrc;
+bool fullscreen;
+
+public:
+  uint16 *lock(uint32 &pitch);
+  void    unlock();
+
+  void    clear_video();
+  bool    set_video_mode(int width, int height, bool fullscreen,
+            int refresh_rate, int output_width, int output_height);
+  void    init();
+  void    term();
+
+  void    create_surface(uint8 i);
+  void    set_mode_windowed();
+  void    set_mode_fullscreen();
+  void    set_source_window();
+  void    redraw();
+  void    scanline();
+  void    update();
+
+  VideoDD();
+};
diff --git a/src/win/video/video.h b/src/win/video/video.h
new file mode 100644
index 00000000..1ff98091
--- /dev/null
+++ b/src/win/video/video.h
@@ -0,0 +1,24 @@
+class Video {
+public:
+SNES::video_info vi;
+struct {
+  int  width, height, refresh_rate;
+  int  output_width, output_height;
+  int  screen_height;
+  bool fullscreen;
+} settings;
+  virtual uint16 *lock(uint32 &pitch) = 0;
+  virtual void    unlock() = 0;
+
+  virtual void    clear_video() = 0;
+  virtual bool    set_video_mode(int width, int height, bool fullscreen,
+                    int refresh_rate, int output_width, int output_height) = 0;
+
+  virtual void    scanline() {}
+  virtual void    redraw() = 0;
+  virtual void    update() = 0;
+  virtual void    init() = 0;
+  virtual void    term() = 0;
+};
+
+#include "ddraw.h"
diff --git a/src/win_legacy/Makefile b/src/win_legacy/Makefile
new file mode 100644
index 00000000..d6b485f6
--- /dev/null
+++ b/src/win_legacy/Makefile
@@ -0,0 +1,123 @@
+CC = cl
+CFLAGS = /nologo /O2 /wd4996
+OBJS = winmain.obj \
+       libstring.obj libconfig.obj \
+       reader.obj cart.obj \
+       memory.obj bmemory.obj \
+       cpu.obj bcpu.obj \
+       apu.obj bapu.obj \
+       bdsp.obj \
+       ppu.obj bppu.obj \
+       snes.obj \
+       srtc.obj sdd1.obj c4.obj
+#      adler32.obj compress.obj crc32.obj deflate.obj gzio.obj inffast.obj \
+#      inflate.obj inftrees.obj ioapi.obj trees.obj unzip.obj zip.obj zutil.obj \
+#      jma.obj jcrc32.obj lzmadec.obj 7zlzma.obj iiostrm.obj inbyte.obj lzma.obj winout.obj
+LIBS = kernel32.lib user32.lib gdi32.lib comdlg32.lib ddraw.lib dsound.lib dxguid.lib
+
+all: $(OBJS)
+	rc /r /fobsnes.res bsnes.rc
+	$(CC) /Febsnes.exe $(CFLAGS) $(OBJS) bsnes.res $(LIBS)
+#/link /PGD:bsnes.pgd /LTCG:PGOPTIMIZE
+
+clean:
+	del *.obj
+	del *.pgd
+	del *.pgc
+	del *.ilk
+	del *.pdb
+
+######################
+### win32-specific ###
+######################
+winmain.obj: *.cpp *.h ../config/*
+	$(CC) $(CFLAGS) /c winmain.cpp
+
+#################
+### libraries ###
+#################
+libstring.obj: ../lib/*.cpp ../lib/*.h
+	$(CC) $(CFLAGS) /c ../lib/libstring.cpp
+libconfig.obj: ../lib/*.cpp ../lib/*.h
+	$(CC) $(CFLAGS) /c ../lib/libconfig.cpp
+
+##############
+### memory ###
+##############
+memory.obj: ../memory/memory.cpp ../memory/memory.h
+	$(CC) $(CFLAGS) /c ../memory/memory.cpp
+
+bmemory.obj: ../memory/bmemory/*
+	$(CC) $(CFLAGS) /c ../memory/bmemory/bmemory.cpp
+
+###########
+### cpu ###
+###########
+cpu.obj: ../cpu/*.cpp ../cpu/*.h
+	$(CC) $(CFLAGS) /c ../cpu/cpu.cpp
+
+bcpu.obj: ../cpu/bcpu/*
+	$(CC) $(CFLAGS) /c ../cpu/bcpu/bcpu.cpp
+
+###########
+### apu ###
+###########
+apu.obj: ../apu/*
+	$(CC) $(CFLAGS) /c ../apu/apu.cpp
+
+bapu.obj: ../apu/bapu/*
+	$(CC) $(CFLAGS) /c ../apu/bapu/bapu.cpp
+
+###########
+### dsp ###
+###########
+bdsp.obj: ../dsp/bdsp/*
+	$(CC) $(CFLAGS) /c ../dsp/bdsp/bdsp.cpp
+
+###########
+### ppu ###
+###########
+ppu.obj: ../ppu/*.cpp ../ppu/*.h
+	$(CC) $(CFLAGS) /c ../ppu/ppu.cpp
+
+bppu.obj: ../ppu/bppu/*
+	$(CC) $(CFLAGS) /c ../ppu/bppu/bppu.cpp
+
+#################
+### utilities ###
+#################
+reader.obj: ../reader/*.cpp ../reader/*.h
+	$(CC) $(CFLAGS) /c ../reader/reader.cpp
+
+cart.obj: ../cart/*.cpp ../cart/*.h
+	$(CC) $(CFLAGS) /c ../cart/cart.cpp
+
+############
+### snes ###
+############
+snes.obj: ../snes/*.cpp ../snes/*.h
+	$(CC) $(CFLAGS) /c ../snes/snes.cpp
+
+#####################
+### special chips ###
+#####################
+srtc.obj: ../chip/srtc/*.cpp ../chip/srtc/*.h
+	$(CC) $(CFLAGS) /c ../chip/srtc/srtc.cpp
+
+sdd1.obj: ../chip/sdd1/*.cpp ../chip/sdd1/*.h
+	$(CC) $(CFLAGS) /c ../chip/sdd1/sdd1.cpp
+
+c4.obj: ../chip/c4/*.cpp ../chip/c4/*.h
+	$(CC) $(CFLAGS) /c ../chip/c4/c4.cpp
+
+############
+### zlib ###
+############
+adler32.obj: ../reader/zlib/*.c ../reader/zlib/*.h
+	$(CC) $(CFLAGS) /c ../reader/zlib/*.c
+
+###########
+### jma ###
+###########
+jma.obj: ../reader/jma/*.cpp ../reader/jma/*.h
+	$(CC) $(CFLAGS) /c ../reader/jma/*.cpp
diff --git a/src/win_legacy/bsnes.cpp b/src/win_legacy/bsnes.cpp
new file mode 100644
index 00000000..cce37c24
--- /dev/null
+++ b/src/win_legacy/bsnes.cpp
@@ -0,0 +1,570 @@
+void bSNES::power() {
+  ds_sound->init();
+  SNES::power();
+}
+
+void bSNES::reset() {
+  SNES::reset();
+}
+
+void bSNES::set_status(uint32 new_status) {
+uint8 cpu_op;
+  run_status = new_status;
+
+  switch(new_status) {
+  case STOP:
+    w_console->is_running(false);
+    w_console->update_status();
+    w_memory->refresh();
+    break;
+  case RUNTOCPUSTEP:
+    status.cpu_ran = false;
+    break;
+  case RUNTOCPUPROCEED:
+    cpu_op = r_mem->read(r_cpu->regs.pc.d);
+
+    if(cpu_op == 0x10 || //bpl rel
+       cpu_op == 0x30 || //bmi rel
+       cpu_op == 0x50 || //bvc rel
+       cpu_op == 0x70 || //bvs rel
+       cpu_op == 0x90 || //bcc rel
+       cpu_op == 0xb0 || //bcs rel
+       cpu_op == 0xd0 || //bne rel
+       cpu_op == 0xf0 || //beq rel
+       cpu_op == 0x20 || //jsr addr
+       cpu_op == 0x22 || //jsl long
+       cpu_op == 0xfc    //jsr (addr,x)
+    ) {
+      w_console->is_running(true);
+      status.cpu_stop_pos = (r_cpu->regs.pc.b << 16) | ((r_cpu->regs.pc.d + r_cpu->opcode_length()) & 0xffff);
+    } else {
+      status.cpu_ran = false;
+      run_status     = RUNTOCPUSTEP;
+    }
+    break;
+  case RUNTOAPUSTEP:
+    status.apu_ran = false;
+    break;
+  }
+}
+
+uint32 bSNES::get_status() {
+  return run_status;
+}
+
+void bSNES::run() {
+  if(!r_mem->cart_loaded())return;
+
+  switch(run_status) {
+  case RUN:
+    SNES::runtoframe();
+    return;
+  case STOP:
+    break;
+  case RUNONCE:
+    SNES::run();
+    set_status(STOP);
+    break;
+  case RUNTOSIGNAL:
+    SNES::run();
+    if(w_bp->hit() == true) {
+      set_status(STOP);
+      disassemble_bp_op();
+    }
+    break;
+  case RUNTOFRAME:
+    SNES::run();
+    if(r_ppu->status.frame_executed == true) {
+      r_ppu->status.frame_executed = false;
+      set_status(STOP);
+      disassemble_apu_op();
+      disassemble_cpu_op();
+    } else if(w_bp->hit() == true) {
+      set_status(STOP);
+      disassemble_bp_op();
+    }
+    return;
+  case RUNTOCPUSTEP:
+    SNES::run();
+    if(status.cpu_ran == true) {
+      set_status(STOP);
+    } else if(w_bp->hit() == true) {
+      set_status(STOP);
+      disassemble_bp_op();
+    }
+    break;
+  case RUNTOCPUPROCEED:
+    SNES::run();
+    if(r_cpu->in_opcode() == false && status.cpu_stop_pos == r_cpu->regs.pc.d) {
+      set_status(STOP);
+      disassemble_cpu_op();
+    } else if(w_bp->hit() == true) {
+      set_status(STOP);
+      disassemble_bp_op();
+    }
+    break;
+  case RUNTOCPUTRACE:
+    SNES::run();
+    if(status.cpu_trace_pos >= status.cpu_trace_stop) {
+      set_status(STOP);
+      disassemble_cpu_op();
+    }
+    break;
+  case RUNTOAPUSTEP:
+    SNES::run();
+    if(status.apu_ran == true || w_bp->hit() == true) {
+      set_status(STOP);
+    }
+    break;
+  }
+}
+
+void bSNES::video_run() {
+  if(r_ppu->status.frames_updated) {
+  char s[512], t[512];
+    r_ppu->status.frames_updated = false;
+    if((bool)config::gui.show_fps == true) {
+      sprintf(s, "%s : %d fps", BSNES_TITLE, r_ppu->status.frames_executed);
+      if(w_main->frameskip != 0) {
+        sprintf(t, " (%d frames)", r_ppu->status.frames_rendered);
+        strcat(s, t);
+      }
+      SetWindowText(w_main->hwnd, s);
+    }
+  }
+
+  w_main->frameskip_pos++;
+  w_main->frameskip_pos %= (w_main->frameskip + 1);
+  if(r_ppu->renderer_enabled())dd_renderer->update();
+  r_ppu->enable_renderer(w_main->frameskip_pos == 0);
+}
+
+void bSNES::sound_run(uint32 data) {
+  ds_sound->run(data);
+}
+
+/***********************
+ *** Video functions ***
+ ***********************/
+uint16 *bSNES::video_lock(uint32 &pitch) {
+  return dd_renderer->lock(pitch);
+}
+
+void bSNES::video_unlock() {
+  dd_renderer->unlock();
+}
+
+/***********************
+ *** Input functions ***
+ ***********************/
+void bSNES::clear_input() {
+  joypad1.up     = joypad2.up =
+  joypad1.down   = joypad2.down =
+  joypad1.left   = joypad2.left =
+  joypad1.right  = joypad2.right =
+  joypad1.a      = joypad2.a =
+  joypad1.b      = joypad2.b =
+  joypad1.x      = joypad2.x =
+  joypad1.y      = joypad2.y =
+  joypad1.l      = joypad2.l =
+  joypad1.r      = joypad2.r =
+  joypad1.select = joypad2.select =
+  joypad1.start  = joypad2.start = 0;
+}
+
+void bSNES::poll_input(uint8 type) {
+//only capture input when main window has focus
+  if(GetForegroundWindow() == w_main->hwnd) {
+    switch(type) {
+    case SNES::DEV_JOYPAD1:
+      joypad1.up     = KeyDown(config::input.joypad1.up);
+      joypad1.down   = KeyDown(config::input.joypad1.down);
+      joypad1.left   = KeyDown(config::input.joypad1.left);
+      joypad1.right  = KeyDown(config::input.joypad1.right);
+      joypad1.select = KeyDown(config::input.joypad1.select);
+      joypad1.start  = KeyDown(config::input.joypad1.start);
+      joypad1.y      = KeyDown(config::input.joypad1.y);
+      joypad1.b      = KeyDown(config::input.joypad1.b);
+      joypad1.x      = KeyDown(config::input.joypad1.x);
+      joypad1.a      = KeyDown(config::input.joypad1.a);
+      joypad1.l      = KeyDown(config::input.joypad1.l);
+      joypad1.r      = KeyDown(config::input.joypad1.r);
+      break;
+    case SNES::DEV_JOYPAD2:
+      joypad2.up     = KeyDown(config::input.joypad2.up);
+      joypad2.down   = KeyDown(config::input.joypad2.down);
+      joypad2.left   = KeyDown(config::input.joypad2.left);
+      joypad2.right  = KeyDown(config::input.joypad2.right);
+      joypad2.select = KeyDown(config::input.joypad2.select);
+      joypad2.start  = KeyDown(config::input.joypad2.start);
+      joypad2.y      = KeyDown(config::input.joypad2.y);
+      joypad2.b      = KeyDown(config::input.joypad2.b);
+      joypad2.x      = KeyDown(config::input.joypad2.x);
+      joypad2.a      = KeyDown(config::input.joypad2.a);
+      joypad2.l      = KeyDown(config::input.joypad2.l);
+      joypad2.r      = KeyDown(config::input.joypad2.r);
+      break;
+    }
+  } else {
+    switch(type) {
+    case SNES::DEV_JOYPAD1:
+      joypad1.up = joypad1.down = joypad1.left = joypad1.right =
+      joypad1.select = joypad1.start =
+      joypad1.y = joypad1.b = joypad1.x = joypad1.a =
+      joypad1.l = joypad1.r = 0;
+      break;
+    case SNES::DEV_JOYPAD2:
+      joypad2.up = joypad2.down = joypad2.left = joypad2.right =
+      joypad2.select = joypad2.start =
+      joypad2.y = joypad2.b = joypad2.x = joypad2.a =
+      joypad1.l = joypad2.r = 0;
+      break;
+    }
+  }
+
+//check for debugger-based key locks
+  if(is_debugger_enabled == true && type == SNES::DEV_JOYPAD1) {
+    if(w_console->joypad_lock.up    )joypad1.up     = true;
+    if(w_console->joypad_lock.down  )joypad1.down   = true;
+    if(w_console->joypad_lock.left  )joypad1.left   = true;
+    if(w_console->joypad_lock.right )joypad1.right  = true;
+    if(w_console->joypad_lock.a     )joypad1.a      = true;
+    if(w_console->joypad_lock.b     )joypad1.b      = true;
+    if(w_console->joypad_lock.x     )joypad1.x      = true;
+    if(w_console->joypad_lock.y     )joypad1.y      = true;
+    if(w_console->joypad_lock.l     )joypad1.l      = true;
+    if(w_console->joypad_lock.r     )joypad1.r      = true;
+    if(w_console->joypad_lock.select)joypad1.select = true;
+    if(w_console->joypad_lock.start )joypad1.start  = true;
+  }
+
+//it's impossible to hold both up+down, or left+right down
+//at the same time on a directional pad; and besides, allowing
+//this to happen causes glitches in many SNES games.
+  if(joypad1.up)  joypad1.down  = 0;
+  if(joypad1.left)joypad1.right = 0;
+
+  if(joypad2.up)  joypad2.down  = 0;
+  if(joypad2.left)joypad2.right = 0;
+}
+
+bool bSNES::get_input_status(uint8 device, uint8 button) {
+  switch(device) {
+  case DEV_JOYPAD1:
+    switch(button) {
+    case JOYPAD_UP:    return joypad1.up;
+    case JOYPAD_DOWN:  return joypad1.down;
+    case JOYPAD_LEFT:  return joypad1.left;
+    case JOYPAD_RIGHT: return joypad1.right;
+    case JOYPAD_A:     return joypad1.a;
+    case JOYPAD_B:     return joypad1.b;
+    case JOYPAD_X:     return joypad1.x;
+    case JOYPAD_Y:     return joypad1.y;
+    case JOYPAD_L:     return joypad1.l;
+    case JOYPAD_R:     return joypad1.r;
+    case JOYPAD_SELECT:return joypad1.select;
+    case JOYPAD_START: return joypad1.start;
+    }
+    break;
+  case DEV_JOYPAD2:
+    switch(button) {
+    case JOYPAD_UP:    return joypad2.up;
+    case JOYPAD_DOWN:  return joypad2.down;
+    case JOYPAD_LEFT:  return joypad2.left;
+    case JOYPAD_RIGHT: return joypad2.right;
+    case JOYPAD_A:     return joypad2.a;
+    case JOYPAD_B:     return joypad2.b;
+    case JOYPAD_X:     return joypad2.x;
+    case JOYPAD_Y:     return joypad2.y;
+    case JOYPAD_L:     return joypad2.l;
+    case JOYPAD_R:     return joypad2.r;
+    case JOYPAD_SELECT:return joypad2.select;
+    case JOYPAD_START: return joypad2.start;
+    }
+    break;
+  }
+
+  return 0;
+}
+
+bJoypad::bJoypad() {
+  up = down = left = right = false;
+  a = b = x = y = false;
+  l = r = select = start = false;
+}
+
+/***************************
+ *** Debugging functions ***
+ ***************************/
+uint8 bSNES::read(uint8 type, uint32 addr) {
+uint32 bank, a;
+uint8  r = 0x00;
+  debug_command = true;
+  switch(type) {
+  case DRAM:
+    addr &= 0xffffff;
+    bank = (addr >> 16) & 0xff;
+    a = addr & 0xffff;
+    if((bank >= 0x00 && bank <= 0x3f) ||
+       (bank >= 0x80 && bank <= 0xbf)) {
+    //don't let the debugger poll MMIO ports
+      if(a >= 0x2000 && a <= 0x5fff) {
+        r = 0x00;
+      } else {
+        r = r_mem->read(addr);
+      }
+    } else {
+      r = r_mem->read(addr);
+    }
+    break;
+  case SPCRAM:
+    addr &= 0xffff;
+    r = r_apu->spcram_read(addr);
+    break;
+  case VRAM:
+    addr &= 0xffff;
+    r = r_ppu->vram_read(addr);
+    break;
+  case OAM:
+    addr &= 0x03ff;
+    r = r_ppu->oam_read(addr);
+    break;
+  case CGRAM:
+    addr &= 0x01ff;
+    r = r_ppu->cgram_read(addr);
+    break;
+  }
+  debug_command = false;
+  return r;
+}
+
+void bSNES::write(uint8 type, uint32 addr, uint8 value) {
+  debug_command = true;
+  switch(type) {
+  case DRAM:
+    addr &= 0xffffff;
+    r_mem->cart->write_protect(false);
+    r_mem->write(addr, value);
+    r_mem->cart->write_protect(true);
+    break;
+  case SPCRAM:
+    addr &= 0xffff;
+    r_apu->spcram_write(addr, value);
+    break;
+  case VRAM:
+    addr &= 0xffff;
+    r_ppu->vram_write(addr, value);
+    break;
+  case OAM:
+    addr &= 0x03ff;
+    r_ppu->oam_write(addr, value);
+    break;
+  case CGRAM:
+    addr &= 0x01ff;
+    r_ppu->cgram_write(addr, value);
+    break;
+  }
+  debug_command = false;
+}
+
+void bSNES::notify(uint32 message, uint32 param1, uint32 param2) {
+//debugging messages
+  if(is_debugger_enabled == false)return;
+
+  switch(message) {
+  case CPU_EXEC_OPCODE_BEGIN:
+    break;
+  case CPU_EXEC_OPCODE_END:
+    status.cpu_ran = true;
+    status.cpu_trace_pos++;
+  //test next opcode for breakpoint
+    w_bp->test(message, r_cpu->regs.pc.d, 0);
+    disassemble_cpu_op();
+    break;
+  case APU_EXEC_OPCODE_BEGIN:
+    break;
+  case APU_EXEC_OPCODE_END:
+    status.apu_ran = true;
+    w_bp->test(message, r_apu->regs.pc, 0);
+    disassemble_apu_op();
+    break;
+  case MEM_READ:
+  case SPCRAM_READ:
+  case VRAM_READ:
+  case OAM_READ:
+  case CGRAM_READ:
+    if(debug_command == false) {
+      w_bp->test(message, param1, param2);
+    }
+    break;
+  case MEM_WRITE:
+  case SPCRAM_WRITE:
+  case VRAM_WRITE:
+  case OAM_WRITE:
+  case CGRAM_WRITE:
+    if(debug_command == false) {
+      w_bp->test(message, param1, param2);
+    }
+  //this needs to be called after the breakpoint test,
+  //as it will access read() and clear debug_command
+    w_memory->refresh(message, param1);
+    break;
+  }
+}
+
+void bSNES::disassemble_cpu_op() {
+char t[512];
+//don't disassemble opcodes when no ROM is loaded
+  if(is_debugger_activated == false)return;
+
+//don't disassemble opcodes that won't be printed to console/traced to log anyway
+  if(!w_console->can_write(Console::CPU_MESSAGE) && !w_console->tracing_enabled)return;
+
+  r_cpu->disassemble_opcode(t);
+  w_console->write(t, Console::CPU_MESSAGE);
+}
+
+void bSNES::disassemble_apu_op() {
+char t[512];
+  if(is_debugger_activated == false)return;
+
+  if(!w_console->can_write(Console::APU_MESSAGE) && !w_console->tracing_enabled)return;
+
+  r_apu->disassemble_opcode(t);
+  w_console->write(t, Console::APU_MESSAGE);
+}
+
+void bSNES::disassemble_bp_op() {
+  if(w_bp->bp[w_bp->bp_hit_num].source == SPCRAM) {
+    disassemble_apu_op();
+  } else {
+    disassemble_cpu_op();
+  }
+}
+
+bool bSNES::debugger_enabled() {
+  return is_debugger_enabled;
+}
+
+void bSNES::debugger_enable() {
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_DEBUGGER, MF_CHECKED);
+  set_status(bSNES::STOP);
+
+  w_console->is_running(false);
+  w_console->update_status();
+  w_console->show();
+
+  w_bp->refresh();
+  w_bp->show();
+
+  w_memory->edit_mode = MemoryEditor::MODE_DRAM;
+  w_memory->edit_addr = 0x7e0000;
+  w_memory->edit_mask = 0xffffff;
+  SendDlgItemMessage(w_memory->hwnd, MEMORYEDITOR_MODE, CB_SETCURSEL, 0, 0);
+  w_memory->refresh();
+  w_memory->show();
+
+  debugger_update();
+  is_debugger_enabled = true;
+}
+
+void bSNES::debugger_disable() {
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_DEBUGGER, MF_UNCHECKED);
+  w_console->hide();
+  w_bp->hide();
+  w_memory->hide();
+  is_debugger_enabled = false;
+  set_status(bSNES::RUN);
+}
+
+void bSNES::debugger_update() {
+  w_console->update_status();
+  w_bp->refresh();
+  w_memory->refresh();
+  disassemble_apu_op();
+  disassemble_cpu_op();
+}
+
+bool bSNES::debugger_activated() {
+  return is_debugger_activated;
+}
+
+void bSNES::debugger_activate() {
+HWND hwnd;
+uint32 i, style;
+  for(i=0;i<100;i++) {
+    if(w_console->ctl_disabled[i] == true)continue;
+    hwnd = GetDlgItem(w_console->hwnd, i + 100);
+    if(!hwnd)continue;
+    style = GetWindowLong(hwnd, GWL_STYLE);
+    style &= ~WS_DISABLED;
+    SetWindowLong(hwnd, GWL_STYLE, style);
+  }
+  InvalidateRect(w_console->hwnd, 0, TRUE);
+
+  for(i=0;i<100;i++) {
+    if(w_bp->ctl_disabled[i] == true)continue;
+    hwnd = GetDlgItem(w_bp->hwnd, i + 100);
+    if(!hwnd)continue;
+    style = GetWindowLong(hwnd, GWL_STYLE);
+    style &= ~WS_DISABLED;
+    SetWindowLong(hwnd, GWL_STYLE, style);
+  }
+  InvalidateRect(w_bp->hwnd, 0, TRUE);
+
+  for(i=0;i<100;i++) {
+    if(w_memory->ctl_disabled[i] == true)continue;
+    hwnd = GetDlgItem(w_memory->hwnd, i + 100);
+    if(!hwnd)continue;
+    style = GetWindowLong(hwnd, GWL_STYLE);
+    style &= ~WS_DISABLED;
+    SetWindowLong(hwnd, GWL_STYLE, style);
+  }
+  InvalidateRect(w_memory->hwnd, 0, TRUE);
+
+  is_debugger_activated = true;
+}
+
+void bSNES::debugger_deactivate() {
+HWND hwnd;
+uint32 i, style;
+  for(i=0;i<100;i++) {
+    hwnd = GetDlgItem(w_console->hwnd, i + 100);
+    if(!hwnd)continue;
+    style = GetWindowLong(hwnd, GWL_STYLE);
+    style |= WS_DISABLED;
+    SetWindowLong(hwnd, GWL_STYLE, style);
+  }
+  w_console->clear();
+  InvalidateRect(w_console->hwnd, 0, TRUE);
+
+  for(i=0;i<100;i++) {
+    hwnd = GetDlgItem(w_bp->hwnd, i + 100);
+    if(!hwnd)continue;
+    style = GetWindowLong(hwnd, GWL_STYLE);
+    style |= WS_DISABLED;
+    SetWindowLong(hwnd, GWL_STYLE, style);
+  }
+  w_bp->clear();
+  InvalidateRect(w_bp->hwnd, 0, TRUE);
+
+
+  for(i=0;i<100;i++) {
+    hwnd = GetDlgItem(w_memory->hwnd, i + 100);
+    if(!hwnd)continue;
+    style = GetWindowLong(hwnd, GWL_STYLE);
+    style |= WS_DISABLED;
+    SetWindowLong(hwnd, GWL_STYLE, style);
+  }
+  w_memory->clear();
+  InvalidateRect(w_memory->hwnd, 0, TRUE);
+
+  is_debugger_activated = false;
+}
+
+bSNES::bSNES() {
+  run_status    = STOP;
+  debug_command = false;
+
+  debugger_disable();
+}
diff --git a/src/win_legacy/bsnes.h b/src/win_legacy/bsnes.h
new file mode 100644
index 00000000..054246ca
--- /dev/null
+++ b/src/win_legacy/bsnes.h
@@ -0,0 +1,83 @@
+class bJoypad {
+public:
+bool up, down, left, right;
+bool a, b, x, y;
+bool l, r, select, start;
+  bJoypad();
+};
+
+class bSNES : public SNES {
+private:
+//If true, indicates a ROM is loaded and debugger output
+//is possible.
+bool is_debugger_activated;
+
+//When true, notify() ignores read/write requests, as they
+//have been generated by the debugging interface and not by
+//the emulator.
+bool debug_command;
+uint32 run_status;
+
+bJoypad joypad1, joypad2;
+
+public:
+enum {
+  STOP = 0,
+  RUN,
+  RUNONCE,
+  RUNTOSIGNAL,
+  RUNTOFRAME,
+  RUNTOCPUSTEP,
+  RUNTOCPUPROCEED,
+  RUNTOCPUTRACE,
+  RUNTOAPUSTEP
+};
+enum { DRAM = 0, SPCRAM = 1, VRAM = 2, OAM = 3, CGRAM = 4 };
+  void   power();
+  void   reset();
+
+  void   run();
+  void   video_run();
+  void   sound_run(uint32 data);
+
+  void   set_status(uint32 new_status);
+  uint32 get_status();
+
+//video functions
+  uint16 *video_lock(uint32 &pitch);
+  void    video_unlock();
+
+//input functions
+  void clear_input();
+  void poll_input(uint8 type);
+  bool get_input_status(uint8 device, uint8 button);
+
+//debugging functions
+struct {
+  uint32 cpu_stop_pos;
+  uint32 cpu_trace_pos, cpu_trace_stop;
+  bool   cpu_ran, apu_ran;
+}status;
+  uint8 read (uint8 type, uint32 addr);
+  void  write(uint8 type, uint32 addr, uint8 value);
+  void  notify(uint32 message, uint32 param1 = 0, uint32 param2 = 0);
+  void  disassemble_cpu_op();
+  void  disassemble_apu_op();
+  void  disassemble_bp_op();
+
+//whether or not the user requests the debugger open
+  bool  debugger_enabled();
+  void  debugger_enable();
+  void  debugger_disable();
+  void  debugger_update();
+
+//whether or not the debugger *can* be used
+//e.g., debugger cannot be used without ROM loaded
+  bool  debugger_activated();
+  void  debugger_activate();
+  void  debugger_deactivate();
+
+  bSNES();
+};
+
+bSNES *bsnes;
diff --git a/src/win_legacy/bsnes.ico b/src/win_legacy/bsnes.ico
new file mode 100644
index 00000000..a396add1
Binary files /dev/null and b/src/win_legacy/bsnes.ico differ
diff --git a/src/win_legacy/bsnes.lnk b/src/win_legacy/bsnes.lnk
new file mode 100644
index 00000000..b3f084ab
Binary files /dev/null and b/src/win_legacy/bsnes.lnk differ
diff --git a/src/win_legacy/bsnes.rc b/src/win_legacy/bsnes.rc
new file mode 100644
index 00000000..de8421e1
--- /dev/null
+++ b/src/win_legacy/bsnes.rc
@@ -0,0 +1,3 @@
+#define IDI_APP_ICON 100
+
+IDI_APP_ICON   ICON   DISCARDABLE   "bsnes.ico"
diff --git a/src/win_legacy/cc.bat b/src/win_legacy/cc.bat
new file mode 100644
index 00000000..ec67d554
--- /dev/null
+++ b/src/win_legacy/cc.bat
@@ -0,0 +1,3 @@
+@nmake /NOLOGO
+@move bsnes.exe ../../bsnes.exe>nul
+@pause
\ No newline at end of file
diff --git a/src/win_legacy/clean.bat b/src/win_legacy/clean.bat
new file mode 100644
index 00000000..e0f3d11c
--- /dev/null
+++ b/src/win_legacy/clean.bat
@@ -0,0 +1 @@
+@nmake clean /NOLOGO
diff --git a/src/win_legacy/config.cpp b/src/win_legacy/config.cpp
new file mode 100644
index 00000000..8d238f06
--- /dev/null
+++ b/src/win_legacy/config.cpp
@@ -0,0 +1,60 @@
+namespace config {
+
+struct System {
+  static Setting regulate_speed;
+} system;
+Setting System::regulate_speed(&config_file, "system.regulate_speed", "Regulate speed to 60hz (NTSC) / 50hz (PAL)", true, Setting::TRUE_FALSE);
+
+struct Video {
+  static Setting mode, use_vram, vblank;
+} video;
+Setting Video::mode(&config_file, "video.mode",
+  "Video mode\n"
+  "  0 = 256x224w\n"
+  "  1 = 512x448w\n"
+  "  2 = 960x720w\n"
+  "  3 = 640x480f\n"
+  "  4 = 1024x768f",
+  1, Setting::DEC);
+Setting Video::use_vram(&config_file, "video.use_vram", "Use Video RAM instead of System RAM", true, Setting::TRUE_FALSE);
+Setting Video::vblank(&config_file, "video.vblank", "Wait for vertical retrace when updating screen", false, Setting::TRUE_FALSE);
+
+struct GUI {
+  static Setting show_fps;
+} gui;
+Setting GUI::show_fps(&config_file, "gui.show_fps", "Show framerate in window title", true, Setting::TRUE_FALSE);
+
+struct Input {
+  struct Joypad1 {
+    static Setting up, down, left, right, a, b, x, y, l, r, select, start;
+  } joypad1;
+  struct Joypad2 {
+    static Setting up, down, left, right, a, b, x, y, l, r, select, start;
+  } joypad2;
+} input;
+Setting Input::Joypad1::up    (&config_file, "input.joypad1.up",     "Joypad1 up",     VK_UP,     Setting::HEX);
+Setting Input::Joypad1::down  (&config_file, "input.joypad1.down",   "Joypad1 down",   VK_DOWN,   Setting::HEX);
+Setting Input::Joypad1::left  (&config_file, "input.joypad1.left",   "Joypad1 left",   VK_LEFT,   Setting::HEX);
+Setting Input::Joypad1::right (&config_file, "input.joypad1.right",  "Joypad1 right",  VK_RIGHT,  Setting::HEX);
+Setting Input::Joypad1::a     (&config_file, "input.joypad1.a",      "Joypad1 A",      'X',       Setting::HEX);
+Setting Input::Joypad1::b     (&config_file, "input.joypad1.b",      "Joypad1 B",      'Z',       Setting::HEX);
+Setting Input::Joypad1::x     (&config_file, "input.joypad1.x",      "Joypad1 X",      'S',       Setting::HEX);
+Setting Input::Joypad1::y     (&config_file, "input.joypad1.y",      "Joypad1 Y",      'A',       Setting::HEX);
+Setting Input::Joypad1::l     (&config_file, "input.joypad1.l",      "Joypad1 L",      'D',       Setting::HEX);
+Setting Input::Joypad1::r     (&config_file, "input.joypad1.r",      "Joypad1 R",      'C',       Setting::HEX);
+Setting Input::Joypad1::select(&config_file, "input.joypad1.select", "Joypad1 select", VK_SHIFT,  Setting::HEX);
+Setting Input::Joypad1::start (&config_file, "input.joypad1.start",  "Joypad1 start",  VK_RETURN, Setting::HEX);
+
+Setting Input::Joypad2::up    (&config_file, "input.joypad2.up",     "Joypad2 up",     'T', Setting::HEX);
+Setting Input::Joypad2::down  (&config_file, "input.joypad2.down",   "Joypad2 down",   'G', Setting::HEX);
+Setting Input::Joypad2::left  (&config_file, "input.joypad2.left",   "Joypad2 left",   'F', Setting::HEX);
+Setting Input::Joypad2::right (&config_file, "input.joypad2.right",  "Joypad2 right",  'H', Setting::HEX);
+Setting Input::Joypad2::a     (&config_file, "input.joypad2.a",      "Joypad2 A",      'K', Setting::HEX);
+Setting Input::Joypad2::b     (&config_file, "input.joypad2.b",      "Joypad2 B",      'J', Setting::HEX);
+Setting Input::Joypad2::x     (&config_file, "input.joypad2.x",      "Joypad2 X",      'I', Setting::HEX);
+Setting Input::Joypad2::y     (&config_file, "input.joypad2.y",      "Joypad2 Y",      'U', Setting::HEX);
+Setting Input::Joypad2::l     (&config_file, "input.joypad2.l",      "Joypad2 L",      'O', Setting::HEX);
+Setting Input::Joypad2::r     (&config_file, "input.joypad2.r",      "Joypad2 R",      'L', Setting::HEX);
+Setting Input::Joypad2::select(&config_file, "input.joypad2.select", "Joypad2 select", '[', Setting::HEX);
+Setting Input::Joypad2::start (&config_file, "input.joypad2.start",  "Joypad2 start",  ']', Setting::HEX);
+};
diff --git a/src/win/dd_renderer.cpp b/src/win_legacy/dd_renderer.cpp
similarity index 100%
rename from src/win/dd_renderer.cpp
rename to src/win_legacy/dd_renderer.cpp
diff --git a/src/win/dd_renderer.h b/src/win_legacy/dd_renderer.h
similarity index 100%
rename from src/win/dd_renderer.h
rename to src/win_legacy/dd_renderer.h
diff --git a/src/win/ds_sound.cpp b/src/win_legacy/ds_sound.cpp
similarity index 100%
rename from src/win/ds_sound.cpp
rename to src/win_legacy/ds_sound.cpp
diff --git a/src/win/ds_sound.h b/src/win_legacy/ds_sound.h
similarity index 70%
rename from src/win/ds_sound.h
rename to src/win_legacy/ds_sound.h
index 4e2f9f5d..faaa3db2 100644
--- a/src/win/ds_sound.h
+++ b/src/win_legacy/ds_sound.h
@@ -15,6 +15,17 @@ public:
   void clear();
   void init();
   void term();
+
+  DSSound() {
+    ds          = 0;
+    dsb_p       = 0;
+    dsb_b       = 0;
+    buffer_size = 0;
+  }
+
+  ~DSSound() {
+    term();
+  }
 };
 
 struct {
diff --git a/src/win/lib.cpp b/src/win_legacy/lib.cpp
similarity index 100%
rename from src/win/lib.cpp
rename to src/win_legacy/lib.cpp
diff --git a/src/win_legacy/ui.cpp b/src/win_legacy/ui.cpp
new file mode 100644
index 00000000..281c4c98
--- /dev/null
+++ b/src/win_legacy/ui.cpp
@@ -0,0 +1,58 @@
+HFONT hFont, hMonofont;
+HBRUSH hbr_backbrush;
+
+#include "dd_renderer.cpp"
+#include "ds_sound.cpp"
+#include "uictl_editex.cpp"
+#include "ui_window.cpp"
+#include "ui_main.cpp"
+#include "ui_console.cpp"
+#include "ui_bp.cpp"
+#include "ui_memory.cpp"
+#include "ui_inputconfig.cpp"
+#include "ui_about.cpp"
+
+void CreateFonts() {
+HDC  hdc    = GetDC(0);
+long height = -MulDiv(8, GetDeviceCaps(hdc, LOGPIXELSY), 72);
+  ReleaseDC(0, hdc);
+  hFont     = CreateFont(height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "Tahoma");
+  hMonofont = CreateFont(height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "Courier New");
+}
+
+void CreateWindows() {
+  hbr_backbrush = CreateSolidBrush(RGB(32, 32, 32));
+  w_main->create();
+  w_console->create();
+  w_bp->create();
+  w_memory->create();
+  w_inputconfig->create();
+  w_about->create();
+}
+
+void init_ui0() {
+  LoadLibrary("riched20.dll");
+
+  dd_renderer   = new DDRenderer();
+  ds_sound      = new DSSound();
+  w_main        = new MainWindow();
+  w_console     = new Console();
+  w_bp          = new BreakpointEditor();
+  w_memory      = new MemoryEditor();
+  w_inputconfig = new InputConfig();
+  w_about       = new AboutWindow();
+}
+
+void init_ui1() {
+  CreateFonts();
+  CreateWindows();
+  SetFocus(w_main->hwnd);
+  dd_renderer->set_window(w_main->hwnd);
+  dd_renderer->to_windowed();
+
+  w_main->show_menu();
+  w_main->set_video_mode(config::video.mode);
+  w_main->set_frameskip(0);
+
+  bsnes->debugger_deactivate();
+}
diff --git a/src/win_legacy/ui.h b/src/win_legacy/ui.h
new file mode 100644
index 00000000..8ca69fc5
--- /dev/null
+++ b/src/win_legacy/ui.h
@@ -0,0 +1,281 @@
+#define KeyDown(key) ((GetAsyncKeyState(key) & 0x8000)?1:0)
+
+enum {
+  VIDEOMODE_256x224w = 0,
+  VIDEOMODE_512x448w,
+  VIDEOMODE_960x720w,
+  VIDEOMODE_640x480f,
+  VIDEOMODE_1024x768f
+};
+
+enum {
+  MENU_FILE_LOAD = 100,
+  MENU_FILE_UNLOAD,
+  MENU_FILE_RESET,
+  MENU_FILE_POWER,
+  MENU_FILE_EXIT,
+  MENU_SETTINGS_REGULATE_SPEED,
+  MENU_SETTINGS_FRAMESKIP_OFF,
+  MENU_SETTINGS_FRAMESKIP_1,
+  MENU_SETTINGS_FRAMESKIP_2,
+  MENU_SETTINGS_FRAMESKIP_3,
+  MENU_SETTINGS_FRAMESKIP_4,
+  MENU_SETTINGS_FRAMESKIP_5,
+  MENU_SETTINGS_FRAMESKIP_6,
+  MENU_SETTINGS_FRAMESKIP_7,
+  MENU_SETTINGS_FRAMESKIP_8,
+  MENU_SETTINGS_FRAMESKIP_9,
+  MENU_SETTINGS_VIDEOMODE_256x224w,
+  MENU_SETTINGS_VIDEOMODE_512x448w,
+  MENU_SETTINGS_VIDEOMODE_960x720w,
+  MENU_SETTINGS_VIDEOMODE_640x480f,
+  MENU_SETTINGS_VIDEOMODE_1024x768f,
+  MENU_SETTINGS_COLORADJUST_COLORCURVE,
+  MENU_SETTINGS_COLORADJUST_NORMAL,
+  MENU_SETTINGS_COLORADJUST_GRAYSCALE,
+  MENU_SETTINGS_COLORADJUST_VGA,
+  MENU_SETTINGS_COLORADJUST_GENESIS,
+  MENU_SETTINGS_USEVRAM,
+  MENU_SETTINGS_VBLANK,
+  MENU_SETTINGS_SHOWFPS,
+  MENU_SETTINGS_MUTE,
+  MENU_SETTINGS_INPUTCFG_JOYPAD1,
+  MENU_SETTINGS_INPUTCFG_JOYPAD2,
+  MENU_SETTINGS_DEBUGGER,
+  MENU_MISC_SCREENSHOT,
+  MENU_MISC_LOGAUDIO,
+  MENU_MISC_ABOUT
+};
+
+enum {
+  CONSOLE_OUTPUT = 100,
+  CONSOLE_STATUS,
+
+  CONSOLE_CPUGROUP,
+  CONSOLE_CPUSTEP,
+  CONSOLE_CPUPROCEED,
+  CONSOLE_CPUSKIP,
+  CONSOLE_CPUTRACENUM,
+  CONSOLE_CPUTRACE,
+  CONSOLE_CPUDISABLE,
+
+  CONSOLE_APUGROUP,
+  CONSOLE_APUSTEP,
+  CONSOLE_APUPROCEED,
+  CONSOLE_APUSKIP,
+  CONSOLE_APUTRACENUM,
+  CONSOLE_APUTRACE,
+  CONSOLE_APUDISABLE,
+
+  CONSOLE_SYSGROUP,
+  CONSOLE_SYSRUN,
+  CONSOLE_SYSRUNTOFRAME,
+  CONSOLE_SYSRUNTONMI,
+
+  CONSOLE_CFGGROUP,
+  CONSOLE_CFGOUTPUTCPU,
+  CONSOLE_CFGOUTPUTAPU,
+  CONSOLE_CFGOUTPUTDBG,
+  CONSOLE_CFGTRACE,
+  CONSOLE_CFGREGTYPE,
+  CONSOLE_CFGREGNUM,
+  CONSOLE_CFGREGVAL,
+  CONSOLE_CFGREGSET,
+  CONSOLE_CFGLOCK,
+  CONSOLE_CFGLOCKUP,
+  CONSOLE_CFGLOCKDOWN,
+  CONSOLE_CFGLOCKLEFT,
+  CONSOLE_CFGLOCKRIGHT,
+  CONSOLE_CFGLOCKA,
+  CONSOLE_CFGLOCKB,
+  CONSOLE_CFGLOCKX,
+  CONSOLE_CFGLOCKY,
+  CONSOLE_CFGLOCKL,
+  CONSOLE_CFGLOCKR,
+  CONSOLE_CFGLOCKSELECT,
+  CONSOLE_CFGLOCKSTART
+};
+
+enum {
+  BREAKPOINT_LIST = 100,
+  BREAKPOINT_STATIC1,
+  BREAKPOINT_NUM,
+  BREAKPOINT_OFFSET,
+  BREAKPOINT_R,
+  BREAKPOINT_W,
+  BREAKPOINT_X,
+  BREAKPOINT_V,
+  BREAKPOINT_STATIC2,
+  BREAKPOINT_VALUE,
+  BREAKPOINT_SOURCE,
+  BREAKPOINT_SET,
+  BREAKPOINT_CLEAR,
+  BREAKPOINT_ENABLE,
+  BREAKPOINT_CLEARALL,
+  BREAKPOINT_EXPORT,
+  BREAKPOINT_IMPORT
+};
+
+enum {
+  MEMORYEDITOR_VIEW = 100,
+
+  MEMORYEDITOR_MODE,
+  MEMORYEDITOR_GOTOADDR,
+  MEMORYEDITOR_GOTO,
+
+  MEMORYEDITOR_STATIC1,
+  MEMORYEDITOR_OFFSET,
+  MEMORYEDITOR_VALUE,
+  MEMORYEDITOR_EDIT,
+
+  MEMORYEDITOR_FSOURCE,
+  MEMORYEDITOR_FEXPORT,
+
+  MEMORYEDITOR_UPDATE,
+  MEMORYEDITOR_AUTOUPDATE
+};
+
+enum {
+  ABOUT_STATIC = 100,
+  ABOUT_OK
+};
+
+class Window {
+public:
+HWND  hwnd;
+HMENU hmenu;
+bool fullscreen, visible, cursor_visible;
+RECT workarea, wa_offset;
+struct { int width, height; }window;
+  void resize(int width, int height);
+  void center();
+  void show_menu();
+  void hide_menu();
+  void show();
+  void hide();
+
+  void to_left(HWND _hwnd = 0);
+  void to_center();
+  void to_right();
+  void to_top();
+  void to_middle();
+  void to_bottom(HWND _hwnd = 0);
+
+  Window();
+};
+
+class MainWindow : public Window {
+public:
+uint8 frameskip, frameskip_pos;
+int width, height;
+  void create();
+  void to_fullscreen();
+  void to_windowed();
+  void set_frameskip(uint8 fs);
+  void adjust_video_mode(bool fullscreen_mode);
+  void set_video_mode(uint8 mode);
+  void menu_load();
+  void menu_unload();
+}*w_main = 0;
+
+#define CONSOLE_LINES 240
+class Console : public Window {
+private:
+bool _is_running; //used to swap "Run"/"Stop" text on console window
+
+public:
+bool ctl_disabled[100];
+bool outputcpu, outputapu, outputdbg;
+
+enum { DEBUG_MESSAGE = 0, CPU_MESSAGE, APU_MESSAGE };
+enum { REGTYPE_CPU = 0, REGTYPE_APU };
+char  output_line[CONSOLE_LINES][128];
+uint8 output_linecol[CONSOLE_LINES];
+char  output_data[CONSOLE_LINES * 128];
+FILE *log_fp;
+bool tracing_enabled;
+
+struct {
+  bool up, down, left, right;
+  bool a, b, x, y;
+  bool l, r, select, start;
+}joypad_lock;
+
+  void create();
+  long wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+  void clear();
+  void update_status();
+  void set_reg_list_type(uint8 list_type);
+  bool can_write(uint32 message_type);
+  void write(char *s, uint32 message_type = DEBUG_MESSAGE);
+  void is_running(bool n); //API access to _is_running
+
+  Console();
+}*w_console = 0;
+
+class BreakpointEditor : public Window {
+public:
+bool ctl_disabled[100];
+
+enum { DRAM = 0, SPCRAM = 1, VRAM = 2, OAM = 3, CGRAM = 4 };
+enum { FLAG_NONE = 0, FLAG_R = 1, FLAG_W = 2, FLAG_X = 4, FLAG_V = 8 };
+struct {
+  uint32 addr;
+  uint8  value;
+  uint8  source;
+  uint8  flags;
+  uint32 hit_count;
+  bool   set;
+}bp[16];
+bool  bp_enabled, bp_hit;
+//indicates which breakpoint was hit, used to tell whether to disassemble
+//a cpu or apu opcode once the emulation status is set to stop.
+uint8 bp_hit_num;
+  void clear();
+  void create();
+  bool hit();
+  void test(uint32 message, uint32 addr, uint32 value);
+  void refresh();
+
+  BreakpointEditor();
+}*w_bp = 0;
+
+class MemoryEditor : public Window {
+public:
+bool ctl_disabled[100];
+
+enum { MODE_DRAM = 0, MODE_ROM, MODE_SRAM, MODE_SPCRAM, MODE_VRAM, MODE_OAM, MODE_CGRAM };
+uint32 edit_mode, edit_addr, edit_mask;
+bool   auto_update; //update memory window whenever visible value is written to when true
+  void  clear();
+  void  create();
+  uint8 read_byte(uint32 addr);
+  void  write_byte(uint32 addr, uint8 value);
+  void  refresh(uint32 type = null, uint32 addr = 0);
+  void  export_data(uint32 type);
+}*w_memory = 0;
+
+class InputConfig : public Window {
+public:
+enum {
+  JOYPAD1 = 0,
+  JOYPAD2
+};
+enum {
+  ID_COMMAND = 100
+};
+int config_type, config_pos;
+bool polling;
+  long wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+  void update_polling(int key);
+  void update_command();
+  void set_text(char *str);
+  void begin_config(int type);
+  void create();
+}*w_inputconfig = 0;
+
+class AboutWindow : public Window {
+public:
+  long wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+  void create();
+}*w_about = 0;
diff --git a/src/win/ui_about.cpp b/src/win_legacy/ui_about.cpp
similarity index 100%
rename from src/win/ui_about.cpp
rename to src/win_legacy/ui_about.cpp
diff --git a/src/win/ui_bp.cpp b/src/win_legacy/ui_bp.cpp
similarity index 97%
rename from src/win/ui_bp.cpp
rename to src/win_legacy/ui_bp.cpp
index ed47955d..e2fb3049 100644
--- a/src/win/ui_bp.cpp
+++ b/src/win_legacy/ui_bp.cpp
@@ -167,7 +167,7 @@ void BreakpointEditor::clear() {
 
 void BreakpointEditor::refresh() {
 char s[256 * 16], t[256], source[256], v[16];
-  if(rom_image->loaded() == false)return;
+  if(r_mem->cart_loaded() == false)return;
   if(visible == false)return;
 
   strcpy(s, "");
diff --git a/src/win/ui_console.cpp b/src/win_legacy/ui_console.cpp
similarity index 97%
rename from src/win/ui_console.cpp
rename to src/win_legacy/ui_console.cpp
index 09b01dd0..f9d98a8f 100644
--- a/src/win/ui_console.cpp
+++ b/src/win_legacy/ui_console.cpp
@@ -279,7 +279,7 @@ void Console::is_running(bool n) {
 void Console::update_status() {
 char s[4096], t[512];
 static uint8 linecol[4] = { 1, 2, 3 };
-  if(rom_image->loaded() == false)return;
+  if(r_mem->cart_loaded() == false)return;
 
   strcpy(s, "");
   sprintf(t, "V:%3d H:%3d HC:%4d I:%d IF:%d O:%d",
diff --git a/src/win/ui_inputconfig.cpp b/src/win_legacy/ui_inputconfig.cpp
similarity index 95%
rename from src/win/ui_inputconfig.cpp
rename to src/win_legacy/ui_inputconfig.cpp
index 05af8d69..97e11cc0 100644
--- a/src/win/ui_inputconfig.cpp
+++ b/src/win_legacy/ui_inputconfig.cpp
@@ -3,16 +3,18 @@ HDC hdc, hdcsrc;
 PAINTSTRUCT ps;
 HBITMAP hbm;
   switch(msg) {
+  /*
   case WM_PAINT:
     hdc = BeginPaint(hwnd, &ps);
     hdcsrc = CreateCompatibleDC(hdc);
-    hbm = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(100));
+    hbm = LoadBitmap(GetModuleHandle(0), MAKEINTRESOURCE(101));
     SelectObject(hdcsrc, hbm);
     BitBlt(hdc, 5, 25, 400, 200, hdcsrc, 0, 0, SRCCOPY);
     DeleteDC(hdcsrc);
     DeleteObject(hbm);
     EndPaint(hwnd, &ps);
     break;
+  */
   case WM_KEYUP:
     update_polling((int)wparam);
     break;
diff --git a/src/win_legacy/ui_main.cpp b/src/win_legacy/ui_main.cpp
new file mode 100644
index 00000000..a6bab347
--- /dev/null
+++ b/src/win_legacy/ui_main.cpp
@@ -0,0 +1,408 @@
+void MainWindow::set_frameskip(uint8 fs) {
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_OFF, MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_1,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_2,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_3,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_4,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_5,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_6,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_7,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_8,   MF_UNCHECKED);
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_9,   MF_UNCHECKED);
+
+  CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_OFF + fs, MF_CHECKED);
+  w_main->frameskip     = fs;
+  w_main->frameskip_pos = 0;
+}
+
+void MainWindow::to_fullscreen() {
+  if(bsnes->debugger_enabled() == true) {
+    bsnes->debugger_disable();
+  }
+  SetWindowLong(hwnd, GWL_STYLE,   WS_POPUP);
+  SetWindowLong(hwnd, GWL_EXSTYLE, WS_EX_TOPMOST);
+  SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, width, height, 0);
+  dd_renderer->to_fullscreen(width, height);
+  hide_menu();
+}
+
+void MainWindow::to_windowed() {
+  SetWindowLong(hwnd, GWL_STYLE,   WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
+  SetWindowLong(hwnd, GWL_EXSTYLE, 0);
+//always call in case the video mode change is simply changing
+//the backbuffer from a VRAM surface to a DRAM surface.
+  dd_renderer->to_windowed();
+  if(dd_renderer->fullscreen == true) {
+    show_menu();
+  }
+}
+
+void MainWindow::adjust_video_mode(bool fullscreen_mode) {
+  fullscreen = fullscreen_mode;
+
+  if(fullscreen == true) {
+    to_fullscreen();
+  } else {
+    to_windowed();
+  }
+
+  resize(width, height);
+  if(fullscreen == false)center();
+
+  if(bsnes->debugger_enabled() == true) {
+    to_bottom();
+    to_right();
+  }
+}
+
+void MainWindow::set_video_mode(uint8 mode) {
+  hide();
+  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_256x224w,  MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_512x448w,  MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_960x720w,  MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_640x480f,  MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_1024x768f, MF_UNCHECKED);
+  switch(mode) {
+  case VIDEOMODE_256x224w:
+    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_256x224w, MF_CHECKED);
+    width  =  256;
+    height =  223;
+    adjust_video_mode(false);
+    break;
+  case VIDEOMODE_512x448w:
+    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_512x448w, MF_CHECKED);
+    width  =  512;
+    height =  446;
+    adjust_video_mode(false);
+    break;
+  case VIDEOMODE_960x720w:
+    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_960x720w, MF_CHECKED);
+    width  =  960;
+    height =  720;
+    adjust_video_mode(false);
+    break;
+  case VIDEOMODE_640x480f:
+    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_640x480f, MF_CHECKED);
+    width  =  640;
+    height =  480;
+    adjust_video_mode(true);
+    break;
+  case VIDEOMODE_1024x768f:
+    CheckMenuItem(hmenu, MENU_SETTINGS_VIDEOMODE_1024x768f, MF_CHECKED);
+    width  = 1024;
+    height =  768;
+    adjust_video_mode(true);
+    break;
+  }
+
+  config::video.mode = mode;
+  show();
+}
+
+void MainWindow::menu_load() {
+OPENFILENAME ofn;
+char t[4096];
+  strcpy(t, "");
+  memset(&ofn, 0, sizeof(ofn));
+
+  ofn.lStructSize = sizeof(ofn);
+  ofn.hwndOwner   = hwnd;
+  ofn.lpstrFilter = "SNES ROM Images (*.smc;*.sfc;*.swc;*.fig;*.ufo;*.gd3;*.078"
+#ifdef GZIP_SUPPORT
+                      ";.gz;.z;.zip"
+#endif
+#ifdef JMA_SUPPORT
+                      ";.jma"
+#endif
+                      ")\0"
+                      "*.smc;*.sfc;*.swc;*.fig;*.ufo;*.gd3;*.078"
+#ifdef GZIP_SUPPORT
+                      ";*.gz;*.z;*.zip"
+#endif
+#ifdef JMA_SUPPORT
+                      ";*.jma"
+#endif
+                      "\0"
+                    "All Files (*.*)\0"
+                      "*.*\0";
+  ofn.lpstrFile   = t;
+  ofn.nMaxFile    = MAX_PATH;
+  ofn.Flags       = OFN_EXPLORER | OFN_FILEMUSTEXIST;
+  ofn.lpstrDefExt = "smc";
+
+  if(!GetOpenFileName(&ofn))return;
+
+  cartridge.unload();
+  bsnes->debugger_activate();
+  dprintf("");
+  cartridge.load(t);
+
+  snes->power();
+  bsnes->debugger_update();
+}
+
+void MainWindow::menu_unload() {
+  cartridge.unload();
+  bsnes->debugger_deactivate();
+}
+
+long __stdcall wndproc_main(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
+time_t timeout;
+int i;
+  switch(msg) {
+  case WM_ENTERMENULOOP:
+    ds_sound->clear();
+    break;
+  case WM_EXITMENULOOP:
+    timeout = time(0);
+    while(difftime(time(0), timeout) < 3) {
+      if(!KeyDown(VK_RETURN))break;
+    }
+    bsnes->clear_input();
+    break;
+  case WM_KEYDOWN:
+    if(wparam == VK_ESCAPE) {
+      if(GetMenu(w_main->hwnd) == NULL) {
+        w_main->show_menu();
+      } else {
+        w_main->hide_menu();
+      }
+      w_main->center();
+    }
+    break;
+  case WM_COMMAND:
+    switch(LOWORD(wparam)) {
+    case MENU_FILE_LOAD:
+      w_main->menu_load();
+      break;
+    case MENU_FILE_UNLOAD:
+      w_main->menu_unload();
+      break;
+    case MENU_FILE_RESET:
+      if(r_mem->cart_loaded() == false)break;
+      dprintf("* Soft Reset");
+      snes->reset();
+      bsnes->debugger_update();
+      break;
+    case MENU_FILE_POWER:
+      if(r_mem->cart_loaded() == false)break;
+      dprintf("* Power (Hard Reset)");
+      snes->power();
+      bsnes->debugger_update();
+      break;
+    case MENU_FILE_EXIT:
+      PostQuitMessage(0);
+      break;
+    case MENU_SETTINGS_REGULATE_SPEED:
+      config::system.regulate_speed.toggle();
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_REGULATE_SPEED,
+        (config::system.regulate_speed)?MF_CHECKED:MF_UNCHECKED);
+      break;
+    case MENU_SETTINGS_FRAMESKIP_OFF:
+    case MENU_SETTINGS_FRAMESKIP_1:
+    case MENU_SETTINGS_FRAMESKIP_2:
+    case MENU_SETTINGS_FRAMESKIP_3:
+    case MENU_SETTINGS_FRAMESKIP_4:
+    case MENU_SETTINGS_FRAMESKIP_5:
+    case MENU_SETTINGS_FRAMESKIP_6:
+    case MENU_SETTINGS_FRAMESKIP_7:
+    case MENU_SETTINGS_FRAMESKIP_8:
+    case MENU_SETTINGS_FRAMESKIP_9:
+      w_main->set_frameskip(LOWORD(wparam) - MENU_SETTINGS_FRAMESKIP_OFF);
+      break;
+    case MENU_SETTINGS_VIDEOMODE_256x224w:
+      w_main->set_video_mode(VIDEOMODE_256x224w);
+      break;
+    case MENU_SETTINGS_VIDEOMODE_512x448w:
+      w_main->set_video_mode(VIDEOMODE_512x448w);
+      break;
+    case MENU_SETTINGS_VIDEOMODE_960x720w:
+      w_main->set_video_mode(VIDEOMODE_960x720w);
+      break;
+    case MENU_SETTINGS_VIDEOMODE_640x480f:
+      w_main->set_video_mode(VIDEOMODE_640x480f);
+      break;
+    case MENU_SETTINGS_VIDEOMODE_1024x768f:
+      w_main->set_video_mode(VIDEOMODE_1024x768f);
+      break;
+    case MENU_SETTINGS_COLORADJUST_COLORCURVE:
+      config::snes.video_color_curve.toggle();
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_COLORCURVE,
+        (config::snes.video_color_curve)?MF_CHECKED:MF_UNCHECKED);
+      break;
+    case MENU_SETTINGS_COLORADJUST_NORMAL:
+    case MENU_SETTINGS_COLORADJUST_GRAYSCALE:
+    case MENU_SETTINGS_COLORADJUST_VGA:
+    case MENU_SETTINGS_COLORADJUST_GENESIS:
+      i = LOWORD(wparam) - MENU_SETTINGS_COLORADJUST_NORMAL;
+      config::snes.video_color_adjust_mode = i;
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_NORMAL,    (i == 0)?MF_CHECKED:MF_UNCHECKED);
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_GRAYSCALE, (i == 1)?MF_CHECKED:MF_UNCHECKED);
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_VGA,       (i == 2)?MF_CHECKED:MF_UNCHECKED);
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_COLORADJUST_GENESIS,   (i == 3)?MF_CHECKED:MF_UNCHECKED);
+      break;
+    case MENU_SETTINGS_USEVRAM:
+      config::video.use_vram.toggle();
+      w_main->set_video_mode(config::video.mode);
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_USEVRAM, (config::video.use_vram)?MF_CHECKED:MF_UNCHECKED);
+      break;
+    case MENU_SETTINGS_VBLANK:
+      config::video.vblank.toggle();
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VBLANK, (config::video.vblank)?MF_CHECKED:MF_UNCHECKED);
+      break;
+    case MENU_SETTINGS_SHOWFPS:
+      config::gui.show_fps.toggle();
+      SetWindowText(w_main->hwnd, BSNES_TITLE);
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_SHOWFPS, (config::gui.show_fps)?MF_CHECKED:MF_UNCHECKED);
+      break;
+    case MENU_SETTINGS_MUTE:
+      config::snes.mute.toggle();
+      CheckMenuItem(w_main->hmenu, MENU_SETTINGS_MUTE, (config::snes.mute)?MF_CHECKED:MF_UNCHECKED);
+      break;
+    case MENU_SETTINGS_INPUTCFG_JOYPAD1:
+      w_inputconfig->begin_config(InputConfig::JOYPAD1);
+      break;
+    case MENU_SETTINGS_INPUTCFG_JOYPAD2:
+      w_inputconfig->begin_config(InputConfig::JOYPAD2);
+      break;
+    case MENU_SETTINGS_DEBUGGER:
+      if(bsnes->debugger_enabled() == true) {
+        bsnes->debugger_disable();
+      } else {
+        bsnes->debugger_enable();
+        w_main->set_video_mode(VIDEOMODE_256x224w);
+      }
+      break;
+    case MENU_MISC_SCREENSHOT:
+      snes->capture_screenshot();
+      break;
+    case MENU_MISC_LOGAUDIO:
+      i = CheckMenuItem(w_main->hmenu, MENU_MISC_LOGAUDIO, 0);
+      if(i == MF_UNCHECKED) {
+        CheckMenuItem(w_main->hmenu, MENU_MISC_LOGAUDIO, MF_CHECKED);
+        snes->log_audio_enable();
+      } else {
+        CheckMenuItem(w_main->hmenu, MENU_MISC_LOGAUDIO, MF_UNCHECKED);
+        snes->log_audio_disable();
+      }
+      break;
+    case MENU_MISC_ABOUT:
+      w_about->center();
+      w_about->show();
+      SetFocus(w_about->hwnd);
+      break;
+    }
+    break;
+  case WM_DESTROY:
+    PostQuitMessage(0);
+    break;
+  case WM_PAINT:
+    dd_renderer->redraw();
+    break;
+  }
+  return DefWindowProc(hwnd, msg, wparam, lparam);
+}
+
+void MainWindow::create() {
+WNDCLASS wc;
+int i;
+  wc.cbClsExtra    = 0;
+  wc.cbWndExtra    = 0;
+  wc.hbrBackground = CreateSolidBrush(RGB(0, 0, 0));
+  wc.hCursor       = LoadCursor(0, IDC_ARROW);
+  wc.hIcon         = LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(100));
+  wc.hInstance     = GetModuleHandle(0);
+  wc.lpfnWndProc   = wndproc_main;
+  wc.lpszClassName = "bsnes";
+  wc.lpszMenuName  = 0;
+  wc.style         = CS_HREDRAW | CS_VREDRAW;
+  RegisterClass(&wc);
+
+  hwnd = CreateWindowEx(0, "bsnes", BSNES_TITLE,
+    WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
+    0, 0, 512, 446,
+    0, 0, GetModuleHandle(0), 0);
+
+HMENU hsubmenu, hbranchmenu;
+  hmenu = CreateMenu();
+
+  hsubmenu = CreatePopupMenu();
+  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_LOAD, "&Load ROM");
+  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_UNLOAD, "&Unload ROM");
+  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_RESET, "&Reset");
+  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_POWER, "&Power (Hard Reset)");
+  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(hsubmenu, MF_STRING, MENU_FILE_EXIT, "E&xit");
+  AppendMenu(hmenu, MF_STRING | MF_POPUP, (unsigned int)hsubmenu, "&File");
+
+  hsubmenu = CreatePopupMenu();
+  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_REGULATE_SPEED, "&Regulate Speed");
+
+  hbranchmenu = CreatePopupMenu();
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_OFF, "Off");
+  AppendMenu(hbranchmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_1, "1");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_2, "2");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_3, "3");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_4, "4");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_5, "5");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_6, "6");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_7, "7");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_8, "8");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_FRAMESKIP_9, "9");
+  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Frameskip");
+
+  hbranchmenu = CreatePopupMenu();
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_256x224w,  "256x224 Windowed (16:15)");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_512x448w,  "512x448 Windowed (16:15)");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_960x720w,  "960x720 Windowed (4:3)");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_640x480f,  "640x480 Fullscreen (16:15)");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_VIDEOMODE_1024x768f, "1024x768 Fullscreen (4:3)");
+  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Video Mode");
+
+  hbranchmenu = CreatePopupMenu();
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_COLORCURVE, "Use &Color Curve");
+  AppendMenu(hbranchmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_NORMAL,    "Normal (RGB555)");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_GRAYSCALE, "Grayscale Mode (L5)");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_VGA,       "VGA Mode (RGB332)");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_COLORADJUST_GENESIS,   "Genesis Mode (RGB333)");
+  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Color Adjust");
+
+  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_USEVRAM, "Use &Video Memory Surface");
+  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_VBLANK,  "&Wait For Vertical Retrace");
+  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_SHOWFPS, "&Show FPS");
+  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_MUTE,    "&Mute Sound Output");
+
+  hbranchmenu = CreatePopupMenu();
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_INPUTCFG_JOYPAD1, "Joypad 1");
+  AppendMenu(hbranchmenu, MF_STRING, MENU_SETTINGS_INPUTCFG_JOYPAD2, "Joypad 2");
+  AppendMenu(hsubmenu, MF_STRING | MF_POPUP, (unsigned int)hbranchmenu, "&Configure Input Devices");
+
+#ifdef DEBUGGER
+  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_DEBUGGER, "&Debugger");
+#endif
+
+  AppendMenu(hmenu, MF_STRING | MF_POPUP, (unsigned int)hsubmenu, "&Settings");
+
+  hsubmenu = CreatePopupMenu();
+  AppendMenu(hsubmenu, MF_STRING, MENU_MISC_SCREENSHOT, "&Capture Screenshot");
+  AppendMenu(hsubmenu, MF_STRING, MENU_MISC_LOGAUDIO,   "&Log Audio Data");
+  AppendMenu(hsubmenu, MF_SEPARATOR, 0, "");
+  AppendMenu(hsubmenu, MF_STRING, MENU_MISC_ABOUT, "&About...");
+  AppendMenu(hmenu, MF_STRING | MF_POPUP, (unsigned int)hsubmenu, "&Misc");
+
+  CheckMenuItem(hmenu, MENU_SETTINGS_REGULATE_SPEED, (config::system.regulate_speed)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_USEVRAM,    (config::video.use_vram)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_VBLANK,     (config::video.vblank)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_COLORCURVE, (config::snes.video_color_curve)?MF_CHECKED:MF_UNCHECKED);
+  i = config::snes.video_color_adjust_mode;
+  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_NORMAL,     (i == 0)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_GRAYSCALE,  (i == 1)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_VGA,        (i == 2)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_COLORADJUST_GENESIS,    (i == 3)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_SHOWFPS, (config::gui.show_fps)?MF_CHECKED:MF_UNCHECKED);
+  CheckMenuItem(hmenu, MENU_SETTINGS_MUTE,    (config::snes.mute)   ?MF_CHECKED:MF_UNCHECKED);
+}
diff --git a/src/win/ui_memory.cpp b/src/win_legacy/ui_memory.cpp
similarity index 96%
rename from src/win/ui_memory.cpp
rename to src/win_legacy/ui_memory.cpp
index a877778b..c614990d 100644
--- a/src/win/ui_memory.cpp
+++ b/src/win_legacy/ui_memory.cpp
@@ -1,4 +1,4 @@
-WNDPROC wndproc_oldmemoryeditbox;
+WNDPROC wndproc_oldmemoryeditbox = 0;
 
 long __stdcall wndproc_memoryeditbox(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
 int pos, len, xpos, ypos, t, z, read;
@@ -81,7 +81,7 @@ int pos, len, xpos, ypos, t, z, read;
     SendMessage(hwnd, EM_SETSEL, pos, pos);
     break;
   }
-  return wndproc_oldmemoryeditbox(hwnd, msg, wparam, lparam);
+  return CallWindowProc(wndproc_oldmemoryeditbox, hwnd, msg, wparam, lparam);
 }
 
 long __stdcall wndproc_memoryeditor(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
@@ -270,7 +270,7 @@ void MemoryEditor::clear() {
 void MemoryEditor::refresh(uint32 type, uint32 addr) {
 char s[4096], t[256];
 int x, y;
-  if(rom_image->loaded() == false)return;
+  if(r_mem->cart_loaded() == false)return;
   if(visible == false)return;
 
   if(type != null) {
diff --git a/src/win_legacy/ui_window.cpp b/src/win_legacy/ui_window.cpp
new file mode 100644
index 00000000..4e4dcf11
--- /dev/null
+++ b/src/win_legacy/ui_window.cpp
@@ -0,0 +1,163 @@
+void Window::resize(int width, int height) {
+int style;
+  window.width  = width;
+  window.height = height;
+
+  style = GetWindowLong(hwnd, GWL_STYLE);
+  if(style & WS_CAPTION) {
+    width  += GetSystemMetrics(SM_CXFIXEDFRAME) << 1;
+    height += GetSystemMetrics(SM_CYFIXEDFRAME) << 1;
+    height += GetSystemMetrics(SM_CYCAPTION);
+  }
+
+  if(width == GetSystemMetrics(SM_CXSCREEN) && height == GetSystemMetrics(SM_CYSCREEN)) {
+    fullscreen = true;
+  } else {
+    fullscreen = false;
+  }
+
+  if(fullscreen == false) {
+    if(GetMenu(hwnd) != 0) {
+      height += GetSystemMetrics(SM_CYMENU);
+    }
+    SetWindowPos(hwnd, 0, 0, 0, width, height, SWP_NOZORDER | SWP_NOMOVE);
+  } else {
+    SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, width, height, 0);
+  }
+}
+
+void Window::center() {
+RECT rc;
+POINT p;
+  if(fullscreen == true) {
+    SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, window.width, window.height, 0);
+    return;
+  }
+  GetWindowRect(hwnd, &rc);
+  p.x = p.y = 0;
+  ClientToScreen(hwnd, &p);
+  OffsetRect(&rc, p.x, p.y);
+int sw = GetSystemMetrics(SM_CXSCREEN),
+    sh = GetSystemMetrics(SM_CYSCREEN);
+int x = (sw - (rc.right - rc.left)) >> 1,
+    y = (sh - (rc.bottom - rc.top)) >> 1;
+  SetWindowPos(hwnd, 0, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
+void Window::show_menu() {
+  if(GetMenu(hwnd) != NULL)return;
+
+  SetMenu(hwnd, hmenu);
+  if(cursor_visible == false) {
+    ShowCursor(TRUE);
+    cursor_visible = true;
+  }
+  if(fullscreen == true) {
+    return;
+  }
+
+  resize(window.width, window.height);
+}
+
+void Window::hide_menu() {
+  if(GetMenu(hwnd) == NULL)return;
+
+  SetMenu(hwnd, NULL);
+  if(fullscreen == true) {
+    if(cursor_visible == true) {
+      ShowCursor(FALSE);
+      cursor_visible = false;
+    }
+    return;
+  }
+
+  resize(window.width, window.height);
+}
+
+void Window::show() {
+int style;
+  visible = true;
+  style = GetWindowLong(hwnd, GWL_STYLE);
+  if(style & WS_VISIBLE)return;
+  ShowWindow(hwnd, SW_NORMAL);
+}
+
+void Window::hide() {
+int style;
+  visible = false;
+  style = GetWindowLong(hwnd, GWL_STYLE);
+  if(!(style & WS_VISIBLE))return;
+  ShowWindow(hwnd, SW_HIDE);
+}
+
+void Window::to_left(HWND _hwnd) {
+RECT rc;
+int offset = 0;
+  if(_hwnd) {
+    GetWindowRect(_hwnd, &rc);
+    offset = rc.right;
+  } else {
+    offset = wa_offset.left;
+  }
+  GetWindowRect(hwnd, &rc);
+  rc.left = offset;
+  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
+void Window::to_center() {
+RECT rc;
+  GetWindowRect(hwnd, &rc);
+  rc.left = (GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2;
+  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
+void Window::to_right() {
+RECT rc;
+  GetWindowRect(hwnd, &rc);
+  rc.left = GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left);
+  rc.left -= wa_offset.right;
+  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
+void Window::to_top() {
+RECT rc;
+  GetWindowRect(hwnd, &rc);
+  rc.top = wa_offset.top;
+  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
+void Window::to_middle() {
+RECT rc;
+  GetWindowRect(hwnd, &rc);
+  rc.top = (GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2;
+  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
+void Window::to_bottom(HWND _hwnd) {
+RECT rc;
+int offset = 0;
+  if(_hwnd) {
+    GetWindowRect(_hwnd, &rc);
+    offset = rc.bottom - rc.top;
+  }
+  GetWindowRect(hwnd, &rc);
+  rc.top = GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top) - offset;
+  rc.top -= wa_offset.bottom;
+  SetWindowPos(hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+}
+
+Window::Window() {
+  fullscreen     = false;
+  visible        = false;
+  cursor_visible = true;
+  hmenu          = NULL;
+
+  SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea, 0);
+int sw = GetSystemMetrics(SM_CXSCREEN),
+    sh = GetSystemMetrics(SM_CYSCREEN);
+
+  wa_offset.left   = workarea.left;
+  wa_offset.top    = workarea.top;
+  wa_offset.right  = sw - workarea.right;
+  wa_offset.bottom = sh - workarea.bottom;
+}
diff --git a/src/win/uictl_editex.cpp b/src/win_legacy/uictl_editex.cpp
similarity index 91%
rename from src/win/uictl_editex.cpp
rename to src/win_legacy/uictl_editex.cpp
index e05dd5a9..79f3fedb 100644
--- a/src/win/uictl_editex.cpp
+++ b/src/win_legacy/uictl_editex.cpp
@@ -1,3 +1,8 @@
+//for MinGW
+#ifndef CFM_BACKCOLOR
+  #define CFM_BACKCOLOR 0x04000000
+#endif
+
 void editex_setbackcolor(HWND hwnd, COLORREF color) {
   SendMessage(hwnd, EM_SETBKGNDCOLOR, 0, color);
 }
@@ -57,7 +62,7 @@ int pos = 0;
     SendMessage(hwnd, EM_EXSETSEL, 0, (LPARAM)&cr);
     SendMessage(hwnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
   }
-  SendMessage(hwnd, EM_SETSEL, -1, -1);
+  SendMessage(hwnd, EM_SETSEL, (WPARAM)-1, (LPARAM)-1);
 
 //setting the cursor position has no effect on richedit controls,
 //until focus is given to the window. even then, behavior is
diff --git a/src/win/winmain.cpp b/src/win_legacy/winmain.cpp
similarity index 89%
rename from src/win/winmain.cpp
rename to src/win_legacy/winmain.cpp
index 45d8f349..011e3f9c 100644
--- a/src/win/winmain.cpp
+++ b/src/win_legacy/winmain.cpp
@@ -11,7 +11,6 @@
 #include "ds_sound.h"
 
 #include "lib.cpp"
-#include "rom.cpp"
 
 #include "bsnes.cpp"
 #include "ui.cpp"
@@ -76,7 +75,6 @@ string cfg_fn;
   get_config_fn(cfg_fn);
   config_file.load(cfg_fn);
   meminit();
-  rom_image = new ROMImage();
 
   init_ui0();
   init_snes();
@@ -86,8 +84,8 @@ int argc    = __argc;
 char **argv = __argv;
 
   if(argc >= 2) {
-    rom_image->select(argv[1]);
-    rom_image->load();
+    cartridge.load(argv[1]);
+    bsnes->debugger_activate();
     snes->power();
     bsnes->debugger_update();
   }
@@ -103,8 +101,8 @@ char **argv = __argv;
 
 _end:
   config_file.save(cfg_fn);
-  delete(rom_image);
   term_snes();
+  cartridge.unload();
   memterm();
   return 0;
 }
diff --git a/src/win/winmain.h b/src/win_legacy/winmain.h
similarity index 100%
rename from src/win/winmain.h
rename to src/win_legacy/winmain.h