LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_var_stmt_fn(input_t*)
pair<int, pl0_ast_var_stmt *> pl0_var_stmt_fn(input_t *text) {
    auto parser = pl0_string_literal("var") >> ((pl0_var_define << pl0_character(';'))++);
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Variable Statement" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_var_stmt(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x478, %rsp            # imm = 0x478
movq %rdi, %rbx
leaq 0x4ec0f(%rip), %rsi     # 0x5910b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xfa26
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x840a
leaq 0x6(%rsp), %rsi
movb $0x3b, (%rsi)
leaq 0x70(%rsp), %rdi
callq 0x818c
leaq 0x8170d(%rip), %rsi     # 0x8bc40
leaq 0xb8(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x18b1c
leaq 0x1f8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x18a34
leaq 0x3a0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x1f8(%rsp), %rdx
callq 0x189fe
leaq 0x1f8(%rsp), %rdi
callq 0x119fc
leaq 0xb8(%rsp), %rdi
callq 0x119fc
leaq 0x70(%rsp), %rdi
callq 0xfaa6
leaq 0x28(%rsp), %rdi
callq 0x11074
leaq 0x8(%rsp), %rdi
callq 0x5120
leaq 0x81125(%rip), %rsi     # 0x8b6d8
leaq 0xb8(%rsp), %rdi
leaq 0x3a0(%rsp), %rdx
callq 0x18c00
leaq 0x81109(%rip), %rdx     # 0x8b6d8
leaq 0x1f8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x18b52
leaq 0x28(%rsp), %rdi
leaq 0x1f8(%rsp), %rsi
movq %rbx, %rdx
callq 0x11a12
leaq 0x1f8(%rsp), %rdi
callq 0x11c2a
leaq 0xb8(%rsp), %rdi
callq 0x11c44
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x48(%rsp), %rsi
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
callq 0x18c36
leaq 0x28(%rsp), %rdi
movl 0x38(%rdi), %ebx
callq 0x11c5a
leaq 0x3a0(%rsp), %rdi
callq 0x11c70
movl %ebx, %eax
movq %r14, %rdx
addq $0x478, %rsp            # imm = 0x478
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0xa673
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11c5a
jmp 0xa6a6
movq %rax, %rbx
leaq 0x1f8(%rsp), %rdi
callq 0x11c2a
jmp 0xa694
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x11c44
jmp 0xa6a6
movq %rax, %rbx
leaq 0x3a0(%rsp), %rdi
callq 0x11c70
jmp 0xa704
movq %rax, %rbx
leaq 0x1f8(%rsp), %rdi
callq 0x119fc
jmp 0xa6ca
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x119fc
jmp 0xa6dc
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xfaa6
jmp 0xa6eb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11074
jmp 0xa6fa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
movq %rax, %rbx
jmp 0xa704
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_const_define_fn(input_t*)
pair<int, pl0_ast_const_define *> pl0_const_define_fn(input_t *text) {
    auto parser = pl0_identify + (pl0_character('=') >> pl0_const);
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Constant Define" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_const_define(text->locate(), std::get<1>(res).first, std::get<1>(res).second));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %rbx
movq %rsp, %rsi
movb $0x3d, (%rsi)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x818c
leaq 0x81358(%rip), %rdx     # 0x8ba90
leaq 0x178(%rsp), %rdi
movq %r14, %rsi
callq 0x18380
leaq 0x81461(%rip), %rsi     # 0x8bbb0
leaq 0x320(%rsp), %rdi
leaq 0x178(%rsp), %rdx
callq 0x18d1a
leaq 0x178(%rsp), %rdi
callq 0x1135e
leaq 0x38(%rsp), %rdi
callq 0xfaa6
leaq 0x80f56(%rip), %rsi     # 0x8b6d8
leaq 0x38(%rsp), %rdi
leaq 0x320(%rsp), %rdx
callq 0x18dfe
leaq 0x80f3d(%rip), %rdx     # 0x8b6d8
leaq 0x178(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x18d50
movq %rsp, %rdi
leaq 0x178(%rsp), %rsi
movq %rbx, %rdx
callq 0x11c86
leaq 0x178(%rsp), %rdi
callq 0x11e20
leaq 0x38(%rsp), %rdi
callq 0x11e3a
pushq $0x18
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, (%r14)
movq %rsp, %rdi
movups 0x20(%rdi), %xmm0
movups %xmm0, 0x8(%r14)
movl 0x30(%rdi), %ebx
callq 0x5120
leaq 0x320(%rsp), %rdi
callq 0x11e50
movl %ebx, %eax
movq %r14, %rdx
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
jmp 0xa84b
movq %rax, %rbx
leaq 0x178(%rsp), %rdi
callq 0x11e20
jmp 0xa83c
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x11e3a
jmp 0xa84b
movq %rax, %rbx
leaq 0x320(%rsp), %rdi
callq 0x11e50
jmp 0xa879
movq %rax, %rbx
leaq 0x178(%rsp), %rdi
callq 0x1135e
jmp 0xa86f
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xfaa6
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_const_stmt_fn(input_t*)
pair<int, pl0_ast_const_stmt *> pl0_const_stmt_fn(input_t *text) {
    auto parser = pl0_string_literal("const") >> (pl0_const_define % pl0_character(',')) << pl0_character(';');
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Constant Statement" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_const_stmt(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x598, %rsp            # imm = 0x598
movq %rdi, %rbx
leaq 0x4efc8(%rip), %rsi     # 0x5985d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xfa26
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x840a
leaq 0x6(%rsp), %rsi
movb $0x2c, (%rsi)
leaq 0xb8(%rsp), %rdi
callq 0x818c
leaq 0x81179(%rip), %rsi     # 0x8ba48
leaq 0x100(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
callq 0x18fc6
leaq 0x288(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x100(%rsp), %rdx
callq 0x18f90
leaq 0x5(%rsp), %rsi
movb $0x3b, (%rsi)
leaq 0x70(%rsp), %rdi
callq 0x818c
leaq 0x478(%rsp), %rdi
leaq 0x288(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x18e34
leaq 0x70(%rsp), %rdi
callq 0xfaa6
leaq 0x288(%rsp), %rdi
callq 0x11e66
leaq 0x100(%rsp), %rdi
callq 0x11e7c
leaq 0xb8(%rsp), %rdi
callq 0xfaa6
leaq 0x28(%rsp), %rdi
callq 0x11074
leaq 0x8(%rsp), %rdi
callq 0x5120
leaq 0x80d62(%rip), %rsi     # 0x8b6d8
leaq 0x100(%rsp), %rdi
leaq 0x478(%rsp), %rdx
callq 0x190ae
leaq 0x80d46(%rip), %rdx     # 0x8b6d8
leaq 0x288(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x18ffc
leaq 0x28(%rsp), %rdi
leaq 0x288(%rsp), %rsi
movq %rbx, %rdx
callq 0x11e92
leaq 0x288(%rsp), %rdi
callq 0x120aa
leaq 0x100(%rsp), %rdi
callq 0x120c4
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x48(%rsp), %rsi
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
callq 0x190e4
leaq 0x28(%rsp), %rdi
movl 0x38(%rdi), %ebx
callq 0x120da
leaq 0x478(%rsp), %rdi
callq 0x120f0
movl %ebx, %eax
movq %r14, %rdx
addq $0x598, %rsp            # imm = 0x598
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0xaa36
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x120da
jmp 0xaa69
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
callq 0x120aa
jmp 0xaa57
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x120c4
jmp 0xaa69
movq %rax, %rbx
leaq 0x478(%rsp), %rdi
callq 0x120f0
jmp 0xaad4
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xfaa6
jmp 0xaa8a
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
callq 0x11e66
jmp 0xaa9c
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x11e7c
jmp 0xaaae
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xfaa6
jmp 0xaac0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11074
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
movq %rax, %rbx
jmp 0xaaca
movq %rax, %rbx
jmp 0xaad4
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_param_list_fn(input_t*)
pair<int, pl0_ast_param_list *> pl0_param_list_fn(input_t *text) {
    auto parser = pl0_character('(') >> (pl0_param_group % pl0_character(';')) << pl0_character(')');
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Parameter List" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_param_list(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x578, %rsp            # imm = 0x578
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x28, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x818c
leaq 0x6(%rsp), %rsi
movb $0x3b, (%rsi)
leaq 0x98(%rsp), %rdi
callq 0x818c
leaq 0x81075(%rip), %rsi     # 0x8bec8
leaq 0xe0(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x19596
leaq 0x268(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
callq 0x19560
leaq 0x5(%rsp), %rsi
movb $0x29, (%rsi)
leaq 0x50(%rsp), %rdi
callq 0x818c
leaq 0x458(%rsp), %rdi
leaq 0x268(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x19404
leaq 0x50(%rsp), %rdi
callq 0xfaa6
leaq 0x268(%rsp), %rdi
callq 0x125f6
leaq 0xe0(%rsp), %rdi
callq 0x1260c
leaq 0x98(%rsp), %rdi
callq 0xfaa6
leaq 0x8(%rsp), %rdi
callq 0xfaa6
leaq 0x807e8(%rip), %rsi     # 0x8b6d8
leaq 0xe0(%rsp), %rdi
leaq 0x458(%rsp), %rdx
callq 0x1967e
leaq 0x807cc(%rip), %rdx     # 0x8b6d8
leaq 0x268(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x195cc
leaq 0x8(%rsp), %rdi
leaq 0x268(%rsp), %rsi
movq %rbx, %rdx
callq 0x12622
leaq 0x268(%rsp), %rdi
callq 0x1283a
leaq 0xe0(%rsp), %rdi
callq 0x12854
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
callq 0x196b4
leaq 0x8(%rsp), %rdi
movl 0x38(%rdi), %ebx
callq 0x1286a
leaq 0x458(%rsp), %rdi
callq 0x12880
movl %ebx, %eax
movq %r14, %rdx
addq $0x578, %rsp            # imm = 0x578
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0xafb0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1286a
jmp 0xafe3
movq %rax, %rbx
leaq 0x268(%rsp), %rdi
callq 0x1283a
jmp 0xafd1
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x12854
jmp 0xafe3
movq %rax, %rbx
leaq 0x458(%rsp), %rdi
callq 0x12880
jmp 0xb044
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xfaa6
jmp 0xb004
movq %rax, %rbx
leaq 0x268(%rsp), %rdi
callq 0x125f6
jmp 0xb016
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x1260c
jmp 0xb028
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xfaa6
jmp 0xb03a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfaa6
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x80b53(%rip), %rsi     # 0x8bbb0
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x1289a
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq 0x20(%rdi), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movl 0x28(%rdi), %ebx
callq 0x5120
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_procedure_header_fn(input_t*)
pair<int, pl0_ast_procedure_header *> pl0_procedure_header_fn(input_t *text) {
    auto parser = pl0_string_literal("procedure") >> (pl0_identify + (~pl0_param_list)) << pl0_character(';');
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Procedure Header" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_procedure_header(text->locate(), std::get<1>(res).first, std::get<1>(res).second));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x598, %rsp            # imm = 0x598
movq %rdi, %rbx
leaq 0x4e821(%rip), %rsi     # 0x598e8
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xfa26
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x840a
leaq 0x80d94(%rip), %rsi     # 0x8be80
leaq 0xb8(%rsp), %rdi
callq 0x19846
leaq 0x80ab0(%rip), %rsi     # 0x8bbb0
leaq 0x100(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
callq 0x19910
leaq 0x288(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x100(%rsp), %rdx
callq 0x198da
leaq 0x6(%rsp), %rsi
movb $0x3b, (%rsi)
leaq 0x70(%rsp), %rdi
callq 0x818c
leaq 0x478(%rsp), %rdi
leaq 0x288(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x19798
leaq 0x70(%rsp), %rdi
callq 0xfaa6
leaq 0x288(%rsp), %rdi
callq 0x12932
leaq 0x100(%rsp), %rdi
callq 0x12948
leaq 0xb8(%rsp), %rdi
callq 0x19946
leaq 0x28(%rsp), %rdi
callq 0x11074
leaq 0x8(%rsp), %rdi
callq 0x5120
leaq 0x80531(%rip), %rsi     # 0x8b6d8
leaq 0x100(%rsp), %rdi
leaq 0x478(%rsp), %rdx
callq 0x19a12
leaq 0x80515(%rip), %rdx     # 0x8b6d8
leaq 0x288(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x19960
leaq 0x28(%rsp), %rdi
leaq 0x288(%rsp), %rsi
movq %rbx, %rdx
callq 0x1295e
leaq 0x288(%rsp), %rdi
callq 0x12af8
leaq 0x100(%rsp), %rdi
callq 0x12b12
pushq $0x18
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, (%r14)
leaq 0x28(%rsp), %rdi
movups 0x20(%rdi), %xmm0
movups %xmm0, 0x8(%r14)
movl 0x30(%rdi), %ebx
callq 0x5120
leaq 0x478(%rsp), %rdi
callq 0x12b28
movl %ebx, %eax
movq %r14, %rdx
addq $0x598, %rsp            # imm = 0x598
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5120
jmp 0xb282
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
callq 0x12af8
jmp 0xb270
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x12b12
jmp 0xb282
movq %rax, %rbx
leaq 0x478(%rsp), %rdi
callq 0x12b28
jmp 0xb2ed
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xfaa6
jmp 0xb2a3
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
callq 0x12932
jmp 0xb2b5
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x12948
jmp 0xb2c7
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x19946
jmp 0xb2d9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11074
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
movq %rax, %rbx
jmp 0xb2e3
movq %rax, %rbx
jmp 0xb2ed
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rdi, %rbx
leaq 0x807d2(%rip), %rsi     # 0x8bdf0
leaq 0x80393(%rip), %rdx     # 0x8b9b8
leaq 0x98(%rsp), %rdi
callq 0x19d42
leaq 0xf(%rsp), %rsi
movb $0x3b, (%rsi)
leaq 0x50(%rsp), %rdi
callq 0x818c
leaq 0x128(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x19d08
leaq 0x200(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x19be2
leaq 0x10(%rsp), %rdi
leaq 0x200(%rsp), %rsi
movq %rbx, %rdx
callq 0x12d5e
leaq 0x200(%rsp), %rdi
callq 0x12dc6
leaq 0x128(%rsp), %rdi
callq 0x12dc6
leaq 0x50(%rsp), %rdi
callq 0xfaa6
leaq 0x98(%rsp), %rdi
callq 0x12de0
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
callq 0x19d78
leaq 0x10(%rsp), %rdi
movl 0x38(%rdi), %ebx
callq 0x12df6
movl %ebx, %eax
movq %r14, %rdx
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0xb70c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x12df6
jmp 0xb75b
movq %rax, %rbx
leaq 0x200(%rsp), %rdi
callq 0x12dc6
jmp 0xb72d
movq %rax, %rbx
leaq 0x128(%rsp), %rdi
callq 0x12dc6
jmp 0xb73f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xfaa6
jmp 0xb74e
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x12de0
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rdi, %rbx
leaq 0x806c1(%rip), %rsi     # 0x8be38
leaq 0x8023a(%rip), %rdx     # 0x8b9b8
leaq 0x98(%rsp), %rdi
callq 0x19fc2
leaq 0xf(%rsp), %rsi
movb $0x3b, (%rsi)
leaq 0x50(%rsp), %rdi
callq 0x818c
leaq 0x128(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x19f88
leaq 0x200(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x19e62
leaq 0x10(%rsp), %rdi
leaq 0x200(%rsp), %rsi
movq %rbx, %rdx
callq 0x12e0c
leaq 0x200(%rsp), %rdi
callq 0x12e74
leaq 0x128(%rsp), %rdi
callq 0x12e74
leaq 0x50(%rsp), %rdi
callq 0xfaa6
leaq 0x98(%rsp), %rdi
callq 0x12e8e
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
callq 0x19ff8
leaq 0x10(%rsp), %rdi
movl 0x38(%rdi), %ebx
callq 0x12ea4
movl %ebx, %eax
movq %r14, %rdx
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0xb865
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x12ea4
jmp 0xb8b4
movq %rax, %rbx
leaq 0x200(%rsp), %rdi
callq 0x12e74
jmp 0xb886
movq %rax, %rbx
leaq 0x128(%rsp), %rdi
callq 0x12e74
jmp 0xb898
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xfaa6
jmp 0xb8a7
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x12e8e
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_executable_fn(input_t*)
pair<int, pl0_ast_executable *> pl0_executable_fn(input_t *text) {
    auto res = pl0_function_header(text);
    pair<int, pl0_ast_executable *> ans;
    if (std::get<0>(res) != -1) {
        auto res1 = pl0_function_stmt(text);
        ans = make_pair(std::get<0>(res1), new pl0_ast_executable(text->locate(), std::get<1>(res1)));
    }
    else {
        auto res2 = pl0_procedure_stmt(text);
        ans = make_pair(std::get<0>(res2), new pl0_ast_executable(text->locate(), std::get<1>(res2)));
    }
    if (verbose) {
        cout << "parsing: Executable (Function and Procedure)" << endl;
    }
    return ans;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x8056a(%rip), %rsi     # 0x8be38
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x12eba
cmpl $-0x1, 0x28(%rbx)
je 0xb914
leaq 0x804bd(%rip), %rsi     # 0x8bda8
movq %rsp, %rdi
movq %r14, %rdx
callq 0x12f52
pushq $0x40
popq %rdi
callq 0x5260
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq 0x20(%rsp), %rdx
movq %rax, %rdi
callq 0x12fea
jmp 0xb942
leaq 0x80445(%rip), %rsi     # 0x8bd60
movq %rsp, %rdi
movq %r14, %rdx
callq 0x13026
pushq $0x40
popq %rdi
callq 0x5260
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq 0x20(%rsp), %rdx
movq %rax, %rdi
callq 0x130be
movq %rsp, %rdi
movl 0x28(%rdi), %ebp
callq 0x5120
leaq 0x30(%rsp), %rdi
callq 0x5120
movl %ebp, %eax
movq %rbx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xb96b
jmp 0xb97b
jmp 0xb988
movq %rax, %r14
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x5270
jmp 0xb97e
movq %rax, %r14
movq %rsp, %rdi
callq 0x5120
jmp 0xb98b
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x5120
movq %r14, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x7fd2e(%rip), %rsi     # 0x8c030
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x13b8e
pushq $0x10
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq 0x20(%rdi), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movl 0x28(%rdi), %ebx
callq 0x5120
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_arg_list_fn(input_t*)
pair<int, pl0_ast_arg_list *> pl0_arg_list_fn(input_t *text) {
    auto res = (pl0_character('(') >> (pl0_arg % pl0_character(',')) << pl0_character(')'))(text);
    if (verbose) {
        cout << "parsing: Argument List" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_arg_list(text->locate(), std::get<1>(res)));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x3a8, %rsp            # imm = 0x3A8
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x28, (%rsi)
leaq 0xd8(%rsp), %rdi
callq 0x818c
leaq 0x6(%rsp), %rsi
movb $0x2c, (%rsi)
leaq 0x90(%rsp), %rdi
callq 0x818c
leaq 0x7fe02(%rip), %rsi     # 0x8c198
leaq 0x120(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x1a778
leaq 0x1b0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x120(%rsp), %rdx
callq 0x1a742
leaq 0x5(%rsp), %rsi
movb $0x29, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x818c
leaq 0x288(%rsp), %rdi
leaq 0x1b0(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1a5e6
leaq 0x8(%rsp), %rdi
leaq 0x288(%rsp), %rsi
movq %rbx, %rdx
callq 0x13c26
leaq 0x288(%rsp), %rdi
callq 0x13e2e
leaq 0x48(%rsp), %rdi
callq 0xfaa6
leaq 0x1b0(%rsp), %rdi
callq 0x13e48
leaq 0x120(%rsp), %rdi
callq 0x13e5e
leaq 0x90(%rsp), %rdi
callq 0xfaa6
leaq 0xd8(%rsp), %rdi
callq 0xfaa6
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
callq 0x1a7ae
leaq 0x8(%rsp), %rdi
movl 0x38(%rdi), %ebx
callq 0x13e74
movl %ebx, %eax
movq %r14, %rdx
addq $0x3a8, %rsp            # imm = 0x3A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x5270
jmp 0xc4a7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13e74
jmp 0xc515
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
callq 0x13e2e
jmp 0xc4c8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xfaa6
jmp 0xc4d7
movq %rax, %rbx
leaq 0x1b0(%rsp), %rdi
callq 0x13e48
jmp 0xc4e9
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x13e5e
jmp 0xc4fb
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xfaa6
leaq 0xd8(%rsp), %rdi
callq 0xfaa6
movq %rbx, %rdi
callq 0x53f0
movq %rax, %rbx
jmp 0xc508
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rdi, %rbx
leaq 0x7fc1a(%rip), %rsi     # 0x8c150
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
callq 0x1a8c8
leaq 0x7f663(%rip), %rsi     # 0x8bbb0
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x1a892
leaq 0xd0(%rsp), %rdi
callq 0x1a95c
leaq 0x7f16a(%rip), %rsi     # 0x8b6d8
leaq 0x230(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x1aa24
leaq 0x7f151(%rip), %rdx     # 0x8b6d8
leaq 0xd0(%rsp), %rdi
leaq 0x230(%rsp), %rsi
callq 0x1a976
leaq 0x8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdx
callq 0x13e8a
leaq 0xd0(%rsp), %rdi
callq 0x14024
leaq 0x230(%rsp), %rdi
callq 0x1403e
pushq $0x18
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, (%r14)
leaq 0x8(%rsp), %rdi
movups 0x20(%rdi), %xmm0
movups %xmm0, 0x8(%r14)
movl 0x30(%rdi), %ebx
callq 0x5120
leaq 0x40(%rsp), %rdi
callq 0x14054
movl %ebx, %eax
movq %r14, %rdx
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
jmp 0xc643
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x14024
jmp 0xc631
movq %rax, %rbx
leaq 0x230(%rsp), %rdi
callq 0x1403e
jmp 0xc643
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x14054
jmp 0xc65f
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x1a95c
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
leaq 0x7fa44(%rip), %rsi     # 0x8c0c0
leaq 0x7fba5(%rip), %rdx     # 0x8c228
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x1aa5a
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1406a
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %rbx
movq 0x8(%r14), %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x1abd2
movq %rsp, %rdi
movl 0x38(%rdi), %ebp
callq 0x14268
leaq 0x40(%rsp), %rdi
callq 0x1427e
movl %ebp, %eax
movq %rbx, %rdx
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x5270
jmp 0xc6fa
movq %rax, %r14
movq %rsp, %rdi
callq 0x14268
jmp 0xc707
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x1427e
movq %r14, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_condition_fn(input_t*)
pair<int, pl0_ast_condtion *> pl0_condition_fn(input_t *text) {
    auto res = (spaces >> (pl0_expression + pl0_comp_op + pl0_expression) << spaces)(text);
    if (verbose) {
        cout << "parsing: Condition Expression" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_condtion(
        text->locate(),
        std::get<1>(res).first.first,
        std::get<1>(res).first.second,
        std::get<1>(res).second
    ));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x490, %rsp            # imm = 0x490
movq %rdi, %rbx
leaq 0x7eda2(%rip), %r14     # 0x8c030
leaq 0x7f023(%rip), %rdx     # 0x8c2b8
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b72c
leaq 0xd0(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1b6f2
leaq 0x7e419(%rip), %rsi     # 0x8b6d8
leaq 0x1a8(%rsp), %rdi
leaq 0xd0(%rsp), %rdx
callq 0x1b6bc
leaq 0x7e3fd(%rip), %rdx     # 0x8b6d8
leaq 0x2e8(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x1b53c
movq %rsp, %rdi
leaq 0x2e8(%rsp), %rsi
movq %rbx, %rdx
callq 0x14f36
leaq 0x2e8(%rsp), %rdi
callq 0x150ee
leaq 0x1a8(%rsp), %rdi
callq 0x15108
leaq 0xd0(%rsp), %rdi
callq 0x1511e
leaq 0x40(%rsp), %rdi
callq 0x15138
pushq $0x20
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rsp, %rdi
movq 0x30(%rdi), %rcx
movq %rax, (%r14)
movups 0x20(%rdi), %xmm0
movups %xmm0, 0x8(%r14)
movq %rcx, 0x18(%r14)
movl 0x38(%rdi), %ebx
callq 0x5120
movl %ebx, %eax
movq %r14, %rdx
addq $0x490, %rsp            # imm = 0x490
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
jmp 0xd3c4
movq %rax, %rbx
leaq 0x2e8(%rsp), %rdi
callq 0x150ee
jmp 0xd396
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
callq 0x15108
jmp 0xd3a8
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x1511e
jmp 0xd3ba
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x15138
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_case_term_fn(input_t*)
pair<int, pl0_ast_case_term *> pl0_case_term_fn(input_t *text) {
    auto res = ((pl0_const << (spaces >> pl0_character(':') << spaces)) + pl0_stmt)(text);
    if (std::get<0>(res) == -1) {
        cout << "REPORT" << endl;
    }
    if (verbose) {
        cout << "parsing: Cast Item" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_case_term(text->locate(), std::get<1>(res).first, std::get<1>(res).second));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x558, %rsp            # imm = 0x558
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x3a, (%rsi)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x818c
leaq 0x7d8ed(%rip), %rsi     # 0x8b6d8
leaq 0x88(%rsp), %rdi
movq %r14, %rdx
callq 0x1af60
leaq 0x7d8d6(%rip), %rdx     # 0x8b6d8
leaq 0x138(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1c146
leaq 0x7dc72(%rip), %rsi     # 0x8ba90
leaq 0x250(%rsp), %rdi
leaq 0x138(%rsp), %rdx
callq 0x1c110
leaq 0x7e0d6(%rip), %rdx     # 0x8bf10
leaq 0x3b0(%rsp), %rdi
leaq 0x250(%rsp), %rsi
callq 0x1c05e
leaq 0x8(%rsp), %rdi
leaq 0x3b0(%rsp), %rsi
movq %rbx, %rdx
callq 0x15698
leaq 0x3b0(%rsp), %rdi
callq 0x15912
leaq 0x250(%rsp), %rdi
callq 0x1592c
leaq 0x138(%rsp), %rdi
callq 0x15942
leaq 0x88(%rsp), %rdi
callq 0x14746
leaq 0x40(%rsp), %rdi
callq 0xfaa6
cmpl $-0x1, 0x38(%rsp)
jne 0xdec4
movq 0x7d128(%rip), %rdi     # 0x8afd8
leaq 0x4b26e(%rip), %rsi     # 0x59125
callq 0x5250
movq %rax, %rdi
callq 0x5130
pushq $0x18
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, (%r14)
leaq 0x8(%rsp), %rdi
movups 0x20(%rdi), %xmm0
movups %xmm0, 0x8(%r14)
movl 0x30(%rdi), %ebx
callq 0x5120
movl %ebx, %eax
movq %r14, %rdx
addq $0x558, %rsp            # imm = 0x558
popq %rbx
popq %r14
retq
jmp 0xdefe
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
jmp 0xdf62
movq %rax, %rbx
leaq 0x3b0(%rsp), %rdi
callq 0x15912
jmp 0xdf22
movq %rax, %rbx
leaq 0x250(%rsp), %rdi
callq 0x1592c
jmp 0xdf34
movq %rax, %rbx
leaq 0x138(%rsp), %rdi
callq 0x15942
jmp 0xdf46
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x14746
jmp 0xdf58
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xfaa6
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/pl0_parser.cpp
// Function: pl0_call_proc_fn(input_t*)
pair<int, pl0_ast_call_proc *> pl0_call_proc_fn(input_t *text) {
    auto parser = pl0_identify + (~pl0_arg_list);
    auto res = (spaces >> parser << spaces)(text);
    if (verbose) {
        cout << "parsing: Procedure Call" << endl;
    }
    return make_pair(std::get<0>(res), new pl0_ast_call_proc(text->locate(), std::get<1>(res).first, std::get<1>(res).second));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x328, %rsp            # imm = 0x328
movq %rdi, %rbx
leaq 0x7dae8(%rip), %rsi     # 0x8c150
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
callq 0x1a8c8
leaq 0x7d531(%rip), %rsi     # 0x8bbb0
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x1a892
leaq 0xd0(%rsp), %rdi
callq 0x1a95c
leaq 0x7d038(%rip), %rsi     # 0x8b6d8
leaq 0x230(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x1aa24
leaq 0x7d01f(%rip), %rdx     # 0x8b6d8
leaq 0xd0(%rsp), %rdi
leaq 0x230(%rsp), %rsi
callq 0x1a976
leaq 0x8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdx
callq 0x13e8a
leaq 0xd0(%rsp), %rdi
callq 0x14024
leaq 0x230(%rsp), %rdi
callq 0x1403e
pushq $0x28
popq %rdi
callq 0x5260
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movl $0x4, 0x10(%r14)
leaq 0x7bbb9(%rip), %rax     # 0x8a2d8
movq %rax, (%r14)
leaq 0x8(%rsp), %rdi
movups 0x20(%rdi), %xmm0
movups %xmm0, 0x18(%r14)
movl 0x30(%rdi), %ebx
callq 0x5120
leaq 0x40(%rsp), %rdi
callq 0x14054
movl %ebx, %eax
movq %r14, %rdx
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
jmp 0xe788
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x14024
jmp 0xe776
movq %rax, %rbx
leaq 0x230(%rsp), %rdi
callq 0x1403e
jmp 0xe788
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x14054
jmp 0xe7a4
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x1a95c
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./libparsec/input_t.hpp
// Function: input_t::drop(int const&)
input_t *drop(int const & k) {
        if (k < 0) {
            // cout <<  string("ERROR: try to drop ") << k << " chars from input stream." << endl;
            return this;
        }
        int l = line, c = column;
        size_t len = min((size_t)k, text.length());
        for (size_t i = 0; i < len; ++i) {
            if (text.at(i) == '\n') {
                l = l + 1; c = 1;
            }
            else {
                c = c + 1;
            }
        }
        if ((size_t)k < this->text.length()) {
            return new input_t(this->text.substr(k), l, c, this->desc);
        }
        return new input_t("", l, c, this->desc);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movslq (%rsi), %rbx
testq %rbx, %rbx
js 0x10c25
movq %rsi, 0x10(%rsp)
movl 0x8(%rdi), %r13d
movl 0xc(%rdi), %ebp
leaq 0x10(%rdi), %r15
movq %rdi, 0x8(%rsp)
movq 0x18(%rdi), %rax
cmpq %rbx, %rax
cmovbq %rax, %rbx
xorl %r12d, %r12d
pushq $0x1
popq %r14
cmpq %r12, %rbx
je 0x10bc7
movq %r15, %rdi
movq %r12, %rsi
callq 0x5460
incl %ebp
xorl %ecx, %ecx
cmpb $0xa, (%rax)
sete %cl
cmovel %r14d, %ebp
addl %ecx, %r13d
incq %r12
jmp 0x10ba1
movq 0x10(%rsp), %rax
movslq (%rax), %r12
movq 0x8(%rsp), %rax
movq 0x18(%rax), %r14
pushq $0x30
popq %rdi
callq 0x5260
movq %rax, %rbx
cmpq %r12, %r14
jbe 0x10c2a
leaq 0x38(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x52a0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rbx)
movl %r13d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
leaq 0x38(%rsp), %rsi
callq 0x5340
leaq 0x38(%rsp), %rdi
jmp 0x10c68
movq %rdi, %rbx
jmp 0x10c6d
leaq 0x4a90e(%rip), %rsi     # 0x5b53f
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xfa26
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rbx)
movl %r13d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
leaq 0x18(%rsp), %rsi
callq 0x5340
leaq 0x18(%rsp), %rdi
callq 0x5120
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
jmp 0x10c91
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x5120
jmp 0x10c9d
jmp 0x10c9a
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./libparsec/combinator.hpp
// Function: choice<parser_t<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, parser_t<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator()(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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb0(%rsp), %r12
movq %r12, %rdi
callq 0x22eb2
cmpl $-0x1, 0x40(%r12)
je 0x22df1
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0x22f56
leaq 0xf0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rcx
callq 0x23000
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1dcf4
movq %r14, %rdi
callq 0x1dd04
leaq 0x68(%rsp), %rdi
callq 0x5120
jmp 0x22e4e
leaq 0x48(%r14), %rsi
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x22eb2
movq %rsp, %rdi
movq %r14, %rsi
callq 0x22f56
leaq 0x40(%rsp), %rdx
leaq 0x60(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rsp, %rcx
callq 0x23000
leaq 0x68(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1dcf4
movq %r14, %rdi
callq 0x1dd04
movq %rsp, %rdi
callq 0x5120
leaq 0x20(%rsp), %rdi
callq 0x10768
leaq 0xb0(%rsp), %rdi
callq 0x10768
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
jmp 0x22e7d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x10768
jmp 0x22e9d
jmp 0x22e9a
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5120
jmp 0x22e9d
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x10768
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./libparsec/combinator.hpp
// Function: compose<mapfn<many<parser_t<char>, char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<char, std::allocator<char>>>, many1<parser_t<pl0_ast_alnum*>, pl0_ast_alnum*>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<pl0_ast_alnum*, std::allocator<pl0_ast_alnum*>>>::operator()(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(-1, parser_type(), name());
        }
        auto res2 = pb(text->drop(std::get<0>(res1)));
        if (std::get<0>(res2) == -1) {
            return make_tuple(-1, parser_type(), name());
        }
        else {
            return make_tuple(std::get<0>(res1) + std::get<0>(res2), std::get<1>(res2), name());
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
callq 0x1d792
cmpl $-0x1, 0x40(%r12)
je 0x21508
leaq 0x108(%rsp), %rsi
movq %r15, %rdi
callq 0x10b60
leaq 0x68(%r14), %rsi
leaq 0x48(%rsp), %rdi
movq %rax, %rdx
callq 0x216c6
movl 0x80(%rsp), %ebp
cmpl $-0x1, %ebp
je 0x21575
addl 0x108(%rsp), %ebp
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x216a4
leaq 0x68(%rsp), %rsi
leaq 0x88(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x21b2a
leaq 0x88(%rsp), %r14
movl %ebp, 0x38(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2167e
movq %r14, %rdi
callq 0x2168e
leaq 0x10(%rsp), %rdi
callq 0x5120
jmp 0x215dd
orl $-0x1, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
callq 0x216a4
leaq 0x48(%rsp), %r14
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %r15
leaq 0x88(%rsp), %r12
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x21a6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2167e
movq %r14, %rdi
callq 0x2168e
movq %r12, %rdi
callq 0x5120
movq %r15, %rdi
callq 0x21154
jmp 0x215e7
orl $-0x1, 0xc(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x216a4
leaq 0x88(%rsp), %r14
leaq 0xc(%rsp), %rsi
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x21a6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2167e
movq %r14, %rdi
callq 0x2168e
movq %r12, %rdi
callq 0x5120
movq %r15, %rdi
callq 0x21154
leaq 0x48(%rsp), %rdi
callq 0x21434
leaq 0xc8(%rsp), %rdi
callq 0x10768
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x21154
jmp 0x21637
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x21154
jmp 0x21646
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5120
jmp 0x21637
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x21434
jmp 0x21646
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x10768
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sighingnow[P]compile-pascal/./libparsec/combinator.hpp
// Function: times<parser_t<char>, char>::operator()[abi:cxx11](input_t*) const
tuple<int, parser_type const, string const> operator () (input_t *text) const {
        int cnt = 0, offset = 0;
        parser_type actual;
        string expected;
        while (cnt < maxt) {
            auto res = pa(text);
            if (get<0>(res) == -1) {
                if (cnt < mint) {
                    offset = -1; // failed.
                }
                break;
            }
            cnt = cnt + 1; // update counter.
            offset = offset + std::get<0>(res); // update length.
            actual.push_back(std::get<1>(res));
            expected += std::get<2>(res) + ", ";
            text = text->drop(std::get<0>(res)); // update text stream.
            if (cnt >= maxt) {
                break;
            }
        }
        return make_tuple(offset, actual, expected);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x20(%rsp), %rcx
andq $0x0, 0x10(%rcx)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movb $0x0, (%rax)
movl $0x0, 0xc(%rsp)
leaq 0x58(%rsp), %r14
leaq 0x98(%rsp), %r13
xorl %r12d, %r12d
movq 0x10(%rsp), %rsi
cmpl 0x4c(%rsi), %r12d
jge 0x1de33
movq %r14, %rdi
movq %r15, %rdx
callq 0x1024a
movl 0x7c(%rsp), %ebp
cmpl $-0x1, %ebp
je 0x1de09
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1ded8
movq %r13, %rbx
movq %r13, %rdi
movq %r14, %rsi
leaq 0x3d004(%rip), %rdx     # 0x5adcd
callq 0x1def2
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x5470
movq %rbx, %rdi
callq 0x5120
movq %r15, %rdi
leaq 0x7c(%rsp), %rsi
callq 0x10b60
movq %rax, %r15
incl %r12d
addl %ebp, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl 0x4c(%rax), %r12d
setl %bpl
jmp 0x1de22
movq 0x10(%rsp), %rax
cmpl 0x48(%rax), %r12d
pushq $-0x1
popq %rax
movl 0xc(%rsp), %ecx
cmovll %eax, %ecx
movl %ecx, 0xc(%rsp)
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x5120
testb %bpl, %bpl
jne 0x1dd87
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x1e084
leaq 0x58(%rsp), %rbx
movl 0xc(%rsp), %eax
movl %eax, 0x38(%rbx)
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1df2a
movq %rbx, %rdi
callq 0x1df3a
leaq 0x38(%rsp), %rdi
callq 0x5120
leaq 0x20(%rsp), %rdi
callq 0x1e16c
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1deaa
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x5120
jmp 0x1deb2
jmp 0x1deaf
movq %rax, %rbx
jmp 0x1debc
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5120
leaq 0x38(%rsp), %rdi
callq 0x5120
leaq 0x20(%rsp), %rdi
callq 0x1e16c
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1eed8
cmpl $-0x1, 0x28(%r15)
je 0x1ed6b
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f096
jmp 0x1edbd
andl $0x0, 0x4(%rsp)
andq $0x0, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x1ef70
leaq 0x60(%rsp), %r14
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x1f002
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ef92
movq %r14, %rdi
callq 0x5120
movq %r15, %rdi
callq 0x5120
leaq 0x10(%rsp), %rdi
callq 0x5120
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1edd9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1024a
addq $0x48, %r15
leaq 0x70(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1024a
cmpl $-0x1, 0x2c(%rsp)
je 0x20ea8
cmpl $-0x1, 0x94(%rsp)
jne 0x20ea8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20fb2
jmp 0x20f49
orl $-0x1, 0x4(%rsp)
movb $0x0, 0x3(%rsp)
leaq 0x38378(%rip), %rsi     # 0x59231
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xfbb3
leaq 0x3836a(%rip), %rdx     # 0x59239
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfd14
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0xfda4
leaq 0xb8(%rsp), %r14
leaq 0x4(%rsp), %rsi
leaq 0x3(%rsp), %rdx
leaq 0x98(%rsp), %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x20fee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fb34
movq %r14, %rdi
callq 0x5120
movq %r15, %rdi
callq 0x5120
leaq 0x50(%rsp), %rdi
callq 0x5120
leaq 0x30(%rsp), %rdi
callq 0x5120
leaq 0x70(%rsp), %rdi
callq 0x5120
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5120
jmp 0x20f7f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5120
jmp 0x20f90
jmp 0x20f8d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x5120
jmp 0x20f9f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x48, %rsi
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x25434
leaq 0xe0(%rsp), %rdi
movq %r12, %rsi
callq 0x253fa
leaq 0x170(%rsp), %rdi
leaq 0xe0(%rsp), %rdx
movq %r15, %rsi
callq 0x253c4
leaq 0x8(%rsp), %rdi
leaq 0x170(%rsp), %rsi
movq %r14, %rdx
callq 0x25018
leaq 0x170(%rsp), %rdi
callq 0x252f2
leaq 0xe0(%rsp), %rdi
callq 0x25308
leaq 0x50(%rsp), %rdi
callq 0x25308
leaq 0xe0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5340
leaq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x1891a
movq 0x28(%rsp), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x50(%rsp), %rdi
movq (%rdi), %rsi
callq 0x2531e
leaq 0x170(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
callq 0x25bd0
leaq 0x8(%rsp), %r14
movl 0x40(%r14), %eax
leaq 0x170(%rsp), %r15
movl %eax, 0x38(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x25388
movq %r15, %rdi
callq 0x25398
leaq 0x50(%rsp), %rdi
callq 0x18968
leaq 0xe0(%rsp), %rdi
callq 0x5120
movq %r14, %rdi
callq 0x253ae
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x24e04
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x18968
jmp 0x24e16
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x5120
jmp 0x24e28
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x253ae
jmp 0x24e65
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x252f2
jmp 0x24e49
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x25308
jmp 0x24e5b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x25308
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x1, %eax
je 0x3b740
testl %eax, %eax
jne 0x3b74e
movl 0x4(%rsi), %esi
movq %rbx, %rdi
callq 0x3cc01
jmp 0x3b762
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x5340
jmp 0x3b762
leaq 0x1fdea(%rip), %rsi     # 0x5b53f
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xfa26
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop