LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]oblivious-avl-tree/src/OAVLTreePathEviction.cpp
// Function: OAVLTreePathEviction::evictTwoPaths()
void OAVLTreePathEviction::evictTwoPaths() {
    int random_leaf_one = this->rand_gen->getRandomLeaf()/2;
    int random_leaf_two = this->rand_gen->getRandomLeaf()/2 + this->num_leaves/2;
    this->evictByLeaf(random_leaf_one);
    this->evictByLeaf(random_leaf_two);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl 0x20(%rbx), %eax
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
addl %ecx, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6c24
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x6c24
nop
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::RandomForOram()
RandomForOram::RandomForOram() {

	if (this->is_initialized) {
		throw new runtime_error("ONLY ONE RANDOM INSTANCE CAN BE USED AT A TIME");
	}
	this->rng(long());
	this->rand_history = vector<int>();
	is_initialized  = true;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5bd7(%rip), %rax      # 0xcce0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
movq $0x1571, 0x28(%rdi)     # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0x6, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x5, %ecx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x275, %rax            # imm = 0x275
jne 0x7139
movq $0x270, 0x13a8(%rbx) # imm = 0x270
movq $0x0, 0x13b0(%rbx)
leaq 0x13b8(%rbx), %r14
movq %r14, %rdi
callq 0x75ba
cmpb $0x1, 0x6010(%rip)      # 0xd198
je 0x71db
movq %rsp, %rsi
movq $0x0, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x7836
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
testq %rdi, %rdi
je 0x71c5
subq %rdi, %rsi
callq 0x2190
movb $0x1, 0x5fcc(%rip)      # 0xd198
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x20c0
movq %rax, %r12
movl $0x10, %edi
callq 0x2180
movq %rax, %r13
leaq 0x2164(%rip), %rsi      # 0x9360
movq %rax, %rdi
callq 0x2090
movq %r13, (%r12)
leaq 0x5991(%rip), %rsi      # 0xcba0
movq %r12, %rdi
xorl %edx, %edx
callq 0x2280
jmp 0x723a
movq %rax, %r15
movl $0x10, %esi
movq %r13, %rdi
callq 0x2190
jmp 0x7230
movq %rax, %r15
movq %r12, %rdi
callq 0x2110
jmp 0x723d
movq %rax, %r15
movq %r14, %rdi
callq 0x7628
jmp 0x724a
movq %rax, %r15
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x725f
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r15, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::getRandomLeaf()
int RandomForOram::getRandomLeaf() {
	
	long next = this->rng();
	int randVal = next % this->bound;
	if (randVal < 0) {
		randVal += this->bound;
	}
	//this->rand_history.push_back(randVal);
	return randVal;
}

// Assembly:
pushq %rax
addq $0x13b8, %rdi           # imm = 0x13B8
movq %rsp, %rsi
movl $0x1, %edx
callq 0x77ce
movq (%rax), %rax
movslq 0x5f05(%rip), %rcx      # 0xd18c
cqto
idivq %rcx
movq %rdx, %rax
sarq $0x3f, %rax
andl %eax, %ecx
addl %edx, %ecx
movl %ecx, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x1390, %rsp           # imm = 0x1390
cmpb $0x1, 0x5ee9(%rip)      # 0xd198
je 0x730b
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7642
movq %r14, %rdi
callq 0x21e0
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
testq %rdi, %rdi
je 0x72ed
subq %rdi, %rsi
callq 0x2190
movb $0x1, 0x5ea4(%rip)      # 0xd198
leaq 0x8(%rsp), %rdi
callq 0x2150
addq $0x1390, %rsp           # imm = 0x1390
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x20c0
movq %rax, %rbx
movl $0x10, %edi
callq 0x2180
movq %rax, %r15
leaq 0x2034(%rip), %rsi      # 0x9360
movq %rax, %rdi
callq 0x2090
movq %r15, (%rbx)
leaq 0x5862(%rip), %rsi      # 0xcba0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r14
movl $0x10, %esi
movq %r15, %rdi
callq 0x2190
jmp 0x735d
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x7376
jmp 0x737e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2150
movq %r14, %rdi
callq 0x22a0
movq %rax, %rdi
callq 0x320c
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x76bc
movslq 0x5def(%rip), %rcx      # 0xd18c
cqto
idivq %rcx
movq %rdx, %rax
movl %eax, 0x4(%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x73bf
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x73d6
addq $0x8, %rbx
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x41d0
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpb $0x1, 0x5dae(%rip)      # 0xd198
je 0x7445
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x13b0(%rdi), %rax
movabsq $0x5deece66d, %rcx      # imm = 0x5DEECE66D
xorq %rax, %rcx
movq %rcx, 0x13b0(%rdi)
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
testq %rax, %rax
je 0x7438
subq %rax, %rsi
movq %rax, %rdi
callq 0x2190
movb $0x1, 0x5d59(%rip)      # 0xd198
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x20c0
movq %rax, %rbx
movl $0x10, %edi
callq 0x2180
movq %rax, %r14
leaq 0x1efa(%rip), %rsi      # 0x9360
movq %rax, %rdi
callq 0x2090
movq %r14, (%rbx)
leaq 0x5728(%rip), %rsi      # 0xcba0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x2190
jmp 0x7497
movq %rax, %r15
movq %rbx, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movabsq $0xffffffffffff, %r8    # imm = 0xFFFFFFFFFFFF
movabsq $0x5deece66d, %r9       # imm = 0x5DEECE66D
movq 0x13b0(%rdi), %rsi
imulq %r9, %rsi
addq $0xb, %rsi
andq %r8, %rsi
movq %rsi, 0x13b0(%rdi)
movq %rsi, %rcx
shrq $0x11, %rcx
movslq 0x5ca9(%rip), %r10      # 0xd18c
leal -0x1(%r10), %eax
testl %eax, %r10d
jne 0x74f8
imulq %r10, %rcx
shrq $0x1f, %rcx
movl %ecx, %edx
jmp 0x756c
leal -0x1(%r10), %r11d
movl %ecx, %eax
xorl %edx, %edx
idivl %r10d
movl %r11d, %eax
subl %edx, %eax
addl %ecx, %eax
jns 0x7535
imulq %r9, %rsi
addq $0xb, %rsi
andq %r8, %rsi
movq %rsi, %rcx
shrq $0x11, %rcx
movl %ecx, %eax
xorl %edx, %edx
idivl %r10d
movl %r11d, %eax
subl %edx, %eax
addl %ecx, %eax
js 0x750c
movq %rsi, 0x13b0(%rdi)
pushq %rbx
subq $0x10, %rsp
movl %edx, 0xc(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x7554
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rdi)
jmp 0x7567
addq $0x8, %rdi
leaq 0xc(%rsp), %rbx
movq %rbx, %rdx
callq 0x41d0
movl (%rbx), %edx
addq $0x10, %rsp
popq %rbx
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x572f(%rip)      # 0xd19b
je 0x7ab1
movq %rdi, %rbx
movb $0x1, 0x5723(%rip)      # 0xd19b
movl %esi, 0x20(%rdi)
addq $0x8, %rbx
movslq %esi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2b28
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x87f2
leaq 0x8(%rsp), %rdi
callq 0x2ff0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x20c0
movq %rax, %rbx
movl $0x10, %edi
callq 0x2180
movq %rax, %r15
leaq 0x19b4(%rip), %rsi      # 0x9486
movq %rax, %rdi
callq 0x2090
movq %r15, (%rbx)
leaq 0x50bc(%rip), %rsi      # 0xcba0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r14
movl $0x10, %esi
movq %r15, %rdi
callq 0x2190
jmp 0x7b03
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x7b1a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2ff0
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl $0x1, %edi
callq 0x2180
movq %rax, %rbx
movq %rax, %rdi
callq 0x3802
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2190
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x2c(%rdi)
jne 0x2649
movq %rdi, %rbx
leaq 0x18(%rsp), %rbp
leaq 0x2b72(%rip), %r14      # 0x5065
leaq 0x8(%rsp), %r15
leaq 0x2b05(%rip), %r12      # 0x5004
movq (%rbx), %r13
movq 0x8(%r13), %rax
cmpq (%r13), %rax
jne 0x2541
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x3676
movq %r13, %rdi
movq %r15, %rsi
callq 0x3406
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2541
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movl 0x28(%rbx), %esi
movq %rbx, %rdi
callq 0x267c
callq 0x427c
movl %eax, %r13d
movzbl %al, %eax
cmpl $0x6c, %eax
jg 0x257a
addl $-0x61, %eax
cmpl $0x4, %eax
ja 0x25e2
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x2ade
jmp 0x263f
cmpl $0x72, %eax
jg 0x2596
cmpl $0x6d, %eax
je 0x25ce
cmpl $0x71, %eax
jne 0x25e2
movq %rbx, %rdi
callq 0x29cc
jmp 0x263f
cmpl $0x73, %eax
je 0x25d8
cmpl $0x77, %eax
jne 0x25e2
movq %rbx, %rdi
callq 0x299a
jmp 0x263f
movq %rbx, %rdi
callq 0x2826
jmp 0x263f
movq %rbx, %rdi
callq 0x2ba2
jmp 0x263f
movq %rbx, %rdi
callq 0x2a12
jmp 0x263f
movq %rbx, %rdi
callq 0x28da
jmp 0x263f
movq %rbx, %rdi
callq 0x2c66
jmp 0x263f
movl $0x19, %edx
movq %r15, %r12
movq %r14, %r15
movq %rbp, %r14
movq 0x59d9(%rip), %rbp      # 0x7fd0
movq %rbp, %rdi
leaq 0x2a17(%rip), %rsi      # 0x5018
callq 0x2180
movb %r13b, 0x8(%rsp)
movl $0x1, %edx
movq %rbp, %rdi
movq %r14, %rbp
movq %r15, %r14
movq %r12, %r15
leaq 0x29e1(%rip), %r12      # 0x5004
movq %r15, %rsi
callq 0x2180
movl $0x2, %edx
movq %rax, %rdi
leaq 0x29fa(%rip), %rsi      # 0x5034
callq 0x2180
cmpb $0x1, 0x2c(%rbx)
jne 0x24ff
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2674
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r12
callq 0x436e
movq (%r12), %rax
movq 0x8(%rax), %r13
subq (%rax), %r13
shrq $0x5, %r13
callq 0x4347
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
leal -0x2(%rcx), %eax
movl %r15d, %ebx
subl %eax, %ebx
decl %r13d
leal (%rcx,%r15), %r14d
addl $-0x2, %r14d
cmpl %r13d, %r14d
movq %r13, 0x8(%rsp)
cmovgel %r13d, %r14d
xorl %r13d, %r13d
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
movl %eax, 0x4(%rsp)
movq %r12, 0x10(%rsp)
movq (%r12), %rax
movq 0x8(%rax), %rdi
subq (%rax), %rdi
shrq $0x5, %rdi
callq 0x43c4
movl %eax, %ebp
testl %ebx, %ebx
cmovgl %ebx, %r13d
jle 0x271f
movq 0x58c2(%rip), %rdi      # 0x7fd0
leaq 0x291d(%rip), %rsi      # 0x5032
movl $0x4, %edx
callq 0x2180
cmpl 0x4(%rsp), %ebx
jg 0x27e1
movslq %ebp, %r12
movl %r13d, %ebx
movl %r15d, %r13d
movslq %r14d, %rbp
movq %rbx, %r14
shlq $0x5, %r14
orq $0x8, %r14
movq 0x5889(%rip), %r15      # 0x7fd0
cmpq %rbx, %r13
jne 0x2760
movl $0x2, %edx
movq %r15, %rdi
leaq 0x28dc(%rip), %rsi      # 0x5037
callq 0x2180
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2280
movl $0x1, %edx
movq %r15, %rdi
leaq 0x28b3(%rip), %rsi      # 0x5038
callq 0x2180
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rbx, %rdx
jbe 0x2814
movq -0x8(%rax,%r14), %rsi
movq (%rax,%r14), %rdx
movq %r15, %rdi
callq 0x2180
movb $0xa, 0x3(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3(%rsp), %rsi
callq 0x2180
leaq 0x1(%rbx), %rax
addq $0x20, %r14
cmpq %rbp, %rbx
movq %rax, %rbx
jl 0x2747
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x2803
movq 0x57de(%rip), %rdi      # 0x7fd0
leaq 0x2839(%rip), %rsi      # 0x5032
movl $0x4, %edx
callq 0x2180
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x296c(%rip), %rdi      # 0x5187
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x5797(%rip), %rdi      # 0x7fd0
leaq 0x27fa(%rip), %rsi      # 0x503a
movl $0x11, %edx
callq 0x2180
movq 0x578f(%rip), %rbx      # 0x7fe0
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
setne %al
movl (%r15), %esi
testl %esi, %esi
sets %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x28c6
movq 0x574a(%rip), %rdi      # 0x7fd0
leaq 0x27bf(%rip), %rsi      # 0x504c
movl $0x19, %edx
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2260
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20d0
movl $0x1, %eax
jmp 0x28d0
movq %r14, %rdi
callq 0x2d82
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x56e3(%rip), %rdi      # 0x7fd0
leaq 0x2772(%rip), %rsi      # 0x5066
movl $0x14, %edx
callq 0x2180
movq 0x56db(%rip), %rbx      # 0x7fe0
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
setne %cl
movl (%r15), %eax
testl %eax, %eax
sets %dl
orb %cl, %dl
jne 0x294a
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
shrq $0x5, %rdx
cmpl %edx, %eax
jge 0x294a
movl %eax, 0x28(%r14)
xorl %eax, %eax
jmp 0x298f
movq 0x567f(%rip), %rdi      # 0x7fd0
leaq 0x26f4(%rip), %rsi      # 0x504c
movl $0x19, %edx
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2260
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x562b(%rip), %rdi      # 0x7fd0
leaq 0x26cf(%rip), %rsi      # 0x507b
movl $0x15, %edx
callq 0x2180
callq 0x427c
cmpb $0x79, %al
jne 0x29c8
movq %rbx, %rdi
popq %rbx
jmp 0x2ee6
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x55f9(%rip), %rdi      # 0x7fd0
leaq 0x26d2(%rip), %rsi      # 0x50b0
movl $0x13, %edx
callq 0x2180
callq 0x427c
cmpb $0x79, %al
jne 0x2a0d
movb $0x1, 0x2c(%rbx)
movq 0x55d4(%rip), %rdi      # 0x7fd0
leaq 0x2661(%rip), %rsi      # 0x5064
movl $0x1, %edx
callq 0x2180
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x55ab(%rip), %rdi      # 0x7fd0
leaq 0x2698(%rip), %rsi      # 0x50c4
movl $0x1d, %edx
callq 0x2180
movq 0x55a3(%rip), %rbx      # 0x7fe0
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
setne %cl
movl (%r15), %eax
testl %eax, %eax
sets %dl
orb %cl, %dl
jne 0x2a8f
movl %eax, %eax
movq (%r14), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rcx
subq %rsi, %rcx
shrq $0x5, %rcx
cmpl %ecx, %eax
jge 0x2a8f
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3c14
xorl %eax, %eax
jmp 0x2ad4
movq 0x553a(%rip), %rdi      # 0x7fd0
leaq 0x25af(%rip), %rsi      # 0x504c
movl $0x19, %edx
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2260
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x54df(%rip), %rdi      # 0x7fd0
leaq 0x25ea(%rip), %rsi      # 0x50e2
movl $0x19, %edx
callq 0x2180
movq 0x54d7(%rip), %rbx      # 0x7fe0
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
setne %al
movl (%r15), %esi
testl %esi, %esi
sets %cl
orb %al, %cl
jne 0x2b52
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
cmpl %ecx, %esi
jge 0x2b52
movq %r14, %rdi
callq 0x3082
xorl %eax, %eax
jmp 0x2b97
movq 0x5477(%rip), %rdi      # 0x7fd0
leaq 0x24ec(%rip), %rsi      # 0x504c
movl $0x19, %edx
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2260
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x541b(%rip), %rdi      # 0x7fd0
leaq 0x2540(%rip), %rsi      # 0x50fc
movl $0x1b, %edx
callq 0x2180
movq 0x5413(%rip), %rbx      # 0x7fe0
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
setne %al
movl (%r15), %esi
testl %esi, %esi
sets %cl
orb %al, %cl
jne 0x2c16
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
cmpl %ecx, %esi
jge 0x2c16
movq %r14, %rdi
callq 0x312e
xorl %eax, %eax
jmp 0x2c5b
movq 0x53b3(%rip), %rdi      # 0x7fd0
leaq 0x2428(%rip), %rsi      # 0x504c
movl $0x19, %edx
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2260
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x5357(%rip), %rdi      # 0x7fd0
leaq 0x2498(%rip), %rsi      # 0x5118
movl $0x14, %edx
callq 0x2180
movq 0x534f(%rip), %rbx      # 0x7fe0
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
setne %cl
movl (%r15), %eax
testl %eax, %eax
sets %dl
orb %cl, %dl
jne 0x2d33
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
shrq $0x5, %rdx
cmpl %edx, %eax
jge 0x2d33
movq 0x52fb(%rip), %rdi      # 0x7fd0
leaq 0x2451(%rip), %rsi      # 0x512d
movl $0x15, %edx
callq 0x2180
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
setne %al
movl (%r15), %edx
testl %edx, %edx
sets %cl
orb %al, %cl
jne 0x2d33
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
cmpl %ecx, %edx
jge 0x2d33
movl 0x8(%rsp), %esi
movq %r14, %rdi
callq 0x31d0
xorl %eax, %eax
jmp 0x2d78
movq 0x5296(%rip), %rdi      # 0x7fd0
leaq 0x230b(%rip), %rsi      # 0x504c
movl $0x19, %edx
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2260
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x5, %rax
cmpl %esi, %eax
jg 0x2dec
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x22b0(%rip), %rdx      # 0x5065
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3676
leal 0x1(%rbx), %eax
movslq %eax, %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x332e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2dec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x51dd(%rip), %rdi      # 0x7fd0
leaq 0x223d(%rip), %rsi      # 0x5037
movl $0x2, %edx
callq 0x2180
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x51bd(%rip), %r15      # 0x7fe0
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %r15, %rdi
movl $0xa, %edx
callq 0x20d0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq 0x5188(%rip), %r15      # 0x7fe0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x22b0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2260
movq (%r14), %rax
movslq %ebx, %rdi
shlq $0x5, %rdi
addq (%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x20b0
movl %ebx, 0x28(%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ea8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2ebd
movq %rax, %rbx
jmp 0x2ed7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ed7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2270
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
movl $0x10, %edx
callq 0x2090
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
je 0x2f71
movq 0x50a2(%rip), %rdi      # 0x7fd0
leaq 0x215c(%rip), %rsi      # 0x5091
movl $0x10, %edx
callq 0x2180
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x5082(%rip), %rdi      # 0x7fd0
callq 0x2180
movl $0x1, %ebx
leaq 0x2143(%rip), %rsi      # 0x50a2
movl $0xd, %edx
movq %rax, %rdi
callq 0x2180
jmp 0x2ffb
movq (%rbx), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
testl %edx, %edx
jle 0x2fef
movl $0x8, %r13d
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
cmpq %r14, %rdx
jbe 0x3040
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x2180
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
incq %r14
movq (%rbx), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x5, %rdx
shrq $0x5, %rcx
movslq %ecx, %rcx
addq $0x20, %r13
cmpq %rcx, %r14
jl 0x2f99
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x21e0
movq 0x4fc6(%rip), %rax      # 0x7fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x18(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x10(%rsp,%rcx)
callq 0x2120
leaq 0x108(%rsp), %rdi
callq 0x2050
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2140(%rip), %rdi      # 0x5187
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
jmp 0x3055
jmp 0x3055
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq (%rdi), %rcx
movslq %esi, %r15
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x32ce
movl %esi, %ebx
movq %rdi, %r14
shlq $0x5, %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax,%r15), %rsi
movq 0x8(%rax,%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3370
movq (%r14), %rcx
movslq %ebp, %r12
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r12, %rdx
jbe 0x32df
shlq $0x5, %r12
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3370
movq (%r14), %rax
addq (%rax), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x20b0
movq (%r14), %rax
addq (%rax), %r12
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x20b0
movl %ebx, 0x28(%r14)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x32a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x32bd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1eb2(%rip), %rdi      # 0x5187
movq %r15, %rsi
xorl %eax, %eax
callq 0x2220
leaq 0x1ea1(%rip), %rdi      # 0x5187
movq %r12, %rsi
xorl %eax, %eax
callq 0x2220
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x330f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x330f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3326
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x3df8
xorl %ebx, %ebx
jmp 0x3e83
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movl $0x18, %edi
callq 0x2150
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rsp, %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3e6d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ff6
jmp 0x3e2e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3e83
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
leaq 0x20(%rsp), %rdi
callq 0x2030
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x3ebd
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3ebd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
leaq 0x20(%rsp), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x50, %rsp
cmpl $0x1, %edi
jg 0x3efb
movq 0x40f0(%rip), %rdi      # 0x7fd0
leaq 0x1301(%rip), %rsi      # 0x51e8
movl $0x1c, %edx
callq 0x2180
movl $0x1, %ebx
jmp 0x3fa5
movq 0x8(%rsi), %rsi
movq %rsp, %rbx
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x4034
movq %rbx, %rdi
callq 0x3dc0
movq %rax, %rbx
testq %rax, %rax
je 0x3f6d
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x248c
leaq 0x20(%rsp), %rdi
callq 0x24cc
movq %rbx, %rdi
callq 0x4072
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2160
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f69
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
xorl %ebx, %ebx
jmp 0x3f8a
movl $0x1, %ebx
movq 0x4057(%rip), %rdi      # 0x7fd0
leaq 0x1285(%rip), %rsi      # 0x5205
movl $0x14, %edx
callq 0x2180
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fa5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fd2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x3fd2
jmp 0x3fcf
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x50, %rsp
movb $0x0, 0xf(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movups %xmm0, 0x2c(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq 0x3d0c(%rip), %rax      # 0x7fb0
movq (%rax), %rdi
callq 0x21a0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2170
testl %eax, %eax
js 0x430f
leaq 0x10(%rsp), %rdx
andb $-0xb, 0xc(%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %edi, %edi
xorl %esi, %esi
callq 0x21c0
testl %eax, %eax
js 0x431d
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x21f0
testq %rax, %rax
js 0x432b
leaq 0x10(%rsp), %rdx
orb $0xa, 0xc(%rdx)
xorl %edi, %edi
movl $0x1, %esi
callq 0x21c0
testl %eax, %eax
js 0x4339
movb 0xf(%rsp), %al
addq $0x50, %rsp
popq %rbx
retq
leaq 0xf04(%rip), %rdi       # 0x521a
callq 0x2110
jmp 0x42ba
leaq 0xf02(%rip), %rdi       # 0x5226
callq 0x2110
jmp 0x42d6
leaq 0xf05(%rip), %rdi       # 0x5237
callq 0x2110
jmp 0x42ec
leaq 0xefe(%rip), %rdi       # 0x523e
callq 0x2110
jmp 0x4305
// File: /workspace/github_cpp_makefile_star2_O3/brianwu02[P]ImageProcessing/convolve.cpp
// Function: allocateKernel(int, int, int)
kernelP allocateKernel(int w, int h, int s) {
    float *p;
    kernelP k;

    k = (kernelP) malloc(sizeof(kernelS));
    p = (float *) malloc(w * h * s);
    if (p == NULL) {
        cerr << "allocateKernel error, Insufficient memory" << endl;
        return ((kernelP) NULL);
    }

    k->width = w;
    k->height = h;
    k->kernel = p;

    return k;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movl %edi, %r14d
movl $0x10, %edi
callq 0x21c0
movq %rax, %rbx
movl %ebp, %eax
imull %r14d, %eax
imull %r15d, %eax
movslq %eax, %rdi
callq 0x21c0
testq %rax, %rax
je 0x2c29
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
movq %rax, 0x8(%rbx)
jmp 0x2c6d
movq 0x33c0(%rip), %rbx      # 0x5ff0
leaq 0x13ee(%rip), %rsi      # 0x4025
movl $0x29, %edx
movq %rbx, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brianwu02[P]ImageProcessing/convolve.cpp
// Function: readKernelFile[abi:cxx11](char*)
std:: string readKernelFile(char *file) {
    std::string filename = file;
    std::string str;
    std::ifstream t(filename);

    t.seekg(0, std::ios::end);
    str.reserve(t.tellg());
    t.seekg(0, std::ios::beg);

    str.assign((std::istreambuf_iterator<char>(t)),
            std::istreambuf_iterator<char>());

    return str;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
callq 0x2e18
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x2260
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
leaq 0x48(%rsp), %rdi
callq 0x22a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2250
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
movq 0x130(%rsp,%rax), %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq $0x0, 0x18(%rsp)
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x2ef6
leaq 0x48(%rsp), %rdi
callq 0x2070
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d5d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x2d81
jmp 0x2d74
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x2070
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2d94
movq (%r15), %rsi
incq %rsi
callq 0x2150
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2daf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/brianwu02[P]ImageProcessing/convolve.cpp
// Function: cfa(char)
int cfa(char str) {
    // dumb way to parse. convert ASCII char to INT.

    if (str == 48) { return 0; }
    else if (str == 49) { return 1; }
    else if (str == 50) { return 2; }
    else if (str == 51) { return 3; } 
    else if (str == 52) { return 4; }
    else if (str == 53) { return 5; }
    else if (str == 54) { return 6; }
    else if (str == 55) { return 7; }
    else if (str == 56) { return 8; }
    else if (str == 57) { return 9; }


    
    
    else {
        cerr << "error parsing" << endl;
        return str;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leal -0x30(%rdi), %eax
cmpb $0xa, %al
jae 0x2dc7
movzbl %al, %ebx
jmp 0x2e0d
movsbl %dil, %ebx
movq 0x321e(%rip), %r14      # 0x5ff0
leaq 0x1276(%rip), %rsi      # 0x404f
movl $0xd, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dacunni[P]stlloader/stldump.cpp
// Function: main
int main(int argc, char ** argv)
{
    if(argc < 2) {
        std::cerr << "Please supply an argument\n";
        return EXIT_FAILURE;
    }
    stlloader::Mesh mesh;
    stlloader::parse_file(argv[1], mesh);
    stlloader::print(mesh);

    return EXIT_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
cmpl $0x1, %edi
jg 0x3a44
movq 0x25bf(%rip), %rdi      # 0x5fe8
leaq 0x695(%rip), %rsi       # 0x40c5
movl $0x1a, %edx
callq 0x2200
movl $0x1, %eax
jmp 0x3aca
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %rbx
movaps %xmm0, -0x28(%rbx)
xorl %eax, %eax
movq %rax, -0x18(%rbx)
movq %rbx, -0x10(%rbx)
movq %rax, -0x8(%rbx)
movb %al, (%rbx)
leaq 0x48(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
movq 0x8(%rsi), %rdi
movq %rsp, %rsi
callq 0x32ef
movq %rsp, %rdi
callq 0x2560
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a9b
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21b0
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3ab2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21b0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3ac8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3b9e
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/temelmertcan[P]multgen/src/multgen.cpp
// Function: convertToString[abi:cxx11](char*, int)
string convertToString(char* a, int size)
{
  int i;
  string s = "";
  for (i = 0; i < size; i++) {
    s = s + a[i];
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x75633(%rip), %rdx     # 0x79601
movq %rdx, %rsi
callq 0x2ac04
testl %r15d, %r15d
jle 0x4043
movl %r15d, %r12d
xorl %r14d, %r14d
leaq -0x58(%rbp), %r15
movq -0x38(%rbp), %rax
movb (%rax,%r14), %r13b
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x2a8a4
movq -0x50(%rbp), %rsi
movsbl %r13b, %r8d
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x33c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3260
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x403b
callq 0x31d0
incq %r14
cmpq %r14, %r12
jne 0x3fe5
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x406f
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x406f
callq 0x31d0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x407d
callq 0x31d0
movq %r14, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O3/temelmertcan[P]multgen/src/multgen.cpp
// Function: print_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::list<int, std::allocator<int>> const&)
void print_int(string x, std::list<int> const &list)
{
  cout << x << " ";
  for (auto const &i: list) {
    std::cout << i << " ";
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x79c43(%rip), %rbx     # 0x85fd0
movq %rbx, %rdi
callq 0x3240
leaq 0x6a878(%rip), %rsi     # 0x76c14
movl $0x1, %edx
movq %rax, %rdi
callq 0x3240
movq (%r14), %r13
cmpq %r14, %r13
je 0xc3e4
movq 0x79c18(%rip), %r15     # 0x85fd0
leaq 0x6a855(%rip), %r12     # 0x76c14
movl 0x10(%r13), %esi
movq %r15, %rdi
callq 0x3380
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3240
movq (%r13), %r13
cmpq %r14, %r13
jne 0xc3bf
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3160