LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Dts0[P]addCopyright/main.cpp
// Function: showHelp()
void showHelp(){
	cout<<"用法：addCopyright [选项]... [文件]... \n"
		<<"\t-c\t版权文件路径，如果无法打开，直接退出\n"
		<<"\t-h\t打印帮助并退出\n"
		<<"\t-v\t打印版本信息并退出\n";
}

// Assembly:
pushq %rax
movq 0x2562(%rip), %rdi      # 0x4fd8
leaq 0x6e9(%rip), %rsi       # 0x3166
callq 0x2170
leaq 0x70d(%rip), %rsi       # 0x3196
movq %rax, %rdi
callq 0x2170
leaq 0x73a(%rip), %rsi       # 0x31d2
movq %rax, %rdi
callq 0x2170
leaq 0x746(%rip), %rsi       # 0x31ed
movq %rax, %rdi
popq %rax
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/Dts0[P]addCopyright/main.cpp
// Function: showVersion()
void showVersion(){
	cout<<"addCopyright:1.0.0\n"
		<<"Copyright (C) DTS\n"
		<<"License MIT\n"
		<<"Written by DTS\n"
		<<"my website: <http://www.dreamoftime0.com/>"
		<<endl;
}

// Assembly:
pushq %rax
movq 0x24e6(%rip), %rdi      # 0x4fd8
leaq 0x726(%rip), %rsi       # 0x321f
callq 0x2170
leaq 0x72e(%rip), %rsi       # 0x3233
movq %rax, %rdi
callq 0x2170
leaq 0x732(%rip), %rsi       # 0x3246
movq %rax, %rdi
callq 0x2170
leaq 0x730(%rip), %rsi       # 0x3253
movq %rax, %rdi
callq 0x2170
leaq 0x731(%rip), %rsi       # 0x3263
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
popq %rax
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: gaussrand()
inline double gaussrand() {
  static int iset=0;
  static double gset;
  double fac,rsq,v1,v2;

  if (iset==0) {
    do {
      v1=2.0*((rand())/(RAND_MAX+1.0))-1.0;
      v2=2.0*((rand())/(RAND_MAX+1.0))-1.0;
      rsq=v1*v1+v2*v2;
    } while (rsq>=1.0 || rsq==0.0);
    fac=sqrt(-2.0*log(rsq)/rsq);
    gset=v1*fac;
    iset=1;
    return v2*fac;
  }
  else {
    iset=0;
    return gset;
  }
}

// Assembly:
cmpl $0x0, 0x9b7e(%rip)      # 0xe1dc
je 0x4674
andl $0x0, 0x9b75(%rip)      # 0xe1dc
movsd 0x9b71(%rip), %xmm1     # 0xe1e0
jmp 0x4747
subq $0x18, %rsp
callq 0x2080
cvtsi2sd %eax, %xmm1
movsd 0x5a07(%rip), %xmm0     # 0xa090
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x59ff(%rip), %xmm0     # 0xa098
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x2080
cvtsi2sd %eax, %xmm1
mulsd 0x59dd(%rip), %xmm1     # 0xa090
addsd %xmm1, %xmm1
addsd 0x59d9(%rip), %xmm1     # 0xa098
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
movsd (%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
ucomisd 0x5944(%rip), %xmm0     # 0xa020
jae 0x4678
ucomisd 0x59a2(%rip), %xmm0     # 0xa088
jne 0x46ea
jnp 0x4678
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x2160
mulsd 0x599d(%rip), %xmm0     # 0xa0a0
divsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4719
sqrtsd %xmm0, %xmm0
jmp 0x471e
callq 0x2150
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x9ab1(%rip)     # 0xe1e0
movl $0x1, 0x9aa3(%rip)      # 0xe1dc
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
addq $0x18, %rsp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x479d
callq 0x2230
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x47ae
callq 0x2230
pushq $0x38
popq %r14
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x47dd
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x47d0
movq %r15, %rdi
callq 0x4a1a
movq %r15, %rdi
movq %r14, %rsi
callq 0x2200
jmp 0x47b5
leaq 0x18(%rbx), %r14
pushq $0x8
popq %r15
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x4800
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x2200
jmp 0x47e8
movq %rbx, %rdi
callq 0x4a7a
movq %r14, %rdi
callq 0x4a92
movq %r14, %rdi
callq 0x4ad4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4aaa
nop
// File: /workspace/github_cpp_makefile_star2_O2/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: Genome::Genome(Genome*)
Genome(Genome *copyMe) {
        int i;
        list<Tree*>::iterator curTree;
        Tree *new_tree;
        pop_id = copyMe->pop_id;
        num_trees = copyMe->num_trees;
        myData = new double[num_trees];
        initialVal = new double[num_trees];
        fitness = copyMe->fitness;
        closestInd = copyMe->closestInd;
        is_alive = copyMe->is_alive;
        age = copyMe->age;
        mainGridLocation[0] = copyMe->mainGridLocation[0];
        mainGridLocation[1] = copyMe->mainGridLocation[1];
        isNan = copyMe->isNan;

        for (i = 0; i < 2; i++) {
            myPosition[i] = copyMe->myPosition[i];
        }

        i = 0;
        for (curTree = copyMe->trees.begin(); curTree != copyMe->trees.end(); ++curTree) {
//            cout << "Copying eq net...";
            initialVal[i] = copyMe->initialVal[i];
            //myData[i] = copyMe->myData[i];
            new_tree = new Tree((*curTree));
            trees.push_back(new_tree);
            tree_id_lookup.push_back(new TreeID((*curTree)->tree_id));
//            cout << "done copying eq net." << endl;
            i++;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r12
leaq 0x18(%rdi), %r14
movq %r14, 0x20(%rdi)
movq %r14, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movl 0x30(%rsi), %eax
movl %eax, 0x30(%rdi)
movslq 0x34(%rsi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movl %eax, 0x34(%rdi)
pushq $-0x1
popq %r15
cmovnsq %rcx, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, 0x78(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x80(%rbx)
movl 0x38(%r12), %eax
movl %eax, 0x38(%rbx)
movq 0x50(%r12), %rax
movq %rax, 0x50(%rbx)
movb 0x58(%r12), %al
movb %al, 0x58(%rbx)
movsd 0x40(%r12), %xmm0
movsd %xmm0, 0x40(%rbx)
movl 0x48(%r12), %eax
movl %eax, 0x48(%rbx)
movl 0x4c(%r12), %eax
movl %eax, 0x4c(%rbx)
movb 0x88(%r12), %al
movb %al, 0x88(%rbx)
pushq $0xd
popq %rax
cmpq $0xf, %rax
je 0x490e
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x48f8
xorl %ebp, %ebp
movq %r12, %r15
movq (%r15), %r15
cmpq %r12, %r15
je 0x498b
movq 0x80(%r12), %rax
movsd (%rax,%rbp), %xmm0
movq 0x80(%rbx), %rax
movsd %xmm0, (%rax,%rbp)
pushq $0x38
popq %rdi
callq 0x21f0
movq %rax, %r13
movq 0x10(%r15), %rsi
movq %rax, %rdi
callq 0x4afe
movq %r13, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4bac
pushq $0x8
popq %rdi
callq 0x21f0
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x4bb8
addq $0x8, %rbp
jmp 0x4913
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49ae
movq %rax, %r15
pushq $0x38
popq %rsi
movq %r13, %rdi
callq 0x2200
jmp 0x49b1
jmp 0x49ae
movq %rax, %r15
movq %r14, %rdi
callq 0x4ad4
movq %rbx, %rdi
callq 0x4aaa
movq %r15, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%r15), %r15
cmpq %rbx, %r15
je 0x49fd
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x49ee
movq %r14, %rdi
callq 0x4784
movl $0x90, %esi
movq %r14, %rdi
callq 0x2200
jmp 0x49d5
movq %rbx, %rdi
callq 0x474c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4d3c
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rsi
callq 0x2200
cmpl $0x0, 0x18(%rbx)
je 0x4a3b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %r14
testq %r14, %r14
je 0x4a56
movq %r14, %rdi
callq 0x4a1a
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2200
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x4a33
movq %rbx, %rdi
callq 0x4a1a
pushq $0x38
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b33
pushq $0x38
popq %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x4afe
movq %r15, (%rbx)
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x4b56
pushq $0x38
popq %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x4afe
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)
pushq $0x8
popq %rdi
callq 0x21f0
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 0x4b96
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x34(%rdi), %r15
movq 0x78(%rdi), %r12
xorl %r13d, %r13d
cmpq %r15, %r13
jge 0x54ec
movq (%r14), %r14
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x54f6
movsd %xmm0, (%r12,%r13,8)
movsd 0x4b5b(%rip), %xmm1     # 0xa028
ucomisd %xmm1, %xmm0
ja 0x54e1
movsd 0x4b85(%rip), %xmm1     # 0xa060
ucomisd %xmm0, %xmm1
jbe 0x54e7
movsd %xmm1, (%r12,%r13,8)
incq %r13
jmp 0x54a8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x552b
cmpl $0x0, 0x1c(%r14)
movsd 0x20(%r14), %xmm0
jne 0x5603
cvttsd2si %xmm0, %eax
cltq
movsd (%rbx,%rax,8), %xmm0
jmp 0x5603
cvttsd2si 0x20(%r14), %eax
cmpl $0x3, %eax
ja 0x55ff
movl %edx, %ebp
leaq 0x4d71(%rip), %rcx      # 0xa2b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
addsd 0x8(%rsp), %xmm0
jmp 0x5603
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
mulsd 0x8(%rsp), %xmm0
jmp 0x5603
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
jmp 0x55f9
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x54f6
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x5603
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::isEqual(Tree*)
bool Tree::isEqual(Tree *compareTree) {
    bool treesAreEqual = false;

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

    return treesAreEqual;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x18(%r14)
movl 0x18(%rbx), %eax
jne 0x58b0
testl %eax, %eax
jne 0x58d0
movsd 0x20(%r14), %xmm0
ucomisd 0x20(%rbx), %xmm0
jne 0x58d0
jp 0x58d0
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x5870
testb %al, %al
je 0x58d0
movq 0x8(%r14), %r14
movq 0x8(%rbx), %rbx
jmp 0x587a
testl %eax, %eax
je 0x58d0
movl 0x1c(%r14), %eax
cmpl 0x1c(%rbx), %eax
jne 0x58d0
movsd 0x20(%r14), %xmm0
ucomisd 0x20(%rbx), %xmm0
jne 0x58d0
jp 0x58d0
movb $0x1, %al
jmp 0x58d2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::getTreeString[abi:cxx11]()
string Tree::getTreeString() {
    stringstream ss;
    string tempString;
    if (this->isConstant) {
        ss << 1;
    } else {
        ss << 0;
    }
    if (this->isTerminal) {
        ss << "," << 1;
    } else {
        ss << "," << 0;
    }
    ss << "," << this->myDepth << ",";
    ss << showpoint << setprecision(numeric_limits<double>::digits10 + 2) << this->myVal;
    ss << "," << this->numConstants << "," << this->numNodes << "," << this->numTerminals << endl;
    if (this->leftTree != NULL) {
        tempString = this->leftTree->getTreeString();
        ss << tempString;
    }
    if (this->rightTree != NULL) {
        tempString = this->rightTree->getTreeString();
        ss << tempString;
    }
    return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %esi, %esi
cmpl $0x0, 0x1c(%r14)
setne %sil
leaq 0x58(%rsp), %rdi
callq 0x2300
cmpl $0x0, 0x18(%r14)
leaq 0x58(%rsp), %rdi
je 0x5d85
leaq 0x448e(%rip), %rsi      # 0xa209
callq 0x21d0
pushq $0x1
popq %rsi
jmp 0x5d93
leaq 0x447d(%rip), %rsi      # 0xa209
callq 0x21d0
xorl %esi, %esi
movq %rax, %rdi
callq 0x2300
leaq 0x58(%rsp), %r15
leaq 0x4462(%rip), %rsi      # 0xa209
movq %r15, %rdi
callq 0x21d0
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x2300
leaq 0x4447(%rip), %rsi      # 0xa209
movq %rax, %rdi
callq 0x21d0
movq 0x58(%rsp), %rax
movq -0x18(%rax), %rcx
orl $0x400, 0x70(%rsp,%rcx) # imm = 0x400
movq -0x18(%rax), %rax
movq $0x11, 0x60(%rsp,%rax)
movsd 0x20(%r14), %xmm0
movq %r15, %rdi
callq 0x22d0
leaq 0x440c(%rip), %rsi      # 0xa209
movq %r15, %rdi
callq 0x21d0
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x2300
leaq 0x43f1(%rip), %rsi      # 0xa209
movq %rax, %rdi
callq 0x21d0
movl 0x34(%r14), %esi
movq %rax, %rdi
callq 0x2300
leaq 0x43d6(%rip), %rsi      # 0xa209
movq %rax, %rdi
callq 0x21d0
movl 0x30(%r14), %esi
movq %rax, %rdi
callq 0x2300
movq %rax, %rdi
callq 0x20c0
movq (%r14), %rsi
testq %rsi, %rsi
je 0x5e89
leaq 0x28(%rsp), %rdi
callq 0x5d22
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2220
movq %r13, %rdi
callq 0x20b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x21a0
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x5ec4
leaq 0x28(%rsp), %rdi
callq 0x5d22
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x21a0
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x22c0
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x48(%rsp), %rdi
callq 0x2120
movq %rbx, %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5efd
jmp 0x5efd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x48(%rsp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdi
callq 0x21f0
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 0x4199(%rip), %rsi      # 0xa4be
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 0x2340
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 0x63b3
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0x63fb
pushq $0x38
popq %rbx
movq %rbx, %rdi
callq 0x21f0
movq %rax, (%r15)
movq %rax, %rdi
movq 0x18(%rsp), %r14
movq %r14, %rsi
movl 0x8(%rsp), %r12d
movl %r12d, %edx
movl 0xc(%rsp), %ebp
movl %ebp, %ecx
callq 0x62da
movq %rbx, %rdi
callq 0x21f0
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x62da
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x2c(%rdi)
cmpl $0x0, 0x18(%rdi)
je 0x643b
movl $0x1, 0x30(%rbx)
cmpl $0x0, 0x1c(%rbx)
je 0x6492
movl $0x1, 0x2c(%rbx)
jmp 0x6492
movl %esi, %ebp
incl %ebp
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x640a
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 0x6492
movl %ebp, %esi
callq 0x640a
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/pgrouchy[P]NoiseWorld/mathNet.cpp
// Function: Tree::getNonTerminalTree(int&)
Tree* Tree::getNonTerminalTree(int &i) {
    if (i == 0) {
        return this;
    } else {
        Tree *myTree;
        myTree = NULL;
        if (!this->leftTree->isTerminal) {
            i--;
            myTree = this->leftTree->getNonTerminalTree(i);
        }
        if (myTree != NULL) {
            return myTree;
        } else {
            if (!this->rightTree->isTerminal) {
                i--;
                myTree = this->rightTree->getNonTerminalTree(i);
                if (myTree != NULL) {
                    return myTree;
                }
            }
        }
        
        return NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x64e8
movq %rsi, %r14
movq (%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x64c1
movq 0x8(%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x64d5
xorl %ebx, %ebx
jmp 0x64e8
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x649a
testq %rax, %rax
jne 0x64e5
jmp 0x64b3
decl (%r14)
movq %r14, %rsi
callq 0x649a
testq %rax, %rax
je 0x64bd
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movl (%rsi), %r13d
testl %r13d, %r13d
je 0x65c6
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x18(%rdi)
jne 0x656b
leal -0x1(%r13), %eax
movl %eax, (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x64f4
testb %al, %al
je 0x656b
movq (%rbx), %r15
testq %r15, %r15
je 0x6541
movq %r15, %rdi
callq 0x4a1a
pushq $0x38
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4afe
movq %r15, (%rbx)
jmp 0x65c6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x65c6
cmpl $0x0, 0x18(%rdi)
jne 0x65c6
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x64f4
testb %al, %al
je 0x65c6
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x659d
movq %r15, %rdi
callq 0x4a1a
pushq $0x38
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4afe
movq %r15, 0x8(%rbx)
testl %r13d, %r13d
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x65d8
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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(%rbx), %ecx
testl %ecx, %ecx
setne %dl
movl (%r14), %eax
cmpl $-0x1, %eax
sete %sil
testb %sil, %dl
jne 0x6644
testl %ecx, %ecx
jne 0x663d
movq (%rbx), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x6621
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x65ee
testq %rax, %rax
jne 0x6641
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x18(%rbx)
je 0x65f8
decl (%r14)
jmp 0x65f8
xorl %ebx, %ebx
jmp 0x6644
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x18(%rdi), %ebp
movl (%rsi), %r13d
testl %ebp, %ebp
jne 0x6726
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x18(%rdi)
je 0x6682
leal -0x1(%r13), %eax
movl %eax, (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x6650
testb %al, %al
je 0x66cb
movq (%rbx), %r15
testq %r15, %r15
je 0x66a1
movq %r15, %rdi
callq 0x4a1a
pushq $0x38
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4afe
movq %r15, (%rbx)
jmp 0x6726
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6726
cmpl $0x0, 0x18(%rdi)
je 0x66dd
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x6650
testb %al, %al
je 0x6726
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x66fd
movq %r15, %rdi
callq 0x4a1a
pushq $0x38
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4afe
movq %r15, 0x8(%rbx)
testl %ebp, %ebp
setne %cl
cmpl $-0x1, %r13d
sete %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6745
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x1c(%rbx)
setne %cl
movl (%r14), %eax
cmpl $-0x1, %eax
sete %dl
testb %dl, %cl
jne 0x67b1
cmpl $0x0, 0x18(%rbx)
jne 0x67aa
movq (%rbx), %rdi
cmpl $0x0, 0x1c(%rdi)
je 0x678e
decl %eax
movl %eax, (%r14)
movq %r14, %rsi
callq 0x675c
testq %rax, %rax
jne 0x67ae
movq 0x8(%rbx), %rbx
cmpl $0x0, 0x1c(%rbx)
je 0x6766
decl (%r14)
jmp 0x6766
xorl %ebx, %ebx
jmp 0x67b1
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x67fc
cmpl $0x0, 0x18(%rbx)
jne 0x67f5
decl %eax
movl %eax, (%r14)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x67bc
testq %rax, %rax
jne 0x67f9
movl (%r14), %eax
decl %eax
movl %eax, (%r14)
movq 0x8(%rbx), %rbx
jmp 0x67c8
xorl %ebx, %ebx
jmp 0x67fc
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movl (%rsi), %r13d
testl %r13d, %r13d
je 0x68d1
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jne 0x68d1
movq %rdx, %r14
movq %rsi, %r15
leal -0x1(%r13), %eax
movl %eax, (%rsi)
movq (%rbx), %rdi
callq 0x6808
testb %al, %al
je 0x687c
movq (%rbx), %r15
testq %r15, %r15
je 0x6852
movq %r15, %rdi
callq 0x4a1a
pushq $0x38
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4afe
movq %r15, (%rbx)
jmp 0x68d1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x68d1
decl (%r15)
movq %r15, %rsi
movq %r14, %rdx
callq 0x6808
testb %al, %al
je 0x68d1
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x68a8
movq %r15, %rdi
callq 0x4a1a
pushq $0x38
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4afe
movq %r15, 0x8(%rbx)
testl %r13d, %r13d
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x68e3
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rsp, -0x38(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movl 0x34(%rdi), %eax
movq %rsp, %r15
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
andl $0x0, -0x30(%rbp)
leaq 0x18(%rdi), %rax
movq %rdi, -0x40(%rbp)
movl 0x34(%rdi), %ecx
movl %esi, %r14d
movl %esi, %edx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x6969
movq (%rax), %rax
movb $0x0, (%r15,%rsi)
cmpq %rsi, %rdx
jne 0x6964
movq 0x10(%rax), %r12
incq %rsi
jmp 0x694e
xorl %eax, %eax
leaq -0x58(%rbp), %r13
leaq -0x2c(%rbp), %rbx
movl %eax, -0x2c(%rbp)
cmpl $0x2, %eax
jge 0x69d9
movq %r13, %rdi
movq %rbx, %rsi
callq 0x89fa
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x6973
movslq 0x10(%rax), %rbx
cmpb $0x0, (%r15,%rbx)
jne 0x69d1
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
leal 0x1(%rax), %edx
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
decl %edx
jne 0x69a9
movl %eax, -0x2c(%rbp)
movq 0x10(%rcx), %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %r12, %rcx
leaq -0x30(%rbp), %r8
movq %r15, %r9
callq 0x6a1a
movb $0x1, (%r15,%rbx)
movq %r13, %rdi
callq 0x8a06
movq -0x58(%rbp), %rax
cmpq %r13, %rax
jne 0x698d
movl -0x30(%rbp), %ebx
movq -0x38(%rbp), %rsp
leaq -0x58(%rbp), %rdi
callq 0x8d4a
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a05
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x8d4a
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r15
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x6a97
cmpl $0x0, 0x1c(%r15)
jne 0x6a97
movsd 0x20(%r15), %xmm0
addsd 0x3896(%rip), %xmm0     # 0xa2e8
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
js 0x6a9b
movl %eax, %ecx
cmpb $0x0, (%r12,%rcx)
jne 0x6a7b
leaq 0x4(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x89fa
movl (%r12), %eax
cmpl %ebp, %eax
jne 0x6a9b
movq 0x10(%r15), %rax
movl 0x4(%rax), %ecx
cmpl 0x4(%r14), %ecx
jne 0x6a93
movl (%rax), %eax
cmpl (%r14), %eax
je 0x6a9b
incl (%rbx)
jmp 0x6a9b
testl %eax, %eax
je 0x6aaa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
movq %r12, %r9
callq 0x6a1a
movq 0x8(%r15), %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
movq %r12, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a1a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6b51
cmpl $0x0, 0x1c(%rbx)
je 0x6b69
testl %eax, %eax
jne 0x6b9d
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6b36
movq 0x8(%rbx), %rbx
jmp 0x6b44
movsd 0x20(%rbx), %xmm0
addsd 0x3772(%rip), %xmm0     # 0xa2e8
cvttsd2si %xmm0, %eax
movq %r15, %rcx
movq (%rcx), %rcx
cmpq %r15, %rcx
je 0x6b9d
movq (%r14), %r14
cmpl %eax, 0x10(%rcx)
jne 0x6b7d
movl 0x10(%r14), %eax
addl $0x3, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6bd1
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x6ba4
movq 0x8(%r14), %r14
jmp 0x6baf
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movq %rdi, %rcx
movq (%rcx), %rcx
cmpq %rdi, %rcx
je 0x84c0
movq 0x10(%rcx), %rdx
addl 0x34(%rdx), %eax
jmp 0x84af
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x476f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x87ed
sqrtsd %xmm0, %xmm0
jmp 0x87f2
callq 0x2150
mulsd 0x1b3e(%rip), %xmm0     # 0xa338
movsd %xmm0, (%rsp)
callq 0x476f
mulsd 0x1824(%rip), %xmm0     # 0xa030
movsd %xmm0, 0x8(%rsp)
callq 0x2350
mulsd (%rsp), %xmm0
movsd %xmm0, 0x68(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x2060
mulsd (%rsp), %xmm0
movsd %xmm0, 0x70(%rbx)
movupd 0x68(%rbx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x1899(%rip), %xmm1     # 0xa0e0
mulpd 0x18a1(%rip), %xmm1     # 0xa0f0
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x78(%rdi), %rcx
movq 0x80(%rdi), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x8883
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
jmp 0x886f
andq $0x0, 0x60(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movslq 0x4c(%rdi), %rax
imulq $0xa0, %rax, %rax
movslq 0x48(%rdi), %rcx
addq %rax, %rcx
imulq $0x18, %rcx, %rax
addq %rsi, %rax
movq %rax, %r15
movq (%r15), %r15
cmpq %rax, %r15
je 0x8935
movq 0x10(%r15), %rdi
cmpq %r14, (%rdi)
jne 0x88f3
pushq $0x10
popq %rsi
callq 0x2200
movslq 0x4c(%r14), %rax
imulq $0xa0, %rax, %rax
movslq 0x48(%r14), %rcx
addq %rax, %rcx
imulq $0x18, %rcx, %rax
addq %rax, %rbx
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x8d3c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8967
movl 0x4c(%r14), %r15d
cmpl %r15d, 0x4(%rdx)
jne 0x896b
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 0x88cc
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 0x888a
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2940
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rsi
callq 0x290a
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x290a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2942
retq
nop