LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mahdibohloul[P]SnapTrip/./Business-Logic/Backend.cpp
// Function: Backend::get_vector_of_weights(Database::User::Weights)
v_double Backend::get_vector_of_weights(Database::User::Weights weights)
{
    auto temp = v_double();
    for(int count = 0; count < ConstNames::Maximum_Weights_Number; count++)
        temp.push_back(weights[count]);
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x6250
movq -0x48(%rbp), %rdi
callq 0x815c0
movl $0x0, -0x20(%rbp)
cmpl $0x5, -0x20(%rbp)
jge 0x807b3
movq -0x58(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x66300
fstpt -0x64(%rbp)
jmp 0x8077a
movq -0x48(%rbp), %rdi
fldt -0x64(%rbp)
fstpt -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x815e0
jmp 0x8078f
jmp 0x80791
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x80763
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x5ad40
jmp 0x807d0
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x807c6
movq -0x48(%rbp), %rdi
callq 0x5ad40
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/../Models/User/../Rooms/../Database.hpp
// Function: Database::UserInfo::UserInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long long, long double)
UserInfo(info_t i_email = "", info_t i_username = "", long long i_password = 0, long double i_amount = 0.0f)
        {
            email = i_email;
            username = i_username;
            password = i_password;
            amount = i_amount;
            no_transactions = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, -0x48(%rbp)
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
fstpt -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x65d0
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x58(%rbp)
callq 0x65d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6060
jmp 0x80c5a
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
callq 0x6060
jmp 0x80c6d
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
fldt -0x30(%rbp)
fstpt 0x50(%rax)
movl $0x0, 0x60(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6828
movq -0x50(%rbp), %rdi
callq 0x6828
movq -0x38(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mahdibohloul[P]SnapTrip/./API/Result/Result.cpp
// Function: API::Result::~Result()
API::Result::~Result()
{
    comments.clear();
    hotels.clear();
    reservations.clear();
    transactions.clear();
    booked_rooms.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x88, %rdi
callq 0x55690
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x55660
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x69d80
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x6abc0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x5b430
movq -0x10(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x5ad40
movq -0x10(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x69380
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xb0050
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x5a6b0
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x54c70
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x54c20
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x554b0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x69620
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x552f0
movq -0x10(%rbp), %rdi
callq 0x6828
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./API/Result/Result.cpp
// Function: API::Result::get_booked_rooms_id[abi:cxx11]()
string API::Result::get_booked_rooms_id()
{
    ostringstream os;
    string delim;
    for(auto room : booked_rooms)
    {
        os << delim << room->get_id();
        delim = ConstNames::Space;
    }
    return os.str() + ConstNames::New_Line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x65b0
leaq -0x1a8(%rbp), %rdi
callq 0x65d0
movq -0x220(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x1b0(%rbp)
movq -0x1b0(%rbp), %rdi
callq 0x5a930
movq %rax, -0x1b8(%rbp)
movq -0x1b0(%rbp), %rdi
callq 0x5a9a0
movq %rax, -0x1c0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x5a960
testb $0x1, %al
jne 0xadc2b
jmp 0xadcf3
leaq -0x1b8(%rbp), %rdi
callq 0x5a9d0
movq (%rax), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x63d0
movq %rax, -0x238(%rbp)
jmp 0xadc5d
movq -0x1c8(%rbp), %rsi
leaq -0x1f8(%rbp), %rdi
callq 0x60f50
jmp 0xadc72
movq -0x238(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x63d0
jmp 0xadc87
leaq -0x1f8(%rbp), %rdi
callq 0x6828
leaq -0x1a8(%rbp), %rdi
movl $0x20, %esi
callq 0x66c0
jmp 0xadca6
jmp 0xadca8
leaq -0x1b8(%rbp), %rdi
callq 0xb0540
jmp 0xadc0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xadd76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x6828
jmp 0xadd76
leaq -0x218(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x6460
jmp 0xadd08
movq -0x230(%rbp), %rdi
leaq 0x6ad9a(%rip), %rdx     # 0x118ab0
leaq -0x218(%rbp), %rsi
callq 0xb0560
jmp 0xadd24
leaq -0x218(%rbp), %rdi
callq 0x6828
leaq -0x1a8(%rbp), %rdi
callq 0x6828
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x228(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6828
leaq -0x1a8(%rbp), %rdi
callq 0x6828
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x1d0(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./API/Result/Result.cpp
// Function: API::Result::get_transactions_info[abi:cxx11]()
string API::Result::get_transactions_info()
{
    ostringstream os;
    string delim;
    for(long double f : transactions)
    {
        os << delim << f;
        delim = ConstNames::New_Line;
    }
    return os.str() + ConstNames::New_Line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x218(%rbp)
movq %rdi, %rax
movq %rax, -0x210(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x65b0
leaq -0x1a8(%rbp), %rdi
callq 0x65d0
movq -0x208(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x1b0(%rbp)
movq -0x1b0(%rbp), %rdi
callq 0x69420
movq %rax, -0x1b8(%rbp)
movq -0x1b0(%rbp), %rdi
callq 0x69480
movq %rax, -0x1c0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x69450
testb $0x1, %al
jne 0xade3b
jmp 0xadec3
leaq -0x1b8(%rbp), %rdi
callq 0x694f0
fldt (%rax)
fstpt -0x1d0(%rbp)
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x63d0
movq %rax, -0x220(%rbp)
jmp 0xade6b
movq -0x220(%rbp), %rdi
fldt -0x1d0(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x6510
jmp 0xade84
leaq 0x6ac25(%rip), %rsi     # 0x118ab0
leaq -0x1a8(%rbp), %rdi
callq 0x6060
jmp 0xade99
jmp 0xade9b
leaq -0x1b8(%rbp), %rdi
callq 0xb05b0
jmp 0xade1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0xadf46
leaq -0x200(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x6460
jmp 0xaded8
movq -0x218(%rbp), %rdi
leaq 0x6abca(%rip), %rdx     # 0x118ab0
leaq -0x200(%rbp), %rsi
callq 0xb0560
jmp 0xadef4
leaq -0x200(%rbp), %rdi
callq 0x6828
leaq -0x1a8(%rbp), %rdi
callq 0x6828
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x210(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x6828
leaq -0x1a8(%rbp), %rdi
callq 0x6828
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x1d8(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./API/Result/Result.cpp
// Function: API::Result::get_hotels_info[abi:cxx11]()
string API::Result::get_hotels_info()
{
    ostringstream os;
    string delim;
    os << get_extra_info();
    for(auto hotel : hotels)
    {
        os << delim << hotel->to_string() << ConstNames::Space;
        delim = ConstNames::New_Line;
    }
    return os.str() + ConstNames::New_Line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x250(%rbp)
movq %rdi, %rax
movq %rax, -0x248(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x65b0
leaq -0x1a8(%rbp), %rdi
callq 0x65d0
movq -0x240(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0xaefd0
jmp 0xaedac
leaq -0x188(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x63d0
jmp 0xaedc1
leaq -0x1c8(%rbp), %rdi
callq 0x6828
movq -0x240(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x1e0(%rbp)
movq -0x1e0(%rbp), %rdi
callq 0x54ff0
movq %rax, -0x1e8(%rbp)
movq -0x1e0(%rbp), %rdi
callq 0x55050
movq %rax, -0x1f0(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x55020
testb $0x1, %al
jne 0xaee21
jmp 0xaef28
leaq -0x1e8(%rbp), %rdi
callq 0x55110
movq (%rax), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x63d0
movq %rax, -0x258(%rbp)
jmp 0xaee53
movq -0x1f8(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x589e0
jmp 0xaee68
movq -0x258(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x63d0
movq %rax, -0x260(%rbp)
jmp 0xaee84
movq -0x260(%rbp), %rdi
movl $0x20, %esi
callq 0x6520
jmp 0xaee97
leaq -0x218(%rbp), %rdi
callq 0x6828
leaq 0x69c06(%rip), %rsi     # 0x118ab0
leaq -0x1a8(%rbp), %rdi
callq 0x6060
jmp 0xaeeb8
jmp 0xaeeba
leaq -0x1e8(%rbp), %rdi
callq 0x709c0
jmp 0xaee05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xaefab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6828
jmp 0xaefab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6828
jmp 0xaefab
leaq -0x238(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x6460
jmp 0xaef3d
movq -0x250(%rbp), %rdi
leaq 0x69b65(%rip), %rdx     # 0x118ab0
leaq -0x238(%rbp), %rsi
callq 0xb0560
jmp 0xaef59
leaq -0x238(%rbp), %rdi
callq 0x6828
leaq -0x1a8(%rbp), %rdi
callq 0x6828
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x248(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x6828
leaq -0x1a8(%rbp), %rdi
callq 0x6828
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x1d0(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./API/Result/Result.cpp
// Function: API::Result::get_extra_info[abi:cxx11]()
string API::Result::get_extra_info()
{
    ostringstream os;
    auto backend = Backend::get_instance();
    auto user = backend->get_curr_user();
    if(user->the_default_filter_applied())
        os << ConstNames::Default_Filter_msg << endl;
    return os.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x65b0
callq 0x76e70
movq %rax, -0x1b0(%rbp)
jmp 0xaf00e
movq -0x1b0(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rdi
callq 0x80470
movq %rax, -0x1c8(%rbp)
jmp 0xaf031
movq -0x1c8(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rdi
callq 0x68100
movb %al, -0x1c9(%rbp)
jmp 0xaf053
movb -0x1c9(%rbp), %al
testb $0x1, %al
jne 0xaf05f
jmp 0xaf0b2
leaq 0x69d0a(%rip), %rsi     # 0x118d70
leaq -0x188(%rbp), %rdi
callq 0x63d0
movq %rax, -0x1d8(%rbp)
jmp 0xaf07b
movq -0x1d8(%rbp), %rdi
movq 0x58ee7(%rip), %rsi     # 0x107f70
callq 0x6490
jmp 0xaf090
jmp 0xaf0b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x60f0
jmp 0xaf0e3
movq -0x1c0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x6460
jmp 0xaf0c7
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x1b8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Models/Filters/DefaultAvgPriceFilter.cpp
// Function: DefaultAvgPriceFilter::calculate_average(std::__cxx11::list<Database::User::ReserveCase*, std::allocator<Database::User::ReserveCase*>> const&)
long double DefaultAvgPriceFilter::calculate_average(const Database::User::l_booked& booked_rooms)
{
    long double cost = 0.0f;
    int quantity = 0;
    for(auto reserve : booked_rooms)
    {
        cost += reserve->get_cost_of_reserves() / reserve->get_residency_period();
        quantity += reserve->get_quantity_of_reserves();
    }
    if(quantity == 0)
        return 0.0f;
    return cost / quantity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
fldz
fstpt -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x57600
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x57630
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x57700
testb $0x1, %al
jne 0xb36b1
jmp 0xb3703
leaq -0x48(%rbp), %rdi
callq 0x57770
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x64110
fstpt -0x6c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x641c0
fldt -0x6c(%rbp)
movl %eax, -0x60(%rbp)
fildl -0x60(%rbp)
fdivrp %st, %st(1)
fldt -0x30(%rbp)
faddp %st, %st(1)
fstpt -0x30(%rbp)
movq -0x58(%rbp), %rdi
callq 0x640f0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x577a0
jmp 0xb369e
cmpl $0x0, -0x34(%rbp)
jne 0xb3710
fldz
fstpt -0x10(%rbp)
jmp 0xb3721
fldt -0x30(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
fildl -0x5c(%rbp)
fdivrp %st, %st(1)
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Filters/DefaultAvgPriceFilter.cpp
// Function: DefaultAvgPriceFilter::calculate_average_deviation(std::__cxx11::list<Database::User::ReserveCase*, std::allocator<Database::User::ReserveCase*>> const&)
long double DefaultAvgPriceFilter::calculate_average_deviation(const Database::User::l_booked& booked_rooms)
{
    long double deviation = 0.0f, sum = 0.0f;
    int quantity = 0;
    for(auto reserve : booked_rooms)
    {
        sum += (pow(((reserve->get_cost_of_reserves() / reserve->get_residency_period()) / reserve->get_quantity_of_reserves()) - average, 2))* reserve->get_quantity_of_reserves();
        quantity += reserve->get_quantity_of_reserves();
    }
    if(quantity == 1)
        return 0.0f;
    deviation = sum / (quantity - 1);
    return sqrt(deviation);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
fldz
fld %st(0)
fstpt -0x30(%rbp)
fstpt -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x57600
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x57630
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57700
testb $0x1, %al
jne 0xb3794
jmp 0xb3845
leaq -0x58(%rbp), %rdi
callq 0x57770
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x64110
fstpt -0xa4(%rbp)
movq -0x68(%rbp), %rdi
callq 0x641c0
fldt -0xa4(%rbp)
movl %eax, -0x78(%rbp)
fildl -0x78(%rbp)
fdivrp %st, %st(1)
fstpt -0x98(%rbp)
movq -0x68(%rbp), %rdi
callq 0x640f0
fldt -0x98(%rbp)
movl %eax, %ecx
movq -0x80(%rbp), %rax
movl %ecx, -0x74(%rbp)
fildl -0x74(%rbp)
fdivrp %st, %st(1)
fldt 0x40(%rax)
fsubrp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
movl $0x2, %edi
callq 0xb3a10
fstpt -0x8c(%rbp)
movq -0x68(%rbp), %rdi
callq 0x640f0
fldt -0x8c(%rbp)
movl %eax, -0x70(%rbp)
fildl -0x70(%rbp)
fldt -0x40(%rbp)
fxch %st(2)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt -0x40(%rbp)
movq -0x68(%rbp), %rdi
callq 0x640f0
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x577a0
jmp 0xb377e
cmpl $0x1, -0x44(%rbp)
jne 0xb3852
fldz
fstpt -0x10(%rbp)
jmp 0xb3875
fldt -0x40(%rbp)
movl -0x44(%rbp), %eax
decl %eax
movl %eax, -0x6c(%rbp)
fildl -0x6c(%rbp)
fdivrp %st, %st(1)
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0xb3a50
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Filters/DefaultAvgPriceFilter.cpp
// Function: DefaultAvgPriceFilter::filter(std::__cxx11::list<Database::Hotel*, std::allocator<Database::Hotel*>>&)
void DefaultAvgPriceFilter::filter(Database::l_hotels& hotels)
{
    if(activity != ConstNames::Active_Mode)
        this->hotels = hotels;
    else
    {
        for(auto hotel : hotels)
        {
            if(in_range(hotel->get_avg_price()))
                this->hotels.push_back(hotel);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xb391b
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x71ae0
jmp 0xb399d
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x54ff0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x55050
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x55020
testb $0x1, %al
jne 0xb3950
jmp 0xb399b
leaq -0x20(%rbp), %rdi
callq 0x55110
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x58c10
movq -0x38(%rbp), %rdi
movq %rsp, %rax
fstpt (%rax)
callq 0xb39b0
testb $0x1, %al
jne 0xb397d
jmp 0xb398e
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x54ca0
jmp 0xb3990
leaq -0x20(%rbp), %rdi
callq 0x709c0
jmp 0xb393d
jmp 0xb399d
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Models/Filters/DefaultAvgPriceFilter.cpp
// Function: DefaultAvgPriceFilter::in_range(long double)
bool DefaultAvgPriceFilter::in_range(long double hotel_avg_price)
{
    long double abs_val = abs(hotel_avg_price - average);
    if(abs_val <= (ConstNames::Default_Filter_Coefficient * average_deviation))
        return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
fldt 0x10(%rbp)
movq %rdi, -0x10(%rbp)
fstpt -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
fldt -0x20(%rbp)
fldt 0x40(%rax)
fsubrp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0xb3a80
movq -0x38(%rbp), %rax
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
fldt 0x30(%rax)
fadd %st, %st(0)
fucompi %st(1), %st
fstp %st(0)
jb 0xb39f9
jmp 0xb39f3
movb $0x1, -0x1(%rbp)
jmp 0xb39fd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/AI/AI.cpp
// Function: Backend::AI::get_calculated_weights(std::vector<Database::Hotel::Rating*, std::allocator<Database::Hotel::Rating*>>)
Database::User::Weights Backend::AI::get_calculated_weights(Database::Hotel::v_rating ratings)
{
    auto weights_struct = Database::User::Weights();
    auto weights = generate_random_weights();
    weights = calculate_weights(weights, ratings);
    weights_struct.initialize_weights(weights);
    return weights_struct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdx, -0x148(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x57fb0
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rsi
xorl %edx, %edx
callq 0x690f0
jmp 0xb3b78
leaq -0xb0(%rbp), %rdi
callq 0x5a6b0
movq -0x138(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0xb3d30
jmp 0xb3b99
movq -0x148(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x813c0
jmp 0xb3bae
movq -0x138(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
leaq -0xd8(%rbp), %rdx
leaq -0x108(%rbp), %rcx
callq 0xb3de0
jmp 0xb3bd1
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x150(%rbp)
leaq -0xf0(%rbp), %rsi
movq %rsi, -0x158(%rbp)
callq 0xb4540
movq -0x158(%rbp), %rdi
callq 0x5ad40
leaq -0x108(%rbp), %rdi
callq 0x69f20
movq -0x150(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x761c0
jmp 0xb3c1f
movq -0x130(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x66380
jmp 0xb3c34
leaq -0x120(%rbp), %rdi
callq 0x5ad40
movb $0x1, -0x19(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x5ad40
testb $0x1, -0x19(%rbp)
jne 0xb3d02
jmp 0xb3cf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x5a6b0
jmp 0xb3d1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xb3d12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xb3ce8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x69f20
jmp 0xb3ce8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x5ad40
leaq -0xd8(%rbp), %rdi
callq 0x5ad40
jmp 0xb3d12
movq -0x130(%rbp), %rdi
callq 0x69380
movq -0x140(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x130(%rbp), %rdi
callq 0x69380
movq -0xb8(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/AI/AI.cpp
// Function: Backend::AI::generate_random_weights()
v_double Backend::AI::generate_random_weights()
{
    v_double random_number;
    for(int i = ConstNames::Minimum_Weights_Number; i <= ConstNames::Maximum_Weights_Number; i++)
        random_number.push_back(ConstNames::Minimum_Weights_Number + static_cast<long double>(rand() / static_cast<long double>(RAND_MAX / (ConstNames::Maximum_Weights_Number - ConstNames::Minimum_Weights_Number))));
    return random_number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x815c0
movl $0x1, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jg 0xb3dae
callq 0x6110
movq -0x50(%rbp), %rdi
movl %eax, -0x40(%rbp)
fildl -0x40(%rbp)
fldl 0x2712(%rip)            # 0xb6488
fdivrp %st, %st(1)
fld1
faddp %st, %st(1)
fstpt -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x815e0
jmp 0xb3d8a
jmp 0xb3d8c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb3d5b
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x5ad40
jmp 0xb3dcb
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb3dc1
movq -0x50(%rbp), %rdi
callq 0x5ad40
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/AI/AI.cpp
// Function: Backend::AI::calculate_weights(std::vector<long double, std::allocator<long double>>&, std::vector<Database::Hotel::Rating*, std::allocator<Database::Hotel::Rating*>>)
v_double Backend::AI::calculate_weights(v_double& weights, Database::Hotel::v_rating ratings)
{
    for(int iteration = 0; iteration < ConstNames::Iterations_Number; iteration++)
    {
        auto dirivatives = v_double(ConstNames::Maximum_Weights_Number, ConstNames::Minimum_Dirivative_Amount);
        auto rating_itr = ratings.begin();
        while(rating_itr != ratings.end()){
            dirivatives = calculate_dirivatives(weights, rating_itr, dirivatives);
            rating_itr++;
        }
        weights = add_to_weights(weights, dirivatives);
        clamp(weights);
    }
    return weights;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rcx, -0xe0(%rbp)
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3e8, -0x24(%rbp)     # imm = 0x3E8
jge 0xb3fd2
leaq -0x41(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x5aba0
movq -0xe8(%rbp), %rcx
leaq 0x2650(%rip), %rdx      # 0xb64a0
leaq -0x40(%rbp), %rdi
movl $0x5, %esi
callq 0xb4570
jmp 0xb3e60
leaq -0x41(%rbp), %rdi
callq 0x5ac40
movq -0xe0(%rbp), %rdi
callq 0x71400
movq %rax, -0x60(%rbp)
movq -0xe0(%rbp), %rdi
callq 0x71290
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb45f0
testb $0x1, %al
jne 0xb3e9f
jmp 0xb3f5e
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x761c0
jmp 0xb3eb1
movq -0xc8(%rbp), %rsi
movq -0x60(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rcx
leaq -0x80(%rbp), %rdi
leaq -0x98(%rbp), %rdx
leaq -0x40(%rbp), %r8
callq 0xb4000
jmp 0xb3ee0
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xb4540
leaq -0x80(%rbp), %rdi
callq 0x5ad40
leaq -0x98(%rbp), %rdi
callq 0x5ad40
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0xb4630
movq %rax, -0xa8(%rbp)
jmp 0xb3e79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x5ac40
jmp 0xb3ff2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xb3fc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x5ad40
jmp 0xb3fc7
movq -0xc8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rcx
callq 0xb40f0
jmp 0xb3f7b
movq -0x18(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movq %rsi, -0xf0(%rbp)
callq 0xb4540
movq -0xf0(%rbp), %rdi
callq 0x5ad40
movq -0xc8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb41a0
jmp 0xb3fb0
leaq -0x40(%rbp), %rdi
callq 0x5ad40
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb3e25
leaq -0x40(%rbp), %rdi
callq 0x5ad40
jmp 0xb3ff2
movq -0xd8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x761c0
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/AI/AI.cpp
// Function: Backend::AI::clamp(std::vector<long double, std::allocator<long double>>&)
void Backend::AI::clamp(v_double& numbers)
{
    for(long double& f : numbers)
    {
        if(f < ConstNames::Minimum_Weights_Number)
            f = ConstNames::Minimum_Weights_Number;
        else if(f > ConstNames::Maximum_Weights_Number)
            f = ConstNames::Maximum_Weights_Number;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5ac60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5ac90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5acc0
testb $0x1, %al
jne 0xb41e5
jmp 0xb423d
leaq -0x20(%rbp), %rdi
callq 0x5ad00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
fldt (%rax)
fld1
fucompi %st(1), %st
fstp %st(0)
jbe 0xb420c
jmp 0xb4202
movq -0x30(%rbp), %rax
fld1
fstpt (%rax)
jmp 0xb4230
movq -0x30(%rbp), %rax
fldt (%rax)
flds 0x12c4(%rip)            # 0xb54dc
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0xb422e
jmp 0xb4222
movq -0x30(%rbp), %rax
flds 0x12b0(%rip)            # 0xb54dc
fstpt (%rax)
jmp 0xb4230
jmp 0xb4232
leaq -0x20(%rbp), %rdi
callq 0x5ad20
jmp 0xb41d2
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mahdibohloul[P]SnapTrip/./Business-Logic/AI/AI.cpp
// Function: Backend::AI::calculate_dirivative(std::vector<long double, std::allocator<long double>>, __gnu_cxx::__normal_iterator<Database::Hotel::Rating**, std::vector<Database::Hotel::Rating*, std::allocator<Database::Hotel::Rating*>>>, int)
long double Backend::AI::calculate_dirivative(v_double weights, Database::Hotel::v_rating::iterator rating_itr, int which_weight)
{
    long double dirivative = error_func(weights, rating_itr);
    weights[which_weight] += ConstNames::Epsilon;
    dirivative = error_func(weights, rating_itr) - dirivative;
    return dirivative / ConstNames::Epsilon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x761c0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
callq 0xb4380
fstpt -0x8c(%rbp)
jmp 0xb42b3
leaq -0x48(%rbp), %rdi
callq 0x5ad40
fldt -0x8c(%rbp)
movq -0xa8(%rbp), %rdi
fstpt -0x30(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x68ff0
movq -0xa8(%rbp), %rsi
fldt (%rax)
fldl 0x21ac(%rip)            # 0xb6490
faddp %st, %st(1)
fstpt (%rax)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x761c0
movq -0xa0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdx
callq 0xb4380
fstpt -0xb4(%rbp)
jmp 0xb431f
fldt -0xb4(%rbp)
fldt -0x30(%rbp)
fsubrp %st, %st(1)
fstpt -0x30(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5ad40
fldt -0x30(%rbp)
fldl 0x2151(%rip)            # 0xb6490
fdivrp %st, %st(1)
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5ad40
jmp 0xb4376
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5ad40
movq -0x58(%rbp), %rdi
callq 0x6750
nop
// File: mahdibohloul[P]SnapTrip/./Business-Logic/AI/AI.cpp
// Function: Backend::AI::check_error_funcs(std::vector<long double, std::allocator<long double>>, std::vector<Database::Hotel::Rating*, std::allocator<Database::Hotel::Rating*>>)
bool Backend::AI::check_error_funcs(v_double weights, Database::Hotel::v_rating ratings)
{
    auto rating_itr = ratings.begin();
    while(rating_itr != ratings.end())
    {
        if(error_func(weights, rating_itr) > ConstNames::Epsilon)
            return false;
        rating_itr++;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x71400
movq %rax, -0x28(%rbp)
movq -0x78(%rbp), %rdi
callq 0x71290
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb45f0
testb $0x1, %al
jne 0xb4494
jmp 0xb451c
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x761c0
movq -0x70(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
callq 0xb4380
fstpt -0x94(%rbp)
jmp 0xb44cc
leaq -0x48(%rbp), %rdi
callq 0x5ad40
fldt -0x94(%rbp)
fldl 0x1faf(%rip)            # 0xb6490
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0xb4508
jmp 0xb44eb
movb $0x0, -0x1(%rbp)
jmp 0xb4520
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5ad40
jmp 0xb452e
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xb4630
movq %rax, -0x68(%rbp)
jmp 0xb4471
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: number_to_hex
const char* number_to_hex(int32_t x) {
    thread_local static char out[STRING_LEN] = {"0x"};
    uint256_t result(x);
    string str_result = result.str(32, std::ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x4(%rbp), %rsi
callq 0x61d80
movq -0xa8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x20, %edx
movl $0x8, %ecx
callq 0x61dc0
movq -0xa0(%rbp), %rdi
callq 0x10590
movq -0xa0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x103b0
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x10590
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq 0x10f6a6(%rip), %rcx    # 0x13ffc0
callq 0x61e00
movq %rax, -0x98(%rbp)
jmp 0x30928
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %fs:0x0, %rax
leaq -0x690(%rax), %rax
addq $0x2, %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x102c0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq %fs:0x0, %rax
leaq -0x690(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x10d98
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x10d98
movq -0x80(%rbp), %rdi
callq 0x10bc0
nopw (%rax,%rax)
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: add_set
const char* add_set(const char *x, const char *y) {
    string y_str(y);
    set<string> strs = from_chars(x);
    if (strs.find(y_str) != strs.end()) return x;
    strs.insert(y_str);
    string joinedString = boost::algorithm::join(strs, "|");
    char* out = new char[joinedString.length() + 1];
    strcpy(out, joinedString.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x10be0
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x51050
jmp 0x30c87
leaq -0x39(%rbp), %rdi
callq 0x10740
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x30a70
jmp 0x30c9f
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x62090
movq %rax, -0xe8(%rbp)
jmp 0x30cb5
movq -0xe8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5ebc0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x62060
testb $0x1, %al
jne 0x30cec
jmp 0x30d3f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0x30e22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x10740
jmp 0x30e53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x30e4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x30e41
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5e230
movb %dl, -0xf1(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0x30d5b
movb -0xf1(%rbp), %al
movq -0xf0(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movb %al, -0xa0(%rbp)
leaq 0xadf8a(%rip), %rdx     # 0xded06
leaq -0xc8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x620d0
jmp 0x30d8e
leaq -0xc8(%rbp), %rdi
callq 0x10a50
movq %rax, %rdi
incq %rdi
callq 0x10040
movq %rax, -0x100(%rbp)
jmp 0x30dae
movq -0x100(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x102c0
movq -0x108(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq -0xd0(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x10d98
jmp 0x30e22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x10d98
jmp 0x30e41
leaq -0x80(%rbp), %rdi
callq 0x5e2f0
leaq -0x38(%rbp), %rdi
callq 0x10d98
movq -0x8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x5e2f0
leaq -0x38(%rbp), %rdi
callq 0x10d98
movq -0x48(%rbp), %rdi
callq 0x10bc0
nopl (%rax)
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: add_256
const char* add_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = my_x + my_y;
    string str_result = result.str(32, std::ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x120(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x61e80
movq -0x120(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x61e80
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x62270
movq -0x108(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movl $0x20, %edx
movl $0x8, %ecx
callq 0x61dc0
movq -0x100(%rbp), %rdi
callq 0x10590
movq -0x100(%rbp), %rdi
movq %rax, -0xc8(%rbp)
callq 0x103b0
movq -0x100(%rbp), %rdi
movq %rax, -0xd0(%rbp)
callq 0x10590
movq %rax, -0xd8(%rbp)
movq -0xc8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movq 0x10f079(%rip), %rcx    # 0x13ffc0
callq 0x61e00
movq %rax, -0xf8(%rbp)
jmp 0x30f55
movq -0xf8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq %fs:0x0, %rax
leaq -0x640(%rax), %rax
addq $0x2, %rax
movq %rax, -0x130(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x102c0
movq -0x130(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq %fs:0x0, %rax
leaq -0x640(%rax), %rax
movq %rax, -0x128(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x10d98
movq -0x128(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x10d98
movq -0xe0(%rbp), %rdi
callq 0x10bc0
nopw %cs:(%rax,%rax)
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: sub_256
const char* sub_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = my_x - my_y;
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x120(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x61e80
movq -0x120(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x61e80
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x622f0
movq -0x108(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movl $0x20, %edx
movl $0x8, %ecx
callq 0x61dc0
movq -0x100(%rbp), %rdi
callq 0x10590
movq -0x100(%rbp), %rdi
movq %rax, -0xc8(%rbp)
callq 0x103b0
movq -0x100(%rbp), %rdi
movq %rax, -0xd0(%rbp)
callq 0x10590
movq %rax, -0xd8(%rbp)
movq -0xc8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movq 0x10eed9(%rip), %rcx    # 0x13ffc0
callq 0x61e00
movq %rax, -0xf8(%rbp)
jmp 0x310f5
movq -0xf8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq %fs:0x0, %rax
leaq -0x5f0(%rax), %rax
addq $0x2, %rax
movq %rax, -0x130(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x102c0
movq -0x130(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq %fs:0x0, %rax
leaq -0x5f0(%rax), %rax
movq %rax, -0x128(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x10d98
movq -0x128(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x10d98
movq -0xe0(%rbp), %rdi
callq 0x10bc0
nopw %cs:(%rax,%rax)
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: eq_256
const char* eq_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = my_x == my_y;
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x118(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x61e80
movq -0x118(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x120(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x61e80
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x626e0
movq -0x118(%rbp), %rdx
movb %al, -0xa1(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0xa1(%rbp), %rsi
callq 0x626a0
movq -0x110(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x108(%rbp)
movl $0x20, %edx
movl $0x8, %ecx
callq 0x61dc0
movq -0x108(%rbp), %rdi
callq 0x10590
movq -0x108(%rbp), %rdi
movq %rax, -0xd0(%rbp)
callq 0x103b0
movq -0x108(%rbp), %rdi
movq %rax, -0xd8(%rbp)
callq 0x10590
movq %rax, -0xe0(%rbp)
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
movq 0x10e1b0(%rip), %rcx    # 0x13ffc0
callq 0x61e00
movq %rax, -0x100(%rbp)
jmp 0x31e1e
movq -0x100(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq %fs:0x0, %rax
leaq -0x370(%rax), %rax
addq $0x2, %rax
movq %rax, -0x138(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x102c0
movq -0x138(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq %fs:0x0, %rax
leaq -0x370(%rax), %rax
movq %rax, -0x130(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x10d98
movq -0x130(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x10d98
movq -0xe8(%rbp), %rdi
callq 0x10bc0
nop
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: exp_256
const char* exp_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = powm(my_x, my_y, numeric_limits<uint256_t>::max());
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x158(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x150(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x61e80
movq -0x158(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x148(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x61e80
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x62800
movq -0x150(%rbp), %rsi
movq -0x148(%rbp), %rdx
movq -0x140(%rbp), %rcx
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x627a0
movq -0x138(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
movl $0x20, %edx
movl $0x8, %ecx
callq 0x61dc0
movq -0x130(%rbp), %rdi
callq 0x10590
movq -0x130(%rbp), %rdi
movq %rax, -0xf8(%rbp)
callq 0x103b0
movq -0x130(%rbp), %rdi
movq %rax, -0x100(%rbp)
callq 0x10590
movq %rax, -0x108(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0x108(%rbp), %rdx
movq 0x10de4f(%rip), %rcx    # 0x13ffc0
callq 0x61e00
movq %rax, -0x128(%rbp)
jmp 0x3217f
movq -0x128(%rbp), %rax
movq %rax, -0x120(%rbp)
movq %fs:0x0, %rax
leaq -0x2d0(%rax), %rax
addq $0x2, %rax
movq %rax, -0x168(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x102c0
movq -0x168(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq %fs:0x0, %rax
leaq -0x2d0(%rax), %rax
movq %rax, -0x160(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x10d98
movq -0x160(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x10d98
movq -0x110(%rbp), %rdi
callq 0x10bc0
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: smod_256
const char* smod_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    int256_t my_x(x);
    int256_t my_y(y);
    int256_t result = my_x % my_y;
    uint256_t unsigned_result(result);
    string str_result = unsigned_result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x140(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x158(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x62850
movq -0x140(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x150(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x62850
movq -0x158(%rbp), %rsi
movq -0x150(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x62890
movq -0x148(%rbp), %rsi
movq -0x140(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x62910
movq -0x138(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
movl $0x20, %edx
movl $0x8, %ecx
callq 0x61dc0
movq -0x130(%rbp), %rdi
callq 0x10590
movq -0x130(%rbp), %rdi
movq %rax, -0xf8(%rbp)
callq 0x103b0
movq -0x130(%rbp), %rdi
movq %rax, -0x100(%rbp)
callq 0x10590
movq %rax, -0x108(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0x108(%rbp), %rdx
movq 0x10dc98(%rip), %rcx    # 0x13ffc0
callq 0x61e00
movq %rax, -0x128(%rbp)
jmp 0x32336
movq -0x128(%rbp), %rax
movq %rax, -0x120(%rbp)
movq %fs:0x0, %rax
leaq -0x280(%rax), %rax
addq $0x2, %rax
movq %rax, -0x168(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x102c0
movq -0x168(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq %fs:0x0, %rax
leaq -0x280(%rax), %rax
movq %rax, -0x160(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x10d98
movq -0x160(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x10d98
movq -0x110(%rbp), %rdi
callq 0x10bc0
nopw (%rax,%rax)
// File: yanniss[P]souffle-num-addon/./num256.cpp
// Function: shl_256
const char* shl_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(y);
    long my_y = strtol(x, NULL, 16);
    uint256_t result = my_x << my_y;
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xf8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x61e80
movq -0xf8(%rbp), %rsi
movq -0x8(%rbp), %rdi
movl $0x10, %edx
callq 0x109b0
movq -0xf0(%rbp), %rsi
movq %rax, -0x48(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
leaq -0x48(%rbp), %rdx
callq 0x62ad0
movq -0xe8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movl $0x20, %edx
movl $0x8, %ecx
callq 0x61dc0
movq -0xe0(%rbp), %rdi
callq 0x10590
movq -0xe0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x103b0
movq -0xe0(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x10590
movq %rax, -0xb8(%rbp)
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq 0x10d5a1(%rip), %rcx    # 0x13ffc0
callq 0x61e00
movq %rax, -0xd8(%rbp)
jmp 0x32a2d
movq -0xd8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq %fs:0x0, %rax
leaq -0x140(%rax), %rax
addq $0x2, %rax
movq %rax, -0x108(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x102c0
movq -0x108(%rbp), %rdi
movq %rax, %rsi
callq 0x10610
movq %fs:0x0, %rax
leaq -0x140(%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x10d98
movq -0x100(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x10d98
movq -0xc0(%rbp), %rdi
callq 0x10bc0
nop