diff --git a/README.md b/README.md
index 2c6e305..31a2607 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,3 @@
-# cave-story-randomizer
+Cave Story Randomizer
+=====================
 
diff --git a/docs/csresearch.txt b/docs/csresearch.txt
new file mode 100644
index 0000000..7d0f603
--- /dev/null
+++ b/docs/csresearch.txt
@@ -0,0 +1,666 @@
+-=~ Cave Story Research Compendium ~=-
+
+-=~ A guide to Cave Story's file formats and important hacks for those who are interested ~=-
+by F_Deity_Link, using research by others as well
+Made it for myself to learn as well as because the file formats and important hacks weren't all 'published'
+  (actually they're in miza.chm, included with the Miza editor, but I hadn't realized this when I started),
+  and I figured a centralized document with all of it would be helpful
+
+Last updated 2017-02-06
+
+Note that some info might be incorrect - SP's guides are a bit old - feel free to tell me of anything that could be updated
+
+-=~ Credits ~=-
+Big thanks to all the people I got much of this research from!
+  - Carrotlord for TSC file format
+  - q3hardcore for (C)Pixel requirement removal
+  - S.P. Gardebiter for PXA values + EXE mapdata format + npc.tbl format
+  - dooey100 for flag setting, unsetting, and checking
+  - Noxid for Booster's Lab, which helped for seeing how edits affected the files, as well as getting newest info
+    - especially tilesets and sounds in npc.tbl
+
+-=~ TSC File Format ~=-
+  Encoding char is the middle character in file: char at floor (file size / 2)
+  ex: size of 313 bytes, encode char is at 156th byte
+
+  Newlines are Windows-style newlines ("\r\n"): 0x0D + encode char val, then 0x0A + encode char val
+    - Because they're Windows-style newlines, open your files in binary mode, not text, otherwise the following transformations are done, which will end up corrupting the file
+      - "\r\n" --> '\n' for input
+      - '\n' --> "\r\n" for output
+
+  All characters in the file except for the encoding char itself (so other copies of the character are still encoded) have the value of the encoding char added to them when saved
+  ex: encoding char = [space]: only that instance of the [space] character will not be encoded, but the others will
+
+  When reading a TSC file, subtract the encoding character from each character (except the encoding char itself, as noted above) to properly decode the file
+  When writing a TSC file, add the encoding character to each character (except the encoding char itself, as noted above) to properly encode the file
+
+-=~ Removing (C)Pixel Requirement ~=-
+  0x1136C: 0x74 --> 0xEB
+  0x8C4D8: 0x28 --> 0x00
+
+  Then in every .pbm, find the (C)Pixel at the end and change the '(' to the null character (0x00)
+
+-=~ Allowing bitmaps ~=-
+  0x8C286 through 8 and 0x0008C30A through C: 0x70, 0x62, and 0x6D --> 0x62, 0x6D, and 0x70
+  0x8C32E and F: 0x70 and 0x62 --> 0x62 and 0x6D
+  0x8C330: 0x6D --> 0x70
+
+-=~ npc.tbl Format ~=-
+  Cave Story has 361 entities (0x169) from 0 - 360
+  npc.tbl has 11 sets of data, the starting addresses of which are all multiples of 0x169:
+    0x0000: Flags - 2 Bytes
+    0x02D2: Health - 2 Bytes
+    0x05A4: Tileset Number - 1 Byte
+    0x070D: Death Sound - 1 Byte
+    0x0876: Hurt Sound - 1 Byte
+    0x09DF: Death Smoke - 1 Byte
+    0x0B48: Experience - 4 Bytes
+    0x10EC: Damage - 4 Bytes
+    0x1690: Collsion Bounding Box - 4 Bytes
+    0x1C34: Display Bounding Box - 4 Bytes
+
+  -=~ Flags ~=-
+    -=~ Byte 1 ~=-
+      0x01: Solid
+      0x02: No effect about Tile 44
+      0x04: Invulnerable (Blink Sound)
+      0x08: Ignore solid
+      0x10: Bouncing at top
+      0x20: Shootable
+      0x40: Special Solid
+      0x80: Rear and top no damage
+
+    -=~ Byte 2 ~=-
+      0x01: Call Event on Contact
+      0x02: Call Event on Death
+      0x04: Drop Hearts and EXP [Unused]
+      0x08: Visible if FlagID is set
+      0x10: Spawn with Alternate Direction
+      0x20: Call Event on Interaction
+      0x40: Invisible if FlagID is set
+      0x80: Show Damage Numbers ?"Interactable" in Booster's Lab
+
+    Setting Flags: Flag to set OR current flags
+    Unsetting Flags: (Flag to unset XOR 1111 1111) AND current flags
+    Checking Flags: Flag to check AND current flags - returns flag being checked if it is set, 0 if not set
+
+  -=~ Tilesets ~=-
+    0x00: title.pbm
+    0x01: '2004.12 Studio Pixel'
+    0x02: Current map tileset
+    0x03: [Unused]
+    0x04: [Unused]
+    0x05: [Unused]
+    0x06: Fade.pbm
+    0x07: [Unused]
+    0x08: ItemImage.pbm
+    0x09: Map System Buffer
+    0x0A: Screen Buffer
+    0x0B: Arms.pbm
+    0x0C: ArmsImage.pbm
+    0x0D: MNA Text Buffer
+    0x0E: StageImage.pbm
+    0x0F: Loading.pbm
+    0x10: MyChar.pbm
+    0x11: Bullet.pbm
+    0x12: [Unused]
+    0x13: Caret.pbm
+    0x14: Npc/NpcSym.pbm
+    0x15: Map NPC Set 1
+    0x16: Map NPC Set 2
+    0x17: Npc/NpcRegu.pbm
+    0x18: [Unused]
+    0x19: [Unused]
+    0x1A: TextBox.pbm
+    0x1B: Face.pbm
+    0x1C: Current Map BG
+    0x1D: Damage # Buffer
+    0x1E: Textbox Buffer 1
+    0x1F: Textbox Buffer 2
+    0x20: Textbox Buffer 3
+    0x21: [???]
+    0x22: [Unused]
+    0x23: Credits Buffer 1
+    0x24: Credits Buffer 2
+    0x25: Credits Buffer 3
+    0x26: [Unused]
+    0x27: [Unused]
+
+  -=~ Hurt / Death Sounds ~=-
+    0x00: [Nothing]
+    0x01: Blip
+    0x02: Message Typing
+    0x03: Bonk
+    0x04: Weapon Switching
+    0x05: Menu Prompt?
+    0x06: Critter hop
+    0x07: Silent?
+    0x08: Low charge sound
+    0x09: [Nothing?]
+    0x0A: [Nothing?]
+    0x0B: Door
+    0x0C: Block Destroy
+    0x0D: [Nothing?]
+    0x0E: Get EXP
+    0x0F: Quote Jump
+    0x10: Taking Damage
+    0x11: Death
+    0x12: [Menu?]
+    0x13: [Nothing?]
+    0x14: Health/Ammo Refill
+    0x15: Bubble
+    0x16: Chest open
+    0x17: Thud
+    0x18: Walking
+    0x19: Enemy killed?
+    0x1A: Quake
+    0x1B: Level up
+    0x1C: Shot hit
+    0x1D: Teleport
+    0x1E: Critter jump
+    0x1F: Ting
+    0x20: Polar Star lvl
+    0x21: Fireball
+    0x22: Fireball bounce
+    0x23: Explosion
+    0x24: [Nothing?]
+    0x25: No Ammo
+    0x26: Get item?
+    0x27: [*bvng*] Em fire? - taken from BL, what is em?
+    0x28: Water
+    0x29: Water
+    0x2A: Get Missile [Beep]
+    0x2B: Computer [Beep]
+    0x2C: Missile Hit
+    0x2D: EXP Bounce
+    0x2E: Ironhead Shot
+    0x2F: Explosion 2?
+    0x30: Bubble pop
+    0x31: Spur lvl 1
+    0x32: Sqeek!
+    0x33: Squeal!
+    0x34: Roar
+    0x35: Eyoww
+    0x36: Thud
+    0x37: Squeek
+    0x38: Splash
+    0x39: Little damage sound
+    0x3A: [*chik*]
+    0x3B: Spur Charge (lowest)
+    0x3C: Spur Charge (lower)
+    0x3D: Spur Charge (higher)
+    0x3E: Spur lvl 2
+    0x3F: Spur lvl 3
+    0x40: Spur MAX
+    0x41: Spur full?
+    0x42: [Nothing?]
+    0x43: [Nothing?]
+    0x44: [Nothing?]
+    0x45: [Nothing?]
+    0x46: Tiny Explosion
+    0x47: Medium Explosion
+    0x48: Large Explosion
+    0x49: [Nothing?]
+    0x4A: [Nothing?]
+    0x4B: [Nothing?]
+    0x4C: [Nothing?]
+    0x4D: [Nothing?]
+    0x4E: [Nothing?]
+    0x4F: [Nothing?]
+    0x50: [Nothing?]
+    0x51: [Nothing?]
+    0x52: [Nothing?]
+    0x53: [Nothing?]
+    0x54: [Nothing?]
+    0x55: [Nothing?]
+    0x56: [Nothing?]
+    0x57: [Nothing?]
+    0x58: [Nothing?]
+    0x59: [Nothing?]
+    0x5A: [Nothing?]
+    0x5B: [Nothing?]
+    0x5C: [Nothing?]
+    0x5D: [Nothing?]
+    0x5E: [Nothing?]
+    0x5F: [Nothing?]
+    0x60: [Nothing?]
+    0x61: [Nothing?]
+    0x62: [Nothing?]
+    0x63: [Nothing?]
+    0x64: Bubbler lvl 3
+    0x65: Lightning
+    0x66: Sandcroc Bite
+    0x67: Curly Charge
+    0x68: Hit Invisible Block
+    0x69: Puppy Bark
+    0x6A: Blade whoosh
+    0x6B: Block Move
+    0x6C: Power Critter Jump
+    0x6D: Critter Fly
+    0x6E: Power Critter Fly
+    0x6F: Thud
+    0x70: Bigger thud
+    0x71: [*pshew*] Helicopter?
+    0x72: Core hurt
+    0x73: Core thrust
+    0x74: Core super charge
+    0x75: Nemesis?
+    0x76: [Nothing?]
+    0x77: [Nothing?]
+    0x78: [Nothing?]
+    0x79: [Nothing?]
+    0x7A: [Nothing?]
+    0x7B: [Nothing?]
+    0x7C: [Nothing?]
+    0x7D: [Nothing?]
+    0x7E: [Nothing?]
+    0x7F: [Nothing?]
+    0x80: [Nothing?]
+    0x81: [Nothing?]
+    0x82: [Nothing?]
+    0x83: [Nothing?]
+    0x84: [Nothing?]
+    0x85: [Nothing?]
+    0x86: [Nothing?]
+    0x87: [Nothing?]
+    0x88: [Nothing?]
+    0x89: [Nothing?]
+    0x90: [Nothing?]
+    0x91: [Nothing?]
+    0x92: [Nothing?]
+    0x93: [Nothing?]
+    0x94: [Nothing?]
+    0x95: [Nothing?]
+    0x96: BASS01
+    0x97: SNARE01
+    0x98: HICLOSE
+    0x99: HIOPEN
+    0x9A: TOM01
+    0x9B: PER01
+
+  -=~ Smoke ~=-
+    0x01: None
+    0x02: Small amount
+    0x03: Medium amount
+    0x04: Large amount
+
+  -=~ Bounding Box Addresses ~=-
+    (from beginning of each portion)
+    0x00: Left
+    0x01: Top
+    0x02: Right
+    0x03: Bottom
+
+-=~ Map Formats ~=-
+
+  -=~ Mapdata Addresses ~=-
+    (for freeware and stage.tbl(CS+))
+    (from the beginning of each map section)
+    0x00: Tileset name
+    0x20: Filename
+    0x40: Background Scrolling Type
+    0x44: Background Name
+    0x64: NPC Spritesheet 1
+    0x84: NPC Spritesheet 2
+    0xA4: Major Boss
+    0xA5: Mapname
+
+    -=~ Background Scrolling Types ~=-
+      0x00: No Scrolling
+      0x01: Slow Scrolling
+      0x02: Equal Scrolling
+      0x03: Water-Style
+      0x04: Null
+      0x05: Auto Scrolling
+      0x06: Cloud-Style [Gravity: Left]
+      0x07: Cloud-Style [Gravity: Normal]
+
+    -=~ Major Bosses are as follows ~=-
+      0x00: No Major Boss
+      0x01: Omega
+      0x02: Balfrog
+      0x03: Monster X
+      0x04: The Core
+      0x05: Iron Head
+      0x06: Dragon Sisters
+      0x07: Undead Core
+      0x08: Heavy Press
+      0x09: Ballos
+
+
+  WINDOWS IS LITTLE-ENDIAN AND ALL DATA (with the exception of PXM map tile and PXE entity count) TAKES UP TWO BYTES
+    ex: x coord of 256 (dec) is 0x0100, seen as 00 01 in hex editor
+
+  -=~ PXM File Data ~=-
+    maps must be minimum of 21x16
+
+    First three bytes are PXM, then 0x10
+
+    Then 0x_map_length - 2 bytes
+    Then 0x_map_height - 2 bytes
+
+    Then 0x_map_tile_from_tileset for the rest of the file (numbered from 0, and going left to right, top to bottom) - 1 byte
+
+  -=~ PXE File Data ~=-
+    First three bytes are PXE, then 0x00
+
+    Then 0x_entity_count - 4 bytes
+
+    Then each entity takes up 12 bytes, and they are in order based on their draw order (higher drawn on top) - lowest in file first:
+      0x_x_coord - 2 bytes
+      0x_y_coord - 2 bytes
+
+      0x_flag_num - 2 bytes
+      0x_event_num - 2 bytes
+
+      0x_entity_type - 2 bytes
+      0x_entity_flags - 2 bytes
+
+      -=~ Flags ~=-
+        Setting: Flag to set OR current flags
+        Unsetting: (Flag to unset XOR 1111 1111) AND current flags
+        Checking: Flag to check AND current flags - returns flag being checked if it is set, 0 if not set
+
+  -=~ PXA File Data ~=-
+    Format is tile type, corresponds to tileset directly - file has no header
+    Tilesets can be 16x16 tiles max, so PXA has 256 bytes, value of 0 for tiles not in tileset image
+
+    -=~ Tile Types ~=-
+
+      Flags:
+      0x01: Special
+      0x02: Special
+      0x04: Special
+      0x08: Special
+      0x10: Slope
+      0x20: Water
+      0x40: Foreground
+      0x80: Wind
+
+      0x00 (Null):
+      0x00: Null
+      0x01: Background Tile
+      0x02: Background Water
+      0x03: Background NPC-Blocker Tile [Unused]
+      0x04: Background NPC-Blocker Tile [Unused]
+      0x05: Background Shoot-Passer Tile [Unused]
+      0x06: Background Tile [Unused]
+      0x07: Background Tile [Unused]
+      0x08: Background Tile [Unused]
+      0x09: Background Tile [Unused]
+      0x0A: Background Tile [Unused]
+      0x0B: Background Tile [Unused]
+      0x0C: Background Tile [Unused]
+      0x0D: Background Tile [Unused]
+      0x0E: Background Tile [Unused]
+      0x0F: Background Tile [Unused]
+
+      0x10 (Slope):
+      0x10: Background Tile [Unused]
+      0x11: Background Tile [Unused]
+      0x12: Background Tile [Unused]
+      0x13: Background Tile [Unused]
+      0x14: Background Tile [Unused]
+      0x15: Background Tile [Unused]
+      0x16: Background Tile [Unused]
+      0x17: Background Tile [Unused]
+      0x18: Background Tile [Unused]
+      0x19: Background Tile [Unused]
+      0x1A: Background Tile [Unused]
+      0x1B: Background Tile [Unused]
+      0x1C: Background Tile [Unused]
+      0x1D: Background Tile [Unused]
+      0x1E: Background Tile [Unused]
+      0x1F: Background Tile [Unused]
+
+      0x20 (Water):
+      0x20: Null [Unused]
+      0x21: Null [Unused]
+      0x22: Null [Unused]
+      0x23: Null [Unused]
+      0x24: Null [Unused]
+      0x25: Null [Unused]
+      0x26: Null [Unused]
+      0x27: Null [Unused]
+      0x28: Null [Unused]
+      0x29: Null [Unused]
+      0x2A: Null [Unused]
+      0x2B: Null [Unused]
+      0x2C: Null [Unused]
+      0x2D: Null [Unused]
+      0x2E: Null [Unused]
+      0x2F: Null [Unused]
+
+      0x30 (Slope + Water):
+      0x30: Null [Unused]
+      0x31: Null [Unused]
+      0x32: Null [Unused]
+      0x33: Null [Unused]
+      0x34: Null [Unused]
+      0x35: Null [Unused]
+      0x36: Null [Unused]
+      0x37: Null [Unused]
+      0x38: Null [Unused]
+      0x39: Null [Unused]
+      0x3A: Null [Unused]
+      0x3B: Null [Unused]
+      0x3C: Null [Unused]
+      0x3D: Null [Unused]
+      0x3E: Null [Unused]
+      0x3F: Null [Unused]
+
+      0x40 (Foreground):
+      0x40: Foreground Tile
+      0x41: Solid Tile
+      0x42: 10 Damage Foreground Tile
+      0x43: Special Block Tile
+      0x44: Foreground NPC-Blocker Tile
+      0x45: Foreground Tile [Unused]
+      0x46: Character-Blocker Tile [Unused]
+      0x47: Foreground Tile [Unused]
+      0x48: Foreground Tile [Unused]
+      0x49: Foreground Tile [Unused]
+      0x4A: Foreground Tile [Unused]
+      0x4B: Foreground Tile [Unused]
+      0x4C: Foreground Tile [Unused]
+      0x4D: Foreground Tile [Unused]
+      0x4E: Foreground Tile [Unused]
+      0x4F: Foreground Tile [Unused]
+
+      0x50 (Foreground + Slope):
+      0x50: Slope Tile
+      0x51: Slope Tile
+      0x52: Slope Tile
+      0x53: Slope Tile
+      0x54: Slope Tile
+      0x55: Slope Tile
+      0x56: Slope Tile
+      0x57: Slope Tile
+      0x58: Foreground Tile [Unused]
+      0x59: Foreground Tile [Unused]
+      0x5A: Foreground Tile [Unused]
+      0x5B: Foreground Tile [Unused]
+      0x5C: Foreground Tile [Unused]
+      0x5D: Foreground Tile [Unused]
+      0x5E: Foreground Tile [Unused]
+      0x5F: Foreground Tile [Unused]
+
+      0x60 (Foreground + Water):
+      0x60: Foreground Water
+      0x61: Solid Tile [Unused]
+      0x62: 10 Damage Foreground Water Tile [Red]
+      0x63: Foreground Tile [Unused]
+      0x64: Foreground NPC-Blocker Tile [Unused]
+      0x65: Foreground Tile [Unused]
+      0x66: Foreground Tile [Unused]
+      0x67: Foreground Tile [Unused]
+      0x68: Foreground Tile [Unused]
+      0x69: Foreground Tile [Unused]
+      0x6A: Foreground Tile [Unused]
+      0x6B: Foreground Tile [Unused]
+      0x6C: Foreground Tile [Unused]
+      0x6D: Foreground Tile [Unused]
+      0x6E: Foreground Tile [Unused]
+      0x6F: Foreground Tile [Unused]
+
+      0x70 (Foreground + Slope + Water):
+      0x70: Slope Tile [Water]
+      0x71: Slope Tile [Water]
+      0x72: Slope Tile [Water]
+      0x73: Slope Tile [Water]
+      0x74: Slope Tile [Water]
+      0x75: Slope Tile [Water]
+      0x76: Slope Tile [Water]
+      0x77: Slope Tile [Water]
+      0x78: Foreground Tile [Unused]
+      0x79: Foreground Tile [Unused]
+      0x7A: Foreground Tile [Unused]
+      0x7B: Foreground Tile [Unused]
+      0x7C: Foreground Tile [Unused]
+      0x7D: Foreground Tile [Unused]
+      0x7E: Foreground Tile [Unused]
+      0x7F: Foreground Tile [Unused]
+
+      0x80 (Wind):
+      0x80: Wind [Left]
+      0x81: Wind [Up]
+      0x82: Wind [Right]
+      0x83: Wind [Down]
+      0x84: Null [Unused]
+      0x85: Null [Unused]
+      0x86: Null [Unused]
+      0x87: Null [Unused]
+      0x88: Null [Unused]
+      0x89: Null [Unused]
+      0x8A: Null [Unused]
+      0x8B: Null [Unused]
+      0x8C: Null [Unused]
+      0x8D: Null [Unused]
+      0x8E: Null [Unused]
+      0x8F: Null [Unused]
+
+      0x90 (Wind + Slope):
+      0x90: Null [Unused]
+      0x91: Null [Unused]
+      0x92: Null [Unused]
+      0x93: Null [Unused]
+      0x94: Null [Unused]
+      0x95: Null [Unused]
+      0x96: Null [Unused]
+      0x97: Null [Unused]
+      0x98: Null [Unused]
+      0x99: Null [Unused]
+      0x9A: Null [Unused]
+      0x9B: Null [Unused]
+      0x9C: Null [Unused]
+      0x9D: Null [Unused]
+      0x9E: Null [Unused]
+      0x9F: Null [Unused]
+
+      0xA0 (Wind + Water):
+      0xA0: Water Wind [Left]
+      0xA1: Water Wind [Up]
+      0xA2: Water Wind [Right]
+      0xA3: Water Wind [Down]
+      0xA4: Null [Unused]
+      0xA5: Null [Unused]
+      0xA6: Null [Unused]
+      0xA7: Null [Unused]
+      0xA8 :Null [Unused]
+      0xA9: Null [Unused]
+      0xAA: Null [Unused]
+      0xAB: Null [Unused]
+      0xAC: Null [Unused]
+      0xAD: Null [Unused]
+      0xAE: Null [Unused]
+      0xAF: Null [Unused]
+
+      0xB0 (Wind + Slope + Water):
+      0xB0: Null [Unused]
+      0xB1: Null [Unused]
+      0xB2: Null [Unused]
+      0xB3: Null [Unused]
+      0xB4: Null [Unused]
+      0xB5: Null [Unused]
+      0xB6: Null [Unused]
+      0xB7: Null [Unused]
+      0xB8: Null [Unused]
+      0xB9: Null [Unused]
+      0xBA: Null [Unused]
+      0xBB: Null [Unused]
+      0xBC: Null [Unused]
+      0xBD: Null [Unused]
+      0xBE: Null [Unused]
+      0xBF: Null [Unused]
+
+      0xC0 (Wind + Foreground):
+      0xC0: Null [Unused]
+      0xC1: Null [Unused]
+      0xC2: Null [Unused]
+      0xC3: Null [Unused]
+      0xC4: Null [Unused]
+      0xC5: Null [Unused]
+      0xC6: Null [Unused]
+      0xC7: Null [Unused]
+      0xC8: Null [Unused]
+      0xC9: Null [Unused]
+      0xCA: Null [Unused]
+      0xCB: Null [Unused]
+      0xCC: Null [Unused]
+      0xCD: Null [Unused]
+      0xCE: Null [Unused]
+      0xCF: Null [Unused]
+
+      0xD0 (Wind + Foreground + Slope):
+      0xD0: Null [Unused]
+      0xD1: Null [Unused]
+      0xD2: Null [Unused]
+      0xD3: Null [Unused]
+      0xD4: Null [Unused]
+      0xD5: Null [Unused]
+      0xD6: Null [Unused]
+      0xD7: Null [Unused]
+      0xD8: Null [Unused]
+      0xD9: Null [Unused]
+      0xDA: Null [Unused]
+      0xDB: Null [Unused]
+      0xDC: Null [Unused]
+      0xDD: Null [Unused]
+      0xDE: Null [Unused]
+      0xDF: Null [Unused]
+
+      0xE0 (Wind + Foreground + Water):
+      0xE0: Null [Unused]
+      0xE1: Null [Unused]
+      0xE2: Null [Unused]
+      0xE3: Null [Unused]
+      0xE4: Null [Unused]
+      0xE5: Null [Unused]
+      0xE6: Null [Unused]
+      0xE7: Null [Unused]
+      0xE8: Null [Unused]
+      0xE9: Null [Unused]
+      0xEA: Null [Unused]
+      0xEB: Null [Unused]
+      0xEC: Null [Unused]
+      0xED: Null [Unused]
+      0xEE: Null [Unused]
+      0xEF: Null [Unused]
+
+      0xF0 (Wind + Foreground + Slope + Water):
+      0xF0: Null [Unused]
+      0xF1: Null [Unused]
+      0xF2: Null [Unused]
+      0xF3: Null [Unused]
+      0xF4: Null [Unused]
+      0xF5: Null [Unused]
+      0xF6: Null [Unused]
+      0xF7: Null [Unused]
+      0xF8: Null [Unused]
+      0xF9: Null [Unused]
+      0xFA: Null [Unused]
+      0xFB: Null [Unused]
+      0xFC: Null [Unused]
+      0xFD: Null [Unused]
+      0xFE: Null [Unused]
+      0xFF: Null [Unused]
diff --git a/docs/tsc notes.txt b/docs/tsc notes.txt
new file mode 100644
index 0000000..1d34dd5
--- /dev/null
+++ b/docs/tsc notes.txt	
@@ -0,0 +1,557 @@
+Doukutsu Monogatari - TSC notes     (aka Cave Story)
+ by Kapow - 2006 April 24
+ additions by ShInInG PhAnToM - 2007 June 05
+ original: http://lotlot.net/misc/doukutsu/tsc.txt
+ updated: http://filespace.org/ShInInG_PhAnToM/TSC.TXT
+
+THANKS:
+  caveoholic and upthorn from gameflaws forums
+  robert vandiver, for unused TSC commands
+  supergodantman
+
+TSC COMMANDS   (@ = available but unused commands found through disassembly - currently untested)
+============
+<AE+         Arms Energy +          Refill ammo
+<AM+x:y      ArMs +                 Get weapon X, add Y to max ammo (just adds ammo if you have the weapon)
+<AM-x        ArMs -                 Lose weapon X
+<AMJx:y      ArMs Jump              Jump to event Y if you have weapon X
+<ANPx:y:z    Animate NPc            Animate npc X with method Y in direction Z [npc type determines Y values?]
+<BOAx        BOss Animate           Animate boss
+<BSLx        Boss [Script Load?]    Start a boss fight with npc X (npc flag 0200 must be set) (should work with anything that has HP)
+<CAT         [?]                  @ [same as SAT?]
+<CIL         Clear ILlustration     Clear illustration during credits (used after SIL)
+<CLO         CLOse                  Close the text box (used after MSG/MS2/MS3)
+<CLR         CLeaR                  Clear the text box (used after MSG/MS2/MS3)
+<CMPx:y:z    Change Map [P?]        Change map coords X:Y to tile Z
+<CMUx        Change MUsic           Change music to song X
+<CNPx:y:z    Change NPc             Change npc X to npc type Y with direction Z
+<CPS         Clear Prop. Sound      Stop propeller sound (used after SPS) (from helicopter cutscene after final battles)
+<CRE         CREdits                Roll credits
+<CSS         Clear Stream Sound     Stop stream sound (used after SSS) (from River area)
+<DNAx        [?]                    [something to do with bosses]
+<DNPx        Delete NPc             Npc X is removed completely
+<ECJx:y      [EC?] Jump           @ Jump to event Y if any npc with ID X is present
+<END         END                    End scripted event
+<EQ+x        EQuip +                Add X to equip flag bytes
+<EQ-x        EQuip -                Subtract X from equip flag bytes
+<ESC         ESCape                 Quit to title screen
+<EVEx        EVEnt                  Jump to event X (non-conditional)
+<FACx        FACe                   Show face X in text box
+<FAIx        FAde In                Fade in with direction X
+<FAOx        FAde Out               Fade out with direction X
+<FL+x        FLag +                 Set flag X
+<FL-x        FLag -                 Clear flag X
+<FLA         FLAsh                  Flash the screen
+<FLJx:y      FLag Jump              Jump to event Y if flag X is set
+<FMU         Fade MUsic             Fade the music to a low volume (good to use before CMU)
+<FOBx:y      Focus On Boss          [Focus view on boss X? why not use FON?], view movement takes Y ticks
+<FOMx        Focus On Me            Focus view on you (normal view), view movement takes X ticks (WARNING: speed 0000 crashes)
+<FONx:y      Focus On Npc           Focus view on npc X, view movement takes Y ticks
+<FRE         FREe                   Frees menu cursor [also used after ZAM for some reason?]
+<GITx        Graphic ITem           Show weapon/item X icon above text box - add 1000 to X for items - GIT0000 to hide
+<HMC         Hide My Character      Removes main character npc (use SMC after)
+<INI         INItialize             Resets memory and starts game from the beginning
+<INPx:y:z    [I?] NPc             @ Change npc X to npc type Y with direction Z with setting Flag 0x0100 [It seems that it setting the "No Player Damage" Flag and not the Costum 0x0100 Flag]
+<IT+x        ITem +                 Get item X
+<IT-x        ITem -                 Lose item X
+<ITJx:y      ITem Jump              Jump to event Y if you have item X
+<KEY         KEYlock                Hides status bars and locks out input to your character until END (used with MSG/MS2/MS3 and PRI)
+<LDP         LoaD Profile           Loads profile.dat into memory and starts game from save
+<LI+x        LIfe +                 Restore X amount of health
+<ML+x        Max Life +             Max health increased X amount
+<MLP         Map [LP?]              Display map
+<MM0         My Motion 0            Instantly halts your horizontal motion
+<MNA         [Map NAme?]            Displays name of current map
+<MNPx:y:z:w  Move NPc               Move npc X to coords Y:Z facing direction W
+<MOVx:y      MOVe                   Move you to coords X:Y
+<MP+x        [MaP ??]             @ [map-related]
+<MPJx        [MaP Jump?]            [Jump to event X if map exists for current area?  the single instance of this seems to be dummied out]
+<MS2         MeSsage 2              Open invisible text box at top of screen (text follows)
+<MS3         MeSsage 3              Open normal text box at top of screen (text follows)
+<MSG         MeSsaGe 1              Open normal text box (text follows)
+<MYBx        MY Bump                Knocks you back from direction X (0000 knocked right, 0002 knocked left, any other just hops in place)
+<MYDx        MY Direction           Make you face direction X
+<NCJx:y      [NpC?] Jump            Jump to event Y if any npc of type X is present
+<NOD         [Nod?                  Text box wait for button press (used after MSG/MS2/MS3)
+<NUM0000     [Number?]              Used to output Y from AM+ as text
+<PRI         [?]                    Hides status bars and freezes game action until KEY or END (used with MSG/MS2/MS3)
+<PS+x:y      [P? Slot?]             Set teleporter slot X to location Y
+<QUAx        QUAke                  Shake the screen for X ticks
+<RMU         Restore MUsic          Restore music playback [plays previous song?  or only works with some songs?]
+<SAT         Speed-up All Text      Instant text display on all messages until END (glitches scrolling text)
+<SILx        Show ILlustration      Show illustration during credits (use CIL after)
+<SK+x        SKipflag +             Set skipflag X (remains set until program exits, to avoid repeating cutscenes/dialogue after retrying)
+<SK-x        SKipflag -?          @ Clear skipflag
+<SKJx:y      SKipflag Jump          Jump to event Y if skipflag X is set
+<SLP         [Show? Location? P?]   Teleporter location menu
+<SMC         Show My Character      Restores main character npc (used after HMC)
+<SMPx:y      [?]                    [do something with npc X? - only used before and after the Omega fight]
+<SNPx:y:z:w  [Start?] NPc         @ Create npc type X at coords Y:Z with direction W
+<SOUx        SOUnd                  Play sound effect X
+<SPS         Start Prop. Sound      Start propeller sound (use CPS after) (from helicopter cutscene after final battles)
+<SSSx        Start Stream Sound     Start stream sound at pitch X (use CSS after) (from River area - normal pitch is 0400)
+<STC         Save Time Counted      Saves the current time to 290.rec
+<SVP         SaVe Profile           Save game
+<TAMx:y:z    Trade ArMs             Trade weapon X for weapon Y, set max ammo to Z (max ammo 0000 = no change) (GLITCH: first weapon 0000)
+<TRAx:y:z:w  TRAnsport              Load map X, run event Y, transport you to coords Z:W
+<TUR         [?]                    Instant text display [until what? CLR?] (used after MSG/MS2/MS3)
+<UNIx        [?]                    [0000 normal / 0001 zero-g movement, facing direction is locked (disables focus commands) (from Stream boss) / 0002 movement is locked, can still fire]
+<UNJx        [?] Jump?              [?]
+<WAIx        WAIt                   Pause script for X ticks
+<WAS         WAit until Standing    Pause script until your character touches the ground
+<XX1x        [?]                    [shows distant view of island?]
+<YNJx        Yes/No Jump            Ask yes or no, jump to event X if No
+<ZAM         Zero ArMs              All weapons drop to level 1
+
+Notes:
+ Invalid commands show an error message displaying the command before the game exits
+ The "jump if equipped" function is done with FLJ - an arbitrary flag is chosen, and every instance of EQ+/EQ- must also have the FL+/FL- command
+ The colon between parameters can be any character (it's ignored)
+
+
+
+
+
+CREDITS FORMAT (credit.tsc)
+==============
+[T]X  Text T with casts.pbm image X [on left?]
++X     [?]
+!X     [?]
+-X     [line has height X?]
+fX:Y  Jump to location Y if flag X is set
+jX    Jump to location X
+lX    Location X
+~      [switch to the left half of the screen?]
+/      [end?]
+<<<    [comment?]
+
+
+
+
+NPC FLAGS
+==============
+0x0001 - Solid
+0x0002 - No effect about Tile 44
+0x0004 - Invulnerable (Blink Sound)
+0x0008 - Ignore solid
+0x0010 - Bouncing at top
+0x0020 - Shootable
+0x0040 - Special Solid
+0x0080 - Rear and top attack power 0
+0x0100 - Costum
+0x0200 - Boss Flag
+0x0400 - ???
+0x0800 - Is visible if FlagID is set
+0x1000 - Costum
+0x2000 - Call on Event
+0x4000 - Is invisible if FlagID is set
+0x8000 - Show Damage Numbers
+
+
+
+
+
+COMMAND VALUES
+==============
+Maps (TRA)        Profile.dat byte 0x008 - for position, 0x011-012: distance from left,
+                  0x015-016: distance from top, 20h (32) per map tile (low byte first)
+0000 0        Credits
+0001 Pens1    Arthur's House - normal
+0002 Eggs     Egg Corridor
+0003 EggX     Egg No. 00 - normal
+0004 Egg6     Egg No. 06
+0005 EggR     Egg Observation Room
+0006 Weed     Grasstown
+0007 Santa    Santa's House
+0008 Chako    Chaco's House
+0009 MazeI    Labyrinth I (vertical starting room)
+0010 Sand     Sand Zone - normal
+0011 Mimi     Mimiga Village
+0012 Cave     First Cave
+0013 Start    Start Point
+0014 Barr     Shack (Mimiga Village)
+0015 Pool     Reservoir
+0016 Cemet    Graveyard
+0017 Plant    Yamashita Farm
+0018 Shelt    Shelter (Grasstown)
+0019 Comu     Assembly Hall (Mimiga Village)
+0020 MiBox    Save Point (Mimiga Village)
+0021 EgEnd1   Side Room (Egg Corridor)
+0022 Cthu     Cthulhu's Abode (Egg Corridor)
+0023 Egg1     Egg No. 01
+0024 Pens2    Arthur's House - Sue on computer
+0025 Malco    Power Room (Grasstown)
+0026 WeedS    Save Point (Grasstown)
+0027 WeedD    Execution Chamber (Grasstown)
+0028 Frog     Gum (Grasstown)
+0029 Curly    Sand Zone Residence
+0030 WeedB    Grasstown Hut
+0031 Stream   Main Artery (Waterway)
+0032 CurlyS   Small Room (Sand Zone)
+0033 Jenka1   Jenka's House - normal
+0034 Dark     Deserted House (Sand Zone)
+0035 Gard     Sand Zone Storehouse
+0036 Jenka2   Jenka's House - after Balrog attacks
+0037 SandE    Sand Zone - after boss fight
+0038 MazeH    Labyrinth H (sliding block room)
+0039 MazeW    Labyrinth W (main area w/shop, camp)
+0040 MazeO    Camp (Labyrinth)
+0041 MazeD    Clinic Ruins (Labyrinth)
+0042 MazeA    Labyrinth Shop
+0043 MazeB    Labyrinth B (booster)
+0044 MazeS    Boulder Chamber (Labyrinth)
+0045 MazeM    Labyrinth M (gaudi eggs)
+0046 Drain    Dark Place (Labyrinth)
+0047 Almond   Core (Labyrinth)
+0048 River    Waterway
+0049 Eggs2    Egg Corridor?
+0050 Cthu2    Cthulhu's Abode? (Egg Corridor?)
+0051 EggR2    Egg Observation Room?
+0052 EggX2    Egg No. 00 - hatched
+0053 Oside    Outer Wall
+0054 EgEnd2   Side Room (Egg Corridor?)
+0055 Itoh     Storehouse (Outer Wall)
+0056 Cent     Plantation
+0057 Jail1    Jail No. 1 (Plantation)
+0058 Momo     Hideout (Plantation)
+0059 Lounge   Rest Area (Plantation)
+0060 CentW    Teleporter (Plantation)
+0061 Jail2    Jail No. 2 (Plantation)
+0062 Blcny1   Balcony - normal
+0063 Priso1   Last Cave
+0064 Ring1    Throne Room (Balcony)
+0065 Ring2    The King's Table (Balcony)
+0066 Prefa1   Prefab House (Balcony) - normal
+0067 Priso2   Last Cave Hidden
+0068 Ring3    Black Space (Balcony)
+0069 Little   Little House (Outer Wall)
+0070 Blcny2   Balcony - after boss fights
+0071 Fall     Ending
+0072 Kings    Intro
+0073 Pixel    Waterway Cabin
+0074 e_Maze   Credits - Labyrinth
+0075 e_Jenk   Credits - Jenka's House
+0076 e_Malc   Credits - Power Room
+0077 e_Ceme   Credits - Graveyard
+0078 e_Sky    Credits - Sky
+0079 Prefa2   Prefab House (Balcony) - entrance to hell
+0080 Hell1    Sacred Ground B1
+0081 Hell2    Sacred Ground B2
+0082 Hell3    Sacred Ground B3
+0083 Mapi     Storage (Graveyard)
+0084 Hell4    Passage? - normal
+0085 Hell42   Passage? - from Sacred Ground B3
+0086 Statue   Statue Chamber (Plantation/Sacred Grounds)
+0087 Ballo1   Seal Chamber (Sacred Grounds) - normal
+0088 Ostep    Corridor (Sacred Grounds)
+0089 e_Labo   Credits - Laboratory
+0090 Pole     Hermit Gunsmith
+0091 Island    [map is totally blank - TSC is called right before good/best endings]
+0092 Ballo2   Seal Chamber (Sacred Grounds) - after boss fight
+0093 e_Blcn   Credits - Balcony
+0094 Clock    Clock Room (Outer Wall)
+
+
+
+Directions (FAI/FAO/MYD/MYB)    Profile.dat bytes 0x018 (your direction)
+0000 Left
+0001 Up [FAI/FAO only?]
+0002 Right
+0003 Down
+0004 Center [FAI/FAO only?]
+ NOTE: MYB is 0000 Right, 0002 Left (reversed)
+
+
+
+Focus speed (FOB/FOM/FON)
+0000 (CRASH - probably divide by zero error)
+0001 Instant
+0016 Fast
+0032 Medium
+0064 Slow
+ NOTE: Any value besides zero should work, these four are the only ones used normally
+
+
+
+Weapons (AM+/AM-/AMJ/GIT/TAM)    Profile.dat bytes 0x038-098 (every 4 bytes: weapon, level (1-3),
+                                 energy, max ammo (0 = infinite), current ammo) (every 20 bytes)
+0000  [nothing?]
+0001 Snake
+0002 Polar Star
+0003 Fireball
+0004 Machine Gun
+0005 Missile Launcher
+0006 Missiles (GIT only)
+0007 Bubbler
+0008  [nothing?]
+0009 Blade
+0010 Super Missile Launcher
+0011 Super Missiles (GIT only)
+0012 Nemesis
+0013 Spur
+
+
+
+Items (GIT/IT+/IT-/ITJ)    Profile.dat bytes 0x0D8-14C (every 4 bytes)
+0000  [nothing?]
+0001 Arthur's Key
+0002 Map System
+0003 Santa's Key
+0004 Silver Locket
+0005 Beast Fang
+0006 Life Capsule (GIT only)
+0007 ID Card
+0008 Jellyfish Juice
+0009 Rusty Key
+0010 Gum Key
+0011 Gum Base
+0012 Charcoal
+0013 Explosive
+0014 Puppy
+0015 Life Pot
+0016 Cure-All
+0017 Clinic Key
+0018 Booster 0.8
+0019 Arms Barrier
+0020 Turbocharge
+0021 Curly's Air Tank
+0022 Nikumaru Counter
+0023 Booster v2.0
+0024 Mimiga Mask
+0025 Teleporter Room Key
+0026 Sue's Letter
+0027 Controller
+0028 Broken Sprinkler
+0029 Sprinkler
+0030 Tow Rope
+0031 Clay Figure Medal
+0032 Little Man
+0033 Mushroom Badge
+0034 Ma Pignon
+0035 Curly's Underwear
+0036 Alien Medal
+0037 Chaco's Lipstick
+0038 Whimsical Star
+0039 Iron Bond
+
+
+
+Equip (EQ+/EQ-)        Profile.dat bytes 0x02C-02D (low byte first)
+0001 Booster v0.8 (ignored if v2.0 on)
+0002 Map System
+0004 Arms Barrier
+0008 Turbocharge
+0016 Curly's Air Tank
+0032 Booster v2.0
+0064 Mimiga Mask
+0128 Whimsical Star
+0256 Nikumaru Counter
+ NOTE: these are bitwise flags, the final value is the sum of the equipped items
+
+
+
+Faces (FAC)
+0000  [blank - does this set the text to normal width?]
+0001 Sue (smile)
+0002 Sue (frown)
+0003 Sue (angry)
+0004 Sue (hurt)
+0005 Balrog (normal)
+0006 Toroko (normal)
+0007 King
+0008 Toroko (angry)
+0009 Jack
+0010 Kazuma
+0011 Toroko (rage)
+0012 Igor
+0013 Jenka
+0014 Balrog (smile)
+0015 Misery (normal)
+0016 Misery (smile)
+0017 Booster (hurt)
+0018 Booster (normal)
+0019 Curly (smile)
+0020 Curly (frown)
+0021 Doctor
+0022 Momorin
+0023 Balrog (hurt)
+0024 Broken robot
+0025 Curly (?)
+0026 Misery (angry)
+0027 Human Sue
+0028 Itoh
+0029 Ballos
+
+
+
+Illustrations (SIL)
+0001 riding Sky Dragon
+0002 fighting Core
+0003 fighting Misery
+0004 Momorin's rocket
+0005 Outer Wall
+0006 fighting Ironhead
+0007 fighting Balrog (with missiles)
+0008 Clinic
+0009 King fighting the Doctor
+0010 Jenka with puppies
+0011 Curly with Mimiga children
+0012 riding Balrog
+0014 Hell
+0015 floating island (blue sky)
+0016 floating island (orange sky)
+0017 King, Jack, Sue
+0018 Ballos
+ NOTE: any other values (including 0013) show 0001
+
+
+
+Songs (CMU)        Profile.dat byte 0x00C
+0000 (none - silence)
+0001 Mischievous Robot   Egg Chamber
+0002 Safety              various homes
+0003 (no title)          game over
+0004 Gravity             boss battle
+0005 On To Grasstown     Grasstown
+0006 Meltdown 2          Sand Zone
+0007 Eyes of Flame       major boss battle
+0008 Gestation           First Cave, various small rooms
+0009 Mimiga Town         Mimiga Village
+0010 (no title)          get item
+0011 Balrog's Theme      Balrog cutscenes
+0012 Cemetary            Graveyard
+0013 Plant               Yamashita Farm
+0014 Pulse               Egg No. 00, Waterway Cabin, Arthur's House after Waterway
+0015 (no title)          boss defeated
+0016 (no title)          get life capsule
+0017 Tyrant              Doctor cutscenes
+0018 Run!                Balcony areas after boss fights
+0019 Jenka 1             Jenka's House, Labyrinth I & H (first two areas)
+0020 Labyrinth Fight     Labyrinth M (gaudi eggs)
+0021 Access              Shelter (Kazuma on computer)
+0022 Oppression          Core battle
+0023 Geothermal          Dark Place, Core, [Main Artery?]
+0024 Cave Story          title screen, Plantation
+0025 Moonsong            Outer Wall
+0026 Hero's End          bad ending
+0027 Scorching Back      Egg Corridor?
+0028 Quiet               Mimiga Village and homes after Waterway
+0029 Final Cave          Last Cave
+0030 Balcony             Balcony
+0031 Charge              Muscle Doctor battle
+0032 Last Battle         final battles
+0033 The Way Back Home   Credits
+0034 Zombie              before Undead Core battle, after Ballos battle
+0035 Break Down          Ending
+0036 Running Hell        Sacred Grounds
+0037 Jenka 2             Labyrinth W (main area w/shop, camp)
+0038 Living Waterway     Waterway
+0039 Seal Chamber        before Ballos battle
+0040 Toroko's Theme      Title Screen - Toroko
+0041 ["White"?]          Title Screen - King
+
+
+
+Sound Effects (SOU)
+0000 <nothing>
+0001  [blip]
+0002 Message typing
+0003 Bonk
+0004 Weapon switch
+0005  [?]
+0006  [critter hop?]
+0007  [nothing?]
+0008  [nothing?]
+0009  [nothing?]
+0010  [nothing?]
+0011 Door
+0012  [*plsh* - map tile change?]
+0013  [nothing?]
+0014 Get weapon energy
+0015  [click]
+0016 Take damage
+0017 Die
+0018  [menu?]
+0019  [nothing?]
+0020 Health/ammo refill
+0021  [bubble]
+0022 Click (chest, life capsule, unlock door)
+0023  [thud]
+0024  [tap - walking?]
+0025  [enemy killed?]
+0026  [loud thud - balrog?]
+0027 Level Up
+0028  [thump]
+0029 Teleport
+0030  [jump]
+0031 Invulnerable "ting"
+0032  [shot - polar star?]
+0033  [shot - fireball]
+0034  [shot - fireball bounce?]
+0035  [explosion (missiles?]
+0036  [nothing?]
+0037  [click]
+0038  [get item?]
+0039  [*bvng*]
+0040  [water?]
+0041  [water?]
+0042  [beep]
+0043 Computer beep (activate terminals, etc.)
+0044 Blast (blow up door to Shelt)
+0045 Weapon energy bounce
+0046  [*ftt*]
+0047  [?]
+0048  [shot - bubble pop?]
+0049  [shot - spur lv 1]
+0050  [enemy squeak]
+0051  [enemy take damage]
+0052  [large enemy take damage (roar)]
+0053  [enemy squeak-bblblbl]
+0054  [object shot (thud)]
+0055  [enemy squeak]
+0056  [splash]
+0057  [little damage sound]
+0058  [*chlk*]
+0059  [nothing?]
+0060  [spur charge - lower]
+0061  [spur charge - higher]
+0062 Shot - Spur lv 2
+0063 Shot - Spur lv 3
+0064 Shot - Spur max
+0065 Spur fully charged
+0066  [nothing?]
+0067  [nothing?]
+0068  [nothing?]
+0069  [nothing?]
+0070  [Sue hitting you while you're unconscious in Jail1]
+0071  [explosion]
+0072  [explosion]
+0073  [nothing?]
+0074  [nothing?]
+0075  [nothing?]
+0076  [nothing?]
+0077  [nothing?]
+0078  [nothing?]
+0079  [nothing?]
+0080  [nothing?]
+0081  [nothing?]
+0082  [nothing?]
+0083  [nothing?]
+0084  [nothing?]
+0085  [nothing?]
+0086  [nothing?]
+0087  [nothing?]
+0088  [nothing?]
+0089  [nothing?]
+0090  [nothing?]
+0091  [nothing?]
+0092  [nothing?]
+0093  [nothing?]
+0094  [nothing?]
+0095  [nothing?]
+0096  [nothing?]
+0097  [nothing?]
+0098  [nothing?]
+0099  [nothing?]
+
+http://spgardebiter.sp.funpic.de/CaveStory/FAQ/TSC.txt
diff --git a/src/lib/moses.lua b/src/lib/moses.lua
new file mode 100644
index 0000000..8c43af5
--- /dev/null
+++ b/src/lib/moses.lua
@@ -0,0 +1,2250 @@
+--- Utility-belt library for functional programming in Lua ([source](http://github.com/Yonaba/Moses))
+-- @author [Roland Yonaba](http://github.com/Yonaba)
+-- @copyright 2012-2017
+-- @license [MIT](http://www.opensource.org/licenses/mit-license.php)
+-- @release 1.6.1
+-- @module moses
+
+local _MODULEVERSION = '1.6.1'
+
+-- Internalisation
+local next, type, select, pcall  = next, type, select, pcall
+local setmetatable, getmetatable = setmetatable, getmetatable
+local t_insert, t_sort           = table.insert, table.sort
+local t_remove,t_concat          = table.remove, table.concat
+local randomseed, random, huge   = math.randomseed, math.random, math.huge
+local floor, max, min            = math.floor, math.max, math.min
+local rawget                     = rawget
+local unpack                     = table.unpack or unpack
+local pairs,ipairs               = pairs,ipairs
+local clock                      = os.clock
+local _                          = {}
+
+
+-- ======== Private helpers
+
+local function f_max(a,b) return a>b end
+local function f_min(a,b) return a<b end
+local function clamp(var,a,b) return (var<a) and a or (var>b and b or var) end
+local function isTrue(_,value) return value and true end
+local function iNot(value) return not value end
+
+local function count(t)  -- raw count of items in an map-table
+  local i = 0
+    for k,v in pairs(t) do i = i + 1 end
+  return i
+end
+
+local function extract(list,comp,transform,...) -- extracts value from a list
+  local _ans
+  local transform = transform or _.identity
+  for index,value in pairs(list) do
+    if not _ans then _ans = transform(value,...)
+    else
+      local value = transform(value,...)
+      _ans = comp(_ans,value) and _ans or value
+    end
+  end
+  return _ans
+end
+
+local function partgen(t, n, f, pad) -- generates array partitions
+  for i = 0, #t, n do
+    local s = _.slice(t, i+1, i+n)
+    if #s>0 then
+      while (#s < n and pad) do s[#s+1] = pad end
+      f(s)
+    end
+  end
+end
+
+local function partgen2(t, n, f, pad) -- generates sliding array partitions
+  for i = 0, #t, n-1 do
+    local s = _.slice(t, i+1, i+n)
+    if #s>0 and i+1<#t then
+      while (#s < n and pad) do s[#s+1] = pad end
+      f(s)
+    end
+  end
+end
+
+local function permgen(t, n, f) -- taken from PiL: http://www.lua.org/pil/9.3.html
+  if n == 0 then f(t) end
+  for i = 1,n do
+    t[n], t[i] = t[i], t[n]
+    permgen(t, n-1, f)
+    t[n], t[i] = t[i], t[n]
+  end
+end
+
+-- Internal counter for unique ids generation
+local unique_id_counter = -1
+
+--- Table functions
+-- @section Table functions
+
+--- Clears a table. All its values become nil.
+-- @name clear
+-- @param t a table
+-- @return the given table, cleared.
+function _.clear(t)
+  for k in pairs(t) do t[k] = nil end
+  return t
+end
+
+--- Iterates on key-value pairs, calling `f (k, v)` at every step.
+-- <br/><em>Aliased as `forEach`</em>.
+-- @name each
+-- @param t a table
+-- @param f a function, prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @see eachi
+function _.each(t, f, ...)
+  for index,value in pairs(t) do
+    f(index,value,...)
+  end
+end
+
+--- Iterates on integer key-value pairs, calling `f(k, v)` every step.
+-- Only applies to values located at integer keys. The table can be a sparse array.
+-- Iteration will start from the lowest integer key found to the highest one.
+-- <br/><em>Aliased as `forEachi`</em>.
+-- @name eachi
+-- @param t a table
+-- @param f a function, prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @see each
+function _.eachi(t, f, ...)
+  local lkeys = _.sort(_.select(_.keys(t), function(k,v)
+    return _.isInteger(v)
+  end))
+  for k, key in ipairs(lkeys) do
+    f(key, t[key],...)
+  end
+end
+
+--- Collects values at given keys and return them wrapped in an array.
+-- @name at
+-- @param t a table
+-- @param ... A variable number of keys to collect values
+-- @return an array-list of values
+function _.at(t, ...)
+  local values = {}
+  for i, key in ipairs({...}) do
+    if _.has(t, key) then values[#values+1] = t[key] end
+  end
+  return values
+end
+
+--- Counts occurrences of a given value in a table. Uses @{isEqual} to compare values.
+-- @name count
+-- @param t a table
+-- @param[opt] value a value to be searched in the table. If not given, the @{size} of the table will be returned
+-- @return the count of occurrences of the given value
+-- @see countf
+-- @see size
+function _.count(t, value)
+  if _.isNil(value) then return _.size(t) end
+  local count = 0
+  _.each(t, function(k,v)
+    if _.isEqual(v, value) then count = count + 1 end
+  end)
+  return count
+end
+
+--- Counts occurrences validating a predicate. Same as @{count}, but uses an iterator.
+-- Returns the count for values passing the test `f (k, v, ...)`
+-- @name countf
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return the count of values validating the predicate
+-- @see count
+-- @see size
+function _.countf(t, f, ...)
+  return _.count(_.map(t, f, ...), true)
+end
+
+--- Loops `n` times through a table. In case `n` is omitted, it will loop forever.
+-- In case `n` is lower or equal to 0, it returns an empty function.
+-- <br/><em>Aliased as `loop`</em>.
+-- @name cycle
+-- @param t a table
+-- @param n the number of loops
+-- @return an iterator function yielding key-value pairs from the passed-in table.
+function _.cycle(t, n)
+  n = n or 1
+  if n<=0 then return _.noop end
+  local k, fk
+  local i = 0
+  while true do
+    return function()
+      k = k and next(t,k) or next(t)
+      fk = not fk and k or fk
+      if n then
+        i = (k==fk) and i+1 or i
+        if i > n then
+          return
+        end
+      end
+      return k, t[k]
+    end
+  end
+end
+
+--- Maps `f (k, v)` on key-value pairs, collects and returns the results.
+-- <br/><em>Aliased as `collect`</em>.
+-- @name map
+-- @param t a table
+-- @param f  an iterator function, prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return a table of results
+function _.map(t, f, ...)
+  local _t = {}
+  for index,value in pairs(t) do
+    local k, kv, v = index, f(index,value,...)
+    _t[v and kv or k] = v or kv
+  end
+  return _t
+end
+
+--- Reduces a table, left-to-right. Folds the table from the first element to the last element
+-- to a single value, using a given iterator and an initial state.
+-- The iterator takes a state and a value and returns a new state.
+-- <br/><em>Aliased as `inject`, `foldl`</em>.
+-- @name reduce
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (state, value)`
+-- @param[opt] state an initial state of reduction. Defaults to the first value in the table.
+-- @return the final state of reduction
+-- @see reduceRight
+-- @see reduceby
+function _.reduce(t, f, state)
+  for __,value in pairs(t) do
+    if state == nil then state = value
+    else state = f(state,value)
+    end
+  end
+  return state
+end
+
+--- Reduces values in a table passing a given predicate. Folds the table left-to-right, considering
+-- only values validating a given predicate.
+-- @name reduceby
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (state, value)`
+-- @param state an initial state of reduction.
+-- @param pred a predicate function `pred (k, v, ...)` to select values to be considered for reduction
+-- @param[opt] ... optional args to be passed to `pred`
+-- @return the final state of reduction
+-- @see reduce
+function _.reduceby(t, f, state, pred, ...)
+  return _.reduce(_.select(t, pred, ...), f, state)
+end
+
+--- Reduces a table, right-to-left. Folds the table from the last element to the first element
+-- to single value, using a given iterator and an initial state.
+-- The iterator takes a state and a value, and returns a new state.
+-- <br/><em>Aliased as `injectr`, `foldr`</em>.
+-- @name reduceRight
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (state, value)`
+-- @param[opt] state an initial state of reduction. Defaults to the last value in the table.
+-- @return the final state of reduction
+-- @see reduce
+function _.reduceRight(t, f, state)
+  return _.reduce(_.reverse(t),f,state)
+end
+
+--- Reduces a table while saving intermediate states. Folds the table left-to-right
+-- using a given iterator and an initial state. The iterator takes a state and a value,
+-- and returns a new state. The result is an array of intermediate states.
+-- <br/><em>Aliased as `mapr`</em>
+-- @name mapReduce
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (state, value)`
+-- @param[opt] state an initial state of reduction. Defaults to the first value in the table.
+-- @return an array of states
+-- @see mapReduceRight
+function _.mapReduce(t, f, state)
+  local _t = {}
+  for i,value in pairs(t) do
+    _t[i] = not state and value or f(state,value)
+    state = _t[i]
+  end
+  return _t
+end
+
+--- Reduces a table while saving intermediate states. Folds the table right-to-left
+-- using a given iterator and an initial state. The iterator takes a state and a value,
+-- and returns a new state. The result is an array of intermediate states.
+-- <br/><em>Aliased as `maprr`</em>
+-- @name mapReduceRight
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (state, value)`
+-- @param[opt] state an initial state of reduction. Defaults to the last value in the table.
+-- @return an array of states
+-- @see mapReduce
+function _.mapReduceRight(t, f, state)
+  return _.mapReduce(_.reverse(t),f,state)
+end
+
+--- Performs a linear search for a value in a table. It does not work for nested tables.
+-- The given value can be a function prototyped as `f (v, value)` which should return true when
+-- any v in the table equals the value being searched.
+-- <br/><em>Aliased as `any`, `some`, `contains`</em>
+-- @name include
+-- @param t a table
+-- @param value a value to search for
+-- @return a boolean : `true` when found, `false` otherwise
+-- @see detect
+function _.include(t, value)
+  local _iter = _.isFunction(value) and value or _.isEqual
+  for __,v in pairs(t) do
+    if _iter(v,value) then return true end
+  end
+  return false
+end
+
+--- Performs a linear search for a value in a table. Returns the key of the value if found.
+-- The given value can be a function prototyped as `f (v, value)` which should return true when
+-- any v in the table equals the value being searched.
+-- @name detect
+-- @param t a table
+-- @param value a value to search for
+-- @return the key of the value when found or __nil__
+-- @see include
+function _.detect(t, value)
+  local _iter = _.isFunction(value) and value or _.isEqual
+  for key,arg in pairs(t) do
+    if _iter(arg,value) then return key end
+  end
+end
+
+--- Returns all values having specified keys `props`.
+-- @name where
+-- @param t a table
+-- @param props a set of keys
+-- @return an array of values from the passed-in table
+-- @see findWhere
+function _.where(t, props)
+  local r = _.select(t, function(__,v)
+    for key in pairs(props) do
+      if v[key] ~= props[key] then return false end
+    end
+    return true
+  end)
+  return #r > 0 and r or nil
+end
+
+--- Returns the first value having specified keys `props`.
+-- @name findWhere
+-- @param t a table
+-- @param props a set of keys
+-- @return a value from the passed-in table
+-- @see where
+function _.findWhere(t, props)
+  local index = _.detect(t, function(v)
+    for key in pairs(props) do
+      if props[key] ~= v[key] then return false end
+    end
+    return true
+  end)
+  return index and t[index]
+end
+
+--- Selects and returns values passing an iterator test.
+-- <br/><em>Aliased as `filter`</em>.
+-- @name select
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return the selected values
+-- @see reject
+function _.select(t, f, ...)
+  local _t = {}
+  for index,value in pairs(t) do
+    if f(index, value,...) then _t[#_t+1] = value end
+  end
+  return _t
+end
+
+--- Clones a table while dropping values passing an iterator test.
+-- <br/><em>Aliased as `discard`</em>
+-- @name reject
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return the remaining values
+-- @see select
+function _.reject(t, f, ...)
+  local _mapped = _.map(t,f,...)
+  local _t = {}
+  for index,value in pairs (_mapped) do
+    if not value then _t[#_t+1] = t[index] end
+  end
+  return _t
+end
+
+--- Checks if all values in a table are passing an iterator test.
+-- <br/><em>Aliased as `every`</em>
+-- @name all
+-- @param t a table
+-- @param f an iterator function, prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return `true` if all values passes the predicate, `false` otherwise
+function _.all(t, f, ...)
+  return ((#_.select(_.map(t,f,...), isTrue)) == count(t))
+end
+
+--- Invokes a method on each value in a table.
+-- @name invoke
+-- @param t a table
+-- @param method a function, prototyped as `f (v, ...)`
+-- @param[opt] ... Optional args to be passed to `method`
+-- @return the result of the call `f (v, ...)`
+-- @see pluck
+function _.invoke(t, method, ...)
+  local args = {...}
+  return _.map(t, function(__,v)
+    if _.isTable(v) then
+      if _.has(v,method) then
+        if _.isCallable(v[method]) then
+          return v[method](v,unpack(args))
+        else
+          return v[method]
+        end
+      else
+        if _.isCallable(method) then
+          return method(v,unpack(args))
+        end
+      end
+    elseif _.isCallable(method) then
+      return method(v,unpack(args))
+    end
+  end)
+end
+
+--- Extracts values in a table having a given key.
+-- @name pluck
+-- @param t a table
+-- @param key a key, will be used to index in each value: `value[key]`
+-- @return an array of values having the given key
+function _.pluck(t, key)
+  return _.reject(_.map(t,function(__,value)
+      return value[key]
+    end), iNot)
+end
+
+--- Returns the max value in a collection. If an transformation function is passed, it will
+-- be used to evaluate values by which all objects will be sorted.
+-- @name max
+-- @param t a table
+-- @param[opt] transform a transformation function, prototyped as `transform (v, ...)`, defaults to @{identity}
+-- @param[optchain] ... Optional args to be passed to `transform`
+-- @return the max value found
+-- @see min
+function _.max(t, transform, ...)
+  return extract(t, f_max, transform, ...)
+end
+
+--- Returns the min value in a collection. If an transformation function is passed, it will
+-- be used to evaluate values by which all objects will be sorted.
+-- @name min
+-- @param t a table
+-- @param[opt] transform a transformation function, prototyped as `transform (v, ...)`, defaults to @{identity}
+-- @param[optchain] ... Optional args to be passed to `transform`
+-- @return the min value found
+-- @see max
+function _.min(t, transform, ...)
+  return extract(t, f_min, transform, ...)
+end
+
+--- Returns a shuffled copy of a given collection. If a seed is provided, it will
+-- be used to init the pseudo random number generator (using `math.randomseed`).
+-- @name shuffle
+-- @param t a table
+-- @param[opt] seed a seed
+-- @return a shuffled copy of the given table
+function _.shuffle(t, seed)
+  if seed then randomseed(seed) end
+  local _shuffled = {}
+  _.each(t,function(index,value)
+     local randPos = floor(random()*index)+1
+    _shuffled[index] = _shuffled[randPos]
+    _shuffled[randPos] = value
+  end)
+  return _shuffled
+end
+
+--- Checks if two tables are the same. It compares if both tables features the same values,
+-- but not necessarily at the same keys.
+-- @name same
+-- @param a a table
+-- @param b another table
+-- @return `true` or `false`
+function _.same(a, b)
+  return _.all(a, function (i,v) return _.include(b,v) end)
+     and _.all(b, function (i,v) return _.include(a,v) end)
+end
+
+--- Sorts a table, in-place. If a comparison function is given, it will be used to sort values.
+-- @name sort
+-- @param t a table
+-- @param[opt] comp a comparison function prototyped as `comp (a, b)`, defaults to <tt><</tt> operator.
+-- @return the initial table, sorted.
+-- @see sortBy
+function _.sort(t, comp)
+  t_sort(t, comp)
+  return t
+end
+
+--- Sorts a table in-place using a transform. Values are ranked in a custom order of the results of
+-- running `transform (v)` on all values. `transform` may also be a string name property  sort by.
+-- `comp` is a comparison function.
+-- @name sortBy
+-- @param t a table
+-- @param[opt] transform a `transform` function to sort elements prototyped as `transform (v)`. Defaults to @{identity}
+-- @param[optchain] comp a comparision function, defaults to the `<` operator
+-- @return a new array of sorted values
+-- @see sort
+function _.sortBy(t, transform, comp)
+  local f = transform or _.identity
+  if _.isString(transform) then
+    f = function(t) return t[transform] end
+  end
+  comp = comp or f_min
+  local _t = {}
+  _.each(t, function(__,v)
+    _t[#_t+1] = {value = v, transform = f(v)}
+  end)
+  t_sort(_t, function(a,b) return comp(a.transform, b.transform) end)
+  return _.pluck(_t, 'value')
+end
+
+--- Splits a table into subsets groups.
+-- @name groupBy
+-- @param t a table
+-- @param iter an iterator function, prototyped as `iter (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `iter`
+-- @return a table of subsets groups
+function _.groupBy(t, iter, ...)
+  local vararg = {...}
+  local _t = {}
+  _.each(t, function(i,v)
+      local _key = iter(i,v, unpack(vararg))
+      if _t[_key] then _t[_key][#_t[_key]+1] = v
+      else _t[_key] = {v}
+      end
+    end)
+  return _t
+end
+
+--- Groups values in a collection and counts them.
+-- @name countBy
+-- @param t a table
+-- @param iter an iterator function, prototyped as `iter (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `iter`
+-- @return a table of subsets groups names paired with their count
+function _.countBy(t, iter, ...)
+  local vararg = {...}
+  local stats = {}
+  _.each(t,function(i,v)
+      local key = iter(i,v,unpack(vararg))
+      stats[key] = (stats[key] or 0) +1
+    end)
+  return stats
+end
+
+--- Counts the number of values in a collection. If being passed more than one argument
+-- it will return the count of all passed-in arguments.
+-- @name size
+-- @param[opt] ... Optional variable number of arguments
+-- @return a count
+-- @see count
+-- @see countf
+function _.size(...)
+  local args = {...}
+  local arg1 = args[1]
+  if _.isTable(arg1) then
+    return count(args[1])
+  else
+    return count(args)
+  end
+end
+
+--- Checks if all the keys of `other` table exists in table `t`. It does not
+-- compares values. The test is not commutative, i.e table `t` may contains keys
+-- not existing in `other`.
+-- @name containsKeys
+-- @param t a table
+-- @param other another table
+-- @return `true` or `false`
+-- @see sameKeys
+function _.containsKeys(t, other)
+  for key in pairs(other) do
+    if not t[key] then return false end
+  end
+  return true
+end
+
+--- Checks if both given tables have the same keys. It does not compares values.
+-- @name sameKeys
+-- @param tA a table
+-- @param tB another table
+-- @return `true` or `false`
+-- @see containsKeys
+function _.sameKeys(tA, tB)
+  for key in pairs(tA) do
+    if not tB[key] then return false end
+  end
+  for key in pairs(tB) do
+    if not tA[key] then return false end
+  end
+  return true
+end
+
+--- Array functions
+-- @section Array functions
+
+--- Samples `n` random values from an array. If `n` is not specified, returns a single element.
+-- It uses internally @{shuffle} to shuffle the array before sampling values. If `seed` is passed,
+-- it will be used for shuffling.
+-- @name sample
+-- @param array an array
+-- @param[opt] n a number of elements to be sampled. Defaults to 1.
+-- @param[optchain] seed an optional seed for shuffling
+-- @return an array of selected values or a single value when `n` == 1
+-- @see sampleProb
+function _.sample(array, n, seed)
+  n = n or 1
+  if n < 1 then return end
+  if n == 1 then
+    if seed then randomseed(seed) end
+    return array[random(1, #array)]
+  end
+  return _.slice(_.shuffle(array, seed), 1, n)
+end
+
+--- Return elements from a sequence with a given probability. It considers each value independently.
+-- Providing a seed will result in deterministic sampling. Given the same seed it will return the same sample
+-- every time.
+-- @name sampleProb
+-- @param array an array
+-- @param prob a probability for each element in array to be selected
+-- @param[opt] seed an optional seed for deterministic sampling
+-- @return an array of selected values
+-- @see sample
+function _.sampleProb(array, prob, seed)
+  if seed then randomseed(seed) end
+  return _.select(array, function(_,v) return random() < prob end)
+end
+
+--- Converts a list of arguments to an array.
+-- @name toArray
+-- @param ... a list of arguments
+-- @return an array of all passed-in args
+function _.toArray(...) return {...} end
+
+--- Looks for the first occurrence of a given value in an array. Returns the value index if found.
+-- Uses @{isEqual} to compare values.
+-- @name find
+-- @param array an array of values
+-- @param value a value to lookup for
+-- @param[opt] from the index from where the search will start. Defaults to 1.
+-- @return the index of the value if found in the array, `nil` otherwise.
+function _.find(array, value, from)
+  for i = from or 1, #array do
+    if _.isEqual(array[i], value) then return i end
+  end
+end
+
+--- Returns an array where values are in reverse order. The passed-in array should not be sparse.
+-- @name reverse
+-- @param array an array
+-- @return a reversed array
+function _.reverse(array)
+  local _array = {}
+  for i = #array,1,-1 do
+    _array[#_array+1] = array[i]
+  end
+  return _array
+end
+
+--- Replaces elements in a given array with a given value. In case `i` and `j` are given
+-- it will only replaces values at indexes between `[i,j]`. In case `j` is greather than the array
+-- size, it will append new values, increasing the array.
+-- @name fill
+-- @param array an array
+-- @param value a value
+-- @param[opt] i the index from which to start replacing values. Defaults to 1.
+-- @param[optchain] j the index where to stop replacing values. Defaults to the array size.
+-- @return the original array with values changed
+function _.fill(array, value, i, j)
+  j = j or _.size(array)
+  for i = i or 1, j do array[i] = value end
+  return array
+end
+
+--- Collects values from a given array. The passed-in array should not be sparse.
+-- This function collects values as long as they satisfy a given predicate and returns on the first falsy test.
+-- <br/><em>Aliased as `takeWhile`</em>
+-- @name selectWhile
+-- @param array an array
+-- @param f an iterator function prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return a new table containing all values collected
+-- @see dropWhile
+function _.selectWhile(array, f, ...)
+  local t = {}
+  for i,v in ipairs(array) do
+    if f(i,v,...) then t[i] = v else break end
+  end
+  return t
+end
+
+--- Collects values from a given array. The passed-in array should not be sparse.
+-- This function collects values as long as they do not satisfy a given predicate and returns on the first truthy test.
+-- <br/><em>Aliased as `rejectWhile`</em>
+-- @name dropWhile
+-- @param array an array
+-- @param f an iterator function prototyped as `f (k,v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return a new table containing all values collected
+-- @selectWhile
+function _.dropWhile(array, f, ...)
+  local _i
+  for i,v in ipairs(array) do
+    if not f(i,v,...) then
+      _i = i
+      break
+    end
+  end
+  if _.isNil(_i) then return {} end
+  return _.rest(array,_i)
+end
+
+--- Returns the index at which a value should be inserted. This index is evaluated so
+-- that it maintains the sort. If a comparison function is passed, it will be used to sort
+-- values.
+-- @name sortedIndex
+-- @param array an array
+-- @param the value to be inserted
+-- @param[opt] comp an comparison function prototyped as `f (a, b)`, defaults to <tt><</tt> operator.
+-- @param[optchain] sort whether or not the passed-in array should be sorted
+-- @return number the index at which the passed-in value should be inserted
+function _.sortedIndex(array, value, comp, sort)
+  local _comp = comp or f_min
+  if sort then _.sort(array,_comp) end
+  for i = 1,#array do
+    if not _comp(array[i],value) then return i end
+  end
+  return #array+1
+end
+
+--- Returns the index of the first occurence of value in an array.
+-- @name indexOf
+-- @param array an array
+-- @param value the value to search for
+-- @return the index of the passed-in value
+-- @see lastIndexOf
+function _.indexOf(array, value)
+  for k = 1,#array do
+    if array[k] == value then return k end
+  end
+end
+
+--- Returns the index of the last occurrence of value in an array.
+-- @name lastIndexOf
+-- @param array an array
+-- @param value the value to search for
+-- @return the index of the last occurrence of the passed-in value or __nil__
+-- @see indexOf
+function _.lastIndexOf(array, value)
+  local key = _.indexOf(_.reverse(array),value)
+  if key then return #array-key+1 end
+end
+
+--- Returns the first index at which a predicate returns true.
+-- @name findIndex
+-- @param array an array
+-- @param predicate a predicate function prototyped as `predicate (k, v, ...)`
+-- @param[opt] ... optional arguments to `pred`
+-- @return the index found or __nil__
+-- @see findLastIndex
+function _.findIndex(array, predicate, ...)
+  for k = 1, #array do
+    if predicate(k,array[k],...) then return k end
+  end
+end
+
+--- Returns the last index at which a predicate returns true.
+-- @name findLastIndex
+-- @param array an array
+-- @param predicate a predicate function prototyped as `predicate (k, v, ...)`
+-- @param[opt] ... optional arguments to `pred`
+-- @return the index found or __nil__
+-- @see findIndex
+function _.findLastIndex(array, predicate, ...)
+  local key = _.findIndex(_.reverse(array),predicate,...)
+  if key then return #array-key+1 end
+end
+
+--- Adds all passed-in values at the top of an array. The last elements will bubble to the
+-- top of the given array.
+-- @name addTop
+-- @param array an array
+-- @param ... a variable number of arguments
+-- @return the passed-in array with new values added
+-- @see push
+function _.addTop(array, ...)
+  _.each({...},function(i,v) t_insert(array,1,v) end)
+  return array
+end
+
+--- Pushes all passed-in values at the end of an array.
+-- @name push
+-- @param array an array
+-- @param ... a variable number of arguments
+-- @return the passed-in array with new added values
+-- @see addTop
+function _.push(array, ...)
+  _.each({...}, function(i,v) array[#array+1] = v end)
+  return array
+end
+
+--- Removes and returns the values at the top of a given array.
+-- <br/><em>Aliased as `shift`</em>
+-- @name pop
+-- @param array an array
+-- @param[opt] n the number of values to be popped. Defaults to 1.
+-- @return the popped values
+-- @see unshift
+function _.pop(array, n)
+  n = min(n or 1, #array)
+  local ret = {}
+  for i = 1, n do
+    local retValue = array[1]
+    ret[#ret + 1] = retValue
+    t_remove(array,1)
+  end
+  return unpack(ret)
+end
+
+--- Removes and returns the values at the end of a given array.
+-- @name unshift
+-- @param array an array
+-- @param[opt] n the number of values to be unshifted. Defaults to 1.
+-- @return the values
+-- @see pop
+function _.unshift(array, n)
+  n = min(n or 1, #array)
+  local ret = {}
+  for i = 1, n do
+    local retValue = array[#array]
+    ret[#ret + 1] = retValue
+    t_remove(array)
+  end
+  return unpack(ret)
+end
+
+--- Removes all provided values in a given array.
+-- <br/><em>Aliased as `remove`</em>
+-- @name pull
+-- @param array an array
+-- @param ... a variable number of values to be removed from the array
+-- @return the passed-in array with values removed
+function _.pull(array, ...)
+  for __, rmValue in ipairs({...}) do
+    for i = #array, 1, -1 do
+      if _.isEqual(array[i], rmValue) then
+        t_remove(array, i)
+      end
+    end
+  end
+  return array
+end
+
+--- Removes values at index within the range `[start, finish]`.
+-- <br/><em>Aliased as `rmRange`, `chop`</em>
+-- @name removeRange
+-- @param array an array
+-- @param[opt] start the lower bound index, defaults to the first index in the array.
+-- @param[optchain] finish the upper bound index, defaults to the array length.
+-- @return the passed-in array with values removed
+function _.removeRange(array, start, finish)
+  local array = _.clone(array)
+  local i,n = (next(array)),#array
+  if n < 1 then return array end
+
+  start = clamp(start or i,i,n)
+  finish = clamp(finish or n,i,n)
+
+  if finish < start then return array end
+
+  local count = finish - start + 1
+  local i = start
+  while count > 0 do
+    t_remove(array,i)
+    count = count - 1
+  end
+  return array
+end
+
+--- Chunks together consecutive values. Values are chunked on the basis of the return
+-- value of a provided predicate `f (k, v, ...)`. Consecutive elements which return
+-- the same value are chunked together. Leaves the first argument untouched if it is not an array.
+-- @name chunk
+-- @param array an array
+-- @param f an iterator function prototyped as `f (k, v, ...)`
+-- @param[opt] ... Optional args to be passed to `f`
+-- @return a table of chunks (arrays)
+-- @see zip
+function _.chunk(array, f, ...)
+  if not _.isArray(array) then return array end
+  local ch, ck, prev = {}, 0
+  local mask = _.map(array, f,...)
+  _.each(mask, function(k,v)
+    prev = (prev==nil) and v or prev
+    ck = ((v~=prev) and (ck+1) or ck)
+    if not ch[ck] then
+      ch[ck] = {array[k]}
+    else
+      ch[ck][#ch[ck]+1] = array[k]
+    end
+    prev = v
+  end)
+  return ch
+end
+
+--- Slices values indexed within `[start, finish]` range.
+-- <br/><em>Aliased as `_.sub`</em>
+-- @name slice
+-- @param array an array
+-- @param[opt] start the lower bound index, defaults to the first index in the array.
+-- @param[optchain] finish the upper bound index, defaults to the array length.
+-- @return a new array of sliced values
+function _.slice(array, start, finish)
+  return _.select(array, function(index)
+      return (index >= (start or next(array)) and index <= (finish or #array))
+    end)
+end
+
+--- Returns the first N values in an array.
+-- <br/><em>Aliased as `head`, `take`</em>
+-- @name first
+-- @param array an array
+-- @param[opt] n the number of values to be collected, defaults to 1.
+-- @return a new array
+-- @see initial
+-- @see last
+-- @see rest
+function _.first(array, n)
+  local n = n or 1
+  return _.slice(array,1, min(n,#array))
+end
+
+--- Returns all values in an array excluding the last N values.
+-- @name initial
+-- @param array an array
+-- @param[opt] n the number of values to be left, defaults to the array length.
+-- @return a new array
+-- @see first
+-- @see last
+-- @see rest
+function _.initial(array, n)
+  if n and n < 0 then return end
+  return _.slice(array,1, n and #array-(min(n,#array)) or #array-1)
+end
+
+--- Returns the last N values in an array.
+-- @name last
+-- @param array an array
+-- @param[opt] n the number of values to be collected, defaults to the array length.
+-- @return a new array
+-- @see first
+-- @see initial
+-- @see rest
+function _.last(array, n)
+  if n and n <= 0 then return end
+  return _.slice(array,n and #array-min(n-1,#array-1) or 2,#array)
+end
+
+--- Removes all values before index.
+-- <br/><em>Aliased as `tail`</em>
+-- @name rest
+-- @param array an array
+-- @param[opt] index an index, defaults to 1
+-- @return a new array
+-- @see first
+-- @see initial
+-- @see last
+function _.rest(array,index)
+  if index and index > #array then return {} end
+  return _.slice(array,index and max(1,min(index,#array)) or 1,#array)
+end
+
+--- Returns the value at a given index.
+-- @name nth
+-- @param array an array
+-- @param index an index
+-- @return the value at the given index
+function _.nth(array, index)
+  return array[index]
+end
+
+--- Removes all falsy (false and nil) values.
+-- @name compact
+-- @param array an array
+-- @return a new array
+function _.compact(array)
+  return _.reject(array, function (_,value)
+    return not value
+  end)
+end
+
+--- Flattens a nested array. Passing `shallow` will only flatten at the first level.
+-- @name flatten
+-- @param array an array
+-- @param[opt] shallow specifies the flattening depth
+-- @return a new array, flattened
+function _.flatten(array, shallow)
+  local shallow = shallow or false
+  local new_flattened
+  local _flat = {}
+  for key,value in pairs(array) do
+    if _.isTable(value) then
+      new_flattened = shallow and value or _.flatten (value)
+      _.each(new_flattened, function(_,item) _flat[#_flat+1] = item end)
+    else _flat[#_flat+1] = value
+    end
+  end
+  return _flat
+end
+
+--- Returns values from an array not present in all passed-in args.
+-- <br/><em>Aliased as `without` and `diff`</em>
+-- @name difference
+-- @param array an array
+-- @param another array
+-- @return a new array
+-- @see union
+-- @see intersection
+-- @see symmetricDifference
+function _.difference(array, array2)
+  if not array2 then return _.clone(array) end
+  return _.select(array,function(i,value)
+      return not _.include(array2,value)
+    end)
+end
+
+--- Returns the duplicate-free union of all passed in arrays.
+-- @name union
+-- @param ... a variable number of arrays arguments
+-- @return a new array
+-- @see difference
+-- @see intersection
+-- @see symmetricDifference
+function _.union(...)
+  return _.uniq(_.flatten({...}))
+end
+
+--- Returns the  intersection of all passed-in arrays.
+-- Each value in the result is present in each of the passed-in arrays.
+-- @name intersection
+-- @param array an array
+-- @param ... a variable number of array arguments
+-- @return a new array
+-- @see difference
+-- @see union
+-- @see symmetricDifference
+function _.intersection(array, ...)
+  local arg = {...}
+  local _intersect = {}
+  for i,value in ipairs(array) do
+    if _.all(arg,function(i,v)
+          return _.include(v,value)
+        end) then
+      t_insert(_intersect,value)
+    end
+  end
+  return _intersect
+end
+
+--- Performs a symmetric difference. Returns values from `array` not present in `array2` and also values
+-- from `array2` not present in `array`.
+-- <br/><em>Aliased as `symdiff`</em>
+-- @name symmetricDifference
+-- @param array an array
+-- @param array2 another array
+-- @return a new array
+-- @see difference
+-- @see union
+-- @see intersection
+function _.symmetricDifference(array, array2)
+  return _.difference(
+    _.union(array, array2),
+    _.intersection(array,array2)
+  )
+end
+
+--- Produces a duplicate-free version of a given array.
+-- <br/><em>Aliased as `uniq`</em>
+-- @name unique
+-- @param array an array
+-- @return a new array, duplicate-free
+-- @see isunique
+function _.unique(array)
+  local ret = {}
+  for i = 1, #array do
+    if not _.find(ret, array[i]) then
+      ret[#ret+1] = array[i]
+    end
+  end
+  return ret
+end
+
+--- Checks if a given array contains distinct values. Such an array is made of distinct elements,
+-- which only occur once in this array.
+-- <br/><em>Aliased as `isuniq`</em>
+-- @name isunique
+-- @param array an array
+-- @return `true` if the given array is unique, `false` otherwise.
+-- @see unique
+function _.isunique(array)
+  return _.isEqual(array, _.unique(array))
+end
+
+--- Merges values of each of the passed-in arrays in subsets.
+-- Only values indexed with the same key in the given arrays are merged in the same subset.
+-- <br/><em>Aliased as `transpose`</em>
+-- @name zip
+-- @param ... a variable number of array arguments
+-- @return a new array
+function _.zip(...)
+  local arg = {...}
+  local _len = _.max(_.map(arg,function(i,v)
+      return #v
+    end))
+  local _ans = {}
+  for i = 1,_len do
+    _ans[i] = _.pluck(arg,i)
+  end
+  return _ans
+end
+
+--- Clones `array` and appends `other` values.
+-- @name append
+-- @param array an array
+-- @param other an array
+-- @return a new array
+function _.append(array, other)
+  local t = {}
+  for i,v in ipairs(array) do t[i] = v end
+  for i,v in ipairs(other) do t[#t+1] = v end
+  return t
+end
+
+--- Interleaves arrays. It returns a single array made of values from all
+-- passed in arrays in their given order, interleaved.
+-- @name interleave
+-- @param ... a variable list of arrays
+-- @return a new array
+-- @see interpose
+function _.interleave(...) return _.flatten(_.zip(...)) end
+
+--- Interposes value in-between consecutive pair of values in `array`.
+-- @name interpose
+-- @param value a value
+-- @param array an array
+-- @return a new array
+-- @see interleave
+function _.interpose(value, array)
+  return _.flatten(_.zip(array, _.rep(value, #array-1)))
+end
+
+--- Produces a flexible list of numbers. If one positive value is passed, will count from 0 to that value,
+-- with a default step of 1. If two values are passed, will count from the first one to the second one, with the
+-- same default step of 1. A third value passed will be considered a step value.
+-- @name range
+-- @param[opt] from the initial value of the range
+-- @param[optchain] to the final value of the range
+-- @param[optchain] step the step of count
+-- @return a new array of numbers
+function _.range(...)
+  local arg = {...}
+  local _start,_stop,_step
+  if #arg==0 then return {}
+  elseif #arg==1 then _stop,_start,_step = arg[1],0,1
+  elseif #arg==2 then _start,_stop,_step = arg[1],arg[2],1
+  elseif #arg == 3 then _start,_stop,_step = arg[1],arg[2],arg[3]
+  end
+  if (_step and _step==0) then return {} end
+  local _ranged = {}
+  local _steps = max(floor((_stop-_start)/_step),0)
+  for i=1,_steps do _ranged[#_ranged+1] = _start+_step*i end
+  if #_ranged>0 then t_insert(_ranged,1,_start) end
+  return _ranged
+end
+
+--- Creates an array list of `n` values, repeated.
+-- @name rep
+-- @param value a value to be repeated
+-- @param n the number of repetitions of value.
+-- @return a new array of `n` values
+function _.rep(value, n)
+  local ret = {}
+  for i = 1, n do ret[#ret+1] = value end
+  return ret
+end
+
+--- Iterator returning partitions of an array. It returns arrays of length `n`
+-- made of values from the given array. If the last partition has lower elements than `n` and
+-- `pad` is supplied, it will be adjusted to `n` of elements with `pad` value.
+-- @name partition
+-- @param array an array
+-- @param[opt] n the size of partitions. Should be greater than 0. Defaults to 1.
+-- @param[optchain] pad a value to adjust the last subsequence to the `n` elements
+-- @return an iterator function
+function _.partition(array, n, pad)
+  if n<=0 then return end
+  return coroutine.wrap(function()
+    partgen(array, n or 1, coroutine.yield, pad)
+  end)
+end
+
+--- Iterator returning sliding partitions of an array. It returns overlapping subsequences
+-- of length `n`. If the last subsequence has lower elements than `n` and `pad` is
+-- supplied, it will be adjusted to `n` elements with `pad` value.
+-- @name sliding.
+-- @param array an array
+-- @param[opt] n the size of partitions. Should be greater than 1. Defaults to 2.
+-- @param[optchain] pad a value to adjust the last subsequence to the `n` elements
+-- @return an iterator function
+function _.sliding(array, n, pad)
+  if n<=1 then return end
+  return coroutine.wrap(function()
+    partgen2(array, n or 2, coroutine.yield, pad)
+  end)
+end
+
+--- Iterator returning the permutations of an array. It returns arrays made of all values
+-- from the passed-in array, with values permuted.
+-- @name permutation
+-- @param array an array
+-- @return an iterator function
+function _.permutation(array)
+  return coroutine.wrap(function()
+    permgen(array, #array, coroutine.yield)
+  end)
+end
+
+--- Swaps keys with values. Produces a new array where previous keys are now values,
+-- while previous values are now keys.
+-- <br/><em>Aliased as `mirror`</em>
+-- @name invert
+-- @param array a given array
+-- @return a new array
+function _.invert(array)
+  local _ret = {}
+  _.each(array,function(i,v) _ret[v] = i end)
+  return _ret
+end
+
+--- Concatenates values in a given array. Handles booleans as well. If `sep` string is
+-- passed, it will be used as a separator. Passing `i` and `j` will result in concatenating
+-- only values within `[i, j]` range.
+-- <br/><em>Aliased as `join`</em>
+-- @name concat
+-- @param array a given array
+-- @param[opt] sep a separator string, defaults to the empty string `''`.
+-- @param[optchain] i the starting index, defaults to 1.
+-- @param[optchain] j the final index, defaults to the array length.
+-- @return a string
+function _.concat(array, sep, i, j)
+  local _array = _.map(array,function(i,v)
+    return tostring(v)
+  end)
+  return t_concat(_array,sep,i or 1,j or #array)
+
+end
+
+--- Utility functions
+-- @section Utility functions
+
+--- The no-operation function.
+-- @name noop
+-- @return nothing
+function _.noop() return end
+
+--- Returns the passed-in value. This function is used internally
+-- as a default iterator.
+-- @name identity
+-- @param value a value
+-- @return the passed-in value
+function _.identity(value) return value end
+
+--- Creates a constant function which returns the same output on every call.
+-- @name constant
+-- @param value a constant value
+-- @return a constant function
+function _.constant(value) return function() return value end end
+
+--- Memoizes a given function by caching the computed result.
+-- Useful for speeding-up slow-running functions. If a `hash` function is passed,
+-- it will be used to compute hash keys for a set of input values for caching.
+-- <br/><em>Aliased as `cache`</em>
+-- @name memoize
+-- @param f a function
+-- @param[opt] hash a hash function, defaults to @{identity}
+-- @return a new function
+function _.memoize(f, hash)
+  local _cache = setmetatable({},{__mode = 'kv'})
+  local _hasher = hash or _.identity
+  return function (...)
+      local _hashKey = _hasher(...)
+      local _result = _cache[_hashKey]
+      if not _result then _cache[_hashKey] = f(...) end
+      return _cache[_hashKey]
+    end
+end
+
+--- Returns a version of `f` that runs only once. Successive calls to `f`
+-- will keep yielding the same output, no matter what the passed-in arguments are.
+-- It can be used to initialize variables.
+-- @name once
+-- @param f a function
+-- @return a new function
+-- @see before
+-- @see after
+function _.once(f)
+  local _internal = 0
+  local _args = {}
+  return function(...)
+    _internal = _internal+1
+    if _internal <= 1 then _args = {...} end
+    return f(unpack(_args))
+  end
+end
+
+--- Returns a version of `f` that will run no more than `count` times. Next calls will
+-- keep yielding the results of the count-th call.
+-- @name before
+-- @param f a function
+-- @param count a count
+-- @return a new function
+-- @see once
+-- @see after
+function _.before(f, count)
+  local _internal = 0
+  local _args = {}
+  return function(...)
+    _internal = _internal+1
+    if _internal <= count then _args = {...} end
+    return f(unpack(_args))
+  end
+end
+
+--- Returns a version of `f` that runs on the `count-th` call.
+-- Useful when dealing with asynchronous tasks.
+-- @name after
+-- @param f a function
+-- @param count the number of calls before `f` will start running.
+-- @return a new function
+-- @see once
+-- @see before
+function _.after(f, count)
+  local _limit,_internal = count, 0
+  return function(...)
+    _internal = _internal+1
+    if _internal >= _limit then return f(...) end
+  end
+end
+
+--- Composes functions. Each passed-in function consumes the return value of the function that follows.
+-- In math terms, composing the functions `f`, `g`, and `h` produces the function `f(g(h(...)))`.
+-- @name compose
+-- @param ... a variable number of functions
+-- @return a new function
+-- @see pipe
+function _.compose(...)
+  -- See: https://github.com/Yonaba/Moses/pull/15#issuecomment-139038895
+  local f = _.reverse {...}
+  return function (...)
+    local first, _temp = true
+    for i, func in ipairs(f) do
+      if first then
+        first = false
+        _temp = func(...)
+      else
+        _temp = func(_temp)
+      end
+    end
+    return _temp
+  end
+end
+
+--- Pipes a value through a series of functions. In math terms,
+-- given some functions `f`, `g`, and `h` in that order, it returns `f(g(h(value)))`.
+-- @name pipe
+-- @param value a value
+-- @param ... a variable number of functions
+-- @return the result of the composition of function calls.
+-- @see compose
+function _.pipe(value, ...)
+  return _.compose(...)(value)
+end
+
+--- Returns the logical complement of a given function. For a given input, the returned
+-- function will output `false` if the original function would have returned `true`,
+-- and vice-versa.
+-- @name complement
+-- @param f a function
+-- @return  the logical complement of the given function `f`.
+function _.complement(f)
+  return function(...) return not f(...) end
+end
+
+--- Calls a sequence of passed-in functions with the same argument.
+-- Returns a sequence of results.
+-- <br/><em>Aliased as `juxt`</em>
+-- @name juxtapose
+-- @param value a value
+-- @param ... a variable number of functions
+-- @return a list of results
+function _.juxtapose(value, ...)
+  local res = {}
+  _.each({...}, function(_,f) res[#res+1] = f(value) end)
+  return unpack(res)
+end
+
+--- Wraps `f` inside of the `wrapper` function. It passes `f` as the first argument to `wrapper`.
+-- This allows the wrapper to execute code before and after `f` runs,
+-- adjust the arguments, and execute it conditionally.
+-- @name wrap
+-- @param f a function to be wrapped, prototyped as `f (...)`
+-- @param wrapper a wrapper function, prototyped as `wrapper (f, ...)`
+-- @return the results
+function _.wrap(f, wrapper)
+  return function (...) return  wrapper(f,...) end
+end
+
+--- Runs `iter` function `n` times. Collects the results of each run and returns them in an array.
+-- @name times
+-- @param n the number of times `iter` should be called
+-- @param  iter an iterator function, prototyped as `iter (i, ...)`
+-- @param ... args to be passed to `iter` function
+-- @return table an array of results
+function _.times(n, iter, ...)
+  local results = {}
+  for i = 1,n do
+    results[i] = iter(i,...)
+  end
+  return results
+end
+
+--- Binds `v` to be the first argument to `f`. Calling `f (...)` will result to `f (v, ...)`.
+-- @name bind
+-- @param f a function
+-- @param v a value
+-- @return a function
+-- @see bind2
+-- @see bindn
+-- @see bindAll
+function _.bind(f, v)
+  return function (...)
+      return f(v,...)
+    end
+end
+
+--- Binds `v` to be the second argument to `f`. Calling `f (a, ...)` will result to `f (a, v, ...)`.
+-- @name bind2
+-- @param f a function
+-- @param v a value
+-- @return a function
+-- @see bind
+-- @see bindn
+-- @see bindAll
+function _.bind2(f, v)
+  return function (t, ...)
+    return f(t, v, ...)
+  end
+end
+
+--- Binds `...` to be the N-first arguments to function `f`.
+-- Calling `f (a1, a2, ..., aN)` will result to `f (..., a1, a2, ...,aN)`.
+-- @name bindn
+-- @param f a function
+-- @param ... a variable number of arguments
+-- @return a function
+-- @see bind
+-- @see bind2
+-- @see bindAll
+function _.bindn(f, ...)
+  local iArg = {...}
+  return function (...)
+      return f(unpack(_.append(iArg,{...})))
+    end
+end
+
+--- Binds methods to object. As such, whenever any of these methods is invoked, it
+-- always receives the object as its first argument.
+-- @name bindAll
+-- @param obj an abject
+-- @param ... a variable number of method names
+-- @return the passed-in object with all methods bound to the object itself.
+-- @see bind
+-- @see bind2
+-- @see bindn
+function _.bindAll(obj, ...)
+  local methodNames = {...}
+  for __, methodName in ipairs(methodNames) do
+    local method = obj[methodName]
+    if method then obj[methodName] = _.bind(method, obj) end
+  end
+  return obj
+end
+
+--- Generates an unique ID for the current session. If given a string `template`, it
+-- will use this template for output formatting. Otherwise, if `template` is a function, it
+-- will evaluate `template (id, ...)`.
+-- <br/><em>Aliased as `uid`</em>.
+-- @name uniqueId
+-- @param[opt] template either a string or a function template to format the ID
+-- @param[optchain] ... a variable number of arguments to be passed to `template`, in case it is a function.
+-- @return value an ID
+function _.uniqueId(template, ...)
+  unique_id_counter = unique_id_counter + 1
+  if template then
+    if _.isString(template) then
+      return template:format(unique_id_counter)
+    elseif _.isFunction(template) then
+      return template(unique_id_counter,...)
+    end
+  end
+  return unique_id_counter
+end
+
+--- Produces an iterator which repeatedly apply a function `f` onto an input.
+-- Yields x, then f(x), then f(f(x)), continuously.
+-- @name iterator
+-- @param f a function
+-- @param x an initial input to `f`
+-- @return an iterator fnction
+-- <br/><em>Aliased as `iter`</em>.
+function _.iterator(f, x)
+  return function()
+    x = f(x)
+    return x
+  end
+end
+
+--- Iterates an iterator and returns its values in an array.
+-- @name array
+-- @param ... an iterator (a function, a table and a value)
+-- @return an array of results
+function _.array(...)
+  local r = {}
+  for v in ... do r[#r+1] = v end
+  return r
+end
+
+--- Creates a function of `f` with arguments flipped in reverse order.
+-- @name flip
+-- @param f a function
+-- @return a function
+function _.flip(f)
+  return function(...)
+    return f(unpack(_.reverse({...})))
+  end
+end
+
+--- Creates a function that runs transforms on all arguments it receives.
+-- @name over
+-- @param ... a set of functions which will receive all arguments to the returned function
+-- @return a function
+-- @see overEvery
+-- @see overSome
+-- @see overArgs
+function _.over(...)
+  local transforms = {...}
+  return function(...)
+    local r = {}
+    for __,transform in ipairs(transforms) do
+      r[#r+1] = transform(...)
+    end
+    return r
+  end
+end
+
+--- Creates a validation function. The returned function checks if *all* of the given predicates return
+-- truthy when invoked with the arguments it receives.
+-- @name overEvery
+-- @param ... a list of predicate functions
+-- @return a new function
+-- @see over
+-- @see overSome
+-- @see overArgs
+function _.overEvery(...)
+  local f = _.over(...)
+  return function(...)
+    return _.reduce(f(...),function(state,v) return state and v end)
+  end
+end
+
+--- Creates a validation function. The return function checks if *any* of a given predicates return
+-- truthy when invoked with the arguments it receives.
+-- @name overSome
+-- @param ... a list of predicate functions
+-- @return a new function
+-- @see over
+-- @see overEvery
+-- @see overArgs
+function _.overSome(...)
+  local f = _.over(...)
+  return function(...)
+    return _.reduce(f(...),function(state,v) return state or v end)
+  end
+end
+
+--- Creates a function that invokes `f` with its arguments transformed. 1rst arguments will be passed to
+-- the 1rst transform, 2nd arg to the 2nd transform, etc. Remaining arguments will not be transformed.
+-- @name overArgs
+-- @param f a function
+-- @param ... a list of transforms funcs prototyped as `f (v)`
+-- @return the result of running `f` with its transformed arguments
+-- @see over
+-- @see overEvery
+-- @see overSome
+function _.overArgs(f,...)
+  local _argf = {...}
+  return function(...)
+    local _args = {...}
+    for i = 1,#_argf do
+      local f = _argf[i]
+      if _args[i] then _args[i] = f(_args[i]) end
+    end
+    return f(unpack(_args))
+  end
+end
+
+--- Partially apply a function by filling in any number of its arguments.
+-- One may pass a string `'_'` as a placeholder in the list of arguments to specify an argument
+-- that should not be pre-filled, but left open to be supplied at call-time.
+-- @name partial
+-- @param f a function
+-- @param ... a list of partial arguments to `f`
+-- @return a new version of function f having some of it original arguments filled
+-- @see partialRight
+-- @see curry
+function _.partial(f,...)
+  local partial_args = {...}
+  return function (...)
+    local n_args = {...}
+    local f_args = {}
+    for k,v in ipairs(partial_args) do
+      f_args[k] = (v == '_') and _.pop(n_args) or v
+    end
+    return f(unpack(_.append(f_args,n_args)))
+  end
+end
+
+--- Similar to @{partial}, but from the right.
+-- @name partialRight
+-- @param f a function
+-- @param ... a list of partial arguments to `f`
+-- @return a new version of function f having some of it original arguments filled
+-- @see partialRight
+-- @see curry
+function _.partialRight(f,...)
+  local partial_args = {...}
+  return function (...)
+    local n_args = {...}
+    local f_args = {}
+    for k = 1,#partial_args do
+      f_args[k] = (partial_args[k] == '_') and _.pop(n_args) or partial_args[k]
+    end
+    return f(unpack(_.append(n_args, f_args)))
+  end
+end
+
+--- Curries a function. If the given function `f` takes multiple arguments, it returns another version of
+-- `f` that takes a single argument (the first of the arguments to the original function) and returns a new
+-- function that takes the remainder of the arguments and returns the result.
+-- @name curry
+-- @param f a function
+-- @param[opt] n_args the number of arguments expected for `f`. Defaults to 2.
+-- @return a curried version of `f`
+-- @see partial
+-- @see partialRight
+function _.curry(f, n_args)
+  n_args = n_args or 2
+  local _args = {}
+  local function scurry(v)
+    if n_args == 1 then return f(v) end
+    if v ~= nil then _args[#_args+1] = v end
+    if #_args < n_args then
+      return scurry
+    else
+      local r = {f(unpack(_args))}
+      _args = {}
+      return unpack(r)
+    end
+  end
+  return scurry
+end
+
+--- Returns the execution time of `f (...)` and its returned values.
+-- @name time
+-- @param f a function
+-- @param[opt] ... optional args to `f`
+-- @return the execution time and the results of `f (...)`
+function _.time(f, ...)
+  local stime = clock()
+  local r = {f(...)}
+  return clock() - stime, unpack(r)
+end
+
+--- Object functions
+--@section Object functions
+
+--- Returns the keys of the object properties.
+-- @name keys
+-- @param obj an object
+-- @return an array
+function _.keys(obj)
+  local _oKeys = {}
+  _.each(obj,function(key) _oKeys[#_oKeys+1]=key end)
+  return _oKeys
+end
+
+--- Returns the values of the object properties.
+-- @name values
+-- @param obj an object
+-- @return an array
+function _.values(obj)
+  local _oValues = {}
+  _.each(obj,function(_,value) _oValues[#_oValues+1]=value end)
+  return _oValues
+end
+
+--- Converts keys and values a an array-list of [k, v].
+-- @name kvpairs
+-- @param obj an object
+-- @return an array list of key-values pairs
+-- @see toObj
+function _.kvpairs(obj)
+  local t = {}
+  _.each(obj, function(k,v) t[#t+1] = {k,v} end)
+  return t
+end
+
+--- Converts an array list of `kvpairs` to an object. Keys are taken
+-- from the 1rst column in the `kvpairs` sequence, associated with values in the 2nd
+-- column
+-- @name toObj
+-- @param kvpairs an array-list of `kvpairs`
+-- @return an object
+-- @see kvpairs
+function _.toObj(kvpairs)
+  local obj = {}
+  for __, v in ipairs(kvpairs) do
+    obj[v[1]] = v[2]
+  end
+  return obj
+end
+
+--- Returns a function that will return the key property of any passed-in object.
+-- @name property
+-- @param key a key property name
+-- @return a function which should accept an object as argument
+-- @see propertyOf
+function _.property(key)
+  return function(obj) return obj[key] end
+end
+
+--- Returns a function which will return the value of an object property.
+-- @name propertyOf
+-- @param obj an object
+-- @return a function which should accept a key property argument
+-- @see property
+function _.propertyOf(obj)
+  return function(key) return obj[key] end
+end
+
+--- Converts any given value to a boolean
+-- @name toBoolean
+-- @param value a value. Can be of any type
+-- @return `true` if value is true, `false` otherwise (false or nil).
+function _.toBoolean(value)
+  return not not value
+end
+
+--- Extends an object properties. It copies the properties of extra passed-in objects
+-- into the destination object, and returns the destination object. The last objects
+-- will override properties of the same name.
+-- @name extend
+-- @param destObj a destination object
+-- @param ... a list of objects
+-- @return the destination object extended
+function _.extend(destObj, ...)
+  local sources = {...}
+  _.each(sources,function(__,source)
+    if _.isTable(source) then
+      _.each(source,function(key,value)
+        destObj[key] = value
+      end)
+    end
+  end)
+  return destObj
+end
+
+--- Returns a sorted list of all methods names found in an object. If the given object
+-- has a metatable implementing an `__index` field pointing to another table, will also recurse on this
+-- table if `recurseMt` is provided. If `obj` is omitted, it defaults to the library functions.
+-- <br/><em>Aliased as `methods`</em>.
+-- @name functions
+-- @param[opt] obj an object. Defaults to Moses library functions.
+-- @return an array-list of methods names
+function _.functions(obj, recurseMt)
+  obj = obj or _
+  local _methods = {}
+  _.each(obj,function(key,value)
+    if _.isFunction(value) then
+      _methods[#_methods+1]=key
+    end
+  end)
+  if not recurseMt then
+    return _.sort(_methods)
+  end
+  local mt = getmetatable(obj)
+  if mt and mt.__index then
+    local mt_methods = _.functions(mt.__index)
+    _.each(mt_methods, function(k,fn)
+      _methods[#_methods+1] = fn
+    end)
+  end
+  return _.sort(_methods)
+end
+
+--- Clones a given object properties. If `shallow` is passed will also clone nested array properties.
+-- @name clone
+-- @param obj an object
+-- @param[opt] shallow whether or not nested array-properties should be cloned, defaults to false.
+-- @return a copy of the passed-in object
+function _.clone(obj, shallow)
+  if not _.isTable(obj) then return obj end
+  local _obj = {}
+  _.each(obj,function(i,v)
+    if _.isTable(v) then
+      if not shallow then
+        _obj[i] = _.clone(v,shallow)
+      else _obj[i] = v
+      end
+    else
+      _obj[i] = v
+    end
+  end)
+  return _obj
+end
+
+--- Invokes interceptor with the object, and then returns object.
+-- The primary purpose of this method is to "tap into" a method chain, in order to perform operations
+-- on intermediate results within the chain.
+-- @name tap
+-- @param obj an object
+-- @param f an interceptor function, should be prototyped as `f (obj, ...)`
+-- @param[opt] ... args to be passed to `f`
+-- @return the passed-in object
+function _.tap(obj, f, ...)
+  f(obj,...)
+  return obj
+end
+
+--- Checks if a given object implements a property.
+-- @name has
+-- @param obj an object
+-- @param key a key property to be checked
+-- @return `true` or `false`
+function _.has(obj, key)
+  return obj[key]~=nil
+end
+
+--- Returns an object copy having white-listed properties.
+-- <br/><em>Aliased as `choose`</em>.
+-- @name pick
+-- @param obj an object
+-- @param ... a variable number of string keys
+-- @return the filtered object
+function _.pick(obj, ...)
+  local whitelist = _.flatten {...}
+  local _picked = {}
+  _.each(whitelist,function(key,property)
+      if not _.isNil(obj[property]) then
+        _picked[property] = obj[property]
+      end
+    end)
+  return _picked
+end
+
+--- Returns an object copy without black-listed properties.
+-- <br/><em>Aliased as `drop`</em>.
+-- @name omit
+-- @param obj an object
+-- @param ... a variable number of string keys
+-- @return the filtered object
+function _.omit(obj, ...)
+  local blacklist = _.flatten {...}
+  local _picked = {}
+  _.each(obj,function(key,value)
+      if not _.include(blacklist,key) then
+        _picked[key] = value
+      end
+    end)
+  return _picked
+end
+
+--- Applies a template to an object, preserving non-nil properties.
+-- <br/><em>Aliased as `defaults`</em>.
+-- @name template
+-- @param obj an object
+-- @param[opt] template a template object. Defaults to an empty table `{}`.
+-- @return the passed-in object filled
+function _.template(obj, template)
+  _.each(template or {},function(i,v)
+  if not obj[i] then obj[i] = v end
+  end)
+  return obj
+end
+
+--- Performs a deep comparison test between two objects. Can compare strings, functions
+-- (by reference), nil, booleans. Compares tables by reference or by values. If `useMt`
+-- is passed, the equality operator `==` will be used if one of the given objects has a
+-- metatable implementing `__eq`.
+-- <br/><em>Aliased as `_.compare`</em>
+-- @name isEqual
+-- @param objA an object
+-- @param objB another object
+-- @param[opt] useMt whether or not `__eq` should be used, defaults to false.
+-- @return `true` or `false`
+function _.isEqual(objA, objB, useMt)
+  local typeObjA = type(objA)
+  local typeObjB = type(objB)
+
+  if typeObjA~=typeObjB then return false end
+  if typeObjA~='table' then return (objA==objB) end
+
+  local mtA = getmetatable(objA)
+  local mtB = getmetatable(objB)
+
+  if useMt then
+    if (mtA or mtB) and (mtA.__eq or mtB.__eq) then
+      return mtA.__eq(objA, objB) or mtB.__eq(objB, objA) or (objA==objB)
+    end
+  end
+
+  if _.size(objA)~=_.size(objB) then return false end
+
+  for i,v1 in pairs(objA) do
+    local v2 = objB[i]
+    if _.isNil(v2) or not _.isEqual(v1,v2,useMt) then return false end
+  end
+
+  for i,v1 in pairs(objB) do
+    local v2 = objA[i]
+    if _.isNil(v2) then return false end
+  end
+
+  return true
+end
+
+--- Invokes an object method. It passes the object itself as the first argument. if `method` is not
+-- callable, will return `obj[method]`.
+-- @name result
+-- @param obj an object
+-- @param method a string key to index in object `obj`.
+-- @param[opt] ... Optional args to be passed to `method`
+-- @return the returned value of `method (obj, ...)` call
+function _.result(obj, method, ...)
+  if obj[method] then
+    if _.isCallable(obj[method]) then
+      return obj[method](obj,...)
+    else return obj[method]
+    end
+  end
+  if _.isCallable(method) then
+    return method(obj,...)
+  end
+end
+
+--- Checks if the given arg is a table.
+-- @name isTable
+-- @param t a value to be tested
+-- @return `true` or `false`
+function _.isTable(t)
+  return type(t) == 'table'
+end
+
+--- Checks if the given argument is callable. Assumes `obj` is callable if
+-- it is either a function or a table having a metatable implementing `__call` metamethod.
+-- @name isCallable
+-- @param obj an object
+-- @return `true` or `false`
+function _.isCallable(obj)
+  return (_.isFunction(obj) or
+     (_.isTable(obj) and getmetatable(obj)
+                   and getmetatable(obj).__call~=nil) or false)
+end
+
+--- Checks if the given argument is an array. Assumes `obj` is an array
+-- if is a table with consecutive integer keys starting at 1.
+-- @name isArray
+-- @param obj an object
+-- @return `true` or `false`
+function _.isArray(obj)
+  if not _.isTable(obj) then return false end
+  -- Thanks @Wojak and @Enrique García Cota for suggesting this
+  -- See : http://love2d.org/forums/viewtopic.php?f=3&t=77255&start=40#p163624
+  local i = 0
+  for __ in pairs(obj) do
+     i = i + 1
+     if _.isNil(obj[i]) then return false end
+  end
+  return true
+end
+
+--- Checks if the given object is iterable with `pairs` (or `ipairs`).
+-- @name isIterable
+-- @param obj an object
+-- @return `true` if the object can be iterated with `pairs` (or `ipairs`), `false` otherwise
+function _.isIterable(obj)
+  return _.toBoolean((pcall(pairs, obj)))
+end
+
+--- Checks if the given pbject is empty. If `obj` is a string, will return `true`
+-- if `#obj == 0`. Otherwise, if `obj` is a table, will return whether or not this table
+-- is empty. If `obj` is `nil`, it will return true.
+-- @name isEmpty
+-- @param[opt] obj an object
+-- @return `true` or `false`
+function _.isEmpty(obj)
+  if _.isNil(obj) then return true end
+  if _.isString(obj) then return #obj==0 end
+  if _.isTable(obj) then return next(obj)==nil end
+  return true
+end
+
+--- Checks if the given argument is a string.
+-- @name isString
+-- @param obj an object
+-- @return `true` or `false`
+function _.isString(obj)
+  return type(obj) == 'string'
+end
+
+--- Checks if the given argument is a function.
+-- @name isFunction
+-- @param obj an object
+-- @return `true` or `false`
+function _.isFunction(obj)
+   return type(obj) == 'function'
+end
+
+--- Checks if the given argument is nil.
+-- @name isNil
+-- @param obj an object
+-- @return `true` or `false`
+function _.isNil(obj)
+  return obj==nil
+end
+
+--- Checks if the given argument is a number.
+-- @name isNumber
+-- @param obj an object
+-- @return `true` or `false`
+-- @see isNaN
+function _.isNumber(obj)
+  return type(obj) == 'number'
+end
+
+--- Checks if the given argument is NaN (see [Not-A-Number](http://en.wikipedia.org/wiki/NaN)).
+-- @name isNaN
+-- @param obj an object
+-- @return `true` or `false`
+-- @see isNumber
+function _.isNaN(obj)
+  return _.isNumber(obj) and obj~=obj
+end
+
+--- Checks if the given argument is a finite number.
+-- @name isFinite
+-- @param obj an object
+-- @return `true` or `false`
+function _.isFinite(obj)
+  if not _.isNumber(obj) then return false end
+  return obj > -huge and obj < huge
+end
+
+--- Checks if the given argument is a boolean.
+-- @name isBoolean
+-- @param obj an object
+-- @return `true` or `false`
+function _.isBoolean(obj)
+  return type(obj) == 'boolean'
+end
+
+--- Checks if the given argument is an integer.
+-- @name isInteger
+-- @param obj an object
+-- @return `true` or `false`
+function _.isInteger(obj)
+  return _.isNumber(obj) and floor(obj)==obj
+end
+
+-- Aliases
+
+do
+
+  -- Table functions aliases
+  _.forEach     = _.each
+  _.forEachi    = _.eachi
+  _.loop        = _.cycle
+  _.collect     = _.map
+  _.inject      = _.reduce
+  _.foldl       = _.reduce
+  _.injectr     = _.reduceRight
+  _.foldr       = _.reduceRight
+  _.mapr        = _.mapReduce
+  _.maprr       = _.mapReduceRight
+  _.any         = _.include
+  _.some        = _.include
+  _.contains    = _.include
+  _.filter      = _.select
+  _.discard     = _.reject
+  _.every       = _.all
+
+  -- Array functions aliases
+  _.takeWhile   = _.selectWhile
+  _.rejectWhile = _.dropWhile
+  _.shift       = _.pop
+  _.remove      = _.pull
+  _.rmRange     = _.removeRange
+  _.chop        = _.removeRange
+  _.sub         = _.slice
+  _.head        = _.first
+  _.take        = _.first
+  _.tail        = _.rest
+  _.skip        = _.last
+  _.without     = _.difference
+  _.diff        = _.difference
+  _.symdiff     = _.symmetricDifference
+  _.xor         = _.symmetricDifference
+  _.uniq        = _.unique
+  _.isuniq      = _.isunique
+  _.transpose   = _.zip
+  _.part        = _.partition
+  _.perm        = _.permutation
+  _.mirror      = _.invert
+  _.join        = _.concat
+
+  -- Utility functions aliases
+  _.cache       = _.memoize
+  _.juxt        = _.juxtapose
+  _.uid         = _.uniqueId
+  _.iter        = _.iterator
+
+  -- Object functions aliases
+  _.methods     = _.functions
+  _.choose      = _.pick
+  _.drop        = _.omit
+  _.defaults    = _.template
+  _.compare     = _.isEqual
+
+end
+
+-- Setting chaining and building interface
+
+do
+
+  -- Wrapper to Moses
+  local f = {}
+
+  -- Will be returned upon requiring, indexes into the wrapper
+  local __ = {}
+  __.__index = f
+
+  -- Wraps a value into an instance, and returns the wrapped object
+  local function new(value)
+    local i = {_value = value, _wrapped = true}
+    return setmetatable(i, __)
+  end
+
+  setmetatable(__,{
+    __call  = function(self,v) return new(v) end, -- Calls returns to instantiation
+    __index = function(t,key,...) return f[key] end  -- Redirects to the wrapper
+  })
+
+  --- Returns a wrapped object. Calling library functions as methods on this object
+  -- will continue to return wrapped objects until @{obj:value} is used. Can be aliased as `_(value)`.
+  -- @class function
+  -- @name chain
+  -- @param value a value to be wrapped
+  -- @return a wrapped object
+  function __.chain(value)
+    return new(value)
+  end
+
+  --- Extracts the value of a wrapped object. Must be called on an chained object (see @{chain}).
+  -- @class function
+  -- @name obj:value
+  -- @return the value previously wrapped
+  function __:value()
+    return self._value
+  end
+
+  -- Register chaining methods into the wrapper
+  f.chain, f.value = __.chain, __.value
+
+  -- Register all functions into the wrapper
+  for fname,fct in pairs(_) do
+    f[fname] = function(v, ...)
+      local wrapped = _.isTable(v) and v._wrapped or false
+      if wrapped then
+        local _arg = v._value
+        local _rslt = fct(_arg,...)
+        return new(_rslt)
+      else
+        return fct(v,...)
+      end
+    end
+  end
+
+  --- Imports all library functions into a context.
+  -- @name import
+  -- @param[opt] context a context. Defaults to `_G` (global environment) when not given.
+  -- @param[optchain] noConflict if supplied, will not import functions having a key existing in the destination context.
+  -- @return the passed-in context
+  f.import = function(context, noConflict)
+    context = context or _ENV or _G
+    local funcs = _.functions()
+    _.each(funcs, function(k, fname)
+      if rawget(context, fname) then
+        if not noConflict then
+          context[fname] = _[fname]
+        end
+      else
+        context[fname] = _[fname]
+      end
+    end)
+    return context
+  end
+
+  -- Descriptive tags
+  __._VERSION     = 'Moses v'.._MODULEVERSION
+  __._URL         = 'http://github.com/Yonaba/Moses'
+  __._LICENSE     = 'MIT <http://raw.githubusercontent.com/Yonaba/Moses/master/LICENSE>'
+  __._DESCRIPTION = 'utility-belt library for functional programming in Lua'
+
+  return __
+
+end
diff --git a/src/lib/serpent.lua b/src/lib/serpent.lua
new file mode 100644
index 0000000..381db57
--- /dev/null
+++ b/src/lib/serpent.lua
@@ -0,0 +1,124 @@
+local n, v = "serpent", 0.28 -- (C) 2012-15 Paul Kulchenko; MIT License
+local c, d = "Paul Kulchenko", "Lua serializer and pretty printer"
+local snum = {[tostring(1/0)]='1/0 --[[math.huge]]',[tostring(-1/0)]='-1/0 --[[-math.huge]]',[tostring(0/0)]='0/0'}
+local badtype = {thread = true, userdata = true, cdata = true}
+local keyword, globals, G = {}, {}, (_G or _ENV)
+for _,k in ipairs({'and', 'break', 'do', 'else', 'elseif', 'end', 'false',
+  'for', 'function', 'goto', 'if', 'in', 'local', 'nil', 'not', 'or', 'repeat',
+  'return', 'then', 'true', 'until', 'while'}) do keyword[k] = true end
+for k,v in pairs(G) do globals[v] = k end -- build func to name mapping
+for _,g in ipairs({'coroutine', 'debug', 'io', 'math', 'string', 'table', 'os'}) do
+  for k,v in pairs(G[g] or {}) do globals[v] = g..'.'..k end end
+
+local function s(t, opts)
+  local name, indent, fatal, maxnum = opts.name, opts.indent, opts.fatal, opts.maxnum
+  local sparse, custom, huge = opts.sparse, opts.custom, not opts.nohuge
+  local space, maxl = (opts.compact and '' or ' '), (opts.maxlevel or math.huge)
+  local iname, comm = '_'..(name or ''), opts.comment and (tonumber(opts.comment) or math.huge)
+  local seen, sref, syms, symn = {}, {'local '..iname..'={}'}, {}, 0
+  local function gensym(val) return '_'..(tostring(tostring(val)):gsub("[^%w]",""):gsub("(%d%w+)",
+    -- tostring(val) is needed because __tostring may return a non-string value
+    function(s) if not syms[s] then symn = symn+1; syms[s] = symn end return tostring(syms[s]) end)) end
+  local function safestr(s) return type(s) == "number" and tostring(huge and snum[tostring(s)] or s)
+    or type(s) ~= "string" and tostring(s) -- escape NEWLINE/010 and EOF/026
+    or ("%q"):format(s):gsub("\010","n"):gsub("\026","\\026") end
+  local function comment(s,l) return comm and (l or 0) < comm and ' --[['..tostring(s)..']]' or '' end
+  local function globerr(s,l) return globals[s] and globals[s]..comment(s,l) or not fatal
+    and safestr(select(2, pcall(tostring, s))) or error("Can't serialize "..tostring(s)) end
+  local function safename(path, name) -- generates foo.bar, foo[3], or foo['b a r']
+    local n = name == nil and '' or name
+    local plain = type(n) == "string" and n:match("^[%l%u_][%w_]*$") and not keyword[n]
+    local safe = plain and n or '['..safestr(n)..']'
+    return (path or '')..(plain and path and '.' or '')..safe, safe end
+  local alphanumsort = type(opts.sortkeys) == 'function' and opts.sortkeys or function(k, o, n) -- k=keys, o=originaltable, n=padding
+    local maxn, to = tonumber(n) or 12, {number = 'a', string = 'b'}
+    local function padnum(d) return ("%0"..tostring(maxn).."d"):format(tonumber(d)) end
+    table.sort(k, function(a,b)
+      -- sort numeric keys first: k[key] is not nil for numerical keys
+      return (k[a] ~= nil and 0 or to[type(a)] or 'z')..(tostring(a):gsub("%d+",padnum))
+           < (k[b] ~= nil and 0 or to[type(b)] or 'z')..(tostring(b):gsub("%d+",padnum)) end) end
+  local function val2str(t, name, indent, insref, path, plainindex, level)
+    local ttype, level, mt = type(t), (level or 0), getmetatable(t)
+    local spath, sname = safename(path, name)
+    local tag = plainindex and
+      ((type(name) == "number") and '' or name..space..'='..space) or
+      (name ~= nil and sname..space..'='..space or '')
+    if seen[t] then -- already seen this element
+      sref[#sref+1] = spath..space..'='..space..seen[t]
+      return tag..'nil'..comment('ref', level) end
+    if type(mt) == 'table' and (mt.__serialize or mt.__tostring) then -- knows how to serialize itself
+      seen[t] = insref or spath
+      if mt.__serialize then t = mt.__serialize(t) else t = tostring(t) end
+      ttype = type(t) end -- new value falls through to be serialized
+    if ttype == "table" then
+      if level >= maxl then return tag..'{}'..comment('max', level) end
+      seen[t] = insref or spath
+      if next(t) == nil then return tag..'{}'..comment(t, level) end -- table empty
+      local maxn, o, out = math.min(#t, maxnum or #t), {}, {}
+      for key = 1, maxn do o[key] = key end
+      if not maxnum or #o < maxnum then
+        local n = #o -- n = n + 1; o[n] is much faster than o[#o+1] on large tables
+        for key in pairs(t) do if o[key] ~= key then n = n + 1; o[n] = key end end end
+      if maxnum and #o > maxnum then o[maxnum+1] = nil end
+      if opts.sortkeys and #o > maxn then alphanumsort(o, t, opts.sortkeys) end
+      local sparse = sparse and #o > maxn -- disable sparsness if only numeric keys (shorter output)
+      for n, key in ipairs(o) do
+        local value, ktype, plainindex = t[key], type(key), n <= maxn and not sparse
+        if opts.valignore and opts.valignore[value] -- skip ignored values; do nothing
+        or opts.keyallow and not opts.keyallow[key]
+        or opts.valtypeignore and opts.valtypeignore[type(value)] -- skipping ignored value types
+        or sparse and value == nil then -- skipping nils; do nothing
+        elseif ktype == 'table' or ktype == 'function' or badtype[ktype] then
+          if not seen[key] and not globals[key] then
+            sref[#sref+1] = 'placeholder'
+            local sname = safename(iname, gensym(key)) -- iname is table for local variables
+            sref[#sref] = val2str(key,sname,indent,sname,iname,true) end
+          sref[#sref+1] = 'placeholder'
+          local path = seen[t]..'['..tostring(seen[key] or globals[key] or gensym(key))..']'
+          sref[#sref] = path..space..'='..space..tostring(seen[value] or val2str(value,nil,indent,path))
+        else
+          out[#out+1] = val2str(value,key,indent,insref,seen[t],plainindex,level+1)
+        end
+      end
+      local prefix = string.rep(indent or '', level)
+      local head = indent and '{\n'..prefix..indent or '{'
+      local body = table.concat(out, ','..(indent and '\n'..prefix..indent or space))
+      local tail = indent and "\n"..prefix..'}' or '}'
+      return (custom and custom(tag,head,body,tail) or tag..head..body..tail)..comment(t, level)
+    elseif badtype[ttype] then
+      seen[t] = insref or spath
+      return tag..globerr(t, level)
+    elseif ttype == 'function' then
+      seen[t] = insref or spath
+      local ok, res = pcall(string.dump, t)
+      local func = ok and ((opts.nocode and "function() --[[..skipped..]] end" or
+        "((loadstring or load)("..safestr(res)..",'@serialized'))")..comment(t, level))
+      return tag..(func or globerr(t, level))
+    else return tag..safestr(t) end -- handle all other types
+  end
+  local sepr = indent and "\n" or ";"..space
+  local body = val2str(t, name, indent) -- this call also populates sref
+  local tail = #sref>1 and table.concat(sref, sepr)..sepr or ''
+  local warn = opts.comment and #sref>1 and space.."--[[incomplete output with shared/self-references skipped]]" or ''
+  return not name and body..warn or "do local "..body..sepr..tail.."return "..name..sepr.."end"
+end
+
+local function deserialize(data, opts)
+  local env = (opts and opts.safe == false) and G
+    or setmetatable({}, {
+        __index = function(t,k) return t end,
+        __call = function(t,...) error("cannot call functions") end
+      })
+  local f, res = (loadstring or load)('return '..data, nil, nil, env)
+  if not f then f, res = (loadstring or load)(data, nil, nil, env) end
+  if not f then return f, res end
+  if setfenv then setfenv(f, env) end
+  return pcall(f)
+end
+
+local function merge(a, b) if b then for k,v in pairs(b) do a[k] = v end end; return a; end
+return { _NAME = n, _COPYRIGHT = c, _DESCRIPTION = d, _VERSION = v, serialize = s,
+  load = deserialize,
+  dump = function(a, opts) return s(a, merge({name = '_', compact = true, sparse = true}, opts)) end,
+  line = function(a, opts) return s(a, merge({sortkeys = true, comment = true}, opts)) end,
+  block = function(a, opts) return s(a, merge({indent = '  ', sortkeys = true, comment = true}, opts)) end }
diff --git a/src/lib/strict.lua b/src/lib/strict.lua
new file mode 100644
index 0000000..40e62b7
--- /dev/null
+++ b/src/lib/strict.lua
@@ -0,0 +1,39 @@
+-- strict.lua
+-- checks uses of undeclared global variables
+-- All global variables must be 'declared' through a regular assignment
+-- (even assigning nil will do) in a main chunk before being used
+-- anywhere or assigned to inside a function.
+-- distributed under the Lua license: http://www.lua.org/license.html
+
+local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget
+
+local mt = getmetatable(_G)
+if mt == nil then
+  mt = {}
+  setmetatable(_G, mt)
+end
+
+mt.__declared = {}
+
+local function what ()
+  local d = getinfo(3, "S")
+  return d and d.what or "C"
+end
+
+mt.__newindex = function (t, n, v)
+  if not mt.__declared[n] then
+    local w = what()
+    if w ~= "main" and w ~= "C" then
+      error("assign to undeclared variable '"..n.."'", 2)
+    end
+    mt.__declared[n] = true
+  end
+  rawset(t, n, v)
+end
+
+mt.__index = function (t, n)
+  if not mt.__declared[n] and what() ~= "C" then
+    error("variable '"..n.."' is not declared", 2)
+  end
+  return rawget(t, n)
+end
diff --git a/src/main.lua b/src/main.lua
new file mode 100644
index 0000000..965ef91
--- /dev/null
+++ b/src/main.lua
@@ -0,0 +1,214 @@
+io.stdout:setvbuf("no")
+
+require 'lib.strict'
+
+local _       = require 'lib.moses'
+local Serpent = require 'lib.serpent'
+
+local lf = love.filesystem
+
+local MODE_READ_BINARY = 'rb'
+local MODE_WRITE_BINARY = 'wb'
+
+function readLittleEndian(file, bytes)
+  local string = file:read(2)
+  local bytes = string:byte()
+  -- print(string, type(bytes), bytes)
+  return bytes
+end
+
+-- https://gist.github.com/fdeitylink/3fded36e9187fe838eb18a412c712800
+-- -=~ PXM File Data ~=-
+--   maps must be minimum of 21x16
+function readPXM(filename)
+  print('reading PXM: ' .. filename)
+  local file = assert(io.open(filename, MODE_READ_BINARY))
+  -- First three bytes are PXM, then 0x10.
+  assert(file:read(3) == "PXM")
+  assert(file:read(1):byte() == 0x10)
+
+  -- Then 0x_map_length - 2 bytes
+  -- Then 0x_map_height - 2 bytes
+  local length = readLittleEndian(file, 2)
+  local height = readLittleEndian(file, 2)
+  print('length:', length)
+  print('height:', height)
+
+  -- Then 0x_map_tile_from_tileset for the rest of the file (numbered from 0, and going left to right, top to bottom) - 1 byte
+  local tiles = {}
+  for x = 1, length do
+    tiles[x] = {}
+  end
+  for y = 1, height do
+    for x = 1, length do
+      tiles[x][y] = file:read(1):byte()
+    end
+  end
+  -- Print result
+  local XXX = 3
+  for y = 1, height do
+    local line = ""
+    for x = 1, length do
+      local tile = tiles[x][y]
+      local len = string.len(tile)
+      line = line .. string.rep(' ', XXX - len) .. tile
+    end
+    print(line)
+  end
+end
+
+local ITEM_DATA = {
+  -- Weapons
+  wPolar = {
+    name = "Polar Star",
+    map = "Pole",
+    getText = "Got the =Polar Star=!",
+    command = "<AM+0002:0000",
+    displayCmd = "<GIT0002",
+  },
+  -- Items
+  iPanties = {
+    name = "Curly's Panties",
+    map = "CurlyS",
+    -- getText = "Found =Curly's Underwear=.",
+    getText = "Found =Curly's Panties=.",
+    command = "<IT+0035",
+    displayCmd = "<GIT1035",
+  },
+}
+
+function stringReplace(text, needle, replacement)
+  local i = text:find(needle, 1, true)
+  if i == nil then
+    return text
+  end
+  local len = needle:len()
+  local j = i + len - 1
+  assert((i % 1 == 0) and (i > 0) and (i <= j), tostring(i))
+  assert((j % 1 == 0), tostring(j))
+  local a = text:sub(1, i - 1)
+  local b = text:sub(j + 1)
+  return a .. replacement .. b
+end
+
+function readTSC(filename, decodedFilename)
+  print('reading TSC: ' .. filename)
+  local file = assert(io.open(filename, MODE_READ_BINARY))
+  local filesize = file:seek("end")
+  local encodingCharPosition = math.floor(filesize / 2)
+  file:seek("set", encodingCharPosition)
+  local encodingChar = file:read(1):byte()
+  print("  filesize", filesize)
+  print("  encoding char:", encodingChar)
+  print("  encoding char position:", encodingCharPosition)
+
+  -- Decode
+  local chars, len = {}, 0
+  file:seek("set")
+  for pos = 0, filesize - 1 do
+    local byte = file:read(1):byte()
+    if pos ~= encodingCharPosition then
+      -- print(pos, encodingCharPosition)
+      byte = (byte - encodingChar) % 256
+      -- byte = byte - encodingChar
+    end
+    len = len + 1
+    chars[len] = string.char(byte)
+  end
+  local decoded = table.concat(chars)
+
+  local t = {}
+  decoded:gsub(".",function(c) table.insert(t,c) end)
+  -- for i, c in ipairs(t) do
+  local near = 10
+  for i = 1270 - near, 1270 + near do
+    local c = t[i]
+    print (i, c, chars[i])
+    -- print(string.byte(chars[i]) == string.byte(c), string.byte(chars[i]), string.byte(c))
+  end
+
+  -- -- Replace
+  -- decoded = stringReplace(decoded, ITEM_DATA.wPolar.command, ITEM_DATA.iPanties.command)
+  -- decoded = stringReplace(decoded, ITEM_DATA.wPolar.getText, ITEM_DATA.iPanties.getText)
+  -- decoded = stringReplace(decoded, ITEM_DATA.wPolar.displayCmd, ITEM_DATA.iPanties.displayCmd)
+
+  -- Write
+  -- return decoded
+  local tmpFile, err = io.open(decodedFilename, MODE_WRITE_BINARY)
+  assert(err == nil, err)
+  tmpFile:write(decoded)
+  tmpFile:flush()
+  tmpFile:close()
+end
+
+function writeTSC(filename)
+  print('writing TSC: ' .. filename)
+  local file = assert(io.open(filename, MODE_READ_BINARY))
+  local filesize = file:seek("end")
+  local encodingCharPosition = math.floor(filesize / 2)
+  file:seek("set", encodingCharPosition)
+  local encodingChar = file:read(1):byte()
+  file:seek("set", encodingCharPosition)
+  print(file:read(1))
+  -- local encodingChar = 32
+  print("  filesize", filesize)
+  print("  encoding char:", encodingChar)
+  print("  encoding char position:", encodingCharPosition)
+
+  -- Encode
+  local chars, len = {}, 0
+  file:seek("set")
+  for pos = 0, filesize - 1 do
+    local byte = file:read(1):byte()
+    if pos ~= encodingCharPosition then
+      byte = (byte + encodingChar) % 255
+    end
+    len = len + 1
+    chars[len] = string.char(byte)
+  end
+  local decoded = table.concat(chars)
+
+  -- Write
+  local tmpFile, err = io.open('TestingEncoded.tsc', MODE_WRITE_BINARY)
+  assert(err == nil, err)
+  tmpFile:write(decoded)
+  tmpFile:flush()
+  tmpFile:close()
+end
+
+function love.load()
+  -- readPXM('Pole.pxm')
+  -- readTSC('Pole.tsc', 'Testing.tsc')
+  -- writeTSC('Testing.tsc')
+  -- readTSC('TestingEncoded.tsc', 'TestingDecoded.tsc')
+end
+
+function love.directorydropped(path)
+  local success = lf.mount(path, 'data')
+  assert(success)
+
+  local items = lf.getDirectoryItems('/data')
+  local containsStage = _.contains(items, 'Stage')
+  assert(containsStage)
+  local dirStage = '/data/Stage'
+
+  -- local items = lf.getDirectoryItems(dirStage)
+  -- print(Serpent.block(items))
+end
+
+function love.keypressed(key)
+  if key == 'escape' then
+    love.event.push('quit')
+  end
+end
+
+-- #0200
+-- <KEY<FLJ1640:0201<FL+1640<SOU0022<CNP0200:0021:0000
+-- <MSGOpened the chest.<NOD<GIT0002<AM+0002:0000<CLR
+-- <CMU0010Got the =Polar Star=!<WAI0160<NOD<GIT0000<CLO<RMU
+-- <MSG
+-- From somewhere, a transmission...<FAO0004<NOD<TRA0018:0501:0002:0000
+
+-- #0420
+-- <KEY<DNP0420<MSG<GIT1035<IT+0035
+-- Found Curly's Panties.<NOD<END