LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_customer_db()
void TaxiAgency::print_customer_db(){
    cout << rang::fg::blue << "Customers List:" << rang::fg::reset << endl;
    cout << "[" << endl;
    for(auto customer: customer_db){
        customer.print();
    };
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0xf8c1(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
movl $0x22, %esi
callq 0xf2c6
movq %rax, %r15
leaq 0x8252(%rip), %rsi      # 0x1b920
movl $0xf, %edx
movq %rax, %rdi
callq 0x4320
movq %r15, %rdi
movl $0x27, %esi
callq 0xf2c6
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
leaq 0x6d41(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq 0x30(%r14), %rbx
movq 0x38(%r14), %r14
cmpq %r14, %rbx
je 0x13808
leaq -0x60(%rbp), %r15
leaq -0x40(%rbp), %r13
leaq -0x90(%rbp), %r12
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xf530
movq %r15, -0x70(%rbp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0xf530
movq %r13, -0x50(%rbp)
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0xf530
movq 0x60(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
callq 0x10468
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x137d8
callq 0x4280
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x137e6
callq 0x4280
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x137fb
callq 0x4280
addq $0x68, %rbx
cmpq %r14, %rbx
jne 0x1376d
leaq 0x7fbd(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq 0xf75d(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1386f
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x1386f
callq 0x4280
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x13895
callq 0x4280
jmp 0x13895
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x101b8
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::delete_customer_user_by_uuid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TaxiAgency::delete_customer_user_by_uuid(string uuid){
    IndexInstance<Customer> customer = search_customer_by_uuid(uuid);
    if(customer.data->getStatus() == ONSHIFT)
        throw invalid_argument("Can't delete a customer while its ONSHIFT");
    customer_db.erase(customer_db.begin() + customer.index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xf530
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1389e
movl %eax, %r14d
movq %rdx, %r15
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13e97
callq 0x4280
movq %r15, %rdi
callq 0x1049a
testl %eax, %eax
je 0x13ec7
movl %r14d, %eax
imulq $0x68, %rax, %rsi
addq 0x30(%rbx), %rsi
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x18ee8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x7ac0(%rip), %rsi      # 0x1b99b
movq %rax, %rdi
callq 0x44d0
movq 0xf0ce(%rip), %rsi      # 0x22fb8
movq 0xf0a7(%rip), %rdx      # 0x22f98
movq %r14, %rdi
callq 0x4440
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x13f17
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13f17
callq 0x4280
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_drivers_db()
void TaxiAgency::print_drivers_db(){
    cout << rang::fg::blue << "Drivers List:" << rang::fg::reset << endl;
    cout << "[" << endl;
    for(auto driver: driver_db){
        driver.print();
    };
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movq 0xe5bc(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
movl $0x22, %esi
callq 0xf2c6
movq %rax, %r15
leaq 0x702c(%rip), %rsi      # 0x1b9ff
movl $0xd, %edx
movq %rax, %rdi
callq 0x4320
movq %r15, %rdi
movl $0x27, %esi
callq 0xf2c6
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
leaq 0x5a3c(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq 0x18(%r14), %r15
movq 0x20(%r14), %r12
cmpq %r12, %r15
je 0x14ad6
leaq -0x80(%rbp), %r13
leaq -0xa0(%rbp), %rbx
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x17a30
movq %r14, %rdi
callq 0x10146
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x14a96
callq 0x4280
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x14aa8
callq 0x4280
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0x14ab9
callq 0x4280
movq -0xb0(%rbp), %rdi
cmpq %rbx, %rdi
je 0x14aca
callq 0x4280
addq $0x88, %r15
cmpq %r12, %r15
jne 0x14a71
leaq 0x6cef(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq 0xe48f(%rip), %rbx      # 0x22f78
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x17998
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::delete_driver_user_by_uuid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TaxiAgency::delete_driver_user_by_uuid(string uuid){
    IndexInstance<Driver> driver = search_driver_by_uuid(uuid);
    if(driver.data->getStatus() == ONSHIFT)
        throw invalid_argument("Can't delete a driver while its ONSHIFT");
    driver_db.erase(driver_db.begin() + driver.index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xf530
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14b42
movl %eax, %r14d
movq %rdx, %r15
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x15219
callq 0x4280
movq %r15, %rdi
callq 0x101ac
testl %eax, %eax
je 0x15250
movl %r14d, %eax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rsi
addq 0x18(%rbx), %rsi
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x19292
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x67ef(%rip), %rsi      # 0x1ba53
movq %rax, %rdi
callq 0x44d0
movq 0xdd45(%rip), %rsi      # 0x22fb8
movq 0xdd1e(%rip), %rdx      # 0x22f98
movq %r14, %rdi
callq 0x4440
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x152a0
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x152a0
callq 0x4280
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::retrieve_shift_details_by_customer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Shift TaxiAgency::retrieve_shift_details_by_customer(string customer_uuid){
    for(list<Shift>::iterator i = current_shifts.begin(); i != current_shifts.end(); ++i)
        if(i->getCustomerUUID() == customer_uuid)
            return *i;
    throw ("Customer with the supplied UUID is IDLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq 0x48(%rsi), %r13
addq $0x48, %r15
cmpq %r15, %r13
sete %bl
je 0x17062
movq %rdx, %r14
leaq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x10b40
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x17056
testq %rdx, %rdx
je 0x17087
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42e0
testl %eax, %eax
je 0x17087
movq (%r13), %r13
cmpq %r15, %r13
sete %bl
jne 0x1702c
movl $0x8, %edi
callq 0x4170
leaq 0x4b6f(%rip), %rcx      # 0x1bbe2
movq %rcx, (%rax)
movq 0xbecb(%rip), %rsi      # 0x22f48
movq %rax, %rdi
xorl %edx, %edx
callq 0x4440
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x17dd4
testb $0x1, %bl
jne 0x17062
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::end_shift(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TaxiAgency::end_shift(string customer_uuid){
    for(list<Shift>::iterator i = current_shifts.begin(); i != current_shifts.end(); ++i)
        if(i->getCustomerUUID() == customer_uuid){
            IndexInstance<Taxi> taxi = retrieve_taxi_by_id(i->getCarID());
            int total_cost = i->getRunningKms()*taxi.data->fare_amount + i->getWaitingHours()*WaitingCharges;
            shift_history.push_back(*i);
            current_shifts.erase(i);
            search_customer_by_uuid(customer_uuid).data->makeTransaction(total_cost);
            return;
        }
    throw invalid_argument("Customer with the supplied UUID is IDLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x48(%rdi), %r15
movq %rdi, -0x38(%rbp)
movq 0x48(%rdi), %r12
cmpq %r15, %r12
sete %bl
je 0x1710b
movq %rsi, %r14
leaq 0x10(%r12), %r13
movq %r13, %rdi
callq 0x10b40
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x170ff
testq %rdx, %rdx
je 0x1713d
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42e0
testl %eax, %eax
je 0x1713d
movq (%r12), %r12
cmpq %r15, %r12
sete %bl
jne 0x170d4
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x4ac3(%rip), %rsi      # 0x1bbe2
movq %rax, %rdi
callq 0x44d0
movq 0xbe8a(%rip), %rsi      # 0x22fb8
movq 0xbe63(%rip), %rdx      # 0x22f98
movq %r14, %rdi
callq 0x4440
movq %r13, %rdi
callq 0x10b4a
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0xf530
movq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x12838
movq %rdx, -0x30(%rbp)
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x17183
callq 0x4280
movq %r13, %rdi
callq 0x10b68
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x48(%rbp)
movq %r13, %rdi
callq 0x10bf6
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
movl 0x88(%rcx), %eax
movl %eax, -0x40(%rbp)
leaq 0x60(%rcx), %rdi
movq %rdi, -0x30(%rbp)
movq %r13, %rsi
callq 0x1936a
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x4070
movq -0x38(%rbp), %r13
incq 0x70(%r13)
movq %r15, %rdi
movq %r12, %rsi
callq 0x193a8
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0xf530
movq %r13, %rdi
movq %r14, %rsi
callq 0x1389e
movl -0x48(%rbp), %eax
imull -0x44(%rbp), %eax
movl -0x40(%rbp), %esi
imull -0x3c(%rbp), %esi
addl %eax, %esi
movq %rdx, %rdi
callq 0x104ae
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x17238
callq 0x4280
testb $0x1, %bl
jne 0x1710b
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
jne 0x17271
jmp 0x17283
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x17283
callq 0x4280
jmp 0x17283
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_ongoing_shifts()
void TaxiAgency::print_ongoing_shifts(){
    cout << "[" << endl;
    for (list<Shift>::iterator i = current_shifts.begin(); i != current_shifts.end(); ++i)
        cout << *i;
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xbcd7(%rip), %rbx      # 0x22f78
leaq 0x31b2(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq 0x48(%r14), %r12
addq $0x48, %r14
cmpq %r14, %r12
je 0x17306
movq 0xbc88(%rip), %r15      # 0x22f78
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x109fd
movq (%r12), %r12
cmpq %r14, %r12
jne 0x172f0
leaq 0x44bf(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_shift_history()
void TaxiAgency::print_shift_history(){
    cout << "[" << endl;
    for (list<Shift>::iterator i = shift_history.begin(); i != shift_history.end(); ++i)
        cout << *i;
    cout << "]" << endl;
}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x353d(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0x3ca0(%rip), %rsi      # 0x1bc40
movl $0xc, %edx
movq %rbx, %rdi
callq 0x4320
movzbl (%r14), %edx
leaq 0x395a(%rip), %rax      # 0x1b912
leaq 0x3958(%rip), %rsi      # 0x1b917
testq %rdx, %rdx
cmovneq %rax, %rsi
xorq $0x5, %rdx
movq %rbx, %rdi
callq 0x4320
leaq 0x3c74(%rip), %rsi      # 0x1bc4d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x4320
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0x3c56(%rip), %rsi      # 0x1bc56
movl $0x12, %edx
movq %rax, %rdi
callq 0x4320
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0x3c42(%rip), %rsi      # 0x1bc69
movl $0x11, %edx
movq %rax, %rdi
callq 0x4320
movl 0x48(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0x3c31(%rip), %rsi      # 0x1bc7b
movl $0xb, %edx
movq %rax, %rdi
callq 0x4320
movl 0x4c(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0x3c1a(%rip), %rsi      # 0x1bc87
movl $0x15, %edx
movq %rax, %rdi
callq 0x4320
movl 0x50(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0x3c0d(%rip), %rsi      # 0x1bc9d
movl $0x14, %edx
movq %rax, %rdi
callq 0x4320
movl 0x4c(%r14), %esi
subl 0x50(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r14
leaq 0x346c(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bubiche[P]wu_manber/./wu_manber.hpp
// Function: wu_manber::WuManber<char, std::char_traits<char>>::checkShortPattern_(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long)>) const
void checkShortPattern_(const StringType &text, std::size_t cur_idx, std::function<void(const StringType&, std::size_t, std::size_t)> onMatch) const {
      int l1MatchIndex = lengthOnePatternLookup_[static_cast<std::size_t>(text[cur_idx])];
      if (l1MatchIndex > -1) {
        onMatch(lengthOnePatterns_[l1MatchIndex], l1MatchIndex, cur_idx);
      }

      int l2MatchIndex = lengthTwoPatternLookup_[static_cast<std::size_t>(text[cur_idx - 1])][static_cast<std::size_t>(text[cur_idx])];
      if (l2MatchIndex > -1) {
        onMatch(lengthTwoPatterns_[l2MatchIndex], l2MatchIndex, cur_idx - 1);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rax
movsbq (%rax,%rdx), %rax
movq 0x80(%rdi), %rcx
movq (%rcx,%rax,8), %rax
testl %eax, %eax
js 0x3c92
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq 0xb0(%r15), %rsi
movq %rax, 0x10(%rsp)
movq %r14, 0x8(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x3cfb
shlq $0x5, %rax
addq %rax, %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq *0x18(%rbx)
movq (%r12), %rax
movsbq -0x1(%rax,%r14), %rcx
movq 0x98(%r15), %rdx
leaq (%rcx,%rcx,2), %rcx
movsbq (%rax,%r14), %rax
movq (%rdx,%rcx,8), %rcx
movq (%rcx,%rax,8), %rax
testl %eax, %eax
js 0x3cef
decq %r14
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq 0xc8(%r15), %rsi
movq %rax, 0x10(%rsp)
movq %r14, 0x8(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x3cfb
shlq $0x5, %rax
addq %rax, %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq *0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipalsp/genipalsp.cpp
// Function: log(char const*, ...)
void log(const char* fmt ...) {
	va_list args;
	va_start(args, fmt);
	printf("[%.3f] ", getAbsoluteTimeLP() - start);
	vprintf(fmt, args);
	va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2921
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rsp), %r14
movq %rdi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2290
xorps %xmm1, %xmm1
cvtsi2sdq (%r15), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%r15), %xmm0
mulsd 0xf69f(%rip), %xmm0     # 0x12008
addsd %xmm1, %xmm0
subsd 0x1681b(%rip), %xmm0    # 0x19190
leaq 0xf6a4(%rip), %rdi      # 0x12020
movb $0x1, %al
callq 0x2030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipalsp/genipalsp.cpp
// Function: printGraph(Graph const&)
void printGraph(const Graph& graph) {
	printf("p edge %d %d\n", graph.verticesCount, graph.edgesCount);
	for (size_t i = 0; i < graph.neighbours.size(); i++) {
		for (size_t j = 0; j < graph.neighbours[i].size(); j++) {
			printf("e %lu %d\n", i, graph.neighbours[i][j]);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %esi
movl 0x4(%rdi), %edx
leaq 0xf34d(%rip), %rdi      # 0x1210d
xorl %eax, %eax
callq 0x2030
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x2e3e
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
leaq 0xf339(%rip), %r14      # 0x1211b
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
leaq (%r15,%r15,2), %r13
movq (%rcx,%r13,8), %rax
cmpq %rax, 0x8(%rcx,%r13,8)
je 0x2e26
xorl %ebp, %ebp
movl (%rax,%rbp,4), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
incq %rbp
movq 0x8(%rbx), %rcx
movq (%rcx,%r13,8), %rax
movq 0x8(%rcx,%r13,8), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %rbp
jb 0x2dfa
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
incq %r15
sarq $0x3, %rax
imulq %r12, %rax
cmpq %rax, %r15
jb 0x2de5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipalsp/genipalsp.cpp
// Function: printFormula(SimpleFormula const&)
void printFormula(const SimpleFormula& formula) {
	printf("p cnf %d %lu\n", formula.vars, formula.clauses.size());
	for (size_t i = 0; i < formula.clauses.size(); i++) {
		for (size_t j = 0; j < formula.clauses[i].size(); j++) {
			printf("%d ", formula.clauses[i][j]);
		}
		printf("0\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
subq 0x8(%rdi), %rdx
movl (%rdi), %esi
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0xf2a7(%rip), %rdi      # 0x12125
xorl %eax, %eax
callq 0x2030
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x2f15
leaq 0x106e2(%rip), %r14     # 0x1357c
leaq 0xf292(%rip), %r15      # 0x12133
xorl %r13d, %r13d
movq 0x8(%rbx), %rcx
leaq (,%r13,2), %rbp
addq %r13, %rbp
movq (%rcx,%rbp,8), %rax
cmpq %rax, 0x8(%rcx,%rbp,8)
je 0x2eeb
xorl %r12d, %r12d
movl (%rax,%r12,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %r12
movq 0x8(%rbx), %rcx
movq (%rcx,%rbp,8), %rax
movq 0x8(%rcx,%rbp,8), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x2ec1
movq %r14, %rdi
callq 0x2260
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
incq %r13
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %r13
jb 0x2ea4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipalsp/genipalsp.cpp
// Function: recDFS(Graph const&, int, int)
int recDFS(const Graph&g, int vert, int goal) {
	//log("called dfs with %d\n", vert);
	if (vert == goal) {
		return 1;
	}
	visited[vert]=vert;
	int best = 0;
	for (size_t i = 0; i < g.neighbours[vert].size(); i++) {
		int nvert = g.neighbours[vert][i];
		if (!isVisited(nvert)) {
			int res = recDFS(g, nvert, goal);
			if (res > best) {
				best = res;
			}
		}
	}
	return best > 0 ? best+1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movl $0x1, %ebp
cmpl %edx, %esi
je 0x3044
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leaq 0x1620e(%rip), %rdi     # 0x191a0
leaq 0x4(%rsp), %r12
movq %r12, %rsi
callq 0x3598
movl %r15d, (%rax)
movslq (%r12), %rax
movq 0x8(%r14), %rcx
leaq (%rax,%rax,2), %rdx
movq (%rcx,%rdx,8), %rax
xorl %ebp, %ebp
movl $0x0, %r15d
cmpq %rax, 0x8(%rcx,%rdx,8)
je 0x303a
xorl %r15d, %r15d
leaq 0x161dd(%rip), %r12     # 0x191a8
xorl %r13d, %r13d
movl (%rax,%r13,4), %esi
movq 0x161d7(%rip), %rcx     # 0x191b0
movq %r12, %rax
testq %rcx, %rcx
je 0x2ffa
movq %r12, %rax
xorl %edx, %edx
cmpl %esi, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x2fe4
cmpq %r12, %rax
je 0x3004
cmpl %esi, 0x20(%rax)
jle 0x3015
movq %r14, %rdi
movl %ebx, %edx
callq 0x2f67
cmpl %r15d, %eax
cmovgl %eax, %r15d
incq %r13
movslq 0x4(%rsp), %rax
movq 0x8(%r14), %rcx
leaq (%rax,%rax,2), %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
jb 0x2fce
leal 0x1(%r15), %eax
testl %r15d, %r15d
cmovgl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipalsp/genipalsp.cpp
// Function: getLowerUpperBound(Graph const&, int, int, int&, int&)
int getLowerUpperBound(const Graph& g, int start, int goal, int& lowBound, int& upBound) {
	visited.clear();
	lowBound = recDFS(g,start,goal);
	visited[goal] = goal; // because goal is not marked visited by DFS
	upBound = visited.size();
	return lowBound;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl %edx, (%r12)
leaq 0x16125(%rip), %r13     # 0x191a0
movq %r13, %rdi
callq 0x3bfe
movl (%r12), %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x2f67
movl %eax, (%r14)
movl (%r12), %ebp
movq %r13, %rdi
movq %r12, %rsi
callq 0x3598
movl %ebp, (%rax)
movl 0x1611d(%rip), %eax     # 0x191c8
movl %eax, (%rbx)
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipalsp/genipalsp.cpp
// Function: addUniversalConditions(void*, Graph const&, int)
void addUniversalConditions(void* solver, const Graph&g, int step) {
	// at most one vertex has a particular position
	for (int v1 = 1; v1 <= g.verticesCount; v1++) {
		if (!isVisited(v1)) continue;
		for (int v2 = 1; v2 < v1; v2++) {
			if (!isVisited(v2)) continue;
			ipasir_add(solver, -mapVar(v1,step,g.verticesCount));
			ipasir_add(solver, -mapVar(v2,step,g.verticesCount));
			ipasir_add(solver, 0);
		}
	}
}

// Assembly:
cmpl $0x0, (%rsi)
jle 0x31d4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %r13d
leaq 0x1609f(%rip), %r12     # 0x191a8
movq 0x160a0(%rip), %rcx     # 0x191b0
movq %r12, %rax
testq %rcx, %rcx
je 0x3132
movq %r12, %rax
xorl %edx, %edx
cmpl %r13d, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x311b
cmpq %r12, %rax
je 0x31b6
cmpl %r13d, 0x20(%rax)
setg %al
cmpl $0x2, %r13d
setb %cl
orb %al, %cl
jne 0x31b6
movl $0x1, %ebp
movq 0x1605b(%rip), %rcx     # 0x191b0
movq %r12, %rax
testq %rcx, %rcx
je 0x3176
movq %r12, %rax
xorl %edx, %edx
cmpl %ebp, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x3160
cmpq %r12, %rax
je 0x31af
cmpl %ebp, 0x20(%rax)
jg 0x31af
movl (%r14), %esi
imull %ebx, %esi
addl %r13d, %esi
negl %esi
movq %r15, %rdi
callq 0x3ca5
movl (%r14), %esi
imull %ebx, %esi
addl %ebp, %esi
negl %esi
movq %r15, %rdi
callq 0x3ca5
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ca5
incl %ebp
cmpl %r13d, %ebp
jne 0x314e
leal 0x1(%r13), %eax
cmpl (%r14), %r13d
movl %eax, %r13d
jl 0x3109
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/genipalsp/genipalsp.cpp
// Function: addTransitionalConditions(void*, Graph const&, int)
void addTransitionalConditions(void* solver, const Graph&g, int step) {
	int verts = g.verticesCount;
	for (int v1 = 1; v1 <= verts; v1++) {
		if (!isVisited(v1)) continue;
		// clauses expressing that successor of the node in a path is its neighbour
		ipasir_add(solver, -mapVar(v1,step-1,verts));
		for (size_t i = 0; i < g.neighbours[v1].size(); i++) {
			int v2 = g.neighbours[v1][i];
			ipasir_add(solver, mapVar(v2, step,verts));
		}
		ipasir_add(solver, 0);
		// the selected vertex is not used in any of the previous steps
		for (int prevStep=0; prevStep < step; prevStep++) {
			ipasir_add(solver, -mapVar(v1,step,verts));
			ipasir_add(solver, -mapVar(v1,prevStep,verts));
			ipasir_add(solver, 0);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0xc(%rsp)
movq %rdi, %r15
movq %rsi, 0x28(%rsp)
movl (%rsi), %edi
testl %edi, %edi
jle 0x3342
movl $0x1, %ecx
movl 0xc(%rsp), %eax
subl %eax, %ecx
imull %edi, %ecx
movl %ecx, 0x14(%rsp)
movl %edi, %ecx
imull %eax, %ecx
movq %rcx, 0x18(%rsp)
movq %rdi, %r13
incq %r13
movl $0x1, %ebx
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
leaq 0x15f79(%rip), %r8      # 0x191a8
movq %rdi, 0x30(%rsp)
movq %r13, 0x20(%rsp)
movq 0x15f70(%rip), %rcx     # 0x191b0
movq %r8, %rax
testq %rcx, %rcx
je 0x3266
movq %r8, %rax
movslq 0x20(%rcx), %rdx
xorl %esi, %esi
cmpq %rdx, %rbx
setg %sil
cmovleq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x324b
cmpq %r8, %rax
je 0x332b
movslq 0x20(%rax), %rax
cmpq %rax, %rbx
jl 0x332b
movl 0x14(%rsp), %esi
subl %ebx, %esi
movq %r15, %rdi
callq 0x3ca5
movq 0x28(%rsp), %rbp
movq 0x8(%rbp), %rcx
leaq (%rbx,%rbx,2), %r12
movq (%rcx,%r12,8), %rax
cmpq %rax, 0x8(%rcx,%r12,8)
movq 0x18(%rsp), %r13
je 0x32d5
xorl %r14d, %r14d
movl (%rax,%r14,4), %esi
addl %r13d, %esi
movq %r15, %rdi
callq 0x3ca5
incq %r14
movq 0x8(%rbp), %rcx
movq (%rcx,%r12,8), %rax
movq 0x8(%rcx,%r12,8), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r14
jb 0x32aa
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ca5
cmpl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %r13
jle 0x332b
movq 0x18(%rsp), %rax
leal (%rax,%rbx), %ebp
negl %ebp
movl 0x10(%rsp), %r12d
movl 0xc(%rsp), %r14d
movq %r15, %rdi
movl %ebp, %esi
callq 0x3ca5
movq %r15, %rdi
movl %r12d, %esi
callq 0x3ca5
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ca5
movq 0x30(%rsp), %rdi
subl %edi, %r12d
decl %r14d
jne 0x32ff
incq %rbx
decl 0x10(%rsp)
cmpq %r13, %rbx
leaq 0x15e6c(%rip), %r8      # 0x191a8
jne 0x3239
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JameyWoo[P]re2graph/algorithms.cpp
// Function: parse_range(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string parse_range(string str) {
    /**
     * ! 范围解析的函数
     * ! 可以解析出如A-Z, a-zA-Z0-9_- 这一类范围定义的字符
     * 以字符串形式返回
     */
    if (str.size() == 1) return str;
    string range;
    for (size_t i = 0; i < str.size(); ++i) {
        if (i + 1 < str.size() and str[i + 1] == '-') {  // 识别到一个范围
            for (auto x = str[i]; x <= str[i + 2]; ++x) {
                range += x;
            }
            i += 2;
        } else {
            range += str[i];
        }
    }
    return range;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
cmpq $0x1, %rax
jne 0x4bdd
movq (%r14), %rdx
leaq 0x10(%r14), %rcx
cmpq %rcx, %rdx
je 0x4c56
movq %rdx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x4c5d
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4c71
xorl %r12d, %r12d
leaq 0x1(%r12), %rcx
cmpq %rax, %rcx
jae 0x4c38
movq (%r14), %rax
cmpb $0x2d, (%rax,%rcx)
jne 0x4c38
movb (%rax,%r12), %bpl
leaq 0x2(%r12), %r13
movq (%r14), %rax
cmpb 0x2(%rax,%r12), %bpl
jg 0x4c33
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x21c0
incb %bpl
movq (%r14), %rax
cmpb (%rax,%r13), %bpl
jle 0x4c1b
movq %r13, %r12
jmp 0x4c48
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x21c0
incq %r12
movq 0x8(%r14), %rax
cmpq %rax, %r12
jb 0x4bf5
jmp 0x4c71
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %rax, 0x8(%rbx)
movq %rcx, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c85
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4c9b
movq (%r15), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/perf_co_sst.cpp
// Function: test(int, int)
void test(int n, int Q) {
    co_static_search_tree tree(n);

    for (int i = 0; i < n; ++i) {
        tree.update(i, i);
    }

    for (int query = 0; query < Q; ++query)
    {   
        if (query % rand_reset_const == 0) {
            srand(query / rand_reset_const);
        }
        int type = rand() % 2;
        int index = rand() % n;
        if(type == 0) {
            tree.update(index, index);
        } else {
            if(tree.get(index) != index) {
                cout << "Fail: expected value " << index << " at index " << index << endl;
                return;
            }
        }
    }
    cout << "test(" << n << ", " << Q << "): OK" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x133c
testl %ebp, %ebp
jle 0x297b
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
movl %r14d, %edx
callq 0x15de
incl %r14d
cmpl %r14d, %ebp
jne 0x2965
testl %ebx, %ebx
jle 0x29ec
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
movl %r13d, %edi
movl $0xd1b71759, %eax       # imm = 0xD1B71759
imulq %rax, %rdi
shrq $0x2d, %rdi
imull $0x2710, %edi, %eax     # imm = 0x2710
cmpl %r13d, %eax
jne 0x29a7
callq 0x10f0
callq 0x1060
movl %eax, %r12d
callq 0x1060
cltd
idivl %ebp
movl %edx, %r15d
testb $0x1, %r12b
jne 0x29d0
movq %r14, %rdi
movl %r15d, %esi
movl %r15d, %edx
callq 0x15de
jmp 0x29e4
movq %r14, %rdi
movl %r15d, %esi
callq 0x17d2
cmpl %r15d, %eax
jne 0x2a73
incl %r13d
cmpl %r13d, %ebx
jne 0x2987
movq 0x25dd(%rip), %rdi      # 0x4fd0
leaq 0x790(%rip), %rsi       # 0x318a
movl $0x5, %edx
callq 0x1140
movq 0x25c5(%rip), %rdi      # 0x4fd0
movl %ebp, %esi
callq 0x11c0
movq %rax, %r14
leaq 0x774(%rip), %rsi       # 0x3190
movl $0x2, %edx
movq %rax, %rdi
callq 0x1140
movq %r14, %rdi
movl %ebx, %esi
callq 0x11c0
movq %rax, %rbx
leaq 0x756(%rip), %rsi       # 0x3193
movl $0x5, %edx
movq %rax, %rdi
callq 0x1140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
jmp 0x2ae6
movq 0x2556(%rip), %rdi      # 0x4fd0
leaq 0x6e8(%rip), %rsi       # 0x3169
movl $0x15, %edx
callq 0x1140
movq 0x253e(%rip), %rdi      # 0x4fd0
movl %r15d, %esi
callq 0x11c0
movq %rax, %rbx
leaq 0x6db(%rip), %rsi       # 0x317f
movl $0xa, %edx
movq %rax, %rdi
callq 0x1140
movq %rbx, %rdi
movl %r15d, %esi
callq 0x11c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
leaq 0x8(%rsp), %rdi
callq 0x13d6
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b08
jmp 0x2b08
jmp 0x2b08
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13d6
movq %rbx, %rdi
callq 0x11d0
// File: /workspace/github_cpp_makefile_star2_O1/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/perf_co_sst.cpp
// Function: main
int main(){
    // I think it's better to first let the user specify the inputs,
    // then make 10 independent runs on the same inputs n and Q, and
    // measure the runtime of each separately. We need an average of
    // runtimes, not the total runtime - maybe I'm wrong about this?
    srand(10);
    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
    int n, Q;
    cin >> n >> Q;
    test(n, Q);
    chrono::steady_clock::time_point end = chrono::steady_clock::now();
    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xa, %edi
callq 0x10f0
callq 0x1160
movq %rax, %rbx
movq 0x24a1(%rip), %rdi      # 0x4fe0
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x10a0
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x10a0
movl (%r14), %edi
movl (%r15), %esi
callq 0x2938
callq 0x1160
movq %rax, %r14
movq 0x245a(%rip), %r15      # 0x4fd0
leaq 0x61c(%rip), %rsi       # 0x3199
movl $0x12, %edx
movq %r15, %rdi
callq 0x1140
subq %rbx, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x10e0
movq %rax, %rbx
leaq 0x5ef(%rip), %rsi       # 0x31ac
movl $0x5, %edx
movq %rax, %rdi
callq 0x1140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/brianbbsu[P]TCP-Ping/src/server.cpp
// Function: print_help(boost::program_options::options_description)
void print_help(po::options_description desc){
    std::cout<<"Usage: ./server [--help] port\n\n";
    std::cout<<"TCP Ping - Server - Made by Po-Hsuan Su (b08902107)\n\n";
    std::cout<<"Positional Argument\n  port - Port to listen on\n\n";
    std::cout<<"Optional Arguments\n";
    std::cout<<desc<<std::endl;
    exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9f61(%rip), %r14      # 0xffc8
leaq 0x505b(%rip), %rsi      # 0xb0c9
movq %r14, %rdi
callq 0x52a0
leaq 0x506c(%rip), %rsi      # 0xb0e9
movq %r14, %rdi
callq 0x52a0
leaq 0x5093(%rip), %rsi      # 0xb11f
movq %r14, %rdi
callq 0x52a0
leaq 0x50b5(%rip), %rsi      # 0xb150
movq %r14, %rdi
callq 0x52a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5090
movq %rax, %rdi
callq 0x5150
xorl %edi, %edi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O1/NFAcz[P]compareQC/main.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> split(const std::string& s, char delimiter)
{
  std::vector<std::string> tokens;
  std::string token;
  std::istringstream tokenStream(s);

  while (std::getline(tokenStream, token, delimiter))
  {
    tokens.push_back(token);
  }

  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r14d
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x1c8(%rbp), %rdi
movl $0x8, %edx
callq 0x6410
movsbl %r14b, %r14d
leaq -0x1c8(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x64a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x68d1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x89ea
jmp 0x68a8
movq 0x106c0(%rip), %rsi     # 0x16f98
leaq -0x1c8(%rbp), %rdi
callq 0x6340
leaq -0x150(%rbp), %rdi
callq 0x60c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6905
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6280
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6941
movq %rax, %r14
movq 0x1066f(%rip), %rsi     # 0x16f98
leaq -0x1c8(%rbp), %rdi
callq 0x6340
leaq -0x150(%rbp), %rdi
callq 0x60c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6956
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6280
movq %rbx, %rdi
callq 0x8a36
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O1/NFAcz[P]compareQC/main.cpp
// Function: loadFromTxt(char const*, int)
std::vector<float> loadFromTxt(const char *filename, const int jump){

    std:ifstream instream(filename);
    float Y;
    std::string line;
    std::vector<float> tmp;
    int counter = 0;
    int frms = 0;
    while(std::getline(instream, line)){
      if(counter%3==0){
        if(frms%jump==0){
        Y = float(strtof(line.c_str(),NULL));
        tmp.push_back(Y);
        }
        frms++;
      }
      counter++;
    }
    instream.close();

    FPS = 25.0;

    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl %edx, -0x34(%rbp)
movq %rdi, %rbx
leaq -0x260(%rbp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x6490
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
xorl %r14d, %r14d
movq %r14, -0x8(%rax)
movb $0x0, (%rax)
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movq %rbx, -0x30(%rbp)
movups %xmm0, (%rbx)
leaq -0x58(%rbp), %r12
xorl %r13d, %r13d
xorl %ebx, %ebx
movq -0x260(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6250
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x64a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6a55
movl %ebx, %eax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
addl %r14d, %eax
jne 0x6a4b
movl %r13d, %eax
cltd
idivl -0x34(%rbp)
testl %edx, %edx
jne 0x6a48
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x6320
movss %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6a3f
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x6a48
leaq -0x38(%rbp), %rdx
callq 0x916a
incl %r13d
incl %ebx
decl %r14d
jmp 0x69bd
leaq -0x260(%rbp), %rdi
callq 0x6060
movl $0x41c80000, 0x1080d(%rip) # imm = 0x41C80000
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x6a84
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x6280
leaq -0x260(%rbp), %rdi
callq 0x6080
movq -0x30(%rbp), %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6aa8
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6ac7
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x6280
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x6ae0
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x6280
leaq -0x260(%rbp), %rdi
callq 0x6080
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/yyThreadPool.c
// Function: threadpool_init
threadpool_t *threadpool_init(int threadNum,int queueMaxLen){
    threadpool_t *pThreadPool=(threadpool_t *)malloc(sizeof(threadpool_t));
    if(pThreadPool==NULL) return NULL;
    (pThreadPool->tasks).front=NULL;
    (pThreadPool->tasks).rear=NULL;
    pthread_mutex_init(&((pThreadPool->tasks).qmutex),NULL);
    pthread_cond_init(&((pThreadPool->tasks).not_full),NULL);
    (pThreadPool->tasks).max_len=queueMaxLen;
    (pThreadPool->tasks).qlen=0;
    (pThreadPool->tasks).has_tasks=(bsem *)malloc(sizeof(bsem));
    if((pThreadPool->tasks).has_tasks==NULL) return NULL;
    if(bsem_init((pThreadPool->tasks).has_tasks,0)!=0) return NULL;
    pThreadPool->work_threads=(pthread_t *)malloc(threadNum*sizeof(pthread_t));
    pThreadPool->num_alive_threads=threadNum;
    pThreadPool->num_running_threads=0;
    pthread_mutex_init(&(pThreadPool->tmutex),NULL);
    pthread_cond_init(&(pThreadPool->has_idle),NULL);
    keepAlive=1;
    for(int i=0;i<threadNum;i++){
        pthread_create(&((pThreadPool->work_threads)[i]),0,thread_work,(void *)pThreadPool);
    }
    return pThreadPool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r12d
movl %edi, %r14d
movl $0xe0, %edi
callq 0x2360
testq %rax, %rax
je 0x27e5
movq %rax, %rbx
leaq 0x10(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x2400
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
callq 0x2340
movl %r12d, 0x68(%rbx)
movl $0x0, 0x6c(%rbx)
movl $0x60, %edi
callq 0x2360
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x27e8
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
callq 0x2400
addq $0x28, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x2340
movslq %r14d, %r15
leaq (,%r15,8), %rdi
callq 0x2360
movq %rax, 0x78(%rbx)
movl %r15d, 0x80(%rbx)
movl $0x0, 0x84(%rbx)
leaq 0x88(%rbx), %rdi
xorl %esi, %esi
callq 0x2400
movq %rbx, %rdi
addq $0xb0, %rdi
xorl %esi, %esi
callq 0x2340
movl $0x1, 0x7af7(%rip)      # 0xa2a4
testl %r15d, %r15d
jle 0x27e0
movl %r14d, %r15d
shlq $0x3, %r15
xorl %r12d, %r12d
leaq 0x71(%rip), %r14        # 0x2834
movq 0x78(%rbx), %rdi
addq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x24e0
addq $0x8, %r12
cmpq %r12, %r15
jne 0x27c3
movq %rbx, %r15
jmp 0x27e8
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/yyThreadPool.c
// Function: bsem_init(bsem*, int)
int bsem_init(bsem *pBsem,int sem){
    if(sem<0||sem>1){
        printf("the binary sem only can be 1 or 0!\n");
        return -1;
    }
    pthread_mutex_init(&(pBsem->mut),NULL);
    pthread_cond_init(&(pBsem->con),NULL);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %esi
jb 0x2813
leaq 0x4819(%rip), %rdi      # 0x7020
callq 0x2450
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x282d
movq %rdi, %r14
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2400
addq $0x28, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2340
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq