LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: simple_static_search_tree::update_recursive(int, int, int, int, int)
void simple_static_search_tree::update_recursive(int tree_l, int arr_l, int arr_r, int index, int value) {
    if (arr_l == arr_r)
    {
        this->tree[tree_l] = value;
        return;
    }

    int mid = (arr_l + arr_r) / 2;
    int left_child = tree_l * 2;
    int right_child = tree_l * 2 + 1;
    if (index <= mid)
    {
        this->update_recursive(left_child, arr_l, mid, index, value);
    }
    else
    {
        this->update_recursive(right_child, mid + 1, arr_r, index, value);
    }

    this->tree[tree_l] = this->merge(this->tree[left_child], this->tree[right_child]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %ecx, %edx
jne 0x231b
movq (%r14), %rax
jmp 0x2366
leal (%rcx,%rdx), %esi
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
leal (%rbx,%rbx), %ebp
leal 0x1(,%rbx,2), %r15d
cmpl %r8d, %eax
jge 0x2343
incl %eax
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
jmp 0x234a
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %ecx
callq 0x2306
movq (%r14), %rax
movslq %ebp, %rcx
movl (%rax,%rcx,4), %ecx
movslq %r15d, %rdx
movl (%rax,%rdx,4), %r9d
cmpl %r9d, %ecx
cmovgl %ecx, %r9d
movslq %ebx, %rcx
movl %r9d, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: simple_static_search_tree::update_iterative(int, int, int, int, int)
void simple_static_search_tree::update_iterative(int tree_l, int arr_l, int arr_r, int index, int value) {
    while(arr_l != arr_r) {
        int mid = (arr_l + arr_r) >> 1;
        int left_child = tree_l << 1;
        int right_child = left_child + 1;
        if(index <= mid){
            tree_l = left_child;
            arr_r = mid;
        }
        else {
            tree_l = right_child;
            arr_l = mid + 1;
        }
    }
    this->tree[tree_l] = value;
    while(tree_l != 1) {
        tree_l /= 2;
        int left_child = tree_l << 1;
        int right_child = left_child + 1;
        this->tree[tree_l] = this->merge(this->tree[left_child], this->tree[right_child]);
    }
}

// Assembly:
cmpl %ecx, %edx
je 0x23a4
leal (%rdx,%rcx), %eax
sarl %eax
leal 0x1(%rax), %r10d
xorl %r11d, %r11d
cmpl %r8d, %eax
setl %r11b
cmovll %ecx, %eax
cmovgel %edx, %r10d
leal (%r11,%rsi,2), %esi
movl %r10d, %edx
movl %eax, %ecx
cmpl %eax, %r10d
jne 0x237c
movq (%rdi), %rax
movslq %esi, %rcx
movl %r9d, (%rax,%rcx,4)
cmpl $0x1, %ecx
je 0x23e4
movl %esi, %ecx
shrl $0x1f, %ecx
addl %esi, %ecx
movl %ecx, %edx
sarl %edx
andl $-0x2, %ecx
movslq %ecx, %rdi
incl %ecx
movl (%rax,%rdi,4), %edi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl %ecx, %edi
cmovgl %edi, %ecx
movslq %edx, %rdi
movl %ecx, (%rax,%rdi,4)
andl $-0x2, %esi
cmpl $0x2, %esi
movl %edx, %esi
jne 0x23b3
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: simple_static_search_tree::get_recursive(int, int, int, int)
int simple_static_search_tree::get_recursive(int tree_l, int arr_l, int arr_r, int value) {
    if (arr_l == arr_r)
    {
        return arr_l;
    }

    int mid = (arr_l + arr_r) / 2;
    int left_child = tree_l * 2;
    int right_child = tree_l * 2 + 1;

    if(value <= this->tree[left_child]) {
        return this->get_recursive(left_child, arr_l, mid, value);
    } else {
        return this->get_recursive(right_child, mid + 1, arr_r, value);
    }
}

// Assembly:
movl %edx, %eax
movq (%rdi), %rdx
movl %ecx, %edi
cmpl %edi, %eax
je 0x2416
movl %edi, %ecx
leal (%rcx,%rax), %r9d
movl %r9d, %edi
shrl $0x1f, %edi
addl %r9d, %edi
sarl %edi
addl %esi, %esi
movslq %esi, %r9
cmpl %r8d, (%rdx,%r9,4)
jge 0x23ed
orl $0x1, %esi
incl %edi
movl %edi, %eax
jmp 0x23eb
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: simple_static_search_tree::get_iterative(int, int, int, int)
int simple_static_search_tree::get_iterative(int tree_l, int arr_l, int arr_r, int value) {
    while(arr_l != arr_r) {
        int mid = (arr_l + arr_r) >> 1;
        int left_child = tree_l << 1;
        int right_child = left_child + 1;
        if(value <= this->tree[left_child]){
            tree_l = left_child;
            arr_r = mid;
        }
        else {
            tree_l = right_child;
            arr_l = mid + 1;
        }
    }
    return arr_l;
}

// Assembly:
cmpl %ecx, %edx
jne 0x241f
movl %edx, %eax
retq
movq (%rdi), %rdi
leal (%rdx,%rcx), %eax
sarl %eax
leal (%rsi,%rsi), %r9d
movslq %r9d, %r9
leal 0x1(%rax), %r10d
xorl %r11d, %r11d
cmpl %r8d, (%rdi,%r9,4)
setl %r11b
cmovll %ecx, %eax
cmovgel %edx, %r10d
leal (%r11,%rsi,2), %esi
movl %r10d, %edx
movl %eax, %ecx
cmpl %eax, %r10d
jne 0x2422
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: simple_static_search_tree::update(int, int)
void simple_static_search_tree:: update(int index, int value){
    if (this->recursive)
    {
        this->update_recursive(1, 0, this->length - 1, index, value);
    }
    else
    {
        this->update_iterative(1, 0, this->length - 1, index, value);
    }
}

// Assembly:
movl %edx, %r9d
movl %esi, %r8d
movl 0xc(%rdi), %ecx
decl %ecx
cmpb $0x1, 0x18(%rdi)
jne 0x2471
movl $0x1, %esi
xorl %edx, %edx
jmp 0x2306
movl $0x1, %esi
xorl %edx, %edx
jmp 0x2378
nop
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: simple_static_search_tree::get(int)
int simple_static_search_tree::get(int value) {
    if(this->recursive) {
        int result = this->get_recursive(1, 0, this->length - 1, value);
        return result;
    }
    else {
        int result = this->get_iterative(1, 0, this->length - 1, value);
        return result;
    }
}

// Assembly:
movl 0xc(%rdi), %ecx
decl %ecx
cmpb $0x1, 0x18(%rdi)
jne 0x24c5
movq (%rdi), %rdx
xorl %eax, %eax
movl $0x1, %edi
movl %ecx, %r8d
cmpl %r8d, %eax
je 0x2505
movl %r8d, %ecx
leal (%rcx,%rax), %r9d
movl %r9d, %r8d
shrl $0x1f, %r8d
addl %r9d, %r8d
sarl %r8d
addl %edi, %edi
movslq %edi, %r9
cmpl %esi, (%rdx,%r9,4)
jge 0x2496
orl $0x1, %edi
incl %r8d
movl %r8d, %eax
jmp 0x2493
testl %ecx, %ecx
je 0x2506
movq (%rdi), %rdx
xorl %r8d, %r8d
movl $0x1, %edi
leal (%rcx,%r8), %eax
sarl %eax
leal (%rdi,%rdi), %r9d
movslq %r9d, %r9
leal 0x1(%rax), %r10d
xorl %r11d, %r11d
cmpl %esi, (%rdx,%r9,4)
setl %r11b
cmovll %ecx, %eax
cmovgel %r8d, %r10d
leal (%r11,%rdi,2), %edi
movl %r10d, %r8d
movl %eax, %ecx
cmpl %eax, %r10d
jne 0x24d4
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_ca_sst.cpp
// Function: print_array(int*, int)
void print_array(int *a, int n) {
    printf("Array of length: %d\n", n);
    for (int i = 0; i < n; ++i){
        printf("%d ", a[i]);
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18ad(%rip), %rdi      # 0x4169
xorl %eax, %eax
callq 0x1040
testl %ebp, %ebp
jle 0x28ea
movl %ebp, %r15d
leaq 0x1893(%rip), %r14      # 0x4164
xorl %r12d, %r12d
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
incq %r12
cmpq %r12, %r15
jne 0x28d4
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1170
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_ca_sst.cpp
// Function: test_get_update_2()
void test_get_update_2() {
    // Test edge case with a tree of size 1.
    CA_static_search_tree tree(1);
    tree.update(0, 2);
    if (tree.get(2) != 0) {
        cout << "test_get_update_2 failed: expected 2 at index 0." << endl;
        return;
    }
    tree.update(0, 5);
    if (tree.get(5) != 0) {
        cout << "test_get_update_2 failed: expected 5 at index 0." << endl;
        return;
    }
    tree.update(0, 501);
    if (tree.get(501) != 0) {
        cout << "test_get_update_2 failed: expected 501 at index 0." << endl;
        return;
    }
    cout << "test_get_update_2: OK" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1f72
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x219e
movq %rsp, %rdi
movl $0x2, %esi
callq 0x21ce
movl $0x30, %ebx
testl %eax, %eax
je 0x2af1
leaq 0x1757(%rip), %rsi      # 0x4246
jmp 0x2b58
movq %rsp, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x219e
movq %rsp, %rdi
movl $0x5, %esi
callq 0x21ce
testl %eax, %eax
je 0x2b1a
leaq 0x175f(%rip), %rsi      # 0x4277
jmp 0x2b58
movq %rsp, %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x219e
movq %rsp, %rdi
movl $0x1f5, %esi            # imm = 0x1F5
callq 0x21ce
testl %eax, %eax
leaq 0x179c(%rip), %rax      # 0x42db
leaq 0x1762(%rip), %rsi      # 0x42a8
cmoveq %rax, %rsi
movl $0x15, %eax
movl $0x32, %ebx
cmoveq %rax, %rbx
movq 0x4479(%rip), %r14      # 0x6fd8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1130
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq 0x4450(%rip), %rdi      # 0x6fd8
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq %rsp, %rdi
callq 0x1fd8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1fd8
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_ca_sst.cpp
// Function: test_get_update_3()
void test_get_update_3() {
    // -- This is a bit of stress test
    // Test update all elements in order from element 0 to last element.
    // make value = key. Do multiple passes with random tree sizes.
    for (int i = 0; i < 100; i++) {
        // limit size to the range [0...10000]
        // no point in doing more.
        int t_size = 1 + rand() % 10000;
        CA_static_search_tree tree(t_size);
        for (int j = 0; j < t_size; j++) {
            tree.update(j, j);
        }
        for (int j = 0; j < t_size; j++) {
            if (tree.get(j) != j) {
                cout << "test_get_update_3 failed: expected value " << j << " at index " << j << ", tree size: " << t_size << endl;
                return;
            }
        }
    }
    cout << "test_get_update_3: OK" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r15d, %r15d
movq %rsp, %r14
callq 0x1060
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
movl %eax, %r13d
subl %ecx, %r13d
negl %ecx
leal (%rax,%rcx), %ebx
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1f72
testl %r13d, %r13d
js 0x2c3e
leal 0x1(%r13), %r12d
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x219e
incl %ebp
cmpl %ebp, %r12d
jne 0x2c0f
testl %r13d, %r13d
js 0x2c3e
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x21ce
cmpl %eax, %ebp
jne 0x2c9a
incl %ebp
cmpl %ebp, %r12d
jne 0x2c29
movq %r14, %rdi
callq 0x1fd8
incl %r15d
cmpl $0x64, %r15d
jne 0x2bcc
movq 0x437e(%rip), %rbx      # 0x6fd8
leaq 0x16d3(%rip), %rsi      # 0x4334
movl $0x15, %edx
movq %rbx, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
jmp 0x2d34
movq 0x4337(%rip), %rdi      # 0x6fd8
leaq 0x1649(%rip), %rsi      # 0x42f1
movl $0x29, %edx
callq 0x1130
movq 0x431f(%rip), %rdi      # 0x6fd8
movl %ebp, %esi
callq 0x11b0
movq %rax, %r14
leaq 0x1651(%rip), %rsi      # 0x431b
movl $0xa, %edx
movq %rax, %rdi
callq 0x1130
movq %r14, %rdi
movl %ebp, %esi
callq 0x11b0
movq %rax, %r14
leaq 0x163b(%rip), %rsi      # 0x4326
movl $0xd, %edx
movq %rax, %rdi
callq 0x1130
movq %r14, %rdi
movl %ebx, %esi
callq 0x11b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq %rsp, %rdi
callq 0x1fd8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d47
jmp 0x2d47
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1fd8
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_ca_sst.cpp
// Function: main
int main() {
    srand(10);
    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
    test_get_update_1();
    test_get_update_2();
    test_get_update_3();
    test_get_update_4();
    test_get_update_5();
    chrono::steady_clock::time_point end = chrono::steady_clock::now();
    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0xa, %edi
callq 0x10e0
callq 0x1150
movq %rax, %rbx
callq 0x28fc
callq 0x2aac
callq 0x2bb8
callq 0x2d5a
callq 0x2f2e
callq 0x1150
movq %rax, %r14
movq 0x3e26(%rip), %r15      # 0x6fd8
leaq 0x1211(%rip), %rsi      # 0x43ca
movl $0x12, %edx
movq %r15, %rdi
callq 0x1130
subq %rbx, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x10d0
movq %rax, %rbx
leaq 0x11e4(%rip), %rsi      # 0x43dd
movl $0x5, %edx
movq %rax, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: Genome::~Genome()
~Genome() {
        list<Tree*>::iterator curTree;
        list<TreeID*>::iterator curTreeID;

        delete [] myData;
        delete [] initialVal;

        for (curTree = trees.begin(); curTree != trees.end(); ++curTree)
            delete (*curTree);
        for (curTreeID = tree_id_lookup.begin(); curTreeID != tree_id_lookup.end(); ++curTreeID)
            delete (*curTreeID);

        trees.clear();
        tree_id_lookup.clear();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x584c
callq 0x2240
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x585d
callq 0x2240
movq (%rbx), %r15
cmpq %rbx, %r15
je 0x5888
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x5876
movq %r14, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r14, %rdi
callq 0x21f0
movq (%r15), %r15
jmp 0x5860
leaq 0x18(%rbx), %r14
movq 0x18(%rbx), %r15
cmpq %r14, %r15
je 0x58a8
movq 0x10(%r15), %rdi
movl $0x8, %esi
callq 0x21f0
movq (%r15), %r15
jmp 0x5890
movq %rbx, %rdi
callq 0x5b90
movq %r14, %rdi
callq 0x5bcc
movq 0x18(%rbx), %rdi
cmpq %r14, %rdi
je 0x58d6
movq (%rdi), %r15
movl $0x18, %esi
callq 0x21f0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x58c1
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x58f3
movq (%rdi), %r14
movl $0x18, %esi
callq 0x21f0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x58de
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: Population::~Population()
~Population() {
        list<Genome*>::iterator curGenome;
        for (curGenome = genomes.begin(); curGenome != genomes.end(); ++curGenome)
            delete (*curGenome);

        genomes.clear();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
cmpq %rdi, %r15
je 0x5afe
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x5ae9
movq %r14, %rdi
callq 0x5836
movl $0x90, %esi
movq %r14, %rdi
callq 0x21f0
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x5ad8
movq %rbx, %rdi
callq 0x57fa
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x5b23
movq (%rdi), %r14
movl $0x18, %esi
callq 0x21f0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x5b0e
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: Tree::~Tree()
~Tree() {
        delete tree_id;
        if (!isTerminal) {
            if (leftTree != NULL)
                delete leftTree;
            if (rightTree != NULL)
                delete rightTree;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl $0x8, %esi
callq 0x21f0
cmpl $0x0, 0x18(%rbx)
je 0x5b4d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %r14
testq %r14, %r14
je 0x5b6a
movq %r14, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r14, %rdi
callq 0x21f0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x5b45
movq %rbx, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: Tree::Tree(Tree*)
Tree (Tree *copyMe) {
        leftTree = NULL;
        rightTree = NULL;
        if (copyMe->leftTree != NULL)
            leftTree = new Tree(copyMe->leftTree);
        if (copyMe->rightTree != NULL)
            rightTree = new Tree(copyMe->rightTree);

        isTerminal = copyMe->isTerminal;
        isConstant = copyMe->isConstant;
        myVal = copyMe->myVal;
        myDepth = copyMe->myDepth;
        numConstants = copyMe->numConstants;
        numTerminals = copyMe->numTerminals;
        numNodes = copyMe->numNodes;
        tree_id = new TreeID(copyMe->tree_id);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r12
testq %r12, %r12
je 0x5c3f
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x5c08
movq %r15, (%rbx)
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x5c64
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x5c08
movq %r15, 0x8(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movsd 0x20(%r14), %xmm0
movsd %xmm0, 0x20(%rbx)
movups 0x28(%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x8, %edi
callq 0x21e0
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5ca6
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Genome::evalEMM(double*)
void Genome::evalEMM(double currentData[]) {
    int i;
    list<Tree*>::iterator curTree;

    curTree = this->trees.begin();
    for (i = 0; i < this->num_trees; i++) {
        // Evaluate an equation tree in the EMM
        this->myData[i] = (*curTree)->evalEquation(currentData, this->num_trees);

        if (this->myData[i] > DBL_MAX) {
            this->myData[i] = DBL_MAX;
        } else if (this->myData[i] < -DBL_MAX) {
            this->myData[i] = -DBL_MAX;
        }

        ++curTree;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x34(%rdi), %r15
testq %r15, %r15
jle 0x65d5
movq %rsi, %rbx
movq %rdi, %r14
movq 0x78(%rdi), %r12
xorl %r13d, %r13d
movq (%r14), %r14
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x65e0
movsd %xmm0, (%r12,%r13,8)
movsd 0x4bad(%rip), %xmm1     # 0xb160
ucomisd %xmm1, %xmm0
ja 0x65c7
movsd 0x4b97(%rip), %xmm1     # 0xb158
ucomisd %xmm0, %xmm1
jbe 0x65cd
movsd %xmm1, (%r12,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0x6593
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::evalEquation(double*, int)
double Tree::evalEquation(double currentData[], int current_num_trees) {
    double myResult = 0.0;

    if (this->isTerminal) {
        if (this->isConstant) {
            myResult = this->myVal;
        } else {
            myResult = currentData[(int)this->myVal];
        }
    } else {
        switch ((int)this->myVal) {
            case ADD: {
                myResult = this->leftTree->evalEquation(currentData, current_num_trees) + this->rightTree->evalEquation(currentData, current_num_trees);
                break;
            }
            case SUBTRACT: {
                myResult = this->leftTree->evalEquation(currentData, current_num_trees) - this->rightTree->evalEquation(currentData, current_num_trees);
                break;
            }
            case MULTIPLY: {
                myResult = this->leftTree->evalEquation(currentData, current_num_trees) * this->rightTree->evalEquation(currentData, current_num_trees);
                break;
            }
            case DIVIDE: {
                myResult = this->leftTree->evalEquation(currentData, current_num_trees) / this->rightTree->evalEquation(currentData, current_num_trees);
                break;
            }
        }
    }

    return myResult;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x18(%rdi)
je 0x6615
cmpl $0x0, 0x1c(%r14)
movsd 0x20(%r14), %xmm0
jne 0x66ed
cvttsd2si %xmm0, %eax
cltq
movsd (%rbx,%rax,8), %xmm0
jmp 0x66ed
cvttsd2si 0x20(%r14), %eax
cmpl $0x3, %eax
ja 0x66e9
movl %edx, %ebp
leaq 0x4ce7(%rip), %rcx      # 0xb314
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
addsd 0x8(%rsp), %xmm0
jmp 0x66ed
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
mulsd 0x8(%rsp), %xmm0
jmp 0x66ed
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
jmp 0x66e3
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65e0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x66ed
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::isEqual(Tree*)
bool Tree::isEqual(Tree *compareTree) {
    bool treesAreEqual = false;

    if ((!this->isTerminal) && (!compareTree->isTerminal)) {
        if (this->myVal == compareTree->myVal) {
            if ((this->leftTree->isEqual(compareTree->leftTree)) && (this->rightTree->isEqual(compareTree->rightTree))) {
                treesAreEqual = true;
            }
        }
    } else if ((this->isTerminal) && (compareTree->isTerminal)) {
        if (this->isConstant == compareTree->isConstant) {
            if (this->myVal == compareTree->myVal) {
                treesAreEqual = true;
            }
        }
    }

    return treesAreEqual;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x18(%rdi)
je 0x69cd
cmpl $0x0, 0x18(%rbx)
je 0x69d3
movl 0x1c(%r14), %eax
cmpl 0x1c(%rbx), %eax
jne 0x69d3
movsd 0x20(%r14), %xmm0
ucomisd 0x20(%rbx), %xmm0
jne 0x69d3
jp 0x69d3
movb $0x1, %al
jmp 0x69d5
movsd 0x20(%r14), %xmm0
ucomisd 0x20(%rbx), %xmm0
jne 0x69d3
jp 0x69d3
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x696e
testb %al, %al
je 0x69d3
movq 0x8(%r14), %r14
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x18(%r14)
jne 0x697e
cmpl $0x0, 0x18(%rbx)
je 0x69a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::loadTree(_IO_FILE*, int, int)
void Tree::loadTree(FILE *myFile, int islID, int myID) {
    int myInt, myInt2, myInt3, myInt4, myInt5, myInt6;
    double myDouble;

    this->tree_id = new TreeID(islID, myID);

    fscanf(myFile, "%d,%d,%d,%lf,%d,%d,%d\n", &myInt, &myInt2, &myInt3, &myDouble, &myInt4, &myInt5, &myInt6);

    if (myInt == 0)
        this->isConstant = false;
    else
        this->isConstant = true;

    if (myInt2 == 0)
        this->isTerminal = false;
    else
        this->isTerminal = true;

    this->myDepth = myInt3;

    this->myVal = myDouble;

    this->numConstants = myInt4;
    this->numNodes = myInt5;
    this->numTerminals = myInt6;

    if (!this->isTerminal) {
        this->leftTree = new Tree();
        this->leftTree->loadTree(myFile, islID, myID);
        this->rightTree = new Tree();
        this->rightTree->loadTree(myFile, islID, myID);
    } else {
        this->leftTree = NULL;
        this->rightTree = NULL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r15
movl $0x8, %edi
callq 0x21e0
movl %ebp, 0x8(%rsp)
movl %ebp, (%rax)
movl %ebx, 0xc(%rsp)
movl %ebx, 0x4(%rax)
movq %rax, 0x10(%r15)
subq $0x8, %rsp
leaq 0x18(%rsp), %r10
leaq 0x1c(%rsp), %r11
leaq 0x28(%rsp), %r14
leaq 0x3cfd(%rip), %rsi      # 0xb51e
leaq 0x34(%rsp), %r12
leaq 0x30(%rsp), %rbp
leaq 0x2c(%rsp), %rbx
leaq 0x38(%rsp), %r9
movq %r13, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rdx
movq %rbp, %rcx
movq %rbx, %r8
movq %r9, %r13
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %r14
callq 0x2330
addq $0x20, %rsp
xorl %eax, %eax
cmpl $0x0, (%r12)
setne %al
movl %eax, 0x1c(%r15)
xorl %eax, %eax
cmpl $0x0, (%rbp)
setne %al
movl %eax, 0x18(%r15)
movl (%rbx), %eax
movl %eax, 0x28(%r15)
movsd (%r13), %xmm0
movsd %xmm0, 0x20(%r15)
movl (%r14), %eax
movl %eax, 0x2c(%r15)
leaq 0x14(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x34(%r15)
leaq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x30(%r15)
je 0x78af
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0x78f5
movl $0x38, %edi
callq 0x21e0
movq %rax, (%r15)
movq %rax, %rdi
movq 0x18(%rsp), %r14
movq %r14, %rsi
movl 0x8(%rsp), %ebp
movl %ebp, %edx
movl 0xc(%rsp), %ebx
movl %ebx, %ecx
callq 0x77d4
movl $0x38, %edi
callq 0x21e0
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x77d4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::recountNodes(int)
void Tree::recountNodes(int curDepth) {
    this->myDepth = curDepth;
    curDepth++;
    this->numNodes = 1;
    this->numConstants = 0;
    this->numTerminals = 0;
    if (!this->isTerminal) {
        this->leftTree->recountNodes(curDepth);
        this->numNodes += this->leftTree->numNodes;
        this->numConstants += this->leftTree->numConstants;
        this->numTerminals += this->leftTree->numTerminals;
        if (this->rightTree != NULL) {
            this->rightTree->recountNodes(curDepth);
            this->numNodes += this->rightTree->numNodes;
            this->numConstants += this->rightTree->numConstants;
            this->numTerminals += this->rightTree->numTerminals;
        }
    } else {
        this->numTerminals = 1;
        if (this->isConstant) {
            this->numConstants = 1;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x28(%rdi)
movl $0x1, 0x34(%rdi)
movq $0x0, 0x2c(%rdi)
cmpl $0x0, 0x18(%rdi)
je 0x7938
movl $0x1, 0x30(%rbx)
cmpl $0x0, 0x1c(%rbx)
je 0x798f
movl $0x1, 0x2c(%rbx)
jmp 0x798f
movl %esi, %ebp
incl %ebp
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7904
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movl 0x34(%rax), %ecx
addl %ecx, 0x34(%rbx)
movq 0x2c(%rax), %xmm0
movq 0x2c(%rbx), %xmm1
paddd %xmm0, %xmm1
movq %xmm1, 0x2c(%rbx)
testq %rdi, %rdi
je 0x798f
movl %ebp, %esi
callq 0x7904
movq 0x8(%rbx), %rax
movl 0x34(%rax), %ecx
addl %ecx, 0x34(%rbx)
movq 0x2c(%rax), %xmm0
movq 0x2c(%rbx), %xmm1
paddd %xmm0, %xmm1
movq %xmm1, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::getNonTerminalTree(int&)
Tree* Tree::getNonTerminalTree(int &i) {
    if (i == 0) {
        return this;
    } else {
        Tree *myTree;
        myTree = NULL;
        if (!this->leftTree->isTerminal) {
            i--;
            myTree = this->leftTree->getNonTerminalTree(i);
        }
        if (myTree != NULL) {
            return myTree;
        } else {
            if (!this->rightTree->isTerminal) {
                i--;
                myTree = this->rightTree->getNonTerminalTree(i);
                if (myTree != NULL) {
                    return myTree;
                }
            }
        }
        
        return NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x79e4
movq %rsi, %r14
movq (%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x79bd
movq 0x8(%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x79d1
xorl %ebx, %ebx
jmp 0x79e4
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x7996
testq %rax, %rax
jne 0x79e1
jmp 0x79af
decl (%r14)
movq %r14, %rsi
callq 0x7996
testq %rax, %rax
je 0x79b9
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::xOverNonTerminalTree(int&, Tree*)
bool Tree::xOverNonTerminalTree(int &i, Tree *xOverTree) {
    if (i == 0) {
        return true;
    } else {
        bool isMyPointer = false;
        if (!this->leftTree->isTerminal) {
            i--;
            isMyPointer = this->leftTree->xOverNonTerminalTree(i, xOverTree);
        }
        if (isMyPointer) {
            delete this->leftTree;
            this->leftTree = new Tree(xOverTree);
        } else if (this->rightTree != NULL) {
            if (!this->rightTree->isTerminal) {
                i--;
                if (this->rightTree->xOverNonTerminalTree(i, xOverTree)) {
                    delete this->rightTree;
                    this->rightTree = new Tree(xOverTree);
                }
            }
        }
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rsi), %r12d
testl %r12d, %r12d
je 0x7ac2
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x18(%rdi)
jne 0x7a67
leal -0x1(%r12), %eax
movl %eax, (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x79f0
testb %al, %al
je 0x7a67
movq (%rbx), %r15
testq %r15, %r15
je 0x7a3d
movq %r15, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c08
movq %r15, (%rbx)
jmp 0x7ac2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7ac2
cmpl $0x0, 0x18(%rdi)
jne 0x7ac2
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x79f0
testb %al, %al
je 0x7ac2
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x7a99
movq %r15, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c08
movq %r15, 0x8(%rbx)
testl %r12d, %r12d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7ad6
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::getTerminalTree(int&)
Tree* Tree::getTerminalTree(int &i) {
    if ((this->isTerminal) && (i == -1)) {
        return this;
    } else if (!this->isTerminal) {
        Tree *myTree;
        myTree = NULL;
        if (this->leftTree->isTerminal) {
            i--;
        }
        myTree = this->leftTree->getTerminalTree(i);

        if (myTree != NULL) {
            return myTree;
        } else {
            if (this->rightTree->isTerminal) {
                i--;
            }
            myTree =  this->rightTree->getTerminalTree(i);
            if (myTree != NULL) {
                return myTree;
            }
        }
    }
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
setne %dl
movl (%rsi), %eax
cmpl $-0x1, %eax
sete %sil
testb %sil, %dl
jne 0x7b64
testl %ecx, %ecx
jne 0x7b5d
movq (%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x7b20
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x7aee
testq %rax, %rax
jne 0x7b61
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x18(%rbx)
movl (%r14), %eax
je 0x7b44
decl %eax
movl %eax, (%r14)
movl 0x18(%rbx), %ecx
jmp 0x7b46
xorl %ecx, %ecx
testl %ecx, %ecx
setne %dl
cmpl $-0x1, %eax
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x7b0e
jmp 0x7b64
xorl %ebx, %ebx
jmp 0x7b64
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::xOverTerminalTree(int&, Tree*)
bool Tree::xOverTerminalTree(int &i, Tree *xOverTree) {
    if ((this->isTerminal) && (i == -1)) {
        return true;
    } else if (!this->isTerminal) {
        bool isMyPointer = false;
        if (this->leftTree->isTerminal) {
            i--;
        }
        isMyPointer = this->leftTree->xOverTerminalTree(i, xOverTree);

        if (isMyPointer) {
            delete this->leftTree;
            this->leftTree = new Tree(xOverTree);
        } else if (this->rightTree != NULL) {
            if (this->rightTree->isTerminal) {
                i--;
            }
            isMyPointer = this->rightTree->xOverTerminalTree(i, xOverTree);
            if (isMyPointer) {
                delete this->rightTree;
                this->rightTree = new Tree(xOverTree);
            }
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x18(%rdi), %ebp
movl (%rsi), %r12d
testl %ebp, %ebp
jne 0x7c44
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x7ba0
leal -0x1(%r12), %eax
movl %eax, (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x7b70
testb %al, %al
je 0x7be9
movq (%rbx), %r15
testq %r15, %r15
je 0x7bbf
movq %r15, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c08
movq %r15, (%rbx)
jmp 0x7c44
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7c44
cmpl $0x0, 0x18(%rdi)
je 0x7bfb
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x7b70
testb %al, %al
je 0x7c44
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x7c1b
movq %r15, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c08
movq %r15, 0x8(%rbx)
testl %ebp, %ebp
setne %cl
cmpl $-0x1, %r12d
sete %al
andb %cl, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7c5d
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::getConstantTree(int&)
Tree* Tree::getConstantTree(int &i) {
    if ((this->isConstant) && (i == -1)) {
        return this;
    } else if (!this->isTerminal) {
        Tree *myTree;
        myTree = NULL;
        if (this->leftTree->isConstant) {
            i--;
        }
        myTree = this->leftTree->getConstantTree(i);
        if (myTree != NULL) {
            return myTree;
        } else {
            if (this->rightTree->isConstant) {
                i--;
            }
            myTree = this->rightTree->getConstantTree(i);
            if (myTree != NULL) {
                return myTree;
            }
        }
    }
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x1c(%rdi)
setne %cl
movl (%rsi), %eax
cmpl $-0x1, %eax
sete %dl
testb %dl, %cl
jne 0x7ce7
movq %rsi, %r14
cmpl $0x0, 0x18(%rbx)
jne 0x7ce0
movq (%rbx), %rdi
cmpl $0x0, 0x1c(%rdi)
je 0x7ca7
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x7c76
testq %rax, %rax
jne 0x7ce4
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x1c(%rbx)
movl (%r14), %eax
je 0x7ccf
decl %eax
movl %eax, (%r14)
cmpl $0x0, 0x1c(%rbx)
setne %cl
jmp 0x7cd1
xorl %ecx, %ecx
cmpl $-0x1, %eax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x7c93
jmp 0x7ce7
xorl %ebx, %ebx
jmp 0x7ce7
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::getSubTree(int&)
Tree* Tree::getSubTree(int &i) {
    if (i == 0) {
        return this;
    } else if (!this->isTerminal) {
        Tree *myTree = NULL;
        i--;
        myTree = this->leftTree->getSubTree(i);
        if (myTree != NULL) {
            return myTree;
        } else {
            i--;
            myTree = this->rightTree->getSubTree(i);
            if (myTree != NULL) {
                return myTree;
            }
        }
    }
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x7d34
movq %rsi, %r14
cmpl $0x0, 0x18(%rbx)
jne 0x7d2d
decl %eax
movl %eax, (%r14)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x7cf2
testq %rax, %rax
jne 0x7d31
movl (%r14), %eax
decl %eax
movl %eax, (%r14)
movq 0x8(%rbx), %rbx
jne 0x7d02
jmp 0x7d34
xorl %ebx, %ebx
jmp 0x7d34
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::xOverSubTree(int&, Tree*)
bool Tree::xOverSubTree(int &i, Tree *xOverTree) {
    if (i == 0) {
        return true;
    } else if (!this->isTerminal) {
        bool isMyPointer = false;
        i--;
        isMyPointer = this->leftTree->xOverSubTree(i, xOverTree);
        if (isMyPointer) {
            delete this->leftTree;
            this->leftTree = new Tree(xOverTree);
        } else if (this->rightTree != NULL) {
            i--;
            if (this->rightTree->xOverSubTree(i, xOverTree)) {
                delete this->rightTree;
                this->rightTree = new Tree(xOverTree);
            }
        }
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rsi), %r12d
testl %r12d, %r12d
je 0x7e09
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jne 0x7e09
movq %rdx, %r14
movq %rsi, %r15
leal -0x1(%r12), %eax
movl %eax, (%rsi)
movq (%rbx), %rdi
callq 0x7d40
testb %al, %al
je 0x7db4
movq (%rbx), %r15
testq %r15, %r15
je 0x7d8a
movq %r15, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c08
movq %r15, (%rbx)
jmp 0x7e09
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7e09
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x7d40
testb %al, %al
je 0x7e09
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x7de0
movq %r15, %rdi
callq 0x5b2a
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c08
movq %r15, 0x8(%rbx)
testl %r12d, %r12d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7e1d
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::refCheck(std::__cxx11::list<int, std::allocator<int>>&, int, TreeID*, int&, bool*)
void Tree::refCheck(list<int> &treeList, int treeNum, TreeID* treeNumID, int &myCounter, bool isChecked[]) {
    int refTreeId;
    if ((this->isTerminal) && (!this->isConstant)) {
        refTreeId = this->myVal - NUM_INPUTS;
        if (refTreeId >= 0) { // terminal is not an input variable
            if (!isChecked[refTreeId]) {
                treeList.push_back(refTreeId);
            }
            if ((refTreeId == treeNum) && (!this->tree_id->isEqual(treeNumID))) {
                myCounter++;
            }
        }
    } else if (!this->isTerminal) {
        this->leftTree->refCheck(treeList, treeNum, treeNumID, myCounter, isChecked);
        this->rightTree->refCheck(treeList, treeNum, treeNumID, myCounter, isChecked);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x7fea
cmpl $0x0, 0x1c(%r15)
je 0x800e
testl %eax, %eax
jne 0x806c
movq (%r15), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x7fc0
movq 0x8(%r15), %r15
movl 0x18(%r15), %eax
jmp 0x7fdf
movsd 0x20(%r15), %xmm0
addsd 0x332c(%rip), %xmm0     # 0xb348
cvttsd2si %xmm0, %ecx
testl %ecx, %ecx
js 0x806c
movl %ecx, %eax
cmpb $0x0, (%r13,%rax)
jne 0x8052
movl $0x18, %edi
movl %ecx, %r13d
callq 0x21e0
movl %r13d, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x2060
movl %r13d, %ecx
incq 0x10(%r12)
cmpl %ebp, %ecx
jne 0x806c
movq 0x10(%r15), %rax
movl 0x4(%rax), %ecx
cmpl 0x4(%r14), %ecx
jne 0x806a
movl (%rax), %eax
cmpl (%r14), %eax
je 0x806c
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::swapRefs(std::__cxx11::list<int, std::allocator<int>> const&, std::__cxx11::list<int, std::allocator<int>> const&)
void Tree::swapRefs(const list<int> &oldIDs, const list<int> &newIDs) {
    int refTreeId;
    list<int>::const_iterator oldIterator, newIterator;
    if ((this->isTerminal) && (!this->isConstant)) { // this node is an internal variable
        refTreeId = this->myVal - (double)NUM_INPUTS; // get this tree's number
        newIterator = newIDs.begin();
        for (oldIterator = oldIDs.begin(); oldIterator != oldIDs.end(); ++oldIterator) {
            if (refTreeId == (*oldIterator)) { // if this node's internal variable is in the oldIDs list...
                this->myVal = (double)((*newIterator) + NUM_INPUTS); // ...change it to the new value 
                break;
            }
            ++newIterator;
        }
    } else if (!this->isTerminal) {
        this->leftTree->swapRefs(oldIDs, newIDs);
        this->rightTree->swapRefs(oldIDs, newIDs);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x80e9
cmpl $0x0, 0x1c(%rbx)
je 0x8104
testl %eax, %eax
jne 0x813b
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x80ce
movq 0x8(%rbx), %rbx
movl 0x18(%rbx), %eax
jmp 0x80df
movsd 0x20(%rbx), %xmm0
addsd 0x3237(%rip), %xmm0     # 0xb348
cvttsd2si %xmm0, %eax
movq %r15, %rcx
movq (%rcx), %rcx
cmpq %r15, %rcx
je 0x813b
movq (%r14), %r14
cmpl %eax, 0x10(%rcx)
jne 0x8118
movl 0x10(%r14), %eax
addl $0x3, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::updateID(int, int)
void Tree::updateID(int newIslandID, int newID) {
    this->tree_id->islandID = newIslandID;
    this->tree_id->myID = newID;
    if (!this->isTerminal) {
        this->leftTree->updateID(newIslandID, newID);
        this->rightTree->updateID(newIslandID, newID);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
cmpl $0x0, 0x18(%rdi)
jne 0x817c
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x8142
movq 0x8(%r14), %r14
movq 0x10(%r14), %rax
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
cmpl $0x0, 0x18(%r14)
je 0x815c
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Genome::countTotalNumNodes()
int Genome::countTotalNumNodes() {
    int numNodes = 0;
    list<Tree*>::iterator curTree;
    for (curTree = this->trees.begin(); curTree != this->trees.end(); ++curTree) {
        numNodes += (*curTree)->numNodes;
    }
    return numNodes;
}

// Assembly:
movq (%rdi), %rcx
xorl %eax, %eax
cmpq %rdi, %rcx
je 0xa416
movq 0x10(%rcx), %rdx
movq (%rcx), %rsi
addl 0x34(%rdx), %eax
movq %rsi, %rcx
cmpq %rdi, %rsi
jne 0xa404
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Genome::generateRandomPosition()
void Genome::generateRandomPosition() {
    double r = START_RADIUS * sqrt(randfloat());
    double theta = 2.0 * M_PI * randfloat();
    this->myPosition[0] = r * cos(theta);
    this->myPosition[1] = r * sin(theta);

    this->mainGridLocation[0] = (int)((this->myPosition[0] + ((double)ISLAND_SIZE / 2.0)) / NN_BLOCK_SIZE);
    this->mainGridLocation[1] = (int)((this->myPosition[1] + ((double)ISLAND_SIZE / 2.0)) / NN_BLOCK_SIZE);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2080
cvtsi2sd %eax, %xmm0
mulsd 0x89f(%rip), %xmm0      # 0xb130
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xa8a1
sqrtsd %xmm0, %xmm0
jmp 0xa8a6
callq 0x2140
mulsd 0xaea(%rip), %xmm0      # 0xb398
movsd %xmm0, (%rsp)
callq 0x2080
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x869(%rip), %xmm0      # 0xb130
mulsd 0x8a1(%rip), %xmm0      # 0xb170
movsd %xmm0, 0x8(%rsp)
callq 0x2340
mulsd (%rsp), %xmm0
movsd %xmm0, 0x68(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x2070
mulsd (%rsp), %xmm0
movsd %xmm0, 0x70(%rbx)
movupd 0x68(%rbx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x7b6(%rip), %xmm1      # 0xb0c0
mulpd 0x7be(%rip), %xmm1      # 0xb0d0
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Genome::initializeGenome()
void Genome::initializeGenome() {
    int i;
    for (i = 0; i < this->num_trees; i++) {
        this->myData[i] = this->initialVal[i];
    }
    this->currentComm = 0.0;
}

// Assembly:
movslq 0x34(%rdi), %rax
testq %rax, %rax
jle 0xa94a
movq 0x78(%rdi), %rcx
movq 0x80(%rdi), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0xa938
movq $0x0, 0x60(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Genome::removeFromGrid(std::__cxx11::list<gridEntry*, std::allocator<gridEntry*>>*)
void Genome::removeFromGrid(list<gridEntry*> *fullGrid) {
    list<gridEntry*>::iterator curGridEntry;
    for (curGridEntry = fullGrid[(this->mainGridLocation[1]*(int)(ISLAND_SIZE/NN_BLOCK_SIZE) + this->mainGridLocation[0])].begin(); curGridEntry != fullGrid[(this->mainGridLocation[1]*(int)(ISLAND_SIZE/NN_BLOCK_SIZE) + this->mainGridLocation[0])].end(); ++curGridEntry) {
        if ((*curGridEntry)->myGenome == this) {
            delete (*curGridEntry);
            fullGrid[(this->mainGridLocation[1]*(int)(ISLAND_SIZE/NN_BLOCK_SIZE) + this->mainGridLocation[0])].erase(curGridEntry);
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movslq 0x4c(%rdi), %rax
leaq (%rax,%rax,4), %rax
shlq $0x5, %rax
movslq 0x48(%rdi), %rcx
addq %rax, %rcx
leaq (%rcx,%rcx,2), %rax
leaq (%rsi,%rax,8), %rax
movq %rax, %r14
movq (%r14), %r14
cmpq %rax, %r14
je 0xaa28
movq 0x10(%r14), %rdi
cmpq %r15, (%rdi)
jne 0xa9d7
movl $0x10, %esi
callq 0x21f0
movslq 0x4c(%r15), %rax
leaq (%rax,%rax,4), %rax
shlq $0x5, %rax
movslq 0x48(%r15), %rcx
addq %rax, %rcx
leaq (%rcx,%rcx,2), %rax
decq 0x10(%rbx,%rax,8)
movq %r14, %rdi
callq 0x22d0
movl $0x18, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21f0
popq %rbx
popq %r14
popq %r15
retq