LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ariannagavioli[P]ALU/ExampleModule.cpp
// Function: ExampleModule::ExampleModule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
ExampleModule::ExampleModule(string name, int priority):module(name, priority) {
	string Fetch = "Fetch";
	
	//This module is the one which triggers the whole system, so it creates a message in its constructor
	if(getName() == Fetch){
		message* myMessage = new message();
		myMessage->valid = 1;
		myMessage->timestamp = getTime();
		strcpy(myMessage->source, getName().c_str());
		strcpy(myMessage->dest, "Alu");
		myMessage->magic_struct = NULL;
		
		sendWithDelay(myMessage, 10);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x34f2
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x460c
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x36c6
callq 0x2120
leaq 0x46cb(%rip), %rax      # 0x7d98
movq %rax, (%rbx)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a22(%rip), %rsi      # 0x5103
leaq 0x1a20(%rip), %rdx      # 0x5108
leaq 0x28(%rsp), %rdi
callq 0x3588
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x468c
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x372a
movq 0x8(%rsp), %r14
testq %rdx, %rdx
je 0x3733
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bpl
jmp 0x3736
movq 0x8(%rsp), %r14
xorl %ebp, %ebp
jmp 0x3736
movb $0x1, %bpl
leaq 0x18(%rsp), %r13
cmpq %r13, %r14
je 0x3748
movq %r14, %rdi
callq 0x2120
testb %bpl, %bpl
je 0x37c6
movl $0x30, %edi
callq 0x2140
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movb $0x1, 0x4(%rax)
movq %rbx, %rdi
callq 0x4720
movl %eax, 0x8(%r14)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x468c
movq %r14, %rdi
addq $0xc, %rdi
movq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2110
cmpq %r13, %r15
je 0x37a6
movq %r15, %rdi
callq 0x2120
movl $0x756c41, 0x16(%r14)   # imm = 0x756C41
movq $0x0, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x4724
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x37d5
callq 0x2120
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3801
jmp 0x3801
movq %rax, %r14
jmp 0x3813
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x381b
callq 0x2120
jmp 0x381b
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3813
callq 0x2120
movq %rbx, %rdi
callq 0x33a8
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ariannagavioli[P]ALU/System.cpp
// Function: System::notify_all(event*)
vector<event*> System::notify_all(event* e) {
	vector<event*> tempEvents;
	vector<event*> newEvents;
	
	//Notify all the modules while the message is valid (A message can become invalid if it was intercepted and digested. E.g.: A message from CPU to MEMORY intercepted by the CACHE)
	for(int i=0; i<modules.size() && e->m != NULL && e->m->valid; i++){
		tempEvents = modules[i]->notify(e);
		while(tempEvents.size() > 0){
			newEvents.push_back(tempEvents.back());//back() because std::vector does not support front pop
			tempEvents.pop_back();
		}
	}
	
	return newEvents;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rsi, 0x20(%rsp)
cmpq %rax, 0x8(%rsi)
je 0x3bfe
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x3bee
cmpb $0x1, 0x4(%rcx)
jne 0x3bee
movq (%rax,%r14,8), %rsi
movq %rsp, %rdi
movq %rdx, %r15
callq 0x46e0
movq (%rsp), %r13
movq 0x8(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rbp, %rbp
je 0x3b8e
movq %rbp, %rdi
callq 0x2120
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3b8e
callq 0x2120
cmpq %r13, %r12
je 0x3bc7
addq $-0x8, %r12
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3baf
movq (%r12), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x3bba
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4426
leaq -0x8(%r12), %rax
cmpq %r13, %r12
movq %rax, %r12
jne 0x3b97
incq %r14
movq 0x20(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %r13, %rbp
cmpq %r14, %rcx
movq %r15, %rdx
ja 0x3b34
jmp 0x3bf1
movq %rbp, %r13
testq %r13, %r13
je 0x3bfe
movq %r13, %rdi
callq 0x2120
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3c1b
movq %rax, %r14
movq %r13, %rbp
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c28
callq 0x2120
testq %rbp, %rbp
je 0x3c35
movq %rbp, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ariannagavioli[P]ALU/System.cpp
// Function: System::run()
void System::run() {
	vector<event*> tempEvents;
	for(int i=0; i<modules.size(); i++){
		tempEvents = modules[i]->initialize();
		while(tempEvents.size() > 0){
			insert(tempEvents.back());//back() because std::vector does not support front pop
			tempEvents.pop_back();
		}
	}
	
	while(!this->queue.empty()){
		tick();
	}
	//If there are no more events, the program terminates
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x3cf0
leaq 0x18(%rbx), %r15
xorl %ebp, %ebp
xorl %r13d, %r13d
movq (%rax,%rbp,8), %rsi
movq %rsp, %rdi
callq 0x46b4
movq (%rsp), %r14
movq 0x8(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %r13, %r13
je 0x3ca5
movq %r13, %rdi
callq 0x2120
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3ca5
callq 0x2120
cmpq %r14, %r12
movq %rsp, %r13
je 0x3cd1
movq -0x8(%r12), %rax
movq %rax, (%rsp)
movl (%rax), %eax
cmpl 0x38(%rbx), %eax
jl 0x3cc8
movq %r15, %rdi
movq %r13, %rsi
callq 0x423a
addq $-0x8, %r12
cmpq %r14, %r12
jne 0x3cad
incq %rbp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %r14, %r13
cmpq %rbp, %rcx
ja 0x3c65
jmp 0x3cf3
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x3d07
movq %rbx, %rdi
callq 0x3d46
jmp 0x3cf3
testq %r14, %r14
je 0x3d14
movq %r14, %rdi
callq 0x2120
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3d30
jmp 0x3d2a
movq %rax, %rbx
movq %r14, %r13
testq %r13, %r13
je 0x3d3d
movq %r13, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ariannagavioli[P]ALU/System.cpp
// Function: System::tick()
void System::tick() {
	this->currentTime = this->queue.top()->time;
	//Notify all the modules about the next event and remove it from the queue
	vector<event*> result = notify_all(this->queue.top());
	//Deallocate the message and the event
	delete this->queue.top()->m;
	delete this->queue.top();
	this->queue.pop();
	
	//Schedule all the events generated in this tick
	while (result.size() > 0) {
		this->insert(result.back());//back() because std::vector does not support front pop
		result.pop_back();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rax
movq (%rax), %rdx
movl (%rdx), %eax
movl %eax, 0x38(%rdi)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3afe
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2120
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x2120
movq %r14, %rdi
callq 0x42ae
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
cmpq %rdi, %rax
je 0x3dd6
leaq 0x18(%rsp), %r15
movq -0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movl (%rcx), %ecx
cmpl 0x38(%rbx), %ecx
jl 0x3dc8
movq %r14, %rdi
movq %r15, %rsi
callq 0x423a
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
cmpq %rdi, %rax
jne 0x3da4
testq %rdi, %rdi
je 0x3de0
callq 0x2120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3dec
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3dfd
callq 0x2120
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/ariannagavioli[P]ALU/module.cpp
// Function: module::module(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
module::module(string name, int priority){//Default priority is 0. Higher the value, higher the priority. Negative values are allowed. Modules with higher priority are notified first.
	_name = name;
	_priority = priority;
	_currentTime = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %r14
leaq 0x3760(%rip), %rax      # 0x7d80
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x30(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movq %rbx, %rdi
callq 0x2080
movl %ebp, 0x28(%r14)
movl $0x0, 0x2c(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4676
callq 0x2120
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4683
callq 0x2120
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ariannagavioli[P]ALU/module.cpp
// Function: module::notify(event*)
vector<event*> module::notify(event* e){
	_currentTime = e->time;
	onNotify(e->m);
	vector<event*> result = events;
	events.clear();
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %eax
movl %eax, 0x2c(%rsi)
movq 0x8(%rdx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x4794
movq 0x30(%r14), %rax
cmpq %rax, 0x38(%r14)
je 0x4715
movq %rax, 0x38(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ariannagavioli[P]ALU/module.cpp
// Function: module::sendWithDelay(message*, int)
void module::sendWithDelay(message* m, int delay){
	if(delay < 0)
		return;
	
	m->id = ++_messageId;
	event* e = new event();
	e->time = getTime() + delay;
	e->m = m;
	events.push_back(e);
}

// Assembly:
testl %edx, %edx
js 0x4793
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x39ee(%rip), %eax      # 0x812c
incl %eax
movl %eax, 0x39e6(%rip)      # 0x812c
movl %eax, (%rsi)
movl $0x10, %edi
callq 0x2140
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, 0x8(%rsp)
addl 0x2c(%rbx), %ebp
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x477a
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x478b
addq $0x30, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4426
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ruippeixotog[P]algo-lib/segment-tree.cpp
// Function: SegTree<Node, Op>::build(int*, int, int, int)
void build(int* arr, int node, int st, int end) {
    if (st == end) { tree[node] = Node(st, arr[st]); return; }

    build(arr, left(node), st, (st + end) / 2);
    build(arr, right(node), (st + end) / 2 + 1, end);
    tree[node] = tree[left(node)].join(tree[right(node)]);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
cmpl %r8d, %ecx
jne 0x1fe0
movslq %ecx, %rax
movl (%r12,%rax,4), %eax
movslq %ebx, %rcx
movq 0x8(%r14), %rdx
movq %rax, %rsi
shlq $0x20, %rsi
orq %rax, %rsi
movq %rsi, (%rdx,%rcx,8)
jmp 0x2058
movl %r8d, %r15d
leal (%rbx,%rbx), %edx
movl %edx, 0x4(%rsp)
leal (%r15,%rcx), %eax
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %r8d
callq 0x1faa
leal 0x1(,%rbx,2), %ebp
incl %r13d
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %r13d, %ecx
movl %r15d, %r8d
callq 0x1faa
movslq 0x4(%rsp), %rax
movq 0x8(%r14), %rcx
movslq %ebp, %rdx
movl (%rcx,%rax,8), %esi
movl 0x4(%rcx,%rax,8), %eax
movl (%rcx,%rdx,8), %edi
cmpl %esi, %edi
cmovll %edi, %esi
movl 0x4(%rcx,%rdx,8), %edx
cmpl %edx, %eax
cmovgl %eax, %edx
shlq $0x20, %rdx
orq %rdx, %rsi
movslq %ebx, %rax
movq %rsi, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ruippeixotog[P]algo-lib/segment-tree.cpp
// Function: SegTree<Node, Op>::applyPending(int, int, int)
void applyPending(int node, int st, int end) {
    if(hasPending[node]) {
      update(left(node), st, (st + end) / 2, st, end, pending[node]);
      update(right(node), (st + end) / 2 + 1, end, st, end, pending[node]);
      hasPending[node] = false;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movslq %esi, %r15
leal 0x3f(%r15), %eax
testl %r15d, %r15d
cmovnsl %r15d, %eax
sarl $0x6, %eax
movslq %eax, %r13
shlq $0x3, %r13
movq 0x20(%rdi), %rsi
addq %r13, %rsi
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq 0x3f(%rcx), %r8
andq %r15, %r8
xorl %eax, %eax
cmpq %rcx, %r8
setbe %al
movl $0x1, %r14d
movl %r15d, %ecx
shlq %cl, %r14
movq -0x8(%rsi,%rax,8), %rcx
btq %r15, %rcx
jae 0x236d
movl %edx, %r12d
leaq -0x8(,%rax,8), %rax
movq %rax, 0x10(%rsp)
leal (%r15,%r15), %esi
leal (%rbx,%r12), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movq 0x48(%rdi), %rax
movq (%rax,%r15,8), %rax
movq %rax, (%rsp)
movl %ebp, %ecx
movq %rdi, 0x8(%rsp)
movl %edx, %r8d
movl %ebx, %r9d
callq 0x2068
leal 0x1(,%r15,2), %esi
incl %ebp
movq 0x8(%rsp), %rdi
movq 0x48(%rdi), %rax
movq (%rax,%r15,8), %rax
movq %rax, (%rsp)
movq %rdi, %r15
movl %ebp, %edx
movl %ebx, %ecx
movl %r12d, %r8d
movl %ebx, %r9d
callq 0x2068
addq 0x20(%r15), %r13
notq %r14
movq 0x10(%rsp), %rax
andq %r14, (%rax,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ruippeixotog[P]algo-lib/segment-tree.cpp
// Function: SegTree<Node, Op>::query(int, int, int, int, int)
Node query(int node, int st, int end, int i, int j) {
    if (j < st || i > end) return Node();
    if (st >= i && end <= j) return tree[node];

    applyPending(node, st, end);
    Node p1 = query(left(node), st, (st + end) / 2, i, j);
    Node p2 = query(right(node), (st + end) / 2 + 1, end, i, j);
    return p1.join(p2);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
cmpl %edx, %r9d
setl %al
cmpl %ecx, %r8d
setg %cl
orb %al, %cl
je 0x23ad
movl $0xc4653600, %ecx       # imm = 0xC4653600
movl $0x3b9aca00, %r13d      # imm = 0x3B9ACA00
jmp 0x2464
movl %r9d, %ebx
movl %r8d, %ebp
movl %edx, %r13d
movl %esi, %r12d
cmpl %r8d, %edx
setl %al
cmpl %r9d, %r14d
setg %cl
orb %al, %cl
je 0x2452
movq %rdi, 0x8(%rsp)
movl %r12d, %esi
movl %r13d, %edx
movl %r14d, %ecx
callq 0x2292
leal (%r12,%r12), %esi
leal (%r14,%r13), %eax
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
movq 0x8(%rsp), %rdi
movl %r13d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x237c
movq %rax, %r13
shrq $0x20, %rax
movq %rax, 0x10(%rsp)
leal 0x1(,%r12,2), %esi
incl %r15d
movq 0x8(%rsp), %rdi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x237c
movq %rax, %rcx
shrq $0x20, %rcx
cmpl %r13d, %eax
cmovll %eax, %r13d
movq 0x10(%rsp), %rax
cmpl %ecx, %eax
cmovgl %eax, %ecx
jmp 0x2464
movslq %r12d, %rax
movq 0x8(%rdi), %rcx
movq (%rcx,%rax,8), %r13
movq %r13, %rcx
shrq $0x20, %rcx
shlq $0x20, %rcx
movl %r13d, %eax
orq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/threads/part3/timed_mutex.cpp
// Function: work()
void work(){
    std::chrono::milliseconds timeout(100);

    while(true){
        if(mutex.try_lock_for(timeout)){
            std::cout << std::this_thread::get_id() << ": do work with the mutex" << std::endl;

            std::chrono::milliseconds sleepDuration(250);
            std::this_thread::sleep_for(sleepDuration);

            mutex.unlock();

            std::this_thread::sleep_for(sleepDuration);
        } else {
            std::cout << std::this_thread::get_id() << ": do work without mutex" << std::endl;

            std::chrono::milliseconds sleepDuration(100);
            std::this_thread::sleep_for(sleepDuration);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x2d27(%rip), %r13      # 0x3fd8
leaq 0x10(%rsp), %rbx
leaq 0x2e23(%rip), %r14      # 0x40e0
leaq 0xd59(%rip), %r12       # 0x201d
movq %rsp, %rbp
movq $0x64, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1528
movl %eax, %r15d
callq 0x10c0
testb %r15b, %r15b
je 0x12fb
testq %rax, %rax
je 0x1317
movq %r13, %rdi
movq %rax, %rsi
callq 0x1080
movq %rax, %r15
jmp 0x132e
testq %rax, %rax
je 0x13d0
movq %r13, %rdi
movq %rax, %rsi
callq 0x1080
movq %rax, %r15
jmp 0x13e7
movl $0x24, %edx
leaq 0xd12(%rip), %rsi       # 0x2035
movq %r13, %rdi
callq 0x1110
movq %r13, %r15
movl $0x18, %edx
leaq 0xcca(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1110
movq (%r15), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x10f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq $0x0, (%rsp)
movq $0xee6b280, 0x8(%rsp)   # imm = 0xEE6B280
movq %rbp, %rdi
movq %rbp, %rsi
callq 0x1060
cmpl $-0x1, %eax
jne 0x1394
callq 0x1040
cmpl $0x4, (%rax)
je 0x137a
movq %r14, %rdi
callq 0x10a0
movq $0x0, (%rsp)
movq $0xee6b280, 0x8(%rsp)   # imm = 0xEE6B280
movq %rbp, %rdi
movq %rbp, %rsi
callq 0x1060
cmpl $-0x1, %eax
jne 0x12ce
callq 0x1040
cmpl $0x4, (%rax)
je 0x13ad
jmp 0x12ce
movl $0x24, %edx
leaq 0xc59(%rip), %rsi       # 0x2035
movq %r13, %rdi
callq 0x1110
movq %r13, %r15
movl $0x17, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1110
movq (%r15), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x10f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq $0x0, (%rsp)
movq $0x5f5e100, 0x8(%rsp)   # imm = 0x5F5E100
movq %rbp, %rdi
movq %rbp, %rsi
callq 0x1060
cmpl $-0x1, %eax
jne 0x12ce
callq 0x1040
cmpl $0x4, (%rax)
je 0x142f
jmp 0x12ce
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/text_editor.cc
// Function: main
int main (int argc, char** argv) {
 bool toggle=true;  //initiate with line numbering on
 text_ed T;
 if (argc > 1) {
   if (!T.load_file(argv[1]))
     cerr << "Could not open file \"" << argv[1] << "\"." << endl;
 }
 bool keep_going;
 do {
   keep_going = Do_Command(T,toggle);
 } while (keep_going);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movb $0x1, -0x11(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x63a4
cmpl $0x1, %r14d
jle 0x5ec5
movq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x5f20
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x66ae
movl %eax, %r14d
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e1e
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
testb %r14b, %r14b
jne 0x5ec5
movq 0x41c2(%rip), %r14      # 0x9ff0
leaq 0x161d(%rip), %rsi      # 0x7452
movl $0x15, %edx
movq %r14, %rdi
callq 0x2180
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x5e67
movq %rbx, %rdi
callq 0x2090
movq 0x4196(%rip), %rdi      # 0x9ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x5e7f
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq 0x416a(%rip), %rbx      # 0x9ff0
leaq 0x150c(%rip), %rsi      # 0x7399
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq 0x4138(%rip), %rdi      # 0x9ff0
callq 0x2040
movq %rax, %rdi
callq 0x20d0
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x5641
testb %al, %al
jne 0x5ec5
leaq -0x78(%rbp), %rdi
callq 0x6586
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f0f
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x5f0f
jmp 0x5f0c
jmp 0x5f0c
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x6586
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::copy_to_buffer(int, int)
bool text_ed::copy_to_buffer(int start, int end) {  // Copy lines start through end to the buffer.
  int buff_capacity=end-start+1;
  int i,j,k;
  buffer= new string [buff_capacity+1]; 
  for (i=start,j=0; i<=end; i++,j++) { //copy document contents into buffer
    buffer[j]=document[i];
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movl %edx, %eax
subl %esi, %eax
leal 0x2(%rax), %ecx
movslq %ecx, %r13
movq %r13, %r12
shlq $0x5, %r12
leaq 0x8(%r12), %rcx
cmpl $-0x2, %eax
movq $-0x1, %rdi
cmovgeq %rcx, %rdi
callq 0x2030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testl %r13d, %r13d
je 0x6104
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r12
jne 0x60eb
movq %rcx, 0x8(%r14)
subl %r15d, %ebx
jl 0x6137
movslq %r15d, %r15
incl %ebx
shlq $0x5, %r15
xorl %r12d, %r12d
movq (%r14), %rsi
addq %r15, %rsi
addq %r12, %rsi
movq 0x8(%r14), %rdi
addq %r12, %rdi
callq 0x20b0
addq $0x20, %r12
decq %rbx
jne 0x6119
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::copy_to_document(int, int, int)
bool text_ed::copy_to_document(int start, int end, int location) { // Copy the entire buffer to the document starting at line start.
  int buff_capacity=end-start+1;
  int i,j;
  for (i=location+1,j=0; j<buff_capacity; i++,j++) {
    document[i]=buffer[j]; //copy buffer contents to document
  }
  delete [] buffer;
  buffer = NULL; //set buffer pointer to null so destructor function works properly
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
subl %esi, %r14d
jl 0x6190
movslq %ecx, %r15
incl %r14d
shlq $0x5, %r15
addq $0x20, %r15
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movq (%rbx), %rdi
addq %r15, %rdi
addq %r12, %rdi
callq 0x20b0
addq $0x20, %r12
decq %r14
jne 0x6172
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x61e5
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x61d2
addq $-0x10, %r12
movq %r15, %r13
shlq $0x5, %r13
leaq (%r12,%r13), %rax
movq -0x10(%r12,%r13), %rdi
cmpq %rdi, %rax
je 0x61cc
movq (%rax), %rsi
incq %rsi
callq 0x2140
addq $-0x20, %r13
jne 0x61b3
shlq $0x5, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x22a0
movq $0x0, 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::open_up(int, int)
bool text_ed::open_up(int start, int num_lines) { // Create num_lines empty lines following start.
 int space_left;
 int i;
 space_left = capacity-last_line;
 while (space_left <=num_lines) {
   expand_document();
   space_left = capacity - last_line;
 }
 for (i=last_line; i>start; i--) {
   document[i+num_lines] = document[i];
 }
 last_line += num_lines;
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %r14
movl 0x10(%rdi), %eax
movl 0x18(%rdi), %ecx
subl %eax, %ecx
cmpl %edx, %ecx
jg 0x6238
movq %r14, %rdi
callq 0x6290
movl 0x10(%r14), %eax
movl 0x18(%r14), %ecx
subl %eax, %ecx
cmpl %r12d, %ecx
jle 0x6221
cmpl %r15d, %eax
jle 0x6278
movslq %eax, %rbx
movl %r12d, -0x2c(%rbp)
movslq %r12d, %r13
movslq %r15d, %r15
shlq $0x5, %r13
movq %rbx, %r12
shlq $0x5, %r12
movq (%r14), %rsi
addq %r12, %rsi
leaq (%rsi,%r13), %rdi
callq 0x20b0
decq %rbx
addq $-0x20, %r12
cmpq %r15, %rbx
jg 0x6255
movl 0x10(%r14), %eax
movl -0x2c(%rbp), %r12d
addl %r12d, %eax
movl %eax, 0x10(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::expand_document()
void text_ed::expand_document() { // Add more lines to the document array, e.g., double capacity.
 int i;
 capacity *= 2; //double document capacity
   string* temp = new string[capacity+1];
   for (i=0; i<capacity/2; i++) { //copy contents of document into temp
     temp[i]=document[i];
   }
   delete [] document; //delete contents of original document
   document = temp; //set document equal to temp contents of temp
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r14d
leal (%r14,%r14), %r15d
movl %r15d, 0x18(%rdi)
leal 0x1(,%r14,2), %eax
movslq %eax, %r12
movq %r12, %rax
shlq $0x5, %rax
orq $0x8, %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %r12, (%rax)
leaq 0x8(%rax), %r12
addq $0x18, %rax
movslq %r15d, %rcx
shlq $0x5, %rcx
orq $0x20, %rcx
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %rcx
jne 0x62ec
testl %r14d, %r14d
jle 0x633a
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rsi
addq %r14, %rsi
leaq (%r12,%r14), %rdi
callq 0x20b0
incq %r15
movl 0x18(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x6310
movq (%rbx), %r13
testq %r13, %r13
je 0x6391
leaq -0x8(%r13), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%r13), %r14
testq %r14, %r14
je 0x637d
addq $-0x10, %r13
movq %r14, %r15
shlq $0x5, %r15
leaq (%r15,%r13), %rax
movq -0x10(%r13,%r15), %rdi
cmpq %rdi, %rax
je 0x6377
movq (%rax), %rsi
incq %rsi
callq 0x2140
addq $-0x20, %r15
jne 0x635e
shlq $0x5, %r14
orq $0x8, %r14
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x22a0
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::operator=(text_ed&)
text_ed& text_ed::operator=(text_ed& rhs) { //overloading assignment
 if ( this != &rhs ) {
   delete [] document;
   last_line = rhs.last_line;
   capacity = rhs.capacity;
   document = new string[capacity];
   for (int i=0; i<last_line; i++) {
     document[i] = rhs.document[i];
   }
 }
 return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x6573
movq %rsi, %r14
movq (%rbx), %r13
testq %r13, %r13
je 0x64ec
leaq -0x8(%r13), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%r13), %r15
testq %r15, %r15
je 0x64d8
addq $-0x10, %r13
movq %r15, %r12
shlq $0x5, %r12
leaq (%r12,%r13), %rax
movq -0x10(%r13,%r12), %rdi
cmpq %rdi, %rax
je 0x64d2
movq (%rax), %rsi
incq %rsi
callq 0x2140
addq $-0x20, %r12
jne 0x64b9
shlq $0x5, %r15
orq $0x8, %r15
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x22a0
movl 0x10(%r14), %r15d
movl %r15d, 0x10(%rbx)
movslq 0x18(%r14), %r13
movq %r13, %r12
shlq $0x5, %r12
leaq 0x8(%r12), %rax
testq %r13, %r13
movl %r13d, 0x18(%rbx)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %r13, (%rax)
testq %r13, %r13
je 0x6544
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r12
jne 0x652b
movq %rcx, (%rbx)
testl %r15d, %r15d
jle 0x6573
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
addq %r15, %rsi
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x20b0
incq %r12
movslq 0x10(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x6552
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::load_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool text_ed::load_file(string filename) { // Read the file and remember the name in current_file.
 string nextline;
 current_file = filename;
 last_line=0;
 ifstream form (filename.c_str());
 while (getline(form,nextline)) { //while lines can be retrieved, insert them into document array
   insert_line(nextline,last_line);
 }
 form.close();
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
addq $0x20, %rdi
callq 0x20b0
movl $0x0, 0x10(%rbx)
movq (%r14), %rsi
leaq -0x270(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2280
leaq -0x58(%rbp), %r15
leaq -0x68(%rbp), %r12
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq %r14, %rdi
leaq -0x48(%rbp), %rsi
callq 0x2290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x67a3
movq %r15, -0x68(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x5f5e
movl 0x10(%rbx), %r13d
movq %rbx, %rdi
movl %r13d, %esi
movl $0x1, %edx
callq 0x61fe
movslq %r13d, %rax
movq (%rbx), %rcx
shlq $0x5, %rax
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
movq %r12, %rsi
callq 0x20b0
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x670b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x670b
leaq -0x270(%rbp), %rdi
callq 0x2060
leaq -0x270(%rbp), %rdi
callq 0x2070
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x67d4
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
movb $0x1, %al
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x680e
movq %rax, %rbx
jmp 0x681d
movq %rax, %rbx
jmp 0x6821
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x6811
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x6811
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x2070
leaq -0x38(%rbp), %r15
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x6836
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::save_file()
bool text_ed::save_file() { //function to check if saving to a given filename is possible and save it
 if (save_file(current_file)) { 
 return true;
 } else {
   return false;
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x5f5e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6900
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x68d3
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x68f8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::save_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool text_ed::save_file (string filename) { // Save the text under the new name; remember the new name in current_file.
 ofstream savefile;
 int i;
 savefile.open(filename.c_str());
 for (i=1; i<=last_line; i++) { //save each line from document arry to file
   savefile << document[i]; 
   savefile << endl;
 }
 savefile.close();
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x220(%rbp), %r14
movq %r14, %rdi
callq 0x2230
movq (%r15), %rsi
movq %r14, %rdi
movl $0x10, %edx
callq 0x2050
cmpl $0x0, 0x10(%rbx)
jle 0x6995
movl $0x28, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %r14, %rdi
callq 0x2180
movq -0x220(%rbp), %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 0x20d0
movslq 0x10(%rbx), %rax
incq %r12
addq $0x20, %r15
cmpq %rax, %r12
jl 0x6946
leaq -0x220(%rbp), %rdi
callq 0x21b0
movq 0x3610(%rip), %rax      # 0x9fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x218(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x220(%rbp,%rcx)
callq 0x2100
leaq -0x128(%rbp), %rdi
callq 0x2080
movb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x69eb
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::get_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
bool text_ed::get_line(string& dest, int n) { // Copy line n into dest.
  if (n>last_line) {
    return false;
  }
 dest = document[n];
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl 0x10(%rdi), %r14d
cmpl %edx, %r14d
jl 0x6a9b
movslq %ebx, %rax
shlq $0x5, %rax
addq (%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x20b0
cmpl %ebx, %r14d
setge %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::copy_lines(int, int, int)
bool text_ed::copy_lines(int start, int end, int location) { //copy lines start through end to follow line location.
  int buff_capacity=end-start+1;
  copy_to_buffer(start,end);
  open_up(location, buff_capacity);
  copy_to_document(start,end,location);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl %edx, %r13d
subl %esi, %r13d
incl %r13d
callq 0x609c
movq %r12, %rdi
movl %ebx, %esi
movl %r13d, %edx
callq 0x61fe
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x6148
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::move_lines(int, int, int)
bool text_ed::move_lines(int start, int end, int location) { //move lines between two given lines (start to end) to after the given line location
  if (location<start || location>end) { //make sure new line location isnt between the start and end selections
    copy_lines(start,end,location);
    delete_lines(start,end); //delete the original lines so there aren't duplicates
    return true;
  } else {
    cout << "Error. Make sure location given is not between the two lines selected." << endl;
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl %esi, %ecx
setl %al
cmpl %edx, %ecx
setg %bl
orb %al, %bl
cmpb $0x1, %bl
jne 0x6b36
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
callq 0x6aa6
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x6a02
jmp 0x6b78
movq 0x348b(%rip), %r14      # 0x9fc8
leaq 0x94e(%rip), %rsi       # 0x7492
movl $0x46, %edx
movq %r14, %rdi
callq 0x2180
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 0x20d0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
bool text_ed::replace(string oldstr, string newstr, int start, int end) { //replace old word with new word between given lines (start to end)
  int i, j;
  for (i=start; i<=end; i++) { //for each line in the given area
    for(j=0;j<document[i].length(); j++){ //for character in string
      if(document[i].substr(j,oldstr.length())==oldstr){ //if substring found starting at the character position
	document[i].replace(j,oldstr.length(),newstr); //replace old string with new string
      }
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x38(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl %r8d, %ecx
jg 0x6c80
movq %rsi, %r15
movslq %ecx, %r14
incl -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %r14, -0x40(%rbp)
shlq $0x5, %r14
cmpq $0x0, 0x8(%rax,%r14)
je 0x6c6f
addq %r14, %rax
xorl %ebx, %ebx
movq %rax, %rsi
movq 0x8(%r15), %rcx
leaq -0x68(%rbp), %rdi
movq %rbx, %rdx
callq 0x2160
movq -0x60(%rbp), %rdx
cmpq 0x8(%r15), %rdx
jne 0x6c0c
movq -0x68(%rbp), %r13
testq %rdx, %rdx
je 0x6c15
movq (%r15), %rsi
movq %r13, %rdi
callq 0x2150
testl %eax, %eax
sete %r12b
jmp 0x6c18
movq -0x68(%rbp), %r13
xorl %r12d, %r12d
jmp 0x6c18
movb $0x1, %r12b
leaq -0x58(%rbp), %rax
cmpq %rax, %r13
je 0x6c30
movq -0x58(%rbp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x2140
testb %r12b, %r12b
je 0x6c56
movq -0x38(%rbp), %rax
movq (%rax), %rdi
addq %r14, %rdi
movq 0x8(%r15), %rdx
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %rsi
callq 0x2170
incq %rbx
movq -0x38(%rbp), %rax
movq (%rax), %rax
leaq (%rax,%r14), %rsi
cmpq %rbx, 0x8(%rax,%r14)
ja 0x6bd6
movq -0x40(%rbp), %r14
incq %r14
cmpl %r14d, -0x2c(%rbp)
jne 0x6bba
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::FinalizeConstruct()
void ClassFactory::FinalizeConstruct()
  {
    Locator = Boss::Private::GetServiceLocator();
    if (Locator.Get() && Locator->AddService(Service::Locator::Id::ClassFactoryService, GetThisIBase()))
      throw ClassFactoryException("Failed to put ClassFactory into ServiceLocator");
    
    //CleanerThread.reset(new std::thread(&ClassFactory::Clean, this));
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x78340
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x7bf33
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %r14
movq %r14, 0xd0(%rbx)
testq %r14, %r14
je 0x7bf61
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movl $0x16d1a76d, %esi       # imm = 0x16D1A76D
movq %rax, %rdx
callq *0x30(%rcx)
testl %eax, %eax
jne 0x7bf69
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x77550
movq %rax, %r14
leaq 0xa5093(%rip), %rsi     # 0x121010
movq %rax, %rdi
callq 0x769c0
movq 0xdfdd4(%rip), %rsi     # 0x15bd60
movq 0xdf2f5(%rip), %rdx     # 0x15b288
movq %r14, %rdi
callq 0x77b10
movq %rax, %rbx
movq %r14, %rdi
callq 0x76370
jmp 0x7bfba
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7bfba
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x11dae0
movq %rax, %rdi
callq 0x7cf68
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::BeforeRelease()
void ClassFactory::BeforeRelease()
  {
    std::lock_guard<std::recursive_mutex> Lock(Mtx);
    IsRunCleaner = false;
    //CleanerThread->join();
    CleanerThread.reset();
    Registry.Release();
    for (auto &i : Modules)
    {
      try
      {
        assert(!i.second->GetModule().GetRefCount() && "Module has not null reference counter.");
      }
      catch (...)
      {
        assert(false && "Failed to get module reference counter.");
      }
    }
    if (Locator.Get())
      Locator->DelService(Service::Locator::Id::ClassFactoryService);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x78d60
testl %eax, %eax
jne 0x7c07c
movb $0x0, 0xb8(%r14)
leaq 0xc0(%r14), %rdi
xorl %esi, %esi
callq 0x790a0
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x7c00e
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0xc8(%r14)
leaq 0x90(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x7c058
movq 0x10(%r15), %rdi
addq $0x8, %rdi
callq 0x775d0
testl %eax, %eax
je 0x7c020
leaq 0xa4fff(%rip), %rdi     # 0x12103f
leaq 0xa5049(%rip), %rsi     # 0x121090
leaq 0xa506b(%rip), %rcx     # 0x1210b9
movl $0x5d, %edx
callq 0x76990
movq 0xd0(%r14), %rdi
testq %rdi, %rdi
je 0x7c06f
movq (%rdi), %rax
movl $0x16d1a76d, %esi       # imm = 0x16D1A76D
callq *0x38(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x79140
movl %eax, %edi
callq 0x79120
movq %rax, %r14
movq %rbx, %rdi
callq 0x79140
movq %r14, %rdi
callq 0x11dae0
movq %rax, %rdi
callq 0x76470
leaq 0xa503d(%rip), %rdi     # 0x1210e2
leaq 0xa4fe4(%rip), %rsi     # 0x121090
leaq 0xa5006(%rip), %rcx     # 0x1210b9
movl $0x61, %edx
callq 0x76990
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::SetRegistry(Boss::IServiceRegistry*)
RetCode BOSS_CALL ClassFactory::SetRegistry(IServiceRegistry *registry)
  {
    try
    {
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      Registry = registry;
    }
    catch (...)
    {
      return Status::Fail;
    }
    return Status::Ok;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x78d60
testl %eax, %eax
jne 0x7c605
addq $0xc8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x790f0
movq %rbx, %rdi
callq 0x79140
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x79120
movq %rax, %r14
movq %rbx, %rdi
callq 0x79140
jmp 0x7c61c
movq %rax, %r14
movq %r14, %rdi
callq 0x76470
callq 0x78090
movl $0x2, %eax
jmp 0x7c5ff
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::ModuleHolder::GetRefCount() const
UInt const GetRefCount() const
    {
      typedef RetCode (*PFNBossGetRefCount)(UInt *);
      auto *BossGetRefCount = Dll.GetProc<PFNBossGetRefCount>("BossGetRefCount");
      UInt RefCount = 0;
      if (BossGetRefCount(&RefCount) != Status::Ok)
        throw ModuleHolderException("Failed to call BossGetRefCount.");
      return RefCount;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xa4835(%rip), %rsi     # 0x121115
leaq 0xa483d(%rip), %rdx     # 0x121124
leaq 0x8(%rsp), %rdi
callq 0x786b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x780e0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7c910
callq 0x76e40
leaq 0x8(%rsp), %rdi
movl $0x0, (%rdi)
callq *%rbx
testl %eax, %eax
jne 0x7c92d
movl 0x8(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x77550
movq %rax, %r14
leaq 0xa47e4(%rip), %rsi     # 0x121125
movq %rax, %rdi
callq 0x76080
movq 0xdf070(%rip), %rsi     # 0x15b9c0
movq 0xde931(%rip), %rdx     # 0x15b288
movq %r14, %rdi
callq 0x77b10
movq %rax, %rbx
movq %r14, %rdi
callq 0x76370
jmp 0x7c983
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7c983
callq 0x76e40
jmp 0x7c983
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11dae0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/src/class_factory/class_factory.cpp
// Function: Boss::ClassFactory::ModuleHolderEx::ModuleHolderEx(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ModuleHolderEx(std::string const &path)
      : Module(std::move(DllHolder(path)))
    {
      auto Locator = Private::GetServiceLocator();
      if (Locator.Get())
      {
        Module.SetServiceLocator(Locator.Get());
        LocatorExists = false;
      }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movb $0x0, (%rdi)
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x78f40
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x79320
leaq 0x8(%r14), %rbx
movq %rsp, %rdi
callq 0x78340
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x7da43
movq %rbx, %rdi
callq 0x78dd0
movb $0x0, (%r14)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7da43
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x7da78
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7da66
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x7da66
jmp 0x7da78
movq %rax, %r14
movq %rbx, %rdi
callq 0x79320
movq %r14, %rdi
callq 0x11dae0
jmp 0x7da78
movq %rax, %rdi
callq 0x7cf68
// File: /workspace/github_cpp_makefile_star2_O3/tetsuok[P]kernel-pa/kernel_pa.cc
// Function: kernel::(anonymous namespace)::Usage(char const*)
[[noreturn]] void Usage(const char* name) {
  cerr << "usage: " << name << " [-C FLOAT] [-d INT] [-t INT] [-o FILE] FILE\n"
      "-C hyperparameter passive-aggressive. C should be positive. (default: " << kC << ")\n"
      "-d the degree of polynomial kernel (supported: d = 1, 2, 3, and 4) (deafult: " << kKernelDegree << ")\n"
      "-t the number of iterations (default: " << kNumIter << ")\n"
      "-o model filename (default " << kModel << ")\n";
  exit(1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x6707(%rip), %rdi      # 0x8ff0
leaq 0x3778(%rip), %rsi      # 0x6068
callq 0x2180
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x3769(%rip), %rsi      # 0x6070
movq %rax, %rdi
callq 0x2180
movsd 0x36f1(%rip), %xmm0     # 0x6008
movq %rax, %rdi
callq 0x22f0
leaq 0x37be(%rip), %rsi      # 0x60e4
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movl $0x2, %esi
callq 0x22a0
leaq 0x37f2(%rip), %rsi      # 0x6134
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movl $0x3, %esi
callq 0x22a0
leaq 0x37ff(%rip), %rsi      # 0x615d
movq %rax, %rdi
callq 0x2180
leaq 0x36a3(%rip), %rsi      # 0x6010
movq %rax, %rdi
callq 0x2180
leaq 0x37ff(%rip), %rsi      # 0x617b
movq %rax, %rdi
callq 0x2180
movl $0x1, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/dinit.cc
// Function: sigquit_cb(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&)
static void sigquit_cb(eventloop_t &eloop) noexcept
{
    // This performs an immediate shutdown, without service rollback.
    close_control_socket();
    execl(shutdown_exec.c_str(), shutdown_exec.c_str(), "--system", (char *) 0);
    log(loglevel_t::ERROR, error_exec_sd, strerror(errno));
    sync(); // since a hard poweroff might be required at this point...
}

// Assembly:
pushq %rbx
callq 0xb0fd
leaq 0x29425(%rip), %rdi     # 0x33ece
leaq 0x28725(%rip), %rdx     # 0x331d5
movq %rdi, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x8750
callq 0x8050
movl (%rax), %edi
callq 0x81d0
movq %rax, %rbx
leaq 0x2940b(%rip), %rsi     # 0x33edd
movl $0x3, %edi
callq 0x2e412
movq %rbx, %rdi
callq 0x2e53c
popq %rbx
jmp 0x85b0
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/dinit.cc
// Function: control_socket_ready()
static void control_socket_ready() noexcept
{
    if (!control_socket_open || socket_ready_fd < 0) {
        return;
    }
    write(socket_ready_fd, control_socket_path, strlen(control_socket_path) + 1);
    // Once done with, close it (but leave stdout/stderr alone)
    if (socket_ready_fd > 2) {
        close(socket_ready_fd);
    }
    // Ensure that we don't try to issue readiness again:
    socket_ready_fd = -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x3b539(%rip), %ebx     # 0x465e0
testl %ebx, %ebx
setns %al
andb 0x3bc71(%rip), %al      # 0x46d23
cmpb $0x1, %al
jne 0xb0ed
movq 0x3b52b(%rip), %r14     # 0x465e8
movq %r14, %rdi
callq 0x8230
leaq 0x1(%rax), %rdx
movl %ebx, %edi
movq %r14, %rsi
callq 0x81e0
movl 0x3b507(%rip), %edi     # 0x465e0
cmpl $0x3, %edi
jl 0xb0e3
callq 0x8b60
movl $0xffffffff, 0x3b4f3(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xb74e