LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: int stringTo<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T stringTo(const string& str){
  istringstream iss(str);
  T res;
  iss >> res;
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
movl $0x8, %edx
callq 0x33a0
movq -0x1a8(%rbp), %rdi
leaq -0x18c(%rbp), %rsi
callq 0x3130
jmp 0x1c980
movl -0x18c(%rbp), %eax
movl %eax, -0x1ac(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3100
movl -0x1ac(%rbp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3100
movq -0x198(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: thjaeger[P]bindbutton/bindbutton.cc
// Function: parse_args(int, char**)
void parse_args(int argc, char **argv) {
	if ((argc % 3) != 1 || argc <= 3) {
		usage(argv[0]);
		exit(EXIT_SUCCESS);
	}
	for (int i = 0; 3*i+3 < argc; i++) {
		Commands cmds;
		cmds.press = argv[3*i+2];
		cmds.release = argv[3*i+3];
		int button = atoi(argv[3*i+1]);
		if (!button) {
			usage(argv[0]);
			exit(EXIT_FAILURE);
		}
		commands[button] = cmds;
	}
	debug = !!getenv("DEBUG");
	always_grab = !!getenv("ALWAYS_GRAB");
	device_name = getenv("DEVICE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x27d5
cmpl $0x3, -0x4(%rbp)
jg 0x27e8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2770
xorl %edi, %edi
callq 0x21d0
movl $0x0, -0x14(%rbp)
imull $0x3, -0x14(%rbp), %eax
addl $0x3, %eax
cmpl -0x4(%rbp), %eax
jge 0x2894
movq -0x10(%rbp), %rax
imull $0x3, -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
imull $0x3, -0x14(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
imull $0x3, -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2240
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x2861
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2770
movl $0x1, %edi
callq 0x21d0
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq 0x8922(%rip), %rdi      # 0xb190
leaq -0x30(%rbp), %rsi
callq 0x32e0
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27ef
leaq 0x482e(%rip), %rdi      # 0x70c9
callq 0x21e0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x88b5(%rip)       # 0xb168
leaq 0x4815(%rip), %rdi      # 0x70cf
callq 0x21e0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x8897(%rip)       # 0xb169
leaq 0x4802(%rip), %rdi      # 0x70db
callq 0x21e0
movq %rax, 0x888b(%rip)      # 0xb170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: thjaeger[P]bindbutton/bindbutton.cc
// Function: Event::handle()
void Event::handle() {
	if (core && is_press) {
		if (dev) {
			XTestFakeButtonEvent(dpy, button, False, CurrentTime);
			XAllowEvents(dpy, AsyncBoth, t);
		} else {
			XAllowEvents(dpy, ReplayPointer, t);
		}
	}

	if (!dev)
		return;

	std::map<unsigned int, Commands>::iterator i = commands.find(button);
	if (i != commands.end())
		run_cmd(is_press ? i->second.press : i->second.release);
	if (always_grab)
		return;
	if (is_press) {
		if (!dev->status.size())
			dev->grab();
		dev->status.insert(button);
	} else {
		dev->status.erase(button);
		if (!dev->status.size())
			dev->ungrab();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x10(%rax)
je 0x2e6d
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x2e6d
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2e52
movq -0x30(%rbp), %rax
movq 0x8337(%rip), %rdi      # 0xb160
movl 0x4(%rax), %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x21c0
movq -0x30(%rbp), %rax
movq 0x831e(%rip), %rdi      # 0xb160
movq 0x18(%rax), %rdx
movl $0x6, %esi
callq 0x20b0
jmp 0x2e6b
movq -0x30(%rbp), %rax
movq 0x8303(%rip), %rdi      # 0xb160
movq 0x18(%rax), %rdx
movl $0x2, %esi
callq 0x20b0
jmp 0x2e6d
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2e7d
jmp 0x2f82
movq -0x30(%rbp), %rsi
addq $0x4, %rsi
leaq 0x8304(%rip), %rdi      # 0xb190
callq 0x36b0
movq %rax, -0x10(%rbp)
leaq 0x82f4(%rip), %rdi      # 0xb190
callq 0x3600
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x35d0
testb $0x1, %al
jne 0x2eb8
jmp 0x2eee
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x2ed4
leaq -0x10(%rbp), %rdi
callq 0x3630
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2ee5
leaq -0x10(%rbp), %rdi
callq 0x3630
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2b60
testb $0x1, 0x8274(%rip)      # 0xb169
je 0x2efc
jmp 0x2f82
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x2f47
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
callq 0x36e0
cmpq $0x0, %rax
jne 0x2f29
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3470
movq -0x30(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x28, %rdi
addq $0x4, %rsi
callq 0x3700
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
jmp 0x2f82
movq -0x30(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x28, %rdi
addq $0x4, %rsi
callq 0x3750
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
callq 0x36e0
cmpq $0x0, %rax
jne 0x2f80
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3780
jmp 0x2f82
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: thjaeger[P]bindbutton/bindbutton.cc
// Function: Event::combine(Event&)
bool Event::combine(Event &ev) {
	if (is_press != ev.is_press)
		return false;
	if (button != ev.button)
		return false;
	if (t != ev.t)
		return false;
	if (core && !dev && !ev.core && ev.dev) {
		dev = ev.dev;
		return true;
	}
	if (!core && dev && ev.core && !ev.dev) {
		core = ev.core;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x2fc4
movb $0x0, -0x1(%rbp)
jmp 0x307d
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x2fdd
movb $0x0, -0x1(%rbp)
jmp 0x307d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x2ff8
movb $0x0, -0x1(%rbp)
jmp 0x307d
movq -0x20(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x3038
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3038
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x3038
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3038
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x307d
movq -0x20(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x3079
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3079
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x3079
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3079
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x307d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thjaeger[P]bindbutton/bindbutton.cc
// Function: main
int main(int argc, char **argv) {
	printf("bindbutton is deprecated.  Its functionality is now available in\neasystroke (version >= 0.4.0)\n\n");
	dpy = XOpenDisplay(NULL);

	parse_args(argc, argv);
	init_xi();
	grab_buttons();

	Event queue[2];
	int queue_size = 0;

	while (1) {
		while (queue_size < 2 && (!queue_size || XPending(dpy))) {
			if (queue[queue_size].get())
				queue_size++;
			else
				continue;
		}
		if (queue_size == 2 && queue[0].combine(queue[1]))
			queue_size = 1;
		for (int i = 0; i < queue_size; i++)
			queue[i].handle();
		queue_size = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x40c3(%rip), %rdi      # 0x7170
movb $0x0, %al
callq 0x2030
xorl %eax, %eax
movl %eax, %edi
callq 0x21f0
movq %rax, 0x809c(%rip)      # 0xb160
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x27b0
callq 0x23f0
callq 0x28f0
movl $0x0, -0x54(%rbp)
jmp 0x30e3
xorl %eax, %eax
cmpl $0x2, -0x54(%rbp)
movb %al, -0x59(%rbp)
jge 0x3114
movb $0x1, %al
cmpl $0x0, -0x54(%rbp)
movb %al, -0x5a(%rbp)
je 0x310e
movq 0x8060(%rip), %rdi      # 0xb160
callq 0x2140
cmpl $0x0, %eax
setne %al
movb %al, -0x5a(%rbp)
movb -0x5a(%rbp), %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x311d
jmp 0x3146
movslq -0x54(%rbp), %rax
leaq -0x50(%rbp), %rdi
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2ba0
testb $0x1, %al
jne 0x3137
jmp 0x3142
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x3144
jmp 0x30e3
jmp 0x30e3
cmpl $0x2, -0x54(%rbp)
jne 0x316a
leaq -0x50(%rbp), %rdi
leaq -0x50(%rbp), %rsi
addq $0x20, %rsi
callq 0x2f90
testb $0x1, %al
jne 0x3163
jmp 0x316a
movl $0x1, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x54(%rbp), %eax
jge 0x3198
movslq -0x58(%rbp), %rax
leaq -0x50(%rbp), %rdi
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2df0
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x3171
movl $0x0, -0x54(%rbp)
jmp 0x30e1
nopw %cs:(%rax,%rax)
nop
// File: thjaeger[P]bindbutton/bindbutton.cc
// Function: XiDevice::grab()
void grab() {
		if (debug)
			printf("Grabbing device %ld\n", dev->device_id);
		int status = XGrabDevice(dpy, dev, ROOT, False, 2, classes,
				GrabModeAsync, GrabModeAsync, CurrentTime);
		switch (status) {
			case GrabSuccess:
				break;
			case AlreadyGrabbed:
				printf("Grab error: Already grabbed\n");
				break;
			case GrabNotViewable:
				printf("Grab error: Not viewable\n");
				break;
			case GrabFrozen:
				printf("Grab error: Frozen\n");
				break;
			case GrabInvalidTime:
				printf("Grab error: Invalid Time\n");
				break;
			default:
				printf("Grab error: Unknown\n");
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x7cdd(%rip)      # 0xb168
je 0x34a5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x3d33(%rip), %rdi      # 0x71d1
movb $0x0, %al
callq 0x2030
movq -0x18(%rbp), %r9
movq 0x7cb0(%rip), %rdi      # 0xb160
movq (%r9), %rsi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rdx
addq $0x8, %r9
movq %rsp, %rax
movq $0x0, 0x10(%rax)
movl $0x1, 0x8(%rax)
movl $0x1, (%rax)
xorl %ecx, %ecx
movl $0x2, %r8d
callq 0x2190
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x3559
movq -0x20(%rbp), %rax
leaq 0x3af6(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x3567
leaq 0x3cc6(%rip), %rdi      # 0x71e6
movb $0x0, %al
callq 0x2030
jmp 0x3567
leaq 0x3cd3(%rip), %rdi      # 0x7203
movb $0x0, %al
callq 0x2030
jmp 0x3567
leaq 0x3cdd(%rip), %rdi      # 0x721d
movb $0x0, %al
callq 0x2030
jmp 0x3567
leaq 0x3ce1(%rip), %rdi      # 0x7231
movb $0x0, %al
callq 0x2030
jmp 0x3567
leaq 0x3ceb(%rip), %rdi      # 0x724b
movb $0x0, %al
callq 0x2030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/individual.cpp
// Function: Individual::isValid(int)
bool Individual::isValid(int tam){
    std::vector <int> freq(chromosome.size(), 0);
    for(int i = 0; i < chromosome.size(); i++){
        freq[chromosome[i]]++;
        if(freq[chromosome[i]] > 1)return false;    
    }
    return tam == chromosome.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2d80
movq %rax, -0x60(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2df0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x2e10
jmp 0x2a1e
leaq -0x35(%rbp), %rdi
callq 0x1e30
movl $0x0, -0x48(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x2d80
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x2abd
movq -0x68(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x2dd0
movslq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2dd0
movq -0x68(%rbp), %rdi
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movslq -0x48(%rbp), %rsi
callq 0x2dd0
movslq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2dd0
cmpl $0x1, (%rax)
jle 0x2aad
movb $0x0, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x2ae7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x1e30
jmp 0x2afe
jmp 0x2aaf
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x2a2e
movq -0x68(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x2d80
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c50
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1180
nopw (%rax,%rax)
// File: gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::reset()
void Population::reset(){
    if(!resetStatus){
        population.clear();
        weight.clear();
    }
    resetStatus = true;
    currentBest = 1e18;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, (%rax)
jne 0x3da3
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x50f0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x5110
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movabsq $0xde0b6b3a7640000, %rcx # imm = 0xDE0B6B3A7640000
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::F(int)
long long Population::F(int x){
    long long ret = 0;
    for(int i = 0; i < population[x].chromosome.size() - 1; i++){
        int u = population[x].chromosome[i];
        int v = population[x].chromosome[i + 1];
        ret += weight[u][v];
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5510
movq %rax, %rdi
callq 0x2d80
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x41f6
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5510
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2dd0
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5510
movq %rax, %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2dd0
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x24(%rbp)
addq $0x28, %rdi
movslq -0x20(%rbp), %rsi
callq 0x54f0
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0x16d0
movq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4146
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::reproduce()
void Population::reproduce(){
    std::random_shuffle(population.begin(), population.end());

    int sz = population.size();

    // crossing over
    for(int i = 0; i < sz; i += 2){
        std::pair < Individual, Individual > cross = crossingOver(population[i], population[i + 1]);
        population.emplace_back(cross.first);
        population.emplace_back(cross.second);
    }
    // mutation
    for(int i = 0; i < population.size(); i++){
        double random = ((double)rand()) / RAND_MAX;
        if(random <= 0.1){
            population[i].mutate();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x10, %rdi
callq 0x5860
movq -0x70(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x10, %rdi
callq 0x5890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5790
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0x5530
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4ff0
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x80(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x5510
movq -0x80(%rbp), %rdi
movq %rax, -0x88(%rbp)
movl -0x20(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x5510
movq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4790
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x5710
jmp 0x4fac
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0x5710
jmp 0x4fbf
leaq -0x50(%rbp), %rdi
callq 0x5bf0
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
jmp 0x4f49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5bf0
jmp 0x5076
movl $0x0, -0x60(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x60(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x10, %rdi
callq 0x5530
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x506d
callq 0x1030
cvtsi2sd %eax, %xmm0
movsd 0x6071(%rip), %xmm1     # 0xb0a0
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x6058(%rip), %xmm0     # 0xb098
ucomisd -0x68(%rbp), %xmm0
jb 0x5060
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movslq -0x60(%rbp), %rsi
callq 0x5510
movq %rax, %rdi
callq 0x2940
jmp 0x5062
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x4ff7
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1180
nop
// File: RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::Shell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Shell::Shell(string diskName, int numberOfBlocks, int blockSize) : FileSystem(diskName, numberOfBlocks, blockSize)
{
    // Just Some Interesting Styling
    cout << "Interactive DOS Shell Version 0.1" << endl;
    cout << "Copyright 2016 by Ruben Castaneda" << endl;
    cout << "=================================" << endl;
    this->runShell();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3100
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x64b0
jmp 0x3fe0
leaq -0x38(%rbp), %rdi
callq 0x3170
movq 0x9fd8(%rip), %rdi      # 0xdfc8
leaq 0x603d(%rip), %rsi      # 0xa034
callq 0x3280
movq %rax, -0x60(%rbp)
jmp 0x4002
movq -0x60(%rbp), %rdi
movq 0x9fab(%rip), %rsi      # 0xdfb8
callq 0x32c0
jmp 0x4014
movq 0x9fad(%rip), %rdi      # 0xdfc8
leaq 0x6034(%rip), %rsi      # 0xa056
callq 0x3280
movq %rax, -0x68(%rbp)
jmp 0x402d
movq -0x68(%rbp), %rdi
movq 0x9f80(%rip), %rsi      # 0xdfb8
callq 0x32c0
jmp 0x403f
movq 0x9f82(%rip), %rdi      # 0xdfc8
leaq 0x602b(%rip), %rsi      # 0xa078
callq 0x3280
movq %rax, -0x70(%rbp)
jmp 0x4058
movq -0x70(%rbp), %rdi
movq 0x9f55(%rip), %rsi      # 0xdfb8
callq 0x32c0
jmp 0x406a
movq -0x58(%rbp), %rdi
callq 0x40b0
jmp 0x4075
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x40a7
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3820
movq -0x40(%rbp), %rdi
callq 0x3470
// File: RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::dir()
int Shell::dir(){
    vector<string> tmp = this->ls();

    for (int i = 0; i < tmp.size(); i++)
        cout << tmp[i] << " ";
    cout << endl;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x8610
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5a60
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x4895
movslq -0x24(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5a80
movq %rax, %rsi
movq 0x9774(%rip), %rdi      # 0xdfc8
callq 0x3230
movq %rax, -0x48(%rbp)
jmp 0x485f
movq -0x48(%rbp), %rdi
leaq 0x5851(%rip), %rsi      # 0xa0bb
callq 0x3280
jmp 0x4871
jmp 0x4873
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4820
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x38d0
jmp 0x48be
movq 0x972c(%rip), %rdi      # 0xdfc8
movq 0x9715(%rip), %rsi      # 0xdfb8
callq 0x32c0
jmp 0x48aa
leaq -0x20(%rbp), %rdi
callq 0x38d0
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Shell::add(string fileName)
{
    if (this->newFile(fileName)) {
        cout << "Would You Like To Add Data (y/n): ";
        string buffer;
        getline(cin, buffer);
        if (buffer == "y" || buffer == "Y")
            this->append(fileName);
    };
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3100
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x7880
movl %eax, -0x84(%rbp)
jmp 0x4920
leaq -0x30(%rbp), %rdi
callq 0x3170
movl -0x84(%rbp), %eax
cmpl $0x0, %eax
je 0x4a39
movq 0x9689(%rip), %rdi      # 0xdfc8
leaq 0x5754(%rip), %rsi      # 0xa09a
callq 0x3280
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x33e0
movq -0xa8(%rbp), %rsi
movq 0x9677(%rip), %rdi      # 0xdfe0
callq 0x3090
jmp 0x4970
leaq 0x5824(%rip), %rsi      # 0xa19b
leaq -0x60(%rbp), %rdi
callq 0x5aa0
movb %al, -0xa9(%rbp)
jmp 0x4988
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x49b8
jmp 0x4994
leaq 0x5722(%rip), %rsi      # 0xa0bd
leaq -0x60(%rbp), %rdi
callq 0x5aa0
movb %al, -0xaa(%rbp)
jmp 0x49ac
movb -0xaa(%rbp), %al
testb $0x1, %al
jne 0x49b8
jmp 0x4a23
movq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3100
jmp 0x49ca
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4a50
jmp 0x49dc
leaq -0x80(%rbp), %rdi
callq 0x3170
jmp 0x4a23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3170
jmp 0x4a47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4a2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3170
jmp 0x4a2e
leaq -0x60(%rbp), %rdi
callq 0x3170
jmp 0x4a39
leaq -0x60(%rbp), %rdi
callq 0x3170
jmp 0x4a47
movl $0x1, %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3470
// File: RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Shell::del(string fileName)
{
    int curBlock = this->getFirstBlock(fileName);

    // Return If File Does Not Exist
    if (curBlock == -1) {
        cout << "Cannot Find File To Remove" << endl;
        return 0;
    }

    // Remove All Blocks From File
    while ((curBlock = this->getFirstBlock(fileName)) > 0)
        this->delBlock(fileName, curBlock);

    // Remove File From Root
    this->rmFile(fileName);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3100
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x7a10
movl %eax, -0xb4(%rbp)
jmp 0x5060
leaq -0x40(%rbp), %rdi
callq 0x3170
movl -0xb4(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x50c0
movq 0x8f49(%rip), %rdi      # 0xdfc8
leaq 0x5039(%rip), %rsi      # 0xa0bf
callq 0x3280
movq %rax, %rdi
movq 0x8f23(%rip), %rsi      # 0xdfb8
callq 0x32c0
movl $0x0, -0x4(%rbp)
jmp 0x51e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
jmp 0x51f2
jmp 0x50c2
movq -0xd0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3100
movq -0xc8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x7a10
movl %eax, -0xd4(%rbp)
jmp 0x50f4
movl -0xd4(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3170
movl -0xd4(%rbp), %eax
cmpl $0x0, %eax
jle 0x5188
movq -0xd0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3100
movq -0xc8(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x80a0
jmp 0x5143
leaq -0x90(%rbp), %rdi
callq 0x3170
jmp 0x50c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3170
jmp 0x51f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3170
jmp 0x51f2
movq -0xd0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3100
movq -0xc8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x7af0
jmp 0x51b7
leaq -0xb0(%rbp), %rdi
callq 0x3170
movl $0x1, -0x4(%rbp)
jmp 0x51e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3170
jmp 0x51f2
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3470
nopl (%rax,%rax)
// File: RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> splitString(string buffer)
{
    vector<string> split;

    size_t begin, end;
    begin = buffer.find_first_not_of(' ');
    end = buffer.find_first_of(' ', begin);

    while (begin != end) {
        split.push_back(buffer.substr(begin, end - begin));
        begin = buffer.find_first_not_of(' ', end);
        end = buffer.find_first_of(' ', begin);
    }

    return split;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5ad0
movq -0x60(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3240
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movl $0x20, %esi
callq 0x3190
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x5a27
movq -0x60(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x48(%rbp), %rdi
callq 0x32b0
jmp 0x59bc
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5af0
jmp 0x59cb
leaq -0x48(%rbp), %rdi
callq 0x3170
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x20, %esi
callq 0x3240
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movl $0x20, %esi
callq 0x3190
movq %rax, -0x28(%rbp)
jmp 0x5994
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5a44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0x5a44
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5a3a
movq -0x70(%rbp), %rdi
callq 0x38d0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x38d0
movq -0x50(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::FileSystem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
FileSystem::FileSystem(string diskName, int numOfBlocks, int blockSize) : SDisk(diskName, numOfBlocks, blockSize)
{
	if (this->getStatusCode() <= 0)
		return;

	this->rootSize = this->getBlockSize() / 12;
	int byteReq = this->getNumberOfBlocks() * 6;
	this->fatSize = (byteReq / this->getBlockSize()) + (byteReq %
		this->getBlockSize() > 0);

	this->initRoot();
	this->initFat();

	this->fsSynch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3100
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x9660
jmp 0x64f3
leaq -0x38(%rbp), %rdi
callq 0x3170
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x78(%rbp)
callq 0x5ad0
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x70(%rbp)
callq 0x8700
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x68(%rbp)
callq 0x8700
movq -0x58(%rbp), %rdi
callq 0x9c10
movl %eax, -0x5c(%rbp)
jmp 0x653d
movl -0x5c(%rbp), %eax
cmpl $0x0, %eax
jg 0x6599
jmp 0x666a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x6673
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3870
movq -0x70(%rbp), %rdi
callq 0x3870
movq -0x78(%rbp), %rdi
callq 0x38d0
movq -0x58(%rbp), %rdi
callq 0x3930
jmp 0x6673
movq -0x58(%rbp), %rdi
callq 0x9bf0
movl %eax, -0x7c(%rbp)
jmp 0x65a7
movq -0x58(%rbp), %rdi
movl -0x7c(%rbp), %eax
cltq
imulq $0x2aaaaaab, %rax, %rax # imm = 0x2AAAAAAB
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
movl %eax, 0x2c(%rdi)
callq 0x9bd0
movl %eax, -0x80(%rbp)
jmp 0x65d1
movq -0x58(%rbp), %rdi
movl -0x80(%rbp), %ecx
addl %ecx, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x88(%rbp)
callq 0x9bf0
movl %eax, -0x84(%rbp)
jmp 0x65f8
movq -0x58(%rbp), %rdi
movl -0x84(%rbp), %ecx
movl -0x88(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x94(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x90(%rbp)
callq 0x9bf0
movl %eax, -0x8c(%rbp)
jmp 0x6627
movq -0x58(%rbp), %rdi
movl -0x8c(%rbp), %ecx
movl -0x90(%rbp), %eax
cltd
idivl %ecx
movl -0x94(%rbp), %eax
testl %edx, %edx
setg %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, 0x30(%rdi)
callq 0x6680
jmp 0x6654
movq -0x58(%rbp), %rdi
callq 0x6a40
jmp 0x665f
movq -0x58(%rbp), %rdi
callq 0x70c0
jmp 0x666a
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::block(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
vector<string> FileSystem::block(string buffer, int b)
{
	vector<string> blocks;
	int numberofblocks = 0;

	if (buffer.length() % b == 0)
	{
		numberofblocks = buffer.length()/b;
	} else {
		numberofblocks = buffer.length()/b +1;
	}

	string tempblock;
	for (int i = 0; i < numberofblocks; i++)
	{
		tempblock = buffer.substr(b*i, b);
		blocks.push_back(tempblock);
	}

	int lastblock = blocks.size() - 1;

	for (int i = blocks[lastblock].length(); i < b; i++)
	{
		blocks[lastblock] += "#";
	}

	return blocks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x5ad0
movq -0x88(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
callq 0x3410
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x7713
movq -0x88(%rbp), %rdi
callq 0x3410
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, -0x1c(%rbp)
jmp 0x772f
movq -0x88(%rbp), %rdi
callq 0x3410
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33e0
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x77db
movq -0x88(%rbp), %rsi
movslq -0x14(%rbp), %rcx
movl %ecx, %eax
movl -0x44(%rbp), %edx
imull %edx, %eax
movslq %eax, %rdx
leaq -0x68(%rbp), %rdi
callq 0x32b0
jmp 0x776c
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x68(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x3360
movq -0xa8(%rbp), %rdi
callq 0x3170
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x8830
jmp 0x77a8
jmp 0x77aa
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x773f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
movq -0x98(%rbp), %rdi
callq 0x38d0
jmp 0x786e
movq -0x98(%rbp), %rdi
callq 0x5a60
movq -0x98(%rbp), %rdi
subq $0x1, %rax
movl %eax, -0x78(%rbp)
movslq -0x78(%rbp), %rsi
callq 0x5a80
movq %rax, %rdi
callq 0x3410
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x783f
movq -0x98(%rbp), %rdi
movslq -0x78(%rbp), %rsi
callq 0x5a80
movq %rax, %rdi
leaq 0x29ca(%rip), %rsi      # 0xa1f5
callq 0x3260
jmp 0x7832
jmp 0x7834
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x7809
movb $0x1, -0x15(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
testb $0x1, -0x15(%rbp)
jne 0x785e
movq -0x98(%rbp), %rdi
callq 0x38d0
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::newFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::newFile(string fileName)
{
	// Handles FileNames Greater Than 5 Chars
	if (fileName.length() > 5)
		fileName = fileName.substr(0, 5);

	// Returns If File Exists
	if (this->getFirstBlock(fileName) != -1)
		return 0;

	for (int i = 0; i < this->rootFileName.size(); i++)
		if (this->rootFileName[i] == ".....") {
			this->rootFileName[i] = fileName;
			this->rootFirstBlock[i] = 0;
			return this->fsSynch();
		}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, %rax
movq -0x80(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x3410
cmpq $0x5, %rax
jbe 0x78e1
movq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x5, %ecx
callq 0x32b0
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3360
leaq -0x38(%rbp), %rdi
callq 0x3170
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3100
movq -0x70(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x7a10
movl %eax, -0x84(%rbp)
jmp 0x790d
leaq -0x58(%rbp), %rdi
callq 0x3170
movl -0x84(%rbp), %eax
cmpl $-0x1, %eax
je 0x7947
movl $0x0, -0x4(%rbp)
jmp 0x79f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3170
jmp 0x7a00
movl $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
addq $0x38, %rdi
callq 0x5a60
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x79ed
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
movslq -0x68(%rbp), %rsi
callq 0x5a80
movq %rax, %rdi
leaq 0x2859(%rip), %rsi      # 0xa1e9
callq 0x5aa0
testb $0x1, %al
jne 0x799b
jmp 0x79dd
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
movslq -0x68(%rbp), %rsi
callq 0x5a80
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0x3050
movq -0x70(%rbp), %rdi
addq $0x50, %rdi
movslq -0x68(%rbp), %rsi
callq 0x8760
movq -0x70(%rbp), %rdi
movl $0x0, (%rax)
callq 0x70c0
movl %eax, -0x4(%rbp)
jmp 0x79f4
jmp 0x79df
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x794e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::getFirstBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::getFirstBlock(string fileName)
{
	// Handles FileNames Greater Than 5 Chars
	if (fileName.length() > 5)
		fileName = fileName.substr(0, 5);

	for (int i = 0; i < this->rootFileName.size(); i++)
		if (this->rootFileName[i] == fileName)
			return this->rootFirstBlock[i];

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x3410
cmpq $0x5, %rax
jbe 0x7a6e
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x5, %ecx
callq 0x32b0
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3360
leaq -0x38(%rbp), %rdi
callq 0x3170
movl $0x0, -0x3c(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x38, %rdi
callq 0x5a60
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x7ade
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movslq -0x3c(%rbp), %rsi
callq 0x5a80
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x87a0
testb $0x1, %al
jne 0x7ab9
jmp 0x7ad1
movq -0x48(%rbp), %rdi
addq $0x50, %rdi
movslq -0x3c(%rbp), %rsi
callq 0x8760
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ae5
jmp 0x7ad3
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7a75
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::rmFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::rmFile(string fileName)
{
	// Handles FileNames Greater Than 5 Chars
	if (fileName.length() > 5)
		fileName = fileName.substr(0, 5);

	int tmpFB = this->getFirstBlock(fileName);

	// Return 0 File Does Not Exist or File Contains Blocks
	if (tmpFB != 0)
		return 0;

	for (int i = 0; i < this->rootFileName.size(); i++)
		if (this->rootFileName[i] == fileName)
			this->rootFileName[i] = ".....";

	return this->fsSynch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x3410
cmpq $0x5, %rax
jbe 0x7b57
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x5, %ecx
callq 0x32b0
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3360
leaq -0x38(%rbp), %rdi
callq 0x3170
movq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3100
movq -0x78(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x7a10
movl %eax, -0x8c(%rbp)
jmp 0x7b83
leaq -0x60(%rbp), %rdi
callq 0x3170
movl -0x8c(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x7bc1
movl $0x0, -0x4(%rbp)
jmp 0x7c4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3170
jmp 0x7c57
movl $0x0, -0x70(%rbp)
movq -0x78(%rbp), %rdi
movslq -0x70(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x38, %rdi
callq 0x5a60
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x7c3f
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
movslq -0x70(%rbp), %rsi
callq 0x5a80
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x87a0
testb $0x1, %al
jne 0x7c12
jmp 0x7c32
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
movslq -0x70(%rbp), %rsi
callq 0x5a80
movq %rax, %rdi
leaq 0x25bc(%rip), %rsi      # 0xa1e9
callq 0x33d0
jmp 0x7c34
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x7bc8
movq -0x78(%rbp), %rdi
callq 0x70c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3470
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::readBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int FileSystem::readBlock(string fileName, int blockNum, string& buffer)
{
    int curBlock = this->getFirstBlock(fileName);

    // File Does Not Exist
    if (curBlock == -1)
        return 0;

    // Loop Through All Blocks Owned By File
    for ( ; curBlock != 0; curBlock = this->fat[curBlock])
        if (curBlock == blockNum)
            return this->getBlock(blockNum, buffer);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3100
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x7a10
movl %eax, -0x60(%rbp)
jmp 0x834e
leaq -0x50(%rbp), %rdi
callq 0x3170
movl -0x60(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x8383
movl $0x0, -0x4(%rbp)
jmp 0x83c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0x83d2
jmp 0x8385
cmpl $0x0, -0x2c(%rbp)
je 0x83c2
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x83a8
movq -0x70(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x9840
movl %eax, -0x4(%rbp)
jmp 0x83c9
jmp 0x83aa
movq -0x70(%rbp), %rdi
addq $0x68, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8760
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x8385
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3470
nopl (%rax,%rax)
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::writeBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::writeBlock(string fileName, int blockNum, string buffer)
{
    int curBlock = this->getFirstBlock(fileName);

    // File Does Not Exist
    if (curBlock == -1)
        return 0;

    // Loop Through File Blocks Looking For blockNum
    for ( ; curBlock != 0; curBlock = this->fat[curBlock])
        if (curBlock == blockNum)
            return this->putBlock(blockNum, buffer);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3100
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x7a10
movl %eax, -0x84(%rbp)
jmp 0x8437
leaq -0x50(%rbp), %rdi
callq 0x3170
movl -0x84(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x8475
movl $0x0, -0x4(%rbp)
jmp 0x851c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0x8528
jmp 0x8477
cmpl $0x0, -0x2c(%rbp)
je 0x8515
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x84f5
movq -0xa0(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3100
movq -0x98(%rbp), %rdi
movl -0xb4(%rbp), %esi
movq -0xb0(%rbp), %rdx
callq 0x99d0
movl %eax, -0xa4(%rbp)
jmp 0x84ca
movl -0xa4(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3170
jmp 0x851c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3170
jmp 0x8528
jmp 0x84f7
movq -0x98(%rbp), %rdi
addq $0x68, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x8760
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x8477
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::nextBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int FileSystem::nextBlock(string fileName, int blockNum)
{
	int curBlock = this->getFirstBlock(fileName);

    // File Does Not Exist
    if (curBlock == -1)
        return 0;

    // Search File For Given Block Number
    for ( ; curBlock != 0; curBlock = this->fat[curBlock])
        if (curBlock == blockNum)
            // Returns The Block Number Of The Succeeding Block
            return this->fat[curBlock];

    // Handles blockNum = 0, etc.
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3100
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x7a10
movl %eax, -0x50(%rbp)
jmp 0x857a
leaq -0x40(%rbp), %rdi
callq 0x3170
movl -0x50(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x85af
movl $0x0, -0x4(%rbp)
jmp 0x85f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
jmp 0x8601
jmp 0x85b1
cmpl $0x0, -0x20(%rbp)
je 0x85f1
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x85d7
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
movslq -0x20(%rbp), %rsi
callq 0x8760
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x85f8
jmp 0x85d9
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
movslq -0x20(%rbp), %rsi
callq 0x8760
movl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x85b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::ls[abi:cxx11]()
vector<string> FileSystem::ls()
{
    vector<string> files;

    // Loop Through All FileNames And Get All Allocated Files
    for (int i = 0; i < this->rootFileName.size(); i++)
        if (this->rootFileName[i] != ".....")
            files.push_back(this->rootFileName[i]);

    return files;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5ad0
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x38, %rdi
callq 0x5a60
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x86da
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5a80
movq %rax, %rdi
leaq 0x1b6a(%rip), %rsi      # 0xa1e9
callq 0x8910
movb %al, -0x49(%rbp)
jmp 0x8689
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x8692
jmp 0x86ca
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5a80
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x8830
jmp 0x86b1
jmp 0x86ca
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x38d0
jmp 0x86f7
jmp 0x86cc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8643
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x86ed
movq -0x40(%rbp), %rdi
callq 0x38d0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3470