LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/rsync_upload.c
// Function: StripChars
void StripChars(const char *in, char *out, char *stripc)
{
    while (*in)
    {
    	int flag = 0;

		int length = strlen(stripc);
		for(int i = 0; i < length; i++)
		{
			if (*in == stripc[i])
			{
				if (stripc[i] == '.' && strlen(in) == 4)
				{
					continue;
				}
				flag = 1;
				break;
			}
		}

		if (flag)
		{
			in++;
			continue;
		}
        *out++ = *in++;
    }
    *out = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x238b
movq %rdx, %r14
movq %rdi, %r15
movq %r14, %rdi
callq 0x10c0
movq %rax, %r12
testl %r12d, %r12d
jle 0x2379
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
cmpb (%r14,%r13), %bpl
jne 0x2371
cmpb $0x2e, %bpl
jne 0x237f
movq %r15, %rdi
callq 0x10c0
cmpq $0x4, %rax
jne 0x237f
incq %r13
cmpq %r13, %r12
jne 0x2357
movb %bpl, (%rbx)
incq %rbx
movb 0x1(%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x233d
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b17
leaq 0x1ac1(%rip), %rdi      # 0x45d1
callq 0x1070
jmp 0x2b45
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x11f0
movq 0x8(%rbx), %rsi
movzwl %ax, %ebp
leaq 0x17aa(%rip), %rdi      # 0x42db
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0x239d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a90(%rip), %xmm0     # 0x4600
leaq 0x40(%rsp), %r14
movaps %xmm0, (%r14)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x2c67
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d46
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 0x1a42(%rip), %rsi      # 0x4650
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_O3/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 0x2d3c
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 0x2cad
incl %eax
movl %eax, 0x4(%r14)
testl %r13d, %r13d
je 0x2cf6
leal (%r15,%r13), %eax
movl $0x40, %r12d
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 0x2d3c
leaq 0x18(%r14), %rsi
addq %r12, %rbx
subl %r12d, %r15d
movq %r14, %rdi
callq 0x2e4e
cmpl $0x40, %r15d
jl 0x2d1a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e4e
addq $0x40, %rbx
leal -0x40(%r15), %eax
cmpl $0x7f, %r15d
movl %eax, %r15d
ja 0x2cfc
jmp 0x2d1d
movl %r15d, %eax
testl %eax, %eax
je 0x2d3c
addq $0x18, %r14
movslq %eax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
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_O3/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
movdqa 0x18b8(%rip), %xmm0     # 0x4610
xorl %eax, %eax
movdqa 0x18be(%rip), %xmm1     # 0x4620
movaps 0x18c7(%rip), %xmm2     # 0x4630
movdqa 0x18cf(%rip), %xmm3     # 0x4640
movd (%r14,%rax), %xmm4
pshufd $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
movdqa %xmm0, %xmm5
pslld $0x3, %xmm5
pand %xmm1, %xmm5
pshuflw $0xfe, %xmm5, %xmm6     # xmm6 = xmm5[2,3,3,3,4,5,6,7]
movdqa %xmm4, %xmm7
psrld %xmm6, %xmm7
pshuflw $0x54, %xmm5, %xmm6     # xmm6 = xmm5[0,1,1,1,4,5,6,7]
movdqa %xmm4, %xmm8
psrld %xmm6, %xmm8
punpcklqdq %xmm7, %xmm8    # xmm8 = xmm8[0],xmm7[0]
pshufd $0xee, %xmm5, %xmm5     # xmm5 = xmm5[2,3,2,3]
pshuflw $0xfe, %xmm5, %xmm6     # xmm6 = xmm5[2,3,3,3,4,5,6,7]
movdqa %xmm4, %xmm7
psrld %xmm6, %xmm7
pshuflw $0x54, %xmm5, %xmm5     # xmm5 = xmm5[0,1,1,1,4,5,6,7]
psrld %xmm5, %xmm4
punpckhqdq %xmm7, %xmm4    # xmm4 = xmm4[1],xmm7[1]
shufps $0xcc, %xmm4, %xmm8     # xmm8 = xmm8[0,3],xmm4[0,3]
andps %xmm2, %xmm8
packuswb %xmm8, %xmm8
packuswb %xmm8, %xmm8
movd %xmm8, (%rsp,%rax)
addq $0x4, %rax
paddd %xmm3, %xmm0
cmpq $0x8, %rax
jne 0x2d71
movl (%r14), %eax
shrl $0x3, %eax
movl $0x37, %edx
subl %eax, %edx
andl $0x3f, %edx
incl %edx
leaq 0x1897(%rip), %rsi      # 0x46a0
movq %r14, %rdi
callq 0x2c67
movq %rsp, %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x2c67
xorl %eax, %eax
xorl %edx, %edx
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
cmpq $0x10, %rdx
jne 0x2e25
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/0918nobita[P]algorithm/polynomial2.cc
// Function: main
int main() {
  int X0, N;
  std::cin >> X0 >> N;
  std::vector<int> A(N);

  for (int i = 0; i < N; i++) {
    std::cin >> A[i];
  }

  if (N < 1) {
    std::cout << 0 << std::endl;
  } else {
    int S = A[N - 1];

    for (int i = N - 1; i >= 1; i--) {
      S = S * X0 + A[i - 1];
    }

    std::cout << S << std::endl;
  }
  return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x2d84(%rip), %rdi      # 0x3fe0
leaq 0x14(%rsp), %rsi
callq 0x1070
leaq 0x10(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movslq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x13a2
cmpl $0x0, (%rbx)
jle 0x1320
xorl %r14d, %r14d
movq 0x2d45(%rip), %rbx      # 0x3fe0
xorl %r15d, %r15d
movq 0x18(%rsp), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x1070
incq %r15
movslq 0x10(%rsp), %rax
addq $0x4, %r14
cmpq %rax, %r15
jl 0x129e
testl %eax, %eax
jle 0x1320
movq 0x18(%rsp), %rcx
movl -0x4(%rcx,%rax,4), %esi
cmpl $0x1, %eax
je 0x12e8
movl 0x14(%rsp), %edx
incq %rax
imull %edx, %esi
addl -0xc(%rcx,%rax,4), %esi
decq %rax
cmpq $0x2, %rax
ja 0x12d8
movq 0x2ce1(%rip), %rdi      # 0x3fd0
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
jmp 0x1358
movq 0x2ca9(%rip), %rdi      # 0x3fd0
xorl %esi, %esi
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x136f
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x137f
jmp 0x137f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1399
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl 0x14045(%rip), %eax     # 0x23280
cmpl $0x2, %eax
je 0xf270
cmpl $0x1, %eax
jne 0xf2a6
movb 0x1409d(%rip), %al      # 0x232e8
testb %al, %al
je 0xf2b2
cmpb $0x1, 0x1408c(%rip)     # 0x232e2
jne 0xf2a6
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %rdi
callq 0xf5f6
testb %al, %al
je 0xf2a6
leaq 0xb1e2(%rip), %rsi      # 0x1a459
movl $0x2, %edx
movq %rbx, %rdi
callq 0x4320
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4460
movq %rax, %rbx
leaq 0xb840(%rip), %rsi      # 0x1aad9
movl $0x1, %edx
movq %rax, %rdi
callq 0x4320
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1402f(%rip), %rdi     # 0x232e8
callq 0x44b0
testl %eax, %eax
je 0xf24f
leaq -0x11(%rbp), %rdi
callq 0xf678
movb %al, 0x14011(%rip)      # 0x232e2
leaq 0x14010(%rip), %rdi     # 0x232e8
callq 0x41d0
jmp 0xf24f
movq %rax, %rdi
callq 0xf2ea
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13977(%rip), %rax     # 0x22f78
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xf658
movq 0x139c7(%rip), %rax     # 0x22fe0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xf646
movq 0x13907(%rip), %rax     # 0x22f38
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xf646
xorl %eax, %eax
jmp 0xf668
movb 0x13cbc(%rip), %al      # 0x23308
testb %al, %al
je 0xf66a
movb 0x13caa(%rip), %al      # 0x23300
jmp 0xf668
movb 0x13c9a(%rip), %al      # 0x232f8
testb %al, %al
je 0xf671
movb 0x13c88(%rip), %al      # 0x232f0
popq %rbp
retq
callq 0x4500
jmp 0xf650
callq 0x4542
jmp 0xf662
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x13776(%rip), %rax     # 0x232d0
movslq (%rax), %rax
cmpq %rsi, %rax
jb 0xfbc6
movq %rsi, %rbx
testq %rsi, %rsi
je 0xfb86
movq %rdi, %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x43f0
testl %eax, %eax
je 0xfb91
incq %r15
cmpq %r15, %rbx
jne 0xfb70
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
leaq 0x130ee(%rip), %rcx     # 0x22c90
movq %rcx, (%rax)
leaq 0xb8c8(%rip), %rcx      # 0x1b474
movq %rcx, 0x8(%rax)
leaq 0x130b1(%rip), %rsi     # 0x22c68
movq 0x1340a(%rip), %rdx     # 0x22fc8
movq %rax, %rdi
callq 0x4440
movl $0x10, %edi
callq 0x4170
movq %rax, %rbx
leaq 0xb878(%rip), %rsi      # 0x1b452
movq %rax, %rdi
callq 0x4080
movq 0x133bf(%rip), %rsi     # 0x22fa8
movq 0x13398(%rip), %rdx     # 0x22f88
movq %rbx, %rdi
callq 0x4440
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb52f(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0xb521(%rip), %rsi      # 0x1b4cf
movl $0xa, %edx
movq %rbx, %rdi
callq 0x4320
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb505(%rip), %rsi      # 0x1b4da
movl $0xf, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb4ef(%rip), %rsi      # 0x1b4ea
movl $0xe, %edx
movq %rax, %rdi
callq 0x4320
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb4d7(%rip), %rsi      # 0x1b4f9
movl $0x1c, %edx
movq %rax, %rdi
callq 0x4320
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb4cd(%rip), %rsi      # 0x1b516
movl $0xc, %edx
movq %rax, %rdi
callq 0x4320
xorl %eax, %eax
cmpl $0x1, 0x80(%r14)
setne %al
leaq 0xbb9b(%rip), %rcx      # 0x1bc05
leaq 0xb94c(%rip), %rsi      # 0x1b9bd
cmoveq %rcx, %rsi
leaq (%rax,%rax,2), %rdx
addq $0x4, %rdx
movq %r15, %rdi
callq 0x4320
leaq 0xb497(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %r15, %rdi
callq 0x4320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb206(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0xb1f8(%rip), %rsi      # 0x1b4cf
movl $0xa, %edx
movq %rbx, %rdi
callq 0x4320
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb1dc(%rip), %rsi      # 0x1b4da
movl $0xf, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb1c6(%rip), %rsi      # 0x1b4ea
movl $0xe, %edx
movq %rax, %rdi
callq 0x4320
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb1dc(%rip), %rsi      # 0x1b527
movl $0xd, %edx
movq %rax, %rdi
callq 0x4320
movl 0x60(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0xb1c7(%rip), %rsi      # 0x1b535
movl $0xc, %edx
movq %rax, %rdi
callq 0x4320
xorl %eax, %eax
cmpl $0x1, 0x64(%r14)
setne %al
leaq 0xb879(%rip), %rcx      # 0x1bc05
leaq 0xb62a(%rip), %rsi      # 0x1b9bd
cmoveq %rcx, %rsi
leaq (%rax,%rax,2), %rdx
addq $0x4, %rdx
movq %r15, %rdi
callq 0x4320
leaq 0xb175(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %r15, %rdi
callq 0x4320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xab62(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0xabec(%rip), %rsi      # 0x1b567
movl $0x13, %edx
movq %rbx, %rdi
callq 0x4320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xabda(%rip), %rsi      # 0x1b57b
movl $0x1b, %edx
movq %rax, %rdi
callq 0x4320
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xabcf(%rip), %rsi      # 0x1b597
movl $0xd, %edx
movq %rax, %rdi
callq 0x4320
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xabb6(%rip), %rsi      # 0x1b5a5
movl $0x26, %edx
movq %rax, %rdi
callq 0x4320
movl 0x60(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0xabba(%rip), %rsi      # 0x1b5cc
movl $0x1b, %edx
movq %rax, %rdi
callq 0x4320
movl 0x64(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r14
leaq 0xaaee(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movq 0x109a5(%rip), %rbx     # 0x22f78
movq %rbx, %rdi
movl $0x22, %esi
callq 0xf224
movq %rax, %r15
leaq 0x91d5(%rip), %rsi      # 0x1b7bf
movl $0xc, %edx
movq %rax, %rdi
callq 0x4320
movq %r15, %rdi
movl $0x27, %esi
callq 0xf224
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
leaq 0x7e25(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq (%r14), %rbx
movq 0x8(%r14), %r15
cmpq %r15, %rbx
je 0x126fd
leaq -0x78(%rbp), %r14
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %r13
movb (%rbx), %al
movb %al, -0x80(%rbp)
movq %r12, -0x78(%rbp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xf492
movq %r13, -0x58(%rbp)
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0xf492
movl 0x50(%rbx), %eax
movl %eax, 0x48(%r14)
movq 0x48(%rbx), %rax
movq %rax, 0x40(%r14)
movq 0x108a9(%rip), %rdi     # 0x22f78
leaq -0x80(%rbp), %rsi
callq 0x17d8a
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x126e6
callq 0x4280
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x126f4
callq 0x4280
addq $0x58, %rbx
cmpq %r15, %rbx
jne 0x12685
leaq 0x90c8(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq 0x10868(%rip), %rbx     # 0x22f78
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x1276d
callq 0x4280
jmp 0x1276d
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x17668
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rdi), %rbx
movq 0x8(%rdi), %rax
subq %rbx, %rax
je 0x127de
movq %rsi, %r14
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r13 # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %r13
movq 0x8(%rsi), %r15
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %r12d, %r12d
cmpq %r15, 0x10(%rbx)
jne 0x127d2
testq %r15, %r15
je 0x12810
movq (%r14), %rsi
movq 0x8(%rbx), %rdi
movq %r15, %rdx
callq 0x42e0
testl %eax, %eax
je 0x12810
incq %r12
addq $0x58, %rbx
cmpq %r12, %r13
jne 0x127b4
movl $0x10, %edi
callq 0x4170
movq %rax, %rbx
leaq 0x8fdc(%rip), %rsi      # 0x1b7ce
movq %rax, %rdi
callq 0x44d0
movq 0x107b7(%rip), %rsi     # 0x22fb8
movq 0x10790(%rip), %rdx     # 0x22f98
movq %rbx, %rdi
callq 0x4440
movl %r12d, %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xf492
movq %r14, %rdi
movq %r15, %rsi
callq 0x12776
movl %eax, %r12d
movq %rdx, %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12b0c
callq 0x4280
testl %ebx, %ebx
js 0x12b3c
movl 0x4c(%r15), %eax
addl %ebx, %eax
cmpl 0x80(%r14), %eax
jge 0x12b68
movl %eax, 0x4c(%r15)
addl %ebx, 0x50(%r15)
movl %r12d, %eax
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8d17(%rip), %rsi      # 0x1b867
movq %rax, %rdi
callq 0x44d0
movq 0x10459(%rip), %rsi     # 0x22fb8
movq 0x10432(%rip), %rdx     # 0x22f98
jmp 0x12b92
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8d03(%rip), %rsi      # 0x1b87f
movq %rax, %rdi
callq 0x4450
movq 0x10415(%rip), %rsi     # 0x22fa0
movq 0x103d6(%rip), %rdx     # 0x22f68
movq %r14, %rdi
callq 0x4440
jmp 0x12b9c
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x12bba
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12bba
callq 0x4280
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xf492
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12776
movl %eax, %r12d
movq %rdx, %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12c19
callq 0x4280
testl %r14d, %r14d
js 0x12c68
movl 0x4c(%r15), %eax
movl %eax, %ecx
subl %r14d, %ecx
js 0x12c94
movl %ecx, 0x4c(%r15)
movl 0x50(%r15), %ecx
testl %ecx, %ecx
je 0x12c3c
subl %r14d, %ecx
movl %ecx, 0x50(%r15)
cmpl %r14d, %eax
jne 0x12c53
movslq %r12d, %rax
imulq $0x58, %rax, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x188f2
movl %r12d, %eax
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8beb(%rip), %rsi      # 0x1b867
movq %rax, %rdi
callq 0x44d0
movq 0x1032d(%rip), %rsi     # 0x22fb8
movq 0x10306(%rip), %rdx     # 0x22f98
jmp 0x12cbe
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8c18(%rip), %rsi      # 0x1b8c0
movq %rax, %rdi
callq 0x4450
movq 0x102e9(%rip), %rsi     # 0x22fa0
movq 0x102aa(%rip), %rdx     # 0x22f68
movq %r14, %rdi
callq 0x4440
jmp 0x12cc8
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x12ce6
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12ce6
callq 0x4280
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0xf9b3(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
movl $0x22, %esi
callq 0xf224
movq %rax, %r15
leaq 0x8344(%rip), %rsi      # 0x1b920
movl $0xf, %edx
movq %rax, %rdi
callq 0x4320
movq %r15, %rdi
movl $0x27, %esi
callq 0xf224
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
leaq 0x6e33(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq 0x30(%r14), %rbx
movq 0x38(%r14), %r14
cmpq %r14, %rbx
je 0x13716
leaq -0x60(%rbp), %r15
leaq -0x40(%rbp), %r13
leaq -0x90(%rbp), %r12
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xf492
movq %r15, -0x70(%rbp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0xf492
movq %r13, -0x50(%rbp)
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0xf492
movq 0x60(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
callq 0x103f0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x136e6
callq 0x4280
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x136f4
callq 0x4280
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x13709
callq 0x4280
addq $0x68, %rbx
cmpq %r14, %rbx
jne 0x1367b
leaq 0x80af(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq 0xf84f(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1377d
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x1377d
callq 0x4280
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x137a3
callq 0x4280
jmp 0x137a3
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x10140
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xf492
movq %rbx, %rdi
movq %r14, %rsi
callq 0x137ac
movl %eax, %r14d
movq %rdx, %r15
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13d3d
callq 0x4280
movq %r15, %rdi
callq 0x10422
testl %eax, %eax
je 0x13d6d
movl %r14d, %eax
imulq $0x68, %rax, %rsi
addq 0x30(%rbx), %rsi
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x18cf4
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x7c1a(%rip), %rsi      # 0x1b99b
movq %rax, %rdi
callq 0x44d0
movq 0xf228(%rip), %rsi      # 0x22fb8
movq 0xf201(%rip), %rdx      # 0x22f98
movq %r14, %rdi
callq 0x4440
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x13dbd
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13dbd
callq 0x4280
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movq 0xe716(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
movl $0x22, %esi
callq 0xf224
movq %rax, %r15
leaq 0x7186(%rip), %rsi      # 0x1b9ff
movl $0xd, %edx
movq %rax, %rdi
callq 0x4320
movq %r15, %rdi
movl $0x27, %esi
callq 0xf224
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
leaq 0x5b96(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq 0x18(%r14), %r15
movq 0x20(%r14), %r12
cmpq %r12, %r15
je 0x1497c
leaq -0x80(%rbp), %r13
leaq -0xa0(%rbp), %rbx
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x17856
movq %r14, %rdi
callq 0x100ce
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1493c
callq 0x4280
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x1494e
callq 0x4280
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x1495f
callq 0x4280
movq -0xb0(%rbp), %rdi
cmpq %rbx, %rdi
je 0x14970
callq 0x4280
addq $0x88, %r15
cmpq %r12, %r15
jne 0x14917
leaq 0x6e49(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq 0xe5e9(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x177be
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xf492
movq %rbx, %rdi
movq %r14, %rsi
callq 0x149e8
movl %eax, %r14d
movq %rdx, %r15
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1504d
callq 0x4280
movq %r15, %rdi
callq 0x10134
testl %eax, %eax
je 0x15084
movl %r14d, %eax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rsi
addq 0x18(%rbx), %rsi
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1909e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x69bb(%rip), %rsi      # 0x1ba53
movq %rax, %rdi
callq 0x44d0
movq 0xdf11(%rip), %rsi      # 0x22fb8
movq 0xdeea(%rip), %rdx      # 0x22f98
movq %r14, %rdi
callq 0x4440
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x150d4
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x150d4
callq 0x4280
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %r15
movq 0x48(%rsi), %r13
addq $0x48, %r15
cmpq %r15, %r13
je 0x16ead
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x10a96
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x16ea4
testq %rdx, %rdx
je 0x16ed2
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42e0
testl %eax, %eax
je 0x16ed2
movq (%r13), %r13
cmpq %r15, %r13
jne 0x16e7a
movl $0x8, %edi
callq 0x4170
leaq 0x4d24(%rip), %rcx      # 0x1bbe2
movq %rcx, (%rax)
movq 0xc080(%rip), %rsi      # 0x22f48
movq %rax, %rdi
xorl %edx, %edx
callq 0x4440
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17be6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x48(%rdi), %r15
movq %rdi, -0x30(%rbp)
movq 0x48(%rdi), %r12
cmpq %r15, %r12
je 0x16f49
movq %rsi, %r14
leaq 0x10(%r12), %r13
movq %r13, %rdi
callq 0x10a96
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x16f40
testq %rdx, %rdx
je 0x16f7b
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42e0
testl %eax, %eax
je 0x16f7b
movq (%r12), %r12
cmpq %r15, %r12
jne 0x16f15
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x4c85(%rip), %rsi      # 0x1bbe2
movq %rax, %rdi
callq 0x44d0
movq 0xc04c(%rip), %rsi      # 0x22fb8
movq 0xc025(%rip), %rdx      # 0x22f98
movq %r14, %rdi
callq 0x4440
movq %r13, %rdi
callq 0x10aa0
leaq -0x50(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0xf492
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x12776
movq %rdx, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x16fc2
callq 0x4280
movq %r13, %rdi
callq 0x10abe
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl 0x48(%rbx), %eax
movl %eax, -0x40(%rbp)
movq %r13, %rdi
callq 0x10b4c
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rcx
movl 0x88(%rcx), %eax
movl %eax, -0x38(%rbp)
leaq 0x60(%rcx), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x19176
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
movq -0x30(%rbp), %r13
incq 0x70(%r13)
movq %r15, %rdi
movq %r12, %rsi
callq 0x191b4
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0xf492
movq %r13, %rdi
movq %rbx, %rsi
callq 0x137ac
movl -0x40(%rbp), %eax
imull -0x3c(%rbp), %eax
movl -0x38(%rbp), %esi
imull -0x34(%rbp), %esi
addl %eax, %esi
movq %rdx, %rdi
callq 0x10436
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x1706b
callq 0x4280
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
jne 0x17098
jmp 0x170aa
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x170aa
callq 0x4280
jmp 0x170aa
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %r14
movq 0xbeb1(%rip), %rbx      # 0x22f78
leaq 0x338c(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq 0x48(%r14), %r12
addq $0x48, %r14
cmpq %r14, %r12
je 0x1712c
movq 0xbe62(%rip), %r15      # 0x22f78
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x10953
movq (%r12), %r12
cmpq %r14, %r12
jne 0x17116
leaq 0x4699(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_shift_history()
void TaxiAgency::print_shift_history(){
    cout << "[" << endl;
    for (list<Shift>::iterator i = shift_history.begin(); i != shift_history.end(); ++i)
        cout << *i;
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xbdf3(%rip), %rbx      # 0x22f78
leaq 0x32ce(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq 0x60(%r14), %r12
addq $0x60, %r14
cmpq %r14, %r12
je 0x171ea
movq 0xbda4(%rip), %r15      # 0x22f78
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x10953
movq (%r12), %r12
cmpq %r14, %r12
jne 0x171d4
leaq 0x45db(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::upgrade_agency_assets(int, int, int)
void TaxiAgency::upgrade_agency_assets(int garage_limit, int each_car_limit, int driver_vacancies){
    if(garage_limit < GarageLimit || each_car_limit < EachCarLimit || driver_vacancies < DriverLimit){
        return;
    }
    this->GarageLimit = garage_limit;
    this->EachCarLimit = each_car_limit;
    this->DriverLimit = driver_vacancies;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl %esi, 0x7c(%rdi)
jg 0x1724c
movq %rdi, %rbx
cmpl %edx, 0x80(%rdi)
jg 0x1724c
cmpl %ecx, 0x84(%rbx)
jle 0x17253
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %esi, 0x7c(%rbx)
movl %edx, 0x80(%rbx)
movl %ecx, 0x84(%rbx)
incl %esi
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x172e4
leaq 0x18(%rbx), %rdi
movslq 0x84(%rbx), %rsi
incq %rsi
callq 0x17386
movslq 0x84(%rbx), %rsi
addq $0x30, %rbx
incq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17432
// File: /workspace/github_cpp_makefile_star2_O3/Karunika[P]Taxi_Agency_OODB/./src/../include/./Taxi.hpp
// Function: operator<<(std::ostream&, Taxi const&)
ostream& operator<<(ostream& output, const Taxi& T){
        output << "\t{" <<
            "\n\t\thybrid : " << (T.hybrid ? "True" : "False") <<
            "\n\t\tid : " << T.id <<
            "\n\t\tmanufacturer : " << T.manufacturer <<
            "\n\t\tfare amount : " << T.fare_amount <<
            "\n\t\tcount : " << T.number <<
            "\n\t\tavailable count : " << T.available_number <<
            "\n\t\ton shift count : " << T.number - T.available_number <<
            "\n\t}" <<
            endl;
        return output;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x372b(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0x3e8e(%rip), %rsi      # 0x1bc40
movl $0xc, %edx
movq %rbx, %rdi
callq 0x4320
movzbl (%r14), %edx
leaq 0x3b48(%rip), %rax      # 0x1b912
leaq 0x3b46(%rip), %rsi      # 0x1b917
testq %rdx, %rdx
cmovneq %rax, %rsi
xorq $0x5, %rdx
movq %rbx, %rdi
callq 0x4320
leaq 0x3e62(%rip), %rsi      # 0x1bc4d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x4320
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0x3e44(%rip), %rsi      # 0x1bc56
movl $0x12, %edx
movq %rax, %rdi
callq 0x4320
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0x3e30(%rip), %rsi      # 0x1bc69
movl $0x11, %edx
movq %rax, %rdi
callq 0x4320
movl 0x48(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0x3e1f(%rip), %rsi      # 0x1bc7b
movl $0xb, %edx
movq %rax, %rdi
callq 0x4320
movl 0x4c(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0x3e08(%rip), %rsi      # 0x1bc87
movl $0x15, %edx
movq %rax, %rdi
callq 0x4320
movl 0x50(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0x3dfb(%rip), %rsi      # 0x1bc9d
movl $0x14, %edx
movq %rax, %rdi
callq 0x4320
movl 0x4c(%r14), %esi
subl 0x50(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r14
leaq 0x365a(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop