56         for level in 0.. {  in find()
57             self.size = level + 1;  in find()
58             self.node[level] = node;  in find()
69                     self.entry[level] = i as u8;  in find()
76                             self.entry[level] = i as u8;  in find()
80                             self.entry[level] = i as u8;  in find()
94         for level in 0.. {  in first()
95             self.size = level + 1;  in first()
96             self.node[level] = node;  in first()
97             self.entry[level] = 0;  in first()
166     fn next_node(&mut self, level: usize, pool: &NodePool<F>) -> Option<Node> {  in next_node()
167         match self.right_sibling_branch_level(level, pool) {  in next_node()
177                 for l in bl + 1..level {  in next_node()
183                 self.node[level] = node;  in next_node()
184                 self.entry[level] = 0;  in next_node()
205     fn goto_subtree_last(&mut self, level: usize, root: Node, pool: &NodePool<F>) -> Node {  in goto_subtree_last()
207         for l in level.. {  in goto_subtree_last()
303         for level in (0..self.size).rev() {  in split_and_insert()
305             let mut node = self.node[level];  in split_and_insert()
306             let mut entry = self.entry[level].into();  in split_and_insert()
323                 self.node[level] = node;  in split_and_insert()
324                 self.entry[level] = entry as u8;  in split_and_insert()
343                     if n == self.node[level + 1] {  in split_and_insert()
344                         self.entry[level] += 1;  in split_and_insert()
353             if level > 0 {  in split_and_insert()
354                 let pnode = &mut pool[self.node[level - 1]];  in split_and_insert()
355                 let pentry = self.entry[level - 1].into();  in split_and_insert()
359                         self.entry[level - 1] += 1;  in split_and_insert()
399     fn current_crit_key(&self, level: usize, pool: &NodePool<F>) -> Option<F::Key> {  in current_crit_key()
401         self.left_sibling_branch_level(level).map(|bl| {  in current_crit_key()
487     fn heal_level(&mut self, status: Removed, level: usize, pool: &mut NodePool<F>) -> bool {  in heal_level()
494                     usize::from(self.entry[level]),  in heal_level()
495                     pool[self.node[level]].entries()  in heal_level()
497                 self.next_node(level, pool);  in heal_level()
499             Removed::Underflow => self.underflowed_node(level, pool),  in heal_level()
500             Removed::Empty => return self.empty_node(level, pool),  in heal_level()
511     fn underflowed_node(&mut self, level: usize, pool: &mut NodePool<F>) {  in underflowed_node()
514         if let Some((crit_key, rhs_node)) = self.right_sibling(level, pool) {  in underflowed_node()
520             match pool[self.node[level]].balance(crit_key, &mut rhs) {  in underflowed_node()
523                     new_ck = self.current_crit_key(level, pool);  in underflowed_node()
537                 self.update_right_crit_key(level, ck, pool);  in underflowed_node()
540                 let empty_tree = self.empty_node(level, pool);  in underflowed_node()
547             debug_assert!(usize::from(self.entry[level]) < pool[self.node[level]].entries());  in underflowed_node()
548         } else if usize::from(self.entry[level]) >= pool[self.node[level]].entries() {  in underflowed_node()
563     fn empty_node(&mut self, level: usize, pool: &mut NodePool<F>) -> bool {  in empty_node()
564         pool.free_node(self.node[level]);  in empty_node()
565         if level == 0 {  in empty_node()
571         let rhs_node = self.right_sibling(level, pool).map(|(_, n)| n);  in empty_node()
574         let pl = level - 1;  in empty_node()
583             Some(rhs) => self.node[level] = rhs,  in empty_node()
597     fn right_sibling_branch_level(&self, level: usize, pool: &NodePool<F>) -> Option<usize> {  in right_sibling_branch_level()
598         (0..level).rposition(|l| match pool[self.node[l]] {  in right_sibling_branch_level()
605     fn left_sibling_branch_level(&self, level: usize) -> Option<usize> {  in left_sibling_branch_level()
606         self.entry[0..level].iter().rposition(|&e| e != 0)  in left_sibling_branch_level()
611     fn right_sibling(&self, level: usize, pool: &NodePool<F>) -> Option<(F::Key, Node)> {  in right_sibling()
614         self.right_sibling_branch_level(level, pool).map(|bl| {  in right_sibling()
626             for _ in bl + 1..level {  in right_sibling()
635     fn update_right_crit_key(&self, level: usize, crit_key: F::Key, pool: &mut NodePool<F>) {  in update_right_crit_key()
637             .right_sibling_branch_level(level, pool)  in update_right_crit_key()
663         for level in 0..self.size {  in verify()
664             match pool[self.node[level]] {  in verify()
666                     assert!(level < self.size - 1, "Expected leaf node at level {level}");  in verify()
668                         self.entry[level] <= size,  in verify()
670                         self.entry[level],  in verify()
672                         level  in verify()
675                         self.node[level + 1],  in verify()
676                         tree[usize::from(self.entry[level])],  in verify()
681                     assert_eq!(level, self.size - 1, "Expected inner node");  in verify()
683                         self.entry[level] <= size,  in verify()
685                         self.entry[level],  in verify()
690                     panic!("Free {} in path", self.node[level]);  in verify()