diff --git a/scripts/codemapd3.py b/scripts/codemapd3.py
new file mode 100755
index 00000000..a277ae02
--- /dev/null
+++ b/scripts/codemapd3.py
@@ -0,0 +1,2929 @@
+#!/usr/bin/env python3
+#
+# Inspired by d3 and brendangregg's flamegraph svg:
+# - https://d3js.org
+# - https://github.com/brendangregg/FlameGraph
+#
+
+# prevent local imports
+if __name__ == "__main__":
+    __import__('sys').path.pop(0)
+
+import bisect
+import collections as co
+import csv
+import fnmatch
+import itertools as it
+import json
+import math as mt
+import re
+import shlex
+import shutil
+import subprocess as sp
+
+
+# some nicer colors borrowed from Seaborn
+# note these include a non-opaque alpha
+COLORS = [
+    '#7995c4', # was '#4c72b0bf', # blue
+    '#e6a37d', # was '#dd8452bf', # orange
+    '#80be8e', # was '#55a868bf', # green
+    '#d37a7d', # was '#c44e52bf', # red
+    '#a195c6', # was '#8172b3bf', # purple
+    '#ae9a88', # was '#937860bf', # brown
+    '#e3a8d2', # was '#da8bc3bf', # pink
+    '#a9a9a9', # was '#8c8c8cbf', # gray
+    '#d9cb97', # was '#ccb974bf', # yellow
+    '#8bc8da', # was '#64b5cdbf', # cyan
+]
+COLORS_DARK = [
+    '#7997b7', # was '#a1c9f4bf', # blue
+    '#bf8761', # was '#ffb482bf', # orange
+    '#6aac79', # was '#8de5a1bf', # green
+    '#bf7774', # was '#ff9f9bbf', # red
+    '#9c8cbf', # was '#d0bbffbf', # purple
+    '#a68c74', # was '#debb9bbf', # brown
+    '#bb84ab', # was '#fab0e4bf', # pink
+    '#9b9b9b', # was '#cfcfcfbf', # gray
+    '#bfbe7a', # was '#fffea3bf', # yellow
+    '#8bb5b4', # was '#b9f2f0bf', # cyan
+]
+
+WIDTH = 750
+HEIGHT = 350
+FONT = ['sans-serif']
+FONT_SIZE = 10
+
+CODE_PATH = ['./scripts/code.py']
+STACK_PATH = ['./scripts/stack.py']
+CTX_PATH = ['./scripts/ctx.py']
+
+
+def openio(path, mode='r', buffering=-1):
+    # allow '-' for stdin/stdout
+    if path == '-':
+        if 'r' in mode:
+            return os.fdopen(os.dup(sys.stdin.fileno()), mode, buffering)
+        else:
+            return os.fdopen(os.dup(sys.stdout.fileno()), mode, buffering)
+    else:
+        return open(path, mode, buffering)
+
+def iself(path):
+    # check for an elf file's magic string (\x7fELF)
+    with open(path, 'rb') as f:
+        return f.read(4) == b'\x7fELF'
+
+
+# TODO adopt this default scheme elsewhere?
+# parse different data representations
+def dat(x, *args):
+    try:
+        # allow the first part of an a/b fraction
+        if '/' in x:
+            x, _ = x.split('/', 1)
+
+        # first try as int
+        try:
+            return int(x, 0)
+        except ValueError:
+            pass
+
+        # then try as float
+        try:
+            return float(x)
+        except ValueError:
+            pass
+
+        # else give up
+        raise ValueError("invalid dat %r" % x)
+
+    # default on error?
+    except ValueError as e:
+        if args:
+            return args[0]
+        else:
+            raise
+
+def collect(csv_paths, defines=[]):
+    # collect results from CSV files
+    fields = []
+    results = []
+    for path in csv_paths:
+        try:
+            with openio(path) as f:
+                reader = csv.DictReader(f, restval='')
+                fields.extend(
+                        k for k in reader.fieldnames
+                            if k not in fields)
+                for r in reader:
+                    # filter by matching defines
+                    if not all(k in r and r[k] in vs for k, vs in defines):
+                        continue
+
+                    results.append(r)
+        except FileNotFoundError:
+            pass
+
+    return fields, results
+
+def fold(results, by=None, fields=None, defines=[]):
+    # filter by matching defines
+    if defines:
+        results_ = []
+        for r in results:
+            if all(k in r and r[k] in vs for k, vs in defines):
+                results_.append(r)
+        results = results_
+
+    if by:
+        # find all 'by' values
+        keys = set()
+        for r in results:
+            keys.add(tuple(r.get(k, '') for k in by))
+        keys = sorted(keys)
+
+    # collect datasets
+    datasets = co.OrderedDict()
+    dataattrs = co.OrderedDict()
+    for key in (keys if by else [()]):
+        for field in fields:
+            # organize by 'by' and field
+            dataset = []
+            dataattr = {}
+            for r in results:
+                # filter by 'by'
+                if by and not all(
+                        k in r and r[k] == v
+                            for k, v in zip(by, key)):
+                    continue
+
+                # find field
+                if field is not None:
+                    if field not in r:
+                        continue
+                    try:
+                        v = dat(r[field])
+                    except ValueError:
+                        continue
+                else:
+                    v = None
+
+                # do _not_ sum v here, it's tempting but risks
+                # incorrect and misleading results
+                dataset.append(v)
+
+                # include all fields in dataattrs in case we use
+                # them for % modifiers
+                dataattr.update(r)
+
+            # hide 'field' if there is only one field
+            key_ = key
+            if len(fields or []) > 1 or not key_:
+                key_ += (field,)
+            datasets[key_] = dataset
+            dataattrs[key_] = dataattr
+
+    return datasets, dataattrs
+
+# a representation of optionally key-mapped attrs
+class Attr:
+    def __init__(self, attrs, *,
+            defaults=None):
+        # include defaults?
+        if (defaults is not None
+                and not any(
+                    not isinstance(attr, tuple)
+                        or attr[0] in {None, (), ('*',)}
+                    for attr in (attrs or []))):
+            attrs = defaults + (attrs or [])
+
+        # normalize
+        self.attrs = []
+        self.keyed = co.OrderedDict()
+        for attr in (attrs or []):
+            if not isinstance(attr, tuple):
+                attr = ((), attr)
+            elif attr[0] in {None, (), ('*',)}:
+                attr = ((), attr[1])
+
+            self.attrs.append(attr)
+            if attr[0] not in self.keyed:
+                self.keyed[attr[0]] = []
+            self.keyed[attr[0]].append(attr[1])
+
+    def __repr__(self):
+        return 'Attr(%r)' % [
+                (','.join(attr[0]), attr[1])
+                for attr in self.attrs]
+
+    def __iter__(self):
+        return it.cycle(self.keyed[()])
+
+    def __bool__(self):
+        return bool(self.attrs)
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            if len(key) > 0 and not isinstance(key[0], str):
+                i, key = key
+            else:
+                i, key = 0, key
+        else:
+            i, key = key, ()
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            # cycle based on index
+            return best[1][i % len(best[1])]
+
+        return None
+
+    def __contains__(self, key):
+        return self.__getitem__(key) is not None
+
+    # a key function for sorting by key order
+    def key(self, key):
+        # allow key to be a tuple to make sorting dicts easier
+        if (isinstance(key, tuple)
+                and len(key) >= 1
+                and isinstance(key[0], tuple)):
+            key = key[0]
+
+        best = None
+        for i, ks in enumerate(self.keyed.keys()):
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and (not k or key[j] == k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, i)
+
+        if best is not None:
+            return best[1]
+
+        return len(self.keyed)
+
+# TODO adopt this elsewhere (try_dat -> default)
+# parse %-escaped strings
+def punescape(s, attrs=None):
+    if attrs is None:
+        attrs = {}
+    if isinstance(attrs, dict):
+        attrs_ = attrs
+        attrs = lambda k: attrs_[k]
+
+    pattern = re.compile(
+        '%[%n]'
+            '|' '%x..'
+            '|' '%u....'
+            '|' '%U........'
+            '|' '%\((?P<field>[^)]*)\)'
+                '(?P<format>[+\- #0-9\.]*[sdboxXfFeEgG])')
+    def unescape(m):
+        if m.group()[1] == '%': return '%'
+        elif m.group()[1] == 'n': return '\n'
+        elif m.group()[1] == 'x': return chr(int(m.group()[2:], 16))
+        elif m.group()[1] == 'u': return chr(int(m.group()[2:], 16))
+        elif m.group()[1] == 'U': return chr(int(m.group()[2:], 16))
+        elif m.group()[1] == '(':
+            try:
+                v = attrs(m.group('field'))
+            except KeyError:
+                return m.group()
+            f = m.group('format')
+            if f[-1] in 'dboxX':
+                if isinstance(v, str):
+                    v = dat(v, 0)
+                v = int(v)
+            elif f[-1] in 'fFeEgG':
+                if isinstance(v, str):
+                    v = dat(v, 0)
+                v = float(v)
+            else:
+                f = ('<' if '-' in f else '>') + f.replace('-', '')
+                v = str(v)
+            # note we need Python's new format syntax for binary
+            return ('{:%s}' % f).format(v)
+        else: assert False
+    return re.sub(pattern, unescape, s)
+
+
+
+# a type to represent tiles
+class Tile:
+    def __init__(self, key, children,
+            x=None, y=None, width=None, height=None, *,
+            depth=None,
+            attrs=None,
+            label=None,
+            color=None):
+        self.key = key
+        if isinstance(children, list):
+            self.children = children
+            self.value = sum(c.value for c in children)
+        else:
+            self.children = []
+            self.value = children
+
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self.depth = depth
+        self.attrs = attrs
+        self.label = label
+        self.color = color
+
+    def __repr__(self):
+        return 'Tile(%r, %r, %r, %r, %r, %r)' % (
+                ','.join(self.key), self.value,
+                self.x, self.y, self.width, self.height)
+
+    # recursively build heirarchy
+    @staticmethod
+    def merge(tiles, prefix=()):
+        # organize by 'by' field
+        tiles_ = co.OrderedDict()
+        for t in tiles:
+            if len(prefix)+1 >= len(t.key):
+                tiles_[t.key] = t
+            else:
+                key = prefix + (t.key[len(prefix)],)
+                if key not in tiles_:
+                    tiles_[key] = []
+                tiles_[key].append(t)
+
+        tiles__ = []
+        for key, t in tiles_.items():
+            if isinstance(t, Tile):
+                tiles__.append(t)
+            else:
+                tiles__.append(Tile.merge(t, key))
+        tiles_ = tiles__
+
+        return Tile(prefix, tiles_, depth=len(prefix))
+
+    def __lt__(self, other):
+        return self.value < other.value
+
+    # recursive traversals
+    def tiles(self):
+        yield self
+        for child in self.children:
+            yield from child.tiles()
+
+    def leaves(self):
+        for t in self.tiles():
+            if not t.children:
+                yield t
+
+    # sort recursively
+    def sort(self):
+        self.children.sort(reverse=True)
+        for t in self.children:
+            t.sort()
+
+    # recursive align to int boundaries
+    def align(self):
+        # this extra +0.1 and using points instead of width/height is
+        # to help minimize rounding errors
+        x0 = int(self.x+0.1)
+        y0 = int(self.y+0.1)
+        x1 = int(self.x+self.width+0.1)
+        y1 = int(self.y+self.height+0.1)
+        self.x = x0
+        self.y = y0
+        self.width = x1 - x0
+        self.height = y1 - y0
+
+        # recurse
+        for t in self.children:
+            t.align()
+
+    # return some interesting info about these tiles
+    def stat(self):
+        leaves = list(self.leaves())
+        mean = self.value / max(len(leaves), 1)
+        stddev = mt.sqrt(sum((t.value - mean)**2 for t in leaves)
+                / max(len(leaves), 1))
+        min_ = min((t.value for t in leaves), default=0)
+        max_ = max((t.value for t in leaves), default=0)
+        return {
+            'total': self.value,
+            'mean': mean,
+            'stddev': stddev,
+            'min': min_,
+            'max': max_,
+        }
+
+
+# bounded division, limits result to dividend, useful for avoiding
+# divide-by-zero issues
+def bdiv(a, b):
+    return a / max(b, 1)
+
+# our partitioning schemes
+
+def partition_binary(children, total, x, y, width, height):
+    sums = [0]
+    for t in children:
+        sums.append(sums[-1] + t.value)
+
+    # recursively partition into a roughly weight-balanced binary tree
+    def partition_(i, j, value, x, y, width, height):
+        # no child? guess we're done
+        if i == j:
+            return
+        # single child? assign the partition
+        elif i == j-1:
+            children[i].x = x
+            children[i].y = y
+            children[i].width = width
+            children[i].height = height
+            return
+
+        # binary search to find best split index
+        target = sums[i] + (value / 2)
+        k = bisect.bisect(sums, target, i+1, j-1)
+
+        # nudge split index if it results in less error
+        if k > i+1 and (sums[k] - target) > (target - sums[k-1]):
+            k -= 1
+
+        l = sums[k] - sums[i]
+        r = value - l
+
+        # split horizontally?
+        if width > height:
+            dx = bdiv(sums[k] - sums[i], value) * width
+            partition_(i, k, l, x, y, dx, height)
+            partition_(k, j, r, x+dx, y, width-dx, height)
+
+        # split vertically?
+        else:
+            dy = bdiv(sums[k] - sums[i], value) * height
+            partition_(i, k, l, x, y, width, dy)
+            partition_(k, j, r, x, y+dy, width, height-dy)
+
+    partition_(0, len(children), total, x, y, width, height)
+
+def partition_slice(children, total, x, y, width, height):
+    # give each child a slice
+    x_ = x
+    for t in children:
+        t.x = x_
+        t.y = y
+        t.width = bdiv(t.value, total) * width
+        t.height = height
+
+        x_ += t.width
+
+def partition_dice(children, total, x, y, width, height):
+    # give each child a slice
+    y_ = y
+    for t in children:
+        t.x = x
+        t.y = y_
+        t.width = width
+        t.height = bdiv(t.value, total) * height
+
+        y_ += t.height
+
+def partition_squarify(children, total, x, y, width, height, *,
+        aspect_ratio=(1,1)):
+    # this algorithm is described here:
+    # https://www.win.tue.nl/~vanwijk/stm.pdf
+    i = 0
+    x_ = x
+    y_ = y
+    total_ = total
+    width_ = width
+    height_ = height
+    # note we don't really care about width vs height until
+    # actually slicing
+    ratio = max(bdiv(aspect_ratio[0], aspect_ratio[1]),
+            bdiv(aspect_ratio[1], aspect_ratio[0]))
+
+    while i < len(children):
+        # calculate initial aspect ratio
+        sum_ = children[i].value
+        min_ = children[i].value
+        max_ = children[i].value
+        w = total_ * bdiv(ratio,
+                max(bdiv(width_, height_), bdiv(height_, width_)))
+        ratio_ = max(bdiv(max_*w, sum_**2), bdiv(sum_**2, min_*w))
+
+        # keep adding children to this row/col until it starts to hurt
+        # our aspect ratio
+        j = i + 1
+        while j < len(children):
+            sum__ = sum_ + children[j].value
+            min__ = min(min_, children[j].value)
+            max__ = max(max_, children[j].value)
+            ratio__ = max(bdiv(max__*w, sum__**2), bdiv(sum__**2, min__*w))
+            if ratio__ > ratio_:
+                break
+
+            sum_ = sum__
+            min_ = min__
+            max_ = max__
+            ratio_ = ratio__
+            j += 1
+
+        # vertical col? dice horizontally?
+        if width_ > height_:
+            dx = bdiv(sum_, total_) * width_
+            partition_dice(children[i:j], sum_, x_, y_, dx, height_)
+            x_ += dx
+            width_ -= dx
+
+        # horizontal row? slice vertically?
+        else:
+            dy = bdiv(sum_, total_) * height_
+            partition_slice(children[i:j], sum_, x_, y_, width_, dy)
+            y_ += dy
+            height_ -= dy
+
+        # start partitioning the other direction
+        total_ -= sum_
+        i = j
+
+
+def collect_code(obj_paths, *,
+        code_path=CODE_PATH,
+        **args):
+    # note code-path may contain extra args
+    cmd = code_path + ['-O-'] + obj_paths
+    if args.get('verbose'):
+        print(' '.join(shlex.quote(c) for c in cmd))
+    proc = sp.Popen(cmd,
+            stdout=sp.PIPE,
+            universal_newlines=True,
+            errors='replace',
+            close_fds=False)
+    code = json.load(proc.stdout)
+    proc.wait()
+    if proc.returncode != 0:
+        raise sp.CalledProcessError(proc.returncode, proc.args)
+
+    return code
+
+def collect_stack(ci_paths, *,
+        stack_path=STACK_PATH,
+        **args):
+    # note stack-path may contain extra args
+    cmd = stack_path + ['-O-', '--depth=2'] + ci_paths
+    if args.get('verbose'):
+        print(' '.join(shlex.quote(c) for c in cmd))
+    proc = sp.Popen(cmd,
+            stdout=sp.PIPE,
+            universal_newlines=True,
+            errors='replace',
+            close_fds=False)
+    stack = json.load(proc.stdout)
+    proc.wait()
+    if proc.returncode != 0:
+        raise sp.CalledProcessError(proc.returncode, proc.args)
+
+    return stack
+
+def collect_ctx(obj_paths, *,
+        ctx_path=CTX_PATH,
+        **args):
+    # note stack-path may contain extra args
+    cmd = ctx_path + ['-O-', '--depth=2', '--internal'] + obj_paths
+    if args.get('verbose'):
+        print(' '.join(shlex.quote(c) for c in cmd))
+    proc = sp.Popen(cmd,
+            stdout=sp.PIPE,
+            universal_newlines=True,
+            errors='replace',
+            close_fds=False)
+    ctx = json.load(proc.stdout)
+    proc.wait()
+    if proc.returncode != 0:
+        raise sp.CalledProcessError(proc.returncode, proc.args)
+
+    return ctx
+
+
+def main(paths, output, *,
+        namespace_depth=2,
+        quiet=False,
+        labels=[],
+        colors=[],
+        width=None,
+        height=None,
+        no_header=False,
+        no_mode=False,
+        no_stack=False,
+        stack_ratio=1/5,
+        no_ctx=False,
+        no_frames=False,
+        no_javascript=False,
+        mode_callgraph=False,
+        mode_deepest=False,
+        mode_callees=False,
+        mode_callers=False,
+        to_scale=None,
+        aspect_ratio=(1,1),
+        title=None,
+        padding=1,
+        no_label=False,
+        tiny=False,
+        nested=False,
+        dark=False,
+        font=FONT,
+        font_size=FONT_SIZE,
+        background=None,
+        **args):
+    # tiny mode?
+    if tiny:
+        if to_scale is None:
+            to_scale = 1
+        no_header = True
+        no_label = True
+        no_stack = True
+        no_javascript = True
+
+    # default to all modes
+    if (not mode_callgraph
+            and not mode_deepest
+            and not mode_callees
+            and not mode_callers):
+        mode_callgraph = True
+        mode_deepest = True
+        mode_callees = True
+        mode_callers = True
+
+    # what colors/labels to use?
+    colors_ = Attr(colors, defaults=COLORS_DARK if dark else COLORS)
+
+    labels_ = Attr(labels)
+
+    if background is not None:
+        background_ = background
+    elif dark:
+        background_ = '#000000'
+    else:
+        background_ = '#ffffff'
+
+    # figure out width/height
+    if width is not None:
+        width_ = width
+    else:
+        width_ = WIDTH
+
+    if height is not None:
+        height_ = height
+    else:
+        height_ = HEIGHT
+
+    # try to parse files as CSV/JSON
+    results = []
+    try:
+        # if any file starts with elf magic (\x7fELF), assume input is
+        # elf/callgraph files
+        fs = []
+        for path in paths:
+            f = openio(path)
+            if f.buffer.peek(4)[:4] == b'\x7fELF':
+                for f_ in fs:
+                    f_.close()
+                raise StopIteration()
+            fs.append(f)
+
+        for f in fs:
+            with f:
+                # TODO adopt this rename (json -> is_json) in other scripts
+                # csv or json? assume json starts with [
+                is_json = (f.buffer.peek(1)[:1] == b'[')
+
+                # read csv?
+                if not is_json:
+                    results.extend(csv.DictReader(f, restval=''))
+
+                # read json?
+                else:
+                    results.extend(json.load(f))
+
+    # fall back to extracting code/stack/ctx info from elf/callgraph files
+    except StopIteration:
+        # figure out paths
+        obj_paths = []
+        ci_paths = []
+        for path in paths:
+            if iself(path):
+                obj_paths.append(path)
+            else:
+                ci_paths.append(path)
+
+        # find code/stack/ctx sizes
+        if obj_paths:
+            results.extend(collect_code(obj_paths, **args))
+        if ci_paths:
+            results.extend(collect_stack(ci_paths, **args))
+        if obj_paths:
+            results.extend(collect_ctx(obj_paths, **args))
+
+    # don't render code/stack/ctx results if we don't have any
+    nil_code = not any('code_size' in r for r in results)
+    nil_frames = not any('stack_frame' in r for r in results)
+    if nil_frames:
+        no_frames = True
+    nil_ctx = not any('ctx_size' in r for r in results)
+    if nil_ctx:
+        no_ctx = True
+    if no_frames and no_ctx:
+        no_stack = True
+
+    # merge code/stack/ctx results
+    functions = co.OrderedDict()
+    for r in results:
+        if r['function'] not in functions:
+            functions[r['function']] = {'name': r['function']}
+        # code things
+        if 'code_size' in r:
+            functions[r['function']]['code'] = dat(r['code_size'])
+        # stack things, including callgraph
+        if 'stack_frame' in r:
+            functions[r['function']]['frame'] = dat(r['stack_frame'])
+        if 'stack_limit' in r:
+            functions[r['function']]['stack'] = dat(r['stack_limit'], mt.inf)
+        if 'children' in r:
+            if 'children' not in functions[r['function']]:
+                functions[r['function']]['children'] = []
+            functions[r['function']]['children'].extend(
+                    r_['function']
+                        for r_ in r['children']
+                        if r_.get('stack_frame', '') != '')
+        # ctx things, including any arguments
+        if 'ctx_size' in r:
+            functions[r['function']]['ctx'] = dat(r['ctx_size'])
+        # TODO, what if not children in ctx? in stack?
+        if 'children' in r:
+            if 'args' not in functions[r['function']]:
+                functions[r['function']]['args'] = []
+            functions[r['function']]['args'].extend(
+                    {'name': r_['function'],
+                            'ctx': dat(r_['ctx_size']),
+                            'attrs': r_}
+                        for r_ in r['children']
+                        if r_.get('ctx_size', '') != '')
+        # keep track of other attrs for punescaping
+        if 'attrs' not in functions[r['function']]:
+            functions[r['function']]['attrs'] = {}
+        functions[r['function']]['attrs'].update(r)
+
+#    import pprint
+#    pprint.pprint(functions)
+
+#    # figure out paths
+#    obj_paths = []
+#    ci_paths = []
+#    for path in paths:
+#        if iself(path):
+#            obj_paths.append(path)
+#        else:
+#            ci_paths.append(path)
+#
+#    # find code/stack/ctx sizes
+#    functions = co.OrderedDict()
+#    if obj_paths:
+#        for r in collect_code(obj_paths, **args):
+#            if r['function'] not in functions:
+#                functions[r['function']] = {}
+#            functions[r['function']]['code'] = dat(r['code_size'])
+#    if ci_paths:
+#        for r in collect_stack(ci_paths, **args):
+#            if r['function'] not in functions:
+#                functions[r['function']] = {}
+#            functions[r['function']]['frame'] = dat(r['stack_frame'])
+#            functions[r['function']]['stack'] = dat(r['stack_limit'], mt.inf)
+#            if 'children' in r:
+#                functions[r['function']]['children'] = [
+#                        r_['function'] for r_ in r['children']]
+#    if obj_paths:
+#        for r in collect_ctx(obj_paths, **args):
+#            if r['function'] not in functions:
+#                functions[r['function']] = {}
+#            functions[r['function']]['ctx'] = dat(r['ctx_size'])
+#            if 'children' in r:
+#                functions[r['function']]['args'] = [
+#                        (r_['function'], dat(r_['ctx_size']))
+#                            for r_ in r['children']]
+
+    # stack.py returns infinity for recursive functions, so we need to
+    # recompute a bounded stack limit to show something useful
+    def limitof(k, f, seen=set()):
+        # found a cycle? stop here
+        if k in seen:
+            return 0
+#        # cached?
+#        if not hasattr(limitof, 'cache'):
+#            limitof.cache = {}
+#        if k in limitof.cache:
+#            return limitof.cache[k]
+
+        limit = 0
+        for child in f.get('children', []):
+            if child not in functions:
+                continue
+            limit = max(limit, limitof(child, functions[child], seen | {k}))
+
+#        limitof.cache[k] = f['frame'] + limit
+        return f['frame'] + limit
+
+    for k, f in functions.items():
+        if 'stack' in f:
+            if mt.isinf(f['stack']):
+                f['limit'] = limitof(k, f)
+            else:
+                f['limit'] = f['stack']
+
+    # organize into subsystems
+    namespace_pattern = re.compile('_*[^_]+(?:_*$)?')
+    namespace_slice = slice(namespace_depth if namespace_depth else None)
+    subsystems = {}
+    for k, f in functions.items():
+        # ignore leading/trailing underscores
+        f['subsystem'] = ''.join(
+                namespace_pattern.findall(k)[
+                    namespace_slice])
+
+        if f['subsystem'] not in subsystems:
+            subsystems[f['subsystem']] = {'name': f['subsystem']}
+
+    # include ctx in subsystems to give them different colors
+    for _, f in functions.items():
+        for a in f.get('args', []):
+            a['subsystem'] = a['name']
+
+            if a['subsystem'] not in subsystems:
+                subsystems[a['subsystem']] = {'name': a['subsystem']}
+
+    # sort to try to keep things reproducible
+    functions = co.OrderedDict(sorted(functions.items()))
+    subsystems = co.OrderedDict(sorted(subsystems.items()))
+
+    # sum code/stack/ctx/attrs for punescaping
+    for k, s in subsystems.items():
+        s['code'] = sum(
+                f.get('code', 0) for f in functions.values()
+                    if f['subsystem'] == k)
+        s['stack'] = max(
+                (f.get('stack', 0) for f in functions.values()
+                    if f['subsystem'] == k),
+                default=0)
+        s['ctx'] = max(
+                (f.get('ctx', 0) for f in functions.values()
+                    if f['subsystem'] == k),
+                default=0)
+        s['attrs'] = {k_: v_
+                for f in functions.values()
+                if f['subsystem'] == k
+                for k_, v_ in f['attrs'].items()}
+
+    # also build totals
+    totals = {}
+    totals['code'] = sum(
+            f.get('code', 0) for f in functions.values())
+    totals['stack'] = max(
+            (f.get('stack', 0) for f in functions.values()),
+            default=0)
+    totals['ctx'] = max(
+            (f.get('ctx', 0) for f in functions.values()),
+            default=0)
+    totals['attrs'] = {k: v
+            for f in functions.values()
+            for k, v in f['attrs'].items()}
+
+#    import pprint
+#    pprint.pprint(functions)
+
+    # assign colors to subsystems, note this is after sorting, but
+    # before tile generation, we want code and stack tiles to have the
+    # same color if they're in the same subsystem
+    for i, (k, s) in enumerate(subsystems.items()):
+        s['color'] = punescape(colors_[i, (k,)], s['attrs'] | s)
+
+#    # TODO make this configurable?
+#    stack_ratio = 1/5
+
+#    # use colors for top of tree
+#    for i, t in enumerate(tile.children):
+#        for t_ in t.tiles():
+#            t_.color = colors_[i, t_.key]
+
+#    # build functions
+#    datasets = co.OrderedDict()
+#    dataattrs = co.OrderedDict()
+#    for k, v in functions.items():
+#        name = ('_'.join(k.split('_')[:2]), k)
+#
+#        try:
+#            if 'code' in v:
+#                datasets[name] = [dat(v['code'])]
+#        except ValueError:
+#            pass
+#
+#        # bring over everything else
+#        if name not in dataattrs:
+#            dataattrs[name] = {}
+#        dataattrs[name].update(v | {
+#                'subsystem': name[0],
+#                'name': name[1],
+#                'code': datasets[name][0],
+#                'stack': v.get('stack', 0),
+#                'ctx': v.get('ctx', 0)})
+
+#    # break down by namespace
+#    # TODO namespace depth?
+#    results_ = []
+#    for r in results:
+#        name = (r['function'] if 'function' in r
+#                else r['struct'] if 'struct' in r
+#                else r['name'] if name in r
+#                else '?')
+#        results_.append({
+#            'subsystem': '_'.join(name.split('_')[:2]),
+#            'name': name,
+#            'code': r['code'] if 'code' in r
+#                    else r['size'] if 'size' in r
+#                    else '0',
+#            'frame': r['frame'] if 'code' in r
+#                    else '0',
+#            'limit': r['stack'] if 'stack' in r
+#                    else r['limit'] if 'limit' in r
+#                    else '0',
+#            'ctx': r['ctx'] if 'ctx' in r
+#                    else '0'})
+#    results = results_
+#
+#    by = ['subsystem', 'name']
+#    fields = ['code']
+#    labels_ = Attr(['%(name)s%ncode %(code)d%nstack %(stack)d%nctx %(ctx)d'])
+#
+#    if not by and not fields:
+#        print("error: needs --by or --fields to figure out fields",
+#                file=sys.stderr)
+#        sys.exit(-1)
+#
+#    # if by not specified, guess it's anything not in fields/labels/defines
+#    if not by:
+#        by = [k for k in fields_
+#                if k not in (fields or [])
+#                    and k not in (labels or [])
+#                    and not any(k == k_ for k_, _ in defines)]
+#
+#    # if fields not specified, guess it's anything not in by/labels/defines
+#    if not fields:
+#        fields = [k for k in fields_
+#                if k not in (by or [])
+#                    and k not in (labels or [])
+#                    and not any(k == k_ for k_, _ in defines)]
+#
+#    # then extract the requested dataset
+#    datasets, dataattrs = fold(results, by, fields, defines)
+#
+#    import pprint
+#    pprint.pprint(datasets)
+
+    # build code heirarchy
+    code = Tile.merge(
+            Tile(   (f['subsystem'], f['name']),
+                    # fallback to stack/ctx
+                    f.get('code', 0) if not nil_code
+                        else f.get('frame', 0) if not nil_frames
+                        else f.get('ctx', 0),
+                    attrs=f)
+                for f in functions.values())
+
+    # build stack heirarchies
+    if not no_stack and not no_frames:
+        stacks = co.OrderedDict()
+        for k, f in functions.items():
+            stack = []
+            def rec(f, seen=set()):
+                if f['name'] in seen:
+                    stack.append(f)
+                    return
+                seen.add(f['name'])
+
+                stack.append(f)
+
+                if f.get('children'):
+                    hot = max(f['children'], key=lambda k:
+                            functions[k].get('limit', 0)
+                                if k not in seen else -1)
+                    rec(functions[hot], seen)
+            rec(f)
+
+            stacks[k] = Tile.merge(
+                    Tile(   (f['name'],),
+                            f.get('frame', 0),
+                            attrs=f)
+                        for f in stack)
+
+    # build ctx heirarchies
+    if not no_stack and not no_ctx:
+        ctxs = co.OrderedDict()
+        for k, f in functions.items():
+            if f.get('args'):
+                args = f['args']
+            else:
+                args = [{
+                    'name': k,
+                    'subsystem': f['subsystem'],
+                    'ctx': f.get('ctx', 0),
+                    'attrs': f}]
+
+            ctxs[k] = Tile.merge(
+                    Tile(   (a['name'],),
+                            a.get('ctx', 0),
+                            attrs=a)
+                        for a in args)
+
+#                ctxs[k].attrs = {'name': k, 'subsystem': f['subsystem']}
+#                print(ctxs[k])
+
+
+#    children = []
+#    for k, f in functions.items():
+#        children.append(Tile(
+#                k,
+#                f['code'],
+#                attrs=f))
+#
+##    for key, dataset in datasets.items():
+##        for i, v in enumerate(dataset):
+##            children.append(Tile(
+##                key + ((str(i),) if len(dataset) > 1 else ()),
+##                v,
+##                attrs=dataattrs[key]))
+#
+#    tile = Tile.merge(children)
+#
+#    # merge attrs
+#    for t in tile.tiles():
+#        if t.children:
+#            t.attrs = {k: v
+#                    for t_ in t.leaves()
+#                    for k, v in t_.attrs.items()}
+#            # also sum fields here in case they're used by % modifiers,
+#            # note other fields are _not_ summed
+#            for k in fields:
+#                t.attrs[k] = sum(t_.value
+#                        for t_ in t.leaves()
+#                        if len(fields) == 1 or t_.key[len(by)] == k)
+#
+#    # assign colors/labels before sorting to keep things reproducible
+#
+#    # use colors for top of tree
+#    for i, t in enumerate(tile.children):
+#        for t_ in t.tiles():
+#            t_.color = colors_[i, t_.key]
+#
+#    # and labels everywhere
+#    for i, t in enumerate(tile.tiles()):
+#        if (i, t.key) in labels_:
+#            t.label = punescape(labels_[i, t.key], t.attrs)
+
+    # scale width/height if requested now that we have our data
+    if (to_scale is not None
+            and (width is None or height is None)):
+        total_value = (totals.get('code', 0) if not nil_code
+                else totals.get('frame', 0) if not nil_frames
+                else totals.get('ctx', 0))
+        if total_value:
+            # scale width only
+            if height is not None:
+                if not no_stack:
+                    width_ = mt.ceil(((total_value * to_scale) / height_)
+                            # add space for stack
+                            / (1 - stack_ratio))
+                else:
+                    width_ = mt.ceil((total_value * to_scale) / height_)
+            # scale height only
+            elif width is not None:
+                if not no_stack:
+                    height_ = mt.ceil((total_value * to_scale)
+                            # carve out space for stack
+                            / (width_ * (1 - stack_ratio)))
+                else:
+                    height_ = mt.ceil((total_value * to_scale) / width_)
+            # scale based on aspect-ratio
+            else:
+                if not no_stack:
+                    width_ = mt.ceil(mt.sqrt(total_value * to_scale)
+                            * (aspect_ratio[0] / aspect_ratio[1])
+                            # add space for stack
+                            / (1 - stack_ratio))
+                    height_ = mt.ceil((total_value * to_scale)
+                            # carve out space for stack
+                            / (width_ * (1 - stack_ratio)))
+                else:
+                    width_ = mt.ceil(mt.sqrt(total_value * to_scale)
+                            * (aspect_ratio[0] / aspect_ratio[1]))
+                    height_ = mt.ceil((total_value * to_scale) / width_)
+
+    # our general purpose partition function
+    def partition(tile, scheme):
+        if tile.depth == 0:
+            # apply top padding
+            tile.x += padding
+            tile.y += padding
+            tile.width  -= min(padding, tile.width)
+            tile.height -= min(padding, tile.height)
+            # apply bottom padding
+            if not tile.children:
+                tile.width  -= min(padding, tile.width)
+                tile.height -= min(padding, tile.height)
+
+            x__ = tile.x
+            y__ = tile.y
+            width__ = tile.width
+            height__ = tile.height
+
+        else:
+            # apply bottom padding
+            if not tile.children:
+                tile.width  -= min(padding, tile.width)
+                tile.height -= min(padding, tile.height)
+
+            x__ = tile.x
+            y__ = tile.y
+            width__ = tile.width
+            height__ = tile.height
+
+        # partition via requested scheme
+        if tile.children:
+            if scheme == 'binary':
+                partition_binary(tile.children, tile.value,
+                        x__, y__, width__, height__)
+            elif (scheme == 'slice'
+                    or (scheme == 'slice_and_dice' and (tile.depth & 1) == 0)
+                    or (scheme == 'dice_and_slice' and (tile.depth & 1) == 1)):
+                partition_slice(tile.children, tile.value,
+                        x__, y__, width__, height__)
+            elif (scheme == 'dice'
+                    or (scheme == 'slice_and_dice' and (tile.depth & 1) == 1)
+                    or (scheme == 'dice_and_slice' and (tile.depth & 1) == 0)):
+                partition_dice(tile.children, tile.value,
+                        x__, y__, width__, height__)
+            elif scheme == 'squarify':
+                partition_squarify(tile.children, tile.value,
+                        x__, y__, width__, height__)
+            elif scheme == 'rectify':
+                partition_squarify(tile.children, tile.value,
+                        x__, y__, width__, height__,
+                        aspect_ratio=(width_, height_))
+            else:
+                # default to binary partitioning
+                partition_binary(tile.children, tile.value,
+                        x__, y__, width__, height__)
+
+        # recursively partition
+        for t in tile.children:
+            partition(t, scheme)
+
+    # create space for header
+    x__ = 0
+    y__ = 0
+    width__ = width_
+    height__ = height_
+    if not no_header:
+        y__ += mt.ceil(FONT_SIZE * 1.3)
+        height__ -= min(mt.ceil(FONT_SIZE * 1.3), height__)
+
+    # split code/stack
+    if not no_stack:
+        code_split = width__ * (1 - stack_ratio)
+    else:
+        code_split = width__
+
+    # sort and partition code
+    code.sort()
+    code.x = x__
+    code.y = y__
+    code.width = code_split
+    code.height = height__
+    partition(code, 'binary')
+    # align to pixel boundaries
+    code.align()
+
+    # partition stacks/ctxs
+    if not no_stack:
+        deepest = max(functions.values(),
+                key=lambda f:
+                    (f.get('limit', 0) if not no_frames else 0)
+                        + (f.get('ctx', 0) if not no_ctx else 0))
+
+        for k, f in functions.items():
+            # scale to deepest stack/ctx
+            height___ = height__ * bdiv(
+                    (f.get('limit', 0) if not no_frames else 0)
+                        + (f.get('ctx', 0) if not no_ctx else 0),
+                    (deepest.get('limit', 0) if not no_frames else 0)
+                        + (deepest.get('ctx', 0) if not no_ctx else 0))
+
+            # split stack/ctx
+            ctx_split = height___ * bdiv(
+                    (f.get('ctx', 0) if not no_ctx else 0),
+                    (f.get('limit', 0) if not no_frames else 0)
+                        + (f.get('ctx', 0) if not no_ctx else 0))
+
+            # partition ctx
+            if not no_ctx:
+                ctx = ctxs[k]
+                ctx.x = code.x + code.width + 2
+                ctx.y = y__
+                ctx.width = width__ - ctx.x
+                ctx.height = ctx_split
+                partition(ctx, 'slice')
+                # align to pixel boundaries
+                ctx.align()
+
+            # partition stack
+            if not no_frames:
+                stack = stacks[k]
+                stack.x = code.x + code.width + 2
+                stack.y = ctx.y + ctx.height + 2 if ctx_split > 0 else y__
+                stack.width = width__ - stack.x
+                stack.height = height___ - (stack.y - y__)
+                partition(stack, 'dice')
+                # align to pixel boundaries
+                stack.align()
+
+    # create svg file
+    with openio(output, 'w') as f:
+        def writeln(s=''):
+            f.write(s)
+            f.write('\n')
+        f.writeln = writeln
+
+        # yes this is svg
+        f.write('<svg '
+                'xmlns="http://www.w3.org/2000/svg" '
+                'viewBox="0,0,%(width)d,%(height)d" '
+                'width="%(width)d" '
+                'height="%(height)d" '
+                'style="max-width: 100%%; '
+                        'height: auto; '
+                        'font: %(font_size)dpx %(font)s; '
+                        'background-color: %(background)s; '
+                        'user-select: %(user_select)s;">' % dict(
+#                'pointer-events="none" '
+#                'onkeydown="keydown(this,event)" '
+#                'onkeyup="keydown(this,event)" '
+                    width=width_,
+                    height=height_,
+                    font=','.join(font),
+                    font_size=font_size,
+                    background=background_,
+                    user_select='none' if not no_javascript else 'auto'))
+
+        # create header
+        if not no_header:
+            f.write('<g '
+                    'id="header" '
+                    '%(js)s>' % dict(
+                        js= 'cursor="pointer" '
+                            'onclick="click_header(this,event)">'
+                                if not no_javascript else ''))
+            # add an invisible rect to make things more clickable
+            f.write('<rect '
+                    'x="%(x)d" '
+                    'y="%(y)d" '
+                    'width="%(width)d" '
+                    'height="%(height)d" '
+                    'opacity="0">' % dict(
+                        x=0,
+                        y=0,
+                        width=width_,
+                        height=y__))
+            f.write('</rect>')
+            f.write('<text fill="%(color)s">' % dict(
+                    color='#ffffff' if dark else '#000000'))
+            f.write('<tspan x="3" y="1.1em">')
+            if title:
+                f.write(punescape(title, totals['attrs'] | totals))
+            else:
+                f.write('code %d stack %s ctx %d' % (
+                        totals.get('code', 0),
+                        (lambda s: '∞' if mt.isinf(s) else s)(
+                            totals.get('stack', 0)),
+                        totals.get('ctx', 0)))
+            f.write('</tspan>')
+            if not no_mode and not no_javascript:
+                f.write('<tspan id="mode" x="%(x)d" y="1.1em" '
+                        'text-anchor="end">' % dict(
+                            x=width_-3))
+                f.write('mode: callgraph')
+                f.write('</tspan>')
+            f.write('</text>')
+            f.write('</g>')
+
+#        # put all our tiles in a big group to catch clicks
+#        f.write('<g id="body" onclick="click_tile(this,event)">')
+#        # add an invisible rect to make things more clickable
+#        f.write('<rect '
+#                'x="%(x)d" '
+#                'y="%(y)d" '
+#                'width="%(width)d" '
+#                'height="%(height)d" '
+#                'opacity="0">' % dict(
+#                    x=0,
+#                    y=y__,
+#                    width=width_,
+#                    height=height_ - y__))
+#        f.write('</rect>')
+
+        # create code tiles
+        for i, t in enumerate(code.leaves()):
+            # skip anything with zero weight/height after aligning things
+            if t.width == 0 or t.height == 0:
+                continue
+
+            label__ = labels_[i, (t.attrs['name'],)]
+            if label__ is not None:
+                label__ = punescape(label__, t.attrs['attrs'] | t.attrs)
+            else:
+                label__ = '%s%s%s%s' % (
+                        t.attrs['name'],
+                        '\ncode %d' % t.attrs.get('code', 0)
+                            if not nil_code else '',
+                        '\nstack %s' % (lambda s: '∞' if mt.isinf(s) else s)(
+                                t.attrs.get('stack', 0))
+                            if not nil_frames else '',
+                        '\nctx %d' % t.attrs.get('ctx', 0)
+                            if not nil_ctx else '')
+
+            f.write('<g '
+                    'id="c-%(name)s" '
+                    'class="tile code" '
+                    'transform="translate(%(x)d,%(y)d)" '
+                    '%(js)s>' % dict(
+                        name=t.attrs['name'],
+                        x=t.x,
+                        y=t.y,
+                        js= 'data-name="%(name)s" '
+                            # precompute x/y for javascript, svg makes this
+                            # weirdly difficult to figure out post-transform
+                            'data-x="%(x)d" '
+                            'data-y="%(y)d" '
+                            'data-width="%(width)d" '
+                            'data-height="%(height)d" '
+        #                    'cursor="pointer" '
+                            'onmouseenter="enter_tile(this,event)" '
+                            'onmouseleave="leave_tile(this,event)" '
+                            'onclick="click_tile(this,event)">' % dict(
+                                    name=t.attrs['name'],
+                                    x=t.x,
+                                    y=t.y,
+                                    width=t.width,
+                                    height=t.height)
+                                if not no_javascript else ''))
+            # add an invisible rect to make things more clickable
+            f.write('<rect '
+                    'width="%(width)d" '
+                    'height="%(height)d" '
+                    'opacity="0">' % dict(
+                        width=t.width + padding,
+                        height=t.height + padding))
+            f.write('</rect>')
+            f.write('<title>')
+            f.write(label__)
+            f.write('</title>')
+            f.write('<rect '
+                    'id="c-tile-%(id)s" '
+                    'fill="%(color)s" '
+                    'width="%(width)d" '
+                    'height="%(height)d">' % dict(
+                        id=i,
+                        color=subsystems[t.attrs['subsystem']]['color'],
+                        width=t.width,
+                        height=t.height))
+            f.write('</rect>')
+            if not no_label:
+                f.write('<clipPath id="c-clip-%s">' % i)
+                f.write('<use href="#c-tile-%s">' % i)
+                f.write('</use>')
+                f.write('</clipPath>')
+                f.write('<text clip-path="url(#c-clip-%s)">' % i)
+                for j, l in enumerate(label__.split('\n')):
+                    if j == 0:
+                        f.write('<tspan x="3" y="1.1em">')
+                        f.write(l)
+                        f.write('</tspan>')
+                    else:
+                        if t.children:
+                            f.write('<tspan dx="3" y="1.1em" '
+                                    'fill-opacity="0.7">')
+                            f.write(l)
+                            f.write('</tspan>')
+                        else:
+                            f.write('<tspan x="3" dy="1.1em" '
+                                    'fill-opacity="0.7">')
+                            f.write(l)
+                            f.write('</tspan>')
+                f.write('</text>')
+            f.write('</g>')
+
+#        # show the deepest stack/ctx by default
+#        default = max(functions.values(),
+#                key=lambda f: f.get('stack', 0) + f.get('ctx', 0))
+
+        # create stack/ctx tiles
+        if not no_stack and (not no_ctx or not no_frames):
+          for i, k in enumerate(functions.keys()):
+            # only include the deepest stack if no_javascript, no reason to
+            # include a bunch of tiles we will never render
+            if no_javascript and functions[k]['name'] != deepest['name']:
+                continue
+
+            # create stack group
+            #
+            # note we conveniently don't need unique ids for each ctx/frame
+            # tile, just for the entire stack group
+            f.write('<g '
+                    'id="s-%(name)s" '
+                    'class="stack" '
+                    '%(js)s>' % dict(
+                        name=k,
+                        js= 'visibility="%(visibility)s">' % dict(
+                                    visibility="visible"
+                                        if functions[k]['name']
+                                            == deepest['name']
+                                        else "hidden")
+                                if not no_javascript else ''))
+
+            # add a line between code/stack
+            f.write('<rect '
+                    'x="%(x)d" '
+                    'y="%(y)d" '
+                    'width="%(width)d" '
+                    'height="%(height)d" '
+                    'fill="#7f7f7f">' % dict(
+                        x=code.x + code.width,
+                        y=code.y,
+                        width=2,
+                        height=max(
+                                stacks[k].y + stacks[k].height
+                                    if not no_frames else 0,
+                                ctxs[k].y + ctxs[k].height
+                                    if not no_ctx else 0)
+                            - code.y - padding))
+            f.write('</rect>')
+
+#            # create a group to catch stack-enter events
+#            f.write('<g '
+#                    'data-func="%(func)s" '
+#                    'onmouseenter="enter_stack(this,event)">' % dict(
+#                        func=k))
+#            # add an invisible rect to make things more clickable
+#            f.write('<rect '
+#                    'x="%(x)d" '
+#                    'y="%(y)d" '
+#                    'width="%(width)d" '
+#                    'height="%(height)d" '
+#                    'opacity="0">' % dict(
+#                        x=code.x + code.width + 2,
+#                        y=y__,
+#                        width=width_ - (code.x + code.width + 2),
+#                        height=height_ - y__))
+#            f.write('</rect>')
+
+            # create ctx tiles
+            if not no_ctx:
+              for j, t in enumerate(ctxs[k].leaves()):
+                # skip anything with zero weight/height after aligning things
+                if t.width == 0 or t.height == 0:
+                    continue
+
+#                print(ctx)
+                label__ = labels_[j, (t.attrs['name'],)]
+                if label__ is not None:
+                    label__ = punescape(label__, t.attrs['attrs'] | t.attrs)
+                else:
+                    label__ = '%s\nctx %d' % (
+                            t.attrs['name'],
+                            t.value)
+
+                f.write('<g '
+                        'id="x-%(id)s" '
+                        'class="tile ctx" '
+                        'transform="translate(%(x)d,%(y)d)" '
+                        '%(js)s>' % dict(
+                            id='%s-%s' % (i, j),
+                            x=t.x,
+                            y=t.y,
+                            js= 'data-name="%(name)s" '
+                                'data-func="%(func)s" '
+                                # precompute x/y for javascript, svg makes
+                                # this weirdly difficult to figure out
+                                # post-transform
+                                'data-x="%(x)d" '
+                                'data-y="%(y)d" '
+                                'data-width="%(width)d" '
+                                'data-height="%(height)d" '
+        #                        'cursor="pointer" '
+                                'onmouseenter="enter_tile(this,event)" '
+                                'onmouseleave="leave_tile(this,event)" '
+                                'onclick="click_tile(this,event)">' % dict(
+                                        name=t.attrs['name'],
+                                        func=k,
+                                        x=t.x,
+                                        y=t.y,
+                                        width=t.width,
+                                        height=t.height)
+                                    if not no_javascript else ''))
+                # add an invisible rect to make things more clickable
+                f.write('<rect '
+                        'width="%(width)d" '
+                        'height="%(height)d" '
+                        'opacity="0">' % dict(
+                            width=t.width + padding,
+                            height=t.height + padding))
+                f.write('</rect>')
+                f.write('<title>')
+                f.write(label__)
+                f.write('</title>')
+                f.write('<rect '
+                        'id="x-tile-%(id)s" '
+                        'fill="%(color)s" '
+                        'width="%(width)d" '
+                        'height="%(height)d">' % dict(
+                            id='%s-%s' % (i, j),
+                            color=subsystems[t.attrs['subsystem']]['color'],
+                            width=t.width,
+                            height=t.height))
+                f.write('</rect>')
+                if not no_label:
+                    f.write('<clipPath id="x-clip-%s">' % ('%s-%s' % (i, j)))
+                    f.write('<use href="#x-tile-%s">' % ('%s-%s' % (i, j)))
+                    f.write('</use>')
+                    f.write('</clipPath>')
+                    f.write('<text clip-path="url(#x-clip-%s)">' % (
+                            '%s-%s' % (i, j)))
+                    for j, l in enumerate(label__.split('\n')):
+                        if j == 0:
+                            f.write('<tspan x="3" y="1.1em">')
+                            f.write(l)
+                            f.write('</tspan>')
+                        else:
+                            if t.children:
+                                f.write('<tspan dx="3" y="1.1em" '
+                                        'fill-opacity="0.7">')
+                                f.write(l)
+                                f.write('</tspan>')
+                            else:
+                                f.write('<tspan x="3" dy="1.1em" '
+                                        'fill-opacity="0.7">')
+                                f.write(l)
+                                f.write('</tspan>')
+                    f.write('</text>')
+                f.write('</g>')
+
+            # add a line between ctx/stack
+            if not no_ctx and not no_frames:
+              f.write('<rect '
+                      'x="%(x)d" '
+                      'y="%(y)d" '
+                      'width="%(width)d" '
+                      'height="%(height)d" '
+                      'fill="#7f7f7f">' % dict(
+                          x=ctxs[k].x,
+                          y=ctxs[k].y + ctxs[k].height,
+                          width=ctxs[k].width - padding,
+                          height=2))
+              f.write('</rect>')
+
+            # create stack tiles
+            if not no_frames:
+              for j, t in enumerate(stacks[k].leaves()):
+                # skip anything with zero weight/height after aligning things
+                if t.width == 0 or t.height == 0:
+                    continue
+
+                label__ = labels_[j, (t.attrs['name'],)]
+                if label__ is not None:
+                    label__ = punescape(label__, t.attrs['attrs'] | t.attrs)
+                else:
+                    label__ = '%s\nframe %d' % (
+                            t.attrs['name'],
+                            t.attrs.get('frame', 0))
+
+                f.write('<g '
+                        'id="f-%(id)s" '
+                        'class="tile frame" '
+                        'transform="translate(%(x)d,%(y)d)" '
+                        '%(js)s>' % dict(
+                            id='%s-%s' % (i, j),
+                            x=t.x,
+                            y=t.y,
+                            js= 'data-name="%(name)s" '
+                                'data-func="%(func)s" '
+                                # precompute x/y for javascript, svg makes
+                                # this weirdly difficult to figure out
+                                # post-transform
+                                'data-x="%(x)d" '
+                                'data-y="%(y)d" '
+                                'data-width="%(width)d" '
+                                'data-height="%(height)d" '
+#                                'cursor="pointer" '
+                                'onmouseenter="enter_tile(this,event)" '
+                                'onmouseleave="leave_tile(this,event)" '
+                                'onclick="click_tile(this,event)"' % dict(
+                                        name=t.attrs['name'],
+                                        func=k,
+                                        x=t.x,
+                                        y=t.y,
+                                        width=t.width,
+                                        height=t.height)
+                                    if not no_javascript else ''))
+                # add an invisible rect to make things more clickable
+                f.write('<rect '
+                        'width="%(width)d" '
+                        'height="%(height)d" '
+                        'opacity="0">' % dict(
+                            width=t.width + padding,
+                            height=t.height + padding))
+                f.write('</rect>')
+                f.write('<title>')
+                f.write(label__)
+                f.write('</title>')
+                f.write('<rect '
+                        'id="f-tile-%(id)s" '
+                        'fill="%(color)s" '
+                        'width="%(width)d" '
+                        'height="%(height)d">' % dict(
+                            id='%s-%s' % (i, j),
+                            color=subsystems[t.attrs['subsystem']]['color'],
+                            width=t.width,
+                            height=t.height))
+                f.write('</rect>')
+                if not no_label:
+                    f.write('<clipPath id="f-clip-%s">' % ('%s-%s' % (i, j)))
+                    f.write('<use href="#f-tile-%s">' % ('%s-%s' % (i, j)))
+                    f.write('</use>')
+                    f.write('</clipPath>')
+                    f.write('<text clip-path="url(#f-clip-%s)">' % (
+                            '%s-%s' % (i, j)))
+                    for j, l in enumerate(label__.split('\n')):
+                        if j == 0:
+                            f.write('<tspan x="3" y="1.1em">')
+                            f.write(l)
+                            f.write('</tspan>')
+                        else:
+                            if t.children:
+                                f.write('<tspan dx="3" y="1.1em" '
+                                        'fill-opacity="0.7">')
+                                f.write(l)
+                                f.write('</tspan>')
+                            else:
+                                f.write('<tspan x="3" dy="1.1em" '
+                                        'fill-opacity="0.7">')
+                                f.write(l)
+                                f.write('</tspan>')
+                    f.write('</text>')
+                f.write('</g>')
+
+            f.write('</g>')
+
+#            f.write('</g>')
+
+#        f.write('</g>')
+
+        if not no_javascript:
+            # arrowhead for arrows
+            f.write('<defs>')
+            f.write('<marker '
+                    'id="arrowhead" '
+                    'viewBox="0 0 10 10" '
+                    'refX="10" '
+                    'refY="5" '
+                    'markerWidth="6" '
+                    'markerHeight="6" '
+                    'orient="auto-start-reverse" '
+                    'fill="black">')
+            f.write('<path d="M 0 0 L 10 5 L 0 10 z"/>')
+            f.write('</marker>')
+            f.write('</defs>')
+
+            # TODO why are we running into NaNs? for v1?
+
+            # javascript for arrows
+            #
+            # why tf does svg support javascript?
+            f.write('<script><![CDATA[')
+
+            # number of tiles
+    #        n = sum(1 for _ in code.leaves())
+
+            # function names
+    #        f.write('const functions = %s;' % json.dumps(
+    #                [f['name'] for f in functions.values()]))
+            # dict of all children
+    #        children = {}
+    #        children_stack = {}
+    #        for t in code.leaves():
+    #            if 'children' in t.attrs:
+    #                for child in t.attrs['children']:
+    #                    for t_ in code.leaves():
+    #                        if t_.attrs['name'] == child:
+    #                            if 'code-%s' % t.id not in children:
+    #                                children['code-%s' % t.id] = set()
+    #                            children['code-%s' % t.id].add('code-%s' % t_.id)
+    #                            children_stack['code-%s' % t_.id] = (
+    #                                    t_.attrs['stack'])
+            f.write('const children = %s;' % json.dumps(
+                    {f['name']: sorted(f.get('children', []),
+                            key=lambda c: functions[c]['limit'],
+                            reverse=True)
+                        for f in functions.values()},
+                    separators=(',', ':')))
+
+            # function for rect <-> line interesection
+            f.write('function rect_intersect(x, y, width, height, l_x, l_y) {')
+            f.write(    'let r_x = (x + width/2);')
+            f.write(    'let r_y = (y + height/2);')
+            f.write(    'let dx = l_x - r_x;')
+            f.write(    'let dy = l_y - r_y;')
+            f.write(    'let θ = Math.abs(dy / dx);')
+            f.write(    'let φ = height / width;')
+            f.write(    'if (θ > φ) {')
+            f.write(        'return [')
+            f.write(            'r_x + ((height/2)/θ)*Math.sign(dx),')
+            f.write(            'r_y + (height/2)*Math.sign(dy),')
+            f.write(        '];')
+            f.write(    '} else {')
+            f.write(        'return [')
+            f.write(            'r_x + (width/2)*Math.sign(dx),')
+            f.write(            'r_y + ((width/2)*θ)*Math.sign(dy),')
+            f.write(        '];')
+            f.write(    '}')
+            f.write('}')
+
+            # our main drawing functions
+            f.write('function draw_unfocus() {')
+                        # lower opacity of unfocused tiles
+            f.write(    'for (let b of document.querySelectorAll(".tile")) {')
+            f.write(        'b.setAttribute("fill-opacity", 0.7);')
+            f.write(    '}')
+            f.write('}')
+
+            f.write('function draw_focus(a) {')
+                        # revert opacity and move to top
+            f.write(    'a.setAttribute("fill-opacity", 1);')
+            f.write(    'a.parentElement.appendChild(a);')
+            f.write('}')
+
+            # draw an arrow
+            f.write('function draw_arrow(a, b) {')
+                        # no self-referential arrows
+            f.write(    'if (b == a) {')
+            f.write(        'return;')
+            f.write(    '}')
+                        # figure out rect intersections
+            f.write(    'let svg = document.documentElement;')
+            f.write(    'let ns = svg.getAttribute("xmlns");')
+            f.write(    'let a_x = parseInt(a.dataset.x);')
+            f.write(    'let a_y = parseInt(a.dataset.y);')
+            f.write(    'let a_width = parseInt(a.dataset.width);')
+            f.write(    'let a_height = parseInt(a.dataset.height);')
+            f.write(    'let b_x = parseInt(b.dataset.x);')
+            f.write(    'let b_y = parseInt(b.dataset.y);')
+            f.write(    'let b_width = parseInt(b.dataset.width);')
+            f.write(    'let b_height = parseInt(b.dataset.height);')
+            f.write(    'let [a_ix, a_iy] = rect_intersect(')
+            f.write(            'a_x, a_y, a_width, a_height,')
+            f.write(            'b_x + b_width/2, b_y + b_height/2);')
+            f.write(    'let [b_ix, b_iy] = rect_intersect(')
+            f.write(            'b_x, b_y, b_width, b_height,')
+            f.write(            'a_x + a_width/2, a_y + a_height/2);')
+                        # create the actual arrow
+            f.write(    'let arrow = document.createElementNS(ns, "line");')
+            f.write(    'arrow.classList.add("arrow");')
+            f.write(    'arrow.setAttribute("x1", a_ix);')
+            f.write(    'arrow.setAttribute("y1", a_iy);')
+            f.write(    'arrow.setAttribute("x2", b_ix);')
+            f.write(    'arrow.setAttribute("y2", b_iy);')
+            f.write(    'arrow.setAttribute("stroke", "black");')
+            f.write(    'arrow.setAttribute("marker-end", "url(#arrowhead)");')
+            f.write(    'arrow.setAttribute("pointer-events", "none");')
+            f.write(    'a.parentElement.appendChild(arrow);')
+            f.write('}')
+
+            # here are some drawing modes to choose from
+
+            # draw full callgraph
+            f.write('function draw_callgraph(a) {')
+    #                    # clear the old arrows
+    #        f.write(    'undraw();')
+                        # track visited children to avoid cycles
+            f.write(    'let seen = {};')
+                        # create new arrows
+            f.write(    'let recurse = function(a) {')
+            f.write(        'if (a.dataset.name in seen) {')
+            f.write(            'return;')
+            f.write(        '}')
+            f.write(        'seen[a.dataset.name] = true;')
+            f.write(        'for (let child of ')
+            f.write(                'children[a.dataset.name] || []) {')
+            f.write(            'let b = document.getElementById("c-"+child);')
+            f.write(            'if (b) {')
+            f.write(                'draw_arrow(a, b);')
+            f.write(                'recurse(b);')
+            f.write(            '}')
+            f.write(        '}')
+            f.write(    '};')
+            f.write(    'recurse(a);')
+                        # track visited children to avoid cycles
+            f.write(    'seen = {};')
+                        # move in-focus tiles to the top
+            f.write(    'recurse = function(a) {')
+            f.write(        'if (a.dataset.name in seen) {')
+            f.write(            'return;')
+            f.write(        '}')
+            f.write(        'seen[a.dataset.name] = true;')
+            f.write(        'for (let child of ')
+            f.write(                'children[a.dataset.name] || []) {')
+            f.write(            'let b = document.getElementById("c-"+child);')
+            f.write(            'if (b) {')
+            f.write(                'draw_focus(b);')
+            f.write(                'recurse(b);')
+            f.write(            '}')
+            f.write(        '}')
+            f.write(    '};')
+            f.write(    'recurse(a);')
+                        # move our tile to the top
+            f.write(    'draw_focus(a);')
+            f.write('}')
+
+            # draw deepest set of calls
+            f.write('function draw_deepest(a) {')
+    #                    # clear the old arrows
+    #        f.write(    'undraw();')
+    #                    # lower opacity of unfocused tiles
+    #        f.write(    'draw_unfocus();')
+                        # track visited children to avoid cycles
+            f.write(    'let seen = {};')
+                        # create/ new arrows
+            f.write(    'let recurse = function(a) {')
+            f.write(        'if (a.dataset.name in seen) {')
+            f.write(            'return;')
+            f.write(        '}')
+            f.write(        'seen[a.dataset.name] = true;')
+            f.write(        'if (children[a.dataset.name]) {')
+                                # draw recursive arrows to show cycles
+            f.write(            'if (children[a.dataset.name][0] in seen) {')
+            f.write(                'let child = children[a.dataset.name][0];')
+            f.write(                'let b = document.getElementById('
+                                            '"c-"+child);')
+            f.write(                'if (b) {')
+            f.write(                    'draw_arrow(a, b);')
+            f.write(                '}')
+            f.write(            '}')
+                                # but descend down the deepest non-recursive
+                                # child to show useful stack info
+            f.write(            'let child = children[a.dataset.name]'
+                                        '.find((child) => !(child in seen));')
+            f.write(            'if (child) {')
+            f.write(                'let b = document.getElementById('
+                                            '"c-"+child);')
+            f.write(                'if (b) {')
+            f.write(                    'draw_arrow(a, b);')
+            f.write(                    'recurse(b);')
+            f.write(                '}')
+            f.write(            '}')
+            f.write(        '}')
+            f.write(    '};')
+            f.write(    'recurse(a);')
+                        # track visited children to avoid cycles
+            f.write(    'seen = {};')
+                        # move in-focus tiles to the top
+            f.write(    'recurse = function(a) {')
+            f.write(        'if (a.dataset.name in seen) {')
+            f.write(            'return;')
+            f.write(        '}')
+            f.write(        'seen[a.dataset.name] = true;')
+            f.write(        'if (children[a.dataset.name]) {')
+            f.write(            'let child = children[a.dataset.name]'
+                                        '.find((child) => !(child in seen));')
+            f.write(            'if (child) {')
+            f.write(                'let b = document.getElementById('
+                                            '"c-"+child);')
+            f.write(                'if (b) {')
+            f.write(                    'draw_focus(b);')
+            f.write(                    'recurse(b);')
+            f.write(                '}')
+            f.write(            '}')
+            f.write(        '}')
+            f.write(    '};')
+            f.write(    'recurse(a);')
+                        # move our tile to the top
+            f.write(    'draw_focus(a);')
+            f.write('}')
+
+            # draw one level of calls
+            f.write('function draw_callees(a) {')
+    #                    # clear the old arrows
+    #        f.write(    'undraw();')
+    #                    # lower opacity of unfocused tiles
+    #        f.write(    'draw_unfocus();')
+                        # create new arrows
+            f.write(    'for (let child of children[a.dataset.name] || []) {')
+            f.write(        'let b = document.getElementById("c-"+child);')
+            f.write(        'if (b) {')
+            f.write(            'draw_arrow(a, b);')
+            f.write(        '}')
+            f.write(    '}')
+                        # move in-focus tiles to the top
+            f.write(    'for (let child of children[a.dataset.name] || []) {')
+            f.write(        'let b = document.getElementById("c-"+child);')
+            f.write(        'if (b) {')
+            f.write(            'draw_focus(b);')
+            f.write(        '}')
+            f.write(    '}')
+                        # move our tile to the top
+            f.write(    'draw_focus(a);')
+            f.write('}')
+
+            # draw one level of callers
+            f.write('function draw_callers(a) {')
+    #                    # clear the old arrows
+    #        f.write(    'undraw();')
+    #                    # lower opacity of unfocused tiles
+    #        f.write(    'draw_unfocus();')
+                        # create new arrows
+            f.write(    'for (let parent in children) {')
+            f.write(        'if ((children[parent] || []).includes(')
+            f.write(                'a.dataset.name)) {')
+            f.write(            'let b = document.getElementById('
+                                        '"c-"+parent);')
+            f.write(            'if (b) {')
+            f.write(                'draw_arrow(b, a);')
+            f.write(            '}')
+            f.write(        '}')
+            f.write(    '}')
+                        # move in-focus tiles to the top
+            f.write(    'for (let parent in children) {')
+            f.write(        'if ((children[parent] || []).includes(')
+            f.write(                'a.dataset.name)) {')
+            f.write(            'let b = document.getElementById('
+                                        '"c-"+parent);')
+            f.write(            'if (b) {')
+            f.write(                'draw_focus(b);')
+            f.write(            '}')
+            f.write(        '}')
+            f.write(    '}')
+                        # move our tile to the top
+            f.write(    'draw_focus(a);')
+            f.write('}')
+
+    #        # draw path stack takes through the code, this is left rendered
+    #        # for all frame/context tiles
+    #        f.write('function draw_stackpath(name) {')
+    #        f.write(    'let a = document.getElementById("c-"+name);')
+    #                    # clear the old arrows
+    #        f.write(    'undraw();')
+    #                    # lower opacity of unfocused tiles
+    #        f.write(    'draw_unfocus();')
+    #                    # track visited children to avoid cycles
+    #        f.write(    'let seen = {};')
+    #                    # create/ new arrows
+    #        f.write(    'let recurse = function(a) {')
+    #        f.write(        'if (a.dataset.name in seen) {')
+    #        f.write(            'return;')
+    #        f.write(        '}')
+    #        f.write(        'seen[a.dataset.name] = true;')
+    #        f.write(        'if (children[a.dataset.name]) {')
+    #        f.write(            'let child = children[a.dataset.name][0];')
+    #        f.write(            'let b = document.getElementById("c-"+child);')
+    #        f.write(            'if (b) {')
+    #        f.write(                'draw_arrow(a, b);')
+    #        f.write(                'recurse(b);')
+    #        f.write(            '}')
+    #        f.write(        '}')
+    #        f.write(    '};')
+    #        f.write(    'recurse(a);')
+    #                    # track visited children to avoid cycles
+    #        f.write(    'seen = {};')
+    #                    # move in-focus tiles to the top, but don't change
+    #                    # their opacity
+    #        f.write(    'recurse = function(a) {')
+    #        f.write(        'if (a.dataset.name in seen) {')
+    #        f.write(            'return;')
+    #        f.write(        '}')
+    #        f.write(        'seen[a.dataset.name] = true;')
+    #        f.write(        'if (children[a.dataset.name]) {')
+    #        f.write(            'let child = children[a.dataset.name][0];')
+    #        f.write(            'let b = document.getElementById("c-"+child);')
+    #        f.write(            'if (b) {')
+    #        f.write(                'b.parentElement.appendChild(b);')
+    #        f.write(                'recurse(b);')
+    #        f.write(            '}')
+    #        f.write(        '}')
+    #        f.write(    '};')
+    #        f.write(    'recurse(a);')
+    #                    # move our tile to the top, but don't change its opacity
+    #        f.write(    'a.parentElement.appendChild(a);')
+    #        f.write('}')
+
+            # clear old arrows/tiles if we leave
+            f.write('function undraw() {')
+                        # clear arrows
+            f.write(    'for (let arrow of document.querySelectorAll('
+                                '".arrow")) {')
+            f.write(        'arrow.remove();')
+            f.write(    '}')
+                        # revert opacity
+            f.write(    'for (let b of document.querySelectorAll(".tile")) {')
+            f.write(        'b.setAttribute("fill-opacity", 1);')
+            f.write(    '}')
+            f.write('}')
+
+            # render stack+ctx tiles
+            f.write('function switch_stack(name) {')
+                        # update stack tiles
+            f.write(    'for (let b of document.querySelectorAll(".stack")) {')
+            f.write(        'b.setAttribute("visibility", "hidden");')
+            f.write(    '}')
+            f.write(    'let s = document.getElementById("s-"+name);')
+            f.write(    'if (s) {')
+                            # make visible
+            f.write(        's.setAttribute("visibility", "visible");')
+                            # and refocus stack tiles in case they were
+                            # unfocused
+            f.write(        'for (let b of s.querySelectorAll('
+                                    '".frame,.ctx")) {')
+            f.write(            'draw_focus(b);')
+            f.write(        '}')
+            f.write(    '}')
+            f.write('}')
+
+            # draw stack frame/ctx tile
+            f.write('function draw_stack(a) {')
+    #                    # clear the old arrows
+    #        f.write(    'undraw();')
+    #                    # lower opacity of unfocused tiles
+    #        f.write(    'draw_unfocus();')
+
+    #                    # if a is null we just refocus the stack
+            f.write(    'if (!a) {')
+            f.write(        'let s = document.querySelector('
+                                    '".stack[visibility=\\"visible\\"]");')
+            f.write(        'for (let b of s.querySelectorAll('
+                                    '".frame,.ctx")) {')
+            f.write(            'draw_focus(b);')
+            f.write(        '}')
+            f.write(        'return;')
+            f.write(    '}')
+
+                        # render the deepest call path of the relevant code
+                        # tile
+            f.write(    'let c = document.getElementById("c-"+('
+                                'a.classList.contains("ctx")'
+                                    '? a.dataset.func'
+                                    ': a.dataset.name));')
+            f.write(    'if (c) {')
+            f.write(        'draw_deepest(c);')
+            f.write(    '}')
+                        # focus all tiles beneath this one, bit of a hack to
+                        # avoid another recursive function, yes this includes
+                        # all ctxs if any ctx is in focus
+            f.write(    'let y = parseInt(a.dataset.y);')
+            f.write(    'for (b of a.parentElement'
+                                '.querySelectorAll(".frame,.ctx")) {')
+            f.write(        'if (parseInt(b.dataset.y) >= y) {')
+            f.write(            'draw_focus(b);')
+            f.write(        '}')
+            f.write(    '}')
+                        # move our tile to the top
+            f.write(    'draw_focus(a);')
+            f.write('}')
+
+            # state machine for mouseover/clicks
+            f.write('const modes = [')
+            if mode_callgraph:
+                f.write('{name: "callgraph",    draw: draw_callgraph},')
+            if mode_deepest:
+                f.write('{name: "deepest",      draw: draw_deepest  },')
+            if mode_callees:
+                f.write('{name: "callees",      draw: draw_callees  },')
+            if mode_callers:
+                f.write('{name: "callers",      draw: draw_callers  },')
+            f.write('];')
+            f.write('let state = 0;')
+    #        f.write('let frozen = 0;')
+            f.write('let hovered = null;')
+            f.write('let active_code = null;')
+            f.write('let active_stack = null;')
+            f.write('let paused = false;')
+
+            f.write('function enter_tile(a, event) {')
+            f.write(    'hovered = a;')
+                        # do nothing if paused
+            f.write(    'if (paused) {')
+            f.write(        'return;')
+            f.write(    '}')
+                        # do nothing if ctrl is held
+    #        f.write(    'if (event.ctrlKey) { return; }')
+    #        f.write(    'console.log(event);')
+    #        f.write(    'console.log("enter", a);')
+    #        f.write(    'if (!frozen) {')
+                        # code tile or stack tile?
+            f.write(    'if (a.classList.contains("code")) {')
+            f.write(        'if (!active_code && !active_stack) {')
+                                # reset
+            f.write(            'undraw();')
+            f.write(            'draw_unfocus();')
+                                # draw selected mode
+            f.write(            'modes[state].draw(a);')
+            if not no_stack:
+                                # render relevant stack tiles
+                f.write(        'switch_stack(a.dataset.name);')
+    #        f.write(            'active_code = a;')
+            f.write(        '}')
+            f.write(    '} else if (a.classList.contains("frame") '
+                                '|| a.classList.contains("ctx")) {')
+            f.write(        'if (!active_stack) {')
+                                # reset
+            f.write(            'undraw();')
+            f.write(            'draw_unfocus();')
+            if not no_stack:
+                                # draw stack mode
+                f.write(        'draw_stack(a);')
+    #        f.write(            'active_stack = a;')
+            f.write(        '}')
+            f.write(    '}')
+    #        f.write(    'last = a;')
+    #        f.write(    '}')
+            f.write('}')
+
+            f.write('function leave_tile(a, event) {')
+            f.write(    'hovered = null;')
+                        # do nothing if paused
+            f.write(    'if (paused) {')
+            f.write(        'return;')
+            f.write(    '}')
+                        # do nothing if ctrl is held
+    #        f.write(    'if (event.ctrlKey) { return; }')
+            f.write(    'if (!active_stack) {')
+                            # reset
+            f.write(        'undraw();')
+            f.write(        'if (!active_code) {')
+            if not no_stack:
+                                # reset to deepest stack
+                f.write(        'switch_stack("%s");' % deepest['name'])
+    #        f.write(            'active_code = null;')
+            f.write(        '} else {')
+                                # reset to active code
+            f.write(            'draw_unfocus();')
+            f.write(            'modes[state].draw(active_code);')
+            if not no_stack:
+                f.write(        'draw_stack();')
+            f.write(        '}')
+    #        f.write(        'active_stack = null;')
+            f.write(    '}')
+            f.write('}')
+
+            # update the mode string
+            f.write('function draw_mode() {')
+            f.write(    'let mode = document.getElementById("mode");')
+            f.write(    'if (mode) {')
+    #        f.write(    'let mode_ = modes[state].name;')
+    #        f.write(    'let notes '
+    #                            '= (paused) ? ["paused"]'
+    #                            ': (active_code || active_stack) ? ["frozen"]'
+    #                            ': [];')
+            f.write(        'mode.textContent = "mode: "'
+                                    '+ modes[state].name'
+                                    '+ ((paused) ? " (paused)"'
+                                        ': (active_code || active_stack)'
+                                            '? " (frozen)"'
+                                        ': "");')
+            f.write(    '}')
+            f.write('}')
+
+            # redraw things
+            f.write('function redraw() {')
+                        # reset
+            f.write(    'undraw();')
+                        # redraw stack if active
+            f.write(    'if (active_stack) {')
+            f.write(        'draw_unfocus();')
+            if not no_stack:
+                f.write(    'draw_stack(active_stack);')
+                        # redraw code if active
+            f.write(    '} else if (active_code) {')
+            f.write(        'draw_unfocus();')
+            f.write(        'modes[state].draw(active_code);')
+            if not no_stack:
+                f.write(    'draw_stack();')
+                        # otherwise try to enter hovered tile if there is one
+            f.write(    '} else if (hovered) {')
+            f.write(        'enter_tile(hovered);')
+            f.write(    '}')
+            f.write('}')
+
+    #        f.write('function redraw() {')
+    #                    # do nothing if ctrl is held
+    ##        f.write(    'if (event.ctrlKey) { return; }')
+    #                    # reset
+    #        f.write(    'undraw();')
+    #        f.write(    'draw_unfocus();')
+    #        f.write(    'if (active_code) {')
+    #                        # redraw code
+    #        f.write(        'modes[state].draw(active_code);')
+    #        f.write(        'switch_stack(active_code.dataset.name);')
+    #        f.write(    '} else {')
+    #                        # reset to deepest stack
+    #        f.write(        'switch_stack("%s");' % default['name'])
+    #        f.write(    '}')
+    #        f.write(    'if (active_stack) {')
+    #        f.write(        'draw_stack(active_stack);')
+    #        f.write(    '}')
+    #        f.write('}')
+
+            # clicking the mode element changes the mode
+            f.write('function click_header(a, event) {')
+                        # do nothing if paused
+            f.write(    'if (paused) {')
+            f.write(        'return;')
+            f.write(    '}')
+    #        f.write(    'console.log(document.getSelection());')
+    #        #f.write(    'document.getSelection().empty();')
+    #        f.write(    'console.log(event);')
+                        # do nothing if ctrl is held
+    #        f.write(    'if (event.altKey) { event.altKey = false; return; }')
+                        # don't do anything if selecting text
+    #        f.write(    'if (document.getSelection '
+    #                            '&& document.getSelection().toString()) {')
+    #        f.write(        'return;')
+    #        f.write(    '}')
+    #        f.write(    'event.preventDefault();')
+    #        f.write(    'event.stopPropagation();')
+    #        f.write(    'event.stopImmediatePropagation();')
+    #        f.write(    'console.log(event);')
+
+                        # update state
+            f.write(    'state = (state + 1) % modes.length;')
+                        # update the mode string
+            f.write(    'draw_mode();')
+                        # redraw with new mode
+            f.write(    'redraw();')
+    #        f.write(    'if (!active_stack) {')
+    #                        # redraw with new mode
+    #        f.write(        'let code = active_code;')
+    #        f.write(        'if (!code '
+    #                                '&& hovered '
+    #                                '&& hovered.classList.contains("code")) {')
+    #        f.write(            'code = hovered;')
+    #        f.write(        '}')
+    #        f.write(        'if (code) {')
+    #        f.write(            'undraw();')
+    #        f.write(            'draw_unfocus();')
+    #        f.write(            'modes[state].draw(code);')
+    #        f.write(            'draw_stack();')
+    #        f.write(        '}')
+    #        f.write(    '}')
+    #        f.write(    'console.log("h", active_code, active_stack);')
+    #        f.write(    'if (active_stack) {')
+    #        f.write(        'enter_tile(active_stack);')
+    #        f.write(    '} else if (active_code) {')
+    #        f.write(        'enter_tile(active_code);')
+    #        f.write(    '} else {')
+    #        f.write(        'leave_tile();')
+    #        f.write(    '}')
+                        # prevent text highlighting
+    #        f.write(    'e.stopPropagation();')
+    #        f.write(    'leave_tile();')
+    #        f.write(    'frozen = false;')
+    #        f.write(    'if (last) {')
+    #        f.write(        'enter_tile(last);')
+    #        f.write(    '}')
+                        # prevent text highlighting
+    #        f.write(    'event.preventDefault();')
+    #        f.write(    'event.stopPropagation();')
+    #        f.write(    'event.stopImmediatePropagation();')
+    #        f.write(    'return false;')
+            f.write('}')
+
+    ##        f.write(    'console.log("leave", a);')
+    #        f.write(    'if (frozen == 0) {')
+    #        f.write(        'undraw();')
+    #                        # reset to deepest stack
+    #        f.write(        'switch_stack("%s");' % default['name'])
+    ##        f.write(        'active_code = null;')
+    ##        f.write(        'active_stack = null;')
+    #        f.write(    '} else if (frozen == 1) {')
+    #        f.write(        'undraw();')
+    #        f.write(        'modes[state].draw(active_code);')
+    #        f.write(        'switch_stack(active_code.dataset.name);')
+    #        f.write(        'active_stack = null;')
+    #        f.write(    '}')
+    #        f.write('}')
+
+    #        f.write('let prev_frozen = 0;')
+            f.write('let prev_code = null;')
+            f.write('let prev_stack = null;')
+    #        f.write('let p_frozen = false;')
+            f.write('function click_tile(a, event) {')
+                        # do nothing if paused
+            f.write(    'if (paused) {')
+            f.write(        'return;')
+            f.write(    '}')
+                        # do nothing if ctrl is held
+    #        f.write(    'if (event.ctrlKey) { return; }')
+                        # don't do anything if selecting text
+    #        f.write(    'if (document.getSelection '
+    #                            '&& document.getSelection().toString()) {')
+    #        f.write(        'return;')
+    #        f.write(    '}')
+
+    #                    # triply clicking clears any frozen tiles
+    #        f.write(    'if (event && event.detail == 3) {')
+    #        f.write(        'console.log("TRIPLE");')
+    #                        # undo the mode change
+    #        f.write(        'state = (state - 1 + modes.length) % modes.length;')
+    #                        # clear active tiles
+    #        f.write(        'active_code = null;')
+    #        f.write(        'active_stack = null;')
+    #                        # update the mode string
+    #        f.write(        'draw_mode();')
+    #                        # use leave_tile to trigger a redraw
+    #        f.write(        'leave_tile();')
+    #        f.write(        'return;')
+    #        f.write(    '}')
+
+                        # double clicking changes the mode
+            f.write(    'if (event && event.detail == 2 '
+                                # limit this to double-clicking the active tile
+                                '&& ((!prev_code && !prev_stack)'
+                                    '|| (a == prev_code && !prev_stack)'
+                                    '|| a == prev_stack)) {')
+    #                        # undo single click
+    ##        f.write(        'frozen = prev_frozen;')
+    #        f.write(        'active_code = prev_code;')
+    #        f.write(        'active_stack = prev_stack;')
+    ##        f.write(        'last = a;')
+    #        f.write(        'click_header(a, event);')
+                            # undo single-click
+            f.write(        'active_code = prev_code;')
+            f.write(        'active_stack = prev_stack;')
+    #        f.write(        'frozen = p_frozen;')
+                            # trigger a mode change if double-clicking code,
+                            # note we could also change stack modes here if we
+                            # had more than one
+            f.write(        'if (a.classList.contains("code")) {')
+            f.write(            'click_header();')
+    #        f.write(            'enter_tile(a);')
+            f.write(        '}')
+    #                        # update state
+    #        f.write(        'state = (state + 1) % modes.length;')
+    #                        # trigger a redraw
+    #        f.write(        'redraw();')
+    #        f.write(        'enter_tile(a);')
+
+    #                        # double-clicking tiles can still change state
+    #                        # if tile changes
+    #        f.write(        'if ((frozen == 1 && a != active_code)'
+    #                                '|| (frozen == 2 && a != active_stack)) {')
+    #        f.write(            'click_tile(a);')
+    #        f.write(        '}')
+
+    #        f.write(        'if ((a.classList.contains("code")'
+    #                                    '&& ((active_code && a != active_code)'
+    #                                        '|| active_stack))'
+    #                                '|| ((a.classList.contains("frame")'
+    #                                        '|| a.classList.contains("ctx"))'
+    #                                    '&& active_stack && a != active_stack)) {')
+    #        f.write(            'click_tile(a);')
+    #        f.write(        '}')
+
+    #        f.write(        'if (a.classList.contains("code")) {')
+    #        f.write(            'if ((active_code && a != active_code) '
+    #                                    '|| active_stack) {')
+    #        f.write(                'active_code = null;')
+    #        f.write(                'active_stack = null;')
+    #        f.write(                'enter_tile(a);')
+    #        f.write(                'active_code = a;')
+    ##        f.write(            '} else {')
+    ##        f.write(                'active_code = null;')
+    ##        f.write(                'active_stack = null;')
+    ###        f.write(                'leave_tile(a);')
+    #        f.write(            '}')
+    #        f.write(        '} else if (a.classList.contains("frame")'
+    #                                '|| a.classList.contains("ctx")) {')
+    #        f.write(            'if (active_stack && a != active_stack) {')
+    #        f.write(                'active_stack = null;')
+    #        f.write(                'enter_tile(a);')
+    #        f.write(                'active_stack = a;')
+    ##        f.write(            '} else {')
+    ##        f.write(                'active_code = null;')
+    ##        f.write(                'active_stack = null;')
+    ##                                # use leave_tile to rerender the stack, which
+    ##                                # will trigger mouseenter, hacky, but avoids
+    ##                                # needing to figure out the new stack state
+    ##        f.write(                'leave_tile(a);')
+    #        f.write(            '}')
+    #        f.write(        '}')
+    #
+    #                        # update the mode string
+    #        f.write(        'draw_mode(modes[state].name, '
+    #                            'active_code || active_stack);')
+
+            f.write(        'return;')
+
+    #        f.write(        'active_code = prev_code;')
+    #        f.write(        'active_stack = prev_stack;')
+    #                        # trigger a redraw
+    #        f.write(        'redraw();')
+    ##                        # use leave_tile to trigger a redraw
+    ##        f.write(        'leave_tile();')
+    ##        f.write(        'click_tile(a);')
+    ##        f.write(        'active_code = prev_code && active_code;')
+    ##        f.write(        'active_stack = prev_stack && active_stack;')
+    #        f.write(        'switch_mode(modes[state].name, '
+    #                            'active_code || active_stack);')
+    #        f.write(        'enter_tile(a);')
+    ###        f.write(        'frozen = 0;')
+    ###        f.write(        'switch_mode(modes[state].name, frozen);')
+    ###        f.write(        'enter_tile(active_code);')
+    ###        f.write(        'event.sto#pPropagation();')
+    #                        # prevent text highlighting
+    ##        f.write(        'event.preventDefault();')
+    ##        f.write(        'event.stopPropagation();')
+    ##        f.write(        'event.stopImmediatePropagation();')
+    #
+    #                        # only let a click through if we were previously
+    #                        # frozen and the tile is different
+    #        f.write(        'if (a == active_stack '
+    #                                '|| (!active_stack && a == active_code)'
+    #                                '|| (!active_stack && !active_code)) {')
+    #        f.write(        'console.log("weeee");')
+    ##        f.write(        'if (!((active_code'
+    ##                                    '&& !active_stack'
+    ##                                    '&& a != active_code)'
+    ##                                '|| (active_stack && a != active_stack))) {')
+    #        f.write(            'return;')
+    #        f.write(        '}')
+            f.write(    '}')
+                        # save state in case we are trying to double click,
+                        # double clicks always send a single click first
+    #        f.write(   'prev_frozen = frozen;')
+            f.write(    'prev_code = active_code;')
+            f.write(    'prev_stack = active_stack;')
+            #f.write(    'p_frozen = frozen;')
+
+                        # clicking tiles toggles frozen mode
+            f.write(    'if (a.classList.contains("code")) {')
+            f.write(        'if (a == active_code && !active_stack) {')
+            f.write(            'active_code = null;')
+            f.write(        '} else {')
+            f.write(            'active_code = null;')
+            f.write(            'active_stack = null;')
+            f.write(            'enter_tile(a);')
+            f.write(            'active_code = a;')
+            f.write(        '}')
+            f.write(    '} else if (a.classList.contains("frame")'
+                                '|| a.classList.contains("ctx")) {')
+            f.write(        'if (a == active_stack) {')
+            f.write(            'active_stack = null;')
+            f.write(        '} else {')
+            f.write(            'active_stack = null;')
+            f.write(            'enter_tile(a);')
+            f.write(            'active_stack = a;')
+    #        f.write(            'active_code = null;')
+    #        f.write(            'active_stack = null;')
+    #                            # use leave_tile to rerender the stack, which
+    #                            # will trigger mouseenter, hacky, but avoids
+    #                            # needing to figure out the new stack state
+    #        f.write(            'leave_tile(a);')
+            f.write(        '}')
+            f.write(    '}')
+
+    #                    # clicking tiles toggles frozen mode
+    #        f.write(    'if (a.classList.contains("code")) {')
+    #        f.write(        'if (frozen < 1) {')
+    #        f.write(            'frozen = 1;')
+    #        f.write(        '} else {')
+    #        f.write(            'frozen = 0;')
+    #        f.write(            'enter_tile(a);')
+    #        f.write(        '}')
+    #        f.write(        'switch_mode(modes[state].name, frozen);')
+    #        f.write(    '} else if (a.classList.contains("frame")'
+    #                            '|| a.classList.contains("ctx")) {')
+    #        f.write(        'if (frozen < 2) {')
+    #        f.write(            'frozen = 2;')
+    #        f.write(        '} else if (active_code) {')
+    #        f.write(            'frozen = 1;')
+    #        f.write(            'enter_tile(active_code);')
+    #        f.write(        '} else {')
+    #        f.write(            'frozen = 0;')
+    #        f.write(            'leave_tile();')
+    #        f.write(        '}')
+    #
+    ##        f.write(        'frozen = 2;')
+    ##        f.write(        'switch_mode(modes[state].name, frozen);')
+    #        f.write(    '} else {')
+    #        f.write(        'frozen = 0;')
+    ##                        # redraw code if the clicked tile is code,
+    ##                        # conveniently for us frame/ctx redraws already
+    ##                        # happen accidentally due to visibility updates,
+    ##                        # which is nice because figuring out what the
+    ##                        # new stack frame/ctx would be a huge pain (it's
+    ##                        # not a)
+    ##        f.write(        'if (a.classList.contains("code")) {')
+    ##        f.write(            'enter_tile(a);')
+    ##        f.write(        '} else {')
+    #        f.write(        'leave_tile();')
+    ##        f.write(        '}')
+    #        f.write(    '}')
+
+                        # update mode string
+            f.write(    'draw_mode();')
+                        # prevent text highlighting
+    #        f.write(    'if (event) {')
+    #        f.write(        'event.preventDefault();')
+    #        f.write(        'event.stopPropagation();')
+    #        f.write(        'event.stopImmediatePropagation();')
+    #        f.write(    '}')
+    #                    # we also bind click_tile to the top body element,
+    #                    # so we need to stop propagation if we did anything
+    #                    # prevent text highlighting
+    #        f.write(    'e.stopPropagation();')
+            f.write('}')
+
+    #        f.write('function enter_stack(a, e) {')
+    ##        f.write(    'if (!frozen) {')
+    ##        f.write(        'draw_stackpath(a.dataset.func);')
+    ##        f.write(    '}')
+    #        f.write('}')
+    #        f.write('function click_body(a, e) {')
+    #        f.write(    'console.log("hi!!!!!");')
+    #        f.write('}')
+    #        f.write('function leave_body(a, e) {')
+    #        f.write(    'if (!frozen) {')
+    #        f.write(        'undraw();')
+    #        f.write(        'last = null;')
+    #                        # reset to deepest stack
+    #        f.write(        'draw_stack("%s");' % deepest['name'])
+    #        f.write(    '}')
+    #        f.write('}')
+
+            # include some minor keybindings
+            f.write('function keydown(event) {')
+    #        f.write(    'console.log(event);')
+                        # m => change mode
+            f.write(    'if (event.key == "m") {')
+            f.write(        'click_header();')
+                        # escape/e => clear frozen/paused state
+            f.write(    '} else if (event.key == "Escape"'
+                                '|| event.key == "e") {')
+                            # reset frozen state
+            f.write(        'active_code = null;')
+            f.write(        'active_stack = null;')
+                            # reset paused state
+            f.write(        'if (paused) {')
+            f.write(            'keydown({key: "Pause"});')
+            f.write(        '}')
+                            # redraw things
+            f.write(        'draw_mode();')
+            f.write(        'redraw();')
+    #        f.write(        'if (hovered) {')
+    #        f.write(            'enter_tile(hovered);')
+    #        f.write(        '} else {')
+    #        f.write(            'leave_tile();')
+    #        f.write(        '}')
+                        # pause/p  => pause all interactivity and allow copy-paste
+            f.write(    '} else if (event.key == "Pause"'
+                                '|| event.key == "p") {')
+            f.write(        'paused = !paused;')
+                            # update mode string
+            f.write(        'draw_mode();')
+            f.write(        'if (paused) {')
+                                # enabled copy-pasting when paused
+            f.write(            'for (let e of document.querySelectorAll('
+                                        '"[style*=\\"user-select\\"]")) {')
+            f.write(                'e.style["user-select"] = "auto";')
+            f.write(            '}')
+            f.write(            'for (let e of document.querySelectorAll('
+                                        '"[cursor]")) {')
+            f.write(                'e.setAttribute("cursor", "auto");')
+            f.write(            '}')
+            f.write(        '} else {')
+                                # reset copy-pasting
+            f.write(            'document.getSelection().empty();')
+            f.write(            'for (let e of document.querySelectorAll('
+                                        '"[style*=\\"user-select\\"]")) {')
+            f.write(                'e.style["user-select"] = "none";')
+            f.write(            '}')
+            f.write(            'for (let e of document.querySelectorAll('
+                                        '"[cursor]")) {')
+            f.write(                'e.setAttribute("cursor", "pointer");')
+            f.write(            '}')
+            f.write(        '}')
+            f.write(    '}')
+            f.write('}')
+            f.write('window.addEventListener("keydown", keydown);')
+
+    #        f.write('function keyup(event) {')
+    #        f.write(    'console.log(event);')
+    #        f.write('}')
+
+    #        f.write('function scroll(event) {')
+    #        f.write(    'console.log(event);')
+    #        f.write('}')
+    #
+    #        f.write('function wheel(event) {')
+    #        f.write(    'console.log(event);')
+    #        f.write(    'event.preventDefault();')
+    #        f.write(    'event.stopPropagation();')
+    #        f.write('}')
+
+    #        f.write('window.addEventListener("keyup", keyup);')
+    #        f.write('window.addEventListener("scroll", scroll);')
+    #        f.write('window.addEventListener("wheel", wheel, {passive: false});')
+
+            f.write(']]></script>')
+
+        f.write('</svg>')
+
+
+    # print some summary info
+    if not quiet:
+        stat = code.stat()
+        print('updated %s, code %d stack %s ctx %d' % (
+                    output,
+                    totals.get('code', 0),
+                    (lambda s: '∞' if mt.isinf(s) else s)(
+                        totals.get('stack', 0)),
+                    totals.get('ctx', 0)))
+
+
+if __name__ == "__main__":
+    import argparse
+    import sys
+    parser = argparse.ArgumentParser(
+            description="Render code info as an interactive d3-esque treemap.",
+            allow_abbrev=False)
+    class AppendPath(argparse.Action):
+        def __call__(self, parser, namespace, value, option):
+            if getattr(namespace, 'paths', None) is None:
+                namespace.paths = []
+            if value is None:
+                pass
+            elif isinstance(value, str):
+                namespace.paths.append(value)
+            else:
+                namespace.paths.extend(value)
+    parser.add_argument(
+            'obj_paths',
+            nargs='*',
+            action=AppendPath,
+            help="Input *.o files.")
+    parser.add_argument(
+            'ci_paths',
+            nargs='*',
+            action=AppendPath,
+            help="Input *.ci files.")
+    parser.add_argument(
+            'csv_paths',
+            nargs='*',
+            action=AppendPath,
+            help="Input *.csv files.")
+    parser.add_argument(
+            'json_paths',
+            nargs='*',
+            action=AppendPath,
+            help="Input *.json files.")
+    parser.add_argument(
+            '-o', '--output',
+            required=True,
+            help="Output *.svg file.")
+    parser.add_argument(
+            '-n', '--namespace-depth',
+            nargs='?',
+            type=lambda x: int(x, 0),
+            const=0,
+            help="Number of underscore-separated namespaces to partition by. "
+                "0 treats every function as its own subsystem, while -1 uses "
+                "the longest matching prefix. Defaults to 2, which is "
+                "probably a good level of detail for most standalone "
+                "libraries.")
+    parser.add_argument(
+            '-v', '--verbose',
+            action='store_true',
+            help="Output commands that run behind the scenes.")
+    parser.add_argument(
+            '-q', '--quiet',
+            action='store_true',
+            help="Don't print info.")
+    parser.add_argument(
+            '-L', '--add-label',
+            dest='labels',
+            action='append',
+            type=lambda x: (
+                lambda ks, v: (
+                    tuple(k.strip() for k in ks.split(',')),
+                    v.strip())
+                )(*x.split('=', 1))
+                    if '=' in x else x.strip(),
+            help="Add a label to use. Can be assigned to a specific "
+                "function/subsystem. Accepts %% modifiers.")
+    parser.add_argument(
+            '-C', '--add-color',
+            dest='colors',
+            action='append',
+            type=lambda x: (
+                lambda ks, v: (
+                    tuple(k.strip() for k in ks.split(',')),
+                    v.strip())
+                )(*x.split('=', 1))
+                    if '=' in x else x.strip(),
+            # TODO % modifiers in color everywhere? chars? formats? etc?
+            help="Add a color to use. Can be assigned to a specific "
+                "function/subsystem. Accepts %% modifiers.")
+    parser.add_argument(
+            '-W', '--width',
+            type=lambda x: int(x, 0),
+            help="Width in pixels. Defaults to %r." % WIDTH)
+    parser.add_argument(
+            '-H', '--height',
+            type=lambda x: int(x, 0),
+            help="Height in pixels. Defaults to %r." % HEIGHT)
+    parser.add_argument(
+            '-N', '--no-header',
+            action='store_true',
+            help="Don't show the header.")
+    parser.add_argument(
+            '--no-mode',
+            action='store_true',
+            help="Don't show the mode state.")
+    parser.add_argument(
+            '--no-stack',
+            action='store_true',
+            help="Don't render any stack info.")
+    parser.add_argument(
+            '-S', '--stack-ratio',
+            type=lambda x: (
+                (lambda a, b: a / b)(*(float(v) for v in x.split(':', 1)))
+                    if ':' in x else float(x)),
+            help="Ratio of width to use for stack info. Defaults to 1:5.")
+    parser.add_argument(
+            '--no-ctx',
+            action='store_true',
+            help="Don't render function context.")
+    parser.add_argument(
+            '--no-frames',
+            action='store_true',
+            help="Don't render function stack frame info.")
+    parser.add_argument(
+            '-J', '--no-javascript',
+            action='store_true',
+            help="Don't add javascript for interactability.")
+    parser.add_argument(
+            '--mode-callgraph',
+            action='store_true',
+            help="Include the callgraph rendering mode.")
+    parser.add_argument(
+            '--mode-deepest',
+            action='store_true',
+            help="Include the deepest rendering mode.")
+    parser.add_argument(
+            '--mode-callees',
+            action='store_true',
+            help="Include the callees rendering mode.")
+    parser.add_argument(
+            '--mode-callers',
+            action='store_true',
+            help="Include the callers rendering mode.")
+    parser.add_argument(
+            '--binary',
+            action='store_true',
+            help="Use the binary partitioning scheme. This attempts to "
+                "recursively subdivide the tiles into a roughly "
+                "weight-balanced binary tree. This is the default.")
+    parser.add_argument(
+            '--slice',
+            action='store_true',
+            help="Use the slice partitioning scheme. This simply slices "
+                "tiles vertically.")
+    parser.add_argument(
+            '--dice',
+            action='store_true',
+            help="Use the dice partitioning scheme. This simply slices "
+                "tiles horizontally.")
+    parser.add_argument(
+            '--slice-and-dice',
+            action='store_true',
+            help="Use the slice-and-dice partitioning scheme. This "
+                "alternates between slicing and dicing each layer.")
+    parser.add_argument(
+            '--dice-and-slice',
+            action='store_true',
+            help="Use the dice-and-slice partitioning scheme. This is like "
+                "slice-and-dice, but flipped.")
+    parser.add_argument(
+            '--squarify',
+            action='store_true',
+            help="Use the squarify partitioning scheme. This is a greedy "
+                "algorithm created by Mark Bruls et al that tries to "
+                "minimize tile aspect ratios.")
+    parser.add_argument(
+            '--rectify',
+            action='store_true',
+            help="Use the rectify partitioning scheme. This is like "
+                "squarify, but tries to match the aspect ratio of the "
+                "window.")
+    parser.add_argument(
+            '--to-scale',
+            nargs='?',
+            type=lambda x: (
+                (lambda a, b: a / b)(*(float(v) for v in x.split(':', 1)))
+                    if ':' in x else float(x)),
+            const=1,
+            help="Scale the resulting treemap such that 1 pixel ~= 1/scale "
+                "units. Defaults to scale=1. ")
+    parser.add_argument(
+            '-R', '--aspect-ratio',
+            type=lambda x: (
+                tuple(float(v) for v in x.split(':', 1))
+                    if ':' in x else (float(x), 1)),
+            help="Aspect ratio to use with --to-scale. Defaults to 1:1.")
+    # TODO add tiny to treemap.py / codemap.py?
+    parser.add_argument(
+            '-t', '--tiny',
+            action='store_true',
+            help="Tiny mode, alias for --to-scale=1, --no-header, "
+                "--no-label, --no-stack, and --no-javascript.")
+    parser.add_argument(
+            '--title',
+            help="Add a title. Accepts %% modifiers.")
+    parser.add_argument(
+            '--padding',
+            type=float,
+            help="Padding to add to each level of the treemap. Defaults to 1.")
+    parser.add_argument(
+            '--no-label',
+            action='store_true',
+            help="Don't render any labels.")
+    parser.add_argument(
+            '--dark',
+            action='store_true',
+            help="Use the dark style.")
+    parser.add_argument(
+            '--font',
+            type=lambda x: [x.strip() for x in x.split(',')],
+            help="Font family to use.")
+    parser.add_argument(
+            '--font-size',
+            help="Font size to use. Defaults to %r." % FONT_SIZE)
+    parser.add_argument(
+            '--background',
+            help="Background color to use. Note #00000000 can make the "
+                "background transparent.")
+    parser.add_argument(
+            '--code-path',
+            type=lambda x: x.split(),
+            default=CODE_PATH,
+            help="Path to the code.py script, may include flags. "
+                "Defaults to %r." % CODE_PATH)
+    parser.add_argument(
+            '--stack-path',
+            type=lambda x: x.split(),
+            default=STACK_PATH,
+            help="Path to the stack.py script, may include flags. "
+                "Defaults to %r." % STACK_PATH)
+    parser.add_argument(
+            '--ctx-path',
+            type=lambda x: x.split(),
+            default=CTX_PATH,
+            help="Path to the ctx.py script, may include flags. "
+                "Defaults to %r." % CTX_PATH)
+    sys.exit(main(**{k: v
+            for k, v in vars(parser.parse_intermixed_args()).items()
+            if v is not None}))
diff --git a/scripts/treemap.py b/scripts/treemap.py
index dc316fad..f718ec75 100755
--- a/scripts/treemap.py
+++ b/scripts/treemap.py
@@ -1141,22 +1141,24 @@ if __name__ == "__main__":
     parser.add_argument(
             '--to-scale',
             nargs='?',
-            type=float,
+            type=lambda x: (
+                (lambda a, b: a / b)(*(float(v) for v in x.split(':', 1)))
+                    if ':' in x else float(x)),
             const=1,
             help="Scale the resulting treemap such that 1 pixel ~= 1/scale "
                 "units. Defaults to scale=1. ")
     parser.add_argument(
             '-R', '--aspect-ratio',
-            type=lambda x: tuple(float(v) for v in x.split(':', 1)),
-            default=(1, 1),
+            type=lambda x: (
+                tuple(float(v) for v in x.split(':', 1))
+                    if ':' in x else (float(x), 1)),
             help="Aspect ratio to use with --to-scale. Defaults to 1:1.")
     parser.add_argument(
             '--title',
-            help="Add a title.")
+            help="Add a title. Accepts %% modifiers.")
     parser.add_argument(
             '--padding',
             type=float,
-            default=0,
             help="Padding to add to each level of the treemap. Defaults to 0.")
     parser.add_argument(
             '-l', '--label',
diff --git a/scripts/treemapd3.py b/scripts/treemapd3.py
index e8609cd3..1cd7a755 100755
--- a/scripts/treemapd3.py
+++ b/scripts/treemapd3.py
@@ -577,7 +577,8 @@ def main(csv_paths, output, *,
         **args):
     # tiny mode?
     if tiny:
-        to_scale = True
+        if to_scale is None:
+            to_scale = 1
         no_header = True
         no_label = True
 
@@ -666,7 +667,9 @@ def main(csv_paths, output, *,
             t.label = punescape(labels_[i, t.key], t.attrs)
 
     # scale width/height if requested now that we have our data
-    if to_scale and (width is None or height is None) and tile.value != 0:
+    if (to_scale is not None
+            and (width is None or height is None)
+            and tile.value != 0):
         # scale width only
         if height is not None:
             width_ = mt.ceil((tile.value * to_scale) / height_)
@@ -907,7 +910,7 @@ if __name__ == "__main__":
     import argparse
     import sys
     parser = argparse.ArgumentParser(
-            description="Render CSV files as a treemap to a d3-esque svg.",
+            description="Render CSV files as a d3-esque treemap.",
             allow_abbrev=False)
     parser.add_argument(
             'csv_paths',
@@ -1022,14 +1025,17 @@ if __name__ == "__main__":
     parser.add_argument(
             '--to-scale',
             nargs='?',
-            type=float,
+            type=lambda x: (
+                (lambda a, b: a / b)(*(float(v) for v in x.split(':', 1)))
+                    if ':' in x else float(x)),
             const=1,
             help="Scale the resulting treemap such that 1 pixel ~= 1/scale "
                 "units. Defaults to scale=1. ")
     parser.add_argument(
             '-R', '--aspect-ratio',
-            type=lambda x: tuple(float(v) for v in x.split(':', 1)),
-            default=(1, 1),
+            type=lambda x: (
+                tuple(float(v) for v in x.split(':', 1))
+                    if ':' in x else (float(x), 1)),
             help="Aspect ratio to use with --to-scale. Defaults to 1:1.")
     parser.add_argument(
             '-t', '--tiny',
@@ -1042,11 +1048,10 @@ if __name__ == "__main__":
             help="Show nested tiles.")
     parser.add_argument(
             '--title',
-            help="Add a title.")
+            help="Add a title. Accepts %% modifiers.")
     parser.add_argument(
             '--padding',
             type=float,
-            default=1,
             help="Padding to add to each level of the treemap. Defaults to 1.")
     parser.add_argument(
             '--no-label',