LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: coolsuperman[P]ShareCataLogServer/./Tools.hpp
// Function: Tools::StrToDigit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static int64_t StrToDigit(const std::string& str){
      int64_t num;
      std::stringstream ss;
      ss<<str;
      ss>>num;
      return num;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2180
leaq -0x188(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x21f0
jmp 0x479d
leaq -0x198(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2150
jmp 0x47af
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x21b0
movq -0x1b0(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x21b0
movq -0x1a0(%rbp), %rdi
callq 0x23c0
// File: coolsuperman[P]ShareCataLogServer/upload.cc
// Function: Upload::CreateFile()
bool CreateFile(){
      std::string path = "./Web/"+_file_name;
      Shmat sh;
      sh.shmid=sh.createShm(1024);
      sh.Send(path);
      _file_fd=open(path.c_str(),O_CREAT|O_WRONLY,0664);
      if(_file_fd<0){
        fprintf(stderr,"open error:%s\n",strerror(errno));
        return false;
      }
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0xa0(%rbp)
addq $0x10, %rdx
leaq 0x244e(%rip), %rsi      # 0x72c3
leaq -0x30(%rbp), %rdi
callq 0x4800
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5060
movq -0x98(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x5080
movl %eax, -0x90(%rbp)
jmp 0x4ea7
movl -0x90(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20f0
jmp 0x4ec2
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x50b0
jmp 0x4ed4
leaq -0x88(%rbp), %rdi
callq 0x2458
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq %rax, %rdi
xorl %eax, %eax
movl $0x41, %esi
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x21a0
movl %eax, -0xa4(%rbp)
jmp 0x4f05
movq -0xa0(%rbp), %rax
movl -0xa4(%rbp), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0x4f88
movq 0x60ae(%rip), %rax      # 0xafd0
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x2090
movq -0xb0(%rbp), %rdi
movq %rax, %rdx
leaq 0x2381(%rip), %rsi      # 0x72ca
movb $0x0, %al
callq 0x2310
movb $0x0, -0x1(%rbp)
movl $0x1, -0x8c(%rbp)
jmp 0x4f96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4fb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2458
jmp 0x4fb6
movb $0x1, -0x1(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5100
leaq -0x30(%rbp), %rdi
callq 0x2458
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x5100
leaq -0x30(%rbp), %rdi
callq 0x2458
movq -0x60(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: coolsuperman[P]ShareCataLogServer/upload.cc
// Function: Upload::CloseFile()
bool CloseFile(){
      if(_file_fd!=-1){
        close(_file_fd);
        _file_fd = -1;
      }
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $-0x1, 0x8(%rax)
je 0x5051
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2420
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: coolsuperman[P]ShareCataLogServer/./Tools.hpp
// Function: Shmat::commShm(int, int)
static int commShm(int size, int flags)
  {
    key_t _key = ftok(PATHNAME, PROJ_ID);
    //std::cerr<<_key<<std::endl;
    if(_key < 0){
      perror("ftok");
      return -1;
    }
    int shmid = 0;
    if( (shmid = shmget(_key, size, flags)) <= 0 ){
      perror("shmget");
      return -2;
    }
    return shmid;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x21a4(%rip), %rdi      # 0x72d9
movl $0x66, %esi
callq 0x2370
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x515d
leaq 0x218d(%rip), %rdi      # 0x72dc
callq 0x21d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5196
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %edi
movslq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x2160
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jg 0x5190
leaq 0x215f(%rip), %rdi      # 0x72e1
callq 0x21d0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x5196
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: sighingnow[P]compile-pascal/./libparsec/parser.hpp
// Function: any_fn(input_t*)
pair<int, char> any_fn(input_t *text) {
    if (text->empty()) { return make_pair(-1, '\0'); }
    // char k, c = text->at(0);
    // bool escaped = false;
    // if (c == '\\' && text->length() >= 2) {
    //     switch (text->at(1)) {
    //         case '\\': k = '\\'; break;
    //         case '0': k = '\0'; break;
    //         case 'n': k = '\n'; break;
    //         case 'r': k = '\r'; break;
    //         case 'v': k = '\v'; break;
    //         case 't': k = '\t'; break;
    //         case 'b': k = '\b'; break;
    //         case 'f': k = '\f'; break;
    //         default: k = text->at(1);
    //     }
    //     escaped = true;
    // }
    // else {
    //     k = c;
    // }
    // return make_pair(k != EOF ? (escaped ? 2 : 1) : (-1), k);
    char c = text->at(0);
    return make_pair(c != EOF ? (1) : (-1), c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19780
testb $0x1, %al
jne 0x8d9b
jmp 0x8dc1
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movb $0x0, -0x15(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x15(%rbp), %rsi
callq 0x197b0
movl %eax, %ecx
movl %ecx, -0x8(%rbp)
shrq $0x20, %rax
movb %al, -0x4(%rbp)
jmp 0x8e05
movq -0x10(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x197e0
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
subb $-0x1, %al
setne %al
movzbl %al, %ecx
movl %ecx, %eax
leal -0x1(%rax,%rax), %eax
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x16(%rbp), %rsi
callq 0x19810
movl %eax, %ecx
movl %ecx, -0x8(%rbp)
shrq $0x20, %rax
movb %al, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: sighingnow[P]compile-pascal/./libparsec/parser.hpp
// Function: print_fn(input_t*)
pair<int, char> print_fn(input_t *text) {
    if (text->empty()) { return make_pair(-1, '\0'); }
    // char k, h, c = text->at(0);
    // bool escaped = false;
    // if (c == '\\' && text->length() >= 2) {
    //     switch (text->at(1)) {
    //         case '\\': k = '\\'; break;
    //         case '0': k = '\0'; break;
    //         case 'n': k = '\n'; break;
    //         case 'r': k = '\r'; break;
    //         case 'v': k = '\v'; break;
    //         case 't': k = '\t'; break;
    //         case 'b': k = '\b'; break;
    //         case 'f': k = '\f'; break;
    //         default: k = text->at(1);
    //     }
    //     h = text->at(1); escaped = true;
    // }
    // else {
    //     h = c; k = c;
    // }
    // cout << ";; " << (int)k << endl;
    // return make_pair(::isprint(h) ? (escaped ? 2 : 1) : (-1), k);
    char c = text->at(0);
    return make_pair(::isprint(c) ? (1) : (-1), c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19780
testb $0x1, %al
jne 0x957b
jmp 0x95a1
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movb $0x0, -0x15(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x15(%rbp), %rsi
callq 0x197b0
movl %eax, %ecx
movl %ecx, -0x8(%rbp)
shrq $0x20, %rax
movb %al, -0x4(%rbp)
jmp 0x95e9
movq -0x10(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x197e0
movb %al, -0x16(%rbp)
movsbl -0x16(%rbp), %edi
callq 0x55c0
movl %eax, %ecx
xorl %eax, %eax
subl $0x1, %ecx
sbbl %eax, %eax
orl $0x1, %eax
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x16(%rbp), %rsi
callq 0x19810
movl %eax, %ecx
movl %ecx, -0x8(%rbp)
shrq $0x20, %rax
movb %al, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_program_fn(input_t*)
pair<int, pl0_ast_program *> pl0_program_fn(input_t *text) {
    auto parser = pl0_prog << pl0_character('.');
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Program" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_program(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp            # imm = 0x3E0
movq %rdi, -0x18(%rbp)
movb $0x2e, -0xf1(%rbp)
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x3a8(%rbp)
leaq -0xf1(%rbp), %rsi
callq 0xa240
movq -0x3a8(%rbp), %rdx
leaq 0x1552da(%rip), %rsi    # 0x15fab8
leaq -0xa8(%rbp), %rdi
callq 0x1a520
jmp 0xa7ec
leaq -0xf0(%rbp), %rdi
callq 0x19a20
leaq 0x154fd1(%rip), %rsi    # 0x15f7d0
leaq -0x390(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x1a5a0
jmp 0xa814
leaq 0x154fb5(%rip), %rdx    # 0x15f7d0
leaq -0x298(%rbp), %rdi
leaq -0x390(%rbp), %rsi
callq 0x1a560
jmp 0xa830
movq -0x18(%rbp), %rdx
leaq -0x138(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0x1a5e0
jmp 0xa849
leaq -0x298(%rbp), %rdi
callq 0x1a940
leaq -0x390(%rbp), %rdi
callq 0x1a970
testb $0x1, 0x154fd0(%rip)    # 0x15f838
je 0xa938
movq 0x154763(%rip), %rdi    # 0x15efd8
leaq 0xe493b(%rip), %rsi     # 0xef1b7
callq 0x5330
movq %rax, -0x3b0(%rbp)
jmp 0xa88a
movq -0x3b0(%rbp), %rdi
movq 0x154728(%rip), %rsi    # 0x15efc0
callq 0x53a0
jmp 0xa89f
jmp 0xa938
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x19a20
jmp 0xaa49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0xaa3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0xa910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0x298(%rbp), %rdi
callq 0x1a940
leaq -0x390(%rbp), %rdi
callq 0x1a970
jmp 0xaa3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0xaa31
leaq -0x138(%rbp), %rdi
callq 0x1a9d0
movq %rax, -0x3c0(%rbp)
movl $0x10, %edi
callq 0x5340
movq %rax, -0x3b8(%rbp)
jmp 0xa95e
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x3c8(%rbp)
jmp 0xa970
movq -0x3c8(%rbp), %rax
movq %rax, -0x3a0(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x1a9f0
movq -0x3b8(%rbp), %rdi
movq (%rax), %rdx
movq -0x3a0(%rbp), %rsi
callq 0x1aa10
jmp 0xa9a2
movq -0x3c0(%rbp), %rdi
movq -0x3b8(%rbp), %rax
movq %rax, -0x398(%rbp)
leaq -0x398(%rbp), %rsi
callq 0x1a9a0
movq %rdx, -0x3d8(%rbp)
movl %eax, -0x3cc(%rbp)
jmp 0xa9d2
movq -0x3d8(%rbp), %rax
movl -0x3cc(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x1aa40
leaq -0xa8(%rbp), %rdi
callq 0x1aa60
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x3e0, %rsp            # imm = 0x3E0
popq %rbp
retq
movq -0x3b8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
movl $0x10, %esi
callq 0x5350
leaq -0x138(%rbp), %rdi
callq 0x1aa40
leaq -0xa8(%rbp), %rdi
callq 0x1aa60
movq -0x100(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_digit_fn(input_t*)
pair<int, pl0_ast_alnum *> pl0_digit_fn(input_t *text) {
    auto res = digit(text);
    // if (verbose) {
    //     cout << "parsing: Digit" << endl;
    // }
    return make_pair(std::get<0>(res), new pl0_ast_alnum(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x1546d6(%rip), %rsi    # 0x15f570
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1b270
movq -0x78(%rbp), %rdi
callq 0x1b380
movq %rax, -0x70(%rbp)
movl $0xc, %edi
callq 0x5340
movq %rax, -0x68(%rbp)
jmp 0xaec4
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x80(%rbp)
jmp 0xaed3
movq -0x80(%rbp), %rax
movq %rax, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b3a0
movq -0x68(%rbp), %rdi
movsbl (%rax), %edx
movq -0x5c(%rbp), %rsi
callq 0x1b3c0
jmp 0xaef6
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x1b350
movq %rdx, -0x90(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xaf1a
movq -0x90(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b3f0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xaf6f
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0xc, %esi
callq 0x5350
leaq -0x40(%rbp), %rdi
callq 0x1b3f0
movq -0x50(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_alpha_fn(input_t*)
pair<int, pl0_ast_alnum *> pl0_alpha_fn(input_t *text) {
    auto res = alpha(text);
    // if (verbose) {
    //     cout << "parsing: Alpha" << endl;
    // }
    return make_pair(std::get<0>(res), new pl0_ast_alnum(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x1546e6(%rip), %rsi    # 0x15f690
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1b270
movq -0x78(%rbp), %rdi
callq 0x1b380
movq %rax, -0x70(%rbp)
movl $0xc, %edi
callq 0x5340
movq %rax, -0x68(%rbp)
jmp 0xafd4
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x80(%rbp)
jmp 0xafe3
movq -0x80(%rbp), %rax
movq %rax, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b3a0
movq -0x68(%rbp), %rdi
movsbl (%rax), %edx
movq -0x5c(%rbp), %rsi
callq 0x1b3c0
jmp 0xb006
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x1b350
movq %rdx, -0x90(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xb02a
movq -0x90(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b3f0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xb07f
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0xc, %esi
callq 0x5350
leaq -0x40(%rbp), %rdi
callq 0x1b3f0
movq -0x50(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_function_id_fn(input_t*)
pair<int, pl0_ast_function_id *> pl0_function_id_fn(input_t *text) {
    auto res = pl0_identify(text);
    if (verbose) {
        cout << "parsing: Function Identifier" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_function_id(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq 0x150062(%rip), %rsi    # 0x15fcb0
callq 0x218a0
testb $0x1, 0x14fbde(%rip)    # 0x15f838
je 0xfc9a
movq 0x14f375(%rip), %rdi    # 0x15efd8
leaq 0xdf6e3(%rip), %rsi     # 0xef34d
callq 0x5330
movq %rax, -0x70(%rbp)
jmp 0xfc75
movq -0x70(%rbp), %rdi
movq 0x14f340(%rip), %rsi    # 0x15efc0
callq 0x53a0
jmp 0xfc87
jmp 0xfc9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xfd5a
leaq -0x48(%rbp), %rdi
callq 0x219b0
movq %rax, -0x80(%rbp)
movl $0x10, %edi
callq 0x5340
movq %rax, -0x78(%rbp)
jmp 0xfcb7
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x88(%rbp)
jmp 0xfcc9
movq -0x88(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x219d0
movq -0x78(%rbp), %rdi
movq (%rax), %rdx
movq -0x68(%rbp), %rsi
callq 0x219f0
jmp 0xfcef
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x21980
movq %rdx, -0x98(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xfd13
movq -0x98(%rbp), %rax
movl -0x8c(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x21a20
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x10, %esi
callq 0x5350
leaq -0x48(%rbp), %rdi
callq 0x21a20
movq -0x50(%rbp), %rdi
callq 0x55b0
nopl (%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_procedure_stmt_fn(input_t*)
pair<int, pl0_ast_procedure_stmt *> pl0_procedure_stmt_fn(input_t *text) {
    auto res = (((pl0_procedure_header + pl0_prog) << pl0_character(';'))++)(text);
    if (verbose) {
        cout << "parsing: Procedure Statement" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_procedure_stmt(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movq %rdi, -0x18(%rbp)
leaq 0x14f76a(%rip), %rsi    # 0x15fef0
leaq 0x14f32b(%rip), %rdx    # 0x15fab8
leaq -0x298(%rbp), %rdi
callq 0x22770
movb $0x3b, -0x2e1(%rbp)
leaq -0x2e0(%rbp), %rdi
leaq -0x2e1(%rbp), %rsi
callq 0xa240
jmp 0x107b5
leaq -0x208(%rbp), %rdi
leaq -0x298(%rbp), %rsi
leaq -0x2e0(%rbp), %rdx
callq 0x22730
jmp 0x107d1
leaq -0x130(%rbp), %rdi
leaq -0x208(%rbp), %rsi
xorl %edx, %edx
callq 0x22700
jmp 0x107e8
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x227b0
jmp 0x107fe
leaq -0x130(%rbp), %rdi
callq 0x22870
leaq -0x208(%rbp), %rdi
callq 0x22890
leaq -0x2e0(%rbp), %rdi
callq 0x19a20
leaq -0x298(%rbp), %rdi
callq 0x228c0
testb $0x1, 0x14f003(%rip)    # 0x15f838
je 0x1090b
movq 0x14e796(%rip), %rdi    # 0x15efd8
leaq 0xdeb54(%rip), %rsi     # 0xef39d
callq 0x5330
movq %rax, -0x310(%rbp)
jmp 0x10857
movq -0x310(%rbp), %rdi
movq 0x14e75b(%rip), %rsi    # 0x15efc0
callq 0x53a0
jmp 0x1086c
jmp 0x1090b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x108e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x108d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x108cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x22870
leaq -0x208(%rbp), %rdi
callq 0x22890
leaq -0x2e0(%rbp), %rdi
callq 0x19a20
leaq -0x298(%rbp), %rdi
callq 0x228c0
jmp 0x109f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x109ef
leaq -0x58(%rbp), %rdi
callq 0x22920
movq %rax, -0x320(%rbp)
movl $0x20, %edi
callq 0x5340
movq %rax, -0x318(%rbp)
jmp 0x1092e
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x328(%rbp)
jmp 0x10940
movq -0x328(%rbp), %rax
movq %rax, -0x308(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x22940
movq -0x318(%rbp), %rdi
movq %rax, %rdx
movq -0x308(%rbp), %rsi
callq 0x22960
jmp 0x1096f
movq -0x320(%rbp), %rdi
movq -0x318(%rbp), %rax
movq %rax, -0x300(%rbp)
leaq -0x300(%rbp), %rsi
callq 0x228f0
movq %rdx, -0x338(%rbp)
movl %eax, -0x32c(%rbp)
jmp 0x1099f
movq -0x338(%rbp), %rax
movl -0x32c(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x229a0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
movq -0x318(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
movl $0x20, %esi
callq 0x5350
leaq -0x58(%rbp), %rdi
callq 0x229a0
movq -0x2f0(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_function_stmt_fn(input_t*)
pair<int, pl0_ast_function_stmt *> pl0_function_stmt_fn(input_t *text) {
    auto res = (((pl0_function_header + pl0_prog) << pl0_character(';'))++)(text);
    if (verbose) {
        cout << "parsing: Function Statement" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_function_stmt(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movq %rdi, -0x18(%rbp)
leaq 0x14f512(%rip), %rsi    # 0x15ff38
leaq 0x14f08b(%rip), %rdx    # 0x15fab8
leaq -0x298(%rbp), %rdi
callq 0x22a30
movb $0x3b, -0x2e1(%rbp)
leaq -0x2e0(%rbp), %rdi
leaq -0x2e1(%rbp), %rsi
callq 0xa240
jmp 0x10a55
leaq -0x208(%rbp), %rdi
leaq -0x298(%rbp), %rsi
leaq -0x2e0(%rbp), %rdx
callq 0x229f0
jmp 0x10a71
leaq -0x130(%rbp), %rdi
leaq -0x208(%rbp), %rsi
xorl %edx, %edx
callq 0x229c0
jmp 0x10a88
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x22a70
jmp 0x10a9e
leaq -0x130(%rbp), %rdi
callq 0x22b30
leaq -0x208(%rbp), %rdi
callq 0x22b50
leaq -0x2e0(%rbp), %rdi
callq 0x19a20
leaq -0x298(%rbp), %rdi
callq 0x22b80
testb $0x1, 0x14ed63(%rip)    # 0x15f838
je 0x10bab
movq 0x14e4f6(%rip), %rdi    # 0x15efd8
leaq 0xde8d1(%rip), %rsi     # 0xef3ba
callq 0x5330
movq %rax, -0x310(%rbp)
jmp 0x10af7
movq -0x310(%rbp), %rdi
movq 0x14e4bb(%rip), %rsi    # 0x15efc0
callq 0x53a0
jmp 0x10b0c
jmp 0x10bab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x10b83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x10b77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x10b6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x22b30
leaq -0x208(%rbp), %rdi
callq 0x22b50
leaq -0x2e0(%rbp), %rdi
callq 0x19a20
leaq -0x298(%rbp), %rdi
callq 0x22b80
jmp 0x10c98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
jmp 0x10c8f
leaq -0x58(%rbp), %rdi
callq 0x22be0
movq %rax, -0x320(%rbp)
movl $0x20, %edi
callq 0x5340
movq %rax, -0x318(%rbp)
jmp 0x10bce
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x328(%rbp)
jmp 0x10be0
movq -0x328(%rbp), %rax
movq %rax, -0x308(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x22c00
movq -0x318(%rbp), %rdi
movq %rax, %rdx
movq -0x308(%rbp), %rsi
callq 0x22c20
jmp 0x10c0f
movq -0x320(%rbp), %rdi
movq -0x318(%rbp), %rax
movq %rax, -0x300(%rbp)
leaq -0x300(%rbp), %rsi
callq 0x22bb0
movq %rdx, -0x338(%rbp)
movl %eax, -0x32c(%rbp)
jmp 0x10c3f
movq -0x338(%rbp), %rax
movl -0x32c(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x22c60
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
movq -0x318(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2f0(%rbp)
movl %eax, -0x2f4(%rbp)
movl $0x20, %esi
callq 0x5350
leaq -0x58(%rbp), %rdi
callq 0x22c60
movq -0x2f0(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_arg_fn(input_t*)
pair<int, pl0_ast_arg *> pl0_arg_fn(input_t *text) {
    auto res = pl0_expression(text);
    if (verbose) {
        cout << "parsing: Argument" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_arg(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq 0x14ddb2(%rip), %rsi    # 0x160130
callq 0x24fd0
testb $0x1, 0x14d4ae(%rip)    # 0x15f838
je 0x123ca
movq 0x14cc45(%rip), %rdi    # 0x15efd8
leaq 0xdd0c5(%rip), %rsi     # 0xef45f
callq 0x5330
movq %rax, -0x70(%rbp)
jmp 0x123a5
movq -0x70(%rbp), %rdi
movq 0x14cc10(%rip), %rsi    # 0x15efc0
callq 0x53a0
jmp 0x123b7
jmp 0x123ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1248a
leaq -0x48(%rbp), %rdi
callq 0x250e0
movq %rax, -0x80(%rbp)
movl $0x10, %edi
callq 0x5340
movq %rax, -0x78(%rbp)
jmp 0x123e7
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x88(%rbp)
jmp 0x123f9
movq -0x88(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x25100
movq -0x78(%rbp), %rdi
movq (%rax), %rdx
movq -0x68(%rbp), %rsi
callq 0x25120
jmp 0x1241f
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x250b0
movq %rdx, -0x98(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x12443
movq -0x98(%rbp), %rax
movl -0x8c(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x25150
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x10, %esi
callq 0x5350
leaq -0x48(%rbp), %rdi
callq 0x25150
movq -0x50(%rbp), %rdi
callq 0x55b0
nopl (%rax)
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_call_func_fn(input_t*)
pair<int, pl0_ast_call_func *> pl0_call_func_fn(input_t *text) {
    auto parser = pl0_identify + (~pl0_arg_list);
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Function Call" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_call_func(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp            # imm = 0x3E0
movq %rdi, -0x18(%rbp)
leaq 0x14da6a(%rip), %rsi    # 0x160250
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x3a8(%rbp)
callq 0x257c0
movq -0x3a8(%rbp), %rdx
leaq 0x14d4a9(%rip), %rsi    # 0x15fcb0
leaq -0xa8(%rbp), %rdi
callq 0x25780
jmp 0x12815
leaq -0xf0(%rbp), %rdi
callq 0x257f0
leaq 0x14cfa8(%rip), %rsi    # 0x15f7d0
leaq -0x390(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x25850
jmp 0x1283d
leaq 0x14cf8c(%rip), %rdx    # 0x15f7d0
leaq -0x298(%rbp), %rdi
leaq -0x390(%rbp), %rsi
callq 0x25810
jmp 0x12859
movq -0x18(%rbp), %rdx
leaq -0x138(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0x25890
jmp 0x12872
leaq -0x298(%rbp), %rdi
callq 0x25c00
leaq -0x390(%rbp), %rdi
callq 0x25c30
testb $0x1, 0x14cfa7(%rip)    # 0x15f838
je 0x12961
movq 0x14c73a(%rip), %rdi    # 0x15efd8
leaq 0xdcbe3(%rip), %rsi     # 0xef488
callq 0x5330
movq %rax, -0x3b0(%rbp)
jmp 0x128b3
movq -0x3b0(%rbp), %rdi
movq 0x14c6ff(%rip), %rsi    # 0x15efc0
callq 0x53a0
jmp 0x128c8
jmp 0x12961
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x257f0
jmp 0x12a72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x12a66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x12939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0x298(%rbp), %rdi
callq 0x25c00
leaq -0x390(%rbp), %rdi
callq 0x25c30
jmp 0x12a66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x12a5a
leaq -0x138(%rbp), %rdi
callq 0x25c90
movq %rax, -0x3c0(%rbp)
movl $0x18, %edi
callq 0x5340
movq %rax, -0x3b8(%rbp)
jmp 0x12987
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x3c8(%rbp)
jmp 0x12999
movq -0x3c8(%rbp), %rax
movq %rax, -0x3a0(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x25cb0
movq -0x3b8(%rbp), %rdi
movq %rax, %rdx
movq -0x3a0(%rbp), %rsi
callq 0x25cd0
jmp 0x129cb
movq -0x3c0(%rbp), %rdi
movq -0x3b8(%rbp), %rax
movq %rax, -0x398(%rbp)
leaq -0x398(%rbp), %rsi
callq 0x25c60
movq %rdx, -0x3d8(%rbp)
movl %eax, -0x3cc(%rbp)
jmp 0x129fb
movq -0x3d8(%rbp), %rax
movl -0x3cc(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x25d10
leaq -0xa8(%rbp), %rdi
callq 0x25d30
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x3e0, %rsp            # imm = 0x3E0
popq %rbp
retq
movq -0x3b8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
movl $0x18, %esi
callq 0x5350
leaq -0x138(%rbp), %rdi
callq 0x25d10
leaq -0xa8(%rbp), %rdi
callq 0x25d30
movq -0xf8(%rbp), %rdi
callq 0x55b0
nop
// File: sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_term_fn(input_t*)
pair<int, pl0_ast_term *> pl0_term_fn(input_t *text) {
    auto parser = pl0_factor >= pl0_multop;
    auto res = parser(text);
    if (verbose) {
        cout << "parsing: Term" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_term(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x18(%rbp)
leaq 0x14d72a(%rip), %rsi    # 0x1601c0
leaq 0x14d88b(%rip), %rdx    # 0x160328
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x25d60
movq -0x110(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xe8(%rbp), %rdi
callq 0x25da0
jmp 0x12ac9
testb $0x1, 0x14cd68(%rip)    # 0x15f838
je 0x12b33
movq 0x14c4ff(%rip), %rdi    # 0x15efd8
leaq 0xdc9bf(%rip), %rsi     # 0xef49f
callq 0x5330
movq %rax, -0x118(%rbp)
jmp 0x12aee
movq -0x118(%rbp), %rdi
movq 0x14c4c4(%rip), %rsi    # 0x15efc0
callq 0x53a0
jmp 0x12b03
jmp 0x12b33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x12c38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x12c2c
leaq -0xe8(%rbp), %rdi
callq 0x26190
movq %rax, -0x128(%rbp)
movl $0x20, %edi
callq 0x5340
movq %rax, -0x120(%rbp)
jmp 0x12b59
movq -0x18(%rbp), %rdi
callq 0x1a350
movq %rax, -0x130(%rbp)
jmp 0x12b6b
movq -0x130(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x261b0
movq -0x120(%rbp), %rdi
movq %rax, %rdx
movq -0x108(%rbp), %rsi
callq 0x261d0
jmp 0x12b9d
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x100(%rbp), %rsi
callq 0x26160
movq %rdx, -0x140(%rbp)
movl %eax, -0x134(%rbp)
jmp 0x12bcd
movq -0x140(%rbp), %rax
movl -0x134(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x26210
leaq -0xa8(%rbp), %rdi
callq 0x26230
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x120(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
movl $0x20, %esi
callq 0x5350
leaq -0xe8(%rbp), %rdi
callq 0x26210
leaq -0xa8(%rbp), %rdi
callq 0x26230
movq -0xf0(%rbp), %rdi
callq 0x55b0
// File: sighingnow[P]compile-pascal/./libparsec/combinator.hpp
// Function: choice<parser_t<pl0_ast_constv*>, parser_t<pl0_ast_constv*>, pl0_ast_constv*, pl0_ast_constv*>::operator()[abi:cxx11](input_t*) const
tuple<int, parser_type const, string const> operator () (input_t *text) const {
        auto res1 = pa(text);
        if (std::get<0>(res1) != -1) {
            return make_tuple(std::get<0>(res1), std::get<1>(res1), name());
        }
        else {
            auto res2 = pb(text);
            return make_tuple(std::get<0>(res2), std::get<1>(res2), name());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x140(%rbp)
movq %rdi, %rax
movq %rax, -0x138(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x130(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x1ca70
leaq -0x48(%rbp), %rdi
callq 0x1ce40
cmpl $-0x1, (%rax)
je 0x1d02f
leaq -0x48(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x1ce40
movq -0x158(%rbp), %rdi
movq %rax, -0x150(%rbp)
callq 0x1ce60
movq -0x130(%rbp), %rsi
movq %rax, -0x148(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x53200
jmp 0x1cfa1
movq -0x148(%rbp), %rdx
movq -0x150(%rbp), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rcx
callq 0x531c0
jmp 0x1cfc1
movq -0x140(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x52eb0
leaq -0x78(%rbp), %rdi
callq 0x52ee0
leaq -0x98(%rbp), %rdi
callq 0x5200
movl $0x1, -0xa8(%rbp)
jmp 0x1d134
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x1d14d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x5200
jmp 0x1d14d
movq -0x130(%rbp), %rsi
addq $0x48, %rsi
movq -0x18(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
callq 0x1ca70
jmp 0x1d04c
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x1ce40
movq -0x170(%rbp), %rdi
movq %rax, -0x168(%rbp)
callq 0x1ce60
movq -0x130(%rbp), %rsi
movq %rax, -0x160(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x53200
jmp 0x1d08e
movq -0x160(%rbp), %rdx
movq -0x168(%rbp), %rsi
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rcx
callq 0x531c0
jmp 0x1d0b1
movq -0x140(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x52eb0
leaq -0x108(%rbp), %rdi
callq 0x52ee0
leaq -0x128(%rbp), %rdi
callq 0x5200
movl $0x1, -0xa8(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1ceb0
jmp 0x1d134
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x1d126
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x5200
leaq -0xd8(%rbp), %rdi
callq 0x1ceb0
jmp 0x1d14d
leaq -0x48(%rbp), %rdi
callq 0x1ceb0
movq -0x138(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x1ceb0
movq -0xa0(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sighingnow[P]compile-pascal/./pl0_ast.hpp
// Function: pl0_ast_factor::pl0_ast_factor(std::pair<int, int>, pl0_ast_factor::type_t, void*)
pl0_ast_factor(pair<int, int> loc, type_t t, void *ptr): loc(loc), t(t) {
        switch (this->t) {
            case type_t::ID: this->ptr.id = static_cast<pl0_ast_identify *>(ptr); break;
            case type_t::EXPR: this->ptr.expr = static_cast<pl0_ast_expression *>(ptr); break;
            case type_t::CALL_FUNC: this->ptr.call_func = static_cast<pl0_ast_call_func *>(ptr); break;
            case type_t::UNSIGNED: this->ptr.unsignedn = static_cast<pl0_ast_constv *>(ptr); break;
            default: cout << "unknown factor type: " << t << endl; throw(this->t);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, (%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rdi)
addq $0x18, %rdi
callq 0x3c0a0
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x26e75
movq -0x28(%rbp), %rax
leaq 0xc81d0(%rip), %rcx     # 0xef004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x26ec8
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x26ec8
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x26ec8
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x26ec8
movq 0x13815c(%rip), %rdi    # 0x15efd8
leaq 0xc8787(%rip), %rsi     # 0xef60a
callq 0x5330
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x5590
movq %rax, %rdi
movq 0x138123(%rip), %rsi    # 0x15efc0
callq 0x53a0
movl $0x4, %edi
callq 0x5190
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, (%rdi)
leaq 0x137341(%rip), %rsi    # 0x15e200
xorl %eax, %eax
movl %eax, %edx
callq 0x5570
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sighingnow[P]compile-pascal/./libparsec/combinator.hpp
// Function: optional<parser_t<pl0_ast_const_stmt*>, pl0_ast_const_stmt*>::operator()[abi:cxx11](input_t*) const
tuple<int, parser_type const, string const> operator () (input_t *text) const {
        auto res = pa(text);
        if (std::get<0>(res) == -1) {
            return make_tuple(0, parser_type(), name());
        }
        else {
            return res;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x48ab0
leaq -0x48(%rbp), %rdi
callq 0x486f0
cmpl $-0x1, (%rax)
jne 0x4867b
movq -0xc0(%rbp), %rsi
movl $0x0, -0x7c(%rbp)
movq $0x0, -0x88(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x48bd0
jmp 0x485f9
leaq -0x78(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
leaq -0x88(%rbp), %rdx
leaq -0xa8(%rbp), %rcx
callq 0x48b90
jmp 0x48616
movq -0xd0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x48c40
leaq -0x78(%rbp), %rdi
callq 0x48c70
leaq -0xa8(%rbp), %rdi
callq 0x5200
movl $0x1, -0xb8(%rbp)
jmp 0x48697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x486b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5200
jmp 0x486b0
movq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x48c90
jmp 0x4868d
movl $0x1, -0xb8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x48a90
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x48a90
movq -0xb0(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
nop
// File: sighingnow[P]compile-pascal/./libparsec/combinator.hpp
// Function: except<parser_t<char>, parser_t<char>, char, char>::operator()[abi:cxx11](input_t*) const
tuple<int, parser_type const, string const> operator () (input_t *text) const {
        auto res1 = pa(text);
        auto res2 = pb(text);
        if (std::get<0>(res1) != -1 && std::get<0>(res2) == -1) {
            return res1;
        }
        return make_tuple(-1, parser_type(), "except " + std::get<2>(res1) + " from " + std::get<2>(res2));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x110(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x1b270
movq -0x110(%rbp), %rsi
addq $0x48, %rsi
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x1b270
jmp 0x4f3aa
leaq -0x40(%rbp), %rdi
callq 0x1b380
cmpl $-0x1, (%rax)
je 0x4f406
leaq -0x68(%rbp), %rdi
callq 0x1b380
cmpl $-0x1, (%rax)
jne 0x4f406
movq -0x120(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4f570
jmp 0x4f3d8
movl $0x1, -0x78(%rbp)
jmp 0x4f532
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4f55d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4f554
movl $0xffffffff, -0xa4(%rbp) # imm = 0xFFFFFFFF
movb $0x0, -0xa5(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x45940
movq %rax, %rdx
leaq 0xa02d9(%rip), %rsi     # 0xef703
leaq -0x108(%rbp), %rdi
callq 0x19ef0
jmp 0x4f438
leaq 0xa02cc(%rip), %rdx     # 0xef70b
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x1a380
jmp 0x4f454
leaq -0x68(%rbp), %rdi
callq 0x45940
movq %rax, %rdx
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1a4d0
jmp 0x4f475
leaq -0xa0(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
leaq -0xa5(%rbp), %rdx
leaq -0xc8(%rbp), %rcx
callq 0x4f5a0
jmp 0x4f498
movq -0x120(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x4c4e0
leaq -0xa0(%rbp), %rdi
callq 0x4c510
leaq -0xc8(%rbp), %rdi
callq 0x5200
leaq -0xe8(%rbp), %rdi
callq 0x5200
leaq -0x108(%rbp), %rdi
callq 0x5200
movl $0x1, -0x78(%rbp)
jmp 0x4f532
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4f524
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4f518
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x5200
leaq -0xe8(%rbp), %rdi
callq 0x5200
leaq -0x108(%rbp), %rdi
callq 0x5200
jmp 0x4f554
leaq -0x68(%rbp), %rdi
callq 0x1b3f0
leaq -0x40(%rbp), %rdi
callq 0x1b3f0
movq -0x118(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x1b3f0
leaq -0x40(%rbp), %rdi
callq 0x1b3f0
movq -0x70(%rbp), %rdi
callq 0x55b0
nop
// File: sighingnow[P]compile-pascal/./libparsec/combinator.hpp
// Function: sepby1<parser_t<pl0_ast_identify*>, parser_t<char>, pl0_ast_identify*, char>::operator()[abi:cxx11](input_t*) const
tuple<int, parser_type const, string const> operator () (input_t *text) const {
        auto res = (p + (++(sep >> p)))(text);
        string description = std::get<2>(res);
        parser_type vec = std::get<1>(res).second;
        auto firstp = std::get<1>(res).first;
        vec.insert(vec.begin(), firstp);
        return make_tuple(std::get<0>(res), vec, description);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp            # imm = 0x330
movq %rdi, -0x320(%rbp)
movq %rdi, %rax
movq %rax, -0x318(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x310(%rbp)
movq %rdx, %rsi
addq $0x48, %rsi
leaq -0x258(%rbp), %rdi
movq %rdi, -0x308(%rbp)
callq 0x5a730
movq -0x308(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x5a700
jmp 0x59f92
movq -0x310(%rbp), %rsi
leaq -0x138(%rbp), %rdi
leaq -0x1c8(%rbp), %rdx
callq 0x5a6c0
jmp 0x59fae
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x5a770
jmp 0x59fc4
leaq -0x138(%rbp), %rdi
callq 0x5ac10
leaq -0x1c8(%rbp), %rdi
callq 0x5ac40
leaq -0x258(%rbp), %rdi
callq 0x5ac60
leaq -0x60(%rbp), %rdi
callq 0x5ac90
movq %rax, %rsi
leaq -0x288(%rbp), %rdi
callq 0x5150
jmp 0x5a002
leaq -0x60(%rbp), %rdi
callq 0x5acb0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x2a0(%rbp), %rdi
callq 0x31e50
jmp 0x5a020
leaq -0x60(%rbp), %rdi
callq 0x5acb0
movq (%rax), %rax
movq %rax, -0x2a8(%rbp)
leaq -0x2a0(%rbp), %rdi
movq %rdi, -0x330(%rbp)
callq 0x5aed0
movq %rax, -0x2b8(%rbp)
leaq -0x2b0(%rbp), %rdi
leaq -0x2b8(%rbp), %rsi
callq 0x5af00
movq -0x330(%rbp), %rdi
movq -0x2b0(%rbp), %rsi
leaq -0x2a8(%rbp), %rdx
callq 0x5acd0
movq %rax, -0x328(%rbp)
jmp 0x5a083
movq -0x328(%rbp), %rax
movq %rax, -0x2c0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5af80
movq %rax, %rsi
leaq -0x300(%rbp), %rdi
leaq -0x2a0(%rbp), %rdx
leaq -0x288(%rbp), %rcx
callq 0x5af40
jmp 0x5a0b9
movq -0x320(%rbp), %rdi
leaq -0x300(%rbp), %rsi
callq 0x5afa0
leaq -0x300(%rbp), %rdi
callq 0x5afd0
leaq -0x2a0(%rbp), %rdi
callq 0x32740
leaq -0x288(%rbp), %rdi
callq 0x5200
leaq -0x60(%rbp), %rdi
callq 0x5aff0
movq -0x318(%rbp), %rax
addq $0x330, %rsp            # imm = 0x330
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
jmp 0x5a15b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
jmp 0x5a14f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x5ac10
leaq -0x1c8(%rbp), %rdi
callq 0x5ac40
leaq -0x258(%rbp), %rdi
callq 0x5ac60
jmp 0x5a1c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
jmp 0x5a1bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
jmp 0x5a1af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x32740
leaq -0x288(%rbp), %rdi
callq 0x5200
leaq -0x60(%rbp), %rdi
callq 0x5aff0
movq -0x260(%rbp), %rdi
callq 0x55b0
// File: sighingnow[P]compile-pascal/pl0_ast.cpp
// Function: Value::str[abi:cxx11]() const
std::string const Value::str() const {
    switch (t) {
        case IMM: return to_string(iv);
        case STR: return sv;
        default: return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x9f9e8
jmp 0x9f9de
movl -0x28(%rbp), %eax
subl $0x1, %eax
je 0x9f9fa
jmp 0x9fa0d
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xa3920
jmp 0x9fa52
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x5150
jmp 0x9fa52
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x55d0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x52206(%rip), %rsi     # 0xf1c2f
callq 0x19840
jmp 0x9fa30
leaq -0x11(%rbp), %rdi
callq 0x53c0
jmp 0x9fa52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x53c0
jmp 0x9fa5c
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x55b0
nopw %cs:(%rax,%rax)
// File: sighingnow[P]compile-pascal/pl0_ast.cpp
// Function: operator==(proc const&, proc const&)
bool operator == (proc const & a, proc const & b) {
    bool ans = a.name == b.name && a.param_t.size() == b.param_t.size();
    if (ans && a.param_t.size() > 0) {
        for (size_t i = 0; i < a.param_t.size(); ++i) {
            ans = ans && a.param_t[i] == b.param_t[i];
        }
    }
    return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19db0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xa070b
jmp 0xa0739
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0xa3e70
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0xa3e70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0xa07e3
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0xa3e70
cmpq $0x0, %rax
jbe 0xa07e3
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0xa3e70
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xa07e1
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x39(%rbp)
je 0xa07cb
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0xa3e90
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0xa3e90
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x19db0
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa076a
jmp 0xa07e3
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: sighingnow[P]compile-pascal/pl0_ast.cpp
// Function: operator==(func const&, func const&)
bool operator == (func const & a, func const & b) {
    bool ans = a.name == b.name && a.rettype == b.rettype && a.param_t.size() == b.param_t.size();
    if (ans && a.param_t.size() > 0) {
        for (size_t i = 0; i < a.param_t.size(); ++i) {
            ans = ans && a.param_t[i] == b.param_t[i];
        }
    }
    return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19db0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xa08bb
jmp 0xa090c
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x19db0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xa08de
jmp 0xa090c
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0xa3e70
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0xa3e70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0xa09b6
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0xa3e70
cmpq $0x0, %rax
jbe 0xa09b6
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0xa3e70
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xa09b4
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x39(%rbp)
je 0xa099e
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
callq 0xa3e90
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
callq 0xa3e90
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x19db0
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa093d
jmp 0xa09b6
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)