diff --git a/.gitignore b/.gitignore
index 454d147..37b3676 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,3 @@ __pycache__
 *.log
 /powerisa-instructions.xml
 /*.pdf
-/target
diff --git a/Cargo.lock b/Cargo.lock
deleted file mode 100644
index 0281106..0000000
--- a/Cargo.lock
+++ /dev/null
@@ -1,432 +0,0 @@
-# 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"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a6499267155b9ae03ff8e53c456d0bfff988b2647d62ff1df038f39ebe93a0c"
-dependencies = [
- "bitflags",
- "mupdf-sys",
- "num_enum",
- "once_cell",
- "zerocopy",
-]
-
-[[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 = "num_enum"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
-dependencies = [
- "num_enum_derive",
- "rustversion",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
-
-[[package]]
-name = "parse_powerisa_pdf"
-version = "0.1.0"
-dependencies = [
- "indexmap",
- "libm",
- "mupdf",
- "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-macro-crate"
-version = "3.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
-dependencies = [
- "toml_edit",
-]
-
-[[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 = "rustversion"
-version = "1.0.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
-
-[[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 = "toml_datetime"
-version = "0.7.5+spec-1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
-dependencies = [
- "serde_core",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.23.10+spec-1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
-dependencies = [
- "indexmap",
- "toml_datetime",
- "toml_parser",
- "winnow",
-]
-
-[[package]]
-name = "toml_parser"
-version = "1.0.6+spec-1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
-dependencies = [
- "winnow",
-]
-
-[[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 = "winnow"
-version = "0.7.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
-dependencies = [
- "memchr",
-]
-
-[[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
deleted file mode 100644
index 224dad3..0000000
--- a/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-# 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 = { 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/scripts/check-copyright.sh b/scripts/check-copyright.sh
index a9dc2bc..640fb4b 100755
--- a/scripts/check-copyright.sh
+++ b/scripts/check-copyright.sh
@@ -32,7 +32,6 @@ 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()
@@ -42,9 +41,6 @@ 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
             ;;
@@ -57,9 +53,6 @@ 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
deleted file mode 100644
index d9c54ec..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,2253 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// See Notices.txt for copyright information
-
-use crate::quad_tree::QuadTree;
-use indexmap::IndexSet;
-use non_nan_float::NonNaNF32;
-use std::{
-    borrow::{Borrow, Cow},
-    cell::RefCell,
-    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
-    error::Error,
-    fmt,
-    num::NonZero,
-    rc::Rc,
-    sync::OnceLock,
-};
-
-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
-        }
-    }
-
-    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)
-        }
-    }
-}
-
-macro_rules! make_enum_font {
-    (
-        enum $Font:ident {
-            #[other]
-            $Other:ident $other_body:tt,
-            $(#[group]
-            $KnownFontGroup:ident {
-                $(#[name = $known_font_name: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 {
-            fn new(font_name: &str, size: NonNaNF32) -> Self {
-                match (font_name, size.get()) {
-                    $($(($known_font_name, $known_font_size) => Self::$KnownFont,)*)*
-                    _ => 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 => $known_font_name,)*)*
-                }
-            }
-            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() },)*)*
-                }
-            }
-        }
-    };
-}
-
-make_enum_font! {
-    enum Font {
-        #[other]
-        Other {
-            font_name: Box<str>,
-            size: NonNaNF32,
-        },
-        #[group]
-        InsnHeader {
-            #[name = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 9.963]
-            InsnHeader,
-        },
-        #[group]
-        RtlFnHeader {
-            #[name = "APUYSQ+zcoN-Regular", size = 9.963]
-            RtlFnHeader,
-        },
-        #[group]
-        PageHeader {
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 9.963]
-            PageHeader,
-        },
-        #[group]
-        PageFooter {
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 4.981]
-            PageFooter,
-        },
-        #[group]
-        InsnDesc {
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 8.966]
-            InsnDesc0,
-            #[name = "FZTIYT+CMMI9", size = 8.966]
-            InsnDesc1,
-            #[name = "ONUAYC+CMSSI9", size = 8.966]
-            InsnDesc2,
-            #[name = "TNGBFZ+CMSY9", size = 8.966]
-            InsnDesc3,
-            #[name = "WHMZPU+CMEX9", size = 8.966]
-            InsnDesc4,
-            #[name = "ZJTMSG+CMSS9", size = 8.966]
-            InsnDesc5,
-        },
-        #[group]
-        InsnDescMisc {
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 2.377]
-            InsnDescMisc0,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 2.561]
-            InsnDescMisc1,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 4.492]
-            InsnDescMisc2,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 4.641]
-            InsnDescMisc3,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 4.772]
-            InsnDescMisc4,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 4.864]
-            InsnDescMisc5,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 4.925]
-            InsnDescMisc6,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.097]
-            InsnDescMisc7,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.123]
-            InsnDescMisc8,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.131]
-            InsnDescMisc9,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.516]
-            InsnDescMisc10,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.604]
-            InsnDescMisc11,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.634]
-            InsnDescMisc12,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.906]
-            InsnDescMisc13,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 6.033]
-            InsnDescMisc14,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 6.068]
-            InsnDescMisc15,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 6.213]
-            InsnDescMisc16,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 6.252]
-            InsnDescMisc17,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 6.962]
-            InsnDescMisc18,
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 7.977]
-            InsnDescMisc19,
-        },
-        #[group]
-        InsnDescCode {
-            #[name = "APUYSQ+zcoN-Regular", size = 6.974]
-            InsnDescCode,
-        },
-        #[group]
-        InsnDescCodeMisc {
-            #[name = "APUYSQ+zcoN-Regular", size = 3.587]
-            InsnDescCodeMisc0,
-            #[name = "APUYSQ+zcoN-Regular", size = 4.483]
-            InsnDescCodeMisc1,
-        },
-        #[group]
-        InsnDescItalic {
-            #[name = "CGMSHV+DejaVuSansCondensed-Oblique", size = 8.966]
-            InsnDescItalic,
-        },
-        #[group]
-        InsnDescBold {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.966]
-            InsnDescBold,
-        },
-        #[group]
-        InsnDescBoldItalic {
-            #[name = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 8.966]
-            InsnDescBoldItalic,
-        },
-        #[group]
-        InsnDescSmall {
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 7.97]
-            InsnDescSmall,
-        },
-        #[group]
-        InsnDescSmallItalic {
-            #[name = "CGMSHV+DejaVuSansCondensed-Oblique", size = 7.97]
-            InsnDescSmallItalic,
-        },
-        #[group]
-        InsnDescSmallBold {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 7.97]
-            InsnDescSmallBold,
-        },
-        #[group]
-        InsnDescSmallBoldItalic {
-            #[name = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 7.97]
-            InsnDescSmallBoldItalic,
-        },
-        #[group]
-        InsnDescBoldMisc {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.21]
-            InsnDescBoldMisc0,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.399]
-            InsnDescBoldMisc1,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.763]
-            InsnDescBoldMisc2,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.946]
-            InsnDescBoldMisc3,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.949]
-            InsnDescBoldMisc4,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.999]
-            InsnDescBoldMisc5,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.065]
-            InsnDescBoldMisc6,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.086]
-            InsnDescBoldMisc7,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.183]
-            InsnDescBoldMisc8,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.686]
-            InsnDescBoldMisc9,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.744]
-            InsnDescBoldMisc10,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.825]
-            InsnDescBoldMisc11,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.842]
-            InsnDescBoldMisc12,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.857]
-            InsnDescBoldMisc13,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.979]
-            InsnDescBoldMisc14,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.032]
-            InsnDescBoldMisc15,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.112]
-            InsnDescBoldMisc16,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.161]
-            InsnDescBoldMisc17,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.206]
-            InsnDescBoldMisc18,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.353]
-            InsnDescBoldMisc19,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.378]
-            InsnDescBoldMisc20,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.434]
-            InsnDescBoldMisc21,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.595]
-            InsnDescBoldMisc22,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.619]
-            InsnDescBoldMisc23,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.647]
-            InsnDescBoldMisc24,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.68]
-            InsnDescBoldMisc25,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.693]
-            InsnDescBoldMisc26,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.736]
-            InsnDescBoldMisc27,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.781]
-            InsnDescBoldMisc28,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.802]
-            InsnDescBoldMisc29,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.995]
-            InsnDescBoldMisc30,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.201]
-            InsnDescBoldMisc31,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.258]
-            InsnDescBoldMisc32,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.363]
-            InsnDescBoldMisc33,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.442]
-            InsnDescBoldMisc34,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.473]
-            InsnDescBoldMisc35,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.485]
-            InsnDescBoldMisc36,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.512]
-            InsnDescBoldMisc37,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.543]
-            InsnDescBoldMisc38,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.613]
-            InsnDescBoldMisc39,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.744]
-            InsnDescBoldMisc40,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.774]
-            InsnDescBoldMisc41,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.809]
-            InsnDescBoldMisc42,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.849]
-            InsnDescBoldMisc43,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.911]
-            InsnDescBoldMisc44,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.92]
-            InsnDescBoldMisc45,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.962]
-            InsnDescBoldMisc46,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.981]
-            InsnDescBoldMisc47,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.146]
-            InsnDescBoldMisc48,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.213]
-            InsnDescBoldMisc49,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.221]
-            InsnDescBoldMisc50,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.243]
-            InsnDescBoldMisc51,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.55]
-            InsnDescBoldMisc52,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.62]
-            InsnDescBoldMisc53,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.699]
-            InsnDescBoldMisc54,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.725]
-            InsnDescBoldMisc55,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.751]
-            InsnDescBoldMisc56,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.856]
-            InsnDescBoldMisc57,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.029]
-            InsnDescBoldMisc58,
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.406]
-            InsnDescBoldMisc59,
-        },
-        #[group]
-        InsnDescSubscript {
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 5.978]
-            InsnDescSubscript,
-        },
-        #[group]
-        InsnDescBoldSubscript {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.978]
-            InsnDescBoldSubscript,
-        },
-        #[group]
-        InsnDescItalicSubscript {
-            #[name = "CGMSHV+DejaVuSansCondensed-Oblique", size = 5.978]
-            InsnDescItalicSubscript,
-        },
-        #[group]
-        InsnDescBoldItalicSubscript {
-            #[name = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 5.978]
-            InsnDescBoldItalicSubscript,
-        },
-        #[group]
-        InsnExtMnemonic {
-            #[name = "APUYSQ+zcoN-Regular", size = 8.966]
-            InsnExtMnemonic,
-        },
-        #[group]
-        InsnCode {
-            #[name = "APUYSQ+zcoN-Regular", size = 7.97]
-            InsnCode0,
-            #[name = "RRFUNA+CMSY8", size = 7.97]
-            InsnCode1,
-            #[name = "HPXOZC+CMSS8", size = 7.97]
-            InsnCode2,
-        },
-        #[group]
-        InsnCodeSubscript {
-            #[name = "APUYSQ+zcoN-Regular", size = 5.978]
-            InsnCodeSubscript0,
-            #[name = "DBQTKF+CMSY6", size = 5.978]
-            InsnCodeSubscript1,
-        },
-        #[group]
-        TitlePageBig {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 24.787]
-            TitlePageBig,
-        },
-        #[group]
-        TitlePageVersion {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 9.963]
-            TitlePageVersion,
-        },
-        #[group]
-        TitlePageTm {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.974]
-            TitlePageTm,
-        },
-        #[group]
-        TitlePageRev {
-            #[name = "MJBFWM+DejaVuSansCondensed", size = 6.974]
-            TitlePageRev,
-        },
-        #[group]
-        TitlePageBook {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 20.663]
-            TitlePageBook,
-        },
-        #[group]
-        LegalPageItalic {
-            #[name = "CGMSHV+DejaVuSansCondensed-Oblique", size = 9.963]
-            LegalPageItalic,
-        },
-        #[group]
-        ChangeSummaryPageBold {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 11.955]
-            ChangeSummaryPageBold,
-        },
-        #[group]
-        ChapterTitle {
-            #[name = "NHUPPK+DejaVuSansCondensed-Bold", size = 17.215]
-            ChapterTitle,
-        },
-        #[group]
-        MathMisc {
-            #[name = "AAJMKT+CMMI6", size = 5.978]
-            MathMisc0,
-            #[name = "CUTMFD+CMSSI8", size = 5.978]
-            MathMisc1,
-            #[name = "CUTMFD+CMSSI8", size = 7.97]
-            MathMisc2,
-            #[name = "FZTIYT+CMMI9", size = 5.734]
-            MathMisc3,
-            #[name = "FZTIYT+CMMI9", size = 7.168]
-            MathMisc4,
-            #[name = "HONFQS+CMMI8", size = 7.97]
-            MathMisc5,
-            #[name = "HPXOZC+CMSS8", size = 5.978]
-            MathMisc6,
-            #[name = "LLVRDD+CMSY10", size = 11.955]
-            MathMisc7,
-            #[name = "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 {
-        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
-        }
-        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: 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 = line.borrow();
-            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 Borrow<str>) {
-        let text = text.borrow();
-        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: 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 {
-            field.borrow().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(Clone, Debug)]
-enum LineOrRect {
-    Line(()),
-    Rect(()),
-}
-
-#[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 {
-    pages_gen: Option<Box<dyn Iterator<Item = Result<Page, Box<dyn Error>>>>>,
-    pages: BTreeMap<u32, Rc<Page>>,
-    max_page_num: u32,
-}
-
-impl fmt::Debug for Pages {
-    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 Pages {
-    fn new(pages_gen: Option<Box<dyn Iterator<Item = Result<Page, Box<dyn Error>>>>>) -> 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, Box<dyn 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, Box<dyn 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>>, Box<dyn 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 {
-    pages: Pages,
-    text_section: TextSection,
-    insns: Vec<Insn>,
-}
-
-impl Parser {
-    fn new() -> Self {
-        Self {
-            pages: Pages::new(None),
-            text_section: TextSection::first(),
-            insns: Vec::new(),
-        }
-    }
-    fn page(&mut self) -> Result<Rc<Page>, Box<dyn 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>>>>, Box<dyn Error>> {
-        Ok(self
-            .page()?
-            .unprocessed_chars
-            .borrow_mut()
-            .entry(self.text_section)
-            .or_default()
-            .clone())
-    }
-    fn pages_gen(
-        file: &str,
-        page_numbers: Option<Vec<NonZero<u32>>>,
-    ) -> Result<Box<dyn Iterator<Item = Result<Page, Box<dyn Error>>>>, Box<dyn Error>> {
-        let page_numbers = page_numbers.map(|page_numbers| {
-            let mut retval = Vec::from_iter(page_numbers.into_iter().map(|v| v.get() - 1));
-            retval.sort();
-            retval
-        });
-        let document = mupdf::Document::open(file)?;
-        let pages: Vec<mupdf::Page> = document.pages().and_then(|pages| pages.collect())?;
-        Ok(Box::new(pages.into_iter().enumerate().map(
-            move |(i, page)| {
-                let page_num = match &page_numbers {
-                    Some(page_numbers) => page_numbers[i] + 1,
-                    None => i as u32 + 1,
-                };
-                println!("page {page_num}");
-                Ok(Page::from_mupdf_page(page_num, page)
-                    .map_err(|e| format!("error reading pdf page {page_num}: {e}"))?)
-            },
-        )))
-    }
-    fn parse_pdf<I: Iterator<Item = NonZero<u32>>>(
-        &mut self,
-        file: &str,
-        page_numbers: Option<I>,
-    ) -> Result<(), Box<dyn Error>> {
-        self.pages = Pages::new(Some(Self::pages_gen(
-            file,
-            page_numbers.map(|v| v.into_iter().collect()),
-        )?));
-        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(
-        &mut self,
-        f: impl FnOnce(&mut Self) -> Result<(), Box<dyn Error>>,
-    ) -> Result<(), Box<dyn Error>> {
-        let start_text_section = self.text_section;
-        match f(self) {
-            Ok(()) => Ok(()),
-            Err(e) => {
-                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(format!("{e}\nnote: {note}").into())
-            }
-        }
-    }
-    fn parse_text_section(&mut self) -> Result<(), Box<dyn Error>> {
-        todo!()
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-struct MyDevice {
-    qt: Rc<RefCell<BTreeMap<TextSection, QuadTree<PageItem>>>>,
-    unprocessed_non_text: Rc<RefCell<IndexSet<LineOrRect>>>,
-}
-
-impl mupdf::NativeDevice for MyDevice {
-    fn fill_path(
-        &mut self,
-        path: &mupdf::Path,
-        even_odd: bool,
-        cmt: mupdf::Matrix,
-        color_space: &mupdf::Colorspace,
-        color: &[f32],
-        alpha: f32,
-        cp: mupdf::ColorParams,
-    ) {
-        // TODO
-    }
-
-    fn stroke_path(
-        &mut self,
-        path: &mupdf::Path,
-        stroke_state: &mupdf::StrokeState,
-        cmt: mupdf::Matrix,
-        color_space: &mupdf::Colorspace,
-        color: &[f32],
-        alpha: f32,
-        cp: mupdf::ColorParams,
-    ) {
-        // TODO
-    }
-
-    fn clip_path(
-        &mut self,
-        path: &mupdf::Path,
-        even_odd: bool,
-        cmt: mupdf::Matrix,
-        scissor: mupdf::Rect,
-    ) {
-        // TODO
-    }
-
-    fn clip_stroke_path(
-        &mut self,
-        path: &mupdf::Path,
-        stroke_state: &mupdf::StrokeState,
-        cmt: mupdf::Matrix,
-        scissor: mupdf::Rect,
-    ) {
-        // TODO
-    }
-}
-
-#[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::Page,
-    ) -> Result<Self, Box<dyn std::error::Error>> {
-        let device = MyDevice::default();
-        page.run(
-            &mupdf::Device::from_native(device.clone())?,
-            &mupdf::Matrix::IDENTITY,
-        )?;
-        let MyDevice {
-            qt,
-            unprocessed_non_text,
-        } = device;
-        let mut qt = Rc::try_unwrap(qt)
-            .ok()
-            .expect("already dropped all other references")
-            .into_inner();
-        let unprocessed_chars: Rc<
-            RefCell<BTreeMap<TextSection, Rc<RefCell<BTreeMap<Font, IndexSet<Char>>>>>>,
-        > = Rc::default();
-        // we convert to xml and parse that becuase the mupdf rust crate doesn't include all the API surface we need.
-        let xml = page.to_xml()?;
-        let MuPdfXml::Page(xml_page) = quick_xml::de::from_str(&xml)?;
-        for xml_block in xml_page.block {
-            for xml_line in xml_block.line {
-                for xml_font in xml_line.font {
-                    const ROUND_FACTOR: f32 = 1000.0;
-                    let font_size = (xml_font.size * ROUND_FACTOR).round() / ROUND_FACTOR;
-                    let font_size = NonNaNF32::new(font_size).ok_or("font size must not be NaN")?;
-                    let font = Font::new(&xml_font.name, font_size);
-                    for xml_char in xml_font.char {
-                        let [x0, y0, x1, y1, x2, y2, x3, y3] = xml_char.quad;
-                        let min_x = x0.min(x1).min(x2).min(x3);
-                        let max_x = x0.max(x1).max(x2).max(x3);
-                        let min_y = y0.min(y1).min(y2).min(y3);
-                        let max_y = y0.max(y1).max(y2).max(y3);
-                        let Some(text_section) = TextSection::for_position(
-                            page_num,
-                            (min_x + max_x) * 0.5,
-                            (min_y + max_y) * 0.5,
-                        ) else {
-                            if PAGE_BODY_MIN_Y <= min_y && min_y <= PAGE_BODY_MAX_Y {
-                                if page_num != 1072 {
-                                    // page 1072 has characters in the margins
-                                    return Err(
-                                        format!("char not in text section: {xml_char:?}\npage_num={page_num}").into(),
-                                    );
-                                }
-                            }
-                            continue;
-                        };
-                        let char = Char {
-                            font: font.clone(),
-                            text: xml_char.c.into_owned(),
-                            min_x: NonNaNF32::new(min_x).ok_or("char position shouldn't be NaN")?,
-                            min_y: NonNaNF32::new(min_y).ok_or("char position shouldn't be NaN")?,
-                            max_x: NonNaNF32::new(max_x).ok_or("char position shouldn't be NaN")?,
-                            max_y: NonNaNF32::new(max_y).ok_or("char position shouldn't be NaN")?,
-                        };
-                        qt.entry(text_section).or_default().insert(
-                            min_x,
-                            min_y,
-                            PageItem::Char(char.clone()),
-                        );
-                        unprocessed_chars
-                            .borrow_mut()
-                            .entry(text_section)
-                            .or_default()
-                            .borrow_mut()
-                            .entry(char.font.clone())
-                            .or_default()
-                            .insert(char);
-                    }
-                }
-            }
-        }
-        for i in unprocessed_chars.borrow_mut().values_mut() {
-            for j in i.borrow_mut().values_mut() {
-                j.sort_by_key(Char::top_down_left_to_right_sort_key);
-            }
-        }
-        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,
-            unprocessed_chars,
-            unprocessed_non_text,
-        })
-    }
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args: Vec<String> = std::env::args().collect();
-    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
-    };
-    let mut parser = Parser::new();
-    let is_subset = page_numbers.is_some();
-    let file_name = &args[1];
-    parser.parse_pdf(file_name, page_numbers)?;
-    let mut insns = xml_tree::Element::new(
-        "instructions".into(),
-        [("is-subset".into(), is_subset.to_string())],
-    );
-    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(())
-}
diff --git a/src/quad_tree.rs b/src/quad_tree.rs
deleted file mode 100644
index 0c57597..0000000
--- a/src/quad_tree.rs
+++ /dev/null
@@ -1,1115 +0,0 @@
-// 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
deleted file mode 100644
index 6139ca6..0000000
--- a/src/xml_tree.rs
+++ /dev/null
@@ -1,220 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// See Notices.txt for copyright information
-
-use quick_xml::{
-    Writer,
-    events::{BytesDecl, 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) => {
-                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 {
-            writer.write_event(Event::Decl(BytesDecl::new("1.0", Some("utf-8"), None)))?;
-            writer.write_event(Event::Text(BytesText::new("\n")))?;
-        }
-        self.write_to(&mut writer)
-    }
-}