LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yy_get_previous_state()
static yy_state_type yy_get_previous_state (void)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    
	yy_current_state = (yy_start);

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 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 >= 122 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

// Assembly:
movl 0x20c45(%rip), %eax     # 0x282cc
movq 0x20c32(%rip), %rcx     # 0x282c0
movq 0x20c4b(%rip), %rdx     # 0x282e0
cmpq %rdx, %rcx
jae 0x7759
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x180fe(%rip), %rsi     # 0x1f7b0
leaq 0x18357(%rip), %rdi     # 0x1fa10
leaq 0x181f0(%rip), %r8      # 0x1f8b0
leaq 0x18579(%rip), %r9      # 0x1fc40
leaq 0x18442(%rip), %r10     # 0x1fb10
leaq 0x1853b(%rip), %r11     # 0x1fc10
movzbl (%rcx), %r14d
testq %r14, %r14
je 0x76eb
leaq 0x17fcb(%rip), %rbx     # 0x1f6b0
movb (%r14,%rbx), %r14b
jmp 0x76ee
movb $0x1, %r14b
movslq %eax, %r15
cmpw $0x0, (%rsi,%r15,2)
je 0x7706
movl %eax, 0x20bed(%rip)     # 0x282ec
movq %rcx, 0x20bea(%rip)     # 0x282f0
movswq (%rdi,%r15,2), %r13
movzbl %r14b, %r12d
addq %r12, %r13
movswl (%r8,%r13,2), %ebx
cmpl %ebx, %eax
je 0x7742
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x7727
movb (%r12,%r11), %r14b
movswl (%r10,%r15,2), %eax
movslq %eax, %r15
movswq (%rdi,%r15,2), %r13
movzbl %r14b, %r12d
addq %r12, %r13
cmpw (%r8,%r13,2), %r15w
jne 0x771b
movswl (%r9,%r13,2), %eax
incq %rcx
cmpq %rdx, %rcx
jne 0x76d5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yyrestart(_IO_FILE*)
void yyrestart  (FILE * 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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20b3d(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x77a6
movq 0x20b39(%rip), %rcx     # 0x282d8
cmpq $0x0, (%rax,%rcx,8)
jne 0x77ce
callq 0x7577
movq 0x20af6(%rip), %rdi     # 0x282a8
movl $0x4000, %esi           # imm = 0x4000
callq 0x7619
movq 0x20b0d(%rip), %rcx     # 0x282d0
movq 0x20b0e(%rip), %rdx     # 0x282d8
movq %rax, (%rcx,%rdx,8)
movq 0x20afb(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x77e7
movq 0x20af7(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rdi
jmp 0x77e9
xorl %edi, %edi
movq %rbx, %rsi
callq 0x783b
movq 0x20ad8(%rip), %rax     # 0x282d0
movq 0x20ad9(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rdx
movl 0x1c(%rdx), %esi
movl %esi, 0x20aec(%rip)     # 0x282f8
movq 0x10(%rdx), %rdx
movq %rdx, 0x20ac9(%rip)     # 0x282e0
movq %rdx, 0x20aa2(%rip)     # 0x282c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x20a7c(%rip)     # 0x282a8
movb (%rdx), %al
movb %al, 0x20ab4(%rip)      # 0x282e8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yy_init_buffer(yy_buffer_state*, _IO_FILE*)
static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )

{
	int oerrno = errno;
    
	yy_flush_buffer( b );

	b->yy_input_file = file;
	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 = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5040
movq %rax, %r14
movl (%rax), %r12d
movq %rbx, %rdi
callq 0x79d6
movq %r15, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x20a60(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x7882
movq 0x20a5c(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rax
jmp 0x7884
xorl %eax, %eax
cmpq %rbx, %rax
je 0x7891
movq $0x1, 0x2c(%rbx)
testq %r15, %r15
je 0x78ae
movq %r15, %rdi
callq 0x5220
movl %eax, %edi
callq 0x53c0
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
jmp 0x78b0
xorl %ecx, %ecx
movl %ecx, 0x24(%rbx)
movl %r12d, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yy_switch_to_buffer(yy_buffer_state*)
void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
{
    
	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack ();
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*(yy_c_buf_p) = (yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state(  );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	(yy_did_buffer_switch_on_eof) = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7577
movq 0x209fc(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x78e6
movq 0x209f8(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rcx
jmp 0x78e8
xorl %ecx, %ecx
cmpq %rbx, %rcx
je 0x7960
testq %rax, %rax
je 0x7924
movq 0x209df(%rip), %rcx     # 0x282d8
cmpq $0x0, (%rax,%rcx,8)
je 0x7924
movb 0x209e2(%rip), %dl      # 0x282e8
movq 0x209d3(%rip), %rsi     # 0x282e0
movb %dl, (%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x10(%rdx)
movl 0x209db(%rip), %edx     # 0x282f8
movq (%rax,%rcx,8), %rcx
movl %edx, 0x1c(%rcx)
movq 0x209ad(%rip), %rcx     # 0x282d8
movq %rbx, (%rax,%rcx,8)
movl 0x1c(%rbx), %edx
movl %edx, 0x209c0(%rip)     # 0x282f8
movq 0x10(%rbx), %rdx
movq %rdx, 0x2099d(%rip)     # 0x282e0
movq %rdx, 0x20976(%rip)     # 0x282c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x20950(%rip)     # 0x282a8
movb (%rdx), %al
movb %al, 0x20988(%rip)      # 0x282e8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yy_delete_buffer(yy_buffer_state*)
void 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 %rdi, %rdi
je 0x7998
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2094a(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x7999
movq 0x20946(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rcx
jmp 0x799b
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x79af
movq 0x20931(%rip), %rcx     # 0x282d8
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x20(%rbx)
je 0x79be
movq 0x8(%rbx), %rdi
callq 0x5280
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5280
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yy_flush_buffer(yy_buffer_state*)
void yy_flush_buffer (YY_BUFFER_STATE  b )
{
    	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state(  );
}

// Assembly:
testq %rdi, %rdi
je 0x7a60
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
movl %ecx, 0x1c(%rdi)
movq 0x8(%rdi), %rax
movb %cl, (%rax)
movq 0x8(%rdi), %rax
movb %cl, 0x1(%rax)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rdi)
movl $0x1, 0x28(%rdi)
movl %ecx, 0x38(%rdi)
movq 0x208c2(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x7a1e
movq 0x208be(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rcx
cmpq %rdi, %rcx
jne 0x7a5f
movq 0x208ae(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rdx
movl 0x1c(%rdx), %esi
movl %esi, 0x208c1(%rip)     # 0x282f8
movq 0x10(%rdx), %rdx
movq %rdx, 0x2089e(%rip)     # 0x282e0
movq %rdx, 0x20877(%rip)     # 0x282c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x20851(%rip)     # 0x282a8
movb (%rdx), %al
movb %al, 0x20889(%rip)      # 0x282e8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yypush_buffer_state(yy_buffer_state*)
void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{
    	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack();

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*(yy_c_buf_p) = (yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		(yy_buffer_stack_top)++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state(  );
	(yy_did_buffer_switch_on_eof) = 1;
}

// Assembly:
testq %rdi, %rdi
je 0x7b15
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7577
movq 0x20851(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x7ad3
movq 0x2084d(%rip), %rcx     # 0x282d8
cmpq $0x0, (%rax,%rcx,8)
je 0x7ab6
movb 0x20850(%rip), %dl      # 0x282e8
movq 0x20841(%rip), %rsi     # 0x282e0
movb %dl, (%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x10(%rdx)
movl 0x20849(%rip), %edx     # 0x282f8
movq (%rax,%rcx,8), %rcx
movl %edx, 0x1c(%rcx)
testq %rax, %rax
je 0x7ad3
movq 0x20816(%rip), %rcx     # 0x282d8
cmpq $0x0, (%rax,%rcx,8)
je 0x7ad3
incq %rcx
movq %rcx, 0x20805(%rip)     # 0x282d8
movq 0x207fe(%rip), %rcx     # 0x282d8
movq %rbx, (%rax,%rcx,8)
movl 0x1c(%rbx), %edx
movl %edx, 0x20811(%rip)     # 0x282f8
movq 0x10(%rbx), %rdx
movq %rdx, 0x207ee(%rip)     # 0x282e0
movq %rdx, 0x207c7(%rip)     # 0x282c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x207a1(%rip)     # 0x282a8
movb (%rdx), %al
movb %al, 0x207d9(%rip)      # 0x282e8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yypop_buffer_state()
void yypop_buffer_state (void)
{
    	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER );
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if ((yy_buffer_stack_top) > 0)
		--(yy_buffer_stack_top);

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state(  );
		(yy_did_buffer_switch_on_eof) = 1;
	}
}

// Assembly:
movq 0x207b3(%rip), %rax     # 0x282d0
testq %rax, %rax
je 0x7bab
pushq %rbp
movq %rsp, %rbp
movq 0x207a7(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x7baa
callq 0x7971
movq 0x2078a(%rip), %rax     # 0x282d0
movq 0x2078b(%rip), %rcx     # 0x282d8
movq $0x0, (%rax,%rcx,8)
testq %rcx, %rcx
je 0x7b64
decq %rcx
movq %rcx, 0x20774(%rip)     # 0x282d8
testq %rax, %rax
je 0x7baa
movq 0x20768(%rip), %rcx     # 0x282d8
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x7baa
movl 0x1c(%rdx), %esi
movl %esi, 0x20776(%rip)     # 0x282f8
movq 0x10(%rdx), %rdx
movq %rdx, 0x20753(%rip)     # 0x282e0
movq %rdx, 0x2072c(%rip)     # 0x282c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x20706(%rip)     # 0x282a8
movb (%rdx), %al
movb %al, 0x2073e(%rip)      # 0x282e8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yy_scan_buffer(char*, unsigned long)
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return NULL;

	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b  );

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x2, %rsi
jb 0x7bd1
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, -0x2(%rdi,%rsi)
jne 0x7bd1
cmpb $0x0, -0x1(%r15,%r14)
je 0x7be1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x52d0
testq %rax, %rax
je 0x7c2f
movq %rax, %rbx
addq $-0x2, %r14
movl %r14d, 0x18(%rax)
movq %r15, 0x8(%rax)
movq %r15, 0x10(%rax)
movl $0x0, 0x20(%rax)
xorl %eax, %eax
movq %rax, (%rbx)
movl %r14d, 0x1c(%rbx)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x24(%rbx)
movq %rax, 0x34(%rbx)
movq %rbx, %rdi
callq 0x78bf
jmp 0x7bd3
leaq 0x18281(%rip), %rdi     # 0x1feb7
callq 0x775a
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yy_scan_bytes(char const*, int)
YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n  );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n );
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %r12
leal 0x2(%r14), %eax
movslq %eax, %rbx
movq %rbx, %rdi
callq 0x52d0
testq %rax, %rax
je 0x7cbe
movq %rax, %r15
testl %r14d, %r14d
jle 0x7c94
movl %r14d, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5190
movslq %r14d, %rax
movw $0x0, (%r15,%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7bac
testq %rax, %rax
je 0x7cca
movl $0x1, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1821c(%rip), %rdi     # 0x1fee1
callq 0x775a
leaq 0x18239(%rip), %rdi     # 0x1ff0a
callq 0x775a
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/compiler.l.c
// Function: yylex_destroy()
int yylex_destroy  (void)
{
    
    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		yy_delete_buffer( YY_CURRENT_BUFFER  );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state();
	}

	/* Destroy the stack itself. */
	yyfree((yy_buffer_stack) );
	(yy_buffer_stack) = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( );

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20572(%rip), %rdi     # 0x282d0
testq %rdi, %rdi
je 0x7d98
movq 0x2056e(%rip), %rax     # 0x282d8
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x7d98
movq %rax, %rdi
callq 0x7971
movq 0x2054e(%rip), %rax     # 0x282d0
movq 0x2054f(%rip), %rcx     # 0x282d8
movq $0x0, (%rax,%rcx,8)
callq 0x7b16
jmp 0x7d57
callq 0x5280
xorl %eax, %eax
movq %rax, 0x2052a(%rip)     # 0x282d0
movl $0x1, 0x20488(%rip)     # 0x28238
movq %rax, 0x20521(%rip)     # 0x282d8
movq %rax, 0x20542(%rip)     # 0x28300
movq %rax, 0x2051b(%rip)     # 0x282e0
movb $0x0, 0x204fc(%rip)     # 0x282c8
movl $0x0, 0x204f6(%rip)     # 0x282cc
movq %rax, 0x204cb(%rip)     # 0x282a8
movq %rax, 0x204cc(%rip)     # 0x282b0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/ast/node.h
// Function: CommandList::copy(std::function<Node* (Node*)>)
virtual Node *copy(Callback replacer) {
        CommandList *cmdList = new CommandList();

        for (const auto &cmd : commands) {
            cmdList->commands.push_back(cmd->copy(replacer));
        }
        return cmdList;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movl $0x20, %edi
callq 0x51f0
leaq 0x19585(%rip), %rcx     # 0x272d0
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, -0x30(%rbp)
movq $0x0, 0x18(%rax)
movq 0x8(%r15), %r13
movq 0x10(%r15), %rbx
cmpq %rbx, %r13
je 0xddc5
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r15
leaq -0x60(%rbp), %r12
movq (%r13), %r14
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xebc4
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
callq 0x643e
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xddbc
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
addq $0x8, %r13
cmpq %rbx, %r13
jne 0xdd7a
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xddfc
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xddf4
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xec29
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/front/ast/node.h
// Function: DeclarationList::copy(std::function<Node* (Node*)>)
virtual Node *copy(Callback replacer) {
        DeclarationList *dclList = new DeclarationList();

        for (auto const &dcl : declarations) {
            dclList->declarations.push_back(static_cast<AbstractDeclaration *>(dcl->copy(replacer)));
        }

        return dclList;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movl $0x20, %edi
callq 0x51f0
leaq 0x18bfb(%rip), %rcx     # 0x275a0
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, -0x30(%rbp)
movq $0x0, 0x18(%rax)
movq 0x8(%r15), %r13
movq 0x10(%r15), %rbx
cmpq %rbx, %r13
je 0xea1f
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r15
leaq -0x60(%rbp), %r12
movq (%r13), %r14
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xebc4
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
callq 0x65b8
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xea16
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
addq $0x8, %r13
cmpq %rbx, %r13
jne 0xe9d4
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xea56
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xea4e
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xec29
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp
// Function: AbstractAssembler::prepareConstants(bool)
void AbstractAssembler::prepareConstants(bool verbose) {
    constants = new Constants(accumulatorNumber);

    for (const auto num : program.constants.constants) {
        Constant *constantPointer = constants->addConstant(num);

        if (constantPointer && verbose) {
            std::cout << constantPointer->toString() << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x30, %edi
callq 0x51f0
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x177fc
movq %r15, 0x30(%r14)
movq 0x20(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0xed0b
xorb $0x1, %bl
movq (%r15), %rsi
movq 0x30(%r14), %rdi
callq 0x178e2
testq %rax, %rax
sete %cl
orb %bl, %cl
jne 0xecfe
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1761c
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x19312(%rip), %rdi     # 0x27fc8
callq 0x5250
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xecfe
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5200
addq $0x8, %r15
cmpq %r12, %r15
jne 0xec85
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x30, %esi
movq %r15, %rdi
jmp 0xed3e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xed43
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp
// Function: AbstractAssembler::assembleConstants()
InstructionList &AbstractAssembler::assembleConstants() {
    InstructionList &list = constants->oneAndMinusOne(primaryAccumulator);

    for (const auto &constant : constants->getConstants()) {
        InstructionList &generatedCode = constant->generateConstant(constants, primaryAccumulator, secondaryAccumulator);

        list.append(generatedCode);
    }

    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x30(%rdi), %rdi
callq 0x17a9c
movq %rax, %rbx
movq 0x30(%r14), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x1698c
movq (%r15), %r12
movq 0x8(%r15), %r15
cmpq %r15, %r12
je 0xedb4
movq (%r12), %rdi
movq 0x30(%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
callq 0x16dd6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1acfc
addq $0x8, %r12
jmp 0xed89
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xedc9
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xedf1
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp
// Function: AbstractAssembler::removeUselessConstants(InstructionList&)
void AbstractAssembler::removeUselessConstants(InstructionList &instructions) {
    std::vector < Constant * > toRemove;

    for (auto const &constant : constants->getConstants()) {
        bool found = false;
        for (auto const &ins : instructions.getInstructions()) {
            if (auto addrIns = dynamic_cast<InstructionUsingAddress *>(ins)) {
                if (&addrIns->address == &constant->getAddress()) {
                    found = true;
                    break;
                }
            }
        }
        if (!found) {
            toRemove.push_back(constant);
        }
    }

    for (auto const &constant : toRemove) {
        constants->removeConstant(constant);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, -0x70(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq %rdi, -0x60(%rbp)
movq 0x30(%rdi), %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1698c
movq -0x58(%rbp), %r15
movq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq %rax, %r15
je 0xf1f8
movq -0x70(%rbp), %rdi
callq 0x1acaa
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0xf1c7
addq $0x8, %rbx
xorl %r13d, %r13d
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xf190
leaq 0x18698(%rip), %rsi     # 0x27818
leaq 0x184b1(%rip), %rdx     # 0x27638
xorl %ecx, %ecx
callq 0x5240
jmp 0xf192
xorl %eax, %eax
testq %rax, %rax
je 0xf1a8
movq 0x18(%rax), %r12
movq (%r15), %rdi
callq 0x17612
cmpq %rax, %r12
je 0xf1ac
xorl %eax, %eax
jmp 0xf1b1
movb $0x1, %r13b
movb $0x1, %al
testb %al, %al
jne 0xf1c1
leaq 0x8(%rbx), %rax
cmpq %r14, %rbx
movq %rax, %rbx
jne 0xf170
testb $0x1, %r13b
jne 0xf1ea
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0xf1de
movq (%r15), %rax
movq %rax, (%rsi)
addq $0x8, -0x38(%rbp)
jmp 0xf1ea
leaq -0x40(%rbp), %rdi
movq %r15, %rdx
callq 0x16b12
addq $0x8, %r15
cmpq -0x68(%rbp), %r15
jne 0xf154
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0xf20d
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r14
cmpq %r14, %rbx
movq -0x60(%rbp), %r15
je 0xf233
movq 0x30(%r15), %rdi
movq (%rbx), %rsi
callq 0x17a3a
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0xf21e
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xf248
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf25d
jmp 0xf262
jmp 0xf262
movq %rax, %rbx
jmp 0xf27a
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0xf27a
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xf28f
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp
// Function: AbstractAssembler::resolve(AbstractValue&)
Resolution *AbstractAssembler::resolve(AbstractValue &value) {
    try { // NUMBER VALUE - 0
        NumberValue &numberValue = dynamic_cast<NumberValue &>(value);
        ResolvableAddress &address = constants->getConstant(numberValue.value)->getAddress();
        return new Resolution(
                *new InstructionList(),
                address,
                CONSTANT,
                false,
                0
        );
    } catch (std::bad_cast _) {
        try {
            IdentifierValue &identifierValue = dynamic_cast<IdentifierValue &>(value);
            return resolve(identifierValue.identifier);
        } catch (std::bad_cast __) {
            throw "Value resolution error";
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16ada(%rip), %rsi     # 0x275d8
leaq 0x16683(%rip), %rdx     # 0x27188
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
je 0x10b83
movq 0x30(%rbx), %rdi
movq 0x8(%rax), %rsi
callq 0x17c56
movq %rax, %rdi
callq 0x17612
movq %rax, %r15
movl $0x28, %edi
callq 0x51f0
movq %rax, %r12
movl $0x20, %edi
callq 0x51f0
movq %rax, %r13
movq %rax, %rdi
callq 0x1ac28
movw $0x1, (%r12)
movq $0x0, 0x8(%r12)
movq %r13, 0x10(%r12)
movq %r15, 0x18(%r12)
movl $0x0, 0x20(%r12)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5410
movq %rdx, %r15
movq %rax, -0x30(%rbp)
movl $0x20, %esi
movq %r13, %rdi
callq 0x5200
jmp 0x10ba5
movq %rdx, %r15
movq %rax, -0x30(%rbp)
movl $0x28, %esi
movq %r12, %rdi
callq 0x5200
jmp 0x10bbd
jmp 0x10bb6
movq %rdx, %r15
movq %rax, -0x30(%rbp)
cmpl $0x1, %r15d
jne 0x10c9f
movl $0x1, %r13d
movq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x52b0
movq 0x173c8(%rip), %r15     # 0x27fa8
addq $0x10, %r15
movq %r15, -0x38(%rbp)
movq %r12, %rdi
callq 0x50f0
leaq 0x169e1(%rip), %rsi     # 0x275d8
leaq 0x165d2(%rip), %rdx     # 0x271d0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
je 0x10c34
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x100b0
movq %rax, %r12
leaq -0x38(%rbp), %rdi
callq 0x53f0
callq 0x5350
jmp 0x10b71
callq 0x5410
movq %rax, -0x30(%rbp)
cmpl %r13d, %edx
jne 0x10c91
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x52b0
movq %r15, -0x40(%rbp)
movq %rbx, %rdi
callq 0x50f0
movl $0x8, %edi
callq 0x5120
leaq 0xf934(%rip), %rcx      # 0x2059f
movq %rcx, (%rax)
movq 0x1732b(%rip), %rsi     # 0x27fa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x53a0
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x53f0
callq 0x5350
leaq -0x38(%rbp), %rdi
callq 0x53f0
callq 0x5350
movq -0x30(%rbp), %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xec29
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp
// Function: AbstractAssembler::assemble(bool)
InstructionList &AbstractAssembler::assemble(bool verbose) {
    getVariablesFromDeclarations(verbose);
    prepareConstants(verbose);
    SimpleResolution *programCodeResolution = assembleCommands(program.commands);
    removeUselessConstants(programCodeResolution->instructions);
    InstructionList &instructions = assembleConstants();
    instructions.append(programCodeResolution->instructions);
    instructions.seal(true);
    return instructions;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0xedfa
movq %r14, %rdi
movl %ebx, %esi
callq 0xec38
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xf298
movq 0x8(%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf106
movq %r14, %rdi
callq 0xed4c
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1acfc
movq %r14, %rdi
movl $0x1, %esi
callq 0x1ad2c
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/Constant.cpp
// Function: lltoa[abi:cxx11](unsigned long long, int)
std::string lltoa(unsigned long long val, int base) {
    static char buf[64] = {0};

    int i = 62;

    if (val == 0) return std::string("0");

    for (; val && i; --i, val /= base) {
        buf[i] = "0123456789abcdef"[val % base];
    }

    return std::string(&buf[i + 1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x16c9c
movslq %edx, %rcx
leaq 0x11732(%rip), %r14     # 0x2837f
movq $-0x3d, %r8
leaq 0x99f0(%rip), %rdi      # 0x2064b
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movb (%rdx,%rdi), %dl
movb %dl, -0x1(%r14)
decq %r14
cmpq %rcx, %rsi
jb 0x16c81
leaq 0x1(%r8), %rdx
movq %rax, %rsi
testq %r8, %r8
movq %rdx, %r8
jne 0x16c5b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x5100
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x16cb4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x999f(%rip), %rsi      # 0x20649
leaq 0x9999(%rip), %rdx      # 0x2064a
movq %rbx, %rdi
callq 0x7df2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/Constant.cpp
// Function: calculatePrefix(Constant*, Constant*)
long long calculatePrefix(Constant *a, Constant *b) {
    long long prefixLength = 0;
    while (a->binaryString[prefixLength] && b->binaryString[prefixLength] && a->binaryString[prefixLength] == b->binaryString[prefixLength]) {
        prefixLength++;
    }
    return prefixLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rcx
movb (%rcx), %dl
testb %dl, %dl
je 0x16ce7
movq 0x18(%rsi), %rsi
xorl %eax, %eax
cmpb (%rsi,%rax), %dl
jne 0x16ce9
movb 0x1(%rcx,%rax), %dl
incq %rax
testb %dl, %dl
jne 0x16cd5
jmp 0x16ce9
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/Constant.cpp
// Function: Constant::Constant(long long, ResolvableAddress&)
Constant::Constant(long long value, ResolvableAddress &address) : value(value), address(address) {
    long long valCopy = llabs(value);
    binaryString = std::string(lltoa(valCopy, 2));

    generationCost = 0;
    for (long long i = 0; i < binaryString.size(); i++) {
        if (binaryString[i] == '1') generationCost++;
        if (i != binaryString.size() - 1) generationCost += 5;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdx, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %rsi, %rax
negq %rax
cmovnsq %rax, %rsi
leaq -0x38(%rbp), %rdi
movl $0x2, %edx
callq 0x16c34
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x52a0
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x16d5a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x5200
movq $0x0, 0x10(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x16dad
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
leaq -0x1(%rax), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
cmpb $0x31, (%rdx,%rdi)
sete %r8b
leaq (%rcx,%r8), %r9
cmpq %rdi, %rsi
setne %r10b
leaq 0x5(%rcx,%r8), %rcx
cmoveq %r9, %rcx
orb %r10b, %r8b
cmpb $0x1, %r8b
jne 0x16da5
movq %rcx, 0x10(%rbx)
incq %rdi
cmpq %rdi, %rax
jne 0x16d79
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x16dce
movq (%r15), %rsi
incq %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp
// Function: Constants::addConstant(long long)
Constant *Constants::addConstant(long long value) {
    if (value == 1 || value == -1) return nullptr;

    for (const auto &constant : constants) {
        if (constant->value == value) {
            return nullptr;
        }
    }

    ResolvableAddress &address = *new ResolvableAddress(currentAddress++); // assign a new address to it
    Constant *constant = new Constant(value, address); // create it with new value

    if (constants.size() == 0) {
        constants.push_back(constant);
    } else {
        for (long long i = 0; i < constants.size(); i++) {
            if (llabs(constants[i]->value) > llabs(value)) {
                constants.insert(constants.begin() + i, constant);
                break;
            }
            if (i == constants.size() - 1) {
                constants.push_back(constant);
                break;
            }
        }
    }
    return constant;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
cmpq $-0x1, %rsi
je 0x17a15
movq %rsi, %r14
cmpq $0x1, %rsi
je 0x17a15
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
sete %dl
je 0x17947
movq (%rax), %rsi
cmpq %r14, 0x8(%rsi)
je 0x1793f
addq $0x8, %rax
cmpq %rcx, %rax
sete %dl
je 0x17947
movq (%rax), %rsi
addq $0x8, %rax
cmpq %r14, 0x8(%rsi)
jne 0x1792a
testb %dl, %dl
je 0x179f6
movl $0x10, %edi
callq 0x51f0
movq %rax, %r12
movq 0x28(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x28(%rbx)
movq $0x0, (%r12)
movq %rax, 0x8(%r12)
movl $0x38, %edi
callq 0x51f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x16cec
leaq 0x10(%rbx), %rdi
movq %r15, -0x28(%rbp)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
je 0x179e6
sarq $0x3, %rcx
movq %r14, %rdx
negq %rdx
cmovsq %r14, %rdx
leaq -0x1(%rcx), %r8
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %r9d, %r9d
movq (%rax), %r10
movq 0x8(%r10), %r10
movq %r10, %r11
negq %r11
cmovsq %r10, %r11
cmpq %rdx, %r11
ja 0x17a05
cmpq %r9, %r8
je 0x179e6
incq %r9
addq $0x8, %rax
cmpq %r9, %rcx
jne 0x179bd
jmp 0x17a11
cmpq 0x20(%rbx), %rsi
je 0x179fa
movq %r15, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x17a11
xorl %eax, %eax
jmp 0x17a15
leaq -0x28(%rbp), %rdx
callq 0x16b12
jmp 0x17a11
leaq -0x28(%rbp), %rdx
movq %rax, %rsi
callq 0x17c9a
movq -0x28(%rbp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp
// Function: Constants::removeConstant(Constant*)
void Constants::removeConstant(Constant *constant) {
    for (long long i = 0; i < constants.size(); i++) {
        if (constants[i] == constant) {
            constants.erase(constants.begin() + i);
            break;
        }
    }
}

// Assembly:
movq %rsi, %rax
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
je 0x17a9b
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, %rdi
sarq $0x3, %rdi
cmpq $0x1, %rdi
adcq $0x0, %rdi
addq $0x8, %rsi
addq $-0x8, %rdx
cmpq %rax, -0x8(%rsi)
je 0x17a82
addq $0x8, %rsi
addq $-0x8, %rdx
decq %rdi
jne 0x17a6d
jmp 0x17a95
cmpq %rcx, %rsi
je 0x17a90
leaq -0x8(%rsi), %rdi
callq 0x5340
addq $-0x8, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp
// Function: Constants::oneAndMinusOne(ResolvableAddress&)
InstructionList &Constants::oneAndMinusOne(ResolvableAddress &primaryAccumulator) {
    InstructionList &list = *new InstructionList();
    list.append(new Sub(primaryAccumulator))
            .append(new Inc())
            .append(new Store(one->getAddress()))
            .append(new Dec())
            .append(new Dec())
            .append(new Store(minusOne->getAddress()));

    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movl $0x20, %edi
callq 0x51f0
movq %rax, %r14
movq %rax, %rdi
callq 0x1ac28
movl $0x20, %edi
callq 0x51f0
movq $-0x1, %r13
movq %r13, 0x8(%rax)
xorl %ebx, %ebx
movb %bl, 0x10(%rax)
movq %r15, 0x18(%rax)
leaq 0xff1a(%rip), %rcx      # 0x27a08
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r14, -0x38(%rbp)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1adbe
movq %rax, %r15
movl $0x18, %edi
callq 0x51f0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r13, 0x8(%rax)
movb %bl, 0x10(%rax)
leaq 0x101ab(%rip), %rcx     # 0x27cd8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1adbe
movq %rax, %r12
movl $0x20, %edi
callq 0x51f0
movq %rax, %r15
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x17612
movq %r13, 0x8(%r15)
xorl %ebx, %ebx
movb %bl, 0x10(%r15)
movq %rax, 0x18(%r15)
leaq 0xfd58(%rip), %r14      # 0x278c8
addq $0x10, %r14
movq %r14, (%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1adbe
movq %rax, %r15
movl $0x18, %edi
callq 0x51f0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq %r13, 0x8(%rax)
movb %bl, 0x10(%rax)
leaq 0x10181(%rip), %r12     # 0x27d28
addq $0x10, %r12
movq %r12, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1adbe
movq %rax, %r15
movl $0x18, %edi
callq 0x51f0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq %r13, 0x8(%rax)
movb %bl, 0x10(%rax)
movq %r12, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1adbe
movq %rax, %r12
movl $0x20, %edi
callq 0x51f0
movq %rax, %r15
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17612
movq $-0x1, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %r14, (%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1adbe
movq -0x38(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17c36
movq %rax, %r14
movq %r15, %rdi
jmp 0x17c44
movq %r14, %rdi
movq %rax, %r14
movl $0x20, %esi
callq 0x5200
movq %r14, %rdi
callq 0x53d0
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp
// Function: Constants::getConstant(long long)
Constant *Constants::getConstant(long long value) {
    if (value == 1) return one;
    else if (value == -1) return minusOne;
    else {
        for (const auto &constant : constants) {
            if (constant->value == value) return constant;
        }
        return nullptr;
    }
}

// Assembly:
cmpq $-0x1, %rsi
je 0x17c66
cmpq $0x1, %rsi
jne 0x17c6b
movq (%rdi), %rax
retq
movq 0x8(%rdi), %rax
retq
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
je 0x17c96
pushq %rbp
movq %rsp, %rbp
movq (%rcx), %rdi
cmpq %rsi, 0x8(%rdi)
cmoveq %rdi, %rax
je 0x17c94
addq $0x8, %rcx
cmpq %rdx, %rcx
jne 0x17c7c
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/ScopedVariables.cpp
// Function: ScopedVariables::pushVariableScope(Variable*)
void ScopedVariables::pushVariableScope(Variable *variable) {
    if (!dynamic_cast<TemporaryVariable *>(variable)) {
        for (const auto &var : variables) {
            if (var->name == variable->name) throw "Redeclaration of variable " + var->name;
        }
    }

    variable->getAddress().setAddress(currentAddress);
    variables.push_back(variable);
    currentAddress += variable->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
testq %rsi, %rsi
je 0x17d7f
leaq 0xf8f8(%rip), %rsi      # 0x27660
leaq 0xfa09(%rip), %rdx      # 0x27778
movq -0x30(%rbp), %rdi
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
jne 0x17dc5
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x17dc5
movq -0x30(%rbp), %rax
movq 0x18(%rax), %r13
movq 0x8(%r13), %r14
movq (%r15), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdx
cmpq %r14, %rdx
jne 0x17dbc
testq %rdx, %rdx
je 0x17e19
movq (%r13), %rsi
movq (%rax), %rdi
callq 0x5210
testl %eax, %eax
je 0x17e19
addq $0x8, %r15
cmpq %r12, %r15
jne 0x17d97
movq -0x30(%rbp), %rdi
callq 0x180e8
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x17d1c
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x17df2
movq -0x38(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x17dfe
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x17fa8
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
addq %rax, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x5120
movq %rax, %rbx
movq (%r15), %rax
movq 0x18(%rax), %rdx
leaq 0x8834(%rip), %rsi      # 0x20668
movq %rbx, %rdi
callq 0x16793
leaq 0xf80d(%rip), %rsi      # 0x27650
movq 0x1014e(%rip), %rdx     # 0x27f98
movq %rbx, %rdi
callq 0x53a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/ScopedVariables.cpp
// Function: ScopedVariables::popVariableScope(long long)
void ScopedVariables::popVariableScope(long long times) {
    while (times-- > 0) {
        Variable *v = variables.back();

        currentAddress -= variables.back()->size;
        variables.pop_back();
    }
}

// Assembly:
testq %rsi, %rsi
jle 0x17e9b
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rax
addq $-0x8, %rcx
incq %rsi
movq (%rcx), %rdx
subq 0x20(%rdx), %rax
movq %rcx, 0x8(%rdi)
addq $-0x8, %rcx
decq %rsi
cmpq $0x1, %rsi
jg 0x17e7e
movq %rax, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/abstract_assembler/ScopedVariables.cpp
// Function: ScopedVariables::resolveVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Variable *ScopedVariables::resolveVariable(std::string &name) {
    for (const auto &variable : variables) {
        if (dynamic_cast<TemporaryVariable *>(variable) == nullptr) {
            if (variable->name == name) return variable;
        }
    }
    throw "No variable in current scope: " + name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r12
movq 0x8(%rdi), %r13
cmpq %r13, %r12
sete %r15b
movq %rsi, -0x30(%rbp)
je 0x17f46
movq (%rsi), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rsi), %rax
movq %rax, -0x40(%rbp)
movq (%r12), %rbx
testq %rbx, %rbx
je 0x17efc
movq %rbx, %rdi
leaq 0xf779(%rip), %rsi      # 0x27660
leaq 0xf88a(%rip), %rdx      # 0x27778
xorl %ecx, %ecx
callq 0x5240
movb $0x1, %cl
testq %rax, %rax
jne 0x17f33
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdx
cmpq -0x40(%rbp), %rdx
jne 0x17f22
testq %rdx, %rdx
je 0x17f26
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x5210
testl %eax, %eax
sete %al
jmp 0x17f28
xorl %eax, %eax
jmp 0x17f28
movb $0x1, %al
movl %eax, %ecx
xorb $0x1, %cl
testb %al, %al
cmovneq %rbx, %r14
testb %cl, %cl
je 0x17f46
addq $0x8, %r12
cmpq %r13, %r12
sete %r15b
jne 0x17ed4
jmp 0x17f46
testb $0x1, %r15b
jne 0x17f5e
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x8711(%rip), %rsi      # 0x20683
movq %rax, %rdi
movq -0x30(%rbp), %rdx
callq 0x16793
leaq 0xf6cb(%rip), %rsi      # 0x27650
movq 0x1000c(%rip), %rdx     # 0x27f98
movq %rbx, %rdi
callq 0x53a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp
// Function: ASTOptimizer::traverse(CommandList&, std::function<Node* (Node*)>)
bool ASTOptimizer::traverse(CommandList &commandList, Callback callback) {
    bool changed = false;
    for (int i = 0; i < commandList.commands.size(); i++) {
        Node *newNode = callback(commandList.commands[i]);
        if (newNode != commandList.commands[i]) {
            commandList.commands[i] = newNode;
            changed = true;
        }
        traverse(commandList.commands[i], callback);
    }
    return changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x38(%rbp)
movq 0x8(%rsi), %rax
cmpq %rax, 0x10(%rsi)
je 0x18de0
movq %rdx, %rbx
movq %rsi, %r14
xorl %r15d, %r15d
leaq -0x60(%rbp), %r13
movq $0x0, -0x30(%rbp)
movq (%rax,%r15,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x10(%rbx)
je 0x18df3
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
callq *0x18(%rbx)
movq 0x8(%r14), %rcx
cmpq (%rcx,%r15,8), %rax
je 0x18d8b
movq %rax, (%rcx,%r15,8)
movb $0x1, %al
movq %rax, -0x30(%rbp)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %r12
movq %r13, %rdi
movq %rbx, %rsi
callq 0xebc4
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x18e24
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x18dc3
movq %r13, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq *%rax
incq %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x18d5a
movq -0x30(%rbp), %rax
jmp 0x18de2
xorl %eax, %eax
andb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x50e0
jmp 0x18e1c
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x18e14
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xec29