diff --git a/tools/mk2bp_catalog.py b/tools/mk2bp_catalog.py
new file mode 100755
index 0000000..83abd62
--- /dev/null
+++ b/tools/mk2bp_catalog.py
@@ -0,0 +1,892 @@
+#!/usr/bin/env python3
+
+"""
+Command to print info about makefiles remaining to be converted to soong.
+
+See usage / argument parsing below for commandline options.
+"""
+
+import argparse
+import csv
+import itertools
+import json
+import os
+import re
+import sys
+
+DIRECTORY_PATTERNS = [x.split("/") for x in (
+  "device/*",
+  "frameworks/*",
+  "hardware/*",
+  "packages/*",
+  "vendor/*",
+  "*",
+)]
+
+def match_directory_group(pattern, filename):
+  match = []
+  filename = filename.split("/")
+  if len(filename) < len(pattern):
+    return None
+  for i in range(len(pattern)):
+    pattern_segment = pattern[i]
+    filename_segment = filename[i]
+    if pattern_segment == "*" or pattern_segment == filename_segment:
+      match.append(filename_segment)
+    else:
+      return None
+  if match:
+    return os.path.sep.join(match)
+  else:
+    return None
+
+def directory_group(filename):
+  for pattern in DIRECTORY_PATTERNS:
+    match = match_directory_group(pattern, filename)
+    if match:
+      return match
+  return os.path.dirname(filename)
+
+class Analysis(object):
+  def __init__(self, filename, line_matches):
+    self.filename = filename;
+    self.line_matches = line_matches
+
+def analyze_lines(filename, lines, func):
+  line_matches = []
+  for i in range(len(lines)):
+    line = lines[i]
+    stripped = line.strip()
+    if stripped.startswith("#"):
+      continue
+    if func(stripped):
+      line_matches.append((i+1, line))
+  if line_matches:
+    return Analysis(filename, line_matches);
+
+def analyze_has_conditional(line):
+  return (line.startswith("ifeq") or line.startswith("ifneq")
+          or line.startswith("ifdef") or line.startswith("ifndef"))
+
+NORMAL_INCLUDES = [re.compile(pattern) for pattern in (
+  "include \$+\(CLEAR_VARS\)", # These are in defines which are tagged separately
+  "include \$+\(BUILD_.*\)",
+  "include \$\(call first-makefiles-under, *\$\(LOCAL_PATH\)\)",
+  "include \$\(call all-subdir-makefiles\)",
+  "include \$\(all-subdir-makefiles\)",
+  "include \$\(call all-makefiles-under, *\$\(LOCAL_PATH\)\)",
+  "include \$\(call all-makefiles-under, *\$\(call my-dir\).*\)",
+  "include \$\(BUILD_SYSTEM\)/base_rules.mk", # called out separately
+  "include \$\(call all-named-subdir-makefiles,.*\)",
+  "include \$\(subdirs\)",
+)]
+def analyze_has_wacky_include(line):
+  if not (line.startswith("include") or line.startswith("-include")
+          or line.startswith("sinclude")):
+    return False
+  for matcher in NORMAL_INCLUDES:
+    if matcher.fullmatch(line):
+      return False
+  return True
+
+BASE_RULES_RE = re.compile("include \$\(BUILD_SYSTEM\)/base_rules.mk")
+
+class Analyzer(object):
+  def __init__(self, title, func):
+    self.title = title;
+    self.func = func
+
+
+ANALYZERS = (
+  Analyzer("ifeq / ifneq", analyze_has_conditional),
+  Analyzer("Wacky Includes", analyze_has_wacky_include),
+  Analyzer("Calls base_rules", lambda line: BASE_RULES_RE.fullmatch(line)),
+  Analyzer("Calls define", lambda line: line.startswith("define ")),
+  Analyzer("Has ../", lambda line: "../" in line),
+  Analyzer("dist-for-&#8203;goals", lambda line: "dist-for-goals" in line),
+  Analyzer(".PHONY", lambda line: ".PHONY" in line),
+  Analyzer("render-&#8203;script", lambda line: ".rscript" in line),
+  Analyzer("vts src", lambda line: ".vts" in line),
+  Analyzer("COPY_&#8203;HEADERS", lambda line: "LOCAL_COPY_HEADERS" in line),
+)
+
+class Summary(object):
+  def __init__(self):
+    self.makefiles = dict()
+    self.directories = dict()
+
+  def Add(self, makefile):
+    self.makefiles[makefile.filename] = makefile
+    self.directories.setdefault(directory_group(makefile.filename), []).append(makefile)
+
+class Makefile(object):
+  def __init__(self, filename):
+    self.filename = filename
+
+    # Analyze the file
+    with open(filename, "r", errors="ignore") as f:
+      try:
+        lines = f.readlines()
+      except UnicodeDecodeError as ex:
+        sys.stderr.write("Filename: %s\n" % filename)
+        raise ex
+    lines = [line.strip() for line in lines]
+
+    self.analyses = dict([(analyzer, analyze_lines(filename, lines, analyzer.func)) for analyzer
+        in ANALYZERS])
+
+def find_android_mk():
+  cwd = os.getcwd()
+  for root, dirs, files in os.walk(cwd):
+    for filename in files:
+      if filename == "Android.mk":
+        yield os.path.join(root, filename)[len(cwd) + 1:]
+    for ignore in (".git", ".repo"):
+      if ignore in dirs:
+        dirs.remove(ignore)
+
+def is_aosp(dirname):
+  for d in ("device/sample", "hardware/interfaces", "hardware/libhardware",
+          "hardware/ril"):
+    if dirname.startswith(d):
+      return True
+  for d in ("device/", "hardware/", "vendor/"):
+    if dirname.startswith(d):
+      return False
+  return True
+
+def is_google(dirname):
+  for d in ("device/google",
+            "hardware/google",
+            "test/sts",
+            "vendor/auto",
+            "vendor/google",
+            "vendor/unbundled_google",
+            "vendor/widevine",
+            "vendor/xts"):
+    if dirname.startswith(d):
+      return True
+  return False
+
+def make_annotation_link(annotations, analysis, modules):
+  if analysis:
+    return "<a href='javascript:update_details(%d)'>%s</a>" % (
+      annotations.Add(analysis, modules),
+      len(analysis)
+    )
+  else:
+    return "";
+
+
+def is_clean(makefile):
+  for analysis in makefile.analyses.values():
+    if analysis:
+      return False
+  return True
+
+class Annotations(object):
+  def __init__(self):
+    self.entries = []
+    self.count = 0
+
+  def Add(self, makefiles, modules):
+    self.entries.append((makefiles, modules))
+    self.count += 1
+    return self.count-1
+
+class SoongData(object):
+  def __init__(self, reader):
+    """Read the input file and store the modules and dependency mappings.
+    """
+    self.problems = dict()
+    self.deps = dict()
+    self.reverse_deps = dict()
+    self.module_types = dict()
+    self.makefiles = dict()
+    self.reverse_makefiles = dict()
+    self.installed = dict()
+    self.modules = set()
+
+    for (module, module_type, problem, dependencies, makefiles, installed) in reader:
+      self.modules.add(module)
+      makefiles = [f for f in makefiles.strip().split(' ') if f != ""]
+      self.module_types[module] = module_type
+      self.problems[module] = problem
+      self.deps[module] = [d for d in dependencies.strip().split(' ') if d != ""]
+      for dep in self.deps[module]:
+        if not dep in self.reverse_deps:
+          self.reverse_deps[dep] = []
+        self.reverse_deps[dep].append(module)
+      self.makefiles[module] = makefiles
+      for f in makefiles:
+        self.reverse_makefiles.setdefault(f, []).append(module)
+      for f in installed.strip().split(' '):
+        self.installed[f] = module
+
+def count_deps(depsdb, module, seen):
+  """Based on the depsdb, count the number of transitive dependencies.
+
+  You can pass in an reversed dependency graph to count the number of
+  modules that depend on the module."""
+  count = 0
+  seen.append(module)
+  if module in depsdb:
+    for dep in depsdb[module]:
+      if dep in seen:
+        continue
+      count += 1 + count_deps(depsdb, dep, seen)
+  return count
+
+def contains_unblocked_modules(soong, modules):
+  for m in modules:
+    if len(soong.deps[m]) == 0:
+      return True
+  return False
+
+def contains_blocked_modules(soong, modules):
+  for m in modules:
+    if len(soong.deps[m]) > 0:
+      return True
+  return False
+
+OTHER_PARTITON = "_other"
+HOST_PARTITON = "_host"
+
+def get_partition_from_installed(HOST_OUT_ROOT, PRODUCT_OUT, filename):
+  host_prefix = HOST_OUT_ROOT + "/"
+  device_prefix = PRODUCT_OUT + "/"
+
+  if filename.startswith(host_prefix):
+    return HOST_PARTITON
+
+  elif filename.startswith(device_prefix):
+    index = filename.find("/", len(device_prefix))
+    if index < 0:
+      return OTHER_PARTITON
+    return filename[len(device_prefix):index]
+
+  return OTHER_PARTITON
+
+def format_module_link(module):
+  return "<a class='ModuleLink' href='#module_%s'>%s</a>" % (module, module)
+
+def format_module_list(modules):
+  return "".join(["<div>%s</div>" % format_module_link(m) for m in modules])
+
+def main():
+  parser = argparse.ArgumentParser(description="Info about remaining Android.mk files.")
+  parser.add_argument("--device", type=str, required=True,
+                      help="TARGET_DEVICE")
+  parser.add_argument("--title", type=str,
+                      help="page title")
+  parser.add_argument("--codesearch", type=str,
+                      default="https://cs.android.com/android/platform/superproject/+/master:",
+                      help="page title")
+  parser.add_argument("--out_dir", type=str,
+                      default=None,
+                      help="Equivalent of $OUT_DIR, which will also be checked if"
+                        + " --out_dir is unset. If neither is set, default is"
+                        + " 'out'.")
+
+  args = parser.parse_args()
+
+  # Guess out directory name
+  if not args.out_dir:
+    args.out_dir = os.getenv("OUT_DIR", "out")
+  while args.out_dir.endswith("/") and len(args.out_dir) > 1:
+    args.out_dir = args.out_dir[:-1]
+
+  TARGET_DEVICE = args.device
+  HOST_OUT_ROOT = args.out_dir + "host"
+  PRODUCT_OUT = args.out_dir + "/target/product/%s" % TARGET_DEVICE
+
+  if args.title:
+    page_title = args.title
+  else:
+    page_title = "Remaining Android.mk files"
+
+  # Read target information
+  # TODO: Pull from configurable location. This is also slightly different because it's
+  # only a single build, where as the tree scanning we do below is all Android.mk files.
+  with open("%s/obj/PACKAGING/soong_conversion_intermediates/soong_conv_data"
+      % PRODUCT_OUT, "r", errors="ignore") as csvfile:
+    soong = SoongData(csv.reader(csvfile))
+
+  # Which modules are installed where
+  modules_by_partition = dict()
+  partitions = set()
+  for installed, module in soong.installed.items():
+    partition = get_partition_from_installed(HOST_OUT_ROOT, PRODUCT_OUT, installed)
+    modules_by_partition.setdefault(partition, []).append(module)
+    partitions.add(partition)
+
+  print("""
+  <html>
+    <head>
+      <title>%(page_title)s</title>
+      <style type="text/css">
+        body, table {
+          font-family: Roboto, sans-serif;
+          font-size: 9pt;
+        }
+        body {
+          margin: 0;
+          padding: 0;
+          display: flex;
+          flex-direction: column;
+          height: 100vh;
+        }
+        #container {
+          flex: 1;
+          display: flex;
+          flex-direction: row;
+          overflow: hidden;
+        }
+        #tables {
+          padding: 0 20px 0 20px;
+          overflow: scroll;
+          flex: 2 2 600px;
+        }
+        #details {
+          display: none;
+          overflow: scroll;
+          flex: 1 1 650px;
+          padding: 0 20px 0 20px;
+        }
+        h1 {
+          margin: 16px 0 16px 20px;
+        }
+        h2 {
+          margin: 12px 0 4px 0;
+        }
+        .DirName {
+          text-align: left;
+          width: 200px;
+          min-width: 200px;
+        }
+        .Count {
+          text-align: center;
+          width: 60px;
+          min-width: 60px;
+          max-width: 60px;
+        }
+        th.Clean,
+        th.Unblocked {
+          background-color: #1e8e3e;
+        }
+        th.Blocked {
+          background-color: #d93025;
+        }
+        th.Warning {
+          background-color: #e8710a;
+        }
+        th {
+          background-color: #1a73e8;
+          color: white;
+          font-weight: bold;
+        }
+        td.Unblocked {
+          background-color: #81c995;
+        }
+        td.Blocked {
+          background-color: #f28b82;
+        }
+        td, th {
+          padding: 2px 4px;
+          border-right: 2px solid white;
+        }
+        tr.AospDir td {
+          background-color: #e6f4ea;
+          border-right-color: #e6f4ea;
+        }
+        tr.GoogleDir td {
+          background-color: #e8f0fe;
+          border-right-color: #e8f0fe;
+        }
+        tr.PartnerDir td {
+          background-color: #fce8e6;
+          border-right-color: #fce8e6;
+        }
+        table {
+          border-spacing: 0;
+          border-collapse: collapse;
+        }
+        div.Makefile {
+          margin: 12px 0 0 0;
+        }
+        div.Makefile:first {
+          margin-top: 0;
+        }
+        div.FileModules {
+          padding: 4px 0 0 20px;
+        }
+        td.LineNo {
+          vertical-align: baseline;
+          padding: 6px 0 0 20px;
+          width: 50px;
+          vertical-align: baseline;
+        }
+        td.LineText {
+          vertical-align: baseline;
+          font-family: monospace;
+          padding: 6px 0 0 0;
+        }
+        a.CsLink {
+          font-family: monospace;
+        }
+        div.Help {
+          width: 550px;
+        }
+        table.HelpColumns tr {
+          border-bottom: 2px solid white;
+        }
+        .ModuleName {
+          vertical-align: baseline;
+          padding: 6px 0 0 20px;
+          width: 275px;
+        }
+        .ModuleDeps {
+          vertical-align: baseline;
+          padding: 6px 0 0 0;
+        }
+        table#Modules td {
+          vertical-align: baseline;
+        }
+        tr.Alt {
+          background-color: #ececec;
+        }
+        tr.Alt td {
+          border-right-color: #ececec;
+        }
+        .AnalysisCol {
+          width: 300px;
+          padding: 2px;
+          line-height: 21px;
+        }
+        .Analysis {
+          color: white;
+          font-weight: bold;
+          background-color: #e8710a;
+          border-radius: 6px;
+          margin: 4px;
+          padding: 2px 6px;
+          white-space: nowrap;
+        }
+        .Nav {
+          margin: 4px 0 16px 20px;
+        }
+        .NavSpacer {
+          display: inline-block;
+          width: 6px;
+        }
+        .ModuleDetails {
+          margin-top: 20px;
+        }
+        .ModuleDetails td {
+          vertical-align: baseline;
+        }
+      </style>
+    </head>
+    <body>
+      <h1>%(page_title)s</h1>
+      <div class="Nav">
+        <a href='#help'>Help</a>
+        <span class='NavSpacer'></span><span class='NavSpacer'> </span>
+        Partitions:
+  """ % {
+    "page_title": page_title,
+  })
+  for partition in sorted(partitions):
+    print("<a href='#partition_%s'>%s</a><span class='NavSpacer'></span>" % (partition, partition))
+
+  print("""
+        <span class='NavSpacer'></span><span class='NavSpacer'> </span>
+      </div>
+      <div id="container">
+        <div id="tables">
+        <a name="help"></a>
+        <div class="Help">
+          <p>
+          This page analyzes the remaining Android.mk files in the Android Source tree.
+          <p>
+          The modules are first broken down by which of the device filesystem partitions
+          they are installed to. This also includes host tools and testcases which don't
+          actually reside in their own partition but convenitely group together.
+          <p>
+          The makefiles for each partition are further are grouped into a set of directories
+          aritrarily picked to break down the problem size by owners.
+          <ul style="width: 300px">
+            <li style="background-color: #e6f4ea">AOSP directories are colored green.</li>
+            <li style="background-color: #e8f0fe">Google directories are colored blue.</li>
+            <li style="background-color: #fce8e6">Other partner directories are colored red.</li>
+          </ul>
+          Each of the makefiles are scanned for issues that are likely to come up during
+          conversion to soong.  Clicking the number in each cell shows additional information,
+          including the line that triggered the warning.
+          <p>
+          <table class="HelpColumns">
+            <tr>
+              <th>Total</th>
+              <td>The total number of makefiles in this each directory.</td>
+            </tr>
+            <tr>
+              <th class="Unblocked">Unblocked</th>
+              <td>Makefiles containing one or more modules that don't have any
+                  additional dependencies pending before conversion.</td>
+            </tr>
+            <tr>
+              <th class="Blocked">Blocked</th>
+              <td>Makefiles containiong one or more modules which <i>do</i> have
+                  additional prerequesite depenedencies that are not yet converted.</td>
+            </tr>
+            <tr>
+              <th class="Clean">Clean</th>
+              <td>The number of makefiles that have none of the following warnings.</td>
+            </tr>
+            <tr>
+              <th class="Warning">ifeq / ifneq</th>
+              <td>Makefiles that use <code>ifeq</code> or <code>ifneq</code>. i.e.
+              conditionals.</td>
+            </tr>
+            <tr>
+              <th class="Warning">Wacky Includes</th>
+              <td>Makefiles that <code>include</code> files other than the standard build-system
+                  defined template and macros.</td>
+            </tr>
+            <tr>
+              <th class="Warning">Calls base_rules</th>
+              <td>Makefiles that include base_rules.mk directly.</td>
+            </tr>
+            <tr>
+              <th class="Warning">Calls define</th>
+              <td>Makefiles that define their own macros. Some of these are easy to convert
+                  to soong <code>defaults</code>, but others are complex.</td>
+            </tr>
+            <tr>
+              <th class="Warning">Has ../</th>
+              <td>Makefiles containing the string "../" outside of a comment. These likely
+                  access files outside their directories.</td>
+            </tr>
+            <tr>
+              <th class="Warning">dist-for-goals</th>
+              <td>Makefiles that call <code>dist-for-goals</code> directly.</td>
+            </tr>
+            <tr>
+              <th class="Warning">.PHONY</th>
+              <td>Makefiles that declare .PHONY targets.</td>
+            </tr>
+            <tr>
+              <th class="Warning">renderscript</th>
+              <td>Makefiles defining targets that depend on <code>.rscript</code> source files.</td>
+            </tr>
+            <tr>
+              <th class="Warning">vts src</th>
+              <td>Makefiles defining targets that depend on <code>.vts</code> source files.</td>
+            </tr>
+            <tr>
+              <th class="Warning">COPY_HEADERS</th>
+              <td>Makefiles using LOCAL_COPY_HEADERS.</td>
+            </tr>
+          </table>
+          <p>
+          Following the list of directories is a list of the modules that are installed on
+          each partition. Potential issues from their makefiles are listed, as well as the
+          total number of dependencies (both blocking that module and blocked by that module)
+          and the list of direct dependencies.  Note: The number is the number of all transitive
+          dependencies and the list of modules is only the direct dependencies.
+        </div>
+  """)
+
+  annotations = Annotations()
+
+  # For each partition
+  makefiles_for_partitions = dict()
+  for partition in sorted(partitions):
+    modules = modules_by_partition[partition]
+
+    makefiles = set(itertools.chain.from_iterable(
+        [soong.makefiles[module] for module in modules]))
+
+    # Read makefiles
+    summary = Summary()
+    for filename in makefiles:
+      if not filename.startswith(args.out_dir + "/"):
+        summary.Add(Makefile(filename))
+
+    # Categorize directories by who is responsible
+    aosp_dirs = []
+    google_dirs = []
+    partner_dirs = []
+    for dirname in sorted(summary.directories.keys()):
+      if is_aosp(dirname):
+        aosp_dirs.append(dirname)
+      elif is_google(dirname):
+        google_dirs.append(dirname)
+      else:
+        partner_dirs.append(dirname)
+
+    print("""
+      <a name="partition_%(partition)s"></a>
+      <h2>%(partition)s</h2>
+      <table>
+        <tr>
+          <th class="DirName">Directory</th>
+          <th class="Count">Total</th>
+          <th class="Count Unblocked">Unblocked</th>
+          <th class="Count Blocked">Blocked</th>
+          <th class="Count Clean">Clean</th>
+    """ % {
+      "partition": partition
+    })
+
+    for analyzer in ANALYZERS:
+      print("""<th class="Count Warning">%s</th>""" % analyzer.title)
+
+    print("      </tr>")
+    for dirgroup, rowclass in [(aosp_dirs, "AospDir"),
+                               (google_dirs, "GoogleDir"),
+                               (partner_dirs, "PartnerDir"),]:
+      for dirname in dirgroup:
+        makefiles = summary.directories[dirname]
+
+        all_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles]
+        clean_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles
+            if is_clean(makefile)]
+        unblocked_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles
+            if contains_unblocked_modules(soong,
+              soong.reverse_makefiles[makefile.filename])]
+        blocked_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles
+            if contains_blocked_modules(soong,
+              soong.reverse_makefiles[makefile.filename])]
+
+        print("""
+          <tr class="%(rowclass)s">
+            <td class="DirName">%(dirname)s</td>
+            <td class="Count">%(makefiles)s</td>
+            <td class="Count">%(unblocked)s</td>
+            <td class="Count">%(blocked)s</td>
+            <td class="Count">%(clean)s</td>
+        """ % {
+          "rowclass": rowclass,
+          "dirname": dirname,
+          "makefiles": make_annotation_link(annotations, all_makefiles, modules),
+          "unblocked": make_annotation_link(annotations, unblocked_makefiles, modules),
+          "blocked": make_annotation_link(annotations, blocked_makefiles, modules),
+          "clean": make_annotation_link(annotations, clean_makefiles, modules),
+        })
+        for analyzer in ANALYZERS:
+          analyses = [m.analyses.get(analyzer) for m in makefiles if m.analyses.get(analyzer)]
+          print("""<td class="Count">%s</td>"""
+              % make_annotation_link(annotations, analyses, modules))
+
+        print("      </tr>")
+    print("""
+      </table>
+    """)
+
+    module_details = [(count_deps(soong.deps, m, []), -count_deps(soong.reverse_deps, m, []), m)
+               for m in modules]
+    module_details.sort()
+    module_details = [m[2] for m in module_details]
+    print("""
+      <table class="ModuleDetails">""")
+    print("<tr>")
+    print("  <th>Module Name</th>")
+    print("  <th>Issues</th>")
+    print("  <th colspan='2'>Blocked By</th>")
+    print("  <th colspan='2'>Blocking</th>")
+    print("</tr>")
+    altRow = True
+    for module in module_details:
+      analyses = set()
+      for filename in soong.makefiles[module]:
+        makefile = summary.makefiles.get(filename)
+        if makefile:
+          for analyzer, analysis in makefile.analyses.items():
+            if analysis:
+              analyses.add(analyzer.title)
+
+      altRow = not altRow
+      print("<tr class='%s'>" % ("Alt" if altRow else "",))
+      print("  <td><a name='module_%s'></a>%s</td>" % (module, module))
+      print("  <td class='AnalysisCol'>%s</td>" % " ".join(["<span class='Analysis'>%s</span>" % title
+          for title in analyses]))
+      print("  <td>%s</td>" % count_deps(soong.deps, module, []))
+      print("  <td>%s</td>" % format_module_list(soong.deps.get(module, [])))
+      print("  <td>%s</td>" % count_deps(soong.reverse_deps, module, []))
+      print("  <td>%s</td>" % format_module_list(soong.reverse_deps.get(module, [])))
+      print("</tr>")
+    print("""</table>""")
+
+  print("""
+    <script type="text/javascript">
+    function close_details() {
+      document.getElementById('details').style.display = 'none';
+    }
+
+    class LineMatch {
+      constructor(lineno, text) {
+        this.lineno = lineno;
+        this.text = text;
+      }
+    }
+
+    class Analysis {
+      constructor(filename, modules, line_matches) {
+        this.filename = filename;
+        this.modules = modules;
+        this.line_matches = line_matches;
+      }
+    }
+
+    class Module {
+      constructor(deps) {
+        this.deps = deps;
+      }
+    }
+
+    function make_module_link(module) {
+      var a = document.createElement('a');
+      a.className = 'ModuleLink';
+      a.innerText = module;
+      a.href = '#module_' + module;
+      return a;
+    }
+
+    function update_details(id) {
+      document.getElementById('details').style.display = 'block';
+
+      var analyses = ANALYSIS[id];
+
+      var details = document.getElementById("details_data");
+      while (details.firstChild) {
+          details.removeChild(details.firstChild);
+      }
+
+      for (var i=0; i<analyses.length; i++) {
+        var analysis = analyses[i];
+
+        var makefileDiv = document.createElement('div');
+        makefileDiv.className = 'Makefile';
+        details.appendChild(makefileDiv);
+
+        var fileA = document.createElement('a');
+        makefileDiv.appendChild(fileA);
+        fileA.className = 'CsLink';
+        fileA.href = '%(codesearch)s' + analysis.filename;
+        fileA.innerText = analysis.filename;
+        fileA.target = "_blank";
+
+        if (analysis.modules.length > 0) {
+          var moduleTable = document.createElement('table');
+          details.appendChild(moduleTable);
+
+          for (var j=0; j<analysis.modules.length; j++) {
+            var moduleRow = document.createElement('tr');
+            moduleTable.appendChild(moduleRow);
+
+            var moduleNameCell = document.createElement('td');
+            moduleRow.appendChild(moduleNameCell);
+            moduleNameCell.className = 'ModuleName';
+            moduleNameCell.appendChild(make_module_link(analysis.modules[j]));
+
+            var moduleData = MODULE_DATA[analysis.modules[j]];
+            console.log(moduleData);
+
+            var depCell = document.createElement('td');
+            moduleRow.appendChild(depCell);
+
+            if (moduleData.deps.length == 0) {
+              depCell.className = 'ModuleDeps Unblocked';
+              depCell.innerText = 'UNBLOCKED';
+            } else {
+              depCell.className = 'ModuleDeps Blocked';
+
+              for (var k=0; k<moduleData.deps.length; k++) {
+                depCell.appendChild(make_module_link(moduleData.deps[k]));
+                depCell.appendChild(document.createElement('br'));
+              }
+            }
+          }
+        }
+
+        if (analysis.line_matches.length > 0) {
+          var lineTable = document.createElement('table');
+          details.appendChild(lineTable);
+
+          for (var j=0; j<analysis.line_matches.length; j++) {
+            var line_match = analysis.line_matches[j];
+
+            var lineRow = document.createElement('tr');
+            lineTable.appendChild(lineRow);
+
+            var linenoCell = document.createElement('td');
+            lineRow.appendChild(linenoCell);
+            linenoCell.className = 'LineNo';
+
+            var linenoA = document.createElement('a');
+            linenoCell.appendChild(linenoA);
+            linenoA.className = 'CsLink';
+            linenoA.href = '%(codesearch)s' + analysis.filename
+                + ';l=' + line_match.lineno;
+            linenoA.innerText = line_match.lineno;
+            linenoA.target = "_blank";
+
+            var textCell = document.createElement('td');
+            lineRow.appendChild(textCell);
+            textCell.className = 'LineText';
+            textCell.innerText = line_match.text;
+          }
+        }
+      }
+    }
+
+    var ANALYSIS = [
+    """ % {
+        "codesearch": args.codesearch,
+    })
+  for entry, mods in annotations.entries:
+    print("  [")
+    for analysis in entry:
+      print("    new Analysis('%(filename)s', %(modules)s, [%(line_matches)s])," % {
+        "filename": analysis.filename,
+        #"modules": json.dumps([m for m in mods if m in filename in soong.makefiles[m]]),
+        "modules": json.dumps(
+            [m for m in soong.reverse_makefiles[analysis.filename] if m in mods]),
+        "line_matches": ", ".join([
+            "new LineMatch(%d, %s)" % (lineno, json.dumps(text))
+            for lineno, text in analysis.line_matches]),
+      })
+    print("  ],")
+  print("""
+    ];
+    var MODULE_DATA = {
+  """)
+  for module in soong.modules:
+    print("      '%(name)s': new Module(%(deps)s)," % {
+      "name": module,
+      "deps": json.dumps(soong.deps[module]),
+    })
+  print("""
+    };
+    </script>
+
+  """)
+
+  print("""
+      </div> <!-- id=tables -->
+      <div id="details">
+        <div style="text-align: right;">
+          <a href="javascript:close_details();">
+            <svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg>
+          </a>
+        </div>
+        <div id="details_data"></div>
+      </div>
+    </body>
+  </html>
+  """)
+
+if __name__ == "__main__":
+  main()
+