LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/usefcnptr.cc
// Function: min_element(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>)
int min_element(vector<int>::iterator beg, 
                vector<int>::iterator end) {
    int minVal = 0;
    while (beg != end) {
        if (minVal > *beg)
            minVal = *beg;
        ++beg;
    }
    return minVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1550
testb $0x1, %al
jne 0x142a
jmp 0x145c
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1590
movq %rax, %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jle 0x1451
leaq -0x8(%rbp), %rdi
callq 0x1590
movl (%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x15b0
jmp 0x1417
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/flip.cc
// Function: main
int main()
{
	int i = 0, j = 0, k = 0, l = 0;
	cout << i << " " << j << " " << k << " " << l << endl;

	f(42, i);        // f changes its argument i
	flip1(f, j, 42); // f called through flip1 leaves j unchanged
	flip2(f, k, 42); // ok: k is changed
	g(1, i);
	flip(g, i, 42);  // ok: rvalue-ness of the third argument is preserved
	cout << i << " " << j << " " << k << " " << l << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %esi
movq 0x2d23(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xd40(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xd26(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xd0c(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2cb6(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x2a, %edi
leaq -0x8(%rbp), %rsi
callq 0x11c0
movl -0xc(%rbp), %esi
leaq -0x16f(%rip), %rdi      # 0x11c0
movl $0x2a, %edx
callq 0x1400
movl $0x2a, -0x18(%rbp)
leaq -0x187(%rip), %rdi      # 0x11c0
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1430
movl $0x1, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x1220
movl $0x2a, -0x20(%rbp)
leaq -0x156(%rip), %rdi      # 0x1220
leaq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1460
movl -0x8(%rbp), %esi
movq 0x2c4b(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xc68(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xc4e(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xc34(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2bde(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::cummulative_distribution(std::vector<double, std::allocator<double>>&)
void cummulative_distribution(Table &cdf){
            for(size_t i = 0; i < bincount; i++){
                if(i == 0) cdf[i] = pmf[i];
                else{
                    cdf[i] = cdf[i-1] + pmf[i];
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x78(%rcx), %rax
jae 0x4555
cmpq $0x0, -0x18(%rbp)
jne 0x44f7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b70
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b70
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x4542
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x3b70
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3b70
movsd -0x38(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b70
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x4544
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x44b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::cramer_von_mises(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double cramer_von_mises(const Table &cdf, const Table &edf){
            double sum = 0.0;
            for(size_t i = 0; i < bincount; i++){
                sum += (edf[i] - cdf[i]) * (edf[i] - cdf[i]);
            }
            return sqrt(sum / bincount);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x78(%rcx), %rax
jae 0x4a83
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8ed0
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8ed0
movsd -0x48(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8ed0
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8ed0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm0
subsd (%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x49ec
movq -0x30(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movq 0x78(%rax), %xmm1
movaps 0x65f8(%rip), %xmm2     # 0xb090
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x65fc(%rip), %xmm2     # 0xb0a0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x20c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::simple_sas(int, std::vector<double, std::allocator<double>>&, int)
void simple_sas(int samplecount, Table &samples, int from = 0){
                
                double steps = double(bincount) / samplecount;
                //double r = _random(0.0, steps);
                double r = steps * (1.0 - __random(gen));
                double x =  bincount - r;
                int i = from;

                int to = from + samplecount;
                while(i < to){
                  //  int ri = int(x);
                   // int rf  = x  -ri;
                    samples[i] = aliassample(int(x), x- int(x));
                    x -= steps;
                    i++;
                }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x78(%rax), %xmm0
movaps 0x64d3(%rip), %xmm1     # 0xb090
movaps %xmm1, -0x70(%rbp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x64d3(%rip), %xmm1     # 0xb0a0
movaps %xmm1, -0x60(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq 0xdc59(%rip), %rdi      # 0x12858
leaq 0xc8ca(%rip), %rsi      # 0x114d0
callq 0x4560
movq -0x78(%rbp), %rax
movaps -0x70(%rbp), %xmm2
movaps -0x60(%rbp), %xmm1
movaps %xmm0, %xmm4
movsd -0x48(%rbp), %xmm0
movsd 0x63e1(%rip), %xmm3     # 0xb008
subsd %xmm4, %xmm3
mulsd %xmm3, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x78(%rax), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x4cc6
movq -0x78(%rbp), %rdi
cvttsd2si -0x38(%rbp), %esi
movsd -0x38(%rbp), %xmm0
cvttsd2si -0x38(%rbp), %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
callq 0x4cd0
movsd %xmm0, -0x80(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x3b70
movsd -0x80(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4c65
addq $0x80, %rsp
popq %rbp
retq
nop
// File: bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::aliassample(int, double)
double aliassample(int intpart, double fracpart){
            
            if(fracpart <= aliasprobabilities[intpart]){
                return aliasvalue[intpart];
                
                //return values[intpart];
            }else{
                return values[intpart];
                //return aliasvalue[intpart];
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x60, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3b70
movsd -0x28(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4d2e
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3b70
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4d48
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3b70
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::normalize()
bool normalize(){ 
            double sum = 0.0;
            for(auto p: pmf) sum += p; //get the sum for array
            for(auto &p: pmf) p = p / sum; //normalize the array
            sum = 0.0;
            for(auto p:pmf) sum += p;
            return (fabs(sum - 1.0) < 1e-6); //make sure the sum is close to 1.0
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4620
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4650
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6050
testb $0x1, %al
jne 0x5db0
jmp 0x5ddc
leaq -0x20(%rbp), %rdi
callq 0x6090
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x60b0
jmp 0x5d9d
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4620
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4650
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6050
testb $0x1, %al
jne 0x5e11
jmp 0x5e3e
leaq -0x40(%rbp), %rdi
callq 0x6090
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movsd (%rax), %xmm0
divsd -0x10(%rbp), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x60b0
jmp 0x5dfe
movq -0x78(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x4620
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x4650
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6050
testb $0x1, %al
jne 0x5e7b
jmp 0x5ea7
leaq -0x60(%rbp), %rdi
callq 0x6090
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x60b0
jmp 0x5e68
movsd -0x10(%rbp), %xmm1
movsd 0x5154(%rip), %xmm0     # 0xb008
subsd %xmm0, %xmm1
movaps 0x51c1(%rip), %xmm0     # 0xb080
pand %xmm0, %xmm1
movsd 0x517d(%rip), %xmm0     # 0xb048
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: gibsjose[P]VirtualMemorySimulation/Simulation.cpp
// Function: main
int main(int argc, char **argv) {
    Simulation simulation;

    std::cout << "Virtual Memory Simulation" << std::endl;

    //Get the input file from the user
    std::string filepath;
    std::cout << "Input file: ";
    std::cin >> filepath;

    //Remove whitespace/newlines
    StringUtilities::Trim(filepath);

    simulation.SetInputFilepath(filepath);
    simulation.Run();

    std::cout << std::endl << "Simulation Complete:" << std::endl;

    simulation.DisplayStatistics();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x4940
movq 0x181e3(%rip), %rdi     # 0x1bfc8
leaq 0xe27a(%rip), %rsi      # 0x12066
callq 0x3230
movq %rax, -0x1b8(%rbp)
jmp 0x3dfa
movq -0x1b8(%rbp), %rdi
movq 0x181b0(%rip), %rsi     # 0x1bfb8
callq 0x3280
jmp 0x3e0f
leaq -0x170(%rbp), %rdi
callq 0x3360
movq 0x181a6(%rip), %rdi     # 0x1bfc8
leaq 0xe257(%rip), %rsi      # 0x12080
callq 0x3230
jmp 0x3e30
movq 0x181a1(%rip), %rdi     # 0x1bfd8
leaq -0x170(%rbp), %rsi
callq 0x3320
jmp 0x3e45
leaq -0x1b0(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x30f0
jmp 0x3e5a
leaq -0x190(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x49b0
jmp 0x3e6f
leaq -0x190(%rbp), %rdi
callq 0x3170
leaq -0x1b0(%rbp), %rdi
callq 0x3170
leaq -0x140(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x3fa0
jmp 0x3e9c
leaq -0x140(%rbp), %rdi
callq 0x3fd0
jmp 0x3eaa
movq 0x18117(%rip), %rdi     # 0x1bfc8
movq 0x18100(%rip), %rsi     # 0x1bfb8
callq 0x3280
movq %rax, -0x1c0(%rbp)
jmp 0x3ec6
movq -0x1c0(%rbp), %rdi
leaq 0xe1b9(%rip), %rsi      # 0x1208d
callq 0x3230
movq %rax, -0x1c8(%rbp)
jmp 0x3ee2
movq -0x1c8(%rbp), %rdi
movq 0x180c8(%rip), %rsi     # 0x1bfb8
callq 0x3280
jmp 0x3ef7
leaq -0x140(%rbp), %rdi
callq 0x4670
jmp 0x3f05
leaq -0x170(%rbp), %rdi
callq 0x3170
leaq -0x140(%rbp), %rdi
callq 0x4a50
xorl %eax, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
jmp 0x3f7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
jmp 0x3f6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x3170
leaq -0x170(%rbp), %rdi
callq 0x3170
leaq -0x140(%rbp), %rdi
callq 0x4a50
movq -0x148(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: gibsjose[P]VirtualMemorySimulation/./Memory.h
// Function: Memory::Memory()
Memory(void) {
        ram.clear();
        available.clear();
        free.clear();
        lru.clear();

        //Generate 16 available frames
        for(int i = 0; i < (MEM_SIZE / FRAME_SIZE); i++) {
            available.insert(i);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x5b30
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
callq 0x5b30
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x48(%rbp)
callq 0x5b30
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x38(%rbp)
callq 0x5b50
jmp 0x5938
movq -0x58(%rbp), %rdi
callq 0x5b70
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
callq 0x5b70
movq -0x58(%rbp), %rdi
addq $0x60, %rdi
callq 0x5b70
movq -0x58(%rbp), %rdi
addq $0x90, %rdi
callq 0x5b90
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x10, %rax
jae 0x59dc
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movw -0x18(%rbp), %ax
movw %ax, -0x1a(%rbp)
leaq -0x1a(%rbp), %rsi
callq 0x5bd0
movb %dl, -0x61(%rbp)
movq %rax, -0x60(%rbp)
jmp 0x599e
movb -0x61(%rbp), %al
movq -0x60(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movb %al, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5972
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x59e2
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5c20
jmp 0x59e2
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5c80
movq -0x50(%rbp), %rdi
callq 0x5c80
movq -0x40(%rbp), %rdi
callq 0x5c80
movq -0x10(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: gibsjose[P]VirtualMemorySimulation/Memory.cpp
// Function: Memory::GetFreeFrame()
uint16_t Memory::GetFreeFrame(void) {
    if(available.empty()) {
        std::cerr << Color::Red("Error: GetFreeFrame: No available frames") << std::endl;
        return INVALID_FRAME;
    }

    //Get and remove the first available frame
    uint16_t frame = *(available.begin());
    available.erase(available.begin());

    return frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x30, %rdi
callq 0xe8e0
testb $0x1, %al
jne 0xe2cc
jmp 0xe39d
leaq -0x51(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3440
movq -0x90(%rbp), %rdx
leaq 0x4028(%rip), %rsi      # 0x12312
leaq -0x50(%rbp), %rdi
callq 0x4de0
jmp 0xe2f5
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xe530
jmp 0xe304
movq 0xdce5(%rip), %rdi      # 0x1bff0
leaq -0x30(%rbp), %rsi
callq 0x3220
movq %rax, -0x98(%rbp)
jmp 0xe31d
movq -0x98(%rbp), %rdi
movq 0xdc8d(%rip), %rsi      # 0x1bfb8
callq 0x3280
jmp 0xe332
leaq -0x30(%rbp), %rdi
callq 0x3170
leaq -0x50(%rbp), %rdi
callq 0x3170
leaq -0x51(%rbp), %rdi
callq 0x32a0
movw $0x10, -0x2(%rbp)
jmp 0xe3ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xe392
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xe389
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3170
leaq -0x50(%rbp), %rdi
callq 0x3170
leaq -0x51(%rbp), %rdi
callq 0x32a0
jmp 0xe40c
movq -0x88(%rbp), %rdi
addq $0x30, %rdi
callq 0xe900
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe930
movq -0x88(%rbp), %rdi
movw (%rax), %ax
movw %ax, -0x66(%rbp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0xa0(%rbp)
addq $0x30, %rdi
callq 0xe900
movq -0xa0(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
callq 0xe810
movq %rax, -0x80(%rbp)
movw -0x66(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: gibsjose[P]VirtualMemorySimulation/Memory.cpp
// Function: Memory::AvailableToRAM(unsigned short)
void Memory::AvailableToRAM(const uint16_t frame) {
    //Make sure it does not exist in the available list
    if(available.count(frame)) {
        available.erase(available.find(frame));
    }

    ram.insert(frame);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x30, %rdi
leaq -0xa(%rbp), %rsi
callq 0xe7b0
cmpq $0x0, %rax
je 0xe47f
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
leaq -0xa(%rbp), %rsi
callq 0xe850
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0xe810
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
leaq -0xa(%rbp), %rsi
callq 0xe890
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gibsjose[P]VirtualMemorySimulation/Memory.cpp
// Function: Memory::SelectVictim()
uint16_t Memory::SelectVictim(void) {
    //LRU entry
    LRUEntry entry;

    //Get the least recently used entry
    entry = lru.back();
    lru.pop_back();

    //Remove the page table entry from whichever process owned the frame being replaced
    entry.process->GetPageTable().RemoveEntry(entry.page);

    //Return the now available frame
    return entry.frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x90, %rdi
callq 0xe710
movq -0x20(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x90, %rdi
callq 0xe750
movq -0x18(%rbp), %rdi
callq 0xe500
movq %rax, %rdi
movzwl -0x10(%rbp), %esi
callq 0x10550
movw -0xe(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::Process()
Process::Process(void) {
    name.clear();
    references = 0;
    pageFaults = 0;
    size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x3360
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0xfd50
jmp 0xf92f
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0x5b30
movq -0x28(%rbp), %rdi
callq 0x3340
movq -0x28(%rbp), %rax
movw $0x0, 0x20(%rax)
movw $0x0, 0x22(%rax)
movw $0x0, 0x24(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3170
movq -0x10(%rbp), %rdi
callq 0x3430
nop
// File: gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::Process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Process::Process(const std::string & name) {
    this->name = name;
    references = 0;
    pageFaults = 0;
    size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x3360
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0xfd50
jmp 0xf9b7
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5b30
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3040
jmp 0xf9d7
movq -0x38(%rbp), %rax
movw $0x0, 0x20(%rax)
movw $0x0, 0x22(%rax)
movw $0x0, 0x24(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xfa1f
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5c80
movq -0x28(%rbp), %rdi
callq 0xb000
movq -0x30(%rbp), %rdi
callq 0x3170
movq -0x18(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::PageAccess(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
uint16_t Process::PageAccess(const std::string & string) {
    //Decode the string into the page number
    uint16_t page = DecodePageNumber(string);

    //Add the referenced page number to the set
    pages.insert(page);

    //Determine the range of the page set (this is the size...)
    size = ComputeSize();

    //Increment number of references
    references++;

    return page;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xfab0
movq -0x30(%rbp), %rdi
movw %ax, -0x12(%rbp)
addq $0x68, %rdi
leaq -0x12(%rbp), %rsi
callq 0xe890
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
callq 0xfae0
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x24(%rax)
movw 0x20(%rax), %cx
addw $0x1, %cx
movw %cx, 0x20(%rax)
movw -0x12(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::DisplayStatistics()
void Process::DisplayStatistics(void) {
    std::cout << std::endl;
    std::cout << "Process: \"" << name << "\"" << std::endl;
    std::cout << "-------------------------" << std::endl;
    std::cout << "Memory References: " << references << std::endl;
    std::cout << "Page Faults: " << pageFaults << std::endl;
    std::cout << "Size in Pages: " << size << std::endl;
    std::cout << "Fault Rate: " << ((float)pageFaults / (float)references) * 100.0 << "%" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xc48d(%rip), %rdi      # 0x1bfc8
movq %rdi, -0x18(%rbp)
movq 0xc472(%rip), %rsi      # 0x1bfb8
movq %rsi, -0x20(%rbp)
callq 0x3280
movq -0x18(%rbp), %rdi
leaq 0x281e(%rip), %rsi      # 0x12378
callq 0x3230
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
leaq 0x280c(%rip), %rsi      # 0x12381
callq 0x3230
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x3280
movq -0x18(%rbp), %rdi
leaq 0x27f2(%rip), %rsi      # 0x12383
callq 0x3230
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x3280
movq -0x18(%rbp), %rdi
leaq 0x27f0(%rip), %rsi      # 0x1239d
callq 0x3230
movq %rax, %rdi
movq -0x10(%rbp), %rax
movzwl 0x20(%rax), %esi
callq 0x3410
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x3280
movq -0x18(%rbp), %rdi
leaq 0x27d8(%rip), %rsi      # 0x123b1
callq 0x3230
movq %rax, %rdi
movq -0x10(%rbp), %rax
movzwl 0x22(%rax), %esi
callq 0x3410
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x3280
movq -0x18(%rbp), %rdi
leaq 0x27ba(%rip), %rsi      # 0x123bf
callq 0x3230
movq %rax, %rdi
movq -0x10(%rbp), %rax
movzwl 0x24(%rax), %esi
callq 0x3410
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x3280
movq -0x18(%rbp), %rdi
leaq 0x279e(%rip), %rsi      # 0x123cf
callq 0x3230
movq %rax, %rdi
movq -0x10(%rbp), %rax
movzwl 0x22(%rax), %ecx
cvtsi2ss %ecx, %xmm0
movzwl 0x20(%rax), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2713(%rip), %xmm1     # 0x12370
mulsd %xmm1, %xmm0
callq 0x3460
movq %rax, %rdi
leaq 0x276c(%rip), %rsi      # 0x123dc
callq 0x3230
movq %rax, %rdi
movq 0xc339(%rip), %rsi      # 0x1bfb8
callq 0x3280
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::PageTable()
PageTable::PageTable(void) {
    //Initialize an invalid page table entry to return if needed
    invalid.frame = 0;
    invalid.ref = false;
    invalid.dirty = false;
    invalid.valid = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x105e0
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0xe5e0
jmp 0x103ef
movq -0x28(%rbp), %rax
movw $0x0, 0x38(%rax)
movb $0x0, 0x3a(%rax)
movb $0x0, 0x3b(%rax)
movb $0x0, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xb040
movq -0x10(%rbp), %rdi
callq 0x3430
nopl (%rax)
// File: gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::EntryExists(unsigned short)
bool PageTable::EntryExists(const uint16_t page) {
    //Return true if the page entry exists AND is valid
    if(table.count(page)) {
        if(table[page].valid) {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x10600
cmpq $0x0, %rax
je 0x104e5
movq -0x20(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x10630
testb $0x1, 0x4(%rax)
je 0x104e3
movb $0x1, -0x1(%rbp)
jmp 0x104e9
jmp 0x104e5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::GetEntry(unsigned short)
PageTableEntry & PageTable::GetEntry(const uint16_t page) {
    //Returns the entry associated with the page, if it exists
    if(table.count(page)) {
        return table[page];
    } else {
        return invalid;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x10600
cmpq $0x0, %rax
je 0x105bd
movq -0x20(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x10630
movq %rax, -0x8(%rbp)
jmp 0x105c9
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Slexis-Works[P]texture-packing/texture-packing.cpp
// Function: showUsage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void showUsage(const std::string name) {
	std::cerr << "Utilisation : " << std::endl
			<< name << " --help" << std::endl
			<< "Affiche plus de détails" << std::endl
			<< name << " [--seed nombre] [--tmin tailleMin] [--tmax tailleMax] [--lt largeurTexture] [--ht hauteurTexture] [--sortie nomDossier] [--tests nombre] [algorithme(s)]" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x14f39(%rip), %rdi     # 0x1bff0
leaq 0xc613(%rip), %rsi      # 0x136d1
callq 0x3270
movq %rax, %rdi
movq 0x14eeb(%rip), %rsi     # 0x1bfb8
callq 0x32b0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
leaq 0xc5f8(%rip), %rsi      # 0x136e0
callq 0x3270
movq %rax, %rdi
movq 0x14ec1(%rip), %rsi     # 0x1bfb8
callq 0x32b0
movq %rax, %rdi
leaq 0xc5e2(%rip), %rsi      # 0x136e8
callq 0x3270
movq %rax, %rdi
movq 0x14ea3(%rip), %rsi     # 0x1bfb8
callq 0x32b0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
leaq 0xc5d1(%rip), %rsi      # 0x13701
callq 0x3270
movq %rax, %rdi
movq 0x14e79(%rip), %rsi     # 0x1bfb8
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: samuel500[P]NEAT/species.cpp
// Function: Species::get_avg_fitness() const
double Species::get_avg_fitness() const {

	vector<Individual*>::const_iterator indPtr;

	double avg_fitness = 0.;

	for(indPtr=members.begin(); indPtr!=members.end(); indPtr++){

		avg_fitness += (*indPtr)->adjusted_fitness;
	}

	return avg_fitness;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xe0a0
movq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0xbbc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
callq 0xbbf0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe0c0
testb $0x1, %al
jne 0xd64a
jmp 0xd676
leaq -0x10(%rbp), %rdi
callq 0xe100
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xe120
movq %rax, -0x30(%rbp)
jmp 0xd62a
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: samuel500[P]NEAT/species.cpp
// Function: Species::calc_n_offspring()
int Species::calc_n_offspring(){
	vector<Individual*>::iterator indPtr;

	n_offspring = 0;

	double double_offspring = 0.;

	for(indPtr=members.begin(); indPtr!=members.end(); indPtr++){

		double_offspring += (*indPtr)->est_n_offspring;
	}

	n_offspring = (int) floor(double_offspring);

	return n_offspring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x41f0
movq -0x38(%rbp), %rdi
movl $0x0, 0x40(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x4210
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4280
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4240
testb $0x1, %al
jne 0xd741
jmp 0xd76d
leaq -0x10(%rbp), %rdi
callq 0x42b0
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xe060
movq %rax, -0x30(%rbp)
jmp 0xd721
movsd -0x18(%rbp), %xmm0
callq 0x1150
movq -0x38(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x40(%rax)
movl 0x40(%rax), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: samuel500[P]NEAT/species.cpp
// Function: Species::~Species()
Species::~Species(){

	vector<Individual*>::iterator indPtr;

	rep = NULL;

	for(indPtr=members.begin(); indPtr!=members.end(); indPtr++){

	 	*indPtr = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x41f0
movq -0x30(%rbp), %rdi
movq $0x0, 0x18(%rdi)
callq 0x4210
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4280
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4240
testb $0x1, %al
jne 0xdcea
jmp 0xdd0b
leaq -0x10(%rbp), %rdi
callq 0x42b0
movq $0x0, (%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xe060
movq %rax, -0x28(%rbp)
jmp 0xdcca
movq -0x30(%rbp), %rdi
callq 0x3f30
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: samuel500[P]NEAT/individual.cpp
// Function: Individual::get_outputs()
vector<double> Individual::get_outputs(){
	
	vector<double> out;

	vector<Node*>::iterator nodePtr;
	for(nodePtr=outputs.begin(); nodePtr != outputs.end(); ++nodePtr){

		out.push_back((*nodePtr)->firing);

	}
	return out;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x12c30
leaq -0x20(%rbp), %rdi
callq 0x39b0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x3a40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x3ab0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3a70
testb $0x1, %al
jne 0x11e62
jmp 0x11ea1
leaq -0x20(%rbp), %rdi
callq 0x3b50
movq -0x58(%rbp), %rdi
movq (%rax), %rsi
addq $0x10, %rsi
callq 0x12c50
jmp 0x11e7d
jmp 0x11e7f
leaq -0x20(%rbp), %rdi
callq 0x3b70
jmp 0x11e3e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3d40
jmp 0x11ebe
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x11eb4
movq -0x58(%rbp), %rdi
callq 0x3d40
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1180
nopw (%rax,%rax)
// File: samuel500[P]NEAT/individual.cpp
// Function: Individual::mutate(std::vector<Node*, std::allocator<Node*>>*, std::vector<Connection*, std::allocator<Connection*>>*)
void Individual::mutate(vector<Node*> *all_nodes, vector<Connection*> *all_connections){

	if(randdouble(0.,1.)<0.8){
		// cout << "mu1" <<endl;
		mutate_weights();
	}
	if(randdouble(0.,1.)<0.03){
		// cout << "mu2" <<endl;

		mutate_add_node(all_nodes, all_connections);
	}
	if(randdouble(0.,1.)<0.05){
		// cout << "mu3" <<endl;

		mutate_add_connection(all_nodes, all_connections);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd 0x30e1(%rip), %xmm1     # 0x15058
callq 0x12cc0
movaps %xmm0, %xmm1
movsd 0x32d1(%rip), %xmm0     # 0x15258
ucomisd %xmm1, %xmm0
jbe 0x11f96
movq -0x20(%rbp), %rdi
callq 0x12000
xorps %xmm0, %xmm0
movsd 0x30b7(%rip), %xmm1     # 0x15058
callq 0x12cc0
movaps %xmm0, %xmm1
movsd 0x32af(%rip), %xmm0     # 0x15260
ucomisd %xmm1, %xmm0
jbe 0x11fc8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x120b0
xorps %xmm0, %xmm0
movsd 0x3085(%rip), %xmm1     # 0x15058
callq 0x12cc0
movaps %xmm0, %xmm1
movsd 0x3285(%rip), %xmm0     # 0x15268
ucomisd %xmm1, %xmm0
jbe 0x11ffa
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12570
addq $0x20, %rsp
popq %rbp
retq
// File: samuel500[P]NEAT/individual.cpp
// Function: Individual::mutate_weights()
void Individual::mutate_weights(){
	vector<Connection*>::iterator conPtr;

	for(conPtr=connections.begin(); conPtr != connections.end(); ++conPtr){

		// uniform perturbation
		if(randdouble(0.,1.)>0.1){
			(*conPtr)->perturb_weight();
		}
		// assign new random value
		else{
			(*conPtr)->reset_weight();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1800
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
callq 0x1820
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
callq 0x1890
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1850
testb $0x1, %al
jne 0x1205a
jmp 0x120a9
xorps %xmm0, %xmm0
movsd 0x2ff3(%rip), %xmm1     # 0x15058
callq 0x12cc0
movsd 0x3206(%rip), %xmm1     # 0x15278
ucomisd %xmm1, %xmm0
jbe 0x1208b
leaq -0x10(%rbp), %rdi
callq 0x18c0
movq (%rax), %rdi
callq 0x13cb0
jmp 0x1209c
leaq -0x10(%rbp), %rdi
callq 0x18c0
movq (%rax), %rdi
callq 0x13c70
jmp 0x1209e
leaq -0x10(%rbp), %rdi
callq 0x18e0
jmp 0x12036
addq $0x30, %rsp
popq %rbp
retq
nop
// File: samuel500[P]NEAT/individual.cpp
// Function: Individual::~Individual()
Individual::~Individual(){

	vector<Node*>::iterator curNode;
	vector<Connection*>::iterator curCon;

	for(curNode=nodes.begin(); curNode!=nodes.end(); ++curNode){
		delete *curNode;
	}

	for(curCon=connections.begin(); curCon!=connections.end(); ++curCon){
		delete *curCon;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x39b0
leaq -0x18(%rbp), %rdi
callq 0x1800
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x3a40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x3ab0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3a70
testb $0x1, %al
jne 0x12953
jmp 0x1298d
leaq -0x10(%rbp), %rdi
callq 0x3b50
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x12980
movq -0x48(%rbp), %rdi
callq 0x13ae0
movq -0x48(%rbp), %rdi
movl $0x48, %esi
callq 0x10f0
jmp 0x12982
leaq -0x10(%rbp), %rdi
callq 0x3b70
jmp 0x1292f
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x1820
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x1890
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1850
testb $0x1, %al
jne 0x129ca
jmp 0x12a04
leaq -0x18(%rbp), %rdi
callq 0x18c0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x129f7
movq -0x50(%rbp), %rdi
callq 0x13d40
movq -0x50(%rbp), %rdi
movl $0x28, %esi
callq 0x10f0
jmp 0x129f9
leaq -0x18(%rbp), %rdi
callq 0x18e0
jmp 0x129a6
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x3e70
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x3ed0
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x3ed0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x3ed0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: samuel500[P]NEAT/node.cpp
// Function: Node::activate()
bool Node::activate(){

	firing = 0.;

	vector<Connection*>::iterator conPtr;

	bool any_active_input_con = false;
	bool any_active_input_node = false;
	for(conPtr=in_connections.begin(); conPtr != in_connections.end(); ++conPtr){

		if((*conPtr)->is_active){
			any_active_input_con = true;
			if(((*conPtr)->in_node->activated)){
				any_active_input_node = true;
			// 	return false;
			}
		}
	}
	if(!any_active_input_con){
		// cout << "node not activated" <<endl;
		return false; 
	}

	for(conPtr=in_connections.begin(); conPtr != in_connections.end(); ++conPtr){

		firing += (*conPtr)->in_node->firing * (*conPtr)->weight;
	}
	
	if(any_active_input_node){
		firing = sigmoid(firing);
		activated = true;

	}


	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
leaq -0x18(%rbp), %rdi
callq 0x1800
movq -0x48(%rbp), %rdi
movb $0x0, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
addq $0x18, %rdi
callq 0x1820
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x1890
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1850
testb $0x1, %al
jne 0x1397a
jmp 0x139b8
leaq -0x18(%rbp), %rdi
callq 0x18c0
movq (%rax), %rax
testb $0x1, 0x18(%rax)
je 0x139ab
movb $0x1, -0x19(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x18c0
movq (%rax), %rax
movq (%rax), %rax
testb $0x1, 0xc(%rax)
je 0x139a9
movb $0x1, -0x1a(%rbp)
jmp 0x139ab
jmp 0x139ad
leaq -0x18(%rbp), %rdi
callq 0x18e0
jmp 0x13956
testb $0x1, -0x19(%rbp)
jne 0x139c7
movb $0x0, -0x1(%rbp)
jmp 0x13a7c
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x1820
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x1890
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1850
testb $0x1, %al
jne 0x13a04
jmp 0x13a57
leaq -0x18(%rbp), %rdi
callq 0x18c0
movq (%rax), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x18c0
movsd -0x50(%rbp), %xmm0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movsd 0x10(%rcx), %xmm2
movsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
leaq -0x18(%rbp), %rdi
callq 0x18e0
jmp 0x139e0
testb $0x1, -0x1a(%rbp)
je 0x13a78
movq -0x48(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x137e0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movb $0x1, 0xc(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: samuel500[P]NEAT/connection.cpp
// Function: Connection::Connection(Node*, Node*, int, int)
Connection::Connection(Node *inode, Node *onode, int hist_marking, int creation_gen): hist_marking(hist_marking), creation_gen(creation_gen){

	in_node = new Node;
	in_node = inode;

	out_node = new Node;
	out_node = onode;

	is_active = true;

	in_node->out_connections.push_back(this);
	out_node->in_connections.push_back(this);

	weight = randdouble(-1., 1.);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl $0x48, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x13840
jmp 0x13b6a
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl $0x48, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x13840
jmp 0x13b97
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x18(%rax)
movq (%rax), %rdi
addq $0x30, %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x13d60
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rdi
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x13d60
movsd 0x16e4(%rip), %xmm0     # 0x152c8
movsd 0x146c(%rip), %xmm1     # 0x15058
callq 0x12cc0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x48, %esi
callq 0x10f0
jmp 0x13c36
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x48, %esi
callq 0x10f0
movq -0x28(%rbp), %rdi
callq 0x1180
nop
// File: Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: Socket::Socket()
Socket::Socket() {
    my_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (my_socket == INVALID_SOCKET) {
        error_code = ErrorCode::CREATE_ERROR;
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x22ebd(%rip), %rcx     # 0x27848
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x34(%rax)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x40a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $-0x1, 0x8(%rax)
jne 0x49c4
movq -0x10(%rbp), %rax
movl $0x1, 0x34(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Bind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ServerSocket::Bind(std::string ip_address, int port) {
    if (IsInvalid()) return -2;
    memset(&my_address, 0, sizeof(my_address));
    my_address.sin_family = AF_INET;
    my_address.sin_port = htons(port);
    my_address.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(my_socket, (struct sockaddr*)&my_address, sizeof(my_address)) == -1) {
        error_code = ErrorCode::BIND_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x50e0
testb $0x1, %al
jne 0x4a36
jmp 0x4a3f
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x4ab2
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x41b0
movq -0x28(%rbp), %rax
movw $0x2, 0xc(%rax)
movl -0x1c(%rbp), %eax
movzwl %ax, %edi
callq 0x4050
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0xe(%rax)
xorl %edi, %edi
callq 0x4230
movq -0x28(%rbp), %rsi
movl %eax, 0x10(%rsi)
movl 0x8(%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x4060
cmpl $-0x1, %eax
jne 0x4aab
movq -0x28(%rbp), %rax
movl $0x2, 0x34(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ab2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Listen(int)
int ServerSocket::Listen(int backlog) {
    if (IsInvalid()) return -2;
    if (listen(my_socket, backlog) == SOCKET_ERROR) {
        error_code = ErrorCode::LISTEN_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x50e0
testb $0x1, %al
jne 0x4ae2
jmp 0x4aeb
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x4b1a
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movl -0x14(%rbp), %esi
callq 0x4350
cmpl $-0x1, %eax
jne 0x4b13
movq -0x20(%rbp), %rax
movl $0x3, 0x34(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4b1a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Accept()
int ServerSocket::Accept() {
#ifdef _WIN32
    your_socket = accept(my_socket, (struct sockaddr*)&your_address, (int *)&your_address_size);
#else
    your_socket = accept(my_socket, (struct sockaddr*)&your_address, &your_address_size);
#endif
    if (your_socket == INVALID_SOCKET) {
        error_code = ErrorCode::ACCEPT_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x18(%rbp)
movl 0x8(%rdx), %edi
movq %rdx, %rsi
addq $0x20, %rsi
addq $0x30, %rdx
callq 0x40e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
cmpl $-0x1, 0x1c(%rax)
jne 0x4b7a
movq -0x18(%rbp), %rax
movl $0x4, 0x34(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4b81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)