diff --git a/higan/emulator/emulator.hpp b/higan/emulator/emulator.hpp
index fc230d1e..f3d77c4c 100644
--- a/higan/emulator/emulator.hpp
+++ b/higan/emulator/emulator.hpp
@@ -1,8 +1,23 @@
 #pragma once
 
-#include <nall/nall.hpp>
+#include <nall/platform.hpp>
 #include <nall/adaptive-array.hpp>
+#include <nall/any.hpp>
+#include <nall/bit-field.hpp>
+#include <nall/chrono.hpp>
+#include <nall/dl.hpp>
+#include <nall/endian.hpp>
+#include <nall/image.hpp>
+#include <nall/random.hpp>
+#include <nall/serializer.hpp>
+#include <nall/shared-pointer.hpp>
+#include <nall/string.hpp>
+#include <nall/traits.hpp>
+#include <nall/unique-pointer.hpp>
+#include <nall/vector.hpp>
 #include <nall/vfs.hpp>
+#include <nall/hash/crc32.hpp>
+#include <nall/hash/sha256.hpp>
 using namespace nall;
 
 #include "types.hpp"
diff --git a/higan/gb/cartridge/cartridge.cpp b/higan/gb/cartridge/cartridge.cpp
index 012ff51f..1e8688c9 100644
--- a/higan/gb/cartridge/cartridge.cpp
+++ b/higan/gb/cartridge/cartridge.cpp
@@ -17,6 +17,19 @@ Cartridge cartridge;
 #include "tama/tama.cpp"
 #include "serialization.cpp"
 
+auto Cartridge::Enter() -> void {
+  while(true) scheduler.synchronize(), cartridge.main();
+}
+
+auto Cartridge::main() -> void {
+  mapper->main();
+}
+
+auto Cartridge::step(uint clocks) -> void {
+  Thread::step(clocks);
+  synchronize(cpu);
+}
+
 auto Cartridge::load() -> bool {
   information = {};
   rom = {};
@@ -97,6 +110,7 @@ auto Cartridge::load() -> bool {
   }
 
   information.sha256 = Hash::SHA256(rom.data, rom.size).digest();
+  mapper->load(document);
   return true;
 }
 
@@ -118,6 +132,8 @@ auto Cartridge::save() -> void {
       }
     }
   }
+
+  mapper->save(document);
 }
 
 auto Cartridge::unload() -> void {
@@ -154,6 +170,8 @@ auto Cartridge::writeIO(uint16 addr, uint8 data) -> void {
 }
 
 auto Cartridge::power() -> void {
+  create(Enter, 4 * 1024 * 1024);
+
   for(uint n = 0x0000; n <= 0x7fff; n++) bus.mmio[n] = this;
   for(uint n = 0xa000; n <= 0xbfff; n++) bus.mmio[n] = this;
   bus.mmio[0xff50] = this;
@@ -179,4 +197,10 @@ auto Cartridge::Memory::write(uint address, uint8 byte) -> void {
   data[address] = byte;
 }
 
+//
+
+auto Cartridge::Mapper::main() -> void {
+  cartridge.step(cartridge.frequency());
+}
+
 }
diff --git a/higan/gb/cartridge/cartridge.hpp b/higan/gb/cartridge/cartridge.hpp
index 2e25a5ad..87637638 100644
--- a/higan/gb/cartridge/cartridge.hpp
+++ b/higan/gb/cartridge/cartridge.hpp
@@ -1,9 +1,10 @@
-struct Cartridge : MMIO {
+struct Cartridge : Thread, MMIO {
   auto pathID() const -> uint { return information.pathID; }
   auto hash() const -> string { return information.sha256; }
   auto manifest() const -> string { return information.manifest; }
   auto title() const -> string { return information.title; }
 
+  static auto Enter() -> void;
   auto load() -> bool;
   auto save() -> void;
   auto unload() -> void;
@@ -11,6 +12,8 @@ struct Cartridge : MMIO {
   auto readIO(uint16 address) -> uint8;
   auto writeIO(uint16 address, uint8 data) -> void;
 
+  auto main() -> void;
+  auto step(uint clocks) -> void;
   auto power() -> void;
   auto second() -> void;
 
@@ -35,6 +38,9 @@ struct Cartridge : MMIO {
 
 private:
   struct Mapper {
+    virtual auto load(Markup::Node document) -> void {}
+    virtual auto save(Markup::Node document) -> void {}
+    virtual auto main() -> void;
     virtual auto second() -> void {}
     virtual auto read(uint16 address) -> uint8 = 0;
     virtual auto write(uint16 address, uint8 data) -> void = 0;
diff --git a/higan/gb/cartridge/mbc7/eeprom.cpp b/higan/gb/cartridge/mbc7/eeprom.cpp
new file mode 100644
index 00000000..cd2564a8
--- /dev/null
+++ b/higan/gb/cartridge/mbc7/eeprom.cpp
@@ -0,0 +1,226 @@
+//Microchip 93LCx6
+//  93LC46 => 1024 cells => 128 x 8-bit or  64 x 16-bit
+//  93LC56 => 2048 cells => 256 x 8-bit or 128 x 16-bit
+//  93LC66 => 4096 cells => 512 x 8-bit or 256 x 16-bit
+
+auto Cartridge::MBC7::EEPROM::load(Markup::Node document) -> void {
+  for(auto& byte : data) byte = 0xff;
+  size = 4096;  //EEPROM size is in bits
+  width = 16;   //16-bit configuration
+
+  if(auto memory = Emulator::Game::Memory{document["game/board/memory(type=EEPROM,content=Save)"]}) {
+    if(memory.size == 128) size = 1024;  //manifest size is in bytes
+    if(memory.size == 256) size = 2048;
+    if(memory.size == 512) size = 4096;
+
+    if(auto fp = platform->open(cartridge.pathID(), memory.name(), File::Read, File::Optional)) {
+      fp->read(data, min(fp->size(), sizeof(data)));
+    }
+  }
+
+  command.length = 3;
+  if(size == 1024) address.length = width == 8 ? 6 : 7;
+  if(size == 2048) address.length = width == 8 ? 7 : 8;
+  if(size == 4096) address.length = width == 8 ? 8 : 9;
+  input.length = width;
+  output.length = 1 + width;  //there is an extra zero dummy bit on reads
+}
+
+auto Cartridge::MBC7::EEPROM::save(Markup::Node document) -> void {
+  if(auto memory = Emulator::Game::Memory{document["game/board/memory(type=EEPROM,content=Save)"]}) {
+    if(auto fp = platform->open(cartridge.pathID(), memory.name(), File::Write)) {
+      fp->write(data, size >> 3);  //bytes -> bits
+    }
+  }
+}
+
+auto Cartridge::MBC7::EEPROM::main() -> void {
+  //step by approximately one millisecond
+  cartridge.step(cartridge.frequency() / 1000);
+
+  //set during programming commands
+  if(busy) busy--;
+}
+
+auto Cartridge::MBC7::EEPROM::power(bool reset) -> void {
+  if(!reset) {
+    select = 0;
+    writable = 0;
+  }
+
+  clock = 0;
+  busy = 0;
+
+  command.flush();
+  address.flush();
+  input.flush();
+  output.flush();
+}
+
+auto Cartridge::MBC7::EEPROM::readIO() -> uint8 {
+  uint8 data = 0b00'1111'00;
+  data.bit(7) = select;
+  data.bit(6) = clock;
+  data.bit(1) = 1;
+  if(!select) {
+    data.bit(0) = 1;  //high-z when the chip is idle (not selected)
+  } else if(busy) {
+    data.bit(0) = 0;  //low when a programming command is in progress
+  } else if(output.count) {
+    data.bit(0) = output.peek();  //shift register data during read commands
+  } else {
+    data.bit(0) = 1;  //high-z during all other commands
+  }
+  return data;
+}
+
+auto Cartridge::MBC7::EEPROM::writeIO(uint8 data) -> void {
+  //bring chip out of idle state on rising CS edge
+  if(select.raise(data.bit(7))) return power(true);
+
+  //do nothing if chip is idle
+  if(!select) return;
+
+  //shift register clocks on rising edge
+  if(!clock.raise(data.bit(6))) return;
+
+  //sequential read mode
+  if(output.count && !data.bit(1)) {
+    output.read();
+    if(output.count == 0) {
+      address.value++;
+      read();
+    }
+    return;
+  }
+  output.flush();
+
+  //wait for start bit to be set
+  if(command.count == 0 && !data.bit(1)) return;
+
+  //waiting on command?
+  if(command.count < command.length) {
+    command.write(data.bit(1));
+    if(command.count < command.length) return;
+
+    return address.flush();
+  }
+
+  //waiting on address bits?
+  if(address.count < address.length) {
+    address.write(data.bit(1));
+    if(address.count < address.length) return;
+
+    uint3 opcode = command.bits(0, command.length - 1);
+    if(opcode == 0b100) {
+      uint2 mode = address.bits(address.length - 2, address.length - 1);
+      if(mode == 0b00) return writeDisable();
+      if(mode == 0b01) return input.flush();  //writeAll
+      if(mode == 0b10) return eraseAll();
+      if(mode == 0b11) return writeEnable();
+    }
+    if(opcode == 0b101) return input.flush();  //write
+    if(opcode == 0b110) return read();
+    if(opcode == 0b111) return erase();
+    return;
+  }
+
+  //waiting on data bits from a write or writeAll command?
+  if(input.count < input.length) {  //block new commands and inputs until the next clock edge
+    input.write(data.bit(1));
+    if(input.count < input.length) return;
+
+    uint3 opcode = command.bits(0, command.length - 1);
+    if(opcode == 0b101) return write();
+    if(opcode == 0b100) return writeAll();
+    return;
+  }
+}
+
+//
+
+auto Cartridge::MBC7::EEPROM::read() -> void {
+  command.flush();
+  auto address = this->address.value << (width == 16) & (size >> 3) - 1;
+  output.value = 0;
+  if(width >=  8) output.value |= data[address++] << 8;
+  if(width >= 16) output.value |= data[address++] << 0;
+  output.count = output.length;
+}
+
+auto Cartridge::MBC7::EEPROM::write() -> void {
+  command.flush();
+  if(!writable) return;
+  auto address = this->address.value << (width == 16) & (size >> 3) - 1;
+  if(width >=  8) data[address++] = input.value >> 8;
+  if(width >= 16) data[address++] = input.value >> 0;
+  input.flush();
+  busy = 4;  //ms
+}
+
+auto Cartridge::MBC7::EEPROM::erase() -> void {
+  command.flush();
+  if(!writable) return;
+  auto address = this->address.value << (width == 16) & (size >> 3) - 1;
+  if(width >=  8) data[address++] = 0xff;
+  if(width >= 16) data[address++] = 0xff;
+  busy = 4;  //ms
+}
+
+auto Cartridge::MBC7::EEPROM::writeAll() -> void {
+  command.flush();
+  if(!writable) return;
+  uint8 lo = input.byte(0);
+  uint8 hi = input.byte(width == 16);
+  for(uint address = 0; address < 512;) {
+    data[address++] = hi;
+    data[address++] = lo;
+  }
+  input.flush();
+  busy = 16;  //ms
+}
+
+auto Cartridge::MBC7::EEPROM::eraseAll() -> void {
+  command.flush();
+  if(!writable) return;
+  for(uint address; address < 512;) {
+    data[address++] = 0xff;
+    data[address++] = 0xff;
+  }
+  busy = 8;  //ms
+}
+
+auto Cartridge::MBC7::EEPROM::writeEnable() -> void {
+  command.flush();
+  writable = true;
+}
+
+auto Cartridge::MBC7::EEPROM::writeDisable() -> void {
+  command.flush();
+  writable = false;
+}
+
+//
+
+auto Cartridge::MBC7::EEPROM::ShiftRegister::flush() -> void {
+  value = 0;
+  count = 0;
+}
+
+//read the current bit in the shift register without clocking it
+auto Cartridge::MBC7::EEPROM::ShiftRegister::peek() -> bool {
+  return value.bit(length - 1);
+}
+
+auto Cartridge::MBC7::EEPROM::ShiftRegister::read() -> bool {
+  bool bit = value.bit(length - 1);
+  value <<= 1;
+  if(count) count--;
+  return bit;
+}
+
+auto Cartridge::MBC7::EEPROM::ShiftRegister::write(bool bit) -> void {
+  value <<= 1;
+  value |= bit;
+  count++;
+}
diff --git a/higan/gb/cartridge/mbc7/mbc7.cpp b/higan/gb/cartridge/mbc7/mbc7.cpp
index 4494bd22..7e74ff07 100644
--- a/higan/gb/cartridge/mbc7/mbc7.cpp
+++ b/higan/gb/cartridge/mbc7/mbc7.cpp
@@ -1,3 +1,18 @@
+#include "eeprom.cpp"
+#include "serialization.cpp"
+
+auto Cartridge::MBC7::load(Markup::Node document) -> void {
+  eeprom.load(document);
+}
+
+auto Cartridge::MBC7::save(Markup::Node document) -> void {
+  eeprom.save(document);
+}
+
+auto Cartridge::MBC7::main() -> void {
+  eeprom.main();
+}
+
 auto Cartridge::MBC7::read(uint16 address) -> uint8 {
   if((address & 0xc000) == 0x0000) {  //$0000-3fff
     return cartridge.rom.read(address.bits(0,13));
@@ -17,7 +32,7 @@ auto Cartridge::MBC7::read(uint16 address) -> uint8 {
     case 5: return io.accelerometer.y.bits(8,15);
     case 6: return 0x00;  //z?
     case 7: return 0xff;  //z?
-    case 8: return 0xff;
+    case 8: return eeprom.readIO();
     }
 
     return 0xff;
@@ -48,25 +63,24 @@ auto Cartridge::MBC7::write(uint16 address, uint8 data) -> void {
     if(!io.ram.enable[0] || !io.ram.enable[1]) return;
 
     switch(address.bits(4,7)) {
-
     case 0: {
       if(data != 0x55) break;
-      io.accelerometer.x = 0x8000;
-      io.accelerometer.y = 0x8000;
+      io.accelerometer.x = Center;
+      io.accelerometer.y = Center;
       break;
     }
 
     case 1: {
       if(data != 0xaa) break;
-      io.accelerometer.x = 0x8000 + platform->inputPoll(ID::Port::Hardware, ID::Device::Controls, 8);
-      io.accelerometer.y = 0x8000 + platform->inputPoll(ID::Port::Hardware, ID::Device::Controls, 9);
+      io.accelerometer.x = Center + platform->inputPoll(ID::Port::Hardware, ID::Device::Controls, 8);
+      io.accelerometer.y = Center + platform->inputPoll(ID::Port::Hardware, ID::Device::Controls, 9);
       break;
     }
 
     case 8: {
+      eeprom.writeIO(data);
       break;
     }
-
     }
 
     return;
@@ -74,13 +88,6 @@ auto Cartridge::MBC7::write(uint16 address, uint8 data) -> void {
 }
 
 auto Cartridge::MBC7::power() -> void {
+  eeprom.power();
   io = {};
 }
-
-auto Cartridge::MBC7::serialize(serializer& s) -> void {
-  s.integer(io.rom.bank);
-  s.integer(io.ram.enable[0]);
-  s.integer(io.ram.enable[1]);
-  s.integer(io.accelerometer.x);
-  s.integer(io.accelerometer.y);
-}
diff --git a/higan/gb/cartridge/mbc7/mbc7.hpp b/higan/gb/cartridge/mbc7/mbc7.hpp
index c32df17c..f9f3db38 100644
--- a/higan/gb/cartridge/mbc7/mbc7.hpp
+++ b/higan/gb/cartridge/mbc7/mbc7.hpp
@@ -1,8 +1,67 @@
 struct MBC7 : Mapper {
-  auto read(uint16 address) -> uint8;
-  auto write(uint16 address, uint8 data) -> void;
-  auto power() -> void;
-  auto serialize(serializer&) -> void;
+  enum : uint { Center = 0x81d0 };
+
+  //mbc7.cpp
+  auto load(Markup::Node document) -> void override;
+  auto save(Markup::Node document) -> void override;
+  auto main() -> void override;
+  auto read(uint16 address) -> uint8 override;
+  auto write(uint16 address, uint8 data) -> void override;
+  auto power() -> void override;
+
+  //serialization.cpp
+  auto serialize(serializer&) -> void override;
+
+  struct EEPROM {
+    //eeprom.cpp
+    auto load(Markup::Node document) -> void;
+    auto save(Markup::Node document) -> void;
+    auto main() -> void;
+    auto power(bool reset = false) -> void;
+
+    //Game Boy MBC7 interface
+    auto readIO() -> uint8;
+    auto writeIO(uint8 data) -> void;
+
+    //chip commands
+    auto read() -> void;
+    auto write() -> void;
+    auto erase() -> void;
+    auto writeAll() -> void;
+    auto eraseAll() -> void;
+    auto writeEnable() -> void;
+    auto writeDisable() -> void;
+
+    //serialization.cpp
+    auto serialize(serializer&) -> void;
+
+    //it is awkward no matter if data is uint1[4096], uint8[512], or uint16[256]
+    uint8 data[512];  //uint8 was chosen solely for easier serialization and saving
+    uint size;        //in bits; not bytes
+    uint width;       //8-bit (ORG=0) or 16-bit (ORG=1) configuration
+
+    boolean select;    //CS
+    boolean clock;     //CLK
+    boolean writable;  //EWEN, EWDS
+    uint busy;         //busy cycles in milliseconds remaining for programming (write) operations to complete
+
+    struct ShiftRegister {
+      auto bit(uint index) { return value.bit(index); }
+      auto bits(uint lo, uint hi) { return value.bits(lo, hi); }
+      auto byte(uint index) { return value.byte(index); }
+      auto flush() -> void;
+      auto peek() -> bool;
+      auto read() -> bool;
+      auto write(bool data) -> void;
+
+      //serialization.cpp
+      auto serialize(serializer&) -> void;
+
+      uint32 value;
+      uint32 count;
+      uint32 length;
+    } command, address, input, output;
+  } eeprom;
 
   struct IO {
     struct ROM {
@@ -12,8 +71,8 @@ struct MBC7 : Mapper {
       uint1 enable[2];
     } ram;
     struct Accelerometer {
-      uint16 x = 0x8000;
-      uint16 y = 0x8000;
+      uint16 x = Center;
+      uint16 y = Center;
     } accelerometer;
   } io;
 } mbc7;
diff --git a/higan/gb/cartridge/mbc7/serialization.cpp b/higan/gb/cartridge/mbc7/serialization.cpp
new file mode 100644
index 00000000..11a03673
--- /dev/null
+++ b/higan/gb/cartridge/mbc7/serialization.cpp
@@ -0,0 +1,28 @@
+auto Cartridge::MBC7::serialize(serializer& s) -> void {
+  eeprom.serialize(s);
+  s.integer(io.rom.bank);
+  s.integer(io.ram.enable[0]);
+  s.integer(io.ram.enable[1]);
+  s.integer(io.accelerometer.x);
+  s.integer(io.accelerometer.y);
+}
+
+auto Cartridge::MBC7::EEPROM::serialize(serializer& s) -> void {
+  s.array(data);
+  s.integer(size);
+  s.integer(width);
+  s.boolean(select);
+  s.boolean(clock);
+  s.boolean(writable);
+  s.integer(busy);
+  command.serialize(s);
+  address.serialize(s);
+  input.serialize(s);
+  output.serialize(s);
+}
+
+auto Cartridge::MBC7::EEPROM::ShiftRegister::serialize(serializer& s) -> void {
+  s.integer(value);
+  s.integer(count);
+  s.integer(length);
+}
diff --git a/higan/gb/cartridge/serialization.cpp b/higan/gb/cartridge/serialization.cpp
index a03a4d9d..d6211178 100644
--- a/higan/gb/cartridge/serialization.cpp
+++ b/higan/gb/cartridge/serialization.cpp
@@ -1,4 +1,5 @@
 auto Cartridge::serialize(serializer& s) -> void {
+  Thread::serialize(s);
   if(ram.size) s.array(ram.data, ram.size);
   if(rtc.size) s.array(rtc.data, rtc.size);
 
diff --git a/higan/gb/cpu/timing.cpp b/higan/gb/cpu/timing.cpp
index c4e7e206..51dc892a 100644
--- a/higan/gb/cpu/timing.cpp
+++ b/higan/gb/cpu/timing.cpp
@@ -19,6 +19,7 @@ auto CPU::step(uint clocks) -> void {
     Thread::step(1);
     synchronize(ppu);
     synchronize(apu);
+    synchronize(cartridge);
   }
 
   if(Model::SuperGameBoy()) {
diff --git a/higan/gb/system/system.cpp b/higan/gb/system/system.cpp
index 5a90a522..f511e28a 100644
--- a/higan/gb/system/system.cpp
+++ b/higan/gb/system/system.cpp
@@ -15,6 +15,7 @@ auto System::runToSave() -> void {
   scheduler.synchronize(cpu);
   scheduler.synchronize(ppu);
   scheduler.synchronize(apu);
+  scheduler.synchronize(cartridge);
 }
 
 auto System::init() -> void {
diff --git a/higan/target-bsnes/bsnes.cpp b/higan/target-bsnes/bsnes.cpp
index bbaed88d..212e173e 100644
--- a/higan/target-bsnes/bsnes.cpp
+++ b/higan/target-bsnes/bsnes.cpp
@@ -24,18 +24,31 @@ auto hiro::initialize() -> void {
 
 #include <nall/main.hpp>
 auto nall::main(vector<string> arguments) -> void {
-  Application::setScreenSaver(settings.general.screenSaver);
-  Application::setToolTips(settings.general.toolTips);
+  settings.location = locate("settings.bml");
 
-  string locale;  // = "日本語";
+  arguments.takeLeft();  //ignore program location in argument parsing
   for(auto argument : arguments) {
-    if(argument.beginsWith("--locale=")) {
-      locale = argument.trimLeft("--locale=", 1L);
+    if(argument == "--fullscreen") {
+      presentation.startFullScreen = true;
+    } else if(argument.beginsWith("--locale=")) {
+      Application::locale().scan(locate("locales/"));
+      Application::locale().select(argument.trimLeft("--locale=", 1L));
+    } else if(argument.beginsWith("--settings=")) {
+      settings.location = argument.trimLeft("--settings=", 1L);
+    } else if(inode::exists(argument)) {
+      //game without option
+      program.gameQueue.append({";", argument});
+    } else if(argument.find(";")) {
+      //game with option
+      auto game = argument.split(";", 1L);
+      if(inode::exists(game.last())) program.gameQueue.append(argument);
     }
   }
-  Application::locale().scan(locate("locales/"));
-  Application::locale().select(locale);
+
+  settings.load();
+  Application::setScreenSaver(settings.general.screenSaver);
+  Application::setToolTips(settings.general.toolTips);
   emulator = new SuperFamicom::Interface;
-  program.create(arguments);
+  program.create();
   Application::run();
 }
diff --git a/higan/target-bsnes/bsnes.hpp b/higan/target-bsnes/bsnes.hpp
index 862c81ce..ae230649 100644
--- a/higan/target-bsnes/bsnes.hpp
+++ b/higan/target-bsnes/bsnes.hpp
@@ -1,18 +1,19 @@
-#include <nall/nall.hpp>
 #include <ruby/ruby.hpp>
-#include <hiro/hiro.hpp>
-using namespace nall;
 using namespace ruby;
-using namespace hiro;
 extern Video video;
 extern Audio audio;
 extern Input input;
 
+#include <hiro/hiro.hpp>
+using namespace hiro;
+
 #include <emulator/emulator.hpp>
 extern unique_pointer<Emulator::Interface> emulator;
 
-#include <nall/encode/rle.hpp>
 #include <nall/decode/rle.hpp>
+#include <nall/decode/zip.hpp>
+#include <nall/encode/rle.hpp>
+#include <nall/encode/zip.hpp>
 
 #include "program/program.hpp"
 #include "input/input.hpp"
diff --git a/higan/target-bsnes/presentation/presentation.cpp b/higan/target-bsnes/presentation/presentation.cpp
index 3d81a518..a404be11 100644
--- a/higan/target-bsnes/presentation/presentation.cpp
+++ b/higan/target-bsnes/presentation/presentation.cpp
@@ -189,6 +189,7 @@ auto Presentation::create() -> void {
   setBackgroundColor({0, 0, 0});
   resizeWindow();
   setCentered();
+  setFullScreen(startFullScreen);
 
   #if defined(PLATFORM_MACOS)
   Application::Cocoa::onAbout([&] { about.doActivate(); });
@@ -211,8 +212,17 @@ auto Presentation::updateStatusIcon() -> void {
   statusIcon.setIcon(icon);
 }
 
+auto Presentation::configureViewport() -> void {
+  uint width = viewport.geometry().width();
+  uint height = viewport.geometry().height();
+  video.configure(width, height, 60, 60);
+}
+
 auto Presentation::clearViewport() -> void {
-  if(!emulator->loaded()) viewportLayout.setPadding();
+  if(!emulator->loaded()) {
+    viewportLayout.setPadding();
+    configureViewport();
+  }
   if(!visible() || !video) return;
 
   uint32_t* output;
@@ -277,7 +287,7 @@ auto Presentation::resizeViewport() -> void {
     paddingWidth - paddingWidth / 2, paddingHeight - paddingHeight / 2
   });
 
-//clearViewport();
+  configureViewport();
 }
 
 auto Presentation::resizeWindow() -> void {
@@ -449,7 +459,7 @@ auto Presentation::updateRecentGames() -> void {
     bool missing = false;
     if(games) {
       for(auto& game : games.split("|")) {
-        if(!inode::exists(game)) missing = true;
+        if(!inode::exists(game.split(";").last())) missing = true;
       }
     }
     if(missing) {
@@ -467,12 +477,12 @@ auto Presentation::updateRecentGames() -> void {
 
   //update list
   for(auto index : range(RecentGames)) {
-    MenuItem item;
+    MenuItem item{&loadRecentGame};
     if(auto game = settings[{"Game/Recent/", 1 + index}].text()) {
       string displayName;
       auto games = game.split("|");
-      for(auto& part : games) {
-        displayName.append(Location::prefix(part), " + ");
+      for(auto& game : games) {
+        displayName.append(Location::prefix(game.split(";", 1L).last()), " + ");
       }
       displayName.trimRight(" + ", 1L);
       item.setIcon(games(0).endsWith("/") ? (image)Icon::Action::Open : (image)Icon::Emblem::File);
@@ -485,7 +495,6 @@ auto Presentation::updateRecentGames() -> void {
       item.setText({"(", tr("empty"), ")"});
       item.setEnabled(false);
     }
-    loadRecentGame.append(item);
   }
 
   loadRecentGame.append(MenuSeparator());
@@ -514,6 +523,8 @@ auto Presentation::addRecentGame(string location) -> void {
 
 auto Presentation::updateShaders() -> void {
   shaderMenu.reset();
+  shaderMenu.setEnabled(video.hasShader());
+  if(!video.hasShader()) return;
 
   Group shaders;
 
@@ -533,7 +544,7 @@ auto Presentation::updateShaders() -> void {
 
   auto location = locate("shaders/");
 
-  if(settings.video.driver == "OpenGL") {
+  if(settings.video.driver == "OpenGL 3.2") {
     for(auto shader : directory::folders(location, "*.shader")) {
       if(shaders.objectCount() == 2) shaderMenu.append(MenuSeparator());
       MenuRadioItem item{&shaderMenu};
diff --git a/higan/target-bsnes/presentation/presentation.hpp b/higan/target-bsnes/presentation/presentation.hpp
index fd5143b4..ba398c2a 100644
--- a/higan/target-bsnes/presentation/presentation.hpp
+++ b/higan/target-bsnes/presentation/presentation.hpp
@@ -26,6 +26,7 @@ struct Presentation : Window {
   enum : uint { StatusHeight = 24 };
 
   auto updateStatusIcon() -> void;
+  auto configureViewport() -> void;
   auto clearViewport() -> void;
   auto resizeViewport() -> void;
   auto resizeWindow() -> void;
@@ -40,6 +41,8 @@ struct Presentation : Window {
   auto addRecentGame(string location) -> void;
   auto updateShaders() -> void;
 
+  bool startFullScreen = false;
+
   MenuBar menuBar{this};
     Menu systemMenu{&menuBar};
       MenuItem loadGame{&systemMenu};
diff --git a/higan/target-bsnes/program/game.cpp b/higan/target-bsnes/program/game.cpp
index 90ee8b76..9da3a222 100644
--- a/higan/target-bsnes/program/game.cpp
+++ b/higan/target-bsnes/program/game.cpp
@@ -50,12 +50,13 @@ auto Program::load() -> void {
   stateManager.loadStates();
   manifestViewer.loadManifest();
 
-  string locations = superFamicom.location;
-  if(auto& location = gameBoy.location) locations.append("|", location);
-  if(auto& location = bsMemory.location) locations.append("|", location);
-  if(auto& location = sufamiTurboA.location) locations.append("|", location);
-  if(auto& location = sufamiTurboB.location) locations.append("|", location);
-  presentation.addRecentGame(locations);
+  string games;
+  if(auto& game = superFamicom) games.append(game.option, ";", game.location, "|");
+  if(auto& game = gameBoy     ) games.append(game.option, ";", game.location, "|");
+  if(auto& game = bsMemory    ) games.append(game.option, ";", game.location, "|");
+  if(auto& game = sufamiTurboA) games.append(game.option, ";", game.location, "|");
+  if(auto& game = sufamiTurboB) games.append(game.option, ";", game.location, "|");
+  presentation.addRecentGame(games.trimRight("|", 1L));
 
   updateVideoPalette();
   updateAudioEffects();
diff --git a/higan/target-bsnes/program/patch.cpp b/higan/target-bsnes/program/patch.cpp
index 58be7110..7ebb58f4 100644
--- a/higan/target-bsnes/program/patch.cpp
+++ b/higan/target-bsnes/program/patch.cpp
@@ -84,7 +84,7 @@ auto Program::applyPatchIPS(vector<uint8_t>& data, string location) -> bool {
   return true;
 }
 
-#include <nall/beat/patch.hpp>
+#include <nall/beat/single/apply.hpp>
 
 auto Program::applyPatchBPS(vector<uint8_t>& input, string location) -> bool {
   vector<uint8_t> patch;
@@ -107,22 +107,16 @@ auto Program::applyPatchBPS(vector<uint8_t>& input, string location) -> bool {
   }
   if(!patch) return false;
 
-  bpspatch beat;
-  beat.modify(patch.data(), patch.size());
-  beat.source(input.data(), input.size());
-  vector<uint8_t> output;
-  output.resize(beat.size());
-  beat.target(output.data(), output.size());
-  auto result = beat.apply();
-
-  if(result == bpspatch::result::success) {
-    input = output;
+  string manifest;
+  string result;
+  if(auto output = Beat::Single::apply(input.data(), input.size(), patch.data(), patch.size(), manifest, result)) {
+    input = move(*output);
     return true;
   }
 
-  MessageDialog(
-    "Error: patch checksum failure.\n\n"
+  MessageDialog({
+    result, "\n\n",
     "Please ensure you are using the correct (headerless) ROM for this patch."
-  ).setParent(*presentation).error();
+  }).setParent(*presentation).error();
   return false;
 }
diff --git a/higan/target-bsnes/program/platform.cpp b/higan/target-bsnes/program/platform.cpp
index ab86fd2f..e7fbc5e1 100644
--- a/higan/target-bsnes/program/platform.cpp
+++ b/higan/target-bsnes/program/platform.cpp
@@ -106,85 +106,100 @@ auto Program::load(uint id, string name, string type, vector<string> options) ->
 
   if(id == 1 && name == "Super Famicom" && type == "sfc") {
     if(gameQueue) {
-      superFamicom.location = gameQueue.takeLeft();
+      auto game = gameQueue.takeLeft().split(";", 1L);
+      superFamicom.option = game(0);
+      superFamicom.location = game(1);
     } else {
       dialog.setTitle("Load Super Famicom");
       dialog.setPath(path("Games", settings.path.recent.superFamicom));
       dialog.setFilters({string{"Super Famicom Games|*.sfc:*.smc:*.zip"}});
       superFamicom.location = dialog.openObject();
+      superFamicom.option = dialog.option();
     }
     if(inode::exists(superFamicom.location)) {
       settings.path.recent.superFamicom = Location::dir(superFamicom.location);
       if(loadSuperFamicom(superFamicom.location)) {
-        return {id, dialog.option()};
+        return {id, superFamicom.option};
       }
     }
   }
 
   if(id == 2 && name == "Game Boy" && type == "gb") {
     if(gameQueue) {
-      gameBoy.location = gameQueue.takeLeft();
+      auto game = gameQueue.takeLeft().split(";", 1L);
+      gameBoy.option = game(0);
+      gameBoy.location = game(1);
     } else {
       dialog.setTitle("Load Game Boy");
       dialog.setPath(path("Games", settings.path.recent.gameBoy));
       dialog.setFilters({string{"Game Boy Games|*.gb:*.gbc:*.zip"}});
       gameBoy.location = dialog.openObject();
+      gameBoy.option = dialog.option();
     }
     if(inode::exists(gameBoy.location)) {
       settings.path.recent.gameBoy = Location::dir(gameBoy.location);
       if(loadGameBoy(gameBoy.location)) {
-        return {id, dialog.option()};
+        return {id, gameBoy.option};
       }
     }
   }
 
   if(id == 3 && name == "BS Memory" && type == "bs") {
     if(gameQueue) {
-      bsMemory.location = gameQueue.takeLeft();
+      auto game = gameQueue.takeLeft().split(";", 1L);
+      bsMemory.option = game(0);
+      bsMemory.location = game(1);
     } else {
       dialog.setTitle("Load BS Memory");
       dialog.setPath(path("Games", settings.path.recent.bsMemory));
       dialog.setFilters({string{"BS Memory Games|*.bs:*.zip"}});
       bsMemory.location = dialog.openObject();
+      bsMemory.option = dialog.option();
     }
     if(inode::exists(bsMemory.location)) {
       settings.path.recent.bsMemory = Location::dir(bsMemory.location);
       if(loadBSMemory(bsMemory.location)) {
-        return {id, dialog.option()};
+        return {id, bsMemory.option};
       }
     }
   }
 
   if(id == 4 && name == "Sufami Turbo" && type == "st") {
     if(gameQueue) {
-      sufamiTurboA.location = gameQueue.takeLeft();
+      auto game = gameQueue.takeLeft().split(";", 1L);
+      sufamiTurboA.option = game(0);
+      sufamiTurboA.location = game(1);
     } else {
       dialog.setTitle("Load Sufami Turbo - Slot A");
       dialog.setPath(path("Games", settings.path.recent.sufamiTurboA));
       dialog.setFilters({string{"Sufami Turbo Games|*.st:*.zip"}});
       sufamiTurboA.location = dialog.openObject();
+      sufamiTurboA.option = dialog.option();
     }
     if(inode::exists(sufamiTurboA.location)) {
       settings.path.recent.sufamiTurboA = Location::dir(sufamiTurboA.location);
       if(loadSufamiTurboA(sufamiTurboA.location)) {
-        return {id, dialog.option()};
+        return {id, sufamiTurboA.option};
       }
     }
   }
 
   if(id == 5 && name == "Sufami Turbo" && type == "st") {
     if(gameQueue) {
-      sufamiTurboB.location = gameQueue.takeLeft();
+      auto game = gameQueue.takeLeft().split(";", 1L);
+      sufamiTurboB.option = game(0);
+      sufamiTurboB.location = game(1);
     } else {
       dialog.setTitle("Load Sufami Turbo - Slot B");
       dialog.setPath(path("Games", settings.path.recent.sufamiTurboB));
       dialog.setFilters({string{"Sufami Turbo Games|*.st:*.zip"}});
       sufamiTurboB.location = dialog.openObject();
+      sufamiTurboB.option = dialog.option();
     }
     if(inode::exists(sufamiTurboB.location)) {
       settings.path.recent.sufamiTurboB = Location::dir(sufamiTurboB.location);
       if(loadSufamiTurboB(sufamiTurboB.location)) {
-        return {id, dialog.option()};
+        return {id, sufamiTurboB.option};
       }
     }
   }
diff --git a/higan/target-bsnes/program/program.cpp b/higan/target-bsnes/program/program.cpp
index e377f7bb..2f696ae7 100644
--- a/higan/target-bsnes/program/program.cpp
+++ b/higan/target-bsnes/program/program.cpp
@@ -13,7 +13,7 @@
 #include "hacks.cpp"
 Program program;
 
-auto Program::create(vector<string> arguments) -> void {
+auto Program::create() -> void {
   Emulator::platform = this;
 
   presentation.create();
@@ -59,15 +59,6 @@ auto Program::create(vector<string> arguments) -> void {
   driverSettings.audioDriverChanged();
   driverSettings.inputDriverChanged();
 
-  arguments.takeLeft();  //ignore program location in argument parsing
-  for(auto& argument : arguments) {
-    if(argument == "--fullscreen") {
-      presentation.toggleFullscreenMode();
-    } else if(inode::exists(argument)) {
-      gameQueue.append(argument);
-    }
-  }
-
   if(gameQueue) load();
   Application::onMain({&Program::main, this});
 }
diff --git a/higan/target-bsnes/program/program.hpp b/higan/target-bsnes/program/program.hpp
index 96330797..48c660f7 100644
--- a/higan/target-bsnes/program/program.hpp
+++ b/higan/target-bsnes/program/program.hpp
@@ -2,7 +2,7 @@ struct Program : Lock, Emulator::Platform {
   Application::Namespace tr{"Program"};
 
   //program.cpp
-  auto create(vector<string> arguments) -> void;
+  auto create() -> void;
   auto main() -> void;
   auto quit() -> void;
 
@@ -108,6 +108,7 @@ public:
   struct Game {
     explicit operator bool() const { return (bool)location; }
 
+    string option;
     string location;
     string manifest;
     Markup::Node document;
diff --git a/higan/target-bsnes/program/states.cpp b/higan/target-bsnes/program/states.cpp
index 3205f6c3..e1f18fb9 100644
--- a/higan/target-bsnes/program/states.cpp
+++ b/higan/target-bsnes/program/states.cpp
@@ -62,7 +62,7 @@ auto Program::loadState(string filename) -> bool {
   if(auto memory = loadStateData(filename)) {
     if(filename != "Quick/Undo") saveUndoState();
     if(filename == "Quick/Undo") saveRedoState();
-    auto serializerRLE = Decode::RLE<uint8_t>(memory.data() + 3 * sizeof(uint));
+    auto serializerRLE = Decode::RLE<1>(memory.data() + 3 * sizeof(uint));
     serializer s{serializerRLE.data(), serializerRLE.size()};
     if(!emulator->unserialize(s)) return showMessage({"[", prefix, "] is in incompatible format"}), false;
     return showMessage({"Loaded [", prefix, "]"}), true;
@@ -77,7 +77,7 @@ auto Program::saveState(string filename) -> bool {
 
   serializer s = emulator->serialize();
   if(!s.size()) return showMessage({"Failed to save [", prefix, "]"}), false;
-  auto serializerRLE = Encode::RLE<uint8_t>(s.data(), s.size());
+  auto serializerRLE = Encode::RLE<1>(s.data(), s.size());
 
   vector<uint8_t> previewRLE;
   //this can be null if a state is captured before the first frame of video output after power/reset
@@ -86,7 +86,7 @@ auto Program::saveState(string filename) -> bool {
     preview.copy(screenshot.data, screenshot.pitch, screenshot.width, screenshot.height);
     if(preview.width() != 256 || preview.height() != 240) preview.scale(256, 240, true);
     preview.transform(0, 15, 0x8000, 0x7c00, 0x03e0, 0x001f);
-    previewRLE = Encode::RLE<uint16_t>(preview.data(), preview.size() / sizeof(uint16_t));
+    previewRLE = Encode::RLE<2>(preview.data(), preview.size() / sizeof(uint16_t));
   }
 
   vector<uint8_t> saveState;
diff --git a/higan/target-bsnes/program/video.cpp b/higan/target-bsnes/program/video.cpp
index 6bd94a3b..989fd901 100644
--- a/higan/target-bsnes/program/video.cpp
+++ b/higan/target-bsnes/program/video.cpp
@@ -12,6 +12,7 @@ auto Program::updateVideoDriver(Window parent) -> void {
   updateVideoShader();
 
   if(video.ready()) {
+    presentation.configureViewport();
     presentation.clearViewport();
     updateVideoShader();
   }
@@ -52,16 +53,7 @@ auto Program::updateVideoFormat() -> void {
 }
 
 auto Program::updateVideoShader() -> void {
-  if(settings.video.driver == "OpenGL"
-  && settings.video.shader != "None"
-  && settings.video.shader != "Blur"
-  ) {
-    video.setSmooth(false);
-    video.setShader(settings.video.shader);
-  } else {
-    video.setSmooth(settings.video.shader == "Blur");
-    video.setShader("");
-  }
+  video.setShader(settings.video.shader);
 }
 
 auto Program::updateVideoPalette() -> void {
diff --git a/higan/target-bsnes/settings/settings.cpp b/higan/target-bsnes/settings/settings.cpp
index e44ac0d5..a56e82a5 100644
--- a/higan/target-bsnes/settings/settings.cpp
+++ b/higan/target-bsnes/settings/settings.cpp
@@ -17,14 +17,14 @@ DriverSettings driverSettings;
 SettingsWindow settingsWindow;
 
 auto Settings::load() -> void {
-  Markup::Node::operator=(BML::unserialize(string::read(locate("settings.bml")), " "));
+  Markup::Node::operator=(BML::unserialize(string::read(location), " "));
   process(true);
   file::write(locate("settings.bml"), BML::serialize(*this, " "));
 }
 
 auto Settings::save() -> void {
   process(false);
-  file::write(locate("settings.bml"), BML::serialize(*this, " "));
+  file::write(location ? location : locate("settings.bml"), BML::serialize(*this, " "));
 }
 
 auto Settings::process(bool load) -> void {
diff --git a/higan/target-bsnes/settings/settings.hpp b/higan/target-bsnes/settings/settings.hpp
index 34fa2011..b87ef701 100644
--- a/higan/target-bsnes/settings/settings.hpp
+++ b/higan/target-bsnes/settings/settings.hpp
@@ -1,11 +1,10 @@
 struct Settings : Markup::Node {
-  Settings() { load(); }
-  ~Settings() { save(); }
-
   auto load() -> void;
   auto save() -> void;
   auto process(bool load) -> void;
 
+  string location;
+
   struct Video {
     string driver;
     bool exclusive = false;
diff --git a/higan/target-bsnes/tools/state-manager.cpp b/higan/target-bsnes/tools/state-manager.cpp
index 84317eac..c3532301 100644
--- a/higan/target-bsnes/tools/state-manager.cpp
+++ b/higan/target-bsnes/tools/state-manager.cpp
@@ -158,7 +158,7 @@ auto StateManager::updateSelection() -> void {
         uint preview    = memory::readl<sizeof(uint)>(saveState.data() + 2 * sizeof(uint));
         if(signature == Program::State::Signature && preview) {
           uint offset = 3 * sizeof(uint) + serializer;
-          auto preview = Decode::RLE<uint16_t>(saveState.data() + offset, max(offset, saveState.size()) - offset);
+          auto preview = Decode::RLE<2>(saveState.data() + offset, max(offset, saveState.size()) - offset);
           image icon{0, 15, 0x8000, 0x7c00, 0x03e0, 0x001f};
           icon.copy(preview.data(), 256 * sizeof(uint16_t), 256, 240);
           icon.transform();
diff --git a/higan/target-higan/higan.hpp b/higan/target-higan/higan.hpp
index 5d10bf3c..2741f067 100644
--- a/higan/target-higan/higan.hpp
+++ b/higan/target-higan/higan.hpp
@@ -1,13 +1,12 @@
-#include <nall/nall.hpp>
 #include <ruby/ruby.hpp>
-#include <hiro/hiro.hpp>
-using namespace nall;
 using namespace ruby;
-using namespace hiro;
 extern unique_pointer<Video> video;
 extern unique_pointer<Audio> audio;
 extern unique_pointer<Input> input;
 
+#include <hiro/hiro.hpp>
+using namespace hiro;
+
 #include <emulator/emulator.hpp>
 extern Emulator::Interface* emulator;
 
diff --git a/higan/target-higan/presentation/presentation.cpp b/higan/target-higan/presentation/presentation.cpp
index a108229c..0f5488d7 100644
--- a/higan/target-higan/presentation/presentation.cpp
+++ b/higan/target-higan/presentation/presentation.cpp
@@ -317,8 +317,17 @@ auto Presentation::updateSizeMenu() -> void {
   }));
 }
 
+auto Presentation::configureViewport() -> void {
+  uint width = viewport.geometry().width();
+  uint height = viewport.geometry().height();
+  if(video) video->configure(width, height, 60, 60);
+}
+
 auto Presentation::clearViewport() -> void {
-  if(!emulator || !emulator->loaded()) viewportLayout.setPadding();
+  if(!emulator || !emulator->loaded()) {
+    viewportLayout.setPadding();
+    configureViewport();
+  }
   if(!visible() || !video) return;
 
   uint32_t* output;
@@ -399,7 +408,7 @@ auto Presentation::resizeViewport() -> void {
     paddingWidth - paddingWidth / 2, paddingHeight - paddingHeight / 2
   });
 
-  clearViewport();
+  configureViewport();
 }
 
 auto Presentation::resizeWindow() -> void {
@@ -499,7 +508,7 @@ auto Presentation::loadSystems() -> void {
 auto Presentation::loadShaders() -> void {
   auto pathname = locate("shaders/");
 
-  if(settings["Video/Driver"].text() == "OpenGL") {
+  if(settings["Video/Driver"].text() == "OpenGL 3.2") {
     for(auto shader : directory::folders(pathname, "*.shader")) {
       if(videoShaders.objectCount() == 2) videoShaderMenu.append(MenuSeparator());
       MenuRadioItem item{&videoShaderMenu};
diff --git a/higan/target-higan/presentation/presentation.hpp b/higan/target-higan/presentation/presentation.hpp
index 8230febc..c4392c11 100644
--- a/higan/target-higan/presentation/presentation.hpp
+++ b/higan/target-higan/presentation/presentation.hpp
@@ -15,6 +15,7 @@ struct Presentation : Window {
   auto updateEmulatorMenu() -> void;
   auto updateEmulatorDeviceSelections() -> void;
   auto updateSizeMenu() -> void;
+  auto configureViewport() -> void;
   auto clearViewport() -> void;
   auto resizeViewport() -> void;
   auto resizeWindow() -> void;
diff --git a/higan/target-higan/program/utility.cpp b/higan/target-higan/program/utility.cpp
index a4436206..21cac21f 100644
--- a/higan/target-higan/program/utility.cpp
+++ b/higan/target-higan/program/utility.cpp
@@ -14,6 +14,7 @@ auto Program::initializeVideoDriver() -> void {
     video->create("None");
   }
 
+  presentation->configureViewport();
   presentation->clearViewport();
 }
 
@@ -137,17 +138,7 @@ auto Program::updateVideoPalette() -> void {
 }
 
 auto Program::updateVideoShader() -> void {
-  if(settings["Video/Driver"].text() == "OpenGL"
-  && settings["Video/Shader"].text() != "None"
-  && settings["Video/Shader"].text() != "Blur"
-  && directory::exists(settings["Video/Shader"].text())
-  ) {
-    video->setSmooth(false);
-    video->setShader(settings["Video/Shader"].text());
-  } else {
-    video->setSmooth(settings["Video/Shader"].text() == "Blur");
-    video->setShader("");
-  }
+  video->setShader(settings["Video/Shader"].text());
 }
 
 auto Program::updateAudioDriver() -> void {
diff --git a/hiro/gtk/header.hpp b/hiro/gtk/header.hpp
index 3b7787fa..65b67f2a 100644
--- a/hiro/gtk/header.hpp
+++ b/hiro/gtk/header.hpp
@@ -1,10 +1,4 @@
 #if defined(DISPLAY_WINDOWS)
-  #define UNICODE
-  #define WINVER 0x0601
-  #define _WIN32_WINNT WINVER
-  #define _WIN32_IE WINVER
-  #define __MSVCRT_VERSION__ WINVER
-  #define NOMINMAX
   #define TBS_TRANSPARENTBKGND 0x1000
 
   #include <nall/windows/guard.hpp>
diff --git a/hiro/windows/header.hpp b/hiro/windows/header.hpp
index 30cb3a64..a893f8cc 100644
--- a/hiro/windows/header.hpp
+++ b/hiro/windows/header.hpp
@@ -1,15 +1,9 @@
-#define UNICODE
-#define WINVER 0x0601
-#define _WIN32_WINNT WINVER
-#define _WIN32_IE WINVER
-#define __MSVCRT_VERSION__ WINVER
-#define NOMINMAX
-
 #include <nall/windows/guard.hpp>
 #include <winsock2.h>
 #include <windows.h>
 #include <windowsx.h>
 #include <commctrl.h>
+#include <commdlg.h>
 #include <uxtheme.h>
 #include <io.h>
 #include <shlobj.h>
diff --git a/icarus/GNUmakefile b/icarus/GNUmakefile
index ed3714fc..e84a68d3 100644
--- a/icarus/GNUmakefile
+++ b/icarus/GNUmakefile
@@ -59,3 +59,5 @@ else ifneq ($(filter $(platform),linux bsd),)
 	rm -f $(prefix)/share/applications/$(name).desktop
 	rm -f $(prefix)/share/icons/$(name).png
 endif
+
+-include obj/*.d
diff --git a/icarus/heuristics/game-boy.cpp b/icarus/heuristics/game-boy.cpp
index 68f41422..411a1cca 100644
--- a/icarus/heuristics/game-boy.cpp
+++ b/icarus/heuristics/game-boy.cpp
@@ -33,15 +33,17 @@ auto GameBoy::manifest() const -> string {
   bool black = (read(0x0143) & 0xc0) == 0x80;  //cartridge works in DMG+CGB mode
   bool clear = (read(0x0143) & 0xc0) == 0xc0;  //cartridge works in CGB mode only
 
-  bool flash = false;
-  bool battery = false;
   bool ram = false;
+  bool battery = false;
+  bool eeprom = false;
+  bool flash = false;
   bool rtc = false;
   bool accelerometer = false;
   bool rumble = false;
 
   uint romSize = 0;
   uint ramSize = 0;
+  uint eepromSize = 0;
   uint flashSize = 0;
   uint rtcSize = 0;
 
@@ -176,7 +178,7 @@ auto GameBoy::manifest() const -> string {
   case 0x22:
     mapper = "MBC7";
     battery = true;
-    ram = true;
+    eeprom = true;
     accelerometer = true;
     rumble = true;
     break;
@@ -204,6 +206,27 @@ auto GameBoy::manifest() const -> string {
 
   }
 
+  //Game Boy: title = $0134-0143
+  //Game Boy Color (early games): title = $0134-0142; model = $0143
+  //Game Boy Color (later games): title = $0134-013e; serial = $013f-0142; model = $0143
+  string title;
+  for(uint n : range(black || clear ? 15 : 16)) {
+    char byte = read(0x0134 + n);
+    if(byte < 0x20 || byte > 0x7e) byte = ' ';
+    title.append(byte);
+  }
+
+  string serial = title.slice(-4);
+  if(!black && !clear) serial = "";
+  for(auto& byte : serial) {
+    if(byte >= 'A' && byte <= 'Z') continue;
+    //invalid serial
+    serial = "";
+    break;
+  }
+  title.trimRight(serial, 1L);  //remove the serial from the title, if it exists
+  title.strip();  //remove any excess whitespace from the title
+
   switch(read(0x0148)) { default:
   case 0x00: romSize =   2 * 16 * 1024; break;
   case 0x01: romSize =   4 * 16 * 1024; break;
@@ -227,11 +250,21 @@ auto GameBoy::manifest() const -> string {
 
   if(mapper == "MBC2" && ram) ramSize = 256;
   if(mapper == "MBC6" && ram) ramSize =  32 * 1024;
-  if(mapper == "MBC7" && ram) ramSize = 256;
   if(mapper == "TAMA" && ram) ramSize =  32;
 
   if(mapper == "MBC6" && flash) flashSize = 1024 * 1024;
 
+  //Game Boy header does not specify EEPROM size: detect via game title instead
+  //Command Master:        EEPROM = 512 bytes
+  //Kirby Tilt 'n' Tumble: EEPROM = 256 bytes
+  //Korokoro Kirby:        EEPROM = 256 bytes
+  if(mapper == "MBC7" && eeprom) {
+    eepromSize = 256;  //fallback guess; supported values are 128, 256, 512
+    if(title == "CMASTER"     && serial == "KCEJ") eepromSize = 512;
+    if(title == "KIRBY TNT"   && serial == "KTNE") eepromSize = 256;
+    if(title == "KORO2 KIRBY" && serial == "KKKJ") eepromSize = 256;
+  }
+
   if(mapper == "MBC3" && rtc) rtcSize = 13;
   if(mapper == "TAMA" && rtc) rtcSize = 21;
 
@@ -240,12 +273,17 @@ auto GameBoy::manifest() const -> string {
   output.append("  sha256: ", Hash::SHA256(data).digest(), "\n");
   output.append("  label:  ", Location::prefix(location), "\n");
   output.append("  name:   ", Location::prefix(location), "\n");
+  output.append("  title:  ", title, "\n");
+if(serial)
+  output.append("  serial: ", serial, "\n");
   output.append("  board:  ", mapper, "\n");
   output.append(Memory{}.type("ROM").size(data.size()).content("Program").text());
 if(ram && ramSize && battery)
   output.append(Memory{}.type("RAM").size(ramSize).content("Save").text());
 if(ram && ramSize && !battery)
   output.append(Memory{}.type("RAM").size(ramSize).content("Save").isVolatile().text());
+if(eeprom && eepromSize)
+  output.append(Memory{}.type("EEPROM").size(eepromSize).content("Save").text());
 if(flash && flashSize)
   output.append(Memory{}.type("Flash").size(flashSize).content("Download").text());
 if(rtc && rtcSize)
diff --git a/nall/adaptive-array.hpp b/nall/adaptive-array.hpp
index 7f724c9e..9ca84e7c 100644
--- a/nall/adaptive-array.hpp
+++ b/nall/adaptive-array.hpp
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <nall/range.hpp>
+#include <nall/traits.hpp>
 
 namespace nall {
 
diff --git a/nall/array.hpp b/nall/array.hpp
index 504f63f3..48e3ecc4 100644
--- a/nall/array.hpp
+++ b/nall/array.hpp
@@ -1,5 +1,4 @@
 #pragma once
-#define DEBUG
 
 #include <nall/range.hpp>
 
@@ -7,7 +6,7 @@ namespace nall {
 
 template<typename T> struct array;
 
-//usage: int x[256] => array<int, 256>
+//usage: int x[256] => array<int[256]> x
 template<typename T, uint Size> struct array<T[Size]> {
   array() = default;
 
@@ -39,8 +38,9 @@ template<typename T, uint Size> struct array<T[Size]> {
     return values[index];
   }
 
-  auto fill(const T& fill = {}) {
+  auto fill(const T& fill = {}) -> array& {
     for(auto& value : values) value = fill;
+    return *this;
   }
 
   auto data() -> T* { return values; }
@@ -57,74 +57,4 @@ private:
   T values[Size];
 };
 
-template<typename T> struct array_view;
-
-template<typename T, uint Size> struct array_view<T[Size]> {
-  array_view() = default;
-
-  template<uint Capacity>
-  array_view(array<T[Capacity]>& source, uint offset = 0) {
-    #ifdef DEBUG
-    struct out_of_bounds {};
-    if(offset + Size >= Capacity) throw out_of_bounds{};
-    #endif
-    values = &source.data()[offset];
-  }
-
-  template<uint Capacity>
-  array_view(T (&source)[Capacity], uint offset = 0) {
-    #ifdef DEBUG
-    struct out_of_bounds {};
-    if(offset + Size >= Capacity) throw out_of_bounds{};
-    #endif
-    values = &source[offset];
-  }
-
-  array_view(T* source, uint offset = 0) {
-    values = &source[offset];
-  }
-
-  explicit operator bool() const {
-    return values;
-  }
-
-  alwaysinline auto operator[](uint index) -> T& {
-    #ifdef DEBUG
-    struct out_of_bounds {};
-    if(index >= Size) throw out_of_bounds{};
-    #endif
-    return values[index];
-  }
-
-  alwaysinline auto operator[](uint index) const -> const T& {
-    #ifdef DEBUG
-    struct out_of_bounds {};
-    if(index >= Size) throw out_of_bounds{};
-    #endif
-    return values[index];
-  }
-
-  alwaysinline auto operator()(uint index, const T& fallback = {}) const -> const T& {
-    if(index >= Size) return fallback;
-    return values[index];
-  }
-
-  auto fill(const T& fill = {}) -> void {
-    for(uint index : range(Size)) values[index] = fill;
-  }
-
-  auto data() -> T* { return values; }
-  auto data() const -> const T* { return values; }
-  auto size() const -> uint { return Size; }
-
-  auto begin() -> T* { return &values[0]; }
-  auto end() -> T* { return &values[Size]; }
-
-  auto begin() const -> const T* { return &values[0]; }
-  auto end() const -> const T* { return &values[Size]; }
-
-private:
-  T* values = nullptr;
-};
-
 }
diff --git a/nall/beat/archive.hpp b/nall/beat/archive.hpp
deleted file mode 100644
index 03f7276a..00000000
--- a/nall/beat/archive.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#pragma once
-
-#include <nall/beat/file.hpp>
-
-namespace nall { namespace Beat {
-
-struct Archive {
-  static auto create(const string& beatname, const string& pathname, const string& metadata = "") -> bool;
-  static auto unpack(const string& beatname, const string& pathname) -> bool;
-  static auto extract(const string& beatname, const string& pathname) -> vector<uint8_t>;
-
-private:
-  static auto scan(vector<string>& result, const string& basename, const string& pathname) -> void;
-};
-
-auto Archive::create(const string& beatname, const string& pathname, const string& metadata) -> bool {
-  if(!beatname.endsWith(".bpa") || !pathname.endsWith("/")) return false;  //protect against reversed arguments
-
-  File beat{beatname, file::mode::write};
-  if(!beat) return false;  //file not writable?
-
-  beat.writes("BPA1");
-  beat.writevu(metadata.size());
-  beat.writes(metadata);
-
-  vector<string> contents;
-  scan(contents, pathname, pathname);
-
-  for(auto& name : contents) {
-    string location{pathname, name};
-    bool directory = name.endsWith("/");
-    bool writable = inode::writable(location);
-    bool executable = inode::executable(location);
-    uint info = directory << 0 | writable << 1 | executable << 2 | (name.trimRight("/").size() - 1) << 3;
-
-    beat.writevu(info);
-    beat.writes(name);
-    if(directory) continue;
-
-    File input{location, file::mode::read};
-    if(input) {
-      auto size = input.size();
-      beat.writevu(size);
-      while(size--) beat.write(input.read());
-      beat.writel(input.checksum.digest().hex(), 4);
-    } else {
-      beat.writevu(0);
-      beat.writel(0x00000000, 4);
-    }
-  }
-
-  beat.writel(beat.checksum.digest().hex(), 4);
-  return true;
-}
-
-auto Archive::unpack(const string& beatname, const string& pathname) -> bool {
-  if(!beatname.endsWith(".bpa") || !pathname.endsWith("/")) return false;  //protect against reversed arguments
-
-  File beat{beatname, file::mode::read};
-  if(!beat) return false;  //file not readable?
-
-  if(beat.reads(4) != "BPA1") return false;
-  auto size = beat.readvu();
-  while(size--) beat.read();
-
-  directory::create(pathname);
-  while(beat.offset() < beat.size() - 4) {
-    auto info = beat.readvu();
-    auto name = beat.reads((info >> 3) + 1);
-    if(name.find("\\") || name.find("../")) return false;  //block path exploits
-
-    string location{pathname, name};
-    bool directory = info & 1;
-    bool writable = info & 2;
-    bool executable = info & 4;
-
-    if(directory) {
-      if(!nall::directory::create(location)) return false;
-    } else {
-      File output{location, file::mode::write};
-      if(!output) return false;
-
-      auto size = beat.readvu();
-      while(size--) output.write(beat.read());
-      if(beat.readl(4) != output.checksum.digest().hex()) return false;
-    }
-  }
-
-  uint32_t checksum = beat.checksum.digest().hex();
-  return beat.readl(4) == checksum;
-}
-
-auto Archive::extract(const string& beatname, const string& filename) -> vector<uint8_t> {
-  File beat{beatname, file::mode::read};
-  if(!beat) return {};  //file not readable?
-
-  if(beat.reads(4) != "BPA1") return {};
-  auto size = beat.readvu();
-  beat.seek(beat.offset() + size);
-
-  while(beat.offset() < beat.size() - 4) {
-    auto info = beat.readvu();
-    auto name = beat.reads((info >> 3) + 1);
-    if(info & 1) continue;  //ignore directories
-
-    auto size = beat.readvu();
-    if(name != filename) {
-      beat.seek(beat.offset() + size + 4);
-      continue;
-    }
-
-    vector<uint8_t> result;
-    result.resize(size);
-    beat.checksum.reset();
-    for(auto n : range(size)) result[n] = beat.read();
-    uint32_t checksum = beat.checksum.digest().hex();
-    if(beat.readl(4) != checksum) return {};
-    return result;
-  }
-
-  return {};
-}
-
-auto Archive::scan(vector<string>& result, const string& basename, const string& pathname) -> void {
-  for(auto& name : directory::contents(pathname)) {
-    result.append(string{pathname, name}.trimLeft(basename, 1L));
-    if(name.endsWith("/")) scan(result, basename, {pathname, name});
-  }
-}
-
-}}
diff --git a/nall/beat/delta.hpp b/nall/beat/delta.hpp
deleted file mode 100644
index 1edcccb5..00000000
--- a/nall/beat/delta.hpp
+++ /dev/null
@@ -1,211 +0,0 @@
-#pragma once
-
-#include <nall/file.hpp>
-#include <nall/filemap.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-#include <nall/hash/crc32.hpp>
-
-namespace nall {
-
-struct bpsdelta {
-  inline auto source(const uint8_t* data, uint size) -> void;
-  inline auto target(const uint8_t* data, uint size) -> void;
-
-  inline auto source(const string& filename) -> bool;
-  inline auto target(const string& filename) -> bool;
-  inline auto create(const string& filename, const string& metadata = "") -> bool;
-
-protected:
-  enum : uint { SourceRead, TargetRead, SourceCopy, TargetCopy };
-  enum : uint { Granularity = 1 };
-
-  struct Node {
-    Node() = default;
-    ~Node() { if(next) delete next; }
-    uint offset = 0;
-    Node* next = nullptr;
-  };
-
-  filemap sourceFile;
-  const uint8_t* sourceData;
-  uint sourceSize;
-
-  filemap targetFile;
-  const uint8_t* targetData;
-  uint targetSize;
-};
-
-auto bpsdelta::source(const uint8_t* data, uint size) -> void {
-  sourceData = data;
-  sourceSize = size;
-}
-
-auto bpsdelta::target(const uint8_t* data, uint size) -> void {
-  targetData = data;
-  targetSize = size;
-}
-
-auto bpsdelta::source(const string& filename) -> bool {
-  if(sourceFile.open(filename, filemap::mode::read) == false) return false;
-  source(sourceFile.data(), sourceFile.size());
-  return true;
-}
-
-auto bpsdelta::target(const string& filename) -> bool {
-  if(targetFile.open(filename, filemap::mode::read) == false) return false;
-  target(targetFile.data(), targetFile.size());
-  return true;
-}
-
-auto bpsdelta::create(const string& filename, const string& metadata) -> bool {
-  file modifyFile;
-  if(modifyFile.open(filename, file::mode::write) == false) return false;
-
-  Hash::CRC32 sourceChecksum, modifyChecksum;
-  uint sourceRelativeOffset = 0, targetRelativeOffset = 0, outputOffset = 0;
-
-  auto write = [&](uint8_t data) {
-    modifyFile.write(data);
-    modifyChecksum.input(data);
-  };
-
-  auto encode = [&](uint64_t data) {
-    while(true) {
-      uint64_t x = data & 0x7f;
-      data >>= 7;
-      if(data == 0) {
-        write(0x80 | x);
-        break;
-      }
-      write(x);
-      data--;
-    }
-  };
-
-  write('B');
-  write('P');
-  write('S');
-  write('1');
-
-  encode(sourceSize);
-  encode(targetSize);
-
-  uint markupSize = metadata.length();
-  encode(markupSize);
-  for(uint n = 0; n < markupSize; n++) write(metadata[n]);
-
-  Node* sourceTree[65536];
-  Node* targetTree[65536];
-  for(uint n = 0; n < 65536; n++) sourceTree[n] = nullptr, targetTree[n] = nullptr;
-
-  //source tree creation
-  for(uint offset = 0; offset < sourceSize; offset++) {
-    uint16_t symbol = sourceData[offset + 0];
-    sourceChecksum.input(symbol);
-    if(offset < sourceSize - 1) symbol |= sourceData[offset + 1] << 8;
-    Node *node = new Node;
-    node->offset = offset;
-    node->next = sourceTree[symbol];
-    sourceTree[symbol] = node;
-  }
-
-  uint targetReadLength = 0;
-
-  auto targetReadFlush = [&]() {
-    if(targetReadLength) {
-      encode(TargetRead | ((targetReadLength - 1) << 2));
-      uint offset = outputOffset - targetReadLength;
-      while(targetReadLength) write(targetData[offset++]), targetReadLength--;
-    }
-  };
-
-  while(outputOffset < targetSize) {
-    uint maxLength = 0, maxOffset = 0, mode = TargetRead;
-
-    uint16_t symbol = targetData[outputOffset + 0];
-    if(outputOffset < targetSize - 1) symbol |= targetData[outputOffset + 1] << 8;
-
-    { //source read
-      uint length = 0, offset = outputOffset;
-      while(offset < sourceSize && offset < targetSize && sourceData[offset] == targetData[offset]) {
-        length++;
-        offset++;
-      }
-      if(length > maxLength) maxLength = length, mode = SourceRead;
-    }
-
-    { //source copy
-      Node* node = sourceTree[symbol];
-      while(node) {
-        uint length = 0, x = node->offset, y = outputOffset;
-        while(x < sourceSize && y < targetSize && sourceData[x++] == targetData[y++]) length++;
-        if(length > maxLength) maxLength = length, maxOffset = node->offset, mode = SourceCopy;
-        node = node->next;
-      }
-    }
-
-    { //target copy
-      Node* node = targetTree[symbol];
-      while(node) {
-        uint length = 0, x = node->offset, y = outputOffset;
-        while(y < targetSize && targetData[x++] == targetData[y++]) length++;
-        if(length > maxLength) maxLength = length, maxOffset = node->offset, mode = TargetCopy;
-        node = node->next;
-      }
-
-      //target tree append
-      node = new Node;
-      node->offset = outputOffset;
-      node->next = targetTree[symbol];
-      targetTree[symbol] = node;
-    }
-
-    { //target read
-      if(maxLength < 4) {
-        maxLength = min((uint)Granularity, targetSize - outputOffset);
-        mode = TargetRead;
-      }
-    }
-
-    if(mode != TargetRead) targetReadFlush();
-
-    switch(mode) {
-    case SourceRead:
-      encode(SourceRead | ((maxLength - 1) << 2));
-      break;
-    case TargetRead:
-      //delay write to group sequential TargetRead commands into one
-      targetReadLength += maxLength;
-      break;
-    case SourceCopy:
-    case TargetCopy:
-      encode(mode | ((maxLength - 1) << 2));
-      int relativeOffset;
-      if(mode == SourceCopy) {
-        relativeOffset = maxOffset - sourceRelativeOffset;
-        sourceRelativeOffset = maxOffset + maxLength;
-      } else {
-        relativeOffset = maxOffset - targetRelativeOffset;
-        targetRelativeOffset = maxOffset + maxLength;
-      }
-      encode((relativeOffset < 0) | (abs(relativeOffset) << 1));
-      break;
-    }
-
-    outputOffset += maxLength;
-  }
-
-  targetReadFlush();
-
-  for(uint n = 0; n < 32; n += 8) write(sourceChecksum.digest().hex() >> n);
-  uint32_t targetChecksum = Hash::CRC32(targetData, targetSize).digest().hex();
-  for(uint n = 0; n < 32; n += 8) write(targetChecksum >> n);
-  uint32_t outputChecksum = modifyChecksum.digest().hex();
-  for(uint n = 0; n < 32; n += 8) write(outputChecksum >> n);
-
-  modifyFile.close();
-  return true;
-}
-
-}
diff --git a/nall/beat/file.hpp b/nall/beat/file.hpp
deleted file mode 100644
index b42bb630..00000000
--- a/nall/beat/file.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-namespace nall { namespace Beat {
-
-struct File : file {
-  using file::file;
-  auto read() -> uint8_t override;
-  auto write(uint8_t) -> void override;
-  Hash::CRC32 checksum;
-};
-
-auto File::read() -> uint8_t {
-  uint8_t data = file::read();
-  checksum.input(data);
-  return data;
-}
-
-auto File::write(uint8_t data) -> void {
-  checksum.input(data);
-  return file::write(data);
-}
-
-}}
diff --git a/nall/beat/linear.hpp b/nall/beat/linear.hpp
deleted file mode 100644
index b1461c4d..00000000
--- a/nall/beat/linear.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#pragma once
-
-#include <nall/file.hpp>
-#include <nall/filemap.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-struct bpslinear {
-  inline auto source(const uint8_t* data, uint size) -> void;
-  inline auto target(const uint8_t* data, uint size) -> void;
-
-  inline auto source(const string& filename) -> bool;
-  inline auto target(const string& filename) -> bool;
-  inline auto create(const string& filename, const string& metadata = "") -> bool;
-
-protected:
-  enum : uint { SourceRead, TargetRead, SourceCopy, TargetCopy };
-  enum : uint { Granularity = 1 };
-
-  filemap sourceFile;
-  const uint8_t* sourceData;
-  uint sourceSize;
-
-  filemap targetFile;
-  const uint8_t* targetData;
-  uint targetSize;
-};
-
-auto bpslinear::source(const uint8_t* data, uint size) -> void {
-  sourceData = data;
-  sourceSize = size;
-}
-
-auto bpslinear::target(const uint8_t* data, uint size) -> void {
-  targetData = data;
-  targetSize = size;
-}
-
-auto bpslinear::source(const string& filename) -> bool {
-  if(sourceFile.open(filename, filemap::mode::read) == false) return false;
-  source(sourceFile.data(), sourceFile.size());
-  return true;
-}
-
-auto bpslinear::target(const string& filename) -> bool {
-  if(targetFile.open(filename, filemap::mode::read) == false) return false;
-  target(targetFile.data(), targetFile.size());
-  return true;
-}
-
-auto bpslinear::create(const string& filename, const string& metadata) -> bool {
-  file modifyFile;
-  if(modifyFile.open(filename, file::mode::write) == false) return false;
-
-  Hash::CRC32 modifyChecksum;
-  uint targetRelativeOffset = 0, outputOffset = 0;
-
-  auto write = [&](uint8_t data) {
-    modifyFile.write(data);
-    modifyChecksum.input(data);
-  };
-
-  auto encode = [&](uint64_t data) {
-    while(true) {
-      uint64_t x = data & 0x7f;
-      data >>= 7;
-      if(data == 0) {
-        write(0x80 | x);
-        break;
-      }
-      write(x);
-      data--;
-    }
-  };
-
-  uint targetReadLength = 0;
-
-  auto targetReadFlush = [&]() {
-    if(targetReadLength) {
-      encode(TargetRead | ((targetReadLength - 1) << 2));
-      uint offset = outputOffset - targetReadLength;
-      while(targetReadLength) write(targetData[offset++]), targetReadLength--;
-    }
-  };
-
-  write('B');
-  write('P');
-  write('S');
-  write('1');
-
-  encode(sourceSize);
-  encode(targetSize);
-
-  uint markupSize = metadata.length();
-  encode(markupSize);
-  for(uint n = 0; n < markupSize; n++) write(metadata[n]);
-
-  while(outputOffset < targetSize) {
-    uint sourceLength = 0;
-    for(uint n = 0; outputOffset + n < min(sourceSize, targetSize); n++) {
-      if(sourceData[outputOffset + n] != targetData[outputOffset + n]) break;
-      sourceLength++;
-    }
-
-    uint rleLength = 0;
-    for(uint n = 1; outputOffset + n < targetSize; n++) {
-      if(targetData[outputOffset] != targetData[outputOffset + n]) break;
-      rleLength++;
-    }
-
-    if(rleLength >= 4) {
-      //write byte to repeat
-      targetReadLength++;
-      outputOffset++;
-      targetReadFlush();
-
-      //copy starting from repetition byte
-      encode(TargetCopy | ((rleLength - 1) << 2));
-      uint relativeOffset = (outputOffset - 1) - targetRelativeOffset;
-      encode(relativeOffset << 1);
-      outputOffset += rleLength;
-      targetRelativeOffset = outputOffset - 1;
-    } else if(sourceLength >= 4) {
-      targetReadFlush();
-      encode(SourceRead | ((sourceLength - 1) << 2));
-      outputOffset += sourceLength;
-    } else {
-      targetReadLength += Granularity;
-      outputOffset += Granularity;
-    }
-  }
-
-  targetReadFlush();
-
-  uint32_t sourceChecksum = Hash::CRC32(sourceData, sourceSize).digest().hex();
-  for(uint n = 0; n < 32; n += 8) write(sourceChecksum >> n);
-  uint32_t targetChecksum = Hash::CRC32(targetData, targetSize).digest().hex();
-  for(uint n = 0; n < 32; n += 8) write(targetChecksum >> n);
-  uint32_t outputChecksum = modifyChecksum.digest().hex();
-  for(uint n = 0; n < 32; n += 8) write(outputChecksum >> n);
-
-  modifyFile.close();
-  return true;
-}
-
-}
diff --git a/nall/beat/metadata.hpp b/nall/beat/metadata.hpp
deleted file mode 100644
index 48d14cde..00000000
--- a/nall/beat/metadata.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#pragma once
-
-#include <nall/file.hpp>
-#include <nall/filemap.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-struct bpsmetadata {
-  inline auto load(const string& filename) -> bool;
-  inline auto save(const string& filename, const string& metadata) -> bool;
-  inline auto metadata() const -> string;
-
-protected:
-  file sourceFile;
-  string metadataString;
-};
-
-auto bpsmetadata::load(const string& filename) -> bool {
-  if(sourceFile.open(filename, file::mode::read) == false) return false;
-
-  auto read = [&]() -> uint8_t {
-    return sourceFile.read();
-  };
-
-  auto decode = [&]() -> uint64_t {
-    uint64_t data = 0, shift = 1;
-    while(true) {
-      uint8_t x = read();
-      data += (x & 0x7f) * shift;
-      if(x & 0x80) break;
-      shift <<= 7;
-      data += shift;
-    }
-    return data;
-  };
-
-  if(read() != 'B') return false;
-  if(read() != 'P') return false;
-  if(read() != 'S') return false;
-  if(read() != '1') return false;
-  decode();
-  decode();
-  uint metadataSize = decode();
-  char data[metadataSize + 1];
-  for(uint n = 0; n < metadataSize; n++) data[n] = read();
-  data[metadataSize] = 0;
-  metadataString = (const char*)data;
-
-  return true;
-}
-
-auto bpsmetadata::save(const string& filename, const string& metadata) -> bool {
-  file targetFile;
-  if(targetFile.open(filename, file::mode::write) == false) return false;
-  if(sourceFile.open() == false) return false;
-  sourceFile.seek(0);
-
-  auto read = [&]() -> uint8_t {
-    return sourceFile.read();
-  };
-
-  auto decode = [&]() -> uint64_t {
-    uint64_t data = 0, shift = 1;
-    while(true) {
-      uint8_t x = read();
-      data += (x & 0x7f) * shift;
-      if(x & 0x80) break;
-      shift <<= 7;
-      data += shift;
-    }
-    return data;
-  };
-
-  Hash::CRC32 checksum;
-
-  auto write = [&](uint8_t data) {
-    targetFile.write(data);
-    checksum.input(data);
-  };
-
-  auto encode = [&](uint64_t data) {
-    while(true) {
-      uint64_t x = data & 0x7f;
-      data >>= 7;
-      if(data == 0) {
-        write(0x80 | x);
-        break;
-      }
-      write(x);
-      data--;
-    }
-  };
-
-  for(uint n = 0; n < 4; n++) write(read());
-  encode(decode());
-  encode(decode());
-  uint sourceLength = decode();
-  uint targetLength = metadata.length();
-  encode(targetLength);
-  sourceFile.seek(sourceLength, file::index::relative);
-  for(uint n = 0; n < targetLength; n++) write(metadata[n]);
-  uint length = sourceFile.size() - sourceFile.offset() - 4;
-  for(uint n = 0; n < length; n++) write(read());
-  uint32_t outputChecksum = checksum.digest().hex();
-  for(uint n = 0; n < 32; n += 8) write(outputChecksum >> n);
-
-  targetFile.close();
-  return true;
-}
-
-auto bpsmetadata::metadata() const -> string {
-  return metadataString;
-}
-
-}
diff --git a/nall/beat/multi.hpp b/nall/beat/multi.hpp
deleted file mode 100644
index 442f3a59..00000000
--- a/nall/beat/multi.hpp
+++ /dev/null
@@ -1,239 +0,0 @@
-#pragma once
-
-#include <nall/beat/patch.hpp>
-#include <nall/beat/linear.hpp>
-#include <nall/beat/delta.hpp>
-
-namespace nall {
-
-struct bpsmulti {
-  enum : uint {
-    CreatePath = 0,
-    CreateFile = 1,
-    ModifyFile = 2,
-    MirrorFile = 3,
-  };
-
-  enum : uint {
-    OriginSource = 0,
-    OriginTarget = 1,
-  };
-
-  auto create(const string& patchName, const string& sourcePath, const string& targetPath, bool delta = false, const string& metadata = "") -> bool {
-    if(fp.open()) fp.close();
-    fp.open(patchName, file::mode::write);
-    checksum.reset();
-
-    writeString("BPM1");  //signature
-    writeNumber(metadata.length());
-    writeString(metadata);
-
-    vector<string> sourceList, targetList;
-    ls(sourceList, sourcePath, sourcePath);
-    ls(targetList, targetPath, targetPath);
-
-    for(auto& targetName : targetList) {
-      if(targetName.endsWith("/")) {
-        targetName.trimRight("/");
-        writeNumber(CreatePath | ((targetName.length() - 1) << 2));
-        writeString(targetName);
-      } else if(auto position = sourceList.find(targetName)) {  //if sourceName == targetName
-        file sp, dp;
-        sp.open({sourcePath, targetName}, file::mode::read);
-        dp.open({targetPath, targetName}, file::mode::read);
-
-        bool identical = sp.size() == dp.size();
-        Hash::CRC32 cksum;
-
-        for(uint n = 0; n < sp.size(); n++) {
-          uint8_t byte = sp.read();
-          if(identical && byte != dp.read()) identical = false;
-          cksum.input(byte);
-        }
-
-        if(identical) {
-          writeNumber(MirrorFile | ((targetName.length() - 1) << 2));
-          writeString(targetName);
-          writeNumber(OriginSource);
-          writeChecksum(cksum.digest().hex());
-        } else {
-          writeNumber(ModifyFile | ((targetName.length() - 1) << 2));
-          writeString(targetName);
-          writeNumber(OriginSource);
-
-          if(delta == false) {
-            bpslinear patch;
-            patch.source({sourcePath, targetName});
-            patch.target({targetPath, targetName});
-            patch.create({Path::temporary(), "temp.bps"});
-          } else {
-            bpsdelta patch;
-            patch.source({sourcePath, targetName});
-            patch.target({targetPath, targetName});
-            patch.create({Path::temporary(), "temp.bps"});
-          }
-
-          auto buffer = file::read({Path::temporary(), "temp.bps"});
-          writeNumber(buffer.size());
-          for(auto &byte : buffer) write(byte);
-        }
-      } else {
-        writeNumber(CreateFile | ((targetName.length() - 1) << 2));
-        writeString(targetName);
-        auto buffer = file::read({targetPath, targetName});
-        writeNumber(buffer.size());
-        for(auto& byte : buffer) write(byte);
-        writeChecksum(Hash::CRC32(buffer.data(), buffer.size()).digest().hex());
-      }
-    }
-
-    //checksum
-    writeChecksum(checksum.digest().hex());
-    fp.close();
-    return true;
-  }
-
-  auto apply(const string& patchName, const string& sourcePath, const string& targetPath) -> bool {
-    directory::remove(targetPath);  //start with a clean directory
-    directory::create(targetPath);
-
-    if(fp.open()) fp.close();
-    fp.open(patchName, file::mode::read);
-    checksum.reset();
-
-    if(readString(4) != "BPM1") return false;
-    auto metadataLength = readNumber();
-    while(metadataLength--) read();
-
-    while(fp.offset() < fp.size() - 4) {
-      auto encoding = readNumber();
-      uint action = encoding & 3;
-      uint targetLength = (encoding >> 2) + 1;
-      string targetName = readString(targetLength);
-
-      if(action == CreatePath) {
-        directory::create({targetPath, targetName, "/"});
-      } else if(action == CreateFile) {
-        file fp;
-        fp.open({targetPath, targetName}, file::mode::write);
-        auto fileSize = readNumber();
-        while(fileSize--) fp.write(read());
-        uint32_t cksum = readChecksum();
-      } else if(action == ModifyFile) {
-        auto encoding = readNumber();
-        string originPath = encoding & 1 ? targetPath : sourcePath;
-        string sourceName = (encoding >> 1) == 0 ? targetName : readString(encoding >> 1);
-        auto patchSize = readNumber();
-        vector<uint8_t> buffer;
-        buffer.resize(patchSize);
-        for(uint n = 0; n < patchSize; n++) buffer[n] = read();
-        bpspatch patch;
-        patch.modify(buffer.data(), buffer.size());
-        patch.source({originPath, sourceName});
-        patch.target({targetPath, targetName});
-        if(patch.apply() != bpspatch::result::success) return false;
-      } else if(action == MirrorFile) {
-        auto encoding = readNumber();
-        string originPath = encoding & 1 ? targetPath : sourcePath;
-        string sourceName = (encoding >> 1) == 0 ? targetName : readString(encoding >> 1);
-        file::copy({originPath, sourceName}, {targetPath, targetName});
-        uint32_t cksum = readChecksum();
-      }
-    }
-
-    uint32_t cksum = checksum.digest().hex();
-    if(read() != (uint8_t)(cksum >>  0)) return false;
-    if(read() != (uint8_t)(cksum >>  8)) return false;
-    if(read() != (uint8_t)(cksum >> 16)) return false;
-    if(read() != (uint8_t)(cksum >> 24)) return false;
-
-    fp.close();
-    return true;
-  }
-
-protected:
-  file fp;
-  Hash::CRC32 checksum;
-
-  //create() functions
-  auto ls(vector<string>& list, const string& path, const string& basepath) -> void {
-    auto paths = directory::folders(path);
-    for(auto& pathname : paths) {
-      list.append(string{path, pathname}.trimLeft(basepath, 1L));
-      ls(list, {path, pathname}, basepath);
-    }
-
-    auto files = directory::files(path);
-    for(auto& filename : files) {
-      list.append(string{path, filename}.trimLeft(basepath, 1L));
-    }
-  }
-
-  auto write(uint8_t data) -> void {
-    fp.write(data);
-    checksum.input(data);
-  }
-
-  auto writeNumber(uint64_t data) -> void {
-    while(true) {
-      uint64_t x = data & 0x7f;
-      data >>= 7;
-      if(data == 0) {
-        write(0x80 | x);
-        break;
-      }
-      write(x);
-      data--;
-    }
-  }
-
-  auto writeString(const string& text) -> void {
-    uint length = text.length();
-    for(uint n = 0; n < length; n++) write(text[n]);
-  }
-
-  auto writeChecksum(uint32_t cksum) -> void {
-    write(cksum >>  0);
-    write(cksum >>  8);
-    write(cksum >> 16);
-    write(cksum >> 24);
-  }
-
-  //apply() functions
-  auto read() -> uint8_t {
-    uint8_t data = fp.read();
-    checksum.input(data);
-    return data;
-  }
-
-  auto readNumber() -> uint64_t {
-    uint64_t data = 0, shift = 1;
-    while(true) {
-      uint8_t x = read();
-      data += (x & 0x7f) * shift;
-      if(x & 0x80) break;
-      shift <<= 7;
-      data += shift;
-    }
-    return data;
-  }
-
-  auto readString(uint length) -> string {
-    string text;
-    text.resize(length + 1);
-    char* p = text.get();
-    while(length--) *p++ = read();
-    return text;
-  }
-
-  auto readChecksum() -> uint32_t {
-    uint32_t checksum = 0;
-    checksum |= read() <<  0;
-    checksum |= read() <<  8;
-    checksum |= read() << 16;
-    checksum |= read() << 24;
-    return checksum;
-  }
-};
-
-}
diff --git a/nall/beat/patch.hpp b/nall/beat/patch.hpp
deleted file mode 100644
index 8b6279e0..00000000
--- a/nall/beat/patch.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-#pragma once
-
-#include <nall/file.hpp>
-#include <nall/filemap.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-struct bpspatch {
-  inline auto modify(const uint8_t* data, uint size) -> bool;
-  inline auto source(const uint8_t* data, uint size) -> void;
-  inline auto target(uint8_t* data, uint size) -> void;
-
-  inline auto modify(const string& filename) -> bool;
-  inline auto source(const string& filename) -> bool;
-  inline auto target(const string& filename) -> bool;
-
-  inline auto metadata() const -> string;
-  inline auto size() const -> uint;
-
-  enum result : uint {
-    unknown,
-    success,
-    patch_too_small,
-    patch_invalid_header,
-    source_too_small,
-    target_too_small,
-    source_checksum_invalid,
-    target_checksum_invalid,
-    patch_checksum_invalid,
-  };
-
-  inline auto apply() -> result;
-
-protected:
-  enum : uint { SourceRead, TargetRead, SourceCopy, TargetCopy };
-
-  filemap modifyFile;
-  const uint8_t* modifyData;
-  uint modifySize;
-
-  filemap sourceFile;
-  const uint8_t* sourceData;
-  uint sourceSize;
-
-  filemap targetFile;
-  uint8_t* targetData;
-  uint targetSize;
-
-  uint modifySourceSize;
-  uint modifyTargetSize;
-  uint modifyMarkupSize;
-  string metadataString;
-};
-
-auto bpspatch::modify(const uint8_t* data, uint size) -> bool {
-  if(size < 19) return false;
-  modifyData = data;
-  modifySize = size;
-
-  uint offset = 4;
-  auto decode = [&]() -> uint64_t {
-    uint64_t data = 0, shift = 1;
-    while(true) {
-      uint8_t x = modifyData[offset++];
-      data += (x & 0x7f) * shift;
-      if(x & 0x80) break;
-      shift <<= 7;
-      data += shift;
-    }
-    return data;
-  };
-
-  modifySourceSize = decode();
-  modifyTargetSize = decode();
-  modifyMarkupSize = decode();
-
-  char buffer[modifyMarkupSize + 1];
-  for(uint n = 0; n < modifyMarkupSize; n++) buffer[n] = modifyData[offset++];
-  buffer[modifyMarkupSize] = 0;
-  metadataString = (const char*)buffer;
-
-  return true;
-}
-
-auto bpspatch::source(const uint8_t* data, uint size) -> void {
-  sourceData = data;
-  sourceSize = size;
-}
-
-auto bpspatch::target(uint8_t* data, uint size) -> void {
-  targetData = data;
-  targetSize = size;
-}
-
-auto bpspatch::modify(const string& filename) -> bool {
-  if(modifyFile.open(filename, filemap::mode::read) == false) return false;
-  return modify(modifyFile.data(), modifyFile.size());
-}
-
-auto bpspatch::source(const string& filename) -> bool {
-  if(sourceFile.open(filename, filemap::mode::read) == false) return false;
-  source(sourceFile.data(), sourceFile.size());
-  return true;
-}
-
-auto bpspatch::target(const string& filename) -> bool {
-  file fp;
-  if(fp.open(filename, file::mode::write) == false) return false;
-  fp.truncate(modifyTargetSize);
-  fp.close();
-
-  if(targetFile.open(filename, filemap::mode::readwrite) == false) return false;
-  target(targetFile.data(), targetFile.size());
-  return true;
-}
-
-auto bpspatch::metadata() const -> string {
-  return metadataString;
-}
-
-auto bpspatch::size() const -> uint {
-  return modifyTargetSize;
-}
-
-auto bpspatch::apply() -> result {
-  if(modifySize < 19) return result::patch_too_small;
-
-  Hash::CRC32 modifyChecksum, targetChecksum;
-  uint modifyOffset = 0, sourceRelativeOffset = 0, targetRelativeOffset = 0, outputOffset = 0;
-
-  auto read = [&]() -> uint8_t {
-    uint8_t data = modifyData[modifyOffset++];
-    modifyChecksum.input(data);
-    return data;
-  };
-
-  auto decode = [&]() -> uint64_t {
-    uint64_t data = 0, shift = 1;
-    while(true) {
-      uint8_t x = read();
-      data += (x & 0x7f) * shift;
-      if(x & 0x80) break;
-      shift <<= 7;
-      data += shift;
-    }
-    return data;
-  };
-
-  auto write = [&](uint8_t data) {
-    targetData[outputOffset++] = data;
-    targetChecksum.input(data);
-  };
-
-  if(read() != 'B') return result::patch_invalid_header;
-  if(read() != 'P') return result::patch_invalid_header;
-  if(read() != 'S') return result::patch_invalid_header;
-  if(read() != '1') return result::patch_invalid_header;
-
-  modifySourceSize = decode();
-  modifyTargetSize = decode();
-  modifyMarkupSize = decode();
-  for(uint n = 0; n < modifyMarkupSize; n++) read();
-
-  if(modifySourceSize > sourceSize) return result::source_too_small;
-  if(modifyTargetSize > targetSize) return result::target_too_small;
-
-  while(modifyOffset < modifySize - 12) {
-    uint length = decode();
-    uint mode = length & 3;
-    length = (length >> 2) + 1;
-
-    switch(mode) {
-    case SourceRead:
-      while(length--) write(sourceData[outputOffset]);
-      break;
-    case TargetRead:
-      while(length--) write(read());
-      break;
-    case SourceCopy:
-    case TargetCopy:
-      int offset = decode();
-      bool negative = offset & 1;
-      offset >>= 1;
-      if(negative) offset = -offset;
-
-      if(mode == SourceCopy) {
-        sourceRelativeOffset += offset;
-        while(length--) write(sourceData[sourceRelativeOffset++]);
-      } else {
-        targetRelativeOffset += offset;
-        while(length--) write(targetData[targetRelativeOffset++]);
-      }
-      break;
-    }
-  }
-
-  uint32_t modifySourceChecksum = 0, modifyTargetChecksum = 0, modifyModifyChecksum = 0;
-  for(uint n = 0; n < 32; n += 8) modifySourceChecksum |= read() << n;
-  for(uint n = 0; n < 32; n += 8) modifyTargetChecksum |= read() << n;
-  uint32_t checksum = modifyChecksum.digest().hex();
-  for(uint n = 0; n < 32; n += 8) modifyModifyChecksum |= read() << n;
-
-  uint32_t sourceChecksum = Hash::CRC32(sourceData, modifySourceSize).digest().hex();
-
-  if(sourceChecksum != modifySourceChecksum) return result::source_checksum_invalid;
-  if(targetChecksum.digest().hex() != modifyTargetChecksum) return result::target_checksum_invalid;
-  if(checksum != modifyModifyChecksum) return result::patch_checksum_invalid;
-
-  return result::success;
-}
-
-}
diff --git a/nall/beat/single/apply.hpp b/nall/beat/single/apply.hpp
new file mode 100644
index 00000000..e3146971
--- /dev/null
+++ b/nall/beat/single/apply.hpp
@@ -0,0 +1,92 @@
+#pragma once
+
+namespace nall { namespace Beat { namespace Single {
+
+inline auto apply(
+  const uint8_t* sourceData, uint64_t sourceSize,
+  const uint8_t* beatData, uint64_t beatSize,
+  maybe<string&> manifest = {}, maybe<string&> result = {}
+) -> maybe<vector<uint8_t>> {
+  #define error(text) { if(result) *result = {"error: ", text}; return {}; }
+  #define warning(text) { if(result) *result = {"warning: ", text}; return targetData; }
+  #define success() { if(result) *result = ""; return targetData; }
+  if(beatSize < 19) error("beat size mismatch");
+
+  vector<uint8_t> targetData;
+
+  uint beatOffset = 0;
+  auto read = [&]() -> uint8_t {
+    return beatData[beatOffset++];
+  };
+  auto decode = [&]() -> uint64_t {
+    uint64_t data = 0, shift = 1;
+    while(true) {
+      uint8_t x = read();
+      data += (x & 0x7f) * shift;
+      if(x & 0x80) break;
+      shift <<= 7;
+      data += shift;
+    }
+    return data;
+  };
+
+  auto targetOffset = 0;
+  auto write = [&](uint8_t data) {
+    targetData.append(data);
+  };
+
+  if(read() != 'B') error("beat header invalid");
+  if(read() != 'P') error("beat header invalid");
+  if(read() != 'S') error("beat header invalid");
+  if(read() != '1') error("beat version mismatch");
+  if(decode() != sourceSize) error("source size mismatch");
+  uint targetSize = decode();
+  targetData.reserve(targetSize);
+  auto metadataSize = decode();
+  for(uint n : range(metadataSize)) {
+    auto data = read();
+    if(manifest) manifest->append((char)data);
+  }
+
+  enum : uint { SourceRead, TargetRead, SourceCopy, TargetCopy };
+
+  uint sourceRelativeOffset = 0, targetRelativeOffset = 0;
+  while(beatOffset < beatSize - 12) {
+    uint length = decode();
+    uint mode = length & 3;
+    length = (length >> 2) + 1;
+
+    if(mode == SourceRead) {
+      while(length--) write(sourceData[targetOffset]);
+    } else if(mode == TargetRead) {
+      while(length--) write(read());
+    } else {
+      int offset = decode();
+      offset = offset & 1 ? -(offset >> 1) : (offset >> 1);
+      if(mode == SourceCopy) {
+        sourceRelativeOffset += offset;
+        while(length--) write(sourceData[sourceRelativeOffset++]);
+      } else {
+        targetRelativeOffset += offset;
+        while(length--) write(targetData[targetRelativeOffset++]);
+      }
+    }
+  }
+
+  uint32_t sourceHash = 0, targetHash = 0, beatHash = 0;
+  for(uint shift : range(0, 32, 8)) sourceHash |= read() << shift;
+  for(uint shift : range(0, 32, 8)) targetHash |= read() << shift;
+  for(uint shift : range(0, 32, 8)) beatHash |= read() << shift;
+
+  if(targetOffset != targetSize) warning("target size mismatch");
+  if(sourceHash != Hash::CRC32(sourceData, sourceSize).value()) warning("source hash mismatch");
+  if(targetHash != Hash::CRC32(targetData).value()) warning("target hash mismatch");
+  if(beatHash != Hash::CRC32(beatData, beatSize - 4).value()) warning("beat hash mismatch");
+
+  success();
+  #undef error
+  #undef warning
+  #undef success
+}
+
+}}}
diff --git a/nall/beat/single/create.hpp b/nall/beat/single/create.hpp
new file mode 100644
index 00000000..224b5388
--- /dev/null
+++ b/nall/beat/single/create.hpp
@@ -0,0 +1,123 @@
+#pragma once
+
+#include <nall/encode/dictionary.hpp>
+
+namespace nall { namespace Beat { namespace Single {
+
+inline auto create(
+  const uint8_t* sourceData, uint64_t sourceSize,
+  const uint8_t* targetData, uint64_t targetSize,
+  const string& manifest = {}
+) -> maybe<vector<uint8_t>> {
+  vector<uint8_t> beatData;
+
+  auto write = [&](uint8_t data) {
+    beatData.append(data);
+  };
+
+  auto encode = [&](uint64_t data) {
+    while(true) {
+      uint64_t x = data & 0x7f;
+      data >>= 7;
+      if(data == 0) { write(0x80 | x); break; }
+      write(x);
+      data--;
+    }
+  };
+
+  write('B'), write('P'), write('S'), write('1');
+  encode(sourceSize), encode(targetSize), encode(manifest.size());
+  for(auto& byte : manifest) write(byte);
+
+  auto read = [&](const uint8_t* data, uint size, uint offset) -> uint {
+    if(offset + 3 >= size) return 0;
+    return data[offset + 0] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3] << 0;
+  };
+
+  Encode::Dictionary sourceDictionary(sourceData, sourceSize);
+  Encode::Dictionary targetDictionary(targetData, targetSize);
+  sourceDictionary.scan();
+  targetDictionary.scan();
+
+  enum : uint { SourceRead, TargetRead, SourceCopy, TargetCopy };
+  uint outputOffset = 0, sourceRelativeOffset = 0, targetRelativeOffset = 0;
+
+  uint targetReadLength = 0;
+  auto flush = [&] {
+    if(!targetReadLength) return;
+    encode(TargetRead | ((targetReadLength - 1) << 2));
+    uint offset = outputOffset - targetReadLength;
+    while(targetReadLength) write(targetData[offset++]), targetReadLength--;
+  };
+
+  uint longestSize = max(sourceSize, targetSize);
+  while(outputOffset < targetSize) {
+    uint mode = TargetRead, longestLength = 3, longestOffset = 0;
+    uint prefix = read(targetData, targetSize, outputOffset), lower, upper;
+
+    uint length = 0, offset = outputOffset;
+    while(offset < longestOffset) {
+      if(sourceData[offset] != targetData[offset]) break;
+      length++, offset++;
+    }
+    if(length > longestLength) {
+      mode = SourceRead, longestLength = length;
+    }
+
+    sourceDictionary.find(prefix, lower, upper);
+    for(uint index = lower; index <= upper; index++) {
+      uint length = 0, sourceOffset = sourceDictionary[index], targetOffset = outputOffset;
+      while(sourceOffset < sourceSize && targetOffset < targetSize) {
+        if(sourceData[sourceOffset++] != targetData[targetOffset++]) break;
+        length++;
+      }
+      if(length > longestLength) {
+        mode = SourceCopy, longestLength = length, longestOffset = sourceDictionary[index];
+      }
+    }
+
+    targetDictionary.find(prefix, lower, upper);
+    for(uint index = lower; index <= upper; index++) {
+      uint length = 0, sourceOffset = targetDictionary[index], targetOffset = outputOffset;
+      if(sourceOffset >= outputOffset) continue;
+      while(targetOffset < targetSize) {
+        if(targetData[sourceOffset++] != targetData[targetOffset++]) break;
+        length++;
+      }
+      if(length > longestLength) {
+        mode = TargetCopy, longestLength = length, longestOffset = targetDictionary[index];
+      }
+    }
+
+    if(mode == TargetRead) {
+      targetReadLength++;  //queue writes to group sequential commands
+      outputOffset++;
+    } else {
+      flush();
+      encode(mode | ((longestLength - 1) << 2));
+      if(mode == SourceCopy) {
+        int relativeOffset = longestOffset - sourceRelativeOffset;
+        sourceRelativeOffset = longestOffset + longestLength;
+        encode(relativeOffset < 0 | abs(relativeOffset) << 1);
+      }
+      if(mode == TargetCopy) {
+        int relativeOffset = longestOffset - targetRelativeOffset;
+        targetRelativeOffset = longestOffset + longestLength;
+        encode(relativeOffset < 0 | abs(relativeOffset) << 1);
+      }
+      outputOffset += longestLength;
+    }
+  }
+  flush();
+
+  auto sourceHash = Hash::CRC32(sourceData, sourceSize);
+  for(uint shift : range(0, 32, 8)) write(sourceHash.value() >> shift);
+  auto targetHash = Hash::CRC32(targetData, targetSize);
+  for(uint shift : range(0, 32, 8)) write(targetHash.value() >> shift);
+  auto beatHash = Hash::CRC32(beatData);
+  for(uint shift : range(0, 32, 8)) write(beatHash.value() >> shift);
+
+  return beatData;
+}
+
+}}}
diff --git a/nall/counting-sort.hpp b/nall/counting-sort.hpp
new file mode 100644
index 00000000..e4f7100e
--- /dev/null
+++ b/nall/counting-sort.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <nall/range.hpp>
+
+namespace nall {
+
+//counting sort by powers of two: used to implement radix sort
+template<uint Bits, uint Shift, typename T>
+auto counting_sort(T* output, const T* input, uint size) -> void {
+  static_assert(Bits >= 1 && Bits <= 20, "must be between 1 and 20 bits");
+  enum : uint { Base = 1 << Bits, Mask = Base - 1 };
+
+  uint64_t count[Base] = {}, last = 0;
+  for(uint n : range(size)) ++count[(input[n] >> Shift) & Mask];
+  for(uint n : range(Base)) last += count[n], count[n] = last - count[n];
+  for(uint n : range(size)) output[count[(input[n] >> Shift) & Mask]++] = input[n];
+}
+
+}
diff --git a/nall/decode/bwt.hpp b/nall/decode/bwt.hpp
new file mode 100644
index 00000000..76af8daa
--- /dev/null
+++ b/nall/decode/bwt.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+//burrows-wheeler transform
+
+#include <nall/suffix-array.hpp>
+
+namespace nall { namespace Decode {
+
+inline auto BWT(const void* data) -> vector<uint8_t> {
+  auto input = (const uint8_t*)data;
+  vector<uint8_t> output;
+
+  uint size = 0;
+  for(uint byte : range(8)) size |= *input++ << byte * 8;
+  output.resize(size);
+
+  uint I = 0;
+  for(uint byte : range(8)) I |= *input++ << byte * 8;
+
+  auto suffixes = new int[size];
+  suffix_array(suffixes, input, size);
+
+  auto L = input;
+  auto F = new uint8_t[size];
+  for(uint byte : range(size)) F[byte] = L[suffixes[byte]];
+
+  delete[] suffixes;
+
+  uint64_t K[256] = {};
+  auto C = new int[size];
+  for(uint i : range(size)) {
+    C[i] = K[L[i]];
+    K[L[i]]++;
+  }
+
+  int M[256];
+  memory::fill<int>(M, 256, -1);
+  for(uint i : range(size)) {
+    if(M[F[i]] == -1) M[F[i]] = i;
+  }
+
+  uint i = I;
+  for(uint j : reverse(range(size))) {
+    output[j] = L[i];
+    i = C[i] + M[L[i]];
+  }
+
+  return output;
+}
+
+template<typename T>
+inline auto BWT(const vector<T>& buffer) -> vector<uint8_t> {
+  return move(BWT(buffer.data()));
+}
+
+}}
diff --git a/nall/decode/huffman.hpp b/nall/decode/huffman.hpp
new file mode 100644
index 00000000..be89b9c6
--- /dev/null
+++ b/nall/decode/huffman.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+namespace nall { namespace Decode {
+
+inline auto Huffman(const void* data) -> vector<uint8_t> {
+  auto input = (const uint8_t*)data;
+  vector<uint8_t> output;
+
+  uint size = 0;
+  for(uint byte : range(8)) size |= *input++ << byte * 8;
+  output.reserve(size);
+
+  uint byte = 0, bits = 0;
+  auto read = [&]() -> bool {
+    if(bits == 0) bits = 8, byte = *input++;
+    return byte >> --bits & 1;
+  };
+
+  uint nodes[256][2] = {};
+  for(uint offset : range(256)) {
+    for(uint index : range(9)) nodes[offset][0] = nodes[offset][0] << 1 | read();
+    for(uint index : range(9)) nodes[offset][1] = nodes[offset][1] << 1 | read();
+  }
+
+  uint node = 511;
+  while(output.size() < size) {
+    node = nodes[node - 256][read()];
+    if(node < 256) {
+      output.append(node);
+      node = 511;
+    }
+  }
+
+  return output;
+}
+
+template<typename T>
+inline auto Huffman(const vector<T>& buffer) -> vector<uint8_t> {
+  return move(Huffman(buffer.data()));
+}
+
+}}
diff --git a/nall/decode/lzsa.hpp b/nall/decode/lzsa.hpp
new file mode 100644
index 00000000..cb29801c
--- /dev/null
+++ b/nall/decode/lzsa.hpp
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <nall/decode/huffman.hpp>
+
+namespace nall { namespace Decode {
+
+inline auto LZSA(const void* data) -> vector<uint8_t> {
+  vector<uint8_t> output;
+
+  auto input = (const uint8_t*)data;
+  uint index = 0;
+
+  uint size = 0;
+  for(uint byte : range(8)) size |= *input++ << byte * 8;
+  output.resize(size);
+
+  auto load = [&]() -> vector<uint8_t> {
+    uint size = 0;
+    for(uint byte : range(8)) size |= *input++ << byte * 8;
+    vector<uint8_t> buffer;
+    buffer.reserve(size);
+    while(size--) buffer.append(*input++);
+    return buffer;
+  };
+
+  auto flags = Decode::Huffman(load());
+  auto literals = Decode::Huffman(load());
+//auto literals = Decode::BWT(Decode::Huffman(load()));
+  auto lengths = Decode::Huffman(load());
+  auto offsets = Decode::Huffman(load());
+
+  auto flagData = flags.data();
+  uint byte = 0, bits = 0;
+  auto flagRead = [&]() -> bool {
+    if(bits == 0) bits = 8, byte = *flagData++;
+    return byte >> --bits & 1;
+  };
+
+  auto literalData = literals.data();
+  auto literalRead = [&]() -> uint8_t {
+    return *literalData++;
+  };
+
+  auto lengthData = lengths.data();
+  auto lengthRead = [&]() -> uint64_t {
+    uint byte = *lengthData++, bytes = 1;
+    while(!(byte & 1)) byte >>= 1, bytes++;
+    uint length = byte >> 1, shift = 8 - bytes;
+    while(--bytes) length |= *lengthData++ << shift, shift += 8;
+    return length;
+  };
+
+  auto offsetData = offsets.data();
+  auto offsetRead = [&]() -> uint {
+    uint offset = 0;
+    offset |= *offsetData++ <<  0; if(index < 1 <<  8) return offset;
+    offset |= *offsetData++ <<  8; if(index < 1 << 16) return offset;
+    offset |= *offsetData++ << 16; if(index < 1 << 24) return offset;
+    offset |= *offsetData++ << 24; return offset;
+  };
+
+  while(index < size) {
+    if(!flagRead()) {
+      output[index++] = literalRead();
+    } else {
+      uint length = lengthRead() + 6;
+      uint offset = index - offsetRead();
+      while(length--) output[index++] = output[offset++];
+    }
+  }
+
+  return output;
+}
+
+}}
diff --git a/nall/decode/lzss.hpp b/nall/decode/lzss.hpp
new file mode 100644
index 00000000..2345c366
--- /dev/null
+++ b/nall/decode/lzss.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+namespace nall { namespace Decode {
+
+inline auto LZSS(const void* data) -> vector<uint8_t> {
+  vector<uint8_t> output;
+
+  auto input = (const uint8_t*)data;
+  uint64_t size = 0;
+  for(uint byte : range(8)) size |= *input++ << byte * 8;
+  output.resize(size);
+  const uint windowBits = *input++;
+  const uint lengthBits = *input++;
+
+  const uint lengthExtends = 4 + (1 << lengthBits) - 1;
+  const uint windowMask = (1 << windowBits) - 1;
+
+  for(uint offset = 0, flags = 0, bit = 7; offset < size;) {
+    if(++bit == 8) bit = 0, flags = *input++;
+
+    if(flags & 1 << bit) {
+      uint encoding = 0;
+      encoding |= *input++ <<  0;
+      encoding |= *input++ <<  8;
+      encoding |= *input++ << 16;
+
+      uint length = 4 + (encoding >> windowBits);
+      uint window = 1 + (encoding & windowMask);
+      if(length == lengthExtends) length += *input++;
+
+      for(uint index : range(length)) {
+        if(offset + index >= size) break;
+        output[offset + index] = output[offset + index - window];
+      }
+      offset += length;
+    } else {
+      output[offset++] = *input++;
+    }
+  }
+
+  return output;
+}
+
+}}
diff --git a/nall/decode/mtf.hpp b/nall/decode/mtf.hpp
new file mode 100644
index 00000000..96643aab
--- /dev/null
+++ b/nall/decode/mtf.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+//move to front
+
+namespace nall { namespace Decode {
+
+inline auto MTF(const void* data, uint size) -> vector<uint8_t> {
+  auto input = (const uint8_t*)data;
+  vector<uint8_t> output;
+  output.resize(size);
+
+  uint8_t order[256];
+  for(uint n : range(256)) order[n] = n;
+
+  for(uint offset = 0; offset < size; offset++) {
+    auto data = input[offset];
+    for(uint index = 0; index < 256; index++) {
+      uint value = order[data];
+      if(value == index) {
+        output[offset] = value;
+        memory::move(&order[1], &order[0], index);
+        order[0] = index;
+        break;
+      }
+    }
+  }
+
+  return output;
+}
+
+}}
diff --git a/nall/decode/rle.hpp b/nall/decode/rle.hpp
index 78f0a23d..e19f0787 100644
--- a/nall/decode/rle.hpp
+++ b/nall/decode/rle.hpp
@@ -2,45 +2,46 @@
 
 namespace nall { namespace Decode {
 
-template<typename T> inline auto RLE(const uint8_t* data, uint remaining = ~0, uint minimum = 0) -> vector<T> {
-  if(!minimum) minimum = max(1, 4 / sizeof(T));
-  vector<T> result;
+template<uint S = 1, uint M = 4 / S>  //S = word size; M = match length
+inline auto RLE(const void* data, uint remaining = ~0) -> vector<uint8_t> {
+  vector<uint8_t> output;
+
+  auto input = (const uint8_t*)data;
 
   auto load = [&]() -> uint8_t {
     if(!remaining) return 0x00;
-    return --remaining, *data++;
+    return --remaining, *input++;
   };
 
   uint base = 0;
-  uint size = 0;
-  for(uint byte : range(sizeof(uint))) size |= load() << byte * 8;
-  size /= sizeof(T);
-  result.resize(size);
+  uint64_t size = 0;
+  for(uint byte : range(8)) size |= load() << byte * 8;
+  output.resize(size);
 
-  auto read = [&]() -> T {
-    T value = 0;
-    for(uint byte : range(sizeof(T))) value |= load() << byte * 8;
+  auto read = [&]() -> uint64_t {
+    uint64_t value = 0;
+    for(uint byte : range(S)) value |= load() << byte * 8;
     return value;
   };
 
-  auto write = [&](T value) -> void {
+  auto write = [&](uint64_t value) -> void {
     if(base >= size) return;
-    result[base++] = value;
+    for(uint byte : range(S)) output[base++] = value >> byte * 8;
   };
 
   while(base < size) {
-    auto byte = *data++;
+    auto byte = load();
     if(byte < 128) {
       byte++;
       while(byte--) write(read());
     } else {
       auto value = read();
-      byte = (byte & 127) + minimum;
+      byte = (byte & 127) + M;
       while(byte--) write(value);
     }
   }
 
-  return result;
+  return output;
 }
 
 }}
diff --git a/nall/directory.hpp b/nall/directory.hpp
index 3b202661..0fc631d8 100644
--- a/nall/directory.hpp
+++ b/nall/directory.hpp
@@ -3,7 +3,7 @@
 #include <nall/file.hpp>
 #include <nall/inode.hpp>
 #include <nall/intrinsics.hpp>
-#include <nall/sort.hpp>
+#include <nall/merge-sort.hpp>
 #include <nall/string.hpp>
 #include <nall/vector.hpp>
 
@@ -169,7 +169,7 @@ private:
     return list;
   }
 #else
-  inline auto directory_is_folder(DIR* dp, struct dirent* ep) -> bool {
+  inline auto directoryIsFolder(DIR* dp, struct dirent* ep) -> bool {
     if(ep->d_type == DT_DIR) return true;
     if(ep->d_type == DT_LNK || ep->d_type == DT_UNKNOWN) {
       //symbolic links must be resolved to determine type
@@ -218,7 +218,7 @@ private:
       while(ep = readdir(dp)) {
         if(!strcmp(ep->d_name, ".")) continue;
         if(!strcmp(ep->d_name, "..")) continue;
-        if(!directory_is_folder(dp, ep)) continue;
+        if(!directoryIsFolder(dp, ep)) continue;
         string name{ep->d_name};
         if(name.match(pattern)) list.append(std::move(name));
       }
@@ -239,7 +239,7 @@ private:
       while(ep = readdir(dp)) {
         if(!strcmp(ep->d_name, ".")) continue;
         if(!strcmp(ep->d_name, "..")) continue;
-        if(directory_is_folder(dp, ep)) continue;
+        if(directoryIsFolder(dp, ep)) continue;
         string name{ep->d_name};
         if(name.match(pattern)) list.append(std::move(name));
       }
diff --git a/nall/div-suf-sort.hpp b/nall/div-suf-sort.hpp
new file mode 100644
index 00000000..e715a825
--- /dev/null
+++ b/nall/div-suf-sort.hpp
@@ -0,0 +1,1440 @@
+#pragma once
+
+//divsufsort
+//author: Yuta Mori
+//license: MIT
+
+//class:   suffix sort (variant)
+//average: O(n)
+//worst:   O(n log n)
+//memory:  O(5n)
+//stable?: yes (all values unique)
+
+//omitted functionality:
+//* OpenMP support
+//* assertions
+//* non 8-bit values
+//* non 32-bit indexes
+
+#define ALPHABET_SIZE (256)
+#define BUCKET_A(_c0) bucket_A[(_c0)]
+#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)])
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)])
+#define BUCKET_A_SIZE (ALPHABET_SIZE)
+#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE)
+#define SS_INSERTIONSORT_THRESHOLD (8)
+#define SS_BLOCKSIZE (1024)  //0..32767
+#if SS_BLOCKSIZE == 0
+  #define SS_MISORT_STACKSIZE (64)
+#elif SS_BLOCKSIZE <= 4096
+  #define SS_MISORT_STACKSIZE (16)
+#else
+  #define SS_MISORT_STACKSIZE (24)
+#endif
+#define SS_SMERGE_STACKSIZE (32)
+#define TR_INSERTIONSORT_THRESHOLD (8)
+#define TR_STACKSIZE (64)
+#define STACK_PUSH(_a, _b, _c, _d) \
+  do { \
+    stack[ssize].a = (_a), stack[ssize].b = (_b), \
+    stack[ssize].c = (_c), stack[ssize++].d = (_d); \
+  } while(0)
+#define STACK_PUSH5(_a, _b, _c, _d, _e) \
+  do { \
+    stack[ssize].a = (_a), stack[ssize].b = (_b), \
+    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e); \
+  } while(0)
+#define STACK_POP(_a, _b, _c, _d) \
+  do { \
+    if(ssize == 0) return; \
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b, \
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d; \
+  } while(0)
+#define STACK_POP5(_a, _b, _c, _d, _e) \
+  do { \
+    if(ssize == 0) return; \
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b, \
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e; \
+  } while(0)
+
+namespace nall { namespace libdivsufsort {
+
+inline auto ilg16(int n) -> int {
+  static int lg_table[256] = {-1};
+  if(!lg_table[255]) for(uint n : range(1, 256)) lg_table[n] = floor(log2(n));
+  return (n & 0xff00) ?
+           8 + lg_table[(n >> 8) & 0xff]:
+           0 + lg_table[(n >> 0) & 0xff];
+}
+
+inline auto ilg32(int n) -> int {
+  static int lg_table[256] = {-1};
+  if(!lg_table[255]) for(uint n : range(1, 256)) lg_table[n] = floor(log2(n));
+  return (n & 0xffff0000) ?
+           ((n & 0xff000000) ?
+             24 + lg_table[(n >> 24) & 0xff] :
+             16 + lg_table[(n >> 16) & 0xff]):
+           ((n & 0x0000ff00) ?
+              8 + lg_table[(n >>  8) & 0xff] :
+              0 + lg_table[(n >>  0) & 0xff]);
+}
+
+// [[sssort.c]]
+
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
+
+inline auto ss_ilg(int n) -> int {
+  #if SS_BLOCKSIZE == 0
+  return ilg32(n);
+  #elif SS_BLOCKSIZE < 256
+  static int lg_table[256] = {-1};
+  if(!lg_table[255]) for(uint n : range(1, 256)) lg_table[n] = floor(log2(n));
+  return lg_table[n];
+  #else
+  return ilg16(n);
+  #endif
+}
+
+#endif
+
+#if SS_BLOCKSIZE != 0
+
+inline auto ss_isqrt(int x) -> int {
+  static int sqq_table[256] = {};
+  if(!sqq_table[255]) for(uint n : range(256)) sqq_table[n] = floor(sqrt(n) * 16.0);
+
+  int y, e;
+
+  if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; }
+  e = ilg32(x);
+
+  if(e >= 16) {
+    y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7);
+    if(e >= 24) { y = (y + 1 + x / y) >> 1; }
+    y = (y + 1 + x / y) >> 1;
+  } else if(e >= 8) {
+    y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1;
+  } else {
+    return sqq_table[x] >> 4;
+  }
+
+  return (x < (y * y)) ? y - 1 : y;
+}
+
+#endif
+
+//compare two suffixes
+inline auto ss_compare(const uint8_t* T, const int* p1, const int* p2, int depth) -> int {
+  const uint8_t *U1, *U2, *U1n, *U2n;
+  for(U1 = T + depth + *p1, U2 = T + depth + *p2, U1n = T + *(p1 + 1) + 2, U2n = T + *(p2 + 1) + 2;
+     (U1 < U1n) && (U2 < U2n) && (*U1 == *U2);
+     ++U1, ++U2
+  );
+  return U1 < U1n ? (U2 < U2n ? *U1 - *U2 : 1) : (U2 < U2n ? -1 : 0);
+}
+
+#if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1)
+
+inline auto ss_insertionsort(const uint8_t* T, const int* PA, int* first, int* last, int depth) -> void {
+  int *i, *j, t, r;
+
+  for(i = last - 2; first <= i; --i) {
+    for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) {
+      do { *(j - 1) = *j; } while((++j < last) && (*j < 0));
+      if(last <= j) break;
+    }
+    if(r == 0) *j = ~*j;
+    *(j - 1) = t;
+  }
+}
+
+#endif
+
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
+
+inline auto ss_fixdown(const uint8_t* Td, const int* PA, int* SA, int i, int size) -> void {
+  int j, k, v, c, d, e;
+
+  for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
+    d = Td[PA[SA[k = j++]]];
+    if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; }
+    if(d <= c) break;
+  }
+  SA[i] = v;
+}
+
+//simple top-down heapsort
+inline auto ss_heapsort(const uint8_t* Td, const int* PA, int* SA, int size) -> void {
+  int i, m, t;
+
+  m = size;
+  if((size % 2) == 0) {
+    m--;
+    if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) swap(SA[m], SA[m / 2]);
+  }
+
+  for(i = m / 2 - 1; 0 <= i; --i) ss_fixdown(Td, PA, SA, i, m);
+  if((size % 2) == 0) { swap(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); }
+  for(i = m - 1; 0 < i; --i) {
+    t = SA[0], SA[0] = SA[i];
+    ss_fixdown(Td, PA, SA, 0, i);
+    SA[i] = t;
+  }
+}
+
+//returns the median of three elements
+inline auto ss_median3(const uint8_t* Td, const int* PA, int* v1, int* v2, int* v3) -> int* {
+  if(Td[PA[*v1]] > Td[PA[*v2]]) swap(v1, v2);
+  if(Td[PA[*v2]] > Td[PA[*v3]]) return Td[PA[*v1]] > Td[PA[*v3]] ? v1 : v3;
+  return v2;
+}
+
+//returns the median of five elements
+inline auto ss_median5(const uint8_t* Td, const int* PA, int* v1, int* v2, int* v3, int* v4, int* v5) -> int* {
+  if(Td[PA[*v2]] > Td[PA[*v3]]) swap(v2, v3);
+  if(Td[PA[*v4]] > Td[PA[*v5]]) swap(v4, v5);
+  if(Td[PA[*v2]] > Td[PA[*v4]]) swap(v2, v4), swap(v3, v5);
+  if(Td[PA[*v1]] > Td[PA[*v3]]) swap(v1, v3);
+  if(Td[PA[*v1]] > Td[PA[*v4]]) swap(v1, v4), swap(v3, v5);
+  if(Td[PA[*v3]] > Td[PA[*v4]]) return v4;
+  return v3;
+}
+
+//returns the pivot element
+inline auto ss_pivot(const uint8_t* Td, const int* PA, int* first, int* last) -> int* {
+  int *middle, t;
+
+  t = last - first;
+  middle = first + t / 2;
+
+  if(t <= 512) {
+    if(t <= 32) {
+      return ss_median3(Td, PA, first, middle, last - 1);
+    } else {
+      t >>= 2;
+      return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1);
+    }
+  }
+  t >>= 3;
+  first  = ss_median3(Td, PA, first, first + t, first + (t << 1));
+  middle = ss_median3(Td, PA, middle - t, middle, middle + t);
+  last   = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1);
+  return   ss_median3(Td, PA, first, middle, last);
+}
+
+//binary partition for substrings
+inline auto ss_partition(const int* PA, int* first, int* last, int depth) -> int* {
+  int *a, *b, t;
+  for(a = first - 1, b = last;;) {
+    for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) *a = ~*a;
+    for(; (a < --b) && ((PA[*b] + depth) <  (PA[*b + 1] + 1)););
+    if(b <= a) break;
+    t = ~*b;
+    *b = *a;
+    *a = t;
+  }
+  if(first < a) *first = ~*first;
+  return a;
+}
+
+//multikey introsort for medium size groups
+inline auto ss_mintrosort(const uint8_t* T, const int* PA, int* first, int* last, int depth) -> void {
+  #define STACK_SIZE SS_MISORT_STACKSIZE
+  struct { int *a, *b, c, d; } stack[STACK_SIZE];
+  const uint8_t* Td;
+  int *a, *b, *c, *d, *e, *f;
+  int s, t, ssize, limit, v, x = 0;
+
+  for(ssize = 0, limit = ss_ilg(last - first);;) {
+    if((last - first) <= SS_INSERTIONSORT_THRESHOLD) {
+      #if 1 < SS_INSERTIONSORT_THRESHOLD
+      if(1 < (last - first)) ss_insertionsort(T, PA, first, last, depth);
+      #endif
+      STACK_POP(first, last, depth, limit);
+      continue;
+    }
+
+    Td = T + depth;
+    if(limit-- == 0) ss_heapsort(Td, PA, first, last - first);
+    if(limit < 0) {
+      for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) {
+        if((x = Td[PA[*a]]) != v) {
+          if(1 < (a - first)) break;
+          v = x;
+          first = a;
+        }
+      }
+      if(Td[PA[*first] - 1] < v) {
+        first = ss_partition(PA, first, a, depth);
+      }
+      if((a - first) <= (last - a)) {
+        if(1 < (a - first)) {
+          STACK_PUSH(a, last, depth, -1);
+          last = a, depth += 1, limit = ss_ilg(a - first);
+        } else {
+          first = a, limit = -1;
+        }
+      } else {
+        if(1 < (last - a)) {
+          STACK_PUSH(first, a, depth + 1, ss_ilg(a - first));
+          first = a, limit = -1;
+        } else {
+          last = a, depth += 1, limit = ss_ilg(a - first);
+        }
+      }
+      continue;
+    }
+
+    //choose pivot
+    a = ss_pivot(Td, PA, first, last);
+    v = Td[PA[*a]];
+    swap(*first, *a);
+
+    //partition
+    for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v););
+    if(((a = b) < last) && (x < v)) {
+      for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) {
+        if(x == v) { swap(*b, *a); ++a; }
+      }
+    }
+    for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v););
+    if((b < (d = c)) && (x > v)) {
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
+        if(x == v) { swap(*c, *d); --d; }
+      }
+    }
+    for(; b < c;) {
+      swap(*b, *c);
+      for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) {
+        if(x == v) { swap(*b, *a); ++a; }
+      }
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
+        if(x == v) { swap(*c, *d); --d; }
+      }
+    }
+
+    if(a <= d) {
+      c = b - 1;
+
+      if((s = a - first) > (t = b - a)) s = t;
+      for(e = first, f = b - s; 0 < s; --s, ++e, ++f) swap(*e, *f);
+      if((s = d - c) > (t = last - d - 1)) s = t;
+      for(e = b, f = last - s; 0 < s; --s, ++e, ++f) swap(*e, *f);
+
+      a = first + (b - a), c = last - (d - c);
+      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);
+
+      if((a - first) <= (last - c)) {
+        if((last - c) <= (c - b)) {
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          STACK_PUSH(c, last, depth, limit);
+          last = a;
+        } else if((a - first) <= (c - b)) {
+          STACK_PUSH(c, last, depth, limit);
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          last = a;
+        } else {
+          STACK_PUSH(c, last, depth, limit);
+          STACK_PUSH(first, a, depth, limit);
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
+        }
+      } else {
+        if((a - first) <= (c - b)) {
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          STACK_PUSH(first, a, depth, limit);
+          first = c;
+        } else if((last - c) <= (c - b)) {
+          STACK_PUSH(first, a, depth, limit);
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          first = c;
+        } else {
+          STACK_PUSH(first, a, depth, limit);
+          STACK_PUSH(c, last, depth, limit);
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
+        }
+      }
+    } else {
+      limit += 1;
+      if(Td[PA[*first] - 1] < v) {
+        first = ss_partition(PA, first, last, depth);
+        limit = ss_ilg(last - first);
+      }
+      depth += 1;
+    }
+  }
+  #undef STACK_SIZE
+}
+
+#endif
+
+#if SS_BLOCKSIZE != 0
+
+inline auto ss_blockswap(int* a, int* b, int n) -> void {
+  int t;
+  for(; 0 < n; --n, ++a, ++b) {
+    t = *a, *a = *b, *b = t;
+  }
+}
+
+inline auto ss_rotate(int* first, int* middle, int* last) -> void {
+  int *a, *b, t, l, r;
+  l = middle - first, r = last - middle;
+  for(; (0 < l) && (0 < r);) {
+    if(l == r) { ss_blockswap(first, middle, l); break; }
+    if(l < r) {
+      a = last - 1, b = middle - 1;
+      t = *a;
+      do {
+        *a-- = *b, *b-- = *a;
+        if(b < first) {
+          *a = t;
+          last = a;
+          if((r -= l + 1) <= l) break;
+          a -= 1, b = middle - 1;
+          t = *a;
+        }
+      } while(1);
+    } else {
+      a = first, b = middle;
+      t = *a;
+      do {
+        *a++ = *b, *b++ = *a;
+        if(last <= b) {
+          *a = t;
+          first = a + 1;
+          if((l -= r + 1) <= r) break;
+          a += 1, b = middle;
+          t = *a;
+        }
+      } while(1);
+    }
+  }
+}
+
+inline auto ss_inplacemerge(
+  const uint8_t* T, const int* PA, int* first, int* middle, int* last, int depth
+) -> void {
+  const int* p;
+  int *a, *b, len, half, q, r, x;
+
+  for(;;) {
+    if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); }
+    else                { x = 0; p = PA +  *(last - 1); }
+    for(a = first, len = middle - first, half = len >> 1, r = -1; 0 < len; len = half, half >>= 1) {
+      b = a + half;
+      q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth);
+      if(q < 0) {
+        a = b + 1;
+        half -= (len & 1) ^ 1;
+      } else {
+        r = q;
+      }
+    }
+    if(a < middle) {
+      if(r == 0) *a = ~*a;
+      ss_rotate(a, middle, last);
+      last -= middle - a;
+      middle = a;
+      if(first == middle) break;
+    }
+    --last;
+    if(x != 0) { while(*--last < 0); }
+    if(middle == last) break;
+  }
+}
+
+//merge-forward with internal buffer
+inline auto ss_mergeforward(
+  const uint8_t* T, const int* PA, int* first, int* middle, int* last, int* buf, int depth
+) -> void {
+  int *a, *b, *c, *bufend, t, r;
+
+  bufend = buf + (middle - first) - 1;
+  ss_blockswap(buf, first, middle - first);
+
+  for(t = *(a = first), b = buf, c = middle;;) {
+    r = ss_compare(T, PA + *b, PA + *c, depth);
+    if(r < 0) {
+      do {
+        *a++ = *b;
+        if(bufend <= b) { *bufend = t; return; }
+        *b++ = *a;
+      } while(*b < 0);
+    } else if(r > 0) {
+      do {
+        *a++ = *c, *c++ = *a;
+        if(last <= c) {
+          while(b < bufend) { *a++ = *b, *b++ = *a; }
+          *a = *b, *b = t;
+          return;
+        }
+      } while(*c < 0);
+    } else {
+      *c = ~*c;
+      do {
+        *a++ = *b;
+        if(bufend <= b) { *bufend = t; return; }
+        *b++ = *a;
+      } while(*b < 0);
+
+      do {
+        *a++ = *c, *c++ = *a;
+        if(last <= c) {
+          while(b < bufend) *a++ = *b, *b++ = *a;
+          *a = *b, *b = t;
+          return;
+        }
+      } while(*c < 0);
+    }
+  }
+}
+
+//merge-backward with internal buffer
+inline auto ss_mergebackward(
+  const uint8_t* T, const int* PA, int* first, int* middle, int* last, int* buf, int depth
+) -> void {
+  const int *p1, *p2;
+  int *a, *b, *c, *bufend, t, r, x;
+
+  bufend = buf + (last - middle - 1);
+  ss_blockswap(buf, middle, last - middle);
+
+  x = 0;
+  if(*bufend < 0)       { p1 = PA + ~*bufend; x |= 1; }
+  else                  { p1 = PA +  *bufend; }
+  if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; }
+  else                  { p2 = PA +  *(middle - 1); }
+  for(t = *(a = last - 1), b = bufend, c = middle - 1;;) {
+    r = ss_compare(T, p1, p2, depth);
+    if(0 < r) {
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
+      *a-- = *b;
+      if(b <= buf) { *buf = t; break; }
+      *b-- = *a;
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
+      else       { p1 = PA +  *b; }
+    } else if(r < 0) {
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
+      *a-- = *c, *c-- = *a;
+      if(c < first) {
+        while(buf < b) *a-- = *b, *b-- = *a;
+        *a = *b, *b = t;
+        break;
+      }
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
+      else       { p2 = PA +  *c; }
+    } else {
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
+      *a-- = ~*b;
+      if(b <= buf) { *buf = t; break; }
+      *b-- = *a;
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
+      *a-- = *c, *c-- = *a;
+      if(c < first) {
+        while(buf < b) *a-- = *b, *b-- = *a;
+        *a = *b, *b = t;
+        break;
+      }
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
+      else       { p1 = PA +  *b; }
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
+      else       { p2 = PA +  *c; }
+    }
+  }
+}
+
+//D&C based merge
+inline auto ss_swapmerge(
+  const uint8_t* T, const int* PA, int* first, int* middle, int* last, int* buf, int bufsize, int depth
+) -> void {
+  #define STACK_SIZE SS_SMERGE_STACKSIZE
+  #define GETIDX(a) ((0 <= (a)) ? (a) : (~(a)))
+  #define MERGE_CHECK(a, b, c) \
+    do { \
+      if(((c) & 1) || (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) { \
+        *(a) = ~*(a); \
+      } \
+      if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) { \
+        *(b) = ~*(b); \
+      } \
+    } while(0)
+  struct { int *a, *b, *c, d; } stack[STACK_SIZE];
+  int *l, *r, *lm, *rm;
+  int m, len, half, ssize, check, next;
+
+  for(check = 0, ssize = 0;;) {
+    if((last - middle) <= bufsize) {
+      if((first < middle) && (middle < last)) {
+        ss_mergebackward(T, PA, first, middle, last, buf, depth);
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+      continue;
+    }
+
+    if((middle - first) <= bufsize) {
+      if(first < middle) {
+        ss_mergeforward(T, PA, first, middle, last, buf, depth);
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+      continue;
+    }
+
+    for(m = 0, len = min(middle - first, last - middle), half = len >> 1; 0 < len; len = half, half >>= 1) {
+      if(ss_compare(T, PA + GETIDX(*(middle + m + half)),
+                       PA + GETIDX(*(middle - m - half - 1)), depth) < 0
+      ) {
+        m += half + 1;
+        half -= (len & 1) ^ 1;
+      }
+    }
+
+    if(0 < m) {
+      lm = middle - m, rm = middle + m;
+      ss_blockswap(lm, middle, m);
+      l = r = middle, next = 0;
+      if(rm < last) {
+        if(*rm < 0) {
+          *rm = ~*rm;
+          if(first < lm) { for(; *--l < 0;); next |= 4; }
+          next |= 1;
+        } else if(first < lm) {
+          for(; *r < 0; ++r);
+          next |= 2;
+        }
+      }
+
+      if((l - first) <= (last - r)) {
+        STACK_PUSH(r, rm, last, (next & 3) | (check & 4));
+        middle = lm, last = l, check = (check & 3) | (next & 4);
+      } else {
+        if((next & 2) && (r == middle)) next ^= 6;
+        STACK_PUSH(first, lm, l, (check & 3) | (next & 4));
+        first = r, middle = rm, check = (next & 3) | (check & 4);
+      }
+    } else {
+      if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) {
+        *middle = ~*middle;
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+    }
+  }
+
+  #undef STACK_SIZE
+  #undef GETIDX
+  #undef MERGE_CHECK
+}
+
+#endif
+
+//substring sort
+inline auto sssort(
+  const uint8_t* T, const int* PA, int* first, int* last, int* buf, int bufsize, int depth, int n, int lastsuffix
+) -> void {
+  int* a;
+  #if SS_BLOCKSIZE != 0
+  int *b, *middle, *curbuf;
+  int j, k, curbufsize, limit;
+  #endif
+  int i;
+
+  if(lastsuffix != 0) ++first;
+
+  #if SS_BLOCKSIZE == 0
+  ss_mintrosort(T, PA, first, last, depth);
+  #else
+  if((bufsize < SS_BLOCKSIZE) &&
+     (bufsize < (last - first)) &&
+     (bufsize < (limit = ss_isqrt(last - first)))
+  ) {
+    if(SS_BLOCKSIZE < limit) limit = SS_BLOCKSIZE;
+    buf = middle = last - limit, bufsize = limit;
+  } else {
+    middle = last, limit = 0;
+  }
+  for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) {
+    #if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+    ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth);
+    #elif 1 < SS_BLOCKSIZE
+    ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth);
+    #endif
+    curbufsize = last - (a + SS_BLOCKSIZE);
+    curbuf = a + SS_BLOCKSIZE;
+    if(curbufsize <= bufsize) curbufsize = bufsize, curbuf = buf;
+    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) {
+      ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth);
+    }
+  }
+  #if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+  ss_mintrosort(T, PA, a, middle, depth);
+  #elif 1 < SS_BLOCKSIZE
+  ss_insertionsort(T, PA, a, middle, depth);
+  #endif
+  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) {
+    if(i & 1) {
+      ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth);
+      a -= k;
+    }
+  }
+  if(limit != 0) {
+    #if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+    ss_mintrosort(T, PA, middle, last, depth);
+    #elif 1 < SS_BLOCKSIZE
+    ss_insertionsort(T, PA, middle, last, depth);
+    #endif
+    ss_inplacemerge(T, PA, first, middle, last, depth);
+  }
+  #endif
+
+  if(lastsuffix != 0) {
+    //insert last type B* suffix
+    int PAi[2];
+    PAi[0] = PA[*(first - 1)];
+    PAi[1] = n - 2;
+    for(a = first, i = *(first - 1); (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth))); ++a) {
+      *(a - 1) = *a;
+    }
+    *(a - 1) = i;
+  }
+}
+
+// [[trsort.c]]
+
+inline auto tr_ilg(int n) -> int {
+  return ilg32(n);
+}
+
+//simple insertionsort for small size groups
+inline auto tr_insertionsort(const int* ISAd, int* first, int* last) -> void {
+  int *a, *b;
+  int t, r;
+
+  for(a = first + 1; a < last; ++a) {
+    for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) {
+      do { *(b + 1) = *b; } while((first <= --b) && (*b < 0));
+      if(b < first) { break; }
+    }
+    if(r == 0) { *b = ~*b; }
+    *(b + 1) = t;
+  }
+}
+
+inline auto tr_fixdown(const int* ISAd, int* SA, int i, int size) -> void {
+  int j, k, v, c, d, e;
+
+  for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
+    d = ISAd[SA[k = j++]];
+    if(d < (e = ISAd[SA[j]])) { k = j; d = e; }
+    if(d <= c) { break; }
+  }
+  SA[i] = v;
+}
+
+//simple top-down heapsort
+inline auto tr_heapsort(const int* ISAd, int* SA, int size) -> void {
+  int i, m, t;
+
+  m = size;
+  if((size % 2) == 0) {
+    m--;
+    if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { swap(SA[m], SA[m / 2]); }
+  }
+
+  for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); }
+  if((size % 2) == 0) { swap(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); }
+  for(i = m - 1; 0 < i; --i) {
+    t = SA[0], SA[0] = SA[i];
+    tr_fixdown(ISAd, SA, 0, i);
+    SA[i] = t;
+  }
+}
+
+//returns the median of three elements
+inline auto tr_median3(const int* ISAd, int* v1, int* v2, int* v3) -> int* {
+  if(ISAd[*v1] > ISAd[*v2]) swap(v1, v2);
+  if(ISAd[*v2] > ISAd[*v3]) return ISAd[*v1] > ISAd[*v3] ? v1 : v3;
+  return v2;
+}
+
+//returns the median of five elements
+inline auto tr_median5(const int* ISAd, int* v1, int* v2, int* v3, int* v4, int* v5) -> int* {
+  if(ISAd[*v2] > ISAd[*v3]) swap(v2, v3);
+  if(ISAd[*v4] > ISAd[*v5]) swap(v4, v5);
+  if(ISAd[*v2] > ISAd[*v4]) swap(v2, v4), swap(v3, v5);
+  if(ISAd[*v1] > ISAd[*v3]) swap(v1, v3);
+  if(ISAd[*v1] > ISAd[*v4]) swap(v1, v4), swap(v3, v5);
+  if(ISAd[*v3] > ISAd[*v4]) return v4;
+  return v3;
+}
+
+//returns the pivot element
+inline auto tr_pivot(const int* ISAd, int* first, int* last) -> int* {
+  int* middle;
+  int t;
+
+  t = last - first;
+  middle = first + t / 2;
+
+  if(t <= 512) {
+    if(t <= 32) {
+      return tr_median3(ISAd, first, middle, last - 1);
+    } else {
+      t >>= 2;
+      return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1);
+    }
+  }
+  t >>= 3;
+  first  = tr_median3(ISAd, first, first + t, first + (t << 1));
+  middle = tr_median3(ISAd, middle - t, middle, middle + t);
+  last   = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1);
+  return   tr_median3(ISAd, first, middle, last);
+}
+
+struct trbudget_t {
+  int chance;
+  int remain;
+  int incval;
+  int count;
+};
+
+inline auto trbudget_init(trbudget_t* budget, int chance, int incval) -> void {
+  budget->chance = chance;
+  budget->remain = budget->incval = incval;
+}
+
+inline auto trbudget_check(trbudget_t* budget, int size) -> int {
+  if(size <= budget->remain) { budget->remain -= size; return 1; }
+  if(budget->chance == 0) { budget->count += size; return 0; }
+  budget->remain += budget->incval - size;
+  budget->chance -= 1;
+  return 1;
+}
+
+inline auto tr_partition(const int* ISAd, int* first, int* middle, int* last, int** pa, int** pb, int v) -> void {
+  int *a, *b, *c, *d, *e, *f;
+  int t, s;
+  int x = 0;
+
+  for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v););
+  if(((a = b) < last) && (x < v)) {
+    for(; (++b < last) && ((x = ISAd[*b]) <= v);) {
+      if(x == v) { swap(*b, *a); ++a; }
+    }
+  }
+  for(c = last; (b < --c) && ((x = ISAd[*c]) == v););
+  if((b < (d = c)) && (x > v)) {
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
+      if(x == v) { swap(*c, *d); --d; }
+    }
+  }
+  for(; b < c;) {
+    swap(*b, *c);
+    for(; (++b < c) && ((x = ISAd[*b]) <= v);) {
+      if(x == v) { swap(*b, *a); ++a; }
+    }
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
+      if(x == v) { swap(*c, *d); --d; }
+    }
+  }
+
+  if(a <= d) {
+    c = b - 1;
+    if((s = a - first) > (t = b - a)) { s = t; }
+    for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { swap(*e, *f); }
+    if((s = d - c) > (t = last - d - 1)) { s = t; }
+    for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { swap(*e, *f); }
+    first += (b - a), last -= (d - c);
+  }
+  *pa = first, *pb = last;
+}
+
+//sort suffixes of middle partition by using sorted order of suffixes of left and right partition
+inline auto tr_copy(int* ISA, int* SA, int* first, int* a, int* b, int* last, int depth) -> void {
+  int *c, *d, *e;
+  int s, v;
+
+  v = b - SA - 1;
+  for(c = first, d = a - 1; c <= d; ++c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *++d = s;
+      ISA[s] = d - SA;
+    }
+  }
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *--d = s;
+      ISA[s] = d - SA;
+    }
+  }
+}
+
+inline auto tr_partialcopy(int* ISA, int* SA, int* first, int* a, int* b, int* last, int depth) -> void {
+  int *c, *d, *e;
+  int s, v;
+  int rank, lastrank, newrank = -1;
+
+  v = b - SA - 1;
+  lastrank = -1;
+  for(c = first, d = a - 1; c <= d; ++c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *++d = s;
+      rank = ISA[s + depth];
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
+      ISA[s] = newrank;
+    }
+  }
+
+  lastrank = -1;
+  for(e = d; first <= e; --e) {
+    rank = ISA[*e];
+    if(lastrank != rank) { lastrank = rank; newrank = e - SA; }
+    if(newrank != rank) { ISA[*e] = newrank; }
+  }
+
+  lastrank = -1;
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *--d = s;
+      rank = ISA[s + depth];
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
+      ISA[s] = newrank;
+    }
+  }
+}
+
+inline auto tr_introsort(int* ISA, const int* ISAd, int* SA, int* first, int* last, trbudget_t* budget) -> void {
+  struct { const int *a; int *b, *c; int d, e; } stack[TR_STACKSIZE];
+  int *a, *b, *c;
+  int t;
+  int v, x = 0;
+  int incr = ISAd - ISA;
+  int limit, next;
+  int ssize, trlink = -1;
+
+  for(ssize = 0, limit = tr_ilg(last - first);;) {
+    if(limit < 0) {
+      if(limit == -1) {
+        //tandem repeat partition
+        tr_partition(ISAd - incr, first, first, last, &a, &b, last - SA - 1);
+
+        //update ranks
+        if(a < last) {
+          for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
+        }
+        if(b < last) {
+          for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; }
+        }
+
+        //push
+        if(1 < (b - a)) {
+          STACK_PUSH5(nullptr, a, b, 0, 0);
+          STACK_PUSH5(ISAd - incr, first, last, -2, trlink);
+          trlink = ssize - 2;
+        }
+        if((a - first) <= (last - b)) {
+          if(1 < (a - first)) {
+            STACK_PUSH5(ISAd, b, last, tr_ilg(last - b), trlink);
+            last = a, limit = tr_ilg(a - first);
+          } else if(1 < (last - b)) {
+            first = b, limit = tr_ilg(last - b);
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        } else {
+          if(1 < (last - b)) {
+            STACK_PUSH5(ISAd, first, a, tr_ilg(a - first), trlink);
+            first = b, limit = tr_ilg(last - b);
+          } else if(1 < (a - first)) {
+            last = a, limit = tr_ilg(a - first);
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        }
+      } else if(limit == -2) {
+        //tandem repeat copy
+        a = stack[--ssize].b, b = stack[ssize].c;
+        if(stack[ssize].d == 0) {
+          tr_copy(ISA, SA, first, a, b, last, ISAd - ISA);
+        } else {
+          if(0 <= trlink) { stack[trlink].d = -1; }
+          tr_partialcopy(ISA, SA, first, a, b, last, ISAd - ISA);
+        }
+        STACK_POP5(ISAd, first, last, limit, trlink);
+      } else {
+        //sorted partition
+        if(0 <= *first) {
+          a = first;
+          do { ISA[*a] = a - SA; } while((++a < last) && (0 <= *a));
+          first = a;
+        }
+        if(first < last) {
+          a = first; do { *a = ~*a; } while(*++a < 0);
+          next = (ISA[*a] != ISAd[*a]) ? tr_ilg(a - first + 1) : -1;
+          if(++a < last) { for(b = first, v = a - SA - 1; b < a; ++b) { ISA[*b] = v; } }
+
+          //push
+          if(trbudget_check(budget, a - first)) {
+            if((a - first) <= (last - a)) {
+              STACK_PUSH5(ISAd, a, last, -3, trlink);
+              ISAd += incr, last = a, limit = next;
+            } else {
+              if(1 < (last - a)) {
+                STACK_PUSH5(ISAd + incr, first, a, next, trlink);
+                first = a, limit = -3;
+              } else {
+                ISAd += incr, last = a, limit = next;
+              }
+            }
+          } else {
+            if(0 <= trlink) { stack[trlink].d = -1; }
+            if(1 < (last - a)) {
+              first = a, limit = -3;
+            } else {
+              STACK_POP5(ISAd, first, last, limit, trlink);
+            }
+          }
+        } else {
+          STACK_POP5(ISAd, first, last, limit, trlink);
+        }
+      }
+      continue;
+    }
+
+    if((last - first) <= TR_INSERTIONSORT_THRESHOLD) {
+      tr_insertionsort(ISAd, first, last);
+      limit = -3;
+      continue;
+    }
+
+    if(limit-- == 0) {
+      tr_heapsort(ISAd, first, last - first);
+      for(a = last - 1; first < a; a = b) {
+        for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; }
+      }
+      limit = -3;
+      continue;
+    }
+
+    //choose pivot
+    a = tr_pivot(ISAd, first, last);
+    swap(*first, *a);
+    v = ISAd[*first];
+
+    //partition
+    tr_partition(ISAd, first, first + 1, last, &a, &b, v);
+    if((last - first) != (b - a)) {
+      next = (ISA[*a] != v) ? tr_ilg(b - a) : -1;
+
+      //update ranks
+      for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
+      if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } }
+
+      //push
+      if((1 < (b - a)) && (trbudget_check(budget, b - a))) {
+        if((a - first) <= (last - b)) {
+          if((last - b) <= (b - a)) {
+            if(1 < (a - first)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              last = a;
+            } else if(1 < (last - b)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              first = b;
+            } else {
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else if((a - first) <= (b - a)) {
+            if(1 < (a - first)) {
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              last = a;
+            } else {
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else {
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            ISAd += incr, first = a, last = b, limit = next;
+          }
+        } else {
+          if((a - first) <= (b - a)) {
+            if(1 < (last - b)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              first = b;
+            } else if(1 < (a - first)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              last = a;
+            } else {
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else if((last - b) <= (b - a)) {
+            if(1 < (last - b)) {
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              first = b;
+            } else {
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else {
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            ISAd += incr, first = a, last = b, limit = next;
+          }
+        }
+      } else {
+        if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; }
+        if((a - first) <= (last - b)) {
+          if(1 < (a - first)) {
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            last = a;
+          } else if(1 < (last - b)) {
+            first = b;
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        } else {
+          if(1 < (last - b)) {
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            first = b;
+          } else if(1 < (a - first)) {
+            last = a;
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        }
+      }
+    } else {
+      if(trbudget_check(budget, last - first)) {
+        limit = tr_ilg(last - first), ISAd += incr;
+      } else {
+        if(0 <= trlink) { stack[trlink].d = -1; }
+        STACK_POP5(ISAd, first, last, limit, trlink);
+      }
+    }
+  }
+}
+
+//tandem repeat sort
+inline auto trsort(int* ISA, int* SA, int n, int depth) -> void {
+  int *ISAd;
+  int *first, *last;
+  trbudget_t budget;
+  int t, skip, unsorted;
+
+  trbudget_init(&budget, tr_ilg(n) * 2 / 3, n);
+  for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) {
+    first = SA;
+    skip = 0;
+    unsorted = 0;
+    do {
+      if((t = *first) < 0) { first -= t; skip += t; }
+      else {
+        if(skip != 0) { *(first + skip) = skip; skip = 0; }
+        last = SA + ISA[t] + 1;
+        if(1 < (last - first)) {
+          budget.count = 0;
+          tr_introsort(ISA, ISAd, SA, first, last, &budget);
+          if(budget.count != 0) { unsorted += budget.count; }
+          else { skip = first - last; }
+        } else if((last - first) == 1) {
+          skip = -1;
+        }
+        first = last;
+      }
+    } while(first < (SA + n));
+    if(skip != 0) { *(first + skip) = skip; }
+    if(unsorted == 0) break;
+  }
+}
+
+// [[divsufsort.c]]
+
+inline auto sort_typeBstar(const uint8_t* T, int* SA, int* bucket_A, int* bucket_B, int n) -> int {
+  int *PAb, *ISAb, *buf;
+  int i, j, k, t, m, bufsize;
+  int c0, c1;
+
+  //initialize bucket arrays
+  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; }
+  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; }
+
+  //count the number of occurrences of the first one or two characters of each type A, B, and B* suffix
+  //moreover, store the beginning position of all type b* suffixes into the array SA
+  for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) {
+    //type A suffix
+    do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1));
+    if(0 <= i) {
+      //type B* suffix
+      ++BUCKET_BSTAR(c0, c1);
+      SA[--m] = i;
+      //type B suffix
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {
+        ++BUCKET_B(c0, c1);
+      }
+    }
+  }
+  m = n - m;
+
+  //note: a type B* suffix is lexicographically smaller than a type B suffix that begins with the same first two characters
+
+  //calculate the index of start/end point of each bucket
+  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) {
+    t = i + BUCKET_A(c0);
+    BUCKET_A(c0) = i + j;  //start point
+    i = t + BUCKET_B(c0, c0);
+    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) {
+      j += BUCKET_BSTAR(c0, c1);
+      BUCKET_BSTAR(c0, c1) = j;  //end point
+      i += BUCKET_B(c0, c1);
+    }
+  }
+
+  if(0 < m) {
+    //sort the type B* suffixes by their first two characters
+    PAb = SA + n - m; ISAb = SA + m;
+    for(int i = m - 2; 0 <= i; --i) {
+      t = PAb[i], c0 = T[t], c1 = T[t + 1];
+      SA[--BUCKET_BSTAR(c0, c1)] = i;
+    }
+    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1];
+    SA[--BUCKET_BSTAR(c0, c1)] = m - 1;
+
+    //sort the type B* substrings using sssort
+    buf = SA + m, bufsize = n - (2 * m);
+    for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
+        i = BUCKET_BSTAR(c0, c1);
+        if(1 < (j - i)) {
+          sssort(T, PAb, SA + i, SA + j, buf, bufsize, 2, n, *(SA + i) == (m - 1));
+        }
+      }
+    }
+
+    //compare ranks of type B* substrings
+    for(i = m - 1; 0 <= i; --i) {
+      if(0 <= SA[i]) {
+        j = i;
+        do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i]));
+        SA[i + 1] = i - j;
+        if(i <= 0) break;
+      }
+      j = i;
+      do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0);
+      ISAb[SA[i]] = j;
+    }
+
+    //construct the inverse suffix array of type B* suffixes using trsort
+    trsort(ISAb, SA, m, 1);
+
+    //set the sorted order of type B* suffixes
+    for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) {
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0);
+      if(0 <= i) {
+        t = i;
+        for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0);
+        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t;
+      }
+    }
+
+    //calculate the index of start/end point of each bucket
+    BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n;  //end point
+    for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) {
+      i = BUCKET_A(c0 + 1) - 1;
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) {
+        t = i - BUCKET_B(c0, c1);
+        BUCKET_B(c0, c1) = i;  //end point
+
+        //move all type B* suffixes to the correct position
+        for(i = t, j = BUCKET_BSTAR(c0, c1); j <= k; --i, --k) SA[i] = SA[k];
+      }
+      BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1;  //start point
+      BUCKET_B(c0, c0) = i;  //end point
+    }
+  }
+
+  return m;
+}
+
+inline auto construct_SA(const uint8_t* T, int* SA, int* bucket_A, int* bucket_B, int n, int m) -> void {
+  int *i, *j, *k;
+  int s;
+  int c0, c1, c2;
+
+  if(0 < m) {
+    //construct the sorted order of type B suffixes by using the sorted order of type B* suffixes
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      //scan the suffix array from right to left
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
+          j = SA + BUCKET_A(c1 + 1) - 1, k = nullptr, c2 = -1;
+          i <= j;
+          --j) {
+        if(0 < (s = *j)) {
+          *j = ~s;
+          c0 = T[--s];
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
+          if(c0 != c2) {
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          *k-- = s;
+        } else {
+          *j = ~s;
+        }
+      }
+    }
+  }
+
+  //construct the suffix array by using the sorted order of type B suffixes
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1);
+  //scan the suffix array from left to right
+  for(i = SA, j = SA + n; i < j; ++i) {
+    if(0 < (s = *i)) {
+      c0 = T[--s];
+      if((s == 0) || (T[s - 1] < c0)) { s = ~s; }
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      *k++ = s;
+    } else {
+      *i = ~s;
+    }
+  }
+}
+
+//constructs the burrows-wheeler transformed string directly by using the sorted order of type B* suffixes
+inline auto construct_BWT(const uint8_t* T, int* SA, int* bucket_A, int* bucket_B, int n, int m) -> int {
+  int *i, *j, *k, *orig, s, c0, c1, c2;
+
+  if(0 < m) {
+    //construct the sorted order of type B suffixes by using the sorted order of type B* suffixes
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      //scan the suffix array from right to left
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1), j = SA + BUCKET_A(c1 + 1) - 1, k = nullptr, c2 = -1; i <= j; --j) {
+        if(0 < (s = *j)) {
+          c0 = T[--s];
+          *j = ~((int)c0);
+          if((0 < s) && (T[s - 1] > c0)) s = ~s;
+          if(c0 != c2) {
+            if(0 <= c2) BUCKET_B(c2, c1) = k - SA;
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          *k-- = s;
+        } else if(s != 0) {
+          *j = ~s;
+        }
+      }
+    }
+  }
+
+  //construct the BWTed string by using the sorted order of type B suffixes
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1);
+  //scan the suffix array from left to right
+  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
+    if(0 < (s = *i)) {
+      c0 = T[--s];
+      *i = c0;
+      if((0 < s) && (T[s - 1] < c0)) s = ~((int)T[s - 1]);
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      *k++ = s;
+    } else if(s != 0) {
+      *i = ~s;
+    } else {
+      orig = i;
+    }
+  }
+
+  return orig - SA;
+}
+
+}}
+
+namespace nall {
+
+inline auto div_suf_sort(int* SA, const uint8_t* T, int n) -> int {
+  int m, err = 0;
+
+  if(T == nullptr || SA == nullptr || n < 0) return -1;
+  if(n == 0) return 0;
+  if(n == 1) { SA[0] = 0; return 0; }
+  if(n == 2) { m = T[0] < T[1]; SA[m ^ 1] = 0; SA[m] = 1; return 0; }
+
+  auto bucket_A = memory::allocate<int>(BUCKET_A_SIZE);
+  auto bucket_B = memory::allocate<int>(BUCKET_B_SIZE);
+
+  if(bucket_A && bucket_B) {
+    m = libdivsufsort::sort_typeBstar(T, SA, bucket_A, bucket_B, n);
+    libdivsufsort::construct_SA(T, SA, bucket_A, bucket_B, n, m);
+  } else {
+    err = -2;
+  }
+
+  memory::free(bucket_A);
+  memory::free(bucket_B);
+
+  return err;
+}
+
+//byuu: note that this function is broken, and not just in my port of it to nall
+//even with the original library, it is incapable of producing a correct BWT result in *any* case
+
+inline auto div_suf_sort_bwt(const uint8_t* T, uint8_t* U, int* A, int n) -> int {
+  int *B, *bucket_A, *bucket_B, m, pidx, i;
+
+  if(T == nullptr || U == nullptr || n < 0) return -1;
+  if(n == 0) return 0;
+  if(n == 1) return U[0] = T[0], 1;
+
+  if((B = A) == nullptr) B = memory::allocate<int>(n + 1);
+  bucket_A = memory::allocate<int>(BUCKET_A_SIZE);
+  bucket_B = memory::allocate<int>(BUCKET_B_SIZE);
+
+  //burrows-wheeler transform
+  if((B != nullptr) && (bucket_A != nullptr) && (bucket_B != nullptr)) {
+    m = libdivsufsort::sort_typeBstar(T, B, bucket_A, bucket_B, n);
+    pidx = libdivsufsort::construct_BWT(T, B, bucket_A, bucket_B, n, m);
+
+    //copy to output string
+    U[0] = T[n - 1];
+    for(i = 0; i < pidx; ++i) U[i + 1] = (uint8_t)B[i];
+    for(i += 1; i < n; ++i) U[i] = (uint8_t)B[i];
+    pidx += 1;
+  } else {
+    pidx -= 2;
+  }
+
+  memory::free(bucket_A);
+  memory::free(bucket_B);
+  if(A == nullptr) memory::free(B);
+
+  return pidx;
+}
+
+#undef ALPHABET_SIZE
+#undef BUCKET_A
+#undef BUCKET_B
+#undef BUCKET_BSTAR
+#undef BUCKET_A_SIZE
+#undef BUCKET_B_SIZE
+#undef SS_INSERTIONSORT_THRESHOLD
+#undef SS_BLOCKSIZE
+#undef SS_MISORT_STACKSIZE
+#undef SS_SMERGE_STACKSIZE
+#undef TR_INSERTIONSORT_THRESHOLD
+#undef TR_STACKSIZE
+#undef STACK_PUSH
+#undef STACK_PUSH5
+#undef STACK_POP
+#undef STACK_POP5
+
+}
diff --git a/nall/dl.hpp b/nall/dl.hpp
index c3cdb6a2..8116d349 100644
--- a/nall/dl.hpp
+++ b/nall/dl.hpp
@@ -9,7 +9,6 @@
 #include <nall/utility.hpp>
 
 #if defined(PLATFORM_WINDOWS)
-  #include <windows.h>
   #include <nall/windows/utf8.hpp>
 #else
   #include <dlfcn.h>
diff --git a/nall/encode/bwt.hpp b/nall/encode/bwt.hpp
new file mode 100644
index 00000000..fa077dd2
--- /dev/null
+++ b/nall/encode/bwt.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+//burrows-wheeler transform
+
+#include <nall/suffix-array.hpp>
+
+namespace nall { namespace Encode {
+
+inline auto BWT(const void* data, uint size) -> vector<uint8_t> {
+  auto input = (const uint8_t*)data;
+  vector<uint8_t> output;
+  output.reserve(8 + 8 + size);
+  for(uint byte : range(8)) output.append(size >> byte * 8);
+  for(uint byte : range(8)) output.append(0x00);
+
+  auto suffixes = new int[size];
+//suffix_array(suffixes, input, size);
+  for(uint n : range(size)) suffixes[n] = n;
+  sort(suffixes, size, [&](int lhs, int rhs) -> bool {
+    uint l = size;
+    while(l--) {
+      auto x = input[lhs++];
+      auto y = input[rhs++];
+      if(x != y) return x - y < 0;
+      if(lhs >= size) lhs = 0;
+      if(rhs >= size) rhs = 0;
+    }
+    return 0;
+  });
+
+  uint64_t root = 0;
+  for(uint offset : range(size)) {
+    if(suffixes[offset] == 0) root = offset;
+    uint suffix = suffixes[offset];
+    if(suffix == 0) suffix = size;
+    output.append(input[--suffix]);
+  }
+
+  for(uint byte : range(8)) output[8 + byte] = root >> byte * 8;
+  delete[] suffixes;
+  return output;
+}
+
+template<typename T>
+inline auto BWT(const vector<T>& buffer) -> vector<uint8_t> {
+  return move(BWT(buffer.data(), buffer.size() * sizeof(T)));
+}
+
+}}
diff --git a/nall/encode/dictionary.hpp b/nall/encode/dictionary.hpp
new file mode 100644
index 00000000..17417ae0
--- /dev/null
+++ b/nall/encode/dictionary.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <nall/suffix-array.hpp>
+
+namespace nall { namespace Encode {
+
+struct Dictionary {
+  inline Dictionary(const void* data, uint size, uint capacity = 0);
+  inline ~Dictionary();
+
+  inline auto operator[](uint index) const -> uint;
+  inline auto scan(uint offset = 0, uint size = 0) -> uint;
+  inline auto find(uint prefix, uint& lower, uint& upper) -> void;
+
+private:
+  const uint8_t* data = nullptr;
+  uint size = 0;
+
+  uint capacity = 0;
+  uint unique = 0;
+  uint* suffixes = nullptr;
+  uint* prefixes = nullptr;
+};
+
+Dictionary::Dictionary(const void* data, uint size, uint capacity) {
+  this->data = (const uint8_t*)data;
+  this->size = size;
+  this->capacity = capacity ? capacity : size;
+  suffixes = new uint[2 * this->capacity];
+  prefixes = &suffixes[this->capacity];
+}
+
+Dictionary::~Dictionary() {
+  delete[] suffixes;
+}
+
+auto Dictionary::operator[](uint index) const -> uint {
+  return suffixes[index];
+}
+
+auto Dictionary::scan(uint offset, uint size) -> uint {
+  size = min(size ? size : capacity, this->size - offset);
+  partial_suffix_array<32, 32>(suffixes, prefixes, data + offset, size, offset);
+  uint target = 0, source = 0;
+  while(source < size) {
+    prefixes[target] = prefixes[source];
+    suffixes[target] = suffixes[source];
+    uint length = 1;
+    while(source + length < size) {
+      if(suffixes[source + length] != suffixes[source] + length) break;
+      length++;
+    }
+    source += length;
+    target += 1;
+  }
+  return unique = target;
+}
+
+auto Dictionary::find(uint prefix, uint& lower, uint& upper) -> void {
+  uint l = 0, r = unique - 1;
+  while(l < r - 1) {
+    uint m = l + r >> 1;
+    prefixes[m] >= prefix ? r = m : l = m;
+  }
+  lower = l, r = unique - 1;
+  while(l < r - 1) {
+    uint m = l + r >> 1;
+    prefixes[m] <= prefix ? l = m : r = m;
+  }
+  upper = r;
+}
+
+}}
diff --git a/nall/encode/huffman.hpp b/nall/encode/huffman.hpp
new file mode 100644
index 00000000..570f1e89
--- /dev/null
+++ b/nall/encode/huffman.hpp
@@ -0,0 +1,90 @@
+#pragma once
+
+namespace nall { namespace Encode {
+
+inline auto Huffman(const void* data, uint size) -> vector<uint8_t> {
+  auto input = (const uint8_t*)data;
+  vector<uint8_t> output;
+  for(uint byte : range(8)) output.append(size >> byte * 8);
+
+  struct Node {
+    uint frequency = 0;
+    uint parent = 0;
+    uint lhs = 0;
+    uint rhs = 0;
+  };
+  array<Node[512]> nodes;
+  for(uint offset : range(size)) nodes[input[offset]].frequency++;
+
+  uint count = 0;
+  for(uint offset : range(511)) {
+    if(nodes[offset].frequency) count++;
+    else nodes[offset].parent = 511;
+  }
+
+  auto minimum = [&] {
+    uint frequency = ~0, minimum = 511;
+    for(uint index : range(511)) {
+      if(!nodes[index].parent && nodes[index].frequency && nodes[index].frequency < frequency) {
+        frequency = nodes[index].frequency;
+        minimum = index;
+      }
+    }
+    return minimum;
+  };
+
+  //group the least two frequently used nodes until only one node remains
+  uint index = 256;
+  for(uint remaining = max(2, count); remaining >= 2; remaining--) {
+    uint lhs = minimum();
+    nodes[lhs].parent = index;
+    uint rhs = minimum();
+    nodes[rhs].parent = index;
+    if(remaining == 2) index = nodes[lhs].parent = nodes[rhs].parent = 511;
+    nodes[index].lhs = lhs;
+    nodes[index].rhs = rhs;
+    nodes[index].parent = 0;
+    nodes[index].frequency = nodes[lhs].frequency + nodes[rhs].frequency;
+    index++;
+  }
+
+  uint byte = 0, bits = 0;
+  auto write = [&](bool bit) {
+    byte = byte << 1 | bit;
+    if(++bits == 8) output.append(byte), bits = 0;
+  };
+
+  //only the upper half of the table is needed for decompression
+  //the first 256 nodes are always treated as leaf nodes
+  for(uint offset : range(256)) {
+    for(uint index : reverse(range(9))) write(nodes[256 + offset].lhs >> index & 1);
+    for(uint index : reverse(range(9))) write(nodes[256 + offset].rhs >> index & 1);
+  }
+
+  for(uint offset : range(size)) {
+    uint node = input[offset], length = 0;
+    uint256_t sequence = 0;
+    //traversing the array produces the bitstream in reverse order
+    do {
+      uint parent = nodes[node].parent;
+      bool bit = nodes[nodes[node].parent].rhs == node;
+      sequence = sequence << 1 | bit;
+      length++;
+      node = parent;
+    } while(node != 511);
+    //output the generated bits in the correct order
+    for(uint index : range(length)) {
+      write(sequence >> index & 1);
+    }
+  }
+  while(bits) write(0);
+
+  return output;
+}
+
+template<typename T>
+inline auto Huffman(const vector<T>& buffer) -> vector<uint8_t> {
+  return move(Huffman(buffer.data(), buffer.size() * sizeof(T)));
+}
+
+}}
diff --git a/nall/encode/lzsa.hpp b/nall/encode/lzsa.hpp
new file mode 100644
index 00000000..86576aee
--- /dev/null
+++ b/nall/encode/lzsa.hpp
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <nall/suffix-array.hpp>
+#include <nall/encode/bwt.hpp>
+#include <nall/encode/huffman.hpp>
+#include <nall/encode/mtf.hpp>
+#include <nall/encode/rle.hpp>
+
+namespace nall { namespace Encode {
+
+inline auto LZSA(const void* data, uint64_t size) -> vector<uint8_t> {
+  vector<uint8_t> output;
+  for(uint byte : range(8)) output.append(size >> byte * 8);
+
+  auto input = (const uint8_t*)data;
+  uint index = 0;
+
+  auto buffers = new int[size * 4];
+  auto suffixes = &buffers[0 * size];
+  auto phi = &buffers[1 * size];
+  auto lengths = &buffers[2 * size];
+  auto offsets = &buffers[3 * size];
+  suffix_array(suffixes, input, size);
+  suffix_array_phi(phi, suffixes, size);
+  suffix_array_lps(lengths, offsets, phi, input, size);
+
+  vector<uint8_t> flags;
+  vector<uint8_t> literals;
+  vector<uint8_t> stringLengths;
+  vector<uint8_t> stringOffsets;
+
+  uint byte = 0, bits = 0;
+  auto flagWrite = [&](bool bit) {
+    byte = byte << 1 | bit;
+    if(++bits == 8) flags.append(byte), bits = 0;
+  };
+
+  auto literalWrite = [&](uint8_t literal) {
+    literals.append(literal);
+  };
+
+  auto lengthWrite = [&](uint64_t length) {
+         if(length < 1 <<  7) length = length << 1 |     0b1;
+    else if(length < 1 << 14) length = length << 2 |    0b10;
+    else if(length < 1 << 21) length = length << 3 |   0b100;
+    else if(length < 1 << 28) length = length << 4 |  0b1000;
+    else  /*length < 1 << 35*/length = length << 5 | 0b10000;
+    while(length) stringLengths.append(length), length >>= 8;
+  };
+
+  auto offsetWrite = [&](uint offset) {
+    stringOffsets.append(offset >>  0); if(index < 1 <<  8) return;
+    stringOffsets.append(offset >>  8); if(index < 1 << 16) return;
+    stringOffsets.append(offset >> 16); if(index < 1 << 24) return;
+    stringOffsets.append(offset >> 24);
+  };
+
+  while(index < size) {
+    int length = lengths[index];
+    int offset = offsets[index];
+
+    for(uint ahead = 1; ahead <= 2; ahead++) {
+      int aheadLength = lengths[index + ahead];
+      int aheadOffset = offsets[index + ahead];
+      if(aheadLength > length && aheadOffset >= 0) {
+        length = 0;
+        break;
+      }
+    }
+
+    if(length < 6 || offset < 0) {
+      flagWrite(0);
+      literalWrite(input[index++]);
+    } else {
+      flagWrite(1);
+      lengthWrite(length - 6);
+      offsetWrite(index - offset);
+      index += length;
+    }
+  }
+  while(bits) flagWrite(0);
+
+  auto save = [&](const vector<uint8_t>& buffer) {
+    for(uint byte : range(8)) output.append(buffer.size() >> byte * 8);
+    output.append(buffer);
+  };
+
+  save(Encode::Huffman(flags));
+  save(Encode::Huffman(literals));
+//save(Encode::Huffman(Encode::BWT(literals)));
+  save(Encode::Huffman(stringLengths));
+  save(Encode::Huffman(stringOffsets));
+
+  delete[] buffers;
+  return output;
+}
+
+}}
diff --git a/nall/encode/lzss.hpp b/nall/encode/lzss.hpp
new file mode 100644
index 00000000..42182b22
--- /dev/null
+++ b/nall/encode/lzss.hpp
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <nall/encode/dictionary.hpp>
+
+namespace nall { namespace Encode {
+
+inline auto LZSS(const void* data, uint64_t size, uint windowBits = 16, uint lengthBits = 8) -> vector<uint8_t> {
+  vector<uint8_t> output;
+  for(uint byte : range(8)) output.append(size >> byte * 8);
+  output.append(windowBits);
+  output.append(lengthBits);
+
+  const uint lengthExtends = 4 + (1 << lengthBits) - 1;
+  const uint lengthMaximum = lengthExtends + 255;
+  const uint windowMaximum = 1 << windowBits;
+  const uint windowRange = windowMaximum + lengthMaximum;
+
+  auto input = (const uint8_t*)data;
+  auto read = [&](uint address) -> uint {
+    if(address + 3 > size) return 0;
+    return input[address + 0] << 24 | input[address + 1] << 16 | input[address + 2] << 8 | input[address + 3] << 0;
+  };
+
+  Dictionary dictionary(data, size, 2 * windowRange);
+  dictionary.scan();
+
+  for(uint offset = 0, base = 0, flags = 0, bit = 7; offset < size;) {
+    if(offset - base >= 2 * windowRange) {
+      dictionary.scan(base = offset - windowRange);
+    }
+
+    uint prefix = read(offset), lower, upper;
+    dictionary.find(prefix, lower, upper);
+
+    uint lengthLongest = 0, windowLongest = 0;
+    for(uint index = lower; index <= upper; index++) {
+      int window = (int)offset - (int)dictionary[index];
+      if(window <= 0) continue;
+      window = min(window, windowMaximum);
+
+      uint length = 0;
+      do {
+        if(offset + length >= size) break;
+        if(input[offset + length] != input[offset + length - window]) break;
+      } while(++length < lengthMaximum);
+
+      if(length > lengthLongest) {
+        lengthLongest = length;
+        windowLongest = window;
+        if(length == lengthMaximum) break;
+      }
+    }
+
+    if(++bit == 8) {
+      flags = output.size();
+      output.append(bit = 0);
+    }
+
+    if(lengthLongest < 4) {
+      output.append(input[offset++]);
+    } else {
+      output[flags] |= 1 << bit;
+      offset += lengthLongest;
+
+      uint encoding = min(lengthLongest, lengthExtends) - 4 << windowBits | windowLongest - 1;
+      output.append(encoding >>  0);
+      output.append(encoding >>  8);
+      output.append(encoding >> 16);
+      if(lengthLongest >= lengthExtends) output.append(lengthLongest - lengthExtends);
+    }
+  }
+
+  return output;
+}
+
+}}
diff --git a/nall/encode/mtf.hpp b/nall/encode/mtf.hpp
new file mode 100644
index 00000000..b9ed5783
--- /dev/null
+++ b/nall/encode/mtf.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+//move to front
+
+namespace nall { namespace Encode {
+
+inline auto MTF(const void* data, uint size) -> vector<uint8_t> {
+  auto input = (const uint8_t*)data;
+  vector<uint8_t> output;
+  output.resize(size);
+
+  uint8_t order[256];
+  for(uint n : range(256)) order[n] = n;
+
+  for(uint offset = 0; offset < size; offset++) {
+    auto data = input[offset];
+    for(uint index = 0; index < 256; index++) {
+      uint value = order[index];
+      if(value == data) {
+        output[offset] = index;
+        memory::move(&order[1], &order[0], index);
+        order[0] = value;
+        break;
+      }
+    }
+  }
+
+  return output;
+}
+
+template<typename T>
+inline auto MTF(const vector<T>& buffer) -> vector<uint8_t> {
+  return move(MTF(buffer.data(), buffer.size() * sizeof(T)));
+}
+
+}}
diff --git a/nall/encode/rle.hpp b/nall/encode/rle.hpp
index f7bd7c41..f481c55a 100644
--- a/nall/encode/rle.hpp
+++ b/nall/encode/rle.hpp
@@ -2,49 +2,62 @@
 
 namespace nall { namespace Encode {
 
-template<typename T> inline auto RLE(const void* data_, uint size, uint minimum = 0) -> vector<uint8_t> {
-  if(!minimum) minimum = max(1, 4 / sizeof(T));
-  vector<uint8_t> result;
+template<uint S = 1, uint M = 4 / S>  //S = word size; M = match length
+inline auto RLE(const void* data, uint64_t size) -> vector<uint8_t> {
+  vector<uint8_t> output;
+  for(uint byte : range(8)) output.append(size >> byte * 8);
 
-  auto data = (const T*)data_;
+  auto input = (const uint8_t*)data;
   uint base = 0;
   uint skip = 0;
 
-  for(uint byte : range(sizeof(uint))) result.append(size * sizeof(T) >> byte * 8);
-
-  auto read = [&](uint offset) -> T {
-    if(offset >= size) return {};
-    return data[offset];
+  auto load = [&](uint offset) -> uint8_t {
+    if(offset >= size) return 0x00;
+    return input[offset];
   };
 
-  auto write = [&](T value) -> void {
-    for(uint byte : range(sizeof(T))) result.append(value >> byte * 8);
+  auto read = [&](uint offset) -> uint64_t {
+    uint64_t value = 0;
+    for(uint byte : range(S)) value |= load(offset + byte) << byte * 8;
+    return value;
   };
 
-  auto flush = [&]() -> void {
-    result.append(skip - 1);
-    do { write(read(base++)); } while(--skip);
+  auto write = [&](uint64_t value) -> void {
+    for(uint byte : range(S)) output.append(value >> byte * 8);
   };
 
-  while(base + skip < size) {
+  auto flush = [&] {
+    output.append(skip - 1);
+    do {
+      write(read(base));
+      base += S;
+    } while(--skip);
+  };
+
+  while(base + S * skip < size) {
     uint same = 1;
-    for(uint offset = base + skip + 1; offset < size; offset++) {
-      if(read(offset) != read(base + skip)) break;
-      if(++same == 127 + minimum) break;
+    for(uint offset = base + S * (skip + 1); offset < size; offset += S) {
+      if(read(offset) != read(base + S * skip)) break;
+      if(++same == 127 + M) break;
     }
 
-    if(same < minimum) {
+    if(same < M) {
       if(++skip == 128) flush();
     } else {
       if(skip) flush();
-      result.append(128 | same - minimum);
+      output.append(128 | same - M);
       write(read(base));
-      base += same;
+      base += S * same;
     }
   }
   if(skip) flush();
 
-  return result;
+  return output;
+}
+
+template<uint S = 1, uint M = 4 / S, typename T>
+inline auto RLE(const vector<T>& buffer) -> vector<uint8_t> {
+  return move(RLE<S, M>(buffer.data(), buffer.size() * sizeof(T)));
 }
 
 }}
diff --git a/nall/file.hpp b/nall/file.hpp
index cc5228f5..03510d06 100644
--- a/nall/file.hpp
+++ b/nall/file.hpp
@@ -72,17 +72,18 @@ struct file : inode, varint {
     return S_ISREG(data.st_mode) ? data.st_size : 0u;
   }
 
-  static auto read(const string& filename) -> vector<uint8_t> {
+  static auto read(const string& filename, uint reserve = 0) -> vector<uint8_t> {
     vector<uint8_t> memory;
     file fp;
     if(fp.open(filename, mode::read)) {
+      memory.reserve(fp.size() + reserve);
       memory.resize(fp.size());
       fp.read(memory.data(), memory.size());
     }
     return memory;
   }
 
-  static auto read(const string& filename, uint8_t* data, uint size) -> bool {
+  static auto read(const string& filename, void* data, uint size) -> bool {
     file fp;
     if(fp.open(filename, mode::read) == false) return false;
     fp.read(data, size);
@@ -91,14 +92,14 @@ struct file : inode, varint {
   }
 
   static auto write(const string& filename, const string& text) -> bool {
-    return write(filename, (const uint8_t*)text.data(), text.size());
+    return write(filename, text.data(), text.size());
   }
 
   static auto write(const string& filename, const vector<uint8_t>& buffer) -> bool {
     return write(filename, buffer.data(), buffer.size());
   }
 
-  static auto write(const string& filename, const uint8_t* data, uint size) -> bool {
+  static auto write(const string& filename, const void* data, uint size) -> bool {
     file fp;
     if(fp.open(filename, mode::write) == false) return false;
     fp.write(data, size);
@@ -151,8 +152,9 @@ struct file : inode, varint {
     return result;
   }
 
-  auto read(uint8_t* buffer, uint length) -> void {
-    while(length--) *buffer++ = read();
+  auto read(void* data, uint size) -> void {
+    auto output = (uint8_t*)data;
+    while(size--) *output++ = read();
   }
 
   auto write(uint8_t data) -> void {
@@ -181,8 +183,9 @@ struct file : inode, varint {
     for(auto byte : s) write(byte);
   }
 
-  auto write(const uint8_t* buffer, uint length) -> void {
-    while(length--) write(*buffer++);
+  auto write(const void* data, uint size) -> void {
+    auto input = (const uint8_t*)data;
+    while(size--) write(*input++);
   }
 
   template<typename... Args> auto print(Args... args) -> void {
diff --git a/nall/filemap.hpp b/nall/filemap.hpp
index 2a2870ce..0ca9cc0d 100644
--- a/nall/filemap.hpp
+++ b/nall/filemap.hpp
@@ -2,12 +2,11 @@
 
 #include <nall/file.hpp>
 #include <nall/stdint.hpp>
-#include <nall/windows/utf8.hpp>
 
 #include <stdio.h>
 #include <stdlib.h>
-#if defined(_WIN32)
-  #include <windows.h>
+#if defined(PLATFORM_WINDOWS)
+  #include <nall/windows/utf8.hpp>
 #else
   #include <fcntl.h>
   #include <unistd.h>
diff --git a/nall/literals.hpp b/nall/literals.hpp
new file mode 100644
index 00000000..9d2d6b55
--- /dev/null
+++ b/nall/literals.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+//note: gcc 4.9 does not support user-defined literals with arguments other than const char*
+//once nall increases the minimum required GCC version, the use of nall/atoi.hpp can beremoved
+
+#include <nall/atoi.hpp>
+
+namespace nall { namespace Literal {
+
+struct Capacity { uint value; };
+struct Size { uint value; };
+
+}}
+
+namespace nall {
+
+constexpr inline auto operator"" _capacity(const char* s) -> Literal::Capacity {
+  return {(uint)toNatural(s)};
+}
+
+constexpr inline auto operator"" _size(const char* s) -> Literal::Size {
+  return {(uint)toNatural(s)};
+}
+
+}
diff --git a/nall/locale.hpp b/nall/locale.hpp
index c143f31f..6fb9f173 100644
--- a/nall/locale.hpp
+++ b/nall/locale.hpp
@@ -29,10 +29,10 @@ struct Locale {
     return result;
   }
 
-  auto select(string language) -> bool {
+  auto select(string option) -> bool {
     selected.reset();
     for(auto& dictionary : dictionaries) {
-      if(dictionary.language == language) {
+      if(option == Location::prefix(dictionary.location) || option == dictionary.language) {
         selected = dictionary;
         return true;
       }
diff --git a/nall/main.hpp b/nall/main.hpp
index 4579424c..e7f4e1e3 100644
--- a/nall/main.hpp
+++ b/nall/main.hpp
@@ -14,7 +14,7 @@ namespace nall {
     _setmode(_fileno(stdin), O_BINARY);
     _setmode(_fileno(stdout), O_BINARY);
     _setmode(_fileno(stderr), O_BINARY);
-    utf8_args(argc, argv);
+    utf8_arguments(argc, argv);
     #endif
 
     vector<string> arguments;
diff --git a/nall/matrix.hpp b/nall/matrix.hpp
index 76a4da03..7acb7fda 100644
--- a/nall/matrix.hpp
+++ b/nall/matrix.hpp
@@ -1,10 +1,12 @@
 #pragma once
 
-namespace nall {
+namespace nall { namespace Matrix {
 
-namespace Matrix {
-
-template<typename T> inline auto Multiply(T* output, const T* xdata, uint xrows, uint xcols, const T* ydata, uint yrows, uint ycols) -> void {
+template<typename T> inline auto Multiply(
+T* output,
+const T* xdata, uint xrows, uint xcols,
+const T* ydata, uint yrows, uint ycols
+) -> void {
   if(xcols != yrows) return;
 
   for(uint y : range(xrows)) {
@@ -18,13 +20,14 @@ template<typename T> inline auto Multiply(T* output, const T* xdata, uint xrows,
   }
 }
 
-template<typename T> inline auto Multiply(const T* xdata, uint xrows, uint xcols, const T* ydata, uint yrows, uint ycols) -> vector<T> {
+template<typename T> inline auto Multiply(
+const T* xdata, uint xrows, uint xcols,
+const T* ydata, uint yrows, uint ycols
+) -> vector<T> {
   vector<T> output;
   output.resize(xrows * ycols);
   Multiply(output.data(), xdata, xrows, xcols, ydata, yrows, ycols);
   return output;
 }
 
-}
-
-}
+}}
diff --git a/nall/maybe.hpp b/nall/maybe.hpp
index 3444e08f..0c3ae522 100644
--- a/nall/maybe.hpp
+++ b/nall/maybe.hpp
@@ -4,6 +4,7 @@ namespace nall {
 
 struct nothing_t {};
 static nothing_t nothing;
+struct else_t {};
 
 template<typename T>
 struct maybe {
diff --git a/nall/memory.hpp b/nall/memory.hpp
index 4d0c125d..658eb19e 100644
--- a/nall/memory.hpp
+++ b/nall/memory.hpp
@@ -61,15 +61,16 @@ auto free(void* target) -> void {
 }
 
 template<typename T> auto compare(const void* target, uint capacity, const void* source, uint size) -> int {
-  auto t = (int8_t*)target;
-  auto s = (int8_t*)source;
+  auto t = (uint8_t*)target;
+  auto s = (uint8_t*)source;
   auto l = min(capacity, size) * sizeof(T);
   while(l--) {
     auto x = *t++;
     auto y = *s++;
     if(x != y) return x - y;
   }
-  return 0;
+  if(capacity == size) return 0;
+  return -(capacity < size);
 }
 
 template<typename T> auto compare(const void* target, const void* source, uint size) -> int {
@@ -77,8 +78,8 @@ template<typename T> auto compare(const void* target, const void* source, uint s
 }
 
 template<typename T> auto icompare(const void* target, uint capacity, const void* source, uint size) -> int {
-  auto t = (int8_t*)target;
-  auto s = (int8_t*)source;
+  auto t = (uint8_t*)target;
+  auto s = (uint8_t*)source;
   auto l = min(capacity, size) * sizeof(T);
   while(l--) {
     auto x = *t++;
@@ -87,7 +88,7 @@ template<typename T> auto icompare(const void* target, uint capacity, const void
     if(y - 'A' < 26) y += 32;
     if(x != y) return x - y;
   }
-  return 0;
+  return -(capacity < size);
 }
 
 template<typename T> auto icompare(const void* target, const void* source, uint size) -> int {
diff --git a/nall/sort.hpp b/nall/merge-sort.hpp
similarity index 54%
rename from nall/sort.hpp
rename to nall/merge-sort.hpp
index 63053ccb..5c1175b8 100644
--- a/nall/sort.hpp
+++ b/nall/merge-sort.hpp
@@ -13,33 +13,37 @@
 //note: merge sort was chosen over quick sort, because:
 //* it is a stable sort
 //* it lacks O(n^2) worst-case overhead
+//* it usually runs faster than quick sort anyway
 
-#define NALL_SORT_INSERTION
-//#define NALL_SORT_SELECTION
+//note: insertion sort is generally more performant than selection sort
+#define NALL_MERGE_SORT_INSERTION
+//#define NALL_MERGE_SORT_SELECTION
 
 namespace nall {
 
 template<typename T, typename Comparator> auto sort(T list[], uint size, const Comparator& lessthan) -> void {
   if(size <= 1) return;  //nothing to sort
 
-  //use insertion sort to quickly sort smaller blocks
+  //sort smaller blocks using an O(n^2) algorithm (which for small sizes, increases performance)
   if(size < 64) {
-    #if defined(NALL_SORT_INSERTION)
+    //insertion sort requires a copy (via move construction)
+    #if defined(NALL_MERGE_SORT_INSERTION)
     for(int i = 1, j; i < size; i++) {
-      T copy = std::move(list[i]);
+      T copy(move(list[i]));
       for(j = i - 1; j >= 0; j--) {
         if(!lessthan(copy, list[j])) break;
-        list[j + 1] = std::move(list[j]);
+        list[j + 1] = move(list[j]);
       }
-      list[j + 1] = std::move(copy);
+      list[j + 1] = move(copy);
     }
-    #elif defined(NALL_SORT_SELECTION)
+    //selection sort requires a swap
+    #elif defined(NALL_MERGE_SORT_SELECTION)
     for(uint i = 0; i < size; i++) {
       uint min = i;
       for(uint j = i + 1; j < size; j++) {
         if(lessthan(list[j], list[min])) min = j;
       }
-      if(min != i) std::swap(list[i], list[min]);
+      if(min != i) swap(list[i], list[min]);
     }
     #endif
     return;
@@ -51,20 +55,24 @@ template<typename T, typename Comparator> auto sort(T list[], uint size, const C
   sort(list + middle, size - middle, lessthan);
 
   //left and right are sorted here; perform merge sort
-  T* buffer = new T[size];
+  //use placement new to avoid needing T to be default-constructable
+  auto buffer = memory::allocate<T>(size);
   uint offset = 0, left = 0, right = middle;
   while(left < middle && right < size) {
     if(!lessthan(list[right], list[left])) {
-      buffer[offset++] = std::move(list[left++]);
+      new(buffer + offset++) T(move(list[left++]));
     } else {
-      buffer[offset++] = std::move(list[right++]);
+      new(buffer + offset++) T(move(list[right++]));
     }
   }
-  while(left < middle) buffer[offset++] = std::move(list[left++]);
-  while(right < size)  buffer[offset++] = std::move(list[right++]);
+  while(left < middle) new(buffer + offset++) T(move(list[left++]));
+  while(right < size ) new(buffer + offset++) T(move(list[right++]));
 
-  for(uint i = 0; i < size; i++) list[i] = std::move(buffer[i]);
-  delete[] buffer;
+  for(uint i = 0; i < size; i++) {
+    list[i] = move(buffer[i]);
+    buffer[i].~T();
+  }
+  memory::free(buffer);
 }
 
 template<typename T> auto sort(T list[], uint size) -> void {
diff --git a/nall/nall.hpp b/nall/nall.hpp
index 011b8230..95ba2ada 100644
--- a/nall/nall.hpp
+++ b/nall/nall.hpp
@@ -41,6 +41,7 @@
 #include <nall/matrix.hpp>
 #include <nall/maybe.hpp>
 #include <nall/memory.hpp>
+#include <nall/merge-sort.hpp>
 #include <nall/path.hpp>
 #include <nall/pointer.hpp>
 #include <nall/primitives.hpp>
@@ -53,7 +54,6 @@
 #include <nall/set.hpp>
 #include <nall/shared-pointer.hpp>
 #include <nall/simd.hpp>
-#include <nall/sort.hpp>
 #include <nall/stdint.hpp>
 #include <nall/string.hpp>
 #include <nall/thread.hpp>
diff --git a/nall/platform.hpp b/nall/platform.hpp
index 57b5dc7e..e944b986 100644
--- a/nall/platform.hpp
+++ b/nall/platform.hpp
@@ -8,11 +8,16 @@ namespace Math {
 }
 
 #if defined(PLATFORM_WINDOWS)
-  //minimum version needed for _wstat64, AI_ADDRCONFIG, etc
-  #undef  _WIN32_WINNT
-  #define _WIN32_WINNT 0x0601
-  #undef  __MSVCRT_VERSION__
-  #define __MSVCRT_VERSION__ _WIN32_WINNT
+  #include <nall/windows/guard.hpp>
+  #include <winsock2.h>
+  #include <ws2tcpip.h>
+  #include <windows.h>
+  #include <direct.h>
+  #include <io.h>
+  #include <wchar.h>
+  #include <shlobj.h>
+  #include <shellapi.h>
+  #include <nall/windows/guard.hpp>
   #include <nall/windows/utf8.hpp>
 #endif
 
@@ -35,14 +40,7 @@ namespace Math {
 #include <sys/types.h>
 #include <sys/stat.h>
 
-#if defined(PLATFORM_WINDOWS)
-  #include <io.h>
-  #include <direct.h>
-  #include <shlobj.h>
-  #include <wchar.h>
-  #include <winsock2.h>
-  #include <ws2tcpip.h>
-#else
+#if !defined(PLATFORM_WINDOWS)
   #include <dlfcn.h>
   #include <unistd.h>
   #include <pwd.h>
diff --git a/nall/smtp.hpp b/nall/smtp.hpp
index a7388476..6bad4135 100644
--- a/nall/smtp.hpp
+++ b/nall/smtp.hpp
@@ -4,7 +4,7 @@
 #include <nall/stdint.hpp>
 #include <nall/string.hpp>
 
-#if !defined(_WIN32)
+#if !defined(PLATFORM_WINDOWS)
   #include <sys/types.h>
   #include <sys/socket.h>
   #include <netinet/in.h>
@@ -12,7 +12,6 @@
 #else
   #include <winsock2.h>
   #include <ws2tcpip.h>
-  #include <windows.h>
 #endif
 
 namespace nall {
diff --git a/nall/string.hpp b/nall/string.hpp
index 5d9d9e0d..a8558de4 100644
--- a/nall/string.hpp
+++ b/nall/string.hpp
@@ -56,6 +56,9 @@ protected:
   mutable int _size;
 };
 
+//adaptive (SSO + COW) is by far the best choice, the others exist solely to:
+//1) demonstrate the performance benefit of combining SSO + COW
+//2) rule out allocator bugs by trying different allocators when needed
 #define NALL_STRING_ALLOCATOR_ADAPTIVE
 //#define NALL_STRING_ALLOCATOR_COPY_ON_WRITE
 //#define NALL_STRING_ALLOCATOR_SMALL_STRING_OPTIMIZATION
@@ -128,6 +131,8 @@ public:
   inline string();
   template<typename T = char> inline auto get() -> T*;
   template<typename T = char> inline auto data() const -> const T*;
+  template<typename T = char> auto size() const -> uint { return _size / sizeof(T); }
+  template<typename T = char> auto capacity() const -> uint { return _capacity / sizeof(T); }
   inline auto reset() -> type&;
   inline auto reserve(uint) -> type&;
   inline auto resize(uint) -> type&;
@@ -142,9 +147,6 @@ public:
   explicit operator bool() const { return _size; }
   operator const char*() const { return (const char*)data(); }
 
-  auto size() const -> uint { return _size; }
-  auto capacity() const -> uint { return _capacity; }
-
   auto operator==(const string& source) const -> bool {
     return size() == source.size() && memory::compare(data(), source.data(), size()) == 0;
   }
@@ -271,6 +273,7 @@ public:
   inline auto remove(uint offset, uint length) -> type&;
   inline auto reverse() -> type&;
   inline auto size(int length, char fill = ' ') -> type&;
+  inline auto slice(int offset = 0, int length = -1) -> string;
 };
 
 template<> struct vector<string> : vector_base<string> {
@@ -286,7 +289,7 @@ template<> struct vector<string> : vector_base<string> {
   inline auto operator=(vector& source) -> type& { return vector_base::operator=(source), *this; }
   inline auto operator=(vector&& source) -> type& { return vector_base::operator=(move(source)), *this; }
 
-  //list.hpp
+  //vector.hpp
   template<typename... P> inline auto append(const string&, P&&...) -> type&;
   inline auto append() -> type&;
 
diff --git a/nall/string/allocator/copy-on-write.hpp b/nall/string/allocator/copy-on-write.hpp
index 6f2b53f2..c1a19ae5 100644
--- a/nall/string/allocator/copy-on-write.hpp
+++ b/nall/string/allocator/copy-on-write.hpp
@@ -5,17 +5,19 @@ namespace nall {
 string::string() : _data(nullptr), _refs(nullptr), _capacity(0), _size(0) {
 }
 
-auto string::get() -> char* {
+template<typename T>
+auto string::get() -> T* {
   static char _null[] = "";
-  if(!_data) return _null;
+  if(!_data) return (T*)_null;
   if(*_refs > 1) _data = _copy();  //make unique for write operations
-  return _data;
+  return (T*)_data;
 }
 
-auto string::data() const -> const char* {
+template<typename T>
+auto string::data() const -> const T* {
   static const char _null[] = "";
-  if(!_data) return _null;
-  return _data;
+  if(!_data) return (const T*)_null;
+  return (const T*)_data;
 }
 
 auto string::reset() -> type& {
diff --git a/nall/string/allocator/small-string-optimization.hpp b/nall/string/allocator/small-string-optimization.hpp
index a9d50142..39aad4e7 100644
--- a/nall/string/allocator/small-string-optimization.hpp
+++ b/nall/string/allocator/small-string-optimization.hpp
@@ -26,14 +26,16 @@ string::string() {
   _size = 0;
 }
 
-auto string::get() -> char* {
-  if(_capacity < SSO) return _text;
-  return _data;
+template<typename T>
+auto string::get() -> T* {
+  if(_capacity < SSO) return (T*)_text;
+  return (T*)_data;
 }
 
-auto string::data() const -> const char* {
-  if(_capacity < SSO) return _text;
-  return _data;
+template<typename T>
+auto string::data() const -> const T* {
+  if(_capacity < SSO) return (const T*)_text;
+  return (const T*)_data;
 }
 
 auto string::reset() -> type& {
diff --git a/nall/string/allocator/vector.hpp b/nall/string/allocator/vector.hpp
index daac258c..ad113162 100644
--- a/nall/string/allocator/vector.hpp
+++ b/nall/string/allocator/vector.hpp
@@ -19,14 +19,16 @@ cons:
 
 namespace nall {
 
-auto string::get() -> char* {
+template<typename T>
+auto string::get() -> T* {
   if(_capacity == 0) reserve(1);
-  return _data;
+  return (T*)_data;
 }
 
-auto string::data() const -> const char* {
-  if(_capacity == 0) return "";
-  return _data;
+template<typename T>
+auto string::data() const -> const T* {
+  if(_capacity == 0) return (const T*)"";
+  return (const T*)_data;
 }
 
 auto string::reset() -> type& {
diff --git a/nall/string/utility.hpp b/nall/string/utility.hpp
index 4dd255f6..d020dad6 100644
--- a/nall/string/utility.hpp
+++ b/nall/string/utility.hpp
@@ -95,6 +95,10 @@ auto slice(view<string> self, int offset, int length) -> string {
   return result;
 }
 
+auto string::slice(int offset, int length) -> string {
+  return nall::slice(*this, offset, length);
+}
+
 template<typename T> auto fromInteger(char* result, T value) -> char* {
   bool negative = value < 0;
   if(!negative) value = -value;  //negate positive integers to support eg INT_MIN
diff --git a/nall/suffix-array.hpp b/nall/suffix-array.hpp
new file mode 100644
index 00000000..4ff51503
--- /dev/null
+++ b/nall/suffix-array.hpp
@@ -0,0 +1,202 @@
+#pragma once
+
+#include <nall/counting-sort.hpp>
+#include <nall/div-suf-sort.hpp>
+#include <nall/range.hpp>
+
+namespace nall {
+
+/*
+
+input:
+  data = "acaaacatat"
+
+suffix_array:
+  suffixes = [2, 3, 0, 4, 8, 6, 1, 5, 9, 7]
+  2 "aaaacatat"
+  3 "aacatat"
+  0 "acaaacatat"
+  4 "acatat"
+  8 "at"
+  6 "atat"
+  1 "caaacatat"
+  5 "catat"
+  9 "t"
+  7 "tat"
+
+suffix_array_inv:
+  inverted = [2, 6, 0, 1, 3, 7, 5, 9, 4, 8]
+
+suffix_array_lcp:
+  prefixes = [-, 2, 1, 3, 1, 2, 0, 2, 0, 1]
+  "aaaacatat"  -
+  "aacatat"    2 "aa"
+  "acaaacatat" 1 "a"
+  "acatat"     3 "aca"
+  "at"         1 "a"
+  "atat"       2 "at"
+  "caaacatat"  0
+  "catat"      2 "ca"
+  "t"          0
+  "tat"        1 "t"
+
+suffix_array_phi:
+  phi = [3, 6, -, 2, 0, 1, 8, 9, 4, 5]
+
+suffix_array_lps:
+  lengths = [-, 0, 1, 2, 3, 2, 1, 0, 2, 1]
+  offsets = [-, -, 0, 2, 0, 1, 4, -, 6, 7]
+  "acaaacatat" (-,-)
+   "caaacatat" (0,-)
+    "aaacatat" (1,0) at 0, match "a"
+     "aacatat" (2,2) at 2, match "aa"
+      "acatat" (3,0) at 0, match "aca"
+       "catat" (2,1) at 1, match "ca"
+        "atat" (1,4) at 4, match "a" (not 0)
+         "tat" (0,-)
+          "at" (2,6) at 6, match "at"
+           "t" (1,7) at 7, match "a" (not 0)
+
+*/
+
+// O(n log n)
+inline auto suffix_array(int* suffixes, const uint8_t* data, int size) -> void {
+  for(int n : range(size)) suffixes[n] = n;
+  #if 1
+  div_suf_sort(suffixes, data, size);
+  #else
+  sort(suffixes, size, [&](int lhs, int rhs) -> bool {
+    return memory::compare(data + lhs, size - lhs, data + rhs, size - rhs) < 0;
+  });
+  #endif
+}
+
+// inverse
+// O(n)
+inline auto suffix_array_inv(int* inverted, const int* suffixes, int size) -> void {
+  for(int i : range(size)) inverted[suffixes[i]] = i;
+}
+
+// longest common prefix
+// O(n)
+inline auto suffix_array_lcp(int* prefixes, const int* inverted, const int* suffixes, const uint8_t* data, int size) -> void {
+  prefixes[0] = -1;
+  for(int i = 0, l = 0; i < size; i++) {
+    if(inverted[i] == size - 1) { l = 0; continue; }
+    int j = suffixes[inverted[i] + 1];
+    while(i + l < size && j + l < size && data[i + l] == data[j + l]) l++;
+    prefixes[1 + inverted[i]] = l;
+    if(l) l--;
+  }
+}
+
+// O(n)
+inline auto suffix_array_phi(int* phi, const int* suffixes, int size) -> void {
+  phi[suffixes[0]] = -1;
+  for(int i : range(1, size)) phi[suffixes[i]] = suffixes[i - 1];
+}
+
+// longest previous string (longest previous factor)
+// O(n)
+inline auto suffix_array_lps(int* lengths, int* offsets, const int* phi, const uint8_t* data, int size) -> void {
+  function<void (int, int, int)> sop = [&](int i, int l, int j) -> void {
+    if(lengths[i] < 0) {
+      lengths[i] = l;
+      offsets[i] = j;
+    } else {
+      if(lengths[i] < l) {
+        if(offsets[i] > j) {
+          sop(offsets[i], lengths[i], j);
+        } else {
+          sop(j, lengths[i], offsets[i]);
+        }
+        lengths[i] = l;
+        offsets[i] = j;
+      } else {
+        if(offsets[i] > j) {
+          sop(offsets[i], l, j);
+        } else {
+          sop(j, l, offsets[i]);
+        }
+      }
+    }
+  };
+
+  int l = 0;
+  for(int i : range(size)) lengths[i] = -1;
+  for(int i : range(size)) {
+    int j = phi[i];
+    while(i + l < size && j + l < size && data[i + l] == data[j + l]) l++;
+    if(i > j) {
+      sop(i, l, j);
+    } else {
+      sop(j, l, i);
+    }
+    if(l) l--;
+  }
+  lengths[0] = -1;
+}
+
+//partial_suffix_array computes a suffix array in O(n) time by only sorting by SuffixBits into each prefix
+//this is much faster than a proper suffix_array, but at the penalty of not being 100% sorted
+//thus, least common prefixes cannot readily be used with this; deduplication is suggested for binary searching
+//suffixes[] = (offsets) list of indexes into data[] in sorted order
+//prefixes[] = (values) sorted list of data[]
+
+template<uint SuffixBits, uint PrefixBits>
+inline auto partial_suffix_array(uint* suffixes, uint* prefixes, const void* data, uint64_t size, uint offset = 0) -> void;
+
+template<>
+inline auto partial_suffix_array<32, 24>(uint* suffixes, uint* prefixes, const void* data, uint64_t size, uint offset) -> void {
+  auto input = (const uint8_t*)data;
+  if(size == 0 || !data || !suffixes || !prefixes) return;
+  if(size == 1) return suffixes[0] = offset << 16, prefixes[0] = input[0], void();
+
+  auto elements = new uint64_t[2 * size], lhs = &elements[0], rhs = &elements[size];
+  for(uint index : range(size - 2)) {
+    elements[index] = index | uint64_t(input[0] << 16 | input[1] << 8 | input[2] << 0) << 32, input++;
+  }
+  elements[size - 2] = size - 2 | uint64_t(input[0] << 16 | input[1] << 8) << 32, input++;
+  elements[size - 1] = size - 1 | uint64_t(input[0] << 16) << 32;
+
+  counting_sort<12, 32>(rhs, lhs, size);
+  counting_sort<12, 44>(lhs, rhs, size);
+  for(uint n : range(size)) {
+    suffixes[n] = (uint32_t)lhs[n] + offset;
+    prefixes[n] = lhs[n] >> 32;
+  }
+
+  delete[] elements;
+}
+
+template<>
+inline auto partial_suffix_array<32, 32>(uint* suffixes, uint* prefixes, const void* data, uint64_t size, uint offset) -> void {
+  auto input = (const uint8_t*)data;
+  if(size == 0 || !data || !suffixes || !prefixes) return;
+  if(size == 1) return suffixes[0] = offset, prefixes[0] = input[0], void();
+  if(size == 2) {
+    suffixes[0] = offset, suffixes[1] = 1 + offset;
+    prefixes[0] = input[0] << 24 | input[1] << 16, prefixes[1] = input[1] << 24;
+    if(input[0] >= input[1]) swap(suffixes[0], suffixes[1]), swap(prefixes[0], prefixes[1]);
+    return;
+  }
+
+  auto elements = new uint64_t[2 * size], lhs = &elements[0], rhs = &elements[size];
+  for(uint index : range(size - 3)) {
+    elements[index] = index | uint64_t(input[0] << 24 | input[1] << 16 | input[2] << 8 |  input[3] << 0) << 32, input++;
+  }
+  elements[size - 3] = size - 3 | uint64_t(input[0] << 24 | input[1] << 16 | input[2] << 8) << 32, input++;
+  elements[size - 2] = size - 2 | uint64_t(input[0] << 24 | input[1] << 16) << 32, input++;
+  elements[size - 1] = size - 1 | uint64_t(input[0] << 24) << 32;
+
+  counting_sort<16, 32>(rhs, lhs, size);
+  counting_sort<16, 48>(lhs, rhs, size);
+  for(uint n : range(size)) {
+    suffixes[n] = (uint32_t)lhs[n] + offset;
+    prefixes[n] = lhs[n] >> 32;
+  }
+
+  delete[] elements;
+}
+
+}
diff --git a/nall/vector.hpp b/nall/vector.hpp
index 63033329..2f3ba982 100644
--- a/nall/vector.hpp
+++ b/nall/vector.hpp
@@ -5,10 +5,11 @@
 #include <nall/bit.hpp>
 #include <nall/function.hpp>
 #include <nall/iterator.hpp>
+#include <nall/literals.hpp>
 #include <nall/maybe.hpp>
 #include <nall/memory.hpp>
+#include <nall/merge-sort.hpp>
 #include <nall/range.hpp>
-#include <nall/sort.hpp>
 #include <nall/traits.hpp>
 
 namespace nall {
@@ -24,16 +25,18 @@ struct vector_base {
 
   //core.hpp
   vector_base() = default;
+  vector_base(Literal::Capacity capacity);
+  vector_base(Literal::Size size);
   vector_base(const initializer_list<T>& values);
   vector_base(const type& source);
   vector_base(type&& source);
   ~vector_base();
 
   explicit operator bool() const;
-  auto capacity() const -> uint;
-  auto size() const -> uint;
-  auto data() -> T*;
-  auto data() const -> const T*;
+  template<typename Cast = T> auto capacity() const -> uint;
+  template<typename Cast = T> auto size() const -> uint;
+  template<typename Cast = T> auto data(uint offset = 0) -> Cast*;
+  template<typename Cast = T> auto data(uint offset = 0) const -> const Cast*;
 
   //assign.hpp
   auto operator=(const type& source) -> type&;
@@ -112,6 +115,7 @@ struct vector_base {
   auto sort(const function<bool (const T& lhs, const T& rhs)>& comparator = [](auto& lhs, auto& rhs) { return lhs < rhs; }) -> void;
   auto find(const function<bool (const T& lhs)>& comparator) -> maybe<uint>;
   auto find(const T& value) const -> maybe<uint>;
+  auto findSorted(const T& value) const -> maybe<uint>;
   auto foreach(const function<void (const T&)>& callback) -> void;
   auto foreach(const function<void (uint, const T&)>& callback) -> void;
 
diff --git a/nall/vector/core.hpp b/nall/vector/core.hpp
index 0073b89a..fffcda03 100644
--- a/nall/vector/core.hpp
+++ b/nall/vector/core.hpp
@@ -2,6 +2,14 @@
 
 namespace nall {
 
+template<typename T> vector<T>::vector(Literal::Capacity capacity) {
+  reserve(capacity.value);
+}
+
+template<typename T> vector<T>::vector(Literal::Size size) {
+  resize(size.value);
+}
+
 template<typename T> vector<T>::vector(const initializer_list<T>& values) {
   reserveRight(values.size());
   for(auto& value : values) append(value);
@@ -23,20 +31,20 @@ template<typename T> vector<T>::operator bool() const {
   return _size;
 }
 
-template<typename T> auto vector<T>::capacity() const -> uint {
-  return _left + _size + _right;
+template<typename T> template<typename Cast> auto vector<T>::capacity() const -> uint {
+  return (_left + _size + _right) * sizeof(T) / sizeof(Cast);
 }
 
-template<typename T> auto vector<T>::size() const -> uint {
-  return _size;
+template<typename T> template<typename Cast> auto vector<T>::size() const -> uint {
+  return _size * sizeof(T) / sizeof(Cast);
 }
 
-template<typename T> auto vector<T>::data() -> T* {
-  return _pool;
+template<typename T> template<typename Cast> auto vector<T>::data(uint offset) -> Cast* {
+  return (Cast*)_pool + offset;
 }
 
-template<typename T> auto vector<T>::data() const -> const T* {
-  return _pool;
+template<typename T> template<typename Cast> auto vector<T>::data(uint offset) const -> const Cast* {
+  return (const Cast*)_pool + offset;
 }
 
 }
diff --git a/nall/vector/utility.hpp b/nall/vector/utility.hpp
index 78af637a..1a4c1214 100644
--- a/nall/vector/utility.hpp
+++ b/nall/vector/utility.hpp
@@ -16,6 +16,16 @@ template<typename T> auto vector<T>::find(const T& value) const -> maybe<uint> {
   return nothing;
 }
 
+template<typename T> auto vector<T>::findSorted(const T& value) const -> maybe<uint> {
+  int l = 0, r = size() - 1;
+  while(l <= r) {
+    int m = l + (r - l >> 1);
+    if(value == _pool[m]) return m;
+    value < _pool[m] ? r = m - 1 : l = m + 1;
+  }
+  return nothing;
+}
+
 template<typename T> auto vector<T>::foreach(const function<void (const T&)>& callback) -> void {
   for(uint n : range(size())) callback(_pool[n]);
 }
diff --git a/nall/windows/guard.hpp b/nall/windows/guard.hpp
index 60c9269f..aec11d47 100644
--- a/nall/windows/guard.hpp
+++ b/nall/windows/guard.hpp
@@ -4,6 +4,24 @@
 #define boolean WindowsBoolean
 #define interface WindowsInterface
 
+#undef UNICODE
+#undef WINVER
+#undef WIN32_LEAN_AND_LEAN
+#undef _WIN32_WINNT
+#undef _WIN32_IE
+#undef __MSVCRT_VERSION__
+#undef NOMINMAX
+#undef PATH_MAX
+
+#define UNICODE
+#define WINVER 0x0601
+#define WIN32_LEAN_AND_MEAN
+#define _WIN32_WINNT WINVER
+#define _WIN32_IE WINVER
+#define __MSVCRT_VERSION__ WINVER
+#define NOMINMAX
+#define PATH_MAX 260
+
 #else
 #undef NALL_WINDOWS_GUARD_HPP
 
diff --git a/nall/windows/utf8.hpp b/nall/windows/utf8.hpp
index 8ea49c60..98d98fef 100644
--- a/nall/windows/utf8.hpp
+++ b/nall/windows/utf8.hpp
@@ -1,24 +1,5 @@
 #pragma once
 
-//UTF-8 <> UTF-16 conversion
-//used only for Win32; every other OS uses UTF-8 internally
-
-#if defined(_WIN32)
-
-#undef  UNICODE
-#define UNICODE
-#undef  NOMINMAX
-#define NOMINMAX
-
-#include <nall/windows/guard.hpp>
-#include <winsock2.h>
-#include <windows.h>
-#include <nall/windows/guard.hpp>
-
-#if !defined(PATH_MAX)
-  #define PATH_MAX 260
-#endif
-
 using uint = unsigned;
 
 namespace nall {
@@ -94,7 +75,7 @@ namespace nall {
     uint length = 0;
   };
 
-  inline auto utf8_args(int& argc, char**& argv) -> void {
+  inline auto utf8_arguments(int& argc, char**& argv) -> void {
     wchar_t** wargv = CommandLineToArgvW(GetCommandLineW(), &argc);
     argv = new char*[argc + 1]();
     for(uint i = 0; i < argc; i++) {
@@ -103,5 +84,3 @@ namespace nall {
     }
   }
 }
-
-#endif  //if defined(_WIN32)
diff --git a/ruby/audio/xaudio2.cpp b/ruby/audio/xaudio2.cpp
index 1ccc4186..596c6f02 100644
--- a/ruby/audio/xaudio2.cpp
+++ b/ruby/audio/xaudio2.cpp
@@ -1,5 +1,4 @@
 #include "xaudio2.hpp"
-#include <windows.h>
 #undef interface
 
 struct AudioXAudio2 : AudioDriver, public IXAudio2VoiceCallback {
diff --git a/ruby/ruby.cpp b/ruby/ruby.cpp
index 5e537105..f392e7e9 100644
--- a/ruby/ruby.cpp
+++ b/ruby/ruby.cpp
@@ -21,7 +21,7 @@ using namespace ruby;
   #include <Carbon/Carbon.h>
   #include <nall/macos/guard.hpp>
 #elif defined(DISPLAY_WINDOWS)
-  #include <windows.h>
+  #include <mmsystem.h>
 #endif
 
 #include <ruby/video/video.cpp>
diff --git a/ruby/video/cgl.cpp b/ruby/video/cgl.cpp
index 4fac7c79..4a1f7a3f 100644
--- a/ruby/video/cgl.cpp
+++ b/ruby/video/cgl.cpp
@@ -26,7 +26,6 @@ struct VideoCGL : VideoDriver, OpenGL {
   auto hasContext() -> bool override { return true; }
   auto hasBlocking() -> bool override { return true; }
   auto hasFlush() -> bool override { return true; }
-  auto hasSmooth() -> bool override { return true; }
   auto hasShader() -> bool override { return true; }
 
   auto setContext(uintptr context) -> bool override {
@@ -47,14 +46,8 @@ struct VideoCGL : VideoDriver, OpenGL {
     return true;
   }
 
-  auto setSmooth(bool) -> bool override {
-    if(!self.shader) OpenGL::filter = self.smooth ? GL_LINEAR : GL_NEAREST;
-    return true;
-  }
-
-  auto setShader(string) -> bool override {
-    OpenGL::setShader(self.shader);
-    if(!self.shader) OpenGL::filter = self.smooth ? GL_LINEAR : GL_NEAREST;
+  auto setShader(string shader) -> bool override {
+    OpenGL::setShader(shader);
     return true;
   }
 
diff --git a/ruby/video/direct3d.cpp b/ruby/video/direct3d.cpp
index 80011fde..2d22d236 100644
--- a/ruby/video/direct3d.cpp
+++ b/ruby/video/direct3d.cpp
@@ -22,12 +22,12 @@ struct VideoDirect3D : VideoDriver {
   auto hasExclusive() -> bool override { return true; }
   auto hasContext() -> bool override { return true; }
   auto hasBlocking() -> bool override { return true; }
-  auto hasSmooth() -> bool override { return true; }
+  auto hasShader() -> bool override { return true; }
 
   auto setExclusive(bool exclusive) -> bool override { return initialize(); }
   auto setContext(uintptr context) -> bool override { return initialize(); }
   auto setBlocking(bool blocking) -> bool override { return true; }
-  auto setSmooth(bool smooth) -> bool override { return updateFilter(); }
+  auto setShader(string shader) -> bool override { return updateFilter(); }
 
   auto clear() -> void override {
     if(!ready()) return;
@@ -169,7 +169,7 @@ private:
     if(!_device) return false;
     if(_lost && !recover()) return false;
 
-    auto filter = !self.smooth ? D3DTEXF_POINT : D3DTEXF_LINEAR;
+    auto filter = self.shader == "Blur" ? D3DTEXF_LINEAR : D3DTEXF_POINT;
     _device->SetSamplerState(0, D3DSAMP_MINFILTER, filter);
     _device->SetSamplerState(0, D3DSAMP_MAGFILTER, filter);
     return true;
diff --git a/ruby/video/directdraw.cpp b/ruby/video/directdraw.cpp
index a0a63842..8d68b16e 100644
--- a/ruby/video/directdraw.cpp
+++ b/ruby/video/directdraw.cpp
@@ -7,6 +7,7 @@ struct VideoDirectDraw : VideoDriver {
   ~VideoDirectDraw() { terminate(); }
 
   auto create() -> bool override {
+    super.setShader("Blur");
     return initialize();
   }
 
diff --git a/ruby/video/gdi.cpp b/ruby/video/gdi.cpp
index 8e4a9f2a..e4579ce5 100644
--- a/ruby/video/gdi.cpp
+++ b/ruby/video/gdi.cpp
@@ -4,6 +4,7 @@ struct VideoGDI : VideoDriver {
   ~VideoGDI() { terminate(); }
 
   auto create() -> bool override {
+    super.setShader("None");
     return initialize();
   }
 
diff --git a/ruby/video/glx.cpp b/ruby/video/glx.cpp
index c72474c2..da5a536d 100644
--- a/ruby/video/glx.cpp
+++ b/ruby/video/glx.cpp
@@ -23,7 +23,6 @@ struct VideoGLX : VideoDriver, OpenGL {
   auto hasContext() -> bool override { return true; }
   auto hasBlocking() -> bool override { return true; }
   auto hasFlush() -> bool override { return true; }
-  auto hasSmooth() -> bool override { return true; }
   auto hasShader() -> bool override { return true; }
 
   auto hasFormats() -> vector<string> override {
@@ -57,14 +56,8 @@ struct VideoGLX : VideoDriver, OpenGL {
     return false;
   }
 
-  auto setSmooth(bool) -> bool override {
-    if(!self.shader) OpenGL::filter = self.smooth ? GL_LINEAR : GL_NEAREST;
-    return true;
-  }
-
-  auto setShader(string) -> bool override {
-    OpenGL::setShader(self.shader);
-    if(!self.shader) OpenGL::filter = self.smooth ? GL_LINEAR : GL_NEAREST;
+  auto setShader(string shader) -> bool override {
+    OpenGL::setShader(shader);
     return true;
   }
 
@@ -214,7 +207,7 @@ private:
     _doubleBuffer = value;
     _isDirect = glXIsDirect(_display, _glXContext);
 
-    return _ready = OpenGL::initialize();
+    return _ready = OpenGL::initialize(self.shader);
   }
 
   auto terminate() -> void {
diff --git a/ruby/video/glx2.cpp b/ruby/video/glx2.cpp
index 88a4c934..667113e7 100644
--- a/ruby/video/glx2.cpp
+++ b/ruby/video/glx2.cpp
@@ -38,7 +38,7 @@ struct VideoGLX2 : VideoDriver {
   auto hasBlocking() -> bool override { return true; }
   auto hasFlush() -> bool override { return true; }
   auto hasFormats() -> vector<string> override { return {"RGB24"}; }
-  auto hasSmooth() -> bool override { return true; }
+  auto hasShader() -> bool override { return true; }
 
   auto setContext(uintptr context) -> bool override {
     return initialize();
@@ -63,6 +63,15 @@ struct VideoGLX2 : VideoDriver {
     return false;
   }
 
+  auto setShader(string shader) -> bool override {
+    return true;
+  }
+
+  auto configure(uint width, uint height, double inputFrequency, double outputFrequency) -> bool override {
+    XResizeWindow(_display, _window, width, height);
+    return true;
+  }
+
   auto clear() -> void override {
     memory::fill<uint32_t>(_glBuffer, _glWidth * _glHeight);
     glClearColor(0.0, 0.0, 0.0, 1.0);
@@ -81,22 +90,15 @@ struct VideoGLX2 : VideoDriver {
   }
 
   auto output() -> void override {
-    XWindowAttributes parent, child;
-    XGetWindowAttributes(_display, (Window)self.context, &parent);
-    XGetWindowAttributes(_display, _window, &child);
-    if(child.width != parent.width || child.height != parent.height) {
-      XResizeWindow(_display, _window, parent.width, parent.height);
-    }
-
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, self.smooth ? GL_LINEAR : GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, self.smooth ? GL_LINEAR : GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, self.shader == "Blur" ? GL_LINEAR : GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, self.shader == "Blur" ? GL_LINEAR : GL_NEAREST);
 
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
-    glOrtho(0, parent.width, 0, parent.height, -1.0, 1.0);
-    glViewport(0, 0, parent.width, parent.height);
+    glOrtho(0, self.width, 0, self.height, -1.0, 1.0);
+    glViewport(0, 0, self.width, self.height);
 
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
@@ -105,8 +107,8 @@ struct VideoGLX2 : VideoDriver {
 
     double w = (double)_width / (double)_glWidth;
     double h = (double)_height / (double)_glHeight;
-    int u = parent.width;
-    int v = parent.height;
+    int u = self.width;
+    int v = self.height;
 
     glBegin(GL_TRIANGLE_STRIP);
     glTexCoord2f(0, 0); glVertex3i(0, v, 0);
@@ -261,6 +263,7 @@ private:
   }
 
   bool _ready = false;
+  bool blur = false;
 
   Display* _display = nullptr;
   int _screen = 0;
diff --git a/ruby/video/opengl/main.hpp b/ruby/video/opengl/main.hpp
index 6a6b4608..de7c67e5 100644
--- a/ruby/video/opengl/main.hpp
+++ b/ruby/video/opengl/main.hpp
@@ -11,7 +11,11 @@ auto OpenGL::setShader(const string& pathname) -> void {
   relativeWidth = 0, relativeHeight = 0;
 
   uint historySize = 0;
-  if(pathname) {
+  if(pathname == "None") {
+    filter = GL_NEAREST;
+  } else if(pathname == "Blur") {
+    filter = GL_LINEAR;
+  } else if(directory::exists(pathname)) {
     auto document = BML::unserialize(file::read({pathname, "manifest.bml"}));
 
     for(auto node : document["settings"]) {
@@ -180,7 +184,7 @@ auto OpenGL::output() -> void {
   }
 }
 
-auto OpenGL::initialize() -> bool {
+auto OpenGL::initialize(const string& shader) -> bool {
   if(!OpenGLBind()) return false;
 
   glDisable(GL_BLEND);
@@ -196,7 +200,7 @@ auto OpenGL::initialize() -> bool {
   OpenGLSurface::allocate();
   glrLinkProgram(program);
 
-  setShader("");
+  setShader(shader);
   return initialized = true;
 }
 
diff --git a/ruby/video/opengl/opengl.hpp b/ruby/video/opengl/opengl.hpp
index 0b568550..78552333 100644
--- a/ruby/video/opengl/opengl.hpp
+++ b/ruby/video/opengl/opengl.hpp
@@ -70,7 +70,7 @@ struct OpenGL : OpenGLProgram {
   auto clear() -> void;
   auto lock(uint32_t*& data, uint& pitch) -> bool;
   auto output() -> void;
-  auto initialize() -> bool;
+  auto initialize(const string& shader) -> bool;
   auto terminate() -> void;
 
   vector<OpenGLProgram> programs;
diff --git a/ruby/video/video.cpp b/ruby/video/video.cpp
index 9ec2ae14..7c54dd84 100644
--- a/ruby/video/video.cpp
+++ b/ruby/video/video.cpp
@@ -71,13 +71,6 @@ auto Video::setFormat(string format) -> bool {
   return true;
 }
 
-auto Video::setSmooth(bool smooth) -> bool {
-  if(instance->smooth == smooth) return true;
-  if(!instance->hasSmooth()) return false;
-  if(!instance->setSmooth(instance->smooth = smooth)) return false;
-  return true;
-}
-
 auto Video::setShader(string shader) -> bool {
   if(instance->shader == shader) return true;
   if(!instance->hasShader()) return false;
@@ -87,6 +80,14 @@ auto Video::setShader(string shader) -> bool {
 
 //
 
+auto Video::configure(uint width, uint height, double inputFrequency, double outputFrequency) -> bool {
+  instance->width = width;
+  instance->height = height;
+  instance->inputFrequency = inputFrequency;
+  instance->outputFrequency = outputFrequency;
+  return instance->configure(width, height, inputFrequency, outputFrequency);
+}
+
 auto Video::clear() -> void {
   return instance->clear();
 }
diff --git a/ruby/video/video.hpp b/ruby/video/video.hpp
index 29943f9e..456f6d06 100644
--- a/ruby/video/video.hpp
+++ b/ruby/video/video.hpp
@@ -13,7 +13,6 @@ struct VideoDriver {
   virtual auto hasBlocking() -> bool { return false; }
   virtual auto hasFlush() -> bool { return false; }
   virtual auto hasFormats() -> vector<string> { return {"RGB24"}; }
-  virtual auto hasSmooth() -> bool { return false; }
   virtual auto hasShader() -> bool { return false; }
 
   auto hasFormat(string format) -> bool { return (bool)hasFormats().find(format); }
@@ -23,9 +22,9 @@ struct VideoDriver {
   virtual auto setBlocking(bool blocking) -> bool { return true; }
   virtual auto setFlush(bool flush) -> bool { return true; }
   virtual auto setFormat(string format) -> bool { return true; }
-  virtual auto setSmooth(bool smooth) -> bool { return true; }
   virtual auto setShader(string shader) -> bool { return true; }
 
+  virtual auto configure(uint width, uint height, double inputFrequency, double outputFrequency) -> bool { return true; }
   virtual auto clear() -> void {}
   virtual auto acquire(uint32_t*& data, uint& pitch, uint width, uint height) -> bool { return false; }
   virtual auto release() -> void {}
@@ -41,8 +40,12 @@ protected:
   bool blocking = false;
   bool flush = false;
   string format = "RGB24";
-  bool smooth = false;
-  string shader = "";
+  string shader = "Blur";
+
+  uint width = 0;
+  uint height = 0;
+  double inputFrequency = 0.0;
+  double outputFrequency = 0.0;
 };
 
 struct Video {
@@ -63,7 +66,6 @@ struct Video {
   auto hasBlocking() -> bool { return instance->hasBlocking(); }
   auto hasFlush() -> bool { return instance->hasFlush(); }
   auto hasFormats() -> vector<string> { return instance->hasFormats(); }
-  auto hasSmooth() -> bool { return instance->hasSmooth(); }
   auto hasShader() -> bool { return instance->hasShader(); }
 
   auto hasFormat(string format) -> bool { return instance->hasFormat(format); }
@@ -73,7 +75,6 @@ struct Video {
   auto blocking() -> bool { return instance->blocking; }
   auto flush() -> bool { return instance->flush; }
   auto format() -> string { return instance->format; }
-  auto smooth() -> bool { return instance->smooth; }
   auto shader() -> string { return instance->shader; }
 
   auto setExclusive(bool exclusive) -> bool;
@@ -81,9 +82,9 @@ struct Video {
   auto setBlocking(bool blocking) -> bool;
   auto setFlush(bool flush) -> bool;
   auto setFormat(string format) -> bool;
-  auto setSmooth(bool smooth) -> bool;
   auto setShader(string shader) -> bool;
 
+  auto configure(uint width, uint height, double inputFrequency, double outputFrequency) -> bool;
   auto clear() -> void;
   auto acquire(uint32_t*& data, uint& pitch, uint width, uint height) -> bool;
   auto release() -> void;
diff --git a/ruby/video/wgl.cpp b/ruby/video/wgl.cpp
index 78f6799e..cbaf20c0 100644
--- a/ruby/video/wgl.cpp
+++ b/ruby/video/wgl.cpp
@@ -18,7 +18,6 @@ struct VideoWGL : VideoDriver, OpenGL {
   auto hasContext() -> bool override { return true; }
   auto hasBlocking() -> bool override { return true; }
   auto hasFlush() -> bool override { return true; }
-  auto hasSmooth() -> bool override { return true; }
   auto hasShader() -> bool override { return true; }
 
   auto setContext(uintptr context) -> bool override {
@@ -34,14 +33,8 @@ struct VideoWGL : VideoDriver, OpenGL {
     return true;
   }
 
-  auto setSmooth(bool) -> bool override {
-    if(!self.shader) OpenGL::filter = self.smooth ? GL_LINEAR : GL_NEAREST;
-    return true;
-  }
-
-  auto setShader(string) -> bool override {
+  auto setShader(string shader) -> bool override {
     OpenGL::setShader(self.shader);
-    if(!self.shader) OpenGL::filter = self.smooth ? GL_LINEAR : GL_NEAREST;
     return true;
   }
 
@@ -104,7 +97,7 @@ private:
     }
 
     if(wglSwapInterval) wglSwapInterval(self.blocking);
-    return _ready = OpenGL::initialize();
+    return _ready = OpenGL::initialize(self.shader);
   }
 
   auto terminate() -> void {
diff --git a/ruby/video/xshm.cpp b/ruby/video/xshm.cpp
index 7d581572..f7e85b66 100644
--- a/ruby/video/xshm.cpp
+++ b/ruby/video/xshm.cpp
@@ -21,12 +21,29 @@ struct VideoXShm : VideoDriver {
   auto ready() -> bool override { return _ready; }
 
   auto hasContext() -> bool override { return true; }
-  auto hasSmooth() -> bool override { return true; }
+  auto hasShader() -> bool override { return true; }
 
   auto hasFormats() -> vector<string> override { return {"RGB24"}; }
 
   auto setContext(uintptr context) -> bool override { return initialize(); }
-  auto setSmooth(bool smooth) -> bool override { return true; }
+  auto setShader(string shader) -> bool override { return true; }
+
+  auto configure(uint width, uint height, double inputFrequency, double outputFrequency) -> bool override {
+    _outputWidth = width;
+    _outputHeight = height;
+    XResizeWindow(_display, _window, _outputWidth, _outputHeight);
+    free();
+
+    _shmInfo.shmid = shmget(IPC_PRIVATE, _outputWidth * _outputHeight * sizeof(uint32_t), IPC_CREAT | 0777);
+    if(_shmInfo.shmid < 0) return false;
+
+    _shmInfo.shmaddr = (char*)shmat(_shmInfo.shmid, 0, 0);
+    _shmInfo.readOnly = False;
+    XShmAttach(_display, &_shmInfo);
+    _outputBuffer = (uint32_t*)_shmInfo.shmaddr;
+    _image = XShmCreateImage(_display, _visual, _depth, ZPixmap, _shmInfo.shmaddr, &_shmInfo, _outputWidth, _outputHeight);
+    return true;
+  }
 
   auto clear() -> void override {
     auto dp = _inputBuffer;
@@ -65,7 +82,7 @@ struct VideoXShm : VideoDriver {
       uint32_t* sp = _inputBuffer + (uint)ystep * _inputWidth;
       uint32_t* dp = _outputBuffer + y * _outputWidth;
 
-      if(!self.smooth) {
+      if(self.shader != "Blur") {
         for(uint x = 0; x < _outputWidth; x++) {
           *dp++ = 255u << 24 | sp[(uint)xstep];
           xstep += xratio;
@@ -145,23 +162,6 @@ private:
   }
 
   auto size() -> bool {
-    XWindowAttributes windowAttributes;
-    XGetWindowAttributes(_display, (Window)self.context, &windowAttributes);
-
-    if(_outputBuffer && _outputWidth == windowAttributes.width && _outputHeight == windowAttributes.height) return true;
-    _outputWidth = windowAttributes.width;
-    _outputHeight = windowAttributes.height;
-    XResizeWindow(_display, _window, _outputWidth, _outputHeight);
-    free();
-
-    _shmInfo.shmid = shmget(IPC_PRIVATE, _outputWidth * _outputHeight * sizeof(uint32_t), IPC_CREAT | 0777);
-    if(_shmInfo.shmid < 0) return false;
-
-    _shmInfo.shmaddr = (char*)shmat(_shmInfo.shmid, 0, 0);
-    _shmInfo.readOnly = False;
-    XShmAttach(_display, &_shmInfo);
-    _outputBuffer = (uint32_t*)_shmInfo.shmaddr;
-    _image = XShmCreateImage(_display, _visual, _depth, ZPixmap, _shmInfo.shmaddr, &_shmInfo, _outputWidth, _outputHeight);
 
     return true;
   }
diff --git a/ruby/video/xvideo.cpp b/ruby/video/xvideo.cpp
index cfe60b28..9fb7b3ae 100644
--- a/ruby/video/xvideo.cpp
+++ b/ruby/video/xvideo.cpp
@@ -12,6 +12,7 @@ struct VideoXVideo : VideoDriver {
   ~VideoXVideo() { terminate(); }
 
   auto create() -> bool override {
+    super.setShader("Blur");
     return initialize();
   }