LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Expression::print() const
void Expression::print() const {
  switch(type){
    case Constant:
      cout << "[\"int\"," << val << "]";
      break;
    case Var:
      cout << "[\"var\",\"" << name << "\"]";
      break;
    case Lambda:
      cout << "[\"lam\",\"" << name << "\",";
      body->print();
      cout << "]";
      break;
    case Ap:
      cout << "[\"app\",";
      body->print();
      cout << ",";
      arg->print();
      cout << "]";
      break;
    case Nothing:
      cerr << "[Expression] Unexpected expression type: Nothing" << endl;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0xc2c0
movq %rdi, %rbx
leaq 0x3546(%rip), %rcx      # 0xf6a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8e86(%rip), %rbx      # 0x14ff0
leaq 0x394f(%rip), %rsi      # 0xfac0
movl $0x30, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3130
movq 0x8e15(%rip), %r14      # 0x14fc8
leaq 0x38fe(%rip), %rsi      # 0xfab8
movl $0x7, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x28(%rbx), %rdi
callq 0xc140
leaq 0x38e7(%rip), %rsi      # 0xfabe
movl $0x1, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x30(%rbx), %rdi
jmp 0xc264
movq 0x8dd7(%rip), %r14      # 0x14fc8
leaq 0x38a3(%rip), %rsi      # 0xfa9b
movl $0x7, %edx
movq %r14, %rdi
callq 0x31f0
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x32c0
leaq 0x3896(%rip), %rsi      # 0xfaad
movl $0x1, %edx
jmp 0xc2b1
movq 0x8da0(%rip), %r14      # 0x14fc8
leaq 0x3880(%rip), %rsi      # 0xfaaf
movl $0x8, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31f0
leaq 0x386a(%rip), %rsi      # 0xfabd
movl $0x2, %edx
movq %rax, %rdi
callq 0x31f0
movq 0x28(%rbx), %rdi
callq 0xc140
leaq 0x383d(%rip), %rsi      # 0xfaad
movl $0x1, %edx
movq %r14, %rdi
jmp 0xc2b4
movq 0x8d47(%rip), %r14      # 0x14fc8
leaq 0x381b(%rip), %rsi      # 0xfaa3
movl $0x8, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31f0
leaq 0x3800(%rip), %rsi      # 0xfaac
movl $0x2, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Expression::prettyPrint() const
void Expression::prettyPrint() const {
  switch(type){
    case Var:
      cout << name;
      return ;
    case Constant:
      cout << val;
      return ;
    case Lambda:
      cout << "\\" << name << " ";
      body->prettyPrint();
      return ;
    case Ap:
      if(body->isLam() || body->isAp()) cout << "(";
      body->prettyPrint();
      if(body->isLam() || body->isAp()) cout << ")";
      cout << " ";
      if(arg->isLam() || arg->isAp()) cout << "(";
      arg->prettyPrint();
      if(arg->isLam() || arg->isAp()) cout << ")";
      return ;
    case Nothing:
      cerr << "[Expression] Unexpected expression type: Nothing" << endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8cee(%rip), %r14      # 0x14fc8
leaq 0x3810(%rip), %r15      # 0xfaf1
leaq 0x310b(%rip), %r12      # 0xf3f3
movl (%rbx), %eax
cmpl $0x3, %eax
jne 0xc325
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x31f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31f0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31f0
movq 0x28(%rbx), %rbx
jmp 0xc2e8
cmpl $0x4, %eax
ja 0xc488
movl %eax, %eax
leaq 0x337d(%rip), %rcx      # 0xf6b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8ca9(%rip), %rbx      # 0x14ff0
leaq 0x3772(%rip), %rsi      # 0xfac0
movl $0x30, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3130
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x8c2c(%rip), %rdi      # 0x14fc8
jmp 0xc478
movl 0x4(%rbx), %esi
movq 0x8c1d(%rip), %rdi      # 0x14fc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x32c0
movq 0x28(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc3e1
movq 0x8bf8(%rip), %rdi      # 0x14fc8
leaq 0x371c(%rip), %rsi      # 0xfaf3
movl $0x1, %edx
callq 0x31f0
movq 0x28(%rbx), %rdi
callq 0xc2c8
movq 0x28(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc410
movq 0x8bc9(%rip), %rdi      # 0x14fc8
leaq 0x37bf(%rip), %rsi      # 0xfbc5
movl $0x1, %edx
callq 0x31f0
movq 0x8bb1(%rip), %rdi      # 0x14fc8
leaq 0x2fd5(%rip), %rsi      # 0xf3f3
movl $0x1, %edx
callq 0x31f0
movq 0x30(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc44e
movq 0x8b8b(%rip), %rdi      # 0x14fc8
leaq 0x36af(%rip), %rsi      # 0xfaf3
movl $0x1, %edx
callq 0x31f0
movq 0x30(%rbx), %rdi
callq 0xc2c8
movq 0x30(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc488
movq 0x8b5c(%rip), %rdi      # 0x14fc8
leaq 0x3752(%rip), %rsi      # 0xfbc5
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: parseExpression(Scanner&)
Expression * parseExpression(Scanner &scanner){
  Expression * expr(parseExpressionTail(scanner));
  if(expr == nullptr){
    cerr << "[Parse expression] Unexpected token: " << scanner.peekToken().name << endl;
    exit(1);
    return nullptr;
  }
  while(true){
    Expression * expr1(parseExpressionTail(scanner));
    if(expr1 == nullptr){
      return expr;
    }else{
      Expression * expr2(new Expression(Expression::Ap));
      expr2->body = expr;
      expr2->arg  = expr1;
      expr = expr2;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xc587
testq %rax, %rax
je 0xc50e
movq %rax, %r14
movq %rbx, %rdi
callq 0xc587
movq %rax, %r12
testq %rax, %rax
je 0xc4f7
movl $0x38, %edi
callq 0x31c0
movl $0x4, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %r14, 0x28(%rax)
movq %r12, 0x30(%rax)
movq %rax, %r14
jmp 0xc4fa
movq %r14, %r15
testq %r12, %r12
jne 0xc4af
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8adb(%rip), %r14      # 0x14ff0
leaq 0x35d9(%rip), %rsi      # 0xfaf5
movl $0x25, %edx
movq %r14, %rdi
callq 0x31f0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc06a
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
movq %rsp, %rdi
callq 0xdbd0
movl $0x1, %edi
callq 0x3200
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc57f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x32b0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x3110
movl 0xc(%rsp), %ebx
movq 0x7317(%rip), %rsi      # 0x14fb8
leaq 0x10(%rsp), %rdi
callq 0x3240
leaq 0x88(%rsp), %rdi
callq 0x3090
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x72eb(%rip), %rsi      # 0x14fb8
leaq 0x10(%rsp), %rdi
callq 0x3240
leaq 0x88(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x4, %edi
jl 0x2705
movl %edi, %ebp
movslq %edi, %rax
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
cmpl $0x1, %eax
jne 0x2705
movl $0x3, %r12d
leaq 0x4(%rsp), %r15
leal -0x3(%r12), %r13d
movq 0x8(%rbx,%r13,8), %rdi
callq 0x2200
testl %eax, %eax
je 0x26f3
movl %r12d, %ecx
movq (%rbx,%rcx,8), %r14
movq 0x10(%rbx,%r13,8), %r13
movl %eax, 0x4(%rsp)
leaq 0x3aeb(%rip), %rdi      # 0x6178
movq %r15, %rsi
callq 0x2bca
movq %r13, (%rax)
movq %r14, 0x8(%rax)
addq $0x3, %r12
cmpl %ebp, %r12d
jl 0x2663
leaq 0x19df(%rip), %rdi      # 0x408b
callq 0x21a0
testq %rax, %rax
setne 0x3a95(%rip)            # 0x6150
leaq 0x19cf(%rip), %rdi      # 0x4091
callq 0x21a0
testq %rax, %rax
setne 0x3a80(%rip)            # 0x6151
leaq 0x19c5(%rip), %rdi      # 0x409d
callq 0x21a0
movq %rax, 0x3a74(%rip)      # 0x6158
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x25fb
movl $0x1, %edi
callq 0x2190
movq (%rbx), %rdi
callq 0x25fb
xorl %edi, %edi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/thjaeger[P]bindbutton/bindbutton.cc
// Function: grab_buttons()
void grab_buttons() {
	if (always_grab) {
		printf("Grabbing XInput devices...\n");
		for (std::list<XiDevice>::iterator j = devices.begin(); j != devices.end(); j++)
			j->grab();
	}
	for (std::map<unsigned int, Commands>::iterator i = commands.begin(); i != commands.end(); i++) {
		XGrabButton(dpy, i->first, AnyModifier, ROOT, False, ButtonPressMask,
				GrabModeSync, GrabModeAsync, None, None);
		if (always_grab)
			continue;
		for (std::list<XiDevice>::iterator j = devices.begin(); j != devices.end(); j++) {
			if (i->first > j->num_buttons)
				continue;
			XGrabDeviceButton(dpy, j->dev, i->first, AnyModifier, NULL,
					ROOT, False, 2, j->classes, GrabModeAsync, GrabModeAsync);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x3a2d(%rip)      # 0x6151
jne 0x2753
leaq 0x1a5e(%rip), %rdi      # 0x418b
callq 0x21f0
movq 0x3a27(%rip), %rbx      # 0x6160
leaq 0x3a20(%rip), %r14      # 0x6160
cmpq %r14, %rbx
je 0x2753
leaq 0x10(%rbx), %rdi
callq 0x2c2e
movq (%rbx), %rbx
jmp 0x2740
movq 0x3a36(%rip), %rbx      # 0x6190
leaq 0x3a1f(%rip), %r14      # 0x6180
cmpq %r14, %rbx
je 0x2845
leaq 0x39ef(%rip), %r15      # 0x6160
movl $0x1, %r12d
movq 0x39ca(%rip), %rdi      # 0x6148
movl 0x20(%rbx), %esi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rcx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, (%rsp)
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
movl $0x4, %r9d
callq 0x2230
addq $0x20, %rsp
movq (%r15), %r13
cmpq %r15, %r13
sete %al
orb 0x3978(%rip), %al       # 0x6151
jne 0x2831
movl 0x20(%rbx), %edx
cmpl 0x30(%r13), %edx
ja 0x2828
movq 0x395d(%rip), %rdi      # 0x6148
movq 0x10(%r13), %rsi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %r9
leaq 0x18(%r13), %rax
subq $0x8, %rsp
movl $0x8000, %ecx           # imm = 0x8000
xorl %r8d, %r8d
pushq %r12
pushq %r12
pushq %rax
pushq $0x2
pushq $0x0
callq 0x21c0
addq $0x30, %rsp
movq (%r13), %r13
cmpq %r15, %r13
jne 0x27db
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rbx
cmpq %r14, %rax
jne 0x2777
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/thjaeger[P]bindbutton/bindbutton.cc
// Function: Event::get()
bool Event::get() {
	XEvent ev;
	XNextEvent(dpy, &ev);

	if (ev.type == ButtonPress) {
		is_press = true;
		button = ev.xbutton.button;
		dev = NULL;
		core = true;
		t = ev.xbutton.time;
		if (debug)
			printf("Button %d pressed (core)\n", button);
		return true;
	}
	for (std::list<XiDevice>::iterator j = devices.begin(); j != devices.end(); j++) {
		if (ev.type == j->press) {
			XDeviceButtonEvent* bev = (XDeviceButtonEvent *)&ev;
			is_press = true;
			button = bev->button;
			dev = &(*j);
			core = false;
			t = bev->time;
			if (debug)
				printf("Button %d pressed (Xi)\n", button);
			return true;
		}
		if (ev.type == j->release) {
			XDeviceButtonEvent* bev = (XDeviceButtonEvent *)&ev;
			is_press = false;
			button = bev->button;
			dev = &(*j);
			core = false;
			t = bev->time;
			if (debug)
				printf("Button %d released (Xi)\n", bev->button);
			return true;
		}
	}
	printf("Unknown event\n");
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
movq 0x38d0(%rip), %rdi      # 0x6148
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x21d0
movl (%rbx), %ecx
cmpl $0x4, %ecx
jne 0x28c6
movb $0x1, %bl
movb %bl, (%r14)
movl 0x5c(%rsp), %esi
movl %esi, 0x4(%r14)
movq $0x0, 0x8(%r14)
movb %bl, 0x10(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r14)
cmpb %bl, 0x389c(%rip)       # 0x6150
jne 0x2963
leaq 0x17fb(%rip), %rdi      # 0x40bc
jmp 0x295c
leaq 0x3893(%rip), %rdx      # 0x6160
movq %rdx, %rax
movq (%rax), %rax
cmpq %rdx, %rax
je 0x2918
cmpl 0x28(%rax), %ecx
je 0x2928
cmpl 0x2c(%rax), %ecx
jne 0x28d0
addq $0x10, %rax
xorl %ecx, %ecx
movb %cl, (%r14)
movl 0x64(%rsp), %esi
movl %esi, 0x4(%r14)
movq %rax, 0x8(%r14)
movb %cl, 0x10(%r14)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%r14)
movb $0x1, %bl
cmpb $0x1, 0x3843(%rip)      # 0x6150
jne 0x2963
leaq 0x17d8(%rip), %rdi      # 0x40ee
jmp 0x295c
leaq 0x18fc(%rip), %rdi      # 0x421b
callq 0x21f0
xorl %ebx, %ebx
jmp 0x2963
addq $0x10, %rax
movb $0x1, (%r14)
movl 0x64(%rsp), %esi
movl %esi, 0x4(%r14)
movq %rax, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%r14)
movb $0x1, %bl
cmpb $0x1, 0x37fd(%rip)      # 0x6150
jne 0x2963
leaq 0x177a(%rip), %rdi      # 0x40d6
xorl %eax, %eax
callq 0x2030
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x29bd
cmpb $0x1, (%rbx)
jne 0x29bd
cmpq $0x0, 0x8(%rbx)
movq 0x37b9(%rip), %rdi      # 0x6148
je 0x29af
movl 0x4(%rbx), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2180
movq 0x37a4(%rip), %rdi      # 0x6148
movq 0x18(%rbx), %rdx
movl $0x6, %esi
jmp 0x29b8
movq 0x18(%rbx), %rdx
movl $0x2, %esi
callq 0x20a0
cmpq $0x0, 0x8(%rbx)
je 0x2a8c
leaq 0x4(%rbx), %r14
movq 0x37b5(%rip), %rdx      # 0x6188
leaq 0x37a6(%rip), %rax      # 0x6180
movq %rax, %rcx
testq %rdx, %rdx
je 0x2a03
movl (%r14), %esi
leaq 0x3794(%rip), %rcx      # 0x6180
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x29ec
movq %rax, %rdx
cmpq %rax, %rcx
je 0x2a1c
movl (%r14), %edx
cmpl 0x20(%rcx), %edx
leaq 0x3768(%rip), %rdx      # 0x6180
cmovaeq %rcx, %rdx
cmpq %rax, %rdx
je 0x2a31
movzbl (%rbx), %eax
xorl $0x1, %eax
movq 0x28(%rdx,%rax,8), %rdi
callq 0x284f
cmpb $0x0, 0x3719(%rip)      # 0x6151
jne 0x2a8c
movq 0x8(%rbx), %r15
cmpb $0x1, (%rbx)
jne 0x2a67
cmpq $0x0, 0x50(%r15)
jne 0x2a52
movq %r15, %rdi
callq 0x2c2e
movq 0x8(%rbx), %rdi
addq $0x28, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x31f4
addq $0x28, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3304
movq %r15, %rdi
movq %rax, %rsi
callq 0x337c
movq 0x8(%rbx), %rdi
cmpq $0x0, 0x50(%rdi)
je 0x2a92
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x2ce0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movb (%rdi), %al
cmpb (%rsi), %al
jne 0x2ad8
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x2ad8
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x2ad8
movb 0x10(%rdi), %cl
cmpb $0x1, %cl
jne 0x2adb
cmpq $0x0, 0x8(%rdi)
jne 0x2adb
cmpb $0x0, 0x10(%rsi)
jne 0x2adb
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2adb
movq %rax, 0x8(%rdi)
jmp 0x2afb
xorl %eax, %eax
retq
xorl %eax, %eax
testb %cl, %cl
jne 0x2ada
cmpq $0x0, 0x8(%rdi)
je 0x2ada
xorl %eax, %eax
cmpb $0x1, 0x10(%rsi)
jne 0x2ada
cmpq $0x0, 0x8(%rsi)
jne 0x2ada
movb $0x1, 0x10(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1713(%rip), %rdi      # 0x4229
callq 0x21f0
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x21b0
movq %rax, 0x361c(%rip)      # 0x6148
movl %ebp, %edi
movq %rbx, %rsi
callq 0x261a
callq 0x23ec
callq 0x2714
leaq 0x20(%rsp), %rbx
movq %rsp, %r14
testl %r15d, %r15d
je 0x2b5d
movq 0x35f4(%rip), %rdi      # 0x6148
callq 0x2100
testl %eax, %eax
je 0x2b79
movl %r15d, %eax
shlq $0x5, %rax
leaq (%rsp,%rax), %rdi
callq 0x2864
movzbl %al, %eax
addl %eax, %r15d
cmpl $0x2, %r15d
jb 0x2b48
movl %r15d, %eax
cmpl $0x2, %r15d
jne 0x2b97
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a9c
movzbl %al, %ecx
movl $0x2, %eax
subl %ecx, %eax
movl $0x0, %r15d
testl %eax, %eax
jle 0x2b48
movl %eax, %r12d
movq %r14, %r15
movq %r15, %rdi
callq 0x2970
addq $0x20, %r15
decq %r12
jne 0x2ba7
xorl %r15d, %r15d
jmp 0x2b48
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
cmpb $0x1, 0x3517(%rip)      # 0x6150
jne 0x2c4f
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x14bf(%rip), %rdi      # 0x4107
xorl %eax, %eax
callq 0x2030
movq 0x34f2(%rip), %rdi      # 0x6148
movq (%rbx), %rsi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rdx
addq $0x8, %rbx
subq $0x8, %rsp
movl $0x1, %eax
xorl %ecx, %ecx
movl $0x2, %r8d
movq %rbx, %r9
pushq $0x0
pushq %rax
pushq %rax
callq 0x2150
addq $0x20, %rsp
cmpl $0x4, %eax
ja 0x2cd2
movl %eax, %eax
leaq 0x137d(%rip), %rcx      # 0x4020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbx
retq
leaq 0x150a(%rip), %rdi      # 0x41bf
jmp 0x2cd9
leaq 0x14e8(%rip), %rdi      # 0x41a6
jmp 0x2cd9
leaq 0x150b(%rip), %rdi      # 0x41d2
jmp 0x2cd9
leaq 0x151b(%rip), %rdi      # 0x41eb
jmp 0x2cd9
leaq 0x152e(%rip), %rdi      # 0x4207
popq %rbx
jmp 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movl %esi, %ebx
sarq $0x2, %rax
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rcx
movq %rax, %rsi
callq 0x1a70
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rcx, %rdx
je 0x196b
movq 0x10(%rsp), %rdx
cmpq $0x1, %rax
movq %rax, %rsi
adcq $0x0, %rsi
xorl %edi, %edi
movslq (%rcx,%rdi,4), %r8
incl (%rdx,%r8,4)
movslq (%rcx,%rdi,4), %r8
cmpl $0x1, (%rdx,%r8,4)
jg 0x1976
incq %rdi
cmpq %rdi, %rsi
jne 0x1950
movslq %ebx, %rcx
cmpq %rcx, %rax
sete %bl
jmp 0x1978
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x198f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x1b51
leaq 0x10(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x2e32
leaq 0x28(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x2e7c
movb $0x1, (%rbx)
movabsq $0xde0b6b3a7640000, %rax # imm = 0xDE0B6B3A7640000
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq %esi, %rax
movq 0x10(%rdi), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x1eca
movq 0x28(%rdi), %rsi
movl $0x1, %edi
xorl %eax, %eax
movslq -0x4(%rcx,%rdi,4), %r8
movslq (%rcx,%rdi,4), %r9
leaq (%r8,%r8,2), %r8
movq (%rsi,%r8,8), %r8
addq (%r8,%r9,8), %rax
incq %rdi
cmpq %rdi, %rdx
jne 0x1eac
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %rbp
cmpq %rbp, %r12
je 0x2881
leaq 0x18(%r12), %rax
cmpq %rbp, %rax
je 0x2881
movl $0x18, %r13d
leaq 0x8(%rsp), %r14
callq 0x1040
cltq
movq %r13, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
incq %rcx
cqto
idivq %rcx
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %r15
cmpq %r15, %r13
je 0x286c
leaq (%r12,%r13), %rdi
addq %r12, %r15
movq (%r12,%r13), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r12,%r13), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%r12,%r13), %rax
movq %rax, 0x18(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r15, %rsi
callq 0x3b66
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b66
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x286c
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
leaq (%r12,%r13), %rax
addq $0x18, %rax
addq $0x18, %r13
cmpq %rbp, %rax
jne 0x27dd
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
leaq 0x10(%rbx), %r14
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
testl %ebp, %ebp
jle 0x290f
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
xorl %r15d, %r15d
movq (%r14), %rdx
leaq (%rdx,%r15), %rcx
addq $0x18, %rcx
addq %r15, %rdx
movq %r12, %rdi
callq 0x23b2
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b84
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2b84
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x28eb
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2902
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
addq $0x30, %r15
addl $0x2, %r13d
cmpl %ebp, %r13d
jl 0x28a6
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
je 0x2972
xorl %r15d, %r15d
xorl %r12d, %r12d
callq 0x1040
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x279b(%rip), %xmm0     # 0x50d8
movsd 0x278b(%rip), %xmm1     # 0x50d0
ucomisd %xmm0, %xmm1
jb 0x2956
movq (%r14), %rdi
addq %r15, %rdi
callq 0x189e
incq %r12
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x18, %r15
cmpq %r12, %rax
ja 0x2929
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2dc2
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x41ce
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x44e8
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2741
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x7888(%rip), %r14      # 0x9fd0
leaq 0x48e5(%rip), %rsi      # 0x7034
movl $0x21, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x7856(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x7842(%rip), %r14      # 0x9fd0
leaq 0x48c1(%rip), %rsi      # 0x7056
movl $0x21, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x7810(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x77fc(%rip), %r14      # 0x9fd0
leaq 0x489d(%rip), %rsi      # 0x7078
movl $0x21, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x77ca(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2858
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x284f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x284f
movq %rax, %r14
movq %rbx, %rdi
callq 0x416e
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x5ed4
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x2e7e
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x7195(%rip), %rbx      # 0x9fd0
leaq 0x4279(%rip), %r14      # 0x70bb
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %rbx, %rdi
callq 0x21f0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
incq %r12
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r15
cmpq %r12, %rcx
ja 0x2e42
movq 0x714b(%rip), %rdi      # 0x9fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x7130(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x25da
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2eca
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x25da
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x41ce
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5496
movl %eax, %r15d
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f35
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
testl %r15d, %r15d
je 0x300f
movq 0x708b(%rip), %rdi      # 0x9fd0
leaq 0x414e(%rip), %rsi      # 0x709a
movl $0x22, %edx
callq 0x21f0
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x706f(%rip), %rdi      # 0x9fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %edx
movq 0x7054(%rip), %rdi      # 0x9fe0
leaq -0x40(%rbp), %rsi
callq 0x2320
leaq 0x41ff(%rip), %rsi      # 0x719b
leaq -0x40(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x2fbd
leaq 0x410d(%rip), %rsi      # 0x70bd
leaq -0x40(%rbp), %rdi
callq 0x2080
testl %eax, %eax
jne 0x2ffa
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x41ce
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x306e
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x2ffa
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x300f
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movl $0x1, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3050
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x3050
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x3065
movq -0x70(%rbp), %rsi
jmp 0x305d
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3065
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xa0(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
callq 0x41ce
movq %rbx, %rdi
movq %r12, %rsi
callq 0x55f4
movl %eax, %r12d
movq -0xb0(%rbp), %rdi
cmpq %r15, %rdi
je 0x375b
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x21c0
cmpl $-0x1, %r12d
je 0x3844
leaq -0x40(%rbp), %r15
movq %r15, -0x30(%rbp)
movq %r15, -0x50(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x41ce
movq %rbx, %rdi
movq %r12, %rsi
callq 0x55f4
movl %eax, %r13d
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x37aa
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
testl %r13d, %r13d
jle 0x37f9
leaq -0x60(%rbp), %r12
movq %r12, -0x70(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x41ce
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x5b02
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
leaq -0x40(%rbp), %r15
je 0x376d
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x376d
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq 0x41ce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56c4
movq -0x90(%rbp), %rdi
movl $0x1, %ebx
cmpq %r15, %rdi
je 0x3888
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x3888
movq 0x6785(%rip), %rbx      # 0x9fd0
leaq 0x386d(%rip), %rsi      # 0x70bf
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x90(%rbp), %rdi
jmp 0x38b2
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
movq %r15, -0x30(%rbp)
jmp 0x38d1
movq %rax, %rbx
movq -0x70(%rbp), %rdi
movq %r12, -0x30(%rbp)
cmpq %r12, %rdi
jne 0x38d6
jmp 0x38e5
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x38e5
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x2180
movq %rax, %r13
movq %r14, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x2240
cmpq %rax, %r13
je 0x412b
movq %rax, %r12
leaq -0x48(%rbp), %r15
movq %r12, %rcx
subq %r13, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x21e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4268
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4100
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
movl $0x20, %esi
movq %r12, %rdx
callq 0x2180
movq %rax, %r13
movq %r14, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x2240
movq %rax, %r12
cmpq %rax, %r13
jne 0x40c8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x415e
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x415e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x25da
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x41ce
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x62f0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4549
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x78(%rbx)
movq %rbx, %rdi
callq 0x6618
testl %eax, %eax
jle 0x45e9
movq %rbx, %rdi
callq 0x660e
cltq
imulq $0x2aaaaaab, %rax, %rax # imm = 0x2AAAAAAB
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
movl %eax, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x6604
movl %eax, %r14d
movq %rbx, %rdi
callq 0x660e
movl %eax, %r15d
movq %rbx, %rdi
callq 0x660e
movl %eax, %ecx
addl %r14d, %r14d
leal (%r14,%r14,2), %esi
movl %esi, %eax
cltd
idivl %r15d
movl %eax, %edi
movl %esi, %eax
cltd
idivl %ecx
xorl %eax, %eax
testl %edx, %edx
setg %al
addl %edi, %eax
movl %eax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x4664
movq %rbx, %rdi
callq 0x49f4
movq %rbx, %rdi
callq 0x4ed8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0x4650
jmp 0x465c
jmp 0x4608
movq %rax, %r14
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x4620
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
leaq 0x38(%rbx), %r15
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x4639
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x25da
movq (%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %r13
cmpq %rbx, %rdi
je 0x465c
movq (%r13), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
movq %rsi, -0x58(%rbp)
movq 0x8(%rsi), %rax
movslq %edx, %r12
xorl %edx, %edx
divq %r12
cmpq $0x1, %rdx
sbbl $-0x1, %eax
leaq -0x40(%rbp), %rdx
movq %rdx, -0x10(%rdx)
movq %rcx, -0x8(%rdx)
movb $0x0, (%rdx)
testl %eax, %eax
jle 0x53e6
movl %eax, %r15d
xorl %r13d, %r13d
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x21e0
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x2220
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x53d1
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5f6c
addq %r12, %r13
decq %r15
jne 0x5396
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
shlq $0x1b, %rcx
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
addq %rcx, %r15
movq %r15, %rcx
sarq $0x1b, %rcx
subl 0x8(%rax,%rcx), %r14d
jle 0x5439
sarq $0x20, %r15
shlq $0x5, %r15
leaq 0x1dd3(%rip), %rbx      # 0x71f5
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x2330
decl %r14d
jne 0x5422
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5452
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5469
jmp 0x5469
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5485
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rdi
callq 0x25da
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x6, 0x8(%rsi)
jb 0x54ed
leaq -0x68(%rbp), %r15
movl $0x5, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%r15), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x54ed
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x41ce
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55f4
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x552f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
cmpl $-0x1, %r15d
jne 0x55c4
movq 0x38(%rbx), %rdi
cmpq %rdi, 0x40(%rbx)
setne %r12b
je 0x55c0
leaq 0x1c99(%rip), %rsi      # 0x71e9
callq 0x2080
testl %eax, %eax
je 0x5596
movl $0x20, %r15d
xorl %r13d, %r13d
incq %r13
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
seta %r12b
jbe 0x55c0
addq %r15, %rdi
leaq 0x1c62(%rip), %rsi      # 0x71e9
callq 0x2080
addq $0x20, %r15
testl %eax, %eax
jne 0x5562
jmp 0x5599
xorl %r13d, %r13d
movq %r13, %rdi
shlq $0x5, %rdi
addq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x20e0
movq 0x50(%rbx), %rax
movl $0x0, (%rax,%r13,4)
movq %rbx, %rdi
callq 0x4ed8
movzbl %r12b, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x55eb
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x6, 0x8(%rsi)
jb 0x564b
leaq -0x50(%rbp), %r15
movl $0x5, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%r15), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x564b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x38(%rbx), %r12
movq 0x40(%rbx), %r13
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %r12, %r13
je 0x56b4
movq %rbx, -0x30(%rbp)
sarq $0x5, %r13
movq 0x8(%r14), %r15
cmpq $0x1, %r13
adcq $0x0, %r13
addq $0x8, %r12
xorl %ebx, %ebx
movq (%r12), %rdx
cmpq %r15, %rdx
jne 0x5696
testq %rdx, %rdx
je 0x56a9
movq (%r14), %rsi
movq -0x8(%r12), %rdi
callq 0x21d0
testl %eax, %eax
je 0x56a9
incq %rbx
addq $0x20, %r12
cmpq %rbx, %r13
jne 0x5677
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x56b4
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movl (%rax,%rbx,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rax
movq %rdi, %rbx
cmpq $0x6, 0x8(%rsi)
movq %rsi, -0x30(%rbp)
jb 0x5726
leaq -0x70(%rbp), %r15
movl $0x5, %ecx
movq %r15, %rdi
movq %rax, %rsi
movq %rax, %r14
xorl %edx, %edx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%r15), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x5722
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rax
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x41ce
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55f4
movl %eax, %r15d
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x5767
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
testl %r15d, %r15d
jne 0x57f6
movq 0x38(%rbx), %r12
cmpq %r12, 0x40(%rbx)
movq -0x30(%rbp), %rcx
je 0x57e9
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x8(%r12,%r15), %r13
cmpq 0x8(%rcx), %r13
jne 0x57ce
addq %r15, %r12
testq %r13, %r13
je 0x57b0
movq (%rcx), %rsi
movq (%r12), %rdi
movq %r13, %rdx
callq 0x21d0
movq -0x30(%rbp), %rcx
testl %eax, %eax
jne 0x57ce
movl $0x5, %r8d
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
leaq 0x1a24(%rip), %rcx      # 0x71e9
callq 0x22b0
movq -0x30(%rbp), %rcx
incq %r14
movq 0x38(%rbx), %r12
movq 0x40(%rbx), %rax
subq %r12, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %r14, %rax
ja 0x5786
movq %rbx, %rdi
callq 0x4ed8
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x581d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
nop