Move most files out of the root directory

- ram/ froups the ram source files
- slack/ is for unused garbage taking up the ROM's free space
- gfx.py moved to utils/

33 files changed, 1174 insertions, 1175 deletions

diff --git a/Makefile b/Makefile
index 4265cfd..1471080 100644
--- a/Makefile
+++ b/Makefile
@@ -2,8 +2,8 @@ ROM := pokegold-spaceworld.gb
 CORRECTEDROM := $(ROM:%.gb=%-correctheader.gb)
 BASEROM := baserom.gb
 
-DIRS := home engine data audio maps scripts
-FILES := bin.asm gfx.asm vram.asm sram.asm wram.asm hram.asm
+DIRS := home engine data gfx audio maps scripts ram slack
+FILES :=
 
 BUILD := build
 
@@ -94,13 +94,14 @@ $(BUILD)/%.d: %.asm | $$(dir $$@) $(SCAN_INCLUDES)
 
 ### Misc file-specific graphics rules
 
+$(BUILD)/slack/corrupted_9e1c.2bpp: tools/gfx += --trim-whitespace
+$(BUILD)/slack/corrupted_a66c.2bpp: tools/gfx += --trim-whitespace
+$(BUILD)/slack/corrupted_b1e3.2bpp: tools/gfx += --trim-whitespace
+$(BUILD)/slack/sgb_border_gold_corrupted.2bpp: tools/gfx += --trim-whitespace
+
 $(BUILD)/gfx/sgb/sgb_border_alt.2bpp: tools/gfx += --trim-whitespace
 $(BUILD)/gfx/sgb/sgb_border_gold.2bpp: tools/gfx += --trim-whitespace
-$(BUILD)/gfx/sgb/sgb_border_gold_corrupted.2bpp: tools/gfx += --trim-whitespace
 $(BUILD)/gfx/sgb/sgb_border_silver.2bpp: tools/gfx += --trim-whitespace
-$(BUILD)/gfx/sgb/corrupted_9e1c.2bpp: tools/gfx += --trim-whitespace
-$(BUILD)/gfx/sgb/corrupted_a66c.2bpp: tools/gfx += --trim-whitespace
-$(BUILD)/gfx/sgb/corrupted_b1e3.2bpp: tools/gfx += --trim-whitespace
 $(BUILD)/gfx/sgb/sgb_border_silver.2bpp: tools/gfx += --trim-whitespace
 
 $(BUILD)/gfx/trainer_card/leaders.2bpp: tools/gfx += --trim-whitespace
diff --git a/bin.asm b/bin.asm
deleted file mode 100755
index c5ef243..0000000
--- a/bin.asm
+++ /dev/null
@@ -1,9 +0,0 @@
-SECTION "bin.asm@Unknownaebc", ROMX
-
-Unknownaebc:
-INCBIN "bin/unknown_aebc.bin"
-
-SECTION "bin.asm@Unknownbb43", ROMX
-
-Unknownbb43:
-INCBIN "bin/unknown_bb43.bin"
diff --git a/constants.asm b/constants.asm
index 0d1fdec..d3e99ef 100644
--- a/constants.asm
+++ b/constants.asm
@@ -1,6 +1,18 @@
-INCLUDE "charmap.asm"
+INCLUDE "constants/charmap.asm"
 
-INCLUDE "macros.asm"
+INCLUDE "macros/enum.asm"
+INCLUDE "macros/predef.asm"
+INCLUDE "macros/data.asm"
+INCLUDE "macros/code.asm"
+INCLUDE "macros/gfx.asm"
+INCLUDE "macros/coords.asm"
+INCLUDE "macros/farcall.asm"
+INCLUDE "macros/text.asm"
+INCLUDE "macros/wram.asm"
+INCLUDE "macros/audio.asm"
+INCLUDE "macros/scripts.asm"
+INCLUDE "macros/queue.asm"
+INCLUDE "macros/maps.asm"
 
 INCLUDE "constants/audio_constants.asm"
 INCLUDE "constants/gfx_constants.asm"
diff --git a/charmap.asm b/constants/charmap.asm
index be20a37..be20a37 100755
--- a/charmap.asm
+++ b/constants/charmap.asm
diff --git a/constants/text_constants.asm b/constants/text_constants.asm
index e487d4c..b3ed10c 100644
--- a/constants/text_constants.asm
+++ b/constants/text_constants.asm
@@ -40,6 +40,6 @@ PRINTNUM_MONEY          EQU 1 << PRINTNUM_MONEY_F
 PRINTNUM_RIGHTALIGN     EQU 1 << PRINTNUM_RIGHTALIGN_F
 PRINTNUM_LEADINGZEROS   EQU 1 << PRINTNUM_LEADINGZEROS_F
 
-; character sets (see charmap.asm)
+; character sets (see constants/charmap.asm)
 FIRST_REGULAR_TEXT_CHAR EQU $60
 FIRST_HIRAGANA_DAKUTEN_CHAR EQU $20
diff --git a/gfx.py b/gfx.py
deleted file mode 100644
index 04e9f7c..0000000
--- a/gfx.py
+++ /dev/null
@@ -1,171 +0,0 @@
-#!/usr/bin/python
-
-"""Supplementary scripts for graphics conversion."""
-
-import os
-import argparse
-
-from utils import gfx, lz
-
-
-# Graphics with inverted tilemaps that aren't covered by filepath_rules.
-pics = [
-	'gfx/shrink1',
-	'gfx/shrink2',
-]
-
-def recursive_read(filename):
-	def recurse(filename_):
-		lines = []
-		for line in open(filename_):
-			if 'include "' in line.lower():
-				lines += recurse(line.split('"')[1])
-			else:
-				lines += [line]
-		return lines
-	lines = recurse(filename)
-	return ''.join(lines)
-
-base_stats = None
-def get_base_stats():
-	global base_stats
-	if not base_stats:
-		base_stats = recursive_read('data/base_stats.asm')
-	return base_stats
-
-def get_pokemon_dimensions(name):
-	try:
-		if name == 'egg':
-			return 5, 5
-		if name.startswith('annon_'):
-			name = 'annon'
-		base_stats = get_base_stats()
-		start = base_stats.find('\tdb ' + name.upper())
-		start = base_stats.find('\tdn ', start)
-		end = base_stats.find('\n', start)
-		line = base_stats[start:end].replace(',', ' ')
-		w, h = map(int, line.split()[1:3])
-		return w, h
-	except:
-		return 7, 7
-
-def filepath_rules(filepath):
-	"""Infer attributes of certain graphics by their location in the filesystem."""
-	args = {}
-
-	filedir, filename = os.path.split(filepath)
-	if filedir.startswith('./'):
-		filedir = filedir[2:]
-
-	name, ext = os.path.splitext(filename)
-	if ext == '.lz':
-		name, ext = os.path.splitext(name)
-
-	pokemon_name = ''
-
-	if 'gfx/pokemon/' in filedir:
-		pokemon_name = filedir.split('/')[-1]
-		if pokemon_name.startswith('annon_'):
-			index = filedir.find(pokemon_name)
-			if index != -1:
-				filedir = filedir[:index + len('annon')] + filedir[index + len('annon_a'):]
-		if name == 'front':
-			args['pal_file'] = os.path.join(filedir, 'normal.pal')
-			args['pic'] = True
-			args['animate'] = True
-		elif name == 'back':
-			args['pal_file'] = os.path.join(filedir, 'shiny.pal')
-			args['pic'] = True
-
-	elif 'gfx/trainers' in filedir:
-		args['pic'] = True
-
-	elif os.path.join(filedir, name) in pics:
-		args['pic'] = True
-
-	if args.get('pal_file'):
-		if os.path.exists(args['pal_file']):
-			args['palout'] = args['pal_file']
-		else:
-			del args['pal_file']
-
-	if args.get('pic'):
-		if ext == '.png':
-			w, h = gfx.png.Reader(filepath).asRGBA8()[:2]
-			w = min(w/8, h/8)
-			args['pic_dimensions'] = w, w
-		elif ext == '.2bpp':
-			if pokemon_name and name == 'front':
-				w, h = get_pokemon_dimensions(pokemon_name)
-				args['pic_dimensions'] = w, w
-			elif pokemon_name and name == 'back':
-				args['pic_dimensions'] = 6, 6
-			else:
-				args['pic_dimensions'] = 7, 7
-	return args
-
-
-def to_1bpp(filename, **kwargs):
-	name, ext = os.path.splitext(filename)
-	if   ext == '.1bpp': pass
-	elif ext == '.2bpp': gfx.export_2bpp_to_1bpp(filename, **kwargs)
-	elif ext == '.png':  gfx.export_png_to_1bpp(filename, **kwargs)
-	elif ext == '.lz':
-		decompress(filename, **kwargs)
-		to_1bpp(name, **kwargs)
-
-def to_2bpp(filename, **kwargs):
-	name, ext = os.path.splitext(filename)
-	if   ext == '.1bpp': gfx.export_1bpp_to_2bpp(filename, **kwargs)
-	elif ext == '.2bpp': pass
-	elif ext == '.png':  gfx.export_png_to_2bpp(filename, **kwargs)
-	elif ext == '.lz':
-		decompress(filename, **kwargs)
-		to_2bpp(name, **kwargs)
-
-def to_png(filename, **kwargs):
-	name, ext = os.path.splitext(filename)
-	if   ext == '.1bpp': gfx.export_1bpp_to_png(filename, **kwargs)
-	elif ext == '.2bpp': gfx.export_2bpp_to_png(filename, **kwargs)
-	elif ext == '.png':  pass
-	elif ext == '.lz':
-		decompress(filename, **kwargs)
-		to_png(name, **kwargs)
-
-def compress(filename, **kwargs):
-	data = open(filename, 'rb').read()
-	lz_data = lz.Compressed(data).output
-	open(filename + '.lz', 'wb').write(bytearray(lz_data))
-
-def decompress(filename, **kwargs):
-	lz_data = open(filename, 'rb').read()
-	data = lz.Decompressed(lz_data).output
-	name, ext = os.path.splitext(filename)
-	open(name, 'wb').write(bytearray(data))
-
-
-methods = {
-	'2bpp': to_2bpp,
-	'1bpp': to_1bpp,
-	'png':  to_png,
-	'lz':   compress,
-	'unlz': decompress,
-}
-
-def main(method_name, filenames=None):
-	if filenames is None: filenames = []
-	for filename in filenames:
-		args = filepath_rules(filename)
-		method = methods.get(method_name)
-		if method:
-			method(filename, **args)
-
-def get_args():
-	ap = argparse.ArgumentParser()
-	ap.add_argument('method_name')
-	ap.add_argument('filenames', nargs='*')
-	args = ap.parse_args()
-	return args
-
-if __name__ == '__main__':
-	main(**get_args().__dict__)
diff --git a/gfx.asm b/gfx/gfx.asm
index 1b7aa6e..72d65d1 100644
--- a/gfx.asm
+++ b/gfx/gfx.asm
@@ -36,13 +36,13 @@ INCLUDE "data/pokemon/palettes.inc"
 INCLUDE "data/super_palettes.inc"
 
 Corrupted9e1cGFX:
-INCBIN "gfx/sgb/corrupted_9e1c.2bpp"
+INCBIN "slack/corrupted_9e1c.2bpp"
 
 UnusedSGBBorderGFX::
 INCBIN "gfx/sgb/sgb_border_alt.2bpp"
 
 Corrupteda66cGFX:
-INCBIN "gfx/sgb/corrupted_a66c.2bpp"
+INCBIN "slack/corrupted_a66c.2bpp"
 
 SGBBorderGFX::
 if DEF(GOLD)
@@ -51,20 +51,6 @@ else
 INCBIN "gfx/sgb/sgb_border_silver.2bpp"
 endc
 
-SECTION "gfx.asm@Corrupted SGB GFX", ROMX
-
-SGBBorderGoldCorruptedGFX:
-INCBIN "gfx/sgb/sgb_border_gold_corrupted.2bpp"
-
-Corruptedb1e3GFX:
-INCBIN "gfx/sgb/corrupted_b1e3.2bpp"
-
-SGBBorderSilverCorruptedGFX:
-INCBIN "gfx/sgb/sgb_border_silver_corrupted.2bpp"
-
-Corruptedba93GFX:
-INCBIN "gfx/sgb/corrupted_ba93.2bpp"
-
 SECTION "gfx.asm@Title Screen GFX", ROMX
 if DEF(GOLD)
 TitleScreenGFX:: INCBIN "gfx/title/title.2bpp"
@@ -361,16 +347,16 @@ Tileset_1a_Coll:
 INCBIN "data/tilesets/tileset_1a_collision.bin"
 
 SECTION "gfx.asm@PKMN Sprite Bank List", ROMX
-INCLUDE "gfx/pokemon/pkmn_pic_banks.asm"
+INCLUDE "gfx/pokemon/pkmn_pic_banks.inc"
 
-INCLUDE "gfx/pokemon/pkmn_pics.asm"
+INCLUDE "gfx/pokemon/pkmn_pics.inc"
 
 
 SECTION "gfx.asm@Annon Pic Ptrs and Pics", ROMX
-INCLUDE "gfx/pokemon/annon_pic_ptrs.asm"
-INCLUDE "gfx/pokemon/annon_pics.asm"
+INCLUDE "gfx/pokemon/annon_pic_ptrs.inc"
+INCLUDE "gfx/pokemon/annon_pics.inc"
 
-INCLUDE "gfx/pokemon/egg.asm"
+INCLUDE "gfx/pokemon/egg.inc"
 
 SECTION "gfx.asm@Attack Animation GFX", ROMX
 
diff --git a/gfx/pokemon/annon_pic_ptrs.asm b/gfx/pokemon/annon_pic_ptrs.inc
index dae3fd0..dae3fd0 100644
--- a/gfx/pokemon/annon_pic_ptrs.asm
+++ b/gfx/pokemon/annon_pic_ptrs.inc
diff --git a/gfx/pokemon/annon_pics.asm b/gfx/pokemon/annon_pics.inc
index fa1c25b..fa1c25b 100644
--- a/gfx/pokemon/annon_pics.asm
+++ b/gfx/pokemon/annon_pics.inc
diff --git a/gfx/pokemon/egg.asm b/gfx/pokemon/egg.inc
index a5a38fb..a5a38fb 100644
--- a/gfx/pokemon/egg.asm
+++ b/gfx/pokemon/egg.inc
diff --git a/gfx/pokemon/pkmn_pic_banks.asm b/gfx/pokemon/pkmn_pic_banks.inc
index dd0fc42..dd0fc42 100644
--- a/gfx/pokemon/pkmn_pic_banks.asm
+++ b/gfx/pokemon/pkmn_pic_banks.inc
diff --git a/gfx/pokemon/pkmn_pics.asm b/gfx/pokemon/pkmn_pics.inc
index 178b738..178b738 100644
--- a/gfx/pokemon/pkmn_pics.asm
+++ b/gfx/pokemon/pkmn_pics.inc
diff --git a/layout.link b/layout.link
index bdb22e0..f84ba9e 100644
--- a/layout.link
+++ b/layout.link
@@ -129,9 +129,9 @@ ROMX $02
 	"gfx.asm@Title Screen BG Decoration Border"
 	"engine/dumps/bank02.asm@Function928b"
 	"gfx.asm@SGB GFX"
-	"bin.asm@Unknownaebc"
-	"gfx.asm@Corrupted SGB GFX"
-	"bin.asm@Unknownbb43"
+	"slack.asm@Unknownaebc"
+	"slack.asm@Corrupted SGB GFX"
+	"slack.asm@Unknownbb43"
 
 ROMX $03
 	org $4000
diff --git a/macros.asm b/macros.asm
deleted file mode 100644
index c18995a..0000000
--- a/macros.asm
+++ /dev/null
@@ -1,14 +0,0 @@
-INCLUDE "macros/enum.asm"
-INCLUDE "macros/predef.asm"
-;INCLUDE "macros/rst.asm"
-INCLUDE "macros/data.asm"
-INCLUDE "macros/code.asm"
-INCLUDE "macros/gfx.asm"
-INCLUDE "macros/coords.asm"
-INCLUDE "macros/farcall.asm"
-INCLUDE "macros/text.asm"
-INCLUDE "macros/wram.asm"
-INCLUDE "macros/audio.asm"
-INCLUDE "macros/scripts.asm"
-INCLUDE "macros/queue.asm"
-INCLUDE "macros/maps.asm"
diff --git a/hram.asm b/ram/hram.asm
index 4acfbfa..4acfbfa 100644
--- a/hram.asm
+++ b/ram/hram.asm
diff --git a/sram.asm b/ram/sram.asm
index 5200979..5200979 100644
--- a/sram.asm
+++ b/ram/sram.asm
diff --git a/vram.asm b/ram/vram.asm
index bf10e4d..bf10e4d 100644
--- a/vram.asm
+++ b/ram/vram.asm
diff --git a/wram.asm b/ram/wram.asm
index 9690975..9690975 100644
--- a/wram.asm
+++ b/ram/wram.asm
diff --git a/gfx/sgb/corrupted_9e1c.png b/slack/corrupted_9e1c.png
index f124031..f124031 100755..100644
--- a/gfx/sgb/corrupted_9e1c.png
+++ b/slack/corrupted_9e1c.png
diff --git a/gfx/sgb/corrupted_a66c.png b/slack/corrupted_a66c.png
index a8bab25..a8bab25 100755..100644
--- a/gfx/sgb/corrupted_a66c.png
+++ b/slack/corrupted_a66c.png
diff --git a/gfx/sgb/corrupted_b1e3.png b/slack/corrupted_b1e3.png
index 0ee2cb5..0ee2cb5 100755..100644
--- a/gfx/sgb/corrupted_b1e3.png
+++ b/slack/corrupted_b1e3.png
diff --git a/gfx/sgb/corrupted_ba93.png b/slack/corrupted_ba93.png
index dfd88be..dfd88be 100755..100644
--- a/gfx/sgb/corrupted_ba93.png
+++ b/slack/corrupted_ba93.png
diff --git a/gfx/sgb/sgb_border_gold_corrupted.png b/slack/sgb_border_gold_corrupted.png
index 740bbd1..740bbd1 100755..100644
--- a/gfx/sgb/sgb_border_gold_corrupted.png
+++ b/slack/sgb_border_gold_corrupted.png
diff --git a/gfx/sgb/sgb_border_silver_corrupted.png b/slack/sgb_border_silver_corrupted.png
index 5b32a8e..5b32a8e 100755..100644
--- a/gfx/sgb/sgb_border_silver_corrupted.png
+++ b/slack/sgb_border_silver_corrupted.png
diff --git a/slack/slack.asm b/slack/slack.asm
new file mode 100755
index 0000000..85c76d9
--- /dev/null
+++ b/slack/slack.asm
@@ -0,0 +1,23 @@
+SECTION "slack.asm@Unknownaebc", ROMX
+
+Unknownaebc:
+INCBIN "slack/unknown_aebc.bin"
+
+SECTION "slack.asm@Unknownbb43", ROMX
+
+Unknownbb43:
+INCBIN "slack/unknown_bb43.bin"
+
+SECTION "slack.asm@Corrupted SGB GFX", ROMX
+
+SGBBorderGoldCorruptedGFX:
+INCBIN "slack/sgb_border_gold_corrupted.2bpp"
+
+Corruptedb1e3GFX:
+INCBIN "slack/corrupted_b1e3.2bpp"
+
+SGBBorderSilverCorruptedGFX:
+INCBIN "slack/sgb_border_silver_corrupted.2bpp"
+
+Corruptedba93GFX:
+INCBIN "slack/corrupted_ba93.2bpp"
diff --git a/bin/unknown_aebc.bin b/slack/unknown_aebc.bin
index 531072d..531072d 100755..100644
--- a/bin/unknown_aebc.bin
+++ b/slack/unknown_aebc.bin
diff --git a/bin/unknown_bb43.bin b/slack/unknown_bb43.bin
index e21effb..e21effb 100755..100644
--- a/bin/unknown_bb43.bin
+++ b/slack/unknown_bb43.bin
diff --git a/utils/coverage.py b/utils/coverage.py
index 1cd3f4c..2f54e03 100755
--- a/utils/coverage.py
+++ b/utils/coverage.py
@@ -8,7 +8,7 @@ Generate a PNG visualizing the space used by each bank in the ROM.
 """
 
 import sys
-import png
+from pokemontools import png
 from colorsys import hls_to_rgb
 
 from mapreader import MapReader
diff --git a/utils/gfx.py b/utils/gfx.py
index 80c84d3..a9e56d4 100644
--- a/utils/gfx.py
+++ b/utils/gfx.py
@@ -1,951 +1,171 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
+#!/usr/bin/python
+
+"""Supplementary scripts for graphics conversion."""
 
 import os
-import sys
-import png
-from math import sqrt, floor, ceil
 import argparse
-import operator
-
-from lz import Compressed, Decompressed
-
-
-def split(list_, interval):
-    """
-    Split a list by length.
-    """
-    for i in xrange(0, len(list_), interval):
-        j = min(i + interval, len(list_))
-        yield list_[i:j]
-
-
-def hex_dump(data, length=0x10):
-    """
-    just use hexdump -C
-    """
-    margin = len('%x' % len(data))
-    output = []
-    address = 0
-    for line in split(data, length):
-        output += [
-            hex(address)[2:].zfill(margin) +
-            ' | ' +
-            ' '.join('%.2x' % byte for byte in line)
-        ]
-        address += length
-    return '\n'.join(output)
-
-
-def get_tiles(image):
-    """
-    Split a 2bpp image into 8x8 tiles.
-    """
-    return list(split(image, 0x10))
-
-def connect(tiles):
-    """
-    Combine 8x8 tiles into a 2bpp image.
-    """
-    return [byte for tile in tiles for byte in tile]
-
-def transpose(tiles, width=None):
-    """
-    Transpose a tile arrangement along line y=-x.
-
-      00 01 02 03 04 05     00 06 0c 12 18 1e
-      06 07 08 09 0a 0b     01 07 0d 13 19 1f
-      0c 0d 0e 0f 10 11 <-> 02 08 0e 14 1a 20
-      12 13 14 15 16 17     03 09 0f 15 1b 21
-      18 19 1a 1b 1c 1d     04 0a 10 16 1c 22
-      1e 1f 20 21 22 23     05 0b 11 17 1d 23
-
-      00 01 02 03     00 04 08
-      04 05 06 07 <-> 01 05 09
-      08 09 0a 0b     02 06 0a
-                      03 07 0b
-    """
-    if width == None:
-        width = int(sqrt(len(tiles))) # assume square image
-    tiles = sorted(enumerate(tiles), key= lambda (i, tile): i % width)
-    return [tile for i, tile in tiles]
-
-def transpose_tiles(image, width=None):
-    return connect(transpose(get_tiles(image), width))
-
-def interleave(tiles, width):
-    """
-      00 01 02 03 04 05     00 02 04 06 08 0a
-      06 07 08 09 0a 0b     01 03 05 07 09 0b
-      0c 0d 0e 0f 10 11 --> 0c 0e 10 12 14 16
-      12 13 14 15 16 17     0d 0f 11 13 15 17
-      18 19 1a 1b 1c 1d     18 1a 1c 1e 20 22
-      1e 1f 20 21 22 23     19 1b 1d 1f 21 23
-    """
-    interleaved = []
-    left, right = split(tiles[::2], width), split(tiles[1::2], width)
-    for l, r in zip(left, right):
-        interleaved += l + r
-    return interleaved
-
-def deinterleave(tiles, width):
-    """
-      00 02 04 06 08 0a     00 01 02 03 04 05 
-      01 03 05 07 09 0b     06 07 08 09 0a 0b
-      0c 0e 10 12 14 16 --> 0c 0d 0e 0f 10 11
-      0d 0f 11 13 15 17     12 13 14 15 16 17
-      18 1a 1c 1e 20 22     18 19 1a 1b 1c 1d
-      19 1b 1d 1f 21 23     1e 1f 20 21 22 23
-    """
-    deinterleaved = []
-    rows = list(split(tiles, width))
-    for left, right in zip(rows[::2], rows[1::2]):
-        for l, r in zip(left, right):
-            deinterleaved += [l, r]
-    return deinterleaved
-
-def interleave_tiles(image, width):
-    return connect(interleave(get_tiles(image), width))
-
-def deinterleave_tiles(image, width):
-    return connect(deinterleave(get_tiles(image), width))
-
-
-def condense_image_to_map(image, pic=0):
-    """
-    Reduce an image of adjacent frames to an image containing a base frame and any unrepeated tiles.
-    Returns the new image and the corresponding tilemap used to reconstruct the input image.
-
-    If <pic> is 0, ignore the concept of frames. This behavior might be better off as another function.
-    """
-    tiles = get_tiles(image)
-    new_tiles, tilemap = condense_tiles_to_map(tiles, pic)
-    new_image = connect(new_tiles)
-    return new_image, tilemap
-
-def condense_tiles_to_map(tiles, pic=0):
-    """
-    Reduce a sequence of tiles representing adjacent frames to a base frame and any unrepeated tiles.
-    Returns the new tiles and the corresponding tilemap used to reconstruct the input tile sequence.
-
-    If <pic> is 0, ignore the concept of frames. This behavior might be better off as another function.
-    """
-
-    # Leave the first frame intact for pics.
-    new_tiles = tiles[:pic]
-    tilemap   = range(pic)
-
-    for i, tile in enumerate(tiles[pic:]):
-        if tile not in new_tiles:
-            new_tiles.append(tile)
-
-        if pic:
-            # Match the first frame exactly where possible.
-            # This reduces the space needed to replace tiles in pic animations.
-            # For example, if a tile is repeated twice in the first frame,
-            # but at the same relative index as the second tile, use the second index.
-            # When creating a bitmask later, the second index would not require a replacement, but the first index would have.
-            pic_i = i % pic
-            if tile == new_tiles[pic_i]:
-                tilemap.append(pic_i)
-            else:
-                tilemap.append(new_tiles.index(tile))
-        else:
-            tilemap.append(new_tiles.index(tile))
-    return new_tiles, tilemap
-
-def test_condense_tiles_to_map():
-    test = condense_tiles_to_map(list('abcadbae'))
-    if test != (list('abcde'), [0, 1, 2, 0, 3, 1, 0, 4]):
-        raise Exception(test)
-    test = condense_tiles_to_map(list('abcadbae'), 2)
-    if test != (list('abcde'), [0, 1, 2, 0, 3, 1, 0, 4]):
-        raise Exception(test)
-    test = condense_tiles_to_map(list('abcadbae'), 4)
-    if test != (list('abcade'), [0, 1, 2, 3, 4, 1, 0, 5]):
-        raise Exception(test)
-    test = condense_tiles_to_map(list('abcadbea'), 4)
-    if test != (list('abcade'), [0, 1, 2, 3, 4, 1, 5, 3]):
-        raise Exception(test)
-
-
-def to_file(filename, data):
-    """
-    Apparently open(filename, 'wb').write(bytearray(data)) won't work.
-    """
-    file = open(filename, 'wb')
-    for byte in data:
-        file.write('%c' % byte)
-    file.close()
-
-
-def decompress_file(filein, fileout=None):
-    image = bytearray(open(filein).read())
-    de = Decompressed(image)
-
-    if fileout == None:
-        fileout = os.path.splitext(filein)[0]
-    to_file(fileout, de.output)
-
-
-def compress_file(filein, fileout=None):
-    image = bytearray(open(filein).read())
-    lz = Compressed(image)
-
-    if fileout == None:
-        fileout = filein + '.lz'
-    to_file(fileout, lz.output)
-
-
-def bin_to_rgb(word):
-    red   = word & 0b11111
-    word >>= 5
-    green = word & 0b11111
-    word >>= 5
-    blue  = word & 0b11111
-    return (red, green, blue)
-
-def convert_binary_pal_to_text_by_filename(filename):
-    pal = bytearray(open(filename).read())
-    return convert_binary_pal_to_text(pal)
-
-def convert_binary_pal_to_text(pal):
-    output = ''
-    words = [hi * 0x100 + lo for lo, hi in zip(pal[::2], pal[1::2])]
-    for word in words:
-        red, green, blue = ['%.2d' % c for c in bin_to_rgb(word)]
-        output += '\tRGB ' + ', '.join((red, green, blue))
-        output += '\n'
-    return output
-
-def read_rgb_macros(lines):
-    colors = []
-    for line in lines:
-        macro = line.split(" ")[0].strip()
-        if macro == 'RGB':
-            params = ' '.join(line.split(" ")[1:]).split(',')
-            red, green, blue = [int(v) for v in params]
-            colors += [[red, green, blue]]
-    return colors
-
-
-def rewrite_binary_pals_to_text(filenames):
-    for filename in filenames:
-        pal_text = convert_binary_pal_to_text_by_filename(filename)
-        with open(filename, 'w') as out:
-            out.write(pal_text)
-
-
-def flatten(planar):
-    """
-    Flatten planar 2bpp image data into a quaternary pixel map.
-    """
-    strips = []
-    for bottom, top in split(planar, 2):
-        bottom = bottom
-        top = top
-        strip = []
-        for i in xrange(7,-1,-1):
-            color = (
-                (bottom >> i & 1) +
-                (top *2 >> i & 2)
-            )
-            strip += [color]
-        strips += strip
-    return strips
-
-def to_lines(image, width):
-    """
-    Convert a tiled quaternary pixel map to lines of quaternary pixels.
-    """
-    tile_width = 8
-    tile_height = 8
-    num_columns = width / tile_width
-    height = len(image) / width
-
-    lines = []
-    for cur_line in xrange(height):
-        tile_row = cur_line / tile_height
-        line = []
-        for column in xrange(num_columns):
-            anchor = (
-                num_columns * tile_row * tile_width * tile_height +
-                column * tile_width * tile_height +
-                cur_line % tile_height * tile_width
-            )
-            line += image[anchor : anchor + tile_width]
-        lines += [line]
-    return lines
-
-
-def dmg2rgb(word):
-    """
-    For PNGs.
-    """
-    def shift(value):
-        while True:
-            yield value & (2**5 - 1)
-            value >>= 5
-    word = shift(word)
-    # distribution is less even w/ << 3
-    red, green, blue = [int(color * 8.25) for color in [word.next() for _ in xrange(3)]]
-    alpha = 255
-    return (red, green, blue, alpha)
-
-
-def rgb_to_dmg(color):
-    """
-    For PNGs.
-    """
-    word =  (color['r'] / 8)
-    word += (color['g'] / 8) << 5
-    word += (color['b'] / 8) << 10
-    return word
-
-
-def pal_to_png(filename):
-    """
-    Interpret a .pal file as a png palette.
-    """
-    with open(filename) as rgbs:
-        colors = read_rgb_macros(rgbs.readlines())
-    a = 255
-    palette = []
-    for color in colors:
-        # even distribution over 000-255
-        r, g, b = [int(hue * 8.25) for hue in color]
-        palette += [(r, g, b, a)]
-    white = (255,255,255,255)
-    black = (000,000,000,255)
-    if white not in palette and len(palette) < 4:
-        palette = [white] + palette
-    if black not in palette and len(palette) < 4:
-        palette = palette + [black]
-    return palette
-
-
-def png_to_rgb(palette):
-    """
-    Convert a png palette to rgb macros.
-    """
-    output = ''
-    for color in palette:
-        r, g, b = [color[c] / 8 for c in 'rgb']
-        output += '\tRGB ' + ', '.join(['%.2d' % hue for hue in (r, g, b)])
-        output += '\n'
-    return output
-
-
-def read_filename_arguments(filename):
-    """
-    Infer graphics conversion arguments given a filename.
-
-    Arguments are separated with '.'.
-    """
-    parsed_arguments = {}
-
-    int_arguments = {
-        'w': 'width',
-        'h': 'height',
-        't': 'tile_padding',
-    }
-    arguments = os.path.splitext(filename)[0].lstrip('.').split('.')[1:]
-    for argument in arguments:
-
-        # Check for integer arguments first (i.e. "w128").
-        arg   = argument[0]
-        param = argument[1:]
-        if param.isdigit():
-            arg = int_arguments.get(arg, False)
-            if arg:
-                parsed_arguments[arg] = int(param)
-
-        elif argument == 'arrange':
-            parsed_arguments['norepeat'] = True
-            parsed_arguments['tilemap']  = True
-
-        # Pic dimensions (i.e. "6x6").
-        elif 'x' in argument and any(map(str.isdigit, argument)):
-            w, h = argument.split('x')
-            if w.isdigit() and h.isdigit():
-                parsed_arguments['pic_dimensions'] = (int(w), int(h))
-
-        else:
-            parsed_arguments[argument] = True
-
-    return parsed_arguments
-
-
-def export_2bpp_to_png(filein, fileout=None, pal_file=None, height=0, width=0, tile_padding=0, pic_dimensions=None, **kwargs):
-
-    if fileout == None:
-        fileout = os.path.splitext(filein)[0] + '.png'
-
-    image = open(filein, 'rb').read()
-
-    arguments = {
-        'width': width,
-        'height': height,
-        'pal_file': pal_file,
-        'tile_padding': tile_padding,
-        'pic_dimensions': pic_dimensions,
-    }
-    arguments.update(read_filename_arguments(filein))
-
-    if pal_file == None:
-        if os.path.exists(os.path.splitext(fileout)[0]+'.pal'):
-            arguments['pal_file'] = os.path.splitext(fileout)[0]+'.pal'
-
-    arguments['is_tileset'] = 'tilesets' in filein
-    arguments['is_overworld'] = 'sprites' in filein
-    result = convert_2bpp_to_png(image, **arguments)
-    width, height, palette, greyscale, bitdepth, px_map = result
-
-    w = png.Writer(
-        width,
-        height,
-        palette=palette,
-        compression=9,
-        greyscale=greyscale,
-        bitdepth=bitdepth
-    )
-    with open(fileout, 'wb') as f:
-        w.write(f, px_map)
-
-
-def convert_2bpp_to_png(image, **kwargs):
-    """
-    Convert a planar 2bpp graphic to png.
-    """
-
-    image = bytearray(image)
-
-    pad_color = bytearray([0])
-
-    width          = kwargs.get('width', 0)
-    height         = kwargs.get('height', 0)
-    tile_padding   = kwargs.get('tile_padding', 0)
-    pic_dimensions = kwargs.get('pic_dimensions', None)
-    pal_file       = kwargs.get('pal_file', None)
-    interleave     = kwargs.get('interleave', False)
-
-    # Width must be specified to interleave.
-    if interleave and width:
-        image = interleave_tiles(image, width / 8)
-
-    # Pad the image by a given number of tiles if asked.
-    image += pad_color * 0x10 * tile_padding
-
-    # Some images are transposed in blocks.
-    if pic_dimensions:
-        w, h  = pic_dimensions
-        if not width: width = w * 8
-
-        pic_length = w * h * 0x10
-
-        trailing = len(image) % pic_length
-
-        pic = []
-        for i in xrange(0, len(image) - trailing, pic_length):
-            pic += transpose_tiles(image[i:i+pic_length], h)
-        image = bytearray(pic) + image[len(image) - trailing:]
-
-        # Pad out trailing lines.
-        image += pad_color * 0x10 * ((w - (len(image) / 0x10) % h) % w)
-
-    def px_length(img):
-        return len(img) * 4
-    def tile_length(img):
-        return len(img) * 4 / (8*8)
-
-    if width and height:
-        tile_width = width / 8
-        more_tile_padding = (tile_width - (tile_length(image) % tile_width or tile_width))
-        image += pad_color * 0x10 * more_tile_padding
-
-    elif width and not height:
-        tile_width = width / 8
-        more_tile_padding = (tile_width - (tile_length(image) % tile_width or tile_width))
-        image += pad_color * 0x10 * more_tile_padding
-        height = px_length(image) / width
-
-    elif height and not width:
-        tile_height = height / 8
-        more_tile_padding = (tile_height - (tile_length(image) % tile_height or tile_height))
-        image += pad_color * 0x10 * more_tile_padding
-        width = px_length(image) / height
-
-    # at least one dimension should be given
-    if width * height != px_length(image):
-        # look for possible combos of width/height that would form a rectangle
-        matches = []
-        # Height need not be divisible by 8, but width must.
-        # See pokered gfx/minimize_pic.1bpp.
-        for w in range(8, px_length(image) / 2 + 1, 8):
-            h = px_length(image) / w
-            if w * h == px_length(image):
-                matches += [(w, h)]
-        # go for the most square image
-        if len(matches):
-            width, height = sorted(matches, key= lambda (w, h): (h % 8 != 0, w + h))[0] # favor height
-        else:
-            raise Exception, 'Image can\'t be divided into tiles (%d px)!' % (px_length(image))
-        # correct tileset dimensions
-        if kwargs.get('is_tileset', False) and not (width * height // 8) % 128:
-            area = width * height
-            width = 128
-            height = area // width
-        # correct overworld dimensions
-        elif kwargs.get('is_overworld', False) and not (width * height // 8) % 16:
-            area = width * height
-            width = 16
-            height = area // width
-
-    # convert tiles to lines
-    lines = to_lines(flatten(image), width)
-
-    if pal_file == None:
-        palette   = None
-        greyscale = True
-        bitdepth  = 2
-        px_map    = [[3 - pixel for pixel in line] for line in lines]
-
-    else: # gbc color
-        palette   = pal_to_png(pal_file)
-        greyscale = False
-        bitdepth  = 8
-        px_map    = [[pixel for pixel in line] for line in lines]
-
-    return width, height, palette, greyscale, bitdepth, px_map
-
-
-def get_pic_animation(tmap, w, h):
-    """
-    Generate pic animation data from a combined tilemap of each frame.
-    """
-    frame_text = ''
-    bitmask_text = ''
-
-    frames = list(split(tmap, w * h))
-    base = frames.pop(0)
-    bitmasks = []
-
-    for i in xrange(len(frames)):
-        frame_text += '\tdw .frame{}\n'.format(i + 1)
-
-    for i, frame in enumerate(frames):
-        bitmask = map(operator.ne, frame, base)
-        if bitmask not in bitmasks:
-            bitmasks.append(bitmask)
-        which_bitmask = bitmasks.index(bitmask)
-
-        mask = iter(bitmask)
-        masked_frame = filter(lambda _: mask.next(), frame)
-
-        frame_text += '.frame{}\n'.format(i + 1)
-        frame_text += '\tdb ${:02x} ; bitmask\n'.format(which_bitmask)
-        if masked_frame:
-            frame_text += '\tdb {}\n'.format(', '.join(
-                map('${:02x}'.format, masked_frame)
-            ))
-
-    for i, bitmask in enumerate(bitmasks):
-        bitmask_text += '; {}\n'.format(i)
-        for byte in split(bitmask, 8):
-            byte = int(''.join(map(int.__repr__, reversed(byte))), 2)
-            bitmask_text += '\tdb %{:08b}\n'.format(byte)
-
-    return frame_text, bitmask_text
-
-
-def export_png_to_2bpp(filein, fileout=None, palout=None, **kwargs):
-
-    arguments = {
-        'tile_padding': 0,
-        'pic_dimensions': None,
-        'animate': False,
-        'stupid_bitmask_hack': [],
-    }
-    arguments.update(kwargs)
-    arguments.update(read_filename_arguments(filein))
-
-    image, arguments = png_to_2bpp(filein, **arguments)
-
-    if fileout == None:
-        fileout = os.path.splitext(filein)[0] + '.2bpp'
-    to_file(fileout, image)
-
-    tmap = arguments.get('tmap')
-
-    if tmap != None and arguments['animate'] and arguments['pic_dimensions']:
-        # Generate pic animation data.
-        frame_text, bitmask_text = get_pic_animation(tmap, *arguments['pic_dimensions'])
-
-        frames_path = os.path.join(os.path.split(fileout)[0], 'frames.asm')
-        with open(frames_path, 'w') as out:
-            out.write(frame_text)
-
-        bitmask_path = os.path.join(os.path.split(fileout)[0], 'bitmask.asm')
-
-        # The following Pokemon have a bitmask dummied out.
-        for exception in arguments['stupid_bitmask_hack']:
-           if exception in bitmask_path:
-                bitmasks = bitmask_text.split(';')
-                bitmasks[-1] = bitmasks[-1].replace('1', '0')
-                bitmask_text = ';'.join(bitmasks)
-
-        with open(bitmask_path, 'w') as out:
-            out.write(bitmask_text)
-
-    elif tmap != None and arguments.get('tilemap', False):
-        tilemap_path = os.path.splitext(fileout)[0] + '.tilemap'
-        to_file(tilemap_path, tmap)
-
-    palette = arguments.get('palette')
-    if palout == None:
-        palout = os.path.splitext(fileout)[0] + '.pal'
-    export_palette(palette, palout)
-
-
-def get_image_padding(width, height, wstep=8, hstep=8):
-
-    padding = {
-        'left':   0,
-        'right':  0,
-        'top':    0,
-        'bottom': 0,
-    }
-
-    if width % wstep and width >= wstep:
-       pad = float(width % wstep) / 2
-       padding['left']   = int(ceil(pad))
-       padding['right']  = int(floor(pad))
-
-    if height % hstep and height >= hstep:
-       pad = float(height % hstep) / 2
-       padding['top']    = int(ceil(pad))
-       padding['bottom'] = int(floor(pad))
-
-    return padding
-
-
-def png_to_2bpp(filein, **kwargs):
-    """
-    Convert a png image to planar 2bpp.
-    """
-
-    arguments = {
-        'tile_padding': 0,
-        'pic_dimensions': False,
-        'interleave': False,
-        'norepeat': False,
-        'tilemap': False,
-    }
-    arguments.update(kwargs)
-
-    if type(filein) is str:
-        filein = open(filein, 'rb')
-
-    assert type(filein) is file
-
-    width, height, rgba, info = png.Reader(filein).asRGBA8()
-
-    # png.Reader returns flat pixel data. Nested is easier to work with
-    len_px  = len('rgba')
-    image   = []
-    palette = []
-    for line in rgba:
-        newline = []
-        for px in xrange(0, len(line), len_px):
-            color = dict(zip('rgba', line[px:px+len_px]))
-            if color not in palette:
-                if len(palette) < 4:
-                    palette += [color]
-                else:
-                    # TODO Find the nearest match
-                    print 'WARNING: %s: Color %s truncated to' % (filein, color),
-                    color = sorted(palette, key=lambda x: sum(x.values()))[0]
-                    print color
-            newline += [color]
-        image += [newline]
-
-    assert len(palette) <= 4, '%s: palette should be 4 colors, is really %d (%s)' % (filein, len(palette), palette)
-
-    # Pad out smaller palettes with greyscale colors
-    greyscale = {
-        'black': { 'r': 0x00, 'g': 0x00, 'b': 0x00, 'a': 0xff },
-        'grey':  { 'r': 0x55, 'g': 0x55, 'b': 0x55, 'a': 0xff },
-        'gray':  { 'r': 0xaa, 'g': 0xaa, 'b': 0xaa, 'a': 0xff },
-        'white': { 'r': 0xff, 'g': 0xff, 'b': 0xff, 'a': 0xff },
-    }
-    preference = 'white', 'black', 'grey', 'gray'
-    for hue in map(greyscale.get, preference):
-        if len(palette) >= 4:
-            break
-        if hue not in palette:
-            palette += [hue]
-
-    palette.sort(key=lambda x: sum(x.values()))
-
-    # Game Boy palette order
-    palette.reverse()
-
-    # Map pixels to quaternary color ids
-    padding = get_image_padding(width, height)
-    width += padding['left'] + padding['right']
-    height += padding['top'] + padding['bottom']
-    pad = bytearray([0])
-
-    qmap = []
-    qmap += pad * width * padding['top']
-    for line in image:
-        qmap += pad * padding['left']
-        for color in line:
-            qmap += [palette.index(color)]
-        qmap += pad * padding['right']
-    qmap += pad * width * padding['bottom']
-
-    # Graphics are stored in tiles instead of lines
-    tile_width  = 8
-    tile_height = 8
-    num_columns = max(width, tile_width) / tile_width
-    num_rows = max(height, tile_height) / tile_height
-    image = []
-
-    for row in xrange(num_rows):
-        for column in xrange(num_columns):
-
-            # Split it up into strips to convert to planar data
-            for strip in xrange(min(tile_height, height)):
-                anchor = (
-                    row * num_columns * tile_width * tile_height +
-                    column * tile_width +
-                    strip * width
-                )
-                line = qmap[anchor : anchor + tile_width]
-                bottom, top = 0, 0
-                for bit, quad in enumerate(line):
-                    bottom += (quad & 1) << (7 - bit)
-                    top += (quad /2 & 1) << (7 - bit)
-                image += [bottom, top]
-
-    dim = arguments['pic_dimensions']
-    if dim:
-        if type(dim) in (tuple, list):
-            w, h = dim
-        else:
-            # infer dimensions based on width.
-            w = width / tile_width
-            h = height / tile_height
-            if h % w == 0:
-                h = w
-
-        tiles = get_tiles(image)
-        pic_length = w * h
-        tile_width = width / 8
-        trailing = len(tiles) % pic_length
-        new_image = []
-        for block in xrange(len(tiles) / pic_length):
-            offset = (h * tile_width) * ((block * w) / tile_width) + ((block * w) % tile_width)
-            pic = []
-            for row in xrange(h):
-                index = offset + (row * tile_width)
-                pic += tiles[index:index + w]
-            new_image += transpose(pic, w)
-        new_image += tiles[len(tiles) - trailing:]
-        image = connect(new_image)
-
-    # Remove any tile padding used to make the png rectangular.
-    image = image[:len(image) - arguments['tile_padding'] * 0x10]
-
-    tmap = None
-
-    if arguments['interleave']:
-        image = deinterleave_tiles(image, num_columns)
-
-    if arguments['pic_dimensions']:
-        image, tmap = condense_image_to_map(image, w * h)
-    elif arguments['norepeat']:
-        image, tmap = condense_image_to_map(image)
-        if not arguments['tilemap']:
-            tmap = None
-
-    arguments.update({ 'palette': palette, 'tmap': tmap, })
-
-    return image, arguments
-
-
-def export_palette(palette, filename):
-    """
-    Export a palette from png to rgb macros in a .pal file.
-    """
-
-    if os.path.exists(filename):
-
-        # Pic palettes are 2 colors (black/white are added later).
-        with open(filename) as rgbs:
-            colors = read_rgb_macros(rgbs.readlines())
-
-        if len(colors) == 2:
-            palette = palette[1:3]
-
-        text = png_to_rgb(palette)
-        with open(filename, 'w') as out:
-            out.write(text)
-
-
-def png_to_lz(filein):
-
-    name = os.path.splitext(filein)[0]
-
-    export_png_to_2bpp(filein)
-    image = open(name+'.2bpp', 'rb').read()
-    to_file(name+'.2bpp'+'.lz', Compressed(image).output)
-
-
-def convert_2bpp_to_1bpp(data):
-    """
-    Convert planar 2bpp image data to 1bpp. Assume images are two colors.
-    """
-    return data[::2]
-
-def convert_1bpp_to_2bpp(data):
-    """
-    Convert 1bpp image data to planar 2bpp (black/white).
-    """
-    output = []
-    for i in data:
-        output += [i, i]
-    return output
-
-
-def export_2bpp_to_1bpp(filename):
-    name, extension = os.path.splitext(filename)
-    image = open(filename, 'rb').read()
-    image = convert_2bpp_to_1bpp(image)
-    to_file(name + '.1bpp', image)
-
-def export_1bpp_to_2bpp(filename):
-    name, extension = os.path.splitext(filename)
-    image = open(filename, 'rb').read()
-    image = convert_1bpp_to_2bpp(image)
-    to_file(name + '.2bpp', image)
-
-
-def export_1bpp_to_png(filename, fileout=None):
-
-    if fileout == None:
-        fileout = os.path.splitext(filename)[0] + '.png'
-
-    arguments = read_filename_arguments(filename)
-
-    image = open(filename, 'rb').read()
-    image = convert_1bpp_to_2bpp(image)
-
-    result = convert_2bpp_to_png(image, **arguments)
-    width, height, palette, greyscale, bitdepth, px_map = result
-
-    w = png.Writer(width, height, palette=palette, compression=9, greyscale=greyscale, bitdepth=bitdepth)
-    with open(fileout, 'wb') as f:
-        w.write(f, px_map)
-
-
-def export_png_to_1bpp(filename, fileout=None):
-
-    if fileout == None:
-        fileout = os.path.splitext(filename)[0] + '.1bpp'
-
-    arguments = read_filename_arguments(filename)
-    image = png_to_1bpp(filename, **arguments)
-
-    to_file(fileout, image)
-
-def png_to_1bpp(filename, **kwargs):
-    image, kwargs = png_to_2bpp(filename, **kwargs)
-    return convert_2bpp_to_1bpp(image)
-
-
-def convert_to_2bpp(filenames=[]):
-    for filename in filenames:
-        filename, name, extension = try_decompress(filename)
-        if extension == '.1bpp':
-            export_1bpp_to_2bpp(filename)
-        elif extension == '.2bpp':
-            pass
-        elif extension == '.png':
-            export_png_to_2bpp(filename)
-        else:
-            raise Exception, "Don't know how to convert {} to 2bpp!".format(filename)
-
-def convert_to_1bpp(filenames=[]):
-    for filename in filenames:
-        filename, name, extension = try_decompress(filename)
-        if extension == '.1bpp':
-            pass
-        elif extension == '.2bpp':
-            export_2bpp_to_1bpp(filename)
-        elif extension == '.png':
-            export_png_to_1bpp(filename)
-        else:
-            raise Exception, "Don't know how to convert {} to 1bpp!".format(filename)
-
-def convert_to_png(filenames=[]):
-    for filename in filenames:
-        filename, name, extension = try_decompress(filename)
-        if extension == '.1bpp':
-            export_1bpp_to_png(filename)
-        elif extension == '.2bpp':
-            export_2bpp_to_png(filename)
-        elif extension == '.png':
-            pass
-        else:
-            raise Exception, "Don't know how to convert {} to png!".format(filename)
-
-def compress(filenames=[]):
-    for filename in filenames:
-        data = open(filename, 'rb').read()
-        lz_data = Compressed(data).output
-        to_file(filename + '.lz', lz_data)
-
-def decompress(filenames=[]):
-    for filename in filenames:
-        name, extension = os.path.splitext(filename)
-        lz_data = open(filename, 'rb').read()
-        data = Decompressed(lz_data).output
-        to_file(name, data)
-
-def try_decompress(filename):
-    """
-    Try to decompress a graphic when determining the filetype.
-    This skips the manual unlz step when attempting
-    to convert lz-compressed graphics to png.
-    """
-    name, extension = os.path.splitext(filename)
-    if extension == '.lz':
-        decompress([filename])
-        filename = name
-        name, extension = os.path.splitext(filename)
-    return filename, name, extension
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument('mode')
-    ap.add_argument('filenames', nargs='*')
-    args = ap.parse_args()
-
-    method = {
-        '2bpp': convert_to_2bpp,
-        '1bpp': convert_to_1bpp,
-        'png':  convert_to_png,
-        'lz':   compress,
-        'unlz': decompress,
-    }.get(args.mode, None)
-
-    if method == None:
-        raise Exception, "Unknown conversion method!"
-
-    method(args.filenames)
 
-if __name__ == "__main__":
-    main()
+from pokemontools import gfx, lz
+
+
+# Graphics with inverted tilemaps that aren't covered by filepath_rules.
+pics = [
+	'gfx/shrink1',
+	'gfx/shrink2',
+]
+
+def recursive_read(filename):
+	def recurse(filename_):
+		lines = []
+		for line in open(filename_):
+			if 'include "' in line.lower():
+				lines += recurse(line.split('"')[1])
+			else:
+				lines += [line]
+		return lines
+	lines = recurse(filename)
+	return ''.join(lines)
+
+base_stats = None
+def get_base_stats():
+	global base_stats
+	if not base_stats:
+		base_stats = recursive_read('data/base_stats.asm')
+	return base_stats
+
+def get_pokemon_dimensions(name):
+	try:
+		if name == 'egg':
+			return 5, 5
+		if name.startswith('annon_'):
+			name = 'annon'
+		base_stats = get_base_stats()
+		start = base_stats.find('\tdb ' + name.upper())
+		start = base_stats.find('\tdn ', start)
+		end = base_stats.find('\n', start)
+		line = base_stats[start:end].replace(',', ' ')
+		w, h = map(int, line.split()[1:3])
+		return w, h
+	except:
+		return 7, 7
+
+def filepath_rules(filepath):
+	"""Infer attributes of certain graphics by their location in the filesystem."""
+	args = {}
+
+	filedir, filename = os.path.split(filepath)
+	if filedir.startswith('./'):
+		filedir = filedir[2:]
+
+	name, ext = os.path.splitext(filename)
+	if ext == '.lz':
+		name, ext = os.path.splitext(name)
+
+	pokemon_name = ''
+
+	if 'gfx/pokemon/' in filedir:
+		pokemon_name = filedir.split('/')[-1]
+		if pokemon_name.startswith('annon_'):
+			index = filedir.find(pokemon_name)
+			if index != -1:
+				filedir = filedir[:index + len('annon')] + filedir[index + len('annon_a'):]
+		if name == 'front':
+			args['pal_file'] = os.path.join(filedir, 'normal.pal')
+			args['pic'] = True
+			args['animate'] = True
+		elif name == 'back':
+			args['pal_file'] = os.path.join(filedir, 'shiny.pal')
+			args['pic'] = True
+
+	elif 'gfx/trainers' in filedir:
+		args['pic'] = True
+
+	elif os.path.join(filedir, name) in pics:
+		args['pic'] = True
+
+	if args.get('pal_file'):
+		if os.path.exists(args['pal_file']):
+			args['palout'] = args['pal_file']
+		else:
+			del args['pal_file']
+
+	if args.get('pic'):
+		if ext == '.png':
+			w, h = gfx.png.Reader(filepath).asRGBA8()[:2]
+			w = min(w/8, h/8)
+			args['pic_dimensions'] = w, w
+		elif ext == '.2bpp':
+			if pokemon_name and name == 'front':
+				w, h = get_pokemon_dimensions(pokemon_name)
+				args['pic_dimensions'] = w, w
+			elif pokemon_name and name == 'back':
+				args['pic_dimensions'] = 6, 6
+			else:
+				args['pic_dimensions'] = 7, 7
+	return args
+
+
+def to_1bpp(filename, **kwargs):
+	name, ext = os.path.splitext(filename)
+	if   ext == '.1bpp': pass
+	elif ext == '.2bpp': gfx.export_2bpp_to_1bpp(filename, **kwargs)
+	elif ext == '.png':  gfx.export_png_to_1bpp(filename, **kwargs)
+	elif ext == '.lz':
+		decompress(filename, **kwargs)
+		to_1bpp(name, **kwargs)
+
+def to_2bpp(filename, **kwargs):
+	name, ext = os.path.splitext(filename)
+	if   ext == '.1bpp': gfx.export_1bpp_to_2bpp(filename, **kwargs)
+	elif ext == '.2bpp': pass
+	elif ext == '.png':  gfx.export_png_to_2bpp(filename, **kwargs)
+	elif ext == '.lz':
+		decompress(filename, **kwargs)
+		to_2bpp(name, **kwargs)
+
+def to_png(filename, **kwargs):
+	name, ext = os.path.splitext(filename)
+	if   ext == '.1bpp': gfx.export_1bpp_to_png(filename, **kwargs)
+	elif ext == '.2bpp': gfx.export_2bpp_to_png(filename, **kwargs)
+	elif ext == '.png':  pass
+	elif ext == '.lz':
+		decompress(filename, **kwargs)
+		to_png(name, **kwargs)
+
+def compress(filename, **kwargs):
+	data = open(filename, 'rb').read()
+	lz_data = lz.Compressed(data).output
+	open(filename + '.lz', 'wb').write(bytearray(lz_data))
+
+def decompress(filename, **kwargs):
+	lz_data = open(filename, 'rb').read()
+	data = lz.Decompressed(lz_data).output
+	name, ext = os.path.splitext(filename)
+	open(name, 'wb').write(bytearray(data))
+
+
+methods = {
+	'2bpp': to_2bpp,
+	'1bpp': to_1bpp,
+	'png':  to_png,
+	'lz':   compress,
+	'unlz': decompress,
+}
+
+def main(method_name, filenames=None):
+	if filenames is None: filenames = []
+	for filename in filenames:
+		args = filepath_rules(filename)
+		method = methods.get(method_name)
+		if method:
+			method(filename, **args)
+
+def get_args():
+	ap = argparse.ArgumentParser()
+	ap.add_argument('method_name')
+	ap.add_argument('filenames', nargs='*')
+	args = ap.parse_args()
+	return args
+
+if __name__ == '__main__':
+	main(**get_args().__dict__)
diff --git a/utils/__init__.py b/utils/pokemontools/__init__.py
index b64ec3b..b64ec3b 100644
--- a/utils/__init__.py
+++ b/utils/pokemontools/__init__.py
diff --git a/utils/pokemontools/gfx.py b/utils/pokemontools/gfx.py
new file mode 100644
index 0000000..80c84d3
--- /dev/null
+++ b/utils/pokemontools/gfx.py
@@ -0,0 +1,951 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import png
+from math import sqrt, floor, ceil
+import argparse
+import operator
+
+from lz import Compressed, Decompressed
+
+
+def split(list_, interval):
+    """
+    Split a list by length.
+    """
+    for i in xrange(0, len(list_), interval):
+        j = min(i + interval, len(list_))
+        yield list_[i:j]
+
+
+def hex_dump(data, length=0x10):
+    """
+    just use hexdump -C
+    """
+    margin = len('%x' % len(data))
+    output = []
+    address = 0
+    for line in split(data, length):
+        output += [
+            hex(address)[2:].zfill(margin) +
+            ' | ' +
+            ' '.join('%.2x' % byte for byte in line)
+        ]
+        address += length
+    return '\n'.join(output)
+
+
+def get_tiles(image):
+    """
+    Split a 2bpp image into 8x8 tiles.
+    """
+    return list(split(image, 0x10))
+
+def connect(tiles):
+    """
+    Combine 8x8 tiles into a 2bpp image.
+    """
+    return [byte for tile in tiles for byte in tile]
+
+def transpose(tiles, width=None):
+    """
+    Transpose a tile arrangement along line y=-x.
+
+      00 01 02 03 04 05     00 06 0c 12 18 1e
+      06 07 08 09 0a 0b     01 07 0d 13 19 1f
+      0c 0d 0e 0f 10 11 <-> 02 08 0e 14 1a 20
+      12 13 14 15 16 17     03 09 0f 15 1b 21
+      18 19 1a 1b 1c 1d     04 0a 10 16 1c 22
+      1e 1f 20 21 22 23     05 0b 11 17 1d 23
+
+      00 01 02 03     00 04 08
+      04 05 06 07 <-> 01 05 09
+      08 09 0a 0b     02 06 0a
+                      03 07 0b
+    """
+    if width == None:
+        width = int(sqrt(len(tiles))) # assume square image
+    tiles = sorted(enumerate(tiles), key= lambda (i, tile): i % width)
+    return [tile for i, tile in tiles]
+
+def transpose_tiles(image, width=None):
+    return connect(transpose(get_tiles(image), width))
+
+def interleave(tiles, width):
+    """
+      00 01 02 03 04 05     00 02 04 06 08 0a
+      06 07 08 09 0a 0b     01 03 05 07 09 0b
+      0c 0d 0e 0f 10 11 --> 0c 0e 10 12 14 16
+      12 13 14 15 16 17     0d 0f 11 13 15 17
+      18 19 1a 1b 1c 1d     18 1a 1c 1e 20 22
+      1e 1f 20 21 22 23     19 1b 1d 1f 21 23
+    """
+    interleaved = []
+    left, right = split(tiles[::2], width), split(tiles[1::2], width)
+    for l, r in zip(left, right):
+        interleaved += l + r
+    return interleaved
+
+def deinterleave(tiles, width):
+    """
+      00 02 04 06 08 0a     00 01 02 03 04 05 
+      01 03 05 07 09 0b     06 07 08 09 0a 0b
+      0c 0e 10 12 14 16 --> 0c 0d 0e 0f 10 11
+      0d 0f 11 13 15 17     12 13 14 15 16 17
+      18 1a 1c 1e 20 22     18 19 1a 1b 1c 1d
+      19 1b 1d 1f 21 23     1e 1f 20 21 22 23
+    """
+    deinterleaved = []
+    rows = list(split(tiles, width))
+    for left, right in zip(rows[::2], rows[1::2]):
+        for l, r in zip(left, right):
+            deinterleaved += [l, r]
+    return deinterleaved
+
+def interleave_tiles(image, width):
+    return connect(interleave(get_tiles(image), width))
+
+def deinterleave_tiles(image, width):
+    return connect(deinterleave(get_tiles(image), width))
+
+
+def condense_image_to_map(image, pic=0):
+    """
+    Reduce an image of adjacent frames to an image containing a base frame and any unrepeated tiles.
+    Returns the new image and the corresponding tilemap used to reconstruct the input image.
+
+    If <pic> is 0, ignore the concept of frames. This behavior might be better off as another function.
+    """
+    tiles = get_tiles(image)
+    new_tiles, tilemap = condense_tiles_to_map(tiles, pic)
+    new_image = connect(new_tiles)
+    return new_image, tilemap
+
+def condense_tiles_to_map(tiles, pic=0):
+    """
+    Reduce a sequence of tiles representing adjacent frames to a base frame and any unrepeated tiles.
+    Returns the new tiles and the corresponding tilemap used to reconstruct the input tile sequence.
+
+    If <pic> is 0, ignore the concept of frames. This behavior might be better off as another function.
+    """
+
+    # Leave the first frame intact for pics.
+    new_tiles = tiles[:pic]
+    tilemap   = range(pic)
+
+    for i, tile in enumerate(tiles[pic:]):
+        if tile not in new_tiles:
+            new_tiles.append(tile)
+
+        if pic:
+            # Match the first frame exactly where possible.
+            # This reduces the space needed to replace tiles in pic animations.
+            # For example, if a tile is repeated twice in the first frame,
+            # but at the same relative index as the second tile, use the second index.
+            # When creating a bitmask later, the second index would not require a replacement, but the first index would have.
+            pic_i = i % pic
+            if tile == new_tiles[pic_i]:
+                tilemap.append(pic_i)
+            else:
+                tilemap.append(new_tiles.index(tile))
+        else:
+            tilemap.append(new_tiles.index(tile))
+    return new_tiles, tilemap
+
+def test_condense_tiles_to_map():
+    test = condense_tiles_to_map(list('abcadbae'))
+    if test != (list('abcde'), [0, 1, 2, 0, 3, 1, 0, 4]):
+        raise Exception(test)
+    test = condense_tiles_to_map(list('abcadbae'), 2)
+    if test != (list('abcde'), [0, 1, 2, 0, 3, 1, 0, 4]):
+        raise Exception(test)
+    test = condense_tiles_to_map(list('abcadbae'), 4)
+    if test != (list('abcade'), [0, 1, 2, 3, 4, 1, 0, 5]):
+        raise Exception(test)
+    test = condense_tiles_to_map(list('abcadbea'), 4)
+    if test != (list('abcade'), [0, 1, 2, 3, 4, 1, 5, 3]):
+        raise Exception(test)
+
+
+def to_file(filename, data):
+    """
+    Apparently open(filename, 'wb').write(bytearray(data)) won't work.
+    """
+    file = open(filename, 'wb')
+    for byte in data:
+        file.write('%c' % byte)
+    file.close()
+
+
+def decompress_file(filein, fileout=None):
+    image = bytearray(open(filein).read())
+    de = Decompressed(image)
+
+    if fileout == None:
+        fileout = os.path.splitext(filein)[0]
+    to_file(fileout, de.output)
+
+
+def compress_file(filein, fileout=None):
+    image = bytearray(open(filein).read())
+    lz = Compressed(image)
+
+    if fileout == None:
+        fileout = filein + '.lz'
+    to_file(fileout, lz.output)
+
+
+def bin_to_rgb(word):
+    red   = word & 0b11111
+    word >>= 5
+    green = word & 0b11111
+    word >>= 5
+    blue  = word & 0b11111
+    return (red, green, blue)
+
+def convert_binary_pal_to_text_by_filename(filename):
+    pal = bytearray(open(filename).read())
+    return convert_binary_pal_to_text(pal)
+
+def convert_binary_pal_to_text(pal):
+    output = ''
+    words = [hi * 0x100 + lo for lo, hi in zip(pal[::2], pal[1::2])]
+    for word in words:
+        red, green, blue = ['%.2d' % c for c in bin_to_rgb(word)]
+        output += '\tRGB ' + ', '.join((red, green, blue))
+        output += '\n'
+    return output
+
+def read_rgb_macros(lines):
+    colors = []
+    for line in lines:
+        macro = line.split(" ")[0].strip()
+        if macro == 'RGB':
+            params = ' '.join(line.split(" ")[1:]).split(',')
+            red, green, blue = [int(v) for v in params]
+            colors += [[red, green, blue]]
+    return colors
+
+
+def rewrite_binary_pals_to_text(filenames):
+    for filename in filenames:
+        pal_text = convert_binary_pal_to_text_by_filename(filename)
+        with open(filename, 'w') as out:
+            out.write(pal_text)
+
+
+def flatten(planar):
+    """
+    Flatten planar 2bpp image data into a quaternary pixel map.
+    """
+    strips = []
+    for bottom, top in split(planar, 2):
+        bottom = bottom
+        top = top
+        strip = []
+        for i in xrange(7,-1,-1):
+            color = (
+                (bottom >> i & 1) +
+                (top *2 >> i & 2)
+            )
+            strip += [color]
+        strips += strip
+    return strips
+
+def to_lines(image, width):
+    """
+    Convert a tiled quaternary pixel map to lines of quaternary pixels.
+    """
+    tile_width = 8
+    tile_height = 8
+    num_columns = width / tile_width
+    height = len(image) / width
+
+    lines = []
+    for cur_line in xrange(height):
+        tile_row = cur_line / tile_height
+        line = []
+        for column in xrange(num_columns):
+            anchor = (
+                num_columns * tile_row * tile_width * tile_height +
+                column * tile_width * tile_height +
+                cur_line % tile_height * tile_width
+            )
+            line += image[anchor : anchor + tile_width]
+        lines += [line]
+    return lines
+
+
+def dmg2rgb(word):
+    """
+    For PNGs.
+    """
+    def shift(value):
+        while True:
+            yield value & (2**5 - 1)
+            value >>= 5
+    word = shift(word)
+    # distribution is less even w/ << 3
+    red, green, blue = [int(color * 8.25) for color in [word.next() for _ in xrange(3)]]
+    alpha = 255
+    return (red, green, blue, alpha)
+
+
+def rgb_to_dmg(color):
+    """
+    For PNGs.
+    """
+    word =  (color['r'] / 8)
+    word += (color['g'] / 8) << 5
+    word += (color['b'] / 8) << 10
+    return word
+
+
+def pal_to_png(filename):
+    """
+    Interpret a .pal file as a png palette.
+    """
+    with open(filename) as rgbs:
+        colors = read_rgb_macros(rgbs.readlines())
+    a = 255
+    palette = []
+    for color in colors:
+        # even distribution over 000-255
+        r, g, b = [int(hue * 8.25) for hue in color]
+        palette += [(r, g, b, a)]
+    white = (255,255,255,255)
+    black = (000,000,000,255)
+    if white not in palette and len(palette) < 4:
+        palette = [white] + palette
+    if black not in palette and len(palette) < 4:
+        palette = palette + [black]
+    return palette
+
+
+def png_to_rgb(palette):
+    """
+    Convert a png palette to rgb macros.
+    """
+    output = ''
+    for color in palette:
+        r, g, b = [color[c] / 8 for c in 'rgb']
+        output += '\tRGB ' + ', '.join(['%.2d' % hue for hue in (r, g, b)])
+        output += '\n'
+    return output
+
+
+def read_filename_arguments(filename):
+    """
+    Infer graphics conversion arguments given a filename.
+
+    Arguments are separated with '.'.
+    """
+    parsed_arguments = {}
+
+    int_arguments = {
+        'w': 'width',
+        'h': 'height',
+        't': 'tile_padding',
+    }
+    arguments = os.path.splitext(filename)[0].lstrip('.').split('.')[1:]
+    for argument in arguments:
+
+        # Check for integer arguments first (i.e. "w128").
+        arg   = argument[0]
+        param = argument[1:]
+        if param.isdigit():
+            arg = int_arguments.get(arg, False)
+            if arg:
+                parsed_arguments[arg] = int(param)
+
+        elif argument == 'arrange':
+            parsed_arguments['norepeat'] = True
+            parsed_arguments['tilemap']  = True
+
+        # Pic dimensions (i.e. "6x6").
+        elif 'x' in argument and any(map(str.isdigit, argument)):
+            w, h = argument.split('x')
+            if w.isdigit() and h.isdigit():
+                parsed_arguments['pic_dimensions'] = (int(w), int(h))
+
+        else:
+            parsed_arguments[argument] = True
+
+    return parsed_arguments
+
+
+def export_2bpp_to_png(filein, fileout=None, pal_file=None, height=0, width=0, tile_padding=0, pic_dimensions=None, **kwargs):
+
+    if fileout == None:
+        fileout = os.path.splitext(filein)[0] + '.png'
+
+    image = open(filein, 'rb').read()
+
+    arguments = {
+        'width': width,
+        'height': height,
+        'pal_file': pal_file,
+        'tile_padding': tile_padding,
+        'pic_dimensions': pic_dimensions,
+    }
+    arguments.update(read_filename_arguments(filein))
+
+    if pal_file == None:
+        if os.path.exists(os.path.splitext(fileout)[0]+'.pal'):
+            arguments['pal_file'] = os.path.splitext(fileout)[0]+'.pal'
+
+    arguments['is_tileset'] = 'tilesets' in filein
+    arguments['is_overworld'] = 'sprites' in filein
+    result = convert_2bpp_to_png(image, **arguments)
+    width, height, palette, greyscale, bitdepth, px_map = result
+
+    w = png.Writer(
+        width,
+        height,
+        palette=palette,
+        compression=9,
+        greyscale=greyscale,
+        bitdepth=bitdepth
+    )
+    with open(fileout, 'wb') as f:
+        w.write(f, px_map)
+
+
+def convert_2bpp_to_png(image, **kwargs):
+    """
+    Convert a planar 2bpp graphic to png.
+    """
+
+    image = bytearray(image)
+
+    pad_color = bytearray([0])
+
+    width          = kwargs.get('width', 0)
+    height         = kwargs.get('height', 0)
+    tile_padding   = kwargs.get('tile_padding', 0)
+    pic_dimensions = kwargs.get('pic_dimensions', None)
+    pal_file       = kwargs.get('pal_file', None)
+    interleave     = kwargs.get('interleave', False)
+
+    # Width must be specified to interleave.
+    if interleave and width:
+        image = interleave_tiles(image, width / 8)
+
+    # Pad the image by a given number of tiles if asked.
+    image += pad_color * 0x10 * tile_padding
+
+    # Some images are transposed in blocks.
+    if pic_dimensions:
+        w, h  = pic_dimensions
+        if not width: width = w * 8
+
+        pic_length = w * h * 0x10
+
+        trailing = len(image) % pic_length
+
+        pic = []
+        for i in xrange(0, len(image) - trailing, pic_length):
+            pic += transpose_tiles(image[i:i+pic_length], h)
+        image = bytearray(pic) + image[len(image) - trailing:]
+
+        # Pad out trailing lines.
+        image += pad_color * 0x10 * ((w - (len(image) / 0x10) % h) % w)
+
+    def px_length(img):
+        return len(img) * 4
+    def tile_length(img):
+        return len(img) * 4 / (8*8)
+
+    if width and height:
+        tile_width = width / 8
+        more_tile_padding = (tile_width - (tile_length(image) % tile_width or tile_width))
+        image += pad_color * 0x10 * more_tile_padding
+
+    elif width and not height:
+        tile_width = width / 8
+        more_tile_padding = (tile_width - (tile_length(image) % tile_width or tile_width))
+        image += pad_color * 0x10 * more_tile_padding
+        height = px_length(image) / width
+
+    elif height and not width:
+        tile_height = height / 8
+        more_tile_padding = (tile_height - (tile_length(image) % tile_height or tile_height))
+        image += pad_color * 0x10 * more_tile_padding
+        width = px_length(image) / height
+
+    # at least one dimension should be given
+    if width * height != px_length(image):
+        # look for possible combos of width/height that would form a rectangle
+        matches = []
+        # Height need not be divisible by 8, but width must.
+        # See pokered gfx/minimize_pic.1bpp.
+        for w in range(8, px_length(image) / 2 + 1, 8):
+            h = px_length(image) / w
+            if w * h == px_length(image):
+                matches += [(w, h)]
+        # go for the most square image
+        if len(matches):
+            width, height = sorted(matches, key= lambda (w, h): (h % 8 != 0, w + h))[0] # favor height
+        else:
+            raise Exception, 'Image can\'t be divided into tiles (%d px)!' % (px_length(image))
+        # correct tileset dimensions
+        if kwargs.get('is_tileset', False) and not (width * height // 8) % 128:
+            area = width * height
+            width = 128
+            height = area // width
+        # correct overworld dimensions
+        elif kwargs.get('is_overworld', False) and not (width * height // 8) % 16:
+            area = width * height
+            width = 16
+            height = area // width
+
+    # convert tiles to lines
+    lines = to_lines(flatten(image), width)
+
+    if pal_file == None:
+        palette   = None
+        greyscale = True
+        bitdepth  = 2
+        px_map    = [[3 - pixel for pixel in line] for line in lines]
+
+    else: # gbc color
+        palette   = pal_to_png(pal_file)
+        greyscale = False
+        bitdepth  = 8
+        px_map    = [[pixel for pixel in line] for line in lines]
+
+    return width, height, palette, greyscale, bitdepth, px_map
+
+
+def get_pic_animation(tmap, w, h):
+    """
+    Generate pic animation data from a combined tilemap of each frame.
+    """
+    frame_text = ''
+    bitmask_text = ''
+
+    frames = list(split(tmap, w * h))
+    base = frames.pop(0)
+    bitmasks = []
+
+    for i in xrange(len(frames)):
+        frame_text += '\tdw .frame{}\n'.format(i + 1)
+
+    for i, frame in enumerate(frames):
+        bitmask = map(operator.ne, frame, base)
+        if bitmask not in bitmasks:
+            bitmasks.append(bitmask)
+        which_bitmask = bitmasks.index(bitmask)
+
+        mask = iter(bitmask)
+        masked_frame = filter(lambda _: mask.next(), frame)
+
+        frame_text += '.frame{}\n'.format(i + 1)
+        frame_text += '\tdb ${:02x} ; bitmask\n'.format(which_bitmask)
+        if masked_frame:
+            frame_text += '\tdb {}\n'.format(', '.join(
+                map('${:02x}'.format, masked_frame)
+            ))
+
+    for i, bitmask in enumerate(bitmasks):
+        bitmask_text += '; {}\n'.format(i)
+        for byte in split(bitmask, 8):
+            byte = int(''.join(map(int.__repr__, reversed(byte))), 2)
+            bitmask_text += '\tdb %{:08b}\n'.format(byte)
+
+    return frame_text, bitmask_text
+
+
+def export_png_to_2bpp(filein, fileout=None, palout=None, **kwargs):
+
+    arguments = {
+        'tile_padding': 0,
+        'pic_dimensions': None,
+        'animate': False,
+        'stupid_bitmask_hack': [],
+    }
+    arguments.update(kwargs)
+    arguments.update(read_filename_arguments(filein))
+
+    image, arguments = png_to_2bpp(filein, **arguments)
+
+    if fileout == None:
+        fileout = os.path.splitext(filein)[0] + '.2bpp'
+    to_file(fileout, image)
+
+    tmap = arguments.get('tmap')
+
+    if tmap != None and arguments['animate'] and arguments['pic_dimensions']:
+        # Generate pic animation data.
+        frame_text, bitmask_text = get_pic_animation(tmap, *arguments['pic_dimensions'])
+
+        frames_path = os.path.join(os.path.split(fileout)[0], 'frames.asm')
+        with open(frames_path, 'w') as out:
+            out.write(frame_text)
+
+        bitmask_path = os.path.join(os.path.split(fileout)[0], 'bitmask.asm')
+
+        # The following Pokemon have a bitmask dummied out.
+        for exception in arguments['stupid_bitmask_hack']:
+           if exception in bitmask_path:
+                bitmasks = bitmask_text.split(';')
+                bitmasks[-1] = bitmasks[-1].replace('1', '0')
+                bitmask_text = ';'.join(bitmasks)
+
+        with open(bitmask_path, 'w') as out:
+            out.write(bitmask_text)
+
+    elif tmap != None and arguments.get('tilemap', False):
+        tilemap_path = os.path.splitext(fileout)[0] + '.tilemap'
+        to_file(tilemap_path, tmap)
+
+    palette = arguments.get('palette')
+    if palout == None:
+        palout = os.path.splitext(fileout)[0] + '.pal'
+    export_palette(palette, palout)
+
+
+def get_image_padding(width, height, wstep=8, hstep=8):
+
+    padding = {
+        'left':   0,
+        'right':  0,
+        'top':    0,
+        'bottom': 0,
+    }
+
+    if width % wstep and width >= wstep:
+       pad = float(width % wstep) / 2
+       padding['left']   = int(ceil(pad))
+       padding['right']  = int(floor(pad))
+
+    if height % hstep and height >= hstep:
+       pad = float(height % hstep) / 2
+       padding['top']    = int(ceil(pad))
+       padding['bottom'] = int(floor(pad))
+
+    return padding
+
+
+def png_to_2bpp(filein, **kwargs):
+    """
+    Convert a png image to planar 2bpp.
+    """
+
+    arguments = {
+        'tile_padding': 0,
+        'pic_dimensions': False,
+        'interleave': False,
+        'norepeat': False,
+        'tilemap': False,
+    }
+    arguments.update(kwargs)
+
+    if type(filein) is str:
+        filein = open(filein, 'rb')
+
+    assert type(filein) is file
+
+    width, height, rgba, info = png.Reader(filein).asRGBA8()
+
+    # png.Reader returns flat pixel data. Nested is easier to work with
+    len_px  = len('rgba')
+    image   = []
+    palette = []
+    for line in rgba:
+        newline = []
+        for px in xrange(0, len(line), len_px):
+            color = dict(zip('rgba', line[px:px+len_px]))
+            if color not in palette:
+                if len(palette) < 4:
+                    palette += [color]
+                else:
+                    # TODO Find the nearest match
+                    print 'WARNING: %s: Color %s truncated to' % (filein, color),
+                    color = sorted(palette, key=lambda x: sum(x.values()))[0]
+                    print color
+            newline += [color]
+        image += [newline]
+
+    assert len(palette) <= 4, '%s: palette should be 4 colors, is really %d (%s)' % (filein, len(palette), palette)
+
+    # Pad out smaller palettes with greyscale colors
+    greyscale = {
+        'black': { 'r': 0x00, 'g': 0x00, 'b': 0x00, 'a': 0xff },
+        'grey':  { 'r': 0x55, 'g': 0x55, 'b': 0x55, 'a': 0xff },
+        'gray':  { 'r': 0xaa, 'g': 0xaa, 'b': 0xaa, 'a': 0xff },
+        'white': { 'r': 0xff, 'g': 0xff, 'b': 0xff, 'a': 0xff },
+    }
+    preference = 'white', 'black', 'grey', 'gray'
+    for hue in map(greyscale.get, preference):
+        if len(palette) >= 4:
+            break
+        if hue not in palette:
+            palette += [hue]
+
+    palette.sort(key=lambda x: sum(x.values()))
+
+    # Game Boy palette order
+    palette.reverse()
+
+    # Map pixels to quaternary color ids
+    padding = get_image_padding(width, height)
+    width += padding['left'] + padding['right']
+    height += padding['top'] + padding['bottom']
+    pad = bytearray([0])
+
+    qmap = []
+    qmap += pad * width * padding['top']
+    for line in image:
+        qmap += pad * padding['left']
+        for color in line:
+            qmap += [palette.index(color)]
+        qmap += pad * padding['right']
+    qmap += pad * width * padding['bottom']
+
+    # Graphics are stored in tiles instead of lines
+    tile_width  = 8
+    tile_height = 8
+    num_columns = max(width, tile_width) / tile_width
+    num_rows = max(height, tile_height) / tile_height
+    image = []
+
+    for row in xrange(num_rows):
+        for column in xrange(num_columns):
+
+            # Split it up into strips to convert to planar data
+            for strip in xrange(min(tile_height, height)):
+                anchor = (
+                    row * num_columns * tile_width * tile_height +
+                    column * tile_width +
+                    strip * width
+                )
+                line = qmap[anchor : anchor + tile_width]
+                bottom, top = 0, 0
+                for bit, quad in enumerate(line):
+                    bottom += (quad & 1) << (7 - bit)
+                    top += (quad /2 & 1) << (7 - bit)
+                image += [bottom, top]
+
+    dim = arguments['pic_dimensions']
+    if dim:
+        if type(dim) in (tuple, list):
+            w, h = dim
+        else:
+            # infer dimensions based on width.
+            w = width / tile_width
+            h = height / tile_height
+            if h % w == 0:
+                h = w
+
+        tiles = get_tiles(image)
+        pic_length = w * h
+        tile_width = width / 8
+        trailing = len(tiles) % pic_length
+        new_image = []
+        for block in xrange(len(tiles) / pic_length):
+            offset = (h * tile_width) * ((block * w) / tile_width) + ((block * w) % tile_width)
+            pic = []
+            for row in xrange(h):
+                index = offset + (row * tile_width)
+                pic += tiles[index:index + w]
+            new_image += transpose(pic, w)
+        new_image += tiles[len(tiles) - trailing:]
+        image = connect(new_image)
+
+    # Remove any tile padding used to make the png rectangular.
+    image = image[:len(image) - arguments['tile_padding'] * 0x10]
+
+    tmap = None
+
+    if arguments['interleave']:
+        image = deinterleave_tiles(image, num_columns)
+
+    if arguments['pic_dimensions']:
+        image, tmap = condense_image_to_map(image, w * h)
+    elif arguments['norepeat']:
+        image, tmap = condense_image_to_map(image)
+        if not arguments['tilemap']:
+            tmap = None
+
+    arguments.update({ 'palette': palette, 'tmap': tmap, })
+
+    return image, arguments
+
+
+def export_palette(palette, filename):
+    """
+    Export a palette from png to rgb macros in a .pal file.
+    """
+
+    if os.path.exists(filename):
+
+        # Pic palettes are 2 colors (black/white are added later).
+        with open(filename) as rgbs:
+            colors = read_rgb_macros(rgbs.readlines())
+
+        if len(colors) == 2:
+            palette = palette[1:3]
+
+        text = png_to_rgb(palette)
+        with open(filename, 'w') as out:
+            out.write(text)
+
+
+def png_to_lz(filein):
+
+    name = os.path.splitext(filein)[0]
+
+    export_png_to_2bpp(filein)
+    image = open(name+'.2bpp', 'rb').read()
+    to_file(name+'.2bpp'+'.lz', Compressed(image).output)
+
+
+def convert_2bpp_to_1bpp(data):
+    """
+    Convert planar 2bpp image data to 1bpp. Assume images are two colors.
+    """
+    return data[::2]
+
+def convert_1bpp_to_2bpp(data):
+    """
+    Convert 1bpp image data to planar 2bpp (black/white).
+    """
+    output = []
+    for i in data:
+        output += [i, i]
+    return output
+
+
+def export_2bpp_to_1bpp(filename):
+    name, extension = os.path.splitext(filename)
+    image = open(filename, 'rb').read()
+    image = convert_2bpp_to_1bpp(image)
+    to_file(name + '.1bpp', image)
+
+def export_1bpp_to_2bpp(filename):
+    name, extension = os.path.splitext(filename)
+    image = open(filename, 'rb').read()
+    image = convert_1bpp_to_2bpp(image)
+    to_file(name + '.2bpp', image)
+
+
+def export_1bpp_to_png(filename, fileout=None):
+
+    if fileout == None:
+        fileout = os.path.splitext(filename)[0] + '.png'
+
+    arguments = read_filename_arguments(filename)
+
+    image = open(filename, 'rb').read()
+    image = convert_1bpp_to_2bpp(image)
+
+    result = convert_2bpp_to_png(image, **arguments)
+    width, height, palette, greyscale, bitdepth, px_map = result
+
+    w = png.Writer(width, height, palette=palette, compression=9, greyscale=greyscale, bitdepth=bitdepth)
+    with open(fileout, 'wb') as f:
+        w.write(f, px_map)
+
+
+def export_png_to_1bpp(filename, fileout=None):
+
+    if fileout == None:
+        fileout = os.path.splitext(filename)[0] + '.1bpp'
+
+    arguments = read_filename_arguments(filename)
+    image = png_to_1bpp(filename, **arguments)
+
+    to_file(fileout, image)
+
+def png_to_1bpp(filename, **kwargs):
+    image, kwargs = png_to_2bpp(filename, **kwargs)
+    return convert_2bpp_to_1bpp(image)
+
+
+def convert_to_2bpp(filenames=[]):
+    for filename in filenames:
+        filename, name, extension = try_decompress(filename)
+        if extension == '.1bpp':
+            export_1bpp_to_2bpp(filename)
+        elif extension == '.2bpp':
+            pass
+        elif extension == '.png':
+            export_png_to_2bpp(filename)
+        else:
+            raise Exception, "Don't know how to convert {} to 2bpp!".format(filename)
+
+def convert_to_1bpp(filenames=[]):
+    for filename in filenames:
+        filename, name, extension = try_decompress(filename)
+        if extension == '.1bpp':
+            pass
+        elif extension == '.2bpp':
+            export_2bpp_to_1bpp(filename)
+        elif extension == '.png':
+            export_png_to_1bpp(filename)
+        else:
+            raise Exception, "Don't know how to convert {} to 1bpp!".format(filename)
+
+def convert_to_png(filenames=[]):
+    for filename in filenames:
+        filename, name, extension = try_decompress(filename)
+        if extension == '.1bpp':
+            export_1bpp_to_png(filename)
+        elif extension == '.2bpp':
+            export_2bpp_to_png(filename)
+        elif extension == '.png':
+            pass
+        else:
+            raise Exception, "Don't know how to convert {} to png!".format(filename)
+
+def compress(filenames=[]):
+    for filename in filenames:
+        data = open(filename, 'rb').read()
+        lz_data = Compressed(data).output
+        to_file(filename + '.lz', lz_data)
+
+def decompress(filenames=[]):
+    for filename in filenames:
+        name, extension = os.path.splitext(filename)
+        lz_data = open(filename, 'rb').read()
+        data = Decompressed(lz_data).output
+        to_file(name, data)
+
+def try_decompress(filename):
+    """
+    Try to decompress a graphic when determining the filetype.
+    This skips the manual unlz step when attempting
+    to convert lz-compressed graphics to png.
+    """
+    name, extension = os.path.splitext(filename)
+    if extension == '.lz':
+        decompress([filename])
+        filename = name
+        name, extension = os.path.splitext(filename)
+    return filename, name, extension
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('mode')
+    ap.add_argument('filenames', nargs='*')
+    args = ap.parse_args()
+
+    method = {
+        '2bpp': convert_to_2bpp,
+        '1bpp': convert_to_1bpp,
+        'png':  convert_to_png,
+        'lz':   compress,
+        'unlz': decompress,
+    }.get(args.mode, None)
+
+    if method == None:
+        raise Exception, "Unknown conversion method!"
+
+    method(args.filenames)
+
+if __name__ == "__main__":
+    main()
diff --git a/utils/lz.py b/utils/pokemontools/lz.py
index aef5c64..aef5c64 100644
--- a/utils/lz.py
+++ b/utils/pokemontools/lz.py
diff --git a/utils/png.py b/utils/pokemontools/png.py
index db6da12..db6da12 100644
--- a/utils/png.py
+++ b/utils/pokemontools/png.py