LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5030
movq %rax, %r14
movl (%rax), %r12d
movq %rbx, %rdi
callq 0x75a2
movq %r15, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x18e50(%rip), %rax     # 0x202c0
testq %rax, %rax
je 0x7482
movq 0x18e4c(%rip), %rcx     # 0x202c8
movq (%rax,%rcx,8), %rax
jmp 0x7484
xorl %eax, %eax
cmpq %rbx, %rax
je 0x7491
movq $0x1, 0x2c(%rbx)
testq %r15, %r15
je 0x74ae
movq %r15, %rdi
callq 0x51e0
movl %eax, %edi
callq 0x5380
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
jmp 0x74b0
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_O2/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 0x71a2
movq 0x18dec(%rip), %rax     # 0x202c0
testq %rax, %rax
je 0x7514
movq 0x18de8(%rip), %rcx     # 0x202c8
movq (%rax,%rcx,8), %rdx
cmpq %rbx, %rdx
je 0x752f
testq %rdx, %rdx
je 0x7520
movb 0x18de4(%rip), %dl      # 0x202d8
movq 0x18dd5(%rip), %rsi     # 0x202d0
movb %dl, (%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x10(%rdx)
movl 0x18ddd(%rip), %edx     # 0x202e8
movq (%rax,%rcx,8), %rsi
movl %edx, 0x1c(%rsi)
jmp 0x7520
testq %rbx, %rbx
je 0x752f
movq 0x18da8(%rip), %rcx     # 0x202c8
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x72a8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7567
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18d6b(%rip), %rax     # 0x202c0
testq %rax, %rax
je 0x7568
movq 0x18d67(%rip), %rcx     # 0x202c8
movq (%rax,%rcx,8), %rcx
jmp 0x756a
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x757b
movq 0x18d52(%rip), %rcx     # 0x202c8
andq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x20(%rbx)
je 0x758a
movq 0x8(%rbx), %rdi
callq 0x5220
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5220
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x75ed
andl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rcx
xorl %eax, %eax
movb %al, (%rcx)
movq 0x8(%rdi), %rcx
movb %al, 0x1(%rcx)
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movl $0x1, 0x28(%rdi)
andl $0x0, 0x38(%rdi)
movq 0x18ce8(%rip), %rcx     # 0x202c0
testq %rcx, %rcx
je 0x75e8
movq 0x18ce4(%rip), %rax     # 0x202c8
movq (%rcx,%rax,8), %rax
cmpq %rdi, %rax
je 0x75ef
popq %rbp
retq
popq %rbp
jmp 0x72a8
// File: /workspace/github_cpp_makefile_star2_O2/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 0x765f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x71a2
movq 0x18cb1(%rip), %rax     # 0x202c0
movq 0x18cb2(%rip), %rcx     # 0x202c8
testq %rax, %rax
je 0x7650
cmpq $0x0, (%rax,%rcx,8)
je 0x7650
movb 0x18cb0(%rip), %dl      # 0x202d8
movq 0x18ca1(%rip), %rsi     # 0x202d0
movb %dl, (%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x10(%rdx)
movl 0x18ca9(%rip), %edx     # 0x202e8
movq (%rax,%rcx,8), %rsi
movl %edx, 0x1c(%rsi)
incq %rcx
movq %rcx, 0x18c78(%rip)     # 0x202c8
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x72a8
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq 0x18c55(%rip), %rax     # 0x202c0
testq %rax, %rax
je 0x76b6
movq 0x18c51(%rip), %rcx     # 0x202c8
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x76b6
callq 0x7540
movq 0x18c34(%rip), %rax     # 0x202c0
movq 0x18c35(%rip), %rcx     # 0x202c8
andq $0x0, (%rax,%rcx,8)
testq %rcx, %rcx
je 0x76b6
leaq -0x1(%rcx), %rdx
movq %rdx, 0x18c20(%rip)     # 0x202c8
cmpq $0x0, -0x8(%rax,%rcx,8)
je 0x76b6
popq %rbp
jmp 0x72a8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x76dd
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, -0x2(%rdi,%rsi)
jne 0x76dd
cmpb $0x0, -0x1(%r15,%r14)
je 0x76ed
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x5280
testq %rax, %rax
je 0x7736
movq %rax, %rbx
addq $-0x2, %r14
movl %r14d, 0x18(%rax)
movq %r15, 0x8(%rax)
movq %r15, 0x10(%rax)
andl $0x0, 0x20(%rax)
andq $0x0, (%rax)
movl %r14d, 0x1c(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x24(%rbx)
andq $0x0, 0x34(%rbx)
movq %rbx, %rdi
callq 0x74bf
jmp 0x76df
leaq 0x1072a(%rip), %rdi     # 0x17e67
callq 0x73b1
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
leal 0x2(%r14), %eax
movslq %eax, %rbx
movq %rbx, %rdi
callq 0x5280
testq %rax, %rax
je 0x77ce
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %edx
cmovgl %r14d, %edx
cmpq %rcx, %rdx
je 0x77a4
movb (%r15,%rcx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x7792
movslq %r14d, %rcx
andw $0x0, (%rax,%rcx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x76b8
testq %rax, %rax
je 0x77da
movl $0x1, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x106bc(%rip), %rdi     # 0x17e91
callq 0x73b1
leaq 0x106d9(%rip), %rdi     # 0x17eba
callq 0x73b1
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18a52(%rip), %rdi     # 0x202c0
testq %rdi, %rdi
je 0x78a5
movq 0x18a4e(%rip), %rax     # 0x202c8
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x78a5
movq %rax, %rdi
callq 0x7540
movq 0x18a2e(%rip), %rax     # 0x202c0
movq 0x18a2f(%rip), %rcx     # 0x202c8
andq $0x0, (%rax,%rcx,8)
callq 0x7660
jmp 0x7867
callq 0x5220
andq $0x0, 0x18a0e(%rip)     # 0x202c0
andq $0x0, 0x18a0e(%rip)     # 0x202c8
andq $0x0, 0x18a2e(%rip)     # 0x202f0
andq $0x0, 0x18a06(%rip)     # 0x202d0
movl $0x1, 0x1894c(%rip)     # 0x20220
andl $0x0, 0x189e1(%rip)     # 0x202bc
movb $0x0, 0x189d6(%rip)     # 0x202b8
andq $0x0, 0x189ae(%rip)     # 0x20298
andq $0x0, 0x189ae(%rip)     # 0x202a0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Bartor[P]kompilator/front/ast/node.cpp
// Function: CommandList::toString[abi:cxx11](int)
std::string CommandList::toString(int indentation) {
    std::string s = indent(indentation) + ("CommandList<\n");
    for (int i = 0; i < commands.size(); i++) {
        s += commands[i]->toString(indentation + 1);
    }
    s += indent(indentation) + ">\n";
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x79a0
leaq 0xfc49(%rip), %rdx      # 0x1804c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9715
movq %r12, %rdi
callq 0x5418
movq %r14, -0x30(%rbp)
leal 0x1(%r14), %r13d
xorl %r14d, %r14d
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x845c
movq (%rax,%r14,8), %rsi
movq (%rsi), %rax
movq %r12, %rdi
movl %r13d, %edx
callq *(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5400
movq %r12, %rdi
callq 0x5418
incq %r14
jmp 0x8421
leaq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rdx
callq 0x79a0
leaq 0xfb76(%rip), %rdx      # 0x17fe6
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9715
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x5400
leaq -0x50(%rbp), %rdi
callq 0x5418
leaq -0x70(%rbp), %rdi
callq 0x5418
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x5418
jmp 0x84be
movq %rax, %r14
leaq -0x70(%rbp), %rdi
jmp 0x84d6
jmp 0x84dd
movq %rax, %r14
leaq -0x50(%rbp), %rdi
jmp 0x84e3
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x5418
jmp 0x84e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5418
movq %r14, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/Bartor[P]kompilator/front/ast/node.cpp
// Function: DeclarationList::toString[abi:cxx11](int)
std::string DeclarationList::toString(int indentation) {
    std::string s = indent(indentation) + ("DeclarationList<\n");
    for (const auto &declaration : declarations) s += declaration->toString(indentation + 1);
    s += indent(indentation) + ">\n";
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rdx, -0x38(%rbp)
callq 0x79a0
leaq 0xee96(%rip), %rdx      # 0x18096
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9715
movq %r15, %rdi
callq 0x5418
movq 0x8(%r12), %r13
movq 0x10(%r12), %r14
movq -0x38(%rbp), %rbx
leal 0x1(%rbx), %r12d
cmpq %r14, %r13
je 0x9257
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movl %r12d, %edx
callq *(%rax)
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x5400
movq %r15, %rdi
callq 0x5418
addq $0x8, %r13
jmp 0x9229
leaq -0x78(%rbp), %rdi
movl %ebx, %edx
callq 0x79a0
leaq 0xed7d(%rip), %rdx      # 0x17fe6
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq -0x30(%rbp), %rbx
callq 0x9715
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x5400
leaq -0x58(%rbp), %rdi
callq 0x5418
leaq -0x78(%rbp), %rdi
callq 0x5418
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x5418
jmp 0x92bb
movq %rax, %r14
leaq -0x78(%rbp), %rdi
jmp 0x92d8
jmp 0x92cc
movq %rax, %r14
leaq -0x58(%rbp), %rdi
jmp 0x92e1
movq %rax, %r14
jmp 0x92dd
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x5418
movq -0x30(%rbp), %rdi
callq 0x5418
movq %r14, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
pushq $0x20
popq %rdi
callq 0x51c0
leaq 0x1559d(%rip), %rcx     # 0x1f310
movq %rcx, (%rax)
leaq 0x8(%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, -0x30(%rbp)
andq $0x0, 0x18(%rax)
movq 0x8(%r12), %r13
movq 0x10(%r12), %rbx
leaq -0x60(%rbp), %r12
cmpq %rbx, %r13
je 0x9dd7
movq (%r13), %r14
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xa87a
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
callq 0x6102
movq %r12, %rdi
callq 0xa8c8
addq $0x8, %r13
jmp 0x9d98
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa8c8
movq %rbx, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
pushq $0x20
popq %rdi
callq 0x51c0
leaq 0x14fad(%rip), %rcx     # 0x1f5e0
movq %rcx, (%rax)
leaq 0x8(%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, -0x30(%rbp)
andq $0x0, 0x18(%rax)
movq 0x8(%r12), %r13
movq 0x10(%r12), %rbx
leaq -0x60(%rbp), %r12
cmpq %rbx, %r13
je 0xa697
movq (%r13), %r14
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xa87a
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
callq 0x62bc
movq %r12, %rdi
callq 0xa8c8
addq $0x8, %r13
jmp 0xa658
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa8c8
movq %rbx, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x51c0
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x12584
movq %r15, 0x30(%r14)
movq 0x20(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax), %r13
movq 0x8(%rax), %r12
xorb $0x1, %bl
leaq -0x48(%rbp), %r15
cmpq %r12, %r13
je 0xa9ce
movq (%r13), %rsi
movq 0x30(%r14), %rdi
callq 0x12646
testq %rax, %rax
sete %cl
orb %bl, %cl
jne 0xa9c8
movq %r15, %rdi
movq %rax, %rsi
callq 0x12500
movq 0x15618(%rip), %rdi     # 0x1ffc8
movq %r15, %rsi
callq 0x5190
movq %rax, %rdi
callq 0x5100
movq %r15, %rdi
callq 0x5418
addq $0x8, %r13
jmp 0xa982
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x51d0
jmp 0xa9f9
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x5418
movq %rbx, %rdi
callq 0x5390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq 0x8(%rdi), %rsi
movq 0x30(%rdi), %rdi
callq 0x12794
movq %rax, %r14
movq 0x30(%rbx), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x1188c
movq (%r15), %r12
movq 0x8(%r15), %r15
cmpq %r15, %r12
je 0xaa6a
movq (%r12), %rdi
movq 0x30(%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
callq 0x11cfa
movq %r14, %rdi
movq %rax, %rsi
callq 0x14dee
addq $0x8, %r12
jmp 0xaa3f
leaq -0x38(%rbp), %rdi
callq 0x118e4
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x118e4
movq %rbx, %rdi
callq 0x5390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x50(%rbp)
andq $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movq 0x30(%rdi), %rsi
addq $0x10, %rsi
leaq -0x70(%rbp), %rdi
callq 0x1188c
movq -0x70(%rbp), %r15
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x1495b(%rip), %r12     # 0x1f6a0
cmpq -0x58(%rbp), %r15
je 0xada7
movq -0x50(%rbp), %rdi
callq 0x14d9e
movq (%rax), %r14
movq 0x8(%rax), %rbx
cmpq %rbx, %r14
je 0xad95
movq (%r14), %rdi
testq %rdi, %rdi
je 0xad8f
leaq 0x14ab1(%rip), %rsi     # 0x1f820
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x51f0
testq %rax, %rax
je 0xad8f
movq 0x18(%rax), %r13
movq (%r15), %rdi
callq 0x124f6
cmpq %rax, %r13
je 0xada1
addq $0x8, %r14
jmp 0xad5b
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x117f2
addq $0x8, %r15
jmp 0xad45
leaq -0x70(%rbp), %rdi
callq 0x118e4
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r14
cmpq %r14, %rbx
je 0xadd3
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rbx), %rsi
callq 0x1275e
addq $0x8, %rbx
jmp 0xadb8
leaq -0x40(%rbp), %rdi
callq 0x118e4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xadef
jmp 0xadf6
movq %rax, %rbx
jmp 0xae02
jmp 0xadf6
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x118e4
leaq -0x40(%rbp), %rdi
callq 0x118e4
movq %rbx, %rdi
callq 0x5390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x133e2(%rip), %rsi     # 0x1f640
leaq 0x12f63(%rip), %rdx     # 0x1f1c8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x51f0
testq %rax, %rax
je 0xc2d5
movq 0x30(%rbx), %rdi
movq 0x8(%rax), %rsi
callq 0x12924
movq %rax, %rdi
callq 0x124f6
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x51c0
movq %rax, %r13
pushq $0x20
popq %rdi
callq 0x51c0
movq %rax, %r12
movq %rax, %rdi
callq 0x14d30
movw $0x1, (%r13)
andq $0x0, 0x8(%r13)
movq %r12, 0x10(%r13)
movq %r15, 0x18(%r13)
andl $0x0, 0x20(%r13)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x53d0
movq %rdx, -0x30(%rbp)
movq %rax, %r15
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x51d0
jmp 0xc2f5
movq %rdx, -0x30(%rbp)
movq %rax, %r15
pushq $0x28
popq %rsi
movq %r13, %rdi
callq 0x51d0
jmp 0xc30b
jmp 0xc304
movq %rdx, -0x30(%rbp)
movq %rax, %r15
cmpl $0x1, -0x30(%rbp)
jne 0xc3d9
movq %r15, %rdi
callq 0x5250
movq 0x13c8c(%rip), %r12     # 0x1ffb0
addq $0x10, %r12
movq %r12, -0x38(%rbp)
movq %r15, %rdi
callq 0x50d0
leaq 0x13305(%rip), %rsi     # 0x1f640
leaq 0x12ece(%rip), %rdx     # 0x1f210
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x51f0
testq %rax, %rax
je 0xc376
movq 0x8(%rax), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xbb48
movq %rax, %r13
leaq -0x38(%rbp), %rdi
callq 0x53b0
callq 0x5320
jmp 0xc2c3
callq 0x53d0
movq %rax, %r15
cmpl -0x30(%rbp), %edx
jne 0xc3cb
movq %r15, %rdi
callq 0x5250
movq %r12, -0x40(%rbp)
movq %r15, %rdi
callq 0x50d0
pushq $0x8
popq %rdi
callq 0x5110
leaq 0xc1e9(%rip), %rcx      # 0x1858f
movq %rcx, (%rax)
movq 0x13bf8(%rip), %rsi     # 0x1ffa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5360
movq %rax, %r15
leaq -0x40(%rbp), %rdi
callq 0x53b0
callq 0x5320
leaq -0x38(%rbp), %rdi
callq 0x53b0
callq 0x5320
movq %r15, %rdi
callq 0x5390
movq %rax, %rdi
callq 0xa8e7
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xaa98
movq %r14, %rdi
movl %ebx, %esi
callq 0xa93c
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xae14
movq 0x8(%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xacfc
movq %r14, %rdi
callq 0xaa02
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x14dee
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x14e1e
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x11bf9
movq %rsi, %rax
movslq %edx, %rcx
leaq 0xe7a4(%rip), %rsi      # 0x2036f
pushq $-0x3e
popq %rdi
leaq 0x6a66(%rip), %r8       # 0x1863b
testq %rax, %rax
je 0x11bf3
testq %rdi, %rdi
je 0x11bf3
xorl %edx, %edx
divq %rcx
movb (%rdx,%r8), %dl
movb %dl, -0x1(%rsi)
decq %rsi
incq %rdi
jmp 0x11bd5
leaq -0x9(%rbp), %rdx
jmp 0x11c04
leaq 0x6a39(%rip), %rsi      # 0x18639
leaq -0xa(%rbp), %rdx
movq %rbx, %rdi
callq 0x11620
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
movb (%rcx,%rax), %dl
testb %dl, %dl
je 0x11c35
movq 0x18(%rsi), %rdi
cmpb (%rdi,%rax), %dl
jne 0x11c35
incq %rax
jmp 0x11c20
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %rsi, %rax
negq %rax
cmovnsq %rax, %rsi
leaq -0x38(%rbp), %rdi
pushq $0x2
popq %rdx
callq 0x11bb0
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5240
movq %r15, %rdi
callq 0x5418
andq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
leaq -0x1(%rcx), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x11cdc
xorl %r8d, %r8d
cmpb $0x31, (%rax,%rdi)
sete %r8b
leaq (%rsi,%r8), %r9
cmpq %rdi, %rdx
setne %r10b
leaq 0x5(%rsi,%r8), %rsi
cmoveq %r9, %rsi
orb %r10b, %r8b
cmpb $0x1, %r8b
jne 0x11cd7
movq %rsi, 0x10(%rbx)
incq %rdi
jmp 0x11ca6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x5418
movq %rbx, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
cmpq $-0x1, %rsi
je 0x12739
movq %rsi, %r14
cmpq $0x1, %rsi
je 0x12739
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x12695
movq (%rcx), %rsi
addq $0x8, %rcx
cmpq %r14, 0x8(%rsi)
jne 0x1267e
jmp 0x12739
pushq $0x10
popq %rdi
callq 0x51c0
movq %rax, %r13
movq 0x28(%r15), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x28(%r15)
andq $0x0, (%r13)
movq %rax, 0x8(%r13)
pushq $0x38
popq %rdi
callq 0x51c0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x11c38
movq %r12, -0x30(%rbp)
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rax
subq %rsi, %rax
je 0x1271b
sarq $0x3, %rax
movq %r14, %rcx
negq %rcx
cmovsq %r14, %rcx
movq %rax, %rdx
subq $0x1, %rdx
jb 0x12735
movq (%rsi), %rdi
movq 0x8(%rdi), %rdi
movq %rdi, %r8
negq %r8
cmovsq %rdi, %r8
cmpq %rcx, %r8
ja 0x12729
cmpq $0x1, %rax
je 0x1271b
addq $0x8, %rsi
movq %rdx, %rax
jmp 0x126f0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x117f2
jmp 0x12735
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x1295e
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r12, %rdi
callq 0x51d0
movq %rbx, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rcx
addq $0x10, %rdi
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
subq $0x1, %rcx
jb 0x12789
cmpq %rsi, (%rax)
je 0x1278b
addq $0x8, %rax
jmp 0x12778
popq %rbp
retq
movq %rax, %rsi
popq %rbp
jmp 0x129cc
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x51c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x14d30
pushq $0x20
popq %r15
movq %r15, %rdi
callq 0x51c0
orq $-0x1, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r12, 0x18(%rax)
leaq 0xd235(%rip), %rcx      # 0x1fa10
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14e9c
movq %rax, %r12
pushq $0x18
popq %rdi
callq 0x51c0
andq $0x0, 0x10(%rax)
orq $-0x1, 0x8(%rax)
leaq 0xd4d7(%rip), %rcx      # 0x1fce0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x14e9c
movq %rax, %r12
movq %r15, %rdi
callq 0x51c0
movq %rax, %r15
movq %r14, -0x30(%rbp)
movq (%r14), %rdi
callq 0x124f6
orq $-0x1, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq %rax, 0x18(%r15)
leaq 0xd086(%rip), %r13      # 0x1f8d0
addq $0x10, %r13
movq %r13, (%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x14e9c
movq %rax, %r15
pushq $0x18
popq %r12
movq %r12, %rdi
callq 0x51c0
andq $0x0, 0x10(%rax)
orq $-0x1, 0x8(%rax)
leaq 0xd4b4(%rip), %r14      # 0x1fd30
addq $0x10, %r14
movq %r14, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x14e9c
movq %rax, %r15
movq %r12, %rdi
callq 0x51c0
andq $0x0, 0x10(%rax)
orq $-0x1, 0x8(%rax)
movq %r14, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x14e9c
movq %rax, %r15
pushq $0x20
popq %rdi
callq 0x51c0
movq %rax, %r12
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x124f6
orq $-0x1, 0x8(%r12)
movb $0x0, 0x10(%r12)
movq %rax, 0x18(%r12)
movq %r13, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x14e9c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rbx
jmp 0x12911
movq %rax, %r14
movq %r15, %rbx
jmp 0x12911
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x51d0
movq %r14, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12934
cmpq $0x1, %rsi
jne 0x12939
movq (%rdi), %rax
retq
movq 0x8(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
je 0x12959
movq (%rcx), %rax
addq $0x8, %rcx
cmpq %rsi, 0x8(%rax)
jne 0x12945
jmp 0x1295b
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
testq %rsi, %rsi
je 0x12ae6
leaq 0xcc33(%rip), %rsi      # 0x1f6c8
leaq 0xcce4(%rip), %rdx      # 0x1f780
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x51f0
testq %rax, %rax
je 0x12ae6
movq %r14, %rdi
callq 0x12e14
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x12a4c
leaq -0x28(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12c64
movq (%r14), %rax
movq 0x20(%rax), %rax
addq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x12aab
movq (%r15), %rax
movq 0x18(%rax), %rdi
movq 0x18(%r14), %rsi
callq 0x12c38
testb %al, %al
jne 0x12b0c
addq $0x8, %r15
jmp 0x12aed
pushq $0x20
popq %rdi
callq 0x5110
movq %rax, %rbx
movq (%r15), %rax
movq 0x18(%rax), %rdx
leaq 0x5b33(%rip), %rsi      # 0x18658
movq %rbx, %rdi
callq 0x11816
leaq 0xcb84(%rip), %rsi      # 0x1f6b8
movq 0xd465(%rip), %rdx      # 0x1ffa0
movq %rbx, %rdi
callq 0x5360
movq %rax, %r14
movq %rbx, %rdi
callq 0x5140
movq %r14, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
addq $-0x8, %rax
testq %rsi, %rsi
jle 0x12b7f
movq (%rax), %rdx
subq 0x20(%rdx), %rcx
decq %rsi
movq %rcx, 0x18(%rdi)
movq %rax, 0x8(%rdi)
jmp 0x12b62
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r13
movq 0x8(%rdi), %r14
leaq 0xcbdf(%rip), %r15      # 0x1f780
cmpq %r14, %r13
je 0x12bf2
movq (%r13), %r12
testq %r12, %r12
je 0x12bc8
movq %r12, %rdi
leaq 0xcb0f(%rip), %rsi      # 0x1f6c8
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x51f0
testq %rax, %rax
jne 0x12bd9
movq 0x18(%r12), %rdi
movq %rbx, %rsi
callq 0x12c38
testb %al, %al
jne 0x12bdf
addq $0x8, %r13
jmp 0x12ba1
movq (%r13), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x5110
movq %rax, %r14
leaq 0x5a6f(%rip), %rsi      # 0x18673
movq %rax, %rdi
movq %rbx, %rdx
callq 0x11816
leaq 0xcaa2(%rip), %rsi      # 0x1f6b8
movq 0xd383(%rip), %rdx      # 0x1ffa0
movq %r14, %rdi
callq 0x5360
movq %rax, %rbx
movq %r14, %rdi
callq 0x5140
movq %rbx, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
xorl %r15d, %r15d
leaq -0x58(%rbp), %r12
movq $0x0, -0x30(%rbp)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x135e2
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xa854
movq 0x8(%r14), %rcx
movq (%rcx,%r15,8), %r13
cmpq %r13, %rax
je 0x135bb
movq %rax, (%rcx,%r15,8)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %r13
movb $0x1, %al
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa87a
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1360c
movq %r12, %rdi
callq 0xa8c8
incq %r15
jmp 0x1357c
movq -0x30(%rbp), %rax
andb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xa8c8
movq %rbx, %rdi
callq 0x5390
nop
// File: /workspace/github_cpp_makefile_star2_O2/Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp
// Function: ASTOptimizer::iteratorReplacer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, long long)
Callback ASTOptimizer::iteratorReplacer(std::string &variableToReplace, long long value) {
    return [this, variableToReplace, value](Node *node) -> Node * {
        if (auto idVal = dynamic_cast<IdentifierValue *>(node)) {
            try {
                VariableIdentifier &varId = dynamic_cast<VariableIdentifier &>(idVal->identifier);

                if (varId.name == variableToReplace) {
                    return new NumberValue(value);
                }
            } catch (std::bad_cast _) {
                try {
                    VariableAccessIdentifier &varAccId = dynamic_cast<VariableAccessIdentifier &>(idVal->identifier);

                    if (varAccId.accessName == variableToReplace) {
                        return new IdentifierValue(*new AccessIdentifier(varAccId.name, value));
                    }
                } catch (std::bad_cast _) {}
            }
        } else if (auto varArrId = dynamic_cast<VariableAccessIdentifier *>(node)) {
            if (varArrId->accessName == variableToReplace) return new AccessIdentifier(varArrId->name, value);
        }
        return node;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdi, %r14
leaq -0x40(%rbp), %rbx
movq %rsi, -0x8(%rbx)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5290
movq %r15, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
pushq $0x30
popq %rdi
callq 0x51c0
leaq -0x30(%rbp), %rcx
movq -0x18(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, %rdx
addq $0x18, %rdx
movq %rdx, 0x8(%rax)
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
je 0x13e51
movq %rsi, 0x8(%rax)
movq -0x30(%rbp), %rdx
movq %rdx, 0x18(%rax)
jmp 0x13e57
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq -0x38(%rbp), %rdx
movq %rcx, -0x40(%rbp)
andq $0x0, -0x38(%rbp)
movq %rdx, 0x10(%rax)
movb $0x0, -0x30(%rbp)
movq %r15, 0x28(%rax)
movq %rax, (%r14)
leaq 0x39e(%rip), %rax       # 0x14218
movq %rax, 0x18(%r14)
leaq 0x5cb(%rip), %rax       # 0x14450
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x5418
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0xa8c8
movq %rbx, %rdi
callq 0x5418
movq %r15, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp
// Function: ASTOptimizer::optimize(bool)
void ASTOptimizer::optimize(bool verbose) {
    while (traverse(originalProgram->commands, [this](Node *node) -> Node * { return constantConditionRemover(node); })) {
        std::cout << "   [i] flattening always true expressions" << std::endl;
    }

    while (traverse(originalProgram->commands, [this](Node *node) -> Node * { return constantLoopUnroller(node); })) {
        std::cout << "   [i] unrolling constant loops" << std::endl;
    }
    while (traverse(originalProgram->commands, [this](Node *node) -> Node * { return constantExpressionOptimizer(node); })) {
        std::cout << "   [i] Replacing constant expressions" << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
leaq -0x88(%rbp), %rbx
movq 0xbf2e(%rip), %r15      # 0x1ffc8
leaq 0x4788(%rip), %r12      # 0x18829
movq (%r14), %rax
movq 0x8(%rax), %rsi
andq $0x0, -0x80(%rbp)
movq %r14, -0x88(%rbp)
leaq 0x437(%rip), %rax       # 0x144f2
movq %rax, -0x70(%rbp)
leaq 0x43a(%rip), %rax       # 0x14500
movq %rax, -0x78(%rbp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x13552
movl %eax, %r13d
movq %rbx, %rdi
callq 0xa8c8
testb %r13b, %r13b
je 0x140fa
movq %r15, %rdi
movq %r12, %rsi
callq 0x51b0
movq %rax, %rdi
callq 0x5100
jmp 0x140a1
leaq -0x68(%rbp), %rbx
movq 0xbec3(%rip), %r15      # 0x1ffc8
leaq 0x4747(%rip), %r12      # 0x18853
movq (%r14), %rax
movq 0x8(%rax), %rsi
andq $0x0, -0x60(%rbp)
movq %r14, -0x68(%rbp)
leaq 0x407(%rip), %rax       # 0x1452a
movq %rax, -0x50(%rbp)
leaq 0x40c(%rip), %rax       # 0x1453a
movq %rax, -0x58(%rbp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x13552
movl %eax, %r13d
movq %rbx, %rdi
callq 0xa8c8
testb %r13b, %r13b
je 0x14162
movq %r15, %rdi
movq %r12, %rsi
callq 0x51b0
movq %rax, %rdi
callq 0x5100
jmp 0x1410c
leaq -0x48(%rbp), %rbx
movq 0xbe5b(%rip), %r15      # 0x1ffc8
leaq 0x46ff(%rip), %r12      # 0x18873
movq (%r14), %rax
movq 0x8(%rax), %rsi
andq $0x0, -0x40(%rbp)
movq %r14, -0x48(%rbp)
leaq 0x3d9(%rip), %rax       # 0x14564
movq %rax, -0x30(%rbp)
leaq 0x3de(%rip), %rax       # 0x14574
movq %rax, -0x38(%rbp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x13552
movl %eax, %r13d
movq %rbx, %rdi
callq 0xa8c8
testb %r13b, %r13b
je 0x141ca
movq %r15, %rdi
movq %r12, %rsi
callq 0x51b0
movq %rax, %rdi
callq 0x5100
jmp 0x14174
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x141dd
jmp 0x141dd
movq %rax, %r14
movq %rbx, %rdi
callq 0xa8c8
movq %r14, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/Bartor[P]kompilator/middle/peephole/PeepholeOptimizer.cpp
// Function: PeepholeOptimizer::optimize(bool)
void PeepholeOptimizer::optimize(bool verbose) {
    std::cout << "   [i] Removing useless STORE LOADs..." << std::endl;
    while (removeUselessStoreLoads()) {
        if (verbose) std::cout << std::endl << "Removed useless STORE LOAD";
    }
    std::cout << "   [i] Removing useless STORE LOADIs..." << std::endl;
    while (removeUselessStoreLoadis()) {
        if (verbose) std::cout << std::endl << "Removed useless STORE LOADI";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xb815(%rip), %r15      # 0x1ffc8
leaq 0x40f7(%rip), %rsi      # 0x188b1
movq %r15, %rdi
callq 0x51b0
movq %rax, %rdi
callq 0x5100
leaq 0x4107(%rip), %r12      # 0x188d8
movq %r14, %rdi
callq 0x1484a
testb %al, %al
je 0x147f6
testb %bl, %bl
je 0x147d1
movq %r15, %rdi
callq 0x5100
movq %rax, %rdi
movq %r12, %rsi
callq 0x51b0
jmp 0x147d1
movq 0xb7cb(%rip), %r15      # 0x1ffc8
leaq 0x40ef(%rip), %rsi      # 0x188f3
movq %r15, %rdi
callq 0x51b0
movq %rax, %rdi
callq 0x5100
leaq 0x4100(%rip), %r12      # 0x1891b
movq %r14, %rdi
callq 0x14a4c
testb %al, %al
je 0x14840
testb %bl, %bl
je 0x1481b
movq %r15, %rdi
callq 0x5100
movq %rax, %rdi
movq %r12, %rsi
callq 0x51b0
jmp 0x1481b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop