LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/daltonbr[P]RayTracing/./src/vec3.h
// Function: refract(vec3 const&, vec3 const&, float, vec3&)
bool refract(const vec3& v, const vec3& n, float ni_over_nt, vec3& refracted)
{
    vec3 uv = unit_vector(v);
    float dt = dot(uv, n);
    float discriminant = 1.0 - ni_over_nt * ni_over_nt * (1 - dt * dt);
    if (discriminant > 0)
    {
        refracted = ni_over_nt * (uv - n * dt) - n * sqrt(discriminant);
        return true;
    }
    else
    {
        return false;
    }
}

// Assembly:
movsd (%rdi), %xmm8
movss 0x8(%rdi), %xmm9
movaps %xmm8, %xmm10
shufps $0x55, %xmm8, %xmm10    # xmm10 = xmm10[1,1],xmm8[1,1]
movaps %xmm10, %xmm1
mulss %xmm10, %xmm1
movaps %xmm8, %xmm2
mulss %xmm8, %xmm2
addss %xmm1, %xmm2
movaps %xmm9, %xmm1
mulss %xmm9, %xmm1
addss %xmm2, %xmm1
sqrtss %xmm1, %xmm1
divss %xmm1, %xmm8
divss %xmm1, %xmm10
divss %xmm1, %xmm9
movss (%rsi), %xmm2
movss 0x4(%rsi), %xmm1
movaps %xmm1, %xmm3
mulss %xmm10, %xmm3
movaps %xmm8, %xmm5
mulss %xmm2, %xmm5
addss %xmm3, %xmm5
movss 0x8(%rsi), %xmm3
movaps %xmm9, %xmm4
mulss %xmm3, %xmm4
addss %xmm5, %xmm4
movaps %xmm0, %xmm5
mulss %xmm0, %xmm5
movaps %xmm4, %xmm6
mulss %xmm4, %xmm6
movss 0x14b57(%rip), %xmm11   # 0x17008
movaps %xmm11, %xmm7
subss %xmm6, %xmm7
mulss %xmm5, %xmm7
subss %xmm7, %xmm11
xorps %xmm5, %xmm5
ucomiss %xmm5, %xmm11
jbe 0x2590
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
mulss %xmm4, %xmm2
mulss %xmm4, %xmm1
mulss %xmm4, %xmm3
subss %xmm2, %xmm8
subss %xmm1, %xmm10
subss %xmm3, %xmm9
mulss %xmm0, %xmm8
mulss %xmm0, %xmm10
mulss %xmm0, %xmm9
ucomiss %xmm5, %xmm11
jb 0x251a
xorps %xmm0, %xmm0
sqrtss %xmm11, %xmm0
jmp 0x2552
movaps %xmm11, %xmm0
movaps %xmm8, -0x40(%rbp)
movss %xmm9, -0x18(%rbp)
movaps %xmm10, -0x30(%rbp)
movss %xmm11, -0x14(%rbp)
callq 0x21e0
xorps %xmm5, %xmm5
movss -0x14(%rbp), %xmm11
movaps -0x30(%rbp), %xmm10
movss -0x18(%rbp), %xmm9
movaps -0x40(%rbp), %xmm8
movss (%r14), %xmm1
mulss %xmm0, %xmm1
movss 0x4(%r14), %xmm2
mulss %xmm0, %xmm2
mulss 0x8(%r14), %xmm0
subss %xmm0, %xmm9
subss %xmm1, %xmm8
subss %xmm2, %xmm10
unpcklps %xmm10, %xmm8           # xmm8 = xmm8[0],xmm10[0],xmm8[1],xmm10[1]
movlps %xmm8, (%rbx)
movss %xmm9, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
ucomiss %xmm5, %xmm11
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/daltonbr[P]RayTracing/./src/../vendor/stb/stb_image.h
// Function: stbi_is_hdr_from_callbacks
STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
{
   #ifndef STBI_NO_HDR
   stbi__context s;
   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
   return stbi__hdr_test(&s);
   #else
   STBI_NOTUSED(clbk);
   STBI_NOTUSED(user);
   return 0;
   #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xd8, %rsp
movq 0x10(%rdi), %rax
leaq -0xa8(%rbp), %rbx
movq %rax, -0x18(%rbx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rbx)
movq %rsi, -0x10(%rbx)
movabsq $0x8000000001, %rax     # imm = 0x8000000001
movq %rax, -0x8(%rbx)
movq %rbx, 0x90(%rbx)
movq %rsi, %rdi
movq %rbx, %rsi
movl $0x80, %edx
callq *-0x28(%rbx)
testl %eax, %eax
je 0x3747
cltq
addq %rbx, %rax
jmp 0x3759
leaq -0xa7(%rbp), %rax
movl $0x0, -0x9(%rax)
movb $0x0, -0x1(%rax)
leaq -0xe0(%rbp), %rdi
movq %rbx, 0xb8(%rdi)
movq %rax, 0xc0(%rdi)
movq %rax, 0xd0(%rdi)
callq 0x3611
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/daltonbr[P]RayTracing/./src/main.cpp
// Function: color(ray const&, hitable*, int)
vec3 color(const ray& r, hitable *world, int depth)
{
    hit_record rec;
    if (world->hit(r, 0.001, MAXFLOAT, rec))  // acne problem solved
    {
        ray scattered;
        vec3 attenuation;
        if (depth < 50 && rec.mat_ptr->scatter(r, rec, attenuation, scattered))
        {
            return attenuation * color(scattered, world, depth + 1);
        }
        else
        {
            return vec3(0, 0, 0);
        }
    }
    else
    {
        vec3 unit_direction = unit_vector(r.direction());
        float t = 0.5 * (unit_direction.y() + 1.0);
        // Lerping from white to blue in y
        return (1.0 - t) * vec3(1, 1, 1) + t * vec3(0.5, 0.7, 1.0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movss 0x101aa(%rip), %xmm0    # 0x1703c
movss 0x101a6(%rip), %xmm1    # 0x17040
leaq -0x68(%rbp), %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq *(%rax)
testb %al, %al
je 0x6f0e
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
cmpl $0x31, %ebx
jg 0x6f91
leaq -0x68(%rbp), %rdx
movq 0x20(%rdx), %rdi
movq (%rdi), %rax
leaq -0x24(%rbp), %rcx
leaq -0x3c(%rbp), %r8
movq %r15, %rsi
callq *(%rax)
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
testb %al, %al
je 0x6f91
incl %ebx
leaq -0x3c(%rbp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x6e72
movss -0x24(%rbp), %xmm2
mulss %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss -0x20(%rbp), %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
mulss -0x1c(%rbp), %xmm1
jmp 0x6f91
movsd 0xc(%r15), %xmm0
movss 0x14(%r15), %xmm1
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
mulss %xmm0, %xmm0
addss %xmm3, %xmm0
mulss %xmm1, %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
divss %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
addsd 0x12316(%rip), %xmm0    # 0x19268
mulsd 0x12316(%rip), %xmm0    # 0x19270
cvtsd2ss %xmm0, %xmm0
movss 0x100a2(%rip), %xmm1    # 0x17008
subss %xmm0, %xmm1
movss 0x100be(%rip), %xmm2    # 0x17030
mulss %xmm0, %xmm2
movss 0x100c6(%rip), %xmm3    # 0x17044
mulss %xmm0, %xmm3
addss %xmm1, %xmm2
addss %xmm1, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
addss %xmm0, %xmm1
movaps %xmm2, %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::getAccountIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int User::getAccountIndex(string accountName) {
    for(int i = 0; i < accounts.size(); i++) {
        if(accounts[i].accountName.compare(accountName) == 0) {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %rdi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq %rdi, 0x8(%r15)
je 0x4704
movq %rsi, %r14
movl $0x8, %r13d
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
addq %r13, %rdi
movq %r14, %rsi
callq 0x2040
testl %eax, %eax
je 0x4701
incq %r12
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
sarq $0x4, %rax
imulq %rbp, %rax
addq $0x30, %r13
cmpq %r12, %rax
ja 0x46d2
jmp 0x4704
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::deposit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool User::deposit(string accountName, double amount) {
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    if(amount <= 0) { return false; }
    accounts[index].balance += amount;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x476f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
setne %cl
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
setb %al
andb %cl, %al
je 0x47a7
movapd %xmm1, %xmm0
movslq %ebp, %rcx
movq (%rbx), %rdx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addsd 0x28(%rdx,%rcx), %xmm0
movsd %xmm0, 0x28(%rdx,%rcx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x47cc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::withdraw(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool User::withdraw(string accountName, double amount) {
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    if(amount <= 0 || amount > accounts[index].balance) { return false; }
    accounts[index].balance -= amount;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x482d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
setne %al
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
setb %cl
testb %al, %cl
je 0x4861
movslq %ebp, %rcx
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movsd 0x28(%rax,%rcx), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x4865
xorl %eax, %eax
jmp 0x4876
addq %rcx, %rax
addq $0x28, %rax
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x489b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::createAccount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::createAccount(string accountName) {
    if(!isAdmin()) return false;
    if(getAccountIndex(accountName) != -1) { return false; }
    account acc;
    acc.disabled = false;
    acc.isStudentPlan = false;
    acc.accountName = accountName;
    acc.balance = 0.00;
    cout << endl << "Account Balance is: 0.00" << endl;
    accounts.push_back(acc);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4906
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3440
movq %rbx, %rdi
movq %r15, %rsi
callq 0x46a0
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4901
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
je 0x4915
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movw $0x0, -0x18(%r15)
movq %r14, %rsi
callq 0x2140
movq $0x0, 0x48(%rsp)
movq 0x967a(%rip), %rdi      # 0xdfc8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq 0x965f(%rip), %rdi      # 0xdfc8
callq 0x2030
movq %rax, %rdi
callq 0x2180
movq %rax, %r14
leaq 0x5859(%rip), %rsi      # 0xa1d9
movl $0x18, %edx
movq %rax, %rdi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4cb4
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x49d8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
movb $0x1, %al
jmp 0x4908
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4a0c
movq 0x10(%rsp), %rsi
jmp 0x4a04
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a0c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::disableAccount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::disableAccount(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    accounts[index].disabled = true;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4a8c
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a71
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
je 0x4a8c
movslq %ebp, %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movb $0x1, (%rcx,%rax)
movb $0x1, %al
jmp 0x4a8e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4ab3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::isDisabled(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::isDisabled(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    return accounts[index].disabled;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4b31
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4b19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
je 0x4b31
movslq %ebp, %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movb (%rcx,%rax), %al
jmp 0x4b33
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4b58
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::deleteAccount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::deleteAccount(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    accounts.erase(accounts.begin() + index);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4bdc
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4bbd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
je 0x4bdc
movslq %ebp, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x4fe2
movb $0x1, %al
jmp 0x4bde
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c03
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::changePlan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::changePlan(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    accounts[index].isStudentPlan = !accounts[index].isStudentPlan;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4c85
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3440
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
je 0x4c85
movslq %ebp, %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
xorb $0x1, 0x1(%rcx,%rax)
movb $0x1, %al
jmp 0x4c87
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4cac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/request.cpp
// Function: req::askAccountName[abi:cxx11](User, int)
string req::askAccountName(User user, int valid)
{
    string accountName;
    cout << "Enter account name: ";
    cin >> accountName;
    while (user.getAccountIndex(accountName) == valid)
    {
        cerr << "Error: Invalid account name!" << endl;
        cout << "Enter account name: ";
        cin >> accountName;
    }
    return accountName;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x4ff6(%rip), %rdi      # 0xdfc8
leaq 0x1756(%rip), %rsi      # 0xa72f
movl $0x14, %edx
callq 0x2270
movq 0x4fee(%rip), %rdi      # 0xdfd8
movq %rbx, %rsi
callq 0x22b0
leaq 0x28(%rsp), %rbp
leaq 0x18(%rsp), %r15
movq 0x4fed(%rip), %r12      # 0xdff0
movq %rbp, 0x18(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3440
movq %r14, %rdi
movq %r15, %rsi
callq 0x46a0
movl %eax, %r13d
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x903f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl 0xc(%rsp), %r13d
jne 0x90ae
movl $0x1c, %edx
movq %r12, %rdi
leaq 0x1519(%rip), %rsi      # 0xa56e
callq 0x2270
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
movl $0x14, %edx
movq 0x4f3a(%rip), %rdi      # 0xdfc8
leaq 0x169a(%rip), %rsi      # 0xa72f
callq 0x2270
movq 0x4f37(%rip), %rdi      # 0xdfd8
movq %rbx, %rsi
callq 0x22b0
jmp 0x9003
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x90de
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x90e1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x90e1
movq %rax, %r14
movq (%rbx), %rdi
movq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x90f9
movq (%rax), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/request.cpp
// Function: req::askNames(User)
void req::askNames(User user)
{
    string fName;
    string lName;
    bool valid = false;
    while(!valid) {
        cout << "Enter your first name: ";
        cin >> fName;
        cout << "Enter your last name: ";
        cin >> lName;
        if (fName == user.getFirstName() && lName == user.getLastName())
            valid = true;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbp
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movq 0x4e8c(%rip), %r14      # 0xdfc8
leaq 0x1601(%rip), %r13      # 0xa744
movq 0x4e8e(%rip), %r12      # 0xdfd8
movl $0x17, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2270
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
callq 0x22b0
movl $0x16, %edx
movq %r14, %rdi
leaq 0x15e6(%rip), %rsi      # 0xa75c
callq 0x2270
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x22b0
leaq 0x48(%rsp), %rdi
movq %rbp, %rsi
callq 0x3d96
movq 0x30(%rsp), %rdx
cmpq 0x50(%rsp), %rdx
jne 0x91b9
testq %rdx, %rdx
je 0x91be
movq 0x48(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x2240
testl %eax, %eax
je 0x91be
xorl %r15d, %r15d
jmp 0x9223
leaq 0x68(%rsp), %rdi
movq %rbp, %rbx
movq %rbp, %rsi
callq 0x3dde
movq 0x10(%rsp), %rdx
cmpq 0x70(%rsp), %rdx
jne 0x91f9
movq 0x68(%rsp), %rbp
testq %rdx, %rdx
je 0x9203
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x2240
testl %eax, %eax
sete %r15b
jmp 0x9206
movq 0x68(%rsp), %rbp
xorl %r15d, %r15d
jmp 0x9206
movb $0x1, %r15b
leaq 0x78(%rsp), %rax
cmpq %rax, %rbp
je 0x9220
movq 0x78(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x2230
movq %rbx, %rbp
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x923f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2230
testb %r15b, %r15b
je 0x914a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9264
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x9280
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x92b8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x92b8
jmp 0x92b5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x92d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x92f0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/Kyle-Alvares[P]SQA1/request.cpp
// Function: req::askAmount(double)
double req::askAmount(double max)
{
    double amount;
    bool validDecimal;
    bool valid = false;
    while(!valid) 
    {
        cout << "Enter amount: $";
        cin >> amount;
        string strAmount = to_string(amount);
        string decimal = strAmount.substr(strAmount.find('.') + 1);
        validDecimal = true;
        for(int i = 2; i < decimal.length(); i++)
            if(decimal[i] != '0')
                validDecimal = false;
        if(amount <= 0 || amount > max || !validDecimal)
            cerr << "Error: Invalid amount!" << endl;
        else 
            valid = true;
    }
    return amount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movapd %xmm0, 0x50(%rsp)
movq 0x4c90(%rip), %r13      # 0xdfb0
leaq 0x13ba(%rip), %rbp      # 0xa6e1
leaq 0x30(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq 0x4cb8(%rip), %r15      # 0xdff0
movl $0xf, %edx
movq 0x4c84(%rip), %rdi      # 0xdfc8
leaq 0x1428(%rip), %rsi      # 0xa773
callq 0x2270
movq 0x4c81(%rip), %rdi      # 0xdfd8
leaq 0x8(%rsp), %rsi
callq 0x2170
movsd 0x8(%rsp), %xmm0
movl $0x148, %edx            # imm = 0x148
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rcx
movb $0x1, %al
callq 0x88f6
movq %rbx, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0x22c0
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x2250
movq 0x18(%rsp), %rcx
movb $0x1, %al
cmpq $0x3, %rcx
jb 0x93cb
movl $0x2, %edx
movq 0x10(%rsp), %rsi
cmpb $0x30, (%rsi,%rdx)
sete %dil
andb %dil, %al
incq %rdx
cmpq %rdx, %rcx
jne 0x93b8
movsd 0x8(%rsp), %xmm0
movapd 0x50(%rsp), %xmm1
cmpnltpd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpnlepd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %r12d
andb %al, %r12b
testb $0x1, %r12b
jne 0x9432
movl $0x16, %edx
movq %r15, %rdi
leaq 0x137d(%rip), %rsi      # 0xa783
callq 0x2270
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x944e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x946a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2230
testb $0x1, %r12b
je 0x9338
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x94ad
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x94ad
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x94c9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Selector.hpp
// Function: void evolve::selector::top<std::array<int, 3ul>, 3ul, (evolve::Ordering)1>(std::vector<std::array<int, 3ul>, std::allocator<std::array<int, 3ul>>>&, std::function<float (std::array<int, 3ul> const&)> const&)
void top(std::vector<Genome>& population,
         const std::function<float(const Genome&)>& evaluator) {
    static_assert(Num >= 1, "Selector must leave at least 1 individual in the "
                            "population");
    assert(population.size() >= Num);
    using is_pointer_t = typename std::is_pointer<Genome>::type;
    details::topHelper<Genome, Num, Order>(population, evaluator,
                                           is_pointer_t{});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x2, %rcx
jbe 0x26aa
movq %rdi, %rbx
movl $0x1, %edx
callq 0x2f8d
movq (%rbx), %rax
addq $0x24, %rax
cmpq 0x8(%rbx), %rax
je 0x26a3
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x29f5(%rip), %rdi      # 0x50a6
leaq 0x2a07(%rip), %rsi      # 0x50bf
leaq 0x2a1f(%rip), %rcx      # 0x50de
movl $0x53, %edx
callq 0x20a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Selector.hpp
// Function: void evolve::selector::details::orderedSort<std::array<int, 3ul>>(std::vector<std::array<int, 3ul>, std::allocator<std::array<int, 3ul>>>&, std::function<float (std::array<int, 3ul> const&)> const&, evolve::Ordering)
void orderedSort(std::vector<Genome>& population,
                 const std::function<float(const Genome&)>& evaluator,
                 Ordering Ord) {

    if (Ord == Ordering::LOWER) {
        std::sort(population.begin(), population.end(),
                  [&evaluator](const Genome& left, const Genome& right) {
            return evaluator(left) < evaluator(right);
        });
    } else {
        std::sort(population.begin(), population.end(),
                  [&evaluator](const Genome& left, const Genome& right) {
            return evaluator(left) > evaluator(right);
        });
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r14
testl %edx, %edx
je 0x2ff9
cmpq %r14, %r15
je 0x3049
movq %r14, %rax
subq %r15, %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x37f2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38d3
cmpq %r14, %r15
je 0x3049
movq %r14, %rax
subq %r15, %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x3054
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3135
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/dinitcheck.cc
// Function: report_service_description_exc(service_description_exc&)
static void report_service_description_exc(service_description_exc &exc)
{
    if (exc.input_pos.get_line_num() != (unsigned)-1) {
        report_service_description_err(exc.service_name, exc.input_pos, exc.exc_description);
    }
    else {
        report_service_description_err(exc.service_name, exc.setting_name, exc.exc_description);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, 0x40(%rdi)
je 0xf808
movq 0x1686b(%rip), %r14     # 0x25ff0
leaq 0xd069(%rip), %rsi      # 0x1c7f5
movl $0x9, %edx
movq %r14, %rdi
callq 0x4410
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4410
movq %rax, %r14
leaq 0xded2(%rip), %rsi      # 0x1d684
movl $0x3, %edx
movq %rax, %rdi
callq 0x4410
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq %r14, %rdi
callq 0x4410
movq %rax, %r14
leaq 0xdb9d(%rip), %rsi      # 0x1d376
movl $0x1, %edx
movq %rax, %rdi
callq 0x4410
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x4290
movq %rax, %r14
leaq 0xde8d(%rip), %rsi      # 0x1d688
movl $0x3, %edx
movq %rax, %rdi
jmp 0xf893
movq 0x68(%rbx), %r15
movq 0x167dd(%rip), %r14     # 0x25ff0
leaq 0xcfdb(%rip), %rsi      # 0x1c7f5
movl $0x9, %edx
movq %r14, %rdi
callq 0x4410
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4410
movq %rax, %r14
leaq 0xde4c(%rip), %rsi      # 0x1d68c
movl $0xb, %edx
movq %rax, %rdi
callq 0x4410
testq %r15, %r15
je 0xf86a
movq %r15, %rdi
callq 0x4190
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4410
jmp 0xf884
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x4610
leaq 0xcec4(%rip), %rsi      # 0x1c74f
movl $0x3, %edx
movq %r14, %rdi
callq 0x4410
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x4410
leaq 0xccba(%rip), %rsi      # 0x1c569
movl $0x1, %edx
movq %rax, %rdi
callq 0x4410
movb $0x1, 0x16f26(%rip)     # 0x267e9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::clear_no_inherit()
void clear_no_inherit()
    {
        keep_parent_env = false;
        import_from_parent.clear();
        undefine.clear();
        set_vars.clear();
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x0, (%rdi)
addq $0x8, %rdi
callq 0x12a70
leaq 0x38(%rbx), %rdi
callq 0x12a70
addq $0x68, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x12b0c
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::set_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, bool)
void set_var(std::string &&var_and_val, bool notify = false)
    {
        string_view var_name = find_var_name(var_and_val);

        import_from_parent.erase(var_name);
        auto n_removed = undefine.erase(var_name);

        bool in_sysenv = false;
        if (notify && n_removed == 0) {
            // workaround to avoid an allocation; when notify is true,
            // we know for sure that the value is sanitized from before
            //
            // we don't check this when the variable was in undefine,
            // as that means we were undefining it explicitly
            auto name_size = var_name.size();
            var_and_val[name_size] = '\0';
            in_sysenv = !!bp_sys::getenv(var_and_val.c_str());
            var_and_val[name_size] = '=';
        }

        auto insert_result = set_vars.insert(std::move(var_and_val));
        // if the variable was in sys environment, it is always overridden
        bool overridden = in_sysenv;
        if (!insert_result.second) {
            *insert_result.first = var_and_val;
            overridden = true;
        }

        if (notify) {
            notify_listeners(*insert_result.first, overridden);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
xorl %ecx, %ecx
movzbl (%rax,%rcx), %edx
testl %edx, %edx
je 0x11915
cmpl $0x3d, %edx
je 0x11915
incq %rcx
jmp 0x11903
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rcx, 0x8(%r15)
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x142b6
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x142b6
testq %rax, %rax
setne %al
movl %ebp, %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x1196e
movq 0x10(%rsp), %r13
movq (%r14), %rax
movb $0x0, (%rax,%r13)
movq (%r14), %r15
movq %r15, %rdi
callq 0x4470
testq %rax, %rax
setne %r12b
movb $0x3d, (%r15,%r13)
jmp 0x11971
xorl %r12d, %r12d
leaq 0x68(%rbx), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x1433c
cmpb $0x0, 0x18(%r15)
jne 0x119a0
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x4230
movb $0x1, %r12b
testb %bpl, %bpl
je 0x119d7
movq 0xa8(%rbx), %r15
testq %r15, %r15
je 0x119d7
movq 0x20(%rsp), %r14
addq $0x10, %r14
movzbl %r12b, %ebp
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq *(%rax)
movq (%r15), %r15
testq %r15, %r15
jne 0x119be
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::clear()
void clear() noexcept
    {
        for (auto &bucket : buckets) {
            bucket.clear();
        }
        current_size = 0;
        current_limit = 0;
        buckets.clear();
        try {
            buckets.shrink_to_fit();
        }
        catch (std::bad_alloc &) {
            // ignore any (unlikely) error
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x12ad6
movq %r14, %rdi
callq 0x12458
movq %r14, 0x8(%r14)
movq %r14, (%r14)
movq $0x0, 0x10(%r14)
addq $0x18, %r14
cmpq %r15, %r14
jne 0x12a88
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
cmpq %r14, %r12
je 0x12adf
movq %r14, %r15
movq %r15, %rdi
callq 0x12458
addq $0x18, %r15
cmpq %r12, %r15
jne 0x12abf
movq %r14, 0x10(%rbx)
jmp 0x12ae2
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
jmp 0x12ae2
movq %r12, %r14
cmpq %r14, 0x18(%rbx)
je 0x12aff
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12ba8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::iterator dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::find<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator find(const V &value) noexcept
    {
        if (buckets.empty()) return end();
        size_t hashval = hash_f(value);
        size_t bucket_num = hashval % buckets.size();
        for (auto list_it = buckets[bucket_num].begin(); list_it != buckets[bucket_num].end(); ++list_it) {
            if (key_equal_f(*list_it, value)) {
                return { &buckets, list_it, bucket_num };
            }
        }
        return end();
    }

// Assembly:
movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdi
cmpq %rdi, %rcx
je 0x14e26
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movq %rax, (%rsp)
movq (%rdx), %r15
movq 0x8(%rdx), %rbp
testq %rbp, %rbp
je 0x14e35
xorl %ebx, %ebx
movq %rbp, %r12
xorl %r14d, %r14d
movq %r14, %r13
movq $0x0, 0x8(%rsp)
leaq (%r15,%rbx), %rsi
cmpq $0x8, %r12
movl $0x8, %edx
cmovbq %r12, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4310
shlq $0x5, %r13
subq %r14, %r13
addq 0x8(%rsp), %r13
addq $0x8, %rbx
addq $-0x8, %r12
movq %r13, %r14
cmpq %rbp, %rbx
jb 0x14de4
jmp 0x14e38
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $-0x1, 0x10(%rax)
retq
xorl %r13d, %r13d
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %r14
movq (%r14), %rbx
cmpq %r14, %rbx
movq 0x20(%rsp), %r12
je 0x14ea1
movq %rdx, %r13
addq $0x8, %r12
cmpq %rbp, 0x18(%rbx)
jne 0x14e99
testq %rbp, %rbp
je 0x14eb5
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x43b0
testl %eax, %eax
je 0x14eb5
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x14e7b
xorps %xmm0, %xmm0
movq (%rsp), %rax
movups %xmm0, (%rax)
movq $-0x1, 0x10(%rax)
jmp 0x14ec4
movq (%rsp), %rax
movq %r12, (%rax)
movq %rbx, 0x8(%rax)
movq %r13, 0x10(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::begin()
iterator begin() noexcept
    {
        if (current_size == 0) return end();
        for (size_t i = 0; i < buckets.size(); ++i) {
            if (!buckets[i].empty()) {
                return { &buckets, buckets[i].begin(), i };
            }
        }
        return end(); // (should not be reachable)
    }

// Assembly:
movq %rdi, %rax
cmpq $0x0, 0x20(%rsi)
je 0x13a83
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdi
subq %rcx, %rdi
je 0x13a83
addq $0x8, %rsi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %edi, %edi
movq (%rcx), %r8
cmpq %r8, %rcx
jne 0x13a92
incq %rdi
addq $0x18, %rcx
cmpq %rdi, %rdx
jne 0x13a6f
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $-0x1, 0x10(%rax)
retq
movq %rsi, (%rax)
movq %r8, 0x8(%rax)
movq %rdi, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-util.h
// Function: unsigned long dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::erase<string_view>(string_view const&)
size_type erase(const V &value) noexcept
    {
        auto it = find(value);
        if (it != end()) {
            buckets[it.bucket_num].erase(it.list_it);
            return 1;
        }
        return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13538
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
movq %rax, %rcx
notq %rcx
orq %rsi, %rcx
je 0x142fc
leaq (%rax,%rax,2), %rdi
shlq $0x3, %rdi
addq 0x8(%rbx), %rdi
callq 0x14306
movl $0x1, %eax
jmp 0x142fe
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_env_name, env_equal_name>::rehash(unsigned long)
void rehash(size_type new_bucket_count)
    {
        // calculate minimum bucket count, limited by maximum possible count.
        size_t max_buckets = buckets.max_size();
        size_t max_count = buckets_to_max(max_buckets);
        size_t min_buckets;
        if (current_size > max_count) {
            min_buckets = max_buckets;
        }
        else {
            size_t base = current_size / 3 * 4;
            size_t extra = (current_size % 3) * 4 / 3;
            min_buckets = base + extra;
        }

        new_bucket_count = std::max(new_bucket_count, min_buckets);

        if (new_bucket_count < buckets.size()) {
            // buckets vector will shrink: we need to reallocate entries into their new buckets first
            do_rehash(new_bucket_count);
            buckets.resize(new_bucket_count);
        }
        else {
            // grow the vector, then rehash
            buckets.resize(new_bucket_count);
            do_rehash(new_bucket_count);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rcx
movq %rcx, %rax
shrq $0x3a, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
je 0x1461e
movabsq $0x555555555555555, %rax # imm = 0x555555555555555
jmp 0x1463c
movq %rcx, %rax
mulq %rsi
shrq %rdx
leal (%rdx,%rdx,2), %eax
subl %eax, %ecx
shlb $0x2, %cl
movzbl %cl, %eax
imull $0x56, %eax, %eax
shrl $0x8, %eax
leaq (%rax,%rdx,4), %rax
cmpq %rbx, %rax
cmovaq %rax, %rbx
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
leaq 0x8(%r14), %r15
sarq $0x3, %rax
imulq %rsi, %rax
cmpq %rax, %rbx
jae 0x14677
movq %r14, %rdi
movq %rbx, %rsi
callq 0x148bc
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x14574
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14574
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x148bc
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string_view get(const std::string &name) const
    {
        auto it = set_vars.find(string_view(name));
        if (it != set_vars.end()) {
            return *it;
        }

        if (!keep_parent_env && !import_from_parent.contains(name)) {
            return {};
        }

        const char *val = bp_sys::getenv(name.c_str());
        if (val == nullptr) {
            return {};
        }
        const char *name_and_val = val - (name.length() + 1);
        size_t val_len = strlen(val);
        return {name_and_val, name.length() + 1 + val_len};
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rsi
movq (%rbx), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rdx)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x14c08
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
notq %rcx
orq %rax, %rcx
je 0x14a89
movq 0x10(%rax), %r14
movq 0x18(%rax), %rdx
jmp 0x14aed
cmpb $0x0, (%r14)
je 0x14aba
movq (%rbx), %rdi
callq 0x4470
testq %rax, %rax
je 0x14ae8
movq 0x8(%rbx), %rbx
movq %rbx, %r14
notq %r14
addq %rax, %r14
movq %rax, %rdi
callq 0x4190
leaq (%rbx,%rax), %rdx
incq %rdx
jmp 0x14aed
addq $0x8, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x14d9c
cmpq $-0x1, 0x10(%r15)
jne 0x14a8f
xorl %edx, %edx
cmpq $0x0, 0x8(%rsp)
movl $0x0, %r14d
je 0x14aed
jmp 0x14a8f
xorl %edx, %edx
xorl %r14d, %r14d
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::undefine_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, bool)
void undefine_var(std::string &&var_name, bool notify = false)
    {
        import_from_parent.erase(var_name);

        auto n_removed = set_vars.erase(string_view(var_name));
        bool was_set = n_removed > 0;
        if (notify && !was_set) {
            // also track if we're undefining it from system environment
            was_set = !!bp_sys::getenv(var_name.c_str());
        }
        if (keep_parent_env) {
            auto insert_result = undefine.insert(std::move(var_name));
            if (notify) {
                notify_listeners(*insert_result.first, was_set);
            }
        }
        else if (notify) {
            notify_listeners(var_name, was_set);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x15a6e
leaq 0x68(%rbx), %rdi
movq (%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsi)
callq 0x15abe
testq %rax, %rax
setne %r15b
movl %ebp, %eax
xorb $0x1, %al
orb %r15b, %al
jne 0x157da
movq (%r14), %rdi
callq 0x4470
testq %rax, %rax
setne %r15b
cmpb $0x1, (%rbx)
jne 0x15829
leaq 0x38(%rbx), %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0x15b0e
testb %bpl, %bpl
je 0x1585e
movq 0xa8(%rbx), %r12
testq %r12, %r12
je 0x1585e
movq 0x8(%rsp), %r14
addq $0x10, %r14
movzbl %r15b, %ebp
movq 0x8(%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq *(%rax)
movq (%r12), %r12
testq %r12, %r12
jne 0x1580c
jmp 0x1585e
movq 0xa8(%rbx), %r12
testq %r12, %r12
setne %al
andb %al, %bpl
cmpb $0x1, %bpl
jne 0x1585e
movzbl %r15b, %ebp
movq 0x8(%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq *(%rax)
movq (%r12), %r12
testq %r12, %r12
jne 0x15843
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::import_parent_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
void import_parent_var(std::string &&var_name)
    {
        undefine.erase(var_name);
        set_vars.erase(string_view(var_name));
        if (!keep_parent_env) {
            import_from_parent.insert(std::move(var_name));
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x38, %rdi
callq 0x15a6e
leaq 0x68(%r14), %rdi
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsi)
callq 0x15abe
cmpb $0x0, (%r14)
jne 0x158b8
addq $0x8, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15b0e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::do_rehash(unsigned long)
void do_rehash(size_t new_buckets) noexcept
    {
        // note, buckets vector is already at least new_buckets in size
        size_t old_buckets = buckets.size();

        // first splice all nodes from all buckets into a single list
        std::list<K> all_nodes;
        for (size_t i = 0; i < old_buckets; ++i) {
            all_nodes.splice(all_nodes.end(), buckets[i]);
        }

        // now put all nodes into the correct bucket
        auto node_i = all_nodes.begin();
        while (node_i != all_nodes.end()) {
            auto next_node_i = std::next(node_i);
            size_t hashval = hash_f(*node_i);
            size_t bucket_num = hashval % new_buckets;
            buckets[bucket_num].splice(buckets[bucket_num].end(), all_nodes, node_i);
            node_i = next_node_i;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
leaq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rdx)
movq %rdx, (%rdx)
movq $0x0, 0x10(%rdx)
subq %rcx, %rax
je 0x15f59
movq %rdi, %r13
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbx
cmpq $0x1, %rbx
adcq $0x0, %rbx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r12
movq 0x8(%r13), %r15
leaq (%r15,%r14), %rdx
movq (%r15,%r14), %rsi
cmpq %rsi, %rdx
je 0x15e77
movq %r12, %rdi
callq 0x41f0
movq 0x10(%r15,%r14), %rax
addq %rax, 0x20(%rsp)
movq $0x0, 0x10(%r15,%r14)
addq $0x18, %r14
decq %rbx
jne 0x15e4b
movq 0x10(%rsp), %r14
cmpq %r12, %r14
je 0x15f59
leaq 0x8(%rsp), %r12
movq %r13, 0x28(%rsp)
movq %r14, %rsi
movq (%r14), %r14
movq 0x18(%rsi), %rbx
testq %rbx, %rbx
je 0x15f12
movq %r14, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x10(%rsi), %r14
movq %rbx, %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
leaq (%r14,%r13), %rsi
cmpq $0x8, %r15
movl $0x8, %edx
cmovbq %r15, %rdx
movq %r12, %rdi
callq 0x4310
movq %rbp, %rax
shlq $0x5, %rax
subq %rbp, %rax
movq %rax, %rbp
addq 0x8(%rsp), %rbp
addq $0x8, %r13
addq $-0x8, %r15
cmpq %rbx, %r13
jb 0x15ebd
movq 0x38(%rsp), %rsi
movq (%rsi), %rcx
movq 0x28(%rsp), %r13
movq 0x40(%rsp), %r14
jmp 0x15f17
movq %r14, %rcx
xorl %ebp, %ebp
movq %rbp, %rax
xorl %edx, %edx
divq 0x30(%rsp)
leaq (%rdx,%rdx,2), %rbp
shlq $0x3, %rbp
addq 0x8(%r13), %rbp
cmpq %rsi, %rbp
je 0x15f4b
cmpq %rbp, %rcx
je 0x15f4b
movq %rbp, %rdi
movq %rcx, %rdx
callq 0x41f0
incq 0x10(%rbp)
decq 0x20(%rsp)
leaq 0x10(%rsp), %rax
cmpq %rax, %r14
jne 0x15e98
leaq 0x10(%rsp), %rdi
callq 0x12458
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq