SYMBOL INDEX (1173 symbols across 111 files)

FILE: analyze_programming_time.py
  function parse_git_log (line 15) | def parse_git_log(log_output):
  function calculate_programming_sessions (line 48) | def calculate_programming_sessions(commits, max_gap_minutes=120):
  function analyze_daily_programming (line 95) | def analyze_daily_programming(sessions):
  function create_visualizations (line 110) | def create_visualizations(sessions, daily_data):
  function print_summary (line 166) | def print_summary(sessions, daily_data):
  function main (line 210) | def main():

FILE: python/benchmarks/performance_benchmark.py
  class BenchmarkSuite (line 24) | class BenchmarkSuite:
    method __init__ (line 27) | def __init__(self, size: int = 10000):
    method time_operation (line 31) | def time_operation(self, name: str, operation):
    method benchmark_sequential_insertion (line 46) | def benchmark_sequential_insertion(self):
    method benchmark_random_insertion (line 57) | def benchmark_random_insertion(self):
    method benchmark_lookups (line 70) | def benchmark_lookups(self, tree: BPlusTreeMap):
    method benchmark_range_queries (line 81) | def benchmark_range_queries(self, tree: BPlusTreeMap):
    method benchmark_iteration (line 96) | def benchmark_iteration(self, tree: BPlusTreeMap):
    method benchmark_deletions (line 104) | def benchmark_deletions(self, tree: BPlusTreeMap):
    method benchmark_dict_comparison (line 115) | def benchmark_dict_comparison(self):
    method run_all_benchmarks (line 152) | def run_all_benchmarks(self):
  function format_results (line 187) | def format_results(results: Dict[str, Any]) -> str:
  function save_results (line 211) | def save_results(results: Dict[str, Any], filename: str = None):
  function main (line 230) | def main():

FILE: python/bplustree/__init__.py
  class BPlusTreeMap (line 19) | class BPlusTreeMap(_c_ext.BPlusTree):
    method __init__ (line 22) | def __init__(self, capacity=None):
    method get (line 29) | def get(self, key, default=None):
    method values (line 36) | def values(self):
    method clear (line 41) | def clear(self):
    method pop (line 51) | def pop(self, key, *args):
    method popitem (line 66) | def popitem(self):
    method setdefault (line 77) | def setdefault(self, key, default=None):
    method update (line 85) | def update(self, other):
    method copy (line 100) | def copy(self):
    method capacity (line 108) | def capacity(self):
    method root (line 113) | def root(self):
    method leaves (line 118) | def leaves(self):
  function get_implementation (line 131) | def get_implementation():

FILE: python/bplustree/bplus_tree.py
  class BPlusTreeError (line 21) | class BPlusTreeError(Exception):
  class InvalidCapacityError (line 27) | class InvalidCapacityError(BPlusTreeError):
  class BPlusTreeMap (line 33) | class BPlusTreeMap:
    method __init__ (line 58) | def __init__(self, capacity: int = DEFAULT_CAPACITY) -> None:
    method from_sorted_items (line 79) | def from_sorted_items(
    method _bulk_load_sorted (line 98) | def _bulk_load_sorted(self, items) -> None:
    method _insert_sorted_optimized (line 114) | def _insert_sorted_optimized(self, key: Any, value: Any) -> None:
    method _update_rightmost_leaf_cache (line 134) | def _update_rightmost_leaf_cache(self) -> None:
    method __setitem__ (line 141) | def __setitem__(self, key: Any, value: Any) -> None:
    method _insert_recursive (line 159) | def _insert_recursive(
    method _insert_into_leaf (line 180) | def _insert_into_leaf(
    method _insert_into_branch (line 199) | def _insert_into_branch(
    method __getitem__ (line 211) | def __getitem__(self, key: Any) -> Any:
    method get (line 221) | def get(self, key: Any, default: Any = None) -> Any:
    method __contains__ (line 238) | def __contains__(self, key: Any) -> bool:
    method __len__ (line 247) | def __len__(self) -> int:
    method __bool__ (line 251) | def __bool__(self) -> bool:
    method __delitem__ (line 255) | def __delitem__(self, key: Any) -> None:
    method _delete_recursive (line 261) | def _delete_recursive(self, node: "Node", key: Any) -> bool:
    method _handle_underflow (line 291) | def _handle_underflow(self, parent: "BranchNode", child_index: int) ->...
    method _redistribute_from_left (line 325) | def _redistribute_from_left(self, parent: "BranchNode", child_index: i...
    method _redistribute_from_right (line 341) | def _redistribute_from_right(self, parent: "BranchNode", child_index: ...
    method _merge_with_sibling (line 357) | def _merge_with_sibling(self, parent: "BranchNode", child_index: int) ...
    method _delete_from_leaf (line 444) | def _delete_from_leaf(self, leaf: "LeafNode", key: Any) -> bool:
    method keys (line 449) | def keys(self, start_key=None, end_key=None) -> Iterator[Any]:
    method values (line 454) | def values(self, start_key=None, end_key=None) -> Iterator[Any]:
    method items (line 459) | def items(self, start_key=None, end_key=None) -> Iterator[Tuple[Any, A...
    method _find_leaf_for_key (line 480) | def _find_leaf_for_key(self, key: Any) -> Optional["LeafNode"]:
    method _find_position_in_leaf (line 484) | def _find_position_in_leaf(self, leaf: "LeafNode", key: Any) -> int:
    method range (line 496) | def range(
    method clear (line 514) | def clear(self) -> None:
    method pop (line 522) | def pop(self, key: Any, *args) -> Any:
    method popitem (line 547) | def popitem(self) -> Tuple[Any, Any]:
    method setdefault (line 569) | def setdefault(self, key: Any, default: Any = None) -> Any:
    method update (line 585) | def update(self, other) -> None:
    method copy (line 604) | def copy(self) -> "BPlusTreeMap":
    method leaf_count (line 617) | def leaf_count(self) -> int:
    method _count_total_nodes (line 626) | def _count_total_nodes(self) -> int:
  class Node (line 640) | class Node(ABC):
    method is_leaf (line 649) | def is_leaf(self) -> bool:
    method is_full (line 654) | def is_full(self) -> bool:
    method __len__ (line 659) | def __len__(self) -> int:
    method is_underfull (line 664) | def is_underfull(self) -> bool:
  class LeafNode (line 669) | class LeafNode(Node):
    method __init__ (line 682) | def __init__(self, capacity: int):
    method is_leaf (line 688) | def is_leaf(self) -> bool:
    method is_full (line 691) | def is_full(self) -> bool:
    method __len__ (line 694) | def __len__(self) -> int:
    method is_underfull (line 697) | def is_underfull(self) -> bool:
    method can_donate (line 702) | def can_donate(self) -> bool:
    method borrow_from_left (line 707) | def borrow_from_left(self, left_sibling: "LeafNode") -> None:
    method borrow_from_right (line 717) | def borrow_from_right(self, right_sibling: "LeafNode") -> None:
    method merge_with_right (line 727) | def merge_with_right(self, right_sibling: "LeafNode") -> None:
    method find_position (line 736) | def find_position(self, key: Any) -> Tuple[int, bool]:
    method insert (line 746) | def insert(self, key: Any, value: Any) -> Optional[Any]:
    method get (line 763) | def get(self, key: Any) -> Optional[Any]:
    method delete (line 770) | def delete(self, key: Any) -> Optional[Any]:
    method split (line 778) | def split(self) -> "LeafNode":
    method split_and_insert (line 800) | def split_and_insert(self, key: Any, value: Any) -> Tuple["LeafNode", ...
    method find_leaf_for_key (line 812) | def find_leaf_for_key(self, _key: Any) -> "LeafNode":
    method key_count (line 816) | def key_count(self) -> int:
  class BranchNode (line 821) | class BranchNode(Node):
    method __init__ (line 838) | def __init__(self, capacity: int):
    method is_leaf (line 843) | def is_leaf(self) -> bool:
    method is_full (line 846) | def is_full(self) -> bool:
    method __len__ (line 849) | def __len__(self) -> int:
    method is_underfull (line 852) | def is_underfull(self) -> bool:
    method can_donate (line 857) | def can_donate(self) -> bool:
    method borrow_from_left (line 862) | def borrow_from_left(self, left_sibling: "BranchNode", separator_key: ...
    method borrow_from_right (line 877) | def borrow_from_right(self, right_sibling: "BranchNode", separator_key...
    method merge_with_right (line 892) | def merge_with_right(self, right_sibling: "BranchNode", separator_key:...
    method find_child_index (line 901) | def find_child_index(self, key: Any) -> int:
    method get_child (line 924) | def get_child(self, key: Any) -> Node:
    method split (line 935) | def split(self) -> "BranchNode":
    method insert_child_and_split_if_needed (line 958) | def insert_child_and_split_if_needed(
    method find_leaf_for_key (line 973) | def find_leaf_for_key(self, key: Any) -> "LeafNode":

FILE: python/bplustree_c_src/bplustree.h
  type NodeType (line 32) | typedef enum {
  type BPlusNode (line 38) | typedef struct BPlusNode BPlusNode;
  type BPlusTree (line 39) | typedef struct BPlusTree BPlusTree;
  type BPlusNode (line 48) | typedef struct BPlusNode {
  type BPlusTree (line 66) | typedef struct BPlusTree {
  function PyObject (line 78) | static inline PyObject* node_get_key(BPlusNode *node, int index) {
  function PyObject (line 82) | static inline PyObject* node_get_value(BPlusNode *node, int index) {
  function BPlusNode (line 86) | static inline BPlusNode* node_get_child(BPlusNode *node, int index) {
  function node_set_key (line 90) | static inline void node_set_key(BPlusNode *node, int index, PyObject *ke...
  function node_set_value (line 94) | static inline void node_set_value(BPlusNode *node, int index, PyObject *...
  function node_set_child (line 98) | static inline void node_set_child(BPlusNode *node, int index, BPlusNode ...
  function BPlusNode (line 103) | static inline BPlusNode *node_prefetch_child(BPlusNode *node, int index) {

FILE: python/bplustree_c_src/bplustree_module.c
  function PyObject (line 22) | PyObject *
  function BPlusTree_init (line 37) | int
  function BPlusTree_dealloc (line 67) | void
  function PyObject (line 77) | PyObject *
  function BPlusTree_setitem (line 83) | int
  function BPlusTree_delitem (line 91) | int
  function Py_ssize_t (line 104) | Py_ssize_t
  function BPlusTree_contains (line 109) | int
  type BPlusTreeIterator (line 123) | typedef struct {
  function BPlusTreeIterator_dealloc (line 132) | static void
  function PyObject (line 138) | static PyObject *
  function PyObject (line 212) | static PyObject *
  function PyObject (line 237) | static PyObject *
  function PyObject (line 242) | static PyObject *
  function PyObject (line 287) | static PyObject *
  function node_gc_op (line 326) | static int
  function node_traverse (line 360) | static int
  function node_clear_gc (line 366) | static int
  function BPlusTree_traverse (line 373) | static int
  function BPlusTree_clear (line 384) | static int
  function PyMODINIT_FUNC (line 434) | PyMODINIT_FUNC

FILE: python/bplustree_c_src/node_ops.c
  function fast_compare_lt (line 17) | int fast_compare_lt(PyObject *a, PyObject *b) {
  function fast_compare_eq (line 43) | int fast_compare_eq(PyObject *a, PyObject *b) {
  function node_find_position (line 68) | int node_find_position(BPlusNode *node, PyObject *key) {
  function BPlusNode (line 92) | BPlusNode* node_create(NodeType type, uint16_t capacity) {
  function node_destroy (line 121) | void node_destroy(BPlusNode *node) {
  function node_clear_slot (line 148) | static void node_clear_slot(BPlusNode *node, int i) {
  function node_insert_leaf (line 172) | int node_insert_leaf(BPlusNode *node, PyObject *key, PyObject *value,
  function node_delete (line 290) | int node_delete(BPlusNode *node, PyObject *key) {
  function PyObject (line 326) | PyObject* node_get(BPlusNode *node, PyObject *key) {
  function cache_aligned_free (line 360) | void cache_aligned_free(void* ptr) {

FILE: python/bplustree_c_src/tree_ops.c
  function BPlusNode (line 11) | BPlusNode* tree_find_leaf(BPlusTree *tree, PyObject *key) {
  function tree_insert_recursive (line 43) | static int tree_insert_recursive(BPlusNode *node, PyObject *key, PyObjec...
  function tree_insert (line 78) | int tree_insert(BPlusTree *tree, PyObject *key, PyObject *value) {
  function tree_delete (line 114) | int tree_delete(BPlusTree *tree, PyObject *key) {
  function PyObject (line 128) | PyObject* tree_get(BPlusTree *tree, PyObject *key) {
  function node_insert_branch (line 135) | int node_insert_branch(BPlusNode *node, PyObject *key, BPlusNode *right_...

FILE: python/examples/basic_usage.py
  function main (line 19) | def main():

FILE: python/examples/migration_guide.py
  function demo_dict_migration (line 19) | def demo_dict_migration():
  function demo_sorteddict_migration (line 67) | def demo_sorteddict_migration():
  function demo_api_compatibility (line 103) | def demo_api_compatibility():
  function demo_performance_benefits (line 154) | def demo_performance_benefits():
  function demo_gotchas_and_tips (line 185) | def demo_gotchas_and_tips():
  function demo_real_world_migration (line 223) | def demo_real_world_migration():
  function main (line 270) | def main():

FILE: python/examples/performance_demo.py
  function benchmark_function (line 32) | def benchmark_function(func, *args, **kwargs):
  function create_test_data (line 40) | def create_test_data(size):
  function benchmark_range_queries (line 45) | def benchmark_range_queries():
  function benchmark_iteration (line 123) | def benchmark_iteration():
  function benchmark_insertion (line 175) | def benchmark_insertion():
  function benchmark_memory_usage (line 221) | def benchmark_memory_usage():
  function demonstrate_early_termination (line 246) | def demonstrate_early_termination():
  function capacity_tuning_demo (line 291) | def capacity_tuning_demo():
  function main (line 323) | def main():

FILE: python/examples/range_queries.py
  function demo_basic_range_queries (line 21) | def demo_basic_range_queries():
  function demo_practical_use_cases (line 67) | def demo_practical_use_cases():
  function demo_pagination_pattern (line 132) | def demo_pagination_pattern():
  function demo_performance_comparison (line 182) | def demo_performance_comparison():
  function main (line 238) | def main():

FILE: python/setup.py
  function get_version (line 15) | def get_version():
  function get_long_description (line 26) | def get_long_description():

FILE: python/tests/_invariant_checker.py
  class BPlusTreeInvariantChecker (line 24) | class BPlusTreeInvariantChecker:
    method __init__ (line 32) | def __init__(self, capacity: int):
    method check_invariants (line 35) | def check_invariants(
    method _check_keys_ascending (line 89) | def _check_keys_ascending(self, node: "Node") -> bool:
    method _check_min_occupancy (line 117) | def _check_min_occupancy(self, node: "Node", is_root: bool = False) ->...
    method _check_max_occupancy (line 143) | def _check_max_occupancy(self, node: "Node") -> bool:
    method _check_branch_structure (line 160) | def _check_branch_structure(self, node: "Node") -> bool:
    method _check_leaf_consistency (line 184) | def _check_leaf_consistency(self, node: "Node") -> bool:
    method _check_leaf_ordering (line 205) | def _check_leaf_ordering(self, leaves_head: "LeafNode") -> bool:
    method _check_uniform_depth (line 222) | def _check_uniform_depth(self, node: "Node") -> bool:
    method _get_leaf_depths (line 236) | def _get_leaf_depths(
    method _find_root (line 257) | def _find_root(self, node: "Node") -> "Node":
    method count_nodes_per_level (line 262) | def count_nodes_per_level(self, node: "Node") -> List[int]:
    method get_tree_stats (line 289) | def get_tree_stats(self, node: "Node") -> dict:
    method _count_total_keys (line 318) | def _count_total_keys(self, node: "Node") -> int:
    method _count_total_nodes (line 330) | def _count_total_nodes(self, node: "Node") -> int:

FILE: python/tests/comprehensive_fuzz_test.py
  function run_capacity_sweep (line 18) | def run_capacity_sweep():
  function run_stress_test (line 152) | def run_stress_test():
  function run_edge_case_tests (line 185) | def run_edge_case_tests():

FILE: python/tests/fuzz_test.py
  function check_invariants (line 27) | def check_invariants(tree: BPlusTreeMap) -> bool:
  class BPlusTreeFuzzTester (line 33) | class BPlusTreeFuzzTester:
    method __init__ (line 36) | def __init__(self, capacity: int = 16, seed: int = None, prepopulate: ...
    method log_operation (line 66) | def log_operation(
    method _prepopulate_tree (line 74) | def _prepopulate_tree(self, count: int) -> None:
    method _calculate_tree_depth (line 122) | def _calculate_tree_depth(self) -> int:
    method verify_consistency (line 134) | def verify_consistency(self) -> bool:
    method _get_all_btree_keys (line 174) | def _get_all_btree_keys(self) -> List[Any]:
    method random_key (line 183) | def random_key(self, existing_bias: float = 0.7) -> Any:
    method random_value (line 190) | def random_value(self) -> str:
    method do_insert_or_update (line 194) | def do_insert_or_update(self):
    method do_delete (line 209) | def do_delete(self):
    method do_get (line 241) | def do_get(self):
    method do_batch_delete (line 269) | def do_batch_delete(self):
    method do_compact (line 312) | def do_compact(self):
    method run_fuzz_test (line 318) | def run_fuzz_test(self, num_operations: int = 1000000) -> bool:
    method _save_failure_info (line 387) | def _save_failure_info(self, failed_at: int):
  function run_quick_fuzz_test (line 473) | def run_quick_fuzz_test():
  function run_full_fuzz_test (line 481) | def run_full_fuzz_test():
  function run_complex_structure_test (line 489) | def run_complex_structure_test():
  function run_varied_capacity_tests (line 505) | def run_varied_capacity_tests():

FILE: python/tests/test_bplus_tree.py
  function check_invariants (line 10) | def check_invariants(tree: BPlusTreeMap) -> bool:
  class TestBasicOperations (line 16) | class TestBasicOperations:
    method test_create_empty_tree (line 19) | def test_create_empty_tree(self):
    method test_insert_and_get_single_item (line 26) | def test_insert_and_get_single_item(self):
    method test_insert_multiple_items (line 37) | def test_insert_multiple_items(self):
    method test_update_existing_key (line 50) | def test_update_existing_key(self):
    method test_contains_operator (line 60) | def test_contains_operator(self):
    method test_get_with_default (line 71) | def test_get_with_default(self):
    method test_key_error_on_missing_key (line 81) | def test_key_error_on_missing_key(self):
  class TestSetItemSplitting (line 92) | class TestSetItemSplitting:
    method test_overflow (line 95) | def test_overflow(self):
    method test_split_then_add (line 114) | def test_split_then_add(self):
    method test_many_insertions_maintain_invariants (line 144) | def test_many_insertions_maintain_invariants(self):
    method test_parent_splitting (line 158) | def test_parent_splitting(self):
  class TestLeafNode (line 186) | class TestLeafNode:
    method test_leaf_node_creation (line 189) | def test_leaf_node_creation(self):
    method test_leaf_node_insert (line 196) | def test_leaf_node_insert(self):
    method test_leaf_node_full (line 220) | def test_leaf_node_full(self):
    method test_leaf_find_position (line 231) | def test_leaf_find_position(self):
  class TestRemoval (line 250) | class TestRemoval:
    method test_remove_single_item_from_leaf_root (line 253) | def test_remove_single_item_from_leaf_root(self):
    method test_remove_multiple_items_from_leaf_root (line 270) | def test_remove_multiple_items_from_leaf_root(self):
    method test_remove_nonexistent_key_raises_error (line 306) | def test_remove_nonexistent_key_raises_error(self):
    method test_remove_from_tree_with_branch_root (line 322) | def test_remove_from_tree_with_branch_root(self):
    method test_remove_multiple_from_tree_with_branches (line 346) | def test_remove_multiple_from_tree_with_branches(self):
    method test_collapse_root_when_empty (line 375) | def test_collapse_root_when_empty(self):
  class TestNodeUnderflow (line 402) | class TestNodeUnderflow:
    method test_leaf_underflow_detection (line 405) | def test_leaf_underflow_detection(self):
    method test_branch_underflow_detection (line 424) | def test_branch_underflow_detection(self):
    method test_underflow_after_deletion_creates_violation (line 443) | def test_underflow_after_deletion_creates_violation(self):
    method test_deletion_can_violate_underflow_invariant (line 465) | def test_deletion_can_violate_underflow_invariant(self):
    method _tree_has_underflow (line 493) | def _tree_has_underflow(self, tree) -> bool:
  class TestBranchNode (line 512) | class TestBranchNode:
    method test_branch_node_creation (line 515) | def test_branch_node_creation(self):
    method test_find_child_index (line 522) | def test_find_child_index(self):
    method test_branch_node_split (line 540) | def test_branch_node_split(self):
  class TestSiblingRedistribution (line 559) | class TestSiblingRedistribution:
    method test_leaf_can_donate (line 562) | def test_leaf_can_donate(self):
    method test_branch_can_donate (line 584) | def test_branch_can_donate(self):
    method test_leaf_borrow_from_left (line 606) | def test_leaf_borrow_from_left(self):
    method test_leaf_borrow_from_right (line 628) | def test_leaf_borrow_from_right(self):
    method test_branch_borrow_from_left (line 650) | def test_branch_borrow_from_left(self):
    method test_branch_borrow_from_right (line 673) | def test_branch_borrow_from_right(self):
    method test_redistribution_during_deletion (line 696) | def test_redistribution_during_deletion(self):
    method test_actual_redistribution_scenario (line 720) | def test_actual_redistribution_scenario(self):
    method test_forced_redistribution_scenario (line 745) | def test_forced_redistribution_scenario(self):
  class TestNodeMerging (line 778) | class TestNodeMerging:
    method test_leaf_merge_with_right (line 781) | def test_leaf_merge_with_right(self):
    method test_branch_merge_with_right (line 805) | def test_branch_merge_with_right(self):
    method test_merging_during_deletion_creates_balanced_tree (line 825) | def test_merging_during_deletion_creates_balanced_tree(self):
    method test_cascade_merging (line 852) | def test_cascade_merging(self):
    method test_merge_vs_redistribute_preference (line 880) | def test_merge_vs_redistribute_preference(self):

FILE: python/tests/test_c_extension.py
  function test_c_extension_basic (line 32) | def test_c_extension_basic():
  function test_c_extension_performance (line 74) | def test_c_extension_performance():
  function test_stress_c_extension (line 174) | def test_stress_c_extension():

FILE: python/tests/test_c_extension_comprehensive.py
  function test_empty_tree (line 20) | def test_empty_tree():
  function test_single_item (line 44) | def test_single_item():
  function test_sequential_insert_small (line 63) | def test_sequential_insert_small():
  function test_random_insert_small (line 97) | def test_random_insert_small():
  function test_duplicate_keys (line 131) | def test_duplicate_keys():
  function test_key_error (line 155) | def test_key_error():
  function test_iteration_order (line 175) | def test_iteration_order():
  function test_large_capacity (line 204) | def test_large_capacity():
  function test_string_keys (line 224) | def test_string_keys():
  function test_mixed_types (line 249) | def test_mixed_types():
  function run_all_tests (line 269) | def run_all_tests():

FILE: python/tests/test_c_extension_segfault_fix.py
  class TestCExtensionSegfaultFix (line 17) | class TestCExtensionSegfaultFix:
    method test_sequential_insertion_no_segfault (line 20) | def test_sequential_insertion_no_segfault(self):
    method test_random_insertion_no_segfault (line 46) | def test_random_insertion_no_segfault(self):
    method test_deletion_after_splits_no_segfault (line 66) | def test_deletion_after_splits_no_segfault(self):
    method test_iteration_after_splits_no_segfault (line 89) | def test_iteration_after_splits_no_segfault(self):
    method test_concurrent_modification_safety (line 110) | def test_concurrent_modification_safety(self):
    method test_memory_stress_test (line 144) | def test_memory_stress_test(self):

FILE: python/tests/test_compile_flags.py
  function test_no_unsafe_compile_flags (line 5) | def test_no_unsafe_compile_flags():

FILE: python/tests/test_data_alignment.py
  function test_data_alignment_default (line 9) | def test_data_alignment_default():
  function test_data_alignment_various_capacities (line 16) | def test_data_alignment_various_capacities():

FILE: python/tests/test_dictionary_api.py
  class TestDictionaryAPI (line 25) | class TestDictionaryAPI:
    method setup_method (line 28) | def setup_method(self):
    method test_clear (line 35) | def test_clear(self):
    method test_get_with_default (line 54) | def test_get_with_default(self):
    method test_pop_with_key_present (line 68) | def test_pop_with_key_present(self):
    method test_pop_with_key_missing_no_default (line 82) | def test_pop_with_key_missing_no_default(self):
    method test_pop_with_key_missing_with_default (line 91) | def test_pop_with_key_missing_with_default(self):
    method test_pop_argument_validation (line 101) | def test_pop_argument_validation(self):
    method test_popitem_with_data (line 107) | def test_popitem_with_data(self):
    method test_popitem_empty_tree (line 122) | def test_popitem_empty_tree(self):
    method test_popitem_until_empty (line 129) | def test_popitem_until_empty(self):
    method test_setdefault_new_key (line 146) | def test_setdefault_new_key(self):
    method test_setdefault_existing_key (line 155) | def test_setdefault_existing_key(self):
    method test_setdefault_none_default (line 164) | def test_setdefault_none_default(self):
    method test_update_with_dict (line 172) | def test_update_with_dict(self):
    method test_update_with_another_bplustree (line 188) | def test_update_with_another_bplustree(self):
    method test_update_with_iterable_of_pairs (line 207) | def test_update_with_iterable_of_pairs(self):
    method test_update_with_generator (line 223) | def test_update_with_generator(self):
    method test_copy (line 238) | def test_copy(self):
    method test_copy_empty_tree (line 263) | def test_copy_empty_tree(self):
    method test_dict_compatibility (line 272) | def test_dict_compatibility(self):
    method test_edge_cases (line 300) | def test_edge_cases(self):
    method test_method_chaining_compatibility (line 322) | def test_method_chaining_compatibility(self):
  class TestDictionaryAPILargeDataset (line 333) | class TestDictionaryAPILargeDataset:
    method test_large_dataset_operations (line 336) | def test_large_dataset_operations(self):

FILE: python/tests/test_docstyle.py
  function test_pydocstyle_conformance (line 8) | def test_pydocstyle_conformance():

FILE: python/tests/test_fuzz_discovered_patterns.py
  function check_invariants (line 19) | def check_invariants(tree: BPlusTreeMap) -> bool:
  class TestFuzzDiscoveredPatterns (line 25) | class TestFuzzDiscoveredPatterns:
    method test_rapid_deletion_followed_by_insertion (line 28) | def test_rapid_deletion_followed_by_insertion(self):
    method test_mixed_operations_stress_pattern (line 108) | def test_mixed_operations_stress_pattern(self):
    method test_high_capacity_rapid_operations (line 180) | def test_high_capacity_rapid_operations(self):
    method test_small_capacity_stress_pattern (line 238) | def test_small_capacity_stress_pattern(self):

FILE: python/tests/test_gc_support.py
  function test_gc_collects_self_referencing_tree (line 10) | def test_gc_collects_self_referencing_tree():

FILE: python/tests/test_gprof_harness.py
  function test_generate_gprof (line 17) | def test_generate_gprof(tmp_path):

FILE: python/tests/test_import_error_fallback.py
  function test_extension_import_error_triggers_python_fallback (line 9) | def test_extension_import_error_triggers_python_fallback(tmp_path, monke...

FILE: python/tests/test_invariant_bug.py
  function check_invariants (line 10) | def check_invariants(tree: BPlusTreeMap) -> bool:
  function test_invariant_checker_catches_single_child (line 16) | def test_invariant_checker_catches_single_child():
  function _print_tree_structure (line 42) | def _print_tree_structure(node, level):

FILE: python/tests/test_iterator.py
  class TestBPlusTreeIterator (line 7) | class TestBPlusTreeIterator:
    method test_iterate_empty_tree (line 10) | def test_iterate_empty_tree(self):
    method test_iterate_single_item (line 16) | def test_iterate_single_item(self):
    method test_iterate_multiple_items_single_leaf (line 24) | def test_iterate_multiple_items_single_leaf(self):
    method test_iterate_multiple_leaves (line 35) | def test_iterate_multiple_leaves(self):
    method test_iterate_large_tree (line 46) | def test_iterate_large_tree(self):
    method test_keys_iterator (line 61) | def test_keys_iterator(self):
    method test_values_iterator (line 70) | def test_values_iterator(self):
  class TestBPlusTreeRangeIterator (line 80) | class TestBPlusTreeRangeIterator:
    method test_iterate_from_key (line 83) | def test_iterate_from_key(self):
    method test_iterate_until_key (line 93) | def test_iterate_until_key(self):
    method test_iterate_range (line 103) | def test_iterate_range(self):
    method test_iterate_from_nonexistent_key (line 113) | def test_iterate_from_nonexistent_key(self):
    method test_iterate_empty_range (line 124) | def test_iterate_empty_range(self):
    method test_iterate_range_beyond_tree (line 134) | def test_iterate_range_beyond_tree(self):
    method test_iterate_from_middle_of_leaf (line 144) | def test_iterate_from_middle_of_leaf(self):

FILE: python/tests/test_iterator_modification_safety.py
  class TestIteratorModificationSafety (line 22) | class TestIteratorModificationSafety:
    method test_iterator_invalidation_on_insertion (line 25) | def test_iterator_invalidation_on_insertion(self):
    method test_iterator_invalidation_on_deletion (line 50) | def test_iterator_invalidation_on_deletion(self):
    method test_iterator_invalidation_on_update (line 75) | def test_iterator_invalidation_on_update(self):
    method test_items_iterator_invalidation (line 100) | def test_items_iterator_invalidation(self):
    method test_multiple_iterators_invalidation (line 125) | def test_multiple_iterators_invalidation(self):
    method test_iterator_after_tree_modification (line 159) | def test_iterator_after_tree_modification(self):
    method test_list_keys_after_heavy_modification (line 188) | def test_list_keys_after_heavy_modification(self):
    method test_iteration_with_structural_changes (line 219) | def test_iteration_with_structural_changes(self):
    method test_concurrent_modification_detection (line 244) | def test_concurrent_modification_detection(self):
    method test_no_false_positives (line 273) | def test_no_false_positives(self):
    method test_modification_counter_wrapping (line 295) | def test_modification_counter_wrapping(self):

FILE: python/tests/test_leak_detection.py
  function test_no_memory_leak_on_insert_delete (line 9) | def test_no_memory_leak_on_insert_delete():

FILE: python/tests/test_max_occupancy_bug.py
  function check_invariants (line 8) | def check_invariants(tree: BPlusTreeMap) -> bool:
  class TestMaxOccupancyBug (line 14) | class TestMaxOccupancyBug:
    method test_small_tree_deletion_pattern (line 17) | def test_small_tree_deletion_pattern(self):
    method test_specific_deletion_sequence (line 43) | def test_specific_deletion_sequence(self):
    method test_root_accumulation (line 77) | def test_root_accumulation(self):
    method test_single_deletion_trigger (line 107) | def test_single_deletion_trigger(self):

FILE: python/tests/test_memory_leaks.py
  class TestMemoryLeaks (line 18) | class TestMemoryLeaks:
    method test_insertion_deletion_cycle_no_leak (line 21) | def test_insertion_deletion_cycle_no_leak(self):
    method test_deleted_values_are_released (line 50) | def test_deleted_values_are_released(self):
    method test_clear_releases_all_references (line 82) | def test_clear_releases_all_references(self):
    method test_tree_destruction_releases_nodes (line 103) | def test_tree_destruction_releases_nodes(self):
    method test_update_operations_no_leak (line 134) | def test_update_operations_no_leak(self):
    method test_copy_creates_independent_references (line 162) | def test_copy_creates_independent_references(self):
    method test_large_tree_memory_usage (line 191) | def test_large_tree_memory_usage(self):
    method test_iterator_cleanup (line 211) | def test_iterator_cleanup(self):
    method test_circular_reference_handling (line 242) | def test_circular_reference_handling(self):

FILE: python/tests/test_multithreaded_lookup.py
  function test_multithreaded_lookup (line 23) | def test_multithreaded_lookup():

FILE: python/tests/test_no_segfaults.py
  class TestNoSegfaults (line 22) | class TestNoSegfaults:
    method test_large_sequential_insert (line 25) | def test_large_sequential_insert(self):
    method test_large_random_insert (line 43) | def test_large_random_insert(self):
    method test_mixed_operations_large (line 68) | def test_mixed_operations_large(self):
    method test_stress_with_iterations (line 109) | def test_stress_with_iterations(self):
    method test_capacity_edge_cases (line 142) | def test_capacity_edge_cases(self):
    method test_boundary_values (line 165) | def test_boundary_values(self):
    method test_memory_pressure (line 191) | def test_memory_pressure(self):
  function test_no_segfaults (line 217) | def test_no_segfaults():

FILE: python/tests/test_node_split_minimal.py
  function test_single_node_split_maintains_order (line 20) | def test_single_node_split_maintains_order():
  function test_two_splits_maintains_order (line 46) | def test_two_splits_maintains_order():

FILE: python/tests/test_optimized_bplus_tree.py
  class OptimizedLeafNode (line 19) | class OptimizedLeafNode:
    method __init__ (line 22) | def __init__(self, capacity: int):
    method is_leaf (line 29) | def is_leaf(self) -> bool:
    method find_position (line 32) | def find_position(self, key) -> int:
    method get_child (line 36) | def get_child(self, key) -> "OptimizedLeafNode":
    method insert (line 40) | def insert(self, key, value) -> Optional[Tuple[Any, "OptimizedLeafNode...
    method _split_and_insert (line 68) | def _split_and_insert(
    method get (line 116) | def get(self, key) -> Optional[Any]:
  class OptimizedBranchNode (line 124) | class OptimizedBranchNode:
    method __init__ (line 127) | def __init__(self, capacity: int):
    method is_leaf (line 133) | def is_leaf(self) -> bool:
    method find_child_index (line 136) | def find_child_index(self, key) -> int:
    method get_child (line 140) | def get_child(self, key):
    method set_child (line 145) | def set_child(self, index: int, child):
    method insert (line 149) | def insert(self, key, right_child) -> Optional[Tuple[Any, "OptimizedBr...
    method _split_and_insert (line 174) | def _split_and_insert(
  class OptimizedBPlusTree (line 228) | class OptimizedBPlusTree:
    method __init__ (line 231) | def __init__(self, capacity: int = 128):
    method __getitem__ (line 236) | def __getitem__(self, key) -> Any:
    method __setitem__ (line 247) | def __setitem__(self, key, value):
    method _insert_recursive (line 258) | def _insert_recursive(self, node, key, value) -> Optional[Tuple]:
    method items (line 269) | def items(self, start_key=None, end_key=None) -> Iterator[Tuple[Any, A...
  function test_optimized_performance (line 295) | def test_optimized_performance():

FILE: python/tests/test_performance_baseline.py
  class PerformanceBaseline (line 18) | class PerformanceBaseline:
    method __init__ (line 21) | def __init__(self, tree_size: int = 10000, order: int = 128):
    method measure_operation (line 28) | def measure_operation(self, operation, iterations: int = 1) -> Tuple[f...
    method test_sequential_insert (line 43) | def test_sequential_insert(self) -> Dict[str, float]:
    method test_random_insert (line 59) | def test_random_insert(self) -> Dict[str, float]:
    method test_lookup_performance (line 75) | def test_lookup_performance(self) -> Dict[str, float]:
    method test_range_query (line 96) | def test_range_query(self) -> Dict[str, float]:
    method run_all_tests (line 120) | def run_all_tests(self) -> Dict[str, Dict[str, float]]:
  function test_baseline_performance (line 131) | def test_baseline_performance():

FILE: python/tests/test_performance_benchmarks.py
  class TestPerformanceBenchmarks (line 21) | class TestPerformanceBenchmarks:
    method test_insertion_performance_small (line 24) | def test_insertion_performance_small(self):
    method test_insertion_performance_medium (line 42) | def test_insertion_performance_medium(self):
    method test_bulk_loading_performance (line 62) | def test_bulk_loading_performance(self):
    method test_lookup_performance (line 88) | def test_lookup_performance(self):
    method test_range_query_performance (line 114) | def test_range_query_performance(self):
    method test_mixed_workload_performance (line 141) | def test_mixed_workload_performance(self):
    method test_capacity_impact_on_performance (line 188) | def test_capacity_impact_on_performance(self):
    method test_memory_efficiency (line 212) | def test_memory_efficiency(self):
    method test_sequential_vs_random_insertion (line 237) | def test_sequential_vs_random_insertion(self):
    method test_large_dataset_scalability (line 272) | def test_large_dataset_scalability(self):
    method test_stress_performance (line 305) | def test_stress_performance(self):
  class TestPerformanceRegression (line 343) | class TestPerformanceRegression:
    method test_baseline_insertion_performance (line 346) | def test_baseline_insertion_performance(self):
    method test_baseline_lookup_performance (line 364) | def test_baseline_lookup_performance(self):
    method test_memory_usage_baseline (line 387) | def test_memory_usage_baseline(self):

FILE: python/tests/test_performance_regression.py
  function time_it (line 19) | def time_it() -> float:
  class TestPerformanceRegression (line 25) | class TestPerformanceRegression:
    method generate_test_data (line 35) | def generate_test_data(self, size: int) -> List[Tuple[int, str]]:
    method test_insertion_performance (line 39) | def test_insertion_performance(self):
    method test_sequential_vs_random_insertion (line 53) | def test_sequential_vs_random_insertion(self):
    method test_lookup_performance (line 80) | def test_lookup_performance(self):
    method test_deletion_performance (line 99) | def test_deletion_performance(self):
    method test_iteration_performance (line 118) | def test_iteration_performance(self):
    method test_range_query_performance (line 137) | def test_range_query_performance(self):
    method test_mixed_operations_performance (line 159) | def test_mixed_operations_performance(self):
    method test_performance_scales_logarithmically (line 188) | def test_performance_scales_logarithmically(self):
    method test_memory_efficiency (line 214) | def test_memory_efficiency(self):
  class TestPerformanceComparison (line 234) | class TestPerformanceComparison:
    method test_insertion_comparable_to_dict (line 237) | def test_insertion_comparable_to_dict(self):
    method test_ordered_iteration_faster_than_sorted_dict (line 263) | def test_ordered_iteration_faster_than_sorted_dict(self):

FILE: python/tests/test_performance_vs_sorteddict.py
  class PerformanceComparison (line 28) | class PerformanceComparison:
    method __init__ (line 31) | def __init__(self, size: int = 10000):
    method measure_operation (line 37) | def measure_operation(self, operation, iterations: int = 1) -> float:
    method compare_lookup (line 51) | def compare_lookup(self) -> Dict[str, float]:
    method compare_insert (line 81) | def compare_insert(self) -> Dict[str, float]:
    method compare_range_query (line 104) | def compare_range_query(self) -> Dict[str, float]:
  function test_performance_comparison (line 142) | def test_performance_comparison():

FILE: python/tests/test_prefetch_microbench.py
  function test_prefetch_microbench (line 30) | def test_prefetch_microbench():

FILE: python/tests/test_proper_deletion.py
  function check_invariants (line 10) | def check_invariants(tree: BPlusTreeMap) -> bool:
  function test_deletion_maintains_invariants (line 16) | def test_deletion_maintains_invariants():
  function test_specific_problematic_case (line 52) | def test_specific_problematic_case():
  function test_merge_vs_redistribute (line 81) | def test_merge_vs_redistribute():
  function _print_structure (line 100) | def _print_structure(node, level):

FILE: python/tests/test_segfault_regression.py
  function test_no_segfault_on_large_operations (line 20) | def test_no_segfault_on_large_operations():
  function test_no_segfault_multiple_trees (line 53) | def test_no_segfault_multiple_trees():
  function test_no_segfault_stress_iterations (line 72) | def test_no_segfault_stress_iterations():

FILE: python/tests/test_single_array_int_optimization.py
  class IntArrayLeafNode (line 16) | class IntArrayLeafNode:
    method __init__ (line 19) | def __init__(self, capacity: int = 128):
    method find_position (line 27) | def find_position(self, key: int) -> int:
    method insert (line 38) | def insert(self, key: int, value: int) -> bool:
    method lookup (line 66) | def lookup(self, key: int) -> int:
  class TwoArrayLeafNode (line 74) | class TwoArrayLeafNode:
    method __init__ (line 77) | def __init__(self, capacity: int = 128):
    method find_position (line 83) | def find_position(self, key: int) -> int:
    method insert (line 94) | def insert(self, key: int, value: int) -> bool:
    method lookup (line 112) | def lookup(self, key: int) -> int:
  function benchmark_int_arrays (line 120) | def benchmark_int_arrays(size: int = 64, iterations: int = 10000):
  function test_single_array_int_optimization (line 269) | def test_single_array_int_optimization():

FILE: python/tests/test_single_child_parent.py
  function test_single_child_parent_handled (line 10) | def test_single_child_parent_handled():

FILE: python/tests/test_stress_edge_cases.py
  function check_invariants (line 13) | def check_invariants(tree: BPlusTreeMap) -> bool:
  class TestStressEdgeCases (line 19) | class TestStressEdgeCases:
    method test_minimum_capacity_heavy_deletion (line 22) | def test_minimum_capacity_heavy_deletion(self):
    method test_alternating_insert_delete_stress (line 49) | def test_alternating_insert_delete_stress(self):
    method test_large_capacity_edge_cases (line 72) | def test_large_capacity_edge_cases(self):
    method test_sequential_vs_random_patterns (line 93) | def test_sequential_vs_random_patterns(self):
    method test_duplicate_key_operations (line 118) | def test_duplicate_key_operations(self):
    method test_empty_tree_operations (line 140) | def test_empty_tree_operations(self):
    method test_capacity_boundary_conditions (line 165) | def test_capacity_boundary_conditions(self):
    method test_deep_tree_stress (line 191) | def test_deep_tree_stress(self):

FILE: python/tests/test_stress_large_datasets.py
  class TestLargeDatasets (line 17) | class TestLargeDatasets:
    method test_one_million_sequential_insertions (line 21) | def test_one_million_sequential_insertions(self):
    method test_one_million_random_insertions (line 48) | def test_one_million_random_insertions(self):
    method test_large_string_keys (line 79) | def test_large_string_keys(self):
    method test_large_value_objects (line 103) | def test_large_value_objects(self):
    method test_stress_mixed_operations (line 130) | def test_stress_mixed_operations(self):
    method test_range_queries_on_large_dataset (line 177) | def test_range_queries_on_large_dataset(self):
    method test_memory_efficiency_at_scale (line 205) | def test_memory_efficiency_at_scale(self):
    method test_persistence_pattern_simulation (line 237) | def test_persistence_pattern_simulation(self):

FILE: rust/benches/comparison.rs
  function bench_sequential_insertion (line 6) | fn bench_sequential_insertion(c: &mut Criterion) {
  function bench_random_insertion (line 33) | fn bench_random_insertion(c: &mut Criterion) {
  function bench_lookup (line 66) | fn bench_lookup(c: &mut Criterion) {
  function bench_iteration (line 110) | fn bench_iteration(c: &mut Criterion) {
  function bench_deletion (line 142) | fn bench_deletion(c: &mut Criterion) {
  function bench_mixed_operations (line 186) | fn bench_mixed_operations(c: &mut Criterion) {
  function bench_capacity_optimization (line 254) | fn bench_capacity_optimization(c: &mut Criterion) {
  function bench_range_queries (line 308) | fn bench_range_queries(c: &mut Criterion) {
  function bench_range_edge_cases (line 357) | fn bench_range_edge_cases(c: &mut Criterion) {

FILE: rust/benches/profiling_benchmark.rs
  function profile_balanced_workload (line 9) | fn profile_balanced_workload(c: &mut Criterion) {
  function profile_individual_operations (line 46) | fn profile_individual_operations(c: &mut Criterion) {
  function profile_tree_operations_breakdown (line 103) | fn profile_tree_operations_breakdown(c: &mut Criterion) {
  function profile_range_operations (line 163) | fn profile_range_operations(c: &mut Criterion) {
  function profile_memory_allocation_patterns (line 188) | fn profile_memory_allocation_patterns(c: &mut Criterion) {
  type Operation (line 223) | enum Operation {
  function generate_balanced_operations (line 229) | fn generate_balanced_operations(count: usize) -> Vec<Operation> {

FILE: rust/benches/quick_clone_bench.rs
  function benchmark_key_operations (line 4) | fn benchmark_key_operations(c: &mut Criterion) {

FILE: rust/benches/range_scan_profiling.rs
  function profile_large_range_scans (line 9) | fn profile_large_range_scans(c: &mut Criterion) {
  function profile_random_range_scans (line 63) | fn profile_random_range_scans(c: &mut Criterion) {
  function profile_range_iteration_patterns (line 117) | fn profile_range_iteration_patterns(c: &mut Criterion) {
  function profile_range_bounds_types (line 176) | fn profile_range_bounds_types(c: &mut Criterion) {
  function profile_very_large_single_scan (line 223) | fn profile_very_large_single_scan(c: &mut Criterion) {

FILE: rust/examples/comprehensive_comparison.rs
  type BenchmarkResult (line 9) | struct BenchmarkResult {
    method new (line 19) | fn new(
    method winner (line 39) | fn winner(&self) -> &str {
    method best_ratio (line 57) | fn best_ratio(&self) -> f64 {
  function run_benchmark (line 70) | fn run_benchmark<F>(_name: &str, iterations: usize, mut f: F) -> std::ti...
  function main (line 86) | fn main() {

FILE: rust/examples/find_optimal_capacity.rs
  constant ITERATIONS (line 5) | const ITERATIONS: usize = 10;
  constant INSERT_COUNT (line 6) | const INSERT_COUNT: usize = 10_000;
  constant LOOKUP_COUNT (line 7) | const LOOKUP_COUNT: usize = 100_000;
  constant ITER_COUNT (line 8) | const ITER_COUNT: usize = 100;
  function benchmark_capacity (line 10) | fn benchmark_capacity(capacity: usize) -> (Duration, Duration, Duration) {
  function benchmark_btreemap (line 54) | fn benchmark_btreemap() -> (Duration, Duration, Duration) {
  function main (line 98) | fn main() {

FILE: rust/examples/quick_perf.rs
  function main (line 5) | fn main() {

FILE: rust/examples/range_syntax_demo.rs
  function main (line 3) | fn main() {

FILE: rust/examples/readme_examples.rs
  function main (line 3) | fn main() {
  function quick_start_example (line 21) | fn quick_start_example() {
  function api_examples (line 42) | fn api_examples() {
  function range_query_examples (line 70) | fn range_query_examples() {
  function time_series_example (line 97) | fn time_series_example() {

FILE: rust/focused_results/custom_analysis.rs
  function main (line 4) | fn main() {
  function analyze_tree_navigation (line 13) | fn analyze_tree_navigation() {
  function analyze_iteration_patterns (line 37) | fn analyze_iteration_patterns() {
  function analyze_memory_access (line 65) | fn analyze_memory_access() {

FILE: rust/profiling_results/timing_analysis.rs
  function main (line 4) | fn main() {

FILE: rust/src/bin/arena_profile.rs
  function main (line 4) | fn main() {
  function test_single_operations (line 23) | fn test_single_operations(tree: &BPlusTreeMap<i32, String>) {
  function test_arena_lookups (line 67) | fn test_arena_lookups(tree: &BPlusTreeMap<i32, String>) {

FILE: rust/src/bin/bound_check_test.rs
  function main (line 4) | fn main() {

FILE: rust/src/bin/delete_profiler.rs
  function main (line 4) | fn main() {
  function profile_sequential_deletes (line 15) | fn profile_sequential_deletes() {
  function profile_pseudo_random_deletes (line 38) | fn profile_pseudo_random_deletes() {
  function profile_mixed_workload_deletes (line 68) | fn profile_mixed_workload_deletes() {
  function profile_rebalancing_heavy_deletes (line 119) | fn profile_rebalancing_heavy_deletes() {

FILE: rust/src/bin/detailed_delete_profiler.rs
  function main (line 4) | fn main() {
  function profile_delete_operations_detailed (line 12) | fn profile_delete_operations_detailed() {
  function profile_tree_size (line 34) | fn profile_tree_size(size: usize) {
  function profile_capacity (line 126) | fn profile_capacity(capacity: usize) {

FILE: rust/src/bin/function_profiler.rs
  type ProfileData (line 5) | struct ProfileData {
    method new (line 13) | fn new() -> Self {
    method record (line 22) | fn record(&mut self, duration: Duration) {
    method avg_time (line 29) | fn avg_time(&self) -> Duration {
  function main (line 38) | fn main() {
  function profile_delete_scenarios (line 46) | fn profile_delete_scenarios() {
  function profile_workload (line 61) | fn profile_workload(workload: Vec<Operation>) {
  type Operation (line 176) | enum Operation {
  function create_sequential_delete_workload (line 182) | fn create_sequential_delete_workload() -> Vec<Operation> {
  function create_random_delete_workload (line 193) | fn create_random_delete_workload() -> Vec<Operation> {
  function create_rebalancing_workload (line 207) | fn create_rebalancing_workload() -> Vec<Operation> {
  function create_mixed_workload (line 219) | fn create_mixed_workload() -> Vec<Operation> {

FILE: rust/src/bin/instruments_delete_target.rs
  function main (line 8) | fn main() {

FILE: rust/src/bin/large_delete_benchmark.rs
  function main (line 8) | fn main() {

FILE: rust/src/bin/micro_range_bench.rs
  function main (line 4) | fn main() {

FILE: rust/src/bin/profile_functions.rs
  function main (line 4) | fn main() {
  function profile_large_tree_operations (line 20) | fn profile_large_tree_operations(tree_size: usize, operations_count: usi...
  type Operation (line 279) | enum Operation {
  function generate_mixed_operations (line 285) | fn generate_mixed_operations(count: usize) -> Vec<Operation> {

FILE: rust/src/bin/range_comparison.rs
  function main (line 5) | fn main() {
  function test_range_sizes (line 51) | fn test_range_sizes(
  function test_range_positions (line 92) | fn test_range_positions(
  function test_startup_vs_iteration (line 140) | fn test_startup_vs_iteration(
  function test_creation_overhead (line 206) | fn test_creation_overhead(

FILE: rust/src/bin/range_profile.rs
  function main (line 4) | fn main() {
  function test_range_sizes (line 31) | fn test_range_sizes(tree: &BPlusTreeMap<i32, String>, tree_size: usize) {
  function test_range_positions (line 56) | fn test_range_positions(tree: &BPlusTreeMap<i32, String>, tree_size: usi...
  function test_range_vs_iteration_overhead (line 87) | fn test_range_vs_iteration_overhead(tree: &BPlusTreeMap<i32, String>, _t...
  function test_iterator_creation_cost (line 121) | fn test_iterator_creation_cost(tree: &BPlusTreeMap<i32, String>, tree_si...

FILE: rust/src/compact_arena.rs
  type NodeId (line 7) | pub type NodeId = u32;
  constant NULL_NODE (line 8) | pub const NULL_NODE: NodeId = u32::MAX;
  type CompactArenaStats (line 12) | pub struct CompactArenaStats {
  type CompactArena (line 23) | pub struct CompactArena<T> {
  function new (line 36) | pub fn new() -> Self {
  function with_capacity (line 46) | pub fn with_capacity(capacity: usize) -> Self {
  function allocate (line 57) | pub fn allocate(&mut self, item: T) -> NodeId {
  function deallocate (line 78) | pub fn deallocate(&mut self, id: NodeId) -> Option<T>
  function deallocate_no_return (line 103) | pub fn deallocate_no_return(&mut self, id: NodeId) -> bool {
  function get (line 123) | pub fn get(&self, id: NodeId) -> Option<&T> {
  function get_mut (line 140) | pub fn get_mut(&mut self, id: NodeId) -> Option<&mut T> {
  function get_unchecked (line 159) | pub unsafe fn get_unchecked(&self, id: NodeId) -> &T {
  function get_unchecked_mut (line 168) | pub unsafe fn get_unchecked_mut(&mut self, id: NodeId) -> &mut T {
  function contains (line 174) | pub fn contains(&self, id: NodeId) -> bool {
  function stats (line 184) | pub fn stats(&self) -> CompactArenaStats {
  function compact (line 213) | pub fn compact(&mut self)
  function len (line 245) | pub fn len(&self) -> usize {
  function is_empty (line 253) | pub fn is_empty(&self) -> bool {
  function capacity (line 258) | pub fn capacity(&self) -> usize {
  function clear (line 263) | pub fn clear(&mut self) {
  function free_count (line 271) | pub fn free_count(&self) -> usize {
  function allocated_count (line 276) | pub fn allocated_count(&self) -> usize {
  function utilization (line 281) | pub fn utilization(&self) -> f64 {
  method default (line 288) | fn default() -> Self {
  function deallocate_with_default (line 296) | pub fn deallocate_with_default(&mut self, id: NodeId) -> Option<T> {
  function allocate_leaf (line 332) | pub fn allocate_leaf(&mut self, leaf: LeafNode<K, V>) -> NodeId {
  function allocate_leaf_with_data (line 339) | pub fn allocate_leaf_with_data(
  function allocate_branch (line 357) | pub fn allocate_branch(&mut self, branch: BranchNode<K, V>) -> NodeId {
  function deallocate_leaf (line 363) | pub fn deallocate_leaf(&mut self, id: NodeId) -> Option<LeafNode<K, V>> {
  function deallocate_branch (line 369) | pub fn deallocate_branch(&mut self, id: NodeId) -> Option<BranchNode<K, ...
  function free_leaf_count (line 378) | pub fn free_leaf_count(&self) -> usize {
  function allocated_leaf_count (line 383) | pub fn allocated_leaf_count(&self) -> usize {
  function leaf_utilization (line 388) | pub fn leaf_utilization(&self) -> f64 {
  function free_branch_count (line 393) | pub fn free_branch_count(&self) -> usize {
  function allocated_branch_count (line 398) | pub fn allocated_branch_count(&self) -> usize {
  function branch_utilization (line 403) | pub fn branch_utilization(&self) -> f64 {
  function leaf_arena_stats (line 408) | pub fn leaf_arena_stats(&self) -> CompactArenaStats {
  function branch_arena_stats (line 413) | pub fn branch_arena_stats(&self) -> CompactArenaStats {
  function set_leaf_next (line 418) | pub fn set_leaf_next(&mut self, id: NodeId, next_id: NodeId) -> bool {
  function get_leaf_unchecked (line 435) | pub unsafe fn get_leaf_unchecked(&self, id: NodeId) -> &LeafNode<K, V> {
  function get_branch_unchecked (line 443) | pub unsafe fn get_branch_unchecked(&self, id: NodeId) -> &BranchNode<K, ...
  function test_compact_arena_basic_operations (line 453) | fn test_compact_arena_basic_operations() {
  function test_compact_arena_with_default (line 475) | fn test_compact_arena_with_default() {
  function test_unsafe_access (line 495) | fn test_unsafe_access() {

FILE: rust/src/comprehensive_performance_benchmark.rs
  function run_comprehensive_benchmark (line 8) | pub fn run_comprehensive_benchmark() {
  function setup_trees (line 37) | fn setup_trees(
  function benchmark_access (line 53) | fn benchmark_access(
  function benchmark_insert (line 98) | fn benchmark_insert(
  function benchmark_delete (line 157) | fn benchmark_delete(
  function benchmark_iterate (line 218) | fn benchmark_iterate(
  function test_comprehensive_benchmark (line 271) | fn test_comprehensive_benchmark() {

FILE: rust/src/construction.rs
  type InitResult (line 13) | pub type InitResult<T> = BTreeResult<T>;
  constant DEFAULT_CAPACITY (line 16) | pub const DEFAULT_CAPACITY: usize = 128;
  function new (line 37) | pub fn new(capacity: usize) -> InitResult<Self> {
  function with_default_capacity (line 69) | pub fn with_default_capacity() -> InitResult<Self> {
  function empty (line 91) | pub fn empty(capacity: usize) -> InitResult<Self> {
  function new (line 124) | pub fn new(capacity: usize) -> Self {
  function with_default_capacity (line 144) | pub fn with_default_capacity() -> Self {
  function with_reserved_capacity (line 165) | pub fn with_reserved_capacity(capacity: usize) -> Self {
  function new (line 190) | pub fn new(capacity: usize) -> Self {
  function with_default_capacity (line 209) | pub fn with_default_capacity() -> Self {
  function with_reserved_capacity (line 230) | pub fn with_reserved_capacity(capacity: usize) -> Self {
  method default (line 242) | fn default() -> Self {
  method default (line 249) | fn default() -> Self {
  method default (line 256) | fn default() -> Self {
  function validate_capacity (line 275) | pub fn validate_capacity(capacity: usize) -> BTreeResult<()> {
  function recommended_capacity (line 296) | pub fn recommended_capacity(expected_elements: usize) -> usize {
  function test_btree_construction (line 314) | fn test_btree_construction() {
  function test_btree_invalid_capacity (line 321) | fn test_btree_invalid_capacity() {
  function test_btree_default (line 328) | fn test_btree_default() {
  function test_btree_empty (line 334) | fn test_btree_empty() {
  function test_leaf_construction (line 342) | fn test_leaf_construction() {
  function test_leaf_with_reserved_capacity (line 349) | fn test_leaf_with_reserved_capacity() {
  function test_branch_construction (line 356) | fn test_branch_construction() {
  function test_validation (line 363) | fn test_validation() {
  function test_recommended_capacity (line 370) | fn test_recommended_capacity() {

FILE: rust/src/delete_operations.rs
  function remove (line 44) | pub fn remove(&mut self, key: &K) -> Option<V> {
  function remove_item (line 61) | pub fn remove_item(&mut self, key: &K) -> ModifyResult<V> {
  function remove_recursive (line 67) | fn remove_recursive(&mut self, node: &NodeRef<K, V>, key: &K) -> RemoveR...
  function collapse_root_if_needed (line 110) | fn collapse_root_if_needed(&mut self) {
  function create_empty_root_leaf (line 160) | fn create_empty_root_leaf(&mut self) {
  function is_node_underfull (line 167) | fn is_node_underfull(&self, node_ref: &NodeRef<K, V>) -> bool {
  function rebalance_child (line 182) | fn rebalance_child(&mut self, parent_id: NodeId, child_index: usize) -> ...
  function test_delete_operations_module_exists (line 256) | fn test_delete_operations_module_exists() {
  function test_optimized_rebalancing_reduces_arena_access (line 266) | fn test_optimized_rebalancing_reduces_arena_access() {
  function test_rebalancing_with_various_sibling_scenarios (line 299) | fn test_rebalancing_with_various_sibling_scenarios() {
  function test_delete_performance_characteristics (line 332) | fn test_delete_performance_characteristics() {
  function rebalance_leaf (line 369) | fn rebalance_leaf(
  function rebalance_branch (line 468) | fn rebalance_branch(
  function merge_with_left_branch (line 553) | fn merge_with_left_branch(&mut self, parent_id: NodeId, child_index: usi...
  function merge_with_right_branch (line 610) | fn merge_with_right_branch(&mut self, parent_id: NodeId, child_index: us...
  function borrow_from_left_branch_with (line 667) | fn borrow_from_left_branch_with(
  function borrow_from_right_branch_with (line 695) | fn borrow_from_right_branch_with(
  function borrow_from_left_leaf_with_ids (line 723) | fn borrow_from_left_leaf_with_ids(
  function borrow_from_right_leaf_with_ids (line 750) | fn borrow_from_right_leaf_with_ids(
  function merge_with_left_leaf_with_ids (line 778) | fn merge_with_left_leaf_with_ids(
  function merge_with_right_leaf_with_ids (line 806) | fn merge_with_right_leaf_with_ids(

FILE: rust/src/detailed_iterator_analysis.rs
  function analyze_iterator_implementation (line 7) | pub fn analyze_iterator_implementation() {
  function analyze_arena_access_pattern (line 33) | fn analyze_arena_access_pattern(bplus: &BPlusTreeMap<usize, usize>, size...
  function compare_iterator_implementations (line 76) | fn compare_iterator_implementations(bplus: &BPlusTreeMap<usize, usize>, ...
  function analyze_next_call_work (line 126) | fn analyze_next_call_work(bplus: &BPlusTreeMap<usize, usize>, _size: usi...
  function compare_with_btreemap (line 164) | fn compare_with_btreemap(bplus: &BPlusTreeMap<usize, usize>, size: usize) {
  function test_detailed_iterator_analysis (line 219) | fn test_detailed_iterator_analysis() {

FILE: rust/src/error.rs
  type BPlusTreeError (line 8) | pub enum BPlusTreeError {
    method invalid_capacity (line 29) | pub fn invalid_capacity(capacity: usize, min_required: usize) -> Self {
    method data_integrity (line 37) | pub fn data_integrity(context: &str, details: &str) -> Self {
    method arena_error (line 42) | pub fn arena_error(operation: &str, details: &str) -> Self {
    method node_error (line 47) | pub fn node_error(node_type: &str, node_id: u32, details: &str) -> Self {
    method corrupted_tree (line 52) | pub fn corrupted_tree(component: &str, details: &str) -> Self {
    method invalid_state (line 57) | pub fn invalid_state(operation: &str, state: &str) -> Self {
    method allocation_error (line 62) | pub fn allocation_error(resource: &str, reason: &str) -> Self {
    method is_capacity_error (line 67) | pub fn is_capacity_error(&self) -> bool {
    method is_arena_error (line 72) | pub fn is_arena_error(&self) -> bool {
    method fmt (line 78) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TreeResult (line 95) | pub(crate) type TreeResult<T> = Result<T, BPlusTreeError>;
  type BTreeResult (line 98) | pub type BTreeResult<T> = Result<T, BPlusTreeError>;
  type KeyResult (line 101) | pub type KeyResult<T> = Result<T, BPlusTreeError>;
  type ModifyResult (line 104) | pub type ModifyResult<T> = Result<T, BPlusTreeError>;
  type InitResult (line 107) | pub type InitResult<T> = Result<T, BPlusTreeError>;
  type BTreeResultExt (line 110) | pub trait BTreeResultExt<T> {
    method with_context (line 112) | fn with_context(self, context: &str) -> BTreeResult<T>;
    method with_operation (line 115) | fn with_operation(self, operation: &str) -> BTreeResult<T>;
    method or_default_with_log (line 118) | fn or_default_with_log(self) -> T
  function with_context (line 124) | fn with_context(self, context: &str) -> BTreeResult<T> {
  function with_operation (line 143) | fn with_operation(self, operation: &str) -> BTreeResult<T> {
  function or_default_with_log (line 147) | fn or_default_with_log(self) -> T

FILE: rust/src/get_operations.rs
  function get (line 34) | pub fn get(&self, key: &K) -> Option<&V> {
  function contains_key (line 62) | pub fn contains_key(&self, key: &K) -> bool {
  function get_or_default (line 87) | pub fn get_or_default<'a>(&'a self, key: &K, default: &'a V) -> &'a V {
  function get_item (line 112) | pub fn get_item(&self, key: &K) -> KeyResult<&V> {
  function get_mut (line 138) | pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
  function try_get (line 166) | pub fn try_get(&self, key: &K) -> KeyResult<&V> {
  function get_many (line 194) | pub fn get_many(&self, keys: &[K]) -> BTreeResult<Vec<&V>> {
  function get_child_for_key (line 217) | pub fn get_child_for_key(&self, branch_id: NodeId, key: &K) -> Option<(u...
  function get_leaf (line 233) | pub fn get_leaf(&self, id: NodeId) -> Option<&LeafNode<K, V>> {
  function get_leaf_mut (line 239) | pub fn get_leaf_mut(&mut self, id: NodeId) -> Option<&mut LeafNode<K, V>> {
  function get_leaf_next (line 244) | pub fn get_leaf_next(&self, id: NodeId) -> Option<NodeId> {
  function get_branch (line 256) | pub fn get_branch(&self, id: NodeId) -> Option<&BranchNode<K, V>> {
  function get_branch_mut (line 262) | pub fn get_branch_mut(&mut self, id: NodeId) -> Option<&mut BranchNode<K...
  function test_basic_get_operations (line 277) | fn test_basic_get_operations() {
  function test_get_or_default (line 303) | fn test_get_or_default() {
  function test_get_item (line 312) | fn test_get_item() {
  function test_get_mut (line 325) | fn test_get_mut() {
  function test_get_many (line 340) | fn test_get_many() {
  function test_try_get (line 359) | fn test_try_get() {
  function test_leaf_node_get_operations (line 369) | fn test_leaf_node_get_operations() {
  function test_branch_node_operations (line 395) | fn test_branch_node_operations() {

FILE: rust/src/insert_operations.rs
  function new_root (line 15) | pub fn new_root(&mut self, new_node: NodeRef<K, V>, separator_key: K) ->...
  function insert_into_leaf (line 31) | fn insert_into_leaf(&mut self, leaf_id: NodeId, key: K, value: V) -> Ins...
  function insert_recursive (line 123) | pub fn insert_recursive(
  function insert (line 230) | pub fn insert(&mut self, key: K, value: V) -> Option<V> {
  function test_insert_operations_module_exists (line 292) | fn test_insert_operations_module_exists() {

FILE: rust/src/iteration.rs
  type ItemIterator (line 14) | pub struct ItemIterator<'a, K, V> {
  type FastItemIterator (line 25) | pub struct FastItemIterator<'a, K, V> {
  type KeyIterator (line 34) | pub struct KeyIterator<'a, K, V> {
  type ValueIterator (line 39) | pub struct ValueIterator<'a, K, V> {
  type RangeIterator (line 45) | pub struct RangeIterator<'a, K, V> {
  function items (line 57) | pub fn items(&self) -> ItemIterator<'_, K, V> {
  function items_fast (line 67) | pub fn items_fast(&self) -> FastItemIterator<'_, K, V> {
  function keys (line 72) | pub fn keys(&self) -> KeyIterator<'_, K, V> {
  function values (line 77) | pub fn values(&self) -> ValueIterator<'_, K, V> {
  function items_range (line 84) | pub fn items_range<'a>(
  function new (line 103) | pub fn new(tree: &'a BPlusTreeMap<K, V>) -> Self {
  function new_from_position_with_bounds (line 121) | pub fn new_from_position_with_bounds(
  function try_get_next_item (line 148) | fn try_get_next_item(&mut self, leaf: &'a LeafNode<K, V>) -> Option<(&'a...
  function advance_to_next_leaf_direct (line 199) | fn advance_to_next_leaf_direct(&mut self) -> bool {
  type Item (line 225) | type Item = (&'a K, &'a V);
  method next (line 227) | fn next(&mut self) -> Option<Self::Item> {
  function new (line 259) | pub fn new(tree: &'a BPlusTreeMap<K, V>) -> Self {
  type Item (line 267) | type Item = &'a K;
  method next (line 269) | fn next(&mut self) -> Option<Self::Item> {
  function new (line 279) | pub fn new(tree: &'a BPlusTreeMap<K, V>) -> Self {
  type Item (line 287) | type Item = &'a V;
  method next (line 289) | fn next(&mut self) -> Option<Self::Item> {
  function new_with_skip_owned (line 299) | pub fn new_with_skip_owned(
  type Item (line 343) | type Item = (&'a K, &'a V);
  method next (line 345) | fn next(&mut self) -> Option<Self::Item> {
  function new (line 370) | pub fn new(tree: &'a BPlusTreeMap<K, V>) -> Self {
  type Item (line 388) | type Item = (&'a K, &'a V);
  method next (line 391) | fn next(&mut self) -> Option<Self::Item> {

FILE: rust/src/lib.rs
  function try_insert (line 59) | pub fn try_insert(&mut self, key: K, value: V) -> ModifyResult<Option<V>>
  function try_remove (line 80) | pub fn try_remove(&mut self, key: &K) -> ModifyResult<V> {
  function batch_insert (line 97) | pub fn batch_insert(&mut self, items: Vec<(K, V)>) -> ModifyResult<Vec<O...
  function test_leaf_caching_optimization_proof (line 184) | fn test_leaf_caching_optimization_proof() {
  function test_fast_iterator_also_uses_leaf_caching (line 216) | fn test_fast_iterator_also_uses_leaf_caching() {

FILE: rust/src/macros.rs
  function test_assert_tree_valid_macro (line 235) | fn test_assert_tree_valid_macro() {
  function test_create_test_tree_macro (line 249) | fn test_create_test_tree_macro() {
  function test_attack_pattern_macro (line 269) | fn test_attack_pattern_macro() {
  function test_verify_attack_result_macro (line 284) | fn test_verify_attack_result_macro() {
  function test_stress_test_macro (line 304) | fn test_stress_test_macro() {

FILE: rust/src/node.rs
  function get (line 20) | pub fn get(&self, key: &K) -> Option<&V> {
  function get_mut (line 28) | pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
  function len (line 35) | pub fn len(&self) -> usize {
  function keys (line 40) | pub fn keys(&self) -> &Vec<K> {
  function values (line 45) | pub fn values(&self) -> &Vec<V> {
  function values_mut (line 50) | pub fn values_mut(&mut self) -> &mut Vec<V> {
  function get_key (line 56) | pub fn get_key(&self, index: usize) -> Option<&K> {
  function get_value (line 62) | pub fn get_value(&self, index: usize) -> Option<&V> {
  function get_value_mut (line 68) | pub fn get_value_mut(&mut self, index: usize) -> Option<&mut V> {
  function first_key (line 74) | pub fn first_key(&self) -> Option<&K> {
  function last_key (line 80) | pub fn last_key(&self) -> Option<&K> {
  function keys_is_empty (line 86) | pub fn keys_is_empty(&self) -> bool {
  function keys_len (line 92) | pub fn keys_len(&self) -> usize {
  function values_len (line 98) | pub fn values_len(&self) -> usize {
  function get_key_unchecked (line 146) | pub unsafe fn get_key_unchecked(&self, index: usize) -> &K {
  function get_value_unchecked (line 171) | pub unsafe fn get_value_unchecked(&self, index: usize) -> &V {
  function get_key_value_unchecked (line 198) | pub unsafe fn get_key_value_unchecked(&self, index: usize) -> (&K, &V) {
  function push_key (line 207) | pub fn push_key(&mut self, key: K) {
  function push_value (line 213) | pub fn push_value(&mut self, value: V) {
  function append_keys (line 219) | pub fn append_keys(&mut self, other: &mut Vec<K>) {
  function append_values (line 225) | pub fn append_values(&mut self, other: &mut Vec<V>) {
  function take_keys (line 231) | pub fn take_keys(&mut self) -> Vec<K> {
  function take_values (line 237) | pub fn take_values(&mut self) -> Vec<V> {
  function binary_search_keys (line 243) | pub fn binary_search_keys(&self, key: &K) -> Result<usize, usize>
  function into_keys_values (line 251) | pub fn into_keys_values(self) -> (impl Iterator<Item = K>, impl Iterator...
  function get_key_at (line 256) | pub fn get_key_at(&self, index: usize) -> Option<&K> {
  function get_value_at (line 261) | pub fn get_value_at(&self, index: usize) -> Option<&V> {
  function insert_at (line 266) | pub fn insert_at(&mut self, index: usize, key: K, value: V) {
  function remove_at (line 272) | pub fn remove_at(&mut self, index: usize) -> Option<(K, V)> {
  function pop (line 283) | pub fn pop(&mut self) -> Option<(K, V)> {
  function remove_first (line 292) | pub fn remove_first(&mut self) -> Option<(K, V)> {
  function insert (line 307) | pub fn insert(&mut self, key: K, value: V) -> InsertResult<K, V> {
  function insert_at_index (line 353) | pub fn insert_at_index(&mut self, index: usize, key: K, value: V) {
  function split (line 359) | pub fn split(&mut self) -> LeafNode<K, V> {
  function remove (line 401) | pub fn remove(&mut self, key: &K) -> (Option<V>, bool) {
  function is_empty (line 418) | pub fn is_empty(&self) -> bool {
  function is_full (line 423) | pub fn is_full(&self) -> bool {
  function needs_split (line 429) | pub fn needs_split(&self) -> bool {
  function is_underfull (line 435) | pub fn is_underfull(&self) -> bool {
  function can_donate (line 441) | pub fn can_donate(&self) -> bool {
  function min_keys (line 451) | pub fn min_keys(&self) -> usize {
  function borrow_last (line 462) | pub fn borrow_last(&mut self) -> Option<(K, V)> {
  function borrow_first (line 470) | pub fn borrow_first(&mut self) -> Option<(K, V)> {
  function accept_from_left (line 478) | pub fn accept_from_left(&mut self, key: K, value: V) {
  function accept_from_right (line 484) | pub fn accept_from_right(&mut self, key: K, value: V) {
  function merge_from (line 490) | pub fn merge_from(&mut self, other: &mut LeafNode<K, V>) -> NodeId {
  function extract_all (line 501) | pub fn extract_all(&mut self) -> (Vec<K>, Vec<V>, NodeId) {
  function insert_child_and_split_if_needed (line 522) | pub fn insert_child_and_split_if_needed(
  function split_data (line 548) | pub fn split_data(&mut self) -> (BranchNode<K, V>, K) {
  function is_empty (line 586) | pub fn is_empty(&self) -> bool {
  function is_full (line 591) | pub fn is_full(&self) -> bool {
  function is_underfull (line 597) | pub fn is_underfull(&self) -> bool {
  function can_donate (line 603) | pub fn can_donate(&self) -> bool {
  function min_keys (line 613) | pub fn min_keys(&self) -> usize {
  function find_child_index (line 621) | pub fn find_child_index(&self, key: &K) -> usize {
  function len (line 630) | pub fn len(&self) -> usize {
  function needs_split (line 636) | pub fn needs_split(&self) -> bool {
  function get_child (line 642) | pub fn get_child(&self, key: &K) -> Option<&NodeRef<K, V>> {
  function get_child_mut (line 652) | pub fn get_child_mut(&mut self, key: &K) -> Option<&mut NodeRef<K, V>> {
  function borrow_last (line 665) | pub fn borrow_last(&mut self) -> Option<(K, NodeRef<K, V>)> {
  function borrow_first (line 675) | pub fn borrow_first(&mut self) -> Option<(K, NodeRef<K, V>)> {
  function accept_from_left (line 686) | pub fn accept_from_left(
  function accept_from_right (line 699) | pub fn accept_from_right(
  function merge_from (line 711) | pub fn merge_from(&mut self, separator: K, other: &mut BranchNode<K, V>) {

FILE: rust/src/range_queries.rs
  type RangeAnalysisResult (line 11) | type RangeAnalysisResult<K> = (Option<(NodeId, usize)>, bool, Option<(K,...
  function range (line 49) | pub fn range<R>(&self, range: R) -> RangeIterator<'_, K, V>
  function first (line 58) | pub fn first(&self) -> Option<(&K, &V)> {
  function last (line 63) | pub fn last(&self) -> Option<(&K, &V)> {
  function resolve_range_bounds (line 72) | pub fn resolve_range_bounds<R>(&self, range: R) -> RangeAnalysisResult<K>

FILE: rust/src/tree_structure.rs
  function len (line 15) | pub fn len(&self) -> usize {
  function len_recursive (line 20) | fn len_recursive(&self, node: &NodeRef<K, V>) -> usize {
  function is_empty (line 37) | pub fn is_empty(&self) -> bool {
  function is_leaf_root (line 42) | pub fn is_leaf_root(&self) -> bool {
  function leaf_count (line 47) | pub fn leaf_count(&self) -> usize {
  function leaf_count_recursive (line 52) | fn leaf_count_recursive(&self, node: &NodeRef<K, V>) -> usize {
  function clear (line 69) | pub fn clear(&mut self) {
  function count_nodes_in_tree (line 81) | pub fn count_nodes_in_tree(&self) -> (usize, usize) {
  function count_nodes_recursive (line 91) | fn count_nodes_recursive(&self, node: &NodeRef<K, V>) -> (usize, usize) {
  function get_first_leaf_id (line 120) | pub fn get_first_leaf_id(&self) -> Option<NodeId> {
  function find_leaf_for_key (line 144) | pub(crate) fn find_leaf_for_key(&self, key: &K) -> Option<(NodeId, usize...
  function find_leaf_for_key_with_match (line 180) | pub(crate) fn find_leaf_for_key_with_match(&self, key: &K) -> Option<(No...
  function find_child (line 219) | pub fn find_child(&self, branch_id: NodeId, key: &K) -> Option<(usize, N...
  function find_child_mut (line 227) | pub fn find_child_mut(&mut self, branch_id: NodeId, key: &K) -> Option<(...

FILE: rust/src/types.rs
  constant MIN_CAPACITY (line 14) | pub(crate) const MIN_CAPACITY: usize = 4;
  type NodeId (line 21) | pub type NodeId = u32;
  constant NULL_NODE (line 24) | pub const NULL_NODE: NodeId = u32::MAX;
  constant ROOT_NODE (line 25) | pub const ROOT_NODE: NodeId = 0;
  type BPlusTreeMap (line 76) | pub struct BPlusTreeMap<K, V> {
  type LeafNode (line 91) | pub struct LeafNode<K, V> {
  type BranchNode (line 109) | pub struct BranchNode<K, V> {
  type NodeRef (line 124) | pub enum NodeRef<K, V> {
  method clone (line 130) | fn clone(&self) -> Self {
  function id (line 139) | pub fn id(&self) -> NodeId {
  function is_leaf (line 147) | pub fn is_leaf(&self) -> bool {
  type SplitNodeData (line 153) | pub enum SplitNodeData<K, V> {
  type InsertResult (line 162) | pub enum InsertResult<K, V> {
  type RemoveResult (line 176) | pub enum RemoveResult<V> {

FILE: rust/src/validation.rs
  function check_invariants (line 16) | pub fn check_invariants(&self) -> bool {
  function check_invariants_detailed (line 21) | pub fn check_invariants_detailed(&self) -> Result<(), String> {
  function check_arena_tree_consistency (line 37) | fn check_arena_tree_consistency(&self) -> TreeResult<()> {
  function check_linked_list_invariants (line 74) | fn check_linked_list_invariants(&self) -> Result<(), String> {
  function check_leaf_linked_list_completeness (line 98) | fn check_leaf_linked_list_completeness(&self) -> TreeResult<()> {
  function collect_leaf_ids (line 136) | fn collect_leaf_ids(&self, node: &NodeRef<K, V>, ids: &mut Vec<NodeId>) {
  function check_node_invariants (line 150) | fn check_node_invariants(
  function validate (line 283) | pub fn validate(&self) -> Result<(), String> {
  function slice (line 288) | pub fn slice(&self) -> Vec<(&K, &V)> {
  function leaf_sizes (line 293) | pub fn leaf_sizes(&self) -> Vec<usize> {
  function print_node_chain (line 300) | pub fn print_node_chain(&self) {
  function collect_leaf_sizes (line 306) | fn collect_leaf_sizes(&self, node: &NodeRef<K, V>, sizes: &mut Vec<usize...
  function print_node (line 324) | fn print_node(&self, node: &NodeRef<K, V>, depth: usize) {
  function validate_for_operation (line 365) | pub fn validate_for_operation(&self, operation: &str) -> crate::error::B...

FILE: rust/tests/adversarial_arena_corruption.rs
  function test_arena_id_exhaustion_attack (line 10) | fn test_arena_id_exhaustion_attack() {
  function test_concurrent_arena_access_simulation (line 28) | fn test_concurrent_arena_access_simulation() {
  function test_arena_growth_boundary_attack (line 43) | fn test_arena_growth_boundary_attack() {
  function test_free_list_corruption_attack (line 82) | fn test_free_list_corruption_attack() {
  function test_deep_recursion_arena_explosion (line 142) | fn test_deep_recursion_arena_explosion() {
  function test_force_arena_corruption_panic (line 196) | fn test_force_arena_corruption_panic() {

FILE: rust/tests/adversarial_branch_rebalancing.rs
  function test_cascading_branch_rebalance_attack (line 9) | fn test_cascading_branch_rebalance_attack() {
  function test_branch_borrow_from_underfull_sibling_attack (line 65) | fn test_branch_borrow_from_underfull_sibling_attack() {
  function test_branch_merge_with_maximum_keys_attack (line 105) | fn test_branch_merge_with_maximum_keys_attack() {
  function test_alternating_sibling_operations_attack (line 153) | fn test_alternating_sibling_operations_attack() {
  function test_deep_tree_branch_collapse_attack (line 200) | fn test_deep_tree_branch_collapse_attack() {
  function test_force_branch_rebalance_panic (line 251) | fn test_force_branch_rebalance_panic() {

FILE: rust/tests/adversarial_edge_cases.rs
  function test_root_collapse_infinite_loop_attack (line 8) | fn test_root_collapse_infinite_loop_attack() {
  function test_minimum_capacity_edge_cases_attack (line 35) | fn test_minimum_capacity_edge_cases_attack() {
  function test_odd_capacity_arithmetic_attack (line 75) | fn test_odd_capacity_arithmetic_attack() {
  function test_insert_remove_same_key_attack (line 119) | fn test_insert_remove_same_key_attack() {
  function test_get_mut_corruption_attack (line 150) | fn test_get_mut_corruption_attack() {
  function test_split_merge_thrashing_attack (line 188) | fn test_split_merge_thrashing_attack() {
  function test_extreme_key_values_attack (line 227) | fn test_extreme_key_values_attack() {
  function test_ultimate_adversarial_attack (line 287) | fn test_ultimate_adversarial_attack() {

FILE: rust/tests/adversarial_linked_list.rs
  function test_linked_list_cycle_attack (line 9) | fn test_linked_list_cycle_attack() {
  function test_concurrent_iteration_modification_attack (line 51) | fn test_concurrent_iteration_modification_attack() {
  function test_split_during_iteration_attack (line 100) | fn test_split_during_iteration_attack() {
  function test_range_iterator_boundary_attack (line 141) | fn test_range_iterator_boundary_attack() {
  function test_linked_list_fragmentation_attack (line 211) | fn test_linked_list_fragmentation_attack() {
  function test_iterator_state_corruption_attack (line 266) | fn test_iterator_state_corruption_attack() {
  function test_force_linked_list_corruption (line 320) | fn test_force_linked_list_corruption() {

FILE: rust/tests/bplus_tree.rs
  function test_node_ref_id_and_is_leaf (line 12) | fn test_node_ref_id_and_is_leaf() {
  function test_insert_overwrite_value (line 27) | fn test_insert_overwrite_value() {
  function test_create_empty_tree (line 43) | fn test_create_empty_tree() {
  function test_insert_and_get_single_item (line 51) | fn test_insert_and_get_single_item() {
  function test_insert_multiple_items (line 62) | fn test_insert_multiple_items() {
  function test_update_existing_key (line 76) | fn test_update_existing_key() {
  function test_contains_key (line 88) | fn test_contains_key() {
  function test_get_with_default (line 100) | fn test_get_with_default() {
  function test_overflow (line 118) | fn test_overflow() {
  function test_split_then_add (line 139) | fn test_split_then_add() {
  function test_many_insertions_maintain_invariants (line 169) | fn test_many_insertions_maintain_invariants() {
  function test_parent_splitting (line 185) | fn test_parent_splitting() {
  function test_remove_single_item_from_leaf_root (line 210) | fn test_remove_single_item_from_leaf_root() {
  function test_remove_multiple_items_from_leaf_root (line 228) | fn test_remove_multiple_items_from_leaf_root() {
  function test_remove_nonexistent_key_returns_none (line 268) | fn test_remove_nonexistent_key_returns_none() {
  function test_remove_from_tree_with_branch_root (line 291) | fn test_remove_from_tree_with_branch_root() {
  function test_remove_multiple_from_tree_with_branches (line 316) | fn test_remove_multiple_from_tree_with_branches() {
  function test_insert_through_branch_node (line 421) | fn test_insert_through_branch_node() {
  function test_leaf_split_updates_parent_branch (line 474) | fn test_leaf_split_updates_parent_branch() {
  function test_root_promotion_leaf_to_branch (line 539) | fn test_root_promotion_leaf_to_branch() {
  function test_branch_node_split_creates_new_level (line 631) | fn test_branch_node_split_creates_new_level() {
  function test_comprehensive_insert_scenarios (line 721) | fn test_comprehensive_insert_scenarios() {
  function test_leaf_allocation (line 854) | fn test_leaf_allocation() {
  function test_leaf_linked_list (line 941) | fn test_leaf_linked_list() {
  function test_invalid_capacity_error (line 1064) | fn test_invalid_capacity_error() {
  function test_key_error_on_missing_key (line 1082) | fn test_key_error_on_missing_key() {
  function test_remove_nonexistent_key_raises_error (line 1096) | fn test_remove_nonexistent_key_raises_error() {
  function test_iterate_empty_tree (line 1116) | fn test_iterate_empty_tree() {
  function test_iterate_single_item (line 1123) | fn test_iterate_single_item() {
  function test_iterate_multiple_items_single_leaf (line 1132) | fn test_iterate_multiple_items_single_leaf() {
  function test_iterate_multiple_leaves (line 1152) | fn test_iterate_multiple_leaves() {
  function test_keys_iterator (line 1171) | fn test_keys_iterator() {
  function test_values_iterator (line 1182) | fn test_values_iterator() {
  function test_iterate_from_key (line 1200) | fn test_iterate_from_key() {
  function test_iterate_until_key (line 1217) | fn test_iterate_until_key() {
  function test_iterate_range (line 1234) | fn test_iterate_range() {
  function test_iterate_from_nonexistent_key (line 1251) | fn test_iterate_from_nonexistent_key() {
  function test_iterate_empty_range (line 1266) | fn test_iterate_empty_range() {
  function test_invariants_empty_tree (line 1282) | fn test_invariants_empty_tree() {
  function test_invariants_single_item (line 1288) | fn test_invariants_single_item() {
  function test_invariants_after_split (line 1295) | fn test_invariants_after_split() {
  function test_invariants_after_many_operations (line 1309) | fn test_invariants_after_many_operations() {
  function test_large_capacity_edge_cases (line 1348) | fn test_large_capacity_edge_cases() {
  function test_capacity_boundary_conditions (line 1378) | fn test_capacity_boundary_conditions() {
  function test_sequential_vs_random_patterns (line 1411) | fn test_sequential_vs_random_patterns() {
  function test_deep_tree_insertion (line 1458) | fn test_deep_tree_insertion() {
  function test_branch_node_splitting (line 1482) | fn test_branch_node_splitting() {
  function test_multi_level_splits (line 1506) | fn test_multi_level_splits() {
  function test_large_sequential_insertion (line 1533) | fn test_large_sequential_insertion() {
  function test_reverse_order_insertion (line 1560) | fn test_reverse_order_insertion() {
  function test_delete_until_empty (line 1590) | fn test_delete_until_empty() {
  function test_root_collapse (line 1622) | fn test_root_collapse() {
  function test_alternating_insert_delete (line 1648) | fn test_alternating_insert_delete() {
  function test_delete_from_deep_tree (line 1669) | fn test_delete_from_deep_tree() {
  function test_delete_all_but_one (line 1702) | fn test_delete_all_but_one() {
  function test_massive_insertion_deletion_cycle (line 1736) | fn test_massive_insertion_deletion_cycle() {
  function test_random_deletion_pattern (line 1777) | fn test_random_deletion_pattern() {
  function test_delete_from_minimal_tree (line 1810) | fn test_delete_from_minimal_tree() {
  function test_stress_deletion_with_invariants (line 1835) | fn test_stress_deletion_with_invariants() {
  function test_single_key_operations (line 1864) | fn test_single_key_operations() {
  function test_duplicate_key_handling (line 1888) | fn test_duplicate_key_handling() {
  function test_extreme_capacity_values (line 1908) | fn test_extreme_capacity_values() {
  function test_pathological_deletion_patterns (line 1935) | fn test_pathological_deletion_patterns() {
  function test_clustered_key_patterns (line 1966) | fn test_clustered_key_patterns() {
  function test_interleaved_operations (line 1999) | fn test_interleaved_operations() {
  function test_clear_and_reuse (line 2027) | fn test_clear_and_reuse() {
  function test_range_query_edge_cases (line 2052) | fn test_range_query_edge_cases() {
  function test_range_syntax_support (line 2076) | fn test_range_syntax_support() {
  function test_range_syntax_with_excluded_bounds (line 2117) | fn test_range_syntax_with_excluded_bounds() {
  function test_first_and_last (line 2146) | fn test_first_and_last() {
  function test_get_mut (line 2162) | fn test_get_mut() {
  function test_arena_consistency (line 2180) | fn test_arena_consistency() {
  function test_leaf_linked_list_completeness (line 2209) | fn test_leaf_linked_list_completeness() {
  function test_try_insert_and_remove (line 2226) | fn test_try_insert_and_remove() {
  function test_batch_insert (line 2242) | fn test_batch_insert() {
  function test_get_many (line 2260) | fn test_get_many() {
  function test_validate_for_operation (line 2282) | fn test_validate_for_operation() {

FILE: rust/tests/bug_reproduction_tests.rs
  function test_memory_leak_in_root_creation (line 8) | fn test_memory_leak_in_root_creation() {
  function test_linked_list_corruption_during_merge (line 31) | fn test_linked_list_corruption_during_merge() {
  function test_incorrect_split_logic_odd_capacity (line 69) | fn test_incorrect_split_logic_odd_capacity() {
  function test_root_split_linked_list_race (line 88) | fn test_root_split_linked_list_race() {
  function test_range_iterator_bound_handling (line 110) | fn test_range_iterator_bound_handling() {
  function test_min_keys_calculation_inconsistency (line 142) | fn test_min_keys_calculation_inconsistency() {
  function test_incomplete_rebalancing_logic (line 168) | fn test_incomplete_rebalancing_logic() {
  function test_arena_tree_consistency (line 197) | fn test_arena_tree_consistency() {
  function test_iterator_lifetime_safety (line 221) | fn test_iterator_lifetime_safety() {
  function test_root_collapse_edge_cases (line 235) | fn test_root_collapse_edge_cases() {
  function test_arena_id_collision (line 260) | fn test_arena_id_collision() {
  function test_split_validation_missing (line 282) | fn test_split_validation_missing() {

FILE: rust/tests/critical_bug_test.rs
  function test_linked_list_corruption_causes_data_loss (line 9) | fn test_linked_list_corruption_causes_data_loss() {
  function demonstrate_memory_leak_accumulation (line 66) | fn demonstrate_memory_leak_accumulation() {
  function test_invariants_after_problematic_operations (line 96) | fn test_invariants_after_problematic_operations() {
  function stress_test_arena_consistency (line 136) | fn stress_test_arena_consistency() {

FILE: rust/tests/debug_infinite_loop.rs
  function test_empty_tree_leaf_count (line 8) | fn test_empty_tree_leaf_count() {
  function test_tree_creation_only (line 20) | fn test_tree_creation_only() {
  function test_leaf_sizes (line 27) | fn test_leaf_sizes() {
  function test_single_insertion (line 39) | fn test_single_insertion() {
  function test_split_balance (line 54) | fn test_split_balance() {

FILE: rust/tests/enhanced_error_handling.rs
  function test_enhanced_error_constructors (line 18) | fn test_enhanced_error_constructors() {
  function test_result_type_aliases (line 64) | fn test_result_type_aliases() {
  function test_result_extension_trait (line 99) | fn test_result_extension_trait() {
  function test_get_or_default (line 135) | fn test_get_or_default() {
  function test_try_get (line 153) | fn test_try_get() {
  function test_try_insert_and_try_remove (line 172) | fn test_try_insert_and_try_remove() {
  function test_batch_insert (line 201) | fn test_batch_insert() {
  function test_get_many (line 228) | fn test_get_many() {
  function test_validate_for_operation (line 254) | fn test_validate_for_operation() {
  function test_error_context_propagation (line 271) | fn test_error_context_propagation() {
  function test_integration_with_existing_api (line 294) | fn test_integration_with_existing_api() {
  function test_error_recovery_patterns (line 324) | fn test_error_recovery_patterns() {
  function test_error_handling_performance (line 347) | fn test_error_handling_performance() {
  function test_comprehensive_error_scenario (line 376) | fn test_comprehensive_error_scenario() {

FILE: rust/tests/error_handling_consistency.rs
  function test_public_api_error_consistency (line 11) | fn test_public_api_error_consistency() {
  function test_error_message_formatting (line 67) | fn test_error_message_formatting() {
  function test_edge_case_error_handling (line 108) | fn test_edge_case_error_handling() {
  function test_error_propagation (line 151) | fn test_error_propagation() {
  function test_operation_safety (line 192) | fn test_operation_safety() {
  function test_error_recovery (line 244) | fn test_error_recovery() {
  function test_internal_error_consistency (line 305) | fn test_internal_error_consistency() {

FILE: rust/tests/fuzz_tests.rs
  function fuzz_test_bplustree (line 17) | fn fuzz_test_bplustree() {
  function fuzz_test_with_random_keys (line 151) | fn fuzz_test_with_random_keys() {
  function fuzz_test_with_updates (line 260) | fn fuzz_test_with_updates() {
  function fuzz_test_timed (line 334) | fn fuzz_test_timed() {
  function parse_duration (line 427) | fn parse_duration(s: &str) -> Result<Duration, String> {

FILE: rust/tests/linked_list_corruption_detection.rs
  function test_intensive_linked_list_corruption_detection (line 9) | fn test_intensive_linked_list_corruption_detection() {
  function test_merge_scenarios_linked_list_integrity (line 135) | fn test_merge_scenarios_linked_list_integrity() {
  function test_linked_list_edge_cases (line 227) | fn test_linked_list_edge_cases() {
  function test_linked_list_stress_consistency (line 281) | fn test_linked_list_stress_consistency() {

FILE: rust/tests/memory_leak_detection.rs
  function test_memory_leak_regression_prevention (line 13) | fn test_memory_leak_regression_prevention() {
  function test_root_split_no_memory_accumulation (line 157) | fn test_root_split_no_memory_accumulation() {
  function test_arena_fragmentation_and_reuse (line 193) | fn test_arena_fragmentation_and_reuse() {
  function test_stress_allocation_deallocation_cycles (line 245) | fn test_stress_allocation_deallocation_cycles() {
  function test_edge_case_memory_scenarios (line 287) | fn test_edge_case_memory_scenarios() {

FILE: rust/tests/memory_safety_audit.rs
  function test_arena_bounds_checking (line 11) | fn test_arena_bounds_checking() {
  function test_node_id_capacity_limits (line 54) | fn test_node_id_capacity_limits() {
  function test_arena_iteration_type_safety (line 92) | fn test_arena_iteration_type_safety() {
  function test_integer_overflow_prevention (line 131) | fn test_integer_overflow_prevention() {
  function test_memory_safety_stress (line 172) | fn test_memory_safety_stress() {
  function test_arena_operations_bounds (line 217) | fn test_arena_operations_bounds() {

FILE: rust/tests/range_bounds_syntax.rs
  function test_range_syntax_inclusive (line 4) | fn test_range_syntax_inclusive() {
  function test_range_syntax_exclusive (line 25) | fn test_range_syntax_exclusive() {
  function test_range_syntax_from (line 45) | fn test_range_syntax_from() {
  function test_range_syntax_to (line 57) | fn test_range_syntax_to() {
  function test_range_syntax_to_inclusive (line 69) | fn test_range_syntax_to_inclusive() {
  function test_range_syntax_full (line 81) | fn test_range_syntax_full() {
  function test_range_syntax_empty_ranges (line 93) | fn test_range_syntax_empty_ranges() {
  function test_range_syntax_edge_cases (line 113) | fn test_range_syntax_edge_cases() {
  function test_range_syntax_with_strings (line 133) | fn test_range_syntax_with_strings() {
  function test_range_syntax_single_element (line 156) | fn test_range_syntax_single_element() {
  function test_range_syntax_excluded_start (line 172) | fn test_range_syntax_excluded_start() {

FILE: rust/tests/range_differential.rs
  function populate_maps (line 4) | fn populate_maps(capacity: usize, data: &[i32]) -> (BPlusTreeMap<i32, i3...
  function test_range_differential_basic_boundaries (line 15) | fn test_range_differential_basic_boundaries() {
  function test_range_differential_gaps_and_nonexistent_bounds (line 64) | fn test_range_differential_gaps_and_nonexistent_bounds() {

FILE: rust/tests/remove_operations.rs
  function test_underfull_child_rebalancing_path (line 7) | fn test_underfull_child_rebalancing_path() {
  function test_underfull_leaf_detection (line 80) | fn test_underfull_leaf_detection() {
  function test_underfull_without_root_collapse (line 135) | fn test_underfull_without_root_collapse() {
  function test_demonstrates_need_for_borrowing_and_merging (line 189) | fn test_demonstrates_need_for_borrowing_and_merging() {
  function test_underfull_nodes_violate_invariants (line 246) | fn test_underfull_nodes_violate_invariants() {
  function test_strict_invariant_checking_should_fail (line 279) | fn test_strict_invariant_checking_should_fail() {
  function test_bplustree_remove_existing_key (line 306) | fn test_bplustree_remove_existing_key() {
  function test_bplustree_remove_with_underflow (line 328) | fn test_bplustree_remove_with_underflow() {
  function test_bplustree_remove_last_key_from_tree (line 367) | fn test_bplustree_remove_last_key_from_tree() {
  function test_bplustree_remove_all_keys_from_single_node (line 394) | fn test_bplustree_remove_all_keys_from_single_node() {
  function test_bplustree_remove_from_first_node_causing_empty (line 432) | fn test_bplustree_remove_from_first_node_causing_empty() {
  function test_bplustree_remove_with_root_node_empty_validation (line 463) | fn test_bplustree_remove_with_root_node_empty_validation() {
  function test_remove_nonexistent_key (line 485) | fn test_remove_nonexistent_key() {

FILE: rust/tests/simple_bug_tests.rs
  function test_memory_leak_placeholder (line 6) | fn test_memory_leak_placeholder() {
  function test_odd_capacity_split (line 40) | fn test_odd_capacity_split() {
  function test_linked_list_integrity (line 63) | fn test_linked_list_integrity() {
  function test_range_excluded_bounds (line 104) | fn test_range_excluded_bounds() {
  function test_min_keys_consistency (line 142) | fn test_min_keys_consistency() {
  function test_rebalancing_after_deletions (line 159) | fn test_rebalancing_after_deletions() {
  function test_iterator_consistency (line 193) | fn test_iterator_consistency() {
  function test_arena_utilization (line 211) | fn test_arena_utilization() {

FILE: rust/tests/specific_bug_demos.rs
  function demonstrate_memory_leak_bug (line 8) | fn demonstrate_memory_leak_bug() {
  function demonstrate_incorrect_split_for_odd_capacity (line 39) | fn demonstrate_incorrect_split_for_odd_capacity() {
  function demonstrate_min_keys_inconsistency (line 72) | fn demonstrate_min_keys_inconsistency() {
  function demonstrate_range_iterator_excluded_bound_bug (line 98) | fn demonstrate_range_iterator_excluded_bound_bug() {
  function demonstrate_linked_list_merge_corruption (line 137) | fn demonstrate_linked_list_merge_corruption() {
  function demonstrate_rebalancing_issues (line 181) | fn demonstrate_rebalancing_issues() {
  function demonstrate_arena_tree_consistency_issues (line 224) | fn demonstrate_arena_tree_consistency_issues() {
  function demonstrate_root_collapse_edge_case (line 273) | fn demonstrate_root_collapse_edge_case() {
  function verify_all_bugs_detected (line 314) | fn verify_all_bugs_detected() {

FILE: rust/tests/test_utils.rs
  function create_tree_4 (line 12) | pub fn create_tree_4() -> BPlusTreeMap<i32, String> {
  function create_tree_4_int (line 17) | pub fn create_tree_4_int() -> BPlusTreeMap<i32, i32> {
  function create_tree_5 (line 22) | pub fn create_tree_5() -> BPlusTreeMap<i32, String> {
  function create_tree_6 (line 27) | pub fn create_tree_6() -> BPlusTreeMap<i32, String> {
  function create_tree_capacity (line 32) | pub fn create_tree_capacity(capacity: usize) -> BPlusTreeMap<i32, String> {
  function create_tree_capacity_int (line 37) | pub fn create_tree_capacity_int(capacity: usize) -> BPlusTreeMap<i32, i3...
  function insert_sequential_range (line 49) | pub fn insert_sequential_range(tree: &mut BPlusTreeMap<i32, String>, cou...
  function insert_sequential_range_int (line 56) | pub fn insert_sequential_range_int(tree: &mut BPlusTreeMap<i32, i32>, co...
  function insert_with_multiplier (line 63) | pub fn insert_with_multiplier(tree: &mut BPlusTreeMap<i32, String>, coun...
  function insert_with_multiplier_int (line 71) | pub fn insert_with_multiplier_int(
  function insert_with_offset_multiplier (line 83) | pub fn insert_with_offset_multiplier(
  function insert_with_custom_fn (line 96) | pub fn insert_with_custom_fn<F, G>(
  function insert_range (line 113) | pub fn insert_range(tree: &mut BPlusTreeMap<i32, String>, start: usize, ...
  function insert_range_int (line 120) | pub fn insert_range_int(tree: &mut BPlusTreeMap<i32, i32>, start: usize,...
  function create_tree_4_with_data (line 131) | pub fn create_tree_4_with_data(count: usize) -> BPlusTreeMap<i32, String> {
  function create_tree_4_int_with_data (line 138) | pub fn create_tree_4_int_with_data(count: usize) -> BPlusTreeMap<i32, i3...
  function create_tree_with_data (line 145) | pub fn create_tree_with_data(capacity: usize, count: usize) -> BPlusTree...
  function create_tree_int_with_data (line 152) | pub fn create_tree_int_with_data(capacity: usize, count: usize) -> BPlus...
  function create_tree_4_with_multiplier (line 159) | pub fn create_tree_4_with_multiplier(count: usize, multiplier: i32) -> B...
  function assert_invariants (line 170) | pub fn assert_invariants(tree: &BPlusTreeMap<i32, String>, context: &str) {
  function assert_invariants_int (line 177) | pub fn assert_invariants_int(tree: &BPlusTreeMap<i32, i32>, context: &st...
  function assert_full_validation (line 184) | pub fn assert_full_validation(tree: &BPlusTreeMap<i32, String>, context:...
  function assert_full_validation_int (line 190) | pub fn assert_full_validation_int(tree: &BPlusTreeMap<i32, i32>, context...
  function deletion_range_attack (line 200) | pub fn deletion_range_attack(tree: &mut BPlusTreeMap<i32, String>, start...
  function deletion_range_attack_int (line 207) | pub fn deletion_range_attack_int(tree: &mut BPlusTreeMap<i32, i32>, star...
  function alternating_deletion_attack (line 214) | pub fn alternating_deletion_attack(tree: &mut BPlusTreeMap<i32, String>,...
  function stress_test_cycle (line 221) | pub fn stress_test_cycle<F>(tree: &mut BPlusTreeMap<i32, String>, cycles...
  function arena_exhaustion_attack (line 236) | pub fn arena_exhaustion_attack(tree: &mut BPlusTreeMap<i32, String>, cyc...
  function fragmentation_attack (line 258) | pub fn fragmentation_attack(tree: &mut BPlusTreeMap<i32, String>, base_k...
  function deep_tree_attack (line 276) | pub fn deep_tree_attack(tree: &mut BPlusTreeMap<i32, i32>, capacity: usi...
  function alternating_operations_attack (line 289) | pub fn alternating_operations_attack(tree: &mut BPlusTreeMap<i32, String...
  function verify_ordering (line 312) | pub fn verify_ordering(tree: &BPlusTreeMap<i32, String>) {
  function verify_ordering_int (line 322) | pub fn verify_ordering_int(tree: &BPlusTreeMap<i32, i32>) {
  function verify_item_count (line 332) | pub fn verify_item_count(tree: &BPlusTreeMap<i32, String>, expected: usi...
  function verify_item_count_int (line 343) | pub fn verify_item_count_int(tree: &BPlusTreeMap<i32, i32>, expected: us...
  function create_branch_test_tree (line 358) | pub fn create_branch_test_tree(capacity: usize) -> BPlusTreeMap<i32, Str...
  function setup_concurrent_simulation (line 378) | pub fn setup_concurrent_simulation() -> (Vec<(bool, i32)>, Vec<(bool, i3...
  function execute_interleaved_ops (line 399) | pub fn execute_interleaved_ops(
  function print_tree_stats (line 434) | pub fn print_tree_stats(tree: &BPlusTreeMap<i32, String>, label: &str) {
  function print_tree_stats_int (line 448) | pub fn print_tree_stats_int(tree: &BPlusTreeMap<i32, i32>, label: &str) {
  function create_attack_tree (line 466) | pub fn create_attack_tree(capacity: usize) -> BPlusTreeMap<i32, String> {
  function create_simple_tree (line 471) | pub fn create_simple_tree(capacity: usize) -> BPlusTreeMap<i32, i32> {
  function populate_sequential (line 476) | pub fn populate_sequential(tree: &mut BPlusTreeMap<i32, String>, count: ...
  function populate_sequential_int (line 481) | pub fn populate_sequential_int(tree: &mut BPlusTreeMap<i32, i32>, count:...
  function populate_sequential_int_x10 (line 486) | pub fn populate_sequential_int_x10(tree: &mut BPlusTreeMap<i32, i32>, co...
  function assert_attack_failed (line 493) | pub fn assert_attack_failed(tree: &BPlusTreeMap<i32, String>, context: &...
  function assert_attack_failed_int (line 498) | pub fn assert_attack_failed_int(tree: &BPlusTreeMap<i32, i32>, context: ...
  function test_utilities_basic_functionality (line 507) | fn test_utilities_basic_functionality() {
  function test_stress_cycle_utility (line 517) | fn test_stress_cycle_utility() {
  function test_combined_creation_utilities (line 529) | fn test_combined_creation_utilities() {
  function test_attack_patterns (line 536) | fn test_attack_patterns() {

FILE: rust/tools/parse_time_profile.py
  function main (line 17) | def main(path: str) -> int:

FILE: scripts/analyze_benchmarks.py
  function create_comparison_charts (line 40) | def create_comparison_charts():
  function create_capacity_optimization_chart (line 111) | def create_capacity_optimization_chart():
  function create_performance_ratio_chart (line 169) | def create_performance_ratio_chart():
  function print_summary (line 210) | def print_summary():

FILE: simple_time_analysis.py
  function parse_git_log (line 12) | def parse_git_log():
  function calculate_programming_sessions (line 60) | def calculate_programming_sessions(commits, max_gap_minutes=120):
  function analyze_daily_programming (line 107) | def analyze_daily_programming(sessions):
  function create_ascii_chart (line 122) | def create_ascii_chart(daily_data):
  function print_summary (line 144) | def print_summary(sessions, daily_data):
  function analyze_patterns (line 207) | def analyze_patterns(sessions, daily_data):
  function main (line 259) | def main():

FILE: visualize_programming_time.py
  function parse_git_log (line 15) | def parse_git_log():
  function calculate_programming_sessions (line 61) | def calculate_programming_sessions(commits, max_gap_minutes=120):
  function analyze_daily_programming (line 101) | def analyze_daily_programming(sessions):
  function create_comprehensive_visualization (line 116) | def create_comprehensive_visualization(sessions, daily_data):
  function main (line 351) | def main():