LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rockytriton[P]dreamsys_emu_gb/src/ui.cpp
// Function: dsemu::ui::updateDebugWindow()
void updateDebugWindow() {
    int xDraw = 0;
    int yDraw = 0;
    int tileNum = 0;

    for (int y=0; y<32; y++) {
        for (int x=0; x<16; x++) {
            displayTile(debugScreen, 0x8000, tileNum, xDraw + (x * scale), yDraw + (y * scale));
            xDraw += (7 * scale);
            tileNum++;
        }
        yDraw += (7 * scale);
        xDraw = 0;
    }


	SDL_UpdateTexture(sdlDebugTexture, NULL, debugScreen->pixels, debugScreen->pitch);
	SDL_RenderClear(sdlDebugRenderer);
	SDL_RenderCopy(sdlDebugRenderer, sdlDebugTexture, NULL, NULL);
	SDL_RenderPresent(sdlDebugRenderer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jge 0x232a5
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x23283
movq 0x315ee(%rip), %rdi     # 0x54820
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
movl -0x14(%rbp), %edx
imull 0xc09e(%rip), %edx      # 0x2f2e0
addl %edx, %ecx
movl -0x8(%rbp), %r8d
movl -0x10(%rbp), %edx
imull 0xc08e(%rip), %edx      # 0x2f2e0
addl %edx, %r8d
movl $0x8000, %esi           # imm = 0x8000
movzwl %ax, %edx
callq 0x23080
imull $0x7, 0xc077(%rip), %eax # 0x2f2e0
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23225
imull $0x7, 0xc056(%rip), %eax # 0x2f2e0
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x23214
movq 0x3156c(%rip), %rdi     # 0x54818
movq 0x3156d(%rip), %rax     # 0x54820
movq 0x20(%rax), %rdx
movq 0x31562(%rip), %rax     # 0x54820
movl 0x18(%rax), %ecx
xorl %eax, %eax
movl %eax, %esi
callq 0x3200
movq 0x3153f(%rip), %rdi     # 0x54810
callq 0x32a0
movq 0x31533(%rip), %rdi     # 0x54810
movq 0x31534(%rip), %rsi     # 0x54818
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x3360
movq 0x31519(%rip), %rdi     # 0x54810
callq 0x3070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::reset()
void Cedit::reset()
{
	this->content.clear();
	this->content.emplace_back("");
	this->contentIt = this->content.begin();
	this->currentIndex = 0;
	this->savedIndex = 0;
	this->entryLine = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9250
movq -0x18(%rbp), %rdi
leaq 0x95e5(%rip), %rsi      # 0xe279
callq 0x9170
movq -0x18(%rbp), %rdi
callq 0x91c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_open()
void Cedit::event_open()
{
	if(!this->menu.type(FILE_OPEN)) {
		this->refreshDisplay = false;
		return;
	}

	this->refreshHeader = true;

	this->event_load(this->menu.content.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xb0, %rdi
leaq 0x83d5(%rip), %rsi      # 0xe107
leaq 0x8540(%rip), %rdx      # 0xe279
callq 0xd910
testb $0x1, %al
jne 0x5d4c
movq -0x10(%rbp), %rax
movb $0x0, 0x6c(%rax)
jmp 0x5d70
movq -0x10(%rbp), %rdi
movb $0x1, 0x6d(%rdi)
addq $0xb0, %rdi
addq $0x18, %rdi
callq 0x4220
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x7380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_left()
void Cedit::event_left()
{
	this->refreshDisplay = false;

	if(this->currentIndex > 0)
	{
		this->currentIndex--;
		this->savedIndex = this->currentIndex;
	}
	else if(this->currentIndex == 0 && this->contentIt != this->content.begin())
	{
		this->scrollup();
		this->contentIt = std::prev(this->contentIt);

		this->currentIndex = this->contentIt->length()-1;
		this->savedIndex = this->currentIndex;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, 0x6c(%rax)
cmpq $0x0, 0x50(%rax)
jbe 0x650c
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rcx
movq %rcx, 0x58(%rax)
jmp 0x65aa
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, -0x29(%rbp)
jne 0x6544
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
callq 0x91c0
movq -0x38(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x9310
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x654d
jmp 0x65a8
movq -0x28(%rbp), %rdi
callq 0x8590
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rcx
movq %rcx, 0x58(%rax)
jmp 0x65aa
addq $0x40, %rsp
popq %rbp
retq
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_right()
void Cedit::event_right()
{
	this->refreshDisplay = false;

	const auto itEnd = std::prev(this->content.end());

	if(this->currentIndex < this->contentIt->length()-1 ||
	  (this->currentIndex < this->contentIt->length() && contentIt == itEnd)
	)
	{
		if(currentIndex == this->contentIt->length() && this->contentIt->back() != '\n')
		{
			return;
		}

		this->refreshDisplay = false;
		this->currentIndex++;
		this->savedIndex = this->currentIndex;
	}
	else if(this->contentIt != itEnd)
	{
		this->contentIt = std::next(this->contentIt);
		this->scrolldown();

		this->currentIndex = 0;
		this->savedIndex = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb $0x0, 0x6c(%rdi)
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x38(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq 0x50(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x6650
movq -0x38(%rbp), %rdi
movq 0x50(%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x66b6
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x9e30
testb $0x1, %al
jne 0x6650
jmp 0x66b6
movq -0x38(%rbp), %rdi
movq 0x50(%rdi), %rax
movq %rax, -0x48(%rbp)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0x6698
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4350
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x6698
jmp 0x6712
movq -0x38(%rbp), %rax
movb $0x0, 0x6c(%rax)
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rcx
movq %rcx, 0x58(%rax)
jmp 0x6712
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x9310
testb $0x1, %al
jne 0x66cd
jmp 0x6710
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9d90
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x18(%rdi)
callq 0x86c0
movq -0x38(%rbp), %rax
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
jmp 0x6712
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_up()
void Cedit::event_up()
{
	this->refreshDisplay = false;

	if(this->contentIt != this->content.begin())
	{
		this->scrollup();
		this->contentIt = std::prev(this->contentIt);

		if(this->contentIt->length()-1 < this->savedIndex)
		{
			this->currentIndex = this->contentIt->length()-1;
		}
		else
		{
			this->currentIndex = this->savedIndex;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, 0x6c(%rdi)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
callq 0x91c0
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x9310
testb $0x1, %al
jne 0x6762
jmp 0x67e8
movq -0x30(%rbp), %rdi
callq 0x8590
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq -0x30(%rbp), %rcx
subq $0x1, %rax
cmpq 0x58(%rcx), %rax
jae 0x67da
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movq %rcx, 0x50(%rax)
jmp 0x67e6
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rcx
movq %rcx, 0x50(%rax)
jmp 0x67e8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_down()
void Cedit::event_down()
{
	this->refreshDisplay = false;

	if(this->contentIt == std::prev(this->content.end()))
	{
		return;
	}

	this->contentIt = std::next(this->contentIt);
	this->scrolldown();

	if(this->contentIt->length() <= this->savedIndex && this->contentIt == std::prev(this->content.end()))
	{
		this->currentIndex = this->contentIt->length();
	}
	else if(this->contentIt->length()-1 < this->savedIndex)
	{
		this->currentIndex = this->contentIt->length()-1;
	}
	else
	{
		this->currentIndex = this->savedIndex;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x0, 0x6c(%rdi)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x40(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x9e30
testb $0x1, %al
jne 0x6841
jmp 0x6846
jmp 0x6958
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9d90
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x18(%rdi)
callq 0x86c0
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq -0x48(%rbp), %rdx
movq %rax, %rcx
xorl %eax, %eax
cmpq 0x58(%rdx), %rcx
movb %al, -0x49(%rbp)
ja 0x68d6
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
callq 0x92c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x9e30
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x68df
jmp 0x6901
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x6958
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq -0x48(%rbp), %rcx
subq $0x1, %rax
cmpq 0x58(%rcx), %rax
jae 0x694a
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
movq %rcx, 0x50(%rax)
jmp 0x6956
movq -0x48(%rbp), %rax
movq 0x58(%rax), %rcx
movq %rcx, 0x50(%rax)
jmp 0x6958
addq $0x60, %rsp
popq %rbp
retq
nop
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_pagedown()
void Cedit::event_pagedown()
{
	if(this->entryLine > this->content.size()-this->height)
	{
		this->contentIt = std::prev(this->content.end());
	}
	else
	{
		this->entryLine += this->height;

		// Compares long int with size_t aka unsigned long int, type cast is required
		if(std::distance(this->contentIt, this->content.end()) > (long int)this->height)
		{
			this->contentIt = std::next(this->contentIt, this->height);
		}
		else
		{
			this->contentIt = std::prev(this->content.end());
		}
	}

	this->currentIndex = 0;
	this->savedIndex = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq 0x60(%rdi), %rax
movq %rax, -0x50(%rbp)
callq 0x9590
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq 0x100(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x69cb
movq -0x58(%rbp), %rdi
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6a6a
movq -0x58(%rbp), %rdi
movq 0x100(%rdi), %rax
addq 0x60(%rdi), %rax
movq %rax, 0x60(%rdi)
movq 0x18(%rdi), %rax
movq %rax, -0x20(%rbp)
callq 0x92c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9680
movq -0x58(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jle 0x6a3a
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x100(%rax), %rsi
movq -0x38(%rbp), %rdi
callq 0x9d90
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6a68
movq -0x58(%rbp), %rdi
callq 0x92c0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6a6a
movq -0x58(%rbp), %rax
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_pageup()
void Cedit::event_pageup()
{
	if(this->entryLine < this->height)
	{
		this->entryLine = 0;
		this->contentIt = this->content.begin();
	}
	else
	{
		this->entryLine -= this->height;
		this->contentIt = std::prev(this->contentIt, this->height);
	}

	this->currentIndex = 0;
	this->savedIndex = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x60(%rcx), %rax
cmpq 0x100(%rcx), %rax
jae 0x6ad7
movq -0x28(%rbp), %rdi
movq $0x0, 0x60(%rdi)
callq 0x91c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6b18
movq -0x28(%rbp), %rax
movq 0x100(%rax), %rdx
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq 0x18(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x100(%rax), %rsi
movq -0x20(%rbp), %rdi
callq 0x9280
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_end()
void Cedit::event_end()
{
	if(contentIt != std::prev(this->content.end()))
	{
		this->currentIndex = this->contentIt->length()-1;
		this->savedIndex = this->contentIt->length()-1;
	}
	else
	{
		this->currentIndex = this->contentIt->length();
		this->savedIndex = this->contentIt->length();
	}

	this->refreshDisplay = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x9310
testb $0x1, %al
jne 0x6bbd
jmp 0x6c00
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq -0x28(%rbp), %rdi
subq $0x1, %rax
movq %rax, 0x50(%rdi)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movq %rcx, 0x58(%rax)
jmp 0x6c39
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq -0x28(%rbp), %rdi
movq %rax, 0x50(%rdi)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x6c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_goto()
void Cedit::event_goto()
{
	if(!this->menu.type("Springe zu [Zeile Spalte]: ")) {
		this->refreshDisplay = false;
		return;
	}

	std::size_t row;
	std::size_t column = 1;
	std::stringstream converter(this->menu.content);
	converter >> row >> column;
	row--;
	column--;

	if(this->content.size() > row)
	{
		this->contentIt = std::next(this->content.begin(), row);

		this->entryLine = row;

		if(this->contentIt->length() >= column)
		{
			this->currentIndex = column;
			this->savedIndex = column;
		}
		else
		{
			this->currentIndex = 0;
			this->savedIndex = 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
addq $0xb0, %rdi
leaq 0x748c(%rip), %rsi      # 0xe124
leaq 0x75da(%rip), %rdx      # 0xe279
callq 0xd910
testb $0x1, %al
jne 0x6cb8
movq -0x1c8(%rbp), %rax
movb $0x0, 0x6c(%rax)
jmp 0x6e21
movq -0x1c8(%rbp), %rax
movq $0x1, -0x18(%rbp)
addq $0xc8, %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x9e60
movq -0x1e0(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x4670
movq -0x1d8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x45e0
movq %rax, -0x1d0(%rbp)
jmp 0x6d18
movq -0x1d0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x45e0
jmp 0x6d2a
movq -0x1c8(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x9590
cmpq -0x10(%rbp), %rax
jbe 0x6e15
movq -0x1c8(%rbp), %rdi
callq 0x91c0
movq %rax, -0x1c0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x1c0(%rbp), %rdi
callq 0x9d90
movq %rax, -0x1e8(%rbp)
jmp 0x6d84
movq -0x1c8(%rbp), %rdi
movq -0x1e8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movq -0x1b8(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x60(%rdi)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
cmpq -0x18(%rbp), %rax
jb 0x6dfc
movq -0x1c8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x58(%rax)
jmp 0x6e13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x4360
jmp 0x6e2a
movq -0x1c8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
jmp 0x6e15
leaq -0x1a0(%rbp), %rdi
callq 0x4360
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x4700
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::event_change_tab()
void Cedit::event_change_tab()
{
	if(this->session.size() == 0)
	{
		return;
	}

	short int key = wgetch(this->menu.window);

	auto mapIt = this->session.find(this->filename);

	if(key == KEY_LEFT)
	{
		if(mapIt == this->session.begin())
		{
			mapIt = std::prev(this->session.end());
		}
		else
		{
			mapIt = std::prev(mapIt);
		}
	}
	else if(key == KEY_RIGHT)
	{
		if(mapIt == this->session.end() || mapIt == std::prev(this->session.end()))
		{
			mapIt = this->session.begin();
		}
		else
		{
			mapIt = std::next(mapIt);
		}
	}
	else
	{
		return;
	}

	this->event_load(mapIt->first.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x20, %rdi
callq 0x9e80
cmpq $0x0, %rax
jne 0x6e6b
jmp 0x6fef
movq -0x78(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x41d0
movq -0x78(%rbp), %rsi
movw %ax, -0xa(%rbp)
movq %rsi, %rdi
addq $0x20, %rdi
addq $0x70, %rsi
callq 0x9ca0
movq %rax, -0x18(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x104, %eax            # imm = 0x104
jne 0x6f1a
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x9ed0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9ea0
testb $0x1, %al
jne 0x6ec6
jmp 0x6ef3
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x9cd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x9f00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6f15
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x9f00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6fd2
movswl -0xa(%rbp), %eax
cmpl $0x105, %eax            # imm = 0x105
jne 0x6fce
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x9cd0
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9ea0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x79(%rbp)
jne 0x6f86
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x9cd0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x9f00
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9ea0
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x6f8f
jmp 0x6faa
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x9ed0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6fcc
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x9f40
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6fd0
jmp 0x6fef
jmp 0x6fd2
leaq -0x18(%rbp), %rdi
callq 0x9f70
movq %rax, %rdi
callq 0x4220
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x7380
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::display_header()
void Cedit::display_header()
{
	const std::string filename = this->filename.empty() ? NEW_FILE : this->filename;

	if(this->refreshHeader)
	{
		wclear(this->wheader);
		wbkgd(this->wheader, A_REVERSE);
		mvwprintw(this->wheader, 0, 2, VERSION);
		mvwprintw(this->wheader, 0, this->width / 2 - filename.size() / 2, filename.c_str());

		wrefresh(this->wheader);

		this->refreshHeader = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x70, %rdi
callq 0x46c0
movb $0x0, -0x2a(%rbp)
testb $0x1, %al
jne 0x8757
jmp 0x8780
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4710
movq -0x50(%rbp), %rdx
movb $0x1, -0x2a(%rbp)
leaq 0x58da(%rip), %rsi      # 0xe04d
leaq -0x28(%rbp), %rdi
callq 0x90c0
jmp 0x877e
jmp 0x8795
movq -0x48(%rbp), %rsi
addq $0x70, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4240
jmp 0x8793
jmp 0x8795
testb $0x1, -0x2a(%rbp)
jne 0x879d
jmp 0x87a6
leaq -0x29(%rbp), %rdi
callq 0x44a0
movq -0x48(%rbp), %rax
testb $0x1, 0x6d(%rax)
je 0x88aa
movq -0x48(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x4410
jmp 0x87c6
movq -0x48(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
callq 0x46d0
jmp 0x87dd
movq -0x48(%rbp), %rax
movq 0xa0(%rax), %rdi
leaq 0x5959(%rip), %rcx      # 0xe148
xorl %esi, %esi
movb %sil, %al
movl $0x2, %edx
callq 0x4120
jmp 0x8800
movq -0x48(%rbp), %rax
movq 0xa0(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0xf8(%rax), %rax
shrq %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4320
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq -0x68(%rbp), %rax
shrq %rcx
subl %ecx, %eax
movl %eax, -0x54(%rbp)
callq 0x4220
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %edx
movq %rax, %rcx
xorl %esi, %esi
movb %sil, %al
callq 0x4120
jmp 0x8858
movq -0x48(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x44f0
jmp 0x886a
movq -0x48(%rbp), %rax
movb $0x0, 0x6d(%rax)
jmp 0x88aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x2a(%rbp)
jne 0x8888
jmp 0x8891
leaq -0x29(%rbp), %rdi
callq 0x44a0
jmp 0x88b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x42d0
jmp 0x88b9
leaq -0x28(%rbp), %rdi
callq 0x42d0
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4700
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/cedit.cpp
// Function: cedit::Cedit::display_linenumbers(std::_List_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void Cedit::display_linenumbers(std::list<std::string>::iterator it)
{
	if(this->showLineNumbers)
	{
		const auto itBegin = this->displayFirstIt();

		std::stringstream ss;
		ss <<  " " << std::setw(3) << std::distance(itBegin, it) + this->entryLine + 1;

		wattron(this->wcontent, A_REVERSE);
		wprintw(this->wcontent, ss.str().c_str());
		wattroff(this->wcontent, A_REVERSE);

		wprintw(this->wcontent, " ");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
testb $0x1, 0x90(%rax)
je 0x8fc0
movq -0x1e8(%rbp), %rdi
callq 0x8600
movq %rax, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x4330
leaq -0x190(%rbp), %rdi
leaq 0x531f(%rip), %rsi      # 0xe144
callq 0x43f0
movq %rax, -0x1f0(%rbp)
jmp 0x8e33
movl $0x3, %edi
callq 0xa220
movl %eax, -0x1f4(%rbp)
jmp 0x8e45
movq -0x1f0(%rbp), %rdi
movl -0x1f4(%rbp), %eax
movl %eax, -0x1b0(%rbp)
movl -0x1b0(%rbp), %esi
callq 0x4510
movq %rax, -0x200(%rbp)
jmp 0x8e6c
movq -0x18(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1b8(%rbp), %rdi
movq -0x1c0(%rbp), %rsi
callq 0x9680
movq %rax, -0x208(%rbp)
jmp 0x8e9e
movq -0x200(%rbp), %rdi
movq -0x208(%rbp), %rax
movq -0x1e8(%rbp), %rcx
movq 0x60(%rcx), %rcx
leaq 0x1(%rax,%rcx), %rsi
callq 0x4110
jmp 0x8ec3
movq -0x1e8(%rbp), %rax
movq 0xa8(%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x40000, %esi          # imm = 0x40000
callq 0x4290
jmp 0x8ee1
movq -0x1e8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x210(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x43e0
jmp 0x8f0b
leaq -0x1e0(%rbp), %rdi
callq 0x4220
movq -0x210(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x4080
jmp 0x8f2a
leaq -0x1e0(%rbp), %rdi
callq 0x42d0
movq -0x1e8(%rbp), %rax
movq 0xa8(%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x40000, %esi          # imm = 0x40000
callq 0x4590
jmp 0x8f54
movq -0x1e8(%rbp), %rax
movq 0xa8(%rax), %rdi
leaq 0x51db(%rip), %rsi      # 0xe144
xorl %eax, %eax
callq 0x4080
jmp 0x8f72
leaq -0x1a0(%rbp), %rdi
callq 0x4360
jmp 0x8fc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x8fb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x42d0
leaq -0x1a0(%rbp), %rdi
callq 0x4360
jmp 0x8fc9
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x4700
nopw %cs:(%rax,%rax)
// File: JD297[P]cedit/src/main.cpp
// Function: NCURSES_INIT()
void NCURSES_INIT()
{
	initscr();
	noecho();
	cbreak();
	raw();
	keypad(stdscr, true);
	set_escdelay(100);
	set_tabsize(4);

	short bg = 0;
	short fg = 0;

	use_default_colors();
	start_color();

	// get default colors
	pair_content(0, &bg, &fg);

	// set colors with default background
	for(int i = 0; i < 8; i++)
	{
		init_pair(i, i, bg);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x4630
callq 0x4500
callq 0x4180
callq 0x4190
movq 0x5d8d(%rip), %rax      # 0x12fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x41e0
movl $0x64, %edi
callq 0x4490
movl $0x4, %edi
callq 0x44e0
movw $0x0, -0x2(%rbp)
movw $0x0, -0x4(%rbp)
callq 0x42f0
callq 0x40f0
xorl %edi, %edi
leaq -0x2(%rbp), %rsi
leaq -0x4(%rbp), %rdx
callq 0x42e0
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jge 0xd2b9
movl -0x8(%rbp), %eax
movw %ax, %cx
movl -0x8(%rbp), %eax
movswl %cx, %edi
movswl %ax, %esi
movswl -0x2(%rbp), %edx
callq 0x40a0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd290
addq $0x10, %rsp
popq %rbp
retq
nop
// File: JD297[P]cedit/src/main.cpp
// Function: cedit::arguments(int, char const**, cedit::Cedit*)
void arguments(const int argc, const char** argv, cedit::Cedit* cedit)
	{
		if(argc >= 3)
		{
			endwin();

			std::cerr << "cedit: invalid argument -- \'" << argv[2] << "\'\n";
			std::cerr << "usage: cedit [path/to/file]\n";

			exit(1);
		}
		else if(argc == 2) {
			cedit->event_load(argv[1]);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x3, -0x4(%rbp)
jl 0xd32d
callq 0x4540
movq 0x5d0b(%rip), %rdi      # 0x12ff0
leaq 0xf6e(%rip), %rsi       # 0xe25a
callq 0x43f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x43f0
movq %rax, %rdi
leaq 0xf6c(%rip), %rsi       # 0xe277
callq 0x43f0
movq 0x5cd9(%rip), %rdi      # 0x12ff0
leaq 0xf5c(%rip), %rsi       # 0xe27a
callq 0x43f0
movl $0x1, %edi
callq 0x4550
cmpl $0x2, -0x4(%rbp)
jne 0xd344
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7380
jmp 0xd346
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: JD297[P]cedit/src/main.cpp
// Function: main
int main(const int argc, const char** argv)
{
	NCURSES_INIT();

	cedit::Cedit editor;

	cedit::arguments(argc, argv, &editor);

	editor.run();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xd220
leaq -0x128(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x4930
movq -0x140(%rbp), %rdx
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xd2c0
jmp 0xd396
leaq -0x128(%rbp), %rdi
callq 0x4ce0
jmp 0xd3a4
movl $0x0, -0x4(%rbp)
leaq -0x128(%rbp), %rdi
callq 0xd3f0
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x128(%rbp), %rdi
callq 0xd3f0
movq -0x130(%rbp), %rdi
callq 0x4700
nopl (%rax)
// File: JD297[P]cedit/src/menu.cpp
// Function: cedit::Menu::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, short)
void Menu::display(std::string message, short color) {
	wclear(this->window);

	message = "[ " + message + " ]";

	wattron(this->window, COLOR_PAIR(color));
	wattron(this->window, A_REVERSE);

	mvwprintw(this->window, 0, (size_t)(getmaxx(stdscr) / 2 - message.length() / 2), message.c_str());

	wattroff(this->window, A_REVERSE);
	wattroff(this->window, COLOR_PAIR(color));

	wrefresh(this->window);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x78(%rbp)
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq (%rax), %rdi
callq 0x4410
movq -0x78(%rbp), %rdx
leaq 0xd6e(%rip), %rsi       # 0xe297
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xda90
movq -0x70(%rbp), %rsi
leaq 0xd59(%rip), %rdx       # 0xe29a
leaq -0x38(%rbp), %rdi
callq 0x9390
jmp 0xd54c
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4570
leaq -0x38(%rbp), %rdi
callq 0x42d0
leaq -0x58(%rbp), %rdi
callq 0x42d0
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movswl -0x12(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x4290
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x4290
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
xorl %eax, %eax
movq 0x5a1c(%rip), %rcx      # 0x12fd0
cmpq (%rcx), %rax
je 0xd5d2
movq 0x5a10(%rip), %rax      # 0x12fd0
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0xd5df
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x8c(%rbp)
jmp 0xd5df
movq -0x78(%rbp), %rdi
movl -0x8c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
movq %rax, -0x98(%rbp)
callq 0x4640
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movq -0x98(%rbp), %rax
shrq %rcx
subq %rcx, %rax
movl %eax, -0x90(%rbp)
callq 0x4220
movq -0x88(%rbp), %rdi
movl -0x90(%rbp), %edx
movq %rax, %rcx
xorl %esi, %esi
movb $0x0, %al
callq 0x4120
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x4590
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movswl -0x12(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x4590
movq -0x80(%rbp), %rax
movq (%rax), %rdi
callq 0x44f0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x42d0
movq -0x60(%rbp), %rdi
callq 0x4700
nopl (%rax)
// File: JD297[P]cedit/src/menu.cpp
// Function: cedit::Menu::display_type(char const*)
void Menu::display_type(const char* text) {
    wbkgd(this->window, A_REVERSE);

    wclear(this->window);
    wprintw(this->window, text);

    mvwprintw(this->window, 0, std::strlen(text), "%s", this->content.c_str());

    wmove(this->window, 0, std::strlen(text) + this->currentIndex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
movl $0x40000, %esi          # imm = 0x40000
callq 0x46d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4410
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movb $0x0, %al
callq 0x4080
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4250
movq -0x20(%rbp), %rdi
movl %eax, -0x24(%rbp)
addq $0x18, %rdi
callq 0x4220
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movq %rax, %r8
xorl %esi, %esi
leaq 0xa3d(%rip), %rcx       # 0xe157
movb $0x0, %al
callq 0x4120
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4250
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
addq 0x38(%rcx), %rax
movl %eax, %edx
xorl %esi, %esi
callq 0x4450
addq $0x30, %rsp
popq %rbp
retq
// File: JD297[P]cedit/src/menu.cpp
// Function: cedit::Menu::event_backspace()
void Menu::event_backspace() {
    if(this->currentIndex <= 0) {
        return;
    }

    this->content.erase(this->currentIndex - 1, 1);
    this->currentIndex--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x38(%rax)
ja 0xd83d
jmp 0xd86a
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x38(%rax), %rsi
subq $0x1, %rsi
movl $0x1, %edx
callq 0x4100
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: JD297[P]cedit/src/window.cpp
// Function: cedit::Window::Window(unsigned long, unsigned long, unsigned long, unsigned long)
Window::Window(size_t sizeX, std::size_t sizeY, std::size_t posX, std::size_t posY) {
    this->width = sizeX;
    this->height = sizeY;

    this->window = newwin(this->height, this->width, posY, posX);
    keypad(this->window, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
movl %ecx, %edi
movq 0x8(%rax), %rax
movl %eax, %esi
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
callq 0x4440
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movl $0x1, %esi
callq 0x41e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Bartor[P]kompilator/front/compiler.l.c
// Function: yyensure_buffer_stack()
static void yyensure_buffer_stack (void)
{
	yy_size_t num_to_alloc;
    
	if (!(yy_buffer_stack)) {

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x36260(%rip)     # 0x41380
jne 0xb185
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0xbda0
movq %rax, 0x36242(%rip)     # 0x41380
cmpq $0x0, 0x3623a(%rip)     # 0x41380
jne 0xb154
leaq 0x26f68(%rip), %rdi     # 0x320b7
callq 0xbae0
movq 0x36225(%rip), %rdi     # 0x41380
movq -0x8(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x6160
movq -0x8(%rbp), %rax
movq %rax, 0x3623b(%rip)     # 0x413b0
movq $0x0, 0x36208(%rip) # 0x41388
jmp 0xb213
movq 0x361fc(%rip), %rax     # 0x41388
movq 0x3621d(%rip), %rcx     # 0x413b0
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0xb213
movq $0x8, -0x10(%rbp)
movq 0x36205(%rip), %rax     # 0x413b0
addq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x361c6(%rip), %rdi     # 0x41380
movq -0x8(%rbp), %rsi
shlq $0x3, %rsi
callq 0xc530
movq %rax, 0x361b2(%rip)     # 0x41380
cmpq $0x0, 0x361aa(%rip)     # 0x41380
jne 0xb1e4
leaq 0x26ed8(%rip), %rdi     # 0x320b7
callq 0xbae0
movq 0x36195(%rip), %rdi     # 0x41380
movq 0x361be(%rip), %rax     # 0x413b0
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x6160
movq -0x8(%rbp), %rax
movq %rax, 0x3619d(%rip)     # 0x413b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Bartor[P]kompilator/front/compiler.l.c
// Function: yy_create_buffer(_IO_FILE*, int)
YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

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

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file );

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x40, %edi
callq 0xbda0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb250
leaq 0x26d20(%rip), %rdi     # 0x31f6b
callq 0xbae0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0xbda0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb28e
leaq 0x26ce2(%rip), %rdi     # 0x31f6b
callq 0xbae0
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbbd0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: Bartor[P]kompilator/front/compiler.l.c
// Function: yy_load_buffer_state()
static void yy_load_buffer_state  (void)
{
    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	(yy_hold_char) = *(yy_c_buf_p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x360c5(%rip), %rax     # 0x41380
movq 0x360c6(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x360d9(%rip)     # 0x413a8
movq 0x360aa(%rip), %rax     # 0x41380
movq 0x360ab(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x360a4(%rip)     # 0x41390
movq %rax, 0x3607d(%rip)     # 0x41370
movq 0x36086(%rip), %rax     # 0x41380
movq 0x36087(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x36049(%rip)     # 0x41358
movq 0x3607a(%rip), %rax     # 0x41390
movb (%rax), %al
movb %al, 0x3607a(%rip)      # 0x41398
popq %rbp
retq
// File: Bartor[P]kompilator/front/compiler.l.c
// Function: yy_get_previous_state()
static yy_state_type yy_get_previous_state (void)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    
	yy_current_state = (yy_start);

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		if ( yy_accept[yy_current_state] )
			{
			(yy_last_accepting_state) = yy_current_state;
			(yy_last_accepting_cpos) = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 122 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x36052(%rip), %eax     # 0x4137c
movl %eax, -0x4(%rbp)
movq 0x3603c(%rip), %rax     # 0x41370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x3604d(%rip), %rax     # 0x41390
jae 0xb42f
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb36b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x2642e(%rip), %rax     # 0x31790
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
jmp 0xb375
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb375
movl -0x18(%rbp), %eax
movb %al, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2650a(%rip), %rax     # 0x31890
cmpw $0x0, (%rax,%rcx,2)
je 0xb3a1
movl -0x4(%rbp), %eax
movl %eax, 0x36006(%rip)     # 0x4139c
movq -0x10(%rbp), %rax
movq %rax, 0x35fff(%rip)     # 0x413a0
jmp 0xb3a3
movslq -0x4(%rbp), %rcx
leaq 0x26742(%rip), %rax     # 0x31af0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x265ce(%rip), %rax     # 0x31990
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0xb3f8
movslq -0x4(%rbp), %rcx
leaq 0x2681a(%rip), %rax     # 0x31bf0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x7a, -0x4(%rbp)
jl 0xb3f6
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x26900(%rip), %rax     # 0x31cf0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0xb3a3
movslq -0x4(%rbp), %rcx
leaq 0x266ed(%rip), %rax     # 0x31af0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x26909(%rip), %rax     # 0x31d20
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb338
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Bartor[P]kompilator/front/compiler.l.c
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

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

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x35f42(%rip), %rax     # 0x41390
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2642f(%rip), %rax     # 0x31890
cmpw $0x0, (%rax,%rcx,2)
je 0xb47c
movl -0x4(%rbp), %eax
movl %eax, 0x35f2b(%rip)     # 0x4139c
movq -0x10(%rbp), %rax
movq %rax, 0x35f24(%rip)     # 0x413a0
jmp 0xb47e
movslq -0x4(%rbp), %rcx
leaq 0x26667(%rip), %rax     # 0x31af0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x264f3(%rip), %rax     # 0x31990
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0xb4d3
movslq -0x4(%rbp), %rcx
leaq 0x2673f(%rip), %rax     # 0x31bf0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x7a, -0x4(%rbp)
jl 0xb4d1
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x26825(%rip), %rax     # 0x31cf0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0xb47e
movslq -0x4(%rbp), %rcx
leaq 0x26612(%rip), %rax     # 0x31af0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2682e(%rip), %rax     # 0x31d20
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x79, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xb515
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0xb51b
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: Bartor[P]kompilator/front/compiler.l.c
// Function: yyrestart(_IO_FILE*)
void yyrestart  (FILE * input_file )
{
    
	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE );
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x3584c(%rip)     # 0x41380
je 0xbb4e
movq 0x35843(%rip), %rax     # 0x41380
movq 0x35844(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xbb56
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xbb56
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
jne 0xbb8b
callq 0xb110
movq 0x357ec(%rip), %rdi     # 0x41358
movl $0x4000, %esi           # imm = 0x4000
callq 0xb220
movq %rax, %rdx
movq 0x35800(%rip), %rax     # 0x41380
movq 0x35801(%rip), %rcx     # 0x41388
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, 0x357ed(%rip)     # 0x41380
je 0xbbad
movq 0x357e4(%rip), %rax     # 0x41380
movq 0x357e5(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xbbb5
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xbbb5
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbbd0
callq 0xb2b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Bartor[P]kompilator/front/compiler.l.c
// Function: yy_init_buffer(yy_buffer_state*, _IO_FILE*)
static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )

{
	int oerrno = errno;
    
	yy_flush_buffer( b );

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

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

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6040
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbe70
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x35767(%rip)     # 0x41380
je 0xbc33
movq 0x3575e(%rip), %rax     # 0x41380
movq 0x3575f(%rip), %rcx     # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0xbc3b
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xbc3b
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
je 0xbc5e
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xbc85
movq -0x10(%rbp), %rdi
callq 0x62a0
movl %eax, %edi
callq 0x64c0
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0xbc8c
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xbc8c
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x6040
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)