LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0xd2b8(%rip), %rax      # 0x15878
cmpq 0xd291(%rip), %rax      # 0x15858
jne 0x85e0
movq 0xd2f8(%rip), %rax      # 0x158c8
cmpq 0xd2d1(%rip), %rax      # 0x158a8
jne 0x85e0
movb $0x1, 0xd3c8(%rip)      # 0x159a8
xorl %ebx, %ebx
cmpl $0x2, 0xd21f(%rip)      # 0x15808
setne %bl
leaq 0xd37d(%rip), %rdi      # 0x15970
leaq 0xd20a(%rip), %rsi      # 0x15804
callq 0xcdb0
movl (%rax), %edi
leal (%rbx,%rbx,4), %esi
addl $0xf, %esi
callq 0x2310
movq 0xd295(%rip), %r15      # 0x158a8
cmpq %r15, 0xd2ae(%rip)      # 0x158c8
je 0x86f9
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x37c8
movq 0x4e(%r15), %rax
movq %rax, 0x4e(%rbx)
movups 0x20(%r15), %xmm0
movups 0x30(%r15), %xmm1
movups 0x40(%r15), %xmm2
movups %xmm2, 0x40(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
leaq 0xd230(%rip), %rdi      # 0x15898
callq 0xce58
leaq -0x44(%rbp), %rsi
leaq 0xd2f8(%rip), %rdi      # 0x15970
callq 0xcdb0
movl (%rax), %edi
movl $0x12, %esi
callq 0x2310
leaq 0xd148(%rip), %rdi      # 0x157d8
leaq -0x70(%rbp), %rsi
callq 0x2150
leaq -0x50(%rbp), %rax
movq 0x2e(%rax), %rcx
movq %rcx, 0xd17e(%rip)      # 0x15826
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0xd15e(%rip)     # 0x15818
movups %xmm1, 0xd147(%rip)     # 0x15808
movups %xmm0, 0xd130(%rip)     # 0x157f8
leaq -0x123(%rip), %rsi      # 0x85ac
movl $0xe, %edi
callq 0x22b0
leaq -0x70(%rbp), %rdi
callq 0x3746
movl %eax, %edi
callq 0x2410
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x8700
callq 0x2250
jmp 0x8700
movb $0x0, 0xd2a9(%rip)      # 0x159a9
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x871c
callq 0x2250
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf093
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4a22
movq %rbx, %rdi
callq 0xf0d8
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x2130
movq %rax, %rbx
leaq 0x1358(%rip), %rsi      # 0x103ff
movq %rax, %rdi
callq 0x2420
movq 0x5f2a(%rip), %rsi      # 0x14fe0
movq 0x5f13(%rip), %rdx      # 0x14fd0
movq %rbx, %rdi
callq 0x23c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
leaq 0x660f(%rip), %rax      # 0xacc8
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x1, %eax
movl %eax, 0x14(%rdi)
leaq 0x18(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movl %eax, 0x28(%rdi)
leaq 0x30(%rdi), %rax
movups %xmm0, 0x30(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
leaq 0x80(%rdi), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x5042
leaq 0xd0(%rbx), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x51d0
xorl %edi, %edi
callq 0x32b0
movq %rax, 0x120(%rbx)
movl 0x10(%rax), %ecx
movl %ecx, 0x128(%rbx)
movb $0x1, 0x12c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%rbx)
movq $0x0, 0x140(%rbx)
movabsq $0x3f7eb85240333333, %rcx # imm = 0x3F7EB85240333333
movq %rcx, 0x148(%rbx)
movl $0x3f19999a, 0x150(%rbx) # imm = 0x3F19999A
movb $0x0, 0x154(%rbx)
testq %rax, %rax
je 0x47bc
movq %rax, %rdi
callq 0x30c0
movq 0x120(%rbx), %rdi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x3250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x35da
movq %rax, %r12
jmp 0x47d6
movq %rax, %r12
jmp 0x47de
movq %rax, %r12
movq %r15, %rdi
callq 0x5394
movq %r14, %rdi
callq 0x5450
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x54c6
movq %r12, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64c6(%rip), %rax      # 0xacc8
movq %rax, (%rdi)
movq 0x120(%rdi), %rdi
xorl %esi, %esi
callq 0x3270
movq 0x120(%rbx), %rdi
callq 0x3300
movq 0x120(%rbx), %rdi
callq 0x33c0
leaq 0xd0(%rbx), %rdi
callq 0x5394
leaq 0x80(%rbx), %rdi
callq 0x5450
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x54c6
movq %rax, %rdi
callq 0x4584
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x1, 0x12c(%rdi)
jne 0x4984
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq -0xc0(%rbp), %r15
leaq -0x38(%rbp), %r12
leaq -0x180(%rbp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movl 0x128(%rbx), %edi
leal 0x3f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, -0xc0(%rbp,%rax,8)
movq $0x1f40, -0x30(%rbp)    # imm = 0x1F40
movq $0x0, -0x38(%rbp)
incl %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x31c0
testl %eax, %eax
je 0x496a
jg 0x4958
jmp 0x4996
movq 0x120(%rbx), %rdi
movq %r13, %rsi
callq 0x32e0
movq %r14, %rdi
movq %r13, %rsi
callq 0x3410
movq 0x120(%rbx), %rdi
callq 0x3180
testl %eax, %eax
jne 0x493e
jmp 0x4977
callq 0x3340
movq %rax, %rdi
callq 0x33f0
cmpb $0x0, 0x12c(%rbx)
jne 0x48ba
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cd4(%rip), %rdi      # 0x8671
movl %eax, %esi
xorl %eax, %eax
callq 0x3040
movl $0x1, %edi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5bbe
leaq 0xd0(%rbx), %rdi
callq 0x5cf6
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e2e
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x1, 0x12c(%rdi)
jne 0x4db4
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 0x37b5(%rip), %r12      # 0x84b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a3e
testl %eax, %eax
jne 0x4da8
movl -0x28(%rbp), %eax
cmpq $0x7, %rax
ja 0x4d9b
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x4d39
xorps 0x3757(%rip), %xmm0     # 0x8490
addss 0x134(%rbx), %xmm0
movss %xmm0, 0x134(%rbx)
jmp 0x4d9b
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x4d60
xorps 0x3730(%rip), %xmm0     # 0x8490
addss 0x130(%rbx), %xmm0
movss %xmm0, 0x130(%rbx)
jmp 0x4d9b
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x4d32
jmp 0x4d39
movss 0x148(%rbx), %xmm0
cmpb $0x0, -0x24(%rbp)
je 0x4d59
jmp 0x4d60
movb -0x24(%rbp), %al
movb %al, 0x154(%rbx)
cmpb $0x0, 0x12c(%rbx)
jne 0x4cfb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x1, 0x12c(%rdi)
jne 0x4f11
movq %rdi, %rbx
leaq 0xd0(%rdi), %r14
movaps 0x36bf(%rip), %xmm3     # 0x84a0
movss 0x36ef(%rip), %xmm4     # 0x84d8
leaq -0x28(%rbp), %r15
movss 0x130(%rbx), %xmm1
movss 0x134(%rbx), %xmm0
addss 0x138(%rbx), %xmm1
movss %xmm1, 0x138(%rbx)
addss 0x13c(%rbx), %xmm0
movss %xmm0, 0x13c(%rbx)
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 0x4e7b
cvttss2si %xmm1, %ecx
movaps %xmm0, %xmm2
andps %xmm3, %xmm2
ucomiss %xmm4, %xmm2
jb 0x4e8a
cvttss2si %xmm0, %eax
testl %ecx, %ecx
je 0x4ea1
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
subss %xmm2, %xmm1
movss %xmm1, 0x140(%rbx)
testl %eax, %eax
je 0x4eb8
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x144(%rbx)
movl %ecx, %edx
orl %eax, %edx
je 0x4ee5
shlq $0x20, %rax
movl %ecx, %ecx
orq %rax, %rcx
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5724
movq %r15, %rdi
callq 0x68fe
movq $0x8, -0x28(%rbp)
movq %r15, %rdi
callq 0x5fb1
cmpb $0x0, 0x12c(%rbx)
movaps 0x359d(%rip), %xmm3     # 0x84a0
movss 0x35cd(%rip), %xmm4     # 0x84d8
jne 0x4ded
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x68fe
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x778c
testb %al, %al
je 0x44ce
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x77f2
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10b1b(%rip), %rdi     # 0x14ff0
leaq 0xaeb8(%rip), %rsi      # 0xf394
callq 0x31b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3180
movq %rax, %rdi
callq 0x30d0
movl $0x1, %edi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45d4
cmpl $0x3, 0x8(%r14)
jne 0x45fa
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 0x9b02
movq %rsp, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x428e
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9b02
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x458f
callq 0x9f9e
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x45a8
leaq 0x60(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x45b7
callq 0x9f9e
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45e6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31d0
jmp 0x45e6
cmpq $0x0, 0x60(%r14)
je 0x462b
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
callq *0x68(%r14)
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x109ef(%rip), %rdi     # 0x14ff0
leaq 0xadb8(%rip), %rsi      # 0xf3c0
callq 0x31b0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x30d0
movl $0x1, %edi
callq 0x3200
callq 0x30b0
movq %rax, %rdi
callq 0x9d49
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x464f
callq 0x9f9e
jmp 0x464f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9b88
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x50, %edi
callq 0x31c0
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x7280
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6f26
movslq %ebp, %rax
cmpq %rax, 0x8(%r15)
jne 0x7108
movq (%rbx), %rdi
movb $0x1, 0x38(%rdi)
movq (%r14), %rax
movq %rax, 0x40(%rdi)
addq $0x48, %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x9f58
jmp 0x7216
movq (%r15), %rcx
movsbq (%rcx,%rax), %rax
leaq 0xf(%rsp), %rcx
movb %al, (%rcx)
xorl %edx, %edx
divq 0x8(%r12)
movq %r12, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x7624
testq %rax, %rax
je 0x7170
movq 0x10(%rax), %rsi
incl %ebp
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x709c
movq (%rbx), %rdi
leaq 0xf(%rsp), %rsi
callq 0x73ee
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x8(%rax), %rdi
movups %xmm0, (%rax)
jmp 0x71fd
movl $0x50, %edi
callq 0x31c0
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 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x6f26
movq 0x10(%rsp), %rsi
incl %ebp
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x709c
movq (%rbx), %rdi
leaq 0xf(%rsp), %rsi
callq 0x73ee
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x8(%rax), %rdi
movups %xmm0, (%rax)
testq %rdi, %rdi
je 0x71f8
callq 0x9f9e
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x7207
callq 0x9f9e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x7216
callq 0x9f9e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x7241
callq 0x9f9e
jmp 0x7241
jmp 0x723e
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x7257
callq 0x9f9e
jmp 0x7257
jmp 0x7254
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7277
callq 0x9f9e
jmp 0x7277
movq %rax, %r14
movl $0x50, %esi
movq %r13, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x50, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x7280
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6f26
movslq %ebp, %rax
cmpq %rax, 0x8(%r14)
jne 0x76c6
movq (%rbx), %rax
movb $0x0, 0x38(%rax)
jmp 0x773d
movq (%r14), %rcx
movsbq (%rcx,%rax), %rax
leaq 0xf(%rsp), %rcx
movb %al, (%rcx)
xorl %edx, %edx
divq 0x8(%r15)
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x7624
testq %rax, %rax
je 0x773d
movq 0x10(%rax), %rsi
incl %ebp
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x767a
movq (%rbx), %rdi
leaq 0xf(%rsp), %rsi
callq 0x73ee
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x8(%rax), %rdi
movups %xmm0, (%rax)
testq %rdi, %rdi
je 0x772e
callq 0x9f9e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x773d
callq 0x9f9e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x7764
callq 0x9f9e
jmp 0x7764
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7784
callq 0x9f9e
jmp 0x7784
movq %rax, %r14
movl $0x50, %esi
movq %r12, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movslq %edx, %rax
cmpq %rax, 0x8(%rsi)
jne 0x77a4
movb 0x38(%rdi), %r15b
jmp 0x77e4
movl %edx, %ebx
movq %rsi, %r14
movq (%rsi), %rcx
movsbq (%rcx,%rax), %rax
leaq 0xf(%rsp), %rcx
movb %al, (%rcx)
xorl %r15d, %r15d
xorl %edx, %edx
divq 0x8(%rdi)
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x7624
testq %rax, %rax
je 0x77e4
movq 0x10(%rax), %rdi
incl %ebx
movq %r14, %rsi
movl %ebx, %edx
callq 0x778c
movl %eax, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/Dictionary.hpp
// Function: (anonymous namespace)::Trie<std::shared_ptr<Object>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) const
const T& find(const string& str, int i = 0) const {
      if(i == str.size()){
        if(endHere){
          return cargo;
        }else{
          cerr << "[Trie] Nothing here" << endl;
          exit(1);
        }
      }
      char c = str[i];
      auto branch = branches.find(c);
      if(branch != branches.end()){
        return branch->second->find(str, i+1);
      }else{
        cerr << "[Trie] Nothing here" << endl;
        exit(1);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movslq %edx, %r15
leaq 0xf(%rsp), %r14
cmpq 0x8(%rbx), %r15
je 0x7837
movq (%rbx), %rax
movsbq (%rax,%r15), %rax
movb %al, 0xf(%rsp)
xorl %edx, %edx
divq 0x8(%rdi)
movq %rdx, %rsi
movq %r14, %rdx
callq 0x7624
testq %rax, %rax
je 0x784e
movq 0x10(%rax), %rdi
incq %r15
jmp 0x7806
cmpb $0x1, 0x38(%rdi)
jne 0x784e
addq $0x40, %rdi
movq %rdi, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xd79b(%rip), %rdi      # 0x14ff0
leaq 0x7d7c(%rip), %rsi      # 0xf5d8
callq 0x31b0
movq %rax, %rdi
callq 0x30d0
movl $0x1, %edi
callq 0x3200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xda38
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xda9e
leaq 0x48(%rsp), %r14
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0xda38
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rcx
testq %rcx, %rcx
je 0xa452
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)
movq $0x0, 0x30(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
je 0xa48b
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 0x25b6(%rip), %rax      # 0xca4e
movq %rax, 0x18(%rsi)
leaq 0x2683(%rip), %rax      # 0xcb26
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa4c6
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xa4dd
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa4f6
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xa50f
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
jmp 0xa596
jmp 0xa596
jmp 0xa596
jmp 0xa596
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa546
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa546
jmp 0xa596
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa59e
jmp 0xa575
movq %rax, %rbx
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa575
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa575
jmp 0xa596
movq %rax, %rbx
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xa58e
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9d49
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xda38
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xda38
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xda38
movq %r15, %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xda38
movq %rsp, %rsi
movq %r15, (%rsi)
leaq 0x2b08(%rip), %rax      # 0xd206
movq %rax, 0x18(%rsi)
leaq 0x2ba5(%rip), %rax      # 0xd2ae
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa72c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xa743
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xa75c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa811
jmp 0xa811
jmp 0xa811
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa7df
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa7df
jmp 0xa811
movq %rax, %rbx
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xa7b6
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa7b6
jmp 0xa811
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x31d0
jmp 0xa7c8
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa7df
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x20(%rsp), %rdi
callq 0xb15a
movq %rbx, %rdi
callq 0x32d0
jmp 0xa811
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xa7e9
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa7e9
movq %rax, %rdi
callq 0x9d49
nop
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::say(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>)
Parser say(const std::string& msg, std::function<void (const std::string&)> f){
  return Parser([msg, f](Parser::Iterator _, Parser::Iterator __){
    f(msg);
    return goodParse(_);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0xa0a0
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xda9e
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xa0a0
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq $0x0, 0x30(%r15)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%r15)
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xa9c1
movq %r15, %rcx
addq $0x20, %rcx
leaq 0x58(%rsp), %rdx
movups (%r14), %xmm1
movups %xmm1, (%rcx)
movq %rax, 0x30(%r15)
movups %xmm0, (%rdx)
movq %rsp, %rsi
movq %r15, (%rsi)
leaq 0x226e(%rip), %rax      # 0xcc3c
movq %rax, 0x18(%rsi)
leaq 0x2295(%rip), %rax      # 0xcc6e
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa9fc
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xaa13
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xaa2a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xaa99
jmp 0xaa99
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaa87
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xaa87
jmp 0xaa99
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x31d0
jmp 0xaa70
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaa87
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x28(%rsp), %rdi
callq 0xaabe
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9d49
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xaa91
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
jmp 0xaa91
nop
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::word(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Parser word(const std::string& str){
  Parser accu;
  for(char c : str)
    accu = accu >> charp(c);
  return accu;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x1f0f(%rip), %rax      # 0xca28
movq %rax, 0x18(%rdi)
leaq 0x1f12(%rip), %rax      # 0xca36
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xabdf
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x38(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x58(%rsp), %r12
movq 0x8(%rsp), %rax
movb (%rax,%rbp), %r13b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xda38
movsbl %r13b, %esi
movq %r15, %rdi
callq 0xa88b
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xac89
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdcec
movq 0x68(%rsp), %rax
testq %rax, %rax
je 0xaba3
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0xabba
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0xabd1
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
incq %rbp
cmpq %rbp, 0x10(%rsp)
jne 0xab53
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xac81
jmp 0xac81
jmp 0xac81
movq %rax, %r14
jmp 0xac5d
movq %rax, %r14
jmp 0xac44
movq %rax, %r14
jmp 0xac2b
movq %rax, %r14
movq 0x68(%rsp), %rax
testq %rax, %rax
je 0xac2b
leaq 0x58(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0xac44
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0xac5d
leaq 0x38(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xac73
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x32d0
jmp 0xac81
jmp 0xac81
jmp 0xac81
movq %rax, %rdi
callq 0x9d49
// File: /workspace/github_cpp_makefile_star2_O1/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;
    std::tie(good, first) = f.runParser(first, last);
    if(! good) return badParse(first);
    std::tie(good, first) = g.runParser(first, last);
    if(! good) return badParse(first);
    return goodParse(first);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xda38
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xda38
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xda38
movq %r15, %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xda38
movq %rsp, %rsi
movq %r15, (%rsi)
leaq 0x237e(%rip), %rax      # 0xd072
movq %rax, 0x18(%rsi)
leaq 0x2417(%rip), %rax      # 0xd116
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xad22
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xad39
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xad52
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xae07
jmp 0xae07
jmp 0xae07
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xadd5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xadd5
jmp 0xae07
movq %rax, %rbx
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xadac
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xadac
jmp 0xae07
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x31d0
jmp 0xadbe
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xadd5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x20(%rsp), %rdi
callq 0xb11c
movq %rbx, %rdi
callq 0x32d0
jmp 0xae07
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xaddf
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xaddf
movq %rax, %rdi
callq 0x9d49
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::many(Parsers::Parser)
Parser many(Parser parser){
  return Parser([parser](Parser::Iterator first, Parser::Iterator last){
    bool good = true;
    Parser::Iterator second = first;
    while(good){
      std::tie(good, second) = parser.runParser(first, last);
      swap(first, second);
    }
    return goodParse(second);
  });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0xda38
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x20, %edi
callq 0x31c0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xda38
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x208a(%rip), %rax      # 0xcf54
movq %rax, 0x18(%rsi)
leaq 0x20f9(%rip), %rax      # 0xcfce
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaef8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xaf11
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xaf8d
jmp 0xaf8d
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaf6a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xaf6a
jmp 0xaf8d
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x31d0
jmp 0xaf53
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaf6a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xaf83
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
jmp 0xaf8d
movq %rax, %rdi
callq 0x9d49
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::some(Parsers::Parser)
Parser some(Parser parser){
  return Parser([parser](Parser::Iterator first, Parser::Iterator last){
    bool good;
    std::tie(good, first) = parser.runParser(first, last);
    if(! good) return badParse(first);
    std::tie(ignore, first) = many(parser).runParser(first, last);
    return goodParse(first);
  });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0xda38
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x20, %edi
callq 0x31c0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xda38
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x1d24(%rip), %rax      # 0xcd74
movq %rax, 0x18(%rsi)
leaq 0x1e55(%rip), %rax      # 0xceb0
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb07e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xb097
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xb113
jmp 0xb113
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb0f0
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xb0f0
jmp 0xb113
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x31d0
jmp 0xb0d9
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb0f0
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xb109
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
jmp 0xb113
movq %rax, %rdi
callq 0x9d49
nop
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::satisfy(std::function<bool (char)>)
Parser satisfy(std::function<bool (char)> f){
  return Parser([f](Parser::Iterator first, Parser::Iterator last){
    if(first == last) return badParse(first);
    if(! f( *first )) return badParse(first);
    return goodParse(++first);
  });
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xdb22
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x20, %edi
callq 0x31c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0xb1f5
leaq 0x10(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x23b8(%rip), %rax      # 0xd5bc
movq %rax, 0x18(%rsi)
leaq 0x23f5(%rip), %rax      # 0xd604
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xb234
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb24b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
jmp 0xb29a
jmp 0xb29a
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xb27b
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xb27b
jmp 0xb29a
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb292
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9d49
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::oneOf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Parser oneOf(const std::string& sig){
  return Parser([sig](Parser::Iterator first, Parser::Iterator last){
    if(first == last) return badParse(first);
    if(find(sig.begin(), sig.end(), *first) == sig.end())
      return badParse(first);
    return goodParse(++first);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xa0a0
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x20, %edi
callq 0x31c0
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xa0a0
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x20bc(%rip), %rax      # 0xd3cc
movq %rax, 0x18(%rsi)
leaq 0x20fb(%rip), %rax      # 0xd416
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xda38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb33e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xb355
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb3cd
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb3ae
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xb3ae
jmp 0xb3cd
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x31d0
jmp 0xb397
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb3ae
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xb3c5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9d49
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Scanner::Scanner(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Scanner::Scanner(const string& buffer){
  auto first = buffer.begin(), last = buffer.end();
  Token token;
  while(first != last){
    tie(ignore, first) = spaces.runParser(first, last);
    if(first == last) break;
    tie(ignore, first) = tokenParser(token).runParser(first, last);
    if(token.type != Token::Undefined)
      tokens.push_back(token);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0xdd5a
movq (%r14), %rbx
movq 0x8(%r14), %r14
leaq 0x38(%rsp), %rax
movl $0x0, -0x18(%rax)
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testq %r14, %r14
je 0xbf09
addq %rbx, %r14
leaq 0x48(%rsp), %r15
leaq 0x68(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0x20(%rsp), %rbp
movq %rbx, 0x68(%rsp)
movq %r14, 0x10(%rsp)
cmpq $0x0, 0x9415(%rip)      # 0x15290
je 0xbf34
movq %r15, %rdi
leaq 0x93f5(%rip), %rsi      # 0x15280
movq %r12, %rdx
movq %r13, %rcx
callq *0x9401(%rip)           # 0x15298
movq 0x48(%rsp), %rbx
cmpq %rbx, %r14
je 0xbf09
movq %r15, %rdi
movq %rbp, %rsi
callq 0xb508
movq %rbx, 0x10(%rsp)
movq %r14, 0x18(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0xbf39
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
leaq 0x18(%rsp), %rcx
callq *0x60(%rsp)
movq 0x68(%rsp), %rbx
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xbeec
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x0, 0x20(%rsp)
je 0xbf00
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xdb88
cmpq %rbx, %r14
jne 0xbe69
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xbf25
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x30b0
callq 0x30b0
jmp 0xbf6e
jmp 0xbf64
jmp 0xbf6e
jmp 0xbf46
movq %rax, %r14
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xbf71
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xbf71
movq %rax, %rdi
callq 0x9d49
jmp 0xbf6e
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xbf8d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
movq 0x8(%rsp), %rdi
callq 0x9d54
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Scanner::getToken()
Token Scanner::getToken(){
  if(tokens.empty()) return Token(Token::EndOfFile, "EOF");
  Token token = tokens.front();
  tokens.pop_front();
  return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
cmpq %rax, 0x30(%rsi)
je 0xbfe3
movq %rsi, %r14
movl (%rax), %ecx
movl %ecx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
callq 0xa0a0
movq %r14, %rdi
callq 0xdbec
jmp 0xc03c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3aa4(%rip), %rsi      # 0xfa97
leaq 0x3aa0(%rip), %rdx      # 0xfa9a
movq %rsp, %r14
movq %r14, %rdi
callq 0xa240
movl $0x7, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0xa0a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc03c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc062
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rdi
callq 0x32d0