LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::post_reserve(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::post_reserve(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        Database::User::ReserveInfo reserve_info = fill_reserve_info(data);
        booked_out(reserve_info);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, %rax
movq -0xc0(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7b0f4
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x79140
movq -0xb0(%rbp), %rdi
leaq 0x9cb6c(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0xb8(%rbp), %rdx
movq -0xb0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x7b1b0
movq -0xb0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x7b7c0
jmp 0x7b0cc
leaq -0x70(%rbp), %rdi
callq 0x80b60
jmp 0x7b198
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x80b60
jmp 0x7b1a1
movb $0x1, -0xa1(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0xd0(%rbp)
leaq 0x9c26d(%rip), %rsi     # 0x117380
leaq -0xa0(%rbp), %rdi
callq 0x61d0
jmp 0x7b121
movq -0xd0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xabc90
jmp 0x7b136
movq -0xd0(%rbp), %rdi
movb $0x0, -0xa1(%rbp)
leaq 0x8cb1d(%rip), %rsi     # 0x107c68
leaq 0x30bae(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7b1aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x7b17f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6828
testb $0x1, -0xa1(%rbp)
jne 0x7b18a
jmp 0x7b196
movq -0xd0(%rbp), %rdi
callq 0x6360
jmp 0x7b1a1
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::find_info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
Content Backend::find_info(const string& mode, const data_t& data)
{
    auto iterator = find(data.begin(), data.end(), mode);
    if(info_exist(iterator, iterator + 1, data.end()) != ConstNames::Exist)
        return ConstNames::Empty_Str;
    iterator++;
    return (*iterator);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x72c00
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x72c30
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x80f50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x81000
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x72c30
movq -0x60(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x80fa0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x7bb82
movq -0x70(%rbp), %rdi
leaq 0x9b625(%rip), %rsi     # 0x1171a0
callq 0x61d0
jmp 0x7bba6
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x81040
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x73080
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x61d0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::post_rating(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::post_rating(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        auto rating_info = fill_rating_info(data);
        object_relational->post_rating(rating_info);
        responding(ConstNames::OK_msg);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rsi, -0x130(%rbp)
movq %rdi, %rax
movq -0x130(%rbp), %rdi
movq %rdi, -0x128(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7bd27
movq -0x128(%rbp), %rsi
movq -0x120(%rbp), %rdi
callq 0x79140
movq -0x120(%rbp), %rdi
leaq 0x9bfec(%rip), %rsi     # 0x117c00
callq 0x79240
leaq 0x9b9c0(%rip), %rsi     # 0x1175e0
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x61d0
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdx
movq -0x138(%rbp), %rcx
leaq -0xa0(%rbp), %rdi
callq 0x7bdf0
jmp 0x7bc56
leaq -0xc0(%rbp), %rdi
callq 0x6828
movq -0x120(%rbp), %rax
movq (%rax), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x746a0
jmp 0x7bc7a
leaq 0x9b7df(%rip), %rsi     # 0x117460
leaq -0xf0(%rbp), %rdi
callq 0x61d0
jmp 0x7bc8f
movq -0x120(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x7a5e0
jmp 0x7bca4
leaq -0xf0(%rbp), %rdi
callq 0x6828
leaq -0xa0(%rbp), %rdi
callq 0x5a6b0
jmp 0x7bdd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x6828
jmp 0x7bde0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x7bd16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6828
leaq -0xa0(%rbp), %rdi
callq 0x5a6b0
jmp 0x7bde0
movb $0x1, -0x111(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x140(%rbp)
leaq 0x9b63a(%rip), %rsi     # 0x117380
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x7bd54
movq -0x140(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xabc90
jmp 0x7bd69
movq -0x140(%rbp), %rdi
movb $0x0, -0x111(%rbp)
leaq 0x8beea(%rip), %rsi     # 0x107c68
leaq 0x2ff7b(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7bdec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x7bdbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x6828
testb $0x1, -0x111(%rbp)
jne 0x7bdc9
jmp 0x7bdd5
movq -0x140(%rbp), %rdi
callq 0x6360
jmp 0x7bde0
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::post_manual_weights(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::post_manual_weights(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        auto manual_weights = fill_manual_weights_info(data);
        object_relational->post_manual_weights(manual_weights, *online_users.begin());
        responding(ConstNames::OK_msg);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rsi, -0x128(%rbp)
movq %rdi, %rax
movq -0x128(%rbp), %rdi
movq %rdi, -0x120(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7cfe9
movq -0x118(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x79140
movq -0x118(%rbp), %rdi
leaq 0x9ad0c(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x120(%rbp), %rdx
movq -0x118(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x7d0b0
movq -0x118(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x138(%rbp)
addq $0x8, %rdi
callq 0x54d40
movq %rax, -0xb8(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x54dd0
movq -0x138(%rbp), %rdi
movq -0x130(%rbp), %rsi
movq (%rax), %rdx
callq 0x747d0
jmp 0x7cf5f
leaq 0x9a4fa(%rip), %rsi     # 0x117460
leaq -0xe8(%rbp), %rdi
callq 0x61d0
jmp 0x7cf74
movq -0x118(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x7a5e0
jmp 0x7cf89
leaq -0xe8(%rbp), %rdi
callq 0x6828
leaq -0xb0(%rbp), %rdi
callq 0x69380
jmp 0x7d099
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x7cfd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x6828
leaq -0xb0(%rbp), %rdi
callq 0x69380
jmp 0x7d0a2
movb $0x1, -0x109(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x140(%rbp)
leaq 0x9a378(%rip), %rsi     # 0x117380
leaq -0x108(%rbp), %rdi
callq 0x61d0
jmp 0x7d016
movq -0x140(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0xabc90
jmp 0x7d02b
movq -0x140(%rbp), %rdi
movb $0x0, -0x109(%rbp)
leaq 0x8ac28(%rip), %rsi     # 0x107c68
leaq 0x2ecb9(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7d0ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x7d080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x6828
testb $0x1, -0x109(%rbp)
jne 0x7d08b
jmp 0x7d097
movq -0x140(%rbp), %rdi
callq 0x6360
jmp 0x7d0a2
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::post_filter(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::post_filter(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        Database::User::FilterInfo filter_info = fill_filter_info(data);
        set_filters(filter_info);
        responding(ConstNames::OK_msg);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rsi, -0x110(%rbp)
movq %rdi, %rax
movq -0x110(%rbp), %rdi
movq %rdi, -0x108(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7d529
movq -0x100(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0x79140
movq -0x100(%rbp), %rdi
leaq 0x9a79c(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x108(%rbp), %rdx
movq -0x100(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x7d5f0
movq -0x100(%rbp), %rdi
movq -0x118(%rbp), %rsi
callq 0x7dd50
jmp 0x7d49f
leaq 0x99fba(%rip), %rsi     # 0x117460
leaq -0xd0(%rbp), %rdi
callq 0x61d0
jmp 0x7d4b4
movq -0x100(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x7a5e0
jmp 0x7d4c9
leaq -0xd0(%rbp), %rdi
callq 0x6828
leaq -0xa0(%rbp), %rdi
callq 0x80b90
jmp 0x7d5d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x7d518
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x6828
leaq -0xa0(%rbp), %rdi
callq 0x80b90
jmp 0x7d5e2
movb $0x1, -0xf1(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x120(%rbp)
leaq 0x99e38(%rip), %rsi     # 0x117380
leaq -0xf0(%rbp), %rdi
callq 0x61d0
jmp 0x7d556
movq -0x120(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0xabc90
jmp 0x7d56b
movq -0x120(%rbp), %rdi
movb $0x0, -0xf1(%rbp)
leaq 0x8a6e8(%rip), %rsi     # 0x107c68
leaq 0x2e779(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7d5ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x7d5c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6828
testb $0x1, -0xf1(%rbp)
jne 0x7d5cb
jmp 0x7d5d7
movq -0x120(%rbp), %rdi
callq 0x6360
jmp 0x7d5e2
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::post_default_price_filter(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::post_default_price_filter(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        auto activation_mode = fill_default_filter_info(data);
        set_filters(activation_mode);
        responding(ConstNames::OK_msg);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7de6b
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x79140
movq -0x78(%rbp), %rdi
leaq 0x99e0b(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x7df10
movq -0x78(%rbp), %rdi
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %esi
andl $0x1, %esi
callq 0x7e140
leaq 0x9963f(%rip), %rsi     # 0x117460
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x61d0
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x7a5e0
jmp 0x7de43
leaq -0x38(%rbp), %rdi
callq 0x6828
jmp 0x7defd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6828
jmp 0x7df06
movb $0x1, -0x69(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x98(%rbp)
leaq 0x994f9(%rip), %rsi     # 0x117380
leaq -0x68(%rbp), %rdi
callq 0x61d0
jmp 0x7de92
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xabc90
jmp 0x7dea4
movq -0x98(%rbp), %rdi
movb $0x0, -0x69(%rbp)
leaq 0x89db2(%rip), %rsi     # 0x107c68
leaq 0x2de43(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7df0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7dee7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6828
testb $0x1, -0x69(%rbp)
jne 0x7deef
jmp 0x7defb
movq -0x98(%rbp), %rdi
callq 0x6360
jmp 0x7df06
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::post_sort(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::post_sort(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        auto sort_info = fill_sort_info(data);
        set_sort_info(sort_info);
        responding(ConstNames::OK_msg);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xb8(%rbp)
movq %rdi, %rax
movq -0xb8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7e2a8
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x79140
movq -0xa8(%rbp), %rdi
leaq 0x999fc(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x7e360
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x7e5f0
jmp 0x7e23c
leaq 0x9921d(%rip), %rsi     # 0x117460
leaq -0x78(%rbp), %rdi
callq 0x61d0
jmp 0x7e24e
movq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x7a5e0
jmp 0x7e260
leaq -0x78(%rbp), %rdi
callq 0x6828
leaq -0x48(%rbp), %rdi
callq 0x692d0
jmp 0x7e34c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7e29a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6828
leaq -0x48(%rbp), %rdi
callq 0x692d0
jmp 0x7e355
movb $0x1, -0x99(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0xc8(%rbp)
leaq 0x990b9(%rip), %rsi     # 0x117380
leaq -0x98(%rbp), %rdi
callq 0x61d0
jmp 0x7e2d5
movq -0xc8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xabc90
jmp 0x7e2ea
movq -0xc8(%rbp), %rdi
movb $0x0, -0x99(%rbp)
leaq 0x89969(%rip), %rsi     # 0x107c68
leaq 0x2d9fa(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7e35e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7e333
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x6828
testb $0x1, -0x99(%rbp)
jne 0x7e33e
jmp 0x7e34a
movq -0xc8(%rbp), %rdi
callq 0x6360
jmp 0x7e355
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::wallet_get(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::wallet_get(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        Database::UserInfo user_info = fill_user_info(data, ConstNames::GET_Wallet_Order);
        check_account(user_info);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xf0(%rbp)
movq %rdi, %rax
movq -0xf0(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7e752
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdi
callq 0x79140
movq -0xe0(%rbp), %rdi
leaq 0x9955c(%rip), %rsi     # 0x117c00
callq 0x79240
leaq 0x98f70(%rip), %rsi     # 0x117620
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x61d0
movq -0xe0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movq -0xf8(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x79710
jmp 0x7e6e3
leaq -0xa0(%rbp), %rdi
callq 0x6828
movq -0xe0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7e820
jmp 0x7e701
leaq -0x80(%rbp), %rdi
callq 0x54e70
jmp 0x7e802
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6828
jmp 0x7e80b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x54e70
jmp 0x7e80b
movb $0x1, -0xd1(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x100(%rbp)
leaq 0x98c0f(%rip), %rsi     # 0x117380
leaq -0xd0(%rbp), %rdi
callq 0x61d0
jmp 0x7e77f
movq -0x100(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xabc90
jmp 0x7e794
movq -0x100(%rbp), %rdi
movb $0x0, -0xd1(%rbp)
leaq 0x894bf(%rip), %rsi     # 0x107c68
leaq 0x2d550(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7e817
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x7e7e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x6828
testb $0x1, -0xd1(%rbp)
jne 0x7e7f4
jmp 0x7e800
movq -0x100(%rbp), %rdi
callq 0x6360
jmp 0x7e80b
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::get_reserve(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::get_reserve(data_t data)
{
    if(data.empty())
    {
        check_access(ConstNames::Online_Mode);
        object_relational->get_reserve(*online_users.begin());
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7e94e
jmp 0x7e990
movq -0x50(%rbp), %rdi
leaq 0x992a7(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0x54d40
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x54dd0
movq -0x60(%rbp), %rdi
movq (%rax), %rsi
callq 0x74490
jmp 0x7ea16
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x68(%rbp)
leaq 0x989d7(%rip), %rsi     # 0x117380
leaq -0x38(%rbp), %rdi
callq 0x61d0
jmp 0x7e9b4
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xabc90
jmp 0x7e9c3
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x89296(%rip), %rsi     # 0x107c68
leaq 0x2d327(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7ea25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7ea03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6828
testb $0x1, -0x45(%rbp)
jne 0x7ea0b
jmp 0x7ea14
movq -0x68(%rbp), %rdi
callq 0x6360
jmp 0x7ea1c
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::get_full_hotel(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::get_full_hotel(data_t data)
{
    if(!data.empty())
    {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        info_t hotel_id = find_info(ConstNames::ID, data);
        get_hotels_info(hotel_id);
    }
    else
        return get_hotels();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, %rax
movq -0x78(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7eb00
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x79140
movq -0x68(%rbp), %rdi
leaq 0x99181(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rcx
leaq 0x98c0d(%rip), %rdx     # 0x1176a0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7bad0
movq -0x80(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x61d0
jmp 0x7eaaf
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7eb20
jmp 0x7eabe
leaq -0x50(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
jmp 0x7eb09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7eaf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
jmp 0x7eb12
movq -0x68(%rbp), %rdi
callq 0x7eb90
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::get_comment(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::get_comment(data_t data)
{
   if(!data.empty())
   {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        string hotel_id = find_info(ConstNames::Hotel, data);
        object_relational->get_comment(hotel_id);
   }
   else
    throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7ed0b
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x79140
movq -0x90(%rbp), %rdi
leaq 0x98f9c(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %rsi
leaq 0x98de2(%rip), %rdx     # 0x117a60
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x7bad0
movq -0x90(%rbp), %rax
movq -0xb0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x61d0
jmp 0x7ecb1
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x745c0
jmp 0x7ecc3
leaq -0x50(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
jmp 0x7eda6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7ecfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
jmp 0x7edaf
movb $0x1, -0x81(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0xb8(%rbp)
leaq 0x98656(%rip), %rsi     # 0x117380
leaq -0x80(%rbp), %rdi
callq 0x61d0
jmp 0x7ed35
movq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xabc90
jmp 0x7ed47
movq -0xb8(%rbp), %rdi
movb $0x0, -0x81(%rbp)
leaq 0x88f0c(%rip), %rsi     # 0x107c68
leaq 0x2cf9d(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7edb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7ed8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6828
testb $0x1, -0x81(%rbp)
jne 0x7ed98
jmp 0x7eda4
movq -0xb8(%rbp), %rdi
callq 0x6360
jmp 0x7edaf
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::get_rating(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::get_rating(data_t data)
{
  if(!data.empty())
  {
        check_question_mark(data);
        check_access(ConstNames::Online_Mode);
        string hotel_id = find_info(ConstNames::Hotel, data);
        object_relational->get_rating(hotel_id);
  }
  else
    throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7eecb
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x79140
movq -0x90(%rbp), %rdi
leaq 0x98ddc(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %rsi
leaq 0x98c22(%rip), %rdx     # 0x117a60
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x7bad0
movq -0x90(%rbp), %rax
movq -0xb0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x61d0
jmp 0x7ee71
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x74800
jmp 0x7ee83
leaq -0x50(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
jmp 0x7ef66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7eebd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6828
leaq -0x30(%rbp), %rdi
callq 0x6828
jmp 0x7ef6f
movb $0x1, -0x81(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0xb8(%rbp)
leaq 0x98496(%rip), %rsi     # 0x117380
leaq -0x80(%rbp), %rdi
callq 0x61d0
jmp 0x7eef5
movq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xabc90
jmp 0x7ef07
movq -0xb8(%rbp), %rdi
movb $0x0, -0x81(%rbp)
leaq 0x88d4c(%rip), %rsi     # 0x107c68
leaq 0x2cddd(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7ef78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7ef4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6828
testb $0x1, -0x81(%rbp)
jne 0x7ef58
jmp 0x7ef64
movq -0xb8(%rbp), %rdi
callq 0x6360
jmp 0x7ef6f
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::get_manual_weights(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::get_manual_weights(data_t data)
{
    if(data.empty())
    {
        check_access(ConstNames::Online_Mode);
        object_relational->get_manual_weights(*online_users.begin());
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7efae
jmp 0x7eff0
movq -0x50(%rbp), %rdi
leaq 0x98c47(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0x54d40
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x54dd0
movq -0x60(%rbp), %rdi
movq (%rax), %rsi
callq 0x74ab0
jmp 0x7f076
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x68(%rbp)
leaq 0x98377(%rip), %rsi     # 0x117380
leaq -0x38(%rbp), %rdi
callq 0x61d0
jmp 0x7f014
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xabc90
jmp 0x7f023
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x88c36(%rip), %rsi     # 0x107c68
leaq 0x2ccc7(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7f085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7f063
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6828
testb $0x1, -0x45(%rbp)
jne 0x7f06b
jmp 0x7f074
movq -0x68(%rbp), %rdi
callq 0x6360
jmp 0x7f07c
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::get_estimated_weights(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::get_estimated_weights(data_t data)
{
    if(data.empty())
    {
        check_access(ConstNames::Online_Mode);
        object_relational->get_estimated_weights(*online_users.begin());
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7f0be
jmp 0x7f100
movq -0x50(%rbp), %rdi
leaq 0x98b37(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0x54d40
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x54dd0
movq -0x60(%rbp), %rdi
movq (%rax), %rsi
callq 0x74b80
jmp 0x7f186
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x68(%rbp)
leaq 0x98267(%rip), %rsi     # 0x117380
leaq -0x38(%rbp), %rdi
callq 0x61d0
jmp 0x7f124
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xabc90
jmp 0x7f133
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x88b26(%rip), %rsi     # 0x107c68
leaq 0x2cbb7(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7f195
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7f173
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6828
testb $0x1, -0x45(%rbp)
jne 0x7f17b
jmp 0x7f184
movq -0x68(%rbp), %rdi
callq 0x6360
jmp 0x7f18c
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::delete_filter(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void Backend::delete_filter(data_t data)
{
    if(data.empty())
    {
        check_access(ConstNames::Online_Mode);
        object_relational->delete_filter(*online_users.begin());
        responding(ConstNames::OK_msg);
    }
    else
        throw Exception(ConstNames::Bad_Request_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, %rax
movq -0x80(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x80940
testb $0x1, %al
jne 0x7f1d4
jmp 0x7f268
movq -0x78(%rbp), %rdi
leaq 0x98a21(%rip), %rsi     # 0x117c00
callq 0x79240
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x90(%rbp)
addq $0x8, %rdi
callq 0x54d40
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x54dd0
movq -0x90(%rbp), %rdi
movq (%rax), %rsi
callq 0x74130
leaq 0x98242(%rip), %rsi     # 0x117460
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x61d0
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x7a5e0
jmp 0x7f240
leaq -0x38(%rbp), %rdi
callq 0x6828
jmp 0x7f2fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6828
jmp 0x7f303
movb $0x1, -0x69(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x98(%rbp)
leaq 0x980fc(%rip), %rsi     # 0x117380
leaq -0x68(%rbp), %rdi
callq 0x61d0
jmp 0x7f28f
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xabc90
jmp 0x7f2a1
movq -0x98(%rbp), %rdi
movb $0x0, -0x69(%rbp)
leaq 0x889b5(%rip), %rsi     # 0x107c68
leaq 0x2ca46(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7f30c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7f2e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6828
testb $0x1, -0x69(%rbp)
jne 0x7f2ec
jmp 0x7f2f8
movq -0x98(%rbp), %rdi
callq 0x6360
jmp 0x7f303
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::request_from_online_user(Database::UserInfo)
bool Backend::request_from_online_user(Database::UserInfo user_info)
{
    if(online_users.empty())
        return !ConstNames::Exist;
    if(!online_users.empty())
        return ConstNames::Exist;
    return object_relational->authentication(user_info, ConstNames::Online_User_Check, online_users);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x8, %rdi
callq 0x54d20
testb $0x1, %al
jne 0x7f614
jmp 0x7f61d
movb $0x0, -0x1(%rbp)
jmp 0x7f705
movq -0xc8(%rbp), %rdi
addq $0x8, %rdi
callq 0x54d20
testb $0x1, %al
jne 0x7f63a
movb $0x1, -0x1(%rbp)
jmp 0x7f705
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x54df0
leaq 0x980fb(%rip), %rsi     # 0x117760
leaq -0xb0(%rbp), %rdi
callq 0x61d0
jmp 0x7f673
movq -0xd8(%rbp), %rdi
movq -0xc8(%rbp), %rcx
addq $0x8, %rcx
leaq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x73cb0
movb %al, -0xd9(%rbp)
jmp 0x7f6a0
movb -0xd9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x6828
leaq -0x90(%rbp), %rdi
callq 0x54e70
jmp 0x7f705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x7f6f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x6828
leaq -0x90(%rbp), %rdi
callq 0x54e70
jmp 0x7f713
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::valid_sort_info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Backend::valid_sort_info(const std::string& property, const std::string mode)
{
    auto temp_sort = Database::User::SortInfo();
    auto property_i = temp_sort.map_sort_property.find(property);
    if(property_i == temp_sort.map_sort_property.end())
        return false;
    if(mode != ConstNames::Ascending && mode != ConstNames::Descending)
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x658d0
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x80ea0
movq %rax, -0x88(%rbp)
jmp 0x7f7d7
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x80ed0
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6daf0
testb $0x1, %al
jne 0x7f802
jmp 0x7f826
movb $0x0, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
jmp 0x7f870
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x692d0
jmp 0x7f887
movq -0x98(%rbp), %rdi
leaq 0x9856c(%rip), %rsi     # 0x117da0
callq 0x54fc0
testb $0x1, %al
jne 0x7f83f
jmp 0x7f865
movq -0x98(%rbp), %rdi
leaq 0x98573(%rip), %rsi     # 0x117dc0
callq 0x54fc0
testb $0x1, %al
jne 0x7f858
jmp 0x7f865
movb $0x0, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
jmp 0x7f870
movb $0x1, -0x1(%rbp)
movl $0x1, -0x7c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x692d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6750
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::valid_hotel_star(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Backend::valid_hotel_star(string min_star, string max_star)
{
    if(min_star != ConstNames::Empty_Str && max_star != ConstNames::Empty_Str)
    {
        int min = stoi(min_star), max = stoi(max_star);
        if(min >= ConstNames::Minimum_Hotel_Star && max >= min && max <= ConstNames::Maximum_Hotel_Star)
            return true;
        else
            throw Exception(ConstNames::Bad_Request_msg);
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x978df(%rip), %rsi     # 0x1171a0
callq 0x54fc0
testb $0x1, %al
jne 0x7f8cf
jmp 0x7f9b5
movq -0x60(%rbp), %rdi
leaq 0x978c6(%rip), %rsi     # 0x1171a0
callq 0x54fc0
testb $0x1, %al
jne 0x7f8e8
jmp 0x7f9b5
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x74d10
movq -0x60(%rbp), %rdi
movl %eax, -0x24(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x74d10
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0x7f92f
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x7f92f
cmpl $0x5, -0x28(%rbp)
jg 0x7f92f
movb $0x1, -0x1(%rbp)
jmp 0x7f9b9
movb $0x1, -0x55(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x78(%rbp)
leaq 0x97a38(%rip), %rsi     # 0x117380
leaq -0x48(%rbp), %rdi
callq 0x61d0
jmp 0x7f953
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xabc90
jmp 0x7f962
movq -0x78(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x882f7(%rip), %rsi     # 0x107c68
leaq 0x2c388(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7f9d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7f9a2
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 0x7f9aa
jmp 0x7f9b3
movq -0x78(%rbp), %rdi
callq 0x6360
jmp 0x7f9c7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6750
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::valid_price_range(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Backend::valid_price_range(string min_price, string max_price)
{
    if(min_price != ConstNames::Empty_Str && max_price != ConstNames::Empty_Str)
    {
        int min = stold(min_price), max = stold(max_price);
        if(max >= min && min >= 0 && max >= 0)
            return true;
        else
            throw Exception(ConstNames::Bad_Request_msg);
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, %rax
movq -0x80(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x9779f(%rip), %rsi     # 0x1171a0
callq 0x54fc0
testb $0x1, %al
jne 0x7fa0f
jmp 0x7fb3d
movq -0x70(%rbp), %rdi
leaq 0x97786(%rip), %rsi     # 0x1171a0
callq 0x54fc0
testb $0x1, %al
jne 0x7fa28
jmp 0x7fb3d
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x88(%rbp)
callq 0x74cd0
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
fnstcw -0x62(%rbp)
movzwl -0x62(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x64(%rbp)
fldcw -0x64(%rbp)
fistpl -0x60(%rbp)
fldcw -0x62(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x74cd0
fld %st(0)
fstp %st(0)
fnstcw -0x66(%rbp)
movzwl -0x66(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x68(%rbp)
fldcw -0x68(%rbp)
fistpl -0x5c(%rbp)
fldcw -0x66(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x7faab
cmpl $0x0, -0x24(%rbp)
jl 0x7faab
cmpl $0x0, -0x28(%rbp)
jl 0x7faab
movb $0x1, -0x1(%rbp)
jmp 0x7fb41
movb $0x1, -0x55(%rbp)
movl $0x28, %edi
callq 0x6210
movq %rax, -0x90(%rbp)
leaq 0x978b9(%rip), %rsi     # 0x117380
leaq -0x48(%rbp), %rdi
callq 0x61d0
jmp 0x7fad2
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xabc90
jmp 0x7fae4
movq -0x90(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x88172(%rip), %rsi     # 0x107c68
leaq 0x2c203(%rip), %rdx     # 0xabd00
callq 0x6710
jmp 0x7fb58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7fb27
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 0x7fb2f
jmp 0x7fb3b
movq -0x90(%rbp), %rdi
callq 0x6360
jmp 0x7fb4f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::in_the_post_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Backend::in_the_post_command(const std::string& command)
{
    auto command_itr = func_post_map.find(command);
    if(command_itr == func_post_map.end())
        return !IN;
    return IN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x81080
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x50, %rdi
callq 0x810e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x810b0
testb $0x1, %al
jne 0x8036d
jmp 0x80373
movb $0x0, -0x1(%rbp)
jmp 0x80377
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::in_the_get_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Backend::in_the_get_command(const std::string& command)
{
    auto command_itr = func_get_map.find(command);
    if(command_itr == func_get_map.end())
        return !IN;
    return IN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x80, %rdi
movq -0x18(%rbp), %rsi
callq 0x81080
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x80, %rdi
callq 0x810e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x810b0
testb $0x1, %al
jne 0x803e3
jmp 0x803e9
movb $0x0, -0x1(%rbp)
jmp 0x803ed
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::in_the_delete_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Backend::in_the_delete_command(const std::string& command)
{
    auto command_itr = func_delete_map.find(command);
    if(command_itr == func_delete_map.end())
        return !IN;
    return IN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0xb0, %rdi
movq -0x18(%rbp), %rsi
callq 0x81080
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xb0, %rdi
callq 0x810e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x810b0
testb $0x1, %al
jne 0x80453
jmp 0x80459
movb $0x0, -0x1(%rbp)
jmp 0x8045d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::calculate_weighted_average(Database::User::Weights, __gnu_cxx::__normal_iterator<Database::Hotel::Rating**, std::vector<Database::Hotel::Rating*, std::allocator<Database::Hotel::Rating*>>>)
long double Backend::calculate_weighted_average(Database::User::Weights weights, Database::Hotel::v_rating::iterator rating_itr)
{
    auto v_weights = instance->get_vector_of_weights(weights);
    auto sum = (*rating_itr)->get_sum_weighted(v_weights);
    auto weighted_sum = accumulate(v_weights.begin(), v_weights.end(), 0);
    return sum / weighted_sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rsi, %rax
movq %rdi, %rsi
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x97858(%rip), %rax     # 0x117de8
movq %rax, -0x138(%rbp)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x69be0
movq -0x138(%rbp), %rsi
movq -0x130(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x80720
jmp 0x805c3
leaq -0xd0(%rbp), %rdi
callq 0x69380
leaq -0x8(%rbp), %rdi
callq 0x814b0
movq (%rax), %rax
movq %rax, -0x140(%rbp)
leaq -0x108(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x761c0
jmp 0x805f4
movq -0x140(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x72430
fstpt -0x14c(%rbp)
jmp 0x8060f
leaq -0x108(%rbp), %rdi
callq 0x5ad40
fldt -0x14c(%rbp)
fstpt -0xf0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x5ac60
movq -0x158(%rbp), %rdi
movq %rax, -0x118(%rbp)
callq 0x5ac90
movq %rax, -0x120(%rbp)
movq -0x118(%rbp), %rdi
movq -0x120(%rbp), %rsi
xorl %edx, %edx
callq 0x814d0
movl %eax, -0x150(%rbp)
jmp 0x8066e
movl -0x150(%rbp), %eax
movl %eax, -0x10c(%rbp)
fldt -0xf0(%rbp)
movl -0x10c(%rbp), %eax
movl %eax, -0x124(%rbp)
fildl -0x124(%rbp)
fdivrp %st, %st(1)
fstpt -0x164(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5ad40
fldt -0x164(%rbp)
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x69380
jmp 0x8070d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x80704
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x5ad40
leaq -0x28(%rbp), %rdi
callq 0x5ad40
movq -0xd8(%rbp), %rdi
callq 0x6750
nopl (%rax)