LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24c5
movl $0x1, %esi
xorl %edx, %edx
jmp 0x235c
movl $0x1, %esi
xorl %edx, %edx
jmp 0x23ce
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %esi, %r8d
movl 0xc(%rdi), %ecx
decl %ecx
cmpb $0x1, 0x18(%rdi)
jne 0x24ec
movl $0x1, %esi
xorl %edx, %edx
jmp 0x243c
testl %ecx, %ecx
je 0x252c
movq (%rdi), %rdx
xorl %edi, %edi
movl $0x1, %esi
leal (%rcx,%rdi), %r9d
sarl %r9d
leal (%rsi,%rsi), %eax
movslq %eax, %r10
leal 0x1(%r9), %eax
xorl %r11d, %r11d
cmpl %r8d, (%rdx,%r10,4)
setl %r11b
cmovll %ecx, %r9d
cmovgel %edi, %eax
leal (%r11,%rsi,2), %esi
movl %eax, %edi
movl %r9d, %ecx
cmpl %r9d, %eax
jne 0x24fa
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x182d(%rip), %rdi      # 0x4169
xorl %eax, %eax
callq 0x1040
testl %ebp, %ebp
jle 0x296a
movl %ebp, %r15d
leaq 0x1813(%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 0x2954
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fda
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2204
movq %rsp, %rdi
movl $0x2, %esi
callq 0x2234
movl $0x30, %ebx
testl %eax, %eax
je 0x2b71
leaq 0x16d7(%rip), %rsi      # 0x4246
jmp 0x2bd8
movq %rsp, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x2204
movq %rsp, %rdi
movl $0x5, %esi
callq 0x2234
testl %eax, %eax
je 0x2b9a
leaq 0x16df(%rip), %rsi      # 0x4277
jmp 0x2bd8
movq %rsp, %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x2204
movq %rsp, %rdi
movl $0x1f5, %esi            # imm = 0x1F5
callq 0x2234
testl %eax, %eax
leaq 0x171c(%rip), %rax      # 0x42db
leaq 0x16e2(%rip), %rsi      # 0x42a8
cmoveq %rax, %rsi
movl $0x15, %eax
movl $0x32, %ebx
cmoveq %rax, %rbx
movq 0x43f9(%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 0x43d0(%rip), %rdi      # 0x6fd8
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq %rsp, %rdi
callq 0x2040
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x297c
callq 0x2b2c
callq 0x2c38
callq 0x2e1e
callq 0x3037
callq 0x1150
movq %rax, %r14
movq 0x3d10(%rip), %r15      # 0x6fd8
leaq 0x10fb(%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 0x10ce(%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_O1/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 0x5818
callq 0x2240
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x5829
callq 0x2240
movq (%rbx), %r15
cmpq %rbx, %r15
je 0x5854
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x584f
movq %r14, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r14, %rdi
callq 0x21f0
movq (%r15), %r15
jmp 0x582c
leaq 0x18(%rbx), %r14
movq 0x18(%rbx), %r15
cmpq %r14, %r15
je 0x5879
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x5874
movl $0x8, %esi
callq 0x21f0
movq (%r15), %r15
jmp 0x585c
movq %rbx, %rdi
callq 0x5b68
movq %r14, %rdi
callq 0x5ba4
movq 0x18(%rbx), %rdi
cmpq %r14, %rdi
je 0x58a7
movq (%rdi), %r15
movl $0x18, %esi
callq 0x21f0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x5892
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x58c4
movq (%rdi), %r14
movl $0x18, %esi
callq 0x21f0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x58af
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ad2
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x5aca
movq %r14, %rdi
callq 0x5802
movl $0x90, %esi
movq %r14, %rdi
callq 0x21f0
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x5aac
movq %rbx, %rdi
callq 0x57c6
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x5af7
movq (%rdi), %r14
movl $0x18, %esi
callq 0x21f0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x5ae2
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
je 0x5b18
movl $0x8, %esi
callq 0x21f0
cmpl $0x0, 0x18(%rbx)
je 0x5b26
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %r14
testq %r14, %r14
je 0x5b43
movq %r14, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r14, %rdi
callq 0x21f0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x5b1e
movq %rbx, %rdi
callq 0x5afe
movl $0x38, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c17
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x5be0
movq %r15, (%rbx)
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x5c3c
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x5be0
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 0x5c7e
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65a7
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 0x65b2
movsd %xmm0, (%r12,%r13,8)
movsd 0x4bcb(%rip), %xmm1     # 0xb150
ucomisd %xmm1, %xmm0
ja 0x6599
movsd 0x4bb5(%rip), %xmm1     # 0xb148
ucomisd %xmm0, %xmm1
jbe 0x659f
movsd %xmm1, (%r12,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0x6565
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65e7
cmpl $0x0, 0x1c(%r14)
movsd 0x20(%r14), %xmm0
jne 0x66bf
cvttsd2si %xmm0, %eax
cltq
movsd (%rbx,%rax,8), %xmm0
jmp 0x66bf
cvttsd2si 0x20(%r14), %eax
cmpl $0x3, %eax
ja 0x66bb
movl %edx, %ebp
leaq 0x4d05(%rip), %rcx      # 0xb304
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
addsd 0x8(%rsp), %xmm0
jmp 0x66bf
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
mulsd 0x8(%rsp), %xmm0
jmp 0x66bf
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
jmp 0x66b5
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65b2
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x66bf
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x18(%r14), %eax
testl %eax, %eax
jne 0x699c
cmpl $0x0, 0x18(%rbx)
jne 0x6998
movsd 0x20(%r14), %xmm0
ucomisd 0x20(%rbx), %xmm0
jne 0x69be
jp 0x69be
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x6958
testb %al, %al
je 0x69be
movq 0x8(%r14), %r14
movq 0x8(%rbx), %rbx
jmp 0x6962
testl %eax, %eax
je 0x69be
cmpl $0x0, 0x18(%rbx)
je 0x69be
movl 0x1c(%r14), %eax
cmpl 0x1c(%rbx), %eax
jne 0x69be
movsd 0x20(%r14), %xmm0
ucomisd 0x20(%rbx), %xmm0
jne 0x69be
jp 0x69be
movb $0x1, %al
jmp 0x69c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d0b(%rip), %rsi      # 0xb50e
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 0x7891
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0x78d7
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 0x77b6
movl $0x38, %edi
callq 0x21e0
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x77b6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x791a
movl $0x1, 0x30(%rbx)
cmpl $0x0, 0x1c(%rbx)
je 0x7971
movl $0x1, 0x2c(%rbx)
jmp 0x7971
movl %esi, %ebp
incl %ebp
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x78e6
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 0x7971
movl %ebp, %esi
callq 0x78e6
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_O1/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, %r14
movl (%rsi), %eax
testl %eax, %eax
je 0x7995
movq %rsi, %rbx
movq (%r14), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x799a
xorl %eax, %eax
jmp 0x79a6
movq %r14, %rax
jmp 0x79c8
decl %eax
movl %eax, (%rbx)
movq %rbx, %rsi
callq 0x7978
testq %rax, %rax
jne 0x79c8
movq 0x8(%r14), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x79b9
xorl %eax, %eax
jmp 0x79c8
decl (%rbx)
movq %rbx, %rsi
callq 0x7978
testq %rax, %rax
je 0x79b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7aa2
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x18(%rdi)
jne 0x7a47
leal -0x1(%r12), %eax
movl %eax, (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x79d0
testb %al, %al
je 0x7a47
movq (%rbx), %r15
testq %r15, %r15
je 0x7a2a
movq %r15, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5be0
movq %r15, (%rbx)
jmp 0x7aa2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7aa2
cmpl $0x0, 0x18(%rdi)
jne 0x7aa2
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x79d0
testb %al, %al
je 0x7aa2
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x7a86
movq %r15, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5be0
movq %r15, 0x8(%rbx)
testl %r12d, %r12d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7ab6
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b38
testl %ecx, %ecx
jne 0x7b36
movq (%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x7b00
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x7ace
testq %rax, %rax
je 0x7b14
xorl %ecx, %ecx
movq %rax, %rbx
jmp 0x7b32
movq 0x8(%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x7b21
decl (%r14)
movq %r14, %rsi
callq 0x7ace
movq %rax, %rbx
testq %rax, %rax
sete %cl
testb %cl, %cl
je 0x7b38
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c18
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x7b74
leal -0x1(%r12), %eax
movl %eax, (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x7b44
testb %al, %al
je 0x7bbd
movq (%rbx), %r15
testq %r15, %r15
je 0x7ba0
movq %r15, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5be0
movq %r15, (%rbx)
jmp 0x7c18
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7c18
cmpl $0x0, 0x18(%rdi)
je 0x7bcf
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x7b44
testb %al, %al
je 0x7c18
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x7bfc
movq %r15, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5be0
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 0x7c31
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7cb3
cmpl $0x0, 0x18(%rbx)
jne 0x7cb1
movq %rsi, %r14
movq (%rbx), %rdi
cmpl $0x0, 0x1c(%rdi)
je 0x7c7b
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x7c4a
testq %rax, %rax
je 0x7c8f
xorl %ecx, %ecx
movq %rax, %rbx
jmp 0x7cad
movq 0x8(%rbx), %rdi
cmpl $0x0, 0x1c(%rdi)
je 0x7c9c
decl (%r14)
movq %r14, %rsi
callq 0x7c4a
movq %rax, %rbx
testq %rax, %rax
sete %cl
testb %cl, %cl
je 0x7cb3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d0a
cmpl $0x0, 0x18(%rbx)
jne 0x7d08
movq %rsi, %r14
decl %eax
movl %eax, (%rsi)
movq (%rbx), %rdi
callq 0x7cbe
testq %rax, %rax
je 0x7cec
xorl %ecx, %ecx
movq %rax, %rbx
jmp 0x7d04
decl (%r14)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x7cbe
movq %rax, %rbx
testq %rax, %rax
sete %cl
testb %cl, %cl
je 0x7d0a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ddf
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jne 0x7ddf
movq %rdx, %r14
movq %rsi, %r15
leal -0x1(%r12), %eax
movl %eax, (%rsi)
movq (%rbx), %rdi
callq 0x7d16
testb %al, %al
je 0x7d8a
movq (%rbx), %r15
testq %r15, %r15
je 0x7d6d
movq %r15, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5be0
movq %r15, (%rbx)
jmp 0x7ddf
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7ddf
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x7d16
testb %al, %al
je 0x7ddf
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x7dc3
movq %r15, %rdi
callq 0x5afe
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movl $0x38, %edi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5be0
movq %r15, 0x8(%rbx)
testl %r12d, %r12d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7df3
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Genome::numRefsToTree(int)
int Genome::numRefsToTree(int treeNum) {
    list<Tree*>::iterator curTree;
    list<TreeID*>::iterator curTreeID;
    TreeID *treeNumID;
    list<int> treeList;
    int i, currentTreeNum;
    bool isChecked[this->num_trees];
    int counter = 0;
    curTreeID = this->tree_id_lookup.begin();
    for (i = 0; i < this->num_trees; i++) {
        isChecked[i] = false;
        if (i == treeNum) {
            treeNumID = (*curTreeID);
        }
        ++curTreeID;
    }
    // Only check trees that are directly or indirectly referenced by the output equations
    for (i = 0; i < NUM_OUTPUTS; i++) {
        treeList.push_back(i);
    }
    while (!treeList.empty()) {
        currentTreeNum = treeList.front();
        if (!isChecked[currentTreeNum]) {
            curTree = this->trees.begin();
            for (i = 0; i < currentTreeNum; i++) { // get the pointer to the currentTreeNum tree
                ++curTree;
            }
            (*curTree)->refCheck(treeList, treeNum, treeNumID, counter, isChecked);
            isChecked[currentTreeNum] = true;
        }
        treeList.pop_front();
    }
    return counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsp, -0x50(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movl 0x34(%rdi), %eax
movq %rsp, %r12
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movl $0x0, -0x2c(%rbp)
movslq 0x34(%rdi), %rax
testq %rax, %rax
movl %esi, -0x30(%rbp)
jle 0x7e81
leaq 0x18(%r14), %rcx
movl %esi, %edx
xorl %esi, %esi
movq (%rcx), %rcx
movb $0x0, (%r12,%rsi)
cmpq %rsi, %rdx
jne 0x7e77
movq 0x10(%rcx), %r13
incq %rsi
cmpq %rsi, %rax
jne 0x7e66
jmp 0x7e81
xorl %ebx, %ebx
leaq -0x48(%rbp), %r15
movl $0x18, %edi
callq 0x21e0
movl %ebx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
incq -0x38(%rbp)
incl %ebx
cmpl $0x1, %ebx
je 0x7e87
jmp 0x7f08
movslq 0x10(%rax), %rbx
cmpb $0x0, (%r12,%rbx)
jne 0x7eeb
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
incl %eax
movq %r14, %rcx
movq (%rcx), %rcx
decl %eax
jne 0x7ec6
movq 0x10(%rcx), %rdi
movq %r15, %rsi
movl -0x30(%rbp), %edx
movq %r13, %rcx
leaq -0x2c(%rbp), %r8
movq %r12, %r9
callq 0x7f72
movb $0x1, (%r12,%rbx)
movq -0x48(%rbp), %rbx
decq -0x38(%rbp)
movq %rbx, %rdi
callq 0x22d0
movl $0x18, %esi
movq %rbx, %rdi
callq 0x21f0
movq -0x48(%rbp), %rax
cmpq %r15, %rax
jne 0x7eac
movl -0x2c(%rbp), %ebx
movq -0x50(%rbp), %rsp
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x7f36
movq (%rdi), %r14
movl $0x18, %esi
callq 0x21f0
movq %r14, %rdi
cmpq %r15, %r14
jne 0x7f21
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f49
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x7f6a
movq (%rdi), %r14
movl $0x18, %esi
callq 0x21f0
movq %r14, %rdi
cmpq %r15, %r14
jne 0x7f55
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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(%r15), %eax
testl %eax, %eax
je 0x7f9d
cmpl $0x0, 0x1c(%r15)
je 0x7fbd
testl %eax, %eax
jne 0x801b
movq (%r15), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x7f72
movq 0x8(%r15), %r15
jmp 0x7f8e
movsd 0x20(%r15), %xmm0
addsd 0x336d(%rip), %xmm0     # 0xb338
cvttsd2si %xmm0, %ecx
testl %ecx, %ecx
js 0x801b
movl %ecx, %eax
cmpb $0x0, (%r13,%rax)
jne 0x8001
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 0x801b
movq 0x10(%r15), %rax
movl 0x4(%rax), %ecx
cmpl 0x4(%r14), %ecx
jne 0x8019
movl (%rax), %eax
cmpl (%r14), %eax
je 0x801b
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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(%rbx), %eax
testl %eax, %eax
je 0x8097
cmpl $0x0, 0x1c(%rbx)
je 0x80af
testl %eax, %eax
jne 0x80e6
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x807c
movq 0x8(%rbx), %rbx
jmp 0x808a
movsd 0x20(%rbx), %xmm0
addsd 0x327c(%rip), %xmm0     # 0xb338
cvttsd2si %xmm0, %eax
movq %r15, %rcx
movq (%rcx), %rcx
cmpq %r15, %rcx
je 0x80e6
movq (%r14), %r14
cmpl %eax, 0x10(%rcx)
jne 0x80c3
movl 0x10(%r14), %eax
addl $0x3, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq 0x10(%r14), %rax
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
cmpl $0x0, 0x18(%r14)
jne 0x8119
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x80ec
movq 0x8(%r14), %r14
jmp 0x80f7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa398
movq 0x10(%rcx), %rdx
movq (%rcx), %rsi
addl 0x34(%rdx), %eax
movq %rsi, %rcx
cmpq %rdi, %rsi
jne 0xa386
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ad(%rip), %xmm0      # 0xb120
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xa883
sqrtsd %xmm0, %xmm0
jmp 0xa888
callq 0x2140
mulsd 0xaf8(%rip), %xmm0      # 0xb388
movsd %xmm0, (%rsp)
callq 0x2080
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x877(%rip), %xmm0      # 0xb120
mulsd 0x8af(%rip), %xmm0      # 0xb160
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 0x7b4(%rip), %xmm1      # 0xb0a0
mulpd 0x7bc(%rip), %xmm1      # 0xb0b0
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa92c
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 0xa91a
movq $0x0, 0x60(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaa0a
movq 0x10(%r14), %rdi
cmpq %r15, (%rdi)
jne 0xa9b9
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
// File: /workspace/github_cpp_makefile_star2_O1/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Genome::updateOnGrid(std::__cxx11::list<gridEntry*, std::allocator<gridEntry*>>*, int*)
void Genome::updateOnGrid(list<gridEntry*> *fullGrid, int oldGridPosition[]) {
    // no update needed if genome is still in the same grid square as before
    if ((oldGridPosition[0] != this->mainGridLocation[0]) || (oldGridPosition[1] != this->mainGridLocation[1])) {
        int tempGridPosition[2];
        tempGridPosition[0] = this->mainGridLocation[0];
        tempGridPosition[1] = this->mainGridLocation[1];
        this->mainGridLocation[0] = oldGridPosition[0];
        this->mainGridLocation[1] = oldGridPosition[1];
        this->removeFromGrid(fullGrid);
        this->mainGridLocation[0] = tempGridPosition[0];
        this->mainGridLocation[1] = tempGridPosition[1];
        this->addToGrid(fullGrid);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
movl 0x48(%rdi), %ebp
cmpl %ebp, %eax
jne 0xaa3a
movl 0x4(%rdx), %ecx
cmpl 0x4c(%r14), %ecx
jne 0xaa3a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4c(%r14), %r15d
movl %eax, 0x48(%r14)
movl 0x4(%rdx), %eax
movl %eax, 0x4c(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa990
movl %ebp, 0x48(%r14)
movl %r15d, 0x4c(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa936
nop
// File: /workspace/github_cpp_makefile_star2_O1/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::delete_tree(std::allocator<summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node>&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static void delete_tree(node_allocator& alloc, node *n)
    {
	if (!n)
	    return;

	delete_tree(alloc, n->left);
	delete_tree(alloc, n->right);
	delete_node(alloc, n);
    }

// Assembly:
testq %rsi, %rsi
je 0x2ba4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rsi
callq 0x2b60
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x2b60
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x2b95
callq 0x2150
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2150
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_type erase(const key_type& key)
    {
	iterator i = find(key);

	if (i == end())
	    return 0;

	erase(i);
	return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdx
callq 0x3060
cmpq %r14, %rax
je 0x2c64
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30c0
movl $0x1, %eax
jmp 0x2c66
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq