LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xb110
cmpq $0x0, 0x356b7(%rip)     # 0x41380
je 0xbce3
movq 0x356ae(%rip), %rax     # 0x41380
movq 0x356af(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xbceb
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xbceb
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0xbcfa
jmp 0xbd9a
cmpq $0x0, 0x3567e(%rip)     # 0x41380
je 0xbd1c
movq 0x35675(%rip), %rax     # 0x41380
movq 0x35676(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xbd24
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xbd24
movq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0xbd75
movb 0x35664(%rip), %cl      # 0x41398
movq 0x35655(%rip), %rax     # 0x41390
movb %cl, (%rax)
movq 0x3564c(%rip), %rcx     # 0x41390
movq 0x35635(%rip), %rax     # 0x41380
movq 0x35636(%rip), %rdx     # 0x41388
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movl 0x35648(%rip), %ecx     # 0x413a8
movq 0x35619(%rip), %rax     # 0x41380
movq 0x3561a(%rip), %rdx     # 0x41388
movq (%rax,%rdx,8), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rdx
movq 0x35600(%rip), %rax     # 0x41380
movq 0x35601(%rip), %rcx     # 0x41388
movq %rdx, (%rax,%rcx,8)
callq 0xb2b0
movl $0x1, 0x35612(%rip)     # 0x413ac
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbdd5
jmp 0xbe4a
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x3559b(%rip)     # 0x41380
je 0xbdff
movq 0x35592(%rip), %rax     # 0x41380
movq 0x35593(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xbe07
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xbe07
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbe2a
movq 0x35565(%rip), %rax     # 0x41380
movq 0x35566(%rip), %rcx     # 0x41388
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xbe41
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xbe50
movq -0x8(%rbp), %rdi
callq 0xbe50
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbe88
jmp 0xbf14
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x354a0(%rip)     # 0x41380
je 0xbefa
movq 0x35497(%rip), %rax     # 0x41380
movq 0x35498(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xbf02
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xbf02
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbf14
callq 0xb2b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbf38
jmp 0xc023
callq 0xb110
cmpq $0x0, 0x3543b(%rip)     # 0x41380
je 0xbf5f
movq 0x35432(%rip), %rax     # 0x41380
movq 0x35433(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xbf67
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xbf67
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0xbfb8
movb 0x35421(%rip), %cl      # 0x41398
movq 0x35412(%rip), %rax     # 0x41390
movb %cl, (%rax)
movq 0x35409(%rip), %rcx     # 0x41390
movq 0x353f2(%rip), %rax     # 0x41380
movq 0x353f3(%rip), %rdx     # 0x41388
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movl 0x35405(%rip), %ecx     # 0x413a8
movq 0x353d6(%rip), %rax     # 0x41380
movq 0x353d7(%rip), %rdx     # 0x41388
movq (%rax,%rdx,8), %rax
movl %ecx, 0x1c(%rax)
cmpq $0x0, 0x353c0(%rip)     # 0x41380
je 0xbfda
movq 0x353b7(%rip), %rax     # 0x41380
movq 0x353b8(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xbfe2
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xbfe2
movq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0xbffe
movq 0x35395(%rip), %rax     # 0x41388
addq $0x1, %rax
movq %rax, 0x3538a(%rip)     # 0x41388
movq -0x8(%rbp), %rdx
movq 0x35377(%rip), %rax     # 0x41380
movq 0x35378(%rip), %rcx     # 0x41388
movq %rdx, (%rax,%rcx,8)
callq 0xb2b0
movl $0x1, 0x35389(%rip)     # 0x413ac
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
cmpq $0x0, 0x35340(%rip)     # 0x41380
je 0xc05a
movq 0x35337(%rip), %rax     # 0x41380
movq 0x35338(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xc062
xorl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0xc062
movq -0x8(%rbp), %rax
cmpq $0x0, %rax
jne 0xc071
jmp 0xc119
cmpq $0x0, 0x35307(%rip)     # 0x41380
je 0xc093
movq 0x352fe(%rip), %rax     # 0x41380
movq 0x352ff(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xc09b
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xc09b
movq -0x10(%rbp), %rdi
callq 0xbdc0
movq 0x352d5(%rip), %rax     # 0x41380
movq 0x352d6(%rip), %rcx     # 0x41388
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, 0x352c6(%rip)     # 0x41388
jbe 0xc0d6
movq 0x352bd(%rip), %rax     # 0x41388
addq $-0x1, %rax
movq %rax, 0x352b2(%rip)     # 0x41388
cmpq $0x0, 0x352a2(%rip)     # 0x41380
je 0xc0f8
movq 0x35299(%rip), %rax     # 0x41380
movq 0x3529a(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xc100
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xc100
movq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0xc119
callq 0xb2b0
movl $0x1, 0x35293(%rip)     # 0x413ac
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jb 0xc161
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xc161
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xc16e
movq $0x0, -0x8(%rbp)
jmp 0xc215
movl $0x40, %edi
callq 0xbda0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc18f
leaq 0x25e0d(%rip), %rdi     # 0x31f97
callq 0xbae0
movq -0x18(%rbp), %rax
subq $0x2, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x20(%rbp), %rdi
callq 0xbcb0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x2, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbda0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc28b
leaq 0x25d3b(%rip), %rdi     # 0x31fc1
callq 0xbae0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc2bb
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc292
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc2fc
leaq 0x25cf3(%rip), %rdi     # 0x31fea
callq 0xbae0
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
jmp 0xc40a
cmpq $0x0, 0x34f6e(%rip)     # 0x41380
je 0xc42c
movq 0x34f65(%rip), %rax     # 0x41380
movq 0x34f66(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xc434
xorl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0xc434
movq -0x8(%rbp), %rax
cmpq $0x0, %rax
je 0xc491
cmpq $0x0, 0x34f3a(%rip)     # 0x41380
je 0xc460
movq 0x34f31(%rip), %rax     # 0x41380
movq 0x34f32(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xc468
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xc468
movq -0x10(%rbp), %rdi
callq 0xbdc0
movq 0x34f08(%rip), %rax     # 0x41380
movq 0x34f09(%rip), %rcx     # 0x41388
movq $0x0, (%rax,%rcx,8)
callq 0xc030
jmp 0xc40a
movq 0x34ee8(%rip), %rdi     # 0x41380
callq 0xbe50
movq $0x0, 0x34ed8(%rip) # 0x41380
callq 0xc4c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xc560
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq 0x24bc4(%rip), %rdx     # 0x32152
callq 0xf310
jmp 0xd595
leaq -0x38(%rbp), %rdi
callq 0x6598
movl $0x0, -0x48(%rbp)
movq -0xc0(%rbp), %rdi
movslq -0x48(%rbp), %rax
movq %rax, -0xd0(%rbp)
addq $0x8, %rdi
callq 0x9350
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0xd668
movq -0xc0(%rbp), %rdi
addq $0x8, %rdi
movslq -0x48(%rbp), %rsi
callq 0xf600
movq (%rax), %rsi
movl -0x14(%rbp), %edx
incl %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0xd5fd
movq -0xb8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6370
jmp 0xd60f
leaq -0x68(%rbp), %rdi
callq 0x6598
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xd5a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6598
jmp 0xd731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xd725
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6598
jmp 0xd725
movq -0xc0(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0xa8(%rbp), %rdi
callq 0xc560
jmp 0xd680
leaq 0x24a65(%rip), %rdx     # 0x320ec
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xf310
jmp 0xd69c
movq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x6370
jmp 0xd6b1
leaq -0x88(%rbp), %rdi
callq 0x6598
leaq -0xa8(%rbp), %rdi
callq 0x6598
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xd715
jmp 0xd709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xd6fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6598
leaq -0xa8(%rbp), %rdi
callq 0x6598
jmp 0xd725
movq -0xb8(%rbp), %rdi
callq 0x6598
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x6598
movq -0x40(%rbp), %rdi
callq 0x64d0
nopw (%rax,%rax)
// File: 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
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xc560
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
leaq 0x236fe(%rip), %rdx     # 0x3219c
callq 0xf310
jmp 0xeaa5
leaq -0x38(%rbp), %rdi
callq 0x6598
movq -0xe0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9b20
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9970
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xf620
testb $0x1, %al
jne 0xeaed
jmp 0xeb8b
leaq -0x58(%rbp), %rdi
callq 0x9fa0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
incl %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0xeb17
movq -0xd8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x6370
jmp 0xeb2c
leaq -0x88(%rbp), %rdi
callq 0x6598
leaq -0x58(%rbp), %rdi
callq 0xf660
jmp 0xead7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6598
jmp 0xec54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xec48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6598
jmp 0xec48
movq -0xe0(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0xc8(%rbp), %rdi
callq 0xc560
jmp 0xeba3
leaq 0x23542(%rip), %rdx     # 0x320ec
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xf310
jmp 0xebbf
movq -0xd8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x6370
jmp 0xebd4
leaq -0xa8(%rbp), %rdi
callq 0x6598
leaq -0xc8(%rbp), %rdi
callq 0x6598
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xec38
jmp 0xec2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xec1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x6598
leaq -0xc8(%rbp), %rdi
callq 0x6598
jmp 0xec48
movq -0xd8(%rbp), %rdi
callq 0x6598
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x6598
movq -0x40(%rbp), %rdi
callq 0x64d0
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x8420
jmp 0x100bd
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x18(%rbp)
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9200
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9050
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x116e0
testb $0x1, %al
jne 0x10101
jmp 0x101c9
leaq -0x38(%rbp), %rdi
callq 0x9720
movq -0x88(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x11590
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, -0x90(%rbp)
jmp 0x10162
movq -0xa8(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x83f0
jmp 0x1017f
leaq -0x70(%rbp), %rdi
callq 0x11640
leaq -0x38(%rbp), %rdi
callq 0x11720
jmp 0x100eb
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x6270
jmp 0x101d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x11640
jmp 0x101d6
movq -0x18(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x64d0
nop
// File: 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
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x83b0
jmp 0x1107d
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x18(%rbp)
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9b20
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9970
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xf620
testb $0x1, %al
jne 0x110c1
jmp 0x11189
leaq -0x38(%rbp), %rdi
callq 0x9fa0
movq -0x88(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x11590
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, -0x90(%rbp)
jmp 0x11122
movq -0xa8(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x8270
jmp 0x1113f
leaq -0x70(%rbp), %rdi
callq 0x11640
leaq -0x38(%rbp), %rdi
callq 0xf660
jmp 0x110ab
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x6270
jmp 0x11196
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x11640
jmp 0x11196
movq -0x18(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x64d0
nop
// File: 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
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x30, %edi
callq 0x6260
movq %rax, %rdi
movq -0x78(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rsi
callq 0x231a0
jmp 0x11a61
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa2e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa170
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1f820
testb $0x1, %al
jne 0x11aa9
jmp 0x11b6f
leaq -0x30(%rbp), %rdi
callq 0x1f860
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq 0x30(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x23320
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x11b5f
testb $0x1, -0x9(%rbp)
je 0x11b5f
movq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x230e0
movq -0x88(%rbp), %rsi
movq 0x2f4c4(%rip), %rdi     # 0x40fc8
callq 0x6240
movq %rax, -0x80(%rbp)
jmp 0x11b0f
movq -0x80(%rbp), %rdi
movq 0x2f476(%rip), %rsi     # 0x40f90
callq 0x6280
jmp 0x11b21
leaq -0x68(%rbp), %rdi
callq 0x6598
jmp 0x11b5f
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x6270
jmp 0x11b78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6598
jmp 0x11b78
jmp 0x11b61
leaq -0x30(%rbp), %rdi
callq 0x1f880
jmp 0x11a93
addq $0x90, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x64d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x30(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x236c0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq 0x30(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1f8a0
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f8d0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f900
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1f930
testb $0x1, %al
jne 0x11c07
leaq -0x30(%rbp), %rdi
callq 0x1f9b0
jmp 0x11c74
leaq -0x38(%rbp), %rdi
callq 0x1f970
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq (%rcx), %rdi
movq 0x30(%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0x21ec0
movq %rax, -0x70(%rbp)
jmp 0x11c39
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x2b200
jmp 0x11c50
jmp 0x11c52
leaq -0x38(%rbp), %rdi
callq 0x1f990
jmp 0x11beb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f9b0
jmp 0x11c7e
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x64d0
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x11c90
movq -0x28(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x11a20
movq -0x28(%rbp), %rdi
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rsi
callq 0x12420
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x12160
movq -0x28(%rbp), %rdi
callq 0x11b90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2b200
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x2b2a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3e, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x21bc7
leaq -0x19(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x64e0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x10b57(%rip), %rsi     # 0x326ef
callq 0x1f770
jmp 0x21b9f
leaq -0x19(%rbp), %rdi
callq 0x62b0
jmp 0x21c7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x62b0
jmp 0x21c89
jmp 0x21bc9
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x49(%rbp)
je 0x21bdf
cmpl $0x0, -0x18(%rbp)
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x21be8
jmp 0x21c29
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
leaq 0x10af5(%rip), %rax     # 0x326f1
movb (%rax,%rdx), %dl
movslq -0x18(%rbp), %rcx
leaq 0x1f7e6(%rip), %rax     # 0x413f0
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
jmp 0x21bc9
movslq -0x18(%rbp), %rax
leaq 0x1f7bc(%rip), %rcx     # 0x413f0
leaq 0x1(%rax,%rcx), %rax
movq %rax, -0x60(%rbp)
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x64e0
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x1f770
jmp 0x21c5d
leaq -0x2d(%rbp), %rdi
callq 0x62b0
jmp 0x21c7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x62b0
jmp 0x21c89
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x64d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x6580
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x21d2d
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x6580
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x21d2d
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x6580
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x6580
movq %rax, %rcx
movl -0x20(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x21d36
jmp 0x21d47
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x21cb8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x60(%rbp)
callq 0x63b0
movq -0x10(%rbp), %rax
movq %rax, %rcx
negq %rcx
cmovnsq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x2, %edx
callq 0x21b50
jmp 0x21dc1
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
leaq -0x40(%rbp), %rsi
callq 0x6340
leaq -0x40(%rbp), %rdi
callq 0x6598
movq -0x68(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, -0x58(%rbp)
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x18, %rdi
callq 0x61a0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x21ea8
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movq -0x58(%rbp), %rsi
callq 0x6580
movq %rax, -0x78(%rbp)
jmp 0x21e2b
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x21e60
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x21e60
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x6598
jmp 0x21eb1
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x18, %rdi
callq 0x61a0
movq %rax, %rcx
movq -0x80(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x21e95
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x5, %rcx
movq %rcx, 0x10(%rax)
jmp 0x21e97
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x21def
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x64d0
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
callq 0x20600
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x236ab
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x239e0
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x23698
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x1f8d0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x23c00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x23c40
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23c80
movq %rax, -0x38(%rbp)
jmp 0x236ab
jmp 0x2369a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x23610
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x2b0c0
jmp 0x236f6
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x20220
jmp 0x23725
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x2b3a0
movq %rax, -0x70(%rbp)
movl $0x18, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x20320
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2b3a0
movq %rax, -0x60(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq (%rax), %rdi
callq 0x230c0
movq %rax, -0x50(%rbp)
jmp 0x2378e
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x200a0
jmp 0x2379d
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x2b3a0
movq %rax, -0xc8(%rbp)
movl $0x18, %edi
movq %rdi, -0xb8(%rbp)
callq 0x6260
movq %rax, %rdi
movq %rdi, -0xc0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x202e0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x2b3a0
movq -0xb8(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x6260
movaps -0xb0(%rbp), %xmm0
movq %rax, %rdi
movq %rdi, -0x90(%rbp)
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x202e0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x2b3a0
movq %rax, -0x88(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x230c0
movq %rax, -0x78(%rbp)
jmp 0x2386b
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x200a0
jmp 0x2387a
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x2b3a0
movq -0x18(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x6270
jmp 0x23905
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x6270
jmp 0x23905
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x6270
jmp 0x23905
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x6270
movq -0x20(%rbp), %rdi
callq 0x64d0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x2393f
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x239cd
cmpq $-0x1, -0x18(%rbp)
jne 0x23954
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x239cd
movq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f8d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f900
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1f930
testb $0x1, %al
jne 0x2398d
jmp 0x239c5
leaq -0x28(%rbp), %rdi
callq 0x1f970
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x239b8
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x239cd
jmp 0x239ba
leaq -0x28(%rbp), %rdi
callq 0x1f990
jmp 0x2397a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x244f7
movq -0x48(%rbp), %rdi
leaq 0x1c177(%rip), %rsi     # 0x40658
leaq 0x1c288(%rip), %rdx     # 0x40770
xorl %eax, %eax
movl %eax, %ecx
callq 0x62f0
movq %rax, -0x58(%rbp)
jmp 0x244ff
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x244ff
movq -0x58(%rbp), %rax
cmpq $0x0, %rax
jne 0x245dd
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x247d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24800
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24830
testb $0x1, %al
jne 0x24545
jmp 0x245db
leaq -0x20(%rbp), %rdi
callq 0x24870
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x24890
testb $0x1, %al
jne 0x24570
jmp 0x245cb
movl $0x20, %edi
callq 0x6130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdx
leaq 0xe178(%rip), %rsi      # 0x3270e
callq 0x1fef0
jmp 0x2459d
movq -0x60(%rbp), %rdi
leaq 0x1c0a0(%rip), %rsi     # 0x40648
movq 0x1c9f9(%rip), %rdx     # 0x40fa8
callq 0x6490
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x61c0
jmp 0x2461d
jmp 0x245cd
leaq -0x20(%rbp), %rdi
callq 0x24920
jmp 0x2452f
jmp 0x245dd
movq -0x10(%rbp), %rdi
callq 0x25230
movq %rax, %rdi
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x24450
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x24940
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x64d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
jle 0x24693
movq -0x20(%rbp), %rdi
callq 0x249b0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x249b0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq 0x18(%rdi), %rax
subq %rcx, %rax
movq %rax, 0x18(%rdi)
callq 0x249f0
jmp 0x24648
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x247d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24800
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24830
testb $0x1, %al
jne 0x246e8
jmp 0x24772
leaq -0x20(%rbp), %rdi
callq 0x24870
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x24727
movq -0x48(%rbp), %rdi
leaq 0x1bf47(%rip), %rsi     # 0x40658
leaq 0x1c058(%rip), %rdx     # 0x40770
xorl %eax, %eax
movl %eax, %ecx
callq 0x62f0
movq %rax, -0x50(%rbp)
jmp 0x2472f
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x2472f
movq -0x50(%rbp), %rax
cmpq $0x0, %rax
jne 0x24762
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x24890
testb $0x1, %al
jne 0x24753
jmp 0x24760
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
jmp 0x24762
jmp 0x24764
leaq -0x20(%rbp), %rdi
callq 0x24920
jmp 0x246d2
movl $0x20, %edi
callq 0x6130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xdf98(%rip), %rsi      # 0x32729
callq 0x1fef0
jmp 0x24798
movq -0x58(%rbp), %rdi
leaq 0x1bea5(%rip), %rsi     # 0x40648
movq 0x1c7fe(%rip), %rdx     # 0x40fa8
callq 0x6490
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x61c0
movq -0x38(%rbp), %rdi
callq 0x64d0
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x9350
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x26073
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0xf600
movq -0x68(%rbp), %rdi
movq (%rax), %rsi
callq 0x11530
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0xf600
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq (%rcx), %rax
je 0x25ffd
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0xf600
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0xf600
movq -0x68(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x11590
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x26090
jmp 0x26045
leaq -0x48(%rbp), %rdi
callq 0x11640
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x25f6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11640
jmp 0x26081
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x64d0
nopw (%rax,%rax)