LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/monitor.cpp
// Function: Project::Monitor::cmdSplit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char** Monitor::cmdSplit(std::string str)
{
    //string to char*
    std::vector<std::string> buf;
    std::string tmp;
    std::stringstream ss;
    ss<<str;
    
    while(ss>>tmp)
    {
        buf.push_back(tmp + "");
    }
     
    //char* to char**
    char** pList=new char*[buf.size()];
    for(int i=0; i!=buf.size();i++)
    {
        pList[i]=const_cast<char*>(buf[i].c_str());
    }
    //cout<<pList<<endl;

    //delete[] pList;
    return pList;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %rbx
andq $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x208(%rbp), %rdi
callq 0x2180
leaq -0x1f8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2210
leaq -0x208(%rbp), %rbx
leaq -0x60(%rbp), %r14
leaq 0x8c8e(%rip), %r15      # 0xc258
leaq -0x80(%rbp), %r12
leaq -0x40(%rbp), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x360e
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3d39
movq %r13, %rdi
movq %r12, %rsi
callq 0x418a
movq %r12, %rdi
callq 0x2100
jmp 0x35d2
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %rax
subq %r14, %rax
movq %rax, %r15
sarq $0x5, %r15
movq %r15, %rcx
shrq $0x3d, %rcx
sarq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x2030
movq %rax, %rbx
xorl %eax, %eax
cmpq %rax, %r15
je 0x3655
movq (%r14), %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
addq $0x20, %r14
jmp 0x3640
leaq -0x208(%rbp), %rdi
callq 0x21b0
leaq -0x60(%rbp), %rdi
callq 0x2100
leaq -0x40(%rbp), %rdi
callq 0x3d72
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36a1
jmp 0x36a1
movq %rax, %rbx
jmp 0x36b0
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2100
jmp 0x36a4
jmp 0x36a1
movq %rax, %rbx
leaq -0x208(%rbp), %rdi
callq 0x21b0
leaq -0x60(%rbp), %rdi
callq 0x2100
leaq -0x40(%rbp), %rdi
callq 0x3d72
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::sig_handler(int)
static void sig_handler(int sig){
        std::cout << std::endl;
        if(sig==SIGTSTP){ 
            std::cout << "\033[34;1mThe Job is suspended ...\033[0m" << std::endl;
            //std::cout << m[getpid()]<< std::endl;
            kill(m[getpid()], SIGTSTP);         
            signal(SIGTSTP, sig_handler);
        }
        else if(sig==SIGCONT){ 
            std::cout << "\033[32;1mThe Job resumes ... \033[0m" << std::endl;
            //std::cout <<m[getpid()] << std::endl;
            kill(m[getpid()], SIGCONT);
            signal(SIGCONT, sig_handler);
        }
        else if(sig==SIGTERM){
            std::cout << "\033[31;1mThe Job terminate ... \033[0m" << std::endl;
            //std::cout <<m[getpid()] << " child " <<std::endl;
            kill(m[getpid()], SIGKILL);
            //signal(SIGTERM, sig_handler);
        }
        
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movq 0xe67b(%rip), %rdi      # 0x11fc0
callq 0x2110
cmpl $0xf, %ebx
je 0x39e7
cmpl $0x12, %ebx
je 0x3999
cmpl $0x14, %ebx
jne 0x3a23
movq 0xe658(%rip), %rdi      # 0x11fc0
leaq 0x87a9(%rip), %rsi      # 0xc118
callq 0x2230
movq %rax, %rdi
callq 0x2110
callq 0x2300
leaq -0x14(%rbp), %rsi
movl %eax, (%rsi)
leaq 0xedb2(%rip), %rdi      # 0x12740
callq 0x3d9e
movl (%rax), %edi
pushq $0x14
jmp 0x39cf
movq 0xe620(%rip), %rdi      # 0x11fc0
leaq 0x8795(%rip), %rsi      # 0xc13c
callq 0x2230
movq %rax, %rdi
callq 0x2110
callq 0x2300
leaq -0x10(%rbp), %rsi
movl %eax, (%rsi)
leaq 0xed7a(%rip), %rdi      # 0x12740
callq 0x3d9e
movl (%rax), %edi
pushq $0x12
popq %rbx
movl %ebx, %esi
callq 0x22d0
leaq -0xab(%rip), %rsi       # 0x3933
movl %ebx, %edi
callq 0x2260
jmp 0x3a23
movq 0xe5d2(%rip), %rdi      # 0x11fc0
leaq 0x8767(%rip), %rsi      # 0xc15c
callq 0x2230
movq %rax, %rdi
callq 0x2110
callq 0x2300
leaq -0xc(%rbp), %rsi
movl %eax, (%rsi)
leaq 0xed2c(%rip), %rdi      # 0x12740
callq 0x3d9e
movl (%rax), %edi
pushq $0x9
popq %rsi
callq 0x22d0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/monitor.cpp
// Function: Project::Monitor::print_time()
void Monitor::print_time(){
    cout<<"Job Process "<<setw(6)<<get_pid()<<" : Time Elapsed: "<<get_timeElapsed()<<'\n';
    cout<<setfill(' ')<<setw(35)<<"User Time   : "<<get_userTime()<<'\n';
    cout<<setfill(' ')<<setw(35)<<"System Time : "<<get_systemTime()<<'\n';
    cout << "=================================================" << '\n';
    cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xe530(%rip), %rbx      # 0x11fc0
leaq 0x8644(%rip), %rsi      # 0xc0db
movq %rbx, %rdi
callq 0x2230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x6, 0x10(%rax,%rcx)
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x23a0
leaq 0x8626(%rip), %rsi      # 0xc0e8
movq %rax, %rdi
callq 0x2230
movsd 0x70(%r14), %xmm0
movq %rax, %rdi
callq 0x2350
pushq $0xa
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x2250
pushq $0x20
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x23
popq %r13
movq %r13, 0x10(%rax,%rcx)
leaq 0x85ed(%rip), %rsi      # 0xc0fa
movq %rax, %rdi
callq 0x2230
movsd 0x60(%r14), %xmm0
movq %rax, %rdi
callq 0x2350
movq %rax, %rdi
movl %r15d, %esi
callq 0x2250
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r13, 0x10(%rax,%rcx)
leaq 0x85bd(%rip), %rsi      # 0xc109
movq %rax, %rdi
callq 0x2230
movsd 0x68(%r14), %xmm0
movq %rax, %rdi
callq 0x2350
movq %rax, %rdi
movl %r15d, %esi
callq 0x2250
leaq 0x878b(%rip), %rsi      # 0xc2ff
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
movl %r15d, %esi
callq 0x2250
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/monitor.cpp
// Function: Project::Monitor::Monitor(char**)
Monitor::Monitor(char *command[]):command(command)
{
    int process;
    int status;
    
    start = times(&t_start);
    process = fork();

    if(process < 0){
        status = -1;
    }
    else if(process == 0){ 
        //signal(SIGINT, SIG_DFL); //Default handle every child process
        execvp(command[0],command);
        throw invalid_argument("Fail to execute Child Process!\n");
    }
    else{
        int status;
        set_pid(process);
        signal(SIGTSTP, sig_handler);
        signal(SIGCONT, sig_handler);
        signal(SIGTERM, sig_handler);
        waitpid(process,&status,0);

	// quit loop if the child process has been terminated!
    }
    
     // calculate time
    end = times(&t_end);  
    set_timeElapsed(end-start);
    set_userTime(t_end.tms_cutime);
    set_systermTime(t_end.tms_cstime);
    
    // output 
    cout << endl;        
    cout << endl;
    print_time();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
andl $0x0, 0x8(%rdi)
leaq 0x88(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
andq $0x0, 0x70(%rdi)
movq %rax, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
movb $0x0, 0x88(%rdi)
andl $0x0, 0xa0(%rdi)
addq $0x20, %rdi
callq 0x2360
movq %rax, 0x10(%rbx)
callq 0x2090
testl %eax, %eax
js 0x3c3c
je 0x3c9b
movl %eax, %r15d
movl %eax, 0x8(%rbx)
leaq -0x2da(%rip), %r14      # 0x3933
pushq $0x14
popq %rdi
movq %r14, %rsi
callq 0x2260
pushq $0x12
popq %rdi
movq %r14, %rsi
callq 0x2260
pushq $0xf
popq %rdi
movq %r14, %rsi
callq 0x2260
leaq -0x1c(%rbp), %rsi
movl %r15d, %edi
xorl %edx, %edx
callq 0x21f0
leaq 0x40(%rbx), %rdi
callq 0x2360
movq %rax, 0x18(%rbx)
subq 0x10(%rbx), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a2a
movq 0x50(%rbx), %rsi
movq %rbx, %rdi
callq 0x3a44
movq 0x58(%rbx), %rsi
movq %rbx, %rdi
callq 0x3a5e
movq 0xe349(%rip), %rdi      # 0x11fc0
callq 0x2110
movq 0xe33d(%rip), %rdi      # 0x11fc0
callq 0x2110
movq %rbx, %rdi
callq 0x3a78
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movq %r14, %rsi
callq 0x21d0
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %r15
leaq 0x83eb(%rip), %rsi      # 0xc0a3
movq %rax, %rdi
callq 0x23e0
movq 0xe319(%rip), %rsi      # 0x11fe0
movq 0xe302(%rip), %rdx      # 0x11fd0
movq %r15, %rdi
callq 0x2390
movq %rax, %r14
movq %r15, %rdi
callq 0x21a0
jmp 0x3ce8
jmp 0x3ce5
movq %rax, %r14
addq $0x78, %rbx
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::Scheduler(char*, char*)
Scheduler::Scheduler(char *f, char *p) : policyInfo(p)
{
    string tmp = Utils::readFile(f);
    normalizeCheck(tmp);
    splitToken(tmp);
    job_num = job_queue.size();
    choosePolicy();
    //sort(job_queue.begin(),job_queue.end());
    //schedulerDrive();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x118(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x20c0
leaq -0x34(%rbp), %rdx
andl $0x0, (%rdx)
leaq 0x7def(%rip), %rsi      # 0xc1ad
leaq -0x118(%rbp), %r14
movq %r14, %rdi
callq 0x7494
leaq -0xf0(%rbp), %r12
leaq -0x30(%rbp), %rdx
movl $0x1, (%rdx)
leaq 0x7dcd(%rip), %rsi      # 0xc1b2
movq %r12, %rdi
callq 0x7494
leaq -0xc8(%rbp), %r12
leaq -0x2c(%rbp), %rdx
movl $0x2, (%rdx)
leaq 0x7db2(%rip), %rsi      # 0xc1b7
movq %r12, %rdi
callq 0x7494
leaq -0xa0(%rbp), %r12
leaq -0x28(%rbp), %rdx
movl $0x3, (%rdx)
leaq 0x7d97(%rip), %rsi      # 0xc1bc
movq %r12, %rdi
callq 0x74be
leaq 0x20(%rbx), %r14
leaq -0x78(%rbp), %rdx
leaq -0x21(%rbp), %rax
movq %rax, (%rsp)
leaq -0x118(%rbp), %rsi
leaq -0x23(%rbp), %r8
leaq -0x22(%rbp), %r9
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xa100
pushq $0x78
popq %r12
leaq (%r12,%rbp), %rdi
addq $-0x118, %rdi           # imm = 0xFEE8
callq 0x2100
addq $-0x28, %r12
cmpq $-0x28, %r12
jne 0x445a
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
andq $0x0, 0x70(%rbx)
leaq -0x118(%rbp), %rdi
movq %r15, %rsi
callq 0x2cbc
leaq -0x78(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x22c0
leaq -0x78(%rbp), %rsi
callq 0x459e
leaq -0x78(%rbp), %rdi
callq 0x2100
leaq -0x58(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x22c0
leaq -0x58(%rbp), %rsi
callq 0x46a0
leaq -0x58(%rbp), %rdi
callq 0x2100
movq 0xe33e(%rip), %rax      # 0x12818
subq 0xe32f(%rip), %rax      # 0x12810
pushq $0x58
popq %rcx
cqto
idivq %rcx
movl %eax, 0x58(%rbx)
movq %rbx, %rdi
callq 0x4852
leaq -0x118(%rbp), %rdi
callq 0x2100
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq -0x58(%rbp), %rdi
jmp 0x4520
movq %rax, %r15
leaq -0x78(%rbp), %rdi
callq 0x2100
jmp 0x4571
movq %rax, %r15
jmp 0x457d
movq %rax, %r15
pushq $0x78
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0x118, %rdi           # imm = 0xFEE8
callq 0x2100
addq $-0x28, %r14
cmpq $-0x28, %r14
jne 0x4533
jmp 0x458e
jmp 0x4553
jmp 0x4553
movq %rax, %r15
addq $-0x28, %r12
movq %r12, %rdi
callq 0x2100
cmpq %r14, %r12
jne 0x4556
jmp 0x458e
movq %rax, %r15
jmp 0x458e
movq %rax, %r15
leaq -0x118(%rbp), %rdi
callq 0x2100
leaq 0x60(%rbx), %rdi
callq 0x74e8
movq %r14, %rdi
callq 0x760e
movq %rbx, %rdi
callq 0x2100
movq %r15, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::normalizeCheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Scheduler::normalizeCheck(string cont)
{

    int arg_num = 0;

    for (int i = 0; i < cont.length(); ++i)
    {
        if (cont[i] == '\n')
        {

            if (cont[i - 1] == '\n')
            {
                if (cont[i - 2] == '\t')
                {
                    throw invalid_argument("Argument Error: Empty argument!");
                }
                continue;
            }

            if (cont[i - 1] == '\t')
            {
                throw invalid_argument("Argument Error: Empty argument!");
            }

            arg_num++;
            if (arg_num > 3)
            {
                throw invalid_argument("Argument Error: Job description file has redundant arguments!");
            }
            if (arg_num < 3)
            {
                throw invalid_argument("Argument Error: Job description file has less arguments!");
            }
            arg_num = 0;
        }
        if (cont[i] == '\t')
        {
            arg_num++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rcx, %rax
jbe 0x45fd
movq (%rsi), %r8
movb (%r8,%rcx), %dil
cmpb $0xa, %dil
jne 0x45e0
movzbl -0x1(%r8,%rcx), %r9d
cmpl $0xa, %r9d
je 0x45f0
cmpl $0x9, %r9d
je 0x463a
cmpl $0x3, %edx
jge 0x4602
cmpl $0x2, %edx
movl $0x0, %edx
jne 0x461e
xorl %r8d, %r8d
cmpb $0x9, %dil
sete %r8b
addl %r8d, %edx
jmp 0x45f8
cmpb $0x9, -0x2(%r8,%rcx)
je 0x4656
incq %rcx
jmp 0x45ad
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x7bcb(%rip), %rsi      # 0xc1df
movq %rax, %rdi
callq 0x23e0
jmp 0x4670
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x7bed(%rip), %rsi      # 0xc21d
movq %rax, %rdi
callq 0x23e0
jmp 0x4670
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x7b73(%rip), %rsi      # 0xc1bf
movq %rax, %rdi
callq 0x23e0
jmp 0x4670
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x7b57(%rip), %rsi      # 0xc1bf
movq %rax, %rdi
callq 0x23e0
movq 0xd969(%rip), %rsi      # 0x11fe0
movq 0xd952(%rip), %rdx      # 0x11fd0
movq %rbx, %rdi
callq 0x2390
jmp 0x468c
jmp 0x468c
jmp 0x468c
movq %rax, %r14
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::splitToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Scheduler::splitToken(string str)
{
    int cnt = 0;
    char *strBuf = const_cast<char *>(str.c_str());

    char *token = strtok(strBuf, "\t\n");
    Job job = Job();
    while (token != NULL)
    {
        cnt++;
        if (cnt % 3 == 1)
        {
            job.ID = 1 + cnt/3; // assign job id
            Utils::arg_check(token);
            string buf(token);
            job.set_arr_time(stoi(buf));
        }
        else if (cnt % 3 == 2)
        {
            string buf(token);
            job.set_cmd(buf);
        }
        else
        {
            Utils::arg_check(token);
            string buf(token);
            job.set_dur_time(stoi(buf));
            job_queue.push_back(job);
        }
        token = strtok(NULL, "\t\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq (%rsi), %rdi
leaq 0x7b98(%rip), %rsi      # 0xc256
callq 0x2320
leaq -0xb8(%rbp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x20(%rcx)
movups %xmm0, (%rcx)
andq $0x0, 0x40(%rcx)
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movq %rax, %r12
andl $0x0, 0x18(%rcx)
pushq $0x1
popq %r14
pushq $0x3
popq %r13
leaq -0x50(%rbp), %r15
leaq -0xc8(%rbp), %rbx
movl %r14d, %eax
xorl %edx, %edx
divl %r13d
testq %r12, %r12
je 0x47f6
imull $-0x3, %eax, %ecx
addl %r14d, %ecx
movl %r14d, %eax
xorl %edx, %edx
divl %r13d
cmpl $0x2, %ecx
je 0x4765
cmpl $0x1, %ecx
jne 0x4798
incl %eax
movl %eax, -0x9c(%rbp)
movq %r12, %rdi
callq 0x2de4
movq %r15, %rdi
movq %r12, %rsi
leaq -0x29(%rbp), %rdx
callq 0x20c0
movq %r15, %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x2f06
movq %rbx, %rdi
movl %eax, %esi
callq 0x347e
jmp 0x47d5
movq %r15, %rdi
movq %r12, %rsi
leaq -0x29(%rbp), %rdx
callq 0x20c0
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x22c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3474
movq %r12, %rdi
callq 0x2100
jmp 0x47d5
movq %r12, %rdi
callq 0x2de4
movq %r15, %rdi
movq %r12, %rsi
leaq -0x29(%rbp), %rdx
callq 0x20c0
movq %r15, %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x2f06
movq %rbx, %rdi
movl %eax, %esi
callq 0x3488
leaq 0xe043(%rip), %rdi      # 0x12810
movq %rbx, %rsi
callq 0x7514
movq %r15, %rdi
callq 0x2100
xorl %edi, %edi
leaq 0x7a70(%rip), %rsi      # 0xc256
callq 0x2320
movq %rax, %r12
incl %r14d
jmp 0x4704
leaq -0xc8(%rbp), %rdi
callq 0x2100
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x482c
jmp 0x482c
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2100
jmp 0x4834
jmp 0x482c
jmp 0x4831
jmp 0x4831
movq %rax, %rbx
jmp 0x483d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2100
leaq -0xc8(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::choosePolicy()
void Scheduler::choosePolicy()
{
    auto cho = policyMap.find(policyInfo);
    if (cho == policyMap.end())
    {
        throw invalid_argument("Invalid policy!");
        exit(-1);
    }
    switch (cho->second)
    {
    case Policy::FIFO:
        /* FIFO function interface*/
        driveFIFO();
        break;
    case Policy::NONPREEMSJF:
        /*non-preetive SJF function interface*/
        driveSJF1();
        break;
    case Policy::PREESJF:
        /*preetive SJF function interface*/
        driveSJF2();
        break;
    case Policy::RR:
        /*RR function interface*/
        driveRR();
        break;
    default:
        throw invalid_argument("Invalid policy!");
        break;
    }
    //cout << *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
movq %rbx, %rsi
callq 0xa82a
testq %rax, %rax
je 0x48b6
movl 0x28(%rax), %eax
cmpq $0x3, %rax
ja 0x48e6
leaq 0x791f(%rip), %rcx      # 0xc19c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x49fe
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x545e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d3c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4e82
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x7991(%rip), %rsi      # 0xc259
movq %rax, %rdi
callq 0x23e0
movq 0xd709(%rip), %rsi      # 0x11fe0
movq 0xd6f2(%rip), %rdx      # 0x11fd0
movq %rbx, %rdi
callq 0x2390
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x7961(%rip), %rsi      # 0xc259
movq %rax, %rdi
callq 0x23e0
jmp 0x48d0
jmp 0x4904
movq %rax, %r14
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/scheduler.cpp
// Function: Project::Scheduler::find_dur_time(Project::Job, int&)
void Scheduler::find_dur_time(Job j, int& t){
    long tps=sysconf(_SC_CLK_TCK);

    tms start, end;
    clock_t s, e;
    s = times(&start);
    int pID = fork();
    if(pID == 0){ Monitor* monitor = new Monitor(j); exit(0);}
    else{
        waitpid(pID, 0, 0);
        e = times(&end); 
        double realtime = (double)(e-s)/tps;
        
        if(round(realtime)==0){t = 1;}
        else{t= round(realtime);}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %rbx
movq %rsi, %r15
pushq $0x2
popq %rdi
callq 0x2170
movq %rax, %r14
leaq -0xb8(%rbp), %rdi
callq 0x2360
movq %rax, %r12
callq 0x2090
testl %eax, %eax
je 0x49a7
movl %eax, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21f0
leaq -0x98(%rbp), %rdi
callq 0x2360
subq %r12, %rax
cvtsi2sd %rax, %xmm0
cvtsi2sd %r14, %xmm1
divsd %xmm1, %xmm0
callq 0x20e0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
pushq $0x1
popq %rcx
cmovnel %eax, %ecx
cmovpl %eax, %ecx
movl %ecx, (%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xd0, %edi
callq 0x2240
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0x350a
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x36ca
leaq -0x78(%rbp), %rdi
callq 0x2e9c
xorl %edi, %edi
callq 0x2270
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2100
jmp 0x49ed
movq %rax, %r14
movq %rbx, %rdi
callq 0x2220
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::signal_nonpreem(int)
static void signal_nonpreem(int sig){
        
        //std::cout << wait_queue.size() <<std::endl;
        
        if(scheduler.empty() && wait_queue.empty()){stop_flag = true;}
            
        kill(monitor_map[this_job.ID], SIGTERM);  
        
        if(!wait_queue.empty()){
            auto tmp = wait_queue.front();
            wait_queue.pop();

            kill(monitor_map[tmp.ID], SIGCONT);   
            this_job = tmp;

            signal(SIGALRM, signal_nonpreem);
            alarm(tmp.get_dur_time());
        }
        else{allow_preem = true; }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq 0xc45b(%rip), %rax      # 0x12858
cmpq 0xc434(%rip), %rax      # 0x12838
jne 0x641d
movq 0xc49b(%rip), %rax      # 0x128a8
cmpq 0xc474(%rip), %rax      # 0x12888
jne 0x641d
movb $0x1, 0xc56b(%rip)      # 0x12988
leaq 0xc52c(%rip), %rdi      # 0x12950
leaq 0xc3b9(%rip), %rsi      # 0x127e4
callq 0x9faa
movl (%rax), %edi
pushq $0xf
popq %rsi
callq 0x22d0
movq 0xc447(%rip), %rsi      # 0x12888
cmpq %rsi, 0xc460(%rip)      # 0x128a8
je 0x64b3
leaq -0x60(%rbp), %rdi
callq 0x350a
leaq 0xc41e(%rip), %rdi      # 0x12878
callq 0xa080
leaq -0x34(%rbp), %rsi
leaq 0xc4e6(%rip), %rdi      # 0x12950
callq 0x9faa
movl (%rax), %edi
pushq $0x12
popq %rsi
callq 0x22d0
leaq 0xc338(%rip), %rdi      # 0x127b8
leaq -0x60(%rbp), %rsi
callq 0x758c
leaq -0xa3(%rip), %rsi       # 0x63ed
pushq $0xe
popq %rdi
callq 0x2260
leaq -0x60(%rbp), %rdi
callq 0x34be
movl %eax, %edi
callq 0x23d0
leaq -0x60(%rbp), %rdi
callq 0x2100
jmp 0x64ba
movb $0x0, 0xc4cf(%rip)      # 0x12989
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::signal_RR(int)
static void signal_RR(int sig){
        
        if(scheduler.empty() && wait_queue.empty()){stop_flag = true;}
        
        if(this_job.service_time_left <= QUANT){
            kill(monitor_map[this_job.ID], SIGTERM);  
        }
        else{
            kill(monitor_map[this_job.ID], SIGTSTP);
        }
    
        if(!wait_queue.empty()){
            auto tmp = wait_queue.front();
            wait_queue.pop();

            kill(monitor_map[tmp.ID], SIGCONT);   
            this_job = tmp;

            signal(SIGALRM, signal_RR);
            alarm(tmp.get_dur_time());
        }
        else{allow_preem = true; }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq 0xc02e(%rip), %rax      # 0x12858
cmpq 0xc007(%rip), %rax      # 0x12838
jne 0x684a
movq 0xc06e(%rip), %rax      # 0x128a8
cmpq 0xc047(%rip), %rax      # 0x12888
jne 0x684a
movb $0x1, 0xc13e(%rip)      # 0x12988
xorl %ebx, %ebx
cmpl $0x3, 0xbf95(%rip)      # 0x127e8
setge %bl
leaq 0xc0f3(%rip), %rdi      # 0x12950
leaq 0xbf80(%rip), %rsi      # 0x127e4
callq 0x9faa
movl (%rax), %edi
leal (%rbx,%rbx,4), %esi
addl $0xf, %esi
callq 0x22d0
movq 0xc00b(%rip), %rsi      # 0x12888
cmpq %rsi, 0xc024(%rip)      # 0x128a8
je 0x68ef
leaq -0x60(%rbp), %rdi
callq 0x350a
leaq 0xbfe2(%rip), %rdi      # 0x12878
callq 0xa080
leaq -0x34(%rbp), %rsi
leaq 0xc0aa(%rip), %rdi      # 0x12950
callq 0x9faa
movl (%rax), %edi
pushq $0x12
popq %rsi
callq 0x22d0
leaq 0xbefc(%rip), %rdi      # 0x127b8
leaq -0x60(%rbp), %rsi
callq 0x758c
leaq -0xb2(%rip), %rsi       # 0x681a
pushq $0xe
popq %rdi
callq 0x2260
leaq -0x60(%rbp), %rdi
callq 0x34be
movl %eax, %edi
callq 0x23d0
leaq -0x60(%rbp), %rdi
callq 0x2100
jmp 0x68f6
movb $0x0, 0xc093(%rip)      # 0x12989
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/./project.h
// Function: Project::signal_preemSJF(int)
static void signal_preemSJF(int sig){
        
        if(scheduler.empty() && wait_queue.empty()){stop_flag = true;}
        
        if(this_job.service_time_left == 2){
            kill(monitor_map[this_job.ID], SIGTERM);  
        }
        else{
            kill(monitor_map[this_job.ID], SIGTSTP);
        }
    
        if(!wait_queue.empty()){
            auto tmp = wait_queue.front();
            wait_queue.pop();

            kill(monitor_map[tmp.ID], SIGCONT);   
            this_job = tmp;

            signal(SIGALRM, signal_preemSJF);
            alarm(tmp.get_dur_time());
        }
        else{allow_preem = true; }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq 0xbf37(%rip), %rax      # 0x12858
cmpq 0xbf10(%rip), %rax      # 0x12838
jne 0x6941
movq 0xbf77(%rip), %rax      # 0x128a8
cmpq 0xbf50(%rip), %rax      # 0x12888
jne 0x6941
movb $0x1, 0xc047(%rip)      # 0x12988
xorl %ebx, %ebx
cmpl $0x2, 0xbe9e(%rip)      # 0x127e8
setne %bl
leaq 0xbffc(%rip), %rdi      # 0x12950
leaq 0xbe89(%rip), %rsi      # 0x127e4
callq 0x9faa
movl (%rax), %edi
leal (%rbx,%rbx,4), %esi
addl $0xf, %esi
callq 0x22d0
movq 0xbf14(%rip), %rsi      # 0x12888
cmpq %rsi, 0xbf2d(%rip)      # 0x128a8
je 0x69e6
leaq -0x60(%rbp), %rdi
callq 0x350a
leaq 0xbeeb(%rip), %rdi      # 0x12878
callq 0xa080
leaq -0x34(%rbp), %rsi
leaq 0xbfb3(%rip), %rdi      # 0x12950
callq 0x9faa
movl (%rax), %edi
pushq $0x12
popq %rsi
callq 0x22d0
leaq 0xbe05(%rip), %rdi      # 0x127b8
leaq -0x60(%rbp), %rsi
callq 0x758c
leaq -0xb2(%rip), %rsi       # 0x6911
pushq $0xe
popq %rdi
callq 0x2260
leaq -0x60(%rbp), %rdi
callq 0x34be
movl %eax, %edi
callq 0x23d0
leaq -0x60(%rbp), %rdi
callq 0x2100
jmp 0x69ed
movb $0x0, 0xbf9c(%rip)      # 0x12989
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/MUST-Quick-Fry[P]Process-Scheduler/scheduler_main.cpp
// Function: main
int main(int argc, char * argv[]){
    if(argc!=3){
        throw invalid_argument("The number of arguments of Scheduler is nonstandard!");
    }
    Scheduler sc(argv[1],argv[2]);   
    //cout<<sc; 
    //sc.Display();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
cmpl $0x3, %edi
jne 0xb50b
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4386
movq %rbx, %rdi
callq 0xb54e
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq 0xe9f(%rip), %rsi       # 0xc3bc
movq %rax, %rdi
callq 0x23e0
movq 0x6ab4(%rip), %rsi      # 0x11fe0
movq 0x6a9d(%rip), %rdx      # 0x11fd0
movq %rbx, %rdi
callq 0x2390
movq %rax, %r14
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/blak3mill3r[P]mouser/src/mouser.cpp
// Function: Mouser::Mouser()
Mouser::Mouser() : _d(XOpenDisplay(NULL)), _x_fd(ConnectionNumber(_d)) {
  if (_d == NULL) {
    fprintf(stderr, "Cannot open display\n");
    exit(1);
  }
  // TODO(Blake): test whether AutoRepeat is on in the first place; restore its value afterwards
  XAutoRepeatOff(_d);
  XGrabKeyboard(_d, DefaultRootWindow(_d), False, GrabModeAsync, GrabModeAsync, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r12
leaq 0x7917(%rip), %rax      # 0xbcd0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x4c6c
leaq 0x80(%r12), %r14
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x4c9e
leaq 0xd0(%r12), %r15
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x4dd0
xorl %edi, %edi
callq 0x32e0
movq %rax, 0x120(%r12)
movl 0x10(%rax), %ecx
movl %ecx, 0x128(%r12)
movb $0x1, 0x12c(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%r12)
andq $0x0, 0x140(%r12)
movabsq $0x3f7eb85240333333, %rcx # imm = 0x3F7EB85240333333
movq %rcx, 0x148(%r12)
movl $0x3f19999a, 0x150(%r12) # imm = 0x3F19999A
movb $0x0, 0x154(%r12)
movq %rax, %rdi
callq 0x3100
movq 0x120(%r12), %rdi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
pushq $0x1
popq %rcx
xorl %edx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x3270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x44a2
movq %rax, %r12
jmp 0x44aa
movq %rax, %r12
movq %r15, %rdi
callq 0x4f34
movq %r14, %rdi
callq 0x4fb2
movq %rbx, %rdi
callq 0x4fea
movq %r12, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/blak3mill3r[P]mouser/src/mouser.cpp
// Function: Mouser::~Mouser()
Mouser::~Mouser() {
  XUngrabKeyboard(_d, CurrentTime);
  // TODO(Blake): test whether AutoRepeat is on in the first place; restore its value afterwards
  XAutoRepeatOn(_d);
  XCloseDisplay(_d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7806(%rip), %rax      # 0xbcd0
movq %rax, (%rdi)
movq 0x120(%rdi), %rdi
xorl %esi, %esi
callq 0x3290
movq 0x120(%rbx), %rdi
callq 0x3320
movq 0x120(%rbx), %rdi
callq 0x33d0
leaq 0xd0(%rbx), %rdi
callq 0x4f34
leaq 0x80(%rbx), %rdi
callq 0x4fb2
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4fea
movq %rax, %rdi
callq 0x40d7
nop
// File: /workspace/github_cpp_makefile_star2_O2/blak3mill3r[P]mouser/src/mouser.cpp
// Function: Mouser::run()
void Mouser::run() {
  struct timeval tv;
  XEvent ev;
  fd_set in_fds;
  while( _running ) {
    // Create a File Description Set containing x_fd
    FD_ZERO(&in_fds);
    FD_SET(_x_fd, &in_fds);

    // eight milliseconds
    tv.tv_usec = 1000 * 8;
    tv.tv_sec = 0;

    // Wait for X Event or the timeout
    int num_ready_fds = select(_x_fd + 1, &in_fds, NULL, NULL, &tv);
    if (num_ready_fds == 0)
      boost::this_fiber::yield();
    else if (num_ready_fds > 0)
      // Put XEvents onto the channel
      while(XPending(_d)) {
        XNextEvent(_d, &ev);
        _xevent_channel.push(ev);
      }
    else {
      printf("Fatal: select() returned %d\n", num_ready_fds);
      exit(1);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq -0xb8(%rbp), %r15
leaq -0x38(%rbp), %r12
leaq -0x178(%rbp), %r13
cmpb $0x1, 0x12c(%rbx)
jne 0x4618
xorl %eax, %eax
cmpq $0x10, %rax
je 0x4598
andq $0x0, -0xb8(%rbp,%rax,8)
incq %rax
jmp 0x4584
movl 0x128(%rbx), %edi
movl %edi, %eax
cltd
pushq $0x40
popq %rcx
idivl %ecx
movslq %eax, %rdx
shll $0x6, %eax
movl %edi, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, -0xb8(%rbp,%rdx,8)
movq $0x1f40, -0x30(%rbp)    # imm = 0x1F40
andq $0x0, -0x38(%rbp)
incl %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x31f0
testl %eax, %eax
je 0x460e
jle 0x462a
movq 0x120(%rbx), %rdi
callq 0x31b0
testl %eax, %eax
je 0x4575
movq 0x120(%rbx), %rdi
movq %r13, %rsi
callq 0x3300
movq %r14, %rdi
movq %r13, %rsi
callq 0x5026
jmp 0x45e2
callq 0x5013
jmp 0x4575
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40fb(%rip), %rdi      # 0x872c
movl %eax, %esi
xorl %eax, %eax
callq 0x3050
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/blak3mill3r[P]mouser/src/mouser.cpp
// Function: Mouser::stop()
void Mouser::stop() {
  _running = false;
  _keyboard_action_channel.close();
  _xtest_action_channel.close();
  _xevent_channel.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x12c(%rdi)
addq $0x80, %rdi
callq 0x56c4
leaq 0xd0(%rbx), %rdi
callq 0x57b6
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x58a8
// File: /workspace/github_cpp_makefile_star2_O2/blak3mill3r[P]mouser/src/mouser.cpp
// Function: Mouser::key_handler()
void Mouser::key_handler() {
  KeyboardAction action;
  while (_running && channel_op_status::success == _keyboard_action_channel.pop(action)) {
    switch(action.control_key){
    case k_left:  fx += (action.on_off ? -FORCE : +FORCE); break;
    case k_right: fx += (action.on_off ? +FORCE : -FORCE); break;
    case k_up:    fy += (action.on_off ? -FORCE : +FORCE); break;
    case k_down:  fy += (action.on_off ? +FORCE : -FORCE); break;
    case k_brakes: brakes = action.on_off; break;
    default: break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x80(%rdi), %r14
leaq -0x28(%rbp), %r15
leaq 0x3c12(%rip), %r12      # 0x8570
cmpb $0x1, 0x12c(%rbx)
jne 0x4a0c
movq %r14, %rdi
movq %r15, %rsi
callq 0x5574
testl %eax, %eax
jne 0x4a0c
movl -0x28(%rbp), %eax
cmpq $0x7, %rax
ja 0x495e
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x49a5
xorps 0x3bab(%rip), %xmm0     # 0x8550
addss 0x134(%rbx), %xmm0
movss %xmm0, 0x134(%rbx)
jmp 0x495e
movb -0x24(%rbp), %al
movb %al, 0x154(%rbx)
jmp 0x495e
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x49d7
xorps 0x3b79(%rip), %xmm0     # 0x8550
addss 0x130(%rbx), %xmm0
movss %xmm0, 0x130(%rbx)
jmp 0x495e
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x49d0
jmp 0x49d7
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x499e
jmp 0x49a5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/blak3mill3r[P]mouser/src/mouser.cpp
// Function: Mouser::physics_handler()
void Mouser::physics_handler() {
  while (_running) {
    vx += fx;
    vy += fy;
    vx *= (brakes ? FRICTION_BRAKES : FRICTION);
    vy *= (brakes ? FRICTION_BRAKES : FRICTION);
    deltax += vx;
    deltay += vy;
    int mx=0, my=0;
    if(abs(deltax) >= 1.0) mx = int(deltax);
    if(abs(deltay) >= 1.0) my = int(deltay);
    if(mx != 0) deltax -= mx;
    if(my != 0) deltay -= my;
    if(mx != 0 || my != 0) _xtest_action_channel.push(make_pair(mx,my));

    boost::this_fiber::sleep_for(std::chrono::milliseconds(8));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xd0(%rdi), %r14
movaps 0x3b28(%rip), %xmm3     # 0x8560
movss 0x3b58(%rip), %xmm4     # 0x8598
leaq -0x28(%rbp), %r15
cmpb $0x1, 0x12c(%rbx)
jne 0x4b54
movss 0x130(%rbx), %xmm1
movss 0x134(%rbx), %xmm0
addss 0x138(%rbx), %xmm1
addss 0x13c(%rbx), %xmm0
movzbl 0x154(%rbx), %eax
movss 0x14c(%rbx,%rax,4), %xmm2
mulss %xmm2, %xmm1
movss %xmm1, 0x138(%rbx)
mulss %xmm2, %xmm0
movss %xmm0, 0x13c(%rbx)
addss 0x140(%rbx), %xmm1
movss %xmm1, 0x140(%rbx)
addss 0x144(%rbx), %xmm0
movss %xmm0, 0x144(%rbx)
movaps %xmm1, %xmm2
andps %xmm3, %xmm2
xorl %eax, %eax
ucomiss %xmm4, %xmm2
movl $0x0, %ecx
jb 0x4acf
cvttss2si %xmm1, %ecx
movaps %xmm0, %xmm2
andps %xmm3, %xmm2
ucomiss %xmm4, %xmm2
jb 0x4ade
cvttss2si %xmm0, %eax
testl %ecx, %ecx
je 0x4af8
cvtsi2ss %ecx, %xmm2
subss %xmm2, %xmm1
movss %xmm1, 0x140(%rbx)
testl %eax, %eax
jne 0x4afc
jmp 0x4b0c
testl %eax, %eax
je 0x4b30
cvtsi2ss %eax, %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x144(%rbx)
shlq $0x20, %rax
movl %ecx, %ecx
orq %rax, %rcx
movq %rcx, -0x20(%rbp)
andl $0x0, -0x28(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x52bc
movq %r15, %rdi
callq 0x6282
movq $0x8, -0x28(%rbp)
movq %r15, %rdi
callq 0x59c6
movaps 0x3a19(%rip), %xmm3     # 0x8560
movss 0x3a49(%rip), %xmm4     # 0x8598
jmp 0x4a44
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x6282
movq %rbx, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/silverneko[P]Lambda-calculus-interpreter/src/main.cpp
// Function: Context::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Object& Context::operator [] (const string& str) const {
  if(_env.exist(str)){
    return *_env[str];
  }else{
    cerr << "[Context lookup] Unexpected free variable: " << str << endl;
    exit(1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3ec0
testb %al, %al
je 0x3e9f
movq (%r14), %rdi
movq (%rbx), %r14
movq 0x8(%rbx), %r15
xorl %r12d, %r12d
leaq 0x7(%rsp), %rbx
cmpq %r12, %r15
je 0x3e66
movb (%r14,%r12), %al
movb %al, 0x7(%rsp)
movq %rbx, %rsi
callq 0x5818
testq %rax, %rax
je 0x3e7c
movq 0x10(%rax), %rdi
incq %r12
jmp 0x3e43
cmpb $0x0, 0x38(%rdi)
je 0x3e7c
movq 0x40(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd16d(%rip), %rdi      # 0x10ff0
leaq 0x774c(%rip), %rsi      # 0xb5d6
callq 0x31a0
movq %rax, %rdi
callq 0x30e0
pushq $0x1
popq %rdi
callq 0x31e0
movq 0xd14a(%rip), %rdi      # 0x10ff0
leaq 0x74e7(%rip), %rsi      # 0xb394
callq 0x31a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3180
jmp 0x3e8f
nop
// File: /workspace/github_cpp_makefile_star2_O2/silverneko[P]Lambda-calculus-interpreter/src/main.cpp
// Function: Object::call(Expression const&, Context const&) const
Object Object::call(const Expression& expr, const Context& env) const {
  if(type() == Primitive){
    /* TODO */
    return _func(expr, env);
  }else{
    if(_expr.isLam()){
      return Object(*_expr.body, _env.insert(_expr.name, Object(expr, env)));
    }else{
      cerr << "[Object call] Object not callable (not a `Lambda`): " << _expr.type << endl;
      exit(1);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x3f52
cmpl $0x3, 0x8(%r14)
jne 0x3f75
movq 0x30(%r14), %r15
leaq 0x40(%r14), %r12
addq $0x10, %r14
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x6f9c
movq %rsp, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x3d14
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f9c
leaq 0x8(%rsp), %rdi
callq 0x750c
leaq 0x10(%rsp), %rdi
callq 0x6fd6
jmp 0x3f61
addq $0x50, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7076
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xd074(%rip), %rdi      # 0x10ff0
leaq 0x743d(%rip), %rsi      # 0xb3c0
callq 0x31a0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x32a0
movq %rax, %rdi
callq 0x30e0
pushq $0x1
popq %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x750c
jmp 0x3fb6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6fd6
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/silverneko[P]Lambda-calculus-interpreter/src/Dictionary.hpp
// Function: (anonymous namespace)::Trie<std::shared_ptr<Object>>::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Object> const&, int) const
shared_ptr<Trie<T>> insert(const string& str, const T& t, int i = 0) const {
      shared_ptr<Trie<T>> newNode(new Trie<T>(*this));
      if(i == str.size()){
        newNode->endHere = true;
        newNode->cargo = t;
      }else{
        char c = str[i];
        auto branch = branches.find(c);
        if(branch != branches.end()){
          newNode->branches[c] = branch->second->insert(str, t, i+1);
        }else{
          shared_ptr<Trie<T>> empty(new Trie<T>());
          newNode->branches[c] = empty->insert(str, t, i+1);
        }
      }
      return newNode;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x31b0
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x5710
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5436
movslq %ebp, %rax
cmpq %rax, 0x8(%r15)
jne 0x55dd
movq (%rbx), %rdi
movb $0x1, 0x38(%rdi)
addq $0x40, %rdi
movq %r14, %rsi
callq 0x7622
jmp 0x56b5
movq (%r15), %rcx
movb (%rcx,%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %r12, %rdi
callq 0x5818
testq %rax, %rax
je 0x562c
movq 0x10(%rax), %rsi
incl %ebp
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x557e
movq (%rbx), %rdi
leaq 0x7(%rsp), %rsi
callq 0x5830
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x59e6
jmp 0x56ab
pushq $0x50
popq %rdi
callq 0x31b0
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x28(%rax)
movb $0x0, 0x38(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5436
movq 0x8(%rsp), %rsi
incl %ebp
leaq 0x18(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x557e
movq (%rbx), %rdi
leaq 0x7(%rsp), %rsi
callq 0x5830
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x59e6
leaq 0x20(%rsp), %rdi
callq 0x750c
leaq 0x10(%rsp), %rdi
callq 0x750c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x750c
jmp 0x56db
jmp 0x56d8
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x750c
jmp 0x56ec
jmp 0x56e9
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x750c
jmp 0x5708
movq %rax, %r14
pushq $0x50
popq %rsi
movq %r13, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/silverneko[P]Lambda-calculus-interpreter/src/Dictionary.hpp
// Function: (anonymous namespace)::Trie<std::shared_ptr<Object>>::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) const
shared_ptr<Trie<T>> erase(const string& str, int i = 0) const {
      shared_ptr<Trie<T>> newNode(new Trie<T>(*this));
      if(i == str.size()){
        newNode->endHere = false;
      }else{
        char c = str[i];
        auto branch = branches.find(c);
        if(branch != branches.end()){
          newNode->branches[c] = branch->second->erase(str, i+1);
        }
      }
      return newNode;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x5710
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5436
movslq %ebp, %rax
cmpq %rax, 0x8(%r14)
jne 0x5b30
movq (%rbx), %rax
movb $0x0, 0x38(%rax)
jmp 0x5b83
movq (%r14), %rcx
movb (%rcx,%rax), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movq %r15, %rdi
callq 0x5818
testq %rax, %rax
je 0x5b83
movq 0x10(%rax), %rsi
incl %ebp
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x5ae6
movq (%rbx), %rdi
leaq 0xf(%rsp), %rsi
callq 0x5830
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x59e6
leaq 0x18(%rsp), %rdi
callq 0x750c
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x750c
jmp 0x5ba5
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x750c
jmp 0x5bc1
movq %rax, %r14
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/silverneko[P]Lambda-calculus-interpreter/src/Dictionary.hpp
// Function: (anonymous namespace)::Trie<std::shared_ptr<Object>>::exist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) const
bool exist(const string& str, int i = 0) const {
      if(i == str.size()){
        return endHere;
      }
      char c = str[i];
      auto branch = branches.find(c);
      if(branch != branches.end()){
        return branch->second->exist(str, i+1);
      }else{
        return false;
      }
    }

// Assembly:
movslq %edx, %rax
cmpq %rax, 0x8(%rsi)
jne 0x5bd7
movb 0x38(%rdi), %al
retq
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq (%rsi), %rcx
movb (%rcx,%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x5818
testq %rax, %rax
je 0x5c09
movq 0x10(%rax), %rdi
incl %ebx
movq %r14, %rsi
movl %ebx, %edx
callq 0x5bca
jmp 0x5c0b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::Parser::operator[](std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>) const
Parser Parser::operator [] (function<void (const std::string&)> f) const {
  auto parser = this->runParser;
  return Parser([f, parser](Parser::Iterator first, Parser::Iterator last){
    bool good;
    Parser::Iterator second;
    std::tie(good, second) = parser(first, last);
    if(! good) return badParse(second);
    f({first, second});
    return goodParse(second);
  });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x9ce4
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x9d2a
leaq 0x48(%rsp), %r14
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0x9ce4
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x40
popq %rdi
callq 0x31b0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rcx
testq %rcx, %rcx
je 0x789d
leaq 0x38(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movups %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
je 0x78d3
movq %rax, %rdx
addq $0x20, %rdx
leaq 0x58(%rsp), %rsi
movups (%r14), %xmm1
movups %xmm1, (%rdx)
movq %rcx, 0x30(%rax)
movups %xmm0, (%rsi)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x1800(%rip), %rax      # 0x90e0
movq %rax, 0x18(%rsi)
leaq 0x1889(%rip), %rax      # 0x9174
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x795e
leaq 0x68(%rsp), %rdi
callq 0x7274
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
jmp 0x7923
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x795e
jmp 0x794c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7274
jmp 0x794c
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x7274
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::operator|(Parsers::Parser, Parsers::Parser)
Parser operator | (Parser f, Parser g){
  return Parser([f, g](Parser::Iterator first, Parser::Iterator last){
    bool good;
    Parser::Iterator _first;
    std::tie(good, _first) = f.runParser(first, last);
    if(good) return goodParse(_first);
    std::tie(good, first) = g.runParser(first, last);
    if(good) return goodParse(first);
    return badParse(first);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9ce4
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ce4
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x40
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x9ce4
movq %r14, %rdi
addq $0x20, %rdi
movq %r15, %rsi
callq 0x9ce4
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x1c0d(%rip), %rax      # 0x9658
movq %rax, 0x18(%rsi)
leaq 0x1c82(%rip), %rax      # 0x96d8
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x8072
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7aa0
movq %rax, %rbx
movq %r14, %rdi
callq 0x7274
jmp 0x7a93
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x31c0
jmp 0x7aa3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x8072
jmp 0x7ac4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7274
movq %rbx, %rdi
callq 0x32b0