LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7a49
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x74e6
movq 0x1f903(%rip), %rax     # 0x272d0
movq 0x1f904(%rip), %rcx     # 0x272d8
testq %rax, %rax
je 0x7a0e
cmpq $0x0, (%rax,%rcx,8)
je 0x7a0e
movb 0x1f902(%rip), %dl      # 0x272e8
movq 0x1f8f3(%rip), %rsi     # 0x272e0
movb %dl, (%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x10(%rdx)
movl 0x1f8fb(%rip), %edx     # 0x272f8
movq (%rax,%rcx,8), %rsi
movl %edx, 0x1c(%rsi)
incq %rcx
movq %rcx, 0x1f8ca(%rip)     # 0x272d8
movq %rbx, (%rax,%rcx,8)
movl 0x1c(%rbx), %edx
movl %edx, 0x1f8dd(%rip)     # 0x272f8
movq 0x10(%rbx), %rdx
movq %rdx, 0x1f8ba(%rip)     # 0x272e0
movq %rdx, 0x1f893(%rip)     # 0x272c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x1f86d(%rip)     # 0x272a8
movb (%rdx), %al
movb %al, 0x1f8a5(%rip)      # 0x272e8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f87f(%rip), %rax     # 0x272d0
testq %rax, %rax
je 0x7ad2
pushq %rbp
movq %rsp, %rbp
movq 0x1f877(%rip), %rcx     # 0x272d8
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x7ad1
callq 0x78bf
movq 0x1f85a(%rip), %rax     # 0x272d0
movq 0x1f85b(%rip), %rcx     # 0x272d8
movq $0x0, (%rax,%rcx,8)
testq %rcx, %rcx
je 0x7ad1
leaq -0x1(%rcx), %rdx
movq %rdx, 0x1f843(%rip)     # 0x272d8
movq -0x8(%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x7ad1
movl 0x1c(%rdx), %esi
movl %esi, 0x1f850(%rip)     # 0x272f8
movq 0x10(%rdx), %rdx
movq %rdx, 0x1f82d(%rip)     # 0x272e0
movq %rdx, 0x1f806(%rip)     # 0x272c0
movq -0x8(%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x1f7df(%rip)     # 0x272a8
movb (%rdx), %al
movb %al, 0x1f817(%rip)      # 0x272e8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7af8
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, -0x2(%rdi,%rsi)
jne 0x7af8
cmpb $0x0, -0x1(%r15,%r14)
je 0x7b08
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 0x7b56
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 0x7818
jmp 0x7afa
leaq 0x1733a(%rip), %rdi     # 0x1ee97
callq 0x76c9
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7be5
movq %rax, %r15
testl %r14d, %r14d
jle 0x7bbb
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 0x7ad3
testq %rax, %rax
je 0x7bf1
movl $0x1, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x172d5(%rip), %rdi     # 0x1eec1
callq 0x76c9
leaq 0x172f2(%rip), %rdi     # 0x1eeea
callq 0x76c9
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f64b(%rip), %rdi     # 0x272d0
testq %rdi, %rdi
je 0x7cbf
movq 0x1f647(%rip), %rax     # 0x272d8
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x7cc1
movq %rax, %rdi
callq 0x78bf
movq 0x1f627(%rip), %rax     # 0x272d0
movq 0x1f628(%rip), %rcx     # 0x272d8
movq $0x0, (%rax,%rcx,8)
callq 0x7a4a
jmp 0x7c7e
xorl %edi, %edi
callq 0x5280
movl $0x1, 0x1f568(%rip)     # 0x27238
xorl %eax, %eax
movq %rax, 0x1f5f7(%rip)     # 0x272d0
movq %rax, 0x1f5f8(%rip)     # 0x272d8
movq %rax, 0x1f619(%rip)     # 0x27300
movq %rax, 0x1f5f2(%rip)     # 0x272e0
movb $0x0, 0x1f5d3(%rip)     # 0x272c8
movl $0x0, 0x1f5cd(%rip)     # 0x272cc
movq %rax, 0x1f5a2(%rip)     # 0x272a8
movq %rax, 0x1f5a3(%rip)     # 0x272b0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x186c9(%rip), %rcx     # 0x26308
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 0xdcb9
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r15
leaq -0x60(%rbp), %r12
movq (%r13), %r14
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xeab4
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
callq 0x63dc
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xdcb0
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
addq $0x8, %r13
cmpq %rbx, %r13
jne 0xdc6e
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdcf0
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xdce8
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xeb19
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17d43(%rip), %rcx     # 0x265d8
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 0xe90f
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r15
leaq -0x60(%rbp), %r12
movq (%r13), %r14
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xeab4
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
callq 0x655e
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xe906
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
addq $0x8, %r13
cmpq %rbx, %r13
jne 0xe8c4
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe946
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xe93e
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xeb19
// File: /workspace/github_cpp_makefile_star2_O3/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 0x175e4
movq %r15, 0x30(%r14)
movq 0x20(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0xebfb
xorb $0x1, %bl
movq (%r15), %rsi
movq 0x30(%r14), %rdi
callq 0x176ca
testq %rax, %rax
sete %cl
orb %bl, %cl
jne 0xebee
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x17404
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x18422(%rip), %rdi     # 0x26fc8
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 0xebee
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5200
addq $0x8, %r15
cmpq %r12, %r15
jne 0xeb75
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 0xec2e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xec33
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17874
movq %rax, %rbx
movq 0x30(%r14), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x1670a
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0xecac
movq (%r15), %rdi
movq 0x30(%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
callq 0x16b48
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a902
addq $0x8, %r15
cmpq %r12, %r15
jne 0xec80
movq -0x38(%rbp), %r15
testq %r15, %r15
je 0xecc0
movq -0x28(%rbp), %rsi
subq %r15, %rsi
movq %r15, %rdi
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 0xece8
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x30(%rdi), %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1670a
movq -0x58(%rbp), %r15
movq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq %rax, %r15
je 0xf0c1
movq %r12, -0x60(%rbp)
leaq 0x17656(%rip), %r12     # 0x26698
movq -0x70(%rbp), %rdi
callq 0x1a8b0
movq (%rax), %r14
movq 0x8(%rax), %rbx
cmpq %rbx, %r14
je 0xf08c
movq (%r14), %rdi
testq %rdi, %rdi
je 0xf086
leaq 0x177b2(%rip), %rsi     # 0x26818
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
je 0xf086
movq 0x18(%rax), %r13
movq (%r15), %rdi
callq 0x173fa
cmpq %rax, %r13
je 0xf0af
addq $0x8, %r14
jmp 0xf052
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0xf0a3
movq (%r15), %rax
movq %rax, (%rsi)
addq $0x8, -0x38(%rbp)
jmp 0xf0af
leaq -0x40(%rbp), %rdi
movq %r15, %rdx
callq 0x16884
addq $0x8, %r15
cmpq -0x68(%rbp), %r15
jne 0xf042
movq -0x58(%rbp), %r15
movq -0x60(%rbp), %r12
testq %r15, %r15
je 0xf0d5
movq -0x48(%rbp), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x5200
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %rbx
cmpq %rbx, %r14
je 0xf0fc
movq 0x30(%r12), %rdi
movq (%r14), %rsi
callq 0x1780a
addq $0x8, %r14
cmpq %rbx, %r14
jne 0xf0e2
movq -0x40(%rbp), %r14
testq %r14, %r14
je 0xf110
movq -0x30(%rbp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x5200
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf125
jmp 0xf12a
jmp 0xf12a
movq %rax, %rbx
jmp 0xf142
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0xf142
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xf157
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15cec(%rip), %rsi     # 0x26638
leaq 0x1586d(%rip), %rdx     # 0x261c0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
je 0x109cd
movq 0x30(%rbx), %rdi
movq 0x8(%rax), %rsi
callq 0x17a14
movq %rax, %rdi
callq 0x173fa
movq %rax, %r15
movl $0x28, %edi
callq 0x51f0
movq %rax, %r13
movl $0x20, %edi
callq 0x51f0
movq %rax, %r12
movq %rax, %rdi
callq 0x1a830
movw $0x1, (%r13)
movq $0x0, 0x8(%r13)
movq %r12, 0x10(%r13)
movq %r15, 0x18(%r13)
movl $0x0, 0x20(%r13)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5410
movq %rdx, -0x30(%rbp)
movq %rax, %r15
movl $0x20, %esi
movq %r12, %rdi
callq 0x5200
jmp 0x109ef
movq %rdx, -0x30(%rbp)
movq %rax, %r15
movl $0x28, %esi
movq %r13, %rdi
callq 0x5200
jmp 0x10a07
jmp 0x10a00
movq %rdx, -0x30(%rbp)
movq %rax, %r15
cmpl $0x1, -0x30(%rbp)
jne 0x10ad9
movq %r15, %rdi
callq 0x52b0
movq 0x16588(%rip), %r12     # 0x26fa8
addq $0x10, %r12
movq %r12, -0x38(%rbp)
movq %r15, %rdi
callq 0x50f0
leaq 0x15c01(%rip), %rsi     # 0x26638
leaq 0x157ca(%rip), %rdx     # 0x26208
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
je 0x10a74
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0xff14
movq %rax, %r13
leaq -0x38(%rbp), %rdi
callq 0x53f0
callq 0x5350
jmp 0x109bb
callq 0x5410
movq %rax, %r15
cmpl -0x30(%rbp), %edx
jne 0x10acb
movq %r15, %rdi
callq 0x52b0
movq %r12, -0x40(%rbp)
movq %r15, %rdi
callq 0x50f0
movl $0x8, %edi
callq 0x5120
leaq 0xeae9(%rip), %rcx      # 0x1f58f
movq %rcx, (%rax)
movq 0x164f0(%rip), %rsi     # 0x26fa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x53a0
movq %rax, %r15
leaq -0x40(%rbp), %rdi
callq 0x53f0
callq 0x5350
leaq -0x38(%rbp), %rdi
callq 0x53f0
callq 0x5350
movq %r15, %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xeb19
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xecf0
movq %r14, %rdi
movl %ebx, %esi
callq 0xeb28
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xf160
movq 0x8(%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xefea
movq %r14, %rdi
callq 0xec3c
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1a902
movq %r14, %rdi
movl $0x1, %esi
callq 0x1a932
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16a10
movslq %edx, %rcx
leaq 0x109be(%rip), %r14     # 0x2737f
movq $-0x3d, %r8
leaq 0x8c6c(%rip), %rdi      # 0x1f63b
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movb (%rdx,%rdi), %dl
movb %dl, -0x1(%r14)
decq %r14
cmpq %rcx, %rsi
jb 0x169f5
leaq 0x1(%r8), %rdx
movq %rax, %rsi
testq %r8, %r8
movq %rdx, %r8
jne 0x169cf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x5100
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x16a28
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8c1b(%rip), %rsi      # 0x1f639
leaq 0x8c15(%rip), %rdx      # 0x1f63a
movq %rbx, %rdi
callq 0x7d1c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16a5b
movq 0x18(%rsi), %rsi
xorl %eax, %eax
cmpb (%rsi,%rax), %dl
jne 0x16a5d
movb 0x1(%rcx,%rax), %dl
incq %rax
testb %dl, %dl
jne 0x16a49
jmp 0x16a5d
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x169a8
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x52a0
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x16ace
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x5200
movq $0x0, 0x10(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x16b1e
movq (%r14), %rcx
leaq -0x1(%rax), %rdx
xorl %esi, %esi
xorl %edi, %edi
xorl %r8d, %r8d
cmpb $0x31, (%rcx,%rsi)
sete %r8b
leaq (%rdi,%r8), %r9
cmpq %rsi, %rdx
setne %r10b
leaq 0x5(%rdi,%r8), %rdi
cmoveq %r9, %rdi
orb %r10b, %r8b
cmpb $0x1, %r8b
jne 0x16b16
movq %rdi, 0x10(%rbx)
incq %rsi
cmpq %rsi, %rax
jne 0x16aea
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x16b3f
movq (%r15), %rsi
incq %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x177e4
movq %rsi, %r15
cmpq $0x1, %rsi
je 0x177e4
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
je 0x1771a
xorl %eax, %eax
movq (%rcx), %rsi
cmpq %r15, 0x8(%rsi)
je 0x177e4
addq $0x8, %rcx
cmpq %rdx, %rcx
jne 0x17704
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, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x16a60
leaq 0x10(%rbx), %rdi
movq %r14, -0x28(%rbp)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
je 0x177b9
sarq $0x3, %rcx
movq %r15, %rdx
negq %rdx
cmovsq %r15, %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 0x177d4
cmpq %r9, %r8
je 0x177b9
incq %r9
addq $0x8, %rax
cmpq %r9, %rcx
jne 0x17790
jmp 0x177e0
cmpq 0x20(%rbx), %rsi
je 0x177c9
movq %r14, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x177e0
leaq -0x28(%rbp), %rdx
callq 0x16884
jmp 0x177e0
leaq -0x28(%rbp), %rdx
movq %rax, %rsi
callq 0x17a54
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 %r14, %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17872
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 0x17852
addq $0x8, %rsi
addq $-0x8, %rdx
decq %rdi
jne 0x1783d
jmp 0x1786c
cmpq %rcx, %rsi
je 0x17864
leaq -0x8(%rsi), %rdi
callq 0x5340
movq 0x18(%rbx), %rcx
addq $-0x8, %rcx
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movl $0x20, %edi
callq 0x51f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1a830
movl $0x20, %edi
callq 0x51f0
movq $-0x1, %r13
movq %r13, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
leaq 0xf144(%rip), %rcx      # 0x26a08
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a9ba
movq %rax, %r15
movl $0x18, %edi
callq 0x51f0
movq $0x0, 0x10(%rax)
movq %r13, 0x8(%rax)
leaq 0xf3de(%rip), %rcx      # 0x26cd8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a9ba
movq %rax, %r12
movl $0x20, %edi
callq 0x51f0
movq %rax, %r15
movq %r14, -0x38(%rbp)
movq (%r14), %rdi
callq 0x173fa
movq %r13, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq %rax, 0x18(%r15)
leaq 0xef8c(%rip), %r14      # 0x268c8
addq $0x10, %r14
movq %r14, (%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a9ba
movq %rax, %r15
movl $0x18, %edi
callq 0x51f0
xorl %r12d, %r12d
movq %r12, 0x10(%rax)
movq %r13, 0x8(%rax)
leaq 0xf3bb(%rip), %rbx      # 0x26d28
addq $0x10, %rbx
movq %rbx, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a9ba
movq %rax, %r15
movl $0x18, %edi
callq 0x51f0
movq %r12, 0x10(%rax)
movq %r13, 0x8(%rax)
movq %rbx, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a9ba
movq %rax, %r12
movl $0x20, %edi
callq 0x51f0
movq %rax, %r15
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x173fa
movq $-0x1, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %r14, (%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a9ba
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x179f3
movq %rax, %r14
movq %r15, %rdi
jmp 0x17a01
movq %rbx, %rdi
movq %rax, %r14
movl $0x20, %esi
callq 0x5200
movq %r14, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17a24
cmpq $0x1, %rsi
jne 0x17a29
movq (%rdi), %rax
retq
movq 0x8(%rdi), %rax
retq
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
je 0x17a50
pushq %rbp
movq %rsp, %rbp
movq (%rcx), %rax
cmpq %rsi, 0x8(%rax)
je 0x17a4e
addq $0x8, %rcx
cmpq %rdx, %rcx
jne 0x17a3a
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %r14
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
testq %rsi, %rsi
je 0x17b3a
leaq 0xeb9c(%rip), %rsi      # 0x266c0
leaq 0xec4d(%rip), %rdx      # 0x26778
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
jne 0x17b80
movq -0x30(%rbp), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x17b80
movq 0x18(%r14), %rbx
movq 0x8(%rbx), %r15
movq (%r12), %rax
movq 0x18(%rax), %rax
cmpq %r15, 0x8(%rax)
jne 0x17b77
testq %r15, %r15
je 0x17bd5
movq (%rbx), %rsi
movq (%rax), %rdi
movq %r15, %rdx
callq 0x5210
testl %eax, %eax
je 0x17bd5
addq $0x8, %r12
cmpq %r13, %r12
jne 0x17b52
movq %r14, %rdi
callq 0x17e78
movq -0x30(%rbp), %rbx
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x17ad8
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x17bac
movq %r14, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x17bbe
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x17d36
movq (%r14), %r14
movq 0x20(%r14), %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 (%r12), %rax
movq 0x18(%rax), %rdx
leaq 0x7a67(%rip), %rsi      # 0x1f658
movq %rbx, %rdi
callq 0x16512
leaq 0xeab0(%rip), %rsi      # 0x266b0
movq 0xf391(%rip), %rdx      # 0x26f98
movq %rbx, %rdi
callq 0x53a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x53d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17c57
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
ja 0x17c3a
movq %rax, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, -0x30(%rbp)
movq (%rdi), %r14
movq 0x8(%rdi), %r12
cmpq %r12, %r14
je 0x17cdb
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %r15
leaq 0xeae9(%rip), %r13      # 0x26778
movq (%r14), %rbx
testq %rbx, %rbx
je 0x17cb0
movq %rbx, %rdi
leaq 0xea1f(%rip), %rsi      # 0x266c0
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x5240
testq %rax, %rax
jne 0x17cd2
movq 0x18(%rbx), %rax
cmpq %r15, 0x8(%rax)
jne 0x17cd2
testq %r15, %r15
je 0x17d11
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movq %r15, %rdx
callq 0x5210
testl %eax, %eax
je 0x17d11
addq $0x8, %r14
cmpq %r12, %r14
jne 0x17c8f
movl $0x20, %edi
callq 0x5120
movq %rax, %rbx
leaq 0x7984(%rip), %rsi      # 0x1f673
movq %rax, %rdi
movq -0x30(%rbp), %rdx
callq 0x16512
leaq 0xe9ae(%rip), %rsi      # 0x266b0
movq 0xf28f(%rip), %rdx      # 0x26f98
movq %rbx, %rdi
callq 0x53a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x53d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18b53
movq %rdx, %rbx
movq %rsi, %r14
xorl %r15d, %r15d
leaq -0x60(%rbp), %r13
movl $0x0, -0x2c(%rbp)
movq (%rax,%r15,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x10(%rbx)
je 0x18b6e
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
callq *0x18(%rbx)
movq 0x8(%r14), %rcx
movq (%rcx,%r15,8), %r12
cmpq %r12, %rax
je 0x18b06
movq %rax, (%rcx,%r15,8)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %r12
movb $0x1, %al
movl %eax, -0x2c(%rbp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0xeab4
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x18ba0
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x18b36
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 0x18acb
jmp 0x18b5a
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x50e0
jmp 0x18b97
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x18b8f
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x53d0
movq %rax, %rdi
callq 0xeb19
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %rdi
movq %rsi, -0x8(%rdi)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x633e
movq %r14, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl $0x30, %edi
callq 0x51f0
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdx
cmpq %r15, %rdx
je 0x1969b
movq %rdx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x196a2
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %r14, 0x28(%rax)
movq %rax, (%rbx)
leaq 0x548(%rip), %rax       # 0x19c00
movq %rax, 0x18(%rbx)
leaq 0x7ab(%rip), %rax       # 0x19e6e
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x196ed
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x5200
movq %rbx, %rdi
callq 0x53d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcdb1(%rip), %r15      # 0x26fc8
leaq 0x5683(%rip), %rsi      # 0x1f8a1
movl $0x26, %edx
movq %r15, %rdi
callq 0x5250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movq %r14, %rdi
callq 0x1a34a
testb %al, %al
je 0x1a2ac
leaq 0x5663(%rip), %r12      # 0x1f8c8
testb %bl, %bl
je 0x1a2a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movl $0x1a, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5250
movq %r14, %rdi
callq 0x1a34a
testb %al, %al
jne 0x1a265
leaq 0x5630(%rip), %rsi      # 0x1f8e3
movl $0x27, %edx
movq %r15, %rdi
callq 0x5250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movq %r14, %rdi
callq 0x1a564
testb %al, %al
je 0x1a341
leaq 0x5611(%rip), %r12      # 0x1f90b
testb %bl, %bl
je 0x1a335
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x51d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5140
movl $0x1b, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5250
movq %r14, %rdi
callq 0x1a564
testb %al, %al
jne 0x1a2fa
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Bartor[P]kompilator/back/asm/InstructionList.cpp
// Function: InstructionList::seal(bool)
void InstructionList::seal(bool addHalt) {
    if (addHalt) instructions.push_back(new Halt());

    long long counter = 0;
    for (const auto &ins : instructions) { // instruction address resolution
        ins->setAddress(counter);
        if (!ins->stub) {
            counter++; // stubs use next instruction's address
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x1a97e
leaq 0x8(%rbx), %r14
movl $0x18, %edi
callq 0x51f0
movq $0x0, 0x10(%rax)
movq $-0x1, 0x8(%rax)
leaq 0xc320(%rip), %rcx      # 0x26c88
addq $0x10, %rcx
movq %rcx, (%rax)
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x1aa68
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
je 0x1a9af
xorl %ebx, %ebx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq (%r14), %rax
movzbl 0x10(%rax), %eax
xorq $0x1, %rax
addq %rax, %rbx
addq $0x8, %r14
cmpq %r15, %r14
jne 0x1a98d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/jgame.cpp
// Function: main
int main()
{
	bool lAgain = true;
	string lInput;
	while ( lAgain )
	{
		// start game
		Game * lJeopardy = new Game(5);

		cout << "Welcome to a new game of Jeopardy.\n\n";

		// while game not done continue playing
		while(lJeopardy->playing())
		{
			//Start by showing the board
			lJeopardy->showBoard();
			// updates the status (checks if the game is done)
			lJeopardy->updateStatus();
		}
		// when game is finished display the score
		lJeopardy->showScore();
		delete lJeopardy;
		// Play another game?
		cout << "Do you want to play again? [y/N] \n";
		cin >> lInput;
		if(lInput != "")
			lAgain = toupper(lInput[0]) == 'Y';
		else
			lAgain = false;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x6a19(%rip), %rbx      # 0x8fc0
movq 0x6a22(%rip), %r12      # 0x8fd0
leaq -0x48(%rbp), %r13
leaq 0x3ab8(%rip), %r14      # 0x6071
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movl $0x5, %esi
callq 0x26c8
movl $0x24, %edx
movq %rbx, %rdi
leaq 0x3a22(%rip), %rsi      # 0x6004
callq 0x2230
movq %r15, %rdi
callq 0x367e
testb %al, %al
je 0x2605
movq %r15, %rdi
callq 0x2fc6
movq %r15, %rdi
callq 0x3686
jmp 0x25e7
movq %r15, %rdi
callq 0x3606
movq %r15, %rdi
callq 0x2f84
movl $0x18, %esi
movq %r15, %rdi
callq 0x2200
movl $0x22, %edx
movq %rbx, %rdi
leaq 0x39f8(%rip), %rsi      # 0x6029
callq 0x2230
movq %r12, %rdi
movq %r13, %rsi
callq 0x2270
movq %r13, %rdi
movq %r14, %rsi
callq 0x2080
movq -0x48(%rbp), %r15
testl %eax, %eax
je 0x2666
movsbl (%r15), %edi
callq 0x23b0
cmpl $0x59, %eax
je 0x25b9
leaq -0x38(%rbp), %rax
cmpq %rax, %r15
je 0x267e
movq -0x38(%rbp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x2200
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x2200
jmp 0x26a6
jmp 0x26a3
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x26bf
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/jgameClass.cpp
// Function: Game::Game(int)
Game::Game(int aSize)
{
	this->mScore = 0;
	this->mPlaying = true;
	this->mSize = aSize;
	this->mQuestionSet = new Question**[mSize];
	for(int lRow = 0; lRow < aSize; lRow++)
	{
		this->mQuestionSet[lRow] = new Question*[mSize];
	}
	loadQuestions();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
movl $0x0, 0x4(%rdi)
movb $0x1, (%rdi)
movl %esi, 0x8(%rdi)
movl %esi, %r12d
leaq (,%r12,8), %rax
testl %esi, %esi
movq $-0x1, %r14
cmovnsq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testl %r15d, %r15d
jle 0x272a
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r12
jne 0x2712
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x273a
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/jgameClass.cpp
// Function: Game::showScore()
int Game::showScore(void)
{
	clearScreen();
	// display final score;
	cout << "Final Score: " << mScore << "\n";
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x59a6(%rip), %r15      # 0x8fc0
leaq 0x2b95(%rip), %rbx      # 0x61b6
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2230
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2230
leaq 0x2ae1(%rip), %rsi      # 0x6129
movl $0xd, %edx
movq %r15, %rdi
callq 0x2230
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x2340
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2230
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Matlock42[P]Jeopardy/jgameClass.cpp
// Function: Game::updateStatus()
int Game::updateStatus(void)
{
	bool lDone = true; // assume done
	// loop through the questionSet and see if they have all been played
	// for efficency, start with the high dollar/harder questions
	
	// loop through rows (bottom to top)
	for(int i = mSize-1; i >= 0; i--)
	{
		// loop through columns
		for(int j=0; j < mSize; j++)
		{
			// sets done to false if a question hasn't been played
			if( lDone && !mQuestionSet[j][i]->hasBeenPlayed() )
			{
				lDone = false;
			}
		}
	}
	mPlaying = !(lDone);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x8(%rdi), %r12
xorl %r14d, %r14d
testq %r12, %r12
jle 0x36fc
movb $0x1, %r15b
movl %r12d, %eax
movl %r12d, %ecx
movq %r12, -0x30(%rbp)
decq %r12
testl %ecx, %ecx
jle 0x36eb
xorl %r13d, %r13d
testb $0x1, %r15b
je 0x36de
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r12,8), %rdi
callq 0x5ddc
movzbl %r15b, %r15d
testb %al, %al
cmovel %r14d, %r15d
movl 0x8(%rbx), %eax
incq %r13
movslq %eax, %rdx
movl %eax, %ecx
cmpq %rdx, %r13
jl 0x36ba
cmpq $0x2, -0x30(%rbp)
jge 0x36ac
notb %r15b
andb $0x1, %r15b
movl %r15d, %r14d
movb %r14b, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq