LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::updateRing()
void MP2Node::updateRing() {
    vector<Node> curMemList;

    /*
     *  Step 1. Get the current membership list from Membership Protocol / MP1
     */
    curMemList = getMembershipList();

    /*
     * Step 2: Construct the ring
     */
    // Sort the list based on the hashCode
    sort(curMemList.begin(), curMemList.end());

    /*
     * Step 3: Run the stabilization protocol IF REQUIRED
     */
    // Run stabilization protocol if the hash table size is greater than zero and if there has been changes in the ring

    // if stabilization protocol needs to be run, cache the list (now the old list and new list are both present)
    // and then let the stabilization protocol do the work

    // for testing purpose
    // this->ring = curMemList;

    if (this->ring.size() == 0) {
        this->ring = curMemList;
        return;
    }

    // first compare the size
    if (this->ring.size() != curMemList.size()) {
        this->new_ring = curMemList;
        this->stabilizationProtocol();
        return;
    }

    // compare every node hash
    for (int i = 0; i < this->ring.size(); ++i) {
        if (this->ring[i].nodeHashCode != curMemList[i].nodeHashCode) {
            this->new_ring = curMemList;
            this->stabilizationProtocol();
            return;
        }
    }

    // it doesn't change
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xee0e
leaq 0x20(%rsp), %r14
movaps (%r14), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movaps %xmm0, (%r14)
movq %rax, 0x10(%r14)
callq 0xbaf6
movq %r14, %rdi
callq 0xbaf6
movq (%rsp), %r14
movq 0x8(%rsp), %r15
cmpq %r15, %r14
je 0xed60
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x12f8f
movq %r14, %rdi
movq %r15, %rsi
callq 0x13045
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
subq %rax, %rsi
je 0xedaa
movq (%rsp), %rdx
movq 0x8(%rsp), %rdi
subq %rdx, %rdi
cmpq %rdi, %rsi
jne 0xedbb
sarq $0x5, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movl $0x10, %esi
movq (%rax,%rsi), %rdi
cmpq (%rdx,%rsi), %rdi
jne 0xedd1
addq $0x20, %rsi
decq %rcx
jne 0xed95
jmp 0xede5
addq $0x30, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12b2e
jmp 0xede5
leaq 0x70(%rbx), %rdi
movq %rsp, %rsi
callq 0x12b2e
movq %rbx, %rdi
callq 0xef60
jmp 0xede5
leaq 0x70(%rbx), %rdi
movq %rsp, %rsi
callq 0x12b2e
movq %rbx, %rdi
callq 0xef60
movq %rsp, %rdi
callq 0xbaf6
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xedfb
jmp 0xedfb
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbaf6
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::getMembershipList()
vector<Node> MP2Node::getMembershipList() {
    unsigned int i;
    vector<Node> curMemList;
    for ( i = 0 ; i < this->memberNode->memberList.size(); i++ ) {
        Address addressOfThisMember;
        int id = this->memberNode->memberList.at(i).getid();
        short port = this->memberNode->memberList.at(i).getport();
        memcpy(&addressOfThisMember.addr[0], &id, sizeof(int));
        memcpy(&addressOfThisMember.addr[4], &port, sizeof(short));
        curMemList.emplace_back(Node(addressOfThisMember));
    }
    return curMemList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rsp)
movq 0x50(%rsi), %rcx
movq 0x28(%rcx), %rax
cmpq %rax, 0x30(%rcx)
je 0xef10
movl $0x1, %ebx
xorl %ebp, %ebp
leaq 0x22(%rsp), %r13
leaq 0x28(%rsp), %r14
leaq (,%rbp,2), %r15
addq %rbp, %r15
leaq (%rax,%r15,8), %rdi
callq 0xd09e
movl %eax, %r12d
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rbp, %rdx
jbe 0xef24
leaq (%rax,%r15,8), %rdi
callq 0xd0a2
movl %r12d, 0x10(%rsp)
movw %ax, 0x14(%rsp)
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0xd01c
movq %r14, %rdi
movq %r13, %rsi
callq 0x14074
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12c8a
movq %r14, %rdi
callq 0x14116
movl %ebx, %ebp
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
incl %ebx
cmpq %rbp, %rcx
ja 0xee57
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x81c0(%rip), %rdi      # 0x170eb
movq %rbp, %rsi
xorl %eax, %eax
callq 0x33c0
jmp 0xef4a
jmp 0xef4a
jmp 0xef4a
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x14116
jmp 0xef4d
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xbaf6
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O3/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::handleReply(int, bool)
void MP2Node::handleReply(int transID, bool success) {
    if (success) {
        transID2Bundle[transID]->success_responses++;
    } else {
        transID2Bundle[transID]->failure_responses++;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x90, %rdi
movq %rax, %rsi
callq 0x12d7a
movq (%rax), %rax
testl %ebx, %ebx
je 0x109c6
incl (%rax)
jmp 0x109c9
incl 0x4(%rax)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::handleReadReply(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void MP2Node::handleReadReply(string value, int transID) {
    if (!value.empty()) {
        transID2Bundle[transID]->success_responses++;
        // @TODO: here we are assuming all responses are latest
        transID2Bundle[transID]->value = value;
    } else {
        transID2Bundle[transID]->failure_responses++;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movl %edx, (%rsi)
movq 0x8(%rbx), %r15
addq $0x90, %r14
movq %r14, %rdi
callq 0x12d7a
movq (%rax), %rax
testq %r15, %r15
je 0x10a21
incl (%rax)
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x12d7a
movq (%rax), %rdi
addq $0x30, %rdi
movq %rbx, %rsi
callq 0x3140
jmp 0x10a24
incl 0x4(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/51Peg/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    /* set the RV data file */
    datafile = "51Peg.rv";

    // the second argument is the units of the RVs
    // the third (optional) argument, tells kima not to skip any line in the header of the file
    load(datafile, "ms", 0);

    // set the sampler and run it!
    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50); // print to terminal every 50th iteration

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x2fcf6(%rip), %rdx     # 0x50548
leaq 0x2fce7(%rip), %r14     # 0x50540
leaq 0x2208d(%rip), %rcx     # 0x428ed
movl $0x8, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x1cc8f(%rip), %rsi     # 0x3d511
movq %r14, %rdi
callq 0x20a81
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x20b84
movq %r14, %rdi
movl $0x32, %esi
callq 0x20c56
leaq 0x8(%rsp), %rdi
callq 0x20e34
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e34
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/examples/health_echo/main.cpp
// Function: main
int main(int argc, char** argv)
{
    try
    {
        auto interface = nshdev::NetInterfaceFactory::CreateInterfaceFromArgs(argc, argv);
        if(interface == nullptr)
        {
            std::cerr << "Failed to create interface" << std::endl;
            return 2;
        }

        HealthEcho echo;
        interface->SetConsumer(&echo);

        nshdev::Scheduler scheduler(*interface);

        scheduler.SchedulePackets();
    }
    catch(const std::exception& e)
    {
        std::cerr << "Caught exception (aborting)" << std::endl << e.what() << std::endl;
    }

    return 1;  // can only get here by exception
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x14(%rsp), %rax
movl %edi, (%rax)
leaq 0x28(%rsp), %rdx
movq %rsi, (%rdx)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x27dc
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x2586
leaq 0x47f2(%rip), %rax      # 0x6d40
addq $0x10, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rbx)
jne 0x25f5
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x3460
leaq 0x18(%rsp), %rdi
callq 0x3472
xorl %ebp, %ebp
jmp 0x25d1
movq 0x4a5b(%rip), %r14      # 0x6fe8
leaq 0x1a70(%rip), %rsi      # 0x4004
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2200
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x4a29(%rip), %rdi      # 0x6fe8
callq 0x2030
movl $0x2, %ebp
movq %rax, %rdi
callq 0x2140
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25e0
movq (%rdi), %rax
callq *0x8(%rax)
testq %rbx, %rbx
je 0x25ea
movl $0x1, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a3f(%rip), %rdi      # 0x403b
leaq 0x1a44(%rip), %rsi      # 0x4047
leaq 0x1a65(%rip), %rcx      # 0x406f
movl $0x1b, %edx
callq 0x2130
movq %rdx, %r14
movq %rax, %rbx
jmp 0x2633
jmp 0x261e
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2633
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, %r14d
jne 0x2699
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
movq 0x499d(%rip), %rdi      # 0x6fe8
leaq 0x19cd(%rip), %rsi      # 0x401f
movl $0x1b, %edx
callq 0x2200
movq 0x4985(%rip), %rdi      # 0x6fe8
callq 0x2110
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2110
callq 0x2280
jmp 0x25e5
movq %rax, %rbx
callq 0x2280
movq %rbx, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0x26a9
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/NetInterfaceFactory.cpp
// Function: nshdev::CreateDpdkIf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::unique_ptr<DpdkNetInterface> CreateDpdkIf(std::string pciAddr)
{
    std::string progName = "CreateDpdkIf";
    std::string dashW = "-w";
    char * argv[] =
    {
        // ugh
        &progName[0],
        &dashW[0],
        &pciAddr[0]
    };

    const uint32_t numInterfaces = DpdkSetup(3, argv);

    if(numInterfaces < 1)
    {
        return std::unique_ptr<DpdkNetInterface>();
    }

    return std::make_unique<DpdkNetInterface>(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19cd(%rip), %rsi      # 0x40a2
leaq 0x19d2(%rip), %rdx      # 0x40ae
leaq 0x20(%rsp), %rdi
callq 0x2a12
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x19b8(%rip), %rsi      # 0x40af
leaq 0x19b3(%rip), %rdx      # 0x40b1
movq %rsp, %rdi
callq 0x2a12
movq 0x20(%rsp), %rax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq (%rsp), %rax
movq %rax, 0x8(%rsi)
movq (%r14), %rax
movq %rax, 0x10(%rsi)
movl $0x3, %edi
callq 0x33b8
testl %eax, %eax
je 0x2749
movl $0x38, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x3260
jmp 0x274c
xorl %r14d, %r14d
movq %r14, (%rbx)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2765
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x277c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x21f0
jmp 0x27a2
jmp 0x279f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x27bd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x27bd
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x27d4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/NetInterfaceFactory.cpp
// Function: nshdev::NetInterfaceFactory::CreateInterfaceFromArgs(int&, char**&)
std::unique_ptr<NetInterface>
NetInterfaceFactory::CreateInterfaceFromArgs(int& argc,
                                             char**& argv)
{
	// cache the "starting" values so that later users of the args can use getopt

	const int old_optind = optind;
	const int old_optopt = optopt;
	char * const old_optarg = optarg;

    InterfaceOptions options(argc, argv);
	
	// restore
	optind = old_optind;
	optopt = old_optopt;
	optarg = old_optarg;

    argc -= options.GetNumArgsConsumed();
    argv += options.GetNumArgsConsumed();

	if(!options.GetDpdkPciAddress().empty())
    {
        return CreateDpdkIf(options.GetDpdkPciAddress());
    }
    else
    {
        return std::make_unique<PacketSocket>(options.GetIfIndex());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq 0x47cc(%rip), %rax      # 0x6fc8
movl (%rax), %ebp
movq 0x47b3(%rip), %rax      # 0x6fb8
movl (%rax), %r13d
movq 0x4791(%rip), %rax      # 0x6fa0
movq (%rax), %rbx
movl (%rsi), %esi
movq (%rdx), %rdx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x2b98
movq 0x479d(%rip), %rax      # 0x6fc8
movl %ebp, (%rax)
movq 0x4784(%rip), %rax      # 0x6fb8
movl %r13d, (%rax)
movq 0x4762(%rip), %rax      # 0x6fa0
movq %rbx, (%rax)
movq %r12, %rdi
callq 0x2cf2
subl %eax, (%r15)
leaq 0x38(%rsp), %rdi
callq 0x2cf2
movl %eax, %eax
shlq $0x3, %rax
addq %rax, (%r14)
leaq 0x38(%rsp), %rdi
callq 0x2cec
cmpq $0x0, 0x8(%rax)
je 0x28cc
leaq 0x38(%rsp), %rdi
callq 0x2cec
movq 0x8(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x297c
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x26b4
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x28fc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x28fc
leaq 0x38(%rsp), %rdi
callq 0x2ce8
movq 0x8(%rsp), %rbx
movl %eax, %ebp
movl $0x18, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
movl $0x894f, %edx           # imm = 0x894F
callq 0x2d64
movq %r14, (%rbx)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2917
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
jmp 0x294b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2959
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x2959
jmp 0x2956
jmp 0x2956
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2974
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/InterfaceOptions.cpp
// Function: ResolveInterface(char const*)
int ResolveInterface(const char* name)
{
    unsigned i = if_nametoindex(name);
    if( i == 0 )
    {
        std::cerr << "Unknown interface name " << name << std::endl;
	exit(1);
    }
    return i;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2080
testl %eax, %eax
je 0x2ab7
popq %rbx
retq
movq 0x452a(%rip), %rdi      # 0x6fe8
leaq 0x1617(%rip), %rsi      # 0x40dc
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2110
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/InterfaceOptions.cpp
// Function: InterfaceOptions::InterfaceOptions(int, char**)
InterfaceOptions::InterfaceOptions(int argc, char** argv):
    m_ifIndex(0),
    m_numArgsConsumed(0)
{
    while(1)
    {
        int option_index = 0;
        int c = getopt_long(argc, argv, "i:", long_options, &option_index);
        if ( c == -1 )
        {
            break;
        }
        switch(c)
        {
        case 'i':
            m_ifIndex = ResolveInterface(optarg);
            break;
        case 'd':
            m_dpdkPciAddress = optarg;
            break;
        case '?':
            Usage(basename(argv[0]));
            exit(1);
        }
    }

    m_numArgsConsumed = optind;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r13
xorl %eax, %eax
movl %eax, (%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl %eax, 0x28(%rdi)
leaq 0x1558(%rip), %r12      # 0x4136
leaq 0x45cb(%rip), %rbx      # 0x71b0
leaq 0xc(%rsp), %r15
movl %esi, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl %ebp, %edi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2290
cmpl $0x68, %eax
jg 0x2c5a
cmpl $0x64, %eax
jne 0x2c77
movq %rbx, %r14
movq %r12, %rbx
movq 0x437b(%rip), %rax      # 0x6fa0
movq (%rax), %r12
movq 0x10(%r13), %rbp
movq %r12, %rdi
callq 0x2100
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %r12, %rcx
movq %rbx, %r12
movq %r14, %rbx
movq 0x20(%rsp), %r14
movl 0x8(%rsp), %ebp
movq %rax, %r8
callq 0x2260
jmp 0x2bf3
cmpl $0x69, %eax
jne 0x2bf3
movq 0x433a(%rip), %rax      # 0x6fa0
movq (%rax), %rdi
callq 0x2aa8
movl %eax, (%r13)
jmp 0x2bf3
cmpl $-0x1, %eax
je 0x2c9f
cmpl $0x3f, %eax
jne 0x2bf3
movq (%r14), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x2ae7
movl $0x1, %edi
callq 0x2210
movq 0x4322(%rip), %rax      # 0x6fc8
movl (%rax), %eax
movl %eax, 0x28(%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cbd
movq %rax, %rbx
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x2cdf
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::PacketSocket(int, unsigned short)
PacketSocket::PacketSocket(int ifIndex, uint16_t etherType)
    {
	// looking for specified Ethertype, with Ethernet header removed.
	m_socket = socket(AF_PACKET, SOCK_DGRAM, htons(etherType));
	if(m_socket < 0)
	{
	    throw ErrMsg("Couldn't open socket", errno);
	}
	struct sockaddr_ll  bind_addr;
	memset(&bind_addr, 0, sizeof(bind_addr));
	bind_addr.sll_family = AF_PACKET;
	bind_addr.sll_ifindex = ifIndex;
	bind_addr.sll_protocol = htons(etherType);
	int const bind_result = bind(m_socket, reinterpret_cast<const struct sockaddr*>(&bind_addr), sizeof(bind_addr));
	if(bind_result != 0)
	{
	    close(m_socket);
	    throw ErrMsg("Unable to bind socket", errno);
	}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x3edb(%rip), %rax      # 0x6c60
movq %rax, (%rdi)
rolw $0x8, %bp
movzwl %bp, %edx
movl $0x11, %edi
movl $0x2, %esi
callq 0x2090
movl %eax, 0x10(%rbx)
testl %eax, %eax
js 0x2de1
leaq 0x24(%rsp), %rsi
movl $0x0, 0x10(%rsi)
movq $0x0, 0x8(%rsi)
movw $0x11, (%rsi)
movl %r14d, 0x4(%rsi)
movw %bp, 0x2(%rsi)
movl %eax, %edi
movl $0x14, %edx
callq 0x2070
testl %eax, %eax
jne 0x2e3c
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x13a7(%rip), %rsi      # 0x41a5
leaq 0x13b4(%rip), %rdx      # 0x41b9
movq %rsp, %rdi
callq 0x2a12
callq 0x2040
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3058
xorl %ebp, %ebp
leaq 0x3e75(%rip), %rsi      # 0x6ca0
leaq 0x3ba(%rip), %rdx       # 0x31ec
movq %rbx, %rdi
callq 0x22b0
jmp 0x2e9d
movl 0x10(%rbx), %edi
callq 0x2310
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1359(%rip), %rsi      # 0x41ba
leaq 0x1367(%rip), %rdx      # 0x41cf
movq %rsp, %rdi
callq 0x2a12
callq 0x2040
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3058
xorl %ebp, %ebp
leaq 0x3e12(%rip), %rsi      # 0x6ca0
leaq 0x357(%rip), %rdx       # 0x31ec
movq %rbx, %rdi
callq 0x22b0
jmp 0x2ea6
jmp 0x2ec6
movq %rax, %r14
jmp 0x2ed1
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2ebf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
testb %bpl, %bpl
jne 0x2ec9
jmp 0x2ed1
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::Run()
void PacketSocket::Run()
    {
	uint8_t data[2000];
	LinkAddr from;
	from.length = sizeof(from.addr);
	ssize_t read = recvfrom(m_socket, data, sizeof(data),
				/* flags */ 0,
				reinterpret_cast<struct sockaddr*>(&from.addr),
				&from.length);
	if(read < 0)
	{
	    throw ErrMsg("Error from recvfrom", errno);
	}
	//printf("Send addr: ");
	//dump_ll(from.addr, from.length);
        if( from.addr.sll_pkttype == PACKET_HOST ) // for us
	{
	    PacketRef pref(data, read, &from);
	    Forward(pref);
	}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rdi, %rbx
leaq 0x3c(%rsp), %r9
movl $0x14, (%r9)
movl 0x10(%rdi), %edi
leaq 0x40(%rsp), %r15
leaq 0x28(%rsp), %r14
movl $0x7d0, %edx            # imm = 0x7D0
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r8
callq 0x2190
testq %rax, %rax
js 0x2f80
cmpb $0x0, 0x32(%rsp)
jne 0x2f72
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movl %eax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3450
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1233(%rip), %rsi      # 0x41d0
leaq 0x123f(%rip), %rdx      # 0x41e3
leaq 0x8(%rsp), %rdi
callq 0x2a12
callq 0x2040
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3058
xorl %ebp, %ebp
leaq 0x3cd2(%rip), %rsi      # 0x6ca0
leaq 0x217(%rip), %rdx       # 0x31ec
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ff7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
testb %bpl, %bpl
jne 0x3001
jmp 0x3009
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::ReturnToSender(nshdev::PacketRef&)
void PacketSocket::ReturnToSender(PacketRef& packetRef)
    {
        const LinkAddr& from = static_cast<const LinkAddr&>(*packetRef.From());
	struct sockaddr_ll to = from.addr;
	//printf("Return addr: ");
	//dump_ll(to, from.length);

	ssize_t written = sendto(m_socket, packetRef.Data(), packetRef.Length(), MSG_DONTWAIT,
	                         reinterpret_cast<struct sockaddr*>(&to), sizeof(to));
	if(written < 0)
	{
	    fprintf(stderr, "Error %d from sendto (%s)\n", errno, strerror(errno));
	}
    }

// Assembly:
subq $0x18, %rsp
movq 0x10(%rsi), %rax
movl 0x10(%rax), %ecx
movq %rsp, %r8
movl %ecx, 0x10(%r8)
movups (%rax), %xmm0
movaps %xmm0, (%r8)
movl 0x10(%rdi), %edi
movq (%rsi), %rax
movl 0x8(%rsi), %edx
movq %rax, %rsi
movl $0x40, %ecx
movl $0x14, %r9d
callq 0x2060
testq %rax, %rax
js 0x3051
addq $0x18, %rsp
retq
callq 0x2330
jmp 0x304c
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/src/Scheduler/Scheduler.cpp
// Function: nshdev::Scheduler::SchedulePackets()
void Scheduler::SchedulePackets()
{
    if(m_if.GetWaitFD() < 0)
    {
        RunAsyncPollLoop();
    }
    else
    {
        RunSyncPollLoop();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rdi
testl %eax, %eax
jns 0x348b
callq 0x3490
callq 0x34f2
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/src/test-case/cube-mask.cpp
// Function: bool analyseCubeMaskProperties<efgy::geometry::generators::mask::cube<3ul>>(std::ostream&)
bool analyseCubeMaskProperties(std::ostream &log) {
  auto faces = C::faces();

  long c = 0;

  for (auto &f : faces) {
    std::cerr << "\n[";
    for (auto v : f) {
      log << "  (";
      for (auto w : v) {
        log << " " << w;
      }
      log << " )";
    }
    log << " ]";

    auto t = f;
    c++;
  }

  if (C::size() != faces.size()) {
    log << "wrong size() result; object said it would have " << C::size()
        << " elements, but iterator gave us " << c << " elements.\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x139dc
movq 0x18(%rbx), %r15
leaq 0x20(%rsp), %rax
cmpq %rax, %r15
je 0x533b
movq $0x0, 0x10(%rsp)
leaq 0x117f8(%rip), %r12     # 0x16a71
movl $0x2, %edx
movq 0x1ad6b(%rip), %rdi     # 0x1fff0
leaq 0x11834(%rip), %rsi     # 0x16ac0
callq 0x42b0
movl $0x20, %ebx
movb 0x2(%r15,%rbx), %al
movb %al, 0xe(%rsp)
movzwl (%r15,%rbx), %eax
movw %ax, 0xc(%rsp)
movl $0x3, %edx
movq %r14, %rdi
leaq 0x1180b(%rip), %rsi     # 0x16ac3
callq 0x42b0
xorl %ebp, %ebp
movb 0xc(%rsp,%rbp), %r13b
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x42b0
movzbl %r13b, %esi
movq %r14, %rdi
callq 0x4390
incq %rbp
cmpq $0x3, %rbp
jne 0x52bf
movl $0x2, %edx
movq %r14, %rdi
leaq 0x117cf(%rip), %rsi     # 0x16ac7
callq 0x42b0
addq $0x3, %rbx
cmpq $0x2c, %rbx
jne 0x5296
movl $0x2, %edx
movq %r14, %rdi
leaq 0x117b4(%rip), %rsi     # 0x16aca
callq 0x42b0
incq 0x10(%rsp)
movq %r15, %rdi
callq 0x42d0
movq %rax, %r15
leaq 0x20(%rsp), %rax
cmpq %rax, %r15
jne 0x5279
jmp 0x5344
movq $0x0, 0x10(%rsp)
movq 0x40(%rsp), %rbx
cmpq $0x6, %rbx
je 0x53a8
leaq 0x11777(%rip), %rsi     # 0x16acd
movl $0x2f, %edx
movq %r14, %rdi
callq 0x42b0
movl $0x6, %esi
movq %r14, %rdi
callq 0x4190
movq %rax, %r14
leaq 0x11783(%rip), %rsi     # 0x16afd
movl $0x20, %edx
movq %rax, %rdi
callq 0x42b0
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x4220
leaq 0x11783(%rip), %rsi     # 0x16b1e
movl $0xb, %edx
movq %rax, %rdi
callq 0x42b0
cmpq $0x6, %rbx
sete %bl
leaq 0x18(%rsp), %rdi
callq 0x13d38
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53d0
jmp 0x53d0
jmp 0x53d0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13d38
movq %rbx, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O3/matengyue[P]Similar_test_demo/./src/deleteStopWords.h
// Function: ReadAllLinesFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> ReadAllLinesFromFile(const string &fn){
    vector<string> result;
    ifstream ifs(fn);

    //文件异常
    if (!ifs){
        throw runtime_error("Cannot open file!");
    }
    string tmp;
    while (ifs){
        getline(ifs, tmp);
        result.push_back(tmp);
    }
    result.erase(result.end() - 1);

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x2230
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x2a0a
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x29c8
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3860
jmp 0x298b
movq 0x8(%rbx), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0x3d38
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %r15
leaq 0x1602(%rip), %rsi      # 0x4020
movq %rax, %rdi
callq 0x20b0
movq 0x35c3(%rip), %rsi      # 0x5ff0
movq 0x3594(%rip), %rdx      # 0x5fc8
movq %r15, %rdi
callq 0x2250
movq %rax, %r14
jmp 0x2a6e
movq %rax, %r14
movq %r15, %rdi
callq 0x2120
jmp 0x2a6e
jmp 0x2a55
movq %rax, %r14
jmp 0x2a78
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2a6e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x389e
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/matengyue[P]Similar_test_demo/./src/deleteStopWords.h
// Function: deleteStopWords(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
vector<string> deleteStopWords(vector<string> vectorwords){
    vector<string> vectorwordsNStop;

    vector<string> stopwords = ReadAllLinesFromFile("../src/StopWord.txt");

    for (int i = 0; i < vectorwords.size(); i++){
        int flag = 1;
        for (int j = 0; j < stopwords.size(); j++){
            if (vectorwords[i] == stopwords[j]){
                flag = 0;
                break;
            }
        }
        if (flag){
            string word = vectorwords[i];
            vectorwordsNStop.push_back(word);    
        }
    }
    
    return vectorwordsNStop;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x30(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1574(%rip), %rsi      # 0x4032
leaq 0x1580(%rip), %rdx      # 0x4045
leaq 0x10(%rsp), %rdi
callq 0x3db4
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2929
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2af5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x30(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rcx
cmpq %rbx, %rcx
je 0x2bf3
xorl %ebp, %ebp
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r14
subq %r15, %r14
je 0x2b72
movq %rcx, 0x38(%rsp)
sarq $0x5, %r14
movq %rbp, %rax
shlq $0x5, %rax
leaq (%rbx,%rax), %r13
movq 0x8(%rbx,%rax), %r12
cmpq $0x1, %r14
adcq $0x0, %r14
addq $0x8, %r15
cmpq (%r15), %r12
jne 0x2b62
testq %r12, %r12
je 0x2bd3
movq -0x8(%r15), %rsi
movq (%r13), %rdi
movq %r12, %rdx
callq 0x21b0
testl %eax, %eax
je 0x2bd3
addq $0x20, %r15
decq %r14
jne 0x2b40
leaq 0x20(%rsp), %r13
jmp 0x2b7e
movq %rbp, %rax
shlq $0x5, %rax
movq 0x8(%rbx,%rax), %r12
movq %rbp, %rax
shlq $0x5, %rax
movq %r13, 0x10(%rsp)
movq (%rbx,%rax), %rsi
addq %rsi, %r12
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3a58
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x3860
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2bc5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x30(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rcx
jmp 0x2bdd
leaq 0x20(%rsp), %r13
movq 0x38(%rsp), %rcx
incq %rbp
movq %rcx, %rax
subq %rbx, %rax
sarq $0x5, %rax
cmpq %rbp, %rax
ja 0x2b0c
leaq 0x40(%rsp), %rdi
callq 0x389e
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2c5b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x2c5b
movq %rax, %r14
jmp 0x2c5b
movq %rax, %r14
jmp 0x2c51
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2c51
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x40(%rsp), %rdi
callq 0x389e
movq 0x8(%rsp), %rdi
callq 0x389e
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: Interpreter::expression()
long Interpreter::expression() {

    // set current token to the first token taken from the input
    _current_token = get_next_token();

    // we expect the current token to be an integer
    Token left = _current_token;
    eat(TOKENTYPE::INTEGER);

    long result = left.value;
    // loop while we still have tokens
    while(_current_token.type != TOKENTYPE::ENDOFFILE) {
        // we expect the current token to be an operator token
        switch(_current_token.type) {
        case TOKENTYPE::MINUS:
            eat(TOKENTYPE::MINUS);
            result = subtract(result);
            break;
        case TOKENTYPE::PLUS:
            eat(TOKENTYPE::PLUS);
            result = add(result);
            break;
        case TOKENTYPE::TIMES:
            eat(TOKENTYPE::TIMES);
            result = multiply(result);
            break;
        case TOKENTYPE::DIVIDE:
            eat(TOKENTYPE::DIVIDE);
            result = divide(result);
            break;
        case TOKENTYPE::ENDOFFILE:
            break;
        default:
            ostringstream out;
            out << "Error parsing input. Wanted operator, got: "
                << _current_token.type;
            throw(out.str().c_str());
        }
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %r14
callq 0x25ea
movq %rdx, %r15
leaq 0x18(%r14), %rbx
movl %eax, 0x18(%r14)
movq %rdx, 0x20(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x287e
leaq 0xb5b(%rip), %r12       # 0x3008
movl (%rbx), %eax
cmpq $0x5, %rax
ja 0x2534
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r14, %rdi
movl $0x2, %esi
callq 0x287e
addq 0x20(%r14), %r15
jmp 0x2513
movq %r14, %rdi
movl $0x5, %esi
callq 0x287e
movq %r14, %rdi
movq %r15, %rsi
callq 0x29ae
movq %rax, %r15
jmp 0x24ad
movq %r14, %rdi
movl $0x3, %esi
callq 0x287e
subq 0x20(%r14), %r15
jmp 0x2513
movq %r14, %rdi
movl $0x4, %esi
callq 0x287e
imulq 0x20(%r14), %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x287e
jmp 0x24ad
movq %r15, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2170
leaq 0xb6d(%rip), %rsi       # 0x30b5
movl $0x2b, %edx
movq %r14, %rdi
callq 0x2160
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x234c
movl $0x8, %edi
callq 0x2090
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x21c0
movq (%rsp), %rax
movq %rax, (%r14)
movq 0x2a26(%rip), %rsi      # 0x4fb0
movq %r14, %rdi
xorl %edx, %edx
callq 0x21e0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x25c4
movq %rax, %rbx
movq %r14, %rdi
callq 0x20e0
jmp 0x25c4
movq %rax, %rbx
movq 0x29f5(%rip), %rsi      # 0x4fc0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc2.cc
// Function: Interpreter::divide(long)
long  Interpreter::divide(long left_value) {
    // we expect the current token to be an integer
    Token right = _current_token;
    eat(TOKENTYPE::INTEGER);

    // Handle division by 0
    if (right.value == 0) {
        throw("Division by zero");
    }
    // after the above call _current_token is set to ENDOFFILE token

    // at this point INTEGER TIMES INTEGER sequence of tokens has been
    // successfully found and the method can just return the result of
    // dividing two integers, thus effectively interpreting client input
    return left_value / right.value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x20(%rdi), %r14
movl $0x1, %esi
callq 0x287e
testq %r14, %r14
je 0x29d8
movq %rbx, %rax
cqto
idivq %r14
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x2090
leaq 0x6f8(%rip), %rcx       # 0x30e1
movq %rcx, (%rax)
movq 0x25bd(%rip), %rsi      # 0x4fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/allasandeep[P]LocationBoundaryFinder/prog1.cc
// Function: openFiles(std::basic_ifstream<char, std::char_traits<char>>&, char*)
void openFiles( ifstream& is, char *fileName)
{
	// opening the input file. 
	is.open(fileName);
	// If the file fails to open,then displays an error message. 
	if(is.fail()) 
	{
		cerr<<"Error Message:: Unable to read" <<fileName<< endl;
		exit(EXIT_FAILURE);
	}		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %edx
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x278d
popq %rbx
popq %r14
popq %rbp
retq
movq 0x385c(%rip), %rdi      # 0x5ff0
leaq 0x197e(%rip), %rsi      # 0x4119
callq 0x2150
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2250
movl $0x1, %edi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/CoRoT7/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "corot7.txt";

    load(datafile, "ms");

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x30152(%rip), %rdx     # 0x50548
leaq 0x30143(%rip), %r14     # 0x50540
leaq 0x224e9(%rip), %rcx     # 0x428ed
movl $0xa, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x1d0f6(%rip), %rsi     # 0x3d511
movq %r14, %rdi
callq 0x2061b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x20719
movq %r14, %rdi
movl $0x32, %esi
callq 0x207ea
leaq 0x8(%rsp), %rdi
callq 0x209c8
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x209c8
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::turnBlock(int)
void BasicBoard::turnBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->turnPos(amount/abs(amount)));
	cout << valid <<endl;
		if (valid) currentBlock->turn(amount/abs(amount));
		else break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
je 0x6cd3
movq %rdi, %rbx
movl %esi, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
movl %esi, %r15d
negl %r15d
cmovsl %esi, %r15d
movq %rsp, %r14
movq 0xb8(%rbx), %rsi
movq (%rsi), %rax
movq %r14, %rdi
movl %ebp, %edx
callq *0x28(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rax)
movl %eax, %r12d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6c79
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movzbl %r12b, %r12d
movq 0x14344(%rip), %rdi     # 0x1afc8
movl %r12d, %esi
callq 0x5440
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %esi
movq %r13, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51c0
testb %r12b, %r12b
je 0x6cd3
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
decl %r15d
jne 0x6c42
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6cfb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O3/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::moveBlock(int)
void BasicBoard::moveBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->movePos(amount/abs(amount)));
		if (valid) currentBlock->move(amount/abs(amount));
		else break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testl %esi, %esi
je 0x6d7f
movq %rdi, %rbx
movl %esi, %ebp
sarl $0x1f, %ebp
orl $0x1, %ebp
movl %esi, %r12d
negl %r12d
cmovsl %esi, %r12d
leaq 0x8(%rsp), %r14
movq 0xb8(%rbx), %rsi
movq (%rsi), %rax
movq %r14, %rdi
movl %ebp, %edx
callq *0x20(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rax)
movl %eax, %r15d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6d66
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
testb %r15b, %r15b
je 0x6d7f
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x10(%rax)
decl %r12d
jne 0x6d2e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6da6
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
// File: /workspace/github_cpp_makefile_star2_O3/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::downBlock(int)
void BasicBoard::downBlock(int amount) {
	for (int i = 0; i < abs(amount); ++i) {
		bool valid = validMove(currentBlock->downPos(1));
		if (valid) {
			currentBlock->down(1);
		}
		else break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
je 0x6e1f
movq %rdi, %rbx
movl %esi, %r15d
negl %r15d
cmovsl %esi, %r15d
movq %rsp, %r14
movq 0xb8(%rbx), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x8918
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x50(%rax)
movl %eax, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e04
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
testb %bpl, %bpl
je 0x6e1f
movq 0xb8(%rbx), %rdi
movl $0x1, %esi
callq 0x8828
decl %r15d
jne 0x6dcc
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e43
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O3/EstherJin[P]TetrisRemake/basicboard.cc
// Function: BasicBoard::changeCurrentBlock(char)
void BasicBoard::changeCurrentBlock(char type) {
	if (type == 'I') currentBlock = make_unique<I>();
	else if (type == 'J') currentBlock = make_unique<J>();
	else if (type == 'L') currentBlock = make_unique<L>();
	else if (type == 'O') currentBlock = make_unique<O>();
	else if (type == 'S') currentBlock = make_unique<S>();
	else if (type == 'Z') currentBlock = make_unique<Z>();
	//else if (type == '.') currentBlock = make_unique<Dot>();
	else currentBlock = make_unique<T>();
	currentBlock->attach(&sg);
	if (!textOnly) currentBlock->attach(&gd);
	currentBlock->notifCurrPos();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
movl $0x50, %edi
callq 0x52b0
movq %rax, %r14
leal -0x49(%r15), %eax
cmpl $0xa, %eax
ja 0x77d7
leaq 0xb930(%rip), %rcx      # 0x130f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0xa84c
jmp 0x7817
cmpl $0x5a, %r15d
jne 0x77e7
movq %r14, %rdi
callq 0x11a18
jmp 0x7817
movq %r14, %rdi
callq 0x10fc8
jmp 0x7817
movq %r14, %rdi
callq 0xfa88
jmp 0x7817
movq %r14, %rdi
callq 0xe42c
jmp 0x7817
movq %r14, %rdi
callq 0xd8c4
jmp 0x7817
movq %r14, %rdi
callq 0xf41c
movq 0xb8(%rbx), %rdi
movq %r14, 0xb8(%rbx)
testq %rdi, %rdi
je 0x7830
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xb8(%rbx), %rdi
addq $0x8, %rdi
leaq 0x8(%rbx), %rsi
callq 0x10e14
cmpb $0x0, 0xa8(%rbx)
jne 0x7861
movq 0xb8(%rbx), %rdi
addq $0x8, %rdi
leaq 0x30(%rbx), %rsi
callq 0x10e14
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x30(%rax)
jmp 0x787f
jmp 0x787f
jmp 0x787f
jmp 0x787f
jmp 0x787f
jmp 0x787f
movq %rax, %rbx
movl $0x50, %esi
movq %r14, %rdi
callq 0x52c0
movq %rbx, %rdi
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O3/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::~Block1()
Block1::~Block1(){
  for (int i = 0; i < coords.size(); ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x11d1f(%rip), %rax     # 0x1a340
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
cmpq %rdi, 0x38(%rbx)
je 0x8683
leaq 0x8(%rbx), %r14
xorl %r12d, %r12d
movabsq $-0x10000000000, %r13   # imm = 0xFFFFFF0000000000
movq %r15, %rax
andq %r13, %rax
movl (%rdi,%r12,8), %esi
movl 0x4(%rdi,%r12,8), %r15d
shlq $0x20, %rsi
orq %rax, %r15
orq $0x20, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x10e5a
movq %r14, %rdi
callq 0x10e2c
incq %r12
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x863f
testq %rdi, %rdi
je 0x8694
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x86b2
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x52c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x63d3
// File: /workspace/github_cpp_makefile_star2_O3/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::move(int)
void Block1::move(int shift){
  for (int i = 0; i < coords.size(); ++i){
    State stat = {' ', coords[i], false};
    setState(stat);
    notifyObservers();
  }
  for (int i = 0; i < coords.size(); ++i){
    coords.at(i).col += shift;
    State stat = {c, coords[i], true};
    setState(stat);
    notifyObservers();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movabsq $-0x10000000000, %r13   # imm = 0xFFFFFF0000000000
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
cmpq %rax, %rcx
je 0x8753
leaq 0x8(%r14), %r15
xorl %ebp, %ebp
movl (%rax,%rbp,8), %esi
movl 0x4(%rax,%rbp,8), %eax
shlq $0x20, %rsi
andq %r13, %r12
orq %rax, %r12
orq $0x20, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x10e5a
movq %r15, %rdi
callq 0x10e2c
incq %rbp
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbp, %rdx
ja 0x8711
cmpq %rax, %rcx
je 0x87ac
leaq 0x8(%r14), %r15
xorl %ebp, %ebp
movl 0x4(%rax,%rbp,8), %ecx
addl %ebx, %ecx
movl %ecx, 0x4(%rax,%rbp,8)
movzbl 0x4c(%r14), %edx
movl (%rax,%rbp,8), %esi
shlq $0x20, %rsi
orq %rdx, %rsi
andq %r13, %r12
orq %rcx, %r12
btsq $0x20, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x10e5a
movq %r15, %rdi
callq 0x10e2c
incq %rbp
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
ja 0x875e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/EstherJin[P]TetrisRemake/block1.cc
// Function: Block1::movePos(int)
vector<Coordinates> Block1::movePos(int shift){
  vector<Coordinates> cds = coords;
  for (int i = 0; i < 4; ++i){
    cds.at(i).col += shift;
  }
  return cds;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
addq $0x30, %rsi
callq 0x8a30
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x87f8
addl %ebp, 0x4(%rax,%rcx,8)
incq %rcx
cmpq $0x4, %rcx
jne 0x87de
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa965(%rip), %rdi      # 0x13164
movq %rdx, %rsi
xorl %eax, %eax
callq 0x53d0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8820
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5480