diff --git a/.forgejo/workflows/test.yml b/.forgejo/workflows/test.yml
index c98f5b2..bed4795 100644
--- a/.forgejo/workflows/test.yml
+++ b/.forgejo/workflows/test.yml
@@ -2,25 +2,45 @@
 # See Notices.txt for copyright information
 on: [push, pull_request]
 
+env:
+  PDF_HASH: 56372d23ece7e9e2c1b381a639443982a3e16e38109df1c141d655b779b61fdb
+  OUTPUT_XML_HASH: c0b4592cbd0a3e59b9b2931a6a75a3d87ebf23bf453e8587a1522dd157f15ee9
+
 jobs:
   test:
     runs-on: debian-12
+    container:
+      image: git.libre-chip.org/libre-chip/fayalite-deps:latest
     steps:
       - uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - run: |
           scripts/check-copyright.sh
+      - uses: https://git.libre-chip.org/mirrors/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/master' }}
       - run: |
           apt-get update -qq
           apt-get install -qq python3-venv wget
           # copy of https://files.openpower.foundation/s/9izgC5Rogi5Ywmm/download/OPF_PowerISA_v3.1C.pdf
           wget -O OPF_PowerISA_v3.1C.pdf https://libre-chip.org/OPF_PowerISA_v3.1C.pdf
-          echo "56372d23ece7e9e2c1b381a639443982a3e16e38109df1c141d655b779b61fdb  OPF_PowerISA_v3.1C.pdf" | sha256sum -c
+          echo "$PDF_HASH  OPF_PowerISA_v3.1C.pdf" | sha256sum -c
+      - run: |
+          cargo test
+      - run: |
+          cargo build --release
+      - run: |
+          cargo run --release -- OPF_PowerISA_v3.1C.pdf &> >(tee out.log | grep '^page ') || { tail -n1000 out.log; false; }
+          echo "expected output (not all instructions are decoded yet, change when the output is improved):"
+          echo "$OUTPUT_XML_HASH  powerisa-instructions.xml" | sha256sum -c
+          mv powerisa-instructions.xml powerisa-instructions-rust.xml
+      - run: |
           python3 -m venv --upgrade-deps .venv
           . .venv/bin/activate
           pip install -e .
           parse_powerisa_pdf OPF_PowerISA_v3.1C.pdf &> >(tee out.log | grep '^page ') || { tail -n1000 out.log; false; }
           echo "expected output (not all instructions are decoded yet, change when the output is improved):"
-          echo "c0b4592cbd0a3e59b9b2931a6a75a3d87ebf23bf453e8587a1522dd157f15ee9  powerisa-instructions.xml" | sha256sum -c
+          echo "$OUTPUT_XML_HASH  powerisa-instructions.xml" | sha256sum -c
+          mv powerisa-instructions.xml powerisa-instructions-python.xml
 
diff --git a/.gitignore b/.gitignore
index 37b3676..454d147 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@ __pycache__
 *.log
 /powerisa-instructions.xml
 /*.pdf
+/target
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..4de1b68
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,337 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "cc"
+version = "1.2.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "indexmap"
+version = "2.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "mupdf-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13e9a0d4e844ab50315d43312f3d62f72c77205b07c8ee21cbd4b52bdc2a9910"
+dependencies = [
+ "bindgen",
+ "cc",
+ "pkg-config",
+ "regex",
+ "zerocopy",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "parse_powerisa_pdf"
+version = "0.1.0"
+dependencies = [
+ "indexmap",
+ "libm",
+ "mupdf-sys",
+ "quick-xml",
+ "serde",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.38.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21f182278bf2d2bcb3c88b1b08a37df029d71ce3d3ae26168e3c653b213b99d4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..09de0ba
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
+[package]
+name = "parse_powerisa_pdf"
+version = "0.1.0"
+license = "LGPL-3.0-or-later"
+edition = "2024"
+repository = ""
+keywords = []
+categories = []
+rust-version = "1.89.0"
+
+[dependencies]
+indexmap = "2.12.1"
+libm = "0.2.15"
+mupdf-sys = { version = "0.5.0", default-features = false }
+quick-xml = { version = "0.38.4", features = ["serialize"] }
+serde = { version = "1.0.228", features = ["derive"] }
diff --git a/parse_powerisa_pdf/parse_powerisa_pdf.py b/parse_powerisa_pdf/parse_powerisa_pdf.py
index a4afd09..3c2afe5 100755
--- a/parse_powerisa_pdf/parse_powerisa_pdf.py
+++ b/parse_powerisa_pdf/parse_powerisa_pdf.py
@@ -765,7 +765,7 @@ class Page:
     unprocessed_non_text: SetById[LTLine | LTRect]
 
     @staticmethod
-    def from_lt_page(page_num: int, page: LTPage) -> Page:
+    def from_lt_page(page_num: int, page: LTPage, first_seen_fonts: defaultdict[str, set[float]]) -> Page:
         qt: defaultdict[TextSection, QuadTree[Char | LTLine | LTRect]] = defaultdict(QuadTree)
         unprocessed_chars = defaultdict(lambda: defaultdict(SetById[Char]))
         unprocessed_non_text: SetById[LTLine | LTRect] = SetById()
@@ -804,20 +804,25 @@ class Page:
                                 raise AssertionError(
                                     f"char not in text section: {element}\npage_num={page_num}")
                         continue
+                    font_size = round(element.size, 3)
                     char = Char(
                         text=element.get_text(),
-                        font=Font(font_name=element.fontname, size=round(element.size, 3)),
+                        font=Font(font_name=element.fontname, size=font_size),
                         adv=element.adv,
                         min_x=element.x0,
                         min_y=element.y0,
                         max_x=element.x1,
                         max_y=element.y1,
                     )
+                    if font_size not in first_seen_fonts[element.fontname]:
+                        first_seen_fonts[element.fontname].add(font_size)
+                        print(f"first seen font: {element.fontname!r} {font_size}: page {page_num} {char!r}")
                     qt[text_section].insert(char.min_x, char.min_y, char)
                     unprocessed_chars[text_section][char.font].add(char)
-        for i in unprocessed_chars.values():
-            for j in i.values():
-                j.sort(key=Char.top_down_left_to_right_sort_key)
+        for text_section, i in unprocessed_chars.items():
+            for chars in i.values():
+                chars.sort(key=Char.top_down_left_to_right_sort_key)
+                print(f"first char: {text_section!r}: {next(iter(chars), None)!r}")
         unknown_fonts=[]
         unknown_font_errors=[]
         for i in unprocessed_chars.values():
@@ -1181,13 +1186,14 @@ class Parser:
     def __pages_gen(file: Path, page_numbers: Iterable[int] | None) -> Generator[Page, None, None]:
         if page_numbers is not None:
             page_numbers = sorted(i - 1 for i in page_numbers)
+        first_seen_fonts = defaultdict(set)
         for i, page in enumerate(extract_pages(file, page_numbers=page_numbers)):
             if page_numbers is not None:
                 page_num = page_numbers[i] + 1
             else:
                 page_num = i + 1
             print(f"page {page_num}")
-            yield Page.from_lt_page(page_num=page_num, page=page)
+            yield Page.from_lt_page(page_num=page_num, page=page, first_seen_fonts=first_seen_fonts)
 
     def parse_pdf(self, file: Path, page_numbers: Iterable[int] | None = None):
         self.pages = Pages(pages_gen=Parser.__pages_gen(
@@ -1503,7 +1509,7 @@ class Parser:
                 f"instruction bit fields box has wrong number of horizontal lines:\n{h_lines}")
         if len(v_lines) < 2:
             raise InsnParseError(
-                f"instruction bit fields box has too few vertical lines:\n{h_lines}")
+                f"instruction bit fields box has too few vertical lines:\n{v_lines}")
         bottom_line, top_line = h_lines
         box_min_x = v_lines[0].x0
         box_max_x = v_lines[-1].x0
diff --git a/pyproject.toml b/pyproject.toml
index 68c4029..0f3e887 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,4 +13,7 @@ dependencies = [
 requires-python = ">= 3.11"
 
 [project.scripts]
-parse_powerisa_pdf = "parse_powerisa_pdf.parse_powerisa_pdf:main"
\ No newline at end of file
+parse_powerisa_pdf = "parse_powerisa_pdf.parse_powerisa_pdf:main"
+
+[tool.setuptools]
+packages = ["parse_powerisa_pdf"]
diff --git a/scripts/check-copyright.sh b/scripts/check-copyright.sh
index 640fb4b..a9dc2bc 100755
--- a/scripts/check-copyright.sh
+++ b/scripts/check-copyright.sh
@@ -32,6 +32,7 @@ function check_file()
 }
 
 POUND_HEADER=('^"# SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"# See Notices.txt for copyright information"$')
+SLASH_HEADER=('^"// SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"// See Notices.txt for copyright information"$')
 MD_HEADER=('^"<!--"$' '^"SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"See Notices.txt for copyright information"$')
 
 function main()
@@ -41,6 +42,9 @@ function main()
     local file
     for file in $(git ls-tree --name-only --full-tree -r HEAD); do
         case "/$file" in
+        /Cargo.lock)
+            # generated file
+            ;;
         */LICENSE.md|*/Notices.txt)
             # copyright file
             ;;
@@ -53,6 +57,9 @@ function main()
         *.sh)
             check_file "$file" '^'\''#!'\' "${POUND_HEADER[@]}"
             ;;
+        *.rs)
+            check_file "$file" "${SLASH_HEADER[@]}"
+            ;;
         *)
             fail_file "$file" 0 "unimplemented file kind -- you need to add it to $0"
             ;;
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..67d9dd9
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,3874 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use crate::{
+    mupdf_ffi::{
+        MuPdfError, WriteMode, add_points, point_max_components, point_min_components,
+        transform_vector,
+    },
+    quad_tree::QuadTree,
+};
+use indexmap::IndexSet;
+use mupdf_sys::{fz_matrix, fz_point, fz_text_item};
+use non_nan_float::NonNaNF32;
+use std::{
+    backtrace::Backtrace,
+    borrow::Cow,
+    cell::RefCell,
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
+    convert::Infallible,
+    fmt,
+    num::NonZero,
+    ops::ControlFlow,
+    rc::Rc,
+    sync::OnceLock,
+};
+
+mod mupdf_ffi;
+mod quad_tree;
+mod xml_tree;
+
+mod non_nan_float {
+    #[derive(Default, PartialEq, PartialOrd, Clone, Copy)]
+    pub(crate) struct NonNaNF32(f32);
+
+    impl std::fmt::Debug for NonNaNF32 {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl std::fmt::Display for NonNaNF32 {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl NonNaNF32 {
+        pub(crate) const fn new(v: f32) -> Option<Self> {
+            if v.is_nan() { None } else { Some(Self(v)) }
+        }
+        pub(crate) const fn get(self) -> f32 {
+            self.0
+        }
+        pub(crate) const fn min(self, other: Self) -> Self {
+            Self(self.0.min(other.0))
+        }
+        pub(crate) const fn max(self, other: Self) -> Self {
+            Self(self.0.max(other.0))
+        }
+    }
+
+    impl std::hash::Hash for NonNaNF32 {
+        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+            if self.0 == 0.0 { 0.0 } else { self.0 }
+                .to_bits()
+                .hash(state);
+        }
+    }
+
+    impl Eq for NonNaNF32 {}
+
+    impl Ord for NonNaNF32 {
+        fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+            self.partial_cmp(other).expect("known to be non-NaN")
+        }
+    }
+
+    impl std::ops::Neg for NonNaNF32 {
+        type Output = Self;
+
+        fn neg(self) -> Self::Output {
+            Self(-self.0)
+        }
+    }
+}
+
+const fn str_eq(a: &str, b: &str) -> bool {
+    let a = a.as_bytes();
+    let b = b.as_bytes();
+    if a.len() != b.len() {
+        return false;
+    }
+    let mut i = 0;
+    while i < a.len() {
+        if a[i] != b[i] {
+            return false;
+        }
+        i += 1;
+    }
+    true
+}
+
+macro_rules! make_enum_font {
+    (
+        enum $Font:ident {
+            #[other]
+            $Other:ident $other_body:tt,
+            $(#[group]
+            $KnownFontGroup:ident {
+                $(#[name_with_tag = $known_font_name_with_tag:literal, size = $known_font_size:literal]
+                $KnownFont:ident,)*
+            },)*
+        }
+    ) => {
+        #[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Clone)]
+        enum $Font {
+            $Other $other_body,
+            $($($KnownFont,)*)*
+        }
+
+        #[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Copy, Clone)]
+        enum KnownFontGroup {
+            $($KnownFontGroup,)*
+        }
+
+        impl KnownFontGroup {
+            const fn fonts(self) -> &'static [Font] {
+                match self {
+                    $(Self::$KnownFontGroup => &[$(Font::$KnownFont,)*],)*
+                }
+            }
+            const INSN_CODE_FONT_GROUPS: &[Self] = &[Self::InsnCode, Self::InsnCodeSubscript];
+        }
+
+        impl $Font {
+            const fn extract_font_name_from_font_name_with_tag(font_name_with_tag: &str) -> &str {
+                if let [b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'+',_,..] = font_name_with_tag.as_bytes() {
+                    font_name_with_tag.split_at(7).1
+                } else {
+                    panic!("invalid font name with id")
+                }
+            }
+            const fn known_from_name_with_tag(font_name_with_tag: &str, size: NonNaNF32) -> Option<Self> {
+                match size.get() {
+                    $($($known_font_size if str_eq(font_name_with_tag, $known_font_name_with_tag) => Some(Self::$KnownFont),)*)*
+                    _ => None,
+                }
+            }
+            const fn new_known(font_name: &str, size: NonNaNF32) -> Option<Self> {
+                match size.get() {
+                    $($($known_font_size if str_eq(font_name, const {
+                        Self::extract_font_name_from_font_name_with_tag($known_font_name_with_tag)
+                    }) => Some(Self::$KnownFont),)*)*
+                    _ => None,
+                }
+            }
+            fn new(font_name: &str, size: NonNaNF32) -> Self {
+                if let Some(v) = Self::new_known(font_name, size) {
+                    v
+                } else {
+                    Self::Other {
+                        font_name: Box::from(font_name),
+                        size,
+                    }
+                }
+            }
+            const fn size(&self) -> f32 {
+                match *self {
+                    Self::$Other { size, .. } => size.get(),
+                    $($(Self::$KnownFont => $known_font_size,)*)*
+                }
+            }
+            const fn font_name(&self) -> &str {
+                match self {
+                    Self::$Other { font_name, .. } => font_name,
+                    $($(Self::$KnownFont => const { Self::extract_font_name_from_font_name_with_tag($known_font_name_with_tag) },)*)*
+                }
+            }
+            const fn known_font_group(&self) -> Option<KnownFontGroup> {
+                match self {
+                    Self::$Other { .. } => None,
+                    $($(Self::$KnownFont => Some(KnownFontGroup::$KnownFontGroup),)*)*
+                }
+            }
+            const fn line_height(&self) -> f32 {
+                match self {
+                    Self::$Other { .. } => self.line_height_helper(),
+                    $($(Self::$KnownFont => const { Self::$KnownFont.line_height_helper() },)*)*
+                }
+            }
+        }
+
+        const _: () = {
+            $($(
+                let (known_font_name, known_font) = const {
+                    let known_font_name = Font::extract_font_name_from_font_name_with_tag($known_font_name_with_tag);
+                    (known_font_name, &Font::new_known(known_font_name, NonNaNF32::new($known_font_size).unwrap()).unwrap())
+                };
+                assert!(str_eq(known_font_name, known_font.font_name()));
+                assert!(matches!(known_font, Font::$KnownFont));
+            )*)*
+        };
+    };
+}
+
+make_enum_font! {
+    enum Font {
+        #[other]
+        Other {
+            font_name: Box<str>,
+            size: NonNaNF32,
+        },
+        #[group]
+        InsnHeader {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 9.963]
+            InsnHeader,
+        },
+        #[group]
+        RtlFnHeader {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 9.963]
+            RtlFnHeader,
+        },
+        #[group]
+        PageHeader {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 9.963]
+            PageHeader,
+        },
+        #[group]
+        PageFooter {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.981]
+            PageFooter,
+        },
+        #[group]
+        InsnDesc {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 8.966]
+            InsnDesc0,
+            #[name_with_tag = "FZTIYT+CMMI9", size = 8.966]
+            InsnDesc1,
+            #[name_with_tag = "ONUAYC+CMSSI9", size = 8.966]
+            InsnDesc2,
+            #[name_with_tag = "TNGBFZ+CMSY9", size = 8.966]
+            InsnDesc3,
+            #[name_with_tag = "WHMZPU+CMEX9", size = 8.966]
+            InsnDesc4,
+            #[name_with_tag = "ZJTMSG+CMSS9", size = 8.966]
+            InsnDesc5,
+        },
+        #[group]
+        InsnDescMisc {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 2.377]
+            InsnDescMisc0,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 2.561]
+            InsnDescMisc1,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.492]
+            InsnDescMisc2,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.641]
+            InsnDescMisc3,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.772]
+            InsnDescMisc4,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.864]
+            InsnDescMisc5,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.925]
+            InsnDescMisc6,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.097]
+            InsnDescMisc7,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.123]
+            InsnDescMisc8,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.131]
+            InsnDescMisc9,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.516]
+            InsnDescMisc10,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.604]
+            InsnDescMisc11,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.634]
+            InsnDescMisc12,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.906]
+            InsnDescMisc13,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.033]
+            InsnDescMisc14,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.068]
+            InsnDescMisc15,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.213]
+            InsnDescMisc16,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.238]
+            InsnDescMisc17,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.252]
+            InsnDescMisc18,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.962]
+            InsnDescMisc19,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 7.977]
+            InsnDescMisc20,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 8.506]
+            InsnDescMisc21,
+        },
+        #[group]
+        InsnDescCode {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 6.974]
+            InsnDescCode,
+        },
+        #[group]
+        InsnDescCodeMisc {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 3.587]
+            InsnDescCodeMisc0,
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 4.483]
+            InsnDescCodeMisc1,
+        },
+        #[group]
+        InsnDescItalic {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 8.966]
+            InsnDescItalic,
+        },
+        #[group]
+        InsnDescBold {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.966]
+            InsnDescBold,
+        },
+        #[group]
+        InsnDescBoldItalic {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 8.966]
+            InsnDescBoldItalic,
+        },
+        #[group]
+        InsnDescSmall {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 7.97]
+            InsnDescSmall,
+        },
+        #[group]
+        InsnDescSmallItalic {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 7.97]
+            InsnDescSmallItalic,
+        },
+        #[group]
+        InsnDescSmallBold {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 7.97]
+            InsnDescSmallBold,
+        },
+        #[group]
+        InsnDescSmallBoldItalic {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 7.97]
+            InsnDescSmallBoldItalic,
+        },
+        #[group]
+        InsnDescBoldMisc {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.21]
+            InsnDescBoldMisc0,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.399]
+            InsnDescBoldMisc1,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.763]
+            InsnDescBoldMisc2,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.946]
+            InsnDescBoldMisc3,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.949]
+            InsnDescBoldMisc4,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.999]
+            InsnDescBoldMisc5,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.065]
+            InsnDescBoldMisc6,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.086]
+            InsnDescBoldMisc7,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.183]
+            InsnDescBoldMisc8,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.686]
+            InsnDescBoldMisc9,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.744]
+            InsnDescBoldMisc10,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.825]
+            InsnDescBoldMisc11,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.842]
+            InsnDescBoldMisc12,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.857]
+            InsnDescBoldMisc13,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.979]
+            InsnDescBoldMisc14,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.032]
+            InsnDescBoldMisc15,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.112]
+            InsnDescBoldMisc16,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.161]
+            InsnDescBoldMisc17,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.206]
+            InsnDescBoldMisc18,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.353]
+            InsnDescBoldMisc19,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.378]
+            InsnDescBoldMisc20,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.434]
+            InsnDescBoldMisc21,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.595]
+            InsnDescBoldMisc22,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.619]
+            InsnDescBoldMisc23,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.647]
+            InsnDescBoldMisc24,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.68]
+            InsnDescBoldMisc25,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.693]
+            InsnDescBoldMisc26,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.736]
+            InsnDescBoldMisc27,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.781]
+            InsnDescBoldMisc28,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.802]
+            InsnDescBoldMisc29,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.995]
+            InsnDescBoldMisc30,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.201]
+            InsnDescBoldMisc31,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.258]
+            InsnDescBoldMisc32,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.363]
+            InsnDescBoldMisc33,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.442]
+            InsnDescBoldMisc34,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.473]
+            InsnDescBoldMisc35,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.485]
+            InsnDescBoldMisc36,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.512]
+            InsnDescBoldMisc37,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.543]
+            InsnDescBoldMisc38,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.613]
+            InsnDescBoldMisc39,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.744]
+            InsnDescBoldMisc40,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.774]
+            InsnDescBoldMisc41,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.809]
+            InsnDescBoldMisc42,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.849]
+            InsnDescBoldMisc43,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.911]
+            InsnDescBoldMisc44,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.92]
+            InsnDescBoldMisc45,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.962]
+            InsnDescBoldMisc46,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.981]
+            InsnDescBoldMisc47,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.146]
+            InsnDescBoldMisc48,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.213]
+            InsnDescBoldMisc49,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.221]
+            InsnDescBoldMisc50,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.243]
+            InsnDescBoldMisc51,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.55]
+            InsnDescBoldMisc52,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.62]
+            InsnDescBoldMisc53,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.699]
+            InsnDescBoldMisc54,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.725]
+            InsnDescBoldMisc55,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.751]
+            InsnDescBoldMisc56,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.856]
+            InsnDescBoldMisc57,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.029]
+            InsnDescBoldMisc58,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.406]
+            InsnDescBoldMisc59,
+        },
+        #[group]
+        InsnDescSubscript {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.978]
+            InsnDescSubscript,
+        },
+        #[group]
+        InsnDescBoldSubscript {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.978]
+            InsnDescBoldSubscript,
+        },
+        #[group]
+        InsnDescItalicSubscript {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 5.978]
+            InsnDescItalicSubscript,
+        },
+        #[group]
+        InsnDescBoldItalicSubscript {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 5.978]
+            InsnDescBoldItalicSubscript,
+        },
+        #[group]
+        InsnExtMnemonic {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 8.966]
+            InsnExtMnemonic,
+        },
+        #[group]
+        InsnCode {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 7.97]
+            InsnCode0,
+            #[name_with_tag = "RRFUNA+CMSY8", size = 7.97]
+            InsnCode1,
+            #[name_with_tag = "HPXOZC+CMSS8", size = 7.97]
+            InsnCode2,
+        },
+        #[group]
+        InsnCodeSubscript {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 5.978]
+            InsnCodeSubscript0,
+            #[name_with_tag = "DBQTKF+CMSY6", size = 5.978]
+            InsnCodeSubscript1,
+        },
+        #[group]
+        TitlePageBig {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 24.787]
+            TitlePageBig,
+        },
+        #[group]
+        TitlePageVersion {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 9.963]
+            TitlePageVersion,
+        },
+        #[group]
+        TitlePageTm {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.974]
+            TitlePageTm,
+        },
+        #[group]
+        TitlePageRev {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.974]
+            TitlePageRev,
+        },
+        #[group]
+        TitlePageBook {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 20.663]
+            TitlePageBook,
+        },
+        #[group]
+        LegalPageItalic {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 9.963]
+            LegalPageItalic,
+        },
+        #[group]
+        ChangeSummaryPageBold {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 11.955]
+            ChangeSummaryPageBold,
+        },
+        #[group]
+        ChapterTitle {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 17.215]
+            ChapterTitle,
+        },
+        #[group]
+        MathMisc {
+            #[name_with_tag = "AAJMKT+CMMI6", size = 5.978]
+            MathMisc0,
+            #[name_with_tag = "CUTMFD+CMSSI8", size = 5.978]
+            MathMisc1,
+            #[name_with_tag = "CUTMFD+CMSSI8", size = 7.97]
+            MathMisc2,
+            #[name_with_tag = "FZTIYT+CMMI9", size = 5.734]
+            MathMisc3,
+            #[name_with_tag = "FZTIYT+CMMI9", size = 7.168]
+            MathMisc4,
+            #[name_with_tag = "HONFQS+CMMI8", size = 7.97]
+            MathMisc5,
+            #[name_with_tag = "HPXOZC+CMSS8", size = 5.978]
+            MathMisc6,
+            #[name_with_tag = "LLVRDD+CMSY10", size = 11.955]
+            MathMisc7,
+            #[name_with_tag = "ZJTMSG+CMSS9", size = 7.168]
+            MathMisc8,
+        },
+    }
+}
+
+impl Font {
+    const fn space_width(&self) -> f32 {
+        self.size() * const { 3.985 / Font::InsnCode0.size() }
+    }
+    const fn line_height_helper(&self) -> f32 {
+        let font_name = self.font_name();
+        let mut i = 0;
+        while i < KnownFontGroup::INSN_CODE_FONT_GROUPS.len() {
+            let fonts = KnownFontGroup::INSN_CODE_FONT_GROUPS[i].fonts();
+            let mut j = 0;
+            while j < fonts.len() {
+                if str_eq(font_name, fonts[j].font_name()) {
+                    return 9.464 * self.size() / Font::InsnCode0.size();
+                }
+                j += 1;
+            }
+            i += 1;
+        }
+        let group = self.known_font_group();
+        if matches!(group, Some(KnownFontGroup::InsnDesc))
+            || str_eq(font_name, Font::InsnDesc0.font_name())
+            || str_eq(font_name, Font::InsnDescBold.font_name())
+            || str_eq(font_name, Font::InsnDescItalic.font_name())
+            || str_eq(font_name, Font::InsnDescBoldItalic.font_name())
+            || matches!(group, Some(KnownFontGroup::MathMisc))
+        {
+            return 10.959 * self.size() / Font::InsnDesc0.size();
+        }
+        panic!("no line height")
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct Char {
+    font: Font,
+    text: String,
+    min_x: NonNaNF32,
+    min_y: NonNaNF32,
+    max_x: NonNaNF32,
+    max_y: NonNaNF32,
+}
+
+impl Char {
+    fn width(&self) -> f32 {
+        self.max_x.get() - self.min_x.get()
+    }
+    fn height(&self) -> f32 {
+        self.max_y.get() - self.min_y.get()
+    }
+    fn top_down_left_to_right_sort_key(&self) -> impl Ord + use<> {
+        (-self.min_y, self.min_x)
+    }
+}
+
+const COLUMN_SPLIT_X: f32 = 300.0;
+const PAGE_BODY_MAX_X: f32 = 600.0;
+const PAGE_BODY_MIN_X: f32 = 50.0;
+const PAGE_BODY_MAX_Y: f32 = 780.0;
+const PAGE_BODY_MIN_Y: f32 = 45.0;
+const ONE_TITLE_LINE_SPLIT_Y: f32 = 734.0;
+const TWO_TITLE_LINES_SPLIT_Y: f32 = 715.0;
+const INSN_BIT_FIELDS_PREFIX_TEXT_TOP_PAD_HEIGHT: f32 = 29.938;
+const INSN_BIT_FIELDS_AFFIX_TEXT_TO_BOX_TOP_HEIGHT: f32 = 9.278;
+const INSN_BIT_FIELDS_PREFIX_BOX_BOTTOM_TO_SUFFIX_TEXT_HEIGHT: f32 = 20.971;
+const INSN_BIT_FIELDS_TOP_PAD_HEIGHT: f32 = 20.175;
+const INSN_BIT_FIELDS_TOP_PAD_HEIGHT2: f32 = 14.694;
+const INSN_BIT_FIELDS_BOX_HEIGHT: f32 = 22.317;
+const INSN_SP_REGS_ALTERED_REGISTER_COLUMN_X: f32 = 34.405;
+const INSN_SP_REGS_ALTERED_FIELDS_COLUMN_X: f32 = 86.692;
+const INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X: f32 = 188.74;
+
+#[derive(Clone)]
+struct ParsedTextLine {
+    element: xml_tree::Element,
+    regular_min_y: f32,
+    regular_max_y: f32,
+    fonts: TextLineFonts,
+    chars: Vec<Char>,
+    preceding_blank_lines: u32,
+}
+
+impl ParsedTextLine {
+    fn regular_height(&self) -> f32 {
+        self.regular_max_y - self.regular_min_y
+    }
+    fn get_header_text(&self) -> Option<String> {
+        assert_eq!(self.fonts, TextLineFonts::InsnDescFonts);
+        if !self.element.text.trim().is_empty() {
+            return None;
+        }
+        if !self.element.tail.trim().is_empty() {
+            return None;
+        }
+        let [b] = &*self.element.children else {
+            return None;
+        };
+        if b.tag.normal() != Some("b") {
+            return None;
+        }
+        if b.children.len() != 0 {
+            return None;
+        }
+        let text = self.element.inner_text();
+        // should also check titlecase, but rust doesn't include that in std
+        if text.ends_with(":") && text.chars().next().is_some_and(|ch| ch.is_uppercase()) {
+            Some(text)
+        } else {
+            None
+        }
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element, trailing_nl: bool) {
+        for _ in 0..self.preceding_blank_lines {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+        if let Some(last_child) = parent.children.last_mut() {
+            last_child.tail += &self.element.text;
+        } else {
+            parent.text += &self.element.text;
+        }
+        parent.children.extend_from_slice(&self.element.children);
+        if trailing_nl {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+    }
+    fn write_xml_lines(
+        lines: impl IntoIterator<Item: std::borrow::Borrow<ParsedTextLine>>,
+        parent: &mut xml_tree::Element,
+        trailing_nl: bool,
+        preceding_nl: bool,
+    ) {
+        if preceding_nl {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+        let mut first = true;
+        for line in lines {
+            let line = std::borrow::Borrow::borrow(&line);
+            if first {
+                first = false;
+            } else {
+                parent.sub_element("br".into(), []).tail = "\n".into();
+            }
+            line.write_xml(parent, false);
+        }
+        if trailing_nl {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+    }
+}
+
+impl fmt::Debug for ParsedTextLine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            element,
+            regular_min_y,
+            regular_max_y,
+            fonts,
+            chars,
+            preceding_blank_lines,
+        } = self;
+        f.debug_struct("ParsedTextLine")
+            .field("element", &format_args!("{element}"))
+            .field("regular_min_y", regular_min_y)
+            .field("regular_max_y", regular_max_y)
+            .field("fonts", fonts)
+            .field("chars", chars)
+            .field("preceding_blank_lines", preceding_blank_lines)
+            .finish()
+    }
+}
+
+impl fmt::Display for ParsedTextLine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for _ in 0..self.preceding_blank_lines {
+            f.write_str("\n")?;
+        }
+        self.element.fmt(f)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum BaselinePos {
+    Above,
+    Below,
+}
+
+macro_rules! make_enum_with_values {
+    (
+        $(#[$enum_meta:meta])*
+        enum $Enum:ident {
+            $($Variant:ident,)*
+        }
+    ) => {
+        $(#[$enum_meta])*
+        enum $Enum {
+            $($Variant,)*
+        }
+
+        impl $Enum {
+            const VALUES: &[Self] = &[$(Self::$Variant,)*];
+        }
+    };
+}
+
+make_enum_with_values! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    enum TextLineFonts {
+        InsnMnemonicFonts,
+        InsnHeaderFonts,
+        InsnBitFieldBitNumberFonts,
+        InsnBitFieldNameFonts,
+        InsnBitFieldsAffixTitleFonts,
+        InsnCodeFonts,
+        InsnDescFonts,
+    }
+}
+
+impl TextLineFonts {
+    fn regular(self) -> &'static [Font] {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => KnownFontGroup::InsnDesc.fonts(),
+            TextLineFonts::InsnHeaderFonts => &[Font::InsnHeader],
+            TextLineFonts::InsnBitFieldBitNumberFonts => &[Font::InsnDescSmall, Font::TitlePageRev],
+            TextLineFonts::InsnBitFieldNameFonts => KnownFontGroup::InsnDesc.fonts(),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => &[Font::InsnDescSmall],
+            TextLineFonts::InsnCodeFonts => KnownFontGroup::InsnCode.fonts(),
+            TextLineFonts::InsnDescFonts => {
+                static FONTS: OnceLock<Box<[Font]>> = OnceLock::new();
+                FONTS.get_or_init(|| {
+                    Box::from_iter(
+                        KnownFontGroup::InsnDesc
+                            .fonts()
+                            .iter()
+                            .cloned()
+                            .chain([Font::InsnDescSmall]),
+                    )
+                })
+            }
+        }
+    }
+    fn italic(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => {
+                Some(&[Font::InsnDescItalic, Font::InsnDescSmallItalic])
+            }
+        }
+    }
+    fn bold(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => Some(&[Font::InsnDescSmallBold]),
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescBold, Font::InsnDescSmallBold]),
+        }
+    }
+    fn bold_italic(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => {
+                Some(&[Font::InsnDescBoldItalic, Font::InsnDescSmallBoldItalic])
+            }
+        }
+    }
+    fn subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => Some(&[Font::InsnDescSubscript]),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => Some(KnownFontGroup::InsnCodeSubscript.fonts()),
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescSubscript]),
+        }
+    }
+    fn bold_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescBoldSubscript]),
+        }
+    }
+    fn italic_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescItalicSubscript]),
+        }
+    }
+    fn bold_italic_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescBoldItalicSubscript]),
+        }
+    }
+    fn code(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescCode, Font::InsnExtMnemonic]),
+        }
+    }
+    fn code_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(KnownFontGroup::InsnCodeSubscript.fonts()),
+        }
+    }
+    fn get_fonts(
+        self,
+        part_kind: TextLineFontKind,
+    ) -> Option<(&'static [Font], Option<BaselinePos>)> {
+        let fonts = match part_kind {
+            TextLineFontKind::Regular => self.regular(),
+            TextLineFontKind::Italic => self.italic()?,
+            TextLineFontKind::Bold => self.bold()?,
+            TextLineFontKind::BoldItalic => self.bold_italic()?,
+            TextLineFontKind::Subscript => self.subscript()?,
+            TextLineFontKind::Superscript => self.subscript()?,
+            TextLineFontKind::BoldSubscript => self.bold_subscript()?,
+            TextLineFontKind::BoldSuperscript => self.bold_subscript()?,
+            TextLineFontKind::ItalicSubscript => self.italic_subscript()?,
+            TextLineFontKind::ItalicSuperscript => self.italic_subscript()?,
+            TextLineFontKind::BoldItalicSubscript => self.bold_italic_subscript()?,
+            TextLineFontKind::BoldItalicSuperscript => self.bold_italic_subscript()?,
+            TextLineFontKind::Code => self.code()?,
+            TextLineFontKind::CodeSubscript => self.code_subscript()?,
+            TextLineFontKind::CodeSuperscript => self.code_subscript()?,
+        };
+        Some((fonts, part_kind.sub_super().baseline_pos()))
+    }
+    fn font_to_kind_map(self) -> &'static HashMap<(Font, Option<BaselinePos>), TextLineFontKind> {
+        static MAPS: OnceLock<
+            HashMap<TextLineFonts, HashMap<(Font, Option<BaselinePos>), TextLineFontKind>>,
+        > = OnceLock::new();
+        &MAPS.get_or_init(|| {
+            Self::VALUES
+                .iter()
+                .map(|&this: &TextLineFonts| {
+                    let mut map = HashMap::new();
+                    for &kind in TextLineFontKind::VALUES {
+                        let Some((fonts, baseline_pos)) = this.get_fonts(kind) else {
+                            continue;
+                        };
+                        for font in fonts {
+                            let old_kind = map.insert((font.clone(), baseline_pos), kind);
+                            assert!(
+                                old_kind.is_none(),
+                                "duplicate font: kind={kind:?} old_kind={old_kind:?} font={font:?}"
+                            );
+                        }
+                    }
+                    (this, map)
+                })
+                .collect()
+        })[&self]
+    }
+    fn fonts(self) -> &'static HashSet<Font> {
+        static SETS: OnceLock<HashMap<TextLineFonts, HashSet<Font>>> = OnceLock::new();
+        &SETS.get_or_init(|| {
+            Self::VALUES
+                .iter()
+                .map(|&this: &TextLineFonts| {
+                    let mut set = HashSet::new();
+                    for &kind in TextLineFontKind::VALUES {
+                        let Some((fonts, _baseline_pos)) = this.get_fonts(kind) else {
+                            continue;
+                        };
+                        set.extend(fonts.iter().cloned());
+                    }
+                    (this, set)
+                })
+                .collect()
+        })[&self]
+    }
+    fn get_kind(self, font: Font, baseline_pos: BaselinePos) -> Option<TextLineFontKind> {
+        let font_to_kind_map = self.font_to_kind_map();
+        font_to_kind_map
+            .get(&(font.clone(), Some(baseline_pos)))
+            .or_else(|| font_to_kind_map.get(&(font, None)))
+            .copied()
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantCode {
+    Code,
+    NotCode,
+}
+
+impl FontVariantCode {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::Code => &["code"],
+            Self::NotCode => &[],
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantBold {
+    Bold,
+    NotBold,
+}
+
+impl FontVariantBold {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::Bold => &["b"],
+            Self::NotBold => &[],
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantItalic {
+    Italic,
+    NotItalic,
+}
+
+impl FontVariantItalic {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::Italic => &["i"],
+            Self::NotItalic => &[],
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantSubSuper {
+    NotSubSuper,
+    Subscript,
+    Superscript,
+}
+
+impl FontVariantSubSuper {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::NotSubSuper => &[],
+            Self::Subscript => &["sub"],
+            Self::Superscript => &["sup"],
+        }
+    }
+}
+
+impl FontVariantSubSuper {
+    fn baseline_pos(self) -> Option<BaselinePos> {
+        match self {
+            FontVariantSubSuper::NotSubSuper => None,
+            FontVariantSubSuper::Subscript => Some(BaselinePos::Below),
+            FontVariantSubSuper::Superscript => Some(BaselinePos::Above),
+        }
+    }
+}
+
+make_enum_with_values! {
+    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+    enum TextLineFontKind {
+        Regular,
+        Subscript,
+        Superscript,
+        Italic,
+        ItalicSubscript,
+        ItalicSuperscript,
+        Bold,
+        BoldSubscript,
+        BoldSuperscript,
+        BoldItalic,
+        BoldItalicSubscript,
+        BoldItalicSuperscript,
+        Code,
+        CodeSubscript,
+        CodeSuperscript,
+    }
+}
+
+impl TextLineFontKind {
+    fn code(self) -> FontVariantCode {
+        match self {
+            Self::Regular
+            | Self::Subscript
+            | Self::Superscript
+            | Self::Italic
+            | Self::ItalicSubscript
+            | Self::ItalicSuperscript
+            | Self::Bold
+            | Self::BoldSubscript
+            | Self::BoldSuperscript
+            | Self::BoldItalic
+            | Self::BoldItalicSubscript
+            | Self::BoldItalicSuperscript => FontVariantCode::NotCode,
+            Self::Code | Self::CodeSubscript | Self::CodeSuperscript => FontVariantCode::Code,
+        }
+    }
+    fn bold(self) -> FontVariantBold {
+        match self {
+            Self::Regular
+            | Self::Subscript
+            | Self::Superscript
+            | Self::Italic
+            | Self::ItalicSubscript
+            | Self::ItalicSuperscript => FontVariantBold::NotBold,
+            Self::Bold
+            | Self::BoldSubscript
+            | Self::BoldSuperscript
+            | Self::BoldItalic
+            | Self::BoldItalicSubscript
+            | Self::BoldItalicSuperscript => FontVariantBold::Bold,
+            Self::Code | Self::CodeSubscript | Self::CodeSuperscript => FontVariantBold::NotBold,
+        }
+    }
+    fn italic(self) -> FontVariantItalic {
+        match self {
+            Self::Regular | Self::Subscript | Self::Superscript => FontVariantItalic::NotItalic,
+            Self::Italic | Self::ItalicSubscript | Self::ItalicSuperscript => {
+                FontVariantItalic::Italic
+            }
+            Self::Bold | Self::BoldSubscript | Self::BoldSuperscript => {
+                FontVariantItalic::NotItalic
+            }
+            Self::BoldItalic | Self::BoldItalicSubscript | Self::BoldItalicSuperscript => {
+                FontVariantItalic::Italic
+            }
+            Self::Code | Self::CodeSubscript | Self::CodeSuperscript => {
+                FontVariantItalic::NotItalic
+            }
+        }
+    }
+    fn sub_super(self) -> FontVariantSubSuper {
+        match self {
+            Self::Regular => FontVariantSubSuper::NotSubSuper,
+            Self::Subscript => FontVariantSubSuper::Subscript,
+            Self::Superscript => FontVariantSubSuper::Superscript,
+            Self::Italic => FontVariantSubSuper::NotSubSuper,
+            Self::ItalicSubscript => FontVariantSubSuper::Subscript,
+            Self::ItalicSuperscript => FontVariantSubSuper::Superscript,
+            Self::Bold => FontVariantSubSuper::NotSubSuper,
+            Self::BoldSubscript => FontVariantSubSuper::Subscript,
+            Self::BoldSuperscript => FontVariantSubSuper::Superscript,
+            Self::BoldItalic => FontVariantSubSuper::NotSubSuper,
+            Self::BoldItalicSubscript => FontVariantSubSuper::Subscript,
+            Self::BoldItalicSuperscript => FontVariantSubSuper::Superscript,
+            Self::Code => FontVariantSubSuper::NotSubSuper,
+            Self::CodeSubscript => FontVariantSubSuper::Subscript,
+            Self::CodeSuperscript => FontVariantSubSuper::Superscript,
+        }
+    }
+    fn text_line_tags(self) -> impl Clone + Iterator<Item = &'static str> {
+        self.code()
+            .value()
+            .iter()
+            .copied()
+            .chain(self.bold().value().iter().copied())
+            .chain(self.italic().value().iter().copied())
+            .chain(self.sub_super().value().iter().copied())
+    }
+}
+
+#[derive(Debug)]
+struct ElementBodyBuilder<'a> {
+    containing_element: &'a mut xml_tree::Element,
+    stack: Vec<xml_tree::Element>,
+}
+
+impl<'a> ElementBodyBuilder<'a> {
+    fn new(containing_element: &'a mut xml_tree::Element) -> Self {
+        Self {
+            containing_element,
+            stack: Vec::with_capacity(5),
+        }
+    }
+    fn shrink_stack(&mut self, new_len: usize) {
+        while new_len < self.stack.len() {
+            let Some(element) = self.stack.pop() else {
+                unreachable!();
+            };
+            self.insert_point().children.push(element);
+        }
+    }
+    fn set_tag_stack<'b>(&mut self, tag_stack: impl IntoIterator<Item = &'b str>) {
+        let mut new_len = 0;
+        for (i, tag) in tag_stack.into_iter().enumerate() {
+            new_len = i + 1;
+            if i >= self.stack.len() {
+                self.stack.push(xml_tree::Element::new(tag.into(), []));
+            } else if self.stack[i].tag.normal() != Some(tag) {
+                self.shrink_stack(new_len);
+            }
+        }
+        self.shrink_stack(new_len);
+    }
+    fn write_text(&mut self, text: impl std::borrow::Borrow<str>) {
+        let text = std::borrow::Borrow::borrow(&text);
+        let insert_point = self.insert_point();
+        if let Some(child) = insert_point.children.last_mut() {
+            child.tail += text;
+        } else {
+            insert_point.text += text;
+        }
+    }
+    fn insert_point(&mut self) -> &mut xml_tree::Element {
+        self.stack.last_mut().unwrap_or(self.containing_element)
+    }
+    fn scope<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
+        let retval = f(self);
+        self.flush();
+        retval
+    }
+    fn flush(&mut self) {
+        self.set_tag_stack([]);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitField {
+    box_min_x: f32,
+    box_max_x: f32,
+    name: ParsedTextLine,
+    bit_number: ParsedTextLine,
+}
+
+impl fmt::Display for InsnBitField {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            box_min_x,
+            box_max_x,
+            name,
+            bit_number,
+        } = self;
+        write!(
+            f,
+            "<InsnBitField: x={box_min_x}..{box_max_x} name={name} bit_number={bit_number}>"
+        )
+    }
+}
+
+impl InsnBitField {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let field = parent.sub_element("field".into(), []);
+        field.text = "\n".into();
+        field.tail = "\n".into();
+        let name = field.sub_element("name".into(), []);
+        name.tail = "\n".into();
+        self.name.write_xml(name, false);
+        let bit_number = field.sub_element("bit-number".into(), []);
+        bit_number.tail = "\n".into();
+        self.bit_number.write_xml(bit_number, false);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitFieldsPrefix {
+    box_min_x: f32,
+    box_min_y: f32,
+    box_max_x: f32,
+    box_max_y: f32,
+    prefix_text: ParsedTextLine,
+    fields: Vec<InsnBitField>,
+    suffix_text: ParsedTextLine,
+}
+
+impl fmt::Display for InsnBitFieldsPrefix {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            prefix_text,
+            fields,
+            suffix_text,
+        } = self;
+        writeln!(
+            f,
+            "<InsnBitFieldsPrefix: ({box_min_x},{box_min_y})..({box_max_x},{box_max_y})"
+        )?;
+        writeln!(f, "    prefix_text={prefix_text}")?;
+        writeln!(f, "    [")?;
+        for field in fields {
+            writeln!(f, "        {field},")?;
+        }
+        writeln!(f, "    ]")?;
+        write!(f, "    suffix_text={suffix_text}>")
+    }
+}
+
+impl InsnBitFieldsPrefix {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let prefix_elm = parent.sub_element("prefix".into(), []);
+        prefix_elm.text = "\n".into();
+        prefix_elm.tail = "\n".into();
+        let prefix_text = prefix_elm.sub_element("prefix-text".into(), []);
+        prefix_text.tail = "\n".into();
+        self.prefix_text.write_xml(prefix_text, false);
+        InsnBitFields::write_xml_fields(&self.fields, prefix_elm);
+        let suffix_text = prefix_elm.sub_element("suffix-text".into(), []);
+        suffix_text.tail = "\n".into();
+        self.suffix_text.write_xml(suffix_text, false);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitFields {
+    prefix: Option<InsnBitFieldsPrefix>,
+    box_min_x: f32,
+    box_min_y: f32,
+    box_max_x: f32,
+    box_max_y: f32,
+    fields: Vec<InsnBitField>,
+}
+
+impl fmt::Display for InsnBitFields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            prefix,
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            fields,
+        } = self;
+        if let Some(prefix) = prefix {
+            prefix.fmt(f)?;
+        }
+        writeln!(
+            f,
+            "<InsnBitFields: ({box_min_x},{box_min_y})..({box_max_x},{box_max_y}) ["
+        )?;
+        for field in fields {
+            writeln!(f, "    {field},")?;
+        }
+        write!(f, "]>")
+    }
+}
+
+impl InsnBitFields {
+    fn write_xml_fields(
+        fields: impl IntoIterator<Item: std::borrow::Borrow<InsnBitField>>,
+        parent: &mut xml_tree::Element,
+    ) {
+        let fields_elm = parent.sub_element("fields".into(), []);
+        fields_elm.text = "\n".into();
+        fields_elm.tail = "\n".into();
+        for field in fields {
+            std::borrow::Borrow::borrow(&field).write_xml(fields_elm);
+        }
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let bit_fields = parent.sub_element("bit-fields".into(), []);
+        bit_fields.text = "\n".into();
+        bit_fields.tail = "\n".into();
+        if let Some(prefix) = &self.prefix {
+            prefix.write_xml(bit_fields);
+        }
+        Self::write_xml_fields(&self.fields, bit_fields)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnSpRegsAlteredEntry {
+    reg: ParsedTextLine,
+    fields: Vec<ParsedTextLine>,
+    conds: Vec<ParsedTextLine>,
+}
+
+impl InsnSpRegsAlteredEntry {
+    fn display_fmt_with_indent(&self, f: &mut fmt::Formatter<'_>, indent: &str) -> fmt::Result {
+        let Self { reg, fields, conds } = self;
+        writeln!(f, "Entry(")?;
+        writeln!(f, "{indent}    reg={reg},")?;
+        write!(f, "{indent}    fields=")?;
+        if fields.is_empty() {
+            write!(f, "()")?;
+        } else {
+            writeln!(f, "(")?;
+            for field in fields {
+                writeln!(f, "{indent}        {field},")?;
+            }
+            write!(f, "{indent}    )")?;
+        }
+        writeln!(f, ",")?;
+        writeln!(f, "{indent}    conds=")?;
+        if conds.is_empty() {
+            write!(f, "()")?;
+        } else {
+            writeln!(f, "(")?;
+            for cond in conds {
+                writeln!(f, "{indent}        {cond},")?;
+            }
+            write!(f, "{indent}    )")?;
+        }
+        writeln!(f, ",")?;
+        write!(f, "{indent})")
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let entry = parent.sub_element("entry".into(), []);
+        entry.text = "\n".into();
+        entry.tail = "\n".into();
+        let reg = entry.sub_element("register".into(), []);
+        reg.tail = "\n".into();
+        self.reg.write_xml(reg, false);
+        let fields = entry.sub_element("fields".into(), []);
+        fields.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.fields, fields, false, false);
+        let conds = entry.sub_element("conditions".into(), []);
+        conds.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.conds, conds, false, false);
+    }
+}
+
+impl fmt::Display for InsnSpRegsAlteredEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display_fmt_with_indent(f, "")
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnSpRegsAltered {
+    sp_regs_altered_text: ParsedTextLine,
+    special_text: Option<ParsedTextLine>,
+    table_header_reg: Option<ParsedTextLine>,
+    table_header_fields: Option<ParsedTextLine>,
+    entries: Vec<InsnSpRegsAlteredEntry>,
+    final_regular_min_y: f32,
+}
+
+impl fmt::Display for InsnSpRegsAltered {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            sp_regs_altered_text,
+            special_text,
+            table_header_reg,
+            table_header_fields,
+            entries,
+            final_regular_min_y,
+        } = self;
+        writeln!(f, "InsnSpRegsAltered(")?;
+        writeln!(f, "    sp_regs_altered_text={sp_regs_altered_text},")?;
+        if let Some(special_text) = special_text {
+            writeln!(f, "    special_text={special_text},")?;
+        }
+        if let Some(table_header_reg) = table_header_reg {
+            writeln!(f, "    table_header_reg={table_header_reg},")?;
+        }
+        if let Some(table_header_fields) = table_header_fields {
+            writeln!(f, "    table_header_fields={table_header_fields},")?;
+        }
+        if self.entries.is_empty() {
+            writeln!(f, "    entries=(),")?;
+        } else {
+            writeln!(f, "    entries=(")?;
+            for entry in entries {
+                write!(f, "        ")?;
+                entry.display_fmt_with_indent(f, "        ")?;
+                writeln!(f, ",")?;
+            }
+            writeln!(f, "    ),")?;
+        }
+        writeln!(f, "    final_regular_min_y={final_regular_min_y},")?;
+        write!(f, ")")
+    }
+}
+
+impl InsnSpRegsAltered {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let sp_regs_altered = parent.sub_element("special-registers-altered".into(), []);
+        sp_regs_altered.text = "\n".into();
+        sp_regs_altered.tail = "\n".into();
+        let title = sp_regs_altered.sub_element("title".into(), []);
+        title.tail = "\n".into();
+        self.sp_regs_altered_text.write_xml(title, false);
+        if let Some(special_text) = &self.special_text {
+            let special_text_el = sp_regs_altered.sub_element("special-text".into(), []);
+            special_text_el.tail = "\n".into();
+            special_text.write_xml(special_text_el, false);
+        }
+        if let Some(table_header_reg) = &self.table_header_reg {
+            let table_header_reg_el =
+                sp_regs_altered.sub_element("table-header-register".into(), []);
+            table_header_reg_el.tail = "\n".into();
+            table_header_reg.write_xml(table_header_reg_el, false);
+        }
+        if let Some(table_header_fields) = &self.table_header_fields {
+            let table_header_fields_el =
+                sp_regs_altered.sub_element("table-header-fields".into(), []);
+            table_header_fields_el.tail = "\n".into();
+            table_header_fields.write_xml(table_header_fields_el, false);
+        }
+        for entry in &self.entries {
+            entry.write_xml(sp_regs_altered);
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum InsnParseSection {
+    Code,
+    Header,
+    Desc,
+}
+
+#[derive(Clone, Debug)]
+enum PageItem {
+    Char(Char),
+    LineOrRect(LineOrRect),
+}
+
+#[derive(Copy, Clone, Debug)]
+enum LineOrRect {
+    Line(Line),
+    Rect(Rect),
+}
+
+impl LineOrRect {
+    fn width(self) -> f32 {
+        match self {
+            Self::Line(v) => v.width(),
+            Self::Rect(v) => v.width(),
+        }
+    }
+    fn height(self) -> f32 {
+        match self {
+            Self::Line(v) => v.height(),
+            Self::Rect(v) => v.height(),
+        }
+    }
+    fn min_x(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.min_x(),
+            Self::Rect(v) => v.min_x,
+        }
+    }
+    fn max_x(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.max_x(),
+            Self::Rect(v) => v.max_x,
+        }
+    }
+    fn min_y(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.min_y(),
+            Self::Rect(v) => v.min_y,
+        }
+    }
+    fn max_y(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.max_y(),
+            Self::Rect(v) => v.max_y,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+struct Line {
+    p0_x: NonNaNF32,
+    p0_y: NonNaNF32,
+    p1_x: NonNaNF32,
+    p1_y: NonNaNF32,
+}
+
+impl Line {
+    fn width(self) -> f32 {
+        f32::abs(self.p0_x.get() - self.p1_x.get())
+    }
+    fn height(self) -> f32 {
+        f32::abs(self.p0_y.get() - self.p1_y.get())
+    }
+    fn min_x(self) -> NonNaNF32 {
+        self.p0_x.min(self.p1_x)
+    }
+    fn max_x(self) -> NonNaNF32 {
+        self.p0_x.max(self.p1_x)
+    }
+    fn min_y(self) -> NonNaNF32 {
+        self.p0_y.min(self.p1_y)
+    }
+    fn max_y(self) -> NonNaNF32 {
+        self.p0_y.max(self.p1_y)
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+struct Rect {
+    min_x: NonNaNF32,
+    max_x: NonNaNF32,
+    min_y: NonNaNF32,
+    max_y: NonNaNF32,
+}
+
+impl Rect {
+    fn width(self) -> f32 {
+        self.max_x.get() - self.min_x.get()
+    }
+    fn height(self) -> f32 {
+        self.max_y.get() - self.min_y.get()
+    }
+}
+
+#[derive(Debug)]
+struct Page {
+    page_num: u32,
+    qt: BTreeMap<TextSection, QuadTree<PageItem>>,
+    unprocessed_chars:
+        Rc<RefCell<BTreeMap<TextSection, Rc<RefCell<BTreeMap<Font, IndexSet<Char>>>>>>>,
+    unprocessed_non_text: Rc<RefCell<IndexSet<LineOrRect>>>,
+}
+
+struct Pages<'ctx> {
+    pages_gen: Option<Box<dyn Iterator<Item = Result<Page, Error>> + 'ctx>>,
+    pages: BTreeMap<u32, Rc<Page>>,
+    max_page_num: u32,
+}
+
+impl<'ctx> fmt::Debug for Pages<'ctx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            pages_gen,
+            pages,
+            max_page_num,
+        } = self;
+        f.debug_struct("Pages")
+            .field(
+                "pages_gen",
+                &pages_gen.is_some().then_some(format_args!("...")),
+            )
+            .field("pages", pages)
+            .field("max_page_num", max_page_num)
+            .finish()
+    }
+}
+
+impl<'ctx> Pages<'ctx> {
+    fn new(pages_gen: Option<Box<dyn Iterator<Item = Result<Page, Error>> + 'ctx>>) -> Self {
+        Self {
+            pages_gen,
+            pages: BTreeMap::new(),
+            max_page_num: 0,
+        }
+    }
+    fn close(&mut self) {
+        self.pages_gen = None;
+    }
+    fn is_past_end(&mut self, page_num: u32) -> Result<bool, Error> {
+        while self.pages_gen.is_some() && page_num > self.max_page_num {
+            self.fill_page()?;
+        }
+        Ok(page_num > self.max_page_num)
+    }
+    fn fill_page(&mut self) -> Result<bool, Error> {
+        let Some(pages_gen) = &mut self.pages_gen else {
+            return Ok(false);
+        };
+        let page = pages_gen.next();
+        let Some(page) = page else {
+            self.close();
+            return Ok(false);
+        };
+        let page = page?;
+        let page_num = page.page_num;
+        assert!(
+            page_num > self.max_page_num,
+            "page numbers must be a strictly-increasing positive integer sequence:\n\
+            got {page_num} which isn't more than {}",
+            self.max_page_num
+        );
+        self.pages.insert(page_num, Rc::new(page));
+        self.max_page_num = page_num;
+        Ok(true)
+    }
+    fn get(&mut self, page_num: u32) -> Result<Option<Rc<Page>>, Error> {
+        loop {
+            if let Some(page) = self.pages.get(&page_num) {
+                return Ok(Some(page.clone()));
+            }
+            if self.pages_gen.is_none() {
+                return Ok(None);
+            }
+            if page_num < self.max_page_num {
+                return Ok(None);
+            }
+            self.fill_page()?;
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct TextSection {
+    page_num: u32,
+    min_x: NonNaNF32,
+    min_y: NonNaNF32,
+    max_x: NonNaNF32,
+    max_y: NonNaNF32,
+}
+
+struct TextSectionPagesData {
+    columns_then_full_page: BTreeMap<u32, f32>,
+    full_page_then_columns: BTreeMap<u32, f32>,
+    one_title_line_then_columns_then_full_page: BTreeMap<u32, f32>,
+    two_title_lines_then_columns_then_full_page: BTreeMap<u32, f32>,
+    columns_then_columns: BTreeMap<u32, f32>,
+    one_title_line_then_columns_then_columns: BTreeMap<u32, f32>,
+    one_title_line_then_columns: BTreeSet<u32>,
+    two_title_lines_then_columns: BTreeSet<u32>,
+    full_page: BTreeSet<u32>,
+}
+
+impl TextSectionPagesData {
+    fn get() -> &'static Self {
+        static DATA: OnceLock<TextSectionPagesData> = OnceLock::new();
+        DATA.get_or_init(|| Self {
+            columns_then_full_page: FromIterator::from_iter([
+                (129, 438.992),
+                (241, 512.419),
+                (242, 408.077),
+                (243, 488.509),
+                (244, 437.518),
+                (245, 444.522),
+                (247, 352.082),
+                (248, 356.723),
+                (249, 365.944),
+                (251, 334.553),
+                (264, 184.67),
+                (296, 267.29),
+                (297, 200.043),
+                (298, 440.64),
+                (299, 197.356),
+                (300, 160.076),
+                (301, 364.924),
+                (303, 330.055),
+                (305, 344.867),
+                (306, 335.403),
+                (307, 336.897),
+                (308, 365.233),
+                (309, 364.735),
+            ]),
+            full_page_then_columns: FromIterator::from_iter([
+                (246, 689.039),
+                (250, 615.315),
+                (266, 678.088),
+            ]),
+            one_title_line_then_columns_then_full_page: FromIterator::from_iter([(128, 301.55)]),
+            two_title_lines_then_columns_then_full_page: FromIterator::from_iter([(304, 242.732)]),
+            columns_then_columns: FromIterator::from_iter([(79, 621.66), (126, 519.89)]),
+            one_title_line_then_columns_then_columns: FromIterator::from_iter([
+                (130, 550.43),
+                (162, 599.247),
+                (194, 622.161),
+                (196, 682.933),
+                (204, 613.195),
+                (215, 633.12),
+            ]),
+            one_title_line_then_columns: FromIterator::from_iter([
+                103, 104, 105, 121, 139, 143, 146, 151, 153, 158, 207, 213, 218,
+            ]),
+            two_title_lines_then_columns: FromIterator::from_iter([198, 206]),
+            full_page: FromIterator::from_iter(
+                [
+                    118, 157, 252, 254, 255, 257, 259, 260, 265, 268, 270, 271, 272,
+                ]
+                .into_iter()
+                .chain(274..286),
+            ),
+        })
+    }
+}
+
+impl TextSection {
+    fn first() -> TextSection {
+        Self::page_sections(1)[0]
+    }
+
+    fn next(self) -> TextSection {
+        let page_sections = Self::page_sections(self.page_num);
+        let Some(index) = page_sections.iter().position(|v| *v == self) else {
+            panic!("not a known TextSection: {self:?}");
+        };
+        if let Some(&retval) = page_sections.get(index + 1) {
+            return retval;
+        }
+        for page_num in self.page_num + 1..self.page_num + 100000 {
+            let page_sections = Self::page_sections(page_num);
+            if let Some(&retval) = page_sections.get(0) {
+                return retval;
+            }
+        }
+        panic!("can't find next TextSection after {self:?}")
+    }
+
+    fn new(page_num: u32, min_x: f32, min_y: f32, max_x: f32, max_y: f32) -> Self {
+        Self {
+            page_num,
+            min_x: NonNaNF32::new(min_x).expect("invalid min_x"),
+            min_y: NonNaNF32::new(min_y).expect("invalid min_y"),
+            max_x: NonNaNF32::new(max_x).expect("invalid max_x"),
+            max_y: NonNaNF32::new(max_y).expect("invalid max_y"),
+        }
+    }
+
+    fn left_column(page_num: u32, min_y: f32, max_y: f32) -> TextSection {
+        Self::new(page_num, PAGE_BODY_MIN_X, min_y, COLUMN_SPLIT_X, max_y)
+    }
+
+    fn right_column(page_num: u32, min_y: f32, max_y: f32) -> TextSection {
+        Self::new(page_num, COLUMN_SPLIT_X, min_y, PAGE_BODY_MAX_X, max_y)
+    }
+
+    fn columns(page_num: u32, min_y: f32, max_y: f32) -> [TextSection; 2] {
+        [
+            Self::left_column(page_num, min_y, max_y),
+            Self::right_column(page_num, min_y, max_y),
+        ]
+    }
+
+    fn full_page(page_num: u32, min_y: f32, max_y: f32) -> TextSection {
+        Self::new(page_num, PAGE_BODY_MIN_X, min_y, PAGE_BODY_MAX_X, max_y)
+    }
+
+    fn page_sections_helper(page_num: u32) -> Box<[TextSection]> {
+        let TextSectionPagesData {
+            columns_then_full_page,
+            full_page_then_columns,
+            one_title_line_then_columns_then_full_page,
+            two_title_lines_then_columns_then_full_page,
+            columns_then_columns,
+            one_title_line_then_columns_then_columns,
+            one_title_line_then_columns,
+            two_title_lines_then_columns,
+            full_page,
+        } = TextSectionPagesData::get();
+        if let Some(split_y) = columns_then_columns.get(&page_num) {
+            return Box::from_iter(
+                Self::columns(page_num, *split_y, PAGE_BODY_MAX_Y)
+                    .into_iter()
+                    .chain(Self::columns(page_num, PAGE_BODY_MIN_Y, *split_y)),
+            );
+        }
+        if one_title_line_then_columns.contains(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(
+                    page_num,
+                    PAGE_BODY_MIN_Y,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                )),
+            );
+        }
+        if full_page.contains(&page_num) {
+            return Box::new([Self::full_page(page_num, PAGE_BODY_MIN_Y, PAGE_BODY_MAX_Y)]);
+        }
+        if let Some(split_y) = one_title_line_then_columns_then_columns.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(page_num, *split_y, ONE_TITLE_LINE_SPLIT_Y))
+                .chain(Self::columns(page_num, PAGE_BODY_MIN_Y, *split_y)),
+            );
+        }
+        if two_title_lines_then_columns.contains(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    TWO_TITLE_LINES_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(
+                    page_num,
+                    PAGE_BODY_MIN_Y,
+                    TWO_TITLE_LINES_SPLIT_Y,
+                )),
+            );
+        }
+        if let Some(split_y) = columns_then_full_page.get(&page_num) {
+            return Box::from_iter(
+                Self::columns(page_num, *split_y, PAGE_BODY_MAX_Y)
+                    .into_iter()
+                    .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, *split_y)]),
+            );
+        }
+        if let Some(split_y) = full_page_then_columns.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(page_num, *split_y, PAGE_BODY_MAX_Y)]
+                    .into_iter()
+                    .chain(Self::columns(page_num, PAGE_BODY_MIN_Y, *split_y)),
+            );
+        }
+        if let Some(split_y) = one_title_line_then_columns_then_full_page.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(page_num, *split_y, ONE_TITLE_LINE_SPLIT_Y))
+                .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, *split_y)]),
+            );
+        }
+        if let Some(split_y) = two_title_lines_then_columns_then_full_page.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    TWO_TITLE_LINES_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(page_num, *split_y, TWO_TITLE_LINES_SPLIT_Y))
+                .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, *split_y)]),
+            );
+        }
+        if page_num == 263 {
+            return Box::from_iter(
+                [Self::full_page(page_num, 699.997, PAGE_BODY_MAX_Y)]
+                    .into_iter()
+                    .chain(Self::columns(page_num, 366.396, 699.997))
+                    .chain(Self::columns(page_num, 207.0, 366.396))
+                    .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, 207.0)]),
+            );
+        }
+        // TODO: checked up to page 309 (page named 273)
+        Box::new(Self::columns(page_num, PAGE_BODY_MIN_Y, PAGE_BODY_MAX_Y))
+    }
+    fn page_sections(page_num: u32) -> &'static [TextSection] {
+        static CACHE: [OnceLock<Box<[TextSection]>>; 2000] = [const { OnceLock::new() }; _];
+        CACHE
+            .get(page_num as usize)
+            .expect("page_num out of range")
+            .get_or_init(|| Self::page_sections_helper(page_num))
+    }
+    fn for_position(page_num: u32, x: f32, y: f32) -> Option<Self> {
+        for &i in Self::page_sections(page_num) {
+            if i.min_x.get() <= x && x <= i.max_x.get() && i.min_y.get() <= y && y <= i.max_y.get()
+            {
+                return Some(i);
+            }
+        }
+        None
+    }
+}
+
+#[derive(Debug, Clone)]
+struct InsnHeader {
+    header_lines: Vec<ParsedTextLine>,
+    mnemonic_lines: Vec<ParsedTextLine>,
+    bit_fields: InsnBitFields,
+}
+
+impl InsnHeader {
+    fn min_y(&self) -> f32 {
+        self.bit_fields.box_min_y
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let header = parent.sub_element("header".into(), []);
+        header.text = "\n".into();
+        header.tail = "\n".into();
+        let title = header.sub_element("title".into(), []);
+        title.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.header_lines, title, false, false);
+        let mnemonics = header.sub_element("mnemonics".into(), []);
+        mnemonics.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.mnemonic_lines, mnemonics, false, false);
+        self.bit_fields.write_xml(header);
+    }
+}
+
+#[derive(Debug, Clone)]
+struct Insn {
+    headers: Vec<InsnHeader>,
+    code_lines: Vec<ParsedTextLine>,
+    desc_lines: Vec<ParsedTextLine>,
+    sp_regs_altered: Option<InsnSpRegsAltered>,
+}
+
+impl Insn {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let insn = parent.sub_element("instruction".into(), []);
+        insn.text = "\n".into();
+        insn.tail = "\n".into();
+        for header in &self.headers {
+            header.write_xml(insn);
+        }
+        if !self.code_lines.is_empty() {
+            let code = insn.sub_element("code".into(), []);
+            code.tail = "\n".into();
+            ParsedTextLine::write_xml_lines(&self.code_lines, code, false, false);
+        }
+        if !self.desc_lines.is_empty() {
+            let desc = insn.sub_element("description".into(), []);
+            desc.tail = "\n".into();
+            ParsedTextLine::write_xml_lines(&self.desc_lines, desc, false, false);
+        }
+        if let Some(sp_regs_altered) = &self.sp_regs_altered {
+            sp_regs_altered.write_xml(insn);
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Parser<'ctx> {
+    pages: Pages<'ctx>,
+    text_section: TextSection,
+    insns: Vec<Insn>,
+}
+
+#[derive(Debug)]
+struct Error(String, Backtrace);
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.0)?;
+        f.write_str("\n")?;
+        fmt::Display::fmt(&self.1, f)
+    }
+}
+
+trait IntoError: fmt::Display {}
+
+impl<T: IntoError> From<T> for Error {
+    fn from(value: T) -> Self {
+        Error(value.to_string(), Backtrace::capture())
+    }
+}
+
+impl IntoError for &'_ str {}
+impl IntoError for String {}
+impl IntoError for MuPdfError {}
+impl IntoError for std::ffi::NulError {}
+impl IntoError for std::num::ParseIntError {}
+impl IntoError for std::io::Error {}
+impl<T: fmt::Display> IntoError for ErrorWithNote<T> {}
+
+enum ExtractInsnsError {
+    InsnParseError(String, Backtrace),
+    PageParseError(String, Backtrace),
+    Other(Error),
+}
+
+impl fmt::Display for ExtractInsnsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let backtrace = match self {
+            ExtractInsnsError::InsnParseError(msg, backtrace) => {
+                writeln!(f, "instruction parse error: {msg}")?;
+                backtrace
+            }
+            ExtractInsnsError::PageParseError(msg, backtrace) => {
+                writeln!(f, "page parse error: {msg}")?;
+                backtrace
+            }
+            ExtractInsnsError::Other(e) => return fmt::Display::fmt(&e, f),
+        };
+        backtrace.fmt(f)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct ErrorWithNote<E> {
+    error: E,
+    note: String,
+}
+
+impl<E: fmt::Display> fmt::Display for ErrorWithNote<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self { error, note } = self;
+        fmt::Display::fmt(error, f)?;
+        write!(f, "\nnote: {note}")
+    }
+}
+
+impl<E: fmt::Display + fmt::Debug> std::error::Error for ErrorWithNote<E> {}
+
+impl<'ctx> Parser<'ctx> {
+    fn new() -> Self {
+        Self {
+            pages: Pages::new(None),
+            text_section: TextSection::first(),
+            insns: Vec::new(),
+        }
+    }
+    fn page(&mut self) -> Result<Rc<Page>, Error> {
+        Ok(self
+            .pages
+            .get(self.text_section.page_num)?
+            .ok_or("page_num is out of range")?)
+    }
+    fn unprocessed_chars(&mut self) -> Result<Rc<RefCell<BTreeMap<Font, IndexSet<Char>>>>, Error> {
+        Ok(self
+            .page()?
+            .unprocessed_chars
+            .borrow_mut()
+            .entry(self.text_section)
+            .or_default()
+            .clone())
+    }
+    fn pages_gen(
+        ctx: impl Into<mupdf_ffi::ContextRef<'ctx>>,
+        file: &str,
+        page_numbers: Option<Vec<NonZero<u32>>>,
+        dump_mupdf_page_xml: bool,
+    ) -> Result<Box<dyn Iterator<Item = Result<Page, Error>> + 'ctx>, Error> {
+        let ctx = ctx.into();
+        let page_indexes = page_numbers.map(|page_numbers| {
+            let mut retval = Vec::from_iter(page_numbers.into_iter().map(|v| v.get() as usize - 1));
+            retval.sort();
+            retval
+        });
+        let document = mupdf_ffi::Document::open(ctx, &std::ffi::CString::new(file)?)?;
+        let page_count = document.page_count()?;
+        let page_indexes = page_indexes.unwrap_or_else(|| (0..page_count).collect());
+        let mut first_seen_fonts = BTreeMap::new();
+        Ok(Box::new(page_indexes.into_iter().map(move |page_index| {
+            let page_num = page_index as u32 + 1;
+            println!("page {page_num}");
+            let page = document
+                .load_page(page_index)
+                .map_err(|e| format!("error reading pdf page {page_num}: {e}"))?;
+            Ok(
+                Page::from_mupdf_page(page_num, &page, &mut first_seen_fonts, dump_mupdf_page_xml)
+                    .map_err(|e| format!("error reading pdf page {page_num}: {e}"))?,
+            )
+        })))
+    }
+    fn parse_pdf<I: Iterator<Item = NonZero<u32>>>(
+        &mut self,
+        ctx: impl Into<mupdf_ffi::ContextRef<'ctx>>,
+        file: &str,
+        page_numbers: Option<I>,
+        dump_mupdf_page_xml: bool,
+    ) -> Result<(), Error> {
+        self.pages = Pages::new(Some(Self::pages_gen(
+            ctx,
+            file,
+            page_numbers.map(|v| v.into_iter().collect()),
+            dump_mupdf_page_xml,
+        )?));
+        self.text_section = TextSection::first();
+        loop {
+            self.text_section = self.text_section.next();
+            if self.pages.is_past_end(self.text_section.page_num)? {
+                return Ok(());
+            }
+            if self.pages.get(self.text_section.page_num)?.is_some() {
+                println!("section {:?}", self.text_section);
+                self.note_text_section(Self::parse_text_section)?;
+            }
+        }
+    }
+    fn note_text_section<E>(
+        &mut self,
+        f: impl FnOnce(&mut Self) -> Result<(), E>,
+    ) -> Result<(), ErrorWithNote<E>> {
+        let start_text_section = self.text_section;
+        match f(self) {
+            Ok(()) => Ok(()),
+            Err(error) => {
+                let note = if self.text_section == start_text_section {
+                    format!("text_section={:?}", self.text_section)
+                } else {
+                    format!(
+                        "start_text_section={start_text_section:?}\ntext_section={:?}",
+                        self.text_section
+                    )
+                };
+                Err(ErrorWithNote { error, note })
+            }
+        }
+    }
+    fn parse_text_section(&mut self) -> Result<(), ErrorWithNote<Error>> {
+        match self.note_text_section(Self::extract_insns) {
+            Ok(()) => Ok(()),
+            Err(
+                e @ ErrorWithNote {
+                    error:
+                        ExtractInsnsError::InsnParseError(..) | ExtractInsnsError::PageParseError(..),
+                    ..
+                },
+            ) => {
+                println!("{e}");
+                Ok(())
+            }
+            Err(ErrorWithNote {
+                error: ExtractInsnsError::Other(error),
+                note,
+            }) => Err(ErrorWithNote { error, note }),
+        }
+    }
+    fn find_top_left_char_in_range(
+        &mut self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        allow_processed: bool,
+    ) -> Result<Option<Char>, Error> {
+        let mut retval = None;
+        let page = self.page()?;
+        let unprocessed_chars = self.unprocessed_chars()?;
+        let ControlFlow::<Infallible>::Continue(()) =
+            page.qt[&self.text_section].range(min_x, max_x, min_y, max_y, |_x, _y, ch| {
+                let PageItem::Char(ch) = ch else {
+                    return ControlFlow::Continue(());
+                };
+                if !allow_processed && !RefCell::borrow(&*unprocessed_chars)[&ch.font].contains(ch)
+                {
+                    return ControlFlow::Continue(());
+                }
+                match &mut retval {
+                    None => retval = Some(ch.clone()),
+                    Some(retval)
+                        if ch.min_x.get() - ch.min_y.get()
+                            < retval.min_x.get() - retval.min_y.get() =>
+                    {
+                        *retval = ch.clone();
+                    }
+                    Some(_) => {}
+                }
+                ControlFlow::Continue(())
+            });
+        Ok(retval)
+    }
+    fn extract_text_line(
+        &mut self,
+        start_char: Option<Char>,
+        mut start_min_y: f32,
+        min_x: f32,
+        max_x: f32,
+        fonts: TextLineFonts,
+        preceding_blank_lines: u32,
+        mut skip_initial_spaces: bool,
+        allowed_start_min_y_error: Option<f32>,
+    ) -> Result<Option<ParsedTextLine>, ExtractInsnsError> {
+        let mut chars: Vec<Char> = Vec::new();
+        let mut chars_set: IndexSet<Char> = IndexSet::new();
+        if let Some(start_char) = start_char.clone() {
+            chars.push(start_char.clone());
+            chars_set.insert(start_char);
+        }
+        if let Some(start_char) = start_char
+            && start_char.text == "*"
+            && self.text_section.page_num == 168
+            && fonts
+                .subscript()
+                .is_some_and(|v| v.contains(&start_char.font))
+        {
+            start_min_y = start_char.max_y.get() - fonts.regular()[0].size();
+        }
+        let page = self.page().map_err(ExtractInsnsError::Other)?;
+        let unprocessed_chars = self.unprocessed_chars().map_err(ExtractInsnsError::Other)?;
+        let ControlFlow::<Infallible>::Continue(()) = page.qt[&self.text_section].range(
+            min_x - fonts.regular()[0].size() * 0.5,
+            max_x,
+            start_min_y - fonts.regular()[0].size() * 0.4,
+            start_min_y + fonts.regular()[0].size() * 0.6,
+            |_x, _y, ch| {
+                let PageItem::Char(ch) = ch else {
+                    return ControlFlow::Continue(());
+                };
+                if !RefCell::borrow(&*unprocessed_chars)[&ch.font].contains(ch)
+                    || chars_set.contains(ch)
+                {
+                    return ControlFlow::Continue(());
+                }
+                chars_set.insert(ch.clone());
+                chars.push(ch.clone());
+                ControlFlow::Continue(())
+            },
+        );
+        if chars.is_empty() {
+            return Ok(None);
+        }
+        chars.sort_by(|a, b| (a.min_x, &a.text).cmp(&(b.min_x, &b.text)));
+        let mut regular_min_y = chars[0].min_y.get();
+        let mut regular_max_y = chars[0].max_y.get();
+        for ch in &chars {
+            let Some(kind) = fonts.get_kind(ch.font.clone(), BaselinePos::Below) else {
+                continue;
+            };
+            if kind.sub_super() == FontVariantSubSuper::NotSubSuper {
+                regular_min_y = ch.min_y.get();
+                regular_max_y = ch.max_y.get();
+                break;
+            }
+        }
+        let mut retval = ParsedTextLine {
+            element: xml_tree::Element::new("text-line".into(), []),
+            regular_min_y,
+            regular_max_y,
+            fonts,
+            chars,
+            preceding_blank_lines,
+        };
+        let mut text_and_tag_stacks: Vec<(String, Vec<&str>)> = Vec::new();
+        let mut last_max_x = min_x;
+        let mut last_kind = None;
+        let mut last_char: Option<Char> = None;
+        for ch in &retval.chars {
+            let baseline_pos = if (ch.max_y.get() + ch.min_y.get()) * 0.5
+                > (retval.regular_max_y + retval.regular_min_y) * 0.5
+            {
+                BaselinePos::Above
+            } else {
+                BaselinePos::Below
+            };
+            let Some(kind) = fonts.get_kind(ch.font.clone(), baseline_pos) else {
+                println!(
+                    "font kind is None:\n\
+                    regular_min_y={}\n\
+                    fonts={fonts:?}\n\
+                    ch={ch:?}\n\
+                    baseline_pos={baseline_pos:?}\n\
+                    chars[0]={:?}",
+                    retval.regular_min_y, retval.chars[0],
+                );
+                return Ok(None);
+            };
+            let space_kind = match last_kind {
+                None => kind,
+                Some(last_kind) if last_kind != kind => TextLineFontKind::Regular,
+                _ => kind,
+            };
+            let (space_fonts, _) = fonts
+                .get_fonts(space_kind)
+                .unwrap_or((fonts.regular(), None));
+            let space_width = ch.min_x.get() - last_max_x;
+            let space_count_f = space_width / space_fonts[0].space_width();
+            let mut space_count = space_count_f.round() as usize;
+            if space_count == 0 && space_count_f > 0.35 {
+                space_count = 1
+            }
+            if space_count_f > 0.25 && f32::abs(space_count as f32 - space_count_f) > 0.15 {
+                println!("spaces: space_count_f={space_count_f} space_width={space_width}");
+            }
+            if space_count > 0 && !skip_initial_spaces {
+                text_and_tag_stacks.push((
+                    " ".repeat(space_count),
+                    space_kind.text_line_tags().collect(),
+                ));
+            }
+            skip_initial_spaces = false;
+            if ch.text == "\u{0338}"
+                && let Some(last_char) = last_char
+                && last_char.text == "="
+                && f32::abs(ch.min_x.get() - last_char.min_x.get()) < 0.01
+                && f32::abs(ch.min_y.get() - last_char.min_y.get()) < 0.01
+            {
+                *text_and_tag_stacks
+                    .last_mut()
+                    .expect("known to be non-empty") = ("\u{2260}".into(), Vec::new());
+                last_max_x = last_char.max_x.get();
+            } else {
+                let char_text = match &*ch.text {
+                    "\u{fb00}" => "ff",
+                    "\u{fb01}" => "fi",
+                    "\u{fb02}" => "fl",
+                    "\u{fb03}" => "ffi",
+                    "\u{fb04}" => "ffl",
+                    v => v,
+                };
+                if char_text.chars().skip(1).next().is_some() {
+                    dbg!(&ch);
+                }
+                text_and_tag_stacks.push((char_text.into(), kind.text_line_tags().collect()));
+                last_max_x = ch.max_x.get();
+            }
+            last_kind = Some(kind);
+            last_char = Some(ch.clone());
+        }
+        ElementBodyBuilder::scope(
+            &mut ElementBodyBuilder::new(&mut retval.element),
+            |body_builder| {
+                for (text, tag_stack) in text_and_tag_stacks {
+                    body_builder.set_tag_stack(tag_stack);
+                    body_builder.write_text(text)
+                }
+            },
+        );
+        for ch in &retval.chars {
+            RefCell::borrow_mut(&*unprocessed_chars)
+                .get_mut(&ch.font)
+                .expect("known to exist")
+                .shift_remove(ch);
+        }
+        let allowed_start_min_y_error = allowed_start_min_y_error.unwrap_or(0.01);
+        if f32::abs(start_min_y - retval.regular_min_y) > allowed_start_min_y_error {
+            return Err(ExtractInsnsError::PageParseError(
+                format!(
+                    "start_min_y={start_min_y} regular_min_y={}\n\
+                start_min_y error: {}\n\
+                allowed_start_min_y_error={allowed_start_min_y_error}",
+                    retval.regular_min_y,
+                    start_min_y - retval.regular_min_y,
+                ),
+                Backtrace::capture(),
+            ));
+        }
+        Ok(Some(retval))
+    }
+    fn extract_following_text_lines(
+        &mut self,
+        first_text_line: ParsedTextLine,
+        min_x: f32,
+        max_x: f32,
+        allowed_start_min_y_error: Option<f32>,
+    ) -> Result<Vec<ParsedTextLine>, ExtractInsnsError> {
+        let mut retval = Vec::new();
+        let fonts = first_text_line.fonts;
+        let mut line = Some(first_text_line);
+        while let Some(cur_line) = line {
+            let start_min_y = cur_line.regular_min_y - fonts.regular()[0].line_height();
+            retval.push(cur_line);
+            line = self.extract_text_line(
+                None,
+                start_min_y,
+                min_x,
+                max_x,
+                fonts,
+                0,
+                false,
+                allowed_start_min_y_error,
+            )?;
+        }
+        return Ok(retval);
+    }
+    fn extract_insn_bit_fields(
+        &mut self,
+        mnemonic_lines: &[ParsedTextLine],
+    ) -> Result<Option<InsnBitFields>, ExtractInsnsError> {
+        let mut found_non_affix_line = false;
+        let [.., last_mnemonic_line] = mnemonic_lines else {
+            unreachable!();
+        };
+        let expected_non_affix_line_y = last_mnemonic_line.regular_min_y
+            - if mnemonic_lines.len() > 1 {
+                INSN_BIT_FIELDS_TOP_PAD_HEIGHT2
+            } else {
+                INSN_BIT_FIELDS_TOP_PAD_HEIGHT
+            };
+        let page = self.page().map_err(ExtractInsnsError::Other)?;
+        let _ = page.qt[&self.text_section].range(
+            self.text_section.min_x.get() - 5.0,
+            self.text_section.max_x.get() + 5.0,
+            expected_non_affix_line_y - 5.0,
+            expected_non_affix_line_y + 5.0,
+            |_x, _y, line| {
+                let PageItem::LineOrRect(LineOrRect::Line(line)) = line else {
+                    return ControlFlow::Continue(());
+                };
+                if line.width() > line.height() {
+                    found_non_affix_line = true;
+                    return ControlFlow::Break(());
+                }
+                ControlFlow::Continue(())
+            },
+        );
+        if found_non_affix_line {
+            return self.extract_insn_bit_fields_box(expected_non_affix_line_y);
+        };
+        let prefix_text = self.extract_text_line(
+            None,
+            last_mnemonic_line.regular_min_y - INSN_BIT_FIELDS_PREFIX_TEXT_TOP_PAD_HEIGHT,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts,
+            0,
+            true,
+            Some(2.0),
+        )?;
+        let Some(prefix_text) = prefix_text else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn prefix bit fields title".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let prefix_text_str = prefix_text.element.inner_text();
+        if prefix_text_str != "Prefix:" {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!("insn prefix bit fields title is not as expected: {prefix_text_str:?}"),
+                Backtrace::capture(),
+            ));
+        }
+        let prefix_bit_fields = self.extract_insn_bit_fields_box(
+            prefix_text.regular_min_y - INSN_BIT_FIELDS_AFFIX_TEXT_TO_BOX_TOP_HEIGHT,
+        )?;
+        let Some(prefix_bit_fields) = prefix_bit_fields else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn prefix bit fields".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let suffix_text = self.extract_text_line(
+            None,
+            prefix_bit_fields.box_min_y - INSN_BIT_FIELDS_PREFIX_BOX_BOTTOM_TO_SUFFIX_TEXT_HEIGHT,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts,
+            0,
+            true,
+            Some(2.0),
+        )?;
+        let Some(suffix_text) = suffix_text else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn suffix bit fields title".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let suffix_text_str = suffix_text.element.inner_text();
+        if suffix_text_str != "Suffix:" {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!("insn suffix bit fields title is not as expected: {suffix_text_str:?}"),
+                Backtrace::capture(),
+            ));
+        }
+        let suffix_bit_fields = self.extract_insn_bit_fields_box(
+            suffix_text.regular_min_y - INSN_BIT_FIELDS_AFFIX_TEXT_TO_BOX_TOP_HEIGHT,
+        )?;
+        let Some(suffix_bit_fields) = suffix_bit_fields else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn suffix bit fields".into(),
+                Backtrace::capture(),
+            ));
+        };
+        return Ok(Some(InsnBitFields {
+            prefix: Some(InsnBitFieldsPrefix {
+                box_min_x: prefix_bit_fields.box_min_x,
+                box_min_y: prefix_bit_fields.box_min_y,
+                box_max_x: prefix_bit_fields.box_max_x,
+                box_max_y: prefix_bit_fields.box_max_y,
+                prefix_text: prefix_text,
+                fields: prefix_bit_fields.fields,
+                suffix_text: suffix_text,
+            }),
+            box_min_x: suffix_bit_fields.box_min_x,
+            box_min_y: suffix_bit_fields.box_min_y,
+            box_max_x: suffix_bit_fields.box_max_x,
+            box_max_y: suffix_bit_fields.box_max_y,
+            fields: suffix_bit_fields.fields,
+        }));
+    }
+    fn extract_insn_bit_fields_box(
+        &mut self,
+        expected_box_max_y: f32,
+    ) -> Result<Option<InsnBitFields>, ExtractInsnsError> {
+        let mut h_lines = Vec::new();
+        let mut v_lines = Vec::new();
+        let page = self.page().map_err(ExtractInsnsError::Other)?;
+        let ControlFlow::<Infallible>::Continue(()) = page.qt[&self.text_section].range(
+            self.text_section.min_x.get() - 5.0,
+            self.text_section.max_x.get() + 5.0,
+            expected_box_max_y - INSN_BIT_FIELDS_BOX_HEIGHT - 5.0,
+            expected_box_max_y + 5.0,
+            |_x, _y, line| {
+                let PageItem::LineOrRect(LineOrRect::Line(line)) = *line else {
+                    return ControlFlow::Continue(());
+                };
+                if line.width() > line.height() {
+                    h_lines.push(line);
+                } else {
+                    v_lines.push(line);
+                }
+                ControlFlow::Continue(())
+            },
+        );
+        h_lines.sort_by_key(|line| line.min_y());
+        v_lines.sort_by_key(|line| line.min_x());
+        for i in (0..v_lines.len().saturating_sub(1)).rev() {
+            if f32::abs(v_lines[i].min_x().get() - v_lines[i + 1].min_x().get()) < 0.5 {
+                v_lines.remove(i + 1); // remove duplicates
+            }
+        }
+        if h_lines.is_empty() && v_lines.is_empty() {
+            return Ok(None);
+        }
+        let [bottom_line, top_line] = &*h_lines else {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!(
+                    "instruction bit fields box has wrong number of horizontal lines:\n{h_lines:?}"
+                ),
+                Backtrace::capture(),
+            ));
+        };
+        let [leftmost_line, .., rightmost_line] = &*v_lines else {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!("instruction bit fields box has too few vertical lines:\n{v_lines:?}"),
+                Backtrace::capture(),
+            ));
+        };
+        let box_min_x = leftmost_line.min_x().get();
+        let box_max_x = rightmost_line.min_x().get();
+        let box_min_y = bottom_line.min_y().get();
+        let box_max_y = top_line.max_y().get();
+        let box_mid_y = (box_min_y + box_max_y) * 0.5;
+        println!("bottom_line={bottom_line:?}");
+        println!("top_line={top_line:?}");
+        println!("{v_lines:?}");
+        let mut fields = Vec::new();
+        for i in 0..v_lines.len() - 1 {
+            let left_line = v_lines[i];
+            let right_line = v_lines[i + 1];
+            let field_box_min_x = left_line.max_x().get();
+            let field_box_max_x = right_line.min_x().get();
+            let bit_field_name_start_min_y = box_mid_y + 3.288;
+            let bit_field_name = self.extract_text_line(
+                None,
+                bit_field_name_start_min_y,
+                field_box_min_x,
+                field_box_max_x,
+                TextLineFonts::InsnBitFieldNameFonts,
+                0,
+                true,
+                Some(0.4),
+            )?;
+            let Some(bit_field_name) = bit_field_name else {
+                return Err(ExtractInsnsError::InsnParseError(
+                    format!(
+                        "instruction bit field name not found:\n\
+                start_min_y={bit_field_name_start_min_y} \
+                    field_box_min_x={field_box_min_x} \
+                    field_box_max_x={field_box_max_x}"
+                    ),
+                    Backtrace::capture(),
+                ));
+            };
+            let bit_field_number_start_min_y = box_min_y + 3.487;
+            let bit_number = self.extract_text_line(
+                None,
+                bit_field_number_start_min_y,
+                field_box_min_x,
+                field_box_max_x,
+                TextLineFonts::InsnBitFieldBitNumberFonts,
+                0,
+                true,
+                None,
+            )?;
+            let Some(bit_number) = bit_number else {
+                return Err(ExtractInsnsError::InsnParseError(
+                    format!(
+                        "instruction bit field bit number not found:\n\
+                    start_min_y={bit_field_number_start_min_y} \
+                    field_box_min_x={field_box_min_x} \
+                    field_box_max_x={field_box_max_x}"
+                    ),
+                    Backtrace::capture(),
+                ));
+            };
+            fields.push(InsnBitField {
+                box_min_x: field_box_min_x,
+                box_max_x: field_box_max_x,
+                name: bit_field_name,
+                bit_number: bit_number,
+            });
+        }
+        return Ok(Some(InsnBitFields {
+            prefix: None,
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            fields,
+        }));
+    }
+    fn extract_insn_header_mnemonics_and_bit_fields(
+        &mut self,
+        start_min_y: f32,
+        header_start_char: Option<Char>,
+    ) -> Result<Option<InsnHeader>, ExtractInsnsError> {
+        assert!(
+            header_start_char
+                .as_ref()
+                .is_none_or(|v| v.font == Font::InsnHeader)
+        );
+        let Some(header_line) = self.extract_text_line(
+            header_start_char,
+            start_min_y,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnHeaderFonts,
+            0,
+            true,
+            Some(6.0),
+        )?
+        else {
+            return Ok(None);
+        };
+        println!("found header line:\n{header_line}");
+        let header_lines = self.extract_following_text_lines(
+            header_line,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            Some(1.5),
+        )?;
+        println!("insn header lines:");
+        for header_line in &header_lines {
+            println!("{header_line}");
+        }
+        let [.., last_header_line] = &*header_lines else {
+            unreachable!();
+        };
+        let Some(mnemonic_start_char) = self
+            .find_top_left_char_in_range(
+                self.text_section.min_x.get() - 5.0,
+                self.text_section.max_x.get() + 5.0,
+                last_header_line.regular_min_y - 50.0,
+                last_header_line.regular_min_y - 5.0,
+                false,
+            )
+            .map_err(ExtractInsnsError::Other)?
+        else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn mnemonic text line".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let mnemonic_start_char_min_y = mnemonic_start_char.min_y.get();
+        let Some(mnemonic_line) = self.extract_text_line(
+            Some(mnemonic_start_char),
+            mnemonic_start_char_min_y,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnMnemonicFonts,
+            0,
+            true,
+            None,
+        )?
+        else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn mnemonic text line".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let mnemonic_line_first_char_min_x = mnemonic_line.chars[0].min_x.get();
+        let mnemonic_lines = self.extract_following_text_lines(
+            mnemonic_line,
+            mnemonic_line_first_char_min_x,
+            self.text_section.max_x.get(),
+            None,
+        )?;
+        println!("insn mnemonic lines:");
+        for mnemonic_line in &mnemonic_lines {
+            println!("{mnemonic_line}");
+        }
+        let Some(insn_bit_fields) = self.extract_insn_bit_fields(&mnemonic_lines)? else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn bit fields".into(),
+                Backtrace::capture(),
+            ));
+        };
+        println!("{insn_bit_fields}");
+        return Ok(Some(InsnHeader {
+            header_lines,
+            mnemonic_lines,
+            bit_fields: insn_bit_fields,
+        }));
+    }
+    fn extract_insn_sp_regs_altered(
+        &mut self,
+        mut sp_regs_altered_text: ParsedTextLine,
+    ) -> Result<InsnSpRegsAltered, ExtractInsnsError> {
+        sp_regs_altered_text.preceding_blank_lines = 0;
+        let fonts = TextLineFonts::InsnDescFonts;
+        let column_min_x = sp_regs_altered_text.chars[0].min_x.get();
+        let Some(table_header_reg_char) = self
+            .find_top_left_char_in_range(
+                column_min_x - 1.0,
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_COLUMN_X - 1.0,
+                sp_regs_altered_text.regular_min_y - 30.0,
+                sp_regs_altered_text.regular_min_y - 5.0,
+                false,
+            )
+            .map_err(ExtractInsnsError::Other)?
+        else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find special registers altered table's register-column's header".into(),
+                Backtrace::capture(),
+            ));
+        };
+        const KNOWN_SPECIAL_TEXTS: &[&str] = &[
+            "None",
+            "Dependent on the system service",
+            "See above.",
+            "See Table 5.1",
+        ];
+        match &*table_header_reg_char.text {
+            "R" => {}
+            text if KNOWN_SPECIAL_TEXTS.iter().any(|i| text == &i[..1]) => {
+                let start_min_y = table_header_reg_char.min_y.get();
+                let special_text = self.extract_text_line(
+                    Some(table_header_reg_char),
+                    start_min_y,
+                    column_min_x,
+                    self.text_section.max_x.get(),
+                    fonts,
+                    0,
+                    true,
+                    None,
+                )?;
+                let special_text = match special_text {
+                    Some(special_text)
+                        if KNOWN_SPECIAL_TEXTS.contains(&&*special_text.element.text) =>
+                    {
+                        special_text
+                    }
+                    _ => return Err(ExtractInsnsError::Other(
+                        format!(
+                            "can't find special-registers-altered special-text:\n{special_text:?}"
+                        )
+                        .into(),
+                    )),
+                };
+                let final_regular_min_y = special_text.regular_min_y;
+                return Ok(InsnSpRegsAltered {
+                    sp_regs_altered_text,
+                    special_text: Some(special_text),
+                    table_header_reg: None,
+                    table_header_fields: None,
+                    entries: vec![],
+                    final_regular_min_y,
+                });
+            }
+            text => {
+                return Err(ExtractInsnsError::InsnParseError(
+                    format!(
+                        "unknown special-registers-altered special-text start character: {text:?}"
+                    ),
+                    Backtrace::capture(),
+                ));
+            }
+        }
+        let Some(table_header_fields_char) = self
+            .find_top_left_char_in_range(
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_COLUMN_X - 10.0,
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X,
+                table_header_reg_char.min_y.get() - 5.0,
+                table_header_reg_char.min_y.get() + 5.0,
+                false,
+            )
+            .map_err(ExtractInsnsError::Other)?
+        else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's fields-column's header".into(),
+            ));
+        };
+        if table_header_fields_char.text != "F" {
+            return Err(ExtractInsnsError::Other(
+                format!(
+                    "can't find special registers altered table's fields-column's header:\n\
+            table_header_fields_char={table_header_fields_char:?}"
+                )
+                .into(),
+            ));
+        }
+        let columns_x_bounds = [
+            (
+                table_header_reg_char.min_x.get(),
+                table_header_fields_char.min_x.get() - 1.0,
+            ),
+            (
+                table_header_fields_char.min_x.get(),
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X,
+            ),
+            (
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X,
+                self.text_section.max_x.get(),
+            ),
+        ];
+        let start_min_y = table_header_reg_char.min_y.get();
+        let Some(table_header_reg) = self.extract_text_line(
+            Some(table_header_reg_char),
+            start_min_y,
+            columns_x_bounds[0].0,
+            columns_x_bounds[0].1,
+            fonts,
+            0,
+            false,
+            None,
+        )?
+        else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's register-column's header".into(),
+            ));
+        };
+        let table_header_reg_text = table_header_reg.element.inner_text();
+        if table_header_reg_text != "Register" {
+            return Err(ExtractInsnsError::Other(
+                format!(
+                    "can't find special registers altered table's register-column's header:\n\
+            table_header_reg_text={table_header_reg_text:?}"
+                )
+                .into(),
+            ));
+        }
+        let start_min_y = table_header_fields_char.min_y.get();
+        let Some(table_header_fields) = self.extract_text_line(
+            Some(table_header_fields_char),
+            start_min_y,
+            columns_x_bounds[1].0,
+            columns_x_bounds[1].1,
+            fonts,
+            0,
+            false,
+            None,
+        )?
+        else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's fields-column's header".into(),
+            ));
+        };
+        let table_header_fields_text = table_header_fields.element.inner_text();
+        if table_header_fields_text != "Field(s)" {
+            return Err(ExtractInsnsError::Other(
+                format!(
+                    "can't find special registers altered table's fields-column's header:\n\
+                    table_header_fields_text={table_header_fields_text:?}"
+                )
+                .into(),
+            ));
+        }
+        let mut regular_min_y = table_header_reg.regular_min_y;
+        let mut entries = Vec::new();
+        let mut cur_reg = None;
+        let mut cur_fields = Vec::new();
+        let mut cur_conds = Vec::new();
+        loop {
+            let mut row = [None, None, None];
+            let mut next_regular_min_y = None;
+            for (i, (min_x, max_x)) in columns_x_bounds.into_iter().enumerate() {
+                row[i] = self.extract_text_line(
+                    None,
+                    regular_min_y - fonts.regular()[0].line_height(),
+                    min_x,
+                    max_x,
+                    fonts,
+                    0,
+                    true,
+                    Some(2.0),
+                )?;
+                if let Some(cell) = &row[i]
+                    && next_regular_min_y.is_none()
+                {
+                    next_regular_min_y = Some(cell.regular_min_y);
+                }
+            }
+            match next_regular_min_y {
+                Some(v) => regular_min_y = v,
+                None => break,
+            }
+            let [cur_reg_cell, cur_fields_cell, cur_conds_cell] = row;
+            if cur_reg_cell.is_none() {
+                if cur_reg.is_none() {
+                    return Err(ExtractInsnsError::Other(
+                        "can't find special registers altered table's first register".into(),
+                    ));
+                }
+                cur_fields.extend(cur_fields_cell);
+                cur_conds.extend(cur_conds_cell);
+                continue;
+            }
+            if let Some(cur_reg) = cur_reg {
+                entries.push(InsnSpRegsAlteredEntry {
+                    reg: cur_reg,
+                    fields: cur_fields,
+                    conds: cur_conds,
+                });
+                cur_fields = Vec::new();
+                cur_conds = Vec::new();
+            }
+            cur_reg = cur_reg_cell;
+            cur_fields.extend(cur_fields_cell);
+            cur_conds.extend(cur_conds_cell);
+        }
+        let Some(cur_reg) = cur_reg else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's first register".into(),
+            ));
+        };
+        entries.push(InsnSpRegsAlteredEntry {
+            reg: cur_reg,
+            fields: cur_fields,
+            conds: cur_conds,
+        });
+        return Ok(InsnSpRegsAltered {
+            sp_regs_altered_text: sp_regs_altered_text,
+            special_text: None,
+            table_header_reg: Some(table_header_reg),
+            table_header_fields: Some(table_header_fields),
+            entries,
+            final_regular_min_y: regular_min_y,
+        });
+    }
+    fn extract_insn(&mut self, header_start_char: Char) -> Result<Insn, ExtractInsnsError> {
+        assert_eq!(header_start_char.font, Font::InsnHeader);
+        println!("{header_start_char:?}");
+        let Some(header) = self.extract_insn_header_mnemonics_and_bit_fields(
+            header_start_char.min_y.get(),
+            Some(header_start_char),
+        )?
+        else {
+            return Err(ExtractInsnsError::PageParseError(
+                "can't find header text line".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let mut next_start_min_y = header.min_y() - 5.0;
+        let mut headers = vec![header];
+        let mut code_lines: Vec<ParsedTextLine> = Vec::new();
+        let mut desc_lines: Vec<ParsedTextLine> = Vec::new();
+        let mut sp_regs_altered = None;
+        loop {
+            let search_min_y = next_start_min_y - 70.0;
+            let Some(next_char) = self
+                .find_top_left_char_in_range(
+                    self.text_section.min_x.get() - 5.0,
+                    self.text_section.max_x.get() + 5.0,
+                    search_min_y.max(self.text_section.min_y.get()),
+                    next_start_min_y,
+                    false,
+                )
+                .map_err(ExtractInsnsError::Other)?
+            else {
+                if search_min_y <= self.text_section.min_y.get()
+                    && self
+                        .pages
+                        .get(self.text_section.next().page_num)
+                        .map_err(ExtractInsnsError::Other)?
+                        .is_some()
+                {
+                    // go to next section
+                    self.text_section = self.text_section.next();
+                    next_start_min_y = self.text_section.max_y.get();
+                    continue;
+                } else {
+                    return Err(ExtractInsnsError::InsnParseError(
+                        "can't find insn code or description text".into(),
+                        Backtrace::capture(),
+                    ));
+                }
+            };
+            let next_section = match &next_char.font {
+                font if TextLineFonts::InsnCodeFonts.fonts().contains(font) => {
+                    InsnParseSection::Code
+                }
+                font if TextLineFonts::InsnDescFonts.fonts().contains(font) => {
+                    InsnParseSection::Desc
+                }
+                Font::InsnHeader => InsnParseSection::Header,
+                font => {
+                    return Err(ExtractInsnsError::InsnParseError(
+                        format!("can't find insn code or description text\nfont={font:?}"),
+                        Backtrace::capture(),
+                    ));
+                }
+            };
+            match next_section {
+                InsnParseSection::Code => {
+                    if !desc_lines.is_empty() {
+                        break;
+                    }
+                    let start_min_y = next_char.min_y.get();
+                    let min_x = next_char.min_x.get();
+                    let Some(code_line) = self.extract_text_line(
+                        Some(next_char),
+                        start_min_y,
+                        min_x,
+                        self.text_section.max_x.get(),
+                        TextLineFonts::InsnCodeFonts,
+                        if code_lines.is_empty() { 0 } else { 1 },
+                        false,
+                        None,
+                    )?
+                    else {
+                        return Err(ExtractInsnsError::InsnParseError(
+                            "can't find insn code text line".into(),
+                            Backtrace::capture(),
+                        ));
+                    };
+                    let min_x = code_line.chars[0].min_x.get();
+                    let more_code_lines = self.extract_following_text_lines(
+                        code_line,
+                        min_x,
+                        self.text_section.max_x.get(),
+                        Some(0.05),
+                    )?;
+                    println!("more insn code lines:");
+                    for i in &more_code_lines {
+                        println!("{i}");
+                    }
+                    code_lines.extend(more_code_lines);
+                    let Some(last) = code_lines.last() else {
+                        unreachable!()
+                    };
+                    next_start_min_y = last.regular_min_y - 5.0;
+                }
+                InsnParseSection::Header => {
+                    if !(code_lines.is_empty() && desc_lines.is_empty()) {
+                        break;
+                    }
+                    let Some(header) = self.extract_insn_header_mnemonics_and_bit_fields(
+                        next_char.min_y.get(),
+                        Some(next_char),
+                    )?
+                    else {
+                        return Err(ExtractInsnsError::InsnParseError(
+                            "can't find header text line".into(),
+                            Backtrace::capture(),
+                        ));
+                    };
+                    next_start_min_y = header.min_y() - 5.0;
+                    headers.push(header);
+                }
+                InsnParseSection::Desc => {
+                    let start_min_y = next_char.min_y.get();
+                    let min_x = next_char.min_x.get();
+                    let Some(desc_line) = self.extract_text_line(
+                        Some(next_char),
+                        start_min_y,
+                        min_x,
+                        self.text_section.max_x.get(),
+                        TextLineFonts::InsnDescFonts,
+                        if desc_lines.is_empty() { 0 } else { 1 },
+                        false,
+                        Some(3.0),
+                    )?
+                    else {
+                        return Err(ExtractInsnsError::InsnParseError(
+                            "can't find insn desc text line".into(),
+                            Backtrace::capture(),
+                        ));
+                    };
+                    match desc_line.get_header_text() {
+                        None => {
+                            let min_x = desc_line.chars[0].min_x.get();
+                            let more_desc_lines = self.extract_following_text_lines(
+                                desc_line,
+                                min_x,
+                                self.text_section.max_x.get(),
+                                Some(3.5),
+                            )?;
+                            println!("more insn desc lines:");
+                            for i in &more_desc_lines {
+                                println!("{i}");
+                            }
+                            desc_lines.extend(more_desc_lines);
+                            next_start_min_y = desc_lines
+                                .last()
+                                .expect("known to be non-empty")
+                                .regular_min_y
+                                - 5.0;
+                        }
+                        Some(header_text) if header_text == "Special Registers Altered:" => {
+                            let new_sp_regs_altered =
+                                self.extract_insn_sp_regs_altered(desc_line)?;
+                            next_start_min_y = new_sp_regs_altered.final_regular_min_y;
+                            sp_regs_altered = Some(new_sp_regs_altered);
+                            break;
+                        }
+                        Some(header_text) => {
+                            return Err(ExtractInsnsError::Other(
+                                format!("unhandled header text: {header_text:?}\n{desc_line}")
+                                    .into(),
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+        println!("insn code lines:");
+        for i in &code_lines {
+            println!("{i}");
+        }
+        println!("insn desc lines:");
+        for i in &desc_lines {
+            println!("{i}");
+        }
+        println!("sp_regs_altered:");
+        println!("{sp_regs_altered:?}");
+        // TODO: finish
+        return Ok(Insn {
+            headers,
+            code_lines,
+            desc_lines,
+            sp_regs_altered,
+        });
+    }
+    fn extract_insns(&mut self) -> Result<(), ExtractInsnsError> {
+        loop {
+            let Some(header_start_char) =
+                RefCell::borrow(&*self.unprocessed_chars().map_err(ExtractInsnsError::Other)?)
+                    .get(&Font::InsnHeader)
+                    .and_then(|v| v.first().cloned())
+            else {
+                return Ok(());
+            };
+            let insn = self.extract_insn(header_start_char)?;
+            self.insns.push(insn);
+        }
+    }
+}
+
+#[derive(Debug)]
+struct MyDevice<'a> {
+    page_num: u32,
+    qt: RefCell<BTreeMap<TextSection, QuadTree<PageItem>>>,
+    unprocessed_chars:
+        Rc<RefCell<BTreeMap<TextSection, Rc<RefCell<BTreeMap<Font, IndexSet<Char>>>>>>>,
+    unprocessed_non_text: Rc<RefCell<IndexSet<LineOrRect>>>,
+    first_seen_fonts: RefCell<&'a mut BTreeMap<String, BTreeSet<NonNaNF32>>>,
+    error: RefCell<Result<(), Error>>,
+}
+
+impl<'a> MyDevice<'a> {
+    fn new(page_num: u32, first_seen_fonts: &'a mut BTreeMap<String, BTreeSet<NonNaNF32>>) -> Self {
+        Self {
+            page_num,
+            qt: Default::default(),
+            unprocessed_chars: Default::default(),
+            unprocessed_non_text: Default::default(),
+            first_seen_fonts: RefCell::new(first_seen_fonts),
+            error: RefCell::new(Ok(())),
+        }
+    }
+    fn path(&self, path: &mupdf_ffi::Path<'_>, ctm: fz_matrix) {
+        if self.error.borrow().is_err() {
+            return;
+        }
+        enum Walker {
+            Empty,
+            Moved { x: f32, y: f32 },
+            Line(Line),
+            Rect { x1: f32, y1: f32, x2: f32, y2: f32 },
+            NotRecognized,
+        }
+        fn new_line(p0_x: f32, p0_y: f32, p1_x: f32, p1_y: f32) -> Option<Line> {
+            Some(Line {
+                p0_x: NonNaNF32::new(p0_x)?,
+                p0_y: NonNaNF32::new(p0_y)?,
+                p1_x: NonNaNF32::new(p1_x)?,
+                p1_y: NonNaNF32::new(p1_y)?,
+            })
+        }
+        impl<'ctx> mupdf_ffi::PathWalker<'ctx> for Walker {
+            fn move_to(&mut self, _ctx: mupdf_ffi::ContextRef<'ctx>, x: f32, y: f32) {
+                *self = match *self {
+                    Walker::Empty | Walker::Moved { .. } => Walker::Moved { x, y },
+                    Walker::Line(_) | Walker::Rect { .. } | Walker::NotRecognized => {
+                        Walker::NotRecognized
+                    }
+                };
+            }
+            fn line_to(&mut self, _ctx: mupdf_ffi::ContextRef<'ctx>, x: f32, y: f32) {
+                *self = match *self {
+                    Walker::Empty => Walker::NotRecognized,
+                    Walker::Moved { x: p0_x, y: p0_y } => new_line(p0_x, p0_y, x, y)
+                        .map(Walker::Line)
+                        .unwrap_or(Walker::NotRecognized),
+                    Walker::Line(_) | Walker::Rect { .. } | Walker::NotRecognized => {
+                        Walker::NotRecognized
+                    }
+                };
+            }
+            fn curve_to(
+                &mut self,
+                _ctx: mupdf_ffi::ContextRef<'ctx>,
+                _cx1: f32,
+                _cy1: f32,
+                _cx2: f32,
+                _cy2: f32,
+                _ex: f32,
+                _ey: f32,
+            ) {
+                *self = Walker::NotRecognized;
+            }
+            fn close_path(&mut self, _ctx: mupdf_ffi::ContextRef<'ctx>) {}
+            fn rect_to(
+                &mut self,
+                _ctx: mupdf_ffi::ContextRef<'ctx>,
+                x1: f32,
+                y1: f32,
+                x2: f32,
+                y2: f32,
+            ) {
+                *self = match *self {
+                    Walker::Empty => Walker::Rect { x1, y1, x2, y2 },
+                    Walker::Moved { .. }
+                    | Walker::Line(..)
+                    | Walker::Rect { .. }
+                    | Walker::NotRecognized => Walker::NotRecognized,
+                };
+            }
+        }
+        let mut walker = Walker::Empty;
+        path.walk(&mut walker);
+        let component = match walker {
+            Walker::Empty | Walker::Moved { .. } | Walker::NotRecognized => return,
+            Walker::Line(Line {
+                p0_x,
+                p0_y,
+                p1_x,
+                p1_y,
+            }) => {
+                let mupdf_sys::fz_point { x: p0_x, y: p0_y } =
+                    mupdf_ffi::transform_point_xy(p0_x.get(), p0_y.get(), ctm);
+                let mupdf_sys::fz_point { x: p1_x, y: p1_y } =
+                    mupdf_ffi::transform_point_xy(p1_x.get(), p1_y.get(), ctm);
+                let Some(line) = new_line(p0_x, p0_y, p1_x, p1_y) else {
+                    return;
+                };
+                LineOrRect::Line(line)
+            }
+            Walker::Rect { x1, y1, x2, y2 } => {
+                let p1 = mupdf_ffi::transform_point_xy(x1, y1, ctm);
+                let p2 = mupdf_ffi::transform_point_xy(x2, y1, ctm);
+                let p3 = mupdf_ffi::transform_point_xy(x2, y2, ctm);
+                let p4 = mupdf_ffi::transform_point_xy(x1, y2, ctm);
+                let min_x = NonNaNF32::new(p1.x.min(p2.x).min(p3.x).min(p4.x));
+                let max_x = NonNaNF32::new(p1.x.max(p2.x).max(p3.x).max(p4.x));
+                let min_y = NonNaNF32::new(p1.y.min(p2.y).min(p3.y).min(p4.y));
+                let max_y = NonNaNF32::new(p1.y.max(p2.y).max(p3.y).max(p4.y));
+                let (Some(min_x), Some(max_x), Some(min_y), Some(max_y)) =
+                    (min_x, max_x, min_y, max_y)
+                else {
+                    return;
+                };
+                LineOrRect::Rect(Rect {
+                    min_x,
+                    max_x,
+                    min_y,
+                    max_y,
+                })
+            }
+        };
+        if component.width() > 100.0
+            && component.min_x().get() < COLUMN_SPLIT_X - 10.0
+            && component.max_x().get() > COLUMN_SPLIT_X + 10.0
+        {
+            println!("wide component: {component:?}");
+        } else {
+            println!("component: {component:?}");
+        }
+        let text_section = TextSection::for_position(
+            self.page_num,
+            (component.min_x().get() + component.max_x().get()) * 0.5,
+            (component.min_y().get() + component.max_y().get()) * 0.5,
+        );
+        if let Some(text_section) = text_section {
+            self.qt
+                .borrow_mut()
+                .entry(text_section)
+                .or_default()
+                .insert(
+                    component.min_x().get(),
+                    component.min_y().get(),
+                    PageItem::LineOrRect(component),
+                );
+        }
+    }
+    fn text(&self, text: &mupdf_ffi::Text<'_>, ctm: fz_matrix) {
+        if self.error.borrow().is_err() {
+            return;
+        }
+        let mut first_seen_fonts = self.first_seen_fonts.borrow_mut();
+        for span in text.spans() {
+            let tm = span.trm();
+            const ROUND_FACTOR: f32 = 1000.0;
+            let font_size = (mupdf_ffi::matrix_expansion(tm) * ROUND_FACTOR).round() / ROUND_FACTOR;
+            let Some(font_size) = NonNaNF32::new(font_size) else {
+                continue;
+            };
+            let font_name_with_tag = span.font().name();
+            let font_name_with_tag = match font_name_with_tag {
+                "CGMSHV+DejaVuSansCondensed-Obli" => "CGMSHV+DejaVuSansCondensed-Oblique",
+                "YDJYQV+DejaVuSansCondensed-Bold" => "YDJYQV+DejaVuSansCondensed-BoldOblique",
+                "NHUPPK+DejaVuSansCondensed-Bold" => "NHUPPK+DejaVuSansCondensed-Bold",
+                _ if font_name_with_tag.len() == 31 => {
+                    let _ = self.error.replace(Err(format!(
+                        "probably truncated font name: {font_name_with_tag:?}"
+                    )
+                    .into()));
+                    return;
+                }
+                _ => font_name_with_tag,
+            };
+            let mut flush_char = |char: Char| -> Result<(), ()> {
+                let Some(text_section) = TextSection::for_position(
+                    self.page_num,
+                    (char.min_x.get() + char.max_x.get()) * 0.5,
+                    (char.min_y.get() + char.max_y.get()) * 0.5,
+                ) else {
+                    if PAGE_BODY_MIN_Y <= char.min_y.get() && char.min_y.get() <= PAGE_BODY_MAX_Y {
+                        if self.page_num != 1072 {
+                            // page 1072 has characters in the margins
+                            let _ = self.error.replace(Err(format!(
+                                "char not in text section: {:?}\npage_num={}",
+                                char.text, self.page_num,
+                            )
+                            .into()));
+                            return Err(());
+                        }
+                    }
+                    return Ok(());
+                };
+                let set = match first_seen_fonts.get_mut(font_name_with_tag) {
+                    Some(v) => v,
+                    None => first_seen_fonts
+                        .entry(String::from(font_name_with_tag))
+                        .or_default(),
+                };
+                if set.insert(font_size) {
+                    println!(
+                        "first seen font: {font_name_with_tag:?} {font_size}: page {} {char:?}",
+                        self.page_num,
+                    );
+                }
+                self.qt
+                    .borrow_mut()
+                    .entry(text_section)
+                    .or_default()
+                    .insert(
+                        char.min_x.get(),
+                        char.min_y.get(),
+                        PageItem::Char(char.clone()),
+                    );
+                self.unprocessed_chars
+                    .borrow_mut()
+                    .entry(text_section)
+                    .or_default()
+                    .borrow_mut()
+                    .entry(char.font.clone())
+                    .or_default()
+                    .insert(char);
+                Ok(())
+            };
+            let mut last_char = None;
+            for &fz_text_item {
+                x,
+                y,
+                adv,
+                gid,
+                ucs,
+                cid: _,
+            } in span.items()
+            {
+                let adv = if gid >= 0 { adv } else { 0.0 };
+                let tm = fz_matrix { e: x, f: y, ..tm };
+                let trm = mupdf_ffi::concat(tm, ctm);
+                let dir = match span.write_mode() {
+                    WriteMode::Horizontal => fz_point { x: 1.0, y: 0.0 },
+                    WriteMode::Vertical => fz_point { x: 0.0, y: -1.0 },
+                };
+                let dir = mupdf_ffi::transform_vector(dir, trm);
+                let glyph_start;
+                let glyph_stop;
+                let mut glyph_ascender;
+                let glyph_descender;
+                match span.write_mode() {
+                    WriteMode::Horizontal => {
+                        glyph_start = fz_point { x: trm.e, y: trm.f };
+                        glyph_stop = fz_point {
+                            x: trm.e + adv * dir.x,
+                            y: trm.f + adv * dir.y,
+                        };
+                        glyph_ascender = fz_point {
+                            x: 0.0,
+                            y: span.font().ascender(),
+                        };
+                        glyph_descender = fz_point {
+                            x: 0.0,
+                            y: span.font().descender(),
+                        };
+                        if glyph_ascender.y == glyph_descender.y {
+                            glyph_ascender.y += 1.0;
+                        }
+                    }
+                    WriteMode::Vertical => {
+                        glyph_start = fz_point {
+                            x: trm.e - adv * dir.x,
+                            y: trm.f - adv * dir.y,
+                        };
+                        glyph_stop = fz_point { x: trm.e, y: trm.f };
+                        glyph_ascender = fz_point { x: 1.0, y: 0.0 };
+                        glyph_descender = fz_point { x: 0.0, y: 0.0 };
+                    }
+                };
+                let glyph_ascender = transform_vector(glyph_ascender, trm);
+                let glyph_descender = transform_vector(glyph_descender, trm);
+                let points = [
+                    add_points(glyph_start, glyph_descender),
+                    add_points(glyph_start, glyph_ascender),
+                    add_points(glyph_stop, glyph_descender),
+                    add_points(glyph_stop, glyph_ascender),
+                ];
+                let min = point_min_components(
+                    point_min_components(point_min_components(points[0], points[1]), points[2]),
+                    points[3],
+                );
+                let max = point_max_components(
+                    point_max_components(point_max_components(points[0], points[1]), points[2]),
+                    points[3],
+                );
+                let Some(ch) = u32::try_from(ucs).ok().and_then(|v| char::try_from(v).ok()) else {
+                    continue;
+                };
+                let text = String::from(ch);
+                if text.trim().is_empty() {
+                    continue;
+                }
+                let font = Font::known_from_name_with_tag(font_name_with_tag, font_size)
+                    .unwrap_or_else(|| Font::Other {
+                        font_name: font_name_with_tag.into(),
+                        size: font_size,
+                    });
+                let (Some(min_x), Some(min_y), Some(max_x), Some(max_y)) = (
+                    NonNaNF32::new(min.x),
+                    NonNaNF32::new(min.y),
+                    NonNaNF32::new(max.x),
+                    NonNaNF32::new(max.y),
+                ) else {
+                    let _ = self
+                        .error
+                        .replace(Err("char position shouldn't be NaN".into()));
+                    return;
+                };
+                if gid < 0
+                    && last_char
+                        .as_ref()
+                        .is_some_and(|last_char: &Char| last_char.font == font)
+                {
+                    if let Some(Char {
+                        font,
+                        text: last_text,
+                        min_x: last_min_x,
+                        min_y: last_min_y,
+                        max_x: last_max_x,
+                        max_y: last_max_y,
+                    }) = last_char.take()
+                    {
+                        last_char = Some(Char {
+                            font,
+                            text: last_text + &text,
+                            min_x: last_min_x.min(min_x),
+                            min_y: last_min_y.min(min_y),
+                            max_x: last_max_x.max(max_x),
+                            max_y: last_max_y.max(max_y),
+                        });
+                        continue;
+                    }
+                }
+                if let Some(last_char) = last_char.take() {
+                    match flush_char(last_char) {
+                        Ok(()) => {}
+                        Err(()) => return,
+                    }
+                }
+                last_char = Some(Char {
+                    font,
+                    text,
+                    min_x,
+                    min_y,
+                    max_x,
+                    max_y,
+                });
+            }
+            if let Some(last_char) = last_char {
+                match flush_char(last_char) {
+                    Ok(()) => {}
+                    Err(()) => return,
+                }
+            }
+        }
+    }
+}
+
+impl<'ctx> mupdf_ffi::DeviceCallbacks<'ctx> for MyDevice<'_> {
+    fn fill_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        _even_odd: bool,
+        ctm: fz_matrix,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn stroke_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn clip_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        _even_odd: bool,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn clip_stroke_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn fill_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn stroke_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn clip_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn clip_stroke_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn ignore_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.text(text, ctm);
+    }
+}
+
+#[derive(serde::Deserialize, Debug)]
+enum MuPdfXml<'a> {
+    #[serde(rename = "page")]
+    Page(MuPdfXmlPage<'a>),
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct MuPdfXmlPage<'a> {
+    #[serde(rename = "@id")]
+    id: Cow<'a, str>,
+    #[serde(rename = "@width")]
+    width: f32,
+    #[serde(rename = "@height")]
+    height: f32,
+    block: Vec<MuPdfXmlBlock<'a>>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct MuPdfXmlBlock<'a> {
+    #[serde(rename = "@bbox")]
+    bbox: [f32; 4],
+    #[serde(rename = "@justify")]
+    justify: Cow<'a, str>,
+    line: Vec<MuPdfXmlLine<'a>>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct MuPdfXmlLine<'a> {
+    #[serde(rename = "@bbox")]
+    bbox: [f32; 4],
+    #[serde(rename = "@wmode")]
+    wmode: u8,
+    #[serde(rename = "@dir")]
+    dir: [f32; 2],
+    #[serde(rename = "@text")]
+    text: Cow<'a, str>,
+    font: Vec<MuPdfXmlFont<'a>>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct MuPdfXmlFont<'a> {
+    #[serde(rename = "@name")]
+    name: Cow<'a, str>,
+    #[serde(rename = "@size")]
+    size: f32,
+    char: Vec<MuPdfXmlChar<'a>>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct MuPdfXmlChar<'a> {
+    #[serde(rename = "@quad")]
+    quad: [f32; 8],
+    #[serde(rename = "@x")]
+    x: f32,
+    #[serde(rename = "@y")]
+    y: f32,
+    #[serde(rename = "@bidi")]
+    bidi: u16,
+    #[serde(rename = "@color")]
+    color: Cow<'a, str>,
+    #[serde(rename = "@alpha")]
+    alpha: Cow<'a, str>,
+    #[serde(rename = "@flags")]
+    flags: u32,
+    #[serde(rename = "@c")]
+    c: Cow<'a, str>,
+}
+
+impl Page {
+    fn from_mupdf_page(
+        page_num: u32,
+        page: &mupdf_ffi::Page<'_>,
+        first_seen_fonts: &mut BTreeMap<String, BTreeSet<NonNaNF32>>,
+        dump_mupdf_page_xml: bool,
+    ) -> Result<Self, Error> {
+        if dump_mupdf_page_xml {
+            println!("{}", page.to_xml()?);
+        }
+        let Some(pdf_page) = page.pdf_page() else {
+            return Err("page is not from a pdf".into());
+        };
+        let device = mupdf_ffi::Device::new(
+            page.ctx(),
+            Box::new(MyDevice::new(page_num, first_seen_fonts)),
+        )?;
+        page.run(&device, pdf_page.transform()?)?;
+        let MyDevice {
+            page_num: _,
+            qt,
+            unprocessed_chars,
+            unprocessed_non_text,
+            first_seen_fonts: _,
+            error,
+        } = device.get();
+        error.replace(Ok(()))?;
+        for (text_section, i) in unprocessed_chars.borrow_mut().iter_mut() {
+            for chars in i.borrow_mut().values_mut() {
+                chars.sort_by_key(Char::top_down_left_to_right_sort_key);
+                println!("first char: {text_section:?}: {:?}", chars.first());
+            }
+        }
+        let mut unknown_fonts = Vec::new();
+        let mut unknown_font_errors = Vec::new();
+        for i in RefCell::borrow(&unprocessed_chars).values() {
+            for (font, chars) in RefCell::borrow(i).iter() {
+                if font.known_font_group().is_none() {
+                    let mut text = String::new();
+                    for char in chars {
+                        text += &char.text;
+                    }
+                    unknown_fonts.push(format!("{font:?},"));
+                    unknown_font_errors.push(format!(
+                        "unknown font {font:?}\nlast char: {:?}\ntext: {text:?}",
+                        chars.last()
+                    ));
+                }
+            }
+        }
+        unknown_fonts.sort();
+        if !unknown_fonts.is_empty() {
+            return Err(format!(
+                "\nunknown fonts:\n{}\n\n{}",
+                unknown_fonts.join("\n"),
+                unknown_font_errors.join("\n")
+            )
+            .into());
+        }
+        Ok(Self {
+            page_num,
+            qt: qt.take(),
+            unprocessed_chars: unprocessed_chars.clone(),
+            unprocessed_non_text: unprocessed_non_text.clone(),
+        })
+    }
+}
+
+fn main_inner() -> Result<(), Error> {
+    let mut args: Vec<String> = std::env::args().collect();
+    let dump_mupdf_page_xml = if args.get(1).is_some_and(|v| v == "--dump-mupdf-page-xml") {
+        args.remove(1);
+        true
+    } else {
+        false
+    };
+    let page_numbers: Option<Box<dyn Iterator<Item = NonZero<u32>>>> = if 2 < args.len() {
+        Some(if let Some((start, end)) = args[2].split_once(":") {
+            let start: NonZero<u32> = start.trim().parse()?;
+            let end: NonZero<u32> = end.trim().parse()?;
+            Box::new(
+                (start.get()..end.get()).map(|v| NonZero::new(v).expect("known to be non-zero")),
+            )
+        } else {
+            Box::new(
+                Result::<BTreeSet<NonZero<u32>>, _>::from_iter(
+                    args[2].split(",").map(|v| v.trim().parse()),
+                )?
+                .into_iter(),
+            )
+        })
+    } else {
+        None
+    };
+    mupdf_ffi::Context::with(|ctx| {
+        let mut parser = Parser::new();
+        let is_subset = page_numbers.is_some();
+        let file_name = &args[1];
+        parser.parse_pdf(ctx, file_name, page_numbers, dump_mupdf_page_xml)?;
+        let mut insns = xml_tree::Element::new(
+            "instructions".into(),
+            [(
+                "is-subset".into(),
+                if is_subset {
+                    "True".into()
+                } else {
+                    "False".into()
+                },
+            )],
+        );
+        insns.text = "\n".into();
+        insns.tail = "\n".into();
+        let mut comment =
+            xml_tree::Element::comment(format!(" Automatically generated from {file_name} "));
+        comment.tail = "\n".into();
+        insns.children.push(comment);
+        for insn in parser.insns {
+            insn.write_xml(&mut insns);
+        }
+        let mut output = Vec::new();
+        insns.write(&mut output, true)?;
+        std::fs::write("powerisa-instructions.xml", output)?;
+        Ok(())
+    })
+}
+
+fn main() -> std::process::ExitCode {
+    match main_inner() {
+        Ok(()) => std::process::ExitCode::SUCCESS,
+        Err(e) => {
+            println!("Error: {e}");
+            std::process::ExitCode::FAILURE
+        }
+    }
+}
diff --git a/src/mupdf_ffi.rs b/src/mupdf_ffi.rs
new file mode 100644
index 0000000..19d7564
--- /dev/null
+++ b/src/mupdf_ffi.rs
@@ -0,0 +1,866 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use mupdf_sys::{
+    fz_buffer, fz_buffer_storage, fz_clone_context, fz_color_params, fz_colorspace, fz_concat,
+    fz_context, fz_device, fz_document, fz_drop_buffer, fz_drop_context, fz_drop_device,
+    fz_drop_document, fz_drop_page, fz_drop_path, fz_drop_text, fz_error_type_FZ_ERROR_GENERIC,
+    fz_font, fz_font_ascender, fz_font_descender, fz_font_is_bold, fz_font_is_italic, fz_font_name,
+    fz_matrix, fz_matrix_expansion, fz_page, fz_path, fz_path_walker, fz_point, fz_rect,
+    fz_stroke_state, fz_text, fz_text_item, fz_text_span, fz_transform_point,
+    fz_transform_point_xy, fz_transform_vector, fz_walk_path, mupdf_document_page_count,
+    mupdf_drop_error, mupdf_error_t, mupdf_load_page, mupdf_new_base_context,
+    mupdf_new_derived_device, mupdf_open_document, mupdf_page_to_xml, mupdf_pdf_page_transform,
+    mupdf_run_page, pdf_page, pdf_page_from_fz_page,
+};
+use std::{
+    cell::{Cell, UnsafeCell},
+    ffi::{CStr, c_int, c_void},
+    fmt,
+    marker::PhantomData,
+    mem::ManuallyDrop,
+    ptr::{self, NonNull},
+    sync::{Mutex, OnceLock},
+};
+
+#[derive(Debug)]
+pub(crate) struct MuPdfError {
+    type_: c_int,
+    message: String,
+}
+
+impl MuPdfError {
+    fn new_generic(message: impl ToString) -> Self {
+        Self {
+            type_: fz_error_type_FZ_ERROR_GENERIC as _,
+            message: message.to_string(),
+        }
+    }
+}
+
+impl fmt::Display for MuPdfError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "MuPDF error: type: {}, message: {}",
+            self.type_, self.message
+        )
+    }
+}
+
+impl std::error::Error for MuPdfError {}
+
+struct OwnedMuPdfError(NonNull<mupdf_error_t>);
+
+impl Drop for OwnedMuPdfError {
+    fn drop(&mut self) {
+        unsafe {
+            mupdf_drop_error(self.0.as_ptr());
+        }
+    }
+}
+
+unsafe fn mupdf_try<R>(f: impl FnOnce(&mut *mut mupdf_error_t) -> R) -> Result<R, MuPdfError> {
+    let mut err = ptr::null_mut();
+    let retval = f(&mut err);
+    let Some(err) = NonNull::new(err).map(OwnedMuPdfError) else {
+        return Ok(retval);
+    };
+    unsafe {
+        Err(MuPdfError {
+            type_: (*err.0.as_ptr()).type_,
+            message: CStr::from_ptr((*err.0.as_ptr()).message)
+                .to_string_lossy()
+                .into_owned(),
+        })
+    }
+}
+
+pub(crate) struct Context(NonNull<fz_context>);
+
+impl Context {
+    fn new() -> Self {
+        struct BaseContext(NonNull<fz_context>);
+        unsafe impl Send for BaseContext {}
+        static CTX: OnceLock<Mutex<BaseContext>> = OnceLock::new();
+        let base = CTX
+            .get_or_init(|| {
+                let ctx = unsafe { mupdf_new_base_context() };
+                let Some(ctx) = NonNull::new(ctx).map(BaseContext) else {
+                    panic!("failed to allocate a MuPDF context");
+                };
+                Mutex::new(ctx)
+            })
+            .lock()
+            .expect("not poisoned");
+        let ctx = unsafe { fz_clone_context(base.0.as_ptr()) };
+        let Some(ctx) = NonNull::new(ctx).map(Self) else {
+            drop(base);
+            panic!("failed to clone a MuPDF context");
+        };
+        ctx
+    }
+    pub(crate) fn with<R>(f: impl FnOnce(&Self) -> R) -> R {
+        thread_local! {
+            static CTX: Context = Context::new();
+        }
+        CTX.with(f)
+    }
+    pub(crate) fn as_ref(&self) -> ContextRef<'_> {
+        unsafe { ContextRef::from_ptr(self.0.as_ptr()) }
+    }
+}
+
+impl Drop for Context {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_context(self.0.as_ptr());
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct ContextRef<'ctx>(&'ctx UnsafeCell<fz_context>);
+
+impl<'ctx> ContextRef<'ctx> {
+    unsafe fn from_ptr(ptr: *mut fz_context) -> Self {
+        Self(unsafe { &*ptr.cast() })
+    }
+}
+
+impl<'ctx> From<&'ctx Context> for ContextRef<'ctx> {
+    fn from(value: &'ctx Context) -> Self {
+        value.as_ref()
+    }
+}
+
+pub(crate) struct Document<'ctx> {
+    ptr: *mut fz_document,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Document<'ctx> {
+    pub(crate) fn open(
+        ctx: impl Into<ContextRef<'ctx>>,
+        file_name: &CStr,
+    ) -> Result<Document<'ctx>, MuPdfError> {
+        let ctx = ctx.into();
+        unsafe {
+            mupdf_try(|errptr| mupdf_open_document(ctx.0.get(), file_name.as_ptr(), errptr))
+                .map(|ptr| Document { ptr, ctx })
+        }
+    }
+    pub(crate) fn page_count(&self) -> Result<usize, MuPdfError> {
+        unsafe {
+            mupdf_try(|errptr| mupdf_document_page_count(self.ctx.0.get(), self.ptr, errptr))?
+                .try_into()
+                .map_err(MuPdfError::new_generic)
+        }
+    }
+    pub(crate) fn load_page(&self, page: usize) -> Result<Page<'ctx>, MuPdfError> {
+        let page = page.try_into().map_err(MuPdfError::new_generic)?;
+        unsafe {
+            mupdf_try(|errptr| mupdf_load_page(self.ctx.0.get(), self.ptr, page, errptr))
+                .map(|ptr| Page { ptr, ctx: self.ctx })
+        }
+    }
+}
+
+impl<'ctx> Drop for Document<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_document(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+struct Buffer<'ctx> {
+    ptr: *mut fz_buffer,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Buffer<'ctx> {
+    fn storage(&mut self) -> &mut [u8] {
+        unsafe {
+            let mut ptr = ptr::null_mut();
+            let len = fz_buffer_storage(self.ctx.0.get(), self.ptr, &raw mut ptr);
+            if len == 0 {
+                &mut []
+            } else {
+                std::slice::from_raw_parts_mut(ptr, len)
+            }
+        }
+    }
+}
+
+impl<'ctx> Drop for Buffer<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_buffer(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+pub(crate) struct Page<'ctx> {
+    ptr: *mut fz_page,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Page<'ctx> {
+    pub(crate) fn ctx(&self) -> ContextRef<'ctx> {
+        self.ctx
+    }
+    pub(crate) fn run<T>(
+        &self,
+        device: &Device<'ctx, T>,
+        ctm: fz_matrix,
+    ) -> Result<(), MuPdfError> {
+        unsafe {
+            mupdf_try(|errptr| {
+                mupdf_run_page(
+                    self.ctx.0.get(),
+                    self.ptr,
+                    device.dev,
+                    ctm,
+                    ptr::null_mut(),
+                    errptr,
+                )
+            })
+        }
+    }
+    pub(crate) fn to_xml(&self) -> Result<String, MuPdfError> {
+        unsafe {
+            let mut buffer =
+                mupdf_try(|errptr| mupdf_page_to_xml(self.ctx.0.get(), self.ptr, errptr))
+                    .map(|ptr| Buffer { ptr, ctx: self.ctx })?;
+            Ok(str::from_utf8(buffer.storage())
+                .map_err(MuPdfError::new_generic)?
+                .into())
+        }
+    }
+    pub(crate) fn pdf_page<'a>(&'a self) -> Option<PdfPageRef<'a, 'ctx>> {
+        unsafe {
+            let ptr = pdf_page_from_fz_page(self.ctx.0.get(), self.ptr);
+            NonNull::new(ptr).map(|ptr| PdfPageRef {
+                ptr: &*ptr.as_ptr().cast(),
+                ctx: self.ctx,
+            })
+        }
+    }
+}
+
+impl<'ctx> Drop for Page<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_page(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct PdfPageRef<'a, 'ctx> {
+    ptr: &'a UnsafeCell<pdf_page>,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'a, 'ctx> PdfPageRef<'a, 'ctx> {
+    pub(crate) fn transform(self) -> Result<fz_matrix, MuPdfError> {
+        unsafe {
+            mupdf_try(|errptr| mupdf_pdf_page_transform(self.ctx.0.get(), self.ptr.get(), errptr))
+        }
+    }
+}
+
+pub(crate) struct Device<'ctx, T: 'ctx> {
+    dev: *mut fz_device,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<Box<Cell<T>>>,
+}
+
+pub(crate) trait DeviceCallbacks<'ctx> {
+    fn fill_path(&self, ctx: ContextRef<'ctx>, path: &Path<'ctx>, even_odd: bool, ctm: fz_matrix);
+    fn stroke_path(&self, ctx: ContextRef<'ctx>, path: &Path<'ctx>, ctm: fz_matrix);
+    fn clip_path(
+        &self,
+        ctx: ContextRef<'ctx>,
+        path: &Path<'ctx>,
+        even_odd: bool,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    );
+    fn clip_stroke_path(
+        &self,
+        ctx: ContextRef<'ctx>,
+        path: &Path<'ctx>,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    );
+    fn fill_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix);
+    fn stroke_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix);
+    fn clip_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix, scissor: fz_rect);
+    fn clip_stroke_text(
+        &self,
+        ctx: ContextRef<'ctx>,
+        text: &Text<'ctx>,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    );
+    fn ignore_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix);
+}
+
+impl<'ctx, T: DeviceCallbacks<'ctx>> Device<'ctx, T> {
+    pub(crate) fn new(ctx: impl Into<ContextRef<'ctx>>, value: Box<T>) -> Result<Self, MuPdfError> {
+        let ctx = ctx.into();
+        unsafe {
+            let dev_ptr = mupdf_try(|errptr| {
+                mupdf_new_derived_device::<DeviceStruct<T>>(
+                    ctx.0.get(),
+                    c"parse_powerisa_pdf::mupdf_ffi::Device",
+                    errptr,
+                )
+            })?;
+            let retval = Device {
+                dev: dev_ptr.cast(),
+                ctx,
+                _phantom: PhantomData,
+            };
+            (&raw mut (*dev_ptr).value).write(value);
+            let fz_device {
+                drop_device,
+                fill_path,
+                stroke_path,
+                clip_path,
+                clip_stroke_path,
+                fill_text,
+                stroke_text,
+                clip_text,
+                clip_stroke_text,
+                ignore_text,
+                ..
+            } = &mut (*dev_ptr).base;
+            *drop_device = Some(Self::drop_device_fn);
+            *fill_path = Some(Self::fill_path_fn);
+            *stroke_path = Some(Self::stroke_path_fn);
+            *clip_path = Some(Self::clip_path_fn);
+            *clip_stroke_path = Some(Self::clip_stroke_path_fn);
+            *fill_text = Some(Self::fill_text_fn);
+            *stroke_text = Some(Self::stroke_text_fn);
+            *clip_text = Some(Self::clip_text_fn);
+            *clip_stroke_text = Some(Self::clip_stroke_text_fn);
+            *ignore_text = Some(Self::ignore_text_fn);
+            Ok(retval)
+        }
+    }
+    pub(crate) fn get(&self) -> &T {
+        unsafe { &(*self.dev.cast::<DeviceStruct<T>>()).value }
+    }
+    unsafe extern "C" fn drop_device_fn(_ctx: *mut fz_context, dev: *mut fz_device) {
+        unsafe {
+            (&raw mut (*dev.cast::<DeviceStruct<T>>()).value).drop_in_place();
+        }
+    }
+    unsafe extern "C" fn fill_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        even_odd: c_int,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.fill_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            even_odd != 0,
+            ctm,
+        );
+    }
+    unsafe extern "C" fn stroke_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.stroke_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+    unsafe extern "C" fn clip_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        even_odd: ::std::os::raw::c_int,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            even_odd != 0,
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn clip_stroke_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_stroke_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn fill_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.fill_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+    unsafe extern "C" fn stroke_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.stroke_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+    unsafe extern "C" fn clip_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn clip_stroke_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_stroke_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn ignore_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        ctm: fz_matrix,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.ignore_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+}
+
+impl<'ctx, T> Drop for Device<'ctx, T> {
+    fn drop(&mut self) {
+        unsafe {
+            // FIXME: fz_close_device may throw exceptions
+            // fz_close_device(self.ctx.0.get(), self.dev);
+            fz_drop_device(self.ctx.0.get(), self.dev);
+        }
+    }
+}
+
+#[repr(C)]
+struct DeviceStruct<T> {
+    base: fz_device,
+    value: Box<T>,
+}
+
+pub(crate) trait PathWalker<'ctx> {
+    fn move_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32);
+    fn line_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32);
+    fn curve_to(
+        &mut self,
+        ctx: ContextRef<'ctx>,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    );
+    fn close_path(&mut self, ctx: ContextRef<'ctx>);
+    fn rect_to(&mut self, ctx: ContextRef<'ctx>, x1: f32, y1: f32, x2: f32, y2: f32) {
+        self.move_to(ctx, x1, y1);
+        self.move_to(ctx, x2, y1);
+        self.move_to(ctx, x2, y2);
+        self.move_to(ctx, x1, y2);
+        self.close_path(ctx);
+    }
+}
+
+impl<'ctx, T: ?Sized + PathWalker<'ctx>> PathWalker<'ctx> for &'_ mut T {
+    fn move_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32) {
+        T::move_to(self, ctx, x, y);
+    }
+
+    fn line_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32) {
+        T::line_to(self, ctx, x, y);
+    }
+
+    fn curve_to(
+        &mut self,
+        ctx: ContextRef<'ctx>,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    ) {
+        T::curve_to(self, ctx, x1, y1, x2, y2, x3, y3);
+    }
+
+    fn close_path(&mut self, ctx: ContextRef<'ctx>) {
+        T::close_path(self, ctx);
+    }
+
+    fn rect_to(&mut self, ctx: ContextRef<'ctx>, x1: f32, y1: f32, x2: f32, y2: f32) {
+        T::rect_to(self, ctx, x1, y1, x2, y2);
+    }
+}
+
+pub(crate) struct Path<'ctx> {
+    ptr: *mut fz_path,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Path<'ctx> {
+    pub(crate) fn walk<W: PathWalker<'ctx>>(&self, mut walker: W) {
+        unsafe {
+            fz_walk_path(
+                self.ctx.0.get(),
+                self.ptr,
+                const {
+                    &fz_path_walker {
+                        moveto: Some(Self::move_to_fn::<W>),
+                        lineto: Some(Self::line_to_fn::<W>),
+                        curveto: Some(Self::curve_to_fn::<W>),
+                        closepath: Some(Self::close_path_fn::<W>),
+                        quadto: None,
+                        curvetov: None,
+                        curvetoy: None,
+                        rectto: Some(Self::rect_to_fn::<W>),
+                    }
+                },
+                (&raw mut walker).cast(),
+            );
+        }
+    }
+    unsafe extern "C" fn move_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x: f32,
+        y: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.move_to(ctx, x, y);
+    }
+    unsafe extern "C" fn line_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x: f32,
+        y: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.line_to(ctx, x, y);
+    }
+    unsafe extern "C" fn curve_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.curve_to(ctx, x1, y1, x2, y2, x3, y3);
+    }
+    unsafe extern "C" fn close_path_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.close_path(ctx);
+    }
+    unsafe extern "C" fn rect_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.rect_to(ctx, x1, y1, x2, y2);
+    }
+}
+
+impl<'ctx> Drop for Path<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_path(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+pub(crate) struct Text<'ctx> {
+    ptr: *mut fz_text,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Drop for Text<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_text(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+impl<'ctx> Text<'ctx> {
+    pub(crate) fn spans<'a>(&'a self) -> TextSpanIter<'a, 'ctx> {
+        TextSpanIter {
+            ptr: unsafe { NonNull::new((*self.ptr).head).map(|ptr| &*ptr.as_ptr().cast()) },
+            ctx: self.ctx,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct TextSpanIter<'a, 'ctx> {
+    ptr: Option<&'a UnsafeCell<fz_text_span>>,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<&'a Text<'ctx>>,
+}
+
+impl<'a, 'ctx> Iterator for TextSpanIter<'a, 'ctx> {
+    type Item = TextSpanRef<'a, 'ctx>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ptr = self.ptr?;
+        self.ptr = unsafe { NonNull::new((*ptr.get()).next).map(|ptr| &*ptr.as_ptr().cast()) };
+        Some(TextSpanRef {
+            ptr,
+            ctx: self.ctx,
+            _phantom: PhantomData,
+        })
+    }
+}
+
+#[derive(Copy, Clone)]
+pub(crate) struct TextSpanRef<'a, 'ctx> {
+    ptr: &'a UnsafeCell<fz_text_span>,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<&'a Text<'ctx>>,
+}
+
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+pub(crate) enum WriteMode {
+    Horizontal,
+    Vertical,
+}
+
+impl<'a, 'ctx> TextSpanRef<'a, 'ctx> {
+    pub(crate) fn get(self) -> &'a UnsafeCell<fz_text_span> {
+        self.ptr
+    }
+    pub(crate) fn font(self) -> FontRef<'a, 'ctx> {
+        FontRef {
+            ptr: unsafe { &*(*self.ptr.get()).font.cast::<UnsafeCell<fz_font>>() },
+            ctx: self.ctx,
+            _phantom: PhantomData,
+        }
+    }
+    pub(crate) fn trm(self) -> fz_matrix {
+        unsafe { (*self.ptr.get()).trm }
+    }
+    pub(crate) fn write_mode(self) -> WriteMode {
+        if unsafe { (*self.ptr.get()).wmode() != 0 } {
+            WriteMode::Vertical
+        } else {
+            WriteMode::Horizontal
+        }
+    }
+    pub(crate) fn items(self) -> &'a [fz_text_item] {
+        let len = unsafe { (*self.ptr.get()).len } as usize;
+        if len == 0 {
+            return &[];
+        }
+        unsafe { std::slice::from_raw_parts((*self.ptr.get()).items, len) }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct FontRef<'a, 'ctx> {
+    ptr: &'a UnsafeCell<fz_font>,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<&'a Text<'ctx>>,
+}
+
+impl<'a, 'ctx> FontRef<'a, 'ctx> {
+    pub(crate) fn get(self) -> &'a UnsafeCell<fz_font> {
+        self.ptr
+    }
+    pub(crate) fn name(self) -> &'a str {
+        unsafe { CStr::from_ptr(fz_font_name(self.ctx.0.get(), self.ptr.get())) }
+            .to_str()
+            .expect("font name isn't valid UTF-8")
+    }
+    pub(crate) fn is_bold(self) -> bool {
+        unsafe { fz_font_is_bold(self.ctx.0.get(), self.ptr.get()) != 0 }
+    }
+    pub(crate) fn is_italic(self) -> bool {
+        unsafe { fz_font_is_italic(self.ctx.0.get(), self.ptr.get()) != 0 }
+    }
+    pub(crate) fn ascender(self) -> f32 {
+        unsafe { fz_font_ascender(self.ctx.0.get(), self.ptr.get()) }
+    }
+    pub(crate) fn descender(self) -> f32 {
+        unsafe { fz_font_descender(self.ctx.0.get(), self.ptr.get()) }
+    }
+}
+
+pub(crate) fn transform_point(point: fz_point, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_point(point, m) }
+}
+
+pub(crate) fn transform_point_xy(x: f32, y: f32, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_point_xy(x, y, m) }
+}
+
+pub(crate) fn transform_vector(vector: fz_point, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_vector(vector, m) }
+}
+
+pub(crate) fn matrix_expansion(m: fz_matrix) -> f32 {
+    unsafe { fz_matrix_expansion(m) }
+}
+
+pub(crate) fn concat(left: fz_matrix, right: fz_matrix) -> fz_matrix {
+    unsafe { fz_concat(left, right) }
+}
+
+pub(crate) fn add_points(a: fz_point, b: fz_point) -> fz_point {
+    fz_point {
+        x: a.x + b.x,
+        y: a.y + b.y,
+    }
+}
+
+pub(crate) fn point_min_components(a: fz_point, b: fz_point) -> fz_point {
+    fz_point {
+        x: a.x.min(b.x),
+        y: a.y.min(b.y),
+    }
+}
+
+pub(crate) fn point_max_components(a: fz_point, b: fz_point) -> fz_point {
+    fz_point {
+        x: a.x.max(b.x),
+        y: a.y.max(b.y),
+    }
+}
diff --git a/src/quad_tree.rs b/src/quad_tree.rs
new file mode 100644
index 0000000..0c57597
--- /dev/null
+++ b/src/quad_tree.rs
@@ -0,0 +1,1115 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+use std::{fmt, ops::ControlFlow};
+
+/// node in a quad-tree extending from `-(2 ** log2_size)` to
+/// `2 ** log2_size` exclusive on both sides in both `x` and `y`
+/// dimensions.
+///
+/// invariants:
+/// * if `self.values is not None` then all of
+///     `nx_ny`, `px_ny`, `nx_py`, and `px_py` are `None`.
+/// * the `log2_size` field of all of `nx_ny`, `px_ny`, `nx_py`, and `px_py`
+///     is always `self.log2_size - 1`.
+enum QuadTreeNode<V> {
+    Interior {
+        log2_size: i32,
+        nx_ny: Option<Box<QuadTreeNode<V>>>,
+        px_ny: Option<Box<QuadTreeNode<V>>>,
+        nx_py: Option<Box<QuadTreeNode<V>>>,
+        px_py: Option<Box<QuadTreeNode<V>>>,
+    },
+    Leaf {
+        log2_size: i32,
+        values: Vec<(f32, f32, V)>,
+    },
+}
+
+struct DebugQuadTreeLeafValues<'a, V>(&'a [(f32, f32, V)]);
+
+impl<V: fmt::Debug> fmt::Debug for DebugQuadTreeLeafValues<'_, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let alternate = f.alternate();
+        let mut debug_list = f.debug_list();
+        for (x, y, v) in self.0 {
+            if alternate {
+                debug_list.entry(&format_args!("({x}, {y}, {v:#?})"));
+            } else {
+                debug_list.entry(&format_args!("({x}, {y}, {v:?})"));
+            }
+        }
+        debug_list.finish()
+    }
+}
+
+impl<V: fmt::Debug> fmt::Debug for QuadTreeNode<V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Interior {
+                log2_size,
+                nx_ny,
+                px_ny,
+                nx_py,
+                px_py,
+            } => {
+                let mut debug_struct = f.debug_struct("Interior");
+                debug_struct.field("log2_size", log2_size);
+                if let Some(nx_ny) = nx_ny {
+                    debug_struct.field("nx_ny", nx_ny);
+                }
+                if let Some(px_ny) = px_ny {
+                    debug_struct.field("px_ny", px_ny);
+                }
+                if let Some(nx_py) = nx_py {
+                    debug_struct.field("nx_py", nx_py);
+                }
+                if let Some(px_py) = px_py {
+                    debug_struct.field("px_py", px_py);
+                }
+                debug_struct.finish()
+            }
+            Self::Leaf { log2_size, values } => f
+                .debug_struct("Leaf")
+                .field("log2_size", log2_size)
+                .field("values", &DebugQuadTreeLeafValues(values))
+                .finish(),
+        }
+    }
+}
+
+trait Trace<V> {
+    fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug;
+    fn debug_value(v: &V) -> impl fmt::Debug;
+    fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result);
+}
+
+impl<V, T: Trace<V>> Trace<V> for &'_ mut T {
+    fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug {
+        T::debug_quad_tree_node(v)
+    }
+    fn debug_value(v: &V) -> impl fmt::Debug {
+        T::debug_value(v)
+    }
+    fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {
+        T::trace(self, msg);
+    }
+}
+
+impl<V> Trace<V> for () {
+    fn debug_quad_tree_node(_v: &QuadTreeNode<V>) -> impl fmt::Debug {
+        unreachable!()
+    }
+    fn debug_value(_v: &V) -> impl fmt::Debug {
+        unreachable!()
+    }
+    fn trace(&mut self, _msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {}
+}
+
+impl<V> QuadTreeNode<V> {
+    fn log2_size(&self) -> i32 {
+        match *self {
+            QuadTreeNode::Interior { log2_size, .. } | QuadTreeNode::Leaf { log2_size, .. } => {
+                log2_size
+            }
+        }
+    }
+    fn split<Tr: Trace<V>>(
+        &mut self,
+        split_x: f32,
+        split_y: f32,
+        delta: f32,
+        max_leaf_size: usize,
+        trace: &mut Tr,
+    ) {
+        let Self::Leaf {
+            log2_size,
+            ref mut values,
+        } = *self
+        else {
+            unreachable!("can't split interior node");
+        };
+        if values.len() <= max_leaf_size {
+            return;
+        }
+        let values = std::mem::take(values);
+        *self = Self::Interior {
+            log2_size,
+            nx_ny: None,
+            px_ny: None,
+            nx_py: None,
+            px_py: None,
+        };
+        for value @ (x, y, _) in values {
+            let Self::Interior {
+                log2_size: _,
+                nx_ny,
+                px_ny,
+                nx_py,
+                px_py,
+            } = self
+            else {
+                unreachable!();
+            };
+            let child = if x < split_x {
+                if y < split_y { nx_ny } else { nx_py }
+            } else {
+                if y < split_y { px_ny } else { px_py }
+            };
+            let QuadTreeNode::Leaf {
+                log2_size: _,
+                values,
+            } = &mut **child.get_or_insert_with(|| {
+                Box::new(QuadTreeNode::Leaf {
+                    log2_size: log2_size - 1,
+                    values: Vec::new(),
+                })
+            })
+            else {
+                unreachable!();
+            };
+            values.push(value);
+        }
+        trace.trace(|w| {
+            writeln!(
+                w,
+                "split leaf split_x={split_x} split_y={split_y} delta={delta} self={:#?}",
+                Tr::debug_quad_tree_node(self),
+            )
+        });
+        let Self::Interior {
+            log2_size: _,
+            nx_ny,
+            px_ny,
+            nx_py,
+            px_py,
+        } = self
+        else {
+            unreachable!();
+        };
+        if let Some(nx_ny) = nx_ny {
+            nx_ny.split(
+                split_x - delta,
+                split_y - delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(nx_py) = nx_py {
+            nx_py.split(
+                split_x - delta,
+                split_y + delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(px_ny) = px_ny {
+            px_ny.split(
+                split_x + delta,
+                split_y - delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(px_py) = px_py {
+            px_py.split(
+                split_x + delta,
+                split_y + delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+    }
+    fn range<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B, Tr: Trace<V>>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        node_min_x: f32,
+        node_max_x: f32,
+        node_min_y: f32,
+        node_max_y: f32,
+        callback: &mut F,
+        trace: &mut Tr,
+    ) -> ControlFlow<B> {
+        match self {
+            Self::Leaf {
+                log2_size: _,
+                values,
+            } => {
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "range(\n    \
+                min_x={min_x}, max_x={max_x},\n    \
+                min_y={min_y}, max_y={max_y},\n    \
+                node_min_x={node_min_x}, node_max_x={node_max_x},\n    \
+                node_min_y={node_min_y}, node_max_y={node_max_y},\n): \
+                leaf {:#?}",
+                        Tr::debug_quad_tree_node(self)
+                    )
+                });
+                for &(x, y, ref v) in values {
+                    if min_x <= x && x <= max_x && min_y <= y && y <= max_y {
+                        trace.trace(|w| writeln!(w, "yielding {:#?}", (x, y, Tr::debug_value(v))));
+                        callback(x, y, v)?;
+                    } else {
+                        trace.trace(|w| writeln!(w, "skipping {:#?}", (x, y, Tr::debug_value(v))));
+                    }
+                }
+                ControlFlow::Continue(())
+            }
+            &Self::Interior {
+                log2_size: _,
+                ref nx_ny,
+                ref px_ny,
+                ref nx_py,
+                ref px_py,
+            } => {
+                let split_x = (node_min_x + node_max_x) * 0.5;
+                let split_y = (node_min_y + node_max_y) * 0.5;
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "range(\n    \
+                min_x={min_x}, max_x={max_x},\n    \
+                min_y={min_y}, max_y={max_y},\n    \
+                node_min_x={node_min_x}, node_max_x={node_max_x},\n    \
+                node_min_y={node_min_y}, node_max_y={node_max_y},\n): \
+                interior split_x={split_x} split_y={split_y} {:#?}",
+                        Tr::debug_quad_tree_node(self),
+                    )
+                });
+                if let Some(v) = nx_ny {
+                    if min_x <= split_x && min_y <= split_y {
+                        let node_max_x = split_x;
+                        let node_max_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = nx_py {
+                    if min_x <= split_x && max_y >= split_y {
+                        let node_max_x = split_x;
+                        let node_min_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = px_ny {
+                    if max_x >= split_x && min_y <= split_y {
+                        let node_min_x = split_x;
+                        let node_max_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = px_py {
+                    if max_x >= split_x && max_y >= split_y {
+                        let node_min_x = split_x;
+                        let node_min_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                ControlFlow::Continue(())
+            }
+        }
+    }
+}
+
+macro_rules! impl_node_iter {
+    (
+        #[mut = $($mut:tt)?];
+        #[Clone = $($Clone:tt)?];
+        Iter = $Iter:ident;
+        iter = $iter:ident;
+        IterStackEntry = $IterStackEntry:ident;
+        as_iter_stack_entry = $as_iter_stack_entry:ident;
+        as_deref = $as_deref:ident;
+    ) => {
+        impl<V> QuadTreeNode<V> {
+            fn $iter(&$($mut)? self) -> $Iter<'_, V> {
+                $Iter { stack: vec![self.$as_iter_stack_entry()] }
+            }
+            fn $as_iter_stack_entry(&$($mut)? self) -> $IterStackEntry<'_, V> {
+                match self {
+                    QuadTreeNode::Interior {
+                        log2_size: _,
+                        nx_ny,
+                        px_ny,
+                        nx_py,
+                        px_py,
+                    } => $IterStackEntry::NextIsNxNy {
+                        nx_ny: nx_ny.$as_deref(),
+                        px_ny: px_ny.$as_deref(),
+                        nx_py: nx_py.$as_deref(),
+                        px_py: px_py.$as_deref(),
+                    },
+                    QuadTreeNode::Leaf {
+                        log2_size: _,
+                        values,
+                    } => $IterStackEntry::NextIsValues {
+                        values: values.$iter(),
+                    },
+                }
+            }
+        }
+
+        #[derive($($Clone,)? Debug)]
+        enum $IterStackEntry<'a, V> {
+            NextIsNxNy {
+                nx_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsPxNy {
+                px_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsNxPy {
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsPxPy {
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsValues {
+                values: std::slice::$Iter<'a, (f32, f32, V)>,
+            },
+        }
+
+        impl<'a, V> Default for $IterStackEntry<'a, V> {
+            fn default() -> Self {
+                Self::NextIsValues { values: Default::default() }
+            }
+        }
+
+        #[derive($($Clone,)? Debug, Default)]
+        pub struct $Iter<'a, V> {
+            stack: Vec<$IterStackEntry<'a, V>>,
+        }
+
+        impl<'a, V> Iterator for $Iter<'a, V> {
+            type Item = (f32, f32, &'a $($mut)? V);
+
+            fn next(&mut self) -> Option<Self::Item> {
+                while let Some(top) = self.stack.pop() {
+                    match top {
+                        $IterStackEntry::NextIsNxNy {
+                            nx_ny,
+                            px_ny,
+                            nx_py,
+                            px_py,
+                        } => {
+                            self.stack.push($IterStackEntry::NextIsPxNy {
+                                px_ny,
+                                nx_py,
+                                px_py,
+                            });
+                            self.stack
+                                .extend(nx_ny.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsPxNy {
+                            px_ny,
+                            nx_py,
+                            px_py,
+                        } => {
+                            self.stack.push($IterStackEntry::NextIsNxPy {
+                                nx_py,
+                                px_py,
+                            });
+                            self.stack
+                                .extend(px_ny.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsNxPy { nx_py, px_py } => {
+                            self.stack.push($IterStackEntry::NextIsPxPy {
+                                px_py,
+                            });
+                            self.stack
+                                .extend(nx_py.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsPxPy { px_py } => {
+                            self.stack
+                                .extend(px_py.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsValues { mut values } => {
+                            if let Some((x, y, v)) = values.next() {
+                                self.stack
+                                    .push($IterStackEntry::NextIsValues { values });
+                                return Some((*x, *y, v));
+                            }
+                        }
+                    }
+                }
+                None
+            }
+        }
+    };
+}
+
+impl_node_iter! {
+    #[mut =];
+    #[Clone = Clone];
+    Iter = Iter;
+    iter = iter;
+    IterStackEntry = IterStackEntry;
+    as_iter_stack_entry = as_iter_stack_entry;
+    as_deref = as_deref;
+}
+
+impl_node_iter! {
+    #[mut = mut];
+    #[Clone =];
+    Iter = IterMut;
+    iter = iter_mut;
+    IterStackEntry = IterStackEntryMut;
+    as_iter_stack_entry = as_iter_stack_entry_mut;
+    as_deref = as_deref_mut;
+}
+
+pub struct QuadTree<V> {
+    root: QuadTreeNode<V>,
+    max_leaf_size: usize,
+}
+
+impl<V: fmt::Debug> fmt::Debug for QuadTree<V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            root,
+            max_leaf_size: _,
+        } = self;
+        f.write_str("QuadTree(")?;
+        root.fmt(f)?;
+        f.write_str(")")
+    }
+}
+
+impl<V> QuadTree<V> {
+    pub const DEFAULT_MAX_LEAF_SIZE: usize = 16;
+    pub const fn new() -> Self {
+        Self::with_max_leaf_size(Self::DEFAULT_MAX_LEAF_SIZE)
+    }
+    pub const fn with_max_leaf_size(max_leaf_size: usize) -> Self {
+        Self {
+            root: QuadTreeNode::Leaf {
+                log2_size: 0,
+                values: Vec::new(),
+            },
+            max_leaf_size,
+        }
+    }
+    pub fn from_iter_with_max_leaf_size<I: IntoIterator<Item = (f32, f32, V)>>(
+        iter: I,
+        max_leaf_size: usize,
+    ) -> Self {
+        let mut retval = Self::with_max_leaf_size(max_leaf_size);
+        retval.extend(iter);
+        retval
+    }
+    pub fn iter(&self) -> Iter<'_, V> {
+        self.root.iter()
+    }
+    pub fn iter_mut(&mut self) -> IterMut<'_, V> {
+        self.root.iter_mut()
+    }
+    fn expand_root<Tr: Trace<V>>(&mut self, target_log2_size: i32, trace: &mut Tr) {
+        match &mut self.root {
+            QuadTreeNode::Leaf {
+                log2_size,
+                values: _,
+            } => {
+                if target_log2_size > *log2_size {
+                    // leaf node -- just expand in place
+                    trace.trace(|w| writeln!(w, "expand_root({target_log2_size}) leaf"));
+                    *log2_size = target_log2_size;
+                }
+            }
+            QuadTreeNode::Interior { .. } => {
+                while target_log2_size > self.root.log2_size() {
+                    trace.trace(|w| {
+                        writeln!(
+                            w,
+                            "expand_root({target_log2_size}) interior: {:#?}",
+                            Tr::debug_quad_tree_node(&self.root)
+                        )
+                    });
+                    let QuadTreeNode::Interior {
+                        log2_size,
+                        nx_ny,
+                        px_ny,
+                        nx_py,
+                        px_py,
+                    } = &mut self.root
+                    else {
+                        unreachable!();
+                    };
+                    *nx_ny = nx_ny.take().map(|nx_ny| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: None,
+                            nx_py: None,
+                            px_py: Some(nx_ny),
+                        })
+                    });
+                    *px_ny = px_ny.take().map(|px_ny| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: None,
+                            nx_py: Some(px_ny),
+                            px_py: None,
+                        })
+                    });
+                    *nx_py = nx_py.take().map(|nx_py| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: Some(nx_py),
+                            nx_py: None,
+                            px_py: None,
+                        })
+                    });
+                    *px_py = px_py.take().map(|px_py| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: Some(px_py),
+                            px_ny: None,
+                            nx_py: None,
+                            px_py: None,
+                        })
+                    });
+                    *log2_size += 1
+                }
+            }
+        }
+        trace.trace(|w| {
+            writeln!(
+                w,
+                "expand_root({target_log2_size}) done: {:#?}",
+                Tr::debug_quad_tree_node(&self.root)
+            )
+        });
+    }
+    fn range_with_trace<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B, Tr: Trace<V>>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        mut callback: F,
+        mut trace: Tr,
+    ) -> ControlFlow<B> {
+        assert!(!(min_x.is_nan() || max_x.is_nan() || min_y.is_nan() || max_y.is_nan()));
+        if min_x > max_x || min_y > max_y {
+            return ControlFlow::Continue(());
+        }
+        let size = libm::ldexpf(1.0, self.root.log2_size());
+        self.root.range(
+            min_x,
+            max_x,
+            min_y,
+            max_y,
+            -size,
+            size,
+            -size,
+            size,
+            &mut callback,
+            &mut trace,
+        )
+    }
+    pub fn range<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        callback: F,
+    ) -> ControlFlow<B> {
+        self.range_with_trace(min_x, max_x, min_y, max_y, callback, ())
+    }
+    fn insert_with_trace_inner<Tr: Trace<V>>(
+        node: &mut QuadTreeNode<V>,
+        x: f32,
+        y: f32,
+        value: V,
+        split_x: f32,
+        split_y: f32,
+        delta: f32,
+        max_leaf_size: usize,
+        trace: &mut Tr,
+    ) {
+        match node {
+            QuadTreeNode::Interior { .. } => {
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "insert({x}, {y}, _): interior: split_x={split_x} \
+                    split_y={split_y} delta={delta} node={:#?}",
+                        Tr::debug_quad_tree_node(node)
+                    )
+                });
+                let QuadTreeNode::Interior {
+                    log2_size,
+                    nx_ny,
+                    px_ny,
+                    nx_py,
+                    px_py,
+                } = node
+                else {
+                    unreachable!();
+                };
+                if x < split_x {
+                    if y < split_y {
+                        let Some(node) = nx_ny else {
+                            *nx_ny = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert nx_ny leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x - delta,
+                            split_y - delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    } else {
+                        let Some(node) = nx_py else {
+                            *nx_py = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert nx_py leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x - delta,
+                            split_y + delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    }
+                } else {
+                    if y < split_y {
+                        let Some(node) = px_ny else {
+                            *px_ny = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert px_ny leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x + delta,
+                            split_y - delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    } else {
+                        let Some(node) = px_py else {
+                            *px_py = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert px_py leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x + delta,
+                            split_y + delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    }
+                }
+            }
+            QuadTreeNode::Leaf {
+                log2_size: _,
+                values,
+            } => {
+                // got to a leaf
+                values.push((x, y, value));
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "insert({x}, {y}, _): leaf node={:#?}",
+                        Tr::debug_quad_tree_node(node)
+                    )
+                });
+                node.split(split_x, split_y, delta, max_leaf_size, trace)
+            }
+        }
+    }
+    fn insert_with_trace<Tr: Trace<V>>(&mut self, x: f32, y: f32, value: V, mut trace: Tr) {
+        assert!(x.is_finite() && y.is_finite(), "invalid coordinates");
+        trace.trace(|w| writeln!(w, "insert({x}, {y}, {:#?})", Tr::debug_value(&value)));
+        let abs_x = x.abs();
+        let abs_y = y.abs();
+        let abs_max = abs_x.max(abs_y);
+        let (_, log2_abs_max) = libm::frexpf(abs_max);
+        trace.trace(|w| writeln!(w, "insert({x}, {y}, _): log2_abs_max={log2_abs_max}"));
+        self.expand_root(log2_abs_max, &mut trace);
+        let delta = libm::ldexpf(0.5, self.root.log2_size());
+        Self::insert_with_trace_inner(
+            &mut self.root,
+            x,
+            y,
+            value,
+            0.0,
+            0.0,
+            delta,
+            self.max_leaf_size,
+            &mut trace,
+        );
+    }
+    pub fn insert(&mut self, x: f32, y: f32, value: V) {
+        self.insert_with_trace(x, y, value, &mut ());
+    }
+}
+
+impl<V> Default for QuadTree<V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<V> FromIterator<(f32, f32, V)> for QuadTree<V> {
+    fn from_iter<T: IntoIterator<Item = (f32, f32, V)>>(iter: T) -> Self {
+        Self::from_iter_with_max_leaf_size(iter, Self::DEFAULT_MAX_LEAF_SIZE)
+    }
+}
+
+impl<V> Extend<(f32, f32, V)> for QuadTree<V> {
+    fn extend<T: IntoIterator<Item = (f32, f32, V)>>(&mut self, iter: T) {
+        iter.into_iter().for_each(|(x, y, v)| {
+            self.insert(x, y, v);
+        });
+    }
+}
+
+impl<'a, V> IntoIterator for &'a QuadTree<V> {
+    type Item = (f32, f32, &'a V);
+    type IntoIter = Iter<'a, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.root.iter()
+    }
+}
+
+impl<'a, V> IntoIterator for &'a mut QuadTree<V> {
+    type Item = (f32, f32, &'a mut V);
+    type IntoIter = IterMut<'a, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.root.iter_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Print;
+
+    impl<V: fmt::Debug> Trace<V> for Print {
+        fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug {
+            v
+        }
+
+        fn debug_value(v: &V) -> impl fmt::Debug {
+            v
+        }
+
+        fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {
+            let mut out = String::new();
+            msg(&mut out).unwrap();
+            print!("{out}");
+        }
+    }
+
+    #[test]
+    fn test_quad_tree_range() {
+        let mut items = vec![];
+        for x in 0..8 {
+            let mut x = x as f32 + 0.5;
+            x /= 4.0;
+            for y in 0..8 {
+                let mut y = y as f32 + 0.5;
+                y /= 4.0;
+                items.push((x, y, format!("{x},{y}")));
+            }
+        }
+        items.sort_by(|l, r| l.partial_cmp(r).unwrap());
+        let qt = QuadTree::from_iter(items.clone());
+        let check_range = |min_x: f32, max_x: f32, min_y: f32, max_y: f32| {
+            println!("min_x={min_x}, max_x={max_x}, min_y={min_y}, max_y={max_y}");
+            let expected = Vec::from_iter(
+                items
+                    .iter()
+                    .filter(|&&(x, y, _)| min_x <= x && x <= max_x && min_y <= y && y <= max_y)
+                    .map(|&(x, y, ref v)| (x, y, v)),
+            );
+            let mut range_result = Vec::new();
+            let _ = qt.range_with_trace(
+                min_x,
+                max_x,
+                min_y,
+                max_y,
+                |x, y, v| {
+                    range_result.push((x, y, v));
+                    ControlFlow::<()>::Continue(())
+                },
+                &mut Print,
+            );
+            range_result.sort_by(|l, r| l.partial_cmp(r).unwrap());
+            println!("expected={expected:?}");
+            println!("range_result={range_result:?}");
+            assert_eq!(expected, range_result);
+        };
+        check_range(-1.0, 1.0, -1.0, 1.0);
+        check_range(0.125, 0.25, 0.125, 0.25);
+        check_range(items[0].0, items[0].0, items[0].1, items[0].1);
+        check_range(1.0, 0.0, -1.0, 1.0);
+    }
+
+    #[test]
+    fn test_quad_tree_insert() {
+        let mut qt = QuadTree::with_max_leaf_size(4);
+        for x in 0..8 {
+            let mut x = x as f32 + 0.5;
+            x /= 4.0;
+            for y in 0..8 {
+                let mut y = y as f32 + 0.5;
+                y /= 4.0;
+                qt.insert_with_trace(x, y, format!("{x},{y}"), &mut Print);
+            }
+        }
+        println!("{qt:#?}");
+        assert_eq!(
+            format!("{qt:#?}"),
+            r#"QuadTree(Interior {
+    log2_size: 1,
+    px_py: Interior {
+        log2_size: 0,
+        nx_ny: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 0.125, "0.125,0.125"),
+                    (0.125, 0.375, "0.125,0.375"),
+                    (0.375, 0.125, "0.375,0.125"),
+                    (0.375, 0.375, "0.375,0.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 0.125, "0.625,0.125"),
+                    (0.625, 0.375, "0.625,0.375"),
+                    (0.875, 0.125, "0.875,0.125"),
+                    (0.875, 0.375, "0.875,0.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 0.625, "0.125,0.625"),
+                    (0.125, 0.875, "0.125,0.875"),
+                    (0.375, 0.625, "0.375,0.625"),
+                    (0.375, 0.875, "0.375,0.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 0.625, "0.625,0.625"),
+                    (0.625, 0.875, "0.625,0.875"),
+                    (0.875, 0.625, "0.875,0.625"),
+                    (0.875, 0.875, "0.875,0.875"),
+                ],
+            },
+        },
+        px_ny: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 0.125, "1.125,0.125"),
+                    (1.125, 0.375, "1.125,0.375"),
+                    (1.375, 0.125, "1.375,0.125"),
+                    (1.375, 0.375, "1.375,0.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 0.125, "1.625,0.125"),
+                    (1.625, 0.375, "1.625,0.375"),
+                    (1.875, 0.125, "1.875,0.125"),
+                    (1.875, 0.375, "1.875,0.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 0.625, "1.125,0.625"),
+                    (1.125, 0.875, "1.125,0.875"),
+                    (1.375, 0.625, "1.375,0.625"),
+                    (1.375, 0.875, "1.375,0.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 0.625, "1.625,0.625"),
+                    (1.625, 0.875, "1.625,0.875"),
+                    (1.875, 0.625, "1.875,0.625"),
+                    (1.875, 0.875, "1.875,0.875"),
+                ],
+            },
+        },
+        nx_py: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 1.125, "0.125,1.125"),
+                    (0.125, 1.375, "0.125,1.375"),
+                    (0.375, 1.125, "0.375,1.125"),
+                    (0.375, 1.375, "0.375,1.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 1.125, "0.625,1.125"),
+                    (0.625, 1.375, "0.625,1.375"),
+                    (0.875, 1.125, "0.875,1.125"),
+                    (0.875, 1.375, "0.875,1.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 1.625, "0.125,1.625"),
+                    (0.125, 1.875, "0.125,1.875"),
+                    (0.375, 1.625, "0.375,1.625"),
+                    (0.375, 1.875, "0.375,1.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 1.625, "0.625,1.625"),
+                    (0.625, 1.875, "0.625,1.875"),
+                    (0.875, 1.625, "0.875,1.625"),
+                    (0.875, 1.875, "0.875,1.875"),
+                ],
+            },
+        },
+        px_py: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 1.125, "1.125,1.125"),
+                    (1.125, 1.375, "1.125,1.375"),
+                    (1.375, 1.125, "1.375,1.125"),
+                    (1.375, 1.375, "1.375,1.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 1.125, "1.625,1.125"),
+                    (1.625, 1.375, "1.625,1.375"),
+                    (1.875, 1.125, "1.875,1.125"),
+                    (1.875, 1.375, "1.875,1.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 1.625, "1.125,1.625"),
+                    (1.125, 1.875, "1.125,1.875"),
+                    (1.375, 1.625, "1.375,1.625"),
+                    (1.375, 1.875, "1.375,1.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 1.625, "1.625,1.625"),
+                    (1.625, 1.875, "1.625,1.875"),
+                    (1.875, 1.625, "1.875,1.625"),
+                    (1.875, 1.875, "1.875,1.875"),
+                ],
+            },
+        },
+    },
+})"#
+        );
+    }
+}
diff --git a/src/xml_tree.rs b/src/xml_tree.rs
new file mode 100644
index 0000000..4831a38
--- /dev/null
+++ b/src/xml_tree.rs
@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use quick_xml::{
+    Writer,
+    events::{BytesDecl, BytesStart, BytesText, Event},
+};
+use std::fmt;
+
+struct FmtToIoAdaptor<W> {
+    writer: W,
+    partial_char: [u8; 4],
+    partial_char_len: u8,
+}
+
+impl<W: fmt::Write> FmtToIoAdaptor<W> {
+    fn new(writer: W) -> Self {
+        Self {
+            writer,
+            partial_char: [0; 4],
+            partial_char_len: 0,
+        }
+    }
+    fn finish(self) -> Result<W, fmt::Error> {
+        let Self {
+            writer,
+            partial_char: _,
+            partial_char_len,
+        } = self;
+        if partial_char_len != 0 {
+            Err(fmt::Error)
+        } else {
+            Ok(writer)
+        }
+    }
+    fn write_byte(&mut self, b: u8) -> std::io::Result<()> {
+        let Self {
+            writer,
+            partial_char,
+            partial_char_len,
+        } = self;
+        partial_char[usize::from(*partial_char_len)] = b;
+        *partial_char_len += 1;
+        match str::from_utf8(&partial_char[..usize::from(*partial_char_len)]) {
+            Ok(s) => {
+                *partial_char_len = 0;
+                writer.write_str(s).map_err(std::io::Error::other)
+            }
+            Err(e) => {
+                if e.error_len().is_some() {
+                    *partial_char_len = 0;
+                    Err(std::io::Error::new(std::io::ErrorKind::InvalidData, e))
+                } else {
+                    Ok(())
+                }
+            }
+        }
+    }
+}
+
+impl<W: fmt::Write> std::io::Write for FmtToIoAdaptor<W> {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        for &b in buf {
+            self.write_byte(b)?;
+        }
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) enum ElementTag {
+    Comment,
+    Normal(String),
+}
+
+impl ElementTag {
+    pub(crate) fn normal(&self) -> Option<&str> {
+        match self {
+            ElementTag::Comment => None,
+            ElementTag::Normal(v) => Some(v),
+        }
+    }
+}
+
+impl fmt::Debug for ElementTag {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Comment => f.write_str("<Comment>"),
+            Self::Normal(v) => v.fmt(f),
+        }
+    }
+}
+
+/// like python's xml.etree.ElementTree.Element
+#[derive(Clone, Debug)]
+pub(crate) struct Element {
+    pub(crate) tag: ElementTag,
+    pub(crate) attrib: Vec<(String, String)>,
+    /// text contained in this element but before any children
+    pub(crate) text: String,
+    pub(crate) children: Vec<Element>,
+    /// text after the end of this element
+    pub(crate) tail: String,
+}
+
+/// equivalent to python `xml.etree.ElementTree.tostring(self, encoding="unicode")`
+impl fmt::Display for Element {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut writer = Writer::new(FmtToIoAdaptor::new(f));
+        self.write_to(&mut writer).map_err(|_| fmt::Error)?;
+        writer.into_inner().finish()?;
+        Ok(())
+    }
+}
+
+impl Element {
+    pub(crate) fn new(tag: String, attrib: impl IntoIterator<Item = (String, String)>) -> Self {
+        Self {
+            tag: ElementTag::Normal(tag),
+            attrib: Vec::from_iter(attrib),
+            text: String::new(),
+            children: Vec::new(),
+            tail: String::new(),
+        }
+    }
+    /// equivalent of python's `xml.etree.ElementTree.Comment()`
+    pub(crate) fn comment(text: String) -> Self {
+        Self {
+            tag: ElementTag::Comment,
+            attrib: Vec::new(),
+            text,
+            children: Vec::new(),
+            tail: String::new(),
+        }
+    }
+    /// equivalent to python `"".join(self.itertext())`
+    pub(crate) fn inner_text(&self) -> String {
+        let mut retval = String::new();
+        fn helper(element: &Element, retval: &mut String) {
+            let Element {
+                tag,
+                attrib: _,
+                text,
+                children,
+                tail: _,
+            } = element;
+            let ElementTag::Normal(_) = tag else {
+                return;
+            };
+            retval.push_str(text);
+            for child in children {
+                helper(child, retval);
+                retval.push_str(&child.tail);
+            }
+        }
+        helper(self, &mut retval);
+        retval
+    }
+    /// equivalent of python's `xml.etree.ElementTree.SubElement()`
+    pub(crate) fn sub_element(
+        &mut self,
+        tag: String,
+        attrib: impl IntoIterator<Item = (String, String)>,
+    ) -> &mut Self {
+        self.children.push(Self::new(tag, attrib));
+        self.children.last_mut().expect("just pushed")
+    }
+    pub(crate) fn write_to(&self, writer: &mut Writer<impl std::io::Write>) -> std::io::Result<()> {
+        let Element {
+            tag,
+            attrib,
+            text,
+            children,
+            tail,
+        } = self;
+        match tag {
+            ElementTag::Comment => {
+                writer.write_event(Event::Comment(BytesText::new(text)))?;
+            }
+            ElementTag::Normal(tag) if tag.is_empty() => {
+                writer.write_event(Event::Text(BytesText::new(text)))?;
+            }
+            ElementTag::Normal(tag)
+                if attrib.is_empty() && text.is_empty() && children.is_empty() =>
+            {
+                // write element like `<br />` to match python instead of like `<br/>`
+                writer.write_event(Event::Empty(BytesStart::from_content(
+                    tag.clone() + " ",
+                    tag.len(),
+                )))?;
+            }
+            ElementTag::Normal(tag) => {
+                let mut element_writer = writer.create_element(tag);
+                for (name, value) in attrib {
+                    element_writer = element_writer.with_attribute((name.as_str(), value.as_str()));
+                }
+                if text.is_empty() && children.is_empty() {
+                    element_writer.write_empty()?;
+                } else {
+                    element_writer.write_inner_content(|writer| {
+                        writer.write_event(Event::Text(BytesText::new(text)))?;
+                        for child in children {
+                            child.write_to(writer)?;
+                        }
+                        Ok(())
+                    })?;
+                }
+            }
+        }
+        writer.write_event(Event::Text(BytesText::new(tail)))?;
+        Ok(())
+    }
+    /// equivalent of python's `xml.etree.ElementTree(self).write(writer, encoding='utf-8', xml_declaration=xml_declaration)`
+    pub(crate) fn write(
+        &self,
+        writer: impl std::io::Write,
+        xml_declaration: bool,
+    ) -> std::io::Result<()> {
+        let mut writer = Writer::new(writer);
+        if xml_declaration {
+            // use specific string to match python
+            writer.write_event(Event::Decl(BytesDecl::from_start(
+                BytesStart::from_content("xml version='1.0' encoding='utf-8'", 3),
+            )))?;
+            writer.write_event(Event::Text(BytesText::new("\n")))?;
+        }
+        self.write_to(&mut writer)
+    }
+}