LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/rsync_upload.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 3)
	{
		printf("Usage: rsync_upload filename port\r\n");
		return 0;
	}

#ifdef WIN32
	WSADATA		WSAData;

	WSAStartup(MAKEWORD(2, 0), &WSAData);
#endif

	unsigned short port = atoi(argv[2]);
	printf("Attempting to upload %s to client connecting on port %d\r\n", argv[1], (int)port);
	rsync_file_upload(argv[1], port);
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jg 0x2668
leaq 0x1f70(%rip), %rdi      # 0x45d1
callq 0x1070
jmp 0x2696
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x11f0
movq 0x8(%rbx), %rsi
movzwl %ax, %ebp
leaq 0x1c59(%rip), %rdi      # 0x42db
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0x2051
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/md5sum.c
// Function: md5sum
void md5sum(char *data, unsigned int size, char *hash)
{
	md5_state_t	state;
	md5_byte_t	digest[16];

	md5_init(&state);
	md5_append(&state, (const md5_byte_t *)data, size);
	md5_finish(&state, digest);

	sprintf(hash, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
		digest[0], digest[1], digest[2], digest[3],
		digest[4], digest[5], digest[6], digest[7],
		digest[8], digest[9], digest[10], digest[11],
		digest[12], digest[13], digest[14], digest[15]
	);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
movaps 0x1f40(%rip), %xmm0     # 0x4600
leaq 0x40(%rsp), %r14
movaps %xmm0, (%r14)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x27b7
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x288c
movzbl (%r15), %edx
movzbl 0x1(%r15), %ecx
movzbl 0x2(%r15), %r8d
movzbl 0x3(%r15), %r9d
movzbl 0x4(%r15), %eax
movq %rax, 0x28(%rsp)
movzbl 0x5(%r15), %eax
movq %rax, 0x20(%rsp)
movzbl 0x6(%r15), %eax
movq %rax, 0x18(%rsp)
movzbl 0x7(%r15), %eax
movq %rax, 0x10(%rsp)
movzbl 0x8(%r15), %eax
movq %rax, 0x8(%rsp)
movzbl 0x9(%r15), %ebp
movzbl 0xa(%r15), %r10d
movzbl 0xb(%r15), %r11d
movzbl 0xc(%r15), %r14d
movzbl 0xd(%r15), %r12d
movzbl 0xe(%r15), %r13d
movzbl 0xf(%r15), %r15d
leaq 0x1eb2(%rip), %rsi      # 0x4610
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r13
pushq %r12
pushq %r14
pushq %r11
pushq %r10
pushq %rbp
pushq 0x40(%rsp)
pushq 0x50(%rsp)
pushq 0x60(%rsp)
pushq 0x70(%rsp)
pushq 0x80(%rsp)
callq 0x1200
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/md5sum.c
// Function: md5_append
void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
    const md5_byte_t *p = data;
    int left = nbytes;
    int offset = (pms->count[0] >> 3) & 63;
    md5_word_t nbits = (md5_word_t)(nbytes << 3);

    if (nbytes <= 0)
	return;

    /* Update the message length. */
    pms->count[1] += nbytes >> 29;
    pms->count[0] += nbits;
    if (pms->count[0] < nbits)
	pms->count[1]++;

    /* Process an initial partial block. */
    if (offset) {
	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);

	memcpy(pms->buf + offset, p, copy);
	if (offset + copy < 64)
	    return;
	p += copy;
	left -= copy;
	md5_process(pms, pms->buf);
    }

    /* Process full blocks. */
    for (; left >= 64; p += 64, left -= 64)
	md5_process(pms, p);

    /* Process a final partial block. */
    if (left)
	memcpy(pms->buf, p, left);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testl %edx, %edx
jle 0x2882
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %r13d
shrl $0x3, %r13d
andl $0x3f, %r13d
movl %edx, %eax
shrl $0x1d, %eax
addl 0x4(%rdi), %eax
leal (,%r15,8), %edx
movl %eax, 0x4(%rdi)
addl %ecx, %edx
movl %edx, (%rdi)
jae 0x27fd
incl %eax
movl %eax, 0x4(%r14)
testl %r13d, %r13d
je 0x2844
leal (%r15,%r13), %eax
pushq $0x40
popq %r12
subl %r13d, %r12d
cmpl $0x41, %eax
cmovbl %r15d, %r12d
leaq (%r14,%r13), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1160
movl %r12d, %eax
addl %r13d, %eax
cmpl $0x40, %eax
jb 0x2882
leaq 0x18(%r14), %rsi
addq %r12, %rbx
subl %r12d, %r15d
movq %r14, %rdi
callq 0x2918
movslq %r15d, %r15
cmpl $0x40, %r15d
jl 0x2862
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2918
addq $0x40, %rbx
addq $-0x40, %r15
jmp 0x2847
testl %r15d, %r15d
je 0x2882
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/md5sum.c
// Function: md5_finish
void md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{
    static const md5_byte_t pad[64] = {
	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    md5_byte_t data[8];
    int i;

    /* Save the length before padding. */
    for (i = 0; i < 8; ++i)
	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
    /* Pad to 56 bytes mod 64. */
    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
    /* Append the length. */
    md5_append(pms, data, 8);
    for (i = 0; i < 16; ++i)
	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
xorl %edx, %edx
cmpq $0x8, %rdx
je 0x28bc
movl %edx, %ecx
andl $-0x4, %ecx
movl (%r14,%rcx), %esi
movl %eax, %ecx
andb $0x18, %cl
shrl %cl, %esi
movb %sil, (%rsp,%rdx)
incq %rdx
addl $0x8, %eax
jmp 0x289a
movl (%r14), %eax
shrl $0x3, %eax
pushq $0x37
popq %rdx
subl %eax, %edx
andl $0x3f, %edx
incl %edx
leaq 0x1d8d(%rip), %rsi      # 0x4660
movq %r14, %rdi
callq 0x27b7
movq %rsp, %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x27b7
xorl %eax, %eax
xorl %edx, %edx
cmpq $0x10, %rdx
je 0x2910
movl %edx, %ecx
andl $-0x4, %ecx
movl 0x8(%r14,%rcx), %esi
movl %eax, %ecx
andb $0x18, %cl
shrl %cl, %esi
movb %sil, (%rbx,%rdx)
incq %rdx
addl $0x8, %eax
jmp 0x28ed
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/././include/assert.hpp
// Function: print_prompt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<void ()> const&)
void print_prompt(string prompt, const function<void()>& callback){
    char boolean = 'N';
    cout << prompt << " [Y/N] (Default N) : ";
    cin >> boolean;
    if(boolean == 'Y' || boolean == 'y'){
        callback();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x11(%rbp), %r14
movb $0x4e, (%r14)
movq 0x19845(%rip), %rdi     # 0x1df70
callq 0x4250
leaq 0xf8d1(%rip), %rsi      # 0x14008
movq %rax, %rdi
callq 0x4290
movq 0x1987a(%rip), %rdi     # 0x1dfc0
movq %r14, %rsi
callq 0x4340
movb (%r14), %al
andb $-0x21, %al
cmpb $0x59, %al
jne 0x475f
movq %rbx, %rdi
callq 0xbb9a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/././dep/rang.hpp
// Function: std::enable_if<std::is_same<rang::fg, rang::style>::value || std::is_same<rang::fg, rang::fg>::value || std::is_same<rang::fg, rang::bg>::value || std::is_same<rang::fg, rang::fgB>::value || std::is_same<rang::fg, rang::bgB>::value, std::ostream&>::type rang::operator<<<rang::fg>(std::ostream&, rang::fg)
inline rang_implementation::enableStd<T> operator<<(std::ostream &os,
                                                    const T value)
{
    const control option = rang_implementation::controlMode();
    switch (option) {
        case control::Auto:
            return rang_implementation::supportsColor()
                && rang_implementation::isTerminal(os.rdbuf())
              ? rang_implementation::setColor(os, value)
              : os;
        case control::Force: return rang_implementation::setColor(os, value);
        default: return os;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x12679(%rip), %eax     # 0x1e258
cmpl $0x2, %eax
je 0xbc0a
cmpl $0x1, %eax
jne 0xbc18
callq 0xbdc7
testb %al, %al
je 0xbc18
movq (%r14), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r14,%rax), %rdi
callq 0xbe1a
testb %al, %al
je 0xbc18
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xc15a
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/././dep/rang.hpp
// Function: rang::rang_implementation::isTerminal(std::basic_streambuf<char, std::char_traits<char>> const*)
inline bool isTerminal(const std::streambuf *osbuf) noexcept
    {
        using std::cerr;
        using std::clog;
        using std::cout;
#if defined(OS_LINUX) || defined(OS_MAC)
        if (osbuf == cout.rdbuf()) {
            static const bool cout_term = isatty(fileno(stdout)) != 0;
            return cout_term;
        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
            static const bool cerr_term = isatty(fileno(stderr)) != 0;
            return cerr_term;
        }
#elif defined(OS_WIN)
        if (osbuf == cout.rdbuf()) {
            static const bool cout_term
              = (_isatty(_fileno(stdout)) || isMsysPty(_fileno(stdout)));
            return cout_term;
        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
            static const bool cerr_term
              = (_isatty(_fileno(stderr)) || isMsysPty(_fileno(stderr)));
            return cerr_term;
        }
#endif
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1214b(%rip), %rax     # 0x1df70
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xbe7c
movq 0x121a3(%rip), %rax     # 0x1dfe0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xbe6a
movq 0x120e3(%rip), %rax     # 0x1df38
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xbe6a
xorl %eax, %eax
jmp 0xbe8c
movb 0x12470(%rip), %al      # 0x1e2e0
testb %al, %al
je 0xbe8e
movb 0x1245e(%rip), %al      # 0x1e2d8
jmp 0xbe8c
movb 0x1244e(%rip), %al      # 0x1e2d0
testb %al, %al
je 0xbecb
movb 0x1243c(%rip), %al      # 0x1e2c8
popq %rbp
retq
leaq 0x1244b(%rip), %rdi     # 0x1e2e0
callq 0x4460
testl %eax, %eax
je 0xbe74
movq 0x120d3(%rip), %rax     # 0x1df78
movq (%rax), %rdi
callq 0x42d0
movl %eax, %edi
callq 0x4440
testl %eax, %eax
setne 0x1241b(%rip)           # 0x1e2d8
leaq 0x1241c(%rip), %rdi     # 0x1e2e0
callq 0x41f0
jmp 0xbe74
leaq 0x123fe(%rip), %rdi     # 0x1e2d0
callq 0x4460
testl %eax, %eax
je 0xbe86
movq 0x1204e(%rip), %rax     # 0x1df30
movq (%rax), %rdi
callq 0x42d0
movl %eax, %edi
callq 0x4440
testl %eax, %eax
setne 0x123ce(%rip)           # 0x1e2c8
leaq 0x123cf(%rip), %rdi     # 0x1e2d0
callq 0x41f0
jmp 0xbe86
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/User.cpp
// Function: validate_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static void validate_name(string name){
    if(name.length() > User::MaxNameLength){
        throw out_of_range("Name max character limit exceeded");
    }
    int i = 0;
    while(i < name.length()){
        if(isalpha(name[i])){
            i++;
        }else{
            throw invalid_name("Invalid Name: only standard english alphabets are allowed");
        };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
leaq 0x11edc(%rip), %rax     # 0x1e2a8
movslq (%rax), %rax
cmpq %rax, %r14
ja 0xc431
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq %r15, %r14
je 0xc426
movq (%rbx), %rax
movsbl (%rax,%r15), %edi
callq 0x43c0
incq %r15
testl %eax, %eax
jne 0xc3da
pushq $0x10
popq %rdi
callq 0x4190
leaq 0x1188e(%rip), %rcx     # 0x1dc90
movq %rcx, (%rax)
leaq 0x90e3(%rip), %rcx      # 0x154ef
movq %rcx, 0x8(%rax)
leaq 0x11851(%rip), %rsi     # 0x1dc68
movq 0x11baa(%rip), %rdx     # 0x1dfc8
movq %rax, %rdi
callq 0x4410
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0x908a(%rip), %rsi      # 0x154cd
movq %rax, %rdi
callq 0x4070
movq 0x11b56(%rip), %rsi     # 0x1dfa8
movq 0x11b2f(%rip), %rdx     # 0x1df88
movq %rbx, %rdi
callq 0x4410
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/Driver.cpp
// Function: operator<<(std::ostream&, Driver const&)
ostream& operator<<(ostream& output, const Driver& D){
    output << "\t{" <<
        "\n\t\tuuid : " << D.uuid <<
        "\n\t\tfirstname : " << D.firstname <<
        "\n\t\tlastname : " << D.lastname <<
        "\n\t\tdriving license number : " << D.driving_license_num <<
        "\n\t\tStatus : " << (D.status == IDLE ? "IDLE" : "ONSHIFT") <<
        "\n\t}" <<
        endl;
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8e90(%rip), %rsi      # 0x15547
callq 0x4290
leaq 0x8e87(%rip), %rsi      # 0x1554a
movq %rax, %rdi
callq 0x4290
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x8e77(%rip), %rsi      # 0x15555
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
movq %r14, %rsi
callq 0x4250
leaq 0x8e6d(%rip), %rsi      # 0x15565
movq %rax, %rdi
callq 0x4290
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x8e61(%rip), %rsi      # 0x15574
movq %rax, %rdi
callq 0x4290
leaq 0x60(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x8e63(%rip), %rsi      # 0x15591
movq %rax, %rdi
callq 0x4290
cmpl $0x1, 0x80(%r14)
leaq 0x9540(%rip), %rcx      # 0x15c85
leaq 0x92f1(%rip), %rsi      # 0x15a3d
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x4290
leaq 0x8e3f(%rip), %rsi      # 0x1559e
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
callq 0x4180
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/Customer.cpp
// Function: operator<<(std::ostream&, Customer const&)
ostream& operator<<(ostream& output, const Customer& C){
    output << "\t{" <<
        "\n\t\tuuid : " << C.uuid <<
        "\n\t\tfirstname : " << C.firstname <<
        "\n\t\tlastname : " << C.lastname <<
        "\n\t\tbalance : " << C.balance <<
        "\n\t\tstatus : " << (C.status == IDLE ? "IDLE" : "ONSHIFT") <<
        "\n\t}" <<
        endl;
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8c6c(%rip), %rsi      # 0x15547
callq 0x4290
leaq 0x8c63(%rip), %rsi      # 0x1554a
movq %rax, %rdi
callq 0x4290
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x8c53(%rip), %rsi      # 0x15555
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
movq %r14, %rsi
callq 0x4250
leaq 0x8c49(%rip), %rsi      # 0x15565
movq %rax, %rdi
callq 0x4290
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x8c6b(%rip), %rsi      # 0x155a2
movq %rax, %rdi
callq 0x4290
movl 0x60(%r14), %esi
movq %rax, %rdi
callq 0x4430
leaq 0x8c5e(%rip), %rsi      # 0x155b0
movq %rax, %rdi
callq 0x4290
cmpl $0x1, 0x64(%r14)
leaq 0x931f(%rip), %rcx      # 0x15c85
leaq 0x90d0(%rip), %rsi      # 0x15a3d
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x4290
leaq 0x8c1e(%rip), %rsi      # 0x1559e
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
callq 0x4180
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/Shift.cpp
// Function: operator<<(std::ostream&, Shift const&)
ostream& operator<<(ostream& output, const Shift& S){
    output << "\t{" <<
        "\n\t\tcustomer uuid : " << S.customer_uuid <<
        "\n\t\tdriver in charge uuid : " << S.driver_in_charge_uuid <<
        "\n\t\ttaxi id : " << S.car_id <<
        "\n\t\ttaxi fare amount (per kilometer) : " << S.taxi_fare_amount <<
        "\n\t\tdriver waitin charges : " << S.waiting_charges <<
        "\n\t}" <<
        endl;
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x879e(%rip), %rsi      # 0x15547
callq 0x4290
leaq 0x882d(%rip), %rsi      # 0x155e2
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
movq %r14, %rsi
callq 0x4250
leaq 0x8827(%rip), %rsi      # 0x155f6
movq %rax, %rdi
callq 0x4290
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x8828(%rip), %rsi      # 0x15612
movq %rax, %rdi
callq 0x4290
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x881b(%rip), %rsi      # 0x15620
movq %rax, %rdi
callq 0x4290
movl 0x60(%r14), %esi
movq %rax, %rdi
callq 0x4430
leaq 0x8827(%rip), %rsi      # 0x15647
movq %rax, %rdi
callq 0x4290
movl 0x64(%r14), %esi
movq %rax, %rdi
callq 0x4430
leaq 0x8763(%rip), %rsi      # 0x1559e
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
callq 0x4180
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::TaxiAgency()
TaxiAgency::TaxiAgency(){
    DriverWagePerMonth = 1000;
    GarageLimit = 64;
    EachCarLimit = 4;
    DriverLimit = 64;
    WaitingCharges = 10;

    taxies.reserve(GarageLimit+1);
    driver_db.reserve(DriverLimit+1);
    customer_db.reserve(DriverLimit+1);

    cout << rang::fg::yellow << "A Taxi Agency has been instantiated" << rang::fg::reset << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x40(%rdi)
movq %r14, 0x50(%rdi)
movq %r14, 0x48(%rdi)
andq $0x0, 0x58(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, -0x48(%rbp)
leaq 0x30(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq 0x60(%rdi), %r13
movq %r13, 0x68(%rdi)
movq %r13, 0x60(%rdi)
andq $0x0, 0x70(%rdi)
leaq -0x54(%rbp), %rdx
andl $0x0, (%rdx)
leaq 0x7b8a(%rip), %rsi      # 0x15690
leaq -0xd0(%rbp), %r15
movq %r15, %rdi
callq 0x118c2
leaq -0xa8(%rbp), %r12
leaq -0x50(%rbp), %rdx
andl $0x0, (%rdx)
leaq 0x7b78(%rip), %rsi      # 0x156a2
movq %r12, %rdi
callq 0x118ec
leaq -0x80(%rbp), %r12
leaq -0x4c(%rbp), %rdx
andl $0x0, (%rdx)
leaq 0x7b6e(%rip), %rsi      # 0x156b2
movq %r12, %rdi
callq 0x11916
leaq 0xa0(%rbx), %r15
leaq -0x58(%rbp), %rdx
leaq -0x29(%rbp), %rax
movq %rax, (%rsp)
leaq -0xd0(%rbp), %rsi
leaq -0x2b(%rbp), %r8
leaq -0x2a(%rbp), %r9
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xd38a
pushq $0x50
popq %r12
leaq (%r12,%rbp), %rdi
addq $-0xd0, %rdi
callq 0x4170
addq $-0x28, %r12
cmpq $-0x28, %r12
jne 0xdb7c
movaps 0x7ae3(%rip), %xmm0     # 0x15680
movups %xmm0, 0x78(%rbx)
movl $0xa, 0x88(%rbx)
pushq $0x41
popq %rsi
movq %rbx, %rdi
callq 0x11940
movslq 0x84(%rbx), %rsi
incq %rsi
movq -0x48(%rbp), %rdi
callq 0x119d6
movslq 0x84(%rbx), %rsi
incq %rsi
movq -0x40(%rbp), %rdi
callq 0x11a70
movq 0x1038d(%rip), %rdi     # 0x1df70
pushq $0x21
popq %rsi
callq 0xbbcd
leaq 0x7acd(%rip), %rsi      # 0x156bf
movq %rax, %rdi
callq 0x4290
pushq $0x27
popq %rsi
movq %rax, %rdi
callq 0xbbcd
movq %rax, %rdi
callq 0x4180
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x38(%rbp)
pushq $0x50
popq %r15
leaq (%r15,%rbp), %rdi
addq $-0xd0, %rdi
callq 0x4170
addq $-0x28, %r15
cmpq $-0x28, %r15
jne 0xdc27
jmp 0xdc6e
jmp 0xdc45
movq %rax, -0x38(%rbp)
addq $-0x28, %r12
movq %r12, %rdi
callq 0x4170
cmpq %r15, %r12
jne 0xdc49
jmp 0xdc6e
movq %rax, -0x38(%rbp)
jmp 0xdc6e
movq %rax, -0x38(%rbp)
movq %r15, %rdi
callq 0xd2c6
movq %r13, %rdi
callq 0x122e4
movq %r14, %rdi
callq 0x122e4
movq -0x40(%rbp), %rdi
callq 0x11b06
movq -0x48(%rbp), %rdi
callq 0x11b32
movq %rbx, %rdi
callq 0x11b5e
movq -0x38(%rbp), %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_taxies()
void TaxiAgency::print_taxies(){
    cout << rang::fg::blue << "Taxies List:" << rang::fg::reset << endl;
    cout << "[" << endl;
    for(auto taxi: taxies){
        taxi.print();
    };
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0xfab7(%rip), %r14      # 0x1df70
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0xbbcd
leaq 0x7374(%rip), %rsi      # 0x1583f
movq %rax, %rdi
callq 0x4290
pushq $0x27
popq %rsi
movq %rax, %rdi
callq 0xbbcd
movq %rax, %rdi
callq 0x4180
leaq 0x5f48(%rip), %rsi      # 0x14435
movq %r14, %rdi
callq 0x4290
movq %rax, %rdi
callq 0x4180
movq (%rbx), %r14
movq 0x8(%rbx), %r15
leaq -0x70(%rbp), %rbx
cmpq %r15, %r14
je 0xe52e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d1a
movq %rbx, %rdi
callq 0x11d78
movq %rbx, %rdi
callq 0x11cba
addq $0x58, %r14
jmp 0xe508
movq 0xfa3b(%rip), %rdi      # 0x1df70
leaq 0x7310(%rip), %rsi      # 0x1584c
callq 0x4290
movq %rax, %rdi
callq 0x4180
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x11cba
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::retrieve_taxi_by_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
IndexInstance<Taxi> TaxiAgency::retrieve_taxi_by_id(string id){
    for(int i = 0; i < taxies.size(); i++){
        if(taxies[i].id == id){
            return {i, &taxies[i]};
        };
    };
    throw invalid_argument("Taxi with the id doesn't exist");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
pushq $0x58
popq %r13
xorl %r12d, %r12d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0xe5ce
leaq (%rcx,%rbx), %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0xbd1b
testb %al, %al
jne 0xe5b6
incq %r12
addq $0x58, %rbx
jmp 0xe585
addq (%r14), %rbx
movl %r12d, %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0x726e(%rip), %rsi      # 0x1584e
movq %rax, %rdi
callq 0x4470
movq 0xf9c9(%rip), %rsi      # 0x1dfb8
movq 0xf9a2(%rip), %rdx      # 0x1df98
movq %rbx, %rdi
callq 0x4410
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::insert_new_taxi_breed(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void TaxiAgency::insert_new_taxi_breed(bool hybrid, string id, string manufacturer, int fare_amount, int number){
    if(taxies.size() == GarageLimit+1)
        throw range_error("The limit of garage is reached. Need to upgrade the Agency!");
    try{
        retrieve_taxi_by_id(id);
        throw ("Taxi with the provided id already exist. Id should be unique.");
    }catch(invalid_argument){
        taxies.push_back(Taxi(hybrid, id, manufacturer, fare_amount, number, number));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %rdx, %r15
movl %esi, -0x2c(%rbp)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movslq 0x7c(%rdi), %rcx
incq %rcx
cmpq %rcx, %rax
jne 0xe67f
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0x720c(%rip), %rsi      # 0x1586d
movq %rax, %rdi
callq 0x4420
movq 0xf930(%rip), %rsi      # 0x1dfa0
movq 0xf8e9(%rip), %rdx      # 0x1df60
movq %rbx, %rdi
callq 0x4410
movl %r9d, %r14d
movq %rdi, %rbx
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x4360
leaq -0xa8(%rbp), %rsi
movq %rbx, %rdi
callq 0xe568
leaq -0xa8(%rbp), %rdi
callq 0x4170
pushq $0x8
popq %rdi
callq 0x4190
leaq 0x71eb(%rip), %rcx      # 0x158a9
movq %rcx, (%rax)
movq 0xf880(%rip), %rsi      # 0x1df48
movq %rax, %rdi
xorl %edx, %edx
callq 0x4410
movq %rdx, %r13
movq %rax, %r12
leaq -0xa8(%rbp), %rdi
callq 0x4170
jmp 0xe6ff
movq %rax, %r12
movq %rbx, %rdi
callq 0x4220
movq %r12, %rdi
callq 0x4450
movq %rdx, %r13
movq %rax, %r12
cmpl $0x1, %r13d
jne 0xe6f1
movq %r12, %rdi
callq 0x4310
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xbda4
movq %r12, %rdi
callq 0x4150
leaq -0x88(%rbp), %rdi
movq %r15, %rsi
callq 0x4360
leaq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4360
movl %r14d, (%rsp)
movzbl -0x2c(%rbp), %esi
leaq -0x100(%rbp), %rdi
leaq -0x88(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movl -0x30(%rbp), %r8d
movl %r14d, %r9d
callq 0x11bba
leaq -0x100(%rbp), %rsi
movq %rbx, %rdi
callq 0x12c7c
leaq -0x100(%rbp), %rdi
callq 0x11cba
leaq -0x68(%rbp), %rdi
callq 0x4170
leaq -0x88(%rbp), %rdi
callq 0x4170
leaq -0x48(%rbp), %rdi
callq 0x44a0
callq 0x43e0
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq -0x100(%rbp), %rdi
callq 0x11cba
jmp 0xe7c7
movq %rax, %r12
leaq -0x68(%rbp), %rdi
callq 0x4170
jmp 0xe7d5
movq %rax, %r12
leaq -0x88(%rbp), %rdi
callq 0x4170
jmp 0xe7e6
movq %rax, %r12
leaq -0x48(%rbp), %rdi
callq 0x44a0
callq 0x43e0
jmp 0xe6f1
movq %rax, %rdi
callq 0xbc20
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::add_taxi_by_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
IndexInstance<Taxi> TaxiAgency::add_taxi_by_id(string id, int num){
    IndexInstance<Taxi> taxi = retrieve_taxi_by_id(id);
    if(num < 0)
        throw invalid_argument("Invalid Number provided");
    if(taxi.data->number + num >= EachCarLimit)
        throw range_error("Number of a certain Taxi shouldn't increase beyond EachCarLimit.");
    taxi.data->number += num;
    taxi.data->available_number += num;
    return taxi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x4360
movq %r14, %rdi
movq %r15, %rsi
callq 0xe568
movl %eax, %r12d
movq %rdx, %r15
leaq -0x40(%rbp), %rdi
callq 0x4170
testl %ebx, %ebx
js 0xe86a
movl 0x4c(%r15), %eax
addl %ebx, %eax
cmpl 0x80(%r14), %eax
jge 0xe894
movl %eax, 0x4c(%r15)
addl %ebx, 0x50(%r15)
movl %r12d, %eax
movq %r15, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x706b(%rip), %rsi      # 0x158e7
movq %rax, %rdi
callq 0x4470
movq 0xf72d(%rip), %rsi      # 0x1dfb8
movq 0xf706(%rip), %rdx      # 0x1df98
jmp 0xe8bc
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x7059(%rip), %rsi      # 0x158ff
movq %rax, %rdi
callq 0x4420
movq 0xf6eb(%rip), %rsi      # 0x1dfa0
movq 0xf6a4(%rip), %rdx      # 0x1df60
movq %r14, %rdi
callq 0x4410
jmp 0xe8c6
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0xe8df
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::remove_taxi_by_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
IndexInstance<Taxi> TaxiAgency::remove_taxi_by_id(string id, int num){;
    IndexInstance<Taxi> taxi = retrieve_taxi_by_id(id);
    if(num < 0)
        throw invalid_argument("Invalid Number provided");
    if(taxi.data->number - num < 0)
        throw range_error("Not enough taxies to remove.");
    taxi.data->number -= num;
    if(taxi.data->available_number != 0)
        taxi.data->available_number -= num;
    if(taxi.data->number == 0)
        taxies.erase(taxies.begin() + taxi.index);
    return taxi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x4360
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe568
movl %eax, %r12d
movq %rdx, %r15
leaq -0x40(%rbp), %rdi
callq 0x4170
testl %r14d, %r14d
js 0xe970
movl 0x4c(%r15), %eax
movl %eax, %ecx
subl %r14d, %ecx
js 0xe99a
movl %ecx, 0x4c(%r15)
movl 0x50(%r15), %ecx
testl %ecx, %ecx
je 0xe946
subl %r14d, %ecx
movl %ecx, 0x50(%r15)
cmpl %r14d, %eax
jne 0xe95d
movslq %r12d, %rax
imulq $0x58, %rax, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x11d8c
movl %r12d, %eax
movq %r15, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x6f65(%rip), %rsi      # 0x158e7
movq %rax, %rdi
callq 0x4470
movq 0xf627(%rip), %rsi      # 0x1dfb8
movq 0xf600(%rip), %rdx      # 0x1df98
jmp 0xe9c2
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x6f94(%rip), %rsi      # 0x15940
movq %rax, %rdi
callq 0x4420
movq 0xf5e5(%rip), %rsi      # 0x1dfa0
movq 0xf59e(%rip), %rdx      # 0x1df60
movq %r14, %rdi
callq 0x4410
jmp 0xe9cc
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0xe9e5
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::export_taxies(char const*)
void TaxiAgency::export_taxies(const char* TAXIES_FILE){
    ofstream File;
    File.open(TAXIES_FILE);
    if(File.is_open()){
        File << "\"hybrid\",\"id\",\"manufacturer\",\"fare_amount\",\"number\"\n";
        for(auto taxi : taxies){
            File << "\"" << (taxi.hybrid ? "True" : "False") << "\",";
            File << "\"" << taxi.id << "\",";
            File << "\"" << taxi.manufacturer << "\",";
            File << taxi.fare_amount << ",";
            File << taxi.number << ",";
            File << taxi.available_number << "\n";
        }
        File.close();
    }else{
        throw runtime_error("File couldn't be resolved");
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x288(%rbp), %r15
movq %r15, %rdi
callq 0x4400
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4050
leaq -0x218(%rbp), %rdi
callq 0x40d0
testb %al, %al
je 0xeb8c
leaq 0x6f1d(%rip), %rsi      # 0x1595d
leaq -0x288(%rbp), %rdi
callq 0x4290
movq (%r14), %rbx
movq 0x8(%r14), %rax
movq %rax, -0x30(%rbp)
leaq 0x573f(%rip), %r13      # 0x1419d
leaq -0x288(%rbp), %r14
leaq 0x6f31(%rip), %r15      # 0x1599d
leaq 0x6f2b(%rip), %r12      # 0x1599e
cmpq -0x30(%rbp), %rbx
je 0xeb62
leaq -0x88(%rbp), %rdi
movq %rbx, %rsi
callq 0x11d1a
movq %r14, %rdi
movq %r13, %rsi
callq 0x4290
cmpb $0x0, -0x88(%rbp)
leaq 0x6ef2(%rip), %rsi      # 0x15997
leaq 0x6ee6(%rip), %rcx      # 0x15992
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
movq %r15, %rsi
callq 0x4290
movq %r14, %rdi
movq %r13, %rsi
callq 0x4290
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x4250
movq %rax, %rdi
movq %r15, %rsi
callq 0x4290
movq %r14, %rdi
movq %r13, %rsi
callq 0x4290
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x4250
movq %rax, %rdi
movq %r15, %rsi
callq 0x4290
movl -0x40(%rbp), %esi
movq %r14, %rdi
callq 0x4430
movq %rax, %rdi
movq %r12, %rsi
callq 0x4290
movl -0x3c(%rbp), %esi
movq %r14, %rdi
callq 0x4430
movq %rax, %rdi
movq %r12, %rsi
callq 0x4290
movl -0x38(%rbp), %esi
movq %r14, %rdi
callq 0x4430
movq %rax, %rdi
leaq 0x705c(%rip), %rsi      # 0x15ba4
callq 0x4290
leaq -0x88(%rbp), %rdi
callq 0x11cba
addq $0x58, %rbx
jmp 0xea73
leaq -0x288(%rbp), %rdi
callq 0x4370
leaq -0x288(%rbp), %rdi
callq 0x43a0
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x6c87(%rip), %rsi      # 0x15825
movq %rax, %rdi
callq 0x4130
movq 0xf43b(%rip), %rsi      # 0x1dfe8
movq 0xf3b4(%rip), %rdx      # 0x1df68
movq %r14, %rdi
callq 0x4410
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0xebdf
jmp 0xebcb
movq %rax, %rbx
jmp 0xebdf
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x11cba
leaq -0x288(%rbp), %rdi
callq 0x43a0
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_customer_db()
void TaxiAgency::print_customer_db(){
    cout << rang::fg::blue << "Customers List:" << rang::fg::reset << endl;
    cout << "[" << endl;
    for(auto customer: customer_db){
        customer.print();
    };
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0xefc1(%rip), %r14      # 0x1df70
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0xbbcd
leaq 0x69df(%rip), %rsi      # 0x159a0
movq %rax, %rdi
callq 0x4290
pushq $0x27
popq %rsi
movq %rax, %rdi
callq 0xbbcd
movq %rax, %rdi
callq 0x4180
leaq 0x5452(%rip), %rsi      # 0x14435
movq %r14, %rdi
callq 0x4290
movq %rax, %rdi
callq 0x4180
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r15
leaq -0x80(%rbp), %rbx
cmpq %r15, %r14
je 0xf025
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11df4
movq %rbx, %rdi
callq 0xc998
movq %rbx, %rdi
callq 0xc7d8
addq $0x68, %r14
jmp 0xefff
movq 0xef44(%rip), %rdi      # 0x1df70
leaq 0x6819(%rip), %rsi      # 0x1584c
callq 0x4290
movq %rax, %rdi
callq 0x4180
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0xc7d8
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::delete_customer_user_by_uuid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TaxiAgency::delete_customer_user_by_uuid(string uuid){
    IndexInstance<Customer> customer = search_customer_by_uuid(uuid);
    if(customer.data->getStatus() == ONSHIFT)
        throw invalid_argument("Can't delete a customer while its ONSHIFT");
    customer_db.erase(customer_db.begin() + customer.index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x4360
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf060
movl %eax, %r14d
movq %rdx, %r15
leaq -0x38(%rbp), %rdi
callq 0x4170
movq %r15, %rdi
callq 0xc9ca
testl %eax, %eax
je 0xf4ec
movl %r14d, %eax
imulq $0x68, %rax, %rsi
addq 0x30(%rbx), %rsi
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x11eb4
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0x651d(%rip), %rsi      # 0x15a1b
movq %rax, %rdi
callq 0x4470
movq 0xeaab(%rip), %rsi      # 0x1dfb8
movq 0xea84(%rip), %rdx      # 0x1df98
movq %rbx, %rdi
callq 0x4410
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
jmp 0xf535
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_drivers_db()
void TaxiAgency::print_drivers_db(){
    cout << rang::fg::blue << "Drivers List:" << rang::fg::reset << endl;
    cout << "[" << endl;
    for(auto driver: driver_db){
        driver.print();
    };
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0xe368(%rip), %r14      # 0x1df70
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0xbbcd
leaq 0x5e65(%rip), %rsi      # 0x15a7f
movq %rax, %rdi
callq 0x4290
pushq $0x27
popq %rsi
movq %rax, %rdi
callq 0xbbcd
movq %rax, %rdi
callq 0x4180
leaq 0x47f9(%rip), %rsi      # 0x14435
movq %r14, %rdi
callq 0x4290
movq %rax, %rdi
callq 0x4180
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r15
leaq -0xa0(%rbp), %rbx
cmpq %r15, %r14
je 0xfc84
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11f76
movq %rbx, %rdi
callq 0xc778
movq %rbx, %rdi
callq 0x11f18
addq $0x88, %r14
jmp 0xfc5b
movq 0xe2e5(%rip), %rdi      # 0x1df70
leaq 0x5bba(%rip), %rsi      # 0x1584c
callq 0x4290
movq %rax, %rdi
callq 0x4180
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x11f18
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::delete_driver_user_by_uuid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TaxiAgency::delete_driver_user_by_uuid(string uuid){
    IndexInstance<Driver> driver = search_driver_by_uuid(uuid);
    if(driver.data->getStatus() == ONSHIFT)
        throw invalid_argument("Can't delete a driver while its ONSHIFT");
    driver_db.erase(driver_db.begin() + driver.index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x4360
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfcc4
movl %eax, %r14d
movq %rdx, %r15
leaq -0x38(%rbp), %rdi
callq 0x4170
movq %r15, %rdi
callq 0xc7cc
testl %eax, %eax
je 0x101d1
movl %r14d, %eax
imulq $0x88, %rax, %rsi
addq 0x18(%rbx), %rsi
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x12062
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0x58f0(%rip), %rsi      # 0x15ad3
movq %rax, %rdi
callq 0x4470
movq 0xddc6(%rip), %rsi      # 0x1dfb8
movq 0xdd9f(%rip), %rdx      # 0x1df98
movq %rbx, %rdi
callq 0x4410
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
jmp 0x1021a
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::export_ongoing_shifts(char const*)
void TaxiAgency::export_ongoing_shifts(const char* CURRENT_SHIFTS_FILE){
    ofstream File;
    File.open(CURRENT_SHIFTS_FILE);
    if(File.is_open()){
        File << "\"customer_uuid\",\"driver_uuid\",\"taxi_id\"\n";
        for(list<Shift>::iterator shift = current_shifts.begin(); shift != current_shifts.end(); ++shift){
            File << "\"" << shift->getCustomerUUID() << "\",";
            File << "\"" << shift->getDriverUUID() << "\",";
            File << "\"" << shift->getCarID() << "\"";
            File << shift->getFareAmount() << ",";
            File << shift->getWaitingCharges() << "\n";
        }
        File.close();
    }else{
        throw runtime_error("File couldn't be resolved");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r12
leaq -0x230(%rbp), %r14
movq %r14, %rdi
callq 0x4400
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4050
leaq -0x1c0(%rbp), %rdi
callq 0x40d0
testb %al, %al
je 0x10f9e
leaq 0x4d11(%rip), %rsi      # 0x15b7d
leaq -0x230(%rbp), %rdi
callq 0x4290
addq $0x48, %r12
leaq 0x331a(%rip), %r14      # 0x1419d
leaq -0x230(%rbp), %r15
movq %r12, -0x30(%rbp)
movq (%r12), %r12
cmpq -0x30(%rbp), %r12
je 0x10f74
movq %r15, %rdi
movq %r14, %rsi
callq 0x4290
movq %rax, %rbx
leaq 0x10(%r12), %r13
movq %r13, %rdi
callq 0xce72
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4250
movq %rax, %rdi
leaq 0x4ad1(%rip), %rsi      # 0x1599d
callq 0x4290
movq %r15, %rdi
movq %r14, %rsi
callq 0x4290
movq %rax, %rbx
movq %r13, %rdi
callq 0xce68
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4250
movq %rax, %rdi
leaq 0x4aa1(%rip), %rsi      # 0x1599d
callq 0x4290
movq %r15, %rdi
movq %r14, %rsi
callq 0x4290
movq %rax, %rbx
movq %r13, %rdi
callq 0xce7c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4250
movq %rax, %rdi
movq %r14, %rsi
callq 0x4290
movq %r13, %rdi
callq 0xce86
movl (%rax), %esi
movq %r15, %rdi
callq 0x4430
movq %rax, %rdi
leaq 0x4a55(%rip), %rsi      # 0x1599e
callq 0x4290
movq %r13, %rdi
callq 0xce90
movl (%rax), %esi
movq %r15, %rdi
callq 0x4430
movq %rax, %rdi
leaq 0x4c3a(%rip), %rsi      # 0x15ba4
callq 0x4290
jmp 0x10e8e
leaq -0x230(%rbp), %rdi
callq 0x4370
leaq -0x230(%rbp), %rdi
callq 0x43a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x4875(%rip), %rsi      # 0x15825
movq %rax, %rdi
callq 0x4130
movq 0xd029(%rip), %rsi      # 0x1dfe8
movq 0xcfa2(%rip), %rdx      # 0x1df68
movq %r14, %rdi
callq 0x4410
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x10fe0
jmp 0x10fdd
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x43a0
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::extend_shift_tenure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void TaxiAgency::extend_shift_tenure(string customer_uuid, int del_running_kms, int del_waiting_hours){
    for(list<Shift>::iterator i = current_shifts.begin(); i != current_shifts.end(); ++i)
        if(i->getCustomerUUID() == customer_uuid){
            IndexInstance<Taxi> taxi = retrieve_taxi_by_id(i->getCarID());
            int del_total_cost = del_running_kms*taxi.data->fare_amount + del_waiting_hours*WaitingCharges;
            if(search_customer_by_uuid(customer_uuid).data->getBalance() < i->getTotalCost()+del_total_cost)
                throw booking_unsuccessful("Not enough balance to increase the shift tenure");

            i->extend_tenure(del_running_kms, del_waiting_hours);
            return;
        }
    throw invalid_argument("Customer with the supplied UUID is IDLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movq %rsi, %r13
movq %rdi, %r12
leaq 0x48(%rdi), %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x114c5
leaq 0x10(%r14), %r15
movq %r15, %rdi
callq 0xce72
movq %rax, %rdi
movq %r13, %rsi
callq 0xbd1b
testb %al, %al
je 0x11400
movq %r15, %rdi
callq 0xce7c
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4360
movq %r12, %rdi
movq %rbx, %rsi
callq 0xe568
movq %rdx, %rbx
leaq -0x70(%rbp), %rdi
callq 0x4170
movl 0x48(%rbx), %ebx
imull -0x2c(%rbp), %ebx
movl 0x88(%r12), %r14d
imull -0x30(%rbp), %r14d
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x4360
movq %r12, %rdi
leaq -0x50(%rbp), %rsi
callq 0xf060
movq %rdx, %rdi
callq 0xc9d4
movl %eax, %r12d
movq %r15, %rdi
callq 0xcf5a
addl %ebx, %r14d
addl (%rax), %r14d
leaq -0x50(%rbp), %rdi
callq 0x4170
cmpl %r14d, %r12d
jl 0x114f5
movq %r15, %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0xd206
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x478b(%rip), %rsi      # 0x15c62
movq %rax, %rdi
callq 0x4470
movq 0xcad2(%rip), %rsi      # 0x1dfb8
movq 0xcaab(%rip), %rdx      # 0x1df98
movq %r14, %rdi
callq 0x4410
pushq $0x10
popq %rdi
callq 0x4190
leaq 0xc70c(%rip), %rcx      # 0x1dc10
movq %rcx, (%rax)
leaq 0x4724(%rip), %rcx      # 0x15c32
movq %rcx, 0x8(%rax)
leaq 0xc6cf(%rip), %rsi      # 0x1dbe8
movq 0xcaa8(%rip), %rdx      # 0x1dfc8
movq %rax, %rdi
callq 0x4410
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x11538
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4170
jmp 0x1154a
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::retrieve_shift_details_by_customer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Shift TaxiAgency::retrieve_shift_details_by_customer(string customer_uuid){
    for(list<Shift>::iterator i = current_shifts.begin(); i != current_shifts.end(); ++i)
        if(i->getCustomerUUID() == customer_uuid)
            return *i;
    throw ("Customer with the supplied UUID is IDLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x48, %r15
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x115b1
leaq 0x10(%r13), %r12
movq %r12, %rdi
callq 0xce72
movq %rax, %rdi
movq %r14, %rsi
callq 0xbd1b
testb %al, %al
je 0x11570
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12248
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x4190
leaq 0x46a2(%rip), %rcx      # 0x15c62
movq %rcx, (%rax)
movq 0xc97e(%rip), %rsi      # 0x1df48
movq %rax, %rdi
xorl %edx, %edx
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::end_shift(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TaxiAgency::end_shift(string customer_uuid){
    for(list<Shift>::iterator i = current_shifts.begin(); i != current_shifts.end(); ++i)
        if(i->getCustomerUUID() == customer_uuid){
            IndexInstance<Taxi> taxi = retrieve_taxi_by_id(i->getCarID());
            int total_cost = i->getRunningKms()*taxi.data->fare_amount + i->getWaitingHours()*WaitingCharges;
            shift_history.push_back(*i);
            current_shifts.erase(i);
            search_customer_by_uuid(customer_uuid).data->makeTransaction(total_cost);
            return;
        }
    throw invalid_argument("Customer with the supplied UUID is IDLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq 0x48(%rdi), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x116d6
leaq 0x10(%r12), %r13
movq %r13, %rdi
callq 0xce72
movq %rax, %rdi
movq %r14, %rsi
callq 0xbd1b
testb %al, %al
je 0x115f3
movq %r13, %rdi
callq 0xce7c
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4360
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0xe568
movq %rdx, %rbx
leaq -0x80(%rbp), %rdi
callq 0x4170
movq %r13, %rdi
callq 0xce9a
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl 0x48(%rbx), %eax
movl %eax, -0x3c(%rbp)
movq %r13, %rdi
callq 0xcefa
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl 0x88(%rax), %ebx
leaq 0x60(%rax), %rdi
movq %r13, %rsi
callq 0x12238
movq %r15, %rdi
movq %r12, %rsi
callq 0x122cc
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4360
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xf060
movl -0x3c(%rbp), %eax
imull -0x38(%rbp), %eax
imull -0x34(%rbp), %ebx
addl %eax, %ebx
movq %rdx, %rdi
movl %ebx, %esi
callq 0xc9de
leaq -0x60(%rbp), %rdi
callq 0x4170
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r14
leaq 0x457a(%rip), %rsi      # 0x15c62
movq %rax, %rdi
callq 0x4470
movq 0xc8c1(%rip), %rsi      # 0x1dfb8
movq 0xc89a(%rip), %rdx      # 0x1df98
movq %r14, %rdi
callq 0x4410
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x11716
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4170
jmp 0x11728
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_ongoing_shifts()
void TaxiAgency::print_ongoing_shifts(){
    cout << "[" << endl;
    for (list<Shift>::iterator i = current_shifts.begin(); i != current_shifts.end(); ++i)
        cout << *i;
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc82c(%rip), %r14      # 0x1df70
leaq 0x2cea(%rip), %rsi      # 0x14435
movq %r14, %rdi
callq 0x4290
movq %rax, %rdi
callq 0x4180
addq $0x48, %rbx
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x11778
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0xcd95
jmp 0x11762
movq 0xc7f1(%rip), %rdi      # 0x1df70
leaq 0x40c6(%rip), %rsi      # 0x1584c
callq 0x4290
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4180
nop