LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
je 0x28e6
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10b0
movl %eax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x28a1
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
movq 0x10(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2892
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x2888
movq 0x20(%rsp), %rdi
callq 0x10b0
cmpq $0x4, %rax
jne 0x2888
jmp 0x2894
movl $0x1, 0xc(%rsp)
jmp 0x28a1
jmp 0x2894
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x283f
cmpl $0x0, 0xc(%rsp)
je 0x28bb
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2813
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb (%rax), %cl
movq 0x18(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb %cl, (%rax)
jmp 0x2813
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x3, 0x10(%rsp)
jge 0x3354
leaq 0x22a0(%rip), %rdi      # 0x55e3
movb $0x0, %al
callq 0x10e0
movl $0x0, 0x14(%rsp)
jmp 0x339e
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f0
movw %ax, 0x6(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movzwl 0x6(%rsp), %edx
leaq 0x228b(%rip), %rdi      # 0x5607
movb $0x0, %al
callq 0x10e0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movzwl 0x6(%rsp), %esi
callq 0x2900
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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 $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movq %rdx, 0xe0(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x34e0
movq 0xf0(%rsp), %rsi
movl 0xec(%rsp), %edx
leaq 0x88(%rsp), %rdi
callq 0x3530
leaq 0x70(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x36b0
movq 0xe0(%rsp), %rdi
movzbl 0x70(%rsp), %edx
movzbl 0x71(%rsp), %ecx
movzbl 0x72(%rsp), %r8d
movzbl 0x73(%rsp), %r9d
movzbl 0x74(%rsp), %eax
movzbl 0x75(%rsp), %esi
movl %esi, 0x64(%rsp)
movzbl 0x76(%rsp), %esi
movl %esi, 0x68(%rsp)
movzbl 0x77(%rsp), %r13d
movzbl 0x78(%rsp), %r12d
movzbl 0x79(%rsp), %r15d
movzbl 0x7a(%rsp), %r14d
movzbl 0x7b(%rsp), %ebp
movzbl 0x7c(%rsp), %ebx
movzbl 0x7d(%rsp), %r11d
movzbl 0x7e(%rsp), %r10d
movzbl 0x7f(%rsp), %esi
movl %esi, 0x6c(%rsp)
leaq 0x21bb(%rip), %rsi      # 0x5641
movl %eax, (%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x6c(%rsp), %eax
movl %r13d, 0x18(%rsp)
movl %r12d, 0x20(%rsp)
movl %r15d, 0x28(%rsp)
movl %r14d, 0x30(%rsp)
movl %ebp, 0x38(%rsp)
movl %ebx, 0x40(%rsp)
movl %r11d, 0x48(%rsp)
movl %r10d, 0x50(%rsp)
movl %eax, 0x58(%rsp)
movb $0x0, %al
callq 0x1200
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %eax
shll $0x3, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x24(%rsp)
jg 0x357c
jmp 0x36a6
movl 0x24(%rsp), %ecx
sarl $0x1d, %ecx
movq 0x30(%rsp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jae 0x35b6
movq 0x30(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
cmpl $0x0, 0x10(%rsp)
je 0x3654
movl 0x10(%rsp), %eax
addl 0x24(%rsp), %eax
cmpl $0x40, %eax
jle 0x35dd
movl $0x40, %eax
subl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x35e5
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
movslq 0x10(%rsp), %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movslq 0x8(%rsp), %rdx
callq 0x1160
movl 0x10(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl $0x40, %eax
jge 0x361f
jmp 0x36a6
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rsp), %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x18, %rsi
callq 0x3790
jmp 0x3656
cmpl $0x40, 0x14(%rsp)
jl 0x3687
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3790
movq 0x18(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
subl $0x40, %eax
movl %eax, 0x14(%rsp)
jmp 0x3656
cmpl $0x0, 0x14(%rsp)
je 0x36a6
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x1160
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x3703
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl 0xc(%rsp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
shrl %cl, %eax
movb %al, %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x36c6
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
shrl $0x3, %eax
movl $0x37, %edx
subl %eax, %edx
andl $0x3f, %edx
addl $0x1, %edx
leaq 0x1f6a(%rip), %rsi      # 0x5690
callq 0x3530
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x3530
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0x3789
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %eax
movl 0xc(%rsp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
shrl %cl, %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3747
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
movq 0x2d8d(%rip), %rdi      # 0x3fe0
leaq 0x70(%rsp), %rsi
callq 0x1070
movq %rax, %rdi
leaq 0x6c(%rsp), %rsi
callq 0x1070
movslq 0x6c(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1410
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x1420
jmp 0x1299
leaq 0x4f(%rsp), %rdi
callq 0x14a0
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0x131e
movslq 0x38(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x14b0
movq %rax, %rsi
movq 0x2d12(%rip), %rdi      # 0x3fe0
callq 0x1070
jmp 0x12d5
jmp 0x12d7
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x12ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x14a0
jmp 0x1400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x14d0
jmp 0x1400
cmpl $0x1, 0x6c(%rsp)
jge 0x1352
movq 0x2ca4(%rip), %rdi      # 0x3fd0
xorl %esi, %esi
callq 0x10e0
movq %rax, 0x18(%rsp)
jmp 0x133a
movq 0x18(%rsp), %rdi
movq 0x2c7a(%rip), %rsi      # 0x3fc0
callq 0x10c0
jmp 0x134d
jmp 0x13e5
movl 0x6c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x14b0
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x30(%rsp)
cmpl $0x1, 0x30(%rsp)
jl 0x13b9
movl 0x34(%rsp), %eax
imull 0x70(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x30(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x14b0
movq %rax, %rcx
movl 0x14(%rsp), %eax
addl (%rcx), %eax
movl %eax, 0x34(%rsp)
movl 0x30(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1377
movl 0x34(%rsp), %esi
movq 0x2c0c(%rip), %rdi      # 0x3fd0
callq 0x10e0
movq %rax, 0x8(%rsp)
jmp 0x13d0
movq 0x8(%rsp), %rdi
movq 0x2be4(%rip), %rsi      # 0x3fc0
callq 0x10c0
jmp 0x13e3
jmp 0x13e5
movl $0x0, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x14d0
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x10f0
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movb $0x4e, -0x11(%rbp)
movq 0x4170f(%rip), %rdi     # 0x45f80
callq 0x4290
movq %rax, %rdi
leaq 0x2bfa4(%rip), %rsi     # 0x30824
callq 0x42d0
movq 0x41744(%rip), %rdi     # 0x45fd0
leaq -0x11(%rbp), %rsi
callq 0x43b0
movsbl -0x11(%rbp), %eax
cmpl $0x59, %eax
je 0x48a7
movsbl -0x11(%rbp), %eax
cmpl $0x79, %eax
jne 0x48b0
movq -0x10(%rbp), %rdi
callq 0x1d240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x1d880
movq %rax, %rdi
callq 0x1d890
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x1d2d6
jmp 0x1d2cc
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x1d323
jmp 0x1d335
callq 0x1d8b0
testb $0x1, %al
jne 0x1d2e1
jmp 0x1d311
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4180
movq %rax, %rdi
callq 0x1d910
testb $0x1, %al
jne 0x1d2ff
jmp 0x1d311
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1e1c0
movq %rax, -0x28(%rbp)
jmp 0x1d319
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d33d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1e1c0
movq %rax, -0x8(%rbp)
jmp 0x1d33d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Karunika[P]Taxi_Agency_OODB/././dep/rang.hpp
// Function: rang::rang_implementation::supportsColor()
inline bool supportsColor() noexcept
    {
#if defined(OS_LINUX) || defined(OS_MAC)

        static const bool result = [] {
            const char *Terms[]
              = { "ansi",    "color",  "console", "cygwin", "gnome",
                  "konsole", "kterm",  "linux",   "msys",   "putty",
                  "rxvt",    "screen", "vt100",   "xterm" };

            const char *env_p = std::getenv("TERM");
            if (env_p == nullptr) {
                return false;
            }
            return std::any_of(std::begin(Terms), std::end(Terms),
                               [&](const char *term) {
                                   return std::strstr(env_p, term) != nullptr;
                               });
        }();

#elif defined(OS_WIN)
        // All windows versions support colors through native console methods
        static constexpr bool result = true;
#endif
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x28a69(%rip)     # 0x46328
jne 0x1d8f7
leaq 0x28a60(%rip), %rdi     # 0x46328
callq 0x4510
cmpl $0x0, %eax
je 0x1d8f7
leaq -0x1(%rbp), %rdi
callq 0x1db30
movb %al, -0x2(%rbp)
jmp 0x1d8e0
movb -0x2(%rbp), %al
andb $0x1, %al
movb %al, 0x28a37(%rip)      # 0x46322
leaq 0x28a36(%rip), %rdi     # 0x46328
callq 0x4210
movb 0x28a25(%rip), %al      # 0x46322
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1d350
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28655(%rip), %rdi     # 0x45f80
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4180
movq %rax, -0x18(%rbp)
jmp 0x1d940
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1d9a7
cmpb $0x0, 0x289e4(%rip)     # 0x46338
jne 0x1d997
leaq 0x289db(%rip), %rdi     # 0x46338
callq 0x4510
cmpl $0x0, %eax
je 0x1d997
movq 0x285c2(%rip), %rax     # 0x45f30
movq (%rax), %rdi
callq 0x4320
movl %eax, %edi
callq 0x44e0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x289a5(%rip)      # 0x46330
leaq 0x289a6(%rip), %rdi     # 0x46338
callq 0x4210
movb 0x28993(%rip), %al      # 0x46330
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1da66
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x28632(%rip), %rdi     # 0x45fe8
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4180
movq %rax, -0x28(%rbp)
jmp 0x1d9cb
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
je 0x1da09
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x28551(%rip), %rdi     # 0x45f38
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4180
movq %rax, -0x38(%rbp)
jmp 0x1d9fc
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1da60
cmpb $0x0, 0x28938(%rip)     # 0x46348
jne 0x1da53
leaq 0x2892f(%rip), %rdi     # 0x46348
callq 0x4510
cmpl $0x0, %eax
je 0x1da53
movq 0x2855e(%rip), %rax     # 0x45f88
movq (%rax), %rdi
callq 0x4320
movl %eax, %edi
callq 0x44e0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x288f9(%rip)      # 0x46340
leaq 0x288fa(%rip), %rdi     # 0x46348
callq 0x4210
movb 0x288e7(%rip), %al      # 0x46340
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1da66
jmp 0x1da62
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1d350
nopl (%rax)
// File: Karunika[P]Taxi_Agency_OODB/./src/User.cpp
// Function: validate_uuid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static void validate_uuid(string uuid){
    if(uuid.length() < 3){
        throw out_of_range("UUID should have a minimum of 3 characters");
    }
    if(uuid.length() > User::MaxUUIDLength){
        throw out_of_range("UUID max character limit exceeded");
    }
    int i = 0;
    while(i < uuid.length()){
        if(isalnum(uuid[i]) || uuid[i] == '_'){
            i++;
        }else{
            throw invalid_uuid("Invalid UUID: only alphanumeric [a-zA-Z0-9_] characters are allowed");
        };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4430
cmpq $0x3, %rax
jae 0x1e45e
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x13356(%rip), %rsi     # 0x3177c
callq 0x4080
jmp 0x1e42d
movq -0x28(%rbp), %rdi
movq 0x27b80(%rip), %rsi     # 0x45fb8
movq 0x27b59(%rip), %rdx     # 0x45f98
callq 0x44b0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4240
jmp 0x1e586
movq -0x20(%rbp), %rdi
callq 0x4430
leaq 0x27e9e(%rip), %rcx     # 0x4630c
movslq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x1e4c9
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x13316(%rip), %rsi     # 0x317a7
callq 0x4080
jmp 0x1e498
movq -0x30(%rbp), %rdi
movq 0x27b15(%rip), %rsi     # 0x45fb8
movq 0x27aee(%rip), %rdx     # 0x45f98
callq 0x44b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4240
jmp 0x1e586
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4430
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e580
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x4550
movsbl (%rax), %edi
callq 0x42f0
cmpl $0x0, %eax
jne 0x1e520
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x4550
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x1e52b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e57b
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x13283(%rip), %rsi     # 0x317c9
callq 0x1e960
jmp 0x1e54d
movq -0x40(%rbp), %rdi
leaq 0x276d0(%rip), %rsi     # 0x45c28
leaq 0x441(%rip), %rdx       # 0x1e9a0
callq 0x44b0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4240
jmp 0x1e586
jmp 0x1e4d0
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x44f0
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4430
leaq 0x27d64(%rip), %rcx     # 0x46310
movslq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x1e607
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x1323e(%rip), %rsi     # 0x3180d
callq 0x4080
jmp 0x1e5d6
movq -0x28(%rbp), %rdi
movq 0x279d7(%rip), %rsi     # 0x45fb8
movq 0x279b0(%rip), %rdx     # 0x45f98
callq 0x44b0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4240
jmp 0x1e6ab
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4430
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e6a5
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x4550
movsbl (%rax), %edi
callq 0x4460
cmpl $0x0, %eax
je 0x1e650
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e6a0
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x131c4(%rip), %rsi     # 0x3182f
callq 0x1ea10
jmp 0x1e672
movq -0x38(%rbp), %rdi
leaq 0x275eb(%rip), %rsi     # 0x45c68
leaq 0x3cc(%rip), %rdx       # 0x1ea50
callq 0x44b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4240
jmp 0x1e6ab
jmp 0x1e60e
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12c5c(%rip), %rsi     # 0x31887
callq 0x42d0
movq %rax, %rdi
leaq 0x12c50(%rip), %rsi     # 0x3188a
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x12c3c(%rip), %rsi     # 0x31895
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x12c31(%rip), %rsi     # 0x318a5
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x12c21(%rip), %rsi     # 0x318b4
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x12c1f(%rip), %rsi     # 0x318d1
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x80(%rax), %ecx
leaq 0x1309b(%rip), %rsi     # 0x31d66
leaq 0x132dc(%rip), %rax     # 0x31fae
cmpl $0x1, %ecx
cmoveq %rax, %rsi
callq 0x42d0
movq %rax, %rdi
leaq 0x12bf6(%rip), %rsi     # 0x318de
callq 0x42d0
movq %rax, %rdi
movq 0x27251(%rip), %rsi     # 0x45f48
callq 0x4310
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Karunika[P]Taxi_Agency_OODB/./src/Driver.cpp
// Function: Driver::toggle_driver_status()
void Driver::toggle_driver_status(){
    switch (status){
    case IDLE:
        status = ONSHIFT;
        break;
    case ONSHIFT:
        status = IDLE;
        break;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x80(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x1ed79
jmp 0x1ed5f
movl -0xc(%rbp), %eax
subl $0x1, %eax
jne 0x1ed87
jmp 0x1ed69
movq -0x18(%rbp), %rax
movl $0x0, 0x80(%rax)
jmp 0x1ed87
movq -0x18(%rbp), %rax
movl $0x1, 0x80(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1292c(%rip), %rsi     # 0x31887
callq 0x42d0
movq %rax, %rdi
leaq 0x12920(%rip), %rsi     # 0x3188a
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x1290c(%rip), %rsi     # 0x31895
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x12901(%rip), %rsi     # 0x318a5
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x1291f(%rip), %rsi     # 0x318e2
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x44d0
movq %rax, %rdi
leaq 0x1290f(%rip), %rsi     # 0x318f0
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x64(%rax), %ecx
leaq 0x12d6f(%rip), %rsi     # 0x31d66
leaq 0x12fb0(%rip), %rax     # 0x31fae
cmpl $0x1, %ecx
cmoveq %rax, %rsi
callq 0x42d0
movq %rax, %rdi
leaq 0x128ca(%rip), %rsi     # 0x318de
callq 0x42d0
movq %rax, %rdi
movq 0x26f25(%rip), %rsi     # 0x45f48
callq 0x4310
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Karunika[P]Taxi_Agency_OODB/./src/Customer.cpp
// Function: Customer::toggle_customer_status()
void Customer::toggle_customer_status(){
    switch (status){
    case IDLE:
        status = ONSHIFT;
        break;
    case ONSHIFT:
        status = IDLE;
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x64(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x1f0a3
jmp 0x1f08c
movl -0xc(%rbp), %eax
subl $0x1, %eax
jne 0x1f0ae
jmp 0x1f096
movq -0x18(%rbp), %rax
movl $0x0, 0x64(%rax)
jmp 0x1f0ae
movq -0x18(%rbp), %rax
movl $0x1, 0x64(%rax)
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11eec(%rip), %rsi     # 0x31887
callq 0x42d0
movq %rax, %rdi
leaq 0x11f7f(%rip), %rsi     # 0x31929
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x11f78(%rip), %rsi     # 0x3193d
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x11f75(%rip), %rsi     # 0x31959
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x4290
movq %rax, %rdi
leaq 0x11f64(%rip), %rsi     # 0x31967
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x44d0
movq %rax, %rdi
leaq 0x11f6d(%rip), %rsi     # 0x3198e
callq 0x42d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x64(%rax), %esi
callq 0x44d0
movq %rax, %rdi
leaq 0x11e9f(%rip), %rsi     # 0x318de
callq 0x42d0
movq %rax, %rdi
movq 0x264fa(%rip), %rsi     # 0x45f48
callq 0x4310
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x2283f(%rip), %rdi     # 0x45f80
movl $0x22, %esi
callq 0x1d2a0
movq %rax, %rdi
leaq 0xe413(%rip), %rsi      # 0x31b68
callq 0x42d0
movq %rax, %rdi
movl $0x27, %esi
callq 0x1d2a0
movq %rax, %rdi
movq 0x227d7(%rip), %rsi     # 0x45f48
callq 0x4310
movq 0x22803(%rip), %rdi     # 0x45f80
leaq 0xd4cd(%rip), %rsi      # 0x30c51
callq 0x42d0
movq %rax, %rdi
movq 0x227b5(%rip), %rsi     # 0x45f48
callq 0x4310
movq -0x90(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29870
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x298a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x298d0
testb $0x1, %al
jne 0x237d0
jmp 0x23828
leaq -0x18(%rbp), %rdi
callq 0x29910
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x29930
movq -0x98(%rbp), %rdi
callq 0x299c0
jmp 0x237fa
leaq -0x78(%rbp), %rdi
callq 0x297d0
leaq -0x18(%rbp), %rdi
callq 0x299f0
jmp 0x237bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x297d0
jmp 0x23853
movq 0x22751(%rip), %rdi     # 0x45f80
leaq 0xe33f(%rip), %rsi      # 0x31b75
callq 0x42d0
movq %rax, %rdi
movq 0x22703(%rip), %rsi     # 0x45f48
callq 0x4310
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x29a10
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x238f4
movq -0x40(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x29a40
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d6b0
testb $0x1, %al
jne 0x238c3
jmp 0x238e7
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x29a40
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
jmp 0x238e9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x23883
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0xe268(%rip), %rsi      # 0x31b77
callq 0x4530
jmp 0x23916
movq -0x58(%rbp), %rdi
movq 0x226a7(%rip), %rsi     # 0x45fc8
movq 0x22680(%rip), %rdx     # 0x45fa8
callq 0x44b0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4240
movq -0x30(%rbp), %rdi
callq 0x44f0
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4170
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x23860
movq %rdx, -0x60(%rbp)
movl %eax, -0x58(%rbp)
jmp 0x23c61
movq -0x60(%rbp), %rax
movl -0x58(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41f0
cmpl $0x0, -0x24(%rbp)
jge 0x23ceb
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0xdf77(%rip), %rsi      # 0x31c10
callq 0x4530
jmp 0x23ca0
movq -0x78(%rbp), %rdi
movq 0x2231d(%rip), %rsi     # 0x45fc8
movq 0x222f6(%rip), %rdx     # 0x45fa8
callq 0x44b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41f0
jmp 0x23d7f
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x4240
jmp 0x23d7f
movq -0x70(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %eax
addl -0x24(%rbp), %eax
cmpl 0x80(%rcx), %eax
jl 0x23d51
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0xdf0c(%rip), %rsi      # 0x31c28
callq 0x44c0
jmp 0x23d23
movq -0x80(%rbp), %rdi
movq 0x22282(%rip), %rsi     # 0x45fb0
movq 0x22233(%rip), %rdx     # 0x45f68
callq 0x44b0
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x4240
jmp 0x23d7f
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
addl %edx, %ecx
movl %ecx, 0x4c(%rax)
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x50(%rax), %ecx
addl %edx, %ecx
movl %ecx, 0x50(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x44f0
nopl (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4170
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x23860
movq %rdx, -0x88(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x23de0
movq -0x88(%rbp), %rax
movl -0x7c(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41f0
cmpl $0x0, -0x24(%rbp)
jge 0x23e76
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
leaq 0xddf2(%rip), %rsi      # 0x31c10
callq 0x4530
jmp 0x23e25
movq -0xa0(%rbp), %rdi
movq 0x22195(%rip), %rsi     # 0x45fc8
movq 0x2216e(%rip), %rdx     # 0x45fa8
callq 0x44b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41f0
jmp 0x23f65
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x4240
jmp 0x23f65
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %eax
subl -0x24(%rbp), %eax
cmpl $0x0, %eax
jge 0x23ee1
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
leaq 0xddc6(%rip), %rsi      # 0x31c69
callq 0x44c0
jmp 0x23eaa
movq -0xa8(%rbp), %rdi
movq 0x220f8(%rip), %rsi     # 0x45fb0
movq 0x220a9(%rip), %rdx     # 0x45f68
callq 0x44b0
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x4240
jmp 0x23f65
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x23f09
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x50(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
jne 0x23f55
movq -0x98(%rbp), %rdi
callq 0x29870
movq %rax, -0x70(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x29b00
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x29b40
movq -0x98(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x29a90
movq %rax, -0x78(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x44f0
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x2168f(%rip), %rdi     # 0x45f80
movl $0x22, %esi
callq 0x1d2a0
movq %rax, %rdi
leaq 0xd3c4(%rip), %rsi      # 0x31cc9
callq 0x42d0
movq %rax, %rdi
movl $0x27, %esi
callq 0x1d2a0
movq %rax, %rdi
movq 0x21627(%rip), %rsi     # 0x45f48
callq 0x4310
movq 0x21653(%rip), %rdi     # 0x45f80
leaq 0xc31d(%rip), %rsi      # 0x30c51
callq 0x42d0
movq %rax, %rdi
movq 0x21605(%rip), %rsi     # 0x45f48
callq 0x4310
movq -0xa0(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29c70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29ca0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x29cd0
testb $0x1, %al
jne 0x24984
jmp 0x249e8
leaq -0x18(%rbp), %rdi
callq 0x29d10
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x29d30
movq -0xa8(%rbp), %rdi
callq 0x1f040
jmp 0x249b1
leaq -0x88(%rbp), %rdi
callq 0x29be0
leaq -0x18(%rbp), %rdi
callq 0x29d70
jmp 0x24971
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x29be0
jmp 0x24a13
movq 0x21591(%rip), %rdi     # 0x45f80
leaq 0xd17f(%rip), %rsi      # 0x31b75
callq 0x42d0
movq %rax, %rdi
movq 0x21543(%rip), %rsi     # 0x45f48
callq 0x4310
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x44f0
nop
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4170
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x24a20
movq %rdx, -0x80(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2513a
movq -0x80(%rbp), %rax
movl -0x74(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41f0
movq -0x18(%rbp), %rdi
callq 0x1f0b0
cmpl $0x0, %eax
jne 0x251cf
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
leaq 0xcbc7(%rip), %rsi      # 0x31d44
callq 0x4530
jmp 0x25184
movq -0x98(%rbp), %rdi
movq 0x20e36(%rip), %rsi     # 0x45fc8
movq 0x20e0f(%rip), %rdx     # 0x45fa8
callq 0x44b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41f0
jmp 0x2522c
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x4240
jmp 0x2522c
movq -0x90(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0xa0(%rbp)
addq $0x30, %rdi
callq 0x29c70
movq %rax, -0x68(%rbp)
movslq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x29ff0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2a030
movq -0xa0(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2a070
movq %rax, -0x70(%rbp)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq 0x201cf(%rip), %rdi     # 0x45f80
movl $0x22, %esi
callq 0x1d2a0
movq %rax, %rdi
leaq 0xbfe3(%rip), %rsi      # 0x31da8
callq 0x42d0
movq %rax, %rdi
movl $0x27, %esi
callq 0x1d2a0
movq %rax, %rdi
movq 0x20167(%rip), %rsi     # 0x45f48
callq 0x4310
movq 0x20193(%rip), %rdi     # 0x45f80
leaq 0xae5d(%rip), %rsi      # 0x30c51
callq 0x42d0
movq %rax, %rdi
movq 0x20145(%rip), %rsi     # 0x45f48
callq 0x4310
movq -0xc0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a230
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a260
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2a290
testb $0x1, %al
jne 0x25e44
jmp 0x25ea8
leaq -0x18(%rbp), %rdi
callq 0x2a2d0
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2a2f0
movq -0xc8(%rbp), %rdi
callq 0x1ed10
jmp 0x25e71
leaq -0xa8(%rbp), %rdi
callq 0x2a190
leaq -0x18(%rbp), %rdi
callq 0x2a360
jmp 0x25e31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2a190
jmp 0x25ed3
movq 0x200d1(%rip), %rdi     # 0x45f80
leaq 0xbcbf(%rip), %rsi      # 0x31b75
callq 0x42d0
movq %rax, %rdi
movq 0x20083(%rip), %rsi     # 0x45f48
callq 0x4310
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x44f0
nop
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4170
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x25ee0
movq %rdx, -0x80(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2667a
movq -0x80(%rbp), %rax
movl -0x74(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41f0
movq -0x18(%rbp), %rdi
callq 0x1edc0
cmpl $0x0, %eax
jne 0x2670f
movl $0x10, %edi
callq 0x41a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
leaq 0xb73f(%rip), %rsi      # 0x31dfc
callq 0x4530
jmp 0x266c4
movq -0x98(%rbp), %rdi
movq 0x1f8f6(%rip), %rsi     # 0x45fc8
movq 0x1f8cf(%rip), %rdx     # 0x45fa8
callq 0x44b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41f0
jmp 0x2676c
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x4240
jmp 0x2676c
movq -0x90(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0xa0(%rbp)
addq $0x18, %rdi
callq 0x2a230
movq %rax, -0x68(%rbp)
movslq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2a5c0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2a600
movq -0xa0(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2a640
movq %rax, -0x70(%rbp)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x48, %rdi
callq 0x2aa60
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
callq 0x2aac0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2aa90
testb $0x1, %al
jne 0x2890c
jmp 0x2895b
leaq -0x20(%rbp), %rdi
callq 0x2aaf0
movq %rax, %rdi
callq 0x1fab0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x1d6b0
testb $0x1, %al
jne 0x2892f
jmp 0x2894e
leaq -0x20(%rbp), %rdi
callq 0x2ab70
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2ab90
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
jmp 0x28950
leaq -0x20(%rbp), %rdi
callq 0x2ab10
jmp 0x288e8
movl $0x8, %edi
callq 0x41a0
movq %rax, %rdi
leaq 0x961c(%rip), %rax      # 0x31f8b
movq %rax, (%rdi)
movq 0x1d5d7(%rip), %rsi     # 0x45f50
xorl %eax, %eax
movl %eax, %edx
callq 0x44b0
nopw %cs:(%rax,%rax)