Breakpad Linux Dumper: Add DWARF support.

This adds DWARF support to the Breakpad Linux dumper. This is
implemented as two handler classes: google_breakpad::DwarfCUToModule
accepts data from dwarf2reader::CompilationUnit, and
google_breakpad::DwarfLineToModule accepts data from a
dwarf2reader::LineInfo, each populating a google_breakpad::Module with
the results. Behaviors specific to particular source languages are
handled by instances of a new class, google_breakpad::Language.

An input executable may contain both STABS and DWARF debugging
information: the dumper automatically recognizes what sorts of
information are available, and integrates the data into a single
output file.

All classes have unit tests, providing line and branch coverage of all
interesting code. Unit tests are written using the Google C++ Testing
Framework, and the Google C++ Mocking Framework where appropriate.

a=jimblandy, r=ccoutant


git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@497 4c0a9323-5329-0410-9bdc-e9ce6186880e

10 files changed, 3941 insertions, 27 deletions

diff --git a/src/common/linux/dump_symbols.cc b/src/common/linux/dump_symbols.cc
index c4047ebe..74bf8670 100644
--- a/src/common/linux/dump_symbols.cc
+++ b/src/common/linux/dump_symbols.cc
@@ -40,8 +40,11 @@
 #include <cstring>
 #include <string>
 
+#include "common/dwarf/dwarf2diehandler.h"
 #include "common/linux/dump_stabs.h"
 #include "common/linux/dump_symbols.h"
+#include "common/linux/dwarf_cu_to_module.h"
+#include "common/linux/dwarf_line_to_module.h"
 #include "common/linux/file_id.h"
 #include "common/linux/module.h"
 #include "common/linux/stabs_reader.h"
@@ -49,11 +52,10 @@
 // This namespace contains helper functions.
 namespace {
 
-using google_breakpad::Module;
 using google_breakpad::DumpStabsHandler;
-
-// Stab section name.
-static const char *kStabName = ".stab";
+using google_breakpad::DwarfCUToModule;
+using google_breakpad::DwarfLineToModule;
+using google_breakpad::Module;
 
 // Fix offset into virtual address by adding the mapped base into offsets.
 // Make life easier when want to find something by offset.
@@ -87,7 +89,7 @@ static bool IsValidElf(const ElfW(Ehdr) *elf_header) {
 
 static const ElfW(Shdr) *FindSectionByName(const char *name,
                                            const ElfW(Shdr) *sections,
-                                           const ElfW(Shdr) *strtab,
+                                           const ElfW(Shdr) *section_names,
                                            int nsection) {
   assert(name != NULL);
   assert(sections != NULL);
@@ -99,19 +101,16 @@ static const ElfW(Shdr) *FindSectionByName(const char *name,
 
   for (int i = 0; i < nsection; ++i) {
     const char *section_name =
-      reinterpret_cast<char*>(strtab->sh_offset + sections[i].sh_name);
+      reinterpret_cast<char*>(section_names->sh_offset + sections[i].sh_name);
     if (!strncmp(name, section_name, name_len))
       return sections + i;
   }
   return NULL;
 }
 
-static bool LoadSymbols(const ElfW(Shdr) *stab_section,
-                        const ElfW(Shdr) *stabstr_section,
-                        Module *module) {
-  if (stab_section == NULL || stabstr_section == NULL)
-    return false;
-
+static bool LoadStabs(const ElfW(Shdr) *stab_section,
+                      const ElfW(Shdr) *stabstr_section,
+                      Module *module) {
   // A callback object to handle data from the STABS reader.
   DumpStabsHandler handler(module);
   // Find the addresses of the STABS data, and create a STABS reader object.
@@ -121,13 +120,91 @@ static bool LoadSymbols(const ElfW(Shdr) *stab_section,
                                       stabstr, stabstr_section->sh_size,
                                       &handler);
   // Read the STABS data, and do post-processing.
-  if (! reader.Process())
+  if (!reader.Process())
     return false;
   handler.Finalize();
   return true;
 }
 
-static bool LoadSymbols(ElfW(Ehdr) *elf_header, Module *module) {
+// A line-to-module loader that accepts line number info parsed by
+// dwarf2reader::LineInfo and populates a Module and a line vector
+// with the results.
+class DumperLineToModule: public DwarfCUToModule::LineToModuleFunctor {
+ public:
+  // Create a line-to-module converter using BYTE_READER.
+  DumperLineToModule(dwarf2reader::ByteReader *byte_reader)
+      : byte_reader_(byte_reader) { }
+  void operator()(const char *program, uint64 length,
+                  Module *module, vector<Module::Line> *lines) {
+    DwarfLineToModule handler(module, lines);
+    dwarf2reader::LineInfo parser(program, length, byte_reader_, &handler);
+    parser.Start();
+  }
+ private:
+  dwarf2reader::ByteReader *byte_reader_;
+};
+
+static bool LoadDwarf(const string &dwarf_filename,
+                      const ElfW(Ehdr) *elf_header,
+                      Module *module) {
+  // Figure out what endianness this file is.
+  dwarf2reader::Endianness endianness;
+  if (elf_header->e_ident[EI_DATA] == ELFDATA2LSB)
+    endianness = dwarf2reader::ENDIANNESS_LITTLE;
+  else if (elf_header->e_ident[EI_DATA] == ELFDATA2MSB)
+    endianness = dwarf2reader::ENDIANNESS_BIG;
+  else {
+    fprintf(stderr, "bad data encoding in ELF header: %d\n",
+            elf_header->e_ident[EI_DATA]);
+    return false;
+  }
+  dwarf2reader::ByteReader byte_reader(endianness);
+
+  // Construct a context for this file.
+  DwarfCUToModule::FileContext file_context(dwarf_filename, module);
+
+  // Build a map of the ELF file's sections.
+  const ElfW(Shdr) *sections
+      = reinterpret_cast<ElfW(Shdr) *>(elf_header->e_shoff);
+  int num_sections = elf_header->e_shnum;
+  const ElfW(Shdr) *section_names = sections + elf_header->e_shstrndx;
+  for (int i = 0; i < num_sections; i++) {
+    const ElfW(Shdr) *section = &sections[i];
+    string name = reinterpret_cast<const char *>(section_names->sh_offset
+                                                 + section->sh_name);
+    const char *contents = reinterpret_cast<const char *>(section->sh_offset);
+    uint64 length = section->sh_size;
+    file_context.section_map[name] = std::make_pair(contents, length);
+  }
+
+  // Parse all the compilation units in the .debug_info section.
+  DumperLineToModule line_to_module(&byte_reader);
+  std::pair<const char *, uint64> debug_info_section
+      = file_context.section_map[".debug_info"];
+  // We should never have been called if the file doesn't have a
+  // .debug_info section.
+  assert(debug_info_section.first);
+  uint64 debug_info_length = debug_info_section.second;
+  for (uint64 offset = 0; offset < debug_info_length;) {
+    // Make a handler for the root DIE that populates MODULE with the
+    // data we find.
+    DwarfCUToModule::WarningReporter reporter(dwarf_filename, offset);
+    DwarfCUToModule root_handler(&file_context, &line_to_module, &reporter);
+    // Make a Dwarf2Handler that drives our DIEHandler.
+    dwarf2reader::DIEDispatcher die_dispatcher(&root_handler);
+    // Make a DWARF parser for the compilation unit at OFFSET.
+    dwarf2reader::CompilationUnit reader(file_context.section_map,
+                                         offset,
+                                         &byte_reader,
+                                         &die_dispatcher);
+    // Process the entire compilation unit; get the offset of the next.
+    offset += reader.Start();
+  }
+  return true;
+}
+
+static bool LoadSymbols(const std::string &obj_file, ElfW(Ehdr) *elf_header,
+                        Module *module) {
   // Translate all offsets in section headers into address.
   FixAddress(elf_header);
   ElfW(Addr) loading_addr = GetLoadingAddress(
@@ -136,18 +213,36 @@ static bool LoadSymbols(ElfW(Ehdr) *elf_header, Module *module) {
   module->SetLoadAddress(loading_addr);
 
   const ElfW(Shdr) *sections =
-    reinterpret_cast<ElfW(Shdr) *>(elf_header->e_shoff);
-  const ElfW(Shdr) *strtab = sections + elf_header->e_shstrndx;
-  const ElfW(Shdr) *stab_section =
-    FindSectionByName(kStabName, sections, strtab, elf_header->e_shnum);
-  if (stab_section == NULL) {
-    fprintf(stderr, "Stab section not found.\n");
+      reinterpret_cast<ElfW(Shdr) *>(elf_header->e_shoff);
+  const ElfW(Shdr) *section_names = sections + elf_header->e_shstrndx;
+  bool found_debug_info_section = false;
+  const ElfW(Shdr) *stab_section
+      = FindSectionByName(".stab", sections, section_names,
+                          elf_header->e_shnum);
+  if (stab_section) {
+    const ElfW(Shdr) *stabstr_section = stab_section->sh_link + sections;
+    if (stabstr_section) {
+      found_debug_info_section = true;
+      if (!LoadStabs(stab_section, stabstr_section, module))
+        fprintf(stderr, "\".stab\" section found, but failed to load STABS"
+                " debugging information\n");
+    }
+  }
+  const ElfW(Shdr) *dwarf_section
+      = FindSectionByName(".debug_info", sections, section_names,
+                          elf_header->e_shnum);
+  if (dwarf_section) {
+    found_debug_info_section = true;
+    if (!LoadDwarf(obj_file, elf_header, module))
+      fprintf(stderr, "\".debug_info\" section found, but failed to load "
+              "DWARF debugging information\n");
+  }
+  if (!found_debug_info_section) {
+    fprintf(stderr, "file contains no debugging information"
+            " (no \".stab\" or \".debug_info\" sections)\n");
     return false;
   }
-  const ElfW(Shdr) *stabstr_section = stab_section->sh_link + sections;
-
-  // Load symbols.
-  return LoadSymbols(stab_section, stabstr_section, module);
+  return true;
 }
 
 //
@@ -268,11 +363,11 @@ bool DumpSymbols::WriteSymbolFile(const std::string &obj_file,
 
   unsigned char identifier[16];
   google_breakpad::FileID file_id(obj_file.c_str());
-  if (! file_id.ElfFileIdentifier(identifier))
+  if (!file_id.ElfFileIdentifier(identifier))
     return false;
 
   const char *architecture = ElfArchitecture(elf_header);
-  if (! architecture)
+  if (!architecture)
     return false;
 
   std::string name = BaseFileName(obj_file);
@@ -280,7 +375,7 @@ bool DumpSymbols::WriteSymbolFile(const std::string &obj_file,
   std::string id = FormatIdentifier(identifier);
 
   Module module(name, os, architecture, id);
-  if (!LoadSymbols(elf_header, &module))
+  if (!LoadSymbols(obj_file, elf_header, &module))
     return false;
   if (!module.Write(sym_file))
     return false;
diff --git a/src/common/linux/dwarf_cu_to_module.cc b/src/common/linux/dwarf_cu_to_module.cc
new file mode 100644
index 00000000..8063d25f
--- /dev/null
+++ b/src/common/linux/dwarf_cu_to_module.cc
@@ -0,0 +1,786 @@
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <algorithm>
+#include <cassert>
+
+#include "common/linux/dwarf_cu_to_module.h"
+#include "common/linux/dwarf_line_to_module.h"
+
+namespace google_breakpad {
+
+using std::map;
+using std::vector;
+
+// Data provided by a DWARF specification DIE.
+// 
+// In DWARF, the DIE for a definition may contain a DW_AT_specification
+// attribute giving the offset of the corresponding declaration DIE, and
+// the definition DIE may omit information given in the declaration. For
+// example, it's common for a function's address range to appear only in
+// its definition DIE, but its name to appear only in its declaration
+// DIE.
+//
+// The dumper needs to be able to follow DW_AT_specification links to
+// bring all this information together in a FUNC record. Conveniently,
+// DIEs that are the target of such links have a DW_AT_declaration flag
+// set, so we can identify them when we first see them, and record their
+// contents for later reference.
+//
+// A Specification holds information gathered from a declaration DIE that
+// we may need if we find a DW_AT_specification link pointing to it.
+struct DwarfCUToModule::Specification {
+  // The name of the enclosing scope, or the empty string if there is none.
+  string enclosing_name;
+
+  // The name for the specification DIE itself, without any enclosing
+  // name components.
+  string unqualified_name;
+};
+
+// Data global to the DWARF-bearing file that is private to the
+// DWARF-to-Module process.
+struct DwarfCUToModule::FilePrivate {
+  // A map from offsets of DIEs within the .debug_info section to
+  // Specifications describing those DIEs. Specification references can
+  // cross compilation unit boundaries.
+  SpecificationByOffset specifications;
+};
+
+DwarfCUToModule::FileContext::FileContext(const string &filename_arg,
+                                          Module *module_arg)
+    : filename(filename_arg), module(module_arg) {
+  file_private = new FilePrivate();
+}
+
+DwarfCUToModule::FileContext::~FileContext() {
+  delete file_private;
+}
+
+// Information global to the particular compilation unit we're
+// parsing. This is for data shared across the CU's entire DIE tree,
+// and parameters from the code invoking the CU parser.
+struct DwarfCUToModule::CUContext {
+  CUContext(FileContext *file_context_arg, WarningReporter *reporter_arg)
+      : file_context(file_context_arg),
+        reporter(reporter_arg),
+        language(Language::CPlusPlus) { }
+  ~CUContext() {
+    for (vector<Module::Function *>::iterator it = functions.begin();
+         it != functions.end(); it++)
+      delete *it;
+  };
+
+  // The DWARF-bearing file into which this CU was incorporated.
+  FileContext *file_context;
+
+  // For printing error messages.
+  WarningReporter *reporter;
+
+  // The source language of this compilation unit.
+  const Language *language;
+
+  // The functions defined in this compilation unit. We accumulate
+  // them here during parsing. Then, in DwarfCUToModule::Finish, we
+  // assign them lines and add them to file_context->module.
+  //
+  // Destroying this destroys all the functions this vector points to.
+  vector<Module::Function *> functions;
+};
+
+// Information about the context of a particular DIE. This is for
+// information that changes as we descend the tree towards the leaves:
+// the containing classes/namespaces, etc.
+struct DwarfCUToModule::DIEContext {
+  // The fully-qualified name of the context. For example, for a
+  // tree like:
+  //
+  // DW_TAG_namespace Foo
+  //   DW_TAG_class Bar
+  //     DW_TAG_subprogram Baz
+  //
+  // in a C++ compilation unit, the DIEContext's name for the
+  // DW_TAG_subprogram DIE would be "Foo::Bar". The DIEContext's
+  // name for the DW_TAG_namespace DIE would be "".
+  string name;
+};
+
+// An abstract base class for all the dumper's DIE handlers.
+class DwarfCUToModule::GenericDIEHandler: public dwarf2reader::DIEHandler {
+ public:
+  // Create a handler for the DIE at OFFSET whose compilation unit is
+  // described by CU_CONTEXT, and whose immediate context is described
+  // by PARENT_CONTEXT.
+  GenericDIEHandler(CUContext *cu_context, DIEContext *parent_context,
+                    uint64 offset)
+      : cu_context_(cu_context),
+        parent_context_(parent_context),
+        offset_(offset),
+        declaration_(false),
+        specification_(NULL) { }
+
+  // Derived classes' ProcessAttributeUnsigned can defer to this to
+  // handle DW_AT_declaration, or simply not override it.
+  void ProcessAttributeUnsigned(enum DwarfAttribute attr,
+                                enum DwarfForm form,
+                                uint64 data);
+
+  // Derived classes' ProcessAttributeReference can defer to this to
+  // handle DW_AT_specification, or simply not override it.
+  void ProcessAttributeReference(enum DwarfAttribute attr,
+                                 enum DwarfForm form,
+                                 uint64 data);
+
+  // Derived classes' ProcessAttributeReference can defer to this to
+  // handle DW_AT_specification, or simply not override it.
+  void ProcessAttributeString(enum DwarfAttribute attr,
+                              enum DwarfForm form,
+                              const string &data);
+
+ protected:
+  // Compute and return the fully-qualified name of the DIE. If this
+  // DIE is a declaration DIE, to be cited by other DIEs'
+  // DW_AT_specification attributes, record its enclosing name and
+  // unqualified name in the specification table.
+  string ComputeQualifiedName();
+
+  CUContext *cu_context_;
+  DIEContext *parent_context_;
+  uint64 offset_;
+
+  // If this DIE has a DW_AT_declaration attribute, this is its value.
+  // It is false on DIEs with no DW_AT_declaration attribute.
+  bool declaration_;
+
+  // If this DIE has a DW_AT_specification attribute, this is the
+  // Specification structure for the DIE the attribute refers to.
+  // Otherwise, this is NULL.
+  Specification *specification_;
+
+  // The value of the DW_AT_name attribute, or the empty string if the
+  // DIE has no such attribute.
+  string name_attribute_;
+};
+
+void DwarfCUToModule::GenericDIEHandler::ProcessAttributeUnsigned(
+    enum DwarfAttribute attr,
+    enum DwarfForm form,
+    uint64 data) {
+  switch (attr) {
+    case dwarf2reader::DW_AT_declaration: declaration_ = (data != 0); break;
+    default: break;
+  }
+}
+
+void DwarfCUToModule::GenericDIEHandler::ProcessAttributeReference(
+    enum DwarfAttribute attr,
+    enum DwarfForm form,
+    uint64 data) {
+  switch (attr) {
+    case dwarf2reader::DW_AT_specification: {
+      FileContext *file_context = cu_context_->file_context;
+      SpecificationByOffset *specifications
+          = &file_context->file_private->specifications;
+      SpecificationByOffset::iterator spec = specifications->find(data);
+      if (spec != specifications->end()) {
+        specification_ = &spec->second;
+      } else {
+        // Technically, there's no reason a DW_AT_specification
+        // couldn't be a forward reference, but supporting that would
+        // be a lot of work (changing to a two-pass structure), and I
+        // don't think any producers we care about ever emit such
+        // things.
+        cu_context_->reporter->UnknownSpecification(offset_, data);
+      }        
+      break;
+    }
+    default: break;
+  }
+}
+
+void DwarfCUToModule::GenericDIEHandler::ProcessAttributeString(
+    enum DwarfAttribute attr,
+    enum DwarfForm form,
+    const string &data) {
+  switch (attr) {
+    case dwarf2reader::DW_AT_name: name_attribute_ = data; break;
+    default: break;
+  }
+}
+
+string DwarfCUToModule::GenericDIEHandler::ComputeQualifiedName() {
+  // Find our unqualified name. If the DIE has its own DW_AT_name
+  // attribute, then use that; otherwise, check our specification.
+  const string *unqualified_name;
+  if (name_attribute_.empty() && specification_)
+    unqualified_name = &specification_->unqualified_name;
+  else
+    unqualified_name = &name_attribute_;
+
+  // Find the name of our enclosing context. If we have a
+  // specification, it's the specification's enclosing context that
+  // counts; otherwise, use this DIE's context.
+  const string *enclosing_name;
+  if (specification_)
+    enclosing_name = &specification_->enclosing_name;
+  else
+    enclosing_name = &parent_context_->name;
+
+  // If this DIE was marked as a declaration, record its names in the
+  // specification table.
+  if (declaration_) {
+    FileContext *file_context = cu_context_->file_context;
+    Specification spec;
+    spec.enclosing_name = *enclosing_name;
+    spec.unqualified_name = *unqualified_name;
+    file_context->file_private->specifications[offset_] = spec;
+  }
+
+  // Combine the enclosing name and unqualified name to produce our
+  // own fully-qualified name.
+  return cu_context_->language->MakeQualifiedName(*enclosing_name,
+                                                  *unqualified_name);
+}
+
+// A handler class for DW_TAG_subprogram DIEs.
+class DwarfCUToModule::FuncHandler: public GenericDIEHandler {
+ public:
+  FuncHandler(CUContext *cu_context, DIEContext *parent_context,
+              uint64 offset)
+      : GenericDIEHandler(cu_context, parent_context, offset),
+        low_pc_(0), high_pc_(0) { }
+  void ProcessAttributeUnsigned(enum DwarfAttribute attr,
+                                enum DwarfForm form,
+                                uint64 data);
+  bool EndAttributes();
+  void Finish();
+
+ private:
+  // The fully-qualified name, as derived from name_attribute_,
+  // specification_, parent_context_.  Computed in EndAttributes.
+  string name_;
+  uint64 low_pc_, high_pc_; // DW_AT_low_pc, DW_AT_high_pc
+};
+
+void DwarfCUToModule::FuncHandler::ProcessAttributeUnsigned(
+    enum DwarfAttribute attr,
+    enum DwarfForm form,
+    uint64 data) {
+  switch (attr) {
+    case dwarf2reader::DW_AT_low_pc:      low_pc_  = data; break;
+    case dwarf2reader::DW_AT_high_pc:     high_pc_ = data; break;
+    default:
+      GenericDIEHandler::ProcessAttributeUnsigned(attr, form, data);
+      break;
+  }
+}
+
+bool DwarfCUToModule::FuncHandler::EndAttributes() {
+  // Compute our name, and record a specification, if appropriate.
+  name_ = ComputeQualifiedName();
+  return true;
+}
+
+void DwarfCUToModule::FuncHandler::Finish() {
+  // Did we collect the information we need?  Not all DWARF function
+  // entries have low and high addresses (for example, inlined
+  // functions that were never used), but all the ones we're
+  // interested in cover a non-empty range of bytes.
+  if (low_pc_ < high_pc_) {
+    // Create a Module::Function based on the data we've gathered, and
+    // add it to the functions_ list.
+    Module::Function *func = new Module::Function;
+    func->name_ = name_;
+    func->address_ = low_pc_;
+    func->size_ = high_pc_ - low_pc_;
+    func->parameter_size_ = 0;
+    cu_context_->functions.push_back(func);
+  }
+}
+
+// A handler for DIEs that contain functions and contribute a
+// component to their names: namespaces, classes, etc.
+class DwarfCUToModule::NamedScopeHandler: public GenericDIEHandler {
+ public:
+  NamedScopeHandler(CUContext *cu_context, DIEContext *parent_context,
+                    uint64 offset)
+      : GenericDIEHandler(cu_context, parent_context, offset) { }
+  bool EndAttributes();
+  DIEHandler *FindChildHandler(uint64 offset, enum DwarfTag tag,
+                               const AttributeList &attrs);
+
+ private:
+  DIEContext child_context_; // A context for our children.
+};
+
+bool DwarfCUToModule::NamedScopeHandler::EndAttributes() {
+  child_context_.name = ComputeQualifiedName();
+  return true;
+}
+
+dwarf2reader::DIEHandler *DwarfCUToModule::NamedScopeHandler::FindChildHandler(
+    uint64 offset,
+    enum DwarfTag tag,
+    const AttributeList &attrs) {
+  switch (tag) {
+    case dwarf2reader::DW_TAG_subprogram:
+      return new FuncHandler(cu_context_, &child_context_, offset);
+    case dwarf2reader::DW_TAG_namespace:
+    case dwarf2reader::DW_TAG_class_type:
+    case dwarf2reader::DW_TAG_structure_type:
+    case dwarf2reader::DW_TAG_union_type:
+      return new NamedScopeHandler(cu_context_, &child_context_, offset);
+    default:
+      return NULL;
+  }
+};
+
+void DwarfCUToModule::WarningReporter::CUHeading() {
+  if (printed_cu_header_)
+    return;
+  fprintf(stderr, "%s: in compilation unit '%s' (offset 0x%llx):\n",
+          filename_.c_str(), cu_name_.c_str(), cu_offset_);
+  printed_cu_header_ = true;
+}
+
+void DwarfCUToModule::WarningReporter::UnknownSpecification(uint64 offset,
+                                                            uint64 target) {
+  CUHeading();
+  fprintf(stderr, "%s: the DIE at offset 0x%llx has a DW_AT_specification"
+          " attribute referring to the die at offset 0x%llx, which either"
+          " was not marked as a declaration, or comes later in the file",
+          filename_.c_str(), offset, target);
+}
+
+void DwarfCUToModule::WarningReporter::MissingSection(const string &name) {
+  CUHeading();
+  fprintf(stderr, "%s: warning: couldn't find DWARF '%s' section\n",
+          filename_.c_str(), name.c_str());
+}
+
+void DwarfCUToModule::WarningReporter::BadLineInfoOffset(uint64 offset) {
+  CUHeading();
+  fprintf(stderr, "%s: warning: line number data offset beyond end"
+          " of '.debug_line' section\n",
+          filename_.c_str());
+}
+
+void DwarfCUToModule::WarningReporter::UncoveredHeading() {
+  if (printed_unpaired_header_)
+    return;
+  CUHeading();
+  fprintf(stderr, "%s: warning: skipping unpaired lines/functions:\n",
+          filename_.c_str());
+  printed_unpaired_header_ = true;
+}
+
+void DwarfCUToModule::WarningReporter::UncoveredFunction(
+    const Module::Function &function) {
+  UncoveredHeading();
+  fprintf(stderr, "    function%s: %s\n",
+          function.size_ == 0 ? " (zero-length)" : "",
+          function.name_.c_str());
+}
+
+void DwarfCUToModule::WarningReporter::UncoveredLine(const Module::Line &line) {
+  UncoveredHeading();
+  fprintf(stderr, "    line%s: %s:%d at 0x%llx\n",
+          (line.size_ == 0 ? " (zero-length)" : ""),
+          line.file_->name_.c_str(), line.number_, line.address_);
+}
+
+DwarfCUToModule::DwarfCUToModule(FileContext *file_context,
+                                 LineToModuleFunctor *line_reader,
+                                 WarningReporter *reporter)
+    : line_reader_(line_reader), has_source_line_info_(false) { 
+  cu_context_ = new CUContext(file_context, reporter);
+  child_context_ = new DIEContext();
+}
+
+DwarfCUToModule::~DwarfCUToModule() {
+  delete cu_context_;
+  delete child_context_;
+}
+
+void DwarfCUToModule::ProcessAttributeSigned(enum DwarfAttribute attr,
+                                             enum DwarfForm form,
+                                             int64 data) {
+  switch (attr) {
+    case dwarf2reader::DW_AT_language: // source language of this CU
+      SetLanguage(static_cast<DwarfLanguage>(data));
+      break;
+    default:
+      break;
+  }
+}
+
+void DwarfCUToModule::ProcessAttributeUnsigned(enum DwarfAttribute attr,
+                                               enum DwarfForm form,
+                                               uint64 data) {
+  switch (attr) {
+    case dwarf2reader::DW_AT_stmt_list: // Line number information.
+      has_source_line_info_ = true;
+      source_line_offset_ = data;
+      break;
+    case dwarf2reader::DW_AT_language: // source language of this CU
+      SetLanguage(static_cast<DwarfLanguage>(data));
+      break;
+    default:
+      break;
+  }
+}
+
+void DwarfCUToModule::ProcessAttributeString(enum DwarfAttribute attr,
+                                             enum DwarfForm form,
+                                             const string &data) {
+  if (attr == dwarf2reader::DW_AT_name)
+    cu_context_->reporter->SetCUName(data);
+}
+
+bool DwarfCUToModule::EndAttributes() {
+  return true;
+}
+
+dwarf2reader::DIEHandler *DwarfCUToModule::FindChildHandler(
+    uint64 offset,
+    enum DwarfTag tag,
+    const AttributeList &attrs) {
+  switch (tag) {
+    case dwarf2reader::DW_TAG_subprogram:
+      return new FuncHandler(cu_context_, child_context_, offset);
+    case dwarf2reader::DW_TAG_namespace:
+    case dwarf2reader::DW_TAG_class_type:
+    case dwarf2reader::DW_TAG_structure_type:
+    case dwarf2reader::DW_TAG_union_type:
+      return new NamedScopeHandler(cu_context_, child_context_, offset);
+    default:
+      return NULL;
+  }
+}
+
+void DwarfCUToModule::SetLanguage(DwarfLanguage language) {
+  switch (language) {
+    case dwarf2reader::DW_LANG_Java:
+      cu_context_->language = Language::Java;
+      break;
+
+    // DWARF has no generic language code for assembly language; this is
+    // what the GNU toolchain uses.
+    case dwarf2reader::DW_LANG_Mips_Assembler:
+      cu_context_->language = Language::Assembler;
+      break;
+
+    // C++ covers so many cases that it probably has some way to cope
+    // with whatever the other languages throw at us. So make it the
+    // default.
+    //
+    // Objective C and Objective C++ seem to create entries for
+    // methods whose DW_AT_name values are already fully-qualified:
+    // "-[Classname method:]".  These appear at the top level.
+    // 
+    // DWARF data for C should never include namespaces or functions
+    // nested in struct types, but if it ever does, then C++'s
+    // notation is probably not a bad choice for that.
+    default:
+    case dwarf2reader::DW_LANG_ObjC:
+    case dwarf2reader::DW_LANG_ObjC_plus_plus:
+    case dwarf2reader::DW_LANG_C:
+    case dwarf2reader::DW_LANG_C89:
+    case dwarf2reader::DW_LANG_C99:
+    case dwarf2reader::DW_LANG_C_plus_plus:
+      cu_context_->language = Language::CPlusPlus;
+      break;
+  }
+}
+
+void DwarfCUToModule::ReadSourceLines(uint64 offset) {
+  const dwarf2reader::SectionMap &section_map
+      = cu_context_->file_context->section_map;
+  dwarf2reader::SectionMap::const_iterator map_entry
+      = section_map.find(".debug_line");
+  if (map_entry == section_map.end()) {
+    cu_context_->reporter->MissingSection(".debug_line");
+    return;
+  }
+  const char *section_start = map_entry->second.first;
+  uint64 section_length = map_entry->second.second;
+  if (offset >= section_length) {
+    cu_context_->reporter->BadLineInfoOffset(offset);
+    return;
+  }
+  (*line_reader_)(section_start + offset, section_length - offset,
+                  cu_context_->file_context->module, &lines_);
+}
+
+namespace {
+// Return true if ADDRESS falls within the range of ITEM.
+template <class T>
+inline bool within(const T &item, Module::Address address) {
+  // Because Module::Address is unsigned, and unsigned arithmetic
+  // wraps around, this will be false if ADDRESS falls before the
+  // start of ITEM, or if it falls after ITEM's end.
+  return address - item.address_ < item.size_;
+}
+}
+
+void DwarfCUToModule::AssignLinesToFunctions() {
+  vector<Module::Function *> *functions = &cu_context_->functions;
+  WarningReporter *reporter = cu_context_->reporter;
+
+  // This would be simpler if we assumed that source line entries
+  // don't cross function boundaries.  However, there's no real reason
+  // to assume that (say) a series of function definitions on the same
+  // line wouldn't get coalesced into one line number entry.  The
+  // DWARF spec certainly makes no such promises.
+  //
+  // So treat the functions and lines as peers, and take the trouble
+  // to compute their ranges' intersections precisely.  In any case,
+  // the hair here is a constant factor for performance; the
+  // complexity from here on out is linear.
+
+  // Put both our functions and lines in order by address.
+  sort(functions->begin(), functions->end(),
+       Module::Function::CompareByAddress);
+  sort(lines_.begin(), lines_.end(), Module::Line::CompareByAddress);
+
+  // The last line that we used any piece of.  We use this only for
+  // generating warnings.
+  const Module::Line *last_line_used = NULL;
+
+  // The last function and line we warned about --- so we can avoid
+  // doing so more than once.
+  const Module::Function *last_function_cited = NULL;
+  const Module::Line *last_line_cited = NULL;
+
+  // Make a single pass through both vectors from lower to higher
+  // addresses, populating each Function's lines_ vector with lines
+  // from our lines_ vector that fall within the function's address
+  // range.
+  vector<Module::Function *>::iterator func_it = functions->begin();
+  vector<Module::Line>::const_iterator line_it = lines_.begin();
+
+  Module::Address current;
+
+  // Pointers to the referents of func_it and line_it, or NULL if the
+  // iterator is at the end of the sequence.
+  Module::Function *func;
+  const Module::Line *line;
+
+  // Start current at the beginning of the first line or function,
+  // whichever is earlier.
+  if (func_it != functions->end() && line_it != lines_.end()) {
+    func = *func_it;
+    line = &*line_it;
+    current = std::min(func->address_, line->address_);
+  } else if (line_it != lines_.end()) {
+    func = NULL;
+    line = &*line_it;
+    current = line->address_;
+  } else if (func_it != functions->end()) {
+    func = *func_it;
+    line = NULL;
+    current = (*func_it)->address_;
+  } else {
+    return;
+  }
+
+  while (func || line) {
+    // This loop has two invariants that hold at the top.
+    //
+    // First, at least one of the iterators is not at the end of its
+    // sequence, and those that are not refer to the earliest
+    // function or line that contains or starts after CURRENT.
+    //
+    // Note that every byte is in one of four states: it is covered
+    // or not covered by a function, and, independently, it is
+    // covered or not covered by a line.
+    //
+    // The second invariant is that CURRENT refers to a byte whose
+    // state is different from its predecessor, or it refers to the
+    // first byte in the address space. In other words, CURRENT is
+    // always the address of a transition.
+    //
+    // Note that, although each iteration advances CURRENT from one
+    // transition address to the next in each iteration, it might
+    // not advance the iterators. Suppose we have a function that
+    // starts with a line, has a gap, and then a second line, and
+    // suppose that we enter an iteration with CURRENT at the end of
+    // the first line. The next transition address is the start of
+    // the second line, after the gap, so the iteration should
+    // advance CURRENT to that point. At the head of that iteration,
+    // the invariants require that the line iterator be pointing at
+    // the second line. But this is also true at the head of the
+    // next. And clearly, the iteration must not change the function
+    // iterator. So neither iterator moves.
+
+    // Assert the first invariant (see above).
+    assert(!func || current < func->address_ || within(*func, current));
+    assert(!line || current < line->address_ || within(*line, current));
+
+    // The next transition after CURRENT.
+    Module::Address next_transition;
+
+    // Figure out which state we're in, add lines or warn, and compute
+    // the next transition address.
+    if (func && current >= func->address_) {
+      if (line && current >= line->address_) {
+        // Covered by both a line and a function.
+        Module::Address func_left = func->size_ - (current - func->address_);
+        Module::Address line_left = line->size_ - (current - line->address_);
+        // This may overflow, but things work out.
+        next_transition = current + std::min(func_left, line_left);
+        Module::Line l = *line;
+        l.address_ = current;
+        l.size_ = next_transition - current;
+        func->lines_.push_back(l);
+        last_line_used = line;
+      } else {
+        // Covered by a function, but no line.
+        if (func != last_function_cited) {
+          reporter->UncoveredFunction(*func);
+          last_function_cited = func;
+        }
+        if (line && within(*func, line->address_))
+          next_transition = line->address_;
+        else
+          // If this overflows, we'll catch it below.
+          next_transition = func->address_ + func->size_;
+      }
+    } else {
+      if (line && current >= line->address_) {
+        // Covered by a line, but no function.
+        //
+        // If GCC emits padding after one function to align the start
+        // of the next, then it will attribute the padding
+        // instructions to the last source line of function (to reduce
+        // the size of the line number info), but omit it from the
+        // DW_AT_{low,high}_pc range given in .debug_info (since it
+        // costs nothing to be precise there). If we did use at least
+        // some of the line we're about to skip, and it ends at the
+        // start of the next function, then assume this is what
+        // happened, and don't warn.
+        if (line != last_line_cited
+            && !(func
+                 && line == last_line_used
+                 && func->address_ - line->address_ == line->size_)) {
+          reporter->UncoveredLine(*line);
+          last_line_cited = line;
+        }
+        if (func && within(*line, func->address_))
+          next_transition = func->address_;
+        else
+          // If this overflows, we'll catch it below.
+          next_transition = line->address_ + line->size_;
+      } else {
+        // Covered by neither a function nor a line. By the invariant,
+        // both func and line begin after CURRENT. The next transition
+        // is the start of the next function or next line, whichever
+        // is earliest.
+        assert (func || line);
+        if (func && line)
+          next_transition = std::min(func->address_, line->address_);
+        else if (func)
+          next_transition = func->address_;
+        else
+          next_transition = line->address_;
+      }
+    }
+
+    // If a function or line abuts the end of the address space, then
+    // next_transition may end up being zero, in which case we've completed
+    // our pass. Handle that here, instead of trying to deal with it in
+    // each place we compute next_transition.
+    if (!next_transition)
+      break;
+
+    // Advance iterators as needed. If lines overlap or functions overlap,
+    // then we could go around more than once. We don't worry too much
+    // about what result we produce in that case, just as long as we don't
+    // hang or crash.
+    while (func_it != functions->end()
+           && current >= (*func_it)->address_
+           && !within(**func_it, next_transition))
+      func_it++;
+    func = (func_it != functions->end()) ? *func_it : NULL;
+    while (line_it != lines_.end()
+           && current >= line_it->address_
+           && !within(*line_it, next_transition))
+      line_it++;
+    line = (line_it != lines_.end()) ? &*line_it : NULL;
+
+    // We must make progress.
+    assert(next_transition > current);
+    current = next_transition;
+  }
+}
+
+void DwarfCUToModule::Finish() {
+  // Assembly language files have no function data, and that gives us
+  // no place to store our line numbers (even though the GNU toolchain
+  // will happily produce source line info for assembly language
+  // files).  To avoid spurious warnings about lines we can't assign
+  // to functions, skip CUs in languages that lack functions.
+  if (!cu_context_->language->HasFunctions())
+    return;
+
+  // Read source line info, if we have any.
+  if (has_source_line_info_)
+    ReadSourceLines(source_line_offset_);
+
+  vector<Module::Function *> *functions = &cu_context_->functions;
+
+  // Dole out lines to the appropriate functions.
+  AssignLinesToFunctions();
+
+  // Add our functions, which now have source lines assigned to them,
+  // to module_.
+  cu_context_->file_context->module->AddFunctions(functions->begin(),
+                                                  functions->end());
+
+  // Ownership of the function objects has shifted from cu_context to
+  // the Module.
+  functions->clear();
+}
+
+bool DwarfCUToModule::StartCompilationUnit(uint64 offset,
+                                           uint8 address_size,
+                                           uint8 offset_size,
+                                           uint64 cu_length,
+                                           uint8 dwarf_version) {
+  return dwarf_version >= 2;
+}
+
+bool DwarfCUToModule::StartRootDIE(uint64 offset, enum DwarfTag tag,
+                                   const AttributeList& attrs) {
+  // We don't deal with partial compilation units (the only other tag
+  // likely to be used for root DIE).
+  return tag == dwarf2reader::DW_TAG_compile_unit;
+}
+
+} // namespace google_breakpad
diff --git a/src/common/linux/dwarf_cu_to_module.h b/src/common/linux/dwarf_cu_to_module.h
new file mode 100644
index 00000000..1620d2eb
--- /dev/null
+++ b/src/common/linux/dwarf_cu_to_module.h
@@ -0,0 +1,248 @@
+// -*- mode: c++ -*-
+
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef COMMON_LINUX_DWARF_CU_TO_MODULE_H__
+#define COMMON_LINUX_DWARF_CU_TO_MODULE_H__
+
+#include <string>
+
+#include <elf.h>
+#include <link.h>
+#include "common/linux/language.h"
+#include "common/linux/module.h"
+#include "common/dwarf/bytereader.h"
+#include "common/dwarf/dwarf2diehandler.h"
+#include "common/dwarf/dwarf2reader.h"
+
+namespace google_breakpad {
+
+using dwarf2reader::AttributeList;
+using dwarf2reader::DwarfAttribute;
+using dwarf2reader::DwarfForm;
+using dwarf2reader::DwarfLanguage;
+using dwarf2reader::DwarfTag;
+
+// Populate a google_breakpad::Module with DWARF debugging information.
+//
+// An instance of this class can be provided as a handler to a
+// dwarf2reader::CompilationUnit DWARF parser. The handler uses the
+// results of parsing to populate a google_breakpad::Module with
+// source file, function, and source line information.
+class DwarfCUToModule: public dwarf2reader::RootDIEHandler {
+  struct FilePrivate;
+ public:
+
+  // Information global to the DWARF-bearing file we are processing,
+  // for use by DwarfCUToModule. Each DwarfCUToModule instance deals
+  // with a single compilation unit within the file, but information
+  // global to the whole file is held here. The client is responsible
+  // for filling it in appropriately (except for the 'file_private'
+  // field, which the constructor and destructor take care of), and
+  // then providing it to the DwarfCUToModule instance for each
+  // compilation unit we process in that file.
+  struct FileContext {
+    FileContext(const string &filename_arg, Module *module_arg);
+    ~FileContext();
+
+    // The name of this file, for use in error messages.
+    string filename;
+
+    // A map of this file's sections, used for finding other DWARF
+    // sections that the .debug_info section may refer to.
+    dwarf2reader::SectionMap section_map;
+
+    // The Module to which we're contributing definitions.
+    Module *module;
+
+    // Inter-compilation unit data used internally by the handlers.
+    FilePrivate *file_private;
+  };
+
+  // An abstract base class for functors that handle DWARF line data
+  // for DwarfCUToModule. DwarfCUToModule could certainly just use
+  // dwarf2reader::LineInfo itself directly, but decoupling things
+  // this way makes unit testing a little easier.
+  class LineToModuleFunctor {
+   public:
+    LineToModuleFunctor() { }
+    virtual ~LineToModuleFunctor() { }
+
+    // Populate MODULE and LINES with source file names and code/line
+    // mappings, given a pointer to some DWARF line number data
+    // PROGRAM, and an overestimate of its size. Add no zero-length
+    // lines to LINES.
+    virtual void operator()(const char *program, uint64 length,
+                            Module *module, vector<Module::Line> *lines) = 0;
+  };
+
+  // The interface DwarfCUToModule uses to report warnings. The member
+  // function definitions for this class write messages to stderr, but
+  // you can override them if you'd like to detect or report these
+  // conditions yourself.
+  class WarningReporter {
+   public:
+    // Warn about problems in the DWARF file FILENAME, in the
+    // compilation unit at OFFSET.
+    WarningReporter(const string &filename, uint64 cu_offset)
+        : filename_(filename), cu_offset_(cu_offset), printed_cu_header_(false),
+          printed_unpaired_header_(false) { }
+    virtual ~WarningReporter() { }
+
+    // Set the name of the compilation unit we're processing to NAME.
+    virtual void SetCUName(const string &name) { cu_name_ = name; }
+
+    // A DW_AT_specification in the DIE at OFFSET refers to a DIE we
+    // haven't processed yet, or that wasn't marked as a declaration,
+    // at TARGET.
+    virtual void UnknownSpecification(uint64 offset, uint64 target);
+    
+    // We were unable to find the DWARF section named SECTION_NAME.
+    virtual void MissingSection(const string &section_name);
+
+    // The CU's DW_AT_stmt_list offset OFFSET is bogus.
+    virtual void BadLineInfoOffset(uint64 offset);
+
+    // FUNCTION includes code covered by no line number data.
+    virtual void UncoveredFunction(const Module::Function &function);
+
+    // Line number NUMBER in LINE_FILE, of length LENGTH, includes code
+    // covered by no function.
+    virtual void UncoveredLine(const Module::Line &line);
+
+   protected:
+    string filename_;
+    uint64 cu_offset_;
+    string cu_name_;
+    bool printed_cu_header_;
+    bool printed_unpaired_header_;
+
+   private:
+    // Print a per-CU heading, once.
+    void CUHeading();
+    // Print an unpaired function/line heading, once.
+    void UncoveredHeading();
+  };
+
+  // Create a DWARF debugging info handler for a compilation unit
+  // within FILE_CONTEXT. This uses information received from the
+  // dwarf2reader::CompilationUnit DWARF parser to populate
+  // FILE_CONTEXT->module. Use LINE_READER to handle the compilation
+  // unit's line number data. Use REPORTER to report problems with the
+  // data we find.
+  DwarfCUToModule(FileContext *file_context,
+                  LineToModuleFunctor *line_reader,
+                  WarningReporter *reporter);
+  ~DwarfCUToModule();
+
+  void ProcessAttributeSigned(enum DwarfAttribute attr,
+                              enum DwarfForm form,
+                              int64 data);
+  void ProcessAttributeUnsigned(enum DwarfAttribute attr,
+                                enum DwarfForm form,
+                                uint64 data);
+  void ProcessAttributeString(enum DwarfAttribute attr,
+                              enum DwarfForm form,
+                              const string &data);
+  bool EndAttributes();
+  DIEHandler *FindChildHandler(uint64 offset, enum DwarfTag tag,
+                               const AttributeList &attrs);
+
+  // Assign all our source Lines to the Functions that cover their
+  // addresses, and then add them to module_.
+  void Finish();
+
+  bool StartCompilationUnit(uint64 offset, uint8 address_size,
+                            uint8 offset_size, uint64 cu_length,
+                            uint8 dwarf_version);
+  bool StartRootDIE(uint64 offset, enum DwarfTag tag,
+                    const AttributeList& attrs);
+
+ private:
+
+  // Used internally by the handler. Full definitions are in
+  // dwarf_cu_to_module.cc.
+  struct FilePrivate;
+  struct Specification;
+  struct CUContext;
+  struct DIEContext;
+  class GenericDIEHandler;
+  class FuncHandler;
+  class NamedScopeHandler;
+
+  // A map from section offsets to specifications.
+  typedef map<uint64, Specification> SpecificationByOffset;
+
+  // Set this compilation unit's source language to LANGUAGE.
+  void SetLanguage(DwarfLanguage language);
+  
+  // Read source line information at OFFSET in the .debug_line
+  // section.  Record source files in module_, but record source lines
+  // in lines_; we apportion them to functions in
+  // AssignLinesToFunctions.
+  void ReadSourceLines(uint64 offset);
+
+  // Assign the lines in lines_ to the individual line lists of the
+  // functions in functions_.  (DWARF line information maps an entire
+  // compilation unit at a time, and gives no indication of which
+  // lines belong to which functions, beyond their addresses.)
+  void AssignLinesToFunctions();
+
+  // The only reason cu_context_ and child_context_ are pointers is
+  // that we want to keep their definitions private to
+  // dwarf_cu_to_module.cc, instead of listing them all here. They are
+  // owned by this DwarfCUToModule: the constructor sets them, and the
+  // destructor deletes them.
+
+  // The functor to use to handle line number data.
+  LineToModuleFunctor *line_reader_;
+
+  // This compilation unit's context.
+  CUContext *cu_context_;
+
+  // A context for our children.
+  DIEContext *child_context_;
+
+  // True if this compilation unit has source line information.
+  bool has_source_line_info_;
+
+  // The offset of this compilation unit's line number information in
+  // the .debug_line section.
+  uint64 source_line_offset_;
+
+  // The line numbers we have seen thus far.  We accumulate these here
+  // during parsing.  Then, in Finish, we call AssignLinesToFunctions
+  // to dole them out to the appropriate functions.
+  vector<Module::Line> lines_;
+};
+
+} // namespace google_breakpad
+
+#endif  // COMMON_LINUX_DWARF_CU_TO_MODULE_H__
diff --git a/src/common/linux/dwarf_cu_to_module_unittest.cc b/src/common/linux/dwarf_cu_to_module_unittest.cc
new file mode 100644
index 00000000..30ce6ca2
--- /dev/null
+++ b/src/common/linux/dwarf_cu_to_module_unittest.cc
@@ -0,0 +1,1456 @@
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// dwarf_cu_to_module.cc: Unit tests for google_breakpad::DwarfCUToModule.
+
+#include <vector>
+
+#include "breakpad_googletest_includes.h"
+#include "common/linux/dwarf_cu_to_module.h"
+
+using std::vector;
+
+using dwarf2reader::AttributeList;
+using dwarf2reader::DIEHandler;
+using dwarf2reader::DwarfTag;
+using dwarf2reader::DwarfAttribute;
+using dwarf2reader::DwarfForm;
+using dwarf2reader::RootDIEHandler;
+using google_breakpad::DwarfCUToModule;
+using google_breakpad::Module;
+
+using ::testing::_;
+using ::testing::AtMost;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::Test;
+using ::testing::TestWithParam;
+using ::testing::Values;
+using ::testing::ValuesIn;
+
+// Mock classes.
+
+class MockLineToModuleFunctor: public DwarfCUToModule::LineToModuleFunctor {
+ public:
+  MOCK_METHOD4(mock_apply, void(const char *program, uint64 length,
+                                Module *module, vector<Module::Line> *lines));
+  void operator()(const char *program, uint64 length,
+                  Module *module, vector<Module::Line> *lines) {
+    mock_apply(program, length, module, lines);
+  }
+};
+
+class MockWarningReporter: public DwarfCUToModule::WarningReporter {
+ public:
+  MockWarningReporter(const string &filename, uint64 cu_offset)
+      : DwarfCUToModule::WarningReporter(filename, cu_offset) { }
+  MOCK_METHOD1(SetCUName, void(const string &name));
+  MOCK_METHOD2(UnknownSpecification, void(uint64 offset, uint64 target));
+  MOCK_METHOD1(MissingSection, void(const string &section_name));
+  MOCK_METHOD1(BadLineInfoOffset, void(uint64 offset));
+  MOCK_METHOD1(UncoveredFunction, void(const Module::Function &function));
+  MOCK_METHOD1(UncoveredLine, void(const Module::Line &line));
+};
+
+// A fixture class including all the objects needed to handle a
+// compilation unit, and their entourage. It includes member functions
+// for doing common kinds of setup and tests.
+class CUFixtureBase {
+ public:
+
+  // If we have:
+  //
+  //   vector<Module::Line> lines;
+  //   AppendLinesFunctor appender(lines);
+  //
+  // then doing:
+  //
+  //   appender(line_program, length, module, line_vector);
+  //
+  // will append lines to the end of line_vector.  We can use this with
+  // MockLineToModuleFunctor like this:
+  //
+  //   MockLineToModuleFunctor l2m;
+  //   EXPECT_CALL(l2m, mock_apply(_,_,_,_))
+  //       .WillOnce(DoAll(Invoke(appender), Return()));
+  //
+  // in which case calling l2m with some line vector will append lines.
+  class AppendLinesFunctor {
+   public:
+    AppendLinesFunctor(const vector<Module::Line> *lines) : lines_(lines) { }
+    void operator()(const char *program, uint64 length,
+                    Module *module, vector<Module::Line> *lines) {
+      lines->insert(lines->end(), lines_->begin(), lines_->end());
+    }
+   private:
+    const vector<Module::Line> *lines_;
+  };
+
+  CUFixtureBase()
+      : module_("module-name", "module-os", "module-arch", "module-id"),
+        file_context_("dwarf-filename", &module_),
+        language_(dwarf2reader::DW_LANG_none),
+        language_signed_(false),
+        appender_(&lines_),
+        reporter_("dwarf-filename", 0xcf8f9bb6443d29b5LL),
+        root_handler_(&file_context_, &line_reader_, &reporter_),
+        functions_filled_(false) {
+    // By default, expect no warnings to be reported, and expect the
+    // compilation unit's name to be provided. The test can override
+    // these expectations.
+    EXPECT_CALL(reporter_, SetCUName("compilation-unit-name")).Times(1);
+    EXPECT_CALL(reporter_, UnknownSpecification(_, _)).Times(0);
+    EXPECT_CALL(reporter_, MissingSection(_)).Times(0);
+    EXPECT_CALL(reporter_, BadLineInfoOffset(_)).Times(0);
+    EXPECT_CALL(reporter_, UncoveredFunction(_)).Times(0);
+    EXPECT_CALL(reporter_, UncoveredLine(_)).Times(0);
+
+    // By default, expect the line program reader not to be invoked. We
+    // may override this in StartCU.
+    EXPECT_CALL(line_reader_, mock_apply(_,_,_,_)).Times(0);
+
+    // The handler will consult this section map to decide what to
+    // pass to our line reader.
+    file_context_.section_map[".debug_line"] = std::make_pair(dummy_line_program_, 
+                                                   dummy_line_size_);
+  }
+
+  // Add a line with the given address, size, filename, and line
+  // number to the end of the statement list the handler will receive
+  // when it invokes its LineToModuleFunctor. Call this before calling
+  // StartCU.
+  void PushLine(Module::Address address, Module::Address size,
+                const string &filename, int line_number);
+
+  // Use LANGUAGE for the compilation unit. More precisely, arrange
+  // for StartCU to pass the compilation unit's root DIE a
+  // DW_AT_language attribute whose value is LANGUAGE.
+  void SetLanguage(dwarf2reader::DwarfLanguage language) { 
+    language_ = language;
+  }
+
+  // If SIGNED true, have StartCU report DW_AT_language as a signed
+  // attribute; if false, have it report it as unsigned.
+  void SetLanguageSigned(bool is_signed) { language_signed_ = is_signed; }
+
+  // Call the handler this.root_handler_'s StartCompilationUnit and
+  // StartRootDIE member functions, passing it appropriate attributes as
+  // determined by prior calls to PushLine and SetLanguage. Leave
+  // this.root_handler_ ready to hear about children: call
+  // this.root_handler_.EndAttributes, but not this.root_handler_.Finish.
+  void StartCU();
+
+  // Add some strange attributes/form pairs to the end of ATTRS.
+  void PushBackStrangeAttributes(dwarf2reader::AttributeList *attrs);
+
+  // Have HANDLER process some strange attribute/form/value triples.
+  // These will match those promised by PushBackStrangeAttributes.
+  void ProcessStrangeAttributes(dwarf2reader::DIEHandler *handler);
+
+  // Start a child DIE of PARENT with the given tag and name. Leave
+  // the handler ready to hear about children: call EndAttributes, but
+  // not Finish.
+  DIEHandler *StartNamedDIE(DIEHandler *parent, DwarfTag tag,
+                            const string &name);
+ 
+  // Start a child DIE of PARENT with the given tag and a
+  // DW_AT_specification attribute whose value is SPECIFICATION. Leave
+  // the handler ready to hear about children: call EndAttributes, but
+  // not Finish. If NAME is non-zero, use it as the DW_AT_name
+  // attribute.
+  DIEHandler *StartSpecifiedDIE(DIEHandler *parent, DwarfTag tag,
+                                uint64 offset, const char *name = NULL);
+ 
+  // Define a function as a child of PARENT with the given name,
+  // address, and size. Call EndAttributes and Finish; one cannot
+  // define children of the defined function's DIE.
+  void DefineFunction(DIEHandler *parent, const string &name,
+                      Module::Address address, Module::Address size);      
+
+  // Create a declaration DIE as a child of PARENT with the given
+  // offset, tag and name. If NAME is the empty string, don't provide
+  // a DW_AT_name attribute. Call EndAttributes and Finish.
+  void DeclarationDIE(DIEHandler *parent, uint64 offset,
+                      DwarfTag tag, const string &name);
+
+  // Create a definition DIE as a child of PARENT with the given tag
+  // that refers to the declaration DIE at offset SPECIFICATION as its
+  // specification. If NAME is non-empty, pass it as the DW_AT_name
+  // attribute. If SIZE is non-zero, record ADDRESS and SIZE as
+  // low_pc/high_pc attributes.
+  void DefinitionDIE(DIEHandler *parent, DwarfTag tag,
+                     uint64 specification, const string &name,
+                     Module::Address address = 0, Module::Address size = 0);
+
+  // The following Test* functions should be called after calling
+  // this.root_handler_.Finish. After that point, no further calls
+  // should be made on the handler.
+
+  // Test that the number of functions defined in the module this.module_ is
+  // equal to EXPECTED.
+  void TestFunctionCount(size_t expected);
+
+  // Test that the I'th function (ordered by address) in the module
+  // this.module_ has the given name, address, and size, and that its
+  // parameter size is zero.
+  void TestFunction(int i, const string &name,
+                    Module::Address address, Module::Address size);
+  
+  // Test that the number of source lines owned by the I'th function
+  // in the module this.module_ is equal to EXPECTED.
+  void TestLineCount(int i, size_t expected);
+
+  // Test that the J'th line (ordered by address) of the I'th function
+  // (again, by address) has the given address, size, filename, and
+  // line number.
+  void TestLine(int i, int j, Module::Address address, Module::Address size,
+                const string &filename, int number);
+
+  // Actual objects under test.
+  Module module_;
+  DwarfCUToModule::FileContext file_context_;
+
+  // If this is not DW_LANG_none, we'll pass it as a DW_AT_language
+  // attribute to the compilation unit. This defaults to DW_LANG_none.
+  dwarf2reader::DwarfLanguage language_;
+
+  // If this is true, report DW_AT_language as a signed value; if false,
+  // report it as an unsigned value.
+  bool language_signed_;
+
+  // If this is not empty, we'll give the CU a DW_AT_stmt_list
+  // attribute that, when passed to line_reader_, adds these lines to the
+  // provided lines array.
+  vector<Module::Line> lines_;
+
+  // Mock line program reader.
+  MockLineToModuleFunctor line_reader_;
+  AppendLinesFunctor appender_;
+  static const char dummy_line_program_[];
+  static const size_t dummy_line_size_;
+  
+  MockWarningReporter reporter_;
+  DwarfCUToModule root_handler_;
+
+ private:
+  // Fill functions_, if we haven't already.
+  void FillFunctions();
+
+  // If functions_filled_ is true, this is a table of functions we've
+  // extracted from module_, sorted by address.
+  vector<Module::Function *> functions_;
+  // True if we have filled the above vector with this.module_'s function list.
+  bool functions_filled_;
+};
+
+const char CUFixtureBase::dummy_line_program_[] = "lots of fun data";
+const size_t CUFixtureBase::dummy_line_size_ = 
+    sizeof (CUFixtureBase::dummy_line_program_);
+
+void CUFixtureBase::PushLine(Module::Address address, Module::Address size,
+                             const string &filename, int line_number) {
+  Module::Line l;
+  l.address_ = address;
+  l.size_ = size;
+  l.file_ = module_.FindFile(filename);
+  l.number_ = line_number;
+  lines_.push_back(l);
+}
+
+void CUFixtureBase::StartCU() {
+  // If we have lines, make the line reader expect to be invoked at
+  // most once. (Hey, if the handler can pass its tests without
+  // bothering to read the line number data, that's great.)
+  // Have it add the lines passed to PushLine. Otherwise, leave the 
+  // initial expectation (no calls) in force.
+  if (!lines_.empty())
+    EXPECT_CALL(line_reader_,
+                mock_apply(&dummy_line_program_[0], dummy_line_size_,
+                           &module_, _))
+        .Times(AtMost(1))
+        .WillOnce(DoAll(Invoke(appender_), Return()));
+
+  ASSERT_TRUE(root_handler_
+              .StartCompilationUnit(0x51182ec307610b51ULL, 0x81, 0x44,
+                                    0x4241b4f33720dd5cULL, 3));
+  {
+    dwarf2reader::AttributeList attrs;
+    attrs.push_back(make_pair(dwarf2reader::DW_AT_name,
+                              dwarf2reader::DW_FORM_strp));
+    if (!lines_.empty())
+      attrs.push_back(make_pair(dwarf2reader::DW_AT_stmt_list,
+                                dwarf2reader::DW_FORM_ref4));
+    if (language_ != dwarf2reader::DW_LANG_none)
+      attrs.push_back(make_pair(dwarf2reader::DW_AT_language,
+                                language_signed_
+                                ? dwarf2reader::DW_FORM_sdata 
+                                : dwarf2reader::DW_FORM_udata));
+    ASSERT_TRUE(root_handler_.StartRootDIE(0x02e56bfbda9e7337ULL,
+                                           dwarf2reader::DW_TAG_compile_unit,
+                                           attrs));
+  }
+  root_handler_.ProcessAttributeString(dwarf2reader::DW_AT_name,
+                                       dwarf2reader::DW_FORM_strp,
+                                       "compilation-unit-name");
+  if (!lines_.empty())
+    root_handler_.ProcessAttributeUnsigned(dwarf2reader::DW_AT_stmt_list,
+                                           dwarf2reader::DW_FORM_ref4,
+                                           0);
+  if (language_ != dwarf2reader::DW_LANG_none) {
+    if (language_signed_)
+      root_handler_.ProcessAttributeSigned(dwarf2reader::DW_AT_language,
+                                           dwarf2reader::DW_FORM_sdata,
+                                           language_);
+    else
+      root_handler_.ProcessAttributeUnsigned(dwarf2reader::DW_AT_language,
+                                             dwarf2reader::DW_FORM_udata,
+                                             language_);
+  }
+  ASSERT_TRUE(root_handler_.EndAttributes());
+}
+
+void CUFixtureBase::PushBackStrangeAttributes(
+    dwarf2reader::AttributeList *attrs) {
+  attrs->push_back(make_pair((DwarfAttribute) 0xf560dead,
+                             (DwarfForm) 0x4106e4db));
+  attrs->push_back(make_pair((DwarfAttribute) 0x85380095,
+                             (DwarfForm) 0x0f16fe87));
+  attrs->push_back(make_pair((DwarfAttribute) 0xf7f7480f,
+                             (DwarfForm) 0x829e038a));
+  attrs->push_back(make_pair((DwarfAttribute) 0xa55ffb51,
+                             (DwarfForm) 0x2f43b041));
+  attrs->push_back(make_pair((DwarfAttribute) 0x2fde304a,
+                             (DwarfForm) 0x895ffa23));
+}
+
+void CUFixtureBase::ProcessStrangeAttributes(
+    dwarf2reader::DIEHandler *handler) {
+  handler->ProcessAttributeUnsigned((DwarfAttribute) 0xf560dead,
+                                    (DwarfForm) 0x4106e4db,
+                                    0xa592571997facda1ULL);
+  handler->ProcessAttributeSigned((DwarfAttribute) 0x85380095,
+                                  (DwarfForm) 0x0f16fe87,
+                                  0x12602a4e3bf1f446LL);
+  handler->ProcessAttributeReference((DwarfAttribute) 0xf7f7480f,
+                                     (DwarfForm) 0x829e038a,
+                                     0x50fddef44734fdecULL);
+  static const char buffer[10] = "frobynode";
+  handler->ProcessAttributeBuffer((DwarfAttribute) 0xa55ffb51,
+                                  (DwarfForm) 0x2f43b041,
+                                  buffer, sizeof(buffer));
+  handler->ProcessAttributeString((DwarfAttribute) 0x2f43b041,
+                                  (DwarfForm) 0x895ffa23,
+                                  "strange string");
+}
+
+DIEHandler *CUFixtureBase::StartNamedDIE(DIEHandler *parent,
+                                         DwarfTag tag,
+                                         const string &name) {
+  dwarf2reader::AttributeList attrs;
+  attrs.push_back(make_pair(dwarf2reader::DW_AT_name,
+                            dwarf2reader::DW_FORM_strp));
+  PushBackStrangeAttributes(&attrs);
+  dwarf2reader::DIEHandler *handler
+    = parent->FindChildHandler(0x8f4c783c0467c989ULL, tag, attrs);
+  if (!handler)
+    return NULL;
+  handler->ProcessAttributeString(dwarf2reader::DW_AT_name,
+                                  dwarf2reader::DW_FORM_strp,
+                                  name);
+  ProcessStrangeAttributes(handler);
+  if (!handler->EndAttributes()) {
+    handler->Finish();
+    delete handler;
+    return NULL;
+  }
+    
+  return handler;
+}
+
+DIEHandler *CUFixtureBase::StartSpecifiedDIE(DIEHandler *parent,
+                                             DwarfTag tag,
+                                             uint64 specification,
+                                             const char *name) {
+  dwarf2reader::AttributeList attrs;
+  if (name)
+    attrs.push_back(make_pair(dwarf2reader::DW_AT_name,
+                              dwarf2reader::DW_FORM_strp));
+  attrs.push_back(make_pair(dwarf2reader::DW_AT_specification,
+                            dwarf2reader::DW_FORM_ref4));
+  dwarf2reader::DIEHandler *handler
+    = parent->FindChildHandler(0x8f4c783c0467c989ULL, tag, attrs);
+  if (!handler)
+    return NULL;
+  if (name)
+    handler->ProcessAttributeString(dwarf2reader::DW_AT_name,
+                                    dwarf2reader::DW_FORM_strp,
+                                    name);
+  handler->ProcessAttributeReference(dwarf2reader::DW_AT_specification,
+                                     dwarf2reader::DW_FORM_ref4,
+                                     specification);
+  if (!handler->EndAttributes()) {
+    handler->Finish();
+    delete handler;
+    return NULL;
+  }
+    
+  return handler;
+}
+
+void CUFixtureBase::DefineFunction(dwarf2reader::DIEHandler *parent,
+                                   const string &name, Module::Address address,
+                                   Module::Address size) {
+  dwarf2reader::AttributeList func_attrs;
+  func_attrs.push_back(make_pair(dwarf2reader::DW_AT_name,
+                                 dwarf2reader::DW_FORM_strp));
+  func_attrs.push_back(make_pair(dwarf2reader::DW_AT_low_pc,
+                                 dwarf2reader::DW_FORM_addr));
+  func_attrs.push_back(make_pair(dwarf2reader::DW_AT_high_pc,
+                                 dwarf2reader::DW_FORM_addr));
+  PushBackStrangeAttributes(&func_attrs);
+  dwarf2reader::DIEHandler *func
+      = parent->FindChildHandler(0xe34797c7e68590a8LL,
+                                 dwarf2reader::DW_TAG_subprogram,
+                                 func_attrs);
+  ASSERT_TRUE(func != NULL);
+  func->ProcessAttributeString(dwarf2reader::DW_AT_name,
+                               dwarf2reader::DW_FORM_strp,
+                               name);
+  func->ProcessAttributeUnsigned(dwarf2reader::DW_AT_low_pc,
+                                 dwarf2reader::DW_FORM_addr,
+                                 address);
+  func->ProcessAttributeUnsigned(dwarf2reader::DW_AT_high_pc,
+                                 dwarf2reader::DW_FORM_addr,
+                                 address + size);
+  ProcessStrangeAttributes(func);
+  EXPECT_TRUE(func->EndAttributes());
+  func->Finish();
+  delete func;
+}
+
+void CUFixtureBase::DeclarationDIE(DIEHandler *parent, uint64 offset,
+                                   DwarfTag tag,
+                                   const string &name) {
+  dwarf2reader::AttributeList attrs;
+  if (!name.empty())
+    attrs.push_back(make_pair(dwarf2reader::DW_AT_name,
+                              dwarf2reader::DW_FORM_strp));
+  attrs.push_back(make_pair(dwarf2reader::DW_AT_declaration,
+                            dwarf2reader::DW_FORM_flag));
+  dwarf2reader::DIEHandler *die = parent->FindChildHandler(offset, tag, attrs);
+  ASSERT_TRUE(die != NULL);
+  if (!name.empty())
+    die->ProcessAttributeString(dwarf2reader::DW_AT_name,
+                                dwarf2reader::DW_FORM_strp,
+                                name);
+  die->ProcessAttributeUnsigned(dwarf2reader::DW_AT_declaration,
+                                dwarf2reader::DW_FORM_flag,
+                                1);
+  EXPECT_TRUE(die->EndAttributes());
+  die->Finish();
+  delete die;
+}
+
+void CUFixtureBase::DefinitionDIE(DIEHandler *parent,
+                                  DwarfTag tag,
+                                  uint64 specification,
+                                  const string &name,
+                                  Module::Address address,
+                                  Module::Address size) {
+  dwarf2reader::AttributeList attrs;
+  attrs.push_back(make_pair(dwarf2reader::DW_AT_specification,
+                            dwarf2reader::DW_FORM_ref4));
+  if (!name.empty())
+    attrs.push_back(make_pair(dwarf2reader::DW_AT_name,
+                              dwarf2reader::DW_FORM_strp));
+  if (size) {
+    attrs.push_back(make_pair(dwarf2reader::DW_AT_low_pc,
+                              dwarf2reader::DW_FORM_addr));
+    attrs.push_back(make_pair(dwarf2reader::DW_AT_high_pc,
+                              dwarf2reader::DW_FORM_addr));
+  }
+  dwarf2reader::DIEHandler *die
+    = parent->FindChildHandler(0x6ccfea031a9e6cc9ULL, tag, attrs);
+  ASSERT_TRUE(die != NULL);
+  die->ProcessAttributeReference(dwarf2reader::DW_AT_specification,
+                                 dwarf2reader::DW_FORM_ref4,
+                                 specification);
+  if (!name.empty())
+    die->ProcessAttributeString(dwarf2reader::DW_AT_name,
+                                dwarf2reader::DW_FORM_strp,
+                                name);
+  if (size) {
+    die->ProcessAttributeUnsigned(dwarf2reader::DW_AT_low_pc,
+                                  dwarf2reader::DW_FORM_addr,
+                                  address);
+    die->ProcessAttributeUnsigned(dwarf2reader::DW_AT_high_pc,
+                                  dwarf2reader::DW_FORM_addr,
+                                  address + size);
+  }
+  EXPECT_TRUE(die->EndAttributes());
+  die->Finish();
+  delete die;
+}
+
+void CUFixtureBase::FillFunctions() {
+  if (functions_filled_)
+    return;
+  module_.GetFunctions(&functions_, functions_.end());
+  sort(functions_.begin(), functions_.end(),
+       Module::Function::CompareByAddress);
+  functions_filled_ = true;
+}
+
+void CUFixtureBase::TestFunctionCount(size_t expected) {
+  FillFunctions();
+  ASSERT_EQ(expected, functions_.size());
+}
+
+void CUFixtureBase::TestFunction(int i, const string &name,
+                                 Module::Address address,
+                                 Module::Address size) {
+  FillFunctions();
+  ASSERT_LT((size_t) i, functions_.size());
+
+  Module::Function *function = functions_[i];
+  EXPECT_EQ(name,    function->name_);
+  EXPECT_EQ(address, function->address_);
+  EXPECT_EQ(size,    function->size_);
+  EXPECT_EQ(0U,      function->parameter_size_);
+}
+
+void CUFixtureBase::TestLineCount(int i, size_t expected) {
+  FillFunctions();
+  ASSERT_LT((size_t) i, functions_.size());
+
+  ASSERT_EQ(expected, functions_[i]->lines_.size());
+}
+
+void CUFixtureBase::TestLine(int i, int j,
+                             Module::Address address, Module::Address size,
+                             const string &filename, int number) {
+  FillFunctions();
+  ASSERT_LT((size_t) i, functions_.size());
+  ASSERT_LT((size_t) j, functions_[i]->lines_.size());
+
+  Module::Line *line = &functions_[i]->lines_[j];
+  EXPECT_EQ(address,  line->address_);
+  EXPECT_EQ(size,     line->size_);
+  EXPECT_EQ(filename, line->file_->name_.c_str());
+  EXPECT_EQ(number,   line->number_);
+}
+
+// Include caller locations for our test subroutines.
+#define TRACE(call) do { SCOPED_TRACE("called from here"); call; } while (0)
+#define PushLine(a,b,c,d)          TRACE(PushLine((a),(b),(c),(d)))
+#define SetLanguage(a)             TRACE(SetLanguage(a))
+#define StartCU()                  TRACE(StartCU())
+#define DefineFunction(a,b,c,d)    TRACE(DefineFunction((a),(b),(c),(d)))
+#define DeclarationDIE(a,b,c,d)    TRACE(DeclarationDIE((a),(b),(c),(d)))
+#define DefinitionDIE(a,b,c,d,e,f) TRACE(DefinitionDIE((a),(b),(c),(d),(e),(f)))
+#define TestFunctionCount(a)       TRACE(TestFunctionCount(a))
+#define TestFunction(a,b,c,d)      TRACE(TestFunction((a),(b),(c),(d)))
+#define TestLineCount(a,b)         TRACE(TestLineCount((a),(b)))
+#define TestLine(a,b,c,d,e,f)      TRACE(TestLine((a),(b),(c),(d),(e),(f)))
+
+class Simple: public CUFixtureBase, public Test {
+};
+
+TEST_F(Simple, OneFunc) {
+  PushLine(0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "line-file", 246571772);
+
+  StartCU();
+  DefineFunction(&root_handler_, "function1",
+                 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL);
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "function1", 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL);
+  TestLineCount(0, 1);
+  TestLine(0, 0, 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "line-file",
+           246571772);
+}
+
+TEST_F(Simple, IrrelevantRootChildren) {
+  StartCU();
+  dwarf2reader::AttributeList no_attrs;
+  EXPECT_FALSE(root_handler_
+               .FindChildHandler(0x7db32bff4e2dcfb1ULL,
+                                 dwarf2reader::DW_TAG_lexical_block, no_attrs));
+}
+
+TEST_F(Simple, IrrelevantNamedScopeChildren) {
+  StartCU();
+  dwarf2reader::AttributeList no_attrs;
+  DIEHandler *class_A_handler
+    = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type, "class_A");
+  EXPECT_TRUE(class_A_handler != NULL);
+  EXPECT_FALSE(class_A_handler
+               ->FindChildHandler(0x02e55999b865e4e9ULL,
+                                  dwarf2reader::DW_TAG_lexical_block, 
+                                  no_attrs));
+  delete class_A_handler;
+}
+
+// Verify that FileContexts can safely be deleted unused.
+TEST_F(Simple, UnusedFileContext) {
+  Module m("module-name", "module-os", "module-arch", "module-id");
+  DwarfCUToModule::FileContext fc("dwarf-filename", &m);
+
+  // Kludge: satisfy reporter_'s expectation.
+  reporter_.SetCUName("compilation-unit-name");
+}
+
+// An address range.
+struct Range {
+  Module::Address start, end;
+};
+
+// Test data for pairing functions and lines.
+struct Situation {
+  // Two function intervals, and two line intervals.
+  Range functions[2], lines[2];
+
+  // The number of lines we expect to be assigned to each of the
+  // functions, and the address ranges.
+  int paired_count[2];
+  Range paired[2][2];
+
+  // The number of functions that are not entirely covered by lines,
+  // and vice versa.
+  int uncovered_functions, uncovered_lines;
+};
+
+#define PAIRING(func1_start, func1_end, func2_start, func2_end, \
+                line1_start, line1_end, line2_start, line2_end, \
+                func1_num_lines, func2_num_lines,               \
+                func1_line1_start, func1_line1_end,             \
+                func1_line2_start, func1_line2_end,             \
+                func2_line1_start, func2_line1_end,             \
+                func2_line2_start, func2_line2_end,             \
+                uncovered_functions, uncovered_lines)           \
+  { { { func1_start, func1_end }, { func2_start, func2_end } }, \
+    { { line1_start, line1_end }, { line2_start, line2_end } }, \
+    { func1_num_lines, func2_num_lines },                       \
+    { { { func1_line1_start, func1_line1_end },                 \
+        { func1_line2_start, func1_line2_end } },               \
+      { { func2_line1_start, func2_line1_end },                 \
+          { func2_line2_start, func2_line2_end } } },           \
+    uncovered_functions, uncovered_lines },
+
+Situation situations[] = {
+#include "common/linux/testdata/func-line-pairing.h"
+};
+
+#undef PAIRING
+
+class FuncLinePairing: public CUFixtureBase,
+                       public TestWithParam<Situation> { };
+
+INSTANTIATE_TEST_CASE_P(AllSituations, FuncLinePairing,
+                        ValuesIn(situations));
+
+TEST_P(FuncLinePairing, Pairing) {
+  const Situation &s = GetParam();
+  PushLine(s.lines[0].start,
+           s.lines[0].end - s.lines[0].start,
+           "line-file", 67636963);
+  PushLine(s.lines[1].start,
+           s.lines[1].end - s.lines[1].start,
+           "line-file", 67636963);
+  if (s.uncovered_functions)
+    EXPECT_CALL(reporter_, UncoveredFunction(_))
+      .Times(s.uncovered_functions)
+      .WillRepeatedly(Return());
+  if (s.uncovered_lines)
+    EXPECT_CALL(reporter_, UncoveredLine(_))
+      .Times(s.uncovered_lines)
+      .WillRepeatedly(Return());
+
+  StartCU();
+  DefineFunction(&root_handler_, "function1",
+                 s.functions[0].start, 
+                 s.functions[0].end - s.functions[0].start);
+  DefineFunction(&root_handler_, "function2",
+                 s.functions[1].start, 
+                 s.functions[1].end - s.functions[1].start);
+  root_handler_.Finish();
+
+  TestFunctionCount(2);
+  TestFunction(0, "function1",
+               s.functions[0].start, 
+               s.functions[0].end - s.functions[0].start);
+  TestLineCount(0, s.paired_count[0]);
+  for (int i = 0; i < s.paired_count[0]; i++)
+    TestLine(0, i, s.paired[0][i].start, 
+             s.paired[0][i].end - s.paired[0][i].start, 
+             "line-file", 67636963);
+  TestFunction(1, "function2",
+               s.functions[1].start, 
+               s.functions[1].end - s.functions[1].start);
+  TestLineCount(1, s.paired_count[1]);
+  for (int i = 0; i < s.paired_count[1]; i++)
+    TestLine(1, i, s.paired[1][i].start, 
+             s.paired[1][i].end - s.paired[1][i].start, 
+             "line-file", 67636963);
+}
+
+TEST_F(FuncLinePairing, EmptyCU) {
+
+  StartCU();
+  root_handler_.Finish();
+
+  TestFunctionCount(0);
+}
+
+TEST_F(FuncLinePairing, LinesNoFuncs) {
+  PushLine(40, 2, "line-file", 82485646);
+  EXPECT_CALL(reporter_, UncoveredLine(_)).WillOnce(Return());
+
+  StartCU();
+  root_handler_.Finish();
+
+  TestFunctionCount(0);
+}
+
+TEST_F(FuncLinePairing, FuncsNoLines) {
+  EXPECT_CALL(reporter_, UncoveredFunction(_)).WillOnce(Return());
+
+  StartCU();
+  DefineFunction(&root_handler_, "function1", 0x127da12ffcf5c51fULL, 0x1000U);
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "function1", 0x127da12ffcf5c51fULL, 0x1000U);
+}
+
+TEST_F(FuncLinePairing, GapThenFunction) {
+  PushLine(20, 2, "line-file-2", 174314698);
+  PushLine(10, 2, "line-file-1", 263008005);
+
+  StartCU();
+  DefineFunction(&root_handler_, "function1", 10, 2);
+  DefineFunction(&root_handler_, "function2", 20, 2);
+  root_handler_.Finish();
+
+  TestFunctionCount(2);
+  TestFunction(0, "function1", 10, 2);
+  TestLineCount(0, 1);
+  TestLine(0, 0, 10, 2, "line-file-1", 263008005);
+  TestFunction(1, "function2", 20, 2);
+  TestLineCount(1, 1);
+  TestLine(1, 0, 20, 2, "line-file-2", 174314698);
+}
+
+// If GCC emits padding after one function to align the start of
+// the next, then it will attribute the padding instructions to
+// the last source line of function (to reduce the size of the
+// line number info), but omit it from the DW_AT_{low,high}_pc
+// range given in .debug_info (since it costs nothing to be
+// precise there).  If we did use at least some of the line
+// we're about to skip, then assume this is what happened, and
+// don't warn.
+TEST_F(FuncLinePairing, GCCAlignmentStretch) {
+  PushLine(10, 10, "line-file", 63351048);
+  PushLine(20, 10, "line-file", 61661044);
+
+  StartCU();
+  DefineFunction(&root_handler_, "function1", 10, 5);
+  // five-byte gap between functions, covered by line 63351048.
+  // This should not elicit a warning.
+  DefineFunction(&root_handler_, "function2", 20, 10);
+  root_handler_.Finish();
+
+  TestFunctionCount(2);
+  TestFunction(0, "function1", 10, 5);
+  TestLineCount(0, 1);
+  TestLine(0, 0, 10, 5, "line-file", 63351048);
+  TestFunction(1, "function2", 20, 10);
+  TestLineCount(1, 1);
+  TestLine(1, 0, 20, 10, "line-file", 61661044);
+}
+
+// Unfortunately, neither the DWARF parser's handler interface nor the
+// DIEHandler interface is capable of expressing a function that abuts
+// the end of the address space: the high_pc value looks like zero.
+
+TEST_F(FuncLinePairing, LineAtEndOfAddressSpace) {
+  PushLine(0xfffffffffffffff0ULL, 16, "line-file", 63351048);
+  EXPECT_CALL(reporter_, UncoveredLine(_)).WillOnce(Return());
+
+  StartCU();
+  DefineFunction(&root_handler_, "function1", 0xfffffffffffffff0ULL, 6);
+  DefineFunction(&root_handler_, "function2", 0xfffffffffffffffaULL, 5);
+  root_handler_.Finish();
+
+  TestFunctionCount(2);
+  TestFunction(0, "function1", 0xfffffffffffffff0ULL, 6);
+  TestLineCount(0, 1);
+  TestLine(0, 0, 0xfffffffffffffff0ULL, 6, "line-file", 63351048);
+  TestFunction(1, "function2", 0xfffffffffffffffaULL, 5);
+  TestLineCount(1, 1);
+  TestLine(1, 0, 0xfffffffffffffffaULL, 5, "line-file", 63351048);
+}
+
+// A function with more than one uncovered area should only be warned
+// about once.
+TEST_F(FuncLinePairing, WarnOnceFunc) {
+  PushLine(20, 1, "line-file-2", 262951329);
+  PushLine(11, 1, "line-file-1", 219964021);
+  EXPECT_CALL(reporter_, UncoveredFunction(_)).WillOnce(Return());
+
+  StartCU();
+  DefineFunction(&root_handler_, "function", 10, 11);
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "function", 10, 11);
+  TestLineCount(0, 2);
+  TestLine(0, 0, 11, 1, "line-file-1", 219964021);
+  TestLine(0, 1, 20, 1, "line-file-2", 262951329);
+}
+
+// A line with more than one uncovered area should only be warned
+// about once.
+TEST_F(FuncLinePairing, WarnOnceLine) {
+  PushLine(10, 20, "filename1", 118581871);
+  EXPECT_CALL(reporter_, UncoveredLine(_)).WillOnce(Return());
+
+  StartCU();
+  DefineFunction(&root_handler_, "function1", 11, 1);
+  DefineFunction(&root_handler_, "function2", 13, 1);
+  root_handler_.Finish();
+
+  TestFunctionCount(2);
+  TestFunction(0, "function1", 11, 1);
+  TestLineCount(0, 1);
+  TestLine(0, 0, 11, 1, "filename1", 118581871);
+  TestFunction(1, "function2", 13, 1);
+  TestLineCount(1, 1);
+  TestLine(1, 0, 13, 1, "filename1", 118581871);
+}
+
+class CXXQualifiedNames: public CUFixtureBase,
+                         public TestWithParam<DwarfTag> { };
+
+INSTANTIATE_TEST_CASE_P(VersusEnclosures, CXXQualifiedNames,
+                        Values(dwarf2reader::DW_TAG_class_type,
+                               dwarf2reader::DW_TAG_structure_type,
+                               dwarf2reader::DW_TAG_union_type,
+                               dwarf2reader::DW_TAG_namespace));
+
+TEST_P(CXXQualifiedNames, TwoFunctions) {
+  DwarfTag tag = GetParam();
+
+  SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
+  PushLine(10, 1, "filename1", 69819327);
+  PushLine(20, 1, "filename2", 95115701);
+
+  StartCU();
+  DIEHandler *enclosure_handler = StartNamedDIE(&root_handler_, tag,
+                                                "Enclosure");
+  EXPECT_TRUE(enclosure_handler != NULL);
+  DefineFunction(enclosure_handler, "func_B", 10, 1);
+  DefineFunction(enclosure_handler, "func_C", 20, 1);
+  enclosure_handler->Finish();
+  delete enclosure_handler;
+  root_handler_.Finish();
+
+  TestFunctionCount(2);
+  TestFunction(0, "Enclosure::func_B", 10, 1);
+  TestFunction(1, "Enclosure::func_C", 20, 1);
+}
+
+TEST_P(CXXQualifiedNames, FuncInEnclosureInNamespace) {
+  DwarfTag tag = GetParam();
+
+  SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
+  PushLine(10, 1, "line-file", 69819327);
+
+  StartCU();
+  DIEHandler *namespace_handler 
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
+                      "Namespace");
+  EXPECT_TRUE(namespace_handler != NULL);
+  DIEHandler *enclosure_handler = StartNamedDIE(namespace_handler, tag, 
+                                                "Enclosure");
+  EXPECT_TRUE(enclosure_handler != NULL);
+  DefineFunction(enclosure_handler, "function", 10, 1);
+  enclosure_handler->Finish();
+  delete enclosure_handler;
+  namespace_handler->Finish();
+  delete namespace_handler;
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "Namespace::Enclosure::function", 10, 1);
+}
+
+TEST_F(CXXQualifiedNames, FunctionInClassInStructInNamespace) {
+  SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
+  PushLine(10, 1, "filename1", 69819327);
+
+  StartCU();
+  DIEHandler *namespace_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
+                      "namespace_A");
+  EXPECT_TRUE(namespace_handler != NULL);
+  DIEHandler *struct_handler
+      = StartNamedDIE(namespace_handler, dwarf2reader::DW_TAG_structure_type,
+                      "struct_B");
+  EXPECT_TRUE(struct_handler != NULL);
+  DIEHandler *class_handler
+      = StartNamedDIE(struct_handler, dwarf2reader::DW_TAG_class_type,
+                      "class_C");
+  DefineFunction(class_handler, "function_D", 10, 1);
+  class_handler->Finish();
+  delete class_handler;
+  struct_handler->Finish();
+  delete struct_handler;
+  namespace_handler->Finish();
+  delete namespace_handler;
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "namespace_A::struct_B::class_C::function_D", 10, 1);
+}
+
+struct LanguageAndQualifiedName {
+  dwarf2reader::DwarfLanguage language;
+  const char *name;
+};
+
+const LanguageAndQualifiedName LanguageAndQualifiedNameCases[] = {
+  { dwarf2reader::DW_LANG_none,           "class_A::function_B" },
+  { dwarf2reader::DW_LANG_C,              "class_A::function_B" },
+  { dwarf2reader::DW_LANG_C89,            "class_A::function_B" },
+  { dwarf2reader::DW_LANG_C99,            "class_A::function_B" },
+  { dwarf2reader::DW_LANG_C_plus_plus,    "class_A::function_B" },
+  { dwarf2reader::DW_LANG_Java,           "class_A.function_B" },
+  { dwarf2reader::DW_LANG_Cobol74,        "class_A::function_B" },
+  { dwarf2reader::DW_LANG_Mips_Assembler, NULL }
+};
+
+class QualifiedForLanguage:
+    public CUFixtureBase,
+    public TestWithParam<LanguageAndQualifiedName> { };
+                        
+INSTANTIATE_TEST_CASE_P(LanguageAndQualifiedName, QualifiedForLanguage,
+                        ValuesIn(LanguageAndQualifiedNameCases));
+
+TEST_P(QualifiedForLanguage, MemberFunction) {
+  const LanguageAndQualifiedName &param = GetParam();
+
+  PushLine(10, 1, "line-file", 212966758);
+  SetLanguage(param.language);
+
+  StartCU();
+  DIEHandler *class_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
+                      "class_A");
+  DefineFunction(class_handler, "function_B", 10, 1);
+  class_handler->Finish();
+  delete class_handler;
+  root_handler_.Finish();
+
+  if (param.name) {
+    TestFunctionCount(1);
+    TestFunction(0, param.name, 10, 1);
+  } else {
+    TestFunctionCount(0);
+  }
+}
+
+TEST_P(QualifiedForLanguage, MemberFunctionSignedLanguage) {
+  const LanguageAndQualifiedName &param = GetParam();
+
+  PushLine(10, 1, "line-file", 212966758);
+  SetLanguage(param.language);
+  SetLanguageSigned(true);
+
+  StartCU();
+  DIEHandler *class_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
+                      "class_A");
+  DefineFunction(class_handler, "function_B", 10, 1);
+  class_handler->Finish();
+  delete class_handler;
+  root_handler_.Finish();
+
+  if (param.name) {
+    TestFunctionCount(1);
+    TestFunction(0, param.name, 10, 1);
+  } else {
+    TestFunctionCount(0);
+  }
+}
+
+class Specifications: public CUFixtureBase, public Test { };
+
+TEST_F(Specifications, Function) {
+  PushLine(0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL, "line-file", 54883661);
+
+  StartCU();
+  DeclarationDIE(&root_handler_, 0xcd3c51b946fb1eeeLL,
+                 dwarf2reader::DW_TAG_subprogram, "declaration-name");
+  DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
+                0xcd3c51b946fb1eeeLL, "",
+                0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL);
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "declaration-name",
+               0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL);
+}
+
+TEST_F(Specifications, MemberFunction) {
+  PushLine(0x3341a248634e7170ULL, 0x5f6938ee5553b953ULL, "line-file", 18116691);
+
+  StartCU();
+  DIEHandler *class_handler
+    = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type, "class_A");
+  DeclarationDIE(class_handler, 0x7d83028c431406e8ULL,
+                 dwarf2reader::DW_TAG_subprogram, "declaration-name");
+  class_handler->Finish();
+  delete class_handler;
+  DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
+                0x7d83028c431406e8ULL, "",
+                0x3341a248634e7170ULL, 0x5f6938ee5553b953ULL);
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "class_A::declaration-name",
+               0x3341a248634e7170ULL, 0x5f6938ee5553b953ULL);
+}
+
+// This case should gather the name from both the definition and the
+// declaration's parent.
+TEST_F(Specifications, FunctionDeclarationParent) {
+  PushLine(0x463c9ddf405be227ULL, 0x6a47774af5049680ULL, "line-file", 70254922);
+
+  StartCU();
+  {
+    DIEHandler *class_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
+                      "class_A");
+    ASSERT_TRUE(class_handler != NULL);
+    DeclarationDIE(class_handler, 0x0e0e877c8404544aULL,
+                   dwarf2reader::DW_TAG_subprogram, "declaration-name");
+    class_handler->Finish();
+    delete class_handler;
+  }
+
+  DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
+                0x0e0e877c8404544aULL, "definition-name", 
+                0x463c9ddf405be227ULL, 0x6a47774af5049680ULL);
+
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "class_A::definition-name",
+               0x463c9ddf405be227ULL, 0x6a47774af5049680ULL);
+}
+
+// Named scopes should also gather enclosing name components from
+// their declarations.
+TEST_F(Specifications, NamedScopeDeclarationParent) {
+  PushLine(0x5d13433d0df13d00ULL, 0x48ebebe5ade2cab4ULL, "line-file", 77392604);
+
+  StartCU();
+  {
+    DIEHandler *space_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
+                      "space_A");
+    ASSERT_TRUE(space_handler != NULL);
+    DeclarationDIE(space_handler, 0x419bb1d12f9a73a2ULL,
+                   dwarf2reader::DW_TAG_class_type, "class-declaration-name");
+    space_handler->Finish();
+    delete space_handler;
+  }
+
+  {
+    DIEHandler *class_handler
+      = StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
+                          0x419bb1d12f9a73a2ULL, "class-definition-name");
+    ASSERT_TRUE(class_handler != NULL);
+    DefineFunction(class_handler, "function", 
+                   0x5d13433d0df13d00ULL, 0x48ebebe5ade2cab4ULL);
+    class_handler->Finish();
+    delete class_handler;
+  }
+
+  root_handler_.Finish();
+  
+  TestFunctionCount(1);
+  TestFunction(0, "space_A::class-definition-name::function",
+               0x5d13433d0df13d00ULL, 0x48ebebe5ade2cab4ULL);
+}
+
+// Check name construction for a long chain containing each combination of:
+// - struct, union, class, namespace
+// - direct and definition
+TEST_F(Specifications, LongChain) {
+  PushLine(0x5a0dd6bb85db754cULL, 0x3bccb213d08c7fd3ULL, "line-file", 21192926);
+  SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
+
+  StartCU();
+  // The structure we're building here is:
+  // space_A full definition
+  //   space_B declaration
+  // space_B definition
+  //   struct_C full definition
+  //     struct_D declaration
+  // struct_D definition
+  //   union_E full definition
+  //     union_F declaration
+  // union_F definition
+  //   class_G full definition
+  //     class_H declaration
+  // class_H definition
+  //   func_I declaration
+  // func_I definition
+  // 
+  // So: 
+  // - space_A, struct_C, union_E, and class_G don't use specifications;
+  // - space_B, struct_D, union_F, and class_H do.
+  // - func_I uses a specification.
+  // 
+  // The full name for func_I is thus:
+  // 
+  // space_A::space_B::struct_C::struct_D::union_E::union_F::
+  //   class_G::class_H::func_I
+  {
+    DIEHandler *space_A_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
+                      "space_A");
+    DeclarationDIE(space_A_handler, 0x2e111126496596e2ULL,
+                   dwarf2reader::DW_TAG_namespace, "space_B");
+    space_A_handler->Finish();
+    delete space_A_handler;
+  }
+
+  {
+    DIEHandler *space_B_handler
+      = StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
+                          0x2e111126496596e2ULL);
+    DIEHandler *struct_C_handler
+      = StartNamedDIE(space_B_handler, dwarf2reader::DW_TAG_structure_type,
+                      "struct_C");
+    DeclarationDIE(struct_C_handler, 0x20cd423bf2a25a4cULL,
+                   dwarf2reader::DW_TAG_structure_type, "struct_D");
+    struct_C_handler->Finish();
+    delete struct_C_handler;
+    space_B_handler->Finish();
+    delete space_B_handler;
+  }
+
+  {
+    DIEHandler *struct_D_handler
+      = StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_structure_type,
+                          0x20cd423bf2a25a4cULL);
+    DIEHandler *union_E_handler
+      = StartNamedDIE(struct_D_handler, dwarf2reader::DW_TAG_union_type,
+                      "union_E");
+    DeclarationDIE(union_E_handler, 0xe25c84805aa58c32ULL,
+                   dwarf2reader::DW_TAG_union_type, "union_F");
+    union_E_handler->Finish();
+    delete union_E_handler;
+    struct_D_handler->Finish();
+    delete struct_D_handler;
+  }
+
+  {
+    DIEHandler *union_F_handler
+      = StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_union_type,
+                          0xe25c84805aa58c32ULL);
+    DIEHandler *class_G_handler
+      = StartNamedDIE(union_F_handler, dwarf2reader::DW_TAG_class_type,
+                      "class_G");
+    DeclarationDIE(class_G_handler, 0xb70d960dcc173b6eULL,
+                   dwarf2reader::DW_TAG_class_type, "class_H");
+    class_G_handler->Finish();
+    delete class_G_handler;
+    union_F_handler->Finish();
+    delete union_F_handler;
+  }
+
+  {
+    DIEHandler *class_H_handler
+      = StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
+                          0xb70d960dcc173b6eULL);
+    DeclarationDIE(class_H_handler, 0x27ff829e3bf69f37ULL,
+                   dwarf2reader::DW_TAG_subprogram, "func_I");
+    class_H_handler->Finish();
+    delete class_H_handler;
+  }
+
+  DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
+                0x27ff829e3bf69f37ULL, "",
+                0x5a0dd6bb85db754cULL, 0x3bccb213d08c7fd3ULL);
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "space_A::space_B::struct_C::struct_D::union_E::union_F"
+               "::class_G::class_H::func_I",
+               0x5a0dd6bb85db754cULL, 0x3bccb213d08c7fd3ULL);
+}
+
+TEST_F(Specifications, InterCU) {
+  Module m("module-name", "module-os", "module-arch", "module-id");
+  DwarfCUToModule::FileContext fc("dwarf-filename", &m);
+  EXPECT_CALL(reporter_, UncoveredFunction(_)).WillOnce(Return());
+  MockLineToModuleFunctor lr;
+  EXPECT_CALL(lr, mock_apply(_,_,_,_)).Times(0);
+  dwarf2reader::AttributeList no_attrs;
+
+  // Kludge: satisfy reporter_'s expectation.
+  reporter_.SetCUName("compilation-unit-name");
+
+  // First CU.  Declares class_A.
+  {
+    DwarfCUToModule root1_handler(&fc, &lr, &reporter_);
+    ASSERT_TRUE(root1_handler.StartCompilationUnit(0, 1, 2, 3, 3));
+    dwarf2reader::AttributeList attrs;
+    PushBackStrangeAttributes(&attrs);
+    ASSERT_TRUE(root1_handler.StartRootDIE(1, dwarf2reader::DW_TAG_compile_unit,
+                                           attrs));
+    ProcessStrangeAttributes(&root1_handler);
+    ASSERT_TRUE(root1_handler.EndAttributes());
+    DeclarationDIE(&root1_handler, 0xb8fbfdd5f0b26fceULL,
+                   dwarf2reader::DW_TAG_class_type, "class_A");
+    root1_handler.Finish();
+  }
+   
+  // Second CU.  Defines class_A, declares member_func_B.
+  {
+    DwarfCUToModule root2_handler(&fc, &lr, &reporter_);
+    ASSERT_TRUE(root2_handler.StartCompilationUnit(0, 1, 2, 3, 3));
+    ASSERT_TRUE(root2_handler.StartRootDIE(1, dwarf2reader::DW_TAG_compile_unit,
+                                           no_attrs));
+    ASSERT_TRUE(root2_handler.EndAttributes());
+    DIEHandler *class_A_handler
+      = StartSpecifiedDIE(&root2_handler, dwarf2reader::DW_TAG_class_type,
+                          0xb8fbfdd5f0b26fceULL);
+    DeclarationDIE(class_A_handler, 0xb01fef8b380bd1a2ULL,
+                   dwarf2reader::DW_TAG_subprogram, "member_func_B");
+    class_A_handler->Finish();
+    delete class_A_handler;
+    root2_handler.Finish();
+  }
+
+  // Third CU.  Defines member_func_B.
+  {
+    DwarfCUToModule root3_handler(&fc, &lr, &reporter_);
+    ASSERT_TRUE(root3_handler.StartCompilationUnit(0, 1, 2, 3, 3));
+    ASSERT_TRUE(root3_handler.StartRootDIE(1, dwarf2reader::DW_TAG_compile_unit,
+                                           no_attrs));
+    ASSERT_TRUE(root3_handler.EndAttributes());
+    DefinitionDIE(&root3_handler, dwarf2reader::DW_TAG_subprogram,
+                  0xb01fef8b380bd1a2ULL, "",
+                  0x2618f00a1a711e53ULL, 0x4fd94b76d7c2caf5ULL);
+    root3_handler.Finish();
+  }
+
+  vector<Module::Function *> functions;
+  m.GetFunctions(&functions, functions.end());
+  EXPECT_EQ(1U, functions.size());
+  EXPECT_STREQ("class_A::member_func_B", functions[0]->name_.c_str());
+}
+
+TEST_F(Specifications, BadOffset) {
+  PushLine(0xa0277efd7ce83771ULL, 0x149554a184c730c1ULL, "line-file", 56636272);
+  EXPECT_CALL(reporter_, UnknownSpecification(_, 0x2be953efa6f9a996ULL))
+    .WillOnce(Return());
+
+  StartCU();
+  DeclarationDIE(&root_handler_, 0xefd7f7752c27b7e4ULL,
+                 dwarf2reader::DW_TAG_subprogram, "function");
+  DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
+                0x2be953efa6f9a996ULL, "",
+                0xa0277efd7ce83771ULL, 0x149554a184c730c1ULL);
+  root_handler_.Finish();
+}
+
+TEST_F(Specifications, FunctionDefinitionHasOwnName) {
+  PushLine(0xced50b3eea81022cULL, 0x08dd4d301cc7a7d2ULL, "line-file", 56792403);
+
+  StartCU();
+  DeclarationDIE(&root_handler_, 0xc34ff4786cae78bdULL,
+                 dwarf2reader::DW_TAG_subprogram, "declaration-name");
+  DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
+                0xc34ff4786cae78bdULL, "definition-name",
+                0xced50b3eea81022cULL, 0x08dd4d301cc7a7d2ULL);
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "definition-name",
+               0xced50b3eea81022cULL, 0x08dd4d301cc7a7d2ULL);
+}
+
+TEST_F(Specifications, ClassDefinitionHasOwnName) {
+  PushLine(0x1d0f5e0f6ce309bdULL, 0x654e1852ec3599e7ULL, "line-file", 57119241);
+
+  StartCU();
+  DeclarationDIE(&root_handler_, 0xd0fe467ec2f1a58cULL,
+                 dwarf2reader::DW_TAG_class_type, "class-declaration-name");
+
+  dwarf2reader::DIEHandler *class_definition
+    = StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
+                        0xd0fe467ec2f1a58cULL, "class-definition-name");
+  ASSERT_TRUE(class_definition);
+  DeclarationDIE(class_definition, 0x6d028229c15623dbULL,
+                 dwarf2reader::DW_TAG_subprogram,
+                 "function-declaration-name");
+  class_definition->Finish();
+  delete class_definition;
+
+  DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
+                0x6d028229c15623dbULL, "function-definition-name",
+                0x1d0f5e0f6ce309bdULL, 0x654e1852ec3599e7ULL);
+
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "class-definition-name::function-definition-name",
+               0x1d0f5e0f6ce309bdULL, 0x654e1852ec3599e7ULL);
+}
+
+// DIEs that cite a specification should prefer the specification's
+// parents over their own when choosing qualified names. In this test,
+// we take the name from our definition but the enclosing scope name
+// from our declaration. I don't see why they'd ever be different, but
+// we want to verify what DwarfCUToModule is looking at.
+TEST_F(Specifications, PreferSpecificationParents) {
+  PushLine(0xbbd9d54dce3b95b7ULL, 0x39188b7b52b0899fULL, "line-file", 79488694);
+
+  StartCU();
+  {
+    dwarf2reader::DIEHandler *declaration_class_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type, "declaration-class");
+    DeclarationDIE(declaration_class_handler, 0x9ddb35517455ef7aULL,
+                   dwarf2reader::DW_TAG_subprogram, "function-declaration");
+    declaration_class_handler->Finish();
+    delete declaration_class_handler;
+  }
+  {
+    dwarf2reader::DIEHandler *definition_class_handler
+      = StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
+                      "definition-class");
+    DefinitionDIE(definition_class_handler, dwarf2reader::DW_TAG_subprogram,
+                  0x9ddb35517455ef7aULL, "function-definition",
+                  0xbbd9d54dce3b95b7ULL, 0x39188b7b52b0899fULL);
+    definition_class_handler->Finish();
+    delete definition_class_handler;
+  }
+  root_handler_.Finish();
+
+  TestFunctionCount(1);
+  TestFunction(0, "declaration-class::function-definition",
+               0xbbd9d54dce3b95b7ULL, 0x39188b7b52b0899fULL);
+}
+
+class Errors: public CUFixtureBase, public Test { };
+
+TEST_F(Errors, BadStmtList) {
+  EXPECT_CALL(reporter_, BadLineInfoOffset(dummy_line_size_ + 10)).Times(1);
+
+  ASSERT_TRUE(root_handler_
+              .StartCompilationUnit(0xc591d5b037543d7cULL, 0x11, 0xcd,
+                                    0x2d7d19546cf6590cULL, 3));
+  dwarf2reader::AttributeList attrs;
+  attrs.push_back(make_pair(dwarf2reader::DW_AT_name,
+                            dwarf2reader::DW_FORM_strp));
+  attrs.push_back(make_pair(dwarf2reader::DW_AT_stmt_list,
+                            dwarf2reader::DW_FORM_ref4));
+  ASSERT_TRUE(root_handler_.StartRootDIE(0xae789dc102cfca54ULL,
+                                         dwarf2reader::DW_TAG_compile_unit,
+                                         attrs));
+  root_handler_.ProcessAttributeString(dwarf2reader::DW_AT_name,
+                                       dwarf2reader::DW_FORM_strp,
+                                       "compilation-unit-name");
+  root_handler_.ProcessAttributeUnsigned(dwarf2reader::DW_AT_stmt_list,
+                                         dwarf2reader::DW_FORM_ref4,
+                                         dummy_line_size_ + 10);
+  root_handler_.EndAttributes();
+  root_handler_.Finish();
+}
+
+TEST_F(Errors, NoLineSection) {
+  EXPECT_CALL(reporter_, MissingSection(".debug_line")).Times(1);
+  PushLine(0x88507fb678052611ULL, 0x42c8e9de6bbaa0faULL, "line-file", 64472290);
+  // Delete the entry for .debug_line added by the fixture class's constructor.
+  file_context_.section_map.clear();
+
+  StartCU();
+  root_handler_.Finish();
+}
+
+TEST_F(Errors, BadDwarfVersion1) {
+  // Kludge: satisfy reporter_'s expectation.
+  reporter_.SetCUName("compilation-unit-name");
+
+  ASSERT_FALSE(root_handler_
+               .StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
+                                     0xc9de224ccb99ac3eULL, 1));
+}
+
+TEST_F(Errors, GoodDwarfVersion2) {
+  // Kludge: satisfy reporter_'s expectation.
+  reporter_.SetCUName("compilation-unit-name");
+
+  ASSERT_TRUE(root_handler_
+               .StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
+                                     0xc9de224ccb99ac3eULL, 2));
+}
+
+TEST_F(Errors, GoodDwarfVersion3) {
+  // Kludge: satisfy reporter_'s expectation.
+  reporter_.SetCUName("compilation-unit-name");
+
+  ASSERT_TRUE(root_handler_
+               .StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
+                                     0xc9de224ccb99ac3eULL, 3));
+}
+
+TEST_F(Errors, BadCURootDIETag) {
+  // Kludge: satisfy reporter_'s expectation.
+  reporter_.SetCUName("compilation-unit-name");
+
+  ASSERT_TRUE(root_handler_
+               .StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
+                                     0xc9de224ccb99ac3eULL, 3));
+
+  dwarf2reader::AttributeList no_attrs;
+  ASSERT_FALSE(root_handler_.StartRootDIE(0x02e56bfbda9e7337ULL,
+                                          dwarf2reader::DW_TAG_subprogram,
+                                          no_attrs));
+}
+
+// Would be nice to also test:
+// - overlapping lines, functions
diff --git a/src/common/linux/dwarf_line_to_module.cc b/src/common/linux/dwarf_line_to_module.cc
new file mode 100644
index 00000000..745d324c
--- /dev/null
+++ b/src/common/linux/dwarf_line_to_module.cc
@@ -0,0 +1,119 @@
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "common/linux/dwarf_line_to_module.h"
+
+// Trying to support Windows paths in a reasonable way adds a lot of
+// variations to test; it would be better to just put off dealing with
+// it until we actually have to deal with DWARF on Windows.
+
+// Return true if PATH is an absolute path, false if it is relative.
+static bool PathIsAbsolute(const string &path) {
+  return (path.size() >= 1 && path[0] == '/');
+}
+
+// If PATH is an absolute path, return PATH.  If PATH is a relative path,
+// treat it as relative to BASE and return the combined path.
+static string ExpandPath(const string &path, const string &base) {
+  if (PathIsAbsolute(path))
+    return path;
+  return base + "/" + path;
+}
+
+namespace google_breakpad {
+
+void DwarfLineToModule::DefineDir(const string &name, uint32 dir_num) {
+  // Directory number zero is reserved to mean the compilation
+  // directory. Silently ignore attempts to redefine it.
+  if (dir_num != 0)
+    directories_[dir_num] = name;
+}
+
+void DwarfLineToModule::DefineFile(const string &name, int32 file_num,
+                                   uint32 dir_num, uint64 mod_time,
+                                   uint64 length) {
+  if (file_num == -1)
+    file_num = ++highest_file_number_;
+  else if (file_num > highest_file_number_)
+    highest_file_number_ = file_num;
+
+  std::string full_name;
+  if (dir_num != 0) {
+    DirectoryTable::const_iterator directory_it = directories_.find(dir_num);
+    if (directory_it != directories_.end()) {
+      full_name = ExpandPath(name, directory_it->second);
+    } else {
+      if (!warned_bad_directory_number_) {
+        fprintf(stderr, "warning: DWARF line number data refers to undefined"
+                " directory numbers\n");
+        warned_bad_directory_number_ = true;
+      }
+      full_name = name; // just treat name as relative
+    }
+  } else {
+    // Directory number zero is the compilation directory; we just report
+    // relative paths in that case.
+    full_name = name;
+  }
+
+  // Find a Module::File object of the given name, and add it to the
+  // file table.
+  files_[file_num] = module_->FindFile(full_name);
+}
+
+void DwarfLineToModule::AddLine(uint64 address, uint64 length,
+                                uint32 file_num, uint32 line_num,
+                                uint32 column_num) {
+  if (length == 0)
+    return;
+
+  // Clip lines not to extend beyond the end of the address space.
+  if (address + length < address)
+    length = -address;
+
+  // Find the source file being referred to.
+  Module::File *file = files_[file_num];
+  if (!file) {
+    if (!warned_bad_file_number_) {
+      fprintf(stderr, "warning: DWARF line number data refers to "
+              "undefined file numbers\n");
+      warned_bad_file_number_ = true;
+    }
+    return;
+  }
+  Module::Line line;
+  line.address_ = address;
+  // We set the size when we get the next line or the EndSequence call.
+  line.size_ = length;
+  line.file_ = file;
+  line.number_ = line_num;
+  lines_->push_back(line);
+}
+
+} // namespace google_breakpad
diff --git a/src/common/linux/dwarf_line_to_module.h b/src/common/linux/dwarf_line_to_module.h
new file mode 100644
index 00000000..f27036ed
--- /dev/null
+++ b/src/common/linux/dwarf_line_to_module.h
@@ -0,0 +1,111 @@
+// -*- mode: c++ -*-
+
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef COMMON_LINUX_DWARF_LINE_TO_MODULE_H
+#define COMMON_LINUX_DWARF_LINE_TO_MODULE_H
+
+#include "common/linux/module.h"
+#include "common/dwarf/dwarf2reader.h"
+
+namespace google_breakpad {
+
+// A class for producing a vector of google_breakpad::Module::Line
+// instances from parsed DWARF line number data.  
+//
+// An instance of this class can be provided as a handler to a
+// dwarf2reader::LineInfo DWARF line number information parser. The
+// handler accepts source location information from the parser and
+// uses it to produce a vector of google_breakpad::Module::Line
+// objects, referring to google_breakpad::Module::File objects added
+// to a particular google_breakpad::Module.
+class DwarfLineToModule: public dwarf2reader::LineInfoHandler {
+ public:
+  // As the DWARF line info parser passes us line records, add source
+  // files to MODULE, and add all lines to the end of LINES. LINES
+  // need not be empty. If the parser hands us a zero-length line, we
+  // omit it. If the parser hands us a line that extends beyond the
+  // end of the address space, we clip it. It's up to our client to
+  // sort out which lines belong to which functions; we don't add them
+  // to any particular function in MODULE ourselves.
+  DwarfLineToModule(Module *module, vector<Module::Line> *lines)
+      : module_(module),
+        lines_(lines),
+        highest_file_number_(-1),
+        warned_bad_file_number_(false),
+        warned_bad_directory_number_(false) { }
+  
+  ~DwarfLineToModule() { }
+
+  void DefineDir(const std::string &name, uint32 dir_num);
+  void DefineFile(const std::string &name, int32 file_num,
+                  uint32 dir_num, uint64 mod_time,
+                  uint64 length);
+  void AddLine(uint64 address, uint64 length,
+               uint32 file_num, uint32 line_num, uint32 column_num);
+
+ private:
+
+  typedef std::map<uint32, std::string> DirectoryTable;
+  typedef std::map<uint32, Module::File *> FileTable;
+
+  // The module we're contributing debugging info to. Owned by our
+  // client.
+  Module *module_;
+
+  // The vector of lines we're accumulating. Owned by our client.
+  //
+  // In a Module, as in a breakpad symbol file, lines belong to
+  // specific functions, but DWARF simply assigns lines to addresses;
+  // one must infer the line/function relationship using the
+  // functions' beginning and ending addresses. So we can't add these
+  // to the appropriate function from module_ until we've read the
+  // function info as well. Instead, we accumulate lines here, and let
+  // whoever constructed this sort it all out.
+  vector<Module::Line> *lines_;
+
+  // A table mapping directory numbers to paths.
+  DirectoryTable directories_;
+
+  // A table mapping file numbers to Module::File pointers.
+  FileTable files_;
+
+  // The highest file number we've seen so far, or -1 if we've seen
+  // none.  Used for dynamically defined file numbers.
+  int32 highest_file_number_;
+
+  // True if we've warned about:
+  bool warned_bad_file_number_; // bad file numbers
+  bool warned_bad_directory_number_; // bad directory numbers
+};
+
+} // namespace google_breakpad
+
+#endif // COMMON_LINUX_DWARF_LINE_TO_MODULE_H
diff --git a/src/common/linux/dwarf_line_to_module_unittest.cc b/src/common/linux/dwarf_line_to_module_unittest.cc
new file mode 100644
index 00000000..ad0bcc8c
--- /dev/null
+++ b/src/common/linux/dwarf_line_to_module_unittest.cc
@@ -0,0 +1,265 @@
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// dwarf_line_to_module.cc: Unit tests for google_breakpad::DwarfLineToModule.
+
+#include "breakpad_googletest_includes.h"
+#include "common/linux/dwarf_line_to_module.h"
+
+using google_breakpad::DwarfLineToModule;
+using google_breakpad::Module;
+using google_breakpad::Module;
+
+TEST(Simple, One) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineFile("file1", 0x30bf0f27, 0, 0, 0);
+  h.AddLine(0x6fd126fbf74f2680LL, 0x63c9a14cf556712bLL, 0x30bf0f27, 
+            0x4c090cbf, 0x1cf9fe0d);
+
+  vector<Module::File *> files;
+  m.GetFiles(&files);
+  EXPECT_EQ(1U, files.size());
+  EXPECT_STREQ("file1", files[0]->name_.c_str());
+
+  EXPECT_EQ(1U, lines.size());
+  EXPECT_EQ(0x6fd126fbf74f2680ULL, lines[0].address_);
+  EXPECT_EQ(0x63c9a14cf556712bULL, lines[0].size_);
+  EXPECT_TRUE(lines[0].file_ == files[0]);
+  EXPECT_EQ(0x4c090cbf, lines[0].number_);
+}
+
+TEST(Simple, Many) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("directory1", 0x838299ab);
+  h.DefineDir("directory2", 0xf85de023);
+  h.DefineFile("file1", 0x2b80377a, 0x838299ab, 0, 0);
+  h.DefineFile("file1", 0x63beb4a4, 0xf85de023, 0, 0);
+  h.DefineFile("file2", 0x1d161d56, 0x838299ab, 0, 0);
+  h.DefineFile("file2", 0x1e7a667c, 0xf85de023, 0, 0);
+  h.AddLine(0x69900c5d553b7274ULL, 0x90fded183f0d0d3cULL, 0x2b80377a,
+            0x15b0f0a9U, 0x3ff5abd6U);
+  h.AddLine(0x45811219a39b7101ULL, 0x25a5e6a924afc41fULL, 0x63beb4a4,
+            0x4d259ce9U, 0x41c5ee32U);
+  h.AddLine(0xfa90514c1dc9704bULL, 0x0063efeabc02f313ULL, 0x1d161d56,
+            0x1ee9fa4fU, 0xbf70e46aU);
+  h.AddLine(0x556b55fb6a647b10ULL, 0x3f3089ca2bfd80f5ULL, 0x1e7a667c,
+            0x77fc280eU, 0x2c4a728cU);
+  h.DefineFile("file3", -1, 0, 0, 0);
+  h.AddLine(0xe2d72a37f8d9403aULL, 0x034dfab5b0d4d236ULL, 0x63beb4a5,
+            0x75047044U, 0xb6a0016cU);
+
+  vector<Module::File *> files;
+  m.GetFiles(&files);
+  ASSERT_EQ(5U, files.size());
+  EXPECT_STREQ("directory1/file1", files[0]->name_.c_str());
+  EXPECT_STREQ("directory1/file2", files[1]->name_.c_str());
+  EXPECT_STREQ("directory2/file1", files[2]->name_.c_str());
+  EXPECT_STREQ("directory2/file2", files[3]->name_.c_str());
+  EXPECT_STREQ("file3",            files[4]->name_.c_str());
+
+  ASSERT_EQ(5U, lines.size());
+
+  EXPECT_EQ(0x69900c5d553b7274ULL, lines[0].address_);
+  EXPECT_EQ(0x90fded183f0d0d3cULL, lines[0].size_);
+  EXPECT_TRUE(lines[0].file_ == files[0]);
+  EXPECT_EQ(0x15b0f0a9, lines[0].number_);
+
+  EXPECT_EQ(0x45811219a39b7101ULL, lines[1].address_);
+  EXPECT_EQ(0x25a5e6a924afc41fULL, lines[1].size_);
+  EXPECT_TRUE(lines[1].file_ == files[2]);
+  EXPECT_EQ(0x4d259ce9, lines[1].number_);
+
+  EXPECT_EQ(0xfa90514c1dc9704bULL, lines[2].address_);
+  EXPECT_EQ(0x0063efeabc02f313ULL, lines[2].size_);
+  EXPECT_TRUE(lines[2].file_ == files[1]);
+  EXPECT_EQ(0x1ee9fa4f, lines[2].number_);
+
+  EXPECT_EQ(0x556b55fb6a647b10ULL, lines[3].address_);
+  EXPECT_EQ(0x3f3089ca2bfd80f5ULL, lines[3].size_);
+  EXPECT_TRUE(lines[3].file_ == files[3]);
+  EXPECT_EQ(0x77fc280e, lines[3].number_);
+
+  EXPECT_EQ(0xe2d72a37f8d9403aULL, lines[4].address_);
+  EXPECT_EQ(0x034dfab5b0d4d236ULL, lines[4].size_);
+  EXPECT_TRUE(lines[4].file_ == files[4]);
+  EXPECT_EQ(0x75047044, lines[4].number_);
+}
+
+TEST(Filenames, Absolute) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("directory1", 1);
+  h.DefineFile("/absolute", 1, 1, 0, 0);
+
+  h.AddLine(1, 1, 1, 0, 0);
+
+  vector<Module::File *> files;
+  m.GetFiles(&files);
+  ASSERT_EQ(1U, files.size());
+  EXPECT_STREQ("/absolute", files[0]->name_.c_str());
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_TRUE(lines[0].file_ == files[0]);
+}
+
+TEST(Filenames, Relative) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("directory1", 1);
+  h.DefineFile("relative", 1, 1, 0, 0);
+
+  h.AddLine(1, 1, 1, 0, 0);
+
+  vector<Module::File *> files;
+  m.GetFiles(&files);
+  ASSERT_EQ(1U, files.size());
+  EXPECT_STREQ("directory1/relative", files[0]->name_.c_str());
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_TRUE(lines[0].file_ == files[0]);
+}
+
+TEST(Filenames, StrangeFile) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("directory1", 1);
+  h.DefineFile("", 1, 1, 0, 0);
+  h.AddLine(1, 1, 1, 0, 0);
+
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_STREQ("directory1/", lines[0].file_->name_.c_str());
+}
+
+TEST(Filenames, StrangeDirectory) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("", 1);
+  h.DefineFile("file1", 1, 1, 0, 0);
+  h.AddLine(1, 1, 1, 0, 0);
+
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_STREQ("/file1", lines[0].file_->name_.c_str());
+}
+
+TEST(Filenames, StrangeDirectoryAndFile) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("", 1);
+  h.DefineFile("", 1, 1, 0, 0);
+  h.AddLine(1, 1, 1, 0, 0);
+
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_STREQ("/", lines[0].file_->name_.c_str());
+}
+
+// We should silently ignore attempts to define directory number zero,
+// since that is always the compilation directory.
+TEST(Errors, DirectoryZero) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("directory0", 0); // should be ignored
+  h.DefineFile("relative", 1, 0, 0, 0);
+
+  h.AddLine(1, 1, 1, 0, 0);
+
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_STREQ("relative", lines[0].file_->name_.c_str());
+}
+
+// We should refuse to add lines with bogus file numbers. We should
+// produce only one warning, however.
+TEST(Errors, BadFileNumber) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineFile("relative", 1, 0, 0, 0);
+  h.AddLine(1, 1, 2, 0, 0); // bad file number
+  h.AddLine(2, 1, 2, 0, 0); // bad file number (no duplicate warning)
+
+  EXPECT_EQ(0U, lines.size());
+}
+
+// We should treat files with bogus directory numbers as relative to
+// the compilation unit.
+TEST(Errors, BadDirectoryNumber) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineDir("directory1", 1);
+  h.DefineFile("baddirnumber1", 1, 2, 0, 0); // bad directory number
+  h.DefineFile("baddirnumber2", 2, 2, 0, 0); // bad dir number (no warning)
+  h.AddLine(1, 1, 1, 0, 0);
+
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_STREQ("baddirnumber1", lines[0].file_->name_.c_str());
+}
+
+// We promise not to report empty lines.
+TEST(Errors, EmptyLine) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineFile("filename1", 1, 0, 0, 0);
+  h.AddLine(1, 0, 1, 0, 0);
+
+  ASSERT_EQ(0U, lines.size());
+}  
+
+// We are supposed to clip lines that extend beyond the end of the
+// address space.
+TEST(Errors, BigLine) {
+  Module m("name", "os", "architecture", "id");
+  vector<Module::Line> lines;
+  DwarfLineToModule h(&m, &lines);
+
+  h.DefineFile("filename1", 1, 0, 0, 0);
+  h.AddLine(0xffffffffffffffffULL, 2, 1, 0, 0);
+
+  ASSERT_EQ(1U, lines.size());
+  EXPECT_EQ(1U, lines[0].size_);
+}  
diff --git a/src/common/linux/language.cc b/src/common/linux/language.cc
new file mode 100644
index 00000000..dd9fb999
--- /dev/null
+++ b/src/common/linux/language.cc
@@ -0,0 +1,77 @@
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "common/linux/language.h"
+
+namespace google_breakpad {
+
+// C++ language-specific operations.
+class CPPLanguage: public Language {
+ public:
+  string MakeQualifiedName(const string &parent_name,
+                           const string &name) const {
+    if (parent_name.empty())
+      return name;
+    else
+      return parent_name + "::" + name;
+  }
+};
+
+const CPPLanguage CPPLanguageSingleton;
+
+// Java language-specific operations.
+class JavaLanguage: public Language {
+ public:
+  string MakeQualifiedName(const string &parent_name,
+                           const string &name) const {
+    if (parent_name.empty())
+      return name;
+    else
+      return parent_name + "." + name;
+  }
+};
+
+JavaLanguage JavaLanguageSingleton;
+
+// Assembler language-specific operations.
+class AssemblerLanguage: public Language {
+  bool HasFunctions() const { return false; }
+  string MakeQualifiedName(const string &parent_name,
+                           const string &name) const {
+    return name;
+  }
+};
+
+AssemblerLanguage AssemblerLanguageSingleton;
+
+const Language * const Language::CPlusPlus = &CPPLanguageSingleton;
+const Language * const Language::Java = &JavaLanguageSingleton;
+const Language * const Language::Assembler = &AssemblerLanguageSingleton;
+
+} // namespace google_breakpad
diff --git a/src/common/linux/language.h b/src/common/linux/language.h
new file mode 100644
index 00000000..8c2598f1
--- /dev/null
+++ b/src/common/linux/language.h
@@ -0,0 +1,81 @@
+// -*- mode: c++ -*-
+
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// language.h: defines google_breakpad::Language, providing
+// language-specific operations for use by the dumper.
+
+#ifndef COMMON_LINUX_LANGUAGE_H__
+#define COMMON_LINUX_LANGUAGE_H__
+
+#include <string>
+
+namespace google_breakpad {
+
+using std::string;
+
+// An abstract base class for language-specific operations. We choose
+// an instance of a subclass of this when we find the CU's language.
+// This class's definitions are appropriate for CUs with no specified
+// language.
+class Language {
+ public:
+  // Return true if this language has functions to which we can assign
+  // line numbers. (Debugging info for assembly language, for example,
+  // can have source location information, but does not have functions
+  // recorded using DW_TAG_subprogram DIEs.)
+  virtual bool HasFunctions() const { return true; }
+
+  // Construct a fully-qualified, language-appropriate form of NAME,
+  // given that PARENT_NAME is the name of the construct enclosing
+  // NAME. If PARENT_NAME is the empty string, then NAME is a
+  // top-level name.
+  //
+  // This API sort of assumes that a fully-qualified name is always
+  // some simple textual composition of the unqualified name and its
+  // parent's name, and that we don't need to know anything else about
+  // the parent or the child (say, their DIEs' tags) to do the job.
+  // This is true for the languages we support at the moment, and
+  // keeps things concrete. Perhaps a more refined operation would
+  // take into account the parent and child DIE types, allow languages
+  // to use their own data type for complex parent names, etc. But if
+  // C++ doesn't need all that, who would?
+  virtual string MakeQualifiedName (const string &parent_name,
+                                    const string &name) const = 0;
+
+  // Instances for specific languages.
+  static const Language * const CPlusPlus,
+                        * const Java,
+                        * const Assembler;
+};
+
+} // namespace google_breakpad
+
+#endif  // COMMON_LINUX_LANGUAGE_H__
diff --git a/src/common/linux/testdata/func-line-pairing.h b/src/common/linux/testdata/func-line-pairing.h
new file mode 100644
index 00000000..05538f96
--- /dev/null
+++ b/src/common/linux/testdata/func-line-pairing.h
@@ -0,0 +1,676 @@
+// -*- mode: c++ -*-
+
+// Test data for pairing functions and lines.
+// 
+// For a pair of functions that are adjacent (10,20),(20,25) and a
+// pair that are not (10,15),(20,25), we include a test case for every
+// possible arrangement of two lines relative to those functions. We
+// include cases only for non-empty ranges, since empty functions and
+// lines are dropped before we do any pairing.
+//
+// Each test case is represented by a macro call of the form:
+// 
+//   PAIRING(func1_start, func1_end, func2_start, func2_end,
+//           line1_start, line1_end, line2_start, line2_end,
+//           func1_num_lines, func2_num_lines,
+//           func1_line1_start, func1_line1_end,
+//           func1_line2_start, func1_line2_end,
+//           func2_line1_start, func2_line1_end,
+//           func2_line2_start, func2_line2_end,
+//           uncovered_funcs, uncovered_lines)
+//
+// where:
+// - funcN_{start,end} is the range of the N'th function
+// - lineN_{start,end} is the range of the N'th function
+// - funcN_num_lines is the number of source lines that should be
+//   paired with the N'th function
+// - funcN_lineM_{start,end} is the range of the M'th line
+//   paired with the N'th function, where 0,0 indicates that
+//   there should be no such line paired
+// - uncovered_funcs is the number of functions with area that is
+//   uncovered by any line, and
+// - uncovered_lines is the reverse.
+
+//      func1   func2    line1   line2    num    pairing1        pairing2       uncovered
+PAIRING(10, 20, 20, 25,  6,  7,  7,  8,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #0
+PAIRING(10, 20, 20, 25,  6,  7,  7, 10,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #1
+PAIRING(10, 20, 20, 25,  6,  7,  7, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #2
+PAIRING(10, 20, 20, 25,  6,  7,  7, 20,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 2) // #3
+PAIRING(10, 20, 20, 25,  6,  7,  7, 21,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 2) // #4
+PAIRING(10, 20, 20, 25,  6,  7,  7, 25,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #5
+PAIRING(10, 20, 20, 25,  6,  7,  7, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #6
+PAIRING(10, 20, 20, 25,  6,  7,  8,  9,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #7
+PAIRING(10, 20, 20, 25,  6,  7,  8, 10,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #8
+PAIRING(10, 20, 20, 25,  6,  7,  8, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #9
+PAIRING(10, 20, 20, 25,  6,  7,  8, 20,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 2) // #10
+PAIRING(10, 20, 20, 25,  6,  7,  8, 21,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 2) // #11
+PAIRING(10, 20, 20, 25,  6,  7,  8, 25,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #12
+PAIRING(10, 20, 20, 25,  6,  7,  8, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #13
+PAIRING(10, 20, 20, 25,  6,  7, 10, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #14
+PAIRING(10, 20, 20, 25,  6,  7, 10, 20,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 1) // #15
+PAIRING(10, 20, 20, 25,  6,  7, 10, 21,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 1) // #16
+PAIRING(10, 20, 20, 25,  6,  7, 10, 25,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 1) // #17
+PAIRING(10, 20, 20, 25,  6,  7, 10, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #18
+PAIRING(10, 20, 20, 25,  6,  7, 11, 12,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #19
+PAIRING(10, 20, 20, 25,  6,  7, 11, 20,   1, 0, 11, 20,  0,  0,  0,  0,  0,  0,   2, 1) // #20
+PAIRING(10, 20, 20, 25,  6,  7, 11, 21,   1, 1, 11, 20,  0,  0, 20, 21,  0,  0,   2, 1) // #21
+PAIRING(10, 20, 20, 25,  6,  7, 11, 25,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 1) // #22
+PAIRING(10, 20, 20, 25,  6,  7, 11, 26,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 2) // #23
+PAIRING(10, 20, 20, 25,  6,  7, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #24
+PAIRING(10, 20, 20, 25,  6,  7, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #25
+PAIRING(10, 20, 20, 25,  6,  7, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #26
+PAIRING(10, 20, 20, 25,  6,  7, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #27
+PAIRING(10, 20, 20, 25,  6,  7, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #28
+PAIRING(10, 20, 20, 25,  6,  7, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #29
+PAIRING(10, 20, 20, 25,  6,  7, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #30
+PAIRING(10, 20, 20, 25,  6,  7, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #31
+PAIRING(10, 20, 20, 25,  6, 10, 10, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #32
+PAIRING(10, 20, 20, 25,  6, 10, 10, 20,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 1) // #33
+PAIRING(10, 20, 20, 25,  6, 10, 10, 21,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 1) // #34
+PAIRING(10, 20, 20, 25,  6, 10, 10, 25,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 1) // #35
+PAIRING(10, 20, 20, 25,  6, 10, 10, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #36
+PAIRING(10, 20, 20, 25,  6, 10, 11, 12,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #37
+PAIRING(10, 20, 20, 25,  6, 10, 11, 20,   1, 0, 11, 20,  0,  0,  0,  0,  0,  0,   2, 1) // #38
+PAIRING(10, 20, 20, 25,  6, 10, 11, 21,   1, 1, 11, 20,  0,  0, 20, 21,  0,  0,   2, 1) // #39
+PAIRING(10, 20, 20, 25,  6, 10, 11, 25,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 1) // #40
+PAIRING(10, 20, 20, 25,  6, 10, 11, 26,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 2) // #41
+PAIRING(10, 20, 20, 25,  6, 10, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #42
+PAIRING(10, 20, 20, 25,  6, 10, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #43
+PAIRING(10, 20, 20, 25,  6, 10, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #44
+PAIRING(10, 20, 20, 25,  6, 10, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #45
+PAIRING(10, 20, 20, 25,  6, 10, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #46
+PAIRING(10, 20, 20, 25,  6, 10, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #47
+PAIRING(10, 20, 20, 25,  6, 10, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #48
+PAIRING(10, 20, 20, 25,  6, 10, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #49
+PAIRING(10, 20, 20, 25,  6, 11, 11, 12,   2, 0, 10, 11, 11, 12,  0,  0,  0,  0,   2, 1) // #50
+PAIRING(10, 20, 20, 25,  6, 11, 11, 20,   2, 0, 10, 11, 11, 20,  0,  0,  0,  0,   1, 1) // #51
+PAIRING(10, 20, 20, 25,  6, 11, 11, 21,   2, 1, 10, 11, 11, 20, 20, 21,  0,  0,   1, 1) // #52
+PAIRING(10, 20, 20, 25,  6, 11, 11, 25,   2, 1, 10, 11, 11, 20, 20, 25,  0,  0,   0, 1) // #53
+PAIRING(10, 20, 20, 25,  6, 11, 11, 26,   2, 1, 10, 11, 11, 20, 20, 25,  0,  0,   0, 2) // #54
+PAIRING(10, 20, 20, 25,  6, 11, 12, 13,   2, 0, 10, 11, 12, 13,  0,  0,  0,  0,   2, 1) // #55
+PAIRING(10, 20, 20, 25,  6, 11, 12, 20,   2, 0, 10, 11, 12, 20,  0,  0,  0,  0,   2, 1) // #56
+PAIRING(10, 20, 20, 25,  6, 11, 12, 21,   2, 1, 10, 11, 12, 20, 20, 21,  0,  0,   2, 1) // #57
+PAIRING(10, 20, 20, 25,  6, 11, 12, 25,   2, 1, 10, 11, 12, 20, 20, 25,  0,  0,   1, 1) // #58
+PAIRING(10, 20, 20, 25,  6, 11, 12, 26,   2, 1, 10, 11, 12, 20, 20, 25,  0,  0,   1, 2) // #59
+PAIRING(10, 20, 20, 25,  6, 11, 20, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 1) // #60
+PAIRING(10, 20, 20, 25,  6, 11, 20, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #61
+PAIRING(10, 20, 20, 25,  6, 11, 20, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 2) // #62
+PAIRING(10, 20, 20, 25,  6, 11, 21, 22,   1, 1, 10, 11,  0,  0, 21, 22,  0,  0,   2, 1) // #63
+PAIRING(10, 20, 20, 25,  6, 11, 21, 25,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 1) // #64
+PAIRING(10, 20, 20, 25,  6, 11, 21, 26,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 2) // #65
+PAIRING(10, 20, 20, 25,  6, 11, 25, 26,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #66
+PAIRING(10, 20, 20, 25,  6, 11, 26, 27,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #67
+PAIRING(10, 20, 20, 25,  6, 20, 20, 21,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 1) // #68
+PAIRING(10, 20, 20, 25,  6, 20, 20, 25,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 1) // #69
+PAIRING(10, 20, 20, 25,  6, 20, 20, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #70
+PAIRING(10, 20, 20, 25,  6, 20, 21, 22,   1, 1, 10, 20,  0,  0, 21, 22,  0,  0,   1, 1) // #71
+PAIRING(10, 20, 20, 25,  6, 20, 21, 25,   1, 1, 10, 20,  0,  0, 21, 25,  0,  0,   1, 1) // #72
+PAIRING(10, 20, 20, 25,  6, 20, 21, 26,   1, 1, 10, 20,  0,  0, 21, 25,  0,  0,   1, 2) // #73
+PAIRING(10, 20, 20, 25,  6, 20, 25, 26,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 2) // #74
+PAIRING(10, 20, 20, 25,  6, 20, 26, 27,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 2) // #75
+PAIRING(10, 20, 20, 25,  6, 21, 21, 22,   1, 2, 10, 20,  0,  0, 20, 21, 21, 22,   1, 1) // #76
+PAIRING(10, 20, 20, 25,  6, 21, 21, 25,   1, 2, 10, 20,  0,  0, 20, 21, 21, 25,   0, 1) // #77
+PAIRING(10, 20, 20, 25,  6, 21, 21, 26,   1, 2, 10, 20,  0,  0, 20, 21, 21, 25,   0, 2) // #78
+PAIRING(10, 20, 20, 25,  6, 21, 22, 23,   1, 2, 10, 20,  0,  0, 20, 21, 22, 23,   1, 1) // #79
+PAIRING(10, 20, 20, 25,  6, 21, 22, 25,   1, 2, 10, 20,  0,  0, 20, 21, 22, 25,   1, 1) // #80
+PAIRING(10, 20, 20, 25,  6, 21, 22, 26,   1, 2, 10, 20,  0,  0, 20, 21, 22, 25,   1, 2) // #81
+PAIRING(10, 20, 20, 25,  6, 21, 25, 26,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 2) // #82
+PAIRING(10, 20, 20, 25,  6, 21, 26, 27,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 2) // #83
+PAIRING(10, 20, 20, 25,  6, 25, 25, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #84
+PAIRING(10, 20, 20, 25,  6, 25, 26, 27,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #85
+PAIRING(10, 20, 20, 25,  6, 26, 26, 27,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #86
+PAIRING(10, 20, 20, 25,  6, 26, 27, 28,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #87
+PAIRING(10, 20, 20, 25, 10, 11, 11, 12,   2, 0, 10, 11, 11, 12,  0,  0,  0,  0,   2, 0) // #88
+PAIRING(10, 20, 20, 25, 10, 11, 11, 20,   2, 0, 10, 11, 11, 20,  0,  0,  0,  0,   1, 0) // #89
+PAIRING(10, 20, 20, 25, 10, 11, 11, 21,   2, 1, 10, 11, 11, 20, 20, 21,  0,  0,   1, 0) // #90
+PAIRING(10, 20, 20, 25, 10, 11, 11, 25,   2, 1, 10, 11, 11, 20, 20, 25,  0,  0,   0, 0) // #91
+PAIRING(10, 20, 20, 25, 10, 11, 11, 26,   2, 1, 10, 11, 11, 20, 20, 25,  0,  0,   0, 1) // #92
+PAIRING(10, 20, 20, 25, 10, 11, 12, 13,   2, 0, 10, 11, 12, 13,  0,  0,  0,  0,   2, 0) // #93
+PAIRING(10, 20, 20, 25, 10, 11, 12, 20,   2, 0, 10, 11, 12, 20,  0,  0,  0,  0,   2, 0) // #94
+PAIRING(10, 20, 20, 25, 10, 11, 12, 21,   2, 1, 10, 11, 12, 20, 20, 21,  0,  0,   2, 0) // #95
+PAIRING(10, 20, 20, 25, 10, 11, 12, 25,   2, 1, 10, 11, 12, 20, 20, 25,  0,  0,   1, 0) // #96
+PAIRING(10, 20, 20, 25, 10, 11, 12, 26,   2, 1, 10, 11, 12, 20, 20, 25,  0,  0,   1, 1) // #97
+PAIRING(10, 20, 20, 25, 10, 11, 20, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 0) // #98
+PAIRING(10, 20, 20, 25, 10, 11, 20, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 0) // #99
+PAIRING(10, 20, 20, 25, 10, 11, 20, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #100
+PAIRING(10, 20, 20, 25, 10, 11, 21, 22,   1, 1, 10, 11,  0,  0, 21, 22,  0,  0,   2, 0) // #101
+PAIRING(10, 20, 20, 25, 10, 11, 21, 25,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 0) // #102
+PAIRING(10, 20, 20, 25, 10, 11, 21, 26,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 1) // #103
+PAIRING(10, 20, 20, 25, 10, 11, 25, 26,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #104
+PAIRING(10, 20, 20, 25, 10, 11, 26, 27,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #105
+PAIRING(10, 20, 20, 25, 10, 20, 20, 21,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 0) // #106
+PAIRING(10, 20, 20, 25, 10, 20, 20, 25,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 0) // #107
+PAIRING(10, 20, 20, 25, 10, 20, 20, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 1) // #108
+PAIRING(10, 20, 20, 25, 10, 20, 21, 22,   1, 1, 10, 20,  0,  0, 21, 22,  0,  0,   1, 0) // #109
+PAIRING(10, 20, 20, 25, 10, 20, 21, 25,   1, 1, 10, 20,  0,  0, 21, 25,  0,  0,   1, 0) // #110
+PAIRING(10, 20, 20, 25, 10, 20, 21, 26,   1, 1, 10, 20,  0,  0, 21, 25,  0,  0,   1, 1) // #111
+PAIRING(10, 20, 20, 25, 10, 20, 25, 26,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 1) // #112
+PAIRING(10, 20, 20, 25, 10, 20, 26, 27,   1, 0, 10, 20,  0,  0,  0,  0,  0,  0,   1, 1) // #113
+PAIRING(10, 20, 20, 25, 10, 21, 21, 22,   1, 2, 10, 20,  0,  0, 20, 21, 21, 22,   1, 0) // #114
+PAIRING(10, 20, 20, 25, 10, 21, 21, 25,   1, 2, 10, 20,  0,  0, 20, 21, 21, 25,   0, 0) // #115
+PAIRING(10, 20, 20, 25, 10, 21, 21, 26,   1, 2, 10, 20,  0,  0, 20, 21, 21, 25,   0, 1) // #116
+PAIRING(10, 20, 20, 25, 10, 21, 22, 23,   1, 2, 10, 20,  0,  0, 20, 21, 22, 23,   1, 0) // #117
+PAIRING(10, 20, 20, 25, 10, 21, 22, 25,   1, 2, 10, 20,  0,  0, 20, 21, 22, 25,   1, 0) // #118
+PAIRING(10, 20, 20, 25, 10, 21, 22, 26,   1, 2, 10, 20,  0,  0, 20, 21, 22, 25,   1, 1) // #119
+PAIRING(10, 20, 20, 25, 10, 21, 25, 26,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 1) // #120
+PAIRING(10, 20, 20, 25, 10, 21, 26, 27,   1, 1, 10, 20,  0,  0, 20, 21,  0,  0,   1, 1) // #121
+PAIRING(10, 20, 20, 25, 10, 25, 25, 26,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 1) // #122
+PAIRING(10, 20, 20, 25, 10, 25, 26, 27,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 1) // #123
+PAIRING(10, 20, 20, 25, 10, 26, 26, 27,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #124
+PAIRING(10, 20, 20, 25, 10, 26, 27, 28,   1, 1, 10, 20,  0,  0, 20, 25,  0,  0,   0, 2) // #125
+PAIRING(10, 20, 20, 25, 11, 12, 12, 13,   2, 0, 11, 12, 12, 13,  0,  0,  0,  0,   2, 0) // #126
+PAIRING(10, 20, 20, 25, 11, 12, 12, 20,   2, 0, 11, 12, 12, 20,  0,  0,  0,  0,   2, 0) // #127
+PAIRING(10, 20, 20, 25, 11, 12, 12, 21,   2, 1, 11, 12, 12, 20, 20, 21,  0,  0,   2, 0) // #128
+PAIRING(10, 20, 20, 25, 11, 12, 12, 25,   2, 1, 11, 12, 12, 20, 20, 25,  0,  0,   1, 0) // #129
+PAIRING(10, 20, 20, 25, 11, 12, 12, 26,   2, 1, 11, 12, 12, 20, 20, 25,  0,  0,   1, 1) // #130
+PAIRING(10, 20, 20, 25, 11, 12, 13, 14,   2, 0, 11, 12, 13, 14,  0,  0,  0,  0,   2, 0) // #131
+PAIRING(10, 20, 20, 25, 11, 12, 13, 20,   2, 0, 11, 12, 13, 20,  0,  0,  0,  0,   2, 0) // #132
+PAIRING(10, 20, 20, 25, 11, 12, 13, 21,   2, 1, 11, 12, 13, 20, 20, 21,  0,  0,   2, 0) // #133
+PAIRING(10, 20, 20, 25, 11, 12, 13, 25,   2, 1, 11, 12, 13, 20, 20, 25,  0,  0,   1, 0) // #134
+PAIRING(10, 20, 20, 25, 11, 12, 13, 26,   2, 1, 11, 12, 13, 20, 20, 25,  0,  0,   1, 1) // #135
+PAIRING(10, 20, 20, 25, 11, 12, 20, 21,   1, 1, 11, 12,  0,  0, 20, 21,  0,  0,   2, 0) // #136
+PAIRING(10, 20, 20, 25, 11, 12, 20, 25,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 0) // #137
+PAIRING(10, 20, 20, 25, 11, 12, 20, 26,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 1) // #138
+PAIRING(10, 20, 20, 25, 11, 12, 21, 22,   1, 1, 11, 12,  0,  0, 21, 22,  0,  0,   2, 0) // #139
+PAIRING(10, 20, 20, 25, 11, 12, 21, 25,   1, 1, 11, 12,  0,  0, 21, 25,  0,  0,   2, 0) // #140
+PAIRING(10, 20, 20, 25, 11, 12, 21, 26,   1, 1, 11, 12,  0,  0, 21, 25,  0,  0,   2, 1) // #141
+PAIRING(10, 20, 20, 25, 11, 12, 25, 26,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #142
+PAIRING(10, 20, 20, 25, 11, 12, 26, 27,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #143
+PAIRING(10, 20, 20, 25, 11, 20, 20, 21,   1, 1, 11, 20,  0,  0, 20, 21,  0,  0,   2, 0) // #144
+PAIRING(10, 20, 20, 25, 11, 20, 20, 25,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 0) // #145
+PAIRING(10, 20, 20, 25, 11, 20, 20, 26,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 1) // #146
+PAIRING(10, 20, 20, 25, 11, 20, 21, 22,   1, 1, 11, 20,  0,  0, 21, 22,  0,  0,   2, 0) // #147
+PAIRING(10, 20, 20, 25, 11, 20, 21, 25,   1, 1, 11, 20,  0,  0, 21, 25,  0,  0,   2, 0) // #148
+PAIRING(10, 20, 20, 25, 11, 20, 21, 26,   1, 1, 11, 20,  0,  0, 21, 25,  0,  0,   2, 1) // #149
+PAIRING(10, 20, 20, 25, 11, 20, 25, 26,   1, 0, 11, 20,  0,  0,  0,  0,  0,  0,   2, 1) // #150
+PAIRING(10, 20, 20, 25, 11, 20, 26, 27,   1, 0, 11, 20,  0,  0,  0,  0,  0,  0,   2, 1) // #151
+PAIRING(10, 20, 20, 25, 11, 21, 21, 22,   1, 2, 11, 20,  0,  0, 20, 21, 21, 22,   2, 0) // #152
+PAIRING(10, 20, 20, 25, 11, 21, 21, 25,   1, 2, 11, 20,  0,  0, 20, 21, 21, 25,   1, 0) // #153
+PAIRING(10, 20, 20, 25, 11, 21, 21, 26,   1, 2, 11, 20,  0,  0, 20, 21, 21, 25,   1, 1) // #154
+PAIRING(10, 20, 20, 25, 11, 21, 22, 23,   1, 2, 11, 20,  0,  0, 20, 21, 22, 23,   2, 0) // #155
+PAIRING(10, 20, 20, 25, 11, 21, 22, 25,   1, 2, 11, 20,  0,  0, 20, 21, 22, 25,   2, 0) // #156
+PAIRING(10, 20, 20, 25, 11, 21, 22, 26,   1, 2, 11, 20,  0,  0, 20, 21, 22, 25,   2, 1) // #157
+PAIRING(10, 20, 20, 25, 11, 21, 25, 26,   1, 1, 11, 20,  0,  0, 20, 21,  0,  0,   2, 1) // #158
+PAIRING(10, 20, 20, 25, 11, 21, 26, 27,   1, 1, 11, 20,  0,  0, 20, 21,  0,  0,   2, 1) // #159
+PAIRING(10, 20, 20, 25, 11, 25, 25, 26,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 1) // #160
+PAIRING(10, 20, 20, 25, 11, 25, 26, 27,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 1) // #161
+PAIRING(10, 20, 20, 25, 11, 26, 26, 27,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 2) // #162
+PAIRING(10, 20, 20, 25, 11, 26, 27, 28,   1, 1, 11, 20,  0,  0, 20, 25,  0,  0,   1, 2) // #163
+PAIRING(10, 20, 20, 25, 20, 21, 21, 22,   0, 2,  0,  0,  0,  0, 20, 21, 21, 22,   2, 0) // #164
+PAIRING(10, 20, 20, 25, 20, 21, 21, 25,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 0) // #165
+PAIRING(10, 20, 20, 25, 20, 21, 21, 26,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 1) // #166
+PAIRING(10, 20, 20, 25, 20, 21, 22, 23,   0, 2,  0,  0,  0,  0, 20, 21, 22, 23,   2, 0) // #167
+PAIRING(10, 20, 20, 25, 20, 21, 22, 25,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 0) // #168
+PAIRING(10, 20, 20, 25, 20, 21, 22, 26,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 1) // #169
+PAIRING(10, 20, 20, 25, 20, 21, 25, 26,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #170
+PAIRING(10, 20, 20, 25, 20, 21, 26, 27,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #171
+PAIRING(10, 20, 20, 25, 20, 25, 25, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #172
+PAIRING(10, 20, 20, 25, 20, 25, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #173
+PAIRING(10, 20, 20, 25, 20, 26, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #174
+PAIRING(10, 20, 20, 25, 20, 26, 27, 28,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #175
+PAIRING(10, 20, 20, 25, 21, 22, 22, 23,   0, 2,  0,  0,  0,  0, 21, 22, 22, 23,   2, 0) // #176
+PAIRING(10, 20, 20, 25, 21, 22, 22, 25,   0, 2,  0,  0,  0,  0, 21, 22, 22, 25,   2, 0) // #177
+PAIRING(10, 20, 20, 25, 21, 22, 22, 26,   0, 2,  0,  0,  0,  0, 21, 22, 22, 25,   2, 1) // #178
+PAIRING(10, 20, 20, 25, 21, 22, 23, 24,   0, 2,  0,  0,  0,  0, 21, 22, 23, 24,   2, 0) // #179
+PAIRING(10, 20, 20, 25, 21, 22, 23, 25,   0, 2,  0,  0,  0,  0, 21, 22, 23, 25,   2, 0) // #180
+PAIRING(10, 20, 20, 25, 21, 22, 23, 26,   0, 2,  0,  0,  0,  0, 21, 22, 23, 25,   2, 1) // #181
+PAIRING(10, 20, 20, 25, 21, 22, 25, 26,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #182
+PAIRING(10, 20, 20, 25, 21, 22, 26, 27,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #183
+PAIRING(10, 20, 20, 25, 21, 25, 25, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #184
+PAIRING(10, 20, 20, 25, 21, 25, 26, 27,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #185
+PAIRING(10, 20, 20, 25, 21, 26, 26, 27,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #186
+PAIRING(10, 20, 20, 25, 21, 26, 27, 28,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #187
+PAIRING(10, 20, 20, 25, 25, 26, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #188
+PAIRING(10, 20, 20, 25, 25, 26, 27, 28,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #189
+PAIRING(10, 20, 20, 25, 26, 27, 27, 28,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #190
+PAIRING(10, 20, 20, 25, 26, 27, 28, 29,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #191
+PAIRING(10, 15, 20, 25,  6,  7,  7,  8,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #192
+PAIRING(10, 15, 20, 25,  6,  7,  7, 10,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #193
+PAIRING(10, 15, 20, 25,  6,  7,  7, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #194
+PAIRING(10, 15, 20, 25,  6,  7,  7, 15,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #195
+PAIRING(10, 15, 20, 25,  6,  7,  7, 16,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #196
+PAIRING(10, 15, 20, 25,  6,  7,  7, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #197
+PAIRING(10, 15, 20, 25,  6,  7,  7, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #198
+PAIRING(10, 15, 20, 25,  6,  7,  7, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #199
+PAIRING(10, 15, 20, 25,  6,  7,  7, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #200
+PAIRING(10, 15, 20, 25,  6,  7,  8,  9,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #201
+PAIRING(10, 15, 20, 25,  6,  7,  8, 10,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #202
+PAIRING(10, 15, 20, 25,  6,  7,  8, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #203
+PAIRING(10, 15, 20, 25,  6,  7,  8, 15,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #204
+PAIRING(10, 15, 20, 25,  6,  7,  8, 16,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #205
+PAIRING(10, 15, 20, 25,  6,  7,  8, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #206
+PAIRING(10, 15, 20, 25,  6,  7,  8, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #207
+PAIRING(10, 15, 20, 25,  6,  7,  8, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #208
+PAIRING(10, 15, 20, 25,  6,  7,  8, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #209
+PAIRING(10, 15, 20, 25,  6,  7, 10, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #210
+PAIRING(10, 15, 20, 25,  6,  7, 10, 15,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #211
+PAIRING(10, 15, 20, 25,  6,  7, 10, 16,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #212
+PAIRING(10, 15, 20, 25,  6,  7, 10, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #213
+PAIRING(10, 15, 20, 25,  6,  7, 10, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #214
+PAIRING(10, 15, 20, 25,  6,  7, 10, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #215
+PAIRING(10, 15, 20, 25,  6,  7, 10, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #216
+PAIRING(10, 15, 20, 25,  6,  7, 11, 12,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #217
+PAIRING(10, 15, 20, 25,  6,  7, 11, 15,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #218
+PAIRING(10, 15, 20, 25,  6,  7, 11, 16,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #219
+PAIRING(10, 15, 20, 25,  6,  7, 11, 20,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #220
+PAIRING(10, 15, 20, 25,  6,  7, 11, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 2) // #221
+PAIRING(10, 15, 20, 25,  6,  7, 11, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #222
+PAIRING(10, 15, 20, 25,  6,  7, 11, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #223
+PAIRING(10, 15, 20, 25,  6,  7, 15, 16,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #224
+PAIRING(10, 15, 20, 25,  6,  7, 15, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #225
+PAIRING(10, 15, 20, 25,  6,  7, 15, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #226
+PAIRING(10, 15, 20, 25,  6,  7, 15, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #227
+PAIRING(10, 15, 20, 25,  6,  7, 15, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #228
+PAIRING(10, 15, 20, 25,  6,  7, 16, 17,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #229
+PAIRING(10, 15, 20, 25,  6,  7, 16, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #230
+PAIRING(10, 15, 20, 25,  6,  7, 16, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #231
+PAIRING(10, 15, 20, 25,  6,  7, 16, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #232
+PAIRING(10, 15, 20, 25,  6,  7, 16, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #233
+PAIRING(10, 15, 20, 25,  6,  7, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #234
+PAIRING(10, 15, 20, 25,  6,  7, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #235
+PAIRING(10, 15, 20, 25,  6,  7, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #236
+PAIRING(10, 15, 20, 25,  6,  7, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #237
+PAIRING(10, 15, 20, 25,  6,  7, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #238
+PAIRING(10, 15, 20, 25,  6,  7, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #239
+PAIRING(10, 15, 20, 25,  6,  7, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #240
+PAIRING(10, 15, 20, 25,  6,  7, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #241
+PAIRING(10, 15, 20, 25,  6, 10, 10, 11,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #242
+PAIRING(10, 15, 20, 25,  6, 10, 10, 15,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #243
+PAIRING(10, 15, 20, 25,  6, 10, 10, 16,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #244
+PAIRING(10, 15, 20, 25,  6, 10, 10, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #245
+PAIRING(10, 15, 20, 25,  6, 10, 10, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #246
+PAIRING(10, 15, 20, 25,  6, 10, 10, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #247
+PAIRING(10, 15, 20, 25,  6, 10, 10, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #248
+PAIRING(10, 15, 20, 25,  6, 10, 11, 12,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #249
+PAIRING(10, 15, 20, 25,  6, 10, 11, 15,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #250
+PAIRING(10, 15, 20, 25,  6, 10, 11, 16,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #251
+PAIRING(10, 15, 20, 25,  6, 10, 11, 20,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #252
+PAIRING(10, 15, 20, 25,  6, 10, 11, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 2) // #253
+PAIRING(10, 15, 20, 25,  6, 10, 11, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #254
+PAIRING(10, 15, 20, 25,  6, 10, 11, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #255
+PAIRING(10, 15, 20, 25,  6, 10, 15, 16,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #256
+PAIRING(10, 15, 20, 25,  6, 10, 15, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #257
+PAIRING(10, 15, 20, 25,  6, 10, 15, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #258
+PAIRING(10, 15, 20, 25,  6, 10, 15, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #259
+PAIRING(10, 15, 20, 25,  6, 10, 15, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #260
+PAIRING(10, 15, 20, 25,  6, 10, 16, 17,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #261
+PAIRING(10, 15, 20, 25,  6, 10, 16, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #262
+PAIRING(10, 15, 20, 25,  6, 10, 16, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #263
+PAIRING(10, 15, 20, 25,  6, 10, 16, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #264
+PAIRING(10, 15, 20, 25,  6, 10, 16, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #265
+PAIRING(10, 15, 20, 25,  6, 10, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #266
+PAIRING(10, 15, 20, 25,  6, 10, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #267
+PAIRING(10, 15, 20, 25,  6, 10, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #268
+PAIRING(10, 15, 20, 25,  6, 10, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #269
+PAIRING(10, 15, 20, 25,  6, 10, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #270
+PAIRING(10, 15, 20, 25,  6, 10, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #271
+PAIRING(10, 15, 20, 25,  6, 10, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #272
+PAIRING(10, 15, 20, 25,  6, 10, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #273
+PAIRING(10, 15, 20, 25,  6, 11, 11, 12,   2, 0, 10, 11, 11, 12,  0,  0,  0,  0,   2, 1) // #274
+PAIRING(10, 15, 20, 25,  6, 11, 11, 15,   2, 0, 10, 11, 11, 15,  0,  0,  0,  0,   1, 1) // #275
+PAIRING(10, 15, 20, 25,  6, 11, 11, 16,   2, 0, 10, 11, 11, 15,  0,  0,  0,  0,   1, 2) // #276
+PAIRING(10, 15, 20, 25,  6, 11, 11, 20,   2, 0, 10, 11, 11, 15,  0,  0,  0,  0,   1, 1) // #277
+PAIRING(10, 15, 20, 25,  6, 11, 11, 21,   2, 1, 10, 11, 11, 15, 20, 21,  0,  0,   1, 2) // #278
+PAIRING(10, 15, 20, 25,  6, 11, 11, 25,   2, 1, 10, 11, 11, 15, 20, 25,  0,  0,   0, 2) // #279
+PAIRING(10, 15, 20, 25,  6, 11, 11, 26,   2, 1, 10, 11, 11, 15, 20, 25,  0,  0,   0, 2) // #280
+PAIRING(10, 15, 20, 25,  6, 11, 12, 13,   2, 0, 10, 11, 12, 13,  0,  0,  0,  0,   2, 1) // #281
+PAIRING(10, 15, 20, 25,  6, 11, 12, 15,   2, 0, 10, 11, 12, 15,  0,  0,  0,  0,   2, 1) // #282
+PAIRING(10, 15, 20, 25,  6, 11, 12, 16,   2, 0, 10, 11, 12, 15,  0,  0,  0,  0,   2, 2) // #283
+PAIRING(10, 15, 20, 25,  6, 11, 12, 20,   2, 0, 10, 11, 12, 15,  0,  0,  0,  0,   2, 1) // #284
+PAIRING(10, 15, 20, 25,  6, 11, 12, 21,   2, 1, 10, 11, 12, 15, 20, 21,  0,  0,   2, 2) // #285
+PAIRING(10, 15, 20, 25,  6, 11, 12, 25,   2, 1, 10, 11, 12, 15, 20, 25,  0,  0,   1, 2) // #286
+PAIRING(10, 15, 20, 25,  6, 11, 12, 26,   2, 1, 10, 11, 12, 15, 20, 25,  0,  0,   1, 2) // #287
+PAIRING(10, 15, 20, 25,  6, 11, 15, 16,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #288
+PAIRING(10, 15, 20, 25,  6, 11, 15, 20,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #289
+PAIRING(10, 15, 20, 25,  6, 11, 15, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 2) // #290
+PAIRING(10, 15, 20, 25,  6, 11, 15, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 2) // #291
+PAIRING(10, 15, 20, 25,  6, 11, 15, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 2) // #292
+PAIRING(10, 15, 20, 25,  6, 11, 16, 17,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #293
+PAIRING(10, 15, 20, 25,  6, 11, 16, 20,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #294
+PAIRING(10, 15, 20, 25,  6, 11, 16, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 2) // #295
+PAIRING(10, 15, 20, 25,  6, 11, 16, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 2) // #296
+PAIRING(10, 15, 20, 25,  6, 11, 16, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 2) // #297
+PAIRING(10, 15, 20, 25,  6, 11, 20, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 1) // #298
+PAIRING(10, 15, 20, 25,  6, 11, 20, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #299
+PAIRING(10, 15, 20, 25,  6, 11, 20, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 2) // #300
+PAIRING(10, 15, 20, 25,  6, 11, 21, 22,   1, 1, 10, 11,  0,  0, 21, 22,  0,  0,   2, 1) // #301
+PAIRING(10, 15, 20, 25,  6, 11, 21, 25,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 1) // #302
+PAIRING(10, 15, 20, 25,  6, 11, 21, 26,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 2) // #303
+PAIRING(10, 15, 20, 25,  6, 11, 25, 26,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #304
+PAIRING(10, 15, 20, 25,  6, 11, 26, 27,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 2) // #305
+PAIRING(10, 15, 20, 25,  6, 15, 15, 16,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #306
+PAIRING(10, 15, 20, 25,  6, 15, 15, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #307
+PAIRING(10, 15, 20, 25,  6, 15, 15, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #308
+PAIRING(10, 15, 20, 25,  6, 15, 15, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #309
+PAIRING(10, 15, 20, 25,  6, 15, 15, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #310
+PAIRING(10, 15, 20, 25,  6, 15, 16, 17,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #311
+PAIRING(10, 15, 20, 25,  6, 15, 16, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #312
+PAIRING(10, 15, 20, 25,  6, 15, 16, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #313
+PAIRING(10, 15, 20, 25,  6, 15, 16, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #314
+PAIRING(10, 15, 20, 25,  6, 15, 16, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #315
+PAIRING(10, 15, 20, 25,  6, 15, 20, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 1) // #316
+PAIRING(10, 15, 20, 25,  6, 15, 20, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #317
+PAIRING(10, 15, 20, 25,  6, 15, 20, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #318
+PAIRING(10, 15, 20, 25,  6, 15, 21, 22,   1, 1, 10, 15,  0,  0, 21, 22,  0,  0,   1, 1) // #319
+PAIRING(10, 15, 20, 25,  6, 15, 21, 25,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 1) // #320
+PAIRING(10, 15, 20, 25,  6, 15, 21, 26,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 2) // #321
+PAIRING(10, 15, 20, 25,  6, 15, 25, 26,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #322
+PAIRING(10, 15, 20, 25,  6, 15, 26, 27,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #323
+PAIRING(10, 15, 20, 25,  6, 16, 16, 17,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #324
+PAIRING(10, 15, 20, 25,  6, 16, 16, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #325
+PAIRING(10, 15, 20, 25,  6, 16, 16, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #326
+PAIRING(10, 15, 20, 25,  6, 16, 16, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #327
+PAIRING(10, 15, 20, 25,  6, 16, 16, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #328
+PAIRING(10, 15, 20, 25,  6, 16, 17, 18,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #329
+PAIRING(10, 15, 20, 25,  6, 16, 17, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #330
+PAIRING(10, 15, 20, 25,  6, 16, 17, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #331
+PAIRING(10, 15, 20, 25,  6, 16, 17, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #332
+PAIRING(10, 15, 20, 25,  6, 16, 17, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #333
+PAIRING(10, 15, 20, 25,  6, 16, 20, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 1) // #334
+PAIRING(10, 15, 20, 25,  6, 16, 20, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #335
+PAIRING(10, 15, 20, 25,  6, 16, 20, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #336
+PAIRING(10, 15, 20, 25,  6, 16, 21, 22,   1, 1, 10, 15,  0,  0, 21, 22,  0,  0,   1, 1) // #337
+PAIRING(10, 15, 20, 25,  6, 16, 21, 25,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 1) // #338
+PAIRING(10, 15, 20, 25,  6, 16, 21, 26,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 2) // #339
+PAIRING(10, 15, 20, 25,  6, 16, 25, 26,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #340
+PAIRING(10, 15, 20, 25,  6, 16, 26, 27,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #341
+PAIRING(10, 15, 20, 25,  6, 20, 20, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 1) // #342
+PAIRING(10, 15, 20, 25,  6, 20, 20, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #343
+PAIRING(10, 15, 20, 25,  6, 20, 20, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #344
+PAIRING(10, 15, 20, 25,  6, 20, 21, 22,   1, 1, 10, 15,  0,  0, 21, 22,  0,  0,   1, 1) // #345
+PAIRING(10, 15, 20, 25,  6, 20, 21, 25,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 1) // #346
+PAIRING(10, 15, 20, 25,  6, 20, 21, 26,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 2) // #347
+PAIRING(10, 15, 20, 25,  6, 20, 25, 26,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #348
+PAIRING(10, 15, 20, 25,  6, 20, 26, 27,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #349
+PAIRING(10, 15, 20, 25,  6, 21, 21, 22,   1, 2, 10, 15,  0,  0, 20, 21, 21, 22,   1, 1) // #350
+PAIRING(10, 15, 20, 25,  6, 21, 21, 25,   1, 2, 10, 15,  0,  0, 20, 21, 21, 25,   0, 1) // #351
+PAIRING(10, 15, 20, 25,  6, 21, 21, 26,   1, 2, 10, 15,  0,  0, 20, 21, 21, 25,   0, 2) // #352
+PAIRING(10, 15, 20, 25,  6, 21, 22, 23,   1, 2, 10, 15,  0,  0, 20, 21, 22, 23,   1, 1) // #353
+PAIRING(10, 15, 20, 25,  6, 21, 22, 25,   1, 2, 10, 15,  0,  0, 20, 21, 22, 25,   1, 1) // #354
+PAIRING(10, 15, 20, 25,  6, 21, 22, 26,   1, 2, 10, 15,  0,  0, 20, 21, 22, 25,   1, 2) // #355
+PAIRING(10, 15, 20, 25,  6, 21, 25, 26,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #356
+PAIRING(10, 15, 20, 25,  6, 21, 26, 27,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #357
+PAIRING(10, 15, 20, 25,  6, 25, 25, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #358
+PAIRING(10, 15, 20, 25,  6, 25, 26, 27,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #359
+PAIRING(10, 15, 20, 25,  6, 26, 26, 27,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #360
+PAIRING(10, 15, 20, 25,  6, 26, 27, 28,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #361
+PAIRING(10, 15, 20, 25, 10, 11, 11, 12,   2, 0, 10, 11, 11, 12,  0,  0,  0,  0,   2, 0) // #362
+PAIRING(10, 15, 20, 25, 10, 11, 11, 15,   2, 0, 10, 11, 11, 15,  0,  0,  0,  0,   1, 0) // #363
+PAIRING(10, 15, 20, 25, 10, 11, 11, 16,   2, 0, 10, 11, 11, 15,  0,  0,  0,  0,   1, 1) // #364
+PAIRING(10, 15, 20, 25, 10, 11, 11, 20,   2, 0, 10, 11, 11, 15,  0,  0,  0,  0,   1, 0) // #365
+PAIRING(10, 15, 20, 25, 10, 11, 11, 21,   2, 1, 10, 11, 11, 15, 20, 21,  0,  0,   1, 1) // #366
+PAIRING(10, 15, 20, 25, 10, 11, 11, 25,   2, 1, 10, 11, 11, 15, 20, 25,  0,  0,   0, 1) // #367
+PAIRING(10, 15, 20, 25, 10, 11, 11, 26,   2, 1, 10, 11, 11, 15, 20, 25,  0,  0,   0, 1) // #368
+PAIRING(10, 15, 20, 25, 10, 11, 12, 13,   2, 0, 10, 11, 12, 13,  0,  0,  0,  0,   2, 0) // #369
+PAIRING(10, 15, 20, 25, 10, 11, 12, 15,   2, 0, 10, 11, 12, 15,  0,  0,  0,  0,   2, 0) // #370
+PAIRING(10, 15, 20, 25, 10, 11, 12, 16,   2, 0, 10, 11, 12, 15,  0,  0,  0,  0,   2, 1) // #371
+PAIRING(10, 15, 20, 25, 10, 11, 12, 20,   2, 0, 10, 11, 12, 15,  0,  0,  0,  0,   2, 0) // #372
+PAIRING(10, 15, 20, 25, 10, 11, 12, 21,   2, 1, 10, 11, 12, 15, 20, 21,  0,  0,   2, 1) // #373
+PAIRING(10, 15, 20, 25, 10, 11, 12, 25,   2, 1, 10, 11, 12, 15, 20, 25,  0,  0,   1, 1) // #374
+PAIRING(10, 15, 20, 25, 10, 11, 12, 26,   2, 1, 10, 11, 12, 15, 20, 25,  0,  0,   1, 1) // #375
+PAIRING(10, 15, 20, 25, 10, 11, 15, 16,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #376
+PAIRING(10, 15, 20, 25, 10, 11, 15, 20,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #377
+PAIRING(10, 15, 20, 25, 10, 11, 15, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 1) // #378
+PAIRING(10, 15, 20, 25, 10, 11, 15, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #379
+PAIRING(10, 15, 20, 25, 10, 11, 15, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #380
+PAIRING(10, 15, 20, 25, 10, 11, 16, 17,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #381
+PAIRING(10, 15, 20, 25, 10, 11, 16, 20,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #382
+PAIRING(10, 15, 20, 25, 10, 11, 16, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 1) // #383
+PAIRING(10, 15, 20, 25, 10, 11, 16, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #384
+PAIRING(10, 15, 20, 25, 10, 11, 16, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #385
+PAIRING(10, 15, 20, 25, 10, 11, 20, 21,   1, 1, 10, 11,  0,  0, 20, 21,  0,  0,   2, 0) // #386
+PAIRING(10, 15, 20, 25, 10, 11, 20, 25,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 0) // #387
+PAIRING(10, 15, 20, 25, 10, 11, 20, 26,   1, 1, 10, 11,  0,  0, 20, 25,  0,  0,   1, 1) // #388
+PAIRING(10, 15, 20, 25, 10, 11, 21, 22,   1, 1, 10, 11,  0,  0, 21, 22,  0,  0,   2, 0) // #389
+PAIRING(10, 15, 20, 25, 10, 11, 21, 25,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 0) // #390
+PAIRING(10, 15, 20, 25, 10, 11, 21, 26,   1, 1, 10, 11,  0,  0, 21, 25,  0,  0,   2, 1) // #391
+PAIRING(10, 15, 20, 25, 10, 11, 25, 26,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #392
+PAIRING(10, 15, 20, 25, 10, 11, 26, 27,   1, 0, 10, 11,  0,  0,  0,  0,  0,  0,   2, 1) // #393
+PAIRING(10, 15, 20, 25, 10, 15, 15, 16,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #394
+PAIRING(10, 15, 20, 25, 10, 15, 15, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #395
+PAIRING(10, 15, 20, 25, 10, 15, 15, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 1) // #396
+PAIRING(10, 15, 20, 25, 10, 15, 15, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #397
+PAIRING(10, 15, 20, 25, 10, 15, 15, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #398
+PAIRING(10, 15, 20, 25, 10, 15, 16, 17,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #399
+PAIRING(10, 15, 20, 25, 10, 15, 16, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #400
+PAIRING(10, 15, 20, 25, 10, 15, 16, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 1) // #401
+PAIRING(10, 15, 20, 25, 10, 15, 16, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #402
+PAIRING(10, 15, 20, 25, 10, 15, 16, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #403
+PAIRING(10, 15, 20, 25, 10, 15, 20, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 0) // #404
+PAIRING(10, 15, 20, 25, 10, 15, 20, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 0) // #405
+PAIRING(10, 15, 20, 25, 10, 15, 20, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #406
+PAIRING(10, 15, 20, 25, 10, 15, 21, 22,   1, 1, 10, 15,  0,  0, 21, 22,  0,  0,   1, 0) // #407
+PAIRING(10, 15, 20, 25, 10, 15, 21, 25,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 0) // #408
+PAIRING(10, 15, 20, 25, 10, 15, 21, 26,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 1) // #409
+PAIRING(10, 15, 20, 25, 10, 15, 25, 26,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #410
+PAIRING(10, 15, 20, 25, 10, 15, 26, 27,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #411
+PAIRING(10, 15, 20, 25, 10, 16, 16, 17,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #412
+PAIRING(10, 15, 20, 25, 10, 16, 16, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #413
+PAIRING(10, 15, 20, 25, 10, 16, 16, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #414
+PAIRING(10, 15, 20, 25, 10, 16, 16, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #415
+PAIRING(10, 15, 20, 25, 10, 16, 16, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #416
+PAIRING(10, 15, 20, 25, 10, 16, 17, 18,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #417
+PAIRING(10, 15, 20, 25, 10, 16, 17, 20,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #418
+PAIRING(10, 15, 20, 25, 10, 16, 17, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #419
+PAIRING(10, 15, 20, 25, 10, 16, 17, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #420
+PAIRING(10, 15, 20, 25, 10, 16, 17, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #421
+PAIRING(10, 15, 20, 25, 10, 16, 20, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 1) // #422
+PAIRING(10, 15, 20, 25, 10, 16, 20, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #423
+PAIRING(10, 15, 20, 25, 10, 16, 20, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #424
+PAIRING(10, 15, 20, 25, 10, 16, 21, 22,   1, 1, 10, 15,  0,  0, 21, 22,  0,  0,   1, 1) // #425
+PAIRING(10, 15, 20, 25, 10, 16, 21, 25,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 1) // #426
+PAIRING(10, 15, 20, 25, 10, 16, 21, 26,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 2) // #427
+PAIRING(10, 15, 20, 25, 10, 16, 25, 26,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #428
+PAIRING(10, 15, 20, 25, 10, 16, 26, 27,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 2) // #429
+PAIRING(10, 15, 20, 25, 10, 20, 20, 21,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 0) // #430
+PAIRING(10, 15, 20, 25, 10, 20, 20, 25,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 0) // #431
+PAIRING(10, 15, 20, 25, 10, 20, 20, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 1) // #432
+PAIRING(10, 15, 20, 25, 10, 20, 21, 22,   1, 1, 10, 15,  0,  0, 21, 22,  0,  0,   1, 0) // #433
+PAIRING(10, 15, 20, 25, 10, 20, 21, 25,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 0) // #434
+PAIRING(10, 15, 20, 25, 10, 20, 21, 26,   1, 1, 10, 15,  0,  0, 21, 25,  0,  0,   1, 1) // #435
+PAIRING(10, 15, 20, 25, 10, 20, 25, 26,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #436
+PAIRING(10, 15, 20, 25, 10, 20, 26, 27,   1, 0, 10, 15,  0,  0,  0,  0,  0,  0,   1, 1) // #437
+PAIRING(10, 15, 20, 25, 10, 21, 21, 22,   1, 2, 10, 15,  0,  0, 20, 21, 21, 22,   1, 1) // #438
+PAIRING(10, 15, 20, 25, 10, 21, 21, 25,   1, 2, 10, 15,  0,  0, 20, 21, 21, 25,   0, 1) // #439
+PAIRING(10, 15, 20, 25, 10, 21, 21, 26,   1, 2, 10, 15,  0,  0, 20, 21, 21, 25,   0, 2) // #440
+PAIRING(10, 15, 20, 25, 10, 21, 22, 23,   1, 2, 10, 15,  0,  0, 20, 21, 22, 23,   1, 1) // #441
+PAIRING(10, 15, 20, 25, 10, 21, 22, 25,   1, 2, 10, 15,  0,  0, 20, 21, 22, 25,   1, 1) // #442
+PAIRING(10, 15, 20, 25, 10, 21, 22, 26,   1, 2, 10, 15,  0,  0, 20, 21, 22, 25,   1, 2) // #443
+PAIRING(10, 15, 20, 25, 10, 21, 25, 26,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #444
+PAIRING(10, 15, 20, 25, 10, 21, 26, 27,   1, 1, 10, 15,  0,  0, 20, 21,  0,  0,   1, 2) // #445
+PAIRING(10, 15, 20, 25, 10, 25, 25, 26,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #446
+PAIRING(10, 15, 20, 25, 10, 25, 26, 27,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #447
+PAIRING(10, 15, 20, 25, 10, 26, 26, 27,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #448
+PAIRING(10, 15, 20, 25, 10, 26, 27, 28,   1, 1, 10, 15,  0,  0, 20, 25,  0,  0,   0, 2) // #449
+PAIRING(10, 15, 20, 25, 11, 12, 12, 13,   2, 0, 11, 12, 12, 13,  0,  0,  0,  0,   2, 0) // #450
+PAIRING(10, 15, 20, 25, 11, 12, 12, 15,   2, 0, 11, 12, 12, 15,  0,  0,  0,  0,   2, 0) // #451
+PAIRING(10, 15, 20, 25, 11, 12, 12, 16,   2, 0, 11, 12, 12, 15,  0,  0,  0,  0,   2, 1) // #452
+PAIRING(10, 15, 20, 25, 11, 12, 12, 20,   2, 0, 11, 12, 12, 15,  0,  0,  0,  0,   2, 0) // #453
+PAIRING(10, 15, 20, 25, 11, 12, 12, 21,   2, 1, 11, 12, 12, 15, 20, 21,  0,  0,   2, 1) // #454
+PAIRING(10, 15, 20, 25, 11, 12, 12, 25,   2, 1, 11, 12, 12, 15, 20, 25,  0,  0,   1, 1) // #455
+PAIRING(10, 15, 20, 25, 11, 12, 12, 26,   2, 1, 11, 12, 12, 15, 20, 25,  0,  0,   1, 1) // #456
+PAIRING(10, 15, 20, 25, 11, 12, 13, 14,   2, 0, 11, 12, 13, 14,  0,  0,  0,  0,   2, 0) // #457
+PAIRING(10, 15, 20, 25, 11, 12, 13, 15,   2, 0, 11, 12, 13, 15,  0,  0,  0,  0,   2, 0) // #458
+PAIRING(10, 15, 20, 25, 11, 12, 13, 16,   2, 0, 11, 12, 13, 15,  0,  0,  0,  0,   2, 1) // #459
+PAIRING(10, 15, 20, 25, 11, 12, 13, 20,   2, 0, 11, 12, 13, 15,  0,  0,  0,  0,   2, 0) // #460
+PAIRING(10, 15, 20, 25, 11, 12, 13, 21,   2, 1, 11, 12, 13, 15, 20, 21,  0,  0,   2, 1) // #461
+PAIRING(10, 15, 20, 25, 11, 12, 13, 25,   2, 1, 11, 12, 13, 15, 20, 25,  0,  0,   1, 1) // #462
+PAIRING(10, 15, 20, 25, 11, 12, 13, 26,   2, 1, 11, 12, 13, 15, 20, 25,  0,  0,   1, 1) // #463
+PAIRING(10, 15, 20, 25, 11, 12, 15, 16,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #464
+PAIRING(10, 15, 20, 25, 11, 12, 15, 20,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #465
+PAIRING(10, 15, 20, 25, 11, 12, 15, 21,   1, 1, 11, 12,  0,  0, 20, 21,  0,  0,   2, 1) // #466
+PAIRING(10, 15, 20, 25, 11, 12, 15, 25,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 1) // #467
+PAIRING(10, 15, 20, 25, 11, 12, 15, 26,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 1) // #468
+PAIRING(10, 15, 20, 25, 11, 12, 16, 17,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #469
+PAIRING(10, 15, 20, 25, 11, 12, 16, 20,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #470
+PAIRING(10, 15, 20, 25, 11, 12, 16, 21,   1, 1, 11, 12,  0,  0, 20, 21,  0,  0,   2, 1) // #471
+PAIRING(10, 15, 20, 25, 11, 12, 16, 25,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 1) // #472
+PAIRING(10, 15, 20, 25, 11, 12, 16, 26,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 1) // #473
+PAIRING(10, 15, 20, 25, 11, 12, 20, 21,   1, 1, 11, 12,  0,  0, 20, 21,  0,  0,   2, 0) // #474
+PAIRING(10, 15, 20, 25, 11, 12, 20, 25,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 0) // #475
+PAIRING(10, 15, 20, 25, 11, 12, 20, 26,   1, 1, 11, 12,  0,  0, 20, 25,  0,  0,   1, 1) // #476
+PAIRING(10, 15, 20, 25, 11, 12, 21, 22,   1, 1, 11, 12,  0,  0, 21, 22,  0,  0,   2, 0) // #477
+PAIRING(10, 15, 20, 25, 11, 12, 21, 25,   1, 1, 11, 12,  0,  0, 21, 25,  0,  0,   2, 0) // #478
+PAIRING(10, 15, 20, 25, 11, 12, 21, 26,   1, 1, 11, 12,  0,  0, 21, 25,  0,  0,   2, 1) // #479
+PAIRING(10, 15, 20, 25, 11, 12, 25, 26,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #480
+PAIRING(10, 15, 20, 25, 11, 12, 26, 27,   1, 0, 11, 12,  0,  0,  0,  0,  0,  0,   2, 1) // #481
+PAIRING(10, 15, 20, 25, 11, 15, 15, 16,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #482
+PAIRING(10, 15, 20, 25, 11, 15, 15, 20,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #483
+PAIRING(10, 15, 20, 25, 11, 15, 15, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 1) // #484
+PAIRING(10, 15, 20, 25, 11, 15, 15, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 1) // #485
+PAIRING(10, 15, 20, 25, 11, 15, 15, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 1) // #486
+PAIRING(10, 15, 20, 25, 11, 15, 16, 17,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #487
+PAIRING(10, 15, 20, 25, 11, 15, 16, 20,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #488
+PAIRING(10, 15, 20, 25, 11, 15, 16, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 1) // #489
+PAIRING(10, 15, 20, 25, 11, 15, 16, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 1) // #490
+PAIRING(10, 15, 20, 25, 11, 15, 16, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 1) // #491
+PAIRING(10, 15, 20, 25, 11, 15, 20, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 0) // #492
+PAIRING(10, 15, 20, 25, 11, 15, 20, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 0) // #493
+PAIRING(10, 15, 20, 25, 11, 15, 20, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 1) // #494
+PAIRING(10, 15, 20, 25, 11, 15, 21, 22,   1, 1, 11, 15,  0,  0, 21, 22,  0,  0,   2, 0) // #495
+PAIRING(10, 15, 20, 25, 11, 15, 21, 25,   1, 1, 11, 15,  0,  0, 21, 25,  0,  0,   2, 0) // #496
+PAIRING(10, 15, 20, 25, 11, 15, 21, 26,   1, 1, 11, 15,  0,  0, 21, 25,  0,  0,   2, 1) // #497
+PAIRING(10, 15, 20, 25, 11, 15, 25, 26,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #498
+PAIRING(10, 15, 20, 25, 11, 15, 26, 27,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #499
+PAIRING(10, 15, 20, 25, 11, 16, 16, 17,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #500
+PAIRING(10, 15, 20, 25, 11, 16, 16, 20,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #501
+PAIRING(10, 15, 20, 25, 11, 16, 16, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 2) // #502
+PAIRING(10, 15, 20, 25, 11, 16, 16, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #503
+PAIRING(10, 15, 20, 25, 11, 16, 16, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #504
+PAIRING(10, 15, 20, 25, 11, 16, 17, 18,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #505
+PAIRING(10, 15, 20, 25, 11, 16, 17, 20,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #506
+PAIRING(10, 15, 20, 25, 11, 16, 17, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 2) // #507
+PAIRING(10, 15, 20, 25, 11, 16, 17, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #508
+PAIRING(10, 15, 20, 25, 11, 16, 17, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #509
+PAIRING(10, 15, 20, 25, 11, 16, 20, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 1) // #510
+PAIRING(10, 15, 20, 25, 11, 16, 20, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 1) // #511
+PAIRING(10, 15, 20, 25, 11, 16, 20, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #512
+PAIRING(10, 15, 20, 25, 11, 16, 21, 22,   1, 1, 11, 15,  0,  0, 21, 22,  0,  0,   2, 1) // #513
+PAIRING(10, 15, 20, 25, 11, 16, 21, 25,   1, 1, 11, 15,  0,  0, 21, 25,  0,  0,   2, 1) // #514
+PAIRING(10, 15, 20, 25, 11, 16, 21, 26,   1, 1, 11, 15,  0,  0, 21, 25,  0,  0,   2, 2) // #515
+PAIRING(10, 15, 20, 25, 11, 16, 25, 26,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #516
+PAIRING(10, 15, 20, 25, 11, 16, 26, 27,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 2) // #517
+PAIRING(10, 15, 20, 25, 11, 20, 20, 21,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 0) // #518
+PAIRING(10, 15, 20, 25, 11, 20, 20, 25,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 0) // #519
+PAIRING(10, 15, 20, 25, 11, 20, 20, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 1) // #520
+PAIRING(10, 15, 20, 25, 11, 20, 21, 22,   1, 1, 11, 15,  0,  0, 21, 22,  0,  0,   2, 0) // #521
+PAIRING(10, 15, 20, 25, 11, 20, 21, 25,   1, 1, 11, 15,  0,  0, 21, 25,  0,  0,   2, 0) // #522
+PAIRING(10, 15, 20, 25, 11, 20, 21, 26,   1, 1, 11, 15,  0,  0, 21, 25,  0,  0,   2, 1) // #523
+PAIRING(10, 15, 20, 25, 11, 20, 25, 26,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #524
+PAIRING(10, 15, 20, 25, 11, 20, 26, 27,   1, 0, 11, 15,  0,  0,  0,  0,  0,  0,   2, 1) // #525
+PAIRING(10, 15, 20, 25, 11, 21, 21, 22,   1, 2, 11, 15,  0,  0, 20, 21, 21, 22,   2, 1) // #526
+PAIRING(10, 15, 20, 25, 11, 21, 21, 25,   1, 2, 11, 15,  0,  0, 20, 21, 21, 25,   1, 1) // #527
+PAIRING(10, 15, 20, 25, 11, 21, 21, 26,   1, 2, 11, 15,  0,  0, 20, 21, 21, 25,   1, 2) // #528
+PAIRING(10, 15, 20, 25, 11, 21, 22, 23,   1, 2, 11, 15,  0,  0, 20, 21, 22, 23,   2, 1) // #529
+PAIRING(10, 15, 20, 25, 11, 21, 22, 25,   1, 2, 11, 15,  0,  0, 20, 21, 22, 25,   2, 1) // #530
+PAIRING(10, 15, 20, 25, 11, 21, 22, 26,   1, 2, 11, 15,  0,  0, 20, 21, 22, 25,   2, 2) // #531
+PAIRING(10, 15, 20, 25, 11, 21, 25, 26,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 2) // #532
+PAIRING(10, 15, 20, 25, 11, 21, 26, 27,   1, 1, 11, 15,  0,  0, 20, 21,  0,  0,   2, 2) // #533
+PAIRING(10, 15, 20, 25, 11, 25, 25, 26,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #534
+PAIRING(10, 15, 20, 25, 11, 25, 26, 27,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #535
+PAIRING(10, 15, 20, 25, 11, 26, 26, 27,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #536
+PAIRING(10, 15, 20, 25, 11, 26, 27, 28,   1, 1, 11, 15,  0,  0, 20, 25,  0,  0,   1, 2) // #537
+PAIRING(10, 15, 20, 25, 15, 16, 16, 17,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #538
+PAIRING(10, 15, 20, 25, 15, 16, 16, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #539
+PAIRING(10, 15, 20, 25, 15, 16, 16, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #540
+PAIRING(10, 15, 20, 25, 15, 16, 16, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #541
+PAIRING(10, 15, 20, 25, 15, 16, 16, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #542
+PAIRING(10, 15, 20, 25, 15, 16, 17, 18,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #543
+PAIRING(10, 15, 20, 25, 15, 16, 17, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #544
+PAIRING(10, 15, 20, 25, 15, 16, 17, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #545
+PAIRING(10, 15, 20, 25, 15, 16, 17, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #546
+PAIRING(10, 15, 20, 25, 15, 16, 17, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #547
+PAIRING(10, 15, 20, 25, 15, 16, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #548
+PAIRING(10, 15, 20, 25, 15, 16, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #549
+PAIRING(10, 15, 20, 25, 15, 16, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #550
+PAIRING(10, 15, 20, 25, 15, 16, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #551
+PAIRING(10, 15, 20, 25, 15, 16, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #552
+PAIRING(10, 15, 20, 25, 15, 16, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #553
+PAIRING(10, 15, 20, 25, 15, 16, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #554
+PAIRING(10, 15, 20, 25, 15, 16, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #555
+PAIRING(10, 15, 20, 25, 15, 20, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #556
+PAIRING(10, 15, 20, 25, 15, 20, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #557
+PAIRING(10, 15, 20, 25, 15, 20, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #558
+PAIRING(10, 15, 20, 25, 15, 20, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #559
+PAIRING(10, 15, 20, 25, 15, 20, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #560
+PAIRING(10, 15, 20, 25, 15, 20, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #561
+PAIRING(10, 15, 20, 25, 15, 20, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #562
+PAIRING(10, 15, 20, 25, 15, 20, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #563
+PAIRING(10, 15, 20, 25, 15, 21, 21, 22,   0, 2,  0,  0,  0,  0, 20, 21, 21, 22,   2, 1) // #564
+PAIRING(10, 15, 20, 25, 15, 21, 21, 25,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 1) // #565
+PAIRING(10, 15, 20, 25, 15, 21, 21, 26,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 2) // #566
+PAIRING(10, 15, 20, 25, 15, 21, 22, 23,   0, 2,  0,  0,  0,  0, 20, 21, 22, 23,   2, 1) // #567
+PAIRING(10, 15, 20, 25, 15, 21, 22, 25,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 1) // #568
+PAIRING(10, 15, 20, 25, 15, 21, 22, 26,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 2) // #569
+PAIRING(10, 15, 20, 25, 15, 21, 25, 26,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #570
+PAIRING(10, 15, 20, 25, 15, 21, 26, 27,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #571
+PAIRING(10, 15, 20, 25, 15, 25, 25, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #572
+PAIRING(10, 15, 20, 25, 15, 25, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #573
+PAIRING(10, 15, 20, 25, 15, 26, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #574
+PAIRING(10, 15, 20, 25, 15, 26, 27, 28,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #575
+PAIRING(10, 15, 20, 25, 16, 17, 17, 18,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #576
+PAIRING(10, 15, 20, 25, 16, 17, 17, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #577
+PAIRING(10, 15, 20, 25, 16, 17, 17, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #578
+PAIRING(10, 15, 20, 25, 16, 17, 17, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #579
+PAIRING(10, 15, 20, 25, 16, 17, 17, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #580
+PAIRING(10, 15, 20, 25, 16, 17, 18, 19,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #581
+PAIRING(10, 15, 20, 25, 16, 17, 18, 20,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #582
+PAIRING(10, 15, 20, 25, 16, 17, 18, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #583
+PAIRING(10, 15, 20, 25, 16, 17, 18, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #584
+PAIRING(10, 15, 20, 25, 16, 17, 18, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #585
+PAIRING(10, 15, 20, 25, 16, 17, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #586
+PAIRING(10, 15, 20, 25, 16, 17, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #587
+PAIRING(10, 15, 20, 25, 16, 17, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #588
+PAIRING(10, 15, 20, 25, 16, 17, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #589
+PAIRING(10, 15, 20, 25, 16, 17, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #590
+PAIRING(10, 15, 20, 25, 16, 17, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #591
+PAIRING(10, 15, 20, 25, 16, 17, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #592
+PAIRING(10, 15, 20, 25, 16, 17, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #593
+PAIRING(10, 15, 20, 25, 16, 20, 20, 21,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #594
+PAIRING(10, 15, 20, 25, 16, 20, 20, 25,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #595
+PAIRING(10, 15, 20, 25, 16, 20, 20, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #596
+PAIRING(10, 15, 20, 25, 16, 20, 21, 22,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #597
+PAIRING(10, 15, 20, 25, 16, 20, 21, 25,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #598
+PAIRING(10, 15, 20, 25, 16, 20, 21, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #599
+PAIRING(10, 15, 20, 25, 16, 20, 25, 26,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #600
+PAIRING(10, 15, 20, 25, 16, 20, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #601
+PAIRING(10, 15, 20, 25, 16, 21, 21, 22,   0, 2,  0,  0,  0,  0, 20, 21, 21, 22,   2, 1) // #602
+PAIRING(10, 15, 20, 25, 16, 21, 21, 25,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 1) // #603
+PAIRING(10, 15, 20, 25, 16, 21, 21, 26,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 2) // #604
+PAIRING(10, 15, 20, 25, 16, 21, 22, 23,   0, 2,  0,  0,  0,  0, 20, 21, 22, 23,   2, 1) // #605
+PAIRING(10, 15, 20, 25, 16, 21, 22, 25,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 1) // #606
+PAIRING(10, 15, 20, 25, 16, 21, 22, 26,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 2) // #607
+PAIRING(10, 15, 20, 25, 16, 21, 25, 26,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #608
+PAIRING(10, 15, 20, 25, 16, 21, 26, 27,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 2) // #609
+PAIRING(10, 15, 20, 25, 16, 25, 25, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #610
+PAIRING(10, 15, 20, 25, 16, 25, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #611
+PAIRING(10, 15, 20, 25, 16, 26, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #612
+PAIRING(10, 15, 20, 25, 16, 26, 27, 28,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #613
+PAIRING(10, 15, 20, 25, 20, 21, 21, 22,   0, 2,  0,  0,  0,  0, 20, 21, 21, 22,   2, 0) // #614
+PAIRING(10, 15, 20, 25, 20, 21, 21, 25,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 0) // #615
+PAIRING(10, 15, 20, 25, 20, 21, 21, 26,   0, 2,  0,  0,  0,  0, 20, 21, 21, 25,   1, 1) // #616
+PAIRING(10, 15, 20, 25, 20, 21, 22, 23,   0, 2,  0,  0,  0,  0, 20, 21, 22, 23,   2, 0) // #617
+PAIRING(10, 15, 20, 25, 20, 21, 22, 25,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 0) // #618
+PAIRING(10, 15, 20, 25, 20, 21, 22, 26,   0, 2,  0,  0,  0,  0, 20, 21, 22, 25,   2, 1) // #619
+PAIRING(10, 15, 20, 25, 20, 21, 25, 26,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #620
+PAIRING(10, 15, 20, 25, 20, 21, 26, 27,   0, 1,  0,  0,  0,  0, 20, 21,  0,  0,   2, 1) // #621
+PAIRING(10, 15, 20, 25, 20, 25, 25, 26,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #622
+PAIRING(10, 15, 20, 25, 20, 25, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 1) // #623
+PAIRING(10, 15, 20, 25, 20, 26, 26, 27,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #624
+PAIRING(10, 15, 20, 25, 20, 26, 27, 28,   0, 1,  0,  0,  0,  0, 20, 25,  0,  0,   1, 2) // #625
+PAIRING(10, 15, 20, 25, 21, 22, 22, 23,   0, 2,  0,  0,  0,  0, 21, 22, 22, 23,   2, 0) // #626
+PAIRING(10, 15, 20, 25, 21, 22, 22, 25,   0, 2,  0,  0,  0,  0, 21, 22, 22, 25,   2, 0) // #627
+PAIRING(10, 15, 20, 25, 21, 22, 22, 26,   0, 2,  0,  0,  0,  0, 21, 22, 22, 25,   2, 1) // #628
+PAIRING(10, 15, 20, 25, 21, 22, 23, 24,   0, 2,  0,  0,  0,  0, 21, 22, 23, 24,   2, 0) // #629
+PAIRING(10, 15, 20, 25, 21, 22, 23, 25,   0, 2,  0,  0,  0,  0, 21, 22, 23, 25,   2, 0) // #630
+PAIRING(10, 15, 20, 25, 21, 22, 23, 26,   0, 2,  0,  0,  0,  0, 21, 22, 23, 25,   2, 1) // #631
+PAIRING(10, 15, 20, 25, 21, 22, 25, 26,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #632
+PAIRING(10, 15, 20, 25, 21, 22, 26, 27,   0, 1,  0,  0,  0,  0, 21, 22,  0,  0,   2, 1) // #633
+PAIRING(10, 15, 20, 25, 21, 25, 25, 26,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #634
+PAIRING(10, 15, 20, 25, 21, 25, 26, 27,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 1) // #635
+PAIRING(10, 15, 20, 25, 21, 26, 26, 27,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #636
+PAIRING(10, 15, 20, 25, 21, 26, 27, 28,   0, 1,  0,  0,  0,  0, 21, 25,  0,  0,   2, 2) // #637
+PAIRING(10, 15, 20, 25, 25, 26, 26, 27,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #638
+PAIRING(10, 15, 20, 25, 25, 26, 27, 28,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #639
+PAIRING(10, 15, 20, 25, 26, 27, 27, 28,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #640
+PAIRING(10, 15, 20, 25, 26, 27, 28, 29,   0, 0,  0,  0,  0,  0,  0,  0,  0,  0,   2, 2) // #641