LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test002_sender_entry(void*)
static void *__test002_sender_entry(void *p)
{
	static const char *tag = "test002: async-req-rsp sender";

	int fd = (int)(long)p;	
	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2;

		gettimeofday(&t1, NULL);
		__send_req(fd, cmd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		fprintf(stdout, "%s send req with pkg-size=%ld took %ldms\n", \
			tag, (long)sizes[i], DIFF_TV(&t1, &t2));
	}

	return NULL;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x189c(%rip), %r15      # 0x3190
movl $0x3e8, %r12d           # imm = 0x3E8
leaq 0x18ad(%rip), %r13      # 0x31ae
xorl %r14d, %r14d
cmpq $0x38, %r14
je 0x1982
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl 0x4844(%rip), %esi      # 0x6160
leaq 0x19ad(%rip), %rax      # 0x32d0
movl (%r14,%rax), %ebp
movl %ebx, %edi
movl %ebp, %edx
movq %r15, %rcx
callq 0x17be
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x4682(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
movslq %ebp, %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rdx
imulq $0x3e8, %rdx, %r8       # imm = 0x3E8
subq 0x20(%rsp), %rax
cqto
idivq %r12
addq %rax, %r8
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r14
jmp 0x1904
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test002_reader_entry(void*)
static void *__test002_reader_entry(void *p)
{
	static const char *tag = "test002: async-req-rsp reader";

	int fd = (int)(long)p;
	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2;

		gettimeofday(&t1, NULL);
		__read_rsp(fd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		fprintf(stdout, "%s read rsp for pkg-size=%ld took %ldms\n", 
			tag, (long)sizes[i], DIFF_TV(&t1, &t2));
	}

	return NULL;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x182d(%rip), %r15      # 0x31d8
movl $0x3e8, %r12d           # imm = 0x3E8
leaq 0x183e(%rip), %r13      # 0x31f6
xorl %r14d, %r14d
cmpq $0x38, %r14
je 0x1a33
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
leaq 0x18fc(%rip), %rax      # 0x32d0
movl (%r14,%rax), %ebp
movl %ebx, %edi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1870
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x45d1(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
movslq %ebp, %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rdx
imulq $0x3e8, %rdx, %r8       # imm = 0x3E8
subq 0x20(%rsp), %rax
cqto
idivq %r12
addq %rax, %r8
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r14
jmp 0x19bb
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test003_worker(void*)
static void *__test003_worker(void *p)
{
	static const char *tag = "test003: mt-sync-req-rsp-worker";

	int fd = beyondy::XbsClient(host, O_NONBLOCK, 30000);
	if (fd < 0) {
		fprintf(stdout, "%s connect failed: %m\n", tag);
		exit(1);
	}

	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2, t3;

		gettimeofday(&t1, NULL);	
		__send_req(fd, cmd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		__read_rsp(fd, sizes[i], tag);

		gettimeofday(&t3, NULL);
		fprintf(stdout, "%s pkg-size=%ld send took %ldms, read took %ld ms\n", \
			tag, (long)sizes[i], DIFF_TV(&t1, &t2), DIFF_TV(&t2, &t3));
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x46f7(%rip), %rdi      # 0x6150
movl $0x7530, %edx           # imm = 0x7530
movl $0x800, %esi            # imm = 0x800
callq 0x2397
testl %eax, %eax
js 0x1b5f
movl %eax, %ebx
leaq 0x17e5(%rip), %r15      # 0x325e
movl $0x3e8, %r12d           # imm = 0x3E8
leaq 0x17f8(%rip), %rbp      # 0x327e
xorl %r13d, %r13d
cmpq $0x38, %r13
je 0x1b4e
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl 0x46bb(%rip), %esi      # 0x6160
leaq 0x1824(%rip), %rax      # 0x32d0
movl (%r13,%rax), %r14d
movl %ebx, %edi
movl %r14d, %edx
movq %r15, %rcx
callq 0x17be
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0x1870
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x44de(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
movslq %r14d, %rcx
movq 0x18(%rsp), %rsi
movq %rsi, %rdx
subq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r10
movq %r10, %rax
subq 0x30(%rsp), %rax
imulq $0x3e8, %rdx, %r8       # imm = 0x3E8
cqto
idivq %r12
addq %rax, %r8
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq %rsi, %rdx
imulq $0x3e8, %rdx, %r9       # imm = 0x3E8
subq %r10, %rax
cqto
idivq %r12
addq %rax, %r9
movq %rbp, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r13
jmp 0x1a89
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4462(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
leaq 0x150d(%rip), %rsi      # 0x307d
leaq 0x16e7(%rip), %rdx      # 0x325e
xorl %eax, %eax
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/daltonbr[P]RayTracing/./src/vec3.h
// Function: random_in_unit_sphere()
vec3 random_in_unit_sphere()
{
    vec3 p;
    do
    {
        p = 2.0 * vec3(drand48(), drand48(), drand48()) - vec3(1, 1, 1);
    } while (p.squared_length() >= 1.0);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x20a0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
callq 0x20a0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
callq 0x20a0
movaps -0x10(%rbp), %xmm4
movaps -0x20(%rbp), %xmm3
cvtsd2ss %xmm0, %xmm1
addss %xmm3, %xmm3
addss %xmm4, %xmm4
addss %xmm1, %xmm1
movss 0xec81(%rip), %xmm0     # 0x11004
addss %xmm0, %xmm3
addss %xmm0, %xmm4
addss %xmm0, %xmm1
movaps %xmm4, %xmm0
mulss %xmm4, %xmm0
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
ucomiss 0xec55(%rip), %xmm0     # 0x11008
jae 0x2344
unpcklps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
movaps %xmm3, %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movss %xmm0, -0x1c(%rbp)
movq %rsi, %r14
movsd (%rdi), %xmm0
movss 0x8(%rdi), %xmm1
callq 0x109fe
movaps %xmm0, %xmm4
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss 0x4(%r14), %xmm0
movss (%r14), %xmm2
mulss %xmm4, %xmm2
addss %xmm0, %xmm2
movss 0x8(%r14), %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
movss -0x1c(%rbp), %xmm5
mulss %xmm5, %xmm5
movaps %xmm0, %xmm2
mulss %xmm0, %xmm2
movss 0xeba4(%rip), %xmm6     # 0x11008
movaps %xmm6, %xmm3
subss %xmm2, %xmm3
mulss %xmm5, %xmm3
subss %xmm3, %xmm6
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm6
jbe 0x251e
movq %r14, %rdi
movaps %xmm4, -0x30(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm6, -0x18(%rbp)
callq 0x10a3b
movss -0x18(%rbp), %xmm2
movaps -0x30(%rbp), %xmm5
subps %xmm0, %xmm5
movaps %xmm5, %xmm3
shufps $0x55, %xmm5, %xmm3     # xmm3 = xmm3[1,1],xmm5[1,1]
movss -0x14(%rbp), %xmm4
subss %xmm1, %xmm4
movss -0x1c(%rbp), %xmm0
mulss %xmm0, %xmm5
movaps %xmm5, -0x30(%rbp)
mulss %xmm0, %xmm3
movaps %xmm3, -0x40(%rbp)
mulss %xmm0, %xmm4
movss %xmm4, -0x14(%rbp)
ucomiss 0xeb36(%rip), %xmm2     # 0x1100c
jb 0x24de
sqrtss %xmm2, %xmm0
jmp 0x24e6
movaps %xmm2, %xmm0
callq 0x21e0
movq %r14, %rdi
callq 0x10a3b
movaps -0x30(%rbp), %xmm2
subss %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps -0x40(%rbp), %xmm3
subss %xmm0, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movss -0x14(%rbp), %xmm0
subss %xmm1, %xmm0
movlps %xmm2, (%rbx)
movss %xmm0, 0x8(%rbx)
movss -0x18(%rbp), %xmm6
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm6
seta %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movss %xmm0, -0x2c(%rbp)
movq %rsi, %r14
movq %rdi, %r15
cvtss2sd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x10(%r15), %rax
cmpq %rax, %r12
jge 0x2776
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rdi
cvtsd2ss -0x38(%rbp), %xmm1
movq (%rdi), %rax
movq %r14, %rsi
movss -0x2c(%rbp), %xmm0
leaq -0x60(%rbp), %rdx
callq *(%rax)
testb %al, %al
je 0x2771
cvtss2sd -0x60(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, 0x20(%rbx)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $0x1, %r13b
incq %r12
jmp 0x2722
andb $0x1, %r13b
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa839(%rip), %xmm0     # 0x11038
movss 0xa835(%rip), %xmm1     # 0x1103c
leaq -0x68(%rbp), %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq *(%rax)
testb %al, %al
je 0x6878
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
cmpl $0x31, %ebx
jg 0x68d8
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 0x68d8
incl %ebx
leaq -0x3c(%rbp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x67df
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 0x68d8
movsd 0xc(%r15), %xmm0
movss 0x14(%r15), %xmm1
callq 0x109fe
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
addsd 0xc9d7(%rip), %xmm0     # 0x13270
mulsd 0xc9d7(%rip), %xmm0     # 0x13278
cvtsd2ss %xmm0, %xmm0
movss 0xa75b(%rip), %xmm1     # 0x11008
subss %xmm0, %xmm1
movss 0xa773(%rip), %xmm2     # 0x1102c
mulss %xmm0, %xmm2
movss 0xa77b(%rip), %xmm3     # 0x11040
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_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
leaq 0x4(%rdx), %r13
leaq 0x10(%rdx), %rsi
movq %r13, %rdi
callq 0x10a8e
movaps %xmm0, -0x40(%rbp)
movss %xmm1, -0x2c(%rbp)
callq 0x233c
addps -0x40(%rbp), %xmm0
addss -0x2c(%rbp), %xmm1
leaq -0x50(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
movq %r13, %rsi
callq 0x1098d
movl 0xc(%r12), %eax
movq 0x4(%r12), %rcx
movq %rcx, (%r15)
movl %eax, 0x8(%r15)
movlps %xmm0, 0xc(%r15)
movss %xmm1, 0x14(%r15)
movl 0x10(%r14), %eax
movl %eax, 0x8(%rbx)
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r12
movsd 0xc(%rsi), %xmm0
movss 0x14(%rsi), %xmm1
callq 0x109fe
leaq -0x50(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
leaq 0x10(%rbx), %rsi
callq 0x23c1
movaps %xmm0, -0x40(%rbp)
movss %xmm1, -0x28(%rbp)
movss 0x14(%r12), %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x233c
movss -0x24(%rbp), %xmm3
movaps %xmm3, %xmm2
mulss %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm3, %xmm0
mulss %xmm3, %xmm1
movaps -0x40(%rbp), %xmm3
addss %xmm3, %xmm2
shufps $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
addss %xmm0, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
addss -0x28(%rbp), %xmm1
movl 0xc(%rbx), %eax
movq 0x4(%rbx), %rcx
movq %rcx, (%r14)
movl %eax, 0x8(%r14)
movlps %xmm2, 0xc(%r14)
movss %xmm1, 0x14(%r14)
movl 0x10(%r12), %eax
movl %eax, 0x8(%r15)
movq 0x8(%r12), %rax
movq %rax, (%r15)
movsd 0xc(%r14), %xmm0
movss 0x10(%rbx), %xmm1
mulss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss 0x14(%rbx), %xmm0
movss 0x14(%r14), %xmm2
addss %xmm0, %xmm1
mulss 0x18(%rbx), %xmm2
addss %xmm1, %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
seta %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::createUser()
void User::createUser() {
    bool accountExists = true;
    while(accountExists) {
        int min = 10000, max = 99999;
        accountNumber = min + rand() % (max - min + 1); 
        ifstream ifs("./users/" + to_string(accountNumber) + ".txt");
        if(ifs.fail()){
            accountExists = false;
        }
    }
    cout << "Enter first name: ";
    cin >> firstName;
    cout << "Enter middle name: ";
    cin >> middleName;
    cout << "Enter last name: ";
    cin >> lastName;
    cout << "Enter password: ";
    cin >> password;
    isAdminAccount = false;
    account acc;
    acc.disabled = false;
    acc.isStudentPlan = false;
    acc.accountName = "chequings";
    acc.balance = 0;
    accounts.push_back(acc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rbx
movq %rsp, %r14
leaq 0x20(%rsp), %r12
leaq 0x40(%rsp), %rbp
leaq 0x60(%rsp), %r15
callq 0x2090
cltd
movl $0x15f90, %ecx          # imm = 0x15F90
idivl %ecx
leal 0x2710(%rdx), %esi
movl %esi, 0x18(%rbx)
movq %r14, %rdi
callq 0x3c01
movq %r12, %rdi
leaq 0x3d0e(%rip), %rsi      # 0x713a
movq %r14, %rdx
callq 0x3bdd
movq %rbp, %rdi
movq %r12, %rsi
leaq 0x3d02(%rip), %rdx      # 0x7143
callq 0x3bbe
movq %r15, %rdi
movq %rbp, %rsi
pushq $0x8
popq %rdx
callq 0x2320
movq %rbp, %rdi
callq 0x2110
movq %r12, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2110
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
movb 0x80(%rsp,%rax), %r13b
movq %r15, %rdi
callq 0x2080
testb $0x5, %r13b
je 0x3404
movq 0x7b2a(%rip), %r14      # 0xafc0
leaq 0x3cab(%rip), %rsi      # 0x7148
movq %r14, %rdi
callq 0x21f0
leaq 0x20(%rbx), %rsi
movq 0x7b28(%rip), %r15      # 0xafd8
movq %r15, %rdi
callq 0x2260
leaq 0x3c9c(%rip), %rsi      # 0x715b
movq %r14, %rdi
callq 0x21f0
leaq 0x40(%rbx), %rsi
movq %r15, %rdi
callq 0x2260
leaq 0x3c95(%rip), %rsi      # 0x716f
movq %r14, %rdi
callq 0x21f0
leaq 0x60(%rbx), %rsi
movq %r15, %rdi
callq 0x2260
leaq 0x3c8c(%rip), %rsi      # 0x7181
movq %r14, %rdi
callq 0x21f0
leaq 0x88(%rbx), %rsi
movq %r15, %rdi
callq 0x2260
xorl %eax, %eax
movb %al, 0x80(%rbx)
leaq 0x68(%rsp), %r14
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %al, (%rcx)
andw $0x0, -0x18(%rcx)
leaq 0x3c5d(%rip), %rsi      # 0x7192
movq %r14, %rdi
callq 0x2380
leaq 0x60(%rsp), %rsi
andq $0x0, 0x28(%rsi)
movq %rbx, %rdi
callq 0x3c5a
movq %r14, %rdi
callq 0x2110
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
jmp 0x3595
movq %rax, %rbx
jmp 0x3592
movq %rax, %rbx
jmp 0x3588
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2110
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::saveUserData()
void User::saveUserData() {
    ofstream ofs("./users/" + to_string(accountNumber) + ".txt");
    if(ofs.fail()) {
        cerr << "Error! Unable to save user data!";
        exit(1);
    }
    ofs << firstName << endl;
    ofs << middleName << endl;
    ofs << lastName << endl;
    ofs << password << endl;
    ofs << isAdminAccount << endl;
    for(int i = 0; i < accounts.size(); i++) {
        ofs << accounts[i].disabled << accounts[i].isStudentPlan << accounts[i].accountName 
            << "$" << accounts[i].balance << endl;
    }
    accounts.clear();
    ofs.close(); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rbx
movl 0x18(%rdi), %esi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x3c01
leaq 0x3b6d(%rip), %rsi      # 0x713a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x3bdd
leaq 0x3b62(%rip), %rdx      # 0x7143
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3bbe
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0x2390
leaq 0x28(%rsp), %rdi
callq 0x2110
leaq 0x8(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
callq 0x2110
movq 0x68(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x88(%rsp,%rax)
jne 0x3761
leaq 0x20(%rbx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
leaq 0x40(%rbx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
leaq 0x60(%rbx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
leaq 0x88(%rbx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movzbl 0x80(%rbx), %esi
leaq 0x68(%rsp), %rdi
callq 0x2340
movq %rax, %rdi
callq 0x2120
xorl %r12d, %r12d
pushq $0x30
popq %r13
leaq 0x68(%rsp), %r14
leaq 0x3e79(%rip), %r15      # 0x7537
xorl %ebp, %ebp
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %rbp, %rax
jbe 0x3733
movzbl (%rcx,%r12), %esi
movq %r14, %rdi
callq 0x2340
movq (%rbx), %rcx
movzbl 0x1(%rcx,%r12), %esi
movq %rax, %rdi
callq 0x2340
movq (%rbx), %rcx
leaq (%rcx,%r12), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21f0
movq (%rbx), %rcx
movsd 0x28(%rcx,%r12), %xmm0
movq %rax, %rdi
callq 0x2310
movq %rax, %rdi
callq 0x2120
incq %rbp
addq $0x30, %r12
jmp 0x36c0
movq %rbx, %rdi
callq 0x3ca2
leaq 0x68(%rsp), %rdi
callq 0x22a0
leaq 0x68(%rsp), %rdi
callq 0x22d0
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7888(%rip), %rdi      # 0xaff0
leaq 0x3a49(%rip), %rsi      # 0x71b8
callq 0x21f0
pushq $0x1
popq %rdi
callq 0x2240
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2110
jmp 0x378e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
jmp 0x379d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2110
jmp 0x37b8
jmp 0x37ab
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x22d0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r12
xorl %r15d, %r15d
pushq $0x30
popq %r13
pushq $-0x1
popq %rbp
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %r13
cmpq %r15, %rax
jbe 0x380e
addq %r12, %rdi
movq %rbx, %rsi
callq 0x2030
testl %eax, %eax
je 0x380b
incq %r15
addq $0x30, %r12
jmp 0x37df
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37c0
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x2110
cmpl $-0x1, %ebp
setne %cl
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
setb %al
andb %cl, %al
je 0x388a
movapd %xmm1, %xmm0
movslq %ebp, %rcx
movq (%rbx), %rdx
imulq $0x30, %rcx, %rcx
addsd 0x28(%rdx,%rcx), %xmm0
movsd %xmm0, 0x28(%rdx,%rcx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37c0
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x2110
cmpl $-0x1, %ebp
setne %al
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
setb %cl
testb %al, %cl
je 0x390e
movslq %ebp, %rcx
movq (%rbx), %rax
imulq $0x30, %rcx, %rcx
movsd 0x28(%rax,%rcx), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x3912
xorl %eax, %eax
jmp 0x3923
addq %rcx, %rax
addq $0x28, %rax
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x3984
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37c0
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2110
cmpl $-0x1, %ebp
je 0x3991
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30(%rsp), %r14
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andw $0x0, -0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
andq $0x0, 0x50(%rsp)
movq 0x75fc(%rip), %rdi      # 0xafc0
callq 0x2120
leaq 0x3809(%rip), %rsi      # 0x71d9
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2120
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3c5a
movq %r14, %rdi
callq 0x2110
movb $0x1, %al
jmp 0x3986
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x3a09
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x3a61
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37c0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2110
cmpl $-0x1, %ebp
je 0x3a61
movslq %ebp, %rax
movq (%rbx), %rcx
imulq $0x30, %rax, %rax
movb $0x1, (%rcx,%rax)
movb $0x1, %al
jmp 0x3a63
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x3ac8
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37c0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2110
cmpl $-0x1, %ebp
je 0x3ac8
movslq %ebp, %rax
movq (%rbx), %rcx
imulq $0x30, %rax, %rax
movb (%rcx,%rax), %al
jmp 0x3aca
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x3b35
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37c0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2110
cmpl $-0x1, %ebp
je 0x3b35
movslq %ebp, %rax
imulq $0x30, %rax, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x3caa
movb $0x1, %al
jmp 0x3b37
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x3ba0
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37c0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2110
cmpl $-0x1, %ebp
je 0x3ba0
movslq %ebp, %rax
movq (%rbx), %rcx
imulq $0x30, %rax, %rax
xorb $0x1, 0x1(%rcx,%rax)
movb $0x1, %al
jmp 0x3ba2
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/Kyle-Alvares[P]SQA1/session.cpp
// Function: Session::transfer()
void Session::transfer() {
    string mssg = "Enter depositee account number: ";
    cout << endl << "============TRANSFER===========" << endl;
    cout << mssg;
    
    int accountNumber = askAccountNumber(mssg);
    User other(accountNumber);

    bool valid = other.isDisabled("chequings") ? false : true;
    if(valid) {
        double amount = withdraw(1000, false);
        other.deposit("chequings", amount);
        transactions.push_back("02" + username + to_string(amount));
    }
    else cout << "Error: This user has a disabled chequing account!" << endl;
    other.saveUserData();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x2c7a(%rip), %rsi      # 0x73d3
leaq 0x30(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
callq 0x2a46
movq 0x684e(%rip), %rdi      # 0xafc0
callq 0x2120
leaq 0x2c76(%rip), %rsi      # 0x73f4
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2120
movq 0x682b(%rip), %rdi      # 0xafc0
leaq 0x30(%rsp), %rsi
callq 0x21d0
leaq 0xd0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2290
leaq 0xd0(%rsp), %rdi
callq 0x6133
movl %eax, %ebp
leaq 0xd0(%rsp), %rdi
callq 0x2110
leaq 0xf0(%rsp), %rdi
movl %ebp, %esi
callq 0x2ef6
leaq 0x29af(%rip), %rsi      # 0x7192
leaq 0xb0(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2a46
leaq 0xf0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x3a80
movl %eax, %ebp
leaq 0xb0(%rsp), %rdi
callq 0x2110
testb %bpl, %bpl
je 0x483e
movq 0x679b(%rip), %rdi      # 0xafc0
leaq 0x2beb(%rip), %rsi      # 0x7417
callq 0x21f0
movq %rax, %rdi
callq 0x2120
jmp 0x4905
movsd 0x2ab2(%rip), %xmm0     # 0x72f8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x444a
movsd %xmm0, 0x8(%rsp)
leaq 0x2935(%rip), %rsi      # 0x7192
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2a46
leaq 0xf0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3820
leaq 0x90(%rsp), %rdi
callq 0x2110
leaq 0xa8(%rbx), %rdx
leaq 0x2b6f(%rip), %rsi      # 0x7414
leaq 0x70(%rsp), %rdi
callq 0x5927
leaq 0x50(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x599d
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x58c0
addq $0xc8, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e0e
leaq 0x10(%rsp), %rdi
callq 0x2110
leaq 0x50(%rsp), %rdi
callq 0x2110
leaq 0x70(%rsp), %rdi
callq 0x2110
leaq 0xf0(%rsp), %rdi
callq 0x35a2
leaq 0xf0(%rsp), %rdi
callq 0x2b38
leaq 0x30(%rsp), %rdi
callq 0x2110
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
jmp 0x4945
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2110
jmp 0x4954
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x4979
jmp 0x4998
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x4979
jmp 0x4998
jmp 0x4998
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x2110
jmp 0x499b
jmp 0x4998
jmp 0x49aa
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x2110
jmp 0x49ad
jmp 0x49aa
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x2b38
jmp 0x49ad
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kyle-Alvares[P]SQA1/session.cpp
// Function: Session::createAccount()
void Session::createAccount() {
    cout << endl << "========CREATE ACCOUNT========" << endl;
    if(!user.isAdmin()) { 
        cerr << "Error: privileged transaction!" << endl; 
    } else {
        int session = 0;
        while(session == 0) {
            string accountName = askAccountName(user, 0);
            if (std::any_of(accountName.begin(), accountName.end(), ::isdigit) == true){
                cerr << "Error: Invalid account name!" << endl;
            } else if (accountName.size() > 20) {
                cerr << "Error: Invalid account name!" << endl;
            } else {
                session += 1;
                user.createAccount(accountName);
                transactions.push_back("05" + username + "00000000");
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
movq 0x5f2d(%rip), %rdi      # 0xafc0
callq 0x2120
leaq 0x249a(%rip), %rsi      # 0x7539
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x339e
testb %al, %al
je 0x51d3
leaq 0xc8(%rbx), %rax
movq %rax, (%rsp)
leaq 0xa8(%rbx), %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x90(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0x50(%rsp), %r14
leaq 0x70(%rsp), %r15
testl %ebp, %ebp
jne 0x51ff
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2a82
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6265
movq %r12, %rdi
callq 0x2b38
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq %rdi, %rsi
movq 0x5e8d(%rip), %rdx      # 0xafb8
callq 0x5a17
cmpq $0x15, 0x18(%rsp)
setae %cl
orb %cl, %al
je 0x515c
movq 0x5eac(%rip), %rdi      # 0xaff0
leaq 0x242c(%rip), %rsi      # 0x7577
callq 0x21f0
xorl %ebp, %ebp
movq %rax, %rdi
callq 0x2120
jmp 0x51c6
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x2290
movq %rbx, %rdi
leaq 0x30(%rsp), %rbp
movq %rbp, %rsi
callq 0x3942
movq %rbp, %rdi
callq 0x2110
movq %r14, %rdi
leaq 0x2409(%rip), %rsi      # 0x7594
movq 0x8(%rsp), %rdx
callq 0x5927
movq %r15, %rdi
movq %r14, %rsi
leaq 0x23f5(%rip), %rdx      # 0x7597
callq 0x3bbe
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x5e0e
movq %r15, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2110
pushq $0x1
popq %rbp
movq %r13, %rdi
callq 0x2110
jmp 0x50ef
movq 0x5e16(%rip), %rdi      # 0xaff0
leaq 0x2377(%rip), %rsi      # 0x7558
callq 0x21f0
movq %rax, %rdi
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x5232
movq %rax, %rbx
jmp 0x522d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2110
leaq 0x50(%rsp), %rdi
callq 0x2110
jmp 0x5250
jmp 0x524d
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x2b38
jmp 0x525a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
movq 0x5d4a(%rip), %rdi      # 0xafc0
callq 0x2120
leaq 0x231e(%rip), %rsi      # 0x75a0
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x339e
testb %al, %al
je 0x535d
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a82
leaq 0x60(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
callq 0x6265
leaq 0x80(%rsp), %rdi
callq 0x2b38
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2290
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ae6
leaq 0x40(%rsp), %rdi
callq 0x2110
leaq 0xa8(%rbx), %rdx
leaq 0x22b9(%rip), %rsi      # 0x75bf
movq %rsp, %rdi
callq 0x5927
leaq 0x2282(%rip), %rdx      # 0x7597
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3bbe
addq $0xc8, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e0e
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rsp, %rdi
callq 0x2110
leaq 0x60(%rsp), %rdi
callq 0x2110
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
movq 0x5c8c(%rip), %rdi      # 0xaff0
leaq 0x21ed(%rip), %rsi      # 0x7558
callq 0x21f0
movq %rax, %rdi
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
jmp 0x2120
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2110
jmp 0x5394
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x53a3
jmp 0x53aa
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2110
jmp 0x53ad
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2b38
jmp 0x53b7
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
movq 0x5bda(%rip), %rdi      # 0xafc0
callq 0x2120
leaq 0x21d0(%rip), %rsi      # 0x75c2
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x339e
testb %al, %al
je 0x54cd
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a82
leaq 0x60(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
callq 0x6265
leaq 0x80(%rsp), %rdi
callq 0x2b38
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2290
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a16
leaq 0x40(%rsp), %rdi
callq 0x2110
leaq 0xa8(%rbx), %rdx
leaq 0x216b(%rip), %rsi      # 0x75e1
movq %rsp, %rdi
callq 0x5927
leaq 0x2112(%rip), %rdx      # 0x7597
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3bbe
addq $0xc8, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e0e
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rsp, %rdi
callq 0x2110
leaq 0x60(%rsp), %rdi
callq 0x2110
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
movq 0x5b1c(%rip), %rdi      # 0xaff0
leaq 0x207d(%rip), %rsi      # 0x7558
callq 0x21f0
movq %rax, %rdi
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
jmp 0x2120
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2110
jmp 0x5504
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x5513
jmp 0x551a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2110
jmp 0x551d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2b38
jmp 0x5527
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
movq 0x5a6a(%rip), %rdi      # 0xafc0
callq 0x2120
leaq 0x2082(%rip), %rsi      # 0x75e4
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x339e
testb %al, %al
je 0x563d
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a82
leaq 0x60(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
callq 0x6265
leaq 0x80(%rsp), %rdi
callq 0x2b38
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2290
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x3b54
leaq 0x40(%rsp), %rdi
callq 0x2110
leaq 0xa8(%rbx), %rdx
leaq 0x201d(%rip), %rsi      # 0x7603
movq %rsp, %rdi
callq 0x5927
leaq 0x1fa2(%rip), %rdx      # 0x7597
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3bbe
addq $0xc8, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e0e
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rsp, %rdi
callq 0x2110
leaq 0x60(%rsp), %rdi
callq 0x2110
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
movq 0x59ac(%rip), %rdi      # 0xaff0
leaq 0x1f0d(%rip), %rsi      # 0x7558
callq 0x21f0
movq %rax, %rdi
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
jmp 0x2120
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2110
jmp 0x5674
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x5683
jmp 0x568a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2110
jmp 0x568d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2350
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2b38
jmp 0x5697
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kyle-Alvares[P]SQA1/session.cpp
// Function: Session::save()
void Session::save() {
    user.saveUserData();
    time_t rawtime;
    time (&rawtime);
    ofstream ofs("./transactions/" + to_string(user.getAccountNumber()) + ".txt", ios::app);
    if(ofs.fail()) {
        cerr << "Error! Unable to save transactions!";
        exit(1);
    }
    ofs << endl;
    ofs << ctime (&rawtime) << endl;
    for(int i = 0; i < transactions.size(); i++) {
        ofs << transactions[i] << endl;
    }
    ofs.close();
    transactions.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rdi, %rbx
callq 0x35a2
leaq 0x8(%rsp), %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x334e
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x3c01
leaq 0x1fc4(%rip), %rsi      # 0x76b6
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x3bdd
leaq 0x1a3d(%rip), %rdx      # 0x7143
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3bbe
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x2390
leaq 0x30(%rsp), %rdi
callq 0x2110
leaq 0x10(%rsp), %rdi
callq 0x2110
leaq 0x50(%rsp), %rdi
callq 0x2110
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x90(%rsp,%rax)
jne 0x57fa
leaq 0x70(%rsp), %rdi
callq 0x2120
leaq 0x8(%rsp), %rdi
callq 0x20d0
leaq 0x70(%rsp), %rdi
movq %rax, %rsi
callq 0x21f0
movq %rax, %rdi
callq 0x2120
leaq 0xc8(%rbx), %r14
xorl %r12d, %r12d
leaq 0x70(%rsp), %r15
xorl %r13d, %r13d
movq 0xc8(%rbx), %rsi
movq 0xd0(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x57cd
addq %r12, %rsi
movq %r15, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
incq %r13
addq $0x20, %r12
jmp 0x5797
leaq 0x70(%rsp), %rdi
callq 0x22a0
movq %r14, %rdi
callq 0x5a22
leaq 0x70(%rsp), %rdi
callq 0x22d0
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x57ef(%rip), %rdi      # 0xaff0
leaq 0x1ebe(%rip), %rsi      # 0x76c6
callq 0x21f0
pushq $0x1
popq %rdi
callq 0x2240
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2110
jmp 0x5827
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
jmp 0x5836
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2110
jmp 0x5851
jmp 0x5844
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x22d0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rbp
leaq 0x50(%rsp), %r15
leaq 0x70(%rsp), %r13
movq 0x4e8e(%rip), %r14      # 0xaff0
movq 0x4e6f(%rip), %rdi      # 0xafd8
leaq 0xc(%rsp), %rsi
callq 0x2160
movl 0xc(%rsp), %esi
movq %r12, %rdi
callq 0x3c01
movq %rbp, %rdi
leaq 0xfb1(%rip), %rsi       # 0x713a
movq %r12, %rdx
callq 0x3bdd
movq %r15, %rdi
movq %rbp, %rsi
leaq 0xfa5(%rip), %rdx       # 0x7143
callq 0x3bbe
movq %r13, %rdi
movq %r15, %rsi
pushq $0x8
popq %rdx
callq 0x2320
movq %r15, %rdi
callq 0x2110
movq %rbp, %rdi
callq 0x2110
movq %r12, %rdi
callq 0x2110
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x90(%rsp,%rax)
je 0x6203
movq %r14, %rdi
leaq 0x1531(%rip), %rsi      # 0x7717
callq 0x21f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %r13, %rdi
callq 0x2080
jmp 0x6162
leaq 0x70(%rsp), %rdi
callq 0x2080
movl 0xc(%rsp), %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6244
movq %rax, %rbx
jmp 0x623a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2110
leaq 0x30(%rsp), %rdi
callq 0x2110
leaq 0x10(%rsp), %rdi
callq 0x2110
jmp 0x625d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x4d2e(%rip), %rdi      # 0xafc0
leaq 0x149e(%rip), %rsi      # 0x7737
callq 0x21f0
movq 0x4d33(%rip), %rdi      # 0xafd8
movq %rbx, %rsi
callq 0x2260
leaq 0x8(%rsp), %r15
movq 0x4d1f(%rip), %r12      # 0xafd8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2290
movq %r14, %rdi
movq %r15, %rsi
callq 0x37c0
movl %eax, %r13d
movq %r15, %rdi
callq 0x2110
cmpl %ebp, %r13d
jne 0x631a
movq 0x4d0a(%rip), %rdi      # 0xaff0
leaq 0x128a(%rip), %rsi      # 0x7577
callq 0x21f0
movq %rax, %rdi
callq 0x2120
movq 0x4cbf(%rip), %rdi      # 0xafc0
leaq 0x142f(%rip), %rsi      # 0x7737
callq 0x21f0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2260
jmp 0x62b9
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x633d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2110
jmp 0x6340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2350