LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kztomita[P]http-dump/sync_stream_wrapper.cc
// Function: (anonymous namespace)::ssl_keylog_callback(ssl_st const*, char const*)
void ssl_keylog_callback(const SSL *ssl, const char *line) {
  std::ofstream fs(g_keylog_file, std::ios_base::out | std::ios_base::app);
  if (!fs) {
    std::cerr << "Can't open " << g_keylog_file << std::endl;
  }

  fs << line << std::endl;

  fs.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq 0x1c6b9(%rip), %rsi     # 0x47bc0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x11, %edx
callq 0xb6a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x2b5b1
movq 0x1baae(%rip), %r15     # 0x46fe0
leaq 0x8f6a(%rip), %rsi      # 0x344a3
movl $0xb, %edx
movq %r15, %rdi
callq 0xb730
movq 0x1c673(%rip), %r12     # 0x47bc0
testq %r12, %r12
je 0x2b56e
movq %r12, %rdi
callq 0xb2c0
movq 0x1ba7f(%rip), %rdi     # 0x46fe0
movq %r12, %rsi
movq %rax, %rdx
callq 0xb730
jmp 0x2b586
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xbb50
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0xb5b0
movsbl %al, %esi
movq 0x1ba3c(%rip), %rdi     # 0x46fe0
callq 0xb050
movq %rax, %rdi
callq 0xb450
testq %r14, %r14
je 0x2b5d0
movq %r14, %rdi
callq 0xb2c0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb730
jmp 0x2b5ec
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x8, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0xbb50
movq 0x8(%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0xb5b0
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb450
leaq 0x8(%rsp), %rdi
callq 0xb960
movq 0x1b908(%rip), %rax     # 0x46f30
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0xb520
leaq 0x100(%rsp), %rdi
callq 0xb1f0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb9e0
movq %rbx, %rdi
callq 0xbbb0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kztomita[P]http-dump/sync_stream_wrapper.cc
// Function: ssl_stream::connect(boost::asio::ip::address const&, unsigned short)
void ssl_stream::connect(const boost::asio::ip::address& ip, uint16_t port) {
  stream_->lowest_layer().connect(asio::ip::tcp::endpoint(ip, port));

  if (verify_cert_) {
    // for SNI
    SSL_set_tlsext_host_name(stream_->native_handle(), host_.c_str());

    stream_->set_verify_mode(asio::ssl::verify_peer);
    stream_->set_verify_callback(asio::ssl::rfc2818_verification(host_));
  }

  stream_->handshake(asio::ssl::stream_base::client);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %r14
leaq 0x2c(%rsp), %r15
movq %r15, %rdi
callq 0x2b920
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b7d6
cmpb $0x1, 0x30(%rbx)
jne 0x2b736
movq 0x38(%rbx), %rcx
movq 0x58(%rbx), %rax
movq 0x50(%rax), %rdi
movl $0x37, %esi
xorl %edx, %edx
callq 0xb280
movq 0x58(%rbx), %rax
movq 0x50(%rax), %r14
movq %r14, %rdi
callq 0xb220
movq %r14, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0xb460
movq 0x58(%rbx), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe500
movq %r14, %rdi
movq %r15, %rsi
callq 0x2bf7e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b736
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
movq 0x58(%rbx), %rdi
xorl %esi, %esi
callq 0x2c084
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b767
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
movq %rbx, %rdi
callq 0xbbb0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kztomita[P]http-dump/dump.cc
// Function: dump(void const*, unsigned long, unsigned long)
void dump(const void* p, std::size_t size, std::size_t max = 0) {
  const char* p2 = reinterpret_cast<const char*>(p);

  std::size_t last_offset = size;
  bool snip = false;
  if (max && size > max) {
    last_offset = max;
    snip = true;
  }

  for (std::size_t offset = 0 ; offset < last_offset ; offset += 16) {
    if (offset + 16 <= last_offset) {
      out_line(p2 + offset, p2 + offset + 16, false);
    } else {
      out_line(p2 + offset, p2 + last_offset, snip);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
setne %cl
cmpq %rdx, %rsi
seta %al
andb %cl, %al
cmovneq %rdx, %rbx
testq %rbx, %rbx
je 0x30a39
movq %rdi, %r14
leaq (%rdi,%rbx), %r15
xorl %r12d, %r12d
movzbl %al, %ebp
addq $0x10, %r12
cmpq %rbx, %r12
jbe 0x30a22
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
jmp 0x30a2b
leaq 0x10(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x30a42
addq $0x10, %r14
cmpq %rbx, %r12
jb 0x30a0f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyensure_buffer_stack()
void yyFlexLexer::yyensure_buffer_stack(void)
{
	yy_size_t num_to_alloc;
    
	if (!(yy_buffer_stack)) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		(yy_buffer_stack_max) = num_to_alloc;
		(yy_buffer_stack_top) = 0;
		return;
	}

	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = (yy_buffer_stack_max) + grow_size;
		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
								((yy_buffer_stack),
								num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
		(yy_buffer_stack_max) = num_to_alloc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x288(%rdi), %rdi
testq %rdi, %rdi
je 0x3e88
movq 0x280(%rbx), %r14
leaq -0x1(%r14), %rax
cmpq %rax, 0x278(%rbx)
jb 0x3ecc
leaq 0x40(,%r14,8), %rsi
addq $0x8, %r14
callq 0x3350
movq %rax, 0x288(%rbx)
testq %rax, %rax
jne 0x3e62
movq (%rbx), %rax
leaq 0x89be(%rip), %rsi      # 0xc813
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x288(%rbx), %rax
movq 0x280(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax,%rcx,8)
movups %xmm0, 0x20(%rax,%rcx,8)
movups %xmm0, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
movq %r14, 0x280(%rbx)
jmp 0x3ecc
movl $0x8, %edi
callq 0x32d0
movq %rax, 0x288(%rbx)
testq %rax, %rax
jne 0x3eb5
movq (%rbx), %rax
leaq 0x896b(%rip), %rsi      # 0xc813
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x288(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, (%rax)
movq $0x1, 0x280(%rbx)
movq %rcx, 0x278(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_try_NUL_trans(int)
yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 100 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 99);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
leaq -0x63(%rax), %rcx
cmpq $-0x60, %rcx
jb 0x4025
movq 0x260(%rdi), %rcx
movl %esi, 0x290(%rdi)
movq %rcx, 0x298(%rdi)
leaq 0x8394(%rip), %rdx      # 0xc3c0
movswq (%rdx,%rax,2), %rcx
leaq 0x8258(%rip), %rdi      # 0xc290
movswl 0x2(%rdi,%rcx,2), %r8d
cmpl %esi, %r8d
je 0x405b
leaq 0x8446(%rip), %rsi      # 0xc490
movswq (%rsi,%rax,2), %rax
movswq (%rdx,%rax,2), %rcx
cmpw 0x2(%rdi,%rcx,2), %ax
jne 0x404a
incq %rcx
leaq 0x852b(%rip), %rax      # 0xc590
movzwl (%rax,%rcx,2), %eax
xorl %ecx, %ecx
cmpw $0x63, %ax
cmovnel %eax, %ecx
movswl %cx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::~yyFlexLexer()
yyFlexLexer::~yyFlexLexer()
{
	delete [] yy_state_buf;
	yyfree( yy_start_stack  );
	yy_delete_buffer( YY_CURRENT_BUFFER );
	yyfree( yy_buffer_stack  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd354(%rip), %rax      # 0x118c8
movq %rax, (%rdi)
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x4588
callq 0x32b0
movq 0x28(%rbx), %rdi
callq 0x3280
movq 0x288(%rbx), %rax
testq %rax, %rax
je 0x45aa
movq 0x278(%rbx), %rcx
movq (%rax,%rcx,8), %rsi
jmp 0x45ac
xorl %esi, %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq 0x288(%rbx), %rdi
callq 0x3280
leaq 0x150(%rbx), %rdi
callq 0x30d0
movq 0xd9f4(%rip), %rax      # 0x11fc8
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x30(%rbx,%rcx)
movq $0x0, 0x38(%rbx)
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30d0
movq %rax, %rdi
callq 0x4e62
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::LexerInput(char*, int)
int yyFlexLexer::LexerInput( char* buf, int max_size )
#endif
{
	if ( yyin.eof() || yyin.fail() )
		return 0;

#ifdef YY_INTERACTIVE
	yyin.get( buf[0] );

	if ( yyin.eof() )
		return 0;

	if ( yyin.bad() )
		return -1;

	return 1;

#else
	(void) yyin.read( buf, max_size );

	if ( yyin.bad() )
		return -1;
	else
		return yyin.gcount();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
movq -0x18(%rax), %rax
xorl %ebx, %ebx
testb $0x7, 0x50(%rdi,%rax)
jne 0x4727
movq %rdi, %r14
addq $0x30, %r14
movq %r14, %rdi
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x20(%r14,%rax), %eax
testb $0x2, %al
jne 0x4727
andl $0x1, %eax
negl %eax
orl $0x1, %eax
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyunput(int, char*)
void yyFlexLexer::yyunput( int c, char* yy_bp)
{
	char *yy_cp;
    
    yy_cp = (yy_c_buf_p);

	/* undo effects of setting up yytext */
	*yy_cp = (yy_hold_char);

	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		int number_to_move = (yy_n_chars) + 2;
		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
		char *source =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			*--dest = *--source;

		yy_cp += (int) (dest - source);
		yy_bp += (int) (dest - source);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
			(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	*--yy_cp = (char) c;

    if ( c == '\n' ){
        --yylineno;
    }

	(yytext_ptr) = yy_bp;
	(yy_hold_char) = *yy_cp;
	(yy_c_buf_p) = yy_cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x260(%rdi), %r12
movb 0x258(%rdi), %al
movb %al, (%r12)
movq 0x278(%rdi), %rax
movq 0x288(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rax
leaq 0x2(%rax), %rdx
cmpq %rdx, %r12
jae 0x4806
movslq 0x25c(%rbx), %rsi
movslq 0x18(%rcx), %rdi
leaq (%rax,%rdi), %rdx
addq $0x2, %rdx
addq %rax, %rsi
addq $0x2, %rsi
cmpq %rax, %rsi
jbe 0x47d9
movb -0x1(%rsi), %al
decq %rsi
movb %al, -0x1(%rdx)
decq %rdx
movq 0x278(%rbx), %rax
movq 0x288(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rax
cmpq %rax, %rsi
ja 0x47af
movl 0x18(%rcx), %edi
subl %esi, %edx
movslq %edx, %rdx
addq %rdx, %r12
addq %rdx, %r14
movl %edi, 0x25c(%rbx)
movl %edi, 0x1c(%rcx)
addq $0x2, %rax
cmpq %rax, %r12
jae 0x4806
movq (%rbx), %rax
leaq 0x7fc7(%rip), %rsi      # 0xc7c7
movq %rbx, %rdi
callq *0x70(%rax)
movb %r15b, -0x1(%r12)
decq %r12
cmpl $0xa, %r15d
jne 0x4817
decl 0x14(%rbx)
movq %r14, 0x8(%rbx)
movb (%r12), %al
movb %al, 0x258(%rbx)
movq %r12, 0x260(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyinput()
int yyFlexLexer::yyinput()
{
	int c;
    
	*(yy_c_buf_p) = (yy_hold_char);

	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
			/* This was really a NUL. */
			*(yy_c_buf_p) = '\0';

		else
			{ /* need more input */
			int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
			++(yy_c_buf_p);

			switch ( yy_get_next_buffer(  ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin );

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap(  ) )
						return 0;

					if ( ! (yy_did_buffer_switch_on_eof) )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput();
#else
					return input();
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					(yy_c_buf_p) = (yytext_ptr) + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
	*(yy_c_buf_p) = '\0';	/* preserve yytext */
	(yy_hold_char) = *++(yy_c_buf_p);

	if ( c == '\n' )
		
    yylineno++;
;

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb 0x258(%rdi), %al
movq 0x260(%rdi), %rcx
movb %al, (%rcx)
movq 0x260(%rdi), %r15
movb (%r15), %al
testb %al, %al
jne 0x4922
leaq 0x30(%rbx), %r14
movq 0x278(%rbx), %rax
movq 0x288(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movslq 0x25c(%rbx), %rcx
addq 0x8(%rax), %rcx
cmpq %rcx, %r15
jb 0x48fd
movq 0x8(%rbx), %r12
leaq 0x1(%r15), %rax
movq %rax, 0x260(%rbx)
movq %rbx, %rdi
callq 0x4078
cmpl $0x1, %eax
je 0x48b8
cmpl $0x2, %eax
jne 0x490e
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
testl %eax, %eax
jne 0x490a
cmpl $0x0, 0x270(%rbx)
jne 0x48da
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb 0x258(%rbx), %al
movq 0x260(%rbx), %rcx
movb %al, (%rcx)
movq 0x260(%rbx), %r15
movb (%r15), %al
testb %al, %al
je 0x4869
jmp 0x4922
movb $0x0, (%r15)
movq 0x260(%rbx), %r15
jmp 0x491f
xorl %eax, %eax
jmp 0x4952
subl %r12d, %r15d
movslq %r15d, %r15
addq 0x8(%rbx), %r15
movq %r15, 0x260(%rbx)
movb (%r15), %al
movb $0x0, (%r15)
movq 0x260(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x260(%rbx)
movb 0x1(%rcx), %cl
movb %cl, 0x258(%rbx)
cmpb $0xa, %al
jne 0x494f
incl 0x14(%rbx)
movl $0xa, %eax
jmp 0x4952
movzbl %al, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyrestart(std::istream&)
void yyFlexLexer::yyrestart( std::istream& input_file )
{
    
	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE );
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
	yy_load_buffer_state(  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x288(%rdi), %rax
testq %rax, %rax
je 0x4983
movq 0x278(%rbx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x49bb
movq %rbx, %rdi
callq 0x3e00
leaq 0x30(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x4000, %edx           # imm = 0x4000
callq *0x20(%rax)
movq 0x278(%rbx), %rcx
movq 0x288(%rbx), %rdx
movq %rax, (%rdx,%rcx,8)
movq 0x288(%rbx), %rax
testq %rax, %rax
je 0x49c1
movq (%rax,%rcx,8), %rsi
jmp 0x49c3
xorl %esi, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x49da
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3ed2
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_init_buffer(yy_buffer_state*, std::istream&)
void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream& file )

{
	int oerrno = errno;
    
	yy_flush_buffer( b );

	b->yy_input_file = file.rdbuf();
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

	b->yy_is_interactive = 0;
	errno = oerrno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3050
movq %rax, %r14
movl (%rax), %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4bfa
movq (%r12), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r12,%rax), %rax
movq %rax, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x288(%r15), %rax
testq %rax, %rax
je 0x4a3a
movq 0x278(%r15), %rcx
movq (%rax,%rcx,8), %rax
jmp 0x4a3c
xorl %eax, %eax
cmpq %rbx, %rax
je 0x4a49
movq $0x1, 0x2c(%rbx)
movl $0x0, 0x24(%rbx)
movl %r13d, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_create_buffer(std::istream&, int)
YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream& file, int size )
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file );

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
movl $0x40, %edi
callq 0x32d0
movq %rax, %r14
testq %rax, %rax
jne 0x4b3a
movq (%r15), %rax
leaq 0x7cb3(%rip), %rsi      # 0xc7e7
movq %r15, %rdi
callq *0x70(%rax)
movl %r12d, 0x18(%r14)
addl $0x2, %r12d
movslq %r12d, %rdi
callq 0x32d0
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0x4b63
movq (%r15), %rax
leaq 0x7c8a(%rip), %rsi      # 0xc7e7
movq %r15, %rdi
callq *0x70(%rax)
movl $0x1, 0x20(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x49da
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_delete_buffer(yy_buffer_state*)
void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
{
    
	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf  );

	yyfree( (void *) b  );
}

// Assembly:
testq %rsi, %rsi
je 0x4bc5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x288(%rdi), %rax
testq %rax, %rax
je 0x4bc6
movq 0x278(%rdi), %rcx
movq (%rax,%rcx,8), %rcx
jmp 0x4bc8
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x4bdc
movq 0x278(%rdi), %rcx
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x20(%rbx)
je 0x4beb
movq 0x8(%rbx), %rdi
callq 0x3280
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O3/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_push_state(int)
void yyFlexLexer::yy_push_state( int _new_state )
{
    	if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
		{
		yy_size_t new_size;

		(yy_start_stack_depth) += YY_START_STACK_INCR;
		new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int );

		if ( ! (yy_start_stack) )
			(yy_start_stack) = (int *) yyalloc( new_size  );

		else
			(yy_start_stack) = (int *) yyrealloc(
					(void *) (yy_start_stack), new_size  );

		if ( ! (yy_start_stack) )
			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
		}

	(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;

	BEGIN(_new_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movslq 0x20(%rdi), %rax
cmpl %eax, 0x1c(%rdi)
jl 0x4db4
leaq 0x19(%rax), %rcx
movl %ecx, 0x20(%rbx)
leaq 0x64(,%rax,4), %rsi
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4d93
callq 0x3350
jmp 0x4d9b
movq %rsi, %rdi
callq 0x32d0
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x4db4
movq (%rbx), %rax
leaq 0x7a96(%rip), %rsi      # 0xc844
movq %rbx, %rdi
callq *0x70(%rax)
movl 0x26c(%rbx), %eax
movl %eax, %ecx
decl %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
decl %eax
sarl %eax
movq 0x28(%rbx), %rcx
movslq 0x1c(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x1c(%rbx)
movl %eax, (%rcx,%rdx,4)
leal 0x1(%r14,%r14), %eax
movl %eax, 0x26c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0xd3a1(%rip), %rdi      # 0x12228
movl 0x14(%rdi), %eax
movl %eax, 0x8(%rsi)
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebx
leal -0x115(%rbx), %eax
cmpl $0x1, %eax
ja 0x4eed
movq 0xd381(%rip), %rax      # 0x12228
movq 0x8(%rax), %rsi
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x51a0
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x527c
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4eed
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f16
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/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
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), %rcx
testq %rcx, %rcx
je 0x557a
leaq 0x10(%rdi), %rax
leaq 0x770f(%rip), %rdx      # 0xcc20
movzbl (%rcx,%rdx), %ecx
cmpl $0x29, %ecx
jg 0x5542
leal -0x16(%rcx), %edx
cmpl $0x2, %edx
jae 0x554e
leaq 0x20(%rdi), %rdx
movq %rdx, 0x10(%rdi)
movq 0x10(%rsi), %r8
leaq 0x20(%rsi), %rcx
cmpq %rcx, %r8
je 0x555c
movq %r8, (%rax)
movq (%rcx), %rax
movq %rax, (%rdx)
jmp 0x5562
cmpl $0x2a, %ecx
je 0x5553
cmpl $0x2b, %ecx
je 0x5553
jmp 0x557a
cmpl $0x29, %ecx
jne 0x557a
movq 0x10(%rsi), %rcx
movq %rcx, (%rax)
jmp 0x557a
movaps (%rcx), %xmm0
movaps %xmm0, (%rdx)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
movq %rcx, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
movb $0x0, 0x20(%rsi)
movb $0x0, (%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movb %sil, (%rdi)
leaq 0x10(%rdi), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps 0x30(%rdx), %xmm0
movaps 0x40(%rdx), %xmm1
movaps %xmm1, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movl (%rdx), %ecx
cmpl $0x29, %ecx
jg 0x55d5
leal -0x16(%rcx), %esi
cmpl $0x2, %esi
jae 0x55e1
leaq 0x20(%rdi), %rsi
movq %rsi, 0x10(%rdi)
movq 0x10(%rdx), %r8
leaq 0x20(%rdx), %rcx
cmpq %rcx, %r8
je 0x55ef
movq %r8, (%rax)
movq (%rcx), %rax
movq %rax, (%rsi)
jmp 0x55f5
cmpl $0x2a, %ecx
je 0x55e6
cmpl $0x2b, %ecx
je 0x55e6
jmp 0x560d
cmpl $0x29, %ecx
jne 0x560d
movq 0x10(%rdx), %rcx
movq %rcx, (%rax)
jmp 0x560d
movaps (%rcx), %xmm0
movaps %xmm0, (%rsi)
movq 0x18(%rdx), %rax
movq %rax, 0x18(%rdi)
movq %rcx, 0x10(%rdx)
movq $0x0, 0x18(%rdx)
movb $0x0, 0x20(%rdx)
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5580
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6dde
leaq -0x60(%rbp), %rdi
callq 0x6fd0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x6fd0
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x73ca(%rip), %rcx      # 0xca88
movsbl -0x25(%rax,%rcx), %ecx
addl %edi, %ecx
cmpl $0xb9, %ecx
ja 0x56e8
movl %ecx, %edx
leaq 0x748a(%rip), %rcx      # 0xcb60
cmpb %dil, (%rdx,%rcx)
jne 0x56e8
leaq 0x73bd(%rip), %rcx      # 0xcaa0
addq %rdx, %rcx
jmp 0x56f6
addq $-0x25, %rax
leaq 0x739c(%rip), %rcx      # 0xca8f
addq %rax, %rcx
movb (%rcx), %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movb (%rsi), %al
movb %al, (%rdi)
movb $0x0, (%rsi)
movsbq (%rdi), %rax
testq %rax, %rax
je 0x709b
leaq 0x5bf1(%rip), %rcx      # 0xcc20
movzbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jg 0x7062
leal -0x16(%rax), %ecx
cmpl $0x2, %ecx
jae 0x706e
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq 0x10(%rsi), %rdx
leaq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0x707d
movq %rdx, 0x10(%rdi)
movq (%rax), %rcx
movq %rcx, 0x20(%rdi)
jmp 0x7083
cmpl $0x2a, %eax
je 0x7073
cmpl $0x2b, %eax
je 0x7073
jmp 0x709b
cmpl $0x29, %eax
jne 0x709b
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
jmp 0x709b
movaps (%rax), %xmm0
movaps %xmm0, (%rcx)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
movb $0x0, 0x20(%rsi)
movaps 0x30(%rsi), %xmm0
movaps 0x40(%rsi), %xmm1
movaps %xmm1, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x781e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq %rdi, %r14
je 0x77ea
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x77df
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x77d0
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x7807
movq (%r14), %r15
movl $0x18, %esi
movq %r14, %rdi
callq 0x3240
movq %r15, %r14
cmpq %rbx, %r15
jne 0x77ef
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3240
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5260(%rip), %rsi      # 0xce01
callq 0x30b0
movl $0x1, %ebx
testl %eax, %eax
je 0x7c52
leaq 0x5249(%rip), %rsi      # 0xce03
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7c52
leaq 0x5234(%rip), %rsi      # 0xce05
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7c52
leaq 0x5223(%rip), %rsi      # 0xce07
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7c52
leaq 0x5212(%rip), %rsi      # 0xce09
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7c52
leaq 0x5201(%rip), %rsi      # 0xce0b
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7c52
leaq 0x51f0(%rip), %rsi      # 0xce0d
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7c52
leaq 0x51df(%rip), %rsi      # 0xce0f
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7c52
leaq 0x51cf(%rip), %rsi      # 0xce12
movq %r14, %rdi
callq 0x30b0
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x5197(%rip), %rsi      # 0xce01
callq 0x30b0
movl $0x1, %ebx
testl %eax, %eax
je 0x7cc7
leaq 0x5184(%rip), %rsi      # 0xce03
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7cc7
leaq 0x5173(%rip), %rsi      # 0xce05
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7cc7
leaq 0x5162(%rip), %rsi      # 0xce07
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7cc7
leaq 0x5151(%rip), %rsi      # 0xce09
movq %r14, %rdi
callq 0x30b0
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0xa04f(%rip), %rdi      # 0x12250
movq %r14, %rsi
callq 0x8922
leaq 0xa048(%rip), %rcx      # 0x12258
cmpq %rcx, %rax
jne 0x82c7
movl 0x8(%rbx), %r15d
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4cf6(%rip), %rsi      # 0xcf23
leaq 0x4d03(%rip), %rdx      # 0xcf37
leaq -0x68(%rbp), %rdi
callq 0x51de
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq -0x68(%rbp), %rdi
callq 0x30c0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8272
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x827a
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl %r15d, %edi
callq 0x7274
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x82b2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x82c7
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3240
leaq 0x9f82(%rip), %rdi      # 0x12250
movq %r14, %rsi
callq 0x8696
movl 0x28(%rax), %r14d
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl %eax, %r14d
je 0x8332
movl 0x8(%rbx), %ebx
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4cd0(%rip), %rsi      # 0xcfca
leaq 0x4d08(%rip), %rdx      # 0xd009
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x51de
movl %ebx, %edi
movq %r14, %rsi
callq 0x7274
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x8332
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3240
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x835e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0x835e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x838d
movq -0x58(%rbp), %rsi
jmp 0x8385
movq %rax, %rbx
jmp 0x838d
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x838d
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
testl %eax, %eax
je 0x8540
movl 0x8(%rbx), %r14d
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4afd(%rip), %rsi      # 0xd00a
leaq 0x4b23(%rip), %rdx      # 0xd037
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x51de
movl %r14d, %edi
movq %r15, %rsi
callq 0x7274
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x8540
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x8560
movq (%r14), %r15
cmpq %r14, %r15
je 0x8560
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %r15
jmp 0x854c
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x8580
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x8580
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %r14
jmp 0x856c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x85a5
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x85d7
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq %rbx, %r14
je 0x85d3
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %r14
jmp 0x85bf
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
testl %esi, %esi
je 0x9134
leaq 0x40a5(%rip), %rsi      # 0xd1d0
leaq 0x40a1(%rip), %rdx      # 0xd1d3
jmp 0x9142
leaq 0x412b(%rip), %rsi      # 0xd266
leaq 0x4126(%rip), %rdx      # 0xd268
movq %rbx, %rdi
callq 0x51de
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3190
xorl %eax, %eax
cmpl $0x1, %r14d
sete %al
leaq -0x188(%rbp), %r14
leaq 0x3697(%rip), %rcx      # 0xd130
leaq 0x3721(%rip), %rsi      # 0xd1c1
cmoveq %rcx, %rsi
leaq 0x9(,%rax,2), %rdx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x3656(%rip), %rsi      # 0xd13c
movl $0x8, %edx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x3620(%rip), %rsi      # 0xd145
movl $0x8, %edx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x3625(%rip), %rsi      # 0xd189
movl $0xb, %edx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x3320
movq 0x83f6(%rip), %rsi      # 0x11fa8
leaq -0x198(%rbp), %rdi
callq 0x31b0
leaq -0x118(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x83c5(%rip), %rsi      # 0x11fa8
leaq -0x198(%rbp), %rdi
callq 0x31b0
leaq -0x118(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3190
movq 0x30(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1a8(%rbp), %r14
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %r14, %rdi
callq 0x3270
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f24
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3240
leaq 0x32bd(%rip), %rsi      # 0xd1e8
movl $0x8, %edx
movq %r14, %rdi
callq 0x3270
movq -0x1a8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3320
movq 0x802f(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x31b0
leaq -0x138(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fc3
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0x9fc3
jmp 0x9fc0
movq %rax, %rbx
movq 0x7fde(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x31b0
leaq -0x138(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
testl %esi, %esi
je 0xa271
leaq 0x2ff9(%rip), %rsi      # 0xd261
leaq 0x2ff9(%rip), %rdx      # 0xd268
jmp 0xa27f
leaq 0x3012(%rip), %rsi      # 0xd28a
leaq 0x3012(%rip), %rdx      # 0xd291
movq %rbx, %rdi
callq 0x51de
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7f99(%rip), %rdi      # 0x12250
movq %r15, %rsi
callq 0x8696
movl 0x28(%rax), %r14d
leaq -0x1d0(%rbp), %rdi
callq 0x3190
leaq -0x1c0(%rbp), %r12
leaq 0x2f1d(%rip), %rsi      # 0xd1fa
movl $0xa, %edx
movq %r12, %rdi
callq 0x3270
leaq -0x48(%rbp), %rdi
movl %r14d, %esi
callq 0xa24d
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x3270
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq -0x38(%rbp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xa349
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
leaq 0x2ea1(%rip), %rsi      # 0xd1f1
movl $0x5, %edx
movq %r12, %rdi
callq 0x3270
leaq 0x7eec(%rip), %rdi      # 0x12250
movq %r15, %rsi
callq 0x8696
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
movq %r12, %rdi
callq 0x3270
movq %rax, %r15
leaq 0x2e71(%rip), %rsi      # 0xd1f7
movl $0x2, %edx
movq %rax, %rdi
callq 0x3270
leaq -0x48(%rbp), %rdi
movl %r14d, %esi
callq 0x9110
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x3270
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xa3ee
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3320
movq 0x7ba4(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x31b0
leaq -0x150(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa461
jmp 0xa461
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0xa453
jmp 0xa464
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa464
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0xa464
movq %rax, %rbx
movq 0x7b3d(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x31b0
leaq -0x150(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3380
nop