LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x20a0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x83d0
jmp 0x49b9
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq -0xc8(%rbp), %rax
leaq 0x93c0(%rip), %rcx      # 0xdd90
movq %rcx, (%rax)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x2260
movq -0xd0(%rbp), %rdx
leaq 0x5712(%rip), %rsi      # 0xa103
leaq -0x68(%rbp), %rdi
callq 0x21d0
jmp 0x49fc
leaq -0x69(%rbp), %rdi
callq 0x21a0
movq -0xc8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x8470
jmp 0x4a1a
leaq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4220
movb %al, -0xd1(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x20e0
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x4a4b
jmp 0x4b91
movl $0x30, %edi
callq 0x2180
movq %rax, -0xe0(%rbp)
jmp 0x4a5e
movq -0xe0(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x42b0
movq -0xe0(%rbp), %rax
movq -0xc8(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movb $0x1, 0x4(%rax)
callq 0x85a0
movl %eax, -0xe4(%rbp)
jmp 0x4aa5
movq -0xc8(%rbp), %rsi
movl -0xe4(%rbp), %ecx
movq -0x98(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x98(%rbp), %rax
addq $0xc, %rax
movq %rax, -0xf0(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x8470
jmp 0x4adc
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x2080
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x2150
movq -0xf8(%rbp), %rdi
callq 0x20e0
movq -0x98(%rbp), %rdi
addq $0x16, %rdi
leaq 0x55e3(%rip), %rsi      # 0xa0ff
callq 0x2150
movq -0xc8(%rbp), %rdi
movq -0x98(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x98(%rbp), %rsi
movl $0xa, %edx
callq 0x85c0
jmp 0x4b4a
jmp 0x4b91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20e0
jmp 0x4baf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x21a0
jmp 0x4ba3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20e0
jmp 0x4ba3
leaq -0x68(%rbp), %rdi
callq 0x20e0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x42e0
movq -0x40(%rbp), %rdi
callq 0x2250
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6400
movq -0x68(%rbp), %rdi
movb $0x0, -0x31(%rbp)
callq 0x6400
movl $0x0, -0x38(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x6420
movq -0x88(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x79(%rbp)
jae 0x508d
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x79(%rbp)
je 0x508d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movb 0x4(%rax), %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x5099
jmp 0x512f
movq -0x70(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0x6440
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x8520
jmp 0x50b8
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6460
leaq -0x50(%rbp), %rdi
callq 0x44a0
leaq -0x30(%rbp), %rdi
callq 0x6490
cmpq $0x0, %rax
jbe 0x511f
leaq -0x30(%rbp), %rdi
callq 0x6520
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x64b0
jmp 0x50f4
leaq -0x30(%rbp), %rdi
callq 0x6560
jmp 0x50ce
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x44a0
leaq -0x30(%rbp), %rdi
callq 0x44a0
jmp 0x5158
jmp 0x5121
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5047
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x5142
movq -0x68(%rbp), %rdi
callq 0x44a0
leaq -0x30(%rbp), %rdi
callq 0x44a0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6400
movl $0x0, -0x24(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x6420
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x523e
movq -0x58(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6440
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x84c0
jmp 0x51d0
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6460
leaq -0x40(%rbp), %rdi
callq 0x44a0
leaq -0x20(%rbp), %rdi
callq 0x6490
cmpq $0x0, %rax
jbe 0x522e
leaq -0x20(%rbp), %rdi
callq 0x6520
movq -0x58(%rbp), %rdi
movq (%rax), %rsi
callq 0x4fc0
jmp 0x520c
leaq -0x20(%rbp), %rdi
callq 0x6560
jmp 0x51e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x44a0
jmp 0x5279
jmp 0x5230
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5194
jmp 0x5240
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0x6590
movb %al, -0x61(%rbp)
jmp 0x5252
movb -0x61(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x525d
jmp 0x526a
movq -0x58(%rbp), %rdi
callq 0x5290
jmp 0x5268
jmp 0x5240
leaq -0x20(%rbp), %rdi
callq 0x44a0
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x65b0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x38(%rax)
callq 0x65b0
movq -0x48(%rbp), %rsi
movq (%rax), %rdx
leaq -0x20(%rbp), %rdi
callq 0x5000
movq -0x40(%rbp), %rdi
callq 0x65b0
movq %rax, -0x38(%rbp)
jmp 0x52e8
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x5306
movq -0x50(%rbp), %rdi
callq 0x2160
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x65b0
movq %rax, -0x58(%rbp)
jmp 0x5319
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x5333
movq -0x60(%rbp), %rdi
callq 0x2160
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x65d0
jmp 0x5342
jmp 0x5344
leaq -0x20(%rbp), %rdi
callq 0x6490
cmpq $0x0, %rax
jbe 0x538c
leaq -0x20(%rbp), %rdi
callq 0x6520
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x4fc0
jmp 0x536a
leaq -0x20(%rbp), %rdi
callq 0x6560
jmp 0x5344
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x44a0
jmp 0x539b
leaq -0x20(%rbp), %rdi
callq 0x44a0
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq 0x5982(%rip), %rax      # 0xdd78
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x21e0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x40(%rbp)
callq 0x6400
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2030
jmp 0x8426
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x28(%rax)
movl $0x0, 0x2c(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x44a0
movq -0x38(%rbp), %rdi
callq 0x20e0
movq -0x20(%rbp), %rdi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rdi)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb $0x0, -0x19(%rbp)
addq $0x30, %rsi
callq 0x8660
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x8750
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8592
movq -0x30(%rbp), %rdi
callq 0x44a0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x85e3
jmp 0x864e
movl 0x5b8b(%rip), %ecx      # 0xe174
addl $0x1, %ecx
movl %ecx, 0x5b82(%rip)      # 0xe174
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x10, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x20d0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x85a0
movq -0x28(%rbp), %rdi
movl %eax, %ecx
addl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x64b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ruippeixotog[P]algo-lib/segment-tree.cpp
// Function: SegTree<Node, Op>::SegTree(int)
SegTree(int n) {
    size = n;
    tree.resize(4 * n + 1);
    hasPending.resize(4 * n + 1);
    pending.resize(4 * n + 1);
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
callq 0x1e40
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1e50
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x10(%rsp)
callq 0x1e60
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x3c(%rsp), %ecx
movl %ecx, %eax
leal 0x1(,%rax,4), %eax
movslq %eax, %rsi
callq 0x1e70
jmp 0x1d92
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movl 0x3c(%rsp), %ecx
movl %ecx, %eax
leal 0x1(,%rax,4), %eax
movslq %eax, %rsi
xorl %edx, %edx
callq 0x1f10
jmp 0x1db4
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movl 0x3c(%rsp), %ecx
movl %ecx, %eax
leal 0x1(,%rax,4), %eax
movslq %eax, %rsi
callq 0x2060
jmp 0x1dd4
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x16d0
movq 0x8(%rsp), %rdi
callq 0x1730
movq 0x20(%rsp), %rdi
callq 0x1740
movq 0x30(%rsp), %rdi
callq 0x1170
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movl %ecx, 0x60(%rsp)
movl %r8d, 0x5c(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x60(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jne 0x585a
movl 0x60(%rsp), %esi
movq 0x68(%rsp), %rax
movslq 0x60(%rsp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x54(%rsp), %rdi
callq 0x5970
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
movslq 0x64(%rsp), %rsi
callq 0x5990
movq 0x54(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x596b
movq 0x40(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x64(%rsp), %esi
callq 0x59b0
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x60(%rsp), %ecx
movl 0x60(%rsp), %eax
addl 0x5c(%rsp), %eax
movl $0x2, %r8d
cltd
idivl %r8d
movl 0x14(%rsp), %edx
movl %eax, %r8d
callq 0x57f0
movq 0x40(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x64(%rsp), %esi
callq 0x59c0
movq 0x18(%rsp), %rsi
movq 0x40(%rsp), %rdi
movl %eax, 0x24(%rsp)
movl 0x60(%rsp), %eax
addl 0x5c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl 0x24(%rsp), %edx
movl %eax, %ecx
addl $0x1, %ecx
movl 0x5c(%rsp), %r8d
callq 0x57f0
movq 0x40(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movl 0x64(%rsp), %esi
callq 0x59b0
movq 0x28(%rsp), %rdi
movslq %eax, %rsi
callq 0x5990
movq 0x40(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movl 0x64(%rsp), %esi
callq 0x59c0
movq 0x30(%rsp), %rdi
movslq %eax, %rsi
callq 0x5990
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x59e0
movq 0x40(%rsp), %rdi
movq %rax, 0x4c(%rsp)
addq $0x8, %rdi
movslq 0x64(%rsp), %rsi
callq 0x5990
movq 0x4c(%rsp), %rcx
movq %rcx, (%rax)
addq $0x78, %rsp
retq
// File: ruippeixotog[P]algo-lib/segment-tree.cpp
// Function: Node::join(Node&)
Node join(Node& o) {
    Node n;
    n.minVal = min(minVal, o.minVal);
    n.maxVal = max(maxVal, o.maxVal);
    return n;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2950
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x5a40
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x20(%rsp)
addq $0x4, %rdi
movq 0x10(%rsp), %rsi
addq $0x4, %rsi
callq 0x5a80
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: ruippeixotog[P]algo-lib/segment-tree.cpp
// Function: Op::apply(Node&, int, int)
void apply(Node& node, int st, int end) {
    switch(code) {
      case 's': // set values in range to `arg`
        node.minVal = node.maxVal = arg;
        break;
      case 'a': // add `n` to all values in range
        node.minVal += arg; node.maxVal += arg;
        break;
    }
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rsp)
subl $0x61, %eax
je 0x5eae
jmp 0x5e8a
movl -0x1c(%rsp), %eax
subl $0x73, %eax
jne 0x5ecd
jmp 0x5e95
movq -0x28(%rsp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5ecd
movq -0x28(%rsp), %rax
movl 0x4(%rax), %edx
movq -0x10(%rsp), %rcx
addl (%rcx), %edx
movl %edx, (%rcx)
movl 0x4(%rax), %ecx
movq -0x10(%rsp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
retq
nop
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x38(%rsp)
addq $0x20, %rdi
movslq 0x7c(%rsp), %rsi
callq 0x5ed0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x4030
testb $0x1, %al
jne 0x6013
jmp 0x6143
movq 0x38(%rsp), %rdi
movl 0x7c(%rsp), %esi
callq 0x59b0
movq 0x38(%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x78(%rsp), %eax
addl 0x74(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x18(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x20(%rsp)
addq $0x48, %rdi
movslq 0x7c(%rsp), %rsi
callq 0x5f30
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movl 0x20(%rsp), %r9d
movq 0x38(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
callq 0x5ac0
movq 0x38(%rsp), %rdi
movl 0x7c(%rsp), %esi
callq 0x59c0
movq 0x38(%rsp), %rdi
movl %eax, 0x24(%rsp)
movl 0x78(%rsp), %eax
addl 0x74(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x34(%rsp)
addq $0x48, %rdi
movslq 0x7c(%rsp), %rsi
callq 0x5f30
movl 0x24(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x2c(%rsp), %ecx
movl 0x30(%rsp), %r8d
movl 0x34(%rsp), %r9d
movq 0x38(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x5ac0
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
movslq 0x7c(%rsp), %rsi
callq 0x5ed0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x4060
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl %r8d, 0x28(%rsp)
movl %r9d, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x30(%rsp), %eax
jl 0x61ed
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jle 0x61fc
leaq 0x40(%rsp), %rdi
callq 0x2950
jmp 0x62e3
movl 0x30(%rsp), %eax
cmpl 0x28(%rsp), %eax
jl 0x6230
movl 0x2c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0x6230
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x34(%rsp), %rsi
callq 0x5990
movq (%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x62e3
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movl 0x2c(%rsp), %ecx
callq 0x5fc0
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x59b0
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl 0x30(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x30(%rsp), %eax
addl 0x2c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl 0x4(%rsp), %edx
movl %eax, %ecx
movl 0x28(%rsp), %r8d
movl 0x24(%rsp), %r9d
callq 0x61b0
movq 0x8(%rsp), %rdi
movq %rax, 0x1c(%rsp)
movl 0x34(%rsp), %esi
callq 0x59c0
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl 0x30(%rsp), %eax
addl 0x2c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
addl $0x1, %edx
movl 0x2c(%rsp), %ecx
movl 0x28(%rsp), %r8d
movl 0x24(%rsp), %r9d
callq 0x61b0
movq %rax, 0x14(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x59e0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq 0x1d5d(%rip), %rax      # 0x3008
movq %rax, 0x20(%rsp)
leaq 0x4e21(%rip), %rdi      # 0x60d8
leaq 0x20(%rsp), %rsi
callq 0x1480
testb $0x1, %al
jne 0x12c7
jmp 0x132e
callq 0x1520
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq 0x4cfb(%rip), %rdi      # 0x5fd8
callq 0x14b0
movq %rax, %rdi
leaq 0x1d2c(%rip), %rsi      # 0x3018
callq 0x10e0
movq %rax, %rdi
movq 0x4cc5(%rip), %rsi      # 0x5fc0
callq 0x1100
movq 0x1d09(%rip), %rax      # 0x3010
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1550
leaq 0x4dbb(%rip), %rdi      # 0x60d8
callq 0x1620
leaq 0x10(%rsp), %rdi
callq 0x1550
jmp 0x137a
callq 0x1520
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x4c94(%rip), %rdi      # 0x5fd8
callq 0x14b0
movq %rax, %rdi
leaq 0x1cde(%rip), %rsi      # 0x3031
callq 0x10e0
movq %rax, %rdi
movq 0x4c5e(%rip), %rsi      # 0x5fc0
callq 0x1100
movq 0x1c9a(%rip), %rax      # 0x3008
movq %rax, (%rsp)
movq %rsp, %rdi
callq 0x1550
jmp 0x12b0
nop
// File: wichtounet[P]articles/src/threads/part3/timed_mutex.cpp
// Function: main
int main(){
    std::thread t1(work);
    std::thread t2(work);

    t1.join();
    t2.join();

    return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
leaq -0xf3(%rip), %rsi       # 0x12a0
movq %rsi, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1630
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1630
jmp 0x13b3
leaq 0x28(%rsp), %rdi
callq 0x1140
jmp 0x13bf
leaq 0x20(%rsp), %rdi
callq 0x1140
jmp 0x13cb
movl $0x0, 0x34(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x16f0
leaq 0x28(%rsp), %rdi
callq 0x16f0
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x1418
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x16f0
leaq 0x28(%rsp), %rdi
callq 0x16f0
movq 0x18(%rsp), %rdi
callq 0x1150
nopl (%rax)
// File: craigbarstow[P]cmd-line-text-editor/text_editor.cc
// Function: Show_Commands()
void Show_Commands() { //display all available commands
 cout << "h                        Show this list" << endl;
 cout << "g <name>                 Get a file" << endl;
 cout << "n                        Toggle line numbering" << endl;
 cout << "q                        Quit without saving file" << endl;
 cout << "x [name]                 Save file and exit" << endl;
 cout << "s [name]                 Save file" << endl;
 cout << "a [N]                    Add lines after line N" << endl;
 cout << "t [M [N]]                Type lines M through N" << endl;
 cout << "d M [N]                  Delete lines M through N" << endl;
 cout << "m M [N] L                Move lines M through N to follow line L" << endl;
 cout << "c M [N] L                Copy lines M through N to follow line L" << endl;
 cout << "f [M [N]] /word/         Type lines M through N containing word" << endl;
 cout << "r [M [N]] /word1/word2/  Replace word1 by word2 on lines M through N" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8a3d(%rip), %rdi      # 0xbfc8
leaq 0x5b52(%rip), %rsi      # 0x90e4
callq 0x31f0
movq %rax, %rdi
movq 0x8a17(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x8a1b(%rip), %rdi      # 0xbfc8
leaq 0x5b58(%rip), %rsi      # 0x910c
callq 0x31f0
movq %rax, %rdi
movq 0x89f5(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x89f9(%rip), %rdi      # 0xbfc8
leaq 0x5b5a(%rip), %rsi      # 0x9130
callq 0x31f0
movq %rax, %rdi
movq 0x89d3(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x89d7(%rip), %rdi      # 0xbfc8
leaq 0x5b67(%rip), %rsi      # 0x915f
callq 0x31f0
movq %rax, %rdi
movq 0x89b1(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x89b5(%rip), %rdi      # 0xbfc8
leaq 0x5b77(%rip), %rsi      # 0x9191
callq 0x31f0
movq %rax, %rdi
movq 0x898f(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x8993(%rip), %rdi      # 0xbfc8
leaq 0x5b81(%rip), %rsi      # 0x91bd
callq 0x31f0
movq %rax, %rdi
movq 0x896d(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x8971(%rip), %rdi      # 0xbfc8
leaq 0x5b82(%rip), %rsi      # 0x91e0
callq 0x31f0
movq %rax, %rdi
movq 0x894b(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x894f(%rip), %rdi      # 0xbfc8
leaq 0x5b90(%rip), %rsi      # 0x9210
callq 0x31f0
movq %rax, %rdi
movq 0x8929(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x892d(%rip), %rdi      # 0xbfc8
leaq 0x5b9e(%rip), %rsi      # 0x9240
callq 0x31f0
movq %rax, %rdi
movq 0x8907(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x890b(%rip), %rdi      # 0xbfc8
leaq 0x5bae(%rip), %rsi      # 0x9272
callq 0x31f0
movq %rax, %rdi
movq 0x88e5(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x88e9(%rip), %rdi      # 0xbfc8
leaq 0x5bcd(%rip), %rsi      # 0x92b3
callq 0x31f0
movq %rax, %rdi
movq 0x88c3(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x88c7(%rip), %rdi      # 0xbfc8
leaq 0x5bec(%rip), %rsi      # 0x92f4
callq 0x31f0
movq %rax, %rdi
movq 0x88a1(%rip), %rsi      # 0xbfb8
callq 0x3210
movq 0x88a5(%rip), %rdi      # 0xbfc8
leaq 0x5c0a(%rip), %rsi      # 0x9334
callq 0x31f0
movq %rax, %rdi
movq 0x887f(%rip), %rsi      # 0xbfb8
callq 0x3210
popq %rbp
retq
// File: craigbarstow[P]cmd-line-text-editor/text_editor.cc
// Function: get_file(text_ed&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool get_file(text_ed & T, string cl) { //load file to be edited
 string filename;
 string::size_type start,end;
 start = cl.find_first_not_of(' ',1); //find start of filename substring starting after the 'g' command
 if (start == string::npos) { //if string not found return false
   return false;
 }
 end = cl.find(' ',start);
 if ( end == string::npos ) { //if end of filename substring cant be found, set it equal to the end of the string
   end = cl.size();
 }
 filename = cl.substr(start,end-start);
 return T.load_file(filename); //load the file 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x32d0
movq -0xa8(%rbp), %rdi
movl $0x20, %esi
movl $0x1, %edx
callq 0x31e0
movq %rax, -0x40(%rbp)
cmpq $-0x1, -0x40(%rbp)
jne 0x3794
movb $0x0, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x388b
movq -0xa8(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl $0x20, %esi
callq 0x32c0
movq %rax, -0x48(%rbp)
cmpq $-0x1, -0x48(%rbp)
jne 0x37c4
movq -0xa8(%rbp), %rdi
callq 0x3180
movq %rax, -0x48(%rbp)
movq -0xa8(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
subq %rdx, %rcx
leaq -0x70(%rbp), %rdi
callq 0x3200
jmp 0x37e1
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x70(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x3280
movq -0xc0(%rbp), %rdi
callq 0x3160
movq -0xb8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x30e0
jmp 0x3828
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x82e0
movb %al, -0xc1(%rbp)
jmp 0x3843
movb -0xc1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3160
movl $0x1, -0x4c(%rbp)
jmp 0x388b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x38a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3160
jmp 0x38a2
leaq -0x38(%rbp), %rdi
callq 0x3160
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x78(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7e90
cmpl $0x1, -0x8(%rbp)
jle 0x7638
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3390
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x76e0
jmp 0x7538
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x82e0
movb %al, -0xa1(%rbp)
jmp 0x754d
movb -0xa1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa2(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3160
leaq -0x79(%rbp), %rdi
callq 0x3230
movb -0xa2(%rbp), %al
testb $0x1, %al
jne 0x757c
jmp 0x7636
movq 0x4a6d(%rip), %rdi      # 0xbff0
leaq 0x1ec8(%rip), %rsi      # 0x9452
callq 0x31f0
movq %rax, -0xb0(%rbp)
jmp 0x7598
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x31f0
movq %rax, -0xb8(%rbp)
jmp 0x75b5
movq -0xb8(%rbp), %rdi
leaq 0x1dd6(%rip), %rsi      # 0x9399
callq 0x31f0
movq %rax, -0xc0(%rbp)
jmp 0x75d1
movq -0xc0(%rbp), %rdi
movq 0x49d9(%rip), %rsi      # 0xbfb8
callq 0x3210
jmp 0x75e6
jmp 0x7636
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x7617
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3160
leaq -0x79(%rbp), %rdi
callq 0x3230
jmp 0x767b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x767b
jmp 0x7638
jmp 0x763a
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x6c60
movb %al, -0xc1(%rbp)
jmp 0x764f
movb -0xc1(%rbp), %al
andb $0x1, %al
movb %al, -0x8d(%rbp)
testb $0x1, -0x8d(%rbp)
jne 0x763a
leaq -0x58(%rbp), %rdi
callq 0x8180
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x8180
movq -0x88(%rbp), %rdi
callq 0x3380
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x30(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7ae0
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x32d0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x40(%rbp)
jne 0x7abe
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x7b3b
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7af9
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x7bcb
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq (%rax), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7b89
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7c3e
movq -0x30(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x40(%rbp)
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x38(%rbp)
je 0x7c29
movq -0x38(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3160
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x7c07
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
shlq $0x5, %rsi
addq $0x8, %rsi
callq 0x33c0
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x18(%rcx), %eax
subl 0x10(%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x7ca3
movq -0x20(%rbp), %rdi
callq 0x7d00
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
subl 0x10(%rcx), %eax
movl %eax, -0x14(%rbp)
jmp 0x7c83
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x7ce9
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq (%rax), %rdi
movl -0x18(%rbp), %eax
addl -0x10(%rbp), %eax
cltq
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7cad
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x18(%rax), %ecx
shll %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
addl $0x1, %eax
cltq
movq %rax, -0x28(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7da9
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x32d0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x7d87
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x4c(%rbp)
movl 0x18(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7e07
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7db8
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x7e79
movq -0x58(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x68(%rbp)
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x60(%rbp)
je 0x7e64
movq -0x60(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x78(%rbp)
callq 0x3160
movq -0x58(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x7e42
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
shlq $0x5, %rsi
addq $0x8, %rsi
callq 0x33c0
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::text_ed()
text_ed::text_ed() { //constructor function
 capacity = DEFCAP;
 last_line = 0;
 document = new string[capacity+1];
 buffer = NULL;
 buffer_size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x32d0
movq -0x30(%rbp), %rax
movl $0x5, 0x18(%rax)
movl $0x0, 0x10(%rax)
movl 0x18(%rax), %eax
incl %eax
cltq
movq %rax, -0x28(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0x7efc
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
cmpq $0x0, %rax
je 0x7f51
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x32d0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x48(%rbp)
jne 0x7f2f
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x14(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3160
movq -0x10(%rbp), %rdi
callq 0x3380
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x8176
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8084
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x38(%rbp)
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x30(%rbp)
je 0x806f
movq -0x30(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3160
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x804d
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
shlq $0x5, %rsi
addq $0x8, %rsi
callq 0x33c0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movslq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
cmpq $0x0, %rax
je 0x8122
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x32d0
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x8100
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x8174
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8134
jmp 0x8176
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: 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
subq $0x290, %rsp            # imm = 0x290
movq %rsi, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x278(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x32d0
movq -0x278(%rbp), %rdi
movq -0x270(%rbp), %rsi
addq $0x20, %rdi
callq 0x3040
jmp 0x8327
movq -0x270(%rbp), %rdi
movq -0x278(%rbp), %rax
movl $0x0, 0x10(%rax)
callq 0x30d0
movq %rax, %rsi
leaq -0x248(%rbp), %rdi
movl $0x8, %edx
callq 0x33b0
jmp 0x8357
jmp 0x8359
leaq -0x248(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3070
movq %rax, -0x280(%rbp)
jmp 0x8372
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32a0
movb %al, -0x281(%rbp)
jmp 0x8390
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x839c
jmp 0x840a
leaq -0x268(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x30e0
jmp 0x83ae
movq -0x278(%rbp), %rdi
movl 0x10(%rdi), %edx
leaq -0x268(%rbp), %rsi
callq 0x8460
jmp 0x83c6
leaq -0x268(%rbp), %rdi
callq 0x3160
jmp 0x8359
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8446
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x843a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x3160
jmp 0x843a
leaq -0x248(%rbp), %rdi
callq 0x3080
jmp 0x8418
leaq -0x248(%rbp), %rdi
callq 0x3090
leaq -0x30(%rbp), %rdi
callq 0x3160
movb $0x1, %al
andb $0x1, %al
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x248(%rbp), %rdi
callq 0x3090
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rdi
callq 0x3380
nopl (%rax,%rax)
// File: craigbarstow[P]cmd-line-text-editor/document.cc
// Function: text_ed::insert_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool text_ed::insert_line(string newline,int n) { // Insert newline as a new line following line n.
 open_up(n,1);
 document[n+1] = newline;
 if (n > last_line-1) {
   n=last_line+1;
     }
 return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x7c60
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x84c9
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x20, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x30e0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x8560
movb %al, -0x3d(%rbp)
jmp 0x8517
leaq -0x30(%rbp), %rdi
callq 0x3160
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x8529
jmp 0x8546
movb $0x1, -0x1(%rbp)
jmp 0x854a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3160
jmp 0x8555
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3380
nop