LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: devaigergely81[P]flex-bison-example/while.cc
// Function: yylex(yy::parser::value_type*, yy::location*)
int yylex(yy::parser::semantic_type* yylval, yy::parser::location_type* yylloc) {
    yylloc->begin.line = lexer->lineno();
    int token = lexer->yylex();
    if(token == yy::parser::token::ID || token == yy::parser::token::NUM) {
        yylval->build(std::string(lexer->YYText()));
    }
    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x19461(%rip), %rdi     # 0x202c8
callq 0x6dc0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x1944c(%rip), %rdi     # 0x202c8
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, -0x14(%rbp)
cmpl $0x115, -0x14(%rbp)     # imm = 0x115
je 0x6e9b
cmpl $0x116, -0x14(%rbp)     # imm = 0x116
jne 0x6f24
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x1941e(%rip), %rdi     # 0x202c8
callq 0x6de0
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4480
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x7390
jmp 0x6ed3
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7360
jmp 0x6ee2
leaq -0x38(%rbp), %rdi
callq 0x41c0
leaq -0x39(%rbp), %rdi
callq 0x42f0
jmp 0x6f24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6f19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41c0
leaq -0x39(%rbp), %rdi
callq 0x42f0
jmp 0x6f2d
movl -0x14(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4470
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movsbl (%rdx), %esi
addq $0x30, %rdx
callq 0xb080
movq -0x10(%rbp), %rdi
callq 0x7a70
addl $-0x16, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x15, %eax
ja 0x7ba2
movq -0x28(%rbp), %rax
leaq 0xee92(%rip), %rcx      # 0x169b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb0f0
jmp 0x7b3e
jmp 0x7ba4
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xb1f0
jmp 0x7bb1
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb130
jmp 0x7b6e
jmp 0x7ba4
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb170
jmp 0x7b87
jmp 0x7ba4
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb1b0
jmp 0x7ba0
jmp 0x7ba4
jmp 0x7ba4
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4470
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movsbl -0x9(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
callq 0xb080
movq -0x18(%rbp), %rdi
callq 0x7990
addl $-0x16, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x15, %eax
ja 0x7c99
movq -0x30(%rbp), %rax
leaq 0xedf3(%rip), %rcx      # 0x16a08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0xb0f0
jmp 0x7c35
jmp 0x7c9b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb1f0
jmp 0x7cab
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0xb130
jmp 0x7c65
jmp 0x7c9b
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0xb170
jmp 0x7c7e
jmp 0x7c9b
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0xb1b0
jmp 0x7c97
jmp 0x7c9b
jmp 0x7c9b
movq -0x18(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4470
nopw %cs:(%rax,%rax)
// File: 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
movb %dil, %al
movb %al, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x25, %eax
movslq %eax, %rcx
leaq 0xee4b(%rip), %rax      # 0x16c38
movsbl (%rax,%rcx), %eax
movsbl -0x2(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x7e34
cmpl $0xb9, -0xc(%rbp)
jg 0x7e34
movslq -0xc(%rbp), %rcx
leaq 0xeefb(%rip), %rax      # 0x16d10
movsbl (%rax,%rcx), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7e34
movslq -0xc(%rbp), %rcx
leaq 0xee24(%rip), %rax      # 0x16c50
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x7e4a
movl -0x8(%rbp), %eax
subl $0x25, %eax
movslq %eax, %rcx
leaq 0xedfb(%rip), %rax      # 0x16c3f
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
// File: devaigergely81[P]flex-bison-example/while.tab.hh
// Function: yy::parser::basic_symbol<yy::parser::by_state>::clear()
void clear () YY_NOEXCEPT
      {
        // User destructor.
        symbol_kind_type yykind = this->kind ();
        basic_symbol<Base>& yysym = *this;
        (void) yysym;
        switch (yykind)
        {
       default:
          break;
        }

        // Value type destructor.
switch (yykind)
    {
      case symbol_kind::S_expression: // expression
        value.template destroy< expression* > ();
        break;

      case symbol_kind::S_command: // command
        value.template destroy< instruction* > ();
        break;

      case symbol_kind::S_commands: // commands
        value.template destroy< std::list<instruction*>*  > ();
        break;

      case symbol_kind::S_ID: // ID
      case symbol_kind::S_NUM: // NUM
        value.template destroy< std::string > ();
        break;

      default:
        break;
    }

        Base::clear ();
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7a70
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq %rax, -0x18(%rbp)
jmp 0xc148
movl -0xc(%rbp), %eax
addl $-0x16, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x15, %eax
ja 0xc1b1
movq -0x28(%rbp), %rax
leaq 0xaea8(%rip), %rcx      # 0x1700c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1d0
jmp 0xc17c
jmp 0xc1b3
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc1f0
jmp 0xc18d
jmp 0xc1b3
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc210
jmp 0xc19e
jmp 0xc1b3
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xc230
jmp 0xc1af
jmp 0xc1b3
jmp 0xc1b3
movq -0x20(%rbp), %rdi
callq 0x7a00
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6e20
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7a20
movq -0x20(%rbp), %rdi
callq 0x7a70
addl $-0x16, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x15, %eax
ja 0xc468
movq -0x18(%rbp), %rax
leaq 0xac61(%rip), %rcx      # 0x17064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb0f0
jmp 0xc46a
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb130
jmp 0xc46a
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb170
jmp 0xc46a
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xb1b0
jmp 0xc46a
jmp 0xc46a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x40(%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0x48(%rcx), %rcx
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xdcb8
jmp 0xdd48
leaq -0x10(%rbp), %rdi
callq 0xdea0
movq -0x8(%rbp), %rdi
callq 0xdec0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd030
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xdef0
testb $0x1, %al
jne 0xdcf6
jmp 0xdd23
leaq -0x10(%rbp), %rdi
callq 0xdf20
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xdd16
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xdd18
leaq -0x10(%rbp), %rdi
callq 0xdf40
jmp 0xdcd6
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xdd48
movq -0x30(%rbp), %rdi
callq 0xdf60
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0x42b0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x8d4e(%rip), %rsi      # 0x170c5
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8d38(%rip), %rsi      # 0x170c7
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8d22(%rip), %rsi      # 0x170c9
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8d10(%rip), %rsi      # 0x170cb
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8cfe(%rip), %rsi      # 0x170cd
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8cec(%rip), %rsi      # 0x170cf
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8cda(%rip), %rsi      # 0x170d1
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8cc8(%rip), %rsi      # 0x170d3
callq 0x7440
testb $0x1, %al
jne 0xe42a
movq -0x18(%rbp), %rdi
leaq 0x8cb7(%rip), %rsi      # 0x170d6
callq 0x7440
testb $0x1, %al
jne 0xe42a
jmp 0xe433
movl $0x1, -0x4(%rbp)
jmp 0xe43a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: return_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
type return_type(std::string op) {
    if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%") {
           return natural;
    } else {
        return boolean;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x8c5e(%rip), %rsi      # 0x170c5
callq 0x7440
testb $0x1, %al
jne 0xe4c2
movq -0x18(%rbp), %rdi
leaq 0x8c4c(%rip), %rsi      # 0x170c7
callq 0x7440
testb $0x1, %al
jne 0xe4c2
movq -0x18(%rbp), %rdi
leaq 0x8c3a(%rip), %rsi      # 0x170c9
callq 0x7440
testb $0x1, %al
jne 0xe4c2
movq -0x18(%rbp), %rdi
leaq 0x8c28(%rip), %rsi      # 0x170cb
callq 0x7440
testb $0x1, %al
jne 0xe4c2
movq -0x18(%rbp), %rdi
leaq 0x8c16(%rip), %rsi      # 0x170cd
callq 0x7440
testb $0x1, %al
jne 0xe4c2
jmp 0xe4cb
movl $0x1, -0x4(%rbp)
jmp 0xe4d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x90(%rbp)
addq $0x10, %rsi
leaq 0x1186b(%rip), %rdi     # 0x202f0
callq 0xefd0
cmpq $0x0, %rax
jne 0xeb5d
movq -0x90(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x9c(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4480
movq -0x98(%rbp), %rdx
leaq 0x8775(%rip), %rsi      # 0x17237
leaq -0x48(%rbp), %rdi
callq 0x7390
jmp 0xeacd
movq -0x90(%rbp), %rdx
addq $0x10, %rdx
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xf030
jmp 0xeae7
movl -0x9c(%rbp), %edi
leaq -0x28(%rbp), %rsi
callq 0xd3d0
jmp 0xeaf8
leaq -0x28(%rbp), %rdi
callq 0x41c0
leaq -0x48(%rbp), %rdi
callq 0x41c0
leaq -0x49(%rbp), %rdi
callq 0x42f0
jmp 0xeb5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xeb4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xeb46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41c0
leaq -0x48(%rbp), %rdi
callq 0x41c0
leaq -0x49(%rbp), %rdi
callq 0x42f0
jmp 0xec3e
movq -0x90(%rbp), %rsi
addq $0x10, %rsi
leaq 0x11781(%rip), %rdi     # 0x202f0
callq 0xf080
movq %rax, %rcx
movq -0x90(%rbp), %rax
movl 0x28(%rcx), %ecx
movl %ecx, -0xa0(%rbp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movl -0xa0(%rbp), %eax
cmpl %ecx, %eax
je 0xec35
movq -0x90(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xac(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4480
movq -0xa8(%rbp), %rdx
leaq 0x870d(%rip), %rsi      # 0x172de
leaq -0x80(%rbp), %rdi
callq 0x7390
jmp 0xebdc
movl -0xac(%rbp), %edi
leaq -0x80(%rbp), %rsi
callq 0xd3d0
jmp 0xebed
leaq -0x80(%rbp), %rdi
callq 0x41c0
leaq -0x81(%rbp), %rdi
callq 0x42f0
jmp 0xec35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xec27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x41c0
leaq -0x81(%rbp), %rdi
callq 0x42f0
jmp 0xec3e
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4470
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x0, %eax
je 0xee1f
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x54(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4480
movq -0x50(%rbp), %rdx
leaq 0x855a(%rip), %rsi      # 0x1731e
leaq -0x28(%rbp), %rdi
callq 0x7390
jmp 0xedcf
movl -0x54(%rbp), %edi
leaq -0x28(%rbp), %rsi
callq 0xd3d0
jmp 0xeddd
leaq -0x28(%rbp), %rdi
callq 0x41c0
leaq -0x29(%rbp), %rdi
callq 0x42f0
jmp 0xee1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xee14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41c0
leaq -0x29(%rbp), %rdi
callq 0x42f0
jmp 0xee3f
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xee50
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xee50
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4470
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xee65
jmp 0xeec0
leaq -0x10(%rbp), %rdi
callq 0xdea0
movq -0x8(%rbp), %rdi
callq 0xdec0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd030
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xdef0
testb $0x1, %al
jne 0xeea3
jmp 0xeec0
leaq -0x10(%rbp), %rdi
callq 0xdf20
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x10(%rbp), %rdi
callq 0xdf40
jmp 0xee83
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: symbol::get_size()
int symbol::get_size() {
    if(symbol_type == boolean) {
        return 1;
    } else {
        return 4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x10e9b
movl $0x1, -0x4(%rbp)
jmp 0x10ea2
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x10f15
leaq -0xd(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4480
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x668e(%rip), %rsi      # 0x1757a
callq 0x7390
jmp 0x10ef3
leaq -0xd(%rbp), %rdi
callq 0x42f0
jmp 0x10f5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x42f0
jmp 0x10f64
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4480
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x65b3(%rip), %rsi      # 0x174e4
callq 0x7390
jmp 0x10f38
leaq -0x1d(%rbp), %rdi
callq 0x42f0
jmp 0x10f5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x42f0
jmp 0x10f64
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4470
nopl (%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4200
cmpl $0x1, -0xc(%rbp)
jne 0x11b3b
leaq -0x188(%rbp), %rdi
leaq 0x5951(%rip), %rsi      # 0x17444
callq 0x4290
movq %rax, -0x1c0(%rbp)
jmp 0x11b01
movq -0x1c0(%rbp), %rdi
movq 0xe4a9(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x11b16
jmp 0x11b6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4220
jmp 0x11c32
leaq -0x188(%rbp), %rdi
leaq 0x598c(%rip), %rsi      # 0x174d5
callq 0x4290
movq %rax, -0x1c8(%rbp)
jmp 0x11b57
movq -0x1c8(%rbp), %rdi
movq 0xe453(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x11b6c
jmp 0x11b6e
leaq -0x188(%rbp), %rdi
leaq 0x58d4(%rip), %rsi      # 0x17450
callq 0x4290
movq %rax, -0x1d0(%rbp)
jmp 0x11b8a
movq -0x1d0(%rbp), %rdi
movq 0xe420(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x11b9f
leaq -0x188(%rbp), %rdi
leaq 0x58ac(%rip), %rsi      # 0x17459
callq 0x4290
movq %rax, -0x1d8(%rbp)
jmp 0x11bbb
movq -0x1d8(%rbp), %rdi
movq 0xe3ef(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x11bd0
leaq -0x188(%rbp), %rdi
leaq 0x58bf(%rip), %rsi      # 0x1749d
callq 0x4290
movq %rax, -0x1e0(%rbp)
jmp 0x11bec
movq -0x1e0(%rbp), %rdi
movq 0xe3be(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x11c01
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x4280
jmp 0x11c16
leaq -0x198(%rbp), %rdi
callq 0x4220
movq -0x1b0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x4470
nop
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4200
movq -0x1d8(%rbp), %rax
leaq -0x188(%rbp), %rcx
movq %rcx, -0x1d0(%rbp)
movq 0x30(%rax), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0x11fe6
movq -0x1d0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x4270
jmp 0x11ffb
leaq -0x1b8(%rbp), %rdi
callq 0x41c0
leaq -0x188(%rbp), %rdi
leaq 0x54e7(%rip), %rsi      # 0x174fc
callq 0x4290
movq %rax, -0x1f0(%rbp)
jmp 0x12023
movq -0x1f0(%rbp), %rdi
movq 0xdf87(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x12038
movq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x4280
jmp 0x1204d
leaq -0x198(%rbp), %rdi
callq 0x4220
movq -0x1e0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x1209b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x41c0
leaq -0x198(%rbp), %rdi
callq 0x4220
movq -0x1c0(%rbp), %rdi
callq 0x4470
nopw %cs:(%rax,%rax)
// File: 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
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x248(%rbp)
movq %rdi, %rax
movq %rax, -0x240(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4200
movq -0x238(%rbp), %rax
leaq -0x188(%rbp), %rcx
movq %rcx, -0x230(%rbp)
movq 0x30(%rax), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0x12126
movq -0x230(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x4270
jmp 0x1213b
leaq -0x1b8(%rbp), %rdi
callq 0x41c0
movq -0x238(%rbp), %rsi
leaq -0x188(%rbp), %rax
movq %rax, -0x258(%rbp)
addq $0x10, %rsi
leaq 0xe189(%rip), %rdi      # 0x202f0
callq 0xf080
movq %rax, -0x250(%rbp)
jmp 0x12175
movq -0x250(%rbp), %rdx
addq $0x30, %rdx
leaq 0x537e(%rip), %rsi      # 0x17505
leaq -0x208(%rbp), %rdi
callq 0x13120
jmp 0x12195
leaq 0x536f(%rip), %rdx      # 0x1750b
leaq -0x1e8(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0xf1c0
jmp 0x121b1
movq -0x258(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x4270
movq %rax, -0x260(%rbp)
jmp 0x121cd
movq -0x238(%rbp), %rsi
addq $0x10, %rsi
leaq 0xe111(%rip), %rdi      # 0x202f0
callq 0xf080
movq %rax, -0x268(%rbp)
jmp 0x121ed
movq -0x268(%rbp), %rax
movl 0x28(%rax), %esi
leaq -0x228(%rbp), %rdi
callq 0x10eb0
jmp 0x12205
movq -0x260(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x4270
movq %rax, -0x270(%rbp)
jmp 0x12221
movq -0x270(%rbp), %rdi
movq 0xdd89(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x12236
leaq -0x228(%rbp), %rdi
callq 0x41c0
leaq -0x1e8(%rbp), %rdi
callq 0x41c0
leaq -0x208(%rbp), %rdi
callq 0x41c0
movq -0x248(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x4280
jmp 0x1226f
leaq -0x198(%rbp), %rdi
callq 0x4220
movq -0x240(%rbp), %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x1231d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x41c0
jmp 0x1231d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x12311
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x12305
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x41c0
leaq -0x1e8(%rbp), %rdi
callq 0x41c0
leaq -0x208(%rbp), %rdi
callq 0x41c0
leaq -0x198(%rbp), %rdi
callq 0x4220
movq -0x1c0(%rbp), %rdi
callq 0x4470
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x123a5
leaq -0xd(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x4480
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x5222(%rip), %rsi      # 0x1759e
callq 0x7390
jmp 0x12383
leaq -0xd(%rbp), %rdi
callq 0x42f0
jmp 0x123ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x42f0
jmp 0x123f4
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4480
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x51b4(%rip), %rsi      # 0x17575
callq 0x7390
jmp 0x123c8
leaq -0x1d(%rbp), %rdi
callq 0x42f0
jmp 0x123ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x42f0
jmp 0x123f4
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4470
nopl (%rax)
// File: 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
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x210(%rbp)
movq %rdi, %rax
movq %rax, -0x208(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x200(%rbp)
addq $0x10, %rsi
leaq 0xdeb6(%rip), %rdi      # 0x202f0
callq 0xf080
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x4200
leaq -0x190(%rbp), %rdi
leaq 0x50af(%rip), %rsi      # 0x1750e
callq 0x4290
movq %rax, -0x1f8(%rbp)
jmp 0x1246d
movl -0x14(%rbp), %esi
leaq -0x1d0(%rbp), %rdi
callq 0x12340
jmp 0x1247e
movq -0x1f8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x4270
movq %rax, -0x218(%rbp)
jmp 0x1249a
movq -0x218(%rbp), %rdi
movq 0xdb10(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x124af
leaq -0x1d0(%rbp), %rdi
callq 0x41c0
leaq -0x190(%rbp), %rdi
leaq 0x503c(%rip), %rsi      # 0x17505
callq 0x4290
movq %rax, -0x220(%rbp)
jmp 0x124d7
movq -0x200(%rbp), %rsi
addq $0x10, %rsi
leaq 0xde07(%rip), %rdi      # 0x202f0
callq 0xf080
movq %rax, -0x228(%rbp)
jmp 0x124f7
movq -0x220(%rbp), %rdi
movq -0x228(%rbp), %rsi
addq $0x30, %rsi
callq 0x4270
movq %rax, -0x230(%rbp)
jmp 0x12517
movq -0x230(%rbp), %rdi
leaq 0x4fe6(%rip), %rsi      # 0x1750b
callq 0x4290
movq %rax, -0x238(%rbp)
jmp 0x12533
movl -0x14(%rbp), %esi
leaq -0x1f0(%rbp), %rdi
callq 0x10eb0
jmp 0x12544
movq -0x238(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x4270
movq %rax, -0x240(%rbp)
jmp 0x12560
movq -0x240(%rbp), %rdi
movq 0xda4a(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x12575
leaq -0x1f0(%rbp), %rdi
callq 0x41c0
movq -0x210(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x4280
jmp 0x12596
leaq -0x1a0(%rbp), %rdi
callq 0x4220
movq -0x208(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x12604
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x41c0
jmp 0x12604
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x41c0
leaq -0x1a0(%rbp), %rdi
callq 0x4220
movq -0x1a8(%rbp), %rdi
callq 0x4470
nopl (%rax)
// File: 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
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4200
movq -0x1f8(%rbp), %rax
leaq -0x188(%rbp), %rcx
movq %rcx, -0x1f0(%rbp)
movq 0x10(%rax), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0x12686
movq -0x1f0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x4270
jmp 0x1269b
leaq -0x1b8(%rbp), %rdi
callq 0x41c0
movq -0x1f8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x12721
leaq -0x188(%rbp), %rdi
leaq 0x4e57(%rip), %rsi      # 0x17519
callq 0x4290
movq %rax, -0x210(%rbp)
jmp 0x126d0
movq -0x210(%rbp), %rdi
movq 0xd8da(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x126e5
jmp 0x12721
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x12843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x41c0
jmp 0x12843
leaq -0x188(%rbp), %rdi
leaq 0x4db0(%rip), %rsi      # 0x174df
callq 0x4290
movq %rax, -0x218(%rbp)
jmp 0x1273d
movq -0x218(%rbp), %rdi
movq 0xd86d(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x12752
leaq -0x188(%rbp), %rdi
leaq 0x4dc3(%rip), %rsi      # 0x17523
callq 0x4290
movq %rax, -0x220(%rbp)
jmp 0x1276e
movq -0x1f8(%rbp), %rax
movl 0x18(%rax), %esi
leaq -0x1e8(%rbp), %rdi
callq 0x12340
jmp 0x12786
movq -0x220(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x4270
movq %rax, -0x228(%rbp)
jmp 0x127a2
movq -0x228(%rbp), %rdi
movq 0xd808(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x127b7
leaq -0x1e8(%rbp), %rdi
callq 0x41c0
leaq -0x188(%rbp), %rdi
leaq 0x4d5e(%rip), %rsi      # 0x1752f
callq 0x4290
movq %rax, -0x230(%rbp)
jmp 0x127df
movq -0x230(%rbp), %rdi
movq 0xd7cb(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x127f4
movq -0x208(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x4280
jmp 0x12809
leaq -0x198(%rbp), %rdi
callq 0x4220
movq -0x200(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x41c0
leaq -0x198(%rbp), %rdi
callq 0x4220
movq -0x1c0(%rbp), %rdi
callq 0x4470
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12b5c
jmp 0x12bf9
leaq -0x18(%rbp), %rdi
callq 0xdea0
movq -0x10(%rbp), %rdi
callq 0xdec0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd030
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xdef0
testb $0x1, %al
jne 0x12b9a
jmp 0x12bf9
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xdf20
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq *%rax
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x4270
jmp 0x12bce
leaq -0x48(%rbp), %rdi
callq 0x41c0
leaq -0x18(%rbp), %rdi
callq 0xdf40
jmp 0x12b7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41c0
jmp 0x12bff
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4470
nopl (%rax,%rax)
// File: 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
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x43c0
movq -0x1d0(%rbp), %rsi
movq 0xc750(%rip), %rdi      # 0x1ffd8
callq 0x40c0
jmp 0x1388f
movq -0x1d8(%rbp), %rsi
addq $0x10, %rsi
leaq 0xca4f(%rip), %rdi      # 0x202f0
callq 0xf080
movq %rax, -0x1e0(%rbp)
jmp 0x138af
movq -0x1e0(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x1397e
movl $0x10, %edi
movl $0x8, %esi
callq 0xde80
movl %eax, -0x1e4(%rbp)
jmp 0x138d7
movl -0x1e4(%rbp), %edx
leaq -0x1c0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4400
jmp 0x138ef
leaq -0x1c0(%rbp), %rdi
leaq -0x1c4(%rbp), %rsi
callq 0x4080
jmp 0x13904
movq -0x1d8(%rbp), %rsi
movl -0x1c4(%rbp), %eax
movl %eax, -0x1f4(%rbp)
addq $0x10, %rsi
leaq 0xca0e(%rip), %rdi      # 0x20330
callq 0x13ce0
movq %rax, -0x1f0(%rbp)
jmp 0x13930
movq -0x1f0(%rbp), %rax
movl -0x1f4(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x1c0(%rbp), %rdi
callq 0x4220
jmp 0x13a33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x13a45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x4220
jmp 0x13a45
movq -0x1d8(%rbp), %rsi
addq $0x10, %rsi
leaq 0xc960(%rip), %rdi      # 0x202f0
callq 0xf080
movq %rax, -0x200(%rbp)
jmp 0x1399e
movq -0x200(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x13a31
leaq 0x3c58(%rip), %rsi      # 0x1760e
leaq -0x28(%rbp), %rdi
callq 0x7440
movb %al, -0x201(%rbp)
jmp 0x139c7
movb -0x201(%rbp), %al
testb $0x1, %al
jne 0x139d3
jmp 0x13a02
movq -0x1d8(%rbp), %rsi
addq $0x10, %rsi
leaq 0xc94b(%rip), %rdi      # 0x20330
callq 0x13ce0
movq %rax, -0x210(%rbp)
jmp 0x139f3
movq -0x210(%rbp), %rax
movl $0x1, (%rax)
jmp 0x13a2f
movq -0x1d8(%rbp), %rsi
addq $0x10, %rsi
leaq 0xc91c(%rip), %rdi      # 0x20330
callq 0x13ce0
movq %rax, -0x218(%rbp)
jmp 0x13a22
movq -0x218(%rbp), %rax
movl $0x0, (%rax)
jmp 0x13a31
jmp 0x13a33
leaq -0x28(%rbp), %rdi
callq 0x41c0
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x41c0
movq -0x30(%rbp), %rdi
callq 0x4470
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x18(%rax)
jne 0x13aa7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %esi
movq 0xc537(%rip), %rdi      # 0x1ffc8
callq 0x43a0
movq %rax, %rdi
movq 0xc518(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x13b0e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x13b0c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x0, %eax
je 0x13ae8
movq 0xc4fd(%rip), %rdi      # 0x1ffc8
leaq 0x3b3c(%rip), %rsi      # 0x1760e
callq 0x4290
movq %rax, %rdi
movq 0xc4d7(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x13b0a
movq 0xc4d9(%rip), %rdi      # 0x1ffc8
leaq 0x3b1d(%rip), %rsi      # 0x17613
callq 0x4290
movq %rax, %rdi
movq 0xc4b3(%rip), %rsi      # 0x1ffb8
callq 0x42d0
jmp 0x13b0c
jmp 0x13b0e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: if_instruction::execute()
void if_instruction::execute() {
    if(condition->get_value()) {
        execute_commands(true_branch);
    } else {
        execute_commands(false_branch);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x0, %eax
je 0x13b52
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x13b70
jmp 0x13b5f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x13b70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13b85
jmp 0x13be0
leaq -0x10(%rbp), %rdi
callq 0xdea0
movq -0x8(%rbp), %rdi
callq 0xdec0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd030
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xdef0
testb $0x1, %al
jne 0x13bc3
jmp 0x13be0
leaq -0x10(%rbp), %rdi
callq 0xdf20
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq -0x10(%rbp), %rdi
callq 0xdf40
jmp 0x13ba3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
cmpl $0x0, 0xaa5f(%rip)      # 0xf248
jne 0x4918
jmp 0x47f1
callq 0x20a0
cvtsi2sd %eax, %xmm0
movsd 0x68be(%rip), %xmm1     # 0xb0c0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x20a0
cvtsi2sd %eax, %xmm0
movsd 0x68a4(%rip), %xmm1     # 0xb0c0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
addsd %xmm0, %xmm0
movsd 0x6882(%rip), %xmm1     # 0xb0b8
addsd %xmm1, %xmm0
movsd %xmm0, 0xa9ee(%rip)     # 0xf230
movsd -0x28(%rbp), %xmm0
addsd %xmm0, %xmm0
movsd 0x6865(%rip), %xmm1     # 0xb0b8
addsd %xmm1, %xmm0
movsd %xmm0, 0xa9d9(%rip)     # 0xf238
movsd 0xa9c9(%rip), %xmm0     # 0xf230
movsd 0xa9c1(%rip), %xmm2     # 0xf230
movsd 0xa9c1(%rip), %xmm1     # 0xf238
mulsd 0xa9b9(%rip), %xmm1     # 0xf238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xa9b1(%rip)     # 0xf240
movsd 0xa9a9(%rip), %xmm0     # 0xf240
movb $0x1, %al
movsd 0x6767(%rip), %xmm1     # 0xb008
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jae 0x48c4
movsd 0xa98e(%rip), %xmm0     # 0xf240
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x47f1
movsd 0xa959(%rip), %xmm0     # 0xf230
movsd %xmm0, -0x38(%rbp)
movsd 0xa95c(%rip), %xmm0     # 0xf240
callq 0x21b0
movaps %xmm0, %xmm1
movsd 0x67bc(%rip), %xmm0     # 0xb0b0
mulsd %xmm1, %xmm0
divsd 0xa940(%rip), %xmm0     # 0xf240
callq 0x2190
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x495f
movsd 0xa918(%rip), %xmm0     # 0xf238
movsd %xmm0, -0x40(%rbp)
movsd 0xa913(%rip), %xmm0     # 0xf240
callq 0x21b0
movaps %xmm0, %xmm1
movsd 0x6773(%rip), %xmm0     # 0xb0b0
mulsd %xmm1, %xmm0
divsd 0xa8f7(%rip), %xmm0     # 0xf240
callq 0x2190
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x1, %eax
subl 0xa8de(%rip), %eax      # 0xf248
movl %eax, 0xa8d8(%rip)      # 0xf248
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd -0x8(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
ja 0x4a0d
movsd -0x10(%rbp), %xmm0
movsd 0x6601(%rip), %xmm1     # 0xb008
ucomisd %xmm1, %xmm0
jbe 0x4a16
movl $0x0, -0x4(%rbp)
jmp 0x4a72
movl $0x0, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x4a6c
callq 0x20a0
cvtsi2sd %eax, %xmm0
movsd 0x668b(%rip), %xmm1     # 0xb0c8
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4a5f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a61
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4a24
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4ae3
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x8ea0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4aa2
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4b5c
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x4b4f
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl -0x24(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x4b51
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4b17
cvttsd2si -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)