LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::RandomForOramMT()
void RandomForOram::RandomForOramMT() {

	if (this->is_initialized) {
		throw new runtime_error("ONLY ONE RANDOM INSTANCE CAN BE USED AT A TIME");
	}

	std::random_device seed1;
	std::mt19937 mt_generator(seed1()); 

	this->rand_history = vector<int>();
	is_initialized  = true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2770, %rsp           # imm = 0x2770
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2748(%rbp)
testb $0x1, 0xc247(%rip)      # 0x1e238
je 0x1208d
movl $0x8, %edi
callq 0x30d0
movq %rax, -0x2758(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x2750(%rbp)
jmp 0x1201b
movq -0x2750(%rbp), %rdi
leaq 0x42e7(%rip), %rsi      # 0x16310
callq 0x30a0
jmp 0x12030
movq -0x2758(%rbp), %rdi
movq -0x2750(%rbp), %rax
movq %rax, (%rdi)
leaq 0xbaa8(%rip), %rsi      # 0x1daf0
xorl %eax, %eax
movl %eax, %edx
callq 0x3370
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1207c
movq -0x2750(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x2758(%rbp), %rdi
callq 0x3160
jmp 0x12142
leaq -0x13a0(%rbp), %rdi
movq %rdi, -0x2768(%rbp)
callq 0x12690
movq -0x2768(%rbp), %rdi
callq 0x12730
movl %eax, -0x275c(%rbp)
jmp 0x120b4
movl -0x275c(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x2728(%rbp), %rdi
callq 0x12750
jmp 0x120cc
leaq -0x2740(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3100
leaq -0x2740(%rbp), %rdi
callq 0x6c30
movq -0x2748(%rbp), %rdi
addq $0x8, %rdi
leaq -0x2740(%rbp), %rsi
callq 0x125f0
leaq -0x2740(%rbp), %rdi
callq 0x6f40
movb $0x1, 0xc123(%rip)      # 0x1e238
leaq -0x13a0(%rbp), %rdi
callq 0x12780
addq $0x2770, %rsp           # imm = 0x2770
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x13a0(%rbp), %rdi
callq 0x12780
movq -0x10(%rbp), %rdi
callq 0x33a0
nopl (%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::getRandomLeafMT()
int RandomForOram::getRandomLeafMT() {
	long next = mt_generator();
	int randVal = next % this->bound;
	this->rand_history.push_back(randVal);
	return randVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0x127b0
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0xc0ac(%rip), %rcx      # 0x1e22c
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x14(%rbp)
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x6d00
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::RandomForOramLCG()
void RandomForOram::RandomForOramLCG() {

	if (this->is_initialized) {
		throw new runtime_error("ONLY ONE RANDOM INSTANCE CAN BE USED AT A TIME");
	}
	linear_congruential_engine<unsigned long, 0x5DEECE66DL, 11, 281474976710656> rnd_generator;
	rnd_generator.seed(0L);
	this->seed = (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1);
	this->rand_history = vector<int>();
	is_initialized  = true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0xc07d(%rip)      # 0x1e238
je 0x1223b
movl $0x8, %edi
callq 0x30d0
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0x121db
movq -0x48(%rbp), %rdi
leaq 0x412a(%rip), %rsi      # 0x16310
callq 0x30a0
jmp 0x121ed
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, (%rdi)
leaq 0xb8f1(%rip), %rsi      # 0x1daf0
xorl %eax, %eax
movl %eax, %edx
callq 0x3370
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x12230
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x50(%rbp), %rdi
callq 0x3160
jmp 0x122ba
leaq -0x20(%rbp), %rdi
callq 0x124e0
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12870
movq -0x40(%rbp), %rax
movabsq $0x5deece66d, %rcx      # imm = 0x5DEECE66D
xorq 0x13b0(%rax), %rcx
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq %rdx, %rcx
movq %rcx, 0x13b0(%rax)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3100
leaq -0x38(%rbp), %rdi
callq 0x6c30
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x125f0
leaq -0x38(%rbp), %rdi
callq 0x6f40
movb $0x1, 0xbf84(%rip)      # 0x1e238
addq $0x50, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::getRandomLeafLCG()
int RandomForOram::getRandomLeafLCG() {
	long next = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);//rnd_generator();
	this->seed = next;
	int bits = next >> (48 - 31);
	int randVal = 0;
	if ((this->bound & -this->bound) == this->bound) {  // i.e., bound is a power of 2
    	randVal = (int)((this->bound * (long)bits) >> 31);
    	return randVal;
    }
	int val = bits % this->bound;
	while (bits - val + (bound-1) < 0) {
		next = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);//rnd_generator();
		this->seed = next;
		bits = next >> (48 - 31);
		val = bits % this->bound;
	}
	randVal = val;
	this->rand_history.push_back(randVal);
	return randVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movabsq $0x5deece66d, %rcx      # imm = 0x5DEECE66D
imulq 0x13b0(%rax), %rcx
addq $0xb, %rcx
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x13b0(%rax)
movq -0x18(%rbp), %rax
sarq $0x11, %rax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl 0xbefe(%rip), %eax      # 0x1e22c
xorl %ecx, %ecx
subl 0xbef6(%rip), %ecx      # 0x1e22c
andl %ecx, %eax
cmpl 0xbeee(%rip), %eax      # 0x1e22c
jne 0x12361
movslq 0xbee5(%rip), %rax      # 0x1e22c
movslq -0x1c(%rbp), %rcx
imulq %rcx, %rax
sarq $0x1f, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x123f1
movl -0x1c(%rbp), %eax
cltd
idivl 0xbec1(%rip)            # 0x1e22c
movl %edx, -0x24(%rbp)
movl -0x1c(%rbp), %eax
subl -0x24(%rbp), %eax
movl 0xbeb2(%rip), %ecx      # 0x1e22c
subl $0x1, %ecx
addl %ecx, %eax
cmpl $0x0, %eax
jge 0x123d4
movq -0x30(%rbp), %rax
movabsq $0x5deece66d, %rcx      # imm = 0x5DEECE66D
imulq 0x13b0(%rax), %rcx
addq $0xb, %rcx
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x13b0(%rax)
movq -0x18(%rbp), %rax
sarq $0x11, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cltd
idivl 0xbe5d(%rip)            # 0x1e22c
movl %edx, -0x24(%rbp)
jmp 0x1236e
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x6d00
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/ServerStorage.cpp
// Function: ServerStorage::setCapacity(int)
void ServerStorage::setCapacity(int totalNumOfBuckets) {
	if (this->is_capacity_set) {
		throw new runtime_error("Capacity of ServerStorage cannot be changed");
	}
	this->is_capacity_set = true;
	this->capacity = totalNumOfBuckets;
	this->buckets.assign(totalNumOfBuckets, Bucket());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0xab1d(%rip)      # 0x1e23b
je 0x1379e
movl $0x8, %edi
callq 0x30d0
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0x1373e
movq -0x48(%rbp), %rdi
leaq 0x2ced(%rip), %rsi      # 0x16436
callq 0x30a0
jmp 0x13750
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, (%rdi)
leaq 0xa38e(%rip), %rsi      # 0x1daf0
xorl %eax, %eax
movl %eax, %edx
callq 0x3370
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x13793
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x50(%rbp), %rdi
callq 0x3160
jmp 0x13803
movq -0x40(%rbp), %rax
movb $0x1, 0xaa92(%rip)      # 0x1e23b
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
addq $0x8, %rax
movq %rax, -0x68(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x41c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x141e0
jmp 0x137df
leaq -0x38(%rbp), %rdi
callq 0xcfd0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcfd0
movq -0x18(%rbp), %rdi
callq 0x33a0
nopl (%rax)
// File: obliviousram[P]oblivious-avl-tree/src/main.cpp
// Function: main
int main() {
    CorrectnessTester* tester = new CorrectnessTester;
    //make sure ONLY ONE runTester is uncommented before compiling
    // tester->runTester1();
    tester->runTester2();
    delete tester;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x1, %edi
callq 0x3210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x15da0
jmp 0x15d3a
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66c0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x15d67
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3220
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x1, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::run_editor()
int Editor::run_editor() {

    while (!m_stopped) {
        if (m_contents->size() == 0) {
            m_contents->push_back("");
        }

        print_contents_on_line(m_current_line);
        
        char input = Utils::getch();
        switch (input) {
        case 'e':
            edit_command();
            break;
        case 'm':
            move_to_command();
            break;
        case 'w':
            write_command();
            break;
        case 'q':
            quit_command();
            break;
        case 'd':
            delete_and_clamp_command();
            break;
        case 'a':
            append_after_command();
            break;
        case 'b':
            prepend_before_command();
            break;
        case 's':
            swap_lines_command();
            break;
        default:
            std::cout << "Not a recognized command " << input << ".\n";
            break;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movb 0x2c(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2626
jmp 0x2783
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x36e0
cmpq $0x0, %rax
jne 0x26be
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x23b0
movq -0x50(%rbp), %rdx
leaq 0x4a4e(%rip), %rsi      # 0x70ad
leaq -0x28(%rbp), %rdi
callq 0x3730
jmp 0x266a
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3700
jmp 0x2679
leaq -0x28(%rbp), %rdi
callq 0x2120
leaq -0x29(%rbp), %rdi
callq 0x2210
jmp 0x26be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x26b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
leaq -0x29(%rbp), %rdi
callq 0x2210
jmp 0x278b
movq -0x48(%rbp), %rdi
movl 0x28(%rdi), %esi
callq 0x27a0
callq 0x64e0
movb %al, -0x3d(%rbp)
movsbl -0x3d(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x60(%rbp)
subl $0x16, %eax
ja 0x2750
movq -0x60(%rbp), %rax
leaq 0x4915(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rdi
callq 0x2940
jmp 0x277e
movq -0x48(%rbp), %rdi
callq 0x2a10
jmp 0x277e
movq -0x48(%rbp), %rdi
callq 0x2af0
jmp 0x277e
movq -0x48(%rbp), %rdi
callq 0x2b50
jmp 0x277e
movq -0x48(%rbp), %rdi
callq 0x2bb0
jmp 0x277e
movq -0x48(%rbp), %rdi
callq 0x2c90
jmp 0x277e
movq -0x48(%rbp), %rdi
callq 0x2d70
jmp 0x277e
movq -0x48(%rbp), %rdi
callq 0x2e50
jmp 0x277e
movq 0x8879(%rip), %rdi      # 0xafd0
leaq 0x4902(%rip), %rsi      # 0x7060
callq 0x21d0
movq %rax, %rdi
movsbl -0x3d(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0x4903(%rip), %rsi      # 0x707c
callq 0x21d0
jmp 0x2614
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::print_contents_on_line(int) const
int Editor::print_contents_on_line(int line) const {
    Utils::clear_screen();

    int file_length = m_contents->size();
    int line_diff = Utils::window_height() / 2 - 2;
    int start_line = std::max(0, line - line_diff);
    int end_line = std::max(0, std::min(file_length - 1, line + line_diff));

    int line_number_width = Utils::count_digits(m_contents->size());

    if (start_line != 0) {
        std::cout << "...\n";
    }

    for (int i = start_line; i <= end_line; i++) {
        if (i == line) {
            std::cout << "> ";
        }

        std::cout << std::setw(line_number_width) << i;
        std::cout << " " << m_contents->at(i) << '\n';
    }

    if (end_line != file_length - 1) {
        std::cout << "...\n";
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x65f0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x36e0
movl %eax, -0x10(%rbp)
callq 0x65c0
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x2, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x37e0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3820
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x37e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x36e0
movl %eax, %edi
callq 0x6640
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2869
movq 0x8773(%rip), %rdi      # 0xafd0
leaq 0x4816(%rip), %rsi      # 0x707a
callq 0x21d0
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x290c
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x2896
movq 0x8746(%rip), %rdi      # 0xafd0
leaq 0x47ee(%rip), %rsi      # 0x707f
callq 0x21d0
movl -0x34(%rbp), %edi
callq 0x3860
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
movq 0x8725(%rip), %rdi      # 0xafd0
callq 0x2250
movq %rax, %rdi
movl -0x38(%rbp), %esi
callq 0x2390
movq 0x870e(%rip), %rdi      # 0xafd0
leaq 0x47b7(%rip), %rsi      # 0x7080
callq 0x21d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
movslq -0x38(%rbp), %rsi
callq 0x3880
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2270
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x286f
movl -0x24(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x292c
movq 0x86b0(%rip), %rdi      # 0xafd0
leaq 0x4753(%rip), %rsi      # 0x707a
callq 0x21d0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::edit_command()
int Editor::edit_command() {
    std::cout << "Edit which line? ";
    int line;
    std::cin >> line; 
    if (std::cin.fail() || line < 0) {
        std::cout << "Not a valid line number!\n";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        return 1;
    }

    return edit_line(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8675(%rip), %rdi      # 0xafd0
leaq 0x4720(%rip), %rsi      # 0x7082
callq 0x21d0
movq 0x8672(%rip), %rdi      # 0xafe0
leaq -0x14(%rbp), %rsi
callq 0x2110
movq 0x8662(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8658(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x299b
cmpl $0x0, -0x14(%rbp)
jge 0x29ec
movq 0x862e(%rip), %rdi      # 0xafd0
leaq 0x46eb(%rip), %rsi      # 0x7094
callq 0x21d0
movq 0x862b(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8621(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2370
callq 0x38c0
movq %rax, %rsi
movq 0x8607(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
movl $0x1, -0x4(%rbp)
jmp 0x29fb
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2ff0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::move_to_command()
int Editor::move_to_command() {
    std::cout << "Move to which line? ";
    int line;
    std::cin >> line;
    if (std::cin.fail() || line < 0 || line >= (int) m_contents->size()) {
        std::cout << "Not a valid line number!\n";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        return 1;
    }

    return move_to_line(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x85a5(%rip), %rdi      # 0xafd0
leaq 0x467c(%rip), %rsi      # 0x70ae
callq 0x21d0
movq 0x85a2(%rip), %rdi      # 0xafe0
leaq -0x14(%rbp), %rsi
callq 0x2110
movq 0x8592(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8588(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x2a87
cmpl $0x0, -0x14(%rbp)
jl 0x2a87
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jl 0x2ad8
movq 0x8542(%rip), %rdi      # 0xafd0
leaq 0x45ff(%rip), %rsi      # 0x7094
callq 0x21d0
movq 0x853f(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8535(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2370
callq 0x38c0
movq %rax, %rsi
movq 0x851b(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
movl $0x1, -0x4(%rbp)
jmp 0x2ae7
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3190
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: jantuomi[P]me/editor.cpp
// Function: Editor::write_command()
int Editor::write_command() {
    std::cout << "Write to file? [y/n] ";
    char answer = Utils::getch();

    if (answer == 'y') {
        return write();
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x84c5(%rip), %rdi      # 0xafd0
leaq 0x45b1(%rip), %rsi      # 0x70c3
callq 0x21d0
callq 0x64e0
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x79, %eax
jne 0x2b36
movq -0x20(%rbp), %rdi
callq 0x31b0
movl %eax, -0x4(%rbp)
jmp 0x2b3d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::quit_command()
int Editor::quit_command() {
    std::cout << "Really quit? [y/n] ";
    char answer = Utils::getch();

    if (answer == 'y') {
        m_stopped = true;
        std::cout << "\n";
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8465(%rip), %rdi      # 0xafd0
leaq 0x4586(%rip), %rsi      # 0x70f8
callq 0x21d0
callq 0x64e0
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x79, %eax
jne 0x2ba3
movq -0x18(%rbp), %rax
movb $0x1, 0x2c(%rax)
movq 0x8439(%rip), %rdi      # 0xafd0
leaq 0x450e(%rip), %rsi      # 0x70ac
callq 0x21d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::delete_and_clamp_command()
int Editor::delete_and_clamp_command() {
    std::cout << "Delete and clamp which line? ";
    int line;
    std::cin >> line;
    if (std::cin.fail() || line < 0 || line >= (int) m_contents->size()) {
        std::cout << "Not a valid line number!\n";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        return 1;
    }

    return delete_and_clamp(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8405(%rip), %rdi      # 0xafd0
leaq 0x453a(%rip), %rsi      # 0x710c
callq 0x21d0
movq 0x8402(%rip), %rdi      # 0xafe0
leaq -0x14(%rbp), %rsi
callq 0x2110
movq 0x83f2(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x83e8(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x2c27
cmpl $0x0, -0x14(%rbp)
jl 0x2c27
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jl 0x2c78
movq 0x83a2(%rip), %rdi      # 0xafd0
leaq 0x445f(%rip), %rsi      # 0x7094
callq 0x21d0
movq 0x839f(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8395(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2370
callq 0x38c0
movq %rax, %rsi
movq 0x837b(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
movl $0x1, -0x4(%rbp)
jmp 0x2c87
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3390
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: jantuomi[P]me/editor.cpp
// Function: Editor::append_after_command()
int Editor::append_after_command() {
    std::cout << "Append after which line? ";
    int line;
    std::cin >> line;
    if (std::cin.fail() || line < 0 || line >= (int) m_contents->size()) {
        std::cout << "Not a valid line number!\n";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        return 1;
    }

    return append_after_line(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8325(%rip), %rdi      # 0xafd0
leaq 0x4478(%rip), %rsi      # 0x712a
callq 0x21d0
movq 0x8322(%rip), %rdi      # 0xafe0
leaq -0x14(%rbp), %rsi
callq 0x2110
movq 0x8312(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8308(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x2d07
cmpl $0x0, -0x14(%rbp)
jl 0x2d07
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jl 0x2d58
movq 0x82c2(%rip), %rdi      # 0xafd0
leaq 0x437f(%rip), %rsi      # 0x7094
callq 0x21d0
movq 0x82bf(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x82b5(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2370
callq 0x38c0
movq %rax, %rsi
movq 0x829b(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
movl $0x1, -0x4(%rbp)
jmp 0x2d67
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x33f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: jantuomi[P]me/editor.cpp
// Function: Editor::prepend_before_command()
int Editor::prepend_before_command() {
    std::cout << "Prepend before which line? ";
    int line;
    std::cin >> line;
    if (std::cin.fail() || line < 0 || line >= (int) m_contents->size()) {
        std::cout << "Not a valid line number!\n";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        return 1;
    }

    return prepend_before_line(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8245(%rip), %rdi      # 0xafd0
leaq 0x43b2(%rip), %rsi      # 0x7144
callq 0x21d0
movq 0x8242(%rip), %rdi      # 0xafe0
leaq -0x14(%rbp), %rsi
callq 0x2110
movq 0x8232(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8228(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x2de7
cmpl $0x0, -0x14(%rbp)
jl 0x2de7
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jl 0x2e38
movq 0x81e2(%rip), %rdi      # 0xafd0
leaq 0x429f(%rip), %rsi      # 0x7094
callq 0x21d0
movq 0x81df(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x81d5(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2370
callq 0x38c0
movq %rax, %rsi
movq 0x81bb(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
movl $0x1, -0x4(%rbp)
jmp 0x2e47
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3500
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: jantuomi[P]me/editor.cpp
// Function: Editor::swap_lines_command()
int Editor::swap_lines_command() {

    std::cout << "First line to swap? ";
    int first;
    std::cin >> first;
    if (std::cin.fail() || first < 0 || first >= (int) m_contents->size()) {
        std::cout << "Not a valid line number!\n";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        return 1;
    }

    std::cout << "Second line to swap? ";
    int second;
    std::cin >> second;
    if (std::cin.fail() || second < 0 || second >= (int) m_contents->size()) {
        std::cout << "Not a valid line number!\n";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        return 1;
    }

    return swap_lines(first, second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8165(%rip), %rdi      # 0xafd0
leaq 0x42ee(%rip), %rsi      # 0x7160
callq 0x21d0
movq 0x8162(%rip), %rdi      # 0xafe0
leaq -0x14(%rbp), %rsi
callq 0x2110
movq 0x8152(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8148(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x2ec7
cmpl $0x0, -0x14(%rbp)
jl 0x2ec7
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jl 0x2f1b
movq 0x8102(%rip), %rdi      # 0xafd0
leaq 0x41bf(%rip), %rsi      # 0x7094
callq 0x21d0
movq 0x80ff(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x80f5(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2370
callq 0x38c0
movq %rax, %rsi
movq 0x80db(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
movl $0x1, -0x4(%rbp)
jmp 0x2fe1
movq 0x80ae(%rip), %rdi      # 0xafd0
leaq 0x424c(%rip), %rsi      # 0x7175
callq 0x21d0
movq 0x80ab(%rip), %rdi      # 0xafe0
leaq -0x18(%rbp), %rsi
callq 0x2110
movq 0x809b(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x8091(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x2f7e
cmpl $0x0, -0x18(%rbp)
jl 0x2f7e
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, -0x28(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jl 0x2fcf
movq 0x804b(%rip), %rdi      # 0xafd0
leaq 0x4108(%rip), %rsi      # 0x7094
callq 0x21d0
movq 0x8048(%rip), %rax      # 0xafe0
movq (%rax), %rax
movq 0x803e(%rip), %rdi      # 0xafe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2370
callq 0x38c0
movq %rax, %rsi
movq 0x8024(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
movl $0x1, -0x4(%rbp)
jmp 0x2fe1
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x35f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::edit_line(int)
int Editor::edit_line(int line) {

    if (line >= (int) m_contents->size()) {
        m_contents->resize(line + 1, "");
    }

    std::cout << "> ";
    std::string input;

    std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
    std::getline(std::cin, input);
    std::cin.clear();
    (*m_contents)[line] = input;

    move_to_line(line);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x6c(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jl 0x30c3
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
incl %eax
cltq
movq %rax, -0x88(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x23b0
movq -0x80(%rbp), %rdx
leaq 0x4053(%rip), %rsi      # 0x70ad
leaq -0x30(%rbp), %rdi
callq 0x3730
jmp 0x3065
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x38d0
jmp 0x307e
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x31(%rbp), %rdi
callq 0x2210
jmp 0x30c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x30b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x31(%rbp), %rdi
callq 0x2210
jmp 0x317b
movq 0x7f06(%rip), %rdi      # 0xafd0
leaq 0x3fae(%rip), %rsi      # 0x707f
callq 0x21d0
leaq -0x68(%rbp), %rdi
callq 0x22d0
callq 0x38c0
movq %rax, %rsi
movq 0x7ef2(%rip), %rdi      # 0xafe0
movl $0xa, %edx
callq 0x2130
jmp 0x30fa
movq 0x7edf(%rip), %rdi      # 0xafe0
leaq -0x68(%rbp), %rsi
callq 0x2060
jmp 0x310c
movq 0x7ecd(%rip), %rdi      # 0xafe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x2370
jmp 0x3126
movq -0x78(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rsi
callq 0x3980
movq %rax, %rdi
leaq -0x68(%rbp), %rsi
callq 0x2040
jmp 0x3144
movq -0x78(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3190
jmp 0x3152
leaq -0x68(%rbp), %rdi
callq 0x2120
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2120
movq -0x40(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::write()
int Editor::write() {
    std::ofstream file;
    file.open(m_filename);
    if (file.fail()) {
        std::cout << "Can't open file " << m_filename << " for writing!";
        return 1;
    }

    for (int i = 0; i < (int) m_contents->size(); i++) {
        file << m_contents->at(i) << '\n';
    }

    file.close();
    
    return 0;   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x2380
movq -0x238(%rbp), %rsi
movq -0x230(%rbp), %rdi
addq $0x8, %rsi
movl $0x10, %edx
callq 0x20d0
jmp 0x31fb
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x2030
movb %al, -0x239(%rbp)
jmp 0x321b
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x322a
jmp 0x32b4
movq 0x7d9f(%rip), %rdi      # 0xafd0
leaq 0x3ea1(%rip), %rsi      # 0x70d9
callq 0x21d0
movq %rax, -0x248(%rbp)
jmp 0x3246
movq -0x248(%rbp), %rdi
movq -0x238(%rbp), %rsi
addq $0x8, %rsi
callq 0x21c0
movq %rax, -0x250(%rbp)
jmp 0x3266
movq -0x250(%rbp), %rdi
leaq 0x3e76(%rip), %rsi      # 0x70ea
callq 0x21d0
jmp 0x327b
movl $0x1, -0x4(%rbp)
movl $0x1, -0x220(%rbp)
jmp 0x3369
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2320
jmp 0x3381
movl $0x0, -0x224(%rbp)
movq -0x238(%rbp), %rax
movl -0x224(%rbp), %ecx
movl %ecx, -0x254(%rbp)
movq (%rax), %rdi
callq 0x36e0
movq %rax, %rcx
movl -0x254(%rbp), %eax
cmpl %ecx, %eax
jge 0x334a
movq -0x238(%rbp), %rax
movq (%rax), %rdi
movslq -0x224(%rbp), %rsi
callq 0x3880
movq %rax, -0x260(%rbp)
jmp 0x3305
movq -0x260(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x21c0
movq %rax, -0x268(%rbp)
jmp 0x3321
movq -0x268(%rbp), %rdi
movl $0xa, %esi
callq 0x2270
jmp 0x3334
jmp 0x3336
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x32be
leaq -0x210(%rbp), %rdi
callq 0x22f0
jmp 0x3358
movl $0x0, -0x4(%rbp)
movl $0x1, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2320
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x23a0
nopl (%rax)
// File: jantuomi[P]me/editor.cpp
// Function: Editor::swap_lines(int, int)
int Editor::swap_lines(int first, int second) {
    std::string first_str = m_contents->at(first);
    std::string second_str = m_contents->at(second);

    (*m_contents)[first] = second_str;
    (*m_contents)[second] = first_str;

    move_to_line(first);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rax), %rdi
movslq -0xc(%rbp), %rsi
callq 0x3880
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x20b0
movq -0x70(%rbp), %rax
movq (%rax), %rdi
movslq -0x10(%rbp), %rsi
callq 0x3880
movq %rax, -0x68(%rbp)
jmp 0x3638
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x20b0
jmp 0x3647
movq -0x70(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rsi
callq 0x3980
movq %rax, %rdi
leaq -0x50(%rbp), %rsi
callq 0x2040
jmp 0x3665
movq -0x70(%rbp), %rax
movq (%rax), %rdi
movslq -0x10(%rbp), %rsi
callq 0x3980
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2040
jmp 0x3683
movq -0x70(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3190
leaq -0x50(%rbp), %rdi
callq 0x2120
leaq -0x30(%rbp), %rdi
callq 0x2120
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x36cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2120
leaq -0x30(%rbp), %rdi
callq 0x2120
movq -0x58(%rbp), %rdi
callq 0x23a0
nop
// File: jantuomi[P]me/main.cpp
// Function: read_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string>* read_file(const std::string& filename) {
    std::ifstream file(filename);

    if (file.fail())
        return nullptr;

    std::string str;
    std::vector<std::string>* file_contents = new std::vector<std::string>();
    while (std::getline(file, str)) {
        file_contents->push_back(str);
    }
    
    return file_contents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2350
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x2030
movb %al, -0x251(%rbp)
jmp 0x5d44
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x5d50
jmp 0x5d7e
movq $0x0, -0x8(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x5e68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x5e81
leaq -0x248(%rbp), %rdi
callq 0x22d0
movl $0x18, %edi
callq 0x21e0
movq %rax, -0x260(%rbp)
jmp 0x5d9d
movq -0x260(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20f0
movq -0x260(%rbp), %rdi
callq 0x6050
movq -0x260(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x2060
movq %rax, -0x268(%rbp)
jmp 0x5de6
movq -0x268(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22b0
movb %al, -0x269(%rbp)
jmp 0x5e04
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x5e10
jmp 0x5e47
movq -0x250(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x6070
jmp 0x5e25
jmp 0x5dca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2120
jmp 0x5e81
movq -0x250(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2120
leaq -0x218(%rbp), %rdi
callq 0x2070
movq -0x8(%rbp), %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x2070
movq -0x220(%rbp), %rdi
callq 0x23a0
nopl (%rax)
// File: jantuomi[P]me/main.cpp
// Function: main
int main(int argc, char** argv) {
    if (argc < 2) {
        std::cout << "Please provide a file path.\n";
        return 1;
    }

    std::string filepath(argv[1]);
    std::vector<std::string>* contents = read_file(filepath);
    if (contents == nullptr) {
        std::cout << "Error reading file.\n";
        return 1;
    }

    Editor editor(contents, filepath);
    editor.run_editor();

    delete contents;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x5ede
movq 0x510a(%rip), %rdi      # 0xafd0
leaq 0x1363(%rip), %rsi      # 0x7230
callq 0x21d0
movl $0x1, -0x4(%rbp)
jmp 0x6034
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x23b0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3730
jmp 0x5f16
leaq -0x31(%rbp), %rdi
callq 0x2210
leaq -0x30(%rbp), %rdi
callq 0x5d00
movq %rax, -0xa0(%rbp)
jmp 0x5f31
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x5f96
movq 0x5086(%rip), %rdi      # 0xafd0
leaq 0x12fc(%rip), %rsi      # 0x724d
callq 0x21d0
jmp 0x5f58
movl $0x1, -0x4(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x601e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2210
jmp 0x6040
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6029
movq -0x50(%rbp), %rsi
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x25b0
jmp 0x5fac
leaq -0x88(%rbp), %rdi
callq 0x2600
jmp 0x5fba
movq -0x50(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x5fe8
movq -0xa8(%rbp), %rdi
callq 0x60e0
movq -0xa8(%rbp), %rdi
movl $0x18, %esi
callq 0x21f0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6140
jmp 0x601e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6140
jmp 0x6029
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0x6034
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0x6040
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23a0
nopl (%rax)
// File: jantuomi[P]me/utils.cpp
// Function: Utils::getch()
char Utils::getch(){
    char buf=0;
    struct termios old={0};
    fflush(stdout);
    if(tcgetattr(0, &old)<0)
        perror("tcsetattr()");
    old.c_lflag&=~ICANON;
    old.c_lflag&=~ECHO;
    old.c_cc[VMIN]=1;
    old.c_cc[VTIME]=0;
    if(tcsetattr(0, TCSANOW, &old)<0)
        perror("tcsetattr ICANON");
    if(read(0,&buf,1)<0)
        perror("read()");
    old.c_lflag|=ICANON;
    old.c_lflag|=ECHO;
    if(tcsetattr(0, TCSADRAIN, &old)<0)
        perror ("tcsetattr ~ICANON");
    //printf("%c\n",buf);
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb $0x0, -0x1(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x20f0
movq 0x4ab5(%rip), %rax      # 0xafb8
movq (%rax), %rdi
callq 0x2280
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
callq 0x2240
cmpl $0x0, %eax
jge 0x6527
leaq 0xd40(%rip), %rdi       # 0x7262
callq 0x2190
movl -0x34(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x34(%rbp)
movb $0x1, -0x29(%rbp)
movb $0x0, -0x2a(%rbp)
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl %esi, %edi
callq 0x22c0
cmpl $0x0, %eax
jge 0x655f
leaq 0xd14(%rip), %rdi       # 0x726e
callq 0x2190
xorl %edi, %edi
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0x2300
cmpq $0x0, %rax
jge 0x6581
leaq 0xd03(%rip), %rdi       # 0x727f
callq 0x2190
movl -0x34(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x34(%rbp)
xorl %edi, %edi
movl $0x1, %esi
leaq -0x40(%rbp), %rdx
callq 0x22c0
cmpl $0x0, %eax
jge 0x65b4
leaq 0xcd7(%rip), %rdi       # 0x7286
callq 0x2190
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: manpat[P]iterator_trait/./iterator_trait/iterator.h
// Function: StdFwdIteratorConsumer<IterMap<IterFilter<IterEnumerate<InputIteratorAdaptor<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, main::$_2>, main::$_1>>::operator++()
StdFwdIteratorConsumer& operator++() {
		m_item = m_iter.unwrap_ref().next();
		if (!m_item.is_some())
			m_iter = None;

		return *this;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3790
movq %rax, %rsi
leaq 0x6e(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x37c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rdi
callq 0x6550
jmp 0x256f
leaq 0x6e(%rsp), %rdi
callq 0x4af0
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x5440
testb $0x1, %al
jne 0x25e9
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3990
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x39b0
jmp 0x25a9
leaq 0x20(%rsp), %rdi
callq 0x2b70
jmp 0x25e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6e(%rsp), %rdi
callq 0x4af0
jmp 0x25f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2b70
jmp 0x25f3
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x1140
nopl (%rax)
// File: manpat[P]iterator_trait/./iterator_trait/iterator.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Iterator<std::pair<char const, char const>, IterZip<InputIteratorAdaptor<char const*, char const*>, InputIteratorAdaptor<char const*, char const*>>>::fold<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, main::$_7>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, main::$_7&&)
auto fold(A a, F&& f) -> A {
		// TODO: should A be && or is pass-by-value fine?
		// Also assumes `a` is assignable
		while(auto o = super_this()->next()) {
			a = f(a, o.unwrap());
			// TODO: move?
		}

		return a;
	}

// Assembly:
subq $0x98, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x65e0
movq %rax, %rsi
leaq 0x72(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x65f0
movq 0x10(%rsp), %rsi
leaq 0x75(%rsp), %rdi
callq 0x67e0
jmp 0x26a0
leaq 0x72(%rsp), %rdi
callq 0x6830
leaq 0x75(%rsp), %rdi
callq 0x6850
movb %al, 0xf(%rsp)
jmp 0x26ba
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x270b
jmp 0x26c4
movl $0x3, 0x60(%rsp)
jmp 0x276a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x72(%rsp), %rdi
callq 0x6830
jmp 0x27a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x75(%rsp), %rdi
callq 0x6830
jmp 0x27a1
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
leaq 0x75(%rsp), %rdi
callq 0x6860
movw %ax, 0xc(%rsp)
jmp 0x2725
movq 0x18(%rsp), %rdx
movq (%rsp), %rsi
movw 0xc(%rsp), %ax
movw %ax, 0x3e(%rsp)
movzwl 0x3e(%rsp), %ecx
leaq 0x40(%rsp), %rdi
callq 0x3df0
jmp 0x2749
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10e0
leaq 0x40(%rsp), %rdi
callq 0x10a0
movl $0x0, 0x60(%rsp)
leaq 0x75(%rsp), %rdi
callq 0x6830
movl 0x60(%rsp), %eax
testl %eax, %eax
je 0x2780
jmp 0x277e
jmp 0x2785
jmp 0x2673
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x1090
movq 0x28(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x1140
nopl (%rax,%rax)
// File: manpat[P]iterator_trait/main.cpp
// Function: foo
int foo() {
	int foo[] {1, 2, 3, 4, 5};

	return iter(foo)
		.map([] (int v) { return v*v; })
		.fold(0, [] (int a, int v) { return a + v; });
}

// Assembly:
subq $0x48, %rsp
movq 0x46a5(%rip), %rax      # 0x7030
movq %rax, 0x30(%rsp)
movq 0x46a1(%rip), %rax      # 0x7038
movq %rax, 0x38(%rsp)
movl 0x469e(%rip), %eax      # 0x7040
movl %eax, 0x40(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4290
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
callq 0x29e0
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
leaq 0x6(%rsp), %rdx
callq 0x2a30
addq $0x48, %rsp
retq
nop
// File: manpat[P]iterator_trait/./iterator_trait/option.h
// Function: Option<IterMap<IterFilter<IterEnumerate<InputIteratorAdaptor<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, main::$_2>, main::$_1>, true>::operator=(Option<IterMap<IterFilter<IterEnumerate<InputIteratorAdaptor<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, main::$_2>, main::$_1>, true>&&)
Option& operator=(Option&& o) {
		if (m_valid) { m_value.~T(); }

		m_valid = o.m_valid;
		if (m_valid) {
			new (&m_value) T ( std::move(o.m_value) );
			o.m_valid = false;
		}

		return *this;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x30(%rax)
je 0x3d56
movq (%rsp), %rdi
callq 0x2970
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
testb $0x1, 0x30(%rax)
je 0x3d85
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3a40
movq 0x8(%rsp), %rax
movb $0x0, 0x30(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: manpat[P]iterator_trait/./iterator_trait/iterator.h
// Function: IterFilter<IterEnumerate<InputIteratorAdaptor<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, main::$_2>::next()
Option<Item> next() {
		while (auto o = m_iter.next()) {
			if(m_func(o.unwrap_ref()))
				return Some(o.unwrap());
		}

		return None;
	}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x6140
movq 0x38(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x6000
jmp 0x3adc
leaq 0xa8(%rsp), %rdi
callq 0x6050
leaq 0xc0(%rsp), %rdi
callq 0x6070
movb %al, 0x37(%rsp)
jmp 0x3afc
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x3b55
jmp 0x3b06
movl $0x3, 0x98(%rsp)
jmp 0x3c45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x6050
jmp 0x3c9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x3c75
movq 0x50(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x20(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x62e0
movq %rax, 0x28(%rsp)
jmp 0x3b77
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3cd0
movb %al, 0x1f(%rsp)
jmp 0x3b8c
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x3b99
jmp 0x3c3a
leaq 0xc0(%rsp), %rdi
callq 0x6100
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x3bb1
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movb %al, 0x68(%rsp)
movb 0x68(%rsp), %al
movb %al, 0x78(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x6310
jmp 0x3be9
movq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x6000
jmp 0x3bfd
leaq 0x80(%rsp), %rdi
callq 0x6050
movl $0x1, 0x98(%rsp)
jmp 0x3c45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6050
jmp 0x3c75
movl $0x0, 0x98(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x6050
movl 0x98(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x3c70
jmp 0x3c63
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x3c8e
jmp 0x3c6e
jmp 0x3c84
jmp 0x3ab1
leaq 0xc0(%rsp), %rdi
callq 0x6050
jmp 0x3c9b
movq 0x40(%rsp), %rdi
callq 0x6390
movq 0x48(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0x1140
nopl (%rax,%rax)