LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: convertRADecToAzEl(float, float, Mat4<float> const&)
std::pair<float, float> convertRADecToAzEl(float ra, float dec, const Mat4F &matEquToHor)
{
    const Vec4F dirEquatorial = dirRADec(ra, dec);
    const Vec4F dirHorizontal = matEquToHor * dirEquatorial;
    const float x = dirHorizontal.x;//for East
    const float y = dirHorizontal.y;//for Zenith
    const float z = dirHorizontal.z;//for South
    const float az = std::atan2(-x, z);
    const float el = std::asin(y);

    return {az*RAD2DEG, el*RAD2DEG};
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movss %xmm1, (%rsp)
movss %xmm0, 0x10(%rsp)
movaps %xmm1, %xmm0
callq 0x4210
movss %xmm0, 0x20(%rsp)
movss 0x10(%rsp), %xmm0
callq 0x4270
mulss 0x20(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movss (%rsp), %xmm0
callq 0x4270
movaps %xmm0, 0x30(%rsp)
movss (%rsp), %xmm0
callq 0x4210
movss %xmm0, (%rsp)
movss 0x10(%rsp), %xmm0
callq 0x4210
mulss (%rsp), %xmm0
movaps 0x20(%rsp), %xmm2
unpcklps 0x30(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
movaps 0x6785(%rip), %xmm1     # 0xd1a0
movss %xmm0, %xmm1            # xmm1 = xmm0[0],xmm1[1,2,3]
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
leaq 0x40(%rsp), %rsi
movups %xmm2, (%rsi)
movq %rbx, %rdi
callq 0x9db3
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm2, 0x10(%rsp)
xorps 0x676b(%rip), %xmm0     # 0xd1b0
callq 0x43c0
movaps %xmm0, (%rsp)
movaps 0x10(%rsp), %xmm0
callq 0x4480
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtps2pd %xmm1, %xmm0
mulpd 0x6756(%rip), %xmm0     # 0xd1c0
cvtpd2ps %xmm0, %xmm0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: convertUnixSecondsToGreenwichMeanSiderealTime(double)
double convertUnixSecondsToGreenwichMeanSiderealTime(double unixSeconds)
{
    ///@todo validation
    ///@todo add leap seconds
    const double jd00 = unixSeconds / SEC24H + (2440587.5 - 2451545.0); //2440587.5=Unix Epoch(in JD), 2451545.0=J2000.0(in JD)
    const double t = jd00 / 36525.0; //36525.0=Days per Julian century
    const double f = SEC24H * std::fmod(jd00, 1.0);
    const double A = 24110.54841  -  SEC24H / 2.0;
    const double B = 8640184.812866;
    const double C = 0.093104;
    const double D =  -6.2e-6;
    const double gmst = ((A + (B + (C + D * t) * t) * t) + f) * SEC2RAD; //[rad]
    const double gmstNormalized = std::fmod(gmst, 2*PI);
    return gmstNormalized < 0 ? (2*PI) + gmstNormalized : gmstNormalized;
}

// Assembly:
pushq %rax
divsd 0x6673(%rip), %xmm0     # 0xd0f0
addsd 0x6673(%rip), %xmm0     # 0xd0f8
movapd %xmm0, %xmm1
divsd 0x666f(%rip), %xmm1     # 0xd100
movsd %xmm1, (%rsp)
movsd 0x65c2(%rip), %xmm1     # 0xd060
callq 0x4390
movsd 0x665d(%rip), %xmm1     # 0xd108
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd 0x6654(%rip), %xmm1     # 0xd110
mulsd %xmm2, %xmm1
addsd 0x6650(%rip), %xmm1     # 0xd118
mulsd %xmm2, %xmm1
addsd 0x664c(%rip), %xmm1     # 0xd120
mulsd 0x6614(%rip), %xmm0     # 0xd0f0
addsd %xmm1, %xmm0
mulsd 0x6640(%rip), %xmm0     # 0xd128
movsd 0x6640(%rip), %xmm1     # 0xd130
callq 0x4390
movsd 0x6633(%rip), %xmm3     # 0xd130
addsd %xmm0, %xmm3
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpltsd %xmm2, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm0, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: createProjectionMatrix(double, double, double, double)
Mat4F createProjectionMatrix(double screenW, double screenH, double fovY, double viewZ)
{
    Mat4F mat = Mat4F::perspective(fovY, screenW, screenH, 0.0125, 3.0);
    if(viewZ != 0){
        mat = mat * Mat4F::translate(0, 0, -viewZ);
    }
    return mat;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movsd %xmm3, 0x10(%rsp)
cvtsd2ss %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm0
movq %rdi, %rbx
xorps %xmm3, %xmm3
cvtsd2ss %xmm1, %xmm3
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
mulsd 0x6225(%rip), %xmm1     # 0xd138
cvtsd2ss %xmm1, %xmm1
divss %xmm0, %xmm3
movss %xmm3, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x6228(%rip), %xmm0     # 0xd158
callq 0x41a0
movsd 0x10(%rsp), %xmm2
movsd 0x611d(%rip), %xmm1     # 0xd060
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movss %xmm1, 0x14(%rbx)
movups %xmm0, 0x18(%rbx)
movsd 0x627f(%rip), %xmm1     # 0xd1f0
movups %xmm1, 0x28(%rbx)
movss 0x608f(%rip), %xmm1     # 0xd00c
movlpd %xmm1, 0x38(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x6f8e
jnp 0x6ffb
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
xorps 0x6214(%rip), %xmm1     # 0xd1b0
movl $0x3f800000, %eax       # imm = 0x3F800000
leaq 0x18(%rsp), %rdx
movl %eax, (%rdx)
movups %xmm0, 0x4(%rdx)
movl %eax, 0x14(%rdx)
movups %xmm0, 0x18(%rdx)
movss 0x6055(%rip), %xmm0     # 0xd010
movups %xmm0, 0x28(%rdx)
movss %xmm1, 0x38(%rdx)
movl %eax, 0x3c(%rdx)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9dfb
movups (%r14), %xmm0
movupd 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movupd %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: float fromStrView<float>(std::basic_string_view<char, std::char_traits<char>>)
float fromStrView<float>(std::string_view str)
{
    if(str.size() > 1 && str[0] == 'M'){ //M6 means Magnitude 6
        return mag2flux(std::stof(std::string(str.begin() + 1, str.end())));
    }
    else{
        return std::stof(std::string(str));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rdx
cmpq $0x2, %rdi
jb 0x7165
cmpb $0x4d, (%rsi)
jne 0x7165
leaq 0x1(%rsi), %rax
addq %rsi, %rdx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa366
movq 0x8(%rsp), %rbx
callq 0x4040
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
cmpq %rbx, (%r15)
je 0x7217
movaps %xmm0, %xmm1
movl (%r14), %eax
testl %eax, %eax
je 0x71c3
cmpl $0x22, %eax
jne 0x71c6
leaq 0x63e3(%rip), %rdi      # 0xd543
callq 0x4410
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa366
movq 0x8(%rsp), %rbx
callq 0x4040
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
cmpq %rbx, (%r15)
je 0x720b
movl (%r14), %eax
testl %eax, %eax
je 0x71be
cmpl $0x22, %eax
jne 0x71db
leaq 0x638a(%rip), %rdi      # 0xd543
callq 0x4410
movl %ebp, (%r14)
jmp 0x71db
movl %ebp, (%r14)
mulss 0x5e36(%rip), %xmm1     # 0xd004
movss 0x5e32(%rip), %xmm0     # 0xd008
callq 0x4470
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x71fe
movq 0x18(%rsp), %rsi
incq %rsi
movss %xmm0, 0x4(%rsp)
callq 0x42e0
movss 0x4(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6331(%rip), %rdi      # 0xd543
callq 0x41c0
leaq 0x6325(%rip), %rdi      # 0xd543
callq 0x41c0
jmp 0x7227
jmp 0x722c
movq %rax, %rbx
jmp 0x724f
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x7238
movl %ebp, (%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x724f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: bool fromStrView<bool>(std::basic_string_view<char, std::char_traits<char>>)
bool fromStrView<bool>(std::string_view str)
{
    if(str == "true"){
        return true;
    }
    else if(str == "false"){
        return false;
    }
    else{
        return std::stoi(std::string(str)) != 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rdx
cmpq $0x5, %rdi
je 0x7281
cmpq $0x4, %rdx
jne 0x7293
cmpl $0x65757274, (%rsi)     # imm = 0x65757274
jne 0x7293
movb $0x1, %bl
jmp 0x730f
movl $0x736c6166, %eax       # imm = 0x736C6166
xorl (%rsi), %eax
movzbl 0x4(%rsi), %ecx
xorl $0x65, %ecx
orl %eax, %ecx
je 0x730d
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa366
movq (%rbx), %r14
callq 0x4040
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x43e0
cmpq %r14, (%r15)
je 0x731e
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x732a
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x732a
testl %ecx, %ecx
jne 0x72ef
movl %ebp, (%rbx)
testl %eax, %eax
setne %bl
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x730f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x730f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6219(%rip), %rdi      # 0xd53e
callq 0x41c0
leaq 0x620d(%rip), %rdi      # 0xd53e
callq 0x4410
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0x7340
movl %ebp, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7357
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: findOption(std::basic_string_view<char, std::char_traits<char>>)
const Option *findOption(std::string_view name)
{
    for(const auto &cat : optionCategories){
        for(const auto &opt : cat.options){
            const auto it = std::find(opt.names.begin(), opt.names.end(), name);
            if(it != opt.names.end()){
                return &opt;
            }
        }
    }
    return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, (%rsp)
movq %rsi, 0x8(%rsp)
movq 0xaf31(%rip), %r15      # 0x12300
movq 0xaf32(%rip), %r12      # 0x12308
cmpq %r12, %r15
je 0x740f
movq %rsp, %rbx
movq 0x10(%r15), %r14
movq 0x18(%r15), %r13
cmpq %r13, %r14
je 0x7406
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0xb0a7
cmpq 0x8(%r14), %rax
jne 0x7412
addq $0x30, %r14
jmp 0x73e6
addq $0x28, %r15
cmpq %r12, %r15
jne 0x73de
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: emitOption(Options&, Option const*, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>)
bool emitOption(Options &options, const Option *opt, std::string_view name, std::string_view value)
{
    try{
        opt->type->setArgument(options, value);
        if(opt->specified){
            options.*(opt->specified) = true;
        }
        return true;
    }
    catch(const std::logic_error &e){ //sto? throws invalid_argument or out_of_range
        error("Invalid option value %s (%s)",
            std::string(value).c_str(),
            std::string(name).c_str());
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r15
movq 0x18(%rsi), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq *0x10(%rax)
movq 0x28(%rbp), %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
je 0x7467
movb $0x1, (%r15,%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x753a
movq %r15, %rdi
callq 0x4120
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
addq %r13, %r12
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xa366
movq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
addq %r14, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa366
movq 0x28(%rsp), %rdx
leaq 0x5f8a(%rip), %rdi      # 0xd45e
movq %r15, %rsi
callq 0x45b0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x74f3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x750a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
callq 0x4490
xorl %eax, %eax
jmp 0x7467
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7535
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x7535
movq %rax, %r15
callq 0x4490
movq %r15, %rdi
callq 0x4510
movq %rax, %rdi
callq 0xa0c4
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: parseCommandLine(Options&, int, char**)
bool parseCommandLine(Options &options, int argc, char *argv[])
{
    const Option *unresolvedOpt = nullptr;
    std::string_view unresolvedName;
    for(int ai = 1; ai < argc; ++ai){
        const char * const arg = argv[ai];
        if(unresolvedOpt){
            emitOption(options, unresolvedOpt, unresolvedName, std::string_view(arg));
            unresolvedOpt = nullptr;
            unresolvedName = "";
        }
        else if(arg[0] == '-'){
            const char *p = arg + 1;
            for(;!(*p == '=' || *p == '\0'); ++p);
            const std::string_view name = std::string_view(arg, p - arg);
            const Option * const opt = findOption(name);
            if(!opt){
                error("Unknown option %s", std::string(name).c_str());
                return false;
            }
            if(opt->needsValue()){
                if(*p == '='){
                    emitOption(options, opt, name, std::string_view(p+1));
                }
                else{
                    unresolvedOpt = opt;
                    unresolvedName = name;
                }
            }
            else{
                emitOption(options, opt, name, std::string_view());
            }
        }
        else{
            //files_.push_back(arg);
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpl $0x2, %esi
jl 0x7663
movq %rdx, %rbx
movl %esi, %r15d
movl $0x1, %r12d
xorl %r13d, %r13d
xorl %r14d, %r14d
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rdx, 0x18(%rsp)
movq %r15, 0x10(%rsp)
movq (%rbx,%r12,8), %rbp
testq %r14, %r14
jne 0x7603
cmpb $0x2d, (%rbp)
jne 0x75fe
leaq 0x1(%rbp), %rbx
xorl %r15d, %r15d
movzbl (%rbx), %eax
incq %rbx
incq %r15
cmpl $0x3d, %eax
je 0x75bb
testl %eax, %eax
jne 0x75a9
movq %r15, %rdi
movq %rbp, %rsi
callq 0x73b2
testq %rax, %rax
je 0x767c
movq %rax, %r14
cmpb $0x3d, -0x1(%rbx)
jne 0x7640
movq %rbx, %rdi
callq 0x4140
movq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %rax, %r8
movq %rbx, %r9
callq 0x7423
xorl %r14d, %r14d
jmp 0x7649
xorl %r14d, %r14d
jmp 0x7653
movq %rbp, %rdi
callq 0x4140
movq 0x20(%rsp), %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq %rax, %r8
movq %rbp, %r9
callq 0x7423
xorl %r14d, %r14d
movq $0x0, 0x8(%rsp)
leaq 0x5eb0(%rip), %rax      # 0xd4ea
movq %rax, (%rsp)
jmp 0x7653
movq %r15, 0x8(%rsp)
movq %rbp, (%rsp)
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r15
incq %r12
cmpq %r15, %r12
setae %r13b
jne 0x7593
movb $0x1, %r13b
andb $0x1, %r13b
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
movq %r15, %rsi
callq 0x45de
jmp 0x7666
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/./image.h
// Function: Image<ColorRGB<double>> readRawFile<Image<ColorRGB<double>>>(char const*)
ImageT readRawFile(const char *filename)
{
    ImageT image;
    if(File file = File(filename, "rb")){
        unsigned int w = 0, h = 0;
        std::fread(&w, sizeof(w), 1, file);
        std::fread(&h, sizeof(h), 1, file);
        if(w > 0 && h > 0 && w <= 65536 && h <= 65536){
            image.reset(w, h);
            if(std::fread(image.begin(), image.sizeInBytes(), 1, file) != 1){
                image.reset(0, 0);
            }
        }
    }
    return std::move(image);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x34ce(%rip), %rsi      # 0xd5bc
movq %rax, %rdi
callq 0x4350
movq %rax, %r14
xorl %eax, %eax
testq %r14, %r14
je 0xa1c9
leaq 0x14(%rsp), %r15
movl %eax, (%r15)
leaq 0x10(%rsp), %r12
movl %eax, (%r12)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x4430
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x4430
movl (%r15), %esi
movl (%r12), %edx
leal -0x1(%rsi), %eax
movl $0x10000, %ecx          # imm = 0x10000
cmpl %ecx, %eax
setb %al
leal -0x1(%rdx), %edi
cmpl %ecx, %edi
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xa1b5
movq %rsp, %rdi
callq 0xb1ca
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %eax
imull (%rsp), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x1, %edx
movq %r14, %rcx
callq 0x4430
cmpq $0x1, %rax
je 0xa1b5
movq $0x0, (%rsp)
xorl %edi, %edi
callq 0x4030
movq 0x8(%rsp), %rdi
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0xa1b5
callq 0x4370
movq %r14, %rdi
callq 0x42c0
movsd (%rsp), %xmm0
movq 0x8(%rsp), %rax
jmp 0xa1cc
xorps %xmm0, %xmm0
movlps %xmm0, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x42c0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa1fc
callq 0x4370
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/./image.h
// Function: bool writeRawFile<Image<ColorRGB<double>>>(char const*, Image<ColorRGB<double>>&)
bool writeRawFile(const char *filename, ImageT &image)
{
    if(File file = File(filename, "wb")){
        const unsigned int w = image.width();
        const unsigned int h = image.height();
        std::fwrite(&w, sizeof(w), 1, file);
        std::fwrite(&h, sizeof(h), 1, file);
        std::fwrite(image.begin(), image.sizeInBytes(), 1, file);
        return true;
    }
    else{
        return false;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0x3331(%rip), %rsi      # 0xd548
callq 0x4350
movq %rax, %rbx
testq %rax, %rax
je 0xa28a
movl (%r14), %eax
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
movl 0x4(%r14), %eax
leaq 0x8(%rsp), %r15
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4580
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4580
movq 0x8(%r14), %rdi
movl 0x4(%r14), %eax
imull (%r14), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4580
movq %rbx, %rdi
callq 0x42c0
testq %rbx, %rbx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: OptionTime::setArgument(Options&, std::basic_string_view<char, std::char_traits<char>>) const
void setArgument(Options &options, std::string_view str) const override
    {
        int year, month, day, hour, min, sec;
        if(sscanf(str.data(), "%d-%d-%d %d:%d:%d", &year, &month, &day, &hour, &min, &sec) == 6){
            std::tm lt = {sec, min, hour, day, month-1, year-1900, 0, 0, 0};
            std::time_t unixSeconds = std::mktime(&lt);
            if(unixSeconds != -1){
                options.*dst = unixSeconds;
                return;
            }
        }
        throw std::invalid_argument("Invalid time syntax");
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r10
leaq 0xc(%rsp), %r11
leaq 0x2b04(%rip), %rsi      # 0xd596
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rax
leaq 0x14(%rsp), %r8
leaq 0x10(%rsp), %r9
movq %rcx, %rdi
movq %rax, %rcx
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x42b0
addq $0x10, %rsp
cmpl $0x6, %eax
jne 0xab2f
movl 0x8(%rsp), %eax
leaq 0x20(%rsp), %rdi
movl %eax, (%rdi)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rdi)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rdi)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rdi)
movl 0x18(%rsp), %eax
decl %eax
movl %eax, 0x10(%rdi)
movl $0xfffff894, %eax       # imm = 0xFFFFF894
addl 0x1c(%rsp), %eax
movl %eax, 0x14(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
callq 0x41e0
cmpq $-0x1, %rax
je 0xab2f
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq 0x8(%r14), %rax
movsd %xmm0, (%rbx,%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4160
movq %rax, %rbx
leaq 0x2a65(%rip), %rsi      # 0xd5a8
movq %rax, %rdi
callq 0x4560
movq 0x7496(%rip), %rsi      # 0x11fe8
movq 0x747f(%rip), %rdx      # 0x11fd8
movq %rbx, %rdi
callq 0x44d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4200
movq %r14, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: void drawStarOnEquirectangular<GaiaStar>(Image<ColorRGB<double>>&, GaiaStar const&, StarAppearanceOptions const&)
void drawStarOnEquirectangular(ImageType &canvas, const StarType &star, const StarAppearanceOptions &starAppearanceOptions)
{
    const StarAppearance appearance = calculateStarAppearance(star, starAppearanceOptions);

    fillCircleOnEquirectangular(
        canvas,
        star.ra_deg(), star.dec_deg(),
        appearance.radius,
        PixelPlotter(appearance));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xb29f
movss (%rbx), %xmm0
movss 0x4(%rbx), %xmm1
movss 0x18(%r15), %xmm2
movups (%r15), %xmm3
movups 0x10(%r15), %xmm4
movups %xmm4, 0x10(%rsp)
movups %xmm3, (%rsp)
movq %r14, %rdi
callq 0xb3b7
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: StarAppearance calculateStarAppearance<HipStar>(HipStar const&, StarAppearanceOptions const&)
StarAppearance calculateStarAppearance(const Star &star, const StarAppearanceOptions &options)
{
    const float flux = mag2flux(star.mag());
    const float radius =
        flux > options.fluxIncRadius ?
        clamp(std::sqrt(options.radiusDefault * options.radiusDefault * flux / options.fluxIncRadius), 0.0f, options.radiusMax) :
        options.radiusDefault;
    const float fluxAdjusted = options.fluxOffset + options.fluxMultiplier * flux;
    const float fluxSaturated = std::min(options.fluxGamma==1.0 ? fluxAdjusted : std::pow(fluxAdjusted, options.fluxGamma), options.fluxMax);

    return {fluxSaturated * temperatureToRGB(star.teff()), radius};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movss 0x8(%rsi), %xmm1
mulss 0x1634(%rip), %xmm1     # 0xd004
movss 0x1630(%rip), %xmm0     # 0xd008
callq 0x4470
movaps %xmm0, %xmm3
movss 0x10(%r14), %xmm1
movss 0x14(%r14), %xmm2
ucomiss %xmm1, %xmm0
jbe 0xba3a
mulss %xmm2, %xmm2
movaps %xmm3, %xmm0
mulss %xmm2, %xmm0
divss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xba11
xorps %xmm2, %xmm2
sqrtss %xmm0, %xmm2
jmp 0xba28
movss %xmm3, 0x10(%rsp)
callq 0x4530
xorps %xmm1, %xmm1
movss 0x10(%rsp), %xmm3
movaps %xmm0, %xmm2
movss 0x18(%r14), %xmm0
minss %xmm2, %xmm0
cmpltss %xmm1, %xmm2
andnps %xmm0, %xmm2
movaps %xmm2, 0x10(%rsp)
movss 0x4(%r14), %xmm0
mulss %xmm3, %xmm0
addss (%r14), %xmm0
movss 0x8(%r14), %xmm1
ucomiss 0x15b5(%rip), %xmm1     # 0xd010
jne 0xba5f
jnp 0xba64
callq 0x4470
xorps %xmm1, %xmm1
cvtss2sd 0xc(%r15), %xmm1
mulsd 0x171b(%rip), %xmm1     # 0xd190
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
addpd 0x178f(%rip), %xmm1     # 0xd210
movapd 0x1797(%rip), %xmm2     # 0xd220
divpd %xmm1, %xmm2
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
movss 0xc(%r14), %xmm2
mulsd 0x16f1(%rip), %xmm1     # 0xd198
minss %xmm0, %xmm2
movss %xmm2, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6717
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
movsd 0x10(%r14), %xmm1
mulsd %xmm0, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd (%r14), %xmm0
movupd %xmm0, (%rbx)
movsd %xmm1, 0x10(%rbx)
movaps 0x10(%rsp), %xmm0
movss %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: GaiaStar::teff() const
float teff() const
    {
        if(teff_val >= 100 && teff_val < 50000){ // 3229.0 <= teff_val <= 9803.0
            return teff_val;
        }
        else{
            // see: https://github.com/langurmonkey/gaiasky/blob/cfab3a75051a0d521c69b54b5f937b8dafa38b02/core/src/gaiasky/data/group/DR2DataProvider.java#L290
            const float xp = bp - rp;
            return xp <= 1.5 ?
                // Gaia broad band photometry : 5.1.G_BP−G_RP as indicator ofTeﬀ / https://arxiv.org/abs/1008.0815
                std::pow(10, 3.999 + (-0.654+ (0.709 - 0.316*xp) * xp) * xp) :
                lint(xp, 1.5f, 15.0f, 3521.6f, 3000.0f);
        }
    }

// Assembly:
movss 0x14(%rdi), %xmm0
ucomiss 0x1834(%rip), %xmm0     # 0xd038
jb 0xb814
movss 0x182e(%rip), %xmm1     # 0xd03c
ucomiss %xmm0, %xmm1
jbe 0xb814
retq
movss 0xc(%rdi), %xmm0
subss 0x10(%rdi), %xmm0
movss 0x181a(%rip), %xmm1     # 0xd040
ucomiss %xmm0, %xmm1
jae 0xb836
jbe 0xb87d
movss 0x180f(%rip), %xmm0     # 0xd044
retq
pushq %rax
cvtss2sd %xmm0, %xmm0
movsd 0x1925(%rip), %xmm1     # 0xd168
mulsd %xmm0, %xmm1
addsd 0x1921(%rip), %xmm1     # 0xd170
mulsd %xmm0, %xmm1
addsd 0x191d(%rip), %xmm1     # 0xd178
mulsd %xmm0, %xmm1
addsd 0x1919(%rip), %xmm1     # 0xd180
movsd 0x1819(%rip), %xmm0     # 0xd088
callq 0x44f0
cvtsd2ss %xmm0, %xmm0
addq $0x8, %rsp
retq
ucomiss 0x17c8(%rip), %xmm0     # 0xd04c
jbe 0xb88f
movss 0x17ba(%rip), %xmm0     # 0xd048
retq
addss 0x17b9(%rip), %xmm0     # 0xd050
mulss 0x17b5(%rip), %xmm0     # 0xd054
divss 0x17b1(%rip), %xmm0     # 0xd058
addss 0x1795(%rip), %xmm0     # 0xd044
retq
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: TrainData::readInput(std::vector<double, std::allocator<double>>&)
unsigned int TrainData::readInput(vector<double> &input)
{
  // Clear input vector
  input.clear();

  string in;
  m_trainFile >> in;
  if (in.compare("in:") == 0)
  {
    double inputVal;
    m_trainFile >> inputVal;
    input.push_back(inputVal);
    m_trainFile >> inputVal;
    input.push_back(inputVal);
  }

  return input.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x2780
movq %rax, 0x8(%rbx)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x2230
leaq 0x3919(%rip), %rsi      # 0x60c2
leaq 0x10(%rsp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x2827
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2130
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x27e2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x27ef
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ee4
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2130
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x281a
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2827
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ee4
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2845
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
subq %r14, %rbx
shrq $0x3, %rbx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x285a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2874
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: TrainData::readTarget(std::vector<double, std::allocator<double>>&)
unsigned int TrainData::readTarget(vector<double> &target)
{
  // Clear target vector
  target.clear();

  string out;
  m_trainFile >> out;
  if (out.compare("out:") == 0)
  {
    double targetVal;
    m_trainFile >> targetVal;
    target.push_back(targetVal);
  }

  return target.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x28ba
movq %rax, 0x8(%rbx)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x2230
leaq 0x37e3(%rip), %rsi      # 0x60c6
leaq 0x10(%rsp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x2929
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2130
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x291c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2929
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ee4
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2947
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
subq %r14, %rbx
shrq $0x3, %rbx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x295c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2976
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Neuron::calculateOutputGradient(double, std::vector<Neuron, std::allocator<Neuron>>&)
void Neuron::calculateOutputGradient(double target, Layer &prevLayer)
{
  for (unsigned n = 0; n < prevLayer.size()-1; n++)
  {
    m_target = target;
    m_error = m_target - m_outputValue;
    double delta = -(m_target - m_outputValue);
    m_gradient = delta * derivativeSigmoid(m_outputValue) * prevLayer[n].m_outputValue;
    prevLayer[n].m_outputWeight[m_index].deltaWeight = m_gradient * eta;
  }
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x6, %rcx
decq %rcx
je 0x2a81
movsd 0x8(%rdi), %xmm3
movapd %xmm0, %xmm1
subsd %xmm3, %xmm1
movapd 0x35f2(%rip), %xmm4     # 0x6010
xorpd %xmm1, %xmm4
movsd 0x3656(%rip), %xmm2     # 0x6080
subsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm4, %xmm2
movl (%rdi), %edx
addq $0x28, %rax
movl $0x1, %esi
shlq $0x4, %rdx
movsd -0x20(%rax), %xmm3
mulsd %xmm2, %xmm3
movsd 0x6762(%rip), %xmm4     # 0x91b8
mulsd %xmm3, %xmm4
movq (%rax), %r8
movsd %xmm4, 0x8(%r8,%rdx)
movl %esi, %r8d
addq $0x40, %rax
incl %esi
cmpq %r8, %rcx
ja 0x2a45
movsd %xmm0, 0x18(%rdi)
movsd %xmm1, 0x20(%rdi)
movsd %xmm3, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Neuron::calculateHiddenGradient(std::vector<Neuron, std::allocator<Neuron>> const&, std::vector<Neuron, std::allocator<Neuron>>&)
void Neuron::calculateHiddenGradient(const Layer &nextLayer, Layer &prevLayer)
{
  double sum = 0.;
  double delta = 0.;

  for (unsigned n = 0; n < nextLayer.size() - 1; n++)   // Exclude the bias node
  {
    m_error = m_target - m_outputValue;
    delta = -(nextLayer[n].m_target - nextLayer[n].m_outputValue);
    sum += m_outputWeight[n].weight * derivativeSigmoid(nextLayer[n].m_outputValue) * delta;
  }

  for (unsigned n = 0; n < prevLayer.size()-1; n++)
  {
    m_gradient = sum * Neuron::derivativeSigmoid(m_outputValue) * prevLayer[n].m_outputValue;
    prevLayer[n].m_outputWeight[m_index].deltaWeight = m_gradient*eta;
  }
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x6, %rcx
decq %rcx
je 0x2afa
movsd 0x18(%rdi), %xmm0
subsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x20(%rdi)
movq 0x28(%rdi), %rsi
xorpd %xmm0, %xmm0
movl $0x1, %r8d
xorl %r9d, %r9d
movsd 0x35c3(%rip), %xmm1     # 0x6080
movsd 0x8(%rax,%r9,4), %xmm2
movsd 0x18(%rax,%r9,4), %xmm3
subsd %xmm2, %xmm3
movapd %xmm1, %xmm4
subsd %xmm2, %xmm4
mulsd %xmm2, %xmm4
mulsd (%rsi,%r9), %xmm4
mulsd %xmm3, %xmm4
subsd %xmm4, %xmm0
movl %r8d, %r10d
addq $0x10, %r9
incl %r8d
cmpq %r10, %rcx
ja 0x2abd
jmp 0x2afe
xorpd %xmm0, %xmm0
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
subq %rax, %rcx
sarq $0x6, %rcx
decq %rcx
je 0x2b6b
movsd 0x8(%rdi), %xmm1
movsd 0x3562(%rip), %xmm2     # 0x6080
subsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
movl (%rdi), %edx
addq $0x28, %rax
movl $0x1, %esi
shlq $0x4, %rdx
movsd -0x20(%rax), %xmm1
mulsd %xmm0, %xmm1
movsd 0x666e(%rip), %xmm2     # 0x91b8
mulsd %xmm1, %xmm2
movq (%rax), %r8
movsd %xmm2, 0x8(%r8,%rdx)
movl %esi, %r8d
addq $0x40, %rax
incl %esi
cmpq %r8, %rcx
ja 0x2b39
movsd %xmm1, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Neuron::feedForward(std::vector<Neuron, std::allocator<Neuron>> const&)
void Neuron::feedForward(const Layer &prevLayer)
{
  double sum = 0.0;
  // calculate the output*weights of neurons from previous Layer
  for (unsigned i = 0; i < prevLayer.size(); i++)
  {
    sum += prevLayer[i].getOutputVal() * prevLayer[i].m_outputWeight[m_index].weight;
  }

  m_outputValue = Neuron::sigmoid(sum);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x2bb3
sarq $0x6, %rcx
movl (%rbx), %edx
addq $0x28, %rax
xorpd %xmm0, %xmm0
movl $0x1, %esi
shlq $0x4, %rdx
movsd -0x20(%rax), %xmm1
movq (%rax), %rdi
mulsd (%rdi,%rdx), %xmm1
addsd %xmm1, %xmm0
movl %esi, %edi
addq $0x40, %rax
incl %esi
cmpq %rdi, %rcx
ja 0x2b93
jmp 0x2bb7
xorpd %xmm0, %xmm0
xorpd 0x3451(%rip), %xmm0     # 0x6010
callq 0x2320
movsd 0x34b4(%rip), %xmm1     # 0x6080
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Neuron::Neuron(unsigned int, unsigned int)
Neuron::Neuron(unsigned outputs, unsigned index)
{
  // Real random
  random_device rd;
  mt19937 gen(rd());
  uniform_real_distribution<> dis(0, 1);

  for (unsigned i = 0; i < outputs; i++)
  {
    m_outputWeight.push_back(Connection());
    m_outputWeight.back().weight = dis(gen);
    cout << m_outputWeight.back().weight << endl;
  }

  m_index = index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2738, %rsp           # imm = 0x2738
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rdi)
movq $0x0, 0x38(%rdi)
leaq 0x13b0(%rsp), %rdi
callq 0x3b70
leaq 0x13b0(%rsp), %rdi
callq 0x2250
movl %ebp, 0xc(%rsp)
movl %eax, %eax
movq %rax, 0x28(%rsp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, 0x28(%rsp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x2c34
movq $0x270, 0x13a8(%rsp) # imm = 0x270
testl %r15d, %r15d
je 0x2cf3
leaq 0x28(%rsp), %r13
movq 0x6361(%rip), %rbp      # 0x8fd8
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x2c96
movupd %xmm0, (%rsi)
addq $0x10, 0x30(%rbx)
jmp 0x2ca3
movq %r14, %rdi
leaq 0x10(%rsp), %rdx
callq 0x4024
movq %r13, %rdi
callq 0x4163
addsd 0x33d5(%rip), %xmm0     # 0x6088
movq 0x30(%rbx), %rax
movsd %xmm0, -0x10(%rax)
movq %rbp, %rdi
callq 0x22b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
decl %r15d
jne 0x2c77
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
leaq 0x13b0(%rsp), %rdi
callq 0x21c0
addq $0x2738, %rsp           # imm = 0x2738
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d4f
jmp 0x2d23
movq %rax, %r15
jmp 0x2d33
jmp 0x2d23
movq %rax, %r15
leaq 0x13b0(%rsp), %rdi
callq 0x21c0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2d47
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r15, %rdi
callq 0x2310
movq %rax, %rdi
callq 0x3b64
nop
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Net::getOutputValLayer(std::vector<double, std::allocator<double>>&)
void Net::getOutputValLayer(vector<double> &results)
{
  results.clear();
  Layer &outputLayer = m_layers.back();
  for (unsigned i = 0; i < outputLayer.size()-1; i++) // No bias node output
  {
    results.push_back(outputLayer[i].getOutputVal());
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x2d95
movq %rax, 0x8(%rbx)
movq 0x18(%rdi), %r15
movq -0x18(%r15), %rax
movq -0x10(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x40, %rdx
je 0x2e07
movl $0x1, %ebp
xorl %edx, %edx
movq %rsp, %r14
shlq $0x6, %rdx
movsd 0x8(%rax,%rdx), %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2dde
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2df1
movq %rbx, %rdi
movq %r14, %rdx
callq 0x43f4
movq -0x18(%r15), %rax
movq -0x10(%r15), %rcx
movl %ebp, %edx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x6, %rsi
decq %rsi
incl %ebp
cmpq %rdx, %rsi
ja 0x2db7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Net::feedForward(std::vector<double, std::allocator<double>> const&)
void Net::feedForward(const vector<double> &input)
{
  // Assign input values to input neurons
  for (unsigned i = 0; i < input.size(); i++)
  {
    m_layers[0][i].setOutputVal(input[i]);
  }

  // Start @ the first hidden layer after the input layer
  // Per neuron calculate the output*weights of the last layer
  for (unsigned layerNum = 1; layerNum < m_layers.size(); layerNum++)
  {
    Layer &prevLayer = m_layers[layerNum - 1];
    for (unsigned n = 0; n < m_layers[layerNum].size()-1; n++)
    {
      m_layers[layerNum][n].feedForward(prevLayer);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq 0x10(%rdi), %rax
subq %rcx, %rdx
je 0x2e5a
sarq $0x3, %rdx
movq (%rax), %rsi
movl $0x1, %edi
xorl %r8d, %r8d
movsd (%rcx,%r8), %xmm0
movsd %xmm0, 0x8(%rsi,%r8,8)
movl %edi, %r9d
addq $0x8, %r8
incl %edi
cmpq %r9, %rdx
ja 0x2e3f
movq 0x18(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r15, %rdx
cmpq $0x2, %rdx
jb 0x2f01
movl $0x1, %r12d
movl $0x1, %edx
leaq (%rdx,%rdx,2), %r13
movq (%rax,%r13,8), %rdx
movq 0x8(%rax,%r13,8), %rsi
subq %rdx, %rsi
cmpq $0x40, %rsi
je 0x2ee8
leal -0x1(%r12), %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %r14
movl $0x1, %ebp
xorl %edi, %edi
shlq $0x6, %rdi
addq %rdx, %rdi
movq %r14, %rsi
callq 0x2b6c
movl %ebp, %edi
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rdx
movq 0x8(%rax,%r13,8), %rcx
subq %rdx, %rcx
sarq $0x6, %rcx
decq %rcx
incl %ebp
cmpq %rdi, %rcx
ja 0x2eb5
movq 0x18(%rbx), %rcx
incl %r12d
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
imulq %r15, %rsi
movq %r12, %rdx
cmpq %r12, %rsi
ja 0x2e8b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Net::backPropagation(std::vector<double, std::allocator<double>> const&)
void Net::backPropagation(const vector<double> &target)
{
  calcTotalError(target);
  averageError();

  for (unsigned n = 0; n < m_layers.back().size()-1; n++)
  {
    Layer &prevLayer = m_layers[1];
    m_layers.back()[n].calculateOutputGradient(target[n], prevLayer);
  }

  // Calculate the derivative of the hidden neurons
  Layer &hiddenLayer = m_layers[m_layers.size()-2];
  for (unsigned n = 0; n < m_layers[1].size()-1; n++) // Exclude the bias node
  {
    hiddenLayer[n].calculateHiddenGradient(m_layers.back(), m_layers[0]);
  }

  for (unsigned n = 0; n < m_layers.size()-1; n++)  // No output layer opdate...
  {
    for (unsigned i = 0; i < m_layers[n].size()-1; i++) // Exclude bias nodes
    {
      m_layers[n][i].updateWeights();
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3092
movsd 0x6296(%rip), %xmm0     # 0x91c0
movsd (%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rbx), %xmm1
addsd 0x3141(%rip), %xmm0     # 0x6080
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movq 0x18(%rbx), %r15
movq -0x18(%r15), %rax
movq -0x10(%r15), %rcx
subq %rax, %rcx
cmpq $0x40, %rcx
je 0x2fa1
movl $0x1, %ebp
xorl %ecx, %ecx
movq 0x10(%rbx), %rsi
addq $0x18, %rsi
movq %rcx, %rdi
shlq $0x6, %rdi
addq %rax, %rdi
movq (%r14), %rax
movsd (%rax,%rcx,8), %xmm0
callq 0x29f6
movl %ebp, %ecx
movq 0x18(%rbx), %r15
movq -0x18(%r15), %rax
movq -0x10(%r15), %rdx
subq %rax, %rdx
sarq $0x6, %rdx
decq %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x2f63
movq 0x10(%rbx), %r14
subq %r14, %r15
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
cmpq $0x40, %rax
jne 0x2fbb
movq %r14, %rdx
jmp 0x2ffe
movl $0x1, %ebp
xorl %edi, %edi
movq %r14, %rdx
shlq $0x6, %rdi
addq -0x30(%r14,%r15), %rdi
movq 0x18(%rbx), %rsi
addq $-0x18, %rsi
callq 0x2a82
movl %ebp, %edi
movq 0x10(%rbx), %rdx
movq 0x20(%rdx), %rax
subq 0x18(%rdx), %rax
sarq $0x6, %rax
decq %rax
incl %ebp
cmpq %rdi, %rax
ja 0x2fc5
movq 0x18(%rbx), %r15
subq %rdx, %r15
sarq $0x3, %r15
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %r15, %rax
decq %rax
je 0x3087
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdi
movq (%rdx,%rdi,8), %rsi
movq 0x8(%rdx,%rdi,8), %rdi
subq %rsi, %rdi
sarq $0x6, %rdi
decq %rdi
je 0x307d
xorl %r8d, %r8d
movq %r8, %r10
shlq $0x6, %r10
movq 0x28(%rsi,%r10), %r9
movq 0x30(%rsi,%r10), %r10
subq %r9, %r10
je 0x3072
sarq $0x4, %r10
movl $0x1, %r11d
movsd (%r9), %xmm0
subsd 0x8(%r9), %xmm0
movsd %xmm0, (%r9)
movl %r11d, %ebx
addq $0x10, %r9
incl %r11d
cmpq %rbx, %r10
ja 0x3053
incq %r8
movl %r8d, %r9d
cmpq %r9, %rdi
ja 0x3033
incq %rcx
movl %ecx, %esi
cmpq %rsi, %rax
ja 0x3017
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: Net::calcTotalError(std::vector<double, std::allocator<double>> const&)
double Net::calcTotalError(const vector<double> &target)
{
  double sum = 0.;
  for (unsigned n = 0; n < m_layers.back().size()-1; n++)
  {
    sum += 0.5*pow(target[n]-m_layers.back()[n].getError(), 2);
  }

  m_error = sum;

  return sum;
}

// Assembly:
movq 0x18(%rdi), %rcx
movq -0x18(%rcx), %rax
movq -0x10(%rcx), %rcx
subq %rax, %rcx
sarq $0x6, %rcx
decq %rcx
je 0x30ea
movq (%rsi), %rdx
xorpd %xmm0, %xmm0
movl $0x1, %esi
xorl %r8d, %r8d
movsd 0x2fcf(%rip), %xmm1     # 0x6090
movsd (%rdx,%r8), %xmm2
subsd 0x20(%rax,%r8,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movl %esi, %r9d
addq $0x8, %r8
incl %esi
cmpq %r9, %rcx
ja 0x30c1
jmp 0x30ee
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/main.cpp
// Function: showVectorValues[abi:cxx11](std::vector<double, std::allocator<double>>)
string showVectorValues(vector<double> value)
{
  string vStr;
  for (unsigned int i = 0; i < value.size(); i++)
  {
    vStr.append(to_string(value[i]));
    vStr.append(" ");
  }

  return vStr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x331d
movq %rsi, %r14
movl $0x1, %r15d
xorl %ecx, %ecx
leaq 0x2e91(%rip), %r12      # 0x6132
leaq 0x8(%rsp), %r13
leaq 0x2e13(%rip), %rbp      # 0x60c0
movsd (%rax,%rcx,8), %xmm0
movl $0x148, %edx            # imm = 0x148
movq %r13, %rdi
movq 0x5cff(%rip), %rsi      # 0x8fc0
movq %r12, %rcx
movb $0x1, %al
callq 0x3d06
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x32f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2340
movl %r15d, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %r15d
cmpq %rcx, %rdx
ja 0x32ad
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3352
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3355
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x3355
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x336d
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/mnist.cpp
// Function: getInput(std::vector<int, std::allocator<int>>&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>, int)
int getInput(vector<int> &input, vector<vector<int> > training, int index)
{
	input.clear();
	unsigned size = training[index].size();
	for (unsigned n = 0; n < size; n++)
	{
		input.push_back(training[index].at(n));
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x4fd5
movq %rax, 0x8(%r14)
movslq %edx, %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %r12
movq 0x8(%rcx,%r12,8), %rax
subq (%rcx,%r12,8), %rax
shrq $0x2, %rax
testl %eax, %eax
je 0x503f
movl %eax, %r13d
xorl %ebp, %ebp
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r12,8), %rdx
movq 0x8(%rax,%r12,8), %rax
subq %rdx, %rax
sarq $0x2, %rax
cmpq %r15, %rax
jbe 0x5050
addq %rbp, %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x502b
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x5033
movq %r14, %rdi
callq 0x54d8
incq %r15
addq $0x4, %rbp
cmpq %r15, %r13
jne 0x4ff8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11c8(%rip), %rdi      # 0x621f
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/wkohlenberg[P]simple_NN/src/mnist.cpp
// Function: getOutput(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>, int)
int getOutput(vector<int> &output, vector<int> labels, int index)
{
	// Load vector ouput with zero's
	fill (output.begin(), output.end(), 0);

	int label = labels.at(index);
	for (unsigned i = 0; i < labels.size(); i++)
	{
		if (int(i)== label)
		{
			output.at(i) = 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq (%rdi), %r14
movq 0x8(%rdi), %rbx
cmpq %rbx, %r14
je 0x5098
movq %rbx, %rdx
subq %r14, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
movslq %ebp, %rax
movq (%r15), %rdi
movq 0x8(%r15), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x50fd
subq %r14, %rbx
sarq $0x2, %rbx
xorl %esi, %esi
xorl %ecx, %ecx
subl (%rdi,%rax,4), %ecx
movl $0x1, %eax
leal (%rcx,%rax), %edi
cmpl $0x1, %edi
jne 0x50d6
cmpq %rsi, %rbx
jbe 0x50ec
movl $0x1, (%r14,%rsi,4)
movl %eax, %esi
incl %eax
cmpq %rsi, %rdx
ja 0x50c1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x112c(%rip), %rdi      # 0x621f
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2290
leaq 0x111b(%rip), %rdi      # 0x621f
movq %rax, %rsi
jmp 0x50f6
nop
// File: /workspace/github_cpp_makefile_star2_O3/kaiming[P]Chamber-Crawler-3k/Board/board.cc
// Function: Board::isUnoccupied(std::shared_ptr<WalkableTile>)
bool Board::isUnoccupied(std::shared_ptr<WalkableTile> target) {
    // Check in chamber (not a doorway or hallway)
    if (target->getRoom() < 0 || target->getOccupant() || target->getGold() || target->getPotion() || target->isExit()) {
        return false;
    } else {
        return true;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq (%rsi), %rdi
callq 0x1aa58
testl %eax, %eax
js 0xf16a
movq (%r14), %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a98e
cmpq $0x0, (%rbx)
je 0xf16e
xorl %ebx, %ebx
jmp 0xf1c9
xorl %ebx, %ebx
jmp 0xf1d8
movq (%r14), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1aa0e
cmpq $0x0, 0x18(%rsp)
je 0xf187
xorl %ebx, %ebx
jmp 0xf1ba
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1a9ce
movb $0x1, %bl
cmpq $0x0, 0x8(%rsp)
jne 0xf1a8
movq (%r14), %rdi
callq 0x1aa4e
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xf1b7
callq 0x7828
xorb $0x1, %bl
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xf1c9
callq 0x7828
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xf1d8
callq 0x7828
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xf1f9
callq 0x7828
jmp 0xf1f9
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xf20d
callq 0x7828
jmp 0xf20d
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xf21c
callq 0x7828
movq %rbx, %rdi
callq 0x5380