LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x18175(%rip), %rax     # 0x23cb0
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0xcb70
movq -0x28(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x20(%rbp)
movl $0x4, %esi
callq 0xcc20
jmp 0xbb63
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movq %rdi, -0x38(%rbp)
movl $0x8, %esi
callq 0xce30
jmp 0xbb7e
movq -0x28(%rbp), %rax
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x43d0
movq %rax, -0x40(%rbp)
jmp 0xbb9b
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq %rdx, (%rcx)
movq 0x120(%rax), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x128(%rax)
movb $0x1, 0x12c(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x130(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x134(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x138(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x13c(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x140(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x144(%rax)
movss 0xebb5(%rip), %xmm0     # 0x1a7c0
movss %xmm0, 0x148(%rax)
movss 0xeba1(%rip), %xmm0     # 0x1a7bc
movss %xmm0, 0x14c(%rax)
movss 0xeb8d(%rip), %xmm0     # 0x1a7b8
movss %xmm0, 0x150(%rax)
movb $0x0, 0x154(%rax)
cmpq $0x0, 0x120(%rax)
jne 0xbc99
movq 0x18385(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
leaq 0xee6b(%rip), %rsi      # 0x1aac0
movb $0x0, %al
callq 0x4410
movl $0x1, %edi
callq 0x4350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xbcf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xbce8
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd0a0
jmp 0xbce8
movq -0x28(%rbp), %rax
movq 0x120(%rax), %rdi
callq 0x4180
jmp 0xbcab
movq -0x28(%rbp), %rax
movq 0x120(%rax), %rdi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
xorl %edx, %edx
movl %edx, %r9d
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x4360
jmp 0xbce2
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd150
movq -0x30(%rbp), %rdi
callq 0xd1b0
movq -0x10(%rbp), %rdi
callq 0x44d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x17f85(%rip), %rcx     # 0x23cb0
movq %rcx, (%rax)
movq 0x120(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4380
jmp 0xbd40
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdi
callq 0x4440
jmp 0xbd52
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdi
callq 0x4520
jmp 0xbd64
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0xd0a0
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0xd150
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xd1b0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8260
nop
// File: 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
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x178(%rbp), %rax
testb $0x1, 0x12c(%rax)
je 0xbf6d
jmp 0xbe00
leaq -0x158(%rbp), %rax
movq %rax, -0x168(%rbp)
movl $0x0, -0x15c(%rbp)
movl -0x15c(%rbp), %eax
cmpq $0x10, %rax
jae 0xbe4a
movq -0x168(%rbp), %rax
movl -0x15c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x15c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x15c(%rbp)
jmp 0xbe18
jmp 0xbe4c
movq -0x178(%rbp), %rax
movl 0x128(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x178(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, -0x180(%rbp)
movl 0x128(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x180(%rbp), %rdx
movl %eax, %ecx
movq -0x178(%rbp), %rax
movslq %ecx, %rcx
orq -0x158(%rbp,%rcx,8), %rdx
movq %rdx, -0x158(%rbp,%rcx,8)
movq $0x1f40, -0x10(%rbp)    # imm = 0x1F40
movq $0x0, -0x18(%rbp)
movl 0x128(%rax), %edi
addl $0x1, %edi
leaq -0x158(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rdx
callq 0x42a0
movl %eax, -0x16c(%rbp)
cmpl $0x0, -0x16c(%rbp)
jne 0xbef0
callq 0xd1f0
jmp 0xbf68
cmpl $0x0, -0x16c(%rbp)
jle 0xbf48
jmp 0xbefb
movq -0x178(%rbp), %rax
movq 0x120(%rax), %rdi
callq 0x4260
cmpl $0x0, %eax
je 0xbf46
movq -0x178(%rbp), %rax
movq 0x120(%rax), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x4400
movq -0x178(%rbp), %rdi
addq $0x8, %rdi
leaq -0xd8(%rbp), %rsi
callq 0xd210
jmp 0xbefb
jmp 0xbf66
movl -0x16c(%rbp), %esi
leaq 0xeb80(%rip), %rdi      # 0x1aad5
movb $0x0, %al
callq 0x4050
movl $0x1, %edi
callq 0x4350
jmp 0xbf68
jmp 0xbdea
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x0, 0x12c(%rdi)
addq $0x80, %rdi
callq 0x10210
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x110f0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11fd0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xf8e0
movq -0x18(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x12c(%rcx)
movb %al, -0x19(%rbp)
je 0xc51f
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
leaq -0x10(%rbp), %rsi
callq 0xf8f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xc52b
jmp 0xc6b7
movl -0x10(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0xc6b0
movq -0x28(%rbp), %rax
leaq 0xe2cd(%rip), %rcx      # 0x1a814
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testb $0x1, -0xc(%rbp)
je 0xc576
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0xc587
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movss -0x2c(%rbp), %xmm0
addss 0x130(%rax), %xmm0
movss %xmm0, 0x130(%rax)
jmp 0xc6b2
testb $0x1, -0xc(%rbp)
je 0xc5be
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
jmp 0xc5dc
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss -0x30(%rbp), %xmm0
addss 0x130(%rax), %xmm0
movss %xmm0, 0x130(%rax)
jmp 0xc6b2
testb $0x1, -0xc(%rbp)
je 0xc620
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0xc631
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movss -0x34(%rbp), %xmm0
addss 0x134(%rax), %xmm0
movss %xmm0, 0x134(%rax)
jmp 0xc6b2
testb $0x1, -0xc(%rbp)
je 0xc665
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0xc683
movq -0x18(%rbp), %rax
movss 0x148(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movss -0x38(%rbp), %xmm0
addss 0x134(%rax), %xmm0
movss %xmm0, 0x134(%rax)
jmp 0xc6b2
movq -0x18(%rbp), %rax
movb -0xc(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x154(%rax)
jmp 0xc6b2
jmp 0xc6b2
jmp 0xc4ed
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4650
testb $0x1, %al
jne 0x45f7
jmp 0x4612
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4680
movq %rax, %rdi
callq 0x11380
addq $0x20, %rsp
popq %rbp
retq
movq 0x2b9d7(%rip), %rdi     # 0x2fff0
leaq 0x1ae98(%rip), %rsi     # 0x1f4b8
callq 0x3220
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x31d0
movq %rax, %rdi
movq 0x2b96d(%rip), %rsi     # 0x2ffa8
callq 0x3260
movl $0x1, %edi
callq 0x32c0
nopw (%rax,%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/main.cpp
// Function: Object::callable() const
bool Object::callable() const {
  if(type() == Primitive){
    /* TODO */
    return true;
  }else{
    if(_expr.isLam()){
      return true;
    }else{
      return false;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x113b0
cmpl $0x0, %eax
jne 0x4704
movb $0x1, -0x1(%rbp)
jmp 0x4721
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x113c0
testb $0x1, %al
jne 0x4717
jmp 0x471d
movb $0x1, -0x1(%rbp)
jmp 0x4721
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x113b0
cmpl $0x0, %eax
jne 0x4795
movq -0xc8(%rbp), %rdi
movq -0xb8(%rbp), %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x113e0
jmp 0x48bf
movq -0xb8(%rbp), %rdi
addq $0x8, %rdi
callq 0x113c0
testb $0x1, %al
jne 0x47ae
jmp 0x4881
movq -0xb8(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, -0xe8(%rbp)
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0xe0(%rbp)
addq $0x10, %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x11150
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x43a0
jmp 0x4814
movq -0xe8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x11150
jmp 0x482d
leaq -0x30(%rbp), %rdi
callq 0x11340
leaq -0xa0(%rbp), %rdi
callq 0x111d0
jmp 0x48bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x4873
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11340
leaq -0xa0(%rbp), %rdi
callq 0x111d0
jmp 0x48cf
movq 0x2b768(%rip), %rdi     # 0x2fff0
leaq 0x1ac55(%rip), %rsi     # 0x1f4e4
callq 0x3220
movq %rax, %rdi
movq -0xb8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x33b0
movq %rax, %rdi
movq 0x2b6f8(%rip), %rsi     # 0x2ffa8
callq 0x3260
movl $0x1, %edi
callq 0x32c0
movq -0xc0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x33c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x1d(%rbp)
movl $0x50, %edi
callq 0x3230
movq -0x60(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x8700
jmp 0xa020
movq -0x58(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x7a30
movslq -0x1c(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3170
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0xa07b
movq -0x70(%rbp), %rdi
callq 0x8350
movb $0x0, 0x38(%rax)
jmp 0xa157
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x50, %esi
callq 0x3240
jmp 0xa180
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32a0
movq -0x60(%rbp), %rdi
movb (%rax), %al
movb %al, -0x2d(%rbp)
leaq -0x2d(%rbp), %rsi
callq 0x8750
movq %rax, -0x80(%rbp)
jmp 0xa0a0
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x87b0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8780
testb $0x1, %al
jne 0xa0cb
jmp 0xa155
leaq -0x38(%rbp), %rdi
callq 0x87e0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x8350
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
incl %ecx
leaq -0x50(%rbp), %rdi
callq 0x9fd0
jmp 0xa0f7
movq -0x70(%rbp), %rdi
callq 0x8350
movq %rax, %rdi
leaq -0x2d(%rbp), %rsi
callq 0x8810
movq %rax, -0x88(%rbp)
jmp 0xa115
movq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8840
leaq -0x50(%rbp), %rdi
callq 0x7970
jmp 0xa155
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xa177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7970
jmp 0xa177
jmp 0xa157
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0xa16a
movq -0x70(%rbp), %rdi
callq 0x7970
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x7970
movq -0x28(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3170
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0xa1d6
movq -0x40(%rbp), %rax
movb 0x38(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa24b
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32a0
movq -0x40(%rbp), %rdi
movb (%rax), %al
movb %al, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
callq 0x8750
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x87b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8780
testb $0x1, %al
jne 0xa219
jmp 0xa247
leaq -0x28(%rbp), %rdi
callq 0x87e0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x8350
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl $0x1, %edx
callq 0xa190
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa24b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3170
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0xa2df
movq -0x40(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0xa2b3
movq -0x40(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
jmp 0xa37b
movq 0x25d36(%rip), %rdi     # 0x2fff0
leaq 0x1540f(%rip), %rsi     # 0x1f6d0
callq 0x3220
movq %rax, %rdi
movq 0x25cd8(%rip), %rsi     # 0x2ffa8
callq 0x3260
movl $0x1, %edi
callq 0x32c0
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32a0
movq -0x40(%rbp), %rdi
movb (%rax), %al
movb %al, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
callq 0x8750
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x87b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8780
testb $0x1, %al
jne 0xa322
jmp 0xa34f
leaq -0x28(%rbp), %rdi
callq 0x87e0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x8350
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl $0x1, %edx
callq 0xa260
movq %rax, -0x8(%rbp)
jmp 0xa37b
movq 0x25c9a(%rip), %rdi     # 0x2fff0
leaq 0x15373(%rip), %rsi     # 0x1f6d0
callq 0x3220
movq %rax, %rdi
movq 0x25c3c(%rip), %rsi     # 0x2ffa8
callq 0x3260
movl $0x1, %edi
callq 0x32c0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xb8(%rbp)
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1c190
movq -0xb8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1c240
jmp 0x134e8
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c190
jmp 0x134f7
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x135d0
jmp 0x13509
movq -0xc8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c310
jmp 0x1351b
leaq -0x58(%rbp), %rdi
callq 0x1c330
leaq -0x98(%rbp), %rdi
callq 0x13670
leaq -0x38(%rbp), %rdi
callq 0x1c330
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x135b8
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
callq 0x1c2f0
jmp 0x135b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x135ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c330
leaq -0x98(%rbp), %rdi
callq 0x13670
leaq -0x38(%rbp), %rdi
callq 0x1c330
movq -0xa0(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::operator|(Parsers::Parser, Parsers::Parser)::$_0::operator()(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) const
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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d440
movq -0xb0(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x1c570
leaq -0x60(%rbp), %rdi
leaq -0x21(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1d460
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1d4a0
testb $0x1, -0x21(%rbp)
je 0x18c19
movq -0xc0(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
callq 0x133a0
jmp 0x18cb3
movq -0xb0(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rcx
leaq -0x78(%rbp), %rdi
callq 0x1c570
leaq -0x98(%rbp), %rdi
leaq -0x21(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x1d460
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1d4a0
testb $0x1, -0x21(%rbp)
je 0x18c95
movq -0xc0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rsi
callq 0x133a0
jmp 0x18cb3
movq -0xc0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rsi
callq 0x13360
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq -0x10(%rbp), %rsi
callq 0x30e0
movq -0x90(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1c240
jmp 0x13a05
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x13aa0
jmp 0x13a14
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c310
jmp 0x13a26
leaq -0x38(%rbp), %rdi
callq 0x1c330
leaq -0x78(%rbp), %rdi
callq 0x13b40
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x3140
jmp 0x13a97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x13a8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c330
leaq -0x78(%rbp), %rdi
callq 0x13b40
movq -0x80(%rbp), %rdi
callq 0x33c0
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x133e0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3200
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3410
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c3a0
testb $0x1, %al
jne 0x13bd5
jmp 0x13cbd
leaq -0x28(%rbp), %rdi
callq 0x1c3e0
movq -0xb8(%rbp), %rsi
movb (%rax), %al
movb %al, -0x31(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c370
jmp 0x13bf5
movsbl -0x31(%rbp), %esi
leaq -0xa8(%rbp), %rdi
callq 0x13930
jmp 0x13c07
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x13d00
jmp 0x13c1d
movq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c400
jmp 0x13c2f
leaq -0x58(%rbp), %rdi
callq 0x1c350
leaq -0xa8(%rbp), %rdi
callq 0x1c350
leaq -0x78(%rbp), %rdi
callq 0x1c350
leaq -0x28(%rbp), %rdi
callq 0x1c430
jmp 0x13bbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x13ce3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x13cb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x13ca6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c350
leaq -0xa8(%rbp), %rdi
callq 0x1c350
leaq -0x78(%rbp), %rdi
callq 0x1c350
jmp 0x13ce3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x13cd3
movq -0xb8(%rbp), %rdi
callq 0x1c350
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x1c350
movq -0x80(%rbp), %rdi
callq 0x33c0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c370
movq -0x90(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1c370
jmp 0x13d51
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x14190
jmp 0x13d60
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c310
jmp 0x13d72
leaq -0x38(%rbp), %rdi
callq 0x1c330
leaq -0x78(%rbp), %rdi
callq 0x14230
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x1c350
jmp 0x13de3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x13dda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c330
leaq -0x78(%rbp), %rdi
callq 0x14230
movq -0x80(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::many(Parsers::Parser)::$_0::operator()(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) const
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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
je 0x180d2
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x1c570
leaq -0x60(%rbp), %rdi
leaq -0x21(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1d460
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1d4a0
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1db60
jmp 0x1807a
movq -0x80(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
callq 0x133a0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::some(Parsers::Parser)::$_0::operator()(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) const
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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq %rsi, -0xf0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x1c570
leaq -0x58(%rbp), %rdi
leaq -0x21(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x1d460
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d4a0
testb $0x1, -0x21(%rbp)
jne 0x17ab9
movq -0x100(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0x13360
jmp 0x17bc6
movq -0xf0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1c370
movq -0x108(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x13e60
jmp 0x17ae8
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xc8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1c570
jmp 0x17b1e
leaq 0x8291(%rip), %rsi      # 0x1fdb6
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x10(%rbp), %rdx
callq 0x1c5d0
movq -0x110(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1c610
jmp 0x17b4e
leaq -0x90(%rbp), %rdi
callq 0x1c350
leaq -0xb0(%rbp), %rdi
callq 0x1c350
movq -0x100(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rsi
callq 0x133a0
jmp 0x17bc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x17bb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c350
leaq -0xb0(%rbp), %rdi
callq 0x1c350
jmp 0x17bd6
movq -0xf8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::satisfy(std::function<bool (char)>)::$_0::operator()(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) const
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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c640
testb $0x1, %al
jne 0x19f3e
jmp 0x19f55
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x13360
jmp 0x19fa2
leaq -0x10(%rbp), %rdi
callq 0x1c3e0
movq -0x40(%rbp), %rdi
movsbl (%rax), %esi
callq 0x1df70
testb $0x1, %al
jne 0x19f85
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x13360
jmp 0x19fa2
leaq -0x10(%rbp), %rdi
callq 0x1c430
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x133a0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::oneOf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0::operator()[abi:cxx11](__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c640
testb $0x1, %al
jne 0x194ee
jmp 0x19508
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x13360
jmp 0x19593
movq -0x60(%rbp), %rdi
callq 0x3200
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x3410
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1c3e0
movq %rax, %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1dba0
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x3410
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c640
testb $0x1, %al
jne 0x1955f
jmp 0x19576
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
callq 0x13360
jmp 0x19593
leaq -0x10(%rbp), %rdi
callq 0x1c430
movq -0x70(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
callq 0x133a0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
callq 0x1c520
movq -0x10(%rbp), %rdi
callq 0x3200
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3410
movq %rax, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c540
jmp 0x15632
jmp 0x15634
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c3a0
testb $0x1, %al
jne 0x1564a
jmp 0x157a1
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq 0x1ac9f(%rip), %rsi     # 0x30308
leaq -0x68(%rbp), %rdi
callq 0x1c570
jmp 0x15674
leaq 0xa73b(%rip), %rsi      # 0x1fdb6
leaq -0x88(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x1c5d0
movq -0xf0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1c610
jmp 0x156a4
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c640
testb $0x1, %al
jne 0x156b7
jmp 0x156de
jmp 0x157a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x157bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x157b3
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14bf0
jmp 0x156f0
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rdx
movq -0xc8(%rbp), %rcx
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1c570
jmp 0x15729
leaq 0xa686(%rip), %rsi      # 0x1fdb6
leaq -0xd8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x1c5d0
movq -0xf8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1c610
jmp 0x1575c
leaq -0xb8(%rbp), %rdi
callq 0x1c350
cmpl $0x0, -0x48(%rbp)
je 0x1579c
movq -0xe0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c680
jmp 0x15780
jmp 0x1579c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1c350
jmp 0x157b3
jmp 0x15634
leaq -0x48(%rbp), %rdi
callq 0x11de0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x11de0
movq -0xe8(%rbp), %rdi
callq 0x119e0
movq -0x50(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c6e0
testb $0x1, %al
jne 0x1580e
jmp 0x15887
leaq -0x31(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x33e0
movq -0x68(%rbp), %rdx
leaq 0xa460(%rip), %rsi      # 0x1fc86
leaq -0x30(%rbp), %rdi
callq 0x11720
jmp 0x15831
movq -0x60(%rbp), %rdi
movl $0x7, %esi
leaq -0x30(%rbp), %rdx
callq 0x1c710
jmp 0x15845
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq -0x31(%rbp), %rdi
callq 0x3280
jmp 0x158be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1587c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3140
leaq -0x31(%rbp), %rdi
callq 0x3280
jmp 0x158c8
movq -0x50(%rbp), %rdi
movb $0x0, -0x45(%rbp)
callq 0x1c740
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1c770
movq -0x50(%rbp), %rdi
callq 0x1c7b0
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0x158bc
movq -0x60(%rbp), %rdi
callq 0x11de0
jmp 0x158be
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Expression::print() const
void Expression::print() const {
  switch(type){
    case Constant:
      cout << "[\"int\"," << val << "]";
      break;
    case Var:
      cout << "[\"var\",\"" << name << "\"]";
      break;
    case Lambda:
      cout << "[\"lam\",\"" << name << "\",";
      body->print();
      cout << "]";
      break;
    case Ap:
      cout << "[\"app\",";
      body->print();
      cout << ",";
      arg->print();
      cout << "]";
      break;
    case Nothing:
      cerr << "[Expression] Unexpected expression type: Nothing" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0x15b80
movq -0x10(%rbp), %rax
leaq 0x9d75(%rip), %rcx      # 0x1f7b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x1a579(%rip), %rdi     # 0x2ffc8
leaq 0xa234(%rip), %rsi      # 0x1fc8a
callq 0x3220
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x33b0
movq %rax, %rdi
leaq 0xa228(%rip), %rsi      # 0x1fc9c
callq 0x3220
jmp 0x15b80
movq 0x1a543(%rip), %rdi     # 0x2ffc8
leaq 0xa206(%rip), %rsi      # 0x1fc92
callq 0x3220
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xa1f0(%rip), %rsi      # 0x1fc9b
callq 0x3220
jmp 0x15b80
movq 0x1a50c(%rip), %rdi     # 0x2ffc8
leaq 0xa1db(%rip), %rsi      # 0x1fc9e
callq 0x3220
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xa1ca(%rip), %rsi      # 0x1fcac
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15a10
movq 0x1a4cd(%rip), %rdi     # 0x2ffc8
leaq 0xa19a(%rip), %rsi      # 0x1fc9c
callq 0x3220
jmp 0x15b80
movq 0x1a4b8(%rip), %rdi     # 0x2ffc8
leaq 0xa190(%rip), %rsi      # 0x1fca7
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15a10
movq 0x1a498(%rip), %rdi     # 0x2ffc8
leaq 0xa176(%rip), %rsi      # 0x1fcad
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x15a10
movq 0x1a478(%rip), %rdi     # 0x2ffc8
leaq 0xa145(%rip), %rsi      # 0x1fc9c
callq 0x3220
jmp 0x15b80
movq 0x1a48b(%rip), %rdi     # 0x2fff0
leaq 0xa143(%rip), %rsi      # 0x1fcaf
callq 0x3220
movq %rax, %rdi
movq 0x1a42d(%rip), %rsi     # 0x2ffa8
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Expression::prettyPrint() const
void Expression::prettyPrint() const {
  switch(type){
    case Var:
      cout << name;
      return ;
    case Constant:
      cout << val;
      return ;
    case Lambda:
      cout << "\\" << name << " ";
      body->prettyPrint();
      return ;
    case Ap:
      if(body->isLam() || body->isAp()) cout << "(";
      body->prettyPrint();
      if(body->isLam() || body->isAp()) cout << ")";
      cout << " ";
      if(arg->isLam() || arg->isAp()) cout << "(";
      arg->prettyPrint();
      if(arg->isLam() || arg->isAp()) cout << ")";
      return ;
    case Nothing:
      cerr << "[Expression] Unexpected expression type: Nothing" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0x15d6a
movq -0x10(%rbp), %rax
leaq 0x9c09(%rip), %rcx      # 0x1f7c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq 0x1a3f1(%rip), %rdi     # 0x2ffc8
callq 0x31d0
jmp 0x15d6a
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq 0x1a3d9(%rip), %rdi     # 0x2ffc8
callq 0x33b0
jmp 0x15d6a
movq 0x1a3c8(%rip), %rdi     # 0x2ffc8
leaq 0xa0d9(%rip), %rsi      # 0x1fce0
callq 0x3220
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0x98f1(%rip), %rsi      # 0x1f517
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15b90
jmp 0x15d6a
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x113c0
testb $0x1, %al
jne 0x15c61
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1c880
testb $0x1, %al
jne 0x15c61
jmp 0x15c74
movq 0x1a360(%rip), %rdi     # 0x2ffc8
leaq 0xa073(%rip), %rsi      # 0x1fce2
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x15b90
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x113c0
testb $0x1, %al
jne 0x15ca5
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1c880
testb $0x1, %al
jne 0x15ca5
jmp 0x15cb8
movq 0x1a31c(%rip), %rdi     # 0x2ffc8
leaq 0xa101(%rip), %rsi      # 0x1fdb4
callq 0x3220
movq 0x1a309(%rip), %rdi     # 0x2ffc8
leaq 0x9851(%rip), %rsi      # 0x1f517
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x113c0
testb $0x1, %al
jne 0x15cef
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c880
testb $0x1, %al
jne 0x15cef
jmp 0x15d02
movq 0x1a2d2(%rip), %rdi     # 0x2ffc8
leaq 0x9fe5(%rip), %rsi      # 0x1fce2
callq 0x3220
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x15b90
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x113c0
testb $0x1, %al
jne 0x15d33
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c880
testb $0x1, %al
jne 0x15d33
jmp 0x15d46
movq 0x1a28e(%rip), %rdi     # 0x2ffc8
leaq 0xa073(%rip), %rsi      # 0x1fdb4
callq 0x3220
jmp 0x15d6a
movq 0x1a2a1(%rip), %rdi     # 0x2fff0
leaq 0x9f59(%rip), %rsi      # 0x1fcaf
callq 0x3220
movq %rax, %rdi
movq 0x1a243(%rip), %rsi     # 0x2ffa8
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
// File: silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: parseExpression(Scanner&)
Expression * parseExpression(Scanner &scanner){
  Expression * expr(parseExpressionTail(scanner));
  if(expr == nullptr){
    cerr << "[Parse expression] Unexpected token: " << scanner.peekToken().name << endl;
    exit(1);
    return nullptr;
  }
  while(true){
    Expression * expr1(parseExpressionTail(scanner));
    if(expr1 == nullptr){
      return expr;
    }else{
      Expression * expr2(new Expression(Expression::Ap));
      expr2->body = expr;
      expr2->arg  = expr1;
      expr = expr2;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15ea0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15e06
movq 0x1a259(%rip), %rdi     # 0x2fff0
leaq 0x9f46(%rip), %rsi      # 0x1fce4
callq 0x3220
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x158e0
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31d0
movq %rax, -0x60(%rbp)
jmp 0x15dc7
movq -0x60(%rbp), %rdi
movq 0x1a1d6(%rip), %rsi     # 0x2ffa8
callq 0x3260
jmp 0x15dd9
leaq -0x38(%rbp), %rdi
callq 0x11de0
movl $0x1, %edi
callq 0x32c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11de0
jmp 0x15e91
jmp 0x15e08
movq -0x8(%rbp), %rdi
callq 0x15ea0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x15e26
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movl $0x38, %edi
callq 0x3230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movl $0x4, %esi
callq 0x11640
jmp 0x15e46
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x15e8c
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x38, %esi
callq 0x3240
jmp 0x15e91
jmp 0x15e08
movq -0x40(%rbp), %rdi
callq 0x33c0
nopw (%rax,%rax)