diff --git a/higan/emulator/emulator.hpp b/higan/emulator/emulator.hpp
index c4f9891c..fd44948c 100644
--- a/higan/emulator/emulator.hpp
+++ b/higan/emulator/emulator.hpp
@@ -11,7 +11,7 @@ using namespace nall;
 
 namespace Emulator {
   static const string Name    = "higan";
-  static const string Version = "101.01";
+  static const string Version = "101.02";
   static const string Author  = "byuu";
   static const string License = "GPLv3";
   static const string Website = "http://byuu.org/";
diff --git a/higan/emulator/thread.hpp b/higan/emulator/thread.hpp
index d1358fea..39d2bdef 100644
--- a/higan/emulator/thread.hpp
+++ b/higan/emulator/thread.hpp
@@ -3,7 +3,7 @@
 namespace Emulator {
 
 struct Thread {
-  enum : uintmax { Second = (uintmax)1 << (8 * sizeof(uintmax) - 1) };
+  enum : uintmax { Second = (uintmax)-1 >> 1 };
 
   virtual ~Thread() {
     if(_handle) co_delete(_handle);
diff --git a/higan/processor/m68k/disassembler.cpp b/higan/processor/m68k/disassembler.cpp
index 64917c68..442aa0b9 100644
--- a/higan/processor/m68k/disassembler.cpp
+++ b/higan/processor/m68k/disassembler.cpp
@@ -165,12 +165,36 @@ auto M68K::disassembleBCC(uint4 condition, uint8 displacement) -> string {
   return {"b", cc, "     ", _branch(displacement)};
 }
 
-template<uint Size> auto M68K::disassembleBTST(DataRegister dr, EffectiveAddress ea) -> string {
-  return {"btst    ", _dataRegister(dr), ",", _effectiveAddress<Size>(ea)};
+template<uint Size> auto M68K::disassembleBCHG(DataRegister bit, EffectiveAddress with) -> string {
+  return {"bchg", _suffix<Size>(), "  ", _dataRegister(bit), ",", _effectiveAddress<Size>(with)};
 }
 
-template<uint Size> auto M68K::disassembleBTST(EffectiveAddress ea) -> string {
-  return {"btst    ", _immediate<Byte>(), ",", _effectiveAddress<Size>(ea)};
+template<uint Size> auto M68K::disassembleBCHG(EffectiveAddress with) -> string {
+  return {"bchg", _suffix<Size>(), "  ", _immediate<Byte>(), ",", _effectiveAddress<Size>(with)};
+}
+
+template<uint Size> auto M68K::disassembleBCLR(DataRegister bit, EffectiveAddress with) -> string {
+  return {"bclr", _suffix<Size>(), "  ", _dataRegister(bit), ",", _effectiveAddress<Size>(with)};
+}
+
+template<uint Size> auto M68K::disassembleBCLR(EffectiveAddress with) -> string {
+  return {"bclr", _suffix<Size>(), "  ", _immediate<Byte>(), ",", _effectiveAddress<Size>(with)};
+}
+
+template<uint Size> auto M68K::disassembleBSET(DataRegister bit, EffectiveAddress with) -> string {
+  return {"bset", _suffix<Size>(), "  ", _dataRegister(bit), ",", _effectiveAddress<Size>(with)};
+}
+
+template<uint Size> auto M68K::disassembleBSET(EffectiveAddress with) -> string {
+  return {"bset", _suffix<Size>(), "  ", _immediate<Byte>(), ",", _effectiveAddress<Size>(with)};
+}
+
+template<uint Size> auto M68K::disassembleBTST(DataRegister bit, EffectiveAddress with) -> string {
+  return {"btst", _suffix<Size>(), "  ", _dataRegister(bit), ",", _effectiveAddress<Size>(with)};
+}
+
+template<uint Size> auto M68K::disassembleBTST(EffectiveAddress with) -> string {
+  return {"btst", _suffix<Size>(), "  ", _immediate<Byte>(), ",", _effectiveAddress<Size>(with)};
 }
 
 template<uint Size> auto M68K::disassembleCLR(EffectiveAddress ea) -> string {
@@ -215,6 +239,10 @@ auto M68K::disassembleEORI_TO_SR() -> string {
   return {"eori    ", _immediate<Word>(), ",sr"};
 }
 
+auto M68K::disassembleJMP(EffectiveAddress target) -> string {
+  return {"jmp     ", _effectiveAddress<Long>(target)};
+}
+
 auto M68K::disassembleJSR(EffectiveAddress target) -> string {
   return {"jsr     ", _effectiveAddress<Long>(target)};
 }
@@ -289,18 +317,30 @@ auto M68K::disassembleMOVE_TO_SR(EffectiveAddress ea) -> string {
   return {"move    ", _effectiveAddress<Word>(ea), ",sr"};
 }
 
-auto M68K::disassembleMOVE_USP(uint1 direction, AddressRegister ar) -> string {
-  if(direction == 0) {
-    return {"move    ", _addressRegister(ar), ",usp"};
-  } else {
-    return {"move    usp,", _addressRegister(ar)};
-  }
+auto M68K::disassembleMOVE_FROM_USP(AddressRegister to) -> string {
+  return {"move    usp,", _addressRegister(to)};
+}
+
+auto M68K::disassembleMOVE_TO_USP(AddressRegister from) -> string {
+  return {"move    ", _addressRegister(from), ",usp"};
+}
+
+template<uint Size> auto M68K::disassembleNEG(EffectiveAddress with) -> string {
+  return {"neg", _suffix<Size>(), "   ", _effectiveAddress<Size>(with)};
+}
+
+template<uint Size> auto M68K::disassembleNEGX(EffectiveAddress with) -> string {
+  return {"negx", _suffix<Size>(), "  ", _effectiveAddress<Size>(with)};
 }
 
 auto M68K::disassembleNOP() -> string {
   return {"nop     "};
 }
 
+template<uint Size> auto M68K::disassembleNOT(EffectiveAddress with) -> string {
+  return {"not", _suffix<Size>(), "   ", _effectiveAddress<Size>(with)};
+}
+
 template<uint Size> auto M68K::disassembleOR(EffectiveAddress from, DataRegister with) -> string {
   return {"eor", _suffix<Size>(), "   ", _effectiveAddress<Size>(from), ",", _dataRegister(with)};
 }
@@ -369,10 +409,22 @@ auto M68K::disassembleROXR(EffectiveAddress modify) -> string {
   return {"roxr", _suffix<Word>(), "  ", _effectiveAddress<Word>(modify)};
 }
 
+auto M68K::disassembleRTE() -> string {
+  return {"rte     "};
+}
+
+auto M68K::disassembleRTR() -> string {
+  return {"rtr     "};
+}
+
 auto M68K::disassembleRTS() -> string {
   return {"rts     "};
 }
 
+auto M68K::disassembleSCC(uint4 condition, EffectiveAddress to) -> string {
+  return {"s", _condition(condition), "     ", _effectiveAddress<Byte>(to)};
+}
+
 template<uint Size> auto M68K::disassembleSUB(EffectiveAddress source, DataRegister target) -> string {
   return {"sub", _suffix<Size>(), "   ", _effectiveAddress<Size>(source), ",", _dataRegister(target)};
 }
diff --git a/higan/processor/m68k/instruction.cpp b/higan/processor/m68k/instruction.cpp
index 45690f79..7ba6b7e2 100644
--- a/higan/processor/m68k/instruction.cpp
+++ b/higan/processor/m68k/instruction.cpp
@@ -253,6 +253,78 @@ M68K::M68K() {
     bind(opcode, BCC, condition, displacement);
   }
 
+  //BCHG (register)
+  for(uint3 dreg : range(8))
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0000 ---1 01-- ----") | dreg << 9 | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    DataRegister bit{dreg};
+    EffectiveAddress with{mode, reg};
+    if(mode == 0) bind(opcode, BCHG<Long>, bit, with);
+    if(mode != 0) bind(opcode, BCHG<Byte>, bit, with);
+  }
+
+  //BCHG (immediate)
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0000 1000 01-- ----") | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    EffectiveAddress with{mode, reg};
+    if(mode == 0) bind(opcode, BCHG<Long>, with);
+    if(mode != 0) bind(opcode, BCHG<Byte>, with);
+  }
+
+  //BCLR (register)
+  for(uint3 dreg : range(8))
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0000 ---1 10-- ----") | dreg << 9 | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    DataRegister bit{dreg};
+    EffectiveAddress with{mode, reg};
+    if(mode == 0) bind(opcode, BCLR<Long>, bit, with);
+    if(mode != 0) bind(opcode, BCLR<Byte>, bit, with);
+  }
+
+  //BCLR (immediate)
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0000 1000 10-- ----") | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    EffectiveAddress with{mode, reg};
+    if(mode == 0) bind(opcode, BCLR<Long>, with);
+    if(mode != 0) bind(opcode, BCLR<Byte>, with);
+  }
+
+  //BSET (register)
+  for(uint3 dreg : range(8))
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0000 ---1 11-- ----") | dreg << 9 | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    DataRegister bit{dreg};
+    EffectiveAddress with{mode, reg};
+    if(mode == 0) bind(opcode, BSET<Long>, bit, with);
+    if(mode != 0) bind(opcode, BSET<Byte>, bit, with);
+  }
+
+  //BSET (immediate)
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0000 1000 11-- ----") | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    EffectiveAddress with{mode, reg};
+    if(mode == 0) bind(opcode, BSET<Long>, with);
+    if(mode != 0) bind(opcode, BSET<Byte>, with);
+  }
+
   //BTST (register)
   for(uint3 dreg : range(8))
   for(uint3 mode : range(8))
@@ -270,7 +342,7 @@ M68K::M68K() {
   for(uint3 mode : range(8))
   for(uint3 reg  : range(8)) {
     auto opcode = pattern("0000 1000 00-- ----") | mode << 3 | reg << 0;
-    if(mode == 1 || (mode == 7 && (reg == 2 || reg >= 5))) continue;
+    if(mode == 1 || (mode == 7 && reg >= 4)) continue;
 
     EffectiveAddress ea{mode, reg};
     if(mode == 0) bind(opcode, BTST<Long>, ea);
@@ -388,6 +460,16 @@ M68K::M68K() {
     bind(opcode, EORI_TO_SR);
   }
 
+  //JMP
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0100 1110 11-- ----") | mode << 3 | reg << 0;
+    if(mode <= 1 || mode == 3 || mode == 4 || (mode == 7 && reg >= 4)) continue;
+
+    EffectiveAddress target{mode, reg};
+    bind(opcode, JMP, target);
+  }
+
   //JSR
   for(uint3 mode : range(8))
   for(uint3 reg  : range(8)) {
@@ -561,13 +643,44 @@ M68K::M68K() {
     bind(opcode, MOVE_TO_SR, ea);
   }
 
-  //MOVE_USP
-  for(uint1 direction : range(2))
-  for(uint3 areg      : range(8)) {
-    auto opcode = pattern("0100 1110 0110 ----") | direction << 3 | areg << 0;
+  //MOVE_FROM_USP
+  for(uint3 areg : range(8)) {
+    auto opcode = pattern("0100 1110 0110 1---") | areg << 0;
 
-    AddressRegister ar{areg};
-    bind(opcode, MOVE_USP, direction, ar);
+    AddressRegister to{areg};
+    bind(opcode, MOVE_FROM_USP, to);
+  }
+
+  //MOVE_TO_USP
+  for(uint3 areg : range(8)) {
+    auto opcode = pattern("0100 1110 0110 0---") | areg << 0;
+
+    AddressRegister from{areg};
+    bind(opcode, MOVE_TO_USP, from);
+  }
+
+  //NEG
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0100 0100 ++-- ----") | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    EffectiveAddress with{mode, reg};
+    bind(opcode | 0 << 6, NEG<Byte>, with);
+    bind(opcode | 1 << 6, NEG<Word>, with);
+    bind(opcode | 2 << 6, NEG<Long>, with);
+  }
+
+  //NEGX
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0100 0000 ++-- ----") | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    EffectiveAddress with{mode, reg};
+    bind(opcode | 0 << 6, NEGX<Byte>, with);
+    bind(opcode | 1 << 6, NEGX<Word>, with);
+    bind(opcode | 2 << 6, NEGX<Long>, with);
   }
 
   //NOP
@@ -576,6 +689,18 @@ M68K::M68K() {
     bind(opcode, NOP);
   }
 
+  //NOT
+  for(uint3 mode : range(8))
+  for(uint3 reg  : range(8)) {
+    auto opcode = pattern("0100 0110 ++-- ----") | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    EffectiveAddress with{mode, reg};
+    bind(opcode | 0 << 6, NOT<Byte>, with);
+    bind(opcode | 1 << 6, NOT<Word>, with);
+    bind(opcode | 2 << 6, NOT<Long>, with);
+  }
+
   //OR
   for(uint3 dreg : range(8))
   for(uint3 mode : range(8))
@@ -764,12 +889,35 @@ M68K::M68K() {
     bind(opcode, ROXR, modify);
   }
 
+  //RTE
+  { auto opcode = pattern("0100 1110 0111 0011");
+
+    bind(opcode, RTE);
+  }
+
+  //RTR
+  { auto opcode = pattern("0100 1110 0111 0111");
+
+    bind(opcode, RTR);
+  }
+
   //RTS
   { auto opcode = pattern("0100 1110 0111 0101");
 
     bind(opcode, RTS);
   }
 
+  //SCC
+  for(uint4 condition : range(16))
+  for(uint3 mode      : range( 8))
+  for(uint3 reg       : range( 8)) {
+    auto opcode = pattern("0101 ---- 11-- ----") | condition << 8 | mode << 3 | reg << 0;
+    if(mode == 1 || (mode == 7 && reg >= 2)) continue;
+
+    EffectiveAddress to{mode, reg};
+    bind(opcode, SCC, condition, to);
+  }
+
   //SUB
   for(uint3 dreg : range(8))
   for(uint3 mode : range(8))
diff --git a/higan/processor/m68k/instructions.cpp b/higan/processor/m68k/instructions.cpp
index b170fc8b..2fcdec44 100644
--- a/higan/processor/m68k/instructions.cpp
+++ b/higan/processor/m68k/instructions.cpp
@@ -243,20 +243,64 @@ auto M68K::instructionBCC(uint4 condition, uint8 displacement) -> void {
   }
 }
 
-template<uint Size> auto M68K::instructionBTST(DataRegister dr, EffectiveAddress ea) -> void {
-  auto bit = read<Size>(dr);
-  auto test = read<Size>(ea);
-  bit &= bits<Size>() - 1;
-
-  r.z = test.bit(bit) == 0;
+template<uint Size> auto M68K::instructionBCHG(DataRegister bit, EffectiveAddress with) -> void {
+  auto index = read<Size>(bit) & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
+  test.bit(index) ^= 1;
+  write<Size>(with, test);
 }
 
-template<uint Size> auto M68K::instructionBTST(EffectiveAddress ea) -> void {
-  auto bit = (uint8)readPC<Word>();
-  auto test = read<Size>(ea);
-  bit &= bits<Size>() - 1;
+template<uint Size> auto M68K::instructionBCHG(EffectiveAddress with) -> void {
+  auto index = readPC<Word>() & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
+  test.bit(index) ^= 1;
+  write<Size>(with, test);
+}
 
-  r.z = test.bit(bit) == 0;
+template<uint Size> auto M68K::instructionBCLR(DataRegister bit, EffectiveAddress with) -> void {
+  auto index = read<Size>(bit) & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
+  test.bit(index) = 0;
+  write<Size>(with, test);
+}
+
+template<uint Size> auto M68K::instructionBCLR(EffectiveAddress with) -> void {
+  auto index = readPC<Word>() & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
+  test.bit(index) = 0;
+  write<Size>(with, test);
+}
+
+template<uint Size> auto M68K::instructionBSET(DataRegister bit, EffectiveAddress with) -> void {
+  auto index = read<Size>(bit) & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
+  test.bit(index) = 1;
+  write<Size>(with, test);
+}
+
+template<uint Size> auto M68K::instructionBSET(EffectiveAddress with) -> void {
+  auto index = readPC<Word>() & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
+  test.bit(index) = 1;
+  write<Size>(with, test);
+}
+
+template<uint Size> auto M68K::instructionBTST(DataRegister bit, EffectiveAddress with) -> void {
+  auto index = read<Size>(bit) & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
+}
+
+template<uint Size> auto M68K::instructionBTST(EffectiveAddress with) -> void {
+  auto index = readPC<Word>() & bits<Size>() - 1;
+  auto test = read<Size>(with);
+  r.z = test.bit(index) == 0;
 }
 
 template<uint Size> auto M68K::instructionCLR(EffectiveAddress ea) -> void {
@@ -350,6 +394,10 @@ auto M68K::instructionEORI_TO_SR() -> void {
   writeSR(readSR() ^ data);
 }
 
+auto M68K::instructionJMP(EffectiveAddress target) -> void {
+  r.pc = fetch<Long>(target);
+}
+
 auto M68K::instructionJSR(EffectiveAddress target) -> void {
   push<Long>(r.pc);
   r.pc = fetch<Long>(target);
@@ -491,19 +539,43 @@ auto M68K::instructionMOVE_TO_SR(EffectiveAddress ea) -> void {
   writeSR(data);
 }
 
-auto M68K::instructionMOVE_USP(uint1 direction, AddressRegister ar) -> void {
+auto M68K::instructionMOVE_FROM_USP(AddressRegister to) -> void {
   if(!supervisor()) return;
 
-  if(direction == 0) {
-    r.sp = read<Long>(ar);
-  } else {
-    write<Long>(ar, r.sp);
-  }
+  write<Long>(to, r.sp);
+}
+
+auto M68K::instructionMOVE_TO_USP(AddressRegister from) -> void {
+  if(!supervisor()) return;
+
+  r.sp = read<Long>(from);
+}
+
+template<uint Size> auto M68K::instructionNEG(EffectiveAddress with) -> void {
+  auto source = read<Size>(with);
+  auto result = SUB<Size>(0, source);
+  write<Size>(with, result);
+}
+
+template<uint Size> auto M68K::instructionNEGX(EffectiveAddress with) -> void {
+  auto source = read<Size>(with);
+  auto result = SUB<Size, Extend>(0, source);
+  write<Size>(with, result);
 }
 
 auto M68K::instructionNOP() -> void {
 }
 
+template<uint Size> auto M68K::instructionNOT(EffectiveAddress with) -> void {
+  auto result = ~read<Size>(with);
+  write<Size>(with, result);
+
+  r.c = 0;
+  r.v = 0;
+  r.z = clip<Size>(result) == 0;
+  r.n = sign<Size>(result) < 0;
+}
+
 template<uint Size> auto M68K::OR(uint32 source, uint32 target) -> uint32 {
   auto result = target | source;
 
@@ -678,10 +750,28 @@ auto M68K::instructionROXR(EffectiveAddress modify) -> void {
   write<Word>(modify, result);
 }
 
+auto M68K::instructionRTE() -> void {
+  if(!supervisor()) return;
+
+  auto sr = pop<Word>();
+  r.pc = pop<Long>();
+  writeSR(sr);
+}
+
+auto M68K::instructionRTR() -> void {
+  writeCCR(pop<Word>());
+  r.pc = pop<Long>();
+}
+
 auto M68K::instructionRTS() -> void {
   r.pc = pop<Long>();
 }
 
+auto M68K::instructionSCC(uint4 condition, EffectiveAddress to) -> void {
+  uint8 result = testCondition(condition) ? ~0 : 0;
+  write<Byte>(to, result);
+}
+
 template<uint Size, bool Extend> auto M68K::SUB(uint32 source, uint32 target) -> uint32 {
   uint64 result = source - target;
   if(Extend) result -= r.x;
diff --git a/higan/processor/m68k/m68k.hpp b/higan/processor/m68k/m68k.hpp
index 1b4013d5..caca8c91 100644
--- a/higan/processor/m68k/m68k.hpp
+++ b/higan/processor/m68k/m68k.hpp
@@ -119,8 +119,14 @@ struct M68K {
   template<uint Size> auto instructionASR(DataRegister shift, DataRegister modify) -> void;
                       auto instructionASR(EffectiveAddress modify) -> void;
                       auto instructionBCC(uint4 condition, uint8 displacement) -> void;
-  template<uint Size> auto instructionBTST(DataRegister dr, EffectiveAddress ea) -> void;
-  template<uint Size> auto instructionBTST(EffectiveAddress ea) -> void;
+  template<uint Size> auto instructionBCHG(DataRegister bit, EffectiveAddress with) -> void;
+  template<uint Size> auto instructionBCHG(EffectiveAddress with) -> void;
+  template<uint Size> auto instructionBCLR(DataRegister bit, EffectiveAddress with) -> void;
+  template<uint Size> auto instructionBCLR(EffectiveAddress with) -> void;
+  template<uint Size> auto instructionBSET(DataRegister bit, EffectiveAddress with) -> void;
+  template<uint Size> auto instructionBSET(EffectiveAddress with) -> void;
+  template<uint Size> auto instructionBTST(DataRegister bit, EffectiveAddress with) -> void;
+  template<uint Size> auto instructionBTST(EffectiveAddress with) -> void;
   template<uint Size> auto instructionCLR(EffectiveAddress ea) -> void;
   template<uint Size> auto CMP(uint32 source, uint32 target) -> uint32;
   template<uint Size> auto instructionCMP(DataRegister dr, EffectiveAddress ea) -> void;
@@ -133,6 +139,7 @@ struct M68K {
   template<uint Size> auto instructionEORI(EffectiveAddress with) -> void;
                       auto instructionEORI_TO_CCR() -> void;
                       auto instructionEORI_TO_SR() -> void;
+                      auto instructionJMP(EffectiveAddress target) -> void;
                       auto instructionJSR(EffectiveAddress target) -> void;
                       auto instructionLEA(AddressRegister ar, EffectiveAddress ea) -> void;
   template<uint Size> auto LSL(uint32 result, uint shift) -> uint32;
@@ -150,8 +157,12 @@ struct M68K {
                       auto instructionMOVE_FROM_SR(EffectiveAddress ea) -> void;
                       auto instructionMOVE_TO_CCR(EffectiveAddress ea) -> void;
                       auto instructionMOVE_TO_SR(EffectiveAddress ea) -> void;
-                      auto instructionMOVE_USP(uint1 direction, AddressRegister ar) -> void;
+                      auto instructionMOVE_FROM_USP(AddressRegister to) -> void;
+                      auto instructionMOVE_TO_USP(AddressRegister from) -> void;
+  template<uint Size> auto instructionNEG(EffectiveAddress with) -> void;
+  template<uint Size> auto instructionNEGX(EffectiveAddress with) -> void;
                       auto instructionNOP() -> void;
+  template<uint Size> auto instructionNOT(EffectiveAddress with) -> void;
   template<uint Size> auto OR(uint32 source, uint32 target) -> uint32;
   template<uint Size> auto instructionOR(EffectiveAddress from, DataRegister with) -> void;
   template<uint Size> auto instructionOR(DataRegister from, EffectiveAddress with) -> void;
@@ -174,7 +185,10 @@ struct M68K {
   template<uint Size> auto instructionROXR(uint4 shift, DataRegister modify) -> void;
   template<uint Size> auto instructionROXR(DataRegister shift, DataRegister modify) -> void;
                       auto instructionROXR(EffectiveAddress modify) -> void;
+                      auto instructionRTE() -> void;
+                      auto instructionRTR() -> void;
                       auto instructionRTS() -> void;
+                      auto instructionSCC(uint4 condition, EffectiveAddress to) -> void;
   template<uint Size, bool Extend = false> auto SUB(uint32 source, uint32 target) -> uint32;
   template<uint Size> auto instructionSUB(EffectiveAddress source, DataRegister target) -> void;
   template<uint Size> auto instructionSUB(DataRegister source, EffectiveAddress target) -> void;
@@ -229,8 +243,14 @@ private:
   template<uint Size> auto disassembleASR(DataRegister shift, DataRegister modify) -> string;
                       auto disassembleASR(EffectiveAddress modify) -> string;
                       auto disassembleBCC(uint4 condition, uint8 displacement) -> string;
-  template<uint Size> auto disassembleBTST(DataRegister dr, EffectiveAddress ea) -> string;
-  template<uint Size> auto disassembleBTST(EffectiveAddress ea) -> string;
+  template<uint Size> auto disassembleBCHG(DataRegister bit, EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleBCHG(EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleBCLR(DataRegister bit, EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleBCLR(EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleBSET(DataRegister bit, EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleBSET(EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleBTST(DataRegister bit, EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleBTST(EffectiveAddress with) -> string;
   template<uint Size> auto disassembleCLR(EffectiveAddress ea) -> string;
   template<uint Size> auto disassembleCMP(DataRegister dr, EffectiveAddress ea) -> string;
   template<uint Size> auto disassembleCMPA(AddressRegister ar, EffectiveAddress ea) -> string;
@@ -241,6 +261,7 @@ private:
   template<uint Size> auto disassembleEORI(EffectiveAddress with) -> string;
                       auto disassembleEORI_TO_CCR() -> string;
                       auto disassembleEORI_TO_SR() -> string;
+                      auto disassembleJMP(EffectiveAddress target) -> string;
                       auto disassembleJSR(EffectiveAddress target) -> string;
                       auto disassembleLEA(AddressRegister ar, EffectiveAddress ea) -> string;
   template<uint Size> auto disassembleLSL(uint4 immediate, DataRegister dr) -> string;
@@ -256,8 +277,12 @@ private:
                       auto disassembleMOVE_FROM_SR(EffectiveAddress ea) -> string;
                       auto disassembleMOVE_TO_CCR(EffectiveAddress ea) -> string;
                       auto disassembleMOVE_TO_SR(EffectiveAddress ea) -> string;
-                      auto disassembleMOVE_USP(uint1 direction, AddressRegister ar) -> string;
+                      auto disassembleMOVE_FROM_USP(AddressRegister to) -> string;
+                      auto disassembleMOVE_TO_USP(AddressRegister from) -> string;
+  template<uint Size> auto disassembleNEG(EffectiveAddress with) -> string;
+  template<uint Size> auto disassembleNEGX(EffectiveAddress with) -> string;
                       auto disassembleNOP() -> string;
+  template<uint Size> auto disassembleNOT(EffectiveAddress with) -> string;
   template<uint Size> auto disassembleOR(EffectiveAddress from, DataRegister with) -> string;
   template<uint Size> auto disassembleOR(DataRegister from, EffectiveAddress with) -> string;
   template<uint Size> auto disassembleORI(EffectiveAddress with) -> string;
@@ -275,7 +300,10 @@ private:
   template<uint Size> auto disassembleROXR(uint4 shift, DataRegister modify) -> string;
   template<uint Size> auto disassembleROXR(DataRegister shift, DataRegister modify) -> string;
                       auto disassembleROXR(EffectiveAddress modify) -> string;
+                      auto disassembleRTE() -> string;
+                      auto disassembleRTR() -> string;
                       auto disassembleRTS() -> string;
+                      auto disassembleSCC(uint4 condition, EffectiveAddress to) -> string;
   template<uint Size> auto disassembleSUB(EffectiveAddress source, DataRegister target) -> string;
   template<uint Size> auto disassembleSUB(DataRegister source, EffectiveAddress target) -> string;
   template<uint Size> auto disassembleSUBA(AddressRegister to, EffectiveAddress from) -> string;
diff --git a/nall/atoi.hpp b/nall/atoi.hpp
index 46921f76..d6fba252 100644
--- a/nall/atoi.hpp
+++ b/nall/atoi.hpp
@@ -4,7 +4,7 @@
 
 namespace nall {
 
-constexpr inline auto toBinary_(const char* s, uintmax_t sum = 0) -> uintmax_t {
+constexpr inline auto toBinary_(const char* s, uintmax sum = 0) -> uintmax {
   return (
     *s == '0' || *s == '1' ? toBinary_(s + 1, (sum << 1) | *s - '0') :
     *s == '\'' ? toBinary_(s + 1, sum) :
@@ -12,7 +12,7 @@ constexpr inline auto toBinary_(const char* s, uintmax_t sum = 0) -> uintmax_t {
   );
 }
 
-constexpr inline auto toOctal_(const char* s, uintmax_t sum = 0) -> uintmax_t {
+constexpr inline auto toOctal_(const char* s, uintmax sum = 0) -> uintmax {
   return (
     *s >= '0' && *s <= '7' ? toOctal_(s + 1, (sum << 3) | *s - '0') :
     *s == '\'' ? toOctal_(s + 1, sum) :
@@ -20,7 +20,7 @@ constexpr inline auto toOctal_(const char* s, uintmax_t sum = 0) -> uintmax_t {
   );
 }
 
-constexpr inline auto toDecimal_(const char* s, uintmax_t sum = 0) -> uintmax_t {
+constexpr inline auto toDecimal_(const char* s, uintmax sum = 0) -> uintmax {
   return (
     *s >= '0' && *s <= '9' ? toDecimal_(s + 1, (sum * 10) + *s - '0') :
     *s == '\'' ? toDecimal_(s + 1, sum) :
@@ -28,7 +28,7 @@ constexpr inline auto toDecimal_(const char* s, uintmax_t sum = 0) -> uintmax_t
   );
 }
 
-constexpr inline auto toHex_(const char* s, uintmax_t sum = 0) -> uintmax_t {
+constexpr inline auto toHex_(const char* s, uintmax sum = 0) -> uintmax {
   return (
     *s >= 'A' && *s <= 'F' ? toHex_(s + 1, (sum << 4) | *s - 'A' + 10) :
     *s >= 'a' && *s <= 'f' ? toHex_(s + 1, (sum << 4) | *s - 'a' + 10) :
@@ -40,21 +40,21 @@ constexpr inline auto toHex_(const char* s, uintmax_t sum = 0) -> uintmax_t {
 
 //
 
-constexpr inline auto toBinary(const char* s) -> uintmax_t {
+constexpr inline auto toBinary(const char* s) -> uintmax {
   return (
     *s == '0' && (*(s + 1) == 'B' || *(s + 1) == 'b') ? toBinary_(s + 2) :
     *s == '%' ? toBinary_(s + 1) : toBinary_(s)
   );
 }
 
-constexpr inline auto toOctal(const char* s) -> uintmax_t {
+constexpr inline auto toOctal(const char* s) -> uintmax {
   return (
     *s == '0' && (*(s + 1) == 'O' || *(s + 1) == 'o') ? toOctal_(s + 2) :
     toOctal_(s)
   );
 }
 
-constexpr inline auto toHex(const char* s) -> uintmax_t {
+constexpr inline auto toHex(const char* s) -> uintmax {
   return (
     *s == '0' && (*(s + 1) == 'X' || *(s + 1) == 'x') ? toHex_(s + 2) :
     *s == '$' ? toHex_(s + 1) : toHex_(s)
@@ -63,7 +63,7 @@ constexpr inline auto toHex(const char* s) -> uintmax_t {
 
 //
 
-constexpr inline auto toNatural(const char* s) -> uintmax_t {
+constexpr inline auto toNatural(const char* s) -> uintmax {
   return (
     *s == '0' && (*(s + 1) == 'B' || *(s + 1) == 'b') ? toBinary_(s + 2) :
     *s == '0' && (*(s + 1) == 'O' || *(s + 1) == 'o') ? toOctal_(s + 2) :
@@ -72,7 +72,7 @@ constexpr inline auto toNatural(const char* s) -> uintmax_t {
   );
 }
 
-constexpr inline auto toInteger(const char* s) -> intmax_t {
+constexpr inline auto toInteger(const char* s) -> intmax {
   return (
     *s == '+' ? +toNatural(s + 1) : *s == '-' ? -toNatural(s + 1) : toNatural(s)
   );
diff --git a/nall/bit.hpp b/nall/bit.hpp
index f935c864..f2a54b6e 100644
--- a/nall/bit.hpp
+++ b/nall/bit.hpp
@@ -4,28 +4,28 @@
 
 namespace nall {
 
-template<uint bits> inline auto uclamp(const uintmax_t x) -> uintmax_t {
-  enum : uintmax_t { b = 1ull << (bits - 1), y = b * 2 - 1 };
+template<uint bits> inline auto uclamp(const uintmax x) -> uintmax {
+  enum : uintmax { b = 1ull << (bits - 1), y = b * 2 - 1 };
   return y + ((x - y) & -(x < y));  //min(x, y);
 }
 
-template<uint bits> inline auto uclip(const uintmax_t x) -> uintmax_t {
-  enum : uintmax_t { b = 1ull << (bits - 1), m = b * 2 - 1 };
+template<uint bits> inline auto uclip(const uintmax x) -> uintmax {
+  enum : uintmax { b = 1ull << (bits - 1), m = b * 2 - 1 };
   return (x & m);
 }
 
-template<uint bits> inline auto sclamp(const intmax_t x) -> intmax_t {
-  enum : intmax_t { b = 1ull << (bits - 1), m = b - 1 };
+template<uint bits> inline auto sclamp(const intmax x) -> intmax {
+  enum : intmax { b = 1ull << (bits - 1), m = b - 1 };
   return (x > m) ? m : (x < -b) ? -b : x;
 }
 
-template<uint bits> inline auto sclip(const intmax_t x) -> intmax_t {
-  enum : uintmax_t { b = 1ull << (bits - 1), m = b * 2 - 1 };
+template<uint bits> inline auto sclip(const intmax x) -> intmax {
+  enum : uintmax { b = 1ull << (bits - 1), m = b * 2 - 1 };
   return ((x & m) ^ b) - b;
 }
 
 namespace bit {
-  constexpr inline auto mask(const char* s, uintmax_t sum = 0) -> uintmax_t {
+  constexpr inline auto mask(const char* s, uintmax sum = 0) -> uintmax {
     return (
       *s == '0' || *s == '1' ? mask(s + 1, (sum << 1) | 1) :
       *s == ' ' || *s == '_' ? mask(s + 1, sum) :
@@ -34,7 +34,7 @@ namespace bit {
     );
   }
 
-  constexpr inline auto test(const char* s, uintmax_t sum = 0) -> uintmax_t {
+  constexpr inline auto test(const char* s, uintmax sum = 0) -> uintmax {
     return (
       *s == '0' || *s == '1' ? test(s + 1, (sum << 1) | (*s - '0')) :
       *s == ' ' || *s == '_' ? test(s + 1, sum) :
@@ -44,22 +44,22 @@ namespace bit {
   }
 
   //lowest(0b1110) == 0b0010
-  constexpr inline auto lowest(const uintmax_t x) -> uintmax_t {
+  constexpr inline auto lowest(const uintmax x) -> uintmax {
     return x & -x;
   }
 
   //clear_lowest(0b1110) == 0b1100
-  constexpr inline auto clearLowest(const uintmax_t x) -> uintmax_t {
+  constexpr inline auto clearLowest(const uintmax x) -> uintmax {
     return x & (x - 1);
   }
 
   //set_lowest(0b0101) == 0b0111
-  constexpr inline auto setLowest(const uintmax_t x) -> uintmax_t {
+  constexpr inline auto setLowest(const uintmax x) -> uintmax {
     return x | (x + 1);
   }
 
   //count number of bits set in a byte
-  inline auto count(uintmax_t x) -> uint {
+  inline auto count(uintmax x) -> uint {
     uint count = 0;
     do count += x & 1; while(x >>= 1);
     return count;
@@ -67,7 +67,7 @@ namespace bit {
 
   //return index of the first bit set (or zero of no bits are set)
   //first(0b1000) == 3
-  inline auto first(uintmax_t x) -> uint {
+  inline auto first(uintmax x) -> uint {
     uint first = 0;
     while(x) { if(x & 1) break; x >>= 1; first++; }
     return first;
@@ -75,7 +75,7 @@ namespace bit {
 
   //round up to next highest single bit:
   //round(15) == 16, round(16) == 16, round(17) == 32
-  inline auto round(uintmax_t x) -> uintmax_t {
+  inline auto round(uintmax x) -> uintmax {
     if((x & (x - 1)) == 0) return x;
     while(x & (x - 1)) x &= x - 1;
     return x << 1;
diff --git a/nall/decode/bmp.hpp b/nall/decode/bmp.hpp
index 17b094cc..8aeab788 100644
--- a/nall/decode/bmp.hpp
+++ b/nall/decode/bmp.hpp
@@ -5,7 +5,7 @@ namespace nall { namespace Decode {
 struct BMP {
   BMP() = default;
   BMP(const string& filename) { load(filename); }
-  BMP(const uint8_t* data, unsigned size) { load(data, size); }
+  BMP(const uint8_t* data, uint size) { load(data, size); }
 
   explicit operator bool() const { return _data; }
 
@@ -15,28 +15,28 @@ struct BMP {
 
   auto data() -> uint32_t* { return _data; }
   auto data() const -> const uint32_t* { return _data; }
-  auto width() const -> unsigned { return _width; }
-  auto height() const -> unsigned { return _height; }
+  auto width() const -> uint { return _width; }
+  auto height() const -> uint { return _height; }
 
   auto load(const string& filename) -> bool {
     auto buffer = file::read(filename);
     return load(buffer.data(), buffer.size());
   }
 
-  auto load(const uint8_t* data, unsigned size) -> bool {
+  auto load(const uint8_t* data, uint size) -> bool {
     if(size < 0x36) return false;
     const uint8_t* p = data;
     if(read(p, 2) != 0x4d42) return false;  //signature
     read(p, 8);
-    unsigned offset = read(p, 4);
+    uint offset = read(p, 4);
     if(read(p, 4) != 40) return false;  //DIB size
-    signed width = read(p, 4);
+    int width = read(p, 4);
     if(width < 0) return false;
-    signed height = read(p, 4);
+    int height = read(p, 4);
     bool flip = height < 0;
     if(flip) height = -height;
     read(p, 2);
-    unsigned bitsPerPixel = read(p, 2);
+    uint bitsPerPixel = read(p, 2);
     if(bitsPerPixel != 24 && bitsPerPixel != 32) return false;
     if(read(p, 4) != 0) return false;  //compression type
 
@@ -44,9 +44,9 @@ struct BMP {
     _height = height;
     _data = new uint32_t[width * height];
 
-    unsigned bytesPerPixel = bitsPerPixel / 8;
-    unsigned alignedWidth = width * bytesPerPixel;
-    unsigned paddingLength = 0;
+    uint bytesPerPixel = bitsPerPixel / 8;
+    uint alignedWidth = width * bytesPerPixel;
+    uint paddingLength = 0;
     while(alignedWidth % 4) alignedWidth++, paddingLength++;
 
     p = data + offset;
@@ -63,12 +63,12 @@ struct BMP {
 
 private:
   uint32_t* _data = nullptr;
-  unsigned _width = 0;
-  unsigned _height = 0;
+  uint _width = 0;
+  uint _height = 0;
 
-  auto read(const uint8_t*& buffer, unsigned length) -> uintmax_t {
-    uintmax_t result = 0;
-    for(auto n : range(length)) result |= (uintmax_t)*buffer++ << (n << 3);
+  auto read(const uint8_t*& buffer, uint length) -> uintmax {
+    uintmax result = 0;
+    for(auto n : range(length)) result |= (uintmax)*buffer++ << (n << 3);
     return result;
   }
 };
diff --git a/nall/dl.hpp b/nall/dl.hpp
index 28f3d438..cb40740c 100644
--- a/nall/dl.hpp
+++ b/nall/dl.hpp
@@ -32,22 +32,22 @@ struct library {
   auto close() -> void;
 
 private:
-  uintptr_t handle = 0;
+  uintptr handle = 0;
 };
 
 #if defined(PLATFORM_LINUX) || defined(PLATFORM_BSD)
 inline auto library::open(const string& name, const string& path) -> bool {
   if(handle) close();
-  if(path) handle = (uintptr_t)dlopen(string(path, "lib", name, ".so"), RTLD_LAZY);
-  if(!handle) handle = (uintptr_t)dlopen(string(Path::user(), ".local/lib/lib", name, ".so"), RTLD_LAZY);
-  if(!handle) handle = (uintptr_t)dlopen(string("/usr/local/lib/lib", name, ".so"), RTLD_LAZY);
-  if(!handle) handle = (uintptr_t)dlopen(string("lib", name, ".so"), RTLD_LAZY);
+  if(path) handle = (uintptr)dlopen(string(path, "lib", name, ".so"), RTLD_LAZY);
+  if(!handle) handle = (uintptr)dlopen(string(Path::user(), ".local/lib/lib", name, ".so"), RTLD_LAZY);
+  if(!handle) handle = (uintptr)dlopen(string("/usr/local/lib/lib", name, ".so"), RTLD_LAZY);
+  if(!handle) handle = (uintptr)dlopen(string("lib", name, ".so"), RTLD_LAZY);
   return handle;
 }
 
 inline auto library::openAbsolute(const string& name) -> bool {
   if(handle) close();
-  handle = (uintptr_t)dlopen(name, RTLD_LAZY);
+  handle = (uintptr)dlopen(name, RTLD_LAZY);
   return handle;
 }
 
@@ -64,16 +64,16 @@ inline auto library::close() -> void {
 #elif defined(PLATFORM_MACOSX)
 inline auto library::open(const string& name, const string& path) -> bool {
   if(handle) close();
-  if(path) handle = (uintptr_t)dlopen(string(path, "lib", name, ".dylib"), RTLD_LAZY);
-  if(!handle) handle = (uintptr_t)dlopen(string(Path::user(), ".local/lib/lib", name, ".dylib"), RTLD_LAZY);
-  if(!handle) handle = (uintptr_t)dlopen(string("/usr/local/lib/lib", name, ".dylib"), RTLD_LAZY);
-  if(!handle) handle = (uintptr_t)dlopen(string("lib", name, ".dylib"), RTLD_LAZY);
+  if(path) handle = (uintptr)dlopen(string(path, "lib", name, ".dylib"), RTLD_LAZY);
+  if(!handle) handle = (uintptr)dlopen(string(Path::user(), ".local/lib/lib", name, ".dylib"), RTLD_LAZY);
+  if(!handle) handle = (uintptr)dlopen(string("/usr/local/lib/lib", name, ".dylib"), RTLD_LAZY);
+  if(!handle) handle = (uintptr)dlopen(string("lib", name, ".dylib"), RTLD_LAZY);
   return handle;
 }
 
 inline auto library::openAbsolute(const string& name) -> bool {
   if(handle) close();
-  handle = (uintptr_t)dlopen(name, RTLD_LAZY);
+  handle = (uintptr)dlopen(name, RTLD_LAZY);
   return handle;
 }
 
@@ -92,18 +92,18 @@ inline auto library::open(const string& name, const string& path) -> bool {
   if(handle) close();
   if(path) {
     string filepath = {path, name, ".dll"};
-    handle = (uintptr_t)LoadLibraryW(utf16_t(filepath));
+    handle = (uintptr)LoadLibraryW(utf16_t(filepath));
   }
   if(!handle) {
     string filepath = {name, ".dll"};
-    handle = (uintptr_t)LoadLibraryW(utf16_t(filepath));
+    handle = (uintptr)LoadLibraryW(utf16_t(filepath));
   }
   return handle;
 }
 
 inline auto library::openAbsolute(const string& name) -> bool {
   if(handle) close();
-  handle = (uintptr_t)LoadLibraryW(utf16_t(name));
+  handle = (uintptr)LoadLibraryW(utf16_t(name));
   return handle;
 }
 
diff --git a/nall/file.hpp b/nall/file.hpp
index 93014895..cc5228f5 100644
--- a/nall/file.hpp
+++ b/nall/file.hpp
@@ -61,7 +61,7 @@ struct file : inode, varint {
     return !(data.st_mode & S_IFDIR);
   }
 
-  static auto size(const string& filename) -> uintmax_t {
+  static auto size(const string& filename) -> uintmax {
     #if defined(API_POSIX)
     struct stat data;
     stat(filename, &data);
@@ -127,16 +127,16 @@ struct file : inode, varint {
     return buffer[(file_offset++) & buffer_mask];
   }
 
-  auto readl(uint length = 1) -> uintmax_t {
-    uintmax_t data = 0;
+  auto readl(uint length = 1) -> uintmax {
+    uintmax data = 0;
     for(int i = 0; i < length; i++) {
-      data |= (uintmax_t)read() << (i << 3);
+      data |= (uintmax)read() << (i << 3);
     }
     return data;
   }
 
-  auto readm(uint length = 1) -> uintmax_t {
-    uintmax_t data = 0;
+  auto readm(uint length = 1) -> uintmax {
+    uintmax data = 0;
     while(length--) {
       data <<= 8;
       data |= read();
@@ -164,14 +164,14 @@ struct file : inode, varint {
     if(file_offset > file_size) file_size = file_offset;
   }
 
-  auto writel(uintmax_t data, uint length = 1) -> void {
+  auto writel(uintmax data, uint length = 1) -> void {
     while(length--) {
       write(data);
       data >>= 8;
     }
   }
 
-  auto writem(uintmax_t data, uint length = 1) -> void {
+  auto writem(uintmax data, uint length = 1) -> void {
     for(int i = length - 1; i >= 0; i--) {
       write(data >> (i << 3));
     }
@@ -200,7 +200,7 @@ struct file : inode, varint {
     if(!fp) return;  //file not open
     buffer_flush();
 
-    intmax_t req_offset = file_offset;
+    intmax req_offset = file_offset;
     switch(index_) {
     case index::absolute: req_offset  = offset; break;
     case index::relative: req_offset += offset; break;
diff --git a/nall/http/server.hpp b/nall/http/server.hpp
index a2e04224..6110603c 100644
--- a/nall/http/server.hpp
+++ b/nall/http/server.hpp
@@ -114,7 +114,7 @@ auto Server::ipv4_scan() -> bool {
   if(query.fd == fd4 && query.revents & POLLIN) {
     ++connections;
 
-    thread::create([&](uintptr_t) {
+    thread::create([&](uintptr) {
       thread::detach();
 
       signed clientfd = -1;
@@ -161,7 +161,7 @@ auto Server::ipv6_scan() -> bool {
   if(query.fd == fd6 && query.revents & POLLIN) {
     ++connections;
 
-    thread::create([&](uintptr_t) {
+    thread::create([&](uintptr) {
       thread::detach();
 
       signed clientfd = -1;
diff --git a/nall/primitives.hpp b/nall/primitives.hpp
index 5f6dce14..d333b98f 100644
--- a/nall/primitives.hpp
+++ b/nall/primitives.hpp
@@ -60,19 +60,36 @@ template<uint Bits> struct Natural {
   struct Reference {
     inline Reference(Natural& source, uint lo, uint hi) : source(source), Lo(lo), Hi(hi) {}
 
-    inline operator type() const {
+    inline auto get() const -> type {
       const type RangeBits = Hi - Lo + 1;
       const type RangeMask = (((1ull << RangeBits) - 1) << Lo) & Mask;
       return (source & RangeMask) >> Lo;
     }
 
-    inline auto& operator=(const type value) {
+    inline auto& set(const type value) {
       const type RangeBits = Hi - Lo + 1;
       const type RangeMask = (((1ull << RangeBits) - 1) << Lo) & Mask;
       source = (source & ~RangeMask) | ((value << Lo) & RangeMask);
       return *this;
     }
 
+    inline operator type() const { return get(); }
+    inline auto& operator  =(const type value) { return set(         value); }
+    inline auto& operator &=(const type value) { return set(get()  & value); }
+    inline auto& operator |=(const type value) { return set(get()  | value); }
+    inline auto& operator ^=(const type value) { return set(get()  ^ value); }
+    inline auto& operator<<=(const type value) { return set(get() << value); }
+    inline auto& operator>>=(const type value) { return set(get() >> value); }
+    inline auto& operator +=(const type value) { return set(get()  + value); }
+    inline auto& operator -=(const type value) { return set(get()  - value); }
+    inline auto& operator *=(const type value) { return set(get()  * value); }
+    inline auto& operator /=(const type value) { return set(get()  / value); }
+    inline auto& operator %=(const type value) { return set(get()  % value); }
+    inline auto& operator++(int) { auto value = get(); set(value + 1); return value; }
+    inline auto& operator--(int) { auto value = get(); set(value - 1); return value; }
+    inline auto& operator++() { return set(get() + 1); }
+    inline auto& operator--() { return set(get() - 1); }
+
   private:
     Natural& source;
     const type Lo;
@@ -87,15 +104,15 @@ template<uint Bits> struct Natural {
   inline auto bit(uint index) const -> const Reference { return {(Natural&)*this, index, index}; }
   inline auto byte(uint index) const -> const Reference { return {(Natural&)*this, index * 8 + 0, index * 8 + 7}; }
 
-  inline auto clamp(uint bits) -> uintmax_t {
-    const uintmax_t b = 1ull << (bits - 1);
-    const uintmax_t m = b * 2 - 1;
+  inline auto clamp(uint bits) -> uintmax {
+    const uintmax b = 1ull << (bits - 1);
+    const uintmax m = b * 2 - 1;
     return data < m ? data : m;
   }
 
-  inline auto clip(uint bits) -> uintmax_t {
-    const uintmax_t b = 1ull << (bits - 1);
-    const uintmax_t m = b * 2 - 1;
+  inline auto clip(uint bits) -> uintmax {
+    const uintmax b = 1ull << (bits - 1);
+    const uintmax m = b * 2 - 1;
     return data & m;
   }
 
@@ -146,19 +163,36 @@ template<uint Bits> struct Integer {
   struct Reference {
     inline Reference(Integer& source, uint lo, uint hi) : source(source), Lo(lo), Hi(hi) {}
 
-    inline operator utype() const {
+    inline auto get() const -> utype {
       const type RangeBits = Hi - Lo + 1;
       const type RangeMask = (((1ull << RangeBits) - 1) << Lo) & Mask;
       return ((utype)source & RangeMask) >> Lo;
     }
 
-    inline auto& operator=(const utype value) {
+    inline auto& set(const utype value) {
       const type RangeBits = Hi - Lo + 1;
       const type RangeMask = (((1ull << RangeBits) - 1) << Lo) & Mask;
       source = ((utype)source & ~RangeMask) | ((value << Lo) & RangeMask);
       return *this;
     }
 
+    inline operator utype() const { return get(); }
+    inline auto& operator  =(const utype value) { return set(         value); }
+    inline auto& operator &=(const utype value) { return set(get()  & value); }
+    inline auto& operator |=(const utype value) { return set(get()  | value); }
+    inline auto& operator ^=(const utype value) { return set(get()  ^ value); }
+    inline auto& operator<<=(const utype value) { return set(get() << value); }
+    inline auto& operator>>=(const utype value) { return set(get() >> value); }
+    inline auto& operator +=(const utype value) { return set(get()  + value); }
+    inline auto& operator -=(const utype value) { return set(get()  - value); }
+    inline auto& operator *=(const utype value) { return set(get()  * value); }
+    inline auto& operator /=(const utype value) { return set(get()  / value); }
+    inline auto& operator %=(const utype value) { return set(get()  % value); }
+    inline auto& operator++(int) { auto value = get(); set(value + 1); return value; }
+    inline auto& operator--(int) { auto value = get(); set(value - 1); return value; }
+    inline auto& operator++() { return set(get() + 1); }
+    inline auto& operator--() { return set(get() - 1); }
+
   private:
     Integer& source;
     const uint Lo;
@@ -173,15 +207,15 @@ template<uint Bits> struct Integer {
   inline auto bit(uint index) const -> const Reference { return {(Integer&)*this, index, index}; }
   inline auto byte(uint index) const -> const Reference { return {(Integer&)*this, index * 8 + 0, index * 8 + 7}; }
 
-  inline auto clamp(uint bits) -> intmax_t {
-    const intmax_t b = 1ull << (bits - 1);
-    const intmax_t m = b - 1;
+  inline auto clamp(uint bits) -> intmax {
+    const intmax b = 1ull << (bits - 1);
+    const intmax m = b - 1;
     return data > m ? m : data < -b ? -b : data;
   }
 
-  inline auto clip(uint bits) -> intmax_t {
-    const uintmax_t b = 1ull << (bits - 1);
-    const uintmax_t m = b * 2 - 1;
+  inline auto clip(uint bits) -> intmax {
+    const uintmax b = 1ull << (bits - 1);
+    const uintmax m = b * 2 - 1;
     return ((data & m) ^ b) - b;
   }
 
@@ -224,13 +258,147 @@ private:
   type data;
 };
 
-}
-
 using boolean = nall::Boolean;
-using integer = nall::Integer<sizeof( int) * 8>;
 using natural = nall::Natural<sizeof(uint) * 8>;
+using integer = nall::Integer<sizeof( int) * 8>;
 using real    = nall::Real<sizeof(double) * 8>;
 
+using  natural1 = nall::Natural< 1>;
+using  natural2 = nall::Natural< 2>;
+using  natural3 = nall::Natural< 3>;
+using  natural4 = nall::Natural< 4>;
+using  natural5 = nall::Natural< 5>;
+using  natural6 = nall::Natural< 6>;
+using  natural7 = nall::Natural< 7>;
+using  natural8 = nall::Natural< 8>;
+using  natural9 = nall::Natural< 9>;
+using natural10 = nall::Natural<10>;
+using natural11 = nall::Natural<11>;
+using natural12 = nall::Natural<12>;
+using natural13 = nall::Natural<13>;
+using natural14 = nall::Natural<14>;
+using natural15 = nall::Natural<15>;
+using natural16 = nall::Natural<16>;
+using natural17 = nall::Natural<17>;
+using natural18 = nall::Natural<18>;
+using natural19 = nall::Natural<19>;
+using natural20 = nall::Natural<20>;
+using natural21 = nall::Natural<21>;
+using natural22 = nall::Natural<22>;
+using natural23 = nall::Natural<23>;
+using natural24 = nall::Natural<24>;
+using natural25 = nall::Natural<25>;
+using natural26 = nall::Natural<26>;
+using natural27 = nall::Natural<27>;
+using natural28 = nall::Natural<28>;
+using natural29 = nall::Natural<29>;
+using natural30 = nall::Natural<30>;
+using natural31 = nall::Natural<31>;
+using natural32 = nall::Natural<32>;
+using natural33 = nall::Natural<33>;
+using natural34 = nall::Natural<34>;
+using natural35 = nall::Natural<35>;
+using natural36 = nall::Natural<36>;
+using natural37 = nall::Natural<37>;
+using natural38 = nall::Natural<38>;
+using natural39 = nall::Natural<39>;
+using natural40 = nall::Natural<40>;
+using natural41 = nall::Natural<41>;
+using natural42 = nall::Natural<42>;
+using natural43 = nall::Natural<43>;
+using natural44 = nall::Natural<44>;
+using natural45 = nall::Natural<45>;
+using natural46 = nall::Natural<46>;
+using natural47 = nall::Natural<47>;
+using natural48 = nall::Natural<48>;
+using natural49 = nall::Natural<49>;
+using natural50 = nall::Natural<50>;
+using natural51 = nall::Natural<51>;
+using natural52 = nall::Natural<52>;
+using natural53 = nall::Natural<53>;
+using natural54 = nall::Natural<54>;
+using natural55 = nall::Natural<55>;
+using natural56 = nall::Natural<56>;
+using natural57 = nall::Natural<57>;
+using natural58 = nall::Natural<58>;
+using natural59 = nall::Natural<59>;
+using natural60 = nall::Natural<60>;
+using natural61 = nall::Natural<61>;
+using natural62 = nall::Natural<62>;
+using natural63 = nall::Natural<63>;
+using natural64 = nall::Natural<64>;
+
+using  integer1 = nall::Integer< 1>;
+using  integer2 = nall::Integer< 2>;
+using  integer3 = nall::Integer< 3>;
+using  integer4 = nall::Integer< 4>;
+using  integer5 = nall::Integer< 5>;
+using  integer6 = nall::Integer< 6>;
+using  integer7 = nall::Integer< 7>;
+using  integer8 = nall::Integer< 8>;
+using  integer9 = nall::Integer< 9>;
+using integer10 = nall::Integer<10>;
+using integer11 = nall::Integer<11>;
+using integer12 = nall::Integer<12>;
+using integer13 = nall::Integer<13>;
+using integer14 = nall::Integer<14>;
+using integer15 = nall::Integer<15>;
+using integer16 = nall::Integer<16>;
+using integer17 = nall::Integer<17>;
+using integer18 = nall::Integer<18>;
+using integer19 = nall::Integer<19>;
+using integer20 = nall::Integer<20>;
+using integer21 = nall::Integer<21>;
+using integer22 = nall::Integer<22>;
+using integer23 = nall::Integer<23>;
+using integer24 = nall::Integer<24>;
+using integer25 = nall::Integer<25>;
+using integer26 = nall::Integer<26>;
+using integer27 = nall::Integer<27>;
+using integer28 = nall::Integer<28>;
+using integer29 = nall::Integer<29>;
+using integer30 = nall::Integer<30>;
+using integer31 = nall::Integer<31>;
+using integer32 = nall::Integer<32>;
+using integer33 = nall::Integer<33>;
+using integer34 = nall::Integer<34>;
+using integer35 = nall::Integer<35>;
+using integer36 = nall::Integer<36>;
+using integer37 = nall::Integer<37>;
+using integer38 = nall::Integer<38>;
+using integer39 = nall::Integer<39>;
+using integer40 = nall::Integer<40>;
+using integer41 = nall::Integer<41>;
+using integer42 = nall::Integer<42>;
+using integer43 = nall::Integer<43>;
+using integer44 = nall::Integer<44>;
+using integer45 = nall::Integer<45>;
+using integer46 = nall::Integer<46>;
+using integer47 = nall::Integer<47>;
+using integer48 = nall::Integer<48>;
+using integer49 = nall::Integer<49>;
+using integer50 = nall::Integer<50>;
+using integer51 = nall::Integer<51>;
+using integer52 = nall::Integer<52>;
+using integer53 = nall::Integer<53>;
+using integer54 = nall::Integer<54>;
+using integer55 = nall::Integer<55>;
+using integer56 = nall::Integer<56>;
+using integer57 = nall::Integer<57>;
+using integer58 = nall::Integer<58>;
+using integer59 = nall::Integer<59>;
+using integer60 = nall::Integer<60>;
+using integer61 = nall::Integer<61>;
+using integer62 = nall::Integer<62>;
+using integer63 = nall::Integer<63>;
+using integer64 = nall::Integer<64>;
+
+using real32 = nall::Real<32>;
+using real64 = nall::Real<64>;
+//using real80 = nall::Real<80>;
+
+}
+
 using  int1 = nall::Integer< 1>;
 using  int2 = nall::Integer< 2>;
 using  int3 = nall::Integer< 3>;
@@ -360,7 +528,3 @@ using uint61 = nall::Natural<61>;
 using uint62 = nall::Natural<62>;
 using uint63 = nall::Natural<63>;
 using uint64 = nall::Natural<64>;
-
-using real32 = nall::Real<32>;
-using real64 = nall::Real<64>;
-//using real80 = nall::Real<80>;
diff --git a/nall/shared-pointer.hpp b/nall/shared-pointer.hpp
index 634d02a8..90116656 100644
--- a/nall/shared-pointer.hpp
+++ b/nall/shared-pointer.hpp
@@ -110,7 +110,7 @@ struct shared_pointer {
 
   template<typename U, typename = enable_if<is_compatible<U>>>
   auto operator=(const shared_pointer<U>& source) -> shared_pointer& {
-    if((uintptr_t)this != (uintptr_t)&source) {
+    if((uintptr)this != (uintptr)&source) {
       reset();
       if((bool)source) {
         manager = source.manager;
@@ -122,7 +122,7 @@ struct shared_pointer {
 
   template<typename U, typename = enable_if<is_compatible<U>>>
   auto operator=(shared_pointer&& source) -> shared_pointer& {
-    if((uintptr_t)this != (uintptr_t)&source) {
+    if((uintptr)this != (uintptr)&source) {
       reset();
       manager = source.manager;
       source.manager = nullptr;
diff --git a/nall/stdint.hpp b/nall/stdint.hpp
index d667d285..9b4c870b 100644
--- a/nall/stdint.hpp
+++ b/nall/stdint.hpp
@@ -28,13 +28,14 @@
 
 //note: (u)intmax actually mean it: use as many bits as is possible
 #if defined(__SIZEOF_INT128__)
-  #define HAS_INT128
   using int128_t = signed __int128;
   using uint128_t = unsigned __int128;
 
+  #define INTMAX_BITS 128
   using intmax = int128_t;
   using uintmax = uint128_t;
 #else
+  #define INTMAX_BITS 64
   using intmax = intmax_t;
   using uintmax = uintmax_t;
 #endif
diff --git a/nall/string.hpp b/nall/string.hpp
index 5515081c..5e0a5c24 100644
--- a/nall/string.hpp
+++ b/nall/string.hpp
@@ -63,11 +63,11 @@ template<typename T> struct stringify;
 template<typename... P> inline auto print(P&&...) -> void;
 template<typename... P> inline auto print(FILE*, P&&...) -> void;
 template<typename T> inline auto pad(const T& value, long precision = 0, char padchar = ' ') -> string;
-inline auto hex(uintmax_t value, long precision = 0, char padchar = '0') -> string;
-inline auto octal(uintmax_t value, long precision = 0, char padchar = '0') -> string;
-inline auto binary(uintmax_t value, long precision = 0, char padchar = '0') -> string;
+inline auto hex(uintmax value, long precision = 0, char padchar = '0') -> string;
+inline auto octal(uintmax value, long precision = 0, char padchar = '0') -> string;
+inline auto binary(uintmax value, long precision = 0, char padchar = '0') -> string;
 template<typename T> inline auto pointer(const T* value, long precision = 0) -> string;
-inline auto pointer(uintptr_t value, long precision = 0) -> string;
+inline auto pointer(uintptr value, long precision = 0) -> string;
 
 //match.hpp
 inline auto tokenize(const char* s, const char* p) -> bool;
@@ -75,8 +75,8 @@ inline auto tokenize(string_vector& list, const char* s, const char* p) -> bool;
 
 //utility.hpp
 inline auto slice(string_view self, int offset = 0, int length = -1) -> string;
-inline auto fromInteger(char* result, intmax_t value) -> char*;
-inline auto fromNatural(char* result, uintmax_t value) -> char*;
+inline auto fromInteger(char* result, intmax value) -> char*;
+inline auto fromNatural(char* result, uintmax value) -> char*;
 inline auto fromReal(char* str, long double value) -> uint;
 
 struct string {
@@ -168,9 +168,9 @@ public:
   auto end() const -> const char* { return &data()[size()]; }
 
   //atoi.hpp
-  inline auto integer() const -> intmax_t;
-  inline auto natural() const -> uintmax_t;
-  inline auto hex() const -> uintmax_t;
+  inline auto integer() const -> intmax;
+  inline auto natural() const -> uintmax;
+  inline auto hex() const -> uintmax;
   inline auto real() const -> double;
 
   //core.hpp
diff --git a/nall/string/atoi.hpp b/nall/string/atoi.hpp
index 3dd1f772..23feb32f 100644
--- a/nall/string/atoi.hpp
+++ b/nall/string/atoi.hpp
@@ -2,15 +2,15 @@
 
 namespace nall {
 
-auto string::integer() const -> intmax_t {
+auto string::integer() const -> intmax {
   return toInteger(data());
 }
 
-auto string::natural() const -> uintmax_t {
+auto string::natural() const -> uintmax {
   return toNatural(data());
 }
 
-auto string::hex() const -> uintmax_t {
+auto string::hex() const -> uintmax {
   return toHex(data());
 }
 
diff --git a/nall/string/cast.hpp b/nall/string/cast.hpp
index 88f0482c..346f13a8 100644
--- a/nall/string/cast.hpp
+++ b/nall/string/cast.hpp
@@ -67,6 +67,15 @@ template<> struct stringify<signed long long> {
   char _data[2 + sizeof(signed long long) * 3];
 };
 
+#if INTMAX_BITS >= 128
+template<> struct stringify<int128_t> {
+  stringify(int128_t source) { fromInteger(_data, source); }
+  auto data() const -> const char* { return _data; }
+  auto size() const -> uint { return strlen(_data); }
+  char _data[2 + sizeof(int128_t) * 3];
+};
+#endif
+
 template<uint Bits> struct stringify<Integer<Bits>> {
   stringify(Integer<Bits> source) { fromInteger(_data, source); }
   auto data() const -> const char* { return _data; }
@@ -111,6 +120,15 @@ template<> struct stringify<unsigned long long> {
   char _data[1 + sizeof(unsigned long long) * 3];
 };
 
+#if INTMAX_BITS >= 128
+template<> struct stringify<uint128_t> {
+  stringify(uint128_t source) { fromNatural(_data, source); }
+  auto data() const -> const char* { return _data; }
+  auto size() const -> uint { return strlen(_data); }
+  char _data[1 + sizeof(uint128_t) * 3];
+};
+#endif
+
 template<uint Bits> struct stringify<Natural<Bits>> {
   stringify(Natural<Bits> source) { fromNatural(_data, source); }
   auto data() const -> const char* { return _data; }
diff --git a/nall/string/format.hpp b/nall/string/format.hpp
index be86e812..ef682b5c 100644
--- a/nall/string/format.hpp
+++ b/nall/string/format.hpp
@@ -84,9 +84,9 @@ template<typename T> auto pad(const T& value, long precision, char padchar) -> s
   return buffer;
 }
 
-auto hex(uintmax_t value, long precision, char padchar) -> string {
+auto hex(uintmax value, long precision, char padchar) -> string {
   string buffer;
-  buffer.resize(sizeof(uintmax_t) * 2);
+  buffer.resize(sizeof(uintmax) * 2);
   char* p = buffer.get();
 
   uint size = 0;
@@ -101,9 +101,9 @@ auto hex(uintmax_t value, long precision, char padchar) -> string {
   return buffer;
 }
 
-auto octal(uintmax_t value, long precision, char padchar) -> string {
+auto octal(uintmax value, long precision, char padchar) -> string {
   string buffer;
-  buffer.resize(sizeof(uintmax_t) * 3);
+  buffer.resize(sizeof(uintmax) * 3);
   char* p = buffer.get();
 
   uint size = 0;
@@ -117,9 +117,9 @@ auto octal(uintmax_t value, long precision, char padchar) -> string {
   return buffer;
 }
 
-auto binary(uintmax_t value, long precision, char padchar) -> string {
+auto binary(uintmax value, long precision, char padchar) -> string {
   string buffer;
-  buffer.resize(sizeof(uintmax_t) * 8);
+  buffer.resize(sizeof(uintmax) * 8);
   char* p = buffer.get();
 
   uint size = 0;
@@ -135,10 +135,10 @@ auto binary(uintmax_t value, long precision, char padchar) -> string {
 
 template<typename T> auto pointer(const T* value, long precision) -> string {
   if(value == nullptr) return "(nullptr)";
-  return {"0x", hex((uintptr_t)value, precision)};
+  return {"0x", hex((uintptr)value, precision)};
 }
 
-auto pointer(uintptr_t value, long precision) -> string {
+auto pointer(uintptr value, long precision) -> string {
   if(value == 0) return "(nullptr)";
   return {"0x", hex(value, precision)};
 }
diff --git a/nall/string/markup/node.hpp b/nall/string/markup/node.hpp
index f1a3a2a8..ffc818b0 100644
--- a/nall/string/markup/node.hpp
+++ b/nall/string/markup/node.hpp
@@ -32,7 +32,7 @@ struct ManagedNode {
 protected:
   string _name;
   string _value;
-  uintptr_t _metadata = 0;
+  uintptr _metadata = 0;
   vector<SharedNode> _children;
 
   inline auto _evaluate(string query) const -> bool;
@@ -59,8 +59,8 @@ struct Node {
 
   auto text() const -> string { return value().strip(); }
   auto boolean() const -> bool { return text() == "true"; }
-  auto integer() const -> intmax_t { return text().integer(); }
-  auto natural() const -> uintmax_t { return text().natural(); }
+  auto integer() const -> intmax { return text().integer(); }
+  auto natural() const -> uintmax { return text().natural(); }
   auto real() const -> double { return text().real(); }
 
   auto setName(const string& name = "") -> Node& { shared->_name = name; return *this; }
diff --git a/nall/string/utility.hpp b/nall/string/utility.hpp
index 983d259c..29e4a550 100644
--- a/nall/string/utility.hpp
+++ b/nall/string/utility.hpp
@@ -92,7 +92,7 @@ auto slice(string_view self, int offset, int length) -> string {
   return result;
 }
 
-auto fromInteger(char* result, intmax_t value) -> char* {
+auto fromInteger(char* result, intmax value) -> char* {
   bool negative = value < 0;
   if(negative) value = -value;
 
@@ -111,7 +111,7 @@ auto fromInteger(char* result, intmax_t value) -> char* {
   return result;
 }
 
-auto fromNatural(char* result, uintmax_t value) -> char* {
+auto fromNatural(char* result, uintmax value) -> char* {
   char buffer[64];
   uint size = 0;
 
diff --git a/nall/thread.hpp b/nall/thread.hpp
index 3a76e431..fd33e2d5 100644
--- a/nall/thread.hpp
+++ b/nall/thread.hpp
@@ -19,13 +19,13 @@ namespace nall {
 struct thread {
   inline auto join() -> void;
 
-  static inline auto create(const function<void (uintptr_t)>& callback, uintptr_t parameter = 0, uint stacksize = 0) -> thread;
+  static inline auto create(const function<void (uintptr)>& callback, uintptr parameter = 0, uint stacksize = 0) -> thread;
   static inline auto detach() -> void;
   static inline auto exit() -> void;
 
   struct context {
-    function<auto (uintptr_t) -> void> callback;
-    uintptr_t parameter = 0;
+    function<auto (uintptr) -> void> callback;
+    uintptr parameter = 0;
   };
 
 private:
@@ -43,7 +43,7 @@ auto thread::join() -> void {
   pthread_join(handle, nullptr);
 }
 
-auto thread::create(const function<void (uintptr_t)>& callback, uintptr_t parameter, uint stacksize) -> thread {
+auto thread::create(const function<void (uintptr)>& callback, uintptr parameter, uint stacksize) -> thread {
   thread instance;
 
   auto context = new thread::context;
@@ -76,13 +76,13 @@ struct thread {
   inline ~thread();
   inline auto join() -> void;
 
-  static inline auto create(const function<void (uintptr_t)>& callback, uintptr_t parameter = 0, uint stacksize = 0) -> thread;
+  static inline auto create(const function<void (uintptr)>& callback, uintptr parameter = 0, uint stacksize = 0) -> thread;
   static inline auto detach() -> void;
   static inline auto exit() -> void;
 
   struct context {
-    function<auto (uintptr_t) -> void> callback;
-    uintptr_t parameter = 0;
+    function<auto (uintptr) -> void> callback;
+    uintptr parameter = 0;
   };
 
 private:
@@ -111,7 +111,7 @@ auto thread::join() -> void {
   }
 }
 
-auto thread::create(const function<void (uintptr_t)>& callback, uintptr_t parameter, uint stacksize) -> thread {
+auto thread::create(const function<void (uintptr)>& callback, uintptr parameter, uint stacksize) -> thread {
   thread instance;
 
   auto context = new thread::context;
diff --git a/nall/varint.hpp b/nall/varint.hpp
index f684bf4c..ee18a036 100644
--- a/nall/varint.hpp
+++ b/nall/varint.hpp
@@ -10,8 +10,8 @@ struct varint {
   virtual auto read() -> uint8_t = 0;
   virtual auto write(uint8_t) -> void = 0;
 
-  auto readvu() -> uintmax_t {
-    uintmax_t data = 0, shift = 1;
+  auto readvu() -> uintmax {
+    uintmax data = 0, shift = 1;
     while(true) {
       uint8_t x = read();
       data += (x & 0x7f) * shift;
@@ -22,15 +22,15 @@ struct varint {
     return data;
   }
 
-  auto readvs() -> intmax_t {
-    uintmax_t data = readvu();
+  auto readvs() -> intmax {
+    uintmax data = readvu();
     bool negate = data & 1;
     data >>= 1;
     if(negate) data = ~data;
     return data;
   }
 
-  auto writevu(uintmax_t data) -> void {
+  auto writevu(uintmax data) -> void {
     while(true) {
       uint8_t x = data & 0x7f;
       data >>= 7;
@@ -40,7 +40,7 @@ struct varint {
     }
   }
 
-  auto writevs(intmax_t data) -> void {
+  auto writevs(intmax data) -> void {
     bool negate = data < 0;
     if(negate) data = ~data;
     data = (data << 1) | negate;
diff --git a/nall/vfs/fs/file.hpp b/nall/vfs/fs/file.hpp
index d52d3879..d899a434 100644
--- a/nall/vfs/fs/file.hpp
+++ b/nall/vfs/fs/file.hpp
@@ -11,15 +11,15 @@ struct file : vfs::file {
     return instance;
   }
 
-  auto size() const -> uintmax_t override {
+  auto size() const -> uintmax override {
     return _fp.size();
   }
 
-  auto offset() const -> uintmax_t override {
+  auto offset() const -> uintmax override {
     return _fp.offset();
   }
 
-  auto seek(intmax_t offset_, index index_) -> void override {
+  auto seek(intmax offset_, index index_) -> void override {
     _fp.seek(offset_, (nall::file::index)index_);
   }
 
diff --git a/nall/vfs/memory/file.hpp b/nall/vfs/memory/file.hpp
index 02bdcbb0..4f9afa27 100644
--- a/nall/vfs/memory/file.hpp
+++ b/nall/vfs/memory/file.hpp
@@ -5,18 +5,18 @@ namespace nall { namespace vfs { namespace memory {
 struct file : vfs::file {
   ~file() { delete[] _data; }
 
-  static auto open(const uint8_t* data, uintmax_t size) -> vfs::shared::file {
+  static auto open(const uint8_t* data, uintmax size) -> vfs::shared::file {
     auto instance = shared_pointer<file>{new file};
     instance->_open(data, size);
     return instance;
   }
 
-  auto size() const -> uintmax_t override { return _size; }
-  auto offset() const -> uintmax_t override { return _offset; }
+  auto size() const -> uintmax override { return _size; }
+  auto offset() const -> uintmax override { return _offset; }
 
-  auto seek(intmax_t offset, index mode) -> void override {
-    if(mode == index::absolute) _offset = (uintmax_t)offset;
-    if(mode == index::relative) _offset += (intmax_t)offset;
+  auto seek(intmax offset, index mode) -> void override {
+    if(mode == index::absolute) _offset = (uintmax)offset;
+    if(mode == index::relative) _offset += (intmax)offset;
   }
 
   auto read() -> uint8_t override {
@@ -34,15 +34,15 @@ private:
   file(const file&) = delete;
   auto operator=(const file&) -> file& = delete;
 
-  auto _open(const uint8_t* data, uintmax_t size) -> void {
+  auto _open(const uint8_t* data, uintmax size) -> void {
     _size = size;
     _data = new uint8_t[size];
     nall::memory::copy(_data, data, size);
   }
 
   uint8_t* _data = nullptr;
-  uintmax_t _size = 0;
-  uintmax_t _offset = 0;
+  uintmax _size = 0;
+  uintmax _offset = 0;
 };
 
 }}}
diff --git a/nall/vfs/vfs.hpp b/nall/vfs/vfs.hpp
index 69449217..b1589bbf 100644
--- a/nall/vfs/vfs.hpp
+++ b/nall/vfs/vfs.hpp
@@ -11,10 +11,10 @@ struct file {
 
   virtual ~file() = default;
 
-  virtual auto size() const -> uintmax_t = 0;
-  virtual auto offset() const -> uintmax_t = 0;
+  virtual auto size() const -> uintmax = 0;
+  virtual auto offset() const -> uintmax = 0;
 
-  virtual auto seek(intmax_t offset, index = index::absolute) -> void = 0;
+  virtual auto seek(intmax offset, index = index::absolute) -> void = 0;
   virtual auto read() -> uint8_t = 0;
   virtual auto write(uint8_t data) -> void = 0;
   virtual auto flush() -> void {}
@@ -23,19 +23,19 @@ struct file {
     return offset() >= size();
   }
 
-  auto read(void* vdata, uintmax_t bytes) -> void {
+  auto read(void* vdata, uintmax bytes) -> void {
     auto data = (uint8_t*)vdata;
     while(bytes--) *data++ = read();
   }
 
-  auto readl(uint bytes) -> uintmax_t {
-    uintmax_t data = 0;
-    for(auto n : range(bytes)) data |= (uintmax_t)read() << n * 8;
+  auto readl(uint bytes) -> uintmax {
+    uintmax data = 0;
+    for(auto n : range(bytes)) data |= (uintmax)read() << n * 8;
     return data;
   }
 
-  auto readm(uint bytes) -> uintmax_t {
-    uintmax_t data = 0;
+  auto readm(uint bytes) -> uintmax {
+    uintmax data = 0;
     for(auto n : range(bytes)) data = data << 8 | read();
     return data;
   }
@@ -47,16 +47,16 @@ struct file {
     return s;
   }
 
-  auto write(const void* vdata, uintmax_t bytes) -> void {
+  auto write(const void* vdata, uintmax bytes) -> void {
     auto data = (const uint8_t*)vdata;
     while(bytes--) write(*data++);
   }
 
-  auto writel(uintmax_t data, uint bytes) -> void {
+  auto writel(uintmax data, uint bytes) -> void {
     for(auto n : range(bytes)) write(data), data >>= 8;
   }
 
-  auto writem(uintmax_t data, uint bytes) -> void {
+  auto writem(uintmax data, uint bytes) -> void {
     for(auto n : rrange(bytes)) write(data >> n * 8);
   }
 
diff --git a/nall/windows/detour.hpp b/nall/windows/detour.hpp
index bedb1901..d4f304cd 100644
--- a/nall/windows/detour.hpp
+++ b/nall/windows/detour.hpp
@@ -86,7 +86,7 @@ auto detour::insert(const string& moduleName, const string& functionName, void*&
   DWORD privileges;
   VirtualProtect((void*)mirrorData, 512, PAGE_EXECUTE_READWRITE, &privileges);
   VirtualProtect((void*)sourceData, 256, PAGE_EXECUTE_READWRITE, &privileges);
-  uintmax address = (uintmax)target - ((uintmax)sourceData + 5);
+  uint64_t address = (uint64_t)target - ((uint64_t)sourceData + 5);
   sourceData[0] = 0xe9;  //jmp target
   sourceData[1] = address >>  0;
   sourceData[2] = address >>  8;
@@ -157,11 +157,11 @@ auto detour::mirror(uint8* target, const uint8* source) -> uint {
       break;
     case RelNear: {
       source++;
-      uintmax sourceAddress = (uintmax)source + 1 + (int8)*source;
+      uint64_t sourceAddress = (uint64_t)source + 1 + (int8)*source;
       *target++ = opcode->modify;
       if(opcode->modify >> 8) *target++ = opcode->modify >> 8;
-      uintmax targetAddress = (uintmax)target + 4;
-      uintmax address = sourceAddress - targetAddress;
+      uint64_t targetAddress = (uint64_t)target + 4;
+      uint64_t address = sourceAddress - targetAddress;
       *target++ = address >>  0;
       *target++ = address >>  8;
       *target++ = address >> 16;
@@ -173,7 +173,7 @@ auto detour::mirror(uint8* target, const uint8* source) -> uint {
     size -= opcode->length;
   }
 
-  uintmax address = (entryPoint + detour::length(entryPoint)) - (target + 5);
+  uint64_t address = (entryPoint + detour::length(entryPoint)) - (target + 5);
   *target++ = 0xe9;  //jmp entryPoint
   *target++ = address >>  0;
   *target++ = address >>  8;