LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x7ce0
movq 0x8(%rsp), %rdi
callq 0x8810
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x34(%rcx), %eax
jge 0xaf77
leaq 0x18(%rsp), %rdi
callq 0x8890
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdi
movq 0x28(%rsp), %rsi
movl 0x34(%rax), %edx
callq 0xaf80
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
movslq 0x24(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x78(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xa138(%rip), %xmm1     # 0x15038
ucomisd %xmm1, %xmm0
jbe 0xaf23
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd 0xa11c(%rip), %xmm0     # 0x15038
movsd %xmm0, (%rax,%rcx,8)
jmp 0xaf5d
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd 0xa107(%rip), %xmm0     # 0x15040
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xaf5b
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd 0xa0ea(%rip), %xmm0     # 0x15040
movsd %xmm0, (%rax,%rcx,8)
jmp 0xaf5d
leaq 0x18(%rsp), %rdi
callq 0x88b0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xaea3
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x17(%rsp)
cmpl $0x0, 0x18(%rax)
jne 0xb9e7
movq 0x18(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xb9e7
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x18(%rsp), %rax
ucomisd 0x20(%rax), %xmm0
jne 0xb9e5
jp 0xb9e5
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0xb960
testb $0x1, %al
jne 0xb9c1
jmp 0xb9e3
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xb960
testb $0x1, %al
jne 0xb9de
jmp 0xb9e3
movb $0x1, 0x17(%rsp)
jmp 0xb9e5
jmp 0xba32
movq 0x8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0xba30
movq 0x18(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0xba30
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0xba2e
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x18(%rsp), %rax
ucomisd 0x20(%rax), %xmm0
jne 0xba2c
jp 0xba2c
movb $0x1, 0x17(%rsp)
jmp 0xba2e
jmp 0xba30
jmp 0xba32
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movl %ecx, 0x28(%rax)
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rsp)
movl $0x1, 0x34(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x30(%rax)
cmpl $0x0, 0x18(%rax)
jne 0xd0e0
movq (%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
callq 0xd020
movq (%rsp), %rax
movq (%rax), %rcx
movl 0x34(%rcx), %ecx
addl 0x34(%rax), %ecx
movl %ecx, 0x34(%rax)
movq (%rax), %rcx
movl 0x2c(%rcx), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq (%rax), %rcx
movl 0x30(%rcx), %ecx
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
cmpq $0x0, 0x8(%rax)
je 0xd0de
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0xd020
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x34(%rcx), %ecx
addl 0x34(%rax), %ecx
movl %ecx, 0x34(%rax)
movq 0x8(%rax), %rcx
movl 0x2c(%rcx), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq 0x8(%rax), %rcx
movl 0x30(%rcx), %ecx
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
jmp 0xd0fe
movq (%rsp), %rax
movl $0x1, 0x30(%rax)
cmpl $0x0, 0x1c(%rax)
je 0xd0fc
movq (%rsp), %rax
movl $0x1, 0x2c(%rax)
jmp 0xd0fe
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xd13f
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd1dd
movq (%rsp), %rax
movq $0x0, 0x8(%rsp)
movq (%rax), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd177
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd110
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd18b
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd1dd
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd1d2
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd110
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd1d0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd1dd
jmp 0xd1d2
jmp 0xd1d4
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xd221
movb $0x1, 0x67(%rsp)
jmp 0xd3c0
movq 0x28(%rsp), %rax
movb $0x0, 0x47(%rsp)
movq (%rax), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd25d
movq 0x28(%rsp), %rax
movq 0x50(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd1f0
andb $0x1, %al
movb %al, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
je 0xd2e9
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xd294
movq 0x20(%rsp), %rdi
callq 0x89f0
movq 0x20(%rsp), %rdi
movl $0x38, %esi
callq 0x32b0
movl $0x38, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x90b0
jmp 0xd2b5
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0xd3b9
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x38, %esi
callq 0x32b0
jmp 0xd3cb
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd3b7
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd3b5
movq 0x28(%rsp), %rax
movq 0x50(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd1f0
testb $0x1, %al
jne 0xd336
jmp 0xd3b3
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xd363
movq 0x10(%rsp), %rdi
callq 0x89f0
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0x32b0
movl $0x38, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
callq 0x90b0
jmp 0xd384
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xd3b3
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x38, %esi
callq 0x32b0
jmp 0xd3cb
jmp 0xd3b5
jmp 0xd3b7
jmp 0xd3b9
jmp 0xd3bb
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x18(%rax)
je 0xd415
movq 0x10(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0xd415
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd4c3
movq (%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd4b8
movq (%rsp), %rax
movq $0x0, 0x8(%rsp)
movq (%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0xd445
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd3e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd46f
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd4c3
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0xd489
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd3e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd4b4
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd4c3
jmp 0xd4b6
jmp 0xd4b8
jmp 0xd4ba
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x18(%rax)
je 0xd507
movq 0x50(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0xd507
movb $0x1, 0x67(%rsp)
jmp 0xd6b8
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd6b1
movq 0x28(%rsp), %rax
movb $0x0, 0x47(%rsp)
movq (%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0xd535
movq 0x50(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd4d0
andb $0x1, %al
movb %al, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
je 0xd5de
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xd589
movq 0x20(%rsp), %rdi
callq 0x89f0
movq 0x20(%rsp), %rdi
movl $0x38, %esi
callq 0x32b0
movl $0x38, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x90b0
jmp 0xd5aa
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0xd6af
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x38, %esi
callq 0x32b0
jmp 0xd6c3
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd6ad
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0xd609
movq 0x50(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd4d0
andb $0x1, %al
movb %al, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
je 0xd6ab
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xd65b
movq 0x10(%rsp), %rdi
callq 0x89f0
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0x32b0
movl $0x38, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
callq 0x90b0
jmp 0xd67c
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xd6ab
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x38, %esi
callq 0x32b0
jmp 0xd6c3
jmp 0xd6ad
jmp 0xd6af
jmp 0xd6b1
jmp 0xd6b3
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3430
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rax)
je 0xd705
movq 0x10(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0xd705
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd7b3
movq (%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd7a8
movq (%rsp), %rax
movq $0x0, 0x8(%rsp)
movq (%rax), %rax
cmpl $0x0, 0x1c(%rax)
je 0xd735
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd6d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd75f
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd7b3
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x1c(%rax)
je 0xd779
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd6d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd7a4
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd7b3
jmp 0xd7a6
jmp 0xd7a8
jmp 0xd7aa
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xd7ef
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd87e
movq (%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd873
movq (%rsp), %rax
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd7c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd838
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd87e
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd7c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd86f
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd87e
jmp 0xd871
jmp 0xd873
jmp 0xd875
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xd8c1
movb $0x1, 0x67(%rsp)
jmp 0xda4e
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xda47
movq 0x28(%rsp), %rax
movb $0x0, 0x47(%rsp)
movq 0x50(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd890
andb $0x1, %al
movb %al, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
je 0xd98a
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xd935
movq 0x20(%rsp), %rdi
callq 0x89f0
movq 0x20(%rsp), %rdi
movl $0x38, %esi
callq 0x32b0
movl $0x38, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x90b0
jmp 0xd956
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0xda45
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x38, %esi
callq 0x32b0
jmp 0xda59
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xda43
movq 0x28(%rsp), %rax
movq 0x50(%rsp), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd890
testb $0x1, %al
jne 0xd9c4
jmp 0xda41
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xd9f1
movq 0x10(%rsp), %rdi
callq 0x89f0
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0x32b0
movl $0x38, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
callq 0x90b0
jmp 0xda12
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xda41
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x38, %esi
callq 0x32b0
jmp 0xda59
jmp 0xda43
jmp 0xda45
jmp 0xda47
jmp 0xda49
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x18(%rax)
je 0xdd25
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0xdd25
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd 0x735e(%rip), %xmm1     # 0x15020
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0xdd23
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
testb $0x1, (%rax,%rcx)
jne 0xdcf4
movq 0x38(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x12df0
movl 0x14(%rsp), %eax
cmpl 0x34(%rsp), %eax
jne 0xdd21
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xdd90
testb $0x1, %al
jne 0xdd21
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xdd23
jmp 0xdd7d
movq 0x8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xdd7b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0xdc70
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0xdc70
jmp 0xdd7d
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: TreeID::isEqual(TreeID*)
bool TreeID::isEqual(TreeID *compareID) {
    bool result = false;
    if ((this->myID == compareID->myID) && (this->islandID == compareID->islandID)) {
        result = true;
    }
    return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movb $0x0, -0x11(%rsp)
movl 0x4(%rax), %eax
movq -0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0xddcb
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xddcb
movb $0x1, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x12ec0
leaq 0x28(%rsp), %rdi
callq 0x12ec0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0xdf8a
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0xdf8a
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd 0x714f(%rip), %xmm1     # 0x15020
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x12ee0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x12ee0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
callq 0x12f30
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12f10
testb $0x1, %al
jne 0xdf33
jmp 0xdf88
movl 0x3c(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x12f60
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jne 0xdf72
leaq 0x28(%rsp), %rdi
callq 0x12f60
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl (%rcx), %ecx
addl $0x3, %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x20(%rax)
jmp 0xdf88
leaq 0x28(%rsp), %rdi
callq 0x12f90
leaq 0x30(%rsp), %rdi
callq 0x12f90
jmp 0xdf0f
jmp 0xdfc6
movq 0x8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xdfc4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xde70
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xde70
jmp 0xdfc6
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %edx
movq 0x10(%rax), %rcx
movl %edx, (%rcx)
movl 0x8(%rsp), %edx
movq 0x10(%rax), %rcx
movl %edx, 0x4(%rcx)
cmpl $0x0, 0x18(%rax)
jne 0xe02e
movq (%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0xdfd0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0xdfd0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x7ce0
movq 0x8(%rsp), %rdi
callq 0x8810
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
callq 0x8860
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8840
testb $0x1, %al
jne 0x11ea2
jmp 0x11ec6
leaq 0x20(%rsp), %rdi
callq 0x8890
movq (%rax), %rax
movl 0x34(%rax), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x88b0
jmp 0x11e7e
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x8110
callq 0x31e0
movaps %xmm0, %xmm1
movsd 0x29b0(%rip), %xmm0     # 0x15278
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x8110
movaps %xmm0, %xmm1
movsd 0x2766(%rip), %xmm0     # 0x15048
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x3480
movq 0x10(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x68(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x3070
movq 0x10(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
movsd 0x2708(%rip), %xmm0     # 0x15058
addsd 0x68(%rax), %xmm0
movsd 0x28db(%rip), %xmm1     # 0x15238
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x48(%rax)
movsd 0x26e8(%rip), %xmm0     # 0x15058
addsd 0x70(%rax), %xmm0
movsd 0x28bb(%rip), %xmm1     # 0x15238
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x4c(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x18(%rsp), %rcx
movl -0xc(%rsp), %eax
cmpl 0x34(%rcx), %eax
jge 0x129e6
movq -0x18(%rsp), %rax
movq 0x80(%rax), %rcx
movslq -0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x78(%rax), %rax
movslq -0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x129a7
movq -0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x7d20
movq 0x18(%rsp), %rcx
movq 0x48(%rsp), %rdi
imull $0xa0, 0x4c(%rcx), %eax
addl 0x48(%rcx), %eax
cltq
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x13620
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rcx
movq 0x48(%rsp), %rdi
imull $0xa0, 0x4c(%rcx), %eax
addl 0x48(%rcx), %eax
cltq
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x13670
movq %rax, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13650
testb $0x1, %al
jne 0x12b32
jmp 0x12bc9
leaq 0x40(%rsp), %rdi
callq 0x136a0
movq 0x18(%rsp), %rcx
movq (%rax), %rax
cmpq %rcx, (%rax)
jne 0x12bb8
leaq 0x40(%rsp), %rdi
callq 0x136a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x12b70
movq 0x10(%rsp), %rdi
movl $0x10, %esi
callq 0x32b0
movq 0x18(%rsp), %rdx
movq 0x48(%rsp), %rax
imull $0xa0, 0x4c(%rdx), %ecx
addl 0x48(%rdx), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x13790
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x137e0
movq %rax, 0x20(%rsp)
jmp 0x12bc9
jmp 0x12bba
leaq 0x40(%rsp), %rdi
callq 0x13700
jmp 0x12af3
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl 0x48(%rcx), %eax
jne 0x12c09
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x4c(%rcx), %eax
je 0x12c56
movq (%rsp), %rdi
movl 0x48(%rdi), %eax
movl %eax, 0x8(%rsp)
movl 0x4c(%rdi), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x48(%rdi)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4c(%rdi)
movq 0x18(%rsp), %rsi
callq 0x12aa0
movq (%rsp), %rdi
movl 0x8(%rsp), %eax
movl %eax, 0x48(%rdi)
movl 0xc(%rsp), %eax
movl %eax, 0x4c(%rdi)
movq 0x18(%rsp), %rsi
callq 0x12a00
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: dlbeer[P]summary_map/test_perf.cpp
// Function: main
int main(int argc, char **argv)
{
    const char *path = "/usr/share/dict/words";

    if (argc > 1)
	path = argv[1];

    std::cout << "Loading words from " << path << '\n';

    test_vector vec;
    test_map m;
    std::map<std::string, int> sm;

    load_words(path, vec);
    assert(vec.size() >= 1000);
    std::cout << "Working with " << vec.size() << " items\n\n";

    run_test("summary_map", vec, m);
    run_test("std::map", vec, sm);

    return 0;
}

// Assembly:
subq $0xd8, %rsp
movl $0x0, 0xd4(%rsp)
movl %edi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
leaq 0x6c1c(%rip), %rax      # 0x9004
movq %rax, 0xc0(%rsp)
cmpl $0x1, 0xd0(%rsp)
jle 0x240e
movq 0xc8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0xabc3(%rip), %rdi      # 0xcfd8
leaq 0x6bfe(%rip), %rsi      # 0x901a
callq 0x2160
movq %rax, %rdi
movq 0xc0(%rsp), %rsi
callq 0x2160
movq %rax, %rdi
movl $0xa, %esi
callq 0x21b0
leaq 0xa8(%rsp), %rdi
callq 0x2ce0
leaq 0x50(%rsp), %rdi
callq 0x2cf0
jmp 0x2457
leaq 0x10(%rsp), %rdi
callq 0x2d60
movq 0xc0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x78f0
jmp 0x247d
leaq 0xa8(%rsp), %rdi
callq 0x2d70
cmpq $0x3e8, %rax            # imm = 0x3E8
jb 0x2494
jmp 0x24ed
leaq 0x6b93(%rip), %rdi      # 0x902e
leaq 0x6b9f(%rip), %rsi      # 0x9041
movl $0x57, %edx
leaq 0x6ba1(%rip), %rcx      # 0x904f
callq 0x2100
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x25aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2d90
leaq 0x50(%rsp), %rdi
callq 0x2da0
jmp 0x25aa
movq 0xaae4(%rip), %rdi      # 0xcfd8
leaq 0x6b6b(%rip), %rsi      # 0x9066
callq 0x2160
movq %rax, 0x8(%rsp)
jmp 0x2507
leaq 0xa8(%rsp), %rdi
callq 0x2d70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, (%rsp)
jmp 0x2527
movq (%rsp), %rdi
leaq 0x6b42(%rip), %rsi      # 0x9074
callq 0x2160
jmp 0x2539
leaq 0x6b3d(%rip), %rdi      # 0x907d
leaq 0xa8(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x25d0
jmp 0x2554
leaq 0x6b2e(%rip), %rdi      # 0x9089
leaq 0xa8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x28f0
jmp 0x256f
movl $0x0, 0xd4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2d90
leaq 0x50(%rsp), %rdi
callq 0x2da0
leaq 0xa8(%rsp), %rdi
callq 0x2df0
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0x2df0
movq 0x48(%rsp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x35d8
jmp 0x360d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
callq 0x35c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x35c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3630
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rsi
callq 0x37e0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3990
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3bc0
testb $0x1, %al
jne 0x3889
jmp 0x3894
movq $0x0, 0x30(%rsp)
jmp 0x38b5
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x4740
movq $0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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>>>::insert(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>>>::iterator, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int> const&)
iterator insert(iterator pos, const value_type& val)
    {
	// Special-case optimization: insertion of sequential data (with
	// end() supplied as a hint).
	if ((pos == end()) && header.left) {
	    node *last = rightmost_child(header.left);

	    // Does it come after the last item?
	    if (comparer(last->value.first, val.first)) {
		node *n = new_node(allocator, val);

		last->right = n;
		n->parent = last;

		rebalance_after_insert(n);
		return n;
	    }
	}

	return insert(val).first;
    }

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3990
movq %rax, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3bc0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x3a44
jmp 0x3a54
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3a5e
jmp 0x3ad9
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x3be0
movq (%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x3c30
testb $0x1, %al
jne 0x3a89
jmp 0x3ad7
movq (%rsp), %rdi
addq $0x2, %rdi
movq 0x48(%rsp), %rsi
callq 0x3c60
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x30(%rsp), %rdi
callq 0x3d10
movq 0x30(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x3ea0
jmp 0x3b0c
jmp 0x3ad9
movq (%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x3ec0
movb %dl, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movb 0x18(%rsp), %al
movb %al, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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>>>::rightmost_child(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 node *rightmost_child(node *n)
    {
	if (!n)
	    return n;

	while (n->right)
	    n = n->right;

	return n;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x3bf9
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x3c21
jmp 0x3bfb
movq -0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x3c17
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x3bfb
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: 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>>>::new_node(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>&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int> const&)
static node *new_node(node_allocator& alloc, const value_type& val)
    {
	node *n = alloc.allocate(1);

	try {
	    n = new (n) node(val);
	}
	catch (...) {
	    alloc.deallocate(n, 1);
	    throw;
	}

	return n;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x3fb0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x4010
jmp 0x3c9c
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x3cf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20a0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x3670
callq 0x21f0
jmp 0x3d0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x2210
jmp 0x3cf0
jmp 0x3cfc
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2240
movq %rax, %rdi
callq 0x2fb0
nop
// File: 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>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int> const&)
std::pair<iterator, bool> insert(const value_type& val)
    {
	std::pair<node *, bool> r =
	    add_node(comparer, allocator, &header, val);

	if (r.second)
	    item_count++;

	return std::make_pair(r.first, r.second);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
movq %rdi, %rsi
addq $0x2, %rsi
movq %rdi, %rdx
addq $0x8, %rdx
movq 0x48(%rsp), %rcx
callq 0x43e0
movb %dl, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movb 0x30(%rsp), %al
movb %al, 0x40(%rsp)
testb $0x1, 0x40(%rsp)
je 0x3f21
movq (%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x4560
movb %dl, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movb 0x10(%rsp), %al
movb %al, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4590
movq 0x58(%rsp), %rax
movb 0x60(%rsp), %dl
addq $0x68, %rsp
retq
nopl (%rax,%rax)