LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/while.cc
// Function: main
int main(int argc, char *argv[]) {
    if(argc != 3) {
        std::cerr << "Usage: " << argv[0] << " (-c|-i) inputfile" << std::endl;
        exit(1);
    }
    
    if(std::string(argv[1]) == "-c") {
        current_mode = compiler;
    } else if(std::string(argv[1]) == "-i") {
        current_mode = interpreter;
    } else {
        std::cerr << "Usage: " << argv[0] << "(-c|-i) inputfile" << std::endl;
        exit(1);
    }
    
    std::ifstream input(argv[2]);
    if(!input) {
        std::cerr << "Cannot open input file: " << argv[2] << std::endl;
        exit(1);
    }
    
    lexer = new yyFlexLexer(&input);
    yy::parser parser;
    parser.parse();
    delete lexer;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x4ecb
movq 0x8(%rbx), %rsi
leaq -0x240(%rbp), %r14
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0x4f92
leaq 0x5ad8(%rip), %rsi      # 0xa8b8
movq %r14, %rdi
callq 0x4fcd
movl %eax, %r15d
movq %r14, %rdi
callq 0x3110
xorl %eax, %eax
testb %r15b, %r15b
jne 0x4e30
movq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0x4f92
leaq 0x5aaa(%rip), %rsi      # 0xa8bb
movq %r14, %rdi
callq 0x4fcd
movl %eax, %r15d
movq %r14, %rdi
callq 0x3110
testb %r15b, %r15b
je 0x4f1b
pushq $0x1
popq %rax
leaq 0xb3fd(%rip), %rcx      # 0x10234
movl %eax, (%rcx)
movq 0x10(%rbx), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x3390
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x220(%rbp,%rax)
jne 0x4ef2
movl $0x2e0, %edi            # imm = 0x2E0
callq 0x3200
movq %rax, %r14
leaq -0x240(%rbp), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x42aa
movq %r14, 0xb39e(%rip)      # 0x10220
leaq -0x38(%rbp), %rdi
callq 0x507c
leaq -0x38(%rbp), %rdi
callq 0x540a
movq 0xb385(%rip), %rdi      # 0x10220
testq %rdi, %rdi
je 0x4ea6
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x38(%rbp), %rdi
callq 0x509a
leaq -0x240(%rbp), %rdi
callq 0x3090
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xb11e(%rip), %rdi      # 0xfff0
leaq 0x59c4(%rip), %rsi      # 0xa89d
callq 0x31f0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x31f0
leaq 0x59b5(%rip), %rsi      # 0xa8a5
jmp 0x4f40
movq 0xb0f7(%rip), %rdi      # 0xfff0
leaq 0x59be(%rip), %rsi      # 0xa8be
callq 0x31f0
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
jmp 0x4f50
movq 0xb0ce(%rip), %rdi      # 0xfff0
leaq 0x5974(%rip), %rsi      # 0xa89d
callq 0x31f0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x31f0
leaq 0x5966(%rip), %rsi      # 0xa8a6
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
pushq $0x1
popq %rdi
callq 0x3250
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x509a
jmp 0x4f7d
jmp 0x4f7a
movq %rax, %rbx
movl $0x2e0, %esi            # imm = 0x2E0
movq %r14, %rdi
callq 0x3210
jmp 0x4f7d
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::stack_symbol_type::stack_symbol_type(yy::parser::stack_symbol_type&&)
parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
    : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
  {
    switch (that.kind ())
    {
      case symbol_kind::S_expression: // expression
        value.YY_MOVE_OR_COPY< expression* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_command: // command
        value.YY_MOVE_OR_COPY< instruction* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_commands: // commands
        value.YY_MOVE_OR_COPY< std::list<instruction*>*  > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_ID: // ID
      case symbol_kind::S_NUM: // NUM
        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
        break;

      default:
        break;
    }

#if 201103L <= YY_CPLUSPLUS
    // that is emptied.
    that.state = empty_state;
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps 0x30(%rsi), %xmm0
movaps 0x40(%rsi), %xmm1
movaps %xmm1, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movsbq (%rsi), %rax
testq %rax, %rax
je 0x5292
movq %rdi, %r14
addq $0x10, %rdi
leaq 0x59b4(%rip), %rcx      # 0xac20
movzbl (%rax,%rcx), %eax
leal -0x29(%rax), %ecx
cmpl $0x3, %ecx
jae 0x5281
movq 0x10(%rbx), %rax
movq %rax, (%rdi)
jmp 0x5292
addl $-0x16, %eax
cmpl $0x2, %eax
jae 0x5292
leaq 0x10(%rbx), %rsi
callq 0x6466
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x6766
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::stack_symbol_type::stack_symbol_type(signed char, yy::parser::symbol_type&&)
parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
    : super_type (s, YY_MOVE (that.location))
  {
    switch (that.kind ())
    {
      case symbol_kind::S_expression: // expression
        value.move< expression* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_command: // command
        value.move< instruction* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_commands: // commands
        value.move< std::list<instruction*>*  > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_ID: // ID
      case symbol_kind::S_NUM: // NUM
        value.move< std::string > (YY_MOVE (that.value));
        break;

      default:
        break;
    }

    // that is emptied.
    that.kind_ = symbol_kind::S_YYEMPTY;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movb %sil, (%rdi)
leaq 0x10(%rdi), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r14)
movaps %xmm0, 0x20(%r14)
movaps 0x30(%rdx), %xmm0
movaps 0x40(%rdx), %xmm1
movaps %xmm1, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movl (%rdx), %eax
leal -0x29(%rax), %ecx
cmpl $0x3, %ecx
jae 0x52f4
movq 0x10(%rbx), %rax
movq %rax, (%rdi)
jmp 0x5305
addl $-0x16, %eax
cmpl $0x2, %eax
jae 0x5305
leaq 0x10(%rbx), %rsi
callq 0x6466
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x6766
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::yypush_(char const*, signed char, yy::parser::symbol_type&&)
void
  parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
  {
#if 201103L <= YY_CPLUSPLUS
    yypush_ (m, stack_symbol_type (s, std::move (sym)));
#else
    stack_symbol_type ss (s, sym);
    yypush_ (m, ss);
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x52ae
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6482
leaq -0x60(%rbp), %rdi
callq 0x6766
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x6766
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::yy_lr_goto_state_(signed char, int)
parser::state_type
  parser::yy_lr_goto_state_ (state_type yystate, int yysym)
  {
    int yyr = yypgoto_[yysym - YYNTOKENS] + yystate;
    if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
      return yytable_[yyr];
    else
      return yydefgoto_[yysym - YYNTOKENS];
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
leaq 0x56de(%rip), %rcx      # 0xaa88
movsbl -0x25(%rax,%rcx), %ecx
addl %edi, %ecx
cmpl $0xb9, %ecx
ja 0x53d4
movl %ecx, %edx
leaq 0x579e(%rip), %rcx      # 0xab60
cmpb %dil, (%rdx,%rcx)
jne 0x53d4
leaq 0x56d1(%rip), %rcx      # 0xaaa0
addq %rdx, %rcx
jmp 0x53e2
addq $-0x25, %rax
leaq 0x56b0(%rip), %rcx      # 0xaa8f
addq %rax, %rcx
movb (%rcx), %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::basic_symbol<yy::parser::by_state>::move(yy::parser::basic_symbol<yy::parser::by_state>&)
void
  parser::basic_symbol<Base>::move (basic_symbol& s)
  {
    super_type::move (s);
    switch (this->kind ())
    {
      case symbol_kind::S_expression: // expression
        value.move< expression* > (YY_MOVE (s.value));
        break;

      case symbol_kind::S_command: // command
        value.move< instruction* > (YY_MOVE (s.value));
        break;

      case symbol_kind::S_commands: // commands
        value.move< std::list<instruction*>*  > (YY_MOVE (s.value));
        break;

      case symbol_kind::S_ID: // ID
      case symbol_kind::S_NUM: // NUM
        value.move< std::string > (YY_MOVE (s.value));
        break;

      default:
        break;
    }

    location = YY_MOVE (s.location);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movb $0x0, (%rsi)
movsbq (%rdi), %rax
testq %rax, %rax
je 0x67f2
leaq 0x4460(%rip), %rcx      # 0xac20
movzbl (%rax,%rcx), %eax
leal -0x16(%rax), %ecx
cmpl $0x2, %ecx
jb 0x67e5
cmpl $0x29, %eax
je 0x67db
cmpl $0x2a, %eax
je 0x67db
cmpl $0x2b, %eax
jne 0x67f2
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
jmp 0x67f2
leaq 0x10(%rbx), %rdi
leaq 0x10(%r14), %rsi
callq 0x6466
movaps 0x30(%r14), %xmm0
movaps 0x40(%r14), %xmm1
movaps %xmm1, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/implementation.cc
// Function: delete_commands(std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void delete_commands(std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }
    
    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        delete (*it);
    }
    delete commands;
}

// Assembly:
testq %rdi, %rdi
je 0x6ff0
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x6fd9
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x6fc0
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6fc0
movq %rbx, %rdi
callq 0x7080
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3210
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: operand_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
type operand_type(std::string op) {
    if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%" ||
       op == "<" || op == ">" || op == "<=" || op == ">=") {
           return natural;
    } else {
        return boolean;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x3bbf(%rip), %rsi      # 0xae01
callq 0x4fcd
pushq $0x1
popq %rbx
testb %al, %al
jne 0x72ed
leaq 0x3baa(%rip), %rsi      # 0xae03
movq %r14, %rdi
callq 0x4fcd
testb %al, %al
jne 0x72ed
leaq 0x3b95(%rip), %rsi      # 0xae05
movq %r14, %rdi
callq 0x4fcd
testb %al, %al
jne 0x72ed
leaq 0x3b84(%rip), %rsi      # 0xae07
movq %r14, %rdi
callq 0x4fcd
testb %al, %al
jne 0x72ed
leaq 0x3b73(%rip), %rsi      # 0xae09
movq %r14, %rdi
callq 0x4fcd
testb %al, %al
jne 0x72ed
leaq 0x3b62(%rip), %rsi      # 0xae0b
movq %r14, %rdi
callq 0x4fcd
testb %al, %al
jne 0x72ed
leaq 0x3b51(%rip), %rsi      # 0xae0d
movq %r14, %rdi
callq 0x4fcd
testb %al, %al
jne 0x72ed
leaq 0x3b40(%rip), %rsi      # 0xae0f
movq %r14, %rdi
callq 0x4fcd
testb %al, %al
jne 0x72ed
leaq 0x3b30(%rip), %rsi      # 0xae12
movq %r14, %rdi
callq 0x4fcd
movzbl %al, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: assign_instruction::type_check()
void assign_instruction::type_check() {
    if(symbol_table.count(left) == 0) {
        error(line, std::string("Undefined variable: ") + left);
    }
    if(symbol_table[left].symbol_type != right->get_type()) {
        error(line, "Left and right hand sides of assignment are of different types.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x8c13(%rip), %rdi      # 0x10248
movq %r14, %rsi
callq 0x78f2
testq %rax, %rax
jne 0x7688
movl 0x8(%rbx), %r15d
leaq 0x38d6(%rip), %rsi      # 0xaf23
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4f92
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %r14, %rdx
callq 0x7916
leaq -0x80(%rbp), %rsi
movl %r15d, %edi
callq 0x6b74
leaq -0x80(%rbp), %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3110
leaq 0x8bb9(%rip), %rdi      # 0x10248
movq %r14, %rsi
callq 0x7940
movl 0x28(%rax), %r14d
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl %eax, %r14d
je 0x76d4
movl 0x8(%rbx), %ebx
leaq 0x3917(%rip), %rsi      # 0xafca
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x4f92
leaq -0x60(%rbp), %rsi
movl %ebx, %edi
callq 0x6b74
leaq -0x60(%rbp), %rdi
callq 0x3110
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3110
jmp 0x76f0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x76ff
jmp 0x7706
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3110
jmp 0x7709
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: if_instruction::type_check()
void if_instruction::type_check() {
    if(condition->get_type() != boolean) {
        error(line, "Condition of 'if' instruction is not boolean.");
    }
    type_check_commands(true_branch);
    type_check_commands(false_branch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
testl %eax, %eax
je 0x7818
movl 0x8(%rbx), %r14d
leaq 0x3816(%rip), %rsi      # 0xb00a
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x4f92
movl %r14d, %edi
movq %r15, %rsi
callq 0x6b74
leaq -0x40(%rbp), %rdi
callq 0x3110
movq 0x18(%rbx), %rdi
callq 0x7849
movq 0x20(%rbx), %rdi
callq 0x7849
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: type_check_commands(std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void type_check_commands(std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }

    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        (*it)->type_check();
    }
}

// Assembly:
testq %rdi, %rdi
je 0x7873
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x786f
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x785b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: get_register[abi:cxx11](type)
std::string get_register(type t) {
    if(t == boolean) {
        return "al";
    } else {
    return "eax";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x82bc
leaq 0x2f1a(%rip), %rsi      # 0xb1d0
leaq -0x9(%rbp), %rdx
jmp 0x82c7
leaq 0x2fa3(%rip), %rsi      # 0xb266
leaq -0xa(%rbp), %rdx
movq %rbx, %rdi
callq 0x4f92
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: eq_code[abi:cxx11](type)
std::string eq_code(type t) {
    std::stringstream ss;
    if(t == natural) {
        ss << "cmp eax,ecx" << std::endl;
    } else {
        ss << "cmp al,cl" << std::endl;
    }
    ss << "mov al,0" << std::endl;
    ss << "mov cx,1" << std::endl;
    ss << "cmove ax,cx" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x3170
cmpl $0x1, %r14d
leaq -0x188(%rbp), %rdi
leaq 0x290f(%rip), %rax      # 0xb130
leaq 0x2999(%rip), %rsi      # 0xb1c1
cmoveq %rax, %rsi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq -0x188(%rbp), %r14
leaq 0x28f5(%rip), %rsi      # 0xb13c
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x28e7(%rip), %rsi      # 0xb145
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x2914(%rip), %rsi      # 0xb189
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x198(%rbp), %rdi
callq 0x3190
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: binop_expression::get_code[abi:cxx11]() const
std::string binop_expression::get_code() const {
    std::stringstream ss;
    ss << left->get_code();
    ss << "push eax" << std::endl;
    ss << right->get_code();
    ss << "mov ecx,eax" << std::endl;
    ss << "pop eax" << std::endl;
    ss << (op == "=" ? eq_code(left->get_type()) : operator_code(op));
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x3170
movq 0x30(%r15), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1e0(%rbp), %r14
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq 0x28ae(%rip), %rsi      # 0xb1cb
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
movq 0x38(%r15), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *0x18(%rax)
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq 0x287d(%rip), %rsi      # 0xb1d4
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x2872(%rip), %rsi      # 0xb1e0
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x10(%r15), %r13
leaq 0x2487(%rip), %rsi      # 0xae10
movq %r13, %rdi
callq 0x4fcd
movl %eax, %r12d
testb %al, %al
je 0x89ae
movq 0x30(%r15), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x87ef
jmp 0x89c7
leaq -0x68(%rbp), %rdi
movq %r13, %rsi
callq 0x32b0
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x83f5
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x48(%rbp), %rdi
callq 0x3110
testb %r12b, %r12b
jne 0x89ea
leaq -0x68(%rbp), %rdi
callq 0x3110
leaq -0x1d8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x1f0(%rbp), %rdi
callq 0x3190
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x8a30
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
testb %r12b, %r12b
jne 0x8a4f
leaq -0x68(%rbp), %rdi
jmp 0x8a41
jmp 0x8a3a
jmp 0x8a4c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
jmp 0x8a4f
jmp 0x8a4c
jmp 0x8a4c
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: not_expression::get_code[abi:cxx11]() const
std::string not_expression::get_code() const {
    std::stringstream ss;
    ss << operand->get_code();
    ss << "xor al,1" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x3170
movq 0x30(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1a8(%rbp), %r14
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x3110
leaq 0x2733(%rip), %rsi      # 0xb1e8
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x1b8(%rbp), %rdi
callq 0x3190
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3110
jmp 0x8b02
jmp 0x8aff
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: assign_instruction::get_code[abi:cxx11]()
std::string assign_instruction::get_code() {
    std::stringstream ss;
    ss << right->get_code();
    ss << "mov [" + symbol_table[left].label + "]," << get_register(symbol_table[left].symbol_type) << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x200(%rbp), %rdi
callq 0x3170
movq 0x30(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1f0(%rbp), %r15
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x31d0
leaq -0x38(%rbp), %rdi
callq 0x3110
addq $0x10, %r14
leaq 0x76db(%rip), %rdi      # 0x10248
movq %r14, %rsi
callq 0x7940
addq $0x30, %rax
leaq 0x2671(%rip), %rsi      # 0xb1f1
leaq -0x78(%rbp), %rdi
movq %rax, %rdx
callq 0x9443
leaq 0x2664(%rip), %rdx      # 0xb1f7
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x79e7
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
leaq 0x7692(%rip), %rdi      # 0x10248
movq %r14, %rsi
callq 0x7940
movl 0x28(%rax), %esi
leaq -0x58(%rbp), %rdi
callq 0x82a2
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
leaq -0x58(%rbp), %rdi
callq 0x3110
leaq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x78(%rbp), %rdi
callq 0x3110
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x200(%rbp), %rdi
callq 0x3190
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8c5e
jmp 0x8c47
movq %rax, %rbx
jmp 0x8c53
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x8c57
jmp 0x8c5e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3110
jmp 0x8c4a
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x78(%rbp), %rdi
callq 0x3110
jmp 0x8c61
movq %rax, %rbx
leaq -0x200(%rbp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: get_type_name[abi:cxx11](type)
std::string get_type_name(type t) {
    if(t == boolean) {
        return "boolean";
    } else {
        return "natural";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x8c8f
leaq 0x25d8(%rip), %rsi      # 0xb261
leaq -0x9(%rbp), %rdx
jmp 0x8c9a
leaq 0x25f4(%rip), %rsi      # 0xb28a
leaq -0xa(%rbp), %rdx
movq %rbx, %rdi
callq 0x4f92
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: read_instruction::get_code[abi:cxx11]()
std::string read_instruction::get_code() {
    type t = symbol_table[id].symbol_type;
    std::stringstream ss;
    ss << "call read_" << get_type_name(t) << std::endl;
    ss << "mov [" << symbol_table[id].label << "]," << get_register(t) << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x7577(%rip), %rdi      # 0x10248
movq %r15, %rsi
callq 0x7940
movl 0x28(%rax), %r14d
leaq -0x1d0(%rbp), %rdi
callq 0x3170
leaq -0x1c0(%rbp), %r12
leaq 0x2503(%rip), %rsi      # 0xb1fa
movq %r12, %rdi
callq 0x31f0
movq %rax, %r13
leaq -0x48(%rbp), %rdi
movl %r14d, %esi
callq 0x8c75
leaq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq 0x24bf(%rip), %rsi      # 0xb1f1
movq %r12, %rdi
callq 0x31f0
movq %rax, %r12
leaq 0x7504(%rip), %rdi      # 0x10248
movq %r15, %rsi
callq 0x7940
addq $0x30, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x31d0
leaq 0x2495(%rip), %rsi      # 0xb1f7
movq %rax, %rdi
callq 0x31f0
movq %rax, %r15
leaq -0x48(%rbp), %rdi
movl %r14d, %esi
callq 0x82a2
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x1d0(%rbp), %rdi
callq 0x3190
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8dda
jmp 0x8dda
jmp 0x8dcc
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
jmp 0x8ddd
movq %rax, %rbx
leaq -0x1d0(%rbp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: write_instruction::get_code[abi:cxx11]()
std::string write_instruction::get_code() {
    std::stringstream ss;
    ss << exp->get_code();
    if(exp_type == boolean) {
        ss << "and eax,1" << std::endl;
    }
    ss << "push eax" << std::endl;
    ss << "call write_" << get_type_name(exp_type) << std::endl;
    ss << "add esp,4" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x3170
movq 0x10(%r15), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1b8(%rbp), %r14
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x40(%rbp), %rdi
callq 0x3110
cmpl $0x0, 0x18(%r15)
jne 0x8e5e
leaq 0x23b7(%rip), %rsi      # 0xb205
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x2366(%rip), %rsi      # 0xb1cb
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x2393(%rip), %rsi      # 0xb20f
movq %r14, %rdi
callq 0x31f0
movq %rax, %r12
movl 0x18(%r15), %esi
leaq -0x40(%rbp), %rdi
callq 0x8c75
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
leaq -0x40(%rbp), %rdi
callq 0x3110
leaq 0x2363(%rip), %rsi      # 0xb21b
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq -0x1b0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x1c8(%rbp), %rdi
callq 0x3190
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8f0a
jmp 0x8efc
jmp 0x8f0a
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x8f0d
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: if_instruction::get_code[abi:cxx11]()
std::string if_instruction::get_code() {
    std::string else_label = next_label();
    std::string end_label = next_label();
    std::stringstream ss;
    ss << condition->get_code();
    ss << "cmp al,1" << std::endl;
    ss << "jne near " << else_label << std::endl;
    generate_code_of_commands(ss, true_branch);
    ss << "jmp " << end_label << std::endl;
    ss << else_label << ":" << std::endl;
    generate_code_of_commands(ss, false_branch);
    ss << end_label << ":" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x8149
leaq -0x38(%rbp), %rdi
callq 0x8149
leaq -0x200(%rbp), %rdi
callq 0x3170
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1f0(%rbp), %r15
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x31d0
leaq -0x78(%rbp), %rdi
callq 0x3110
leaq 0x21f9(%rip), %rsi      # 0xb180
movq %r15, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x2287(%rip), %rsi      # 0xb225
movq %r15, %rdi
callq 0x31f0
leaq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
movq 0x18(%r14), %rsi
movq %r15, %rdi
callq 0x90bc
leaq 0x2262(%rip), %rsi      # 0xb22f
movq %r15, %rdi
callq 0x31f0
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x31d0
leaq 0x22b5(%rip), %rsi      # 0xb2b1
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x90bc
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x31d0
leaq 0x2286(%rip), %rsi      # 0xb2b1
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x200(%rbp), %rdi
callq 0x3190
leaq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x58(%rbp), %rdi
callq 0x3110
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3110
jmp 0x9096
jmp 0x9093
movq %rax, %rbx
jmp 0x90a2
movq %rax, %rbx
jmp 0x90ab
movq %rax, %rbx
leaq -0x200(%rbp), %rdi
callq 0x3190
leaq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x58(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: generate_code_of_commands(std::ostream&, std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void generate_code_of_commands(std::ostream& out, std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }

    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        out << (*it)->get_code();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x9109
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r15
movq %rsi, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x9109
movq 0x10(%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movq %r15, %rdi
callq 0x3110
jmp 0x90dd
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: while_instruction::get_code[abi:cxx11]()
std::string while_instruction::get_code() {
    std::string begin_label = next_label();
    std::string end_label = next_label();
    std::stringstream ss;
    ss << begin_label << ":" << std::endl;
    ss << condition->get_code();
    ss << "cmp al,1" << std::endl;
    ss << "jne near " << end_label << std::endl;
    generate_code_of_commands(ss, body);
    ss << "jmp " << begin_label << std::endl;
    ss << end_label << ":" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x8149
leaq -0x38(%rbp), %rdi
callq 0x8149
leaq -0x200(%rbp), %rdi
callq 0x3170
leaq -0x1f0(%rbp), %r14
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq 0x2139(%rip), %rsi      # 0xb2b1
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
movq 0x10(%r15), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *0x18(%rax)
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x78(%rbp), %rdi
callq 0x3110
leaq 0x1fce(%rip), %rsi      # 0xb180
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x205c(%rip), %rsi      # 0xb225
movq %r14, %rdi
callq 0x31f0
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x90bc
leaq 0x2037(%rip), %rsi      # 0xb22f
movq %r14, %rdi
callq 0x31f0
leaq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3120
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq 0x208a(%rip), %rsi      # 0xb2b1
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3300
leaq -0x200(%rbp), %rdi
callq 0x3190
leaq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x58(%rbp), %rdi
callq 0x3110
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3110
jmp 0x9292
jmp 0x928f
movq %rax, %rbx
jmp 0x929e
movq %rax, %rbx
jmp 0x92a7
movq %rax, %rbx
leaq -0x200(%rbp), %rdi
callq 0x3190
leaq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x58(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: generate_code(std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void generate_code(std::list<instruction*>* commands) {
    std::cout << "global main" << std::endl;
    std::cout << "extern write_natural" << std::endl;
    std::cout << "extern read_natural" << std::endl;
    std::cout << "extern write_boolean" << std::endl;
    std::cout << "extern read_boolean" << std::endl;
    std::cout << std::endl;
    std::cout << "section .bss" << std::endl;
    std::map<std::string,symbol>::iterator it;
    for(it = symbol_table.begin(); it != symbol_table.end(); ++it) {
        std::cout << it->second.get_code();
    }
    std::cout << std::endl;
    std::cout << "section .text" << std::endl;
    std::cout << "main:" << std::endl;
    generate_code_of_commands(std::cout, commands);
    std::cout << "xor eax,eax" << std::endl;
    std::cout << "ret" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x6cf5(%rip), %r14      # 0xffc8
leaq 0x1f5a(%rip), %rsi      # 0xb234
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x1f4f(%rip), %rsi      # 0xb240
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x1f4d(%rip), %rsi      # 0xb255
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x1f4a(%rip), %rsi      # 0xb269
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x1f48(%rip), %rsi      # 0xb27e
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3120
leaq 0x1f3d(%rip), %rsi      # 0xb292
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x6edc(%rip), %r13      # 0x10248
movq 0x18(%r13), %r12
addq $0x8, %r13
leaq -0x48(%rbp), %r15
cmpq %r13, %r12
je 0x93aa
leaq 0x40(%r12), %rsi
movq %r15, %rdi
callq 0x81d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x31d0
movq %r15, %rdi
callq 0x3110
movq %r12, %rdi
callq 0x3160
movq %rax, %r12
jmp 0x9378
movq 0x6c17(%rip), %r14      # 0xffc8
movq %r14, %rdi
callq 0x3120
leaq 0x1edf(%rip), %rsi      # 0xb29f
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x1ed6(%rip), %rsi      # 0xb2ad
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
movq %r14, %rdi
movq %rbx, %rsi
callq 0x90bc
leaq 0x1eba(%rip), %rsi      # 0xb2b3
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
leaq 0x1eaf(%rip), %rsi      # 0xb2bf
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3120
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: read_instruction::execute()
void read_instruction::execute() {
    std::string input_line;
    getline(std::cin, input_line);
    if(symbol_table[id].symbol_type == natural) {
        std::stringstream ss(input_line);
        unsigned input;
        ss >> input;
        value_table[id] = input;
    } else if(symbol_table[id].symbol_type == boolean) {
        if(input_line == "true") {
            value_table[id] = 1;
        } else {
            value_table[id] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x67d6(%rip), %rdi      # 0xffd8
leaq -0x38(%rbp), %rsi
callq 0x3080
addq $0x10, %rbx
leaq 0x6a32(%rip), %rdi      # 0x10248
movq %rbx, %rsi
callq 0x7940
cmpl $0x1, 0x28(%rax)
jne 0x986b
leaq -0x1c0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x3310
leaq -0x1c0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3360
movl -0x14(%rbp), %r14d
leaq 0x6a36(%rip), %rdi      # 0x10288
movq %rbx, %rsi
callq 0x9a08
movl %r14d, (%rax)
leaq -0x1c0(%rbp), %rdi
callq 0x3190
jmp 0x98bd
leaq 0x69d6(%rip), %rdi      # 0x10248
movq %rbx, %rsi
callq 0x7940
cmpl $0x0, 0x28(%rax)
jne 0x98bd
leaq 0x1a73(%rip), %rsi      # 0xb2fa
leaq -0x38(%rbp), %rdi
callq 0x4fcd
testb %al, %al
je 0x98ab
leaq 0x69ed(%rip), %rdi      # 0x10288
movq %rbx, %rsi
callq 0x9a08
movl $0x1, (%rax)
jmp 0x98bd
leaq 0x69d6(%rip), %rdi      # 0x10288
movq %rbx, %rsi
callq 0x9a08
andl $0x0, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3110
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x98e5
movq %rax, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x3190
jmp 0x98e8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: write_instruction::execute()
void write_instruction::execute() {
    if(exp_type == natural) {
        std::cout << exp->get_value() << std::endl;
    } else if(exp_type == boolean) {
        if(exp->get_value()) {
            std::cout << "true" << std::endl;
        } else {
            std::cout << "false" << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x9924
cmpl $0x1, %eax
jne 0x9942
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %esi
movq 0x66ab(%rip), %rdi      # 0xffc8
callq 0x3150
jmp 0x9950
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x6693(%rip), %rdi      # 0xffc8
testl %eax, %eax
je 0x9944
leaq 0x19ba(%rip), %rsi      # 0xb2fa
jmp 0x994b
popq %rbp
retq
leaq 0x19b4(%rip), %rsi      # 0xb2ff
callq 0x31f0
movq %rax, %rdi
popq %rbp
jmp 0x3120
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: execute_commands(std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void execute_commands(std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }

    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        (*it)->execute();
    }
}

// Assembly:
testq %rdi, %rdi
je 0x99ae
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x99aa
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x9996
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lipiji[P]PG_DEEP/deep.cpp
// Function: sample_from_gaussian(double, double)
double sample_from_gaussian(double miu, double sigma)
{
    //std::default_random_engine generator;
    //std::normal_distribution<double> distribution(miu, sigma);
    //reutrn distribution(generator);

    static double V1, V2, S;
    static int phase = 0;
    double X;

    if (phase == 0)
    {
        do
        {
            double U1 = (double)rand() / RAND_MAX;
            double U2 = (double)rand() / RAND_MAX;

            V1 = 2 * U1 - 1;
            V2 = 2 * U2 - 1;
            S = V1 * V1 + V2 * V2;
        } while(S >= 1 || S == 0);

        X = V1 * sqrt(-2 * log(S) / S);
    } else
        X = V2 * sqrt(-2 * log(S) / S);

    phase = 1 - phase;

    return X * sigma + miu;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
cmpl $0x0, 0x616d(%rip)      # 0x91b8
je 0x3067
movsd 0x6153(%rip), %xmm0     # 0x91a8
movsd %xmm0, (%rsp)
movsd 0x614e(%rip), %xmm0     # 0x91b0
jmp 0x30ee
callq 0x2080
cvtsi2sd %eax, %xmm1
movsd 0x3048(%rip), %xmm0     # 0x60c0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x2080
cvtsi2sd %eax, %xmm1
divsd 0x302e(%rip), %xmm1     # 0x60c0
movsd (%rsp), %xmm2
addsd %xmm2, %xmm2
movsd 0x3025(%rip), %xmm0     # 0x60c8
addsd %xmm0, %xmm2
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x60f1(%rip)     # 0x91a8
mulsd %xmm1, %xmm1
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x60dc(%rip)     # 0x91b0
ucomisd 0x2f3c(%rip), %xmm0     # 0x6018
jae 0x3067
ucomisd 0x2ff2(%rip), %xmm0     # 0x60d8
jne 0x30ee
jnp 0x3067
callq 0x2150
mulsd 0x2fd5(%rip), %xmm0     # 0x60d0
divsd 0x60ad(%rip), %xmm0     # 0x91b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3113
sqrtsd %xmm0, %xmm0
jmp 0x3118
callq 0x2140
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
pushq $0x1
popq %rax
subl 0x608e(%rip), %eax      # 0x91b8
movl %eax, 0x6088(%rip)      # 0x91b8
mulsd 0x8(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lipiji[P]PG_DEEP/deep.cpp
// Function: binomial(int, double)
int binomial(int n, double p) 
{
    if(p < 0 || p > 1) return 0;

    int c = 0;
    double r;

    for(int i=0; i<n; i++) {
        r = rand() / (RAND_MAX + 1.0);
        if (r < p) c++;
    }

    return c;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x31b8
ucomisd 0x2e98(%rip), %xmm0     # 0x6018
ja 0x31b8
movl %edi, %ebp
movsd %xmm0, (%rsp)
xorl %ebx, %ebx
testl %edi, %edi
cmovlel %ebx, %ebp
subl $0x1, %ebp
jb 0x31b8
callq 0x2080
cvtsi2sd %eax, %xmm0
mulsd 0x2f3a(%rip), %xmm0     # 0x60e0
xorl %eax, %eax
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addl %eax, %ebx
jmp 0x3190
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lipiji[P]PG_DEEP/deep.cpp
// Function: square_error(double*, double*, int)
double square_error(double *v1, double *v2, int size)
{
    double error = 0;
    for(int i=0; i<size; i++)
        error += pow((v1[i] - v2[i]), 2);

    return error;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm0, %xmm0
cmpq %rax, %rdx
je 0x31e8
movsd (%rdi,%rax,8), %xmm1
subsd (%rsi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x31cc
retq
// File: /workspace/github_cpp_makefile_star2_O2/lipiji[P]PG_DEEP/deep.cpp
// Function: max_i_(double*, int)
int max_i_(double *x, int l)
{
    double max_v = x[0];
    double max_i = 0;
    for(int i=0; i<l; i++)
    {
        if(x[i] > max_v)
        {
            max_v = x[i];
            max_i = i;
        }
    }
    return max_i;
}

// Assembly:
movsd (%rdi), %xmm0
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorpd %xmm1, %xmm1
cmpq %rax, %rsi
je 0x322c
movsd (%rdi,%rax,8), %xmm2
cvtsi2sd %eax, %xmm3
movapd %xmm2, %xmm4
maxsd %xmm0, %xmm4
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm0
orpd %xmm3, %xmm0
movapd %xmm0, %xmm1
incq %rax
movapd %xmm4, %xmm0
jmp 0x31f8
cvttsd2si %xmm1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lipiji[P]PG_DEEP/deep.cpp
// Function: Conf::Conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int*, int, double, int, int, double)
Conf::Conf(string ftx, string fty, int epc, int bs, int *hls, int k, double lr, int n_ly, int n_lb, double lbd)
{
    f_train_x = ftx;
    f_train_y = fty;
    epoch = epc;
    batch_size = bs;
    hidden_layer_size = hls;
    cd_k = k;
    learning_rate = lr;
    n_layers = n_ly;
    n_labels = n_lb;
    lamda = lbd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r12
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
movb %al, 0x70(%rdi)
callq 0x2100
movq %r12, %rdi
movq %r13, %rsi
callq 0x2100
movl 0x70(%rsp), %eax
movl 0x68(%rsp), %ecx
movl 0x60(%rsp), %edx
movl %r15d, 0x80(%rbx)
movl %ebp, 0x84(%rbx)
movq %r14, 0x88(%rbx)
movl %edx, 0x90(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x98(%rbx)
movl %ecx, 0xa0(%rbx)
movl %eax, 0xa4(%rbx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xa8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x20d0
movq 0x10(%rsp), %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::RBM(int, int, int, double**, double*, double*, double, double)
RBM::RBM(int N, int n_f, int n_h, double **w, double *hb, double *vb, double lbd, double mmt)
{
    n_samples = N;
    n_visible = n_f;
    n_hidden = n_h;
    error = 0.0;
    lamda = lbd;
    momentum = mmt;

    if(w == NULL)
    {
        W = new double*[n_hidden];
        for(int i=0; i<n_hidden; i++)
            W[i] = new double[n_visible];
        for(int i=0; i<n_hidden; i++)
            for(int j=0; j<n_visible; j++)
                W[i][j] = sample_from_gaussian(0, 0.01);
    }
    else
    {
        W = w;
    }

    if(hb == NULL)
    {
        hbias = new double[n_hidden];
        for(int i=0; i<n_hidden; i++)
            hbias[i] = 0;
    }
    else
        hbias = hb;

    if(vb == NULL)
    {
        vbias = new double[n_visible];
        for(int i=0; i<n_visible; i++)
            vbias[i] = 0;
    }
    else
        vbias = vb;


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
andq $0x0, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movsd %xmm1, 0x38(%rdi)
pushq $-0x1
popq %r13
testq %r8, %r8
je 0x3c82
movq %r8, 0x10(%rbx)
jmp 0x3d24
movq %r9, (%rsp)
movl %r15d, %edi
shlq $0x3, %rdi
movq %r13, %rax
xorl %r13d, %r13d
testl %r15d, %r15d
cmovsq %rax, %rdi
movl $0x0, %r14d
cmovgl %r15d, %r14d
callq 0x2030
movq %rax, 0x10(%rbx)
movl %ebp, %r12d
shlq $0x3, %r12
testl %ebp, %ebp
pushq $-0x1
popq %rax
cmovsq %rax, %r12
cmpq %r13, %r14
je 0x3cd7
movq %r12, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x3cbd
xorl %r12d, %r12d
pushq $-0x1
popq %r13
movslq %r15d, %rax
cmpq %rax, %r12
jge 0x3d20
xorl %r14d, %r14d
movslq %ebp, %rax
cmpq %rax, %r14
jge 0x3d17
xorps %xmm0, %xmm0
movsd 0x23ec(%rip), %xmm1     # 0x60e8
callq 0x3034
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movl 0x4(%rbx), %ebp
jmp 0x3ce9
incq %r12
movl 0x8(%rbx), %r15d
jmp 0x3cde
movq (%rsp), %r9
movq 0x40(%rsp), %r12
testq %r9, %r9
je 0x3d4a
movq %r9, 0x18(%rbx)
testq %r12, %r12
je 0x3d7b
movq %r12, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %r15d, %r14
leaq (,%r14,8), %rdi
xorl %r15d, %r15d
testl %r14d, %r14d
cmovsq %r13, %rdi
cmovlel %r15d, %r14d
callq 0x2030
movq %rax, 0x18(%rbx)
cmpq %r15, %r14
je 0x3d32
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x3d6c
movslq %ebp, %r14
leaq (,%r14,8), %rdi
xorl %r15d, %r15d
testl %r14d, %r14d
cmovsq %r13, %rdi
cmovlel %r15d, %r14d
callq 0x2030
movq %rax, 0x20(%rbx)
cmpq %r15, %r14
je 0x3d3b
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x3d9d