diff --git a/.gitignore b/.gitignore
index 37b3676..454d147 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@ __pycache__
 *.log
 /powerisa-instructions.xml
 /*.pdf
+/target
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..e85021f
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,419 @@
+# 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 = [
+ "libm",
+ "mupdf",
+ "quick-xml",
+]
+
+[[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",
+]
+
+[[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_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
new file mode 100644
index 0000000..dd8f2bc
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,16 @@
+# 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]
+libm = "0.2.15"
+mupdf = { version = "0.5.0", default-features = false }
+quick-xml = "0.38.4"
diff --git a/scripts/check-copyright.sh b/scripts/check-copyright.sh
index 640fb4b..a9dc2bc 100755
--- a/scripts/check-copyright.sh
+++ b/scripts/check-copyright.sh
@@ -32,6 +32,7 @@ function check_file()
 }
 
 POUND_HEADER=('^"# SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"# See Notices.txt for copyright information"$')
+SLASH_HEADER=('^"// SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"// See Notices.txt for copyright information"$')
 MD_HEADER=('^"<!--"$' '^"SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"See Notices.txt for copyright information"$')
 
 function main()
@@ -41,6 +42,9 @@ function main()
     local file
     for file in $(git ls-tree --name-only --full-tree -r HEAD); do
         case "/$file" in
+        /Cargo.lock)
+            # generated file
+            ;;
         */LICENSE.md|*/Notices.txt)
             # copyright file
             ;;
@@ -53,6 +57,9 @@ function main()
         *.sh)
             check_file "$file" '^'\''#!'\' "${POUND_HEADER[@]}"
             ;;
+        *.rs)
+            check_file "$file" "${SLASH_HEADER[@]}"
+            ;;
         *)
             fail_file "$file" 0 "unimplemented file kind -- you need to add it to $0"
             ;;
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..5d7e01c
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+mod quad_tree;
+
+fn main() {}
diff --git a/src/quad_tree.rs b/src/quad_tree.rs
new file mode 100644
index 0000000..0c57597
--- /dev/null
+++ b/src/quad_tree.rs
@@ -0,0 +1,1115 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+use std::{fmt, ops::ControlFlow};
+
+/// node in a quad-tree extending from `-(2 ** log2_size)` to
+/// `2 ** log2_size` exclusive on both sides in both `x` and `y`
+/// dimensions.
+///
+/// invariants:
+/// * if `self.values is not None` then all of
+///     `nx_ny`, `px_ny`, `nx_py`, and `px_py` are `None`.
+/// * the `log2_size` field of all of `nx_ny`, `px_ny`, `nx_py`, and `px_py`
+///     is always `self.log2_size - 1`.
+enum QuadTreeNode<V> {
+    Interior {
+        log2_size: i32,
+        nx_ny: Option<Box<QuadTreeNode<V>>>,
+        px_ny: Option<Box<QuadTreeNode<V>>>,
+        nx_py: Option<Box<QuadTreeNode<V>>>,
+        px_py: Option<Box<QuadTreeNode<V>>>,
+    },
+    Leaf {
+        log2_size: i32,
+        values: Vec<(f32, f32, V)>,
+    },
+}
+
+struct DebugQuadTreeLeafValues<'a, V>(&'a [(f32, f32, V)]);
+
+impl<V: fmt::Debug> fmt::Debug for DebugQuadTreeLeafValues<'_, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let alternate = f.alternate();
+        let mut debug_list = f.debug_list();
+        for (x, y, v) in self.0 {
+            if alternate {
+                debug_list.entry(&format_args!("({x}, {y}, {v:#?})"));
+            } else {
+                debug_list.entry(&format_args!("({x}, {y}, {v:?})"));
+            }
+        }
+        debug_list.finish()
+    }
+}
+
+impl<V: fmt::Debug> fmt::Debug for QuadTreeNode<V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Interior {
+                log2_size,
+                nx_ny,
+                px_ny,
+                nx_py,
+                px_py,
+            } => {
+                let mut debug_struct = f.debug_struct("Interior");
+                debug_struct.field("log2_size", log2_size);
+                if let Some(nx_ny) = nx_ny {
+                    debug_struct.field("nx_ny", nx_ny);
+                }
+                if let Some(px_ny) = px_ny {
+                    debug_struct.field("px_ny", px_ny);
+                }
+                if let Some(nx_py) = nx_py {
+                    debug_struct.field("nx_py", nx_py);
+                }
+                if let Some(px_py) = px_py {
+                    debug_struct.field("px_py", px_py);
+                }
+                debug_struct.finish()
+            }
+            Self::Leaf { log2_size, values } => f
+                .debug_struct("Leaf")
+                .field("log2_size", log2_size)
+                .field("values", &DebugQuadTreeLeafValues(values))
+                .finish(),
+        }
+    }
+}
+
+trait Trace<V> {
+    fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug;
+    fn debug_value(v: &V) -> impl fmt::Debug;
+    fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result);
+}
+
+impl<V, T: Trace<V>> Trace<V> for &'_ mut T {
+    fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug {
+        T::debug_quad_tree_node(v)
+    }
+    fn debug_value(v: &V) -> impl fmt::Debug {
+        T::debug_value(v)
+    }
+    fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {
+        T::trace(self, msg);
+    }
+}
+
+impl<V> Trace<V> for () {
+    fn debug_quad_tree_node(_v: &QuadTreeNode<V>) -> impl fmt::Debug {
+        unreachable!()
+    }
+    fn debug_value(_v: &V) -> impl fmt::Debug {
+        unreachable!()
+    }
+    fn trace(&mut self, _msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {}
+}
+
+impl<V> QuadTreeNode<V> {
+    fn log2_size(&self) -> i32 {
+        match *self {
+            QuadTreeNode::Interior { log2_size, .. } | QuadTreeNode::Leaf { log2_size, .. } => {
+                log2_size
+            }
+        }
+    }
+    fn split<Tr: Trace<V>>(
+        &mut self,
+        split_x: f32,
+        split_y: f32,
+        delta: f32,
+        max_leaf_size: usize,
+        trace: &mut Tr,
+    ) {
+        let Self::Leaf {
+            log2_size,
+            ref mut values,
+        } = *self
+        else {
+            unreachable!("can't split interior node");
+        };
+        if values.len() <= max_leaf_size {
+            return;
+        }
+        let values = std::mem::take(values);
+        *self = Self::Interior {
+            log2_size,
+            nx_ny: None,
+            px_ny: None,
+            nx_py: None,
+            px_py: None,
+        };
+        for value @ (x, y, _) in values {
+            let Self::Interior {
+                log2_size: _,
+                nx_ny,
+                px_ny,
+                nx_py,
+                px_py,
+            } = self
+            else {
+                unreachable!();
+            };
+            let child = if x < split_x {
+                if y < split_y { nx_ny } else { nx_py }
+            } else {
+                if y < split_y { px_ny } else { px_py }
+            };
+            let QuadTreeNode::Leaf {
+                log2_size: _,
+                values,
+            } = &mut **child.get_or_insert_with(|| {
+                Box::new(QuadTreeNode::Leaf {
+                    log2_size: log2_size - 1,
+                    values: Vec::new(),
+                })
+            })
+            else {
+                unreachable!();
+            };
+            values.push(value);
+        }
+        trace.trace(|w| {
+            writeln!(
+                w,
+                "split leaf split_x={split_x} split_y={split_y} delta={delta} self={:#?}",
+                Tr::debug_quad_tree_node(self),
+            )
+        });
+        let Self::Interior {
+            log2_size: _,
+            nx_ny,
+            px_ny,
+            nx_py,
+            px_py,
+        } = self
+        else {
+            unreachable!();
+        };
+        if let Some(nx_ny) = nx_ny {
+            nx_ny.split(
+                split_x - delta,
+                split_y - delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(nx_py) = nx_py {
+            nx_py.split(
+                split_x - delta,
+                split_y + delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(px_ny) = px_ny {
+            px_ny.split(
+                split_x + delta,
+                split_y - delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(px_py) = px_py {
+            px_py.split(
+                split_x + delta,
+                split_y + delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+    }
+    fn range<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B, Tr: Trace<V>>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        node_min_x: f32,
+        node_max_x: f32,
+        node_min_y: f32,
+        node_max_y: f32,
+        callback: &mut F,
+        trace: &mut Tr,
+    ) -> ControlFlow<B> {
+        match self {
+            Self::Leaf {
+                log2_size: _,
+                values,
+            } => {
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "range(\n    \
+                min_x={min_x}, max_x={max_x},\n    \
+                min_y={min_y}, max_y={max_y},\n    \
+                node_min_x={node_min_x}, node_max_x={node_max_x},\n    \
+                node_min_y={node_min_y}, node_max_y={node_max_y},\n): \
+                leaf {:#?}",
+                        Tr::debug_quad_tree_node(self)
+                    )
+                });
+                for &(x, y, ref v) in values {
+                    if min_x <= x && x <= max_x && min_y <= y && y <= max_y {
+                        trace.trace(|w| writeln!(w, "yielding {:#?}", (x, y, Tr::debug_value(v))));
+                        callback(x, y, v)?;
+                    } else {
+                        trace.trace(|w| writeln!(w, "skipping {:#?}", (x, y, Tr::debug_value(v))));
+                    }
+                }
+                ControlFlow::Continue(())
+            }
+            &Self::Interior {
+                log2_size: _,
+                ref nx_ny,
+                ref px_ny,
+                ref nx_py,
+                ref px_py,
+            } => {
+                let split_x = (node_min_x + node_max_x) * 0.5;
+                let split_y = (node_min_y + node_max_y) * 0.5;
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "range(\n    \
+                min_x={min_x}, max_x={max_x},\n    \
+                min_y={min_y}, max_y={max_y},\n    \
+                node_min_x={node_min_x}, node_max_x={node_max_x},\n    \
+                node_min_y={node_min_y}, node_max_y={node_max_y},\n): \
+                interior split_x={split_x} split_y={split_y} {:#?}",
+                        Tr::debug_quad_tree_node(self),
+                    )
+                });
+                if let Some(v) = nx_ny {
+                    if min_x <= split_x && min_y <= split_y {
+                        let node_max_x = split_x;
+                        let node_max_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = nx_py {
+                    if min_x <= split_x && max_y >= split_y {
+                        let node_max_x = split_x;
+                        let node_min_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = px_ny {
+                    if max_x >= split_x && min_y <= split_y {
+                        let node_min_x = split_x;
+                        let node_max_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = px_py {
+                    if max_x >= split_x && max_y >= split_y {
+                        let node_min_x = split_x;
+                        let node_min_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                ControlFlow::Continue(())
+            }
+        }
+    }
+}
+
+macro_rules! impl_node_iter {
+    (
+        #[mut = $($mut:tt)?];
+        #[Clone = $($Clone:tt)?];
+        Iter = $Iter:ident;
+        iter = $iter:ident;
+        IterStackEntry = $IterStackEntry:ident;
+        as_iter_stack_entry = $as_iter_stack_entry:ident;
+        as_deref = $as_deref:ident;
+    ) => {
+        impl<V> QuadTreeNode<V> {
+            fn $iter(&$($mut)? self) -> $Iter<'_, V> {
+                $Iter { stack: vec![self.$as_iter_stack_entry()] }
+            }
+            fn $as_iter_stack_entry(&$($mut)? self) -> $IterStackEntry<'_, V> {
+                match self {
+                    QuadTreeNode::Interior {
+                        log2_size: _,
+                        nx_ny,
+                        px_ny,
+                        nx_py,
+                        px_py,
+                    } => $IterStackEntry::NextIsNxNy {
+                        nx_ny: nx_ny.$as_deref(),
+                        px_ny: px_ny.$as_deref(),
+                        nx_py: nx_py.$as_deref(),
+                        px_py: px_py.$as_deref(),
+                    },
+                    QuadTreeNode::Leaf {
+                        log2_size: _,
+                        values,
+                    } => $IterStackEntry::NextIsValues {
+                        values: values.$iter(),
+                    },
+                }
+            }
+        }
+
+        #[derive($($Clone,)? Debug)]
+        enum $IterStackEntry<'a, V> {
+            NextIsNxNy {
+                nx_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsPxNy {
+                px_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsNxPy {
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsPxPy {
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsValues {
+                values: std::slice::$Iter<'a, (f32, f32, V)>,
+            },
+        }
+
+        impl<'a, V> Default for $IterStackEntry<'a, V> {
+            fn default() -> Self {
+                Self::NextIsValues { values: Default::default() }
+            }
+        }
+
+        #[derive($($Clone,)? Debug, Default)]
+        pub struct $Iter<'a, V> {
+            stack: Vec<$IterStackEntry<'a, V>>,
+        }
+
+        impl<'a, V> Iterator for $Iter<'a, V> {
+            type Item = (f32, f32, &'a $($mut)? V);
+
+            fn next(&mut self) -> Option<Self::Item> {
+                while let Some(top) = self.stack.pop() {
+                    match top {
+                        $IterStackEntry::NextIsNxNy {
+                            nx_ny,
+                            px_ny,
+                            nx_py,
+                            px_py,
+                        } => {
+                            self.stack.push($IterStackEntry::NextIsPxNy {
+                                px_ny,
+                                nx_py,
+                                px_py,
+                            });
+                            self.stack
+                                .extend(nx_ny.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsPxNy {
+                            px_ny,
+                            nx_py,
+                            px_py,
+                        } => {
+                            self.stack.push($IterStackEntry::NextIsNxPy {
+                                nx_py,
+                                px_py,
+                            });
+                            self.stack
+                                .extend(px_ny.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsNxPy { nx_py, px_py } => {
+                            self.stack.push($IterStackEntry::NextIsPxPy {
+                                px_py,
+                            });
+                            self.stack
+                                .extend(nx_py.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsPxPy { px_py } => {
+                            self.stack
+                                .extend(px_py.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsValues { mut values } => {
+                            if let Some((x, y, v)) = values.next() {
+                                self.stack
+                                    .push($IterStackEntry::NextIsValues { values });
+                                return Some((*x, *y, v));
+                            }
+                        }
+                    }
+                }
+                None
+            }
+        }
+    };
+}
+
+impl_node_iter! {
+    #[mut =];
+    #[Clone = Clone];
+    Iter = Iter;
+    iter = iter;
+    IterStackEntry = IterStackEntry;
+    as_iter_stack_entry = as_iter_stack_entry;
+    as_deref = as_deref;
+}
+
+impl_node_iter! {
+    #[mut = mut];
+    #[Clone =];
+    Iter = IterMut;
+    iter = iter_mut;
+    IterStackEntry = IterStackEntryMut;
+    as_iter_stack_entry = as_iter_stack_entry_mut;
+    as_deref = as_deref_mut;
+}
+
+pub struct QuadTree<V> {
+    root: QuadTreeNode<V>,
+    max_leaf_size: usize,
+}
+
+impl<V: fmt::Debug> fmt::Debug for QuadTree<V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            root,
+            max_leaf_size: _,
+        } = self;
+        f.write_str("QuadTree(")?;
+        root.fmt(f)?;
+        f.write_str(")")
+    }
+}
+
+impl<V> QuadTree<V> {
+    pub const DEFAULT_MAX_LEAF_SIZE: usize = 16;
+    pub const fn new() -> Self {
+        Self::with_max_leaf_size(Self::DEFAULT_MAX_LEAF_SIZE)
+    }
+    pub const fn with_max_leaf_size(max_leaf_size: usize) -> Self {
+        Self {
+            root: QuadTreeNode::Leaf {
+                log2_size: 0,
+                values: Vec::new(),
+            },
+            max_leaf_size,
+        }
+    }
+    pub fn from_iter_with_max_leaf_size<I: IntoIterator<Item = (f32, f32, V)>>(
+        iter: I,
+        max_leaf_size: usize,
+    ) -> Self {
+        let mut retval = Self::with_max_leaf_size(max_leaf_size);
+        retval.extend(iter);
+        retval
+    }
+    pub fn iter(&self) -> Iter<'_, V> {
+        self.root.iter()
+    }
+    pub fn iter_mut(&mut self) -> IterMut<'_, V> {
+        self.root.iter_mut()
+    }
+    fn expand_root<Tr: Trace<V>>(&mut self, target_log2_size: i32, trace: &mut Tr) {
+        match &mut self.root {
+            QuadTreeNode::Leaf {
+                log2_size,
+                values: _,
+            } => {
+                if target_log2_size > *log2_size {
+                    // leaf node -- just expand in place
+                    trace.trace(|w| writeln!(w, "expand_root({target_log2_size}) leaf"));
+                    *log2_size = target_log2_size;
+                }
+            }
+            QuadTreeNode::Interior { .. } => {
+                while target_log2_size > self.root.log2_size() {
+                    trace.trace(|w| {
+                        writeln!(
+                            w,
+                            "expand_root({target_log2_size}) interior: {:#?}",
+                            Tr::debug_quad_tree_node(&self.root)
+                        )
+                    });
+                    let QuadTreeNode::Interior {
+                        log2_size,
+                        nx_ny,
+                        px_ny,
+                        nx_py,
+                        px_py,
+                    } = &mut self.root
+                    else {
+                        unreachable!();
+                    };
+                    *nx_ny = nx_ny.take().map(|nx_ny| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: None,
+                            nx_py: None,
+                            px_py: Some(nx_ny),
+                        })
+                    });
+                    *px_ny = px_ny.take().map(|px_ny| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: None,
+                            nx_py: Some(px_ny),
+                            px_py: None,
+                        })
+                    });
+                    *nx_py = nx_py.take().map(|nx_py| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: Some(nx_py),
+                            nx_py: None,
+                            px_py: None,
+                        })
+                    });
+                    *px_py = px_py.take().map(|px_py| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: Some(px_py),
+                            px_ny: None,
+                            nx_py: None,
+                            px_py: None,
+                        })
+                    });
+                    *log2_size += 1
+                }
+            }
+        }
+        trace.trace(|w| {
+            writeln!(
+                w,
+                "expand_root({target_log2_size}) done: {:#?}",
+                Tr::debug_quad_tree_node(&self.root)
+            )
+        });
+    }
+    fn range_with_trace<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B, Tr: Trace<V>>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        mut callback: F,
+        mut trace: Tr,
+    ) -> ControlFlow<B> {
+        assert!(!(min_x.is_nan() || max_x.is_nan() || min_y.is_nan() || max_y.is_nan()));
+        if min_x > max_x || min_y > max_y {
+            return ControlFlow::Continue(());
+        }
+        let size = libm::ldexpf(1.0, self.root.log2_size());
+        self.root.range(
+            min_x,
+            max_x,
+            min_y,
+            max_y,
+            -size,
+            size,
+            -size,
+            size,
+            &mut callback,
+            &mut trace,
+        )
+    }
+    pub fn range<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        callback: F,
+    ) -> ControlFlow<B> {
+        self.range_with_trace(min_x, max_x, min_y, max_y, callback, ())
+    }
+    fn insert_with_trace_inner<Tr: Trace<V>>(
+        node: &mut QuadTreeNode<V>,
+        x: f32,
+        y: f32,
+        value: V,
+        split_x: f32,
+        split_y: f32,
+        delta: f32,
+        max_leaf_size: usize,
+        trace: &mut Tr,
+    ) {
+        match node {
+            QuadTreeNode::Interior { .. } => {
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "insert({x}, {y}, _): interior: split_x={split_x} \
+                    split_y={split_y} delta={delta} node={:#?}",
+                        Tr::debug_quad_tree_node(node)
+                    )
+                });
+                let QuadTreeNode::Interior {
+                    log2_size,
+                    nx_ny,
+                    px_ny,
+                    nx_py,
+                    px_py,
+                } = node
+                else {
+                    unreachable!();
+                };
+                if x < split_x {
+                    if y < split_y {
+                        let Some(node) = nx_ny else {
+                            *nx_ny = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert nx_ny leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x - delta,
+                            split_y - delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    } else {
+                        let Some(node) = nx_py else {
+                            *nx_py = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert nx_py leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x - delta,
+                            split_y + delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    }
+                } else {
+                    if y < split_y {
+                        let Some(node) = px_ny else {
+                            *px_ny = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert px_ny leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x + delta,
+                            split_y - delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    } else {
+                        let Some(node) = px_py else {
+                            *px_py = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert px_py leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x + delta,
+                            split_y + delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    }
+                }
+            }
+            QuadTreeNode::Leaf {
+                log2_size: _,
+                values,
+            } => {
+                // got to a leaf
+                values.push((x, y, value));
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "insert({x}, {y}, _): leaf node={:#?}",
+                        Tr::debug_quad_tree_node(node)
+                    )
+                });
+                node.split(split_x, split_y, delta, max_leaf_size, trace)
+            }
+        }
+    }
+    fn insert_with_trace<Tr: Trace<V>>(&mut self, x: f32, y: f32, value: V, mut trace: Tr) {
+        assert!(x.is_finite() && y.is_finite(), "invalid coordinates");
+        trace.trace(|w| writeln!(w, "insert({x}, {y}, {:#?})", Tr::debug_value(&value)));
+        let abs_x = x.abs();
+        let abs_y = y.abs();
+        let abs_max = abs_x.max(abs_y);
+        let (_, log2_abs_max) = libm::frexpf(abs_max);
+        trace.trace(|w| writeln!(w, "insert({x}, {y}, _): log2_abs_max={log2_abs_max}"));
+        self.expand_root(log2_abs_max, &mut trace);
+        let delta = libm::ldexpf(0.5, self.root.log2_size());
+        Self::insert_with_trace_inner(
+            &mut self.root,
+            x,
+            y,
+            value,
+            0.0,
+            0.0,
+            delta,
+            self.max_leaf_size,
+            &mut trace,
+        );
+    }
+    pub fn insert(&mut self, x: f32, y: f32, value: V) {
+        self.insert_with_trace(x, y, value, &mut ());
+    }
+}
+
+impl<V> Default for QuadTree<V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<V> FromIterator<(f32, f32, V)> for QuadTree<V> {
+    fn from_iter<T: IntoIterator<Item = (f32, f32, V)>>(iter: T) -> Self {
+        Self::from_iter_with_max_leaf_size(iter, Self::DEFAULT_MAX_LEAF_SIZE)
+    }
+}
+
+impl<V> Extend<(f32, f32, V)> for QuadTree<V> {
+    fn extend<T: IntoIterator<Item = (f32, f32, V)>>(&mut self, iter: T) {
+        iter.into_iter().for_each(|(x, y, v)| {
+            self.insert(x, y, v);
+        });
+    }
+}
+
+impl<'a, V> IntoIterator for &'a QuadTree<V> {
+    type Item = (f32, f32, &'a V);
+    type IntoIter = Iter<'a, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.root.iter()
+    }
+}
+
+impl<'a, V> IntoIterator for &'a mut QuadTree<V> {
+    type Item = (f32, f32, &'a mut V);
+    type IntoIter = IterMut<'a, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.root.iter_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Print;
+
+    impl<V: fmt::Debug> Trace<V> for Print {
+        fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug {
+            v
+        }
+
+        fn debug_value(v: &V) -> impl fmt::Debug {
+            v
+        }
+
+        fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {
+            let mut out = String::new();
+            msg(&mut out).unwrap();
+            print!("{out}");
+        }
+    }
+
+    #[test]
+    fn test_quad_tree_range() {
+        let mut items = vec![];
+        for x in 0..8 {
+            let mut x = x as f32 + 0.5;
+            x /= 4.0;
+            for y in 0..8 {
+                let mut y = y as f32 + 0.5;
+                y /= 4.0;
+                items.push((x, y, format!("{x},{y}")));
+            }
+        }
+        items.sort_by(|l, r| l.partial_cmp(r).unwrap());
+        let qt = QuadTree::from_iter(items.clone());
+        let check_range = |min_x: f32, max_x: f32, min_y: f32, max_y: f32| {
+            println!("min_x={min_x}, max_x={max_x}, min_y={min_y}, max_y={max_y}");
+            let expected = Vec::from_iter(
+                items
+                    .iter()
+                    .filter(|&&(x, y, _)| min_x <= x && x <= max_x && min_y <= y && y <= max_y)
+                    .map(|&(x, y, ref v)| (x, y, v)),
+            );
+            let mut range_result = Vec::new();
+            let _ = qt.range_with_trace(
+                min_x,
+                max_x,
+                min_y,
+                max_y,
+                |x, y, v| {
+                    range_result.push((x, y, v));
+                    ControlFlow::<()>::Continue(())
+                },
+                &mut Print,
+            );
+            range_result.sort_by(|l, r| l.partial_cmp(r).unwrap());
+            println!("expected={expected:?}");
+            println!("range_result={range_result:?}");
+            assert_eq!(expected, range_result);
+        };
+        check_range(-1.0, 1.0, -1.0, 1.0);
+        check_range(0.125, 0.25, 0.125, 0.25);
+        check_range(items[0].0, items[0].0, items[0].1, items[0].1);
+        check_range(1.0, 0.0, -1.0, 1.0);
+    }
+
+    #[test]
+    fn test_quad_tree_insert() {
+        let mut qt = QuadTree::with_max_leaf_size(4);
+        for x in 0..8 {
+            let mut x = x as f32 + 0.5;
+            x /= 4.0;
+            for y in 0..8 {
+                let mut y = y as f32 + 0.5;
+                y /= 4.0;
+                qt.insert_with_trace(x, y, format!("{x},{y}"), &mut Print);
+            }
+        }
+        println!("{qt:#?}");
+        assert_eq!(
+            format!("{qt:#?}"),
+            r#"QuadTree(Interior {
+    log2_size: 1,
+    px_py: Interior {
+        log2_size: 0,
+        nx_ny: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 0.125, "0.125,0.125"),
+                    (0.125, 0.375, "0.125,0.375"),
+                    (0.375, 0.125, "0.375,0.125"),
+                    (0.375, 0.375, "0.375,0.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 0.125, "0.625,0.125"),
+                    (0.625, 0.375, "0.625,0.375"),
+                    (0.875, 0.125, "0.875,0.125"),
+                    (0.875, 0.375, "0.875,0.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 0.625, "0.125,0.625"),
+                    (0.125, 0.875, "0.125,0.875"),
+                    (0.375, 0.625, "0.375,0.625"),
+                    (0.375, 0.875, "0.375,0.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 0.625, "0.625,0.625"),
+                    (0.625, 0.875, "0.625,0.875"),
+                    (0.875, 0.625, "0.875,0.625"),
+                    (0.875, 0.875, "0.875,0.875"),
+                ],
+            },
+        },
+        px_ny: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 0.125, "1.125,0.125"),
+                    (1.125, 0.375, "1.125,0.375"),
+                    (1.375, 0.125, "1.375,0.125"),
+                    (1.375, 0.375, "1.375,0.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 0.125, "1.625,0.125"),
+                    (1.625, 0.375, "1.625,0.375"),
+                    (1.875, 0.125, "1.875,0.125"),
+                    (1.875, 0.375, "1.875,0.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 0.625, "1.125,0.625"),
+                    (1.125, 0.875, "1.125,0.875"),
+                    (1.375, 0.625, "1.375,0.625"),
+                    (1.375, 0.875, "1.375,0.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 0.625, "1.625,0.625"),
+                    (1.625, 0.875, "1.625,0.875"),
+                    (1.875, 0.625, "1.875,0.625"),
+                    (1.875, 0.875, "1.875,0.875"),
+                ],
+            },
+        },
+        nx_py: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 1.125, "0.125,1.125"),
+                    (0.125, 1.375, "0.125,1.375"),
+                    (0.375, 1.125, "0.375,1.125"),
+                    (0.375, 1.375, "0.375,1.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 1.125, "0.625,1.125"),
+                    (0.625, 1.375, "0.625,1.375"),
+                    (0.875, 1.125, "0.875,1.125"),
+                    (0.875, 1.375, "0.875,1.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 1.625, "0.125,1.625"),
+                    (0.125, 1.875, "0.125,1.875"),
+                    (0.375, 1.625, "0.375,1.625"),
+                    (0.375, 1.875, "0.375,1.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 1.625, "0.625,1.625"),
+                    (0.625, 1.875, "0.625,1.875"),
+                    (0.875, 1.625, "0.875,1.625"),
+                    (0.875, 1.875, "0.875,1.875"),
+                ],
+            },
+        },
+        px_py: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 1.125, "1.125,1.125"),
+                    (1.125, 1.375, "1.125,1.375"),
+                    (1.375, 1.125, "1.375,1.125"),
+                    (1.375, 1.375, "1.375,1.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 1.125, "1.625,1.125"),
+                    (1.625, 1.375, "1.625,1.375"),
+                    (1.875, 1.125, "1.875,1.125"),
+                    (1.875, 1.375, "1.875,1.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 1.625, "1.125,1.625"),
+                    (1.125, 1.875, "1.125,1.875"),
+                    (1.375, 1.625, "1.375,1.625"),
+                    (1.375, 1.875, "1.375,1.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 1.625, "1.625,1.625"),
+                    (1.625, 1.875, "1.625,1.875"),
+                    (1.875, 1.625, "1.875,1.625"),
+                    (1.875, 1.875, "1.875,1.875"),
+                ],
+            },
+        },
+    },
+})"#
+        );
+    }
+}