LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x7512
movslq 0x5fbe(%rip), %rcx      # 0xd18c
cqto
idivq %rcx
movl %edx, 0xc(%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x71ed
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x71fe
addq $0x8, %rbx
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e4a
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x20, %rsp
cmpb $0x1, 0x5f80(%rip)      # 0xd198
je 0x7282
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x13b0(%rdi), %rax
movabsq $0x5deece66d, %rcx      # imm = 0x5DEECE66D
xorq %rax, %rcx
movq %rcx, 0x13b0(%rdi)
addq $0x8, %rdi
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rsi
callq 0x76f2
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7271
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2190
movb $0x1, 0x5f20(%rip)      # 0xd198
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, %r14
leaq 0x208d(%rip), %rsi      # 0x9330
movq %rax, %rdi
callq 0x2090
movq %r14, (%rbx)
leaq 0x58eb(%rip), %rsi      # 0xcba0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x2190
jmp 0x72d4
movq %rax, %r15
movq %rbx, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
movabsq $0x5deece66d, %r8       # imm = 0x5DEECE66D
movq 0x13b0(%rdi), %rcx
imulq %r8, %rcx
addq $0xb, %rcx
andq %rsi, %rcx
movq %rcx, 0x13b0(%rdi)
shrq $0x11, %rcx
movl $0x0, 0x4(%rsp)
movslq 0x5e67(%rip), %r9       # 0xd18c
leal -0x1(%r9), %eax
testl %eax, %r9d
jne 0x733c
imulq %r9, %rcx
shrq $0x1f, %rcx
movl %ecx, 0x4(%rsp)
jmp 0x73ac
leal -0x1(%r9), %r10d
movl %ecx, %eax
xorl %edx, %edx
idivl %r9d
movl %r10d, %eax
subl %edx, %eax
addl %ecx, %eax
jns 0x7380
movq 0x13b0(%rdi), %r11
imulq %r8, %r11
addq $0xb, %r11
andq %rsi, %r11
movq %r11, %rcx
shrq $0x11, %rcx
movl %ecx, %eax
xorl %edx, %edx
idivl %r9d
movl %r10d, %eax
subl %edx, %eax
addl %ecx, %eax
js 0x7357
movq %r11, 0x13b0(%rdi)
movl %edx, 0x4(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x739a
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rdi)
jmp 0x73a8
addq $0x8, %rdi
leaq 0x4(%rsp), %rdx
callq 0x3e4a
movl 0x4(%rsp), %ecx
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x58bf(%rip)      # 0xd19b
je 0x7921
movq %rdi, %rbx
movb $0x1, 0x58b3(%rip)      # 0xd19b
movl %esi, 0x20(%rdi)
addq $0x8, %rbx
movslq %esi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2b38
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8644
leaq 0x8(%rsp), %rdi
callq 0x304c
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 0x1b14(%rip), %rsi      # 0x9456
movq %rax, %rdi
callq 0x2090
movq %r15, (%rbx)
leaq 0x524c(%rip), %rsi      # 0xcba0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r14
movl $0x10, %esi
movq %r15, %rdi
callq 0x2190
jmp 0x7973
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x798a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x304c
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x383e
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2190
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2619
movq %rdi, %rbx
leaq 0x18(%rsp), %rbp
leaq 0x2ba2(%rip), %r14      # 0x5065
leaq 0x8(%rsp), %r15
leaq 0x2b35(%rip), %r12      # 0x5004
movq (%rbx), %r13
movq 0x8(%r13), %rax
cmpq (%r13), %rax
jne 0x2511
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x3638
movq %r13, %rdi
movq %r15, %rsi
callq 0x33d0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2511
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movl 0x28(%rbx), %esi
movq %rbx, %rdi
callq 0x264c
callq 0x4298
movl %eax, %r13d
movzbl %al, %eax
cmpl $0x6c, %eax
jg 0x254a
addl $-0x61, %eax
cmpl $0x4, %eax
ja 0x25b2
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x2aae
jmp 0x260f
cmpl $0x72, %eax
jg 0x2566
cmpl $0x6d, %eax
je 0x259e
cmpl $0x71, %eax
jne 0x25b2
movq %rbx, %rdi
callq 0x299c
jmp 0x260f
cmpl $0x73, %eax
je 0x25a8
cmpl $0x77, %eax
jne 0x25b2
movq %rbx, %rdi
callq 0x296a
jmp 0x260f
movq %rbx, %rdi
callq 0x27f6
jmp 0x260f
movq %rbx, %rdi
callq 0x2b72
jmp 0x260f
movq %rbx, %rdi
callq 0x29e2
jmp 0x260f
movq %rbx, %rdi
callq 0x28aa
jmp 0x260f
movq %rbx, %rdi
callq 0x2c36
jmp 0x260f
movl $0x19, %edx
movq %r15, %r12
movq %r14, %r15
movq %rbp, %r14
movq 0x5a09(%rip), %rbp      # 0x7fd0
movq %rbp, %rdi
leaq 0x2a47(%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 0x2a11(%rip), %r12      # 0x5004
movq %r15, %rsi
callq 0x2180
movl $0x2, %edx
movq %rax, %rdi
leaq 0x2a2a(%rip), %rsi      # 0x5034
callq 0x2180
cmpb $0x1, 0x2c(%rbx)
jne 0x24cf
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 0x2644
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x438a
movq (%r12), %rax
movq 0x8(%rax), %r13
subq (%rax), %r13
shrq $0x5, %r13
callq 0x4363
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 0x43e0
movl %eax, %ebp
testl %ebx, %ebx
cmovgl %ebx, %r13d
jle 0x26ef
movq 0x58f2(%rip), %rdi      # 0x7fd0
leaq 0x294d(%rip), %rsi      # 0x5032
movl $0x4, %edx
callq 0x2180
cmpl 0x4(%rsp), %ebx
jg 0x27b1
movslq %ebp, %r12
movl %r13d, %ebx
movl %r15d, %r13d
movslq %r14d, %rbp
movq %rbx, %r14
shlq $0x5, %r14
orq $0x8, %r14
movq 0x58b9(%rip), %r15      # 0x7fd0
cmpq %rbx, %r13
jne 0x2730
movl $0x2, %edx
movq %r15, %rdi
leaq 0x290c(%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 0x28e3(%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 0x27e4
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 0x2717
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x27d3
movq 0x580e(%rip), %rdi      # 0x7fd0
leaq 0x2869(%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 0x299c(%rip), %rdi      # 0x5187
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57c7(%rip), %rdi      # 0x7fd0
leaq 0x282a(%rip), %rsi      # 0x503a
movl $0x11, %edx
callq 0x2180
movq 0x57bf(%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 0x2896
movq 0x577a(%rip), %rdi      # 0x7fd0
leaq 0x27ef(%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 0x28a0
movq %r14, %rdi
callq 0x2d52
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5713(%rip), %rdi      # 0x7fd0
leaq 0x27a2(%rip), %rsi      # 0x5066
movl $0x14, %edx
callq 0x2180
movq 0x570b(%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 0x291a
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
shrq $0x5, %rdx
cmpl %edx, %eax
jge 0x291a
movl %eax, 0x28(%r14)
xorl %eax, %eax
jmp 0x295f
movq 0x56af(%rip), %rdi      # 0x7fd0
leaq 0x2724(%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_O1/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 0x565b(%rip), %rdi      # 0x7fd0
leaq 0x26ff(%rip), %rsi      # 0x507b
movl $0x15, %edx
callq 0x2180
callq 0x4298
cmpb $0x79, %al
jne 0x2998
movq %rbx, %rdi
popq %rbx
jmp 0x2eb6
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5629(%rip), %rdi      # 0x7fd0
leaq 0x2702(%rip), %rsi      # 0x50b0
movl $0x13, %edx
callq 0x2180
callq 0x4298
cmpb $0x79, %al
jne 0x29dd
movb $0x1, 0x2c(%rbx)
movq 0x5604(%rip), %rdi      # 0x7fd0
leaq 0x2691(%rip), %rsi      # 0x5064
movl $0x1, %edx
callq 0x2180
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55db(%rip), %rdi      # 0x7fd0
leaq 0x26c8(%rip), %rsi      # 0x50c4
movl $0x1d, %edx
callq 0x2180
movq 0x55d3(%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 0x2a5f
movl %eax, %eax
movq (%r14), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rcx
subq %rsi, %rcx
shrq $0x5, %rcx
cmpl %ecx, %eax
jge 0x2a5f
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3bfe
xorl %eax, %eax
jmp 0x2aa4
movq 0x556a(%rip), %rdi      # 0x7fd0
leaq 0x25df(%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_O1/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 0x550f(%rip), %rdi      # 0x7fd0
leaq 0x261a(%rip), %rsi      # 0x50e2
movl $0x19, %edx
callq 0x2180
movq 0x5507(%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 0x2b22
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
cmpl %ecx, %esi
jge 0x2b22
movq %r14, %rdi
callq 0x3052
xorl %eax, %eax
jmp 0x2b67
movq 0x54a7(%rip), %rdi      # 0x7fd0
leaq 0x251c(%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_O1/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 0x544b(%rip), %rdi      # 0x7fd0
leaq 0x2570(%rip), %rsi      # 0x50fc
movl $0x1b, %edx
callq 0x2180
movq 0x5443(%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 0x2be6
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
cmpl %ecx, %esi
jge 0x2be6
movq %r14, %rdi
callq 0x30fe
xorl %eax, %eax
jmp 0x2c2b
movq 0x53e3(%rip), %rdi      # 0x7fd0
leaq 0x2458(%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_O1/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 0x5387(%rip), %rdi      # 0x7fd0
leaq 0x24c8(%rip), %rsi      # 0x5118
movl $0x14, %edx
callq 0x2180
movq 0x537f(%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 0x2d03
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
shrq $0x5, %rdx
cmpl %edx, %eax
jge 0x2d03
movq 0x532b(%rip), %rdi      # 0x7fd0
leaq 0x2481(%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 0x2d03
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
cmpl %ecx, %edx
jge 0x2d03
movl 0x8(%rsp), %esi
movq %r14, %rdi
callq 0x31a0
xorl %eax, %eax
jmp 0x2d48
movq 0x52c6(%rip), %rdi      # 0x7fd0
leaq 0x233b(%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_O1/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 0x2dbc
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x22e0(%rip), %rdx      # 0x5065
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3638
leal 0x1(%rbx), %eax
movslq %eax, %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x32fe
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2dbc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x520d(%rip), %rdi      # 0x7fd0
leaq 0x226d(%rip), %rsi      # 0x5037
movl $0x2, %edx
callq 0x2180
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x51ed(%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 0x51b8(%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 0x2e78
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2e8d
movq %rax, %rbx
jmp 0x2ea7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ea7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f41
movq 0x50d2(%rip), %rdi      # 0x7fd0
leaq 0x218c(%rip), %rsi      # 0x5091
movl $0x10, %edx
callq 0x2180
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x50b2(%rip), %rdi      # 0x7fd0
callq 0x2180
movl $0x1, %ebx
leaq 0x2173(%rip), %rsi      # 0x50a2
movl $0xd, %edx
movq %rax, %rdi
callq 0x2180
jmp 0x2fcb
movq (%rbx), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
testl %edx, %edx
jle 0x2fbf
movl $0x8, %r13d
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
cmpq %r14, %rdx
jbe 0x3010
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 0x2f69
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x21e0
movq 0x4ff6(%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 0x2170(%rip), %rdi      # 0x5187
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
jmp 0x3025
jmp 0x3025
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x329e
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 0x3340
movq (%r14), %rcx
movslq %ebp, %r12
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r12, %rdx
jbe 0x32af
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 0x3340
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 0x3276
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x328d
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 0x1ee2(%rip), %rdi      # 0x5187
movq %r15, %rsi
xorl %eax, %eax
callq 0x2220
leaq 0x1ed1(%rip), %rdi      # 0x5187
movq %r12, %rsi
xorl %eax, %eax
callq 0x2220
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x32df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x32df
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x32f6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3de0
xorl %ebx, %ebx
jmp 0x3e6b
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 0x3e55
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3fda
jmp 0x3e16
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3e6b
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
jmp 0x3e89
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3ea2
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_O1/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 0x3ee0
movq 0x410b(%rip), %rdi      # 0x7fd0
leaq 0x131c(%rip), %rsi      # 0x51e8
movl $0x1c, %edx
callq 0x2180
movl $0x1, %ebx
jmp 0x3f8a
movq 0x8(%rsi), %rsi
movq %rsp, %rbx
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x4018
movq %rbx, %rdi
callq 0x3da8
movq %rax, %rbx
testq %rax, %rax
je 0x3f52
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x245c
leaq 0x20(%rsp), %rdi
callq 0x249c
movq %rbx, %rdi
callq 0x4056
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2160
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f4e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
xorl %ebx, %ebx
jmp 0x3f6f
movl $0x1, %ebx
movq 0x4072(%rip), %rdi      # 0x7fd0
leaq 0x12a0(%rip), %rsi      # 0x5205
movl $0x14, %edx
callq 0x2180
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f8a
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 0x3fb7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x3fb7
jmp 0x3fb4
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fd2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3cf0(%rip), %rax      # 0x7fb0
movq (%rax), %rdi
callq 0x21a0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2170
testl %eax, %eax
js 0x432b
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 0x4339
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x21f0
testq %rax, %rax
js 0x4347
leaq 0x10(%rsp), %rdx
orb $0xa, 0xc(%rdx)
xorl %edi, %edi
movl $0x1, %esi
callq 0x21c0
testl %eax, %eax
js 0x4355
movb 0xf(%rsp), %al
addq $0x50, %rsp
popq %rbx
retq
leaq 0xee8(%rip), %rdi       # 0x521a
callq 0x2110
jmp 0x42d6
leaq 0xee6(%rip), %rdi       # 0x5226
callq 0x2110
jmp 0x42f2
leaq 0xee9(%rip), %rdi       # 0x5237
callq 0x2110
jmp 0x4308
leaq 0xee2(%rip), %rdi       # 0x523e
callq 0x2110
jmp 0x4321
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %ecx, %ecx
leaq 0x69e(%rip), %rdx       # 0x20b0
xorl %esi, %esi
xorl %eax, %eax
movq %rsi, %rdi
cmpq $0x14, %rsi
je 0x1a27
movl (%rsi,%rdx), %r8d
leaq 0x4(%rsi), %rdi
imull %r8d, %r8d
cmpq $0x14, %rsi
cmovel %ecx, %r8d
addl %r8d, %eax
cmpq $0x14, %rsi
movq %rdi, %rsi
jne 0x1a19
retq
// File: /workspace/github_cpp_makefile_star2_O1/manpat[P]iterator_trait/./iterator_trait/iterator.h
// Function: IterZip<InputIteratorAdaptor<char const*, char const*>, InputIteratorAdaptor<char const*, char const*>>::next()
Option<Item> next() {
		auto a = m_iter.next();
		auto b = m_iter2.next();
		if (a && b) {
			return Some(Item(a.unwrap(), b.unwrap()));
		}

		return None;
	}

// Assembly:
movq %rdi, %rax
movq (%rsi), %rdi
movb $0x1, %cl
testq %rdi, %rdi
je 0x1beb
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
sete %r8b
cmpq %rdx, %rdi
sete %dl
orb %r8b, %dl
je 0x1bf2
xorl %edx, %edx
movb $0x1, %dil
jmp 0x1bfd
movzbl (%rdi), %edx
incq %rdi
movq %rdi, (%rsi)
xorl %edi, %edi
movq 0x10(%rsi), %r9
testq %r9, %r9
je 0x1c1d
movq 0x18(%rsi), %r8
testq %r8, %r8
sete %r10b
cmpq %r8, %r9
sete %r8b
orb %r10b, %r8b
je 0x1c22
xorl %r8d, %r8d
jmp 0x1c33
movzbl (%r9), %r8d
incq %r9
movq %r9, 0x10(%rsi)
shll $0x8, %r8d
xorl %ecx, %ecx
orb %cl, %dil
je 0x1c3d
movb $0x0, 0x2(%rax)
retq
movzwl %dx, %ecx
orl %r8d, %ecx
movb $0x1, 0x2(%rax)
movw %cx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c31
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
movq %rax, 0x8(%rbx)
jmp 0x2c75
movq 0x33b8(%rip), %rbx      # 0x5ff0
leaq 0x13e6(%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_O1/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 0x2e20
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 0x2ef8
leaq 0x48(%rsp), %rdi
callq 0x2070
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d65
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 0x2d89
jmp 0x2d7c
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x2070
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2d9c
movq (%r15), %rsi
incq %rsi
callq 0x2150
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2db7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2dcf
movzbl %al, %ebx
jmp 0x2e15
movsbl %dil, %ebx
movq 0x3216(%rip), %r14      # 0x5ff0
leaq 0x126e(%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_O1/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 0x3a6a
movq 0x2599(%rip), %rdi      # 0x5fe8
leaq 0x66f(%rip), %rsi       # 0x40c5
movl $0x1a, %edx
callq 0x2200
movl $0x1, %eax
jmp 0x3af0
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 0x330a
movq %rsp, %rdi
callq 0x2560
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ac1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21b0
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3ad8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21b0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3aee
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 0x3bc4
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76633(%rip), %rdx     # 0x7a601
movq %rdx, %rsi
callq 0x2b022
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 0x2acc6
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_O1/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 0x7ac27(%rip), %rbx     # 0x86fd0
movq %rbx, %rdi
callq 0x3240
leaq 0x6b85f(%rip), %rsi     # 0x77c17
movl $0x1, %edx
movq %rax, %rdi
callq 0x3240
movq (%r14), %r13
cmpq %r14, %r13
je 0xc400
movq 0x7abfc(%rip), %r15     # 0x86fd0
leaq 0x6b83c(%rip), %r12     # 0x77c17
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 0xc3db
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
// File: /workspace/github_cpp_makefile_star2_O1/temelmertcan[P]multgen/src/multgen.cpp
// Function: write_to_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void write_to_file (string file_name,
                    queue<string>& verilog){

  ofstream myfile;

  myfile.open (file_name);

  int indent_count = 0;

  while(!verilog.empty()) {
    string line = verilog.front();
    if (line.compare("indent") == 0)
      indent_count++;
    else if (line.compare("outdent") == 0)
      indent_count--;
    else {
      for (int i = 0; i<indent_count; i++)
        myfile << "    ";
      myfile << line << endl;
    }
    verilog.pop();
  }

  myfile.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x248(%rbp), %r15
movq %r15, %rdi
callq 0x3370
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x30f0
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x29a8e
xorl %r14d, %r14d
leaq -0x48(%rbp), %r15
leaq 0x4fc1c(%rip), %r13     # 0x795d6
leaq -0x248(%rbp), %r12
leaq -0x38(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x2acc6
movq %r15, %rdi
leaq 0x4f2d6(%rip), %rsi     # 0x78cbb
callq 0x3090
testl %eax, %eax
je 0x29a5a
movq %r15, %rdi
leaq 0x4f339(%rip), %rsi     # 0x78d31
callq 0x3090
testl %eax, %eax
je 0x29a5f
movl %r14d, %r15d
testl %r14d, %r14d
jle 0x29a1e
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3240
decl %r15d
jne 0x29a09
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x3240
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3160
jmp 0x29a62
incl %r14d
jmp 0x29a62
decl %r14d
movq %rbx, %rdi
callq 0x2b108
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x29a7c
callq 0x31d0
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
leaq -0x48(%rbp), %r15
jne 0x299c1
leaq -0x248(%rbp), %rdi
callq 0x32c0
movq 0x5d527(%rip), %rax     # 0x86fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x240(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x248(%rbp,%rcx)
callq 0x31b0
leaq -0x150(%rbp), %rdi
callq 0x30b0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29ae6
jmp 0x29ae6
movq %rax, %rbx
jmp 0x29b02
jmp 0x29aed
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x29b02
callq 0x31d0
leaq -0x248(%rbp), %rdi
callq 0x32f0
movq %rbx, %rdi
callq 0x33a0