LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ctSkennerton[P]fxtract/util/tap.c
// Function: exit_status
int
exit_status(void)
{
    int r;

    if (tap_flags & TAP_FLAG_DEBUG) {
        diag("tap_debug: exit_status(): entering");
    }

    LOCK;

    /* If there's no plan, just return the number of failures */
    if(no_plan || !have_plan) {
        UNLOCK;
        return failures;
    }

    /* Ran too many tests?  Return the number of tests that were run
       that shouldn't have been */
    if(e_tests < test_count) {
        r = test_count - e_tests;
        UNLOCK;
        return r;
    }

    /* Return the number of tests that failed + the number of tests
       that weren't run */
    r = failures + e_tests - test_count;
    UNLOCK;

    if (tap_flags & TAP_FLAG_DEBUG) {
        diag("tap_debug: exit_status(): returning %u", r);
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x4dda(%rip), %eax      # 0x107e8
andl $0x2, %eax
cmpl $0x0, %eax
je 0xba24
leaq 0x1224(%rip), %rdi      # 0xcc41
movb $0x0, %al
callq 0xb6d0
cmpl $0x0, 0x4fe5(%rip)      # 0x10a10
jne 0xba36
cmpl $0x0, 0x4fd4(%rip)      # 0x10a08
jne 0xba41
movl 0x4d90(%rip), %eax      # 0x107cc
movl %eax, -0x4(%rbp)
jmp 0xbaa0
movl 0x4fd1(%rip), %eax      # 0x10a18
cmpl 0x4d7b(%rip), %eax      # 0x107c8
jae 0xba66
movl 0x4d73(%rip), %eax      # 0x107c8
subl 0x4fbd(%rip), %eax      # 0x10a18
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbaa0
movl 0x4d60(%rip), %eax      # 0x107cc
addl 0x4fa6(%rip), %eax      # 0x10a18
subl 0x4d50(%rip), %eax      # 0x107c8
movl %eax, -0x8(%rbp)
movl 0x4d67(%rip), %eax      # 0x107e8
andl $0x2, %eax
cmpl $0x0, %eax
je 0xba9a
movl -0x8(%rbp), %esi
leaq 0x11d1(%rip), %rdi      # 0xcc64
movb $0x0, %al
callq 0xb6d0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: deprekate[P]RepeatFinder/src/repeatfinder.cpp
// Function: find_maxlen(char*, repeat&, std::vector<repeat, std::allocator<repeat>>&, int, int)
void find_maxlen(char *dna, repeat &R, vector<repeat> &rep,  int fst, int sec)
{
	int dna_len;
	int i,j,k;
	//  check whether to compute //
	
	dna_len = (int)strlen(dna);
	if(sec-fst < REPEAT_LEN)
		return;
	if (fst > 0)
		if(dna[fst-1] == dna[sec-1])
			return;
	k=0;
	for(i = REPEAT_LEN+fst, j = REPEAT_LEN+sec ; i<sec && j<dna_len; i++, j++)
		if (dna[i] == dna[j])
			k++;
		else 
			break;
	R.fst=fst+1;
	R.sec=sec+1;
	R.len=REPEAT_LEN + k;
	R.seclen = R.len;
	R.visited = 0;
	R.exact = 0;
	rep.push_back(R);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4060
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
subl 0x1c(%rsp), %eax
cmpl $0xb, %eax
jge 0x434c
jmp 0x4477
cmpl $0x0, 0x1c(%rsp)
jle 0x4384
movq 0x30(%rsp), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movl 0x18(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4382
jmp 0x4477
jmp 0x4384
movl $0x0, 0x8(%rsp)
movl 0x1c(%rsp), %eax
addl $0xb, %eax
movl %eax, 0x10(%rsp)
movl 0x18(%rsp), %eax
addl $0xb, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %ecx
xorl %eax, %eax
cmpl 0x18(%rsp), %ecx
movb %al, 0x7(%rsp)
jge 0x43c1
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x43cb
jmp 0x4414
movq 0x30(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x43f8
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x43fa
jmp 0x4414
jmp 0x43fc
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x43a2
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x8(%rsp), %ecx
addl $0xb, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x5a30
addq $0x38, %rsp
retq
nopl (%rax)
// File: deprekate[P]RepeatFinder/src/repeatfinder.cpp
// Function: find_maxlen_rev(char*, repeat&, std::vector<repeat, std::allocator<repeat>>&, int, int)
void find_maxlen_rev(char *dna, repeat &R, vector<repeat> &rep, int fst, int sec)
{
	int dna_len;
	int i,j,k;

	dna_len = (int)strlen(dna);
	sec = sec *(-1);
	//  check whether to compute //
	if(sec-fst +1< 2 * REPEAT_LEN)
		return;
	
	if (fst >0 && sec < dna_len-1 )
		if(dna[fst-1] == complement[(unsigned char)dna[sec+1]])
			return;

	k=0;
	for(i = REPEAT_LEN+fst, j = sec - REPEAT_LEN ; i<dna_len && j>-1 && i<j; i++, j--)
		if (dna[i] == complement[(unsigned char)dna[j]])
			k++;
		else 
			break;
	R.fst = fst + 1;
	R.sec = sec * (-1) - 1;
	R.len = REPEAT_LEN + k;
	R.seclen = R.len;
	R.visited = 0;
	R.exact = 0;
	rep.push_back(R);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4060
movl %eax, 0x14(%rsp)
imull $-0x1, 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
subl 0x1c(%rsp), %eax
addl $0x1, %eax
cmpl $0x16, %eax
jge 0x44c8
jmp 0x4627
cmpl $0x0, 0x1c(%rsp)
jle 0x4519
movl 0x18(%rsp), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4519
movq 0x30(%rsp), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movl 0x18(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movl %ecx, %edx
movq 0x6acb(%rip), %rcx      # 0xafd8
cmpl (%rcx,%rdx,4), %eax
jne 0x4517
jmp 0x4627
jmp 0x4519
movl $0x0, 0x8(%rsp)
movl 0x1c(%rsp), %eax
addl $0xb, %eax
movl %eax, 0x10(%rsp)
movl 0x18(%rsp), %eax
subl $0xb, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %ecx
xorl %eax, %eax
cmpl 0x14(%rsp), %ecx
movb %al, 0x7(%rsp)
jge 0x4563
xorl %eax, %eax
cmpl $-0x1, 0xc(%rsp)
movb %al, 0x7(%rsp)
jle 0x4563
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x456d
jmp 0x45c3
movq 0x30(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movl %ecx, %edx
movq 0x6a46(%rip), %rcx      # 0xafd8
cmpl (%rcx,%rdx,4), %eax
jne 0x45a4
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x45a6
jmp 0x45c3
jmp 0x45a8
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4537
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
imull $-0x1, 0x18(%rsp), %ecx
subl $0x1, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x8(%rsp), %ecx
addl $0xb, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x28(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x5a30
addq $0x38, %rsp
retq
nopl (%rax)
// File: deprekate[P]RepeatFinder/src/repeatfinder.cpp
// Function: extend_gapped_repeat(std::vector<repeat, std::allocator<repeat>>&, int)
void extend_gapped_repeat(vector<repeat> &rep, int gap)
{
	int i,j,k;
        int len = (int)rep.size();
	
	for(i =0;i<len;i++){
		if(rep[i].visited==0){
			for(j=1;j<=gap;j++){
				k = check_extend(rep, i, j, gap);
				if(k==-1)
					continue;
				//extend repeat
				rep[i].len += j+ rep[k].len-1;
				rep[i].seclen += rep[k].sec -(rep[i].sec+rep[i].seclen -1) + rep[k].seclen-1;
				rep[i].exact = 1;
				rep[k].visited = 1;
				i--;
				break;
			}
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
callq 0x5aa0
movl %eax, 0x1c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x4aef
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x5ac0
cmpl $0x0, 0x10(%rax)
jne 0x4add
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0x4adb
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
movl 0x2c(%rsp), %ecx
callq 0x4630
movl %eax, 0x20(%rsp)
cmpl $-0x1, 0x20(%rsp)
jne 0x49c6
jmp 0x4acb
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x5ac0
movq %rax, %rcx
movl 0x4(%rsp), %eax
addl 0x8(%rcx), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x5ac0
movl 0x8(%rsp), %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x5ac0
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x5ac0
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x5ac0
movl 0xc(%rsp), %ecx
movq %rax, %rdx
movl 0x10(%rsp), %eax
addl 0xc(%rdx), %ecx
subl $0x1, %ecx
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x5ac0
movq %rax, %rcx
movl 0x14(%rsp), %eax
addl 0xc(%rcx), %eax
subl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x5ac0
movl 0x18(%rsp), %ecx
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x5ac0
movl $0x1, 0x14(%rax)
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x5ac0
movl $0x1, 0x10(%rax)
movl 0x28(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x4adb
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4992
jmp 0x4add
jmp 0x4adf
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x4963
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: deprekate[P]RepeatFinder/src/repeatfinder.cpp
// Function: main
int
main(int argc, char *argv[])
{
	wchar_t *program = Py_DecodeLocale(argv[0], NULL);
	if (program == NULL) {
		fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
		exit(1);
	}

	/* Add a built-in module, before Py_Initialize */
	PyImport_AppendInittab("repeatfinder", PyInit_repeatfinder);

	/* Pass argv[0] to the Python interpreter */
	Py_SetProgramName(program);

	/* Initialize the Python interpreter.  Required. */
	Py_Initialize();

	/* Optionally import the module; alternatively,
           import can be deferred until the embedded script
           imports it. */
	PyImport_ImportModule("repeatfinder");

	PyMem_RawFree(program);
	return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4160
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x51c3
movq 0x5e38(%rip), %rax      # 0xafe0
movq (%rax), %rdi
leaq 0x2e4e(%rip), %rsi      # 0x8000
movb $0x0, %al
callq 0x4170
movl $0x1, %edi
callq 0x4150
leaq 0x2e5a(%rip), %rdi      # 0x8024
leaq -0x81(%rip), %rsi       # 0x5150
callq 0x41e0
movq (%rsp), %rdi
callq 0x4140
callq 0x41d0
leaq 0x2e39(%rip), %rdi      # 0x8024
callq 0x4100
movq (%rsp), %rdi
callq 0x40e0
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: mahdibohloul[P]SnapTrip/main.cpp
// Function: main
int main(int argc, char const *argv[])
{
    srand(time(0));
    Content file_name = argv[ConstNames::Hotel_File_Addr_Position];
    Content rating_file = argv[ConstNames::Rating_File_Addr_Position];
    UserInterface* user_interface = UserInterface::get_instance();
    user_interface->database_setup(file_name);
    user_interface->rating_db_setup(rating_file);
    user_interface->process();
    UserInterface::release();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x63f0
movl %eax, %edi
callq 0x6420
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x6760
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x65c0
jmp 0x5368a
leaq -0x31(%rbp), %rdi
callq 0x64b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x6760
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x65c0
jmp 0x536cb
leaq -0x69(%rbp), %rdi
callq 0x64b0
callq 0x76650
movq %rax, -0xe0(%rbp)
jmp 0x536e2
movq -0xe0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x61d0
jmp 0x5370a
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x76760
jmp 0x5371f
leaq -0x98(%rbp), %rdi
callq 0x6828
movq -0x78(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x61d0
jmp 0x53748
movq -0xf0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x769e0
jmp 0x5375d
leaq -0xb8(%rbp), %rdi
callq 0x6828
movq -0x78(%rbp), %rdi
callq 0x76c00
jmp 0x53774
callq 0x766c0
jmp 0x5377b
leaq -0x68(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
xorl %eax, %eax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x64b0
jmp 0x53818
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x64b0
jmp 0x5380f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x53806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x6828
jmp 0x53806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x6828
leaq -0x68(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
movq -0x40(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::clean_users_up()
void Database::clean_users_up()
{
    for(auto user_itr = users.begin(); user_itr != users.end(); user_itr++)
    {
        delete *user_itr;
        *user_itr = nullptr;
    }
    users.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x54d40
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x54da0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x54d70
testb $0x1, %al
jne 0x53c4d
jmp 0x53c96
leaq -0x10(%rbp), %rdi
callq 0x54dd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x53c75
movq -0x30(%rbp), %rdi
callq 0x66ae0
movq -0x30(%rbp), %rdi
callq 0x6400
leaq -0x10(%rbp), %rdi
callq 0x54dd0
movq $0x0, (%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x54ea0
movq %rax, -0x20(%rbp)
jmp 0x53c2d
movq -0x28(%rbp), %rdi
callq 0x55630
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::clean_hotels_up()
void Database::clean_hotels_up()
{
    for(auto hotel_itr = hotels.begin(); hotel_itr != hotels.end(); hotel_itr++)
    {
        delete *hotel_itr;
        *hotel_itr = nullptr;
    }
    hotels.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
callq 0x54ff0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x55050
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x55020
testb $0x1, %al
jne 0x53cf5
jmp 0x53d3e
leaq -0x10(%rbp), %rdi
callq 0x55110
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x53d1d
movq -0x30(%rbp), %rdi
callq 0x58790
movq -0x30(%rbp), %rdi
callq 0x6400
leaq -0x10(%rbp), %rdi
callq 0x55110
movq $0x0, (%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x55130
movq %rax, -0x20(%rbp)
jmp 0x53cd1
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x55660
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::clean_comments_up()
void Database::clean_comments_up()
{
    for(auto comment_itr = comments.begin(); comment_itr != comments.end(); comment_itr++)
    {
        delete *comment_itr;
        *comment_itr = nullptr;
    }
    comments.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0x55510
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x55570
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x55540
testb $0x1, %al
jne 0x53da5
jmp 0x53dee
leaq -0x10(%rbp), %rdi
callq 0x555a0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x53dcd
movq -0x30(%rbp), %rdi
callq 0x725c0
movq -0x30(%rbp), %rdi
callq 0x6400
leaq -0x10(%rbp), %rdi
callq 0x555a0
movq $0x0, (%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x55600
movq %rax, -0x20(%rbp)
jmp 0x53d81
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x55690
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::query_in_users(Database::UserInfo)
Database::User* Database::query_in_users(UserInfo user_info)
{
    if(!users.empty())
    {
        for(auto user_itr = users.begin(); user_itr != users.end(); user_itr++)
        {
            if(check_info(*user_itr, user_info) == ConstNames::Equal)
                return *user_itr;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x54d20
testb $0x1, %al
jne 0x5402c
movq -0xc0(%rbp), %rdi
callq 0x54d40
movq %rax, -0x20(%rbp)
movq -0xc0(%rbp), %rdi
callq 0x54da0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x54d70
testb $0x1, %al
jne 0x53f68
jmp 0x5402a
leaq -0x20(%rbp), %rdi
callq 0x54dd0
movq -0xc8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x54df0
movq -0xc0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
callq 0x54050
movb %al, -0xc9(%rbp)
jmp 0x53fb7
movb -0xc9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xe4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x54e70
movl -0xe4(%rbp), %eax
cmpl $0x1, %eax
jne 0x54011
leaq -0x20(%rbp), %rdi
callq 0x54dd0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x54e70
jmp 0x54041
jmp 0x54013
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x54ea0
movq %rax, -0xb8(%rbp)
jmp 0x53f42
jmp 0x5402c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::query_in_users(Database::UserInfo, std::__cxx11::list<Database::User*, std::allocator<Database::User*>> const&)
Database::User* Database::query_in_users(UserInfo user_info, const l_users& users)
{
    if(!users.empty())
    {
        for(auto user_itr = users.begin(); user_itr != users.end(); user_itr++)
        {
            if(check_info(*user_itr, user_info) == ConstNames::Equal)
                return *user_itr;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x54d20
testb $0x1, %al
jne 0x541ee
movq -0x20(%rbp), %rdi
callq 0x54ed0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x54f30
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x54f00
testb $0x1, %al
jne 0x5412a
jmp 0x541ec
leaq -0x28(%rbp), %rdi
callq 0x54f60
movq -0xc8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x54df0
movq -0xc0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
callq 0x54050
movb %al, -0xc9(%rbp)
jmp 0x54179
movb -0xc9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xe4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x54e70
movl -0xe4(%rbp), %eax
cmpl $0x1, %eax
jne 0x541d3
leaq -0x28(%rbp), %rdi
callq 0x54f60
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x541f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x54e70
jmp 0x54203
jmp 0x541d5
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x54f90
movq %rax, -0xb8(%rbp)
jmp 0x54107
jmp 0x541ee
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::query_in_hotels(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Database::Hotel* Database::query_in_hotels(info_t hotel_id)
{
    if(hotel_id != ConstNames::Empty_Str)
    {
        for(auto hotel_itr = hotels.begin(); hotel_itr != hotels.end(); hotel_itr++)
        {
            if((*hotel_itr)->id == hotel_id)
                return *hotel_itr;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xb5262(%rip), %rsi     # 0x1094a0
callq 0x54fc0
testb $0x1, %al
jne 0x54249
jmp 0x542c0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x54ff0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x55050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x55020
testb $0x1, %al
jne 0x5427e
jmp 0x542be
leaq -0x20(%rbp), %rdi
callq 0x55110
movq -0x40(%rbp), %rsi
movq (%rax), %rdi
callq 0x55080
testb $0x1, %al
jne 0x54299
jmp 0x542ab
leaq -0x20(%rbp), %rdi
callq 0x55110
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x542c8
jmp 0x542ad
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x55130
movq %rax, -0x30(%rbp)
jmp 0x5425a
jmp 0x542c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::get_hotels(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Database::Hotel* Database::get_hotels(info_t hotel_id)
{
    Hotel* hotel = query_in_hotels(hotel_id);
    if(hotel == nullptr)
        throw Exception(ConstNames::Not_Found_msg);
    return hotel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x61d0
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x54210
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6828
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x54517
movb $0x1, -0x65(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x80(%rbp)
leaq 0xb51f6(%rip), %rsi     # 0x1096a0
leaq -0x58(%rbp), %rdi
callq 0x61d0
jmp 0x544b5
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xabc90
jmp 0x544c4
movq -0x80(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0xb3795(%rip), %rsi     # 0x107c68
leaq 0x57826(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x5452d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x54504
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6828
testb $0x1, -0x65(%rbp)
jne 0x5450c
jmp 0x54515
movq -0x80(%rbp), %rdi
callq 0x6360
jmp 0x54524
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::get_reserve(Database::User*)
void Database::get_reserve(User *user)
{
    User::l_booked reserves = user->get_reserve();
    if(reserves.empty())
        throw Exception(ConstNames::Empty_msg);
    responding(reserves);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x679e0
leaq -0x28(%rbp), %rdi
callq 0x55350
testb $0x1, %al
jne 0x5463a
jmp 0x546c3
movb $0x1, -0x55(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x80(%rbp)
leaq 0xb50ed(%rip), %rsi     # 0x109740
leaq -0x48(%rbp), %rdi
callq 0x61d0
jmp 0x5465e
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xabc90
jmp 0x5466d
movq -0x80(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0xb35ec(%rip), %rsi     # 0x107c68
leaq 0x5767d(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x54731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x546b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6828
testb $0x1, -0x55(%rbp)
jne 0x546b8
jmp 0x546c1
movq -0x80(%rbp), %rdi
callq 0x6360
jmp 0x5471f
leaq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x553f0
jmp 0x546d2
movq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x55370
jmp 0x546e1
leaq -0x70(%rbp), %rdi
callq 0x554b0
leaq -0x28(%rbp), %rdi
callq 0x554b0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5471f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x554b0
leaq -0x28(%rbp), %rdi
callq 0x554b0
movq -0x50(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::post_comment(Database::User*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Database::post_comment(User *user, std::string hotel_id, std::string comment)
{
    auto hotel = query_in_hotels(hotel_id);
    if(hotel == nullptr)
        throw Exception(ConstNames::Not_Found_msg);
    comments.push_front(new Comment(comment, user, hotel));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xc8(%rbp)
movq %rsi, %rax
movq -0xc8(%rbp), %rsi
movq %rcx, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x61d0
movq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x54210
movq %rax, -0xb0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6828
movq -0xb0(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x54855
movb $0x1, -0x75(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0xd0(%rbp)
leaq 0xb4ec7(%rip), %rsi     # 0x1096a0
leaq -0x68(%rbp), %rdi
callq 0x61d0
jmp 0x547e4
movq -0xd0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xabc90
jmp 0x547f6
movq -0xd0(%rbp), %rdi
movb $0x0, -0x75(%rbp)
leaq 0xb3460(%rip), %rsi     # 0x107c68
leaq 0x574f1(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x54932
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x5483c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6828
testb $0x1, -0x75(%rbp)
jne 0x54844
jmp 0x54850
movq -0xd0(%rbp), %rdi
callq 0x6360
jmp 0x54929
movq -0xb8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0xe0(%rbp)
movl $0x30, %edi
callq 0x6440
movq -0xc0(%rbp), %rsi
movq %rax, -0xd8(%rbp)
movb $0x1, -0xa1(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x61d0
jmp 0x54894
movq -0xd8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0xa0(%rbp), %rsi
callq 0x72540
jmp 0x548b1
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movb $0x0, -0xa1(%rbp)
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x554d0
jmp 0x548d5
leaq -0xa0(%rbp), %rdi
callq 0x6828
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x54910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6828
testb $0x1, -0xa1(%rbp)
jne 0x5491b
jmp 0x54927
movq -0xd8(%rbp), %rdi
callq 0x6400
jmp 0x54929
movq -0x70(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Database.cpp
// Function: Database::get_comment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Database::l_comments Database::get_comment(std::string hotel_id)
{
    auto hotel = query_in_hotels(hotel_id);
    if(hotel == nullptr)
        throw Exception(ConstNames::Not_Found_msg);
    l_comments get_comment;
    for(auto comment_itr = comments.begin(); comment_itr != comments.end(); comment_itr++)
    {
        if((*comment_itr)->hotel == hotel)
            get_comment.push_back(*comment_itr);
    }
    return get_comment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xb0(%rbp)
movq %rsi, %rax
movq -0xb0(%rbp), %rsi
movq %rdi, -0xa8(%rbp)
movq %rdi, %rcx
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x61d0
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x54210
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6828
movq -0x90(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x54a5b
movb $0x1, -0x6d(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0xb8(%rbp)
leaq 0xb4cc1(%rip), %rsi     # 0x1096a0
leaq -0x60(%rbp), %rdi
callq 0x61d0
jmp 0x549ea
movq -0xb8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xabc90
jmp 0x549fc
movq -0xb8(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0xb325a(%rip), %rsi     # 0x107c68
leaq 0x572eb(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x54b3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x54a42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6828
testb $0x1, -0x6d(%rbp)
jne 0x54a4a
jmp 0x54a56
movq -0xb8(%rbp), %rdi
callq 0x6360
jmp 0x54b31
movq -0xa8(%rbp), %rdi
movb $0x0, -0x6e(%rbp)
callq 0x54b80
movq -0x98(%rbp), %rdi
addq $0x30, %rdi
callq 0x55510
movq %rax, -0x78(%rbp)
movq -0x98(%rbp), %rdi
addq $0x30, %rdi
callq 0x55570
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x55540
testb $0x1, %al
jne 0x54aa6
jmp 0x54b0b
leaq -0x78(%rbp), %rdi
callq 0x555a0
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x54af2
leaq -0x78(%rbp), %rdi
callq 0x555a0
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x555c0
jmp 0x54ad6
jmp 0x54af2
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x54c70
jmp 0x54b31
jmp 0x54af4
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
callq 0x55600
movq %rax, -0x88(%rbp)
jmp 0x54a7f
movb $0x1, -0x6e(%rbp)
testb $0x1, -0x6e(%rbp)
jne 0x54b21
movq -0xa8(%rbp), %rdi
callq 0x54c70
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::RatingInfo::RatingInfo()
Database::Hotel::RatingInfo::RatingInfo()
{
    hotel_id = ConstNames::Empty_Str;
    location = 0.0f;
    cleanliness = 0.0f;
    staff = 0.0f;
    facilities = 0.0f;
    value_for_money = 0.0f;
    overall_rating = 0.0f;
    user = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x65d0
movq -0x20(%rbp), %rdi
leaq 0xb210d(%rip), %rsi     # 0x10a0e8
callq 0x6060
jmp 0x57fe2
movq -0x28(%rbp), %rax
fldz
fld %st(0)
fstpt 0x20(%rax)
fld %st(0)
fstpt 0x30(%rax)
fld %st(0)
fstpt 0x40(%rax)
fld %st(0)
fstpt 0x50(%rax)
fld %st(0)
fstpt 0x60(%rax)
fstpt 0x70(%rax)
movq $0x0, 0x80(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x6828
movq -0x10(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::RatingInfo::operator==(Database::Hotel::RatingInfo const&)
bool Database::Hotel::RatingInfo::operator==(const RatingInfo &second)
{
    if(hotel_id == second.hotel_id && location == second.location && cleanliness == second.cleanliness && staff == second.staff &&
        facilities == second.facilities && value_for_money == second.value_for_money && overall_rating == second.overall_rating)
        return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x55080
testb $0x1, %al
jne 0x5806a
jmp 0x58114
movq -0x20(%rbp), %rax
fldt 0x20(%rax)
movq -0x18(%rbp), %rax
fldt 0x20(%rax)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x58114
jp 0x58114
jmp 0x5808c
movq -0x20(%rbp), %rax
fldt 0x30(%rax)
movq -0x18(%rbp), %rax
fldt 0x30(%rax)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x58114
jp 0x58114
jmp 0x580a6
movq -0x20(%rbp), %rax
fldt 0x40(%rax)
movq -0x18(%rbp), %rax
fldt 0x40(%rax)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x58114
jp 0x58114
jmp 0x580c0
movq -0x20(%rbp), %rax
fldt 0x50(%rax)
movq -0x18(%rbp), %rax
fldt 0x50(%rax)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x58114
jp 0x58114
jmp 0x580da
movq -0x20(%rbp), %rax
fldt 0x60(%rax)
movq -0x18(%rbp), %rax
fldt 0x60(%rax)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x58114
jp 0x58114
jmp 0x580f4
movq -0x20(%rbp), %rax
fldt 0x70(%rax)
movq -0x18(%rbp), %rax
fldt 0x70(%rax)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x58114
jp 0x58114
jmp 0x5810e
movb $0x1, -0x1(%rbp)
jmp 0x58118
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::prepare_rooms(Database::HotelInfo const&)
Database::Hotel::v_room Database::Hotel::prepare_rooms(const Database::HotelInfo& info)
{
    v_room rooms = v_room();
    construct_rooms<StandardRoom>(rooms, info.no_standard_rooms, info.standard_room_price);
    construct_rooms<DeluxeRoom>(rooms, info.no_deluxe_rooms, info.deluxe_room_price);
    construct_rooms<LuxuryRoom>(rooms, info.no_luxury_rooms, info.luxury_room_price);
    construct_rooms<PremiumRoom>(rooms, info.no_premium_rooms, info.premium_room_price);
    Room::reset_room_id(rooms);
    return rooms;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5a5a0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0xf0(%rax), %edx
fldt 0x100(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5ada0
jmp 0x584f2
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xf4(%rax), %edx
fldt 0x110(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5ae50
jmp 0x58516
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xf8(%rax), %edx
fldt 0x120(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5af00
jmp 0x5853a
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xfc(%rax), %edx
fldt 0x130(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5afb0
jmp 0x5855e
movq -0x38(%rbp), %rdi
callq 0x60ce0
jmp 0x58569
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x58595
jmp 0x5858c
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x552f0
jmp 0x5859f
movq -0x38(%rbp), %rdi
callq 0x552f0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::calculate_avg_price(Database::HotelInfo const&)
long double Database::Hotel::calculate_avg_price(const HotelInfo& info)
{
    vector<long double> prices {info.standard_room_price, info.deluxe_room_price, info.luxury_room_price, info.premium_room_price};
    long double sum = 0;
    int q = 0;
    for(long double f : prices)
    {
        if(f != 0)
        {
            sum += f;
            q++;
        }
    }
    if(q == 0)
        return 0.0f;
    return sum/q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
fldt 0x100(%rax)
fstpt -0x90(%rbp)
movq -0x20(%rbp), %rax
fldt 0x110(%rax)
fstpt -0x80(%rbp)
movq -0x20(%rbp), %rax
fldt 0x120(%rax)
fstpt -0x70(%rbp)
movq -0x20(%rbp), %rax
fldt 0x130(%rax)
fstpt -0x60(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x4, -0x40(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x5aba0
movq -0x100(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x5abc0
jmp 0x5863a
leaq -0x91(%rbp), %rdi
callq 0x5ac40
fldz
fstpt -0xc0(%rbp)
movl $0x0, -0xc4(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x5ac60
movq %rax, -0xd8(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x5ac90
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x5acc0
testb $0x1, %al
jne 0x586a5
jmp 0x58725
leaq -0xd8(%rbp), %rdi
callq 0x5ad00
fldt (%rax)
fstpt -0xf0(%rbp)
fldt -0xf0(%rbp)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x586cd
jp 0x586cd
jmp 0x58712
fldt -0xf0(%rbp)
fldt -0xc0(%rbp)
faddp %st, %st(1)
fstpt -0xc0(%rbp)
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x58712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x91(%rbp), %rdi
callq 0x5ac40
jmp 0x5877b
jmp 0x58714
leaq -0xd8(%rbp), %rdi
callq 0x5ad20
jmp 0x58689
cmpl $0x0, -0xc4(%rbp)
jne 0x5873f
fldz
fstpt -0x10(%rbp)
movl $0x1, -0xf4(%rbp)
jmp 0x58766
fldt -0xc0(%rbp)
movl -0xc4(%rbp), %eax
movl %eax, -0xf8(%rbp)
fildl -0xf8(%rbp)
fdivrp %st, %st(1)
fstpt -0x10(%rbp)
movl $0x1, -0xf4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5ad40
fldt -0x10(%rbp)
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::clean_rooms_up()
void Database::Hotel::clean_rooms_up()
{
    for(auto room_itr = rooms.begin(); room_itr != rooms.end(); room_itr++)
    {
        delete *room_itr;
        *room_itr = nullptr;
    }
    rooms.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xe0, %rdi
callq 0x5a930
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0xe0, %rdi
callq 0x5a9a0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5a960
testb $0x1, %al
jne 0x5889b
jmp 0x588dc
leaq -0x10(%rbp), %rdi
callq 0x5a9d0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x588bb
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x10(%rbp), %rdi
callq 0x5a9d0
movq $0x0, (%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5aa60
movq %rax, -0x20(%rbp)
jmp 0x58874
movq -0x28(%rbp), %rdi
addq $0xe0, %rdi
callq 0x5b430
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::clean_ratings_up()
void Database::Hotel::clean_ratings_up()
{
    for(auto rating_itr = map_ratings.begin(); rating_itr != map_ratings.end(); rating_itr++)
    {
        delete (*rating_itr).second;
        (*rating_itr).second = nullptr;
    }
    map_ratings.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xf8, %rdi
callq 0x5aaf0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0xf8, %rdi
callq 0x5a7d0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5a7a0
testb $0x1, %al
jne 0x5894b
jmp 0x58996
leaq -0x10(%rbp), %rdi
callq 0x5ab20
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x58974
movq -0x30(%rbp), %rdi
callq 0x72400
movq -0x30(%rbp), %rdi
callq 0x6400
leaq -0x10(%rbp), %rdi
callq 0x5ab20
movq $0x0, 0x8(%rax)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5ab60
movq %rax, -0x20(%rbp)
jmp 0x58924
movq -0x28(%rbp), %rdi
addq $0xf8, %rdi
callq 0x5b450
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::to_string[abi:cxx11]() const
info_t Database::Hotel::to_string() const
{
    ostringstream os;
    os << setprecision(ConstNames::Precision) << fixed;
    os << id << ConstNames::Space_str;
    os << property_name << ConstNames::Space_str;
    os << hotel_star_rating << ConstNames::Space_str;
    os << city << ConstNames::Space_str;
    os << rooms.size() << ConstNames::Space_str;
    os << get_avg_price();
    return os.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x65b0
movl $0x2, %edi
callq 0x5a720
movl %eax, -0x1a0(%rbp)
jmp 0x58a2d
movl -0x1a0(%rbp), %eax
movl %eax, -0x18c(%rbp)
movl -0x18c(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x6660
movq %rax, -0x1c0(%rbp)
jmp 0x58a54
movq -0x1c0(%rbp), %rdi
leaq 0x1cde(%rip), %rsi      # 0x5a740
callq 0x6160
jmp 0x58a69
movq -0x1a8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x63d0
movq %rax, -0x1c8(%rbp)
jmp 0x58a85
movq -0x1c8(%rbp), %rdi
leaq 0xb1675(%rip), %rsi     # 0x10a108
callq 0x63d0
jmp 0x58a9a
movq -0x1a8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x188(%rbp), %rdi
callq 0x63d0
movq %rax, -0x1d0(%rbp)
jmp 0x58aba
movq -0x1d0(%rbp), %rdi
leaq 0xb1640(%rip), %rsi     # 0x10a108
callq 0x63d0
jmp 0x58acf
movq -0x1a8(%rbp), %rax
movl 0x1c0(%rax), %esi
leaq -0x188(%rbp), %rdi
callq 0x6730
movq %rax, -0x1d8(%rbp)
jmp 0x58af1
movq -0x1d8(%rbp), %rdi
leaq 0xb1609(%rip), %rsi     # 0x10a108
callq 0x63d0
jmp 0x58b06
movq -0x1a8(%rbp), %rsi
subq $-0x80, %rsi
leaq -0x188(%rbp), %rdi
callq 0x63d0
movq %rax, -0x1e0(%rbp)
jmp 0x58b26
movq -0x1e0(%rbp), %rdi
leaq 0xb15d4(%rip), %rsi     # 0x10a108
callq 0x63d0
jmp 0x58b3b
movq -0x1a8(%rbp), %rdi
addq $0xe0, %rdi
callq 0x56dd0
movq %rax, %rsi
leaq -0x188(%rbp), %rdi
callq 0x60e0
movq %rax, -0x1e8(%rbp)
jmp 0x58b66
movq -0x1e8(%rbp), %rdi
leaq 0xb1594(%rip), %rsi     # 0x10a108
callq 0x63d0
jmp 0x58b7b
movq -0x1a8(%rbp), %rdi
callq 0x58c10
fstpt -0x1f4(%rbp)
jmp 0x58b8f
fldt -0x1f4(%rbp)
movq %rsp, %rax
fstpt (%rax)
leaq -0x188(%rbp), %rdi
callq 0x6510
jmp 0x58ba8
movq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x6460
jmp 0x58bbd
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x1b0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x198(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::post_rating(Database::Hotel::RatingInfo&)
void Database::Hotel::post_rating(RatingInfo &rating_info)
{
    auto rating = map_ratings.find(rating_info.user);
    if(rating != map_ratings.end())
    {
        delete rating->second;
        auto rating_obj = new Rating(rating_info);
        rating->second = rating_obj;
        rating_info.user->set_rating(this, rating_obj);
    }
    else{
        auto rating_obj = new Rating(rating_info);
        map_ratings.insert(make_pair(rating_info.user, rating_obj));
        rating_info.user->set_rating(this, rating_obj);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0xf8, %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
callq 0x5a770
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0xf8, %rdi
callq 0x5a7d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5a7a0
testb $0x1, %al
jne 0x58c90
jmp 0x58d30
leaq -0x18(%rbp), %rdi
callq 0x5a800
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x58cb9
movq -0x70(%rbp), %rdi
callq 0x72400
movq -0x70(%rbp), %rdi
callq 0x6400
movl $0x60, %edi
callq 0x6440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
callq 0x723b0
jmp 0x58cd8
movq -0x78(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5a800
movq -0x80(%rbp), %rcx
movq -0x68(%rbp), %rsi
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x28(%rbp), %rdx
callq 0x67650
jmp 0x58dd5
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x6400
jmp 0x58dde
movl $0x60, %edi
callq 0x6440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x723b0
jmp 0x58d52
movq -0x68(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, -0x40(%rbp)
addq $0xf8, %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
leaq -0x40(%rbp), %rsi
callq 0x5a860
movq -0x90(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x5a820
movq -0x68(%rbp), %rsi
movq %rax, -0x60(%rbp)
movb %dl, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x40(%rbp), %rdx
callq 0x67650
jmp 0x58dd5
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x6400
jmp 0x58dde
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::have_room_with_this_specifications(int, int, int, int) const
bool Database::Hotel::have_room_with_this_specifications(int type, int quantity, int check_in, int check_out) const
{
    int q = 0;
    for(auto room_itr = rooms.begin(); room_itr != rooms.end(); room_itr++)
    {
        if(in_range(*room_itr, check_in, check_out, type))
            q++;
    }
    if(q >= quantity)
        return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x0, -0x24(%rbp)
addq $0xe0, %rdi
callq 0x56ef0
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
addq $0xe0, %rdi
callq 0x56f20
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5a890
testb $0x1, %al
jne 0x58e4f
jmp 0x58e90
leaq -0x30(%rbp), %rdi
callq 0x5a8d0
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0x58eb0
testb $0x1, %al
jne 0x58e74
jmp 0x58e7d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x58e7f
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x5a8f0
movq %rax, -0x40(%rbp)
jmp 0x58e28
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x58e9e
movb $0x1, -0x1(%rbp)
jmp 0x58ea2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Hotel.cpp
// Function: Database::Hotel::in_range(Database::Hotel::Room*, int, int, int) const
bool Database::Hotel::in_range(Room* room, int check_in, int check_out, int type) const
{
    if(room->type == type)
    {
        if(room->can_reserve(check_in, check_out))
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x58ef4
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0x58eec
jmp 0x58ef2
movb $0x1, -0x1(%rbp)
jmp 0x58ef8
jmp 0x58ef4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)