LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movss -0x48(%rbp), %xmm1
callq 0x20bf0
movss %xmm1, -0x58(%rbp)
movlpd %xmm0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x34(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x34(%rbp), %rdi
callq 0x20b90
movss %xmm0, -0x64(%rbp)
movss -0x1c(%rbp), %xmm0
mulss -0x1c(%rbp), %xmm0
movss -0x64(%rbp), %xmm1
movss -0x64(%rbp), %xmm2
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm1
movss 0x1fa57(%rip), %xmm2    # 0x22008
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1fadb(%rip), %xmm0    # 0x220a0
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x68(%rbp)
movss -0x68(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2744
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x124(%rbp)
movq -0x18(%rbp), %rdi
movss -0x64(%rbp), %xmm0
callq 0x20c80
movss %xmm1, -0xa8(%rbp)
movlpd %xmm0, -0xb0(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x20a30
movaps %xmm0, %xmm2
movss -0x124(%rbp), %xmm0
movaps %xmm2, -0x120(%rbp)
movaps %xmm1, %xmm2
movaps -0x120(%rbp), %xmm1
movss %xmm2, -0xb8(%rbp)
movlpd %xmm1, -0xc0(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x20aa0
movss %xmm1, -0xc8(%rbp)
movlpd %xmm0, -0xd0(%rbp)
movl -0xc8(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x108(%rbp)
movss -0x68(%rbp), %xmm0
callq 0x20cf0
movq -0x108(%rbp), %rdi
callq 0x20c80
movss %xmm1, -0xe8(%rbp)
movlpd %xmm0, -0xf0(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xd8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x20a30
movss %xmm1, -0xf8(%rbp)
movlpd %xmm0, -0x100(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0x74(%rbp)
movl -0xf8(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x28(%rbp), %rax
movq -0x74(%rbp), %rcx
movq %rcx, (%rax)
movl -0x6c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2748
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daltonbr[P]RayTracing/./src/hitable_list.h
// Function: hitable_list::hit(ray const&, float, float, hit_record&) const
bool hitable_list::hit(const ray& r, float t_min, float t_max, hit_record& rec) const
{
    hit_record temp_rec;
    bool hit_anything = false;
    double closest_so_far = t_max;
    for (int i = 0; i < list_size; i++)
    {
        if (list[i]->hit(r, t_min, closest_so_far, temp_rec))
        {
            hit_anything = true;
            closest_so_far = temp_rec.t;
            rec = temp_rec;
        }
    }
    return hit_anything;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20e90
movb $0x0, -0x49(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq -0x68(%rbp), %rcx
movl -0x5c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x2d46
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
movq (%rdi), %rax
leaq -0x48(%rbp), %rdx
callq *(%rax)
testb $0x1, %al
jne 0x2d15
jmp 0x2d39
movb $0x1, -0x49(%rbp)
movss -0x48(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x28, %edx
callq 0x20a0
jmp 0x2d3b
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x2cd8
movb -0x49(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daltonbr[P]RayTracing/./src/camera.h
// Function: camera::camera()
camera()
    {
        lower_left_corner = vec3(-2.0, -1.0, -1.0);
        horizontal = vec3(4.0, 0.0, 0.0);
        vertical = vec3(0.0, 2.0, 0.0);
        origin = vec3(0.0, 0.0, 0.0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x20a20
movq -0x40(%rbp), %rdi
addq $0xc, %rdi
callq 0x20a20
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x20a20
movq -0x40(%rbp), %rdi
addq $0x24, %rdi
callq 0x20a20
leaq -0x14(%rbp), %rdi
movss 0xe94(%rip), %xmm0      # 0x22070
movss 0xe58(%rip), %xmm2      # 0x2203c
movaps %xmm2, %xmm1
callq 0x20b10
movq -0x40(%rbp), %rax
movq -0x14(%rbp), %rcx
movq %rcx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
leaq -0x20(%rbp), %rdi
movss 0xe62(%rip), %xmm0      # 0x2206c
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0x20b10
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x20(%rax)
leaq -0x2c(%rbp), %rdi
xorps %xmm2, %xmm2
movss 0xdce(%rip), %xmm1      # 0x22004
movaps %xmm2, %xmm0
callq 0x20b10
movq -0x40(%rbp), %rax
movq -0x2c(%rbp), %rcx
movq %rcx, 0x24(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x2c(%rax)
leaq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x20b10
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movl -0x30(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: daltonbr[P]RayTracing/./src/material.h
// Function: lambertian::scatter(ray const&, hit_record const&, vec3&, ray&) const
virtual bool scatter(const ray&  r_in, const hit_record& rec, vec3& attenuation, ray& scattered) const
    {
        vec3 target = rec.p + rec.normal + random_in_unit_sphere();
        scattered = ray(rec.p, target - rec.p);
        attenuation = albedo;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x4, %rdi
addq $0x10, %rsi
callq 0x20f80
movss %xmm1, -0x50(%rbp)
movlpd %xmm0, -0x58(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x2360
movss %xmm1, -0x70(%rbp)
movlpd %xmm0, -0x78(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x20f80
movss %xmm1, -0x80(%rbp)
movlpd %xmm0, -0x88(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
movq %rsi, -0xd0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20a30
movq -0xd0(%rbp), %rsi
movss %xmm1, -0xb8(%rbp)
movlpd %xmm0, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xac(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xac(%rbp), %rdx
callq 0x21700
movq -0xc8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0xa0(%rbp), %rdx
movq %rdx, (%rax)
movq -0x98(%rbp), %rdx
movq %rdx, 0x8(%rax)
movq -0x90(%rbp), %rdx
movq %rdx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: daltonbr[P]RayTracing/./src/material.h
// Function: metal::scatter(ray const&, hit_record const&, vec3&, ray&) const
virtual bool scatter(const ray& r_in, const hit_record& rec, vec3& attenuation, ray& scattered) const
    {
        vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
        scattered = ray(rec.p, reflected + fuzz * random_in_unit_sphere());
        attenuation = albedo;
        return (dot(scattered.direction(), rec.normal) > 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d50
movss %xmm1, -0x60(%rbp)
movlpd %xmm0, -0x68(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
movsd -0x78(%rbp), %xmm0
movss -0x70(%rbp), %xmm1
callq 0x20bf0
movss %xmm1, -0x80(%rbp)
movlpd %xmm0, -0x88(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
leaq -0x48(%rbp), %rdi
callq 0x2480
movq -0x138(%rbp), %rax
movss %xmm1, -0x90(%rbp)
movlpd %xmm0, -0x98(%rbp)
movl -0x90(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movq -0x98(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, -0x140(%rbp)
movss 0x14(%rax), %xmm0
movss %xmm0, -0x154(%rbp)
callq 0x2360
movaps %xmm0, %xmm2
movss -0x154(%rbp), %xmm0
movaps %xmm2, -0x150(%rbp)
movaps %xmm1, %xmm2
movaps -0x150(%rbp), %xmm1
movss %xmm2, -0xe8(%rbp)
movlpd %xmm1, -0xf0(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xd8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x20aa0
movss %xmm1, -0xf8(%rbp)
movlpd %xmm0, -0x100(%rbp)
movl -0xf8(%rbp), %eax
movl %eax, -0xc8(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x20f80
movq -0x140(%rbp), %rsi
movss %xmm1, -0x108(%rbp)
movlpd %xmm0, -0x110(%rbp)
movl -0x108(%rbp), %eax
movl %eax, -0xb8(%rbp)
movq -0x110(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
callq 0x21700
movq -0x138(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0xa0(%rbp), %rdx
movq %rdx, 0x10(%rax)
movups -0xb0(%rbp), %xmm0
movups %xmm0, (%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rcx), %edx
movl %edx, 0x8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x20d50
movss %xmm1, -0x128(%rbp)
movlpd %xmm0, -0x130(%rbp)
movq -0x130(%rbp), %rax
movq %rax, -0x11c(%rbp)
movl -0x128(%rbp), %eax
movl %eax, -0x114(%rbp)
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
leaq -0x11c(%rbp), %rdi
callq 0x20b90
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4520
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x6227
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6b20
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x3050
cmpl $0x0, %eax
jne 0x621a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x622e
jmp 0x621c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61d3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3160
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x61b0
movl %eax, -0x58(%rbp)
jmp 0x627c
leaq -0x48(%rbp), %rdi
callq 0x31f0
movl -0x58(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x62ae
movb $0x0, -0x1(%rbp)
jmp 0x62e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31f0
jmp 0x62f3
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x62be
movb $0x0, -0x1(%rbp)
jmp 0x62e8
movq -0x68(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x6b20
movsd -0x70(%rbp), %xmm0
addsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3160
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x61b0
movl %eax, -0x58(%rbp)
jmp 0x633f
leaq -0x48(%rbp), %rdi
callq 0x31f0
movl -0x58(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x6371
movb $0x0, -0x1(%rbp)
jmp 0x63d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31f0
jmp 0x63e0
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jae 0x639e
movq -0x68(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x6b20
movsd -0x70(%rbp), %xmm0
ucomisd 0x28(%rax), %xmm0
jbe 0x63a4
movb $0x0, -0x1(%rbp)
jmp 0x63d2
movq -0x68(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x6b20
movsd -0x78(%rbp), %xmm1
movsd 0x28(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5980
testb $0x1, %al
jne 0x6424
movb $0x0, -0x1(%rbp)
jmp 0x6537
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3160
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x61b0
movl %eax, -0x8c(%rbp)
jmp 0x6453
leaq -0x38(%rbp), %rdi
callq 0x31f0
movl -0x8c(%rbp), %eax
cmpl $-0x1, %eax
je 0x648a
movb $0x0, -0x1(%rbp)
jmp 0x6537
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31f0
jmp 0x6545
leaq -0x78(%rbp), %rdi
callq 0x6a50
movq -0x88(%rbp), %rsi
movb $0x0, -0x78(%rbp)
movb $0x0, -0x77(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3060
jmp 0x64ad
movq $0x0, -0x50(%rbp)
movq 0xcb04(%rip), %rdi      # 0x12fc0
movq 0xcadd(%rip), %rsi      # 0x12fa0
callq 0x3310
movq %rax, -0xa0(%rbp)
jmp 0x64d1
movq -0xa0(%rbp), %rdi
leaq 0x6cfa(%rip), %rsi      # 0xd1d9
callq 0x32d0
movq %rax, -0xa8(%rbp)
jmp 0x64ed
movq -0xa8(%rbp), %rdi
movq 0xcaa5(%rip), %rsi      # 0x12fa0
callq 0x3310
jmp 0x6502
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6a70
jmp 0x6511
movb $0x1, -0x1(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4c20
jmp 0x6537
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4c20
jmp 0x6545
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34c0
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5980
testb $0x1, %al
jne 0x657b
movb $0x0, -0x1(%rbp)
jmp 0x65e4
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3160
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x61b0
movl %eax, -0x64(%rbp)
jmp 0x659e
leaq -0x40(%rbp), %rdi
callq 0x31f0
movl -0x64(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x65d0
movb $0x0, -0x1(%rbp)
jmp 0x65e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31f0
jmp 0x65ef
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6b20
movb $0x1, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5980
testb $0x1, %al
jne 0x662b
movb $0x0, -0x1(%rbp)
jmp 0x6694
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3160
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x61b0
movl %eax, -0x64(%rbp)
jmp 0x664e
leaq -0x40(%rbp), %rdi
callq 0x31f0
movl -0x64(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x6680
movb $0x0, -0x1(%rbp)
jmp 0x6694
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31f0
jmp 0x669f
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6b20
movb (%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5980
testb $0x1, %al
jne 0x66e1
movb $0x0, -0x1(%rbp)
jmp 0x6782
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3160
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x61b0
movl %eax, -0x84(%rbp)
jmp 0x670d
leaq -0x40(%rbp), %rdi
callq 0x31f0
movl -0x84(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x6742
movb $0x0, -0x1(%rbp)
jmp 0x6782
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31f0
jmp 0x6790
movq -0x78(%rbp), %rdi
callq 0x6bd0
movq %rax, -0x68(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x6c00
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6c40
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x6b60
movq %rax, -0x70(%rbp)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5980
testb $0x1, %al
jne 0x67d1
movb $0x0, -0x1(%rbp)
jmp 0x6855
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3160
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x61b0
movl %eax, -0x64(%rbp)
jmp 0x67f4
leaq -0x40(%rbp), %rdi
callq 0x31f0
movl -0x64(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x6826
movb $0x0, -0x1(%rbp)
jmp 0x6855
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31f0
jmp 0x6863
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6b20
movq -0x58(%rbp), %rdi
movb 0x1(%rax), %al
xorb $-0x1, %al
movb %al, -0x71(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x6b20
movb -0x71(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: Kyle-Alvares[P]SQA1/session.cpp
// Function: Session::deleteAccount()
void Session::deleteAccount() {
    cout << endl << "========DELETE ACCOUNT========" << endl;
    if(!user.isAdmin()) { 
        cerr << "Error: privileged transaction!" << endl; 
    } else {
        string accountName = askAccountName(user, -1);
        user.deleteAccount(accountName);
        transactions.push_back("06" + username + "00000000");
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movq 0x954f(%rip), %rdi      # 0x12fc0
movq 0x9528(%rip), %rsi      # 0x12fa0
callq 0x3310
movq %rax, %rdi
leaq 0x3af9(%rip), %rsi      # 0xd580
callq 0x32d0
movq %rax, %rdi
movq 0x950a(%rip), %rsi      # 0x12fa0
callq 0x3310
movq -0x148(%rbp), %rdi
callq 0x5980
testb $0x1, %al
jne 0x9ad2
movq 0x953e(%rip), %rdi      # 0x12ff0
leaq 0x3a7f(%rip), %rsi      # 0xd538
callq 0x32d0
movq %rax, %rdi
movq 0x94d8(%rip), %rsi      # 0x12fa0
callq 0x3310
jmp 0x9c7a
movq -0x148(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x4210
movq -0x150(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc6e0
jmp 0x9b03
leaq -0xd0(%rbp), %rdi
callq 0x4330
movq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3160
jmp 0x9b2f
movq -0x158(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x66b0
jmp 0x9b44
leaq -0x100(%rbp), %rdi
callq 0x31f0
movq -0x148(%rbp), %rdx
movq %rdx, %rax
addq $0xc8, %rax
movq %rax, -0x160(%rbp)
addq $0xa8, %rdx
leaq 0x3a2a(%rip), %rsi      # 0xd59f
leaq -0x140(%rbp), %rdi
callq 0xa5e0
jmp 0x9b83
leaq 0x39ed(%rip), %rdx      # 0xd577
leaq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x6890
jmp 0x9b9f
movq -0x160(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xa5b0
jmp 0x9bb4
leaq -0x120(%rbp), %rdi
callq 0x31f0
leaq -0x140(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0x9c7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x4330
jmp 0x9c83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x9c6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x31f0
jmp 0x9c6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x9c63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x31f0
leaq -0x140(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0x9c83
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x34c0
nop
// File: Kyle-Alvares[P]SQA1/session.cpp
// Function: Session::disableAccount()
void Session::disableAccount() {
    cout << endl << "========DISABLE ACCOUNT=======" << endl;
    if(!user.isAdmin()) { 
        cerr << "Error: privileged transaction!" << endl; 
    } else {
        string accountName = askAccountName(user, -1);
        user.disableAccount(accountName);
        transactions.push_back("07" + username + "00000000");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movq 0x930f(%rip), %rdi      # 0x12fc0
movq 0x92e8(%rip), %rsi      # 0x12fa0
callq 0x3310
movq %rax, %rdi
leaq 0x38db(%rip), %rsi      # 0xd5a2
callq 0x32d0
movq %rax, %rdi
movq 0x92ca(%rip), %rsi      # 0x12fa0
callq 0x3310
movq -0x148(%rbp), %rdi
callq 0x5980
testb $0x1, %al
jne 0x9d12
movq 0x92fe(%rip), %rdi      # 0x12ff0
leaq 0x383f(%rip), %rsi      # 0xd538
callq 0x32d0
movq %rax, %rdi
movq 0x9298(%rip), %rsi      # 0x12fa0
callq 0x3310
jmp 0x9eba
movq -0x148(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x4210
movq -0x150(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc6e0
jmp 0x9d43
leaq -0xd0(%rbp), %rdi
callq 0x4330
movq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3160
jmp 0x9d6f
movq -0x158(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x6550
jmp 0x9d84
leaq -0x100(%rbp), %rdi
callq 0x31f0
movq -0x148(%rbp), %rdx
movq %rdx, %rax
addq $0xc8, %rax
movq %rax, -0x160(%rbp)
addq $0xa8, %rdx
leaq 0x380c(%rip), %rsi      # 0xd5c1
leaq -0x140(%rbp), %rdi
callq 0xa5e0
jmp 0x9dc3
leaq 0x37ad(%rip), %rdx      # 0xd577
leaq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x6890
jmp 0x9ddf
movq -0x160(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xa5b0
jmp 0x9df4
leaq -0x120(%rbp), %rdi
callq 0x31f0
leaq -0x140(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0x9eba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x4330
jmp 0x9ec3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x9eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x31f0
jmp 0x9eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x9ea3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x31f0
leaq -0x140(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0x9ec3
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x34c0
nop
// File: Kyle-Alvares[P]SQA1/session.cpp
// Function: Session::changePlan()
void Session::changePlan() {
    cout << endl << "=========CHANGE PLAN==========" << endl;
    if(!user.isAdmin()) { 
        cerr << "Error: privileged transaction!" << endl; 
    } else {
        string accountName = askAccountName(user, -1);
        user.changePlan(accountName);
        transactions.push_back("08" + username + "00000000");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movq 0x90cf(%rip), %rdi      # 0x12fc0
movq 0x90a8(%rip), %rsi      # 0x12fa0
callq 0x3310
movq %rax, %rdi
leaq 0x36bd(%rip), %rsi      # 0xd5c4
callq 0x32d0
movq %rax, %rdi
movq 0x908a(%rip), %rsi      # 0x12fa0
callq 0x3310
movq -0x148(%rbp), %rdi
callq 0x5980
testb $0x1, %al
jne 0x9f52
movq 0x90be(%rip), %rdi      # 0x12ff0
leaq 0x35ff(%rip), %rsi      # 0xd538
callq 0x32d0
movq %rax, %rdi
movq 0x9058(%rip), %rsi      # 0x12fa0
callq 0x3310
jmp 0xa0fa
movq -0x148(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x4210
movq -0x150(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc6e0
jmp 0x9f83
leaq -0xd0(%rbp), %rdi
callq 0x4330
movq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3160
jmp 0x9faf
movq -0x158(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x67a0
jmp 0x9fc4
leaq -0x100(%rbp), %rdi
callq 0x31f0
movq -0x148(%rbp), %rdx
movq %rdx, %rax
addq $0xc8, %rax
movq %rax, -0x160(%rbp)
addq $0xa8, %rdx
leaq 0x35ee(%rip), %rsi      # 0xd5e3
leaq -0x140(%rbp), %rdi
callq 0xa5e0
jmp 0xa003
leaq 0x356d(%rip), %rdx      # 0xd577
leaq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x6890
jmp 0xa01f
movq -0x160(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xa5b0
jmp 0xa034
leaq -0x120(%rbp), %rdi
callq 0x31f0
leaq -0x140(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0xa0fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x4330
jmp 0xa103
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xa0ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x31f0
jmp 0xa0ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xa0e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x31f0
leaq -0x140(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0xa103
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x34c0
nop
// File: Kyle-Alvares[P]SQA1/request.cpp
// Function: req::askAccountNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int req::askAccountNumber(string errMsg)
{
    bool validAccount = false;
    int accountNumber;
    while (!validAccount)
    {
        validAccount = true;
        cin >> accountNumber;
        ifstream ifs("./users/" + to_string(accountNumber) + ".txt");
        if (ifs.fail())
        {
            cerr << "Error: Invalid account number!\n";
            cerr << errMsg;
            validAccount = false;
        }
    }
    return accountNumber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x290(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc528
jmp 0xc6bb
movb $0x1, -0x9(%rbp)
movq 0x6aa5(%rip), %rdi      # 0x12fd8
leaq -0x10(%rbp), %rsi
callq 0x31e0
movl -0x10(%rbp), %esi
leaq -0x278(%rbp), %rdi
movq %rdi, -0x298(%rbp)
callq 0x6930
movq -0x298(%rbp), %rdx
leaq 0xbda(%rip), %rsi       # 0xd13a
leaq -0x258(%rbp), %rdi
callq 0x68e0
jmp 0xc56e
leaq 0xbce(%rip), %rdx       # 0xd143
leaq -0x238(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x6890
jmp 0xc58a
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
movl $0x8, %edx
callq 0x3490
jmp 0xc5a4
leaq -0x238(%rbp), %rdi
callq 0x31f0
leaq -0x258(%rbp), %rdi
callq 0x31f0
leaq -0x278(%rbp), %rdi
callq 0x31f0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x299(%rbp)
jmp 0xc5e8
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0xc5f7
jmp 0xc6aa
movq 0x69f2(%rip), %rdi      # 0x12ff0
leaq 0x10fa(%rip), %rsi      # 0xd6ff
callq 0x32d0
jmp 0xc60c
movq -0x290(%rbp), %rsi
movq 0x69d6(%rip), %rdi      # 0x12ff0
callq 0x32a0
jmp 0xc621
movb $0x0, -0x9(%rbp)
jmp 0xc6aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
jmp 0xc67c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
jmp 0xc670
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x31f0
leaq -0x258(%rbp), %rdi
callq 0x31f0
leaq -0x278(%rbp), %rdi
callq 0x31f0
jmp 0xc6c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30c0
jmp 0xc6c7
leaq -0x218(%rbp), %rdi
callq 0x30c0
jmp 0xc51a
movl -0x10(%rbp), %eax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x280(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x3400
movq 0x68ae(%rip), %rdi      # 0x12fc0
leaq 0x1006(%rip), %rsi      # 0xd71f
callq 0x32d0
jmp 0xc720
movq -0x58(%rbp), %rsi
movq 0x68ad(%rip), %rdi      # 0x12fd8
callq 0x33b0
jmp 0xc732
jmp 0xc734
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3160
jmp 0xc743
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x61b0
movl %eax, -0x64(%rbp)
jmp 0xc755
movl -0x14(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31f0
movl -0x68(%rbp), %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jne 0xc7ea
movq 0x687b(%rip), %rdi      # 0x12ff0
leaq 0xddb(%rip), %rsi       # 0xd557
callq 0x32d0
movq %rax, -0x70(%rbp)
jmp 0xc787
movq -0x70(%rbp), %rdi
movq 0x680e(%rip), %rsi      # 0x12fa0
callq 0x3310
jmp 0xc799
movq 0x6820(%rip), %rdi      # 0x12fc0
leaq 0xf78(%rip), %rsi       # 0xd71f
callq 0x32d0
jmp 0xc7ae
movq -0x58(%rbp), %rsi
movq 0x681f(%rip), %rdi      # 0x12fd8
callq 0x33b0
jmp 0xc7c0
jmp 0xc734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xc807
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31f0
jmp 0xc807
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xc7fd
movq -0x58(%rbp), %rdi
callq 0x31f0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x31f0
movq -0x20(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3400
leaq -0x48(%rbp), %rdi
callq 0x3400
movb $0x0, -0x49(%rbp)
movb -0x49(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc85a
jmp 0xc979
movq 0x675f(%rip), %rdi      # 0x12fc0
leaq 0xecc(%rip), %rsi       # 0xd734
callq 0x32d0
jmp 0xc86f
movq 0x6762(%rip), %rdi      # 0x12fd8
leaq -0x28(%rbp), %rsi
callq 0x33b0
jmp 0xc881
movq 0x6738(%rip), %rdi      # 0x12fc0
leaq 0xebd(%rip), %rsi       # 0xd74c
callq 0x32d0
jmp 0xc896
movq 0x673b(%rip), %rdi      # 0x12fd8
leaq -0x48(%rbp), %rsi
callq 0x33b0
jmp 0xc8a8
movq -0xb0(%rbp), %rsi
movb $0x0, -0xa1(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x58b0
jmp 0xc8c1
leaq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xcb60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0xc8df
jmp 0xc911
movq -0xb0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x5910
jmp 0xc8f4
movb $0x1, -0xa1(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xcb60
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
movb %al, -0xb2(%rbp)
testb $0x1, -0xa1(%rbp)
jne 0xc928
jmp 0xc934
leaq -0xa0(%rbp), %rdi
callq 0x31f0
leaq -0x80(%rbp), %rdi
callq 0x31f0
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0xc949
jmp 0xc974
movb $0x1, -0x49(%rbp)
jmp 0xc974
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xc994
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31f0
jmp 0xc994
jmp 0xc84c
leaq -0x48(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x31f0
leaq -0x28(%rbp), %rdi
callq 0x31f0
movq -0x58(%rbp), %rdi
callq 0x34c0
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movb $0x0, -0x12(%rbp)
movb -0x12(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc9e2
jmp 0xcb3c
movq 0x65d7(%rip), %rdi      # 0x12fc0
leaq 0xd73(%rip), %rsi       # 0xd763
callq 0x32d0
movq 0x65dc(%rip), %rdi      # 0x12fd8
leaq -0x10(%rbp), %rsi
callq 0x3250
movsd -0x10(%rbp), %xmm0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa6f0
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x2e, %esi
callq 0x33e0
movq -0x70(%rbp), %rsi
movq %rax, %rdx
incq %rdx
leaq -0x58(%rbp), %rdi
movq $-0x1, %rcx
callq 0x3300
jmp 0xca45
movb $0x1, -0x11(%rbp)
movl $0x2, -0x68(%rbp)
movslq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3450
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0xcac7
movslq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3560
movq %rax, -0x80(%rbp)
jmp 0xca80
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0xcaba
movb $0x0, -0x11(%rbp)
jmp 0xcaba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xcb31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31f0
jmp 0xcb31
jmp 0xcabc
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0xca50
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jae 0xcae3
movsd -0x10(%rbp), %xmm0
ucomisd -0x8(%rbp), %xmm0
ja 0xcae3
testb $0x1, -0x11(%rbp)
jne 0xcb16
movq 0x6506(%rip), %rdi      # 0x12ff0
leaq 0xc82(%rip), %rsi       # 0xd773
callq 0x32d0
movq %rax, -0x88(%rbp)
jmp 0xcaff
movq -0x88(%rbp), %rdi
movq 0x6493(%rip), %rsi      # 0x12fa0
callq 0x3310
jmp 0xcb14
jmp 0xcb1a
movb $0x1, -0x12(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31f0
leaq -0x38(%rbp), %rdi
callq 0x31f0
jmp 0xc9d4
leaq -0x38(%rbp), %rdi
callq 0x31f0
jmp 0xcb4a
movsd -0x10(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ALSchwalm[P]cppEvolve/examples/readme_sample.cpp
// Function: main
int main() {
    auto generator = []() -> Genome {return {1, 2, 3};};

    auto fitness = [](const Genome& g) -> double {
        return std::count_if(g.begin(), g.end(),
                             [](int allele) {return allele % 2 == 0;});
    };

    SimpleGA<Genome, 100> ga(generator,
                             fitness,
                             list1d::crossover::singlePoint<Genome>,
                             list1d::mutator::swap<Genome>,
                             selector::top<Genome, 3>);

    ga.run(1000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
leaq -0x108(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
leaq -0x1(%rbp), %rsi
callq 0x2520
leaq -0x128(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
leaq -0x2(%rbp), %rsi
callq 0x25b0
leaq 0xb20(%rip), %rsi       # 0x2ee0
leaq -0x148(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x2f30
leaq 0xbe6(%rip), %rsi       # 0x2fc0
leaq -0x168(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x3040
leaq 0xcdc(%rip), %rsi       # 0x30d0
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x3130
movq -0x1c0(%rbp), %rsi
movq -0x1b8(%rbp), %rdx
movq -0x1b0(%rbp), %rcx
movq -0x1a8(%rbp), %r8
movq -0x1a0(%rbp), %r9
leaq -0xe8(%rbp), %rdi
callq 0x31c0
jmp 0x2438
leaq -0x188(%rbp), %rdi
callq 0x3350
leaq -0x168(%rbp), %rdi
callq 0x3370
leaq -0x148(%rbp), %rdi
callq 0x3390
leaq -0x128(%rbp), %rdi
callq 0x33b0
leaq -0x108(%rbp), %rdi
callq 0x33d0
leaq -0xe8(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movl $0x64, %edx
callq 0x33f0
jmp 0x248c
leaq -0xe8(%rbp), %rdi
callq 0x38d0
xorl %eax, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3350
leaq -0x168(%rbp), %rdi
callq 0x3370
leaq -0x148(%rbp), %rdi
callq 0x3390
leaq -0x128(%rbp), %rdi
callq 0x33b0
leaq -0x108(%rbp), %rdi
callq 0x33d0
jmp 0x2511
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x38d0
movq -0x190(%rbp), %rdi
callq 0x2160
nopl (%rax)
// File: ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/List1D/Mutator.hpp
// Function: void evolve::list1d::mutator::swap<std::array<int, 3ul>>(std::array<int, 3ul>&)
void swap(Genome& g) {
    unsigned int s1 = utils::random_uint(g.size());
    unsigned int s2 = utils::random_uint(g.size());

    auto s1location = begin(g);
    auto s2location = begin(g);

    std::advance(s1location, s1);
    std::advance(s2location, s2);

    std::swap(*s1location, *s2location);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3f50
movq %rax, %rdi
callq 0x2360
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3f50
movq %rax, %rdi
callq 0x2360
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43b0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x43d0
movl -0x10(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x43d0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4420
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/List1D/Crossover.hpp
// Function: std::array<int, 3ul> evolve::list1d::crossover::details::singlePointHelper<std::array<int, 3ul>>(std::array<int, 3ul> const&, std::array<int, 3ul> const&, std::integral_constant<bool, false>)
Genome singlePointHelper(const Genome& g1, const Genome& g2, std::false_type) {
    Genome g;

    auto size = std::min(g1.size(), g2.size());
    auto location = utils::random_uint(size);

    for (auto i = 0U; i < size; ++i) {
        if (i <= location)
            g[i] = g1[i];
        else
            g[i] = g2[i];
    }

    return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3f50
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f50
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3f10
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2360
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x3eef
movl -0x44(%rbp), %eax
cmpq -0x40(%rbp), %rax
ja 0x3ebc
movq -0x18(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x3f60
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %esi
leaq -0xc(%rbp), %rdi
callq 0x3f90
movl -0x5c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x3ee2
movq -0x20(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x3f60
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %esi
leaq -0xc(%rbp), %rdi
callq 0x3f90
movl -0x60(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x3ee4
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3e82
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl -0x50(%rbp), %edx
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ALSchwalm[P]cppEvolve/include/cppEvolve/Selector.hpp
// Function: void evolve::selector::details::topHelper<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&, std::integral_constant<bool, false>)
void topHelper(std::vector<Genome>& population,
               const std::function<float(const Genome&)>& evaluator,
               std::false_type) {
    orderedSort(population, evaluator, Ord);

    auto location = population.begin();
    std::advance(location, Num);

    population.erase(location, population.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x48d0
movq -0x10(%rbp), %rdi
callq 0x4960
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x4990
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4a70
movq -0x10(%rbp), %rdi
callq 0x4ab0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4a70
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x49e0
movq %rax, -0x40(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x491e
movq -0x8(%rbp), %rdi
callq 0x4960
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ab0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4ae0
jmp 0x4951
movq -0x8(%rbp), %rdi
callq 0x4960
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ab0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x4b30
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)