├── .gitignore ├── ada ├── ada_test ├── ada_test2 ├── tree_traversal ├── tree_traversal.o ├── ada_test.adb ├── ada_test2.adb ├── bubble_sort.adb ├── tree_traversal.adb └── tree_traversal.ali ├── go ├── bubble_sort ├── tree_traversal ├── bubble_sort.go └── tree_traversal.go ├── rust ├── bubble_sort ├── tree_traversal ├── bubble_sort.rs └── tree_traversal.rs ├── freepascal ├── pick_random ├── pick_random.o └── pick_random.pas ├── README.md ├── bootstrap.c ├── import_1.s ├── Makefile ├── ref_marking_1.s ├── ref_marking_2.s └── ref_marking_3.s /.gitignore: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /ada/ada_test: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/ada/ada_test -------------------------------------------------------------------------------- /ada/ada_test2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/ada/ada_test2 -------------------------------------------------------------------------------- /go/bubble_sort: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/go/bubble_sort -------------------------------------------------------------------------------- /rust/bubble_sort: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/rust/bubble_sort -------------------------------------------------------------------------------- /ada/tree_traversal: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/ada/tree_traversal -------------------------------------------------------------------------------- /go/tree_traversal: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/go/tree_traversal -------------------------------------------------------------------------------- /ada/tree_traversal.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/ada/tree_traversal.o -------------------------------------------------------------------------------- /rust/tree_traversal: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/rust/tree_traversal -------------------------------------------------------------------------------- /freepascal/pick_random: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/freepascal/pick_random -------------------------------------------------------------------------------- /freepascal/pick_random.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/radareorg/radeco-regressions/master/freepascal/pick_random.o -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## radeco-mini-tests 2 | 3 | Hand-written assembly and small testcases to test specific cases in binary 4 | analysis 5 | 6 | -------------------------------------------------------------------------------- /ada/ada_test.adb: -------------------------------------------------------------------------------- 1 | with Ada.Text_IO; use Ada.Text_IO; 2 | procedure Ada_Test is 3 | begin 4 | Put_Line ("HELL!"); 5 | end Ada_Test; 6 | 7 | -------------------------------------------------------------------------------- /bootstrap.c: -------------------------------------------------------------------------------- 1 | extern int main(); 2 | void _start() { 3 | main(); 4 | asm("mov %eax, 0x1;" 5 | "xor %rbx, %rbx;" 6 | "int 0x80;" 7 | ); 8 | } 9 | 10 | -------------------------------------------------------------------------------- /import_1.s: -------------------------------------------------------------------------------- 1 | # Tests simple reference marking. Arg1/rdi should be marked as a reference 2 | .intel_syntax noprefix 3 | .section .text 4 | .global main 5 | 6 | main: 7 | call strcmp 8 | ret 9 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | CC=gcc 2 | 3 | SRC = $(wildcard *.s) 4 | PROGS = $(patsubst %.s,%,$(SRC)) 5 | current_dir = $(shell pwd) 6 | 7 | all: $(PROGS) 8 | 9 | %: %.s 10 | $(CC) -g -o $@ -masm=intel $< 11 | 12 | clean: 13 | rm $(PROGS) 14 | -------------------------------------------------------------------------------- /ref_marking_1.s: -------------------------------------------------------------------------------- 1 | # Tests simple reference marking. Arg1/rdi should be marked as a reference 2 | .intel_syntax noprefix 3 | .section .text 4 | .global main 5 | 6 | main: 7 | lea rax, [rdi + 0x20] 8 | mov rax, [rax] 9 | ret 10 | -------------------------------------------------------------------------------- /freepascal/pick_random.pas: -------------------------------------------------------------------------------- 1 | Program PickRandomElement (output); 2 | 3 | const 4 | s: array [1..5] of string = ('1234', 'ABCDE', 'WTF', 'Some more', 'qwe'); 5 | 6 | begin 7 | randomize; 8 | writeln(s[low(s) + random(length(s))]); 9 | end. 10 | 11 | -------------------------------------------------------------------------------- /ada/ada_test2.adb: -------------------------------------------------------------------------------- 1 | with Ada.Text_IO; use Ada.Text_IO; 2 | -- Simple procedure 3 | procedure Ada_Test2 is 4 | name :string(1..100); 5 | last :natural; 6 | begin 7 | for i in 1..10 loop 8 | Put_Line ("HELL!" & name(1..last)); 9 | end loop; 10 | end Ada_Test2; 11 | 12 | -------------------------------------------------------------------------------- /ref_marking_2.s: -------------------------------------------------------------------------------- 1 | # Tests simple reference marking. Arg1/rdi should be marked as a reference 2 | .intel_syntax noprefix 3 | .section .text 4 | .global main 5 | 6 | foo1: 7 | lea rax, [rdi + 0x20] 8 | mov rax, [rax] 9 | ret 10 | 11 | main: 12 | call foo1 13 | ret 14 | -------------------------------------------------------------------------------- /ref_marking_3.s: -------------------------------------------------------------------------------- 1 | # Tests simple reference marking. Arg1/rdi should be marked as a reference 2 | .intel_syntax noprefix 3 | .section .text 4 | .global main 5 | 6 | foo1: 7 | lea rax, [rdi + 0x20] 8 | mov rax, [rax] 9 | ret 10 | 11 | foo2: 12 | lea rdi, [rdi + 0x20] 13 | call foo1 14 | ret 15 | 16 | main: 17 | call foo2 18 | ret 19 | -------------------------------------------------------------------------------- /go/bubble_sort.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | list := []int{31, 41, 59, 26, 53, 58, 97, 93, 23, 84} 7 | fmt.Println("unsorted:", list) 8 | 9 | bubblesort(list) 10 | fmt.Println("sorted! ", list) 11 | } 12 | 13 | func bubblesort(a []int) { 14 | for itemCount := len(a) - 1; ; itemCount-- { 15 | hasChanged := false 16 | for index := 0; index < itemCount; index++ { 17 | if a[index] > a[index+1] { 18 | a[index], a[index+1] = a[index+1], a[index] 19 | hasChanged = true 20 | } 21 | } 22 | if hasChanged == false { 23 | break 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /ada/bubble_sort.adb: -------------------------------------------------------------------------------- 1 | generic 2 | type Element is private; 3 | with function "=" (E1, E2 : Element) return Boolean is <>; 4 | with function "<" (E1, E2 : Element) return Boolean is <>; 5 | type Index is (<>); 6 | type Arr is array (Index range <>) of Element; 7 | procedure Bubble_Sort (A : in out Arr); 8 | 9 | procedure Bubble_Sort (A : in out Arr) is 10 | Finished : Boolean; 11 | Temp : Element; 12 | begin 13 | loop 14 | Finished := True; 15 | for J in A'First .. Index'Pred (A'Last) loop 16 | if A (Index'Succ (J)) < A (J) then 17 | Finished := False; 18 | Temp := A (Index'Succ (J)); 19 | A (Index'Succ (J)) := A (J); 20 | A (J) := Temp; 21 | end if; 22 | end loop; 23 | exit when Finished; 24 | end loop; 25 | end Bubble_Sort; 26 | 27 | 28 | -------------------------------------------------------------------------------- /rust/bubble_sort.rs: -------------------------------------------------------------------------------- 1 | fn bubble_sort(values: &mut[T]) { 2 | let mut n = values.len(); 3 | let mut swapped = true; 4 | 5 | while swapped { 6 | swapped = false; 7 | 8 | for i in 1..n { 9 | if values[i - 1] > values[i] { 10 | values.swap(i - 1, i); 11 | swapped = true; 12 | } 13 | } 14 | 15 | n = n - 1; 16 | } 17 | } 18 | 19 | fn main() { 20 | // Sort numbers. 21 | let mut numbers = [8, 7, 1, 2, 9, 3, 4, 5, 0, 6]; 22 | println!("Before: {:?}", numbers); 23 | 24 | bubble_sort(&mut numbers); 25 | println!("After: {:?}", numbers); 26 | 27 | // Sort strings. 28 | let mut strings = ["empty", "beach", "art", "car", "deal"]; 29 | println!("Before: {:?}", strings); 30 | 31 | bubble_sort(&mut strings); 32 | println!("After: {:?}", strings); 33 | } 34 | -------------------------------------------------------------------------------- /go/tree_traversal.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // flat, level-order representation. 6 | // for node at index k, left child has index 2k, right child has index 2k+1. 7 | // a value of -1 means the node does not exist. 8 | type tree []int 9 | 10 | func main() { 11 | t := tree{1, 2, 3, 4, 5, 6, -1, 7, -1, -1, -1, 8, 9} 12 | visitor := func(n int) { 13 | fmt.Print(n, " ") 14 | } 15 | fmt.Print("preorder: ") 16 | t.iterPreorder(visitor) 17 | fmt.Print("\ninorder: ") 18 | t.iterInorder(visitor) 19 | fmt.Print("\npostorder: ") 20 | t.iterPostorder(visitor) 21 | fmt.Print("\nlevel-order: ") 22 | t.iterLevelorder(visitor) 23 | fmt.Println() 24 | } 25 | 26 | func (t tree) iterPreorder(visit func(int)) { 27 | var traverse func(int) 28 | traverse = func(k int) { 29 | if k >= len(t) || t[k] == -1 { 30 | return 31 | } 32 | visit(t[k]) 33 | traverse(2*k + 1) 34 | traverse(2*k + 2) 35 | } 36 | traverse(0) 37 | } 38 | 39 | func (t tree) iterInorder(visit func(int)) { 40 | var traverse func(int) 41 | traverse = func(k int) { 42 | if k >= len(t) || t[k] == -1 { 43 | return 44 | } 45 | traverse(2*k + 1) 46 | visit(t[k]) 47 | traverse(2*k + 2) 48 | } 49 | traverse(0) 50 | } 51 | 52 | func (t tree) iterPostorder(visit func(int)) { 53 | var traverse func(int) 54 | traverse = func(k int) { 55 | if k >= len(t) || t[k] == -1 { 56 | return 57 | } 58 | traverse(2*k + 1) 59 | traverse(2*k + 2) 60 | visit(t[k]) 61 | } 62 | traverse(0) 63 | } 64 | 65 | func (t tree) iterLevelorder(visit func(int)) { 66 | for _, n := range t { 67 | if n != -1 { 68 | visit(n) 69 | } 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /ada/tree_traversal.adb: -------------------------------------------------------------------------------- 1 | with Ada.Text_Io; use Ada.Text_Io; 2 | with Ada.Unchecked_Deallocation; 3 | with Ada.Containers.Doubly_Linked_Lists; 4 | 5 | procedure Tree_Traversal is 6 | type Node; 7 | type Node_Access is access Node; 8 | type Node is record 9 | Left : Node_Access := null; 10 | Right : Node_Access := null; 11 | Data : Integer; 12 | end record; 13 | procedure Destroy_Tree(N : in out Node_Access) is 14 | procedure free is new Ada.Unchecked_Deallocation(Node, Node_Access); 15 | begin 16 | if N.Left /= null then 17 | Destroy_Tree(N.Left); 18 | end if; 19 | if N.Right /= null then 20 | Destroy_Tree(N.Right); 21 | end if; 22 | Free(N); 23 | end Destroy_Tree; 24 | function Tree(Value : Integer; Left : Node_Access; Right : Node_Access) return Node_Access is 25 | Temp : Node_Access := new Node; 26 | begin 27 | Temp.Data := Value; 28 | Temp.Left := Left; 29 | Temp.Right := Right; 30 | return Temp; 31 | end Tree; 32 | procedure Preorder(N : Node_Access) is 33 | begin 34 | Put(Integer'Image(N.Data)); 35 | if N.Left /= null then 36 | Preorder(N.Left); 37 | end if; 38 | if N.Right /= null then 39 | Preorder(N.Right); 40 | end if; 41 | end Preorder; 42 | procedure Inorder(N : Node_Access) is 43 | begin 44 | if N.Left /= null then 45 | Inorder(N.Left); 46 | end if; 47 | Put(Integer'Image(N.Data)); 48 | if N.Right /= null then 49 | Inorder(N.Right); 50 | end if; 51 | end Inorder; 52 | procedure Postorder(N : Node_Access) is 53 | begin 54 | if N.Left /= null then 55 | Postorder(N.Left); 56 | end if; 57 | if N.Right /= null then 58 | Postorder(N.Right); 59 | end if; 60 | Put(Integer'Image(N.Data)); 61 | end Postorder; 62 | procedure Levelorder(N : Node_Access) is 63 | package Queues is new Ada.Containers.Doubly_Linked_Lists(Node_Access); 64 | use Queues; 65 | Node_Queue : List; 66 | Next : Node_Access; 67 | begin 68 | Node_Queue.Append(N); 69 | while not Is_Empty(Node_Queue) loop 70 | Next := First_Element(Node_Queue); 71 | Delete_First(Node_Queue); 72 | Put(Integer'Image(Next.Data)); 73 | if Next.Left /= null then 74 | Node_Queue.Append(Next.Left); 75 | end if; 76 | if Next.Right /= null then 77 | Node_Queue.Append(Next.Right); 78 | end if; 79 | end loop; 80 | end Levelorder; 81 | N : Node_Access; 82 | begin 83 | N := Tree(1, 84 | Tree(2, 85 | Tree(4, 86 | Tree(7, null, null), 87 | null), 88 | Tree(5, null, null)), 89 | Tree(3, 90 | Tree(6, 91 | Tree(8, null, null), 92 | Tree(9, null, null)), 93 | null)); 94 | 95 | Put("preorder: "); 96 | Preorder(N); 97 | New_Line; 98 | Put("inorder: "); 99 | Inorder(N); 100 | New_Line; 101 | Put("postorder: "); 102 | Postorder(N); 103 | New_Line; 104 | Put("level order: "); 105 | Levelorder(N); 106 | New_Line; 107 | Destroy_Tree(N); 108 | end Tree_traversal; 109 | -------------------------------------------------------------------------------- /rust/tree_traversal.rs: -------------------------------------------------------------------------------- 1 | #![feature(box_syntax, box_patterns)] 2 | 3 | use std::collections::VecDeque; 4 | 5 | #[derive(Debug)] 6 | struct TreeNode { 7 | value: T, 8 | left: Option>>, 9 | right: Option>>, 10 | } 11 | 12 | enum TraversalMethod { 13 | PreOrder, 14 | InOrder, 15 | PostOrder, 16 | LevelOrder, 17 | } 18 | 19 | impl TreeNode { 20 | pub fn new(arr: &[[i8; 3]]) -> TreeNode { 21 | 22 | let l = match arr[0][1] { 23 | -1 => None, 24 | i @ _ => Some(Box::new(TreeNode::::new(&arr[(i - arr[0][0]) as usize..]))), 25 | }; 26 | let r = match arr[0][2] { 27 | -1 => None, 28 | i @ _ => Some(Box::new(TreeNode::::new(&arr[(i - arr[0][0]) as usize..]))), 29 | }; 30 | 31 | TreeNode { 32 | value: arr[0][0], 33 | left: l, 34 | right: r, 35 | } 36 | } 37 | 38 | pub fn traverse(&self, tr: &TraversalMethod) -> Vec<&TreeNode> { 39 | match tr { 40 | &TraversalMethod::PreOrder => self.iterative_preorder(), 41 | &TraversalMethod::InOrder => self.iterative_inorder(), 42 | &TraversalMethod::PostOrder => self.iterative_postorder(), 43 | &TraversalMethod::LevelOrder => self.iterative_levelorder(), 44 | } 45 | } 46 | 47 | fn iterative_preorder(&self) -> Vec<&TreeNode> { 48 | let mut stack: Vec<&TreeNode> = Vec::new(); 49 | let mut res: Vec<&TreeNode> = Vec::new(); 50 | 51 | stack.push(self); 52 | while !stack.is_empty() { 53 | let node = stack.pop().unwrap(); 54 | res.push(node); 55 | match node.right { 56 | None => {} 57 | Some(box ref n) => stack.push(n), 58 | } 59 | match node.left { 60 | None => {} 61 | Some(box ref n) => stack.push(n), 62 | } 63 | } 64 | res 65 | } 66 | 67 | // Leftmost to rightmost 68 | fn iterative_inorder(&self) -> Vec<&TreeNode> { 69 | let mut stack: Vec<&TreeNode> = Vec::new(); 70 | let mut res: Vec<&TreeNode> = Vec::new(); 71 | let mut p = self; 72 | 73 | loop { 74 | // Stack parents and right children while left-descending 75 | loop { 76 | match p.right { 77 | None => {} 78 | Some(box ref n) => stack.push(n), 79 | } 80 | stack.push(p); 81 | match p.left { 82 | None => break, 83 | Some(box ref n) => p = n, 84 | } 85 | } 86 | // Visit the nodes with no right child 87 | p = stack.pop().unwrap(); 88 | while !stack.is_empty() && p.right.is_none() { 89 | res.push(p); 90 | p = stack.pop().unwrap(); 91 | } 92 | // First node that can potentially have a right child: 93 | res.push(p); 94 | if stack.is_empty() { 95 | break; 96 | } else { 97 | p = stack.pop().unwrap(); 98 | } 99 | } 100 | res 101 | } 102 | 103 | // Left-to-right postorder is same sequence as right-to-left preorder, reversed 104 | fn iterative_postorder(&self) -> Vec<&TreeNode> { 105 | let mut stack: Vec<&TreeNode> = Vec::new(); 106 | let mut res: Vec<&TreeNode> = Vec::new(); 107 | 108 | stack.push(self); 109 | while !stack.is_empty() { 110 | let node = stack.pop().unwrap(); 111 | res.push(node); 112 | match node.left { 113 | None => {} 114 | Some(box ref n) => stack.push(n), 115 | } 116 | match node.right { 117 | None => {} 118 | Some(box ref n) => stack.push(n), 119 | } 120 | } 121 | let rev_iter = res.iter().rev(); 122 | let mut rev: Vec<&TreeNode> = Vec::new(); 123 | for elem in rev_iter { 124 | rev.push(elem); 125 | } 126 | rev 127 | } 128 | 129 | fn iterative_levelorder(&self) -> Vec<&TreeNode> { 130 | let mut queue: VecDeque<&TreeNode> = VecDeque::new(); 131 | let mut res: Vec<&TreeNode> = Vec::new(); 132 | 133 | queue.push_back(self); 134 | while !queue.is_empty() { 135 | let node = queue.pop_front().unwrap(); 136 | res.push(node); 137 | match node.left { 138 | None => {} 139 | Some(box ref n) => queue.push_back(n), 140 | } 141 | match node.right { 142 | None => {} 143 | Some(box ref n) => queue.push_back(n), 144 | } 145 | } 146 | res 147 | } 148 | } 149 | 150 | fn main() { 151 | // Array representation of task tree 152 | let arr_tree = [[1, 2, 3], 153 | [2, 4, 5], 154 | [3, 6, -1], 155 | [4, 7, -1], 156 | [5, -1, -1], 157 | [6, 8, 9], 158 | [7, -1, -1], 159 | [8, -1, -1], 160 | [9, -1, -1]]; 161 | 162 | let root = TreeNode::::new(&arr_tree); 163 | 164 | for method_label in [(TraversalMethod::PreOrder, "pre-order:"), 165 | (TraversalMethod::InOrder, "in-order:"), 166 | (TraversalMethod::PostOrder, "post-order:"), 167 | (TraversalMethod::LevelOrder, "level-order:")] 168 | .iter() { 169 | print!("{}\t", method_label.1); 170 | for n in root.traverse(&method_label.0) { 171 | print!(" {}", n.value); 172 | } 173 | print!("\n"); 174 | } 175 | } 176 | -------------------------------------------------------------------------------- /ada/tree_traversal.ali: -------------------------------------------------------------------------------- 1 | V "GNAT Lib v8" 2 | M P W=b 3 | P ZX 4 | 5 | RN 6 | RV NO_ACCESS_SUBPROGRAMS 7 | RV NO_ALLOCATORS 8 | RV NO_DIRECT_BOOLEAN_OPERATORS 9 | RV NO_DISPATCH 10 | RV NO_DISPATCHING_CALLS 11 | RV NO_EXCEPTION_HANDLERS 12 | RV NO_EXCEPTION_PROPAGATION 13 | RV NO_EXCEPTIONS 14 | RV NO_IO 15 | RV NO_IMPLICIT_CONDITIONALS 16 | RV NO_LOCAL_ALLOCATORS 17 | RV NO_NESTED_FINALIZATION 18 | RV NO_RECURSION 19 | RV NO_SECONDARY_STACK 20 | RV NO_STANDARD_ALLOCATORS_AFTER_ELABORATION 21 | RV NO_STANDARD_STORAGE_POOLS 22 | RV NO_STREAMS 23 | RV NO_UNCHECKED_ACCESS 24 | RV NO_UNCHECKED_DEALLOCATION 25 | RV NO_DEFAULT_INITIALIZATION 26 | RV NO_DYNAMIC_SIZED_OBJECTS 27 | RV NO_IMPLEMENTATION_ATTRIBUTES 28 | RV NO_IMPLEMENTATION_PRAGMAS 29 | RV NO_IMPLICIT_ALIASING 30 | RV STATIC_DISPATCH_TABLES 31 | RV SPARK_05 32 | 33 | U tree_traversal%b tree_traversal.adb 4db56600 NE OO SU 34 | W ada%s ada.ads ada.ali 35 | W ada.containers%s a-contai.ads a-contai.ali 36 | W ada.containers.doubly_linked_lists%s 37 | Z ada.containers.helpers%s a-conhel.adb a-conhel.ali 38 | Z ada.exceptions%s a-except.adb a-except.ali 39 | Z ada.finalization%s a-finali.ads a-finali.ali 40 | Z ada.iterator_interfaces%s 41 | Z ada.streams%s a-stream.adb a-stream.ali 42 | Z ada.tags%s a-tags.adb a-tags.ali 43 | W ada.text_io%s a-textio.adb a-textio.ali 44 | W ada.unchecked_deallocation%s 45 | Z system%s system.ads system.ali 46 | Z system.address_image%s s-addima.adb s-addima.ali 47 | Z system.concat_2%s s-conca2.adb s-conca2.ali 48 | Z system.finalization_masters%s s-finmas.adb s-finmas.ali 49 | Z system.img_int%s s-imgint.adb s-imgint.ali 50 | Z system.pool_global%s s-pooglo.adb s-pooglo.ali 51 | Z system.secondary_stack%s s-secsta.adb s-secsta.ali 52 | Z system.soft_links%s s-soflin.adb s-soflin.ali 53 | Z system.standard_library%s s-stalib.adb s-stalib.ali 54 | Z system.storage_elements%s s-stoele.adb s-stoele.ali 55 | Z system.storage_pools%s s-stopoo.adb s-stopoo.ali 56 | Z system.storage_pools.subpools%s s-stposu.adb s-stposu.ali 57 | Z system.stream_attributes%s s-stratt.adb s-stratt.ali 58 | 59 | D ada.ads 20180113120628 76789da1 ada%s 60 | D a-contai.ads 20180113120628 61e5e089 ada.containers%s 61 | D a-cdlili.ads 20180113120628 8e06b4f2 ada.containers.doubly_linked_lists%s 62 | D a-cdlili.adb 20180113120628 8ed211ef ada.containers.doubly_linked_lists%b 63 | D a-conhel.ads 20180113120628 20298884 ada.containers.helpers%s 64 | D a-conhel.adb 20180113120628 9cc5095b ada.containers.helpers%b 65 | D a-except.ads 20180113120628 291912d5 ada.exceptions%s 66 | D a-finali.ads 20180113120628 bf4f806b ada.finalization%s 67 | D a-ioexce.ads 20180113120628 e4a01f64 ada.io_exceptions%s 68 | D a-iteint.ads 20180113120628 7c7305e9 ada.iterator_interfaces%s 69 | D a-stream.ads 20180113120628 119b8fb3 ada.streams%s 70 | D a-tags.ads 20180113120628 491b781d ada.tags%s 71 | D a-textio.ads 20180113120628 881db35a ada.text_io%s 72 | D a-unccon.ads 20180113120628 0e9b276f ada.unchecked_conversion%s 73 | D a-uncdea.ads 20180113120628 eff36322 ada.unchecked_deallocation%s 74 | D interfac.ads 20180113120628 5ab55268 interfaces%s 75 | D i-cstrea.ads 20180113120628 e53d8b8e interfaces.c_streams%s 76 | D system.ads 20180113120628 4635ec04 system%s 77 | D s-addima.ads 20180113120628 a1ec9d3a system.address_image%s 78 | D s-atocou.ads 20180113120628 b45c2d8d system.atomic_counters%s 79 | D s-atocou.adb 20180113120628 b65612c0 system.atomic_counters%b 80 | D s-conca2.ads 20180113120628 02a0d7d0 system.concat_2%s 81 | D s-crtl.ads 20180113120628 0ebbdb71 system.crtl%s 82 | D s-exctab.ads 20180113120628 54135002 system.exception_table%s 83 | D s-ficobl.ads 20180113120628 078245e4 system.file_control_block%s 84 | D s-finmas.ads 20180113120628 7811a767 system.finalization_masters%s 85 | D s-finroo.ads 20180113120628 4ff27390 system.finalization_root%s 86 | D s-imgint.ads 20180113120628 02dbe0c2 system.img_int%s 87 | D s-memory.ads 20180113120628 597d6634 system.memory%s 88 | D s-parame.ads 20180113120628 f896c45c system.parameters%s 89 | D s-pooglo.ads 20180113120628 ede33ef8 system.pool_global%s 90 | D s-secsta.ads 20180113120628 283dec34 system.secondary_stack%s 91 | D s-soflin.ads 20180113120628 a7318a92 system.soft_links%s 92 | D s-stache.ads 20180113120628 a37c21ec system.stack_checking%s 93 | D s-stalib.ads 20180113120628 09bd3940 system.standard_library%s 94 | D s-stalib.adb 20180113120628 f2fe2716 system.standard_library%b 95 | D s-stoele.ads 20180113120628 2dc34a04 system.storage_elements%s 96 | D s-stoele.adb 20180113120628 ed88f8fb system.storage_elements%b 97 | D s-stopoo.ads 20180113120628 b16154c2 system.storage_pools%s 98 | D s-stposu.ads 20180113120628 97a6219c system.storage_pools.subpools%s 99 | D s-stratt.ads 20180113120628 aedef97e system.stream_attributes%s 100 | D s-traent.ads 20180113120628 005bf670 system.traceback_entries%s 101 | D s-unstyp.ads 20180113120628 34867c83 system.unsigned_types%s 102 | D s-wchcon.ads 20180113120628 1b7d22d2 system.wch_con%s 103 | D tree_traversal.adb 20180816114541 a45d028a tree_traversal%b 104 | X 1 ada.ads 105 | 16K9*Ada 20e8 45|1r6 1r23 2r6 3r6 14r29 63r29 106 | X 2 a-contai.ads 107 | 16K13*Containers 24e19 45|3r10 63r33 108 | X 3 a-cdlili.ads 109 | 46k24*Doubly_Linked_Lists 406e39 45|3w21 63r44 110 | 51R9 List<8|43R9> 45|65r20[63] 111 | 76V13 Is_Empty{boolean} 45|69s17[63] 112 | 148U14 Append 45|68s18[63] 74s24[63] 77s24[63] 113 | 158U14 Delete_First 45|71s10[63] 114 | 200V13 First_Element{45|7P9} 45|70s18[63] 115 | X 10 a-iteint.ads 116 | 24h9 Forward_Iterator 117 | 32h9 Reversible_Iterator<24R9[3|69]> 118 | X 13 a-textio.ads 119 | 49K13*Text_IO 471e16 45|1w10 1r27 120 | 166U14*New_Line 45|97s4 100s4 103s4 106s4 121 | 242U14*Put 45|34s7 47s7 60s7 72s10 95s4 98s4 101s4 104s4 122 | X 15 a-uncdea.ads 123 | 20u15*Unchecked_Deallocation 45|2w10 14r33 124 | X 18 system.ads 125 | 67M9*Address 126 | X 29 s-memory.ads 127 | 53V13*Alloc{18|67M9} 103i22 128 | 68U14*Free 104i22 129 | 76V13*Realloc{18|67M9} 105i22 130 | X 36 s-stalib.adb 131 | 93U14 Break_Start 94i22 132 | X 45 tree_traversal.adb 133 | 5U11*Tree_Traversal 5b11 108l5 108t19 134 | 6R9 Node 7r31 8c9 12e14 14r56 25r33 135 | 7P9 Node_Access(6R9) 9r14 10r15 13r38 14r62 24r42 24r63 24r83 25r14 32r27 136 | . 42r26 52r28 62r29 63r64 66r14 81r8 137 | 9p7 Left{7P9} 16r12 17m25 28m12 35r12 36r21 44r12 45r20 54r12 55r22 73r18 138 | . 74r36 139 | 10p7 Right{7P9} 19r12 20m25 29m12 38r12 39r21 48r12 49r20 57r12 58r22 76r18 140 | . 77r36 141 | 11i7 Data{integer} 27m12 34r27 47r27 60r27 72r33 142 | 13U14 Destroy_Tree 13b14 13=27 17s10 20s10 23l8 23t20 107s4 143 | 13p27 N{7P9} 16r10 17r23 19r10 20r23 22m12 144 | 14U17 free[15|20] 22s7 145 | 24V13 Tree{7P9} 24b13 24>18 24>35 24>55 31l8 31t12 83s9 84s7 85s10 86s13 146 | . 88s10 89s7 90s10 91s13 92s13 147 | 24i18 Value{integer} 27r20 148 | 24p35 Left{7P9} 28r20 149 | 24p55 Right{7P9} 29r21 150 | 25p7 Temp{7P9} 27r7 28r7 29r7 30r14 151 | 32U14 Preorder 32b14 32>23 36s10 39s10 41l8 41t16 96s4 152 | 32p23 N{7P9} 34r25 35r10 36r19 38r10 39r19 153 | 42U14 Inorder 42b14 42>22 45s10 49s10 51l8 51t15 99s4 154 | 42p22 N{7P9} 44r10 45r18 47r25 48r10 49r18 155 | 52U14 Postorder 52b14 52>24 55s10 58s10 61l8 61t17 102s4 156 | 52p24 N{7P9} 54r10 55r20 57r10 58r20 60r25 157 | 62U14 Levelorder 62b14 62>25 80l8 80t18 105s4 158 | 62p25 N{7P9} 68r25 159 | 63K15 Queues[3|46] 64r11 160 | 65r7 Node_Queue{3|51R9[63]} 68m7 68r7 69r26 70r32 71m23 71r23 74m13 74r13 161 | . 77m13 77r13 162 | 66p7 Next{7P9} 70m10 72r28 73r13 74r31 76r13 77r31 163 | 81p4 N{7P9} 83m4 96r13 99r12 102r14 105r15 107m17 107r17 164 | 165 | --------------------------------------------------------------------------------