LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: conchoecia[P]fasta_stats/src/pretty_print.cc
// Function: pretty_print[abi:cxx11](unsigned long, bool)
std::string pretty_print(unsigned long x, bool negative) {
	std::string s = itoa(x, negative);
	int commas = (s.length() - 1 - (negative ? 1 : 0)) / 3;
	size_t a = s.length() - 1;
	size_t b = a + commas;
	s.resize(b + 1);
	int i;
	for (i = 0; a < b; --a, --b, ++i) {
		s[b] = s[a];
		if (i == 2) {
			i = -1;
			s[--b] = ',';
		}
	}
	return s;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movb $0x0, 0x56(%rsp)
movq 0x58(%rsp), %rsi
movzbl 0x57(%rsp), %edx
andl $0x1, %edx
callq 0xa070
movq 0x28(%rsp), %rdi
callq 0x23b0
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movzbl 0x57(%rsp), %eax
andl $0x1, %eax
notq %rax
addq %rcx, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
movl %edx, %eax
movl %eax, 0x50(%rsp)
callq 0x23b0
movq 0x28(%rsp), %rdi
decq %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movslq 0x50(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2360
jmp 0xe0a3
movl $0x0, 0x30(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0xe17a
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2470
movq %rax, 0x18(%rsp)
jmp 0xe0d1
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
movq 0x40(%rsp), %rsi
callq 0x2470
movq %rax, 0x10(%rsp)
jmp 0xe0f2
movq 0x10(%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, (%rax)
cmpl $0x2, 0x30(%rsp)
jne 0xe14c
movq 0x28(%rsp), %rdi
movl $0xffffffff, 0x30(%rsp) # imm = 0xFFFFFFFF
movq 0x40(%rsp), %rsi
decq %rsi
movq %rsi, 0x40(%rsp)
callq 0x2470
movq %rax, (%rsp)
jmp 0xe129
movq (%rsp), %rax
movb $0x2c, (%rax)
jmp 0xe14c
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x21a0
jmp 0xe19a
jmp 0xe14e
movq 0x48(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x40(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xe0ab
movb $0x1, 0x56(%rsp)
testb $0x1, 0x56(%rsp)
jne 0xe190
movq 0x28(%rsp), %rdi
callq 0x21a0
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2420
// File: bsegovia[P]boodew/boodew.cpp
// Function: boodew::format[abi:cxx11](char const*, ...)
string format(const char *fmt, ...) {
  int size = 256;
  string str;
  va_list ap;
  for (;;) {
    str.resize(size);
    va_start(ap, fmt);
    const auto n = vsnprintf((char*)str.c_str(), size, fmt, ap);
    if (n < 0) throw boodew_exception("format string issue");
    va_end(ap);
    if (n < size) {
      str.resize(n);
      return str;
    }
    size = n+1;
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x130(%rbp)
movq %rdi, %r10
movq %r10, -0x128(%rbp)
testb %al, %al
je 0x49d5
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%rbp)
movq %r8, -0x100(%rbp)
movq %rcx, -0x108(%rbp)
movq %rdx, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x100, -0x14(%rbp)     # imm = 0x100
movb $0x0, -0x15(%rbp)
callq 0x3380
movq -0x130(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3370
jmp 0x4a1b
movq -0x130(%rbp), %rdi
leaq -0x30(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
callq 0x30e0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x3488
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jge 0x4b32
movb $0x1, -0x62(%rbp)
movl $0x28, %edi
callq 0x3120
movq %rax, -0x140(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x3410
movq -0x138(%rbp), %rdx
leaq 0x117e9(%rip), %rsi     # 0x16288
leaq -0x60(%rbp), %rdi
callq 0xc090
jmp 0x4aaa
movq -0x140(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xc140
jmp 0x4abc
movq -0x140(%rbp), %rdi
movb $0x0, -0x62(%rbp)
leaq 0x1e0da(%rip), %rsi     # 0x22ba8
leaq 0x76db(%rip), %rdx      # 0xc1b0
callq 0x33f0
jmp 0x4b9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4b86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4b13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3180
leaq -0x61(%rbp), %rdi
callq 0x32c0
testb $0x1, -0x62(%rbp)
jne 0x4b24
jmp 0x4b30
movq -0x140(%rbp), %rdi
callq 0x31e0
jmp 0x4b86
leaq -0x30(%rbp), %rax
movl -0x40(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4b5c
movq -0x130(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x3370
jmp 0x4b50
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x4b76
jmp 0x4b6a
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a09
movq -0x130(%rbp), %rdi
callq 0x3180
movq -0x128(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x130(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x3400
nopl (%rax,%rax)
// File: bsegovia[P]boodew/boodew.cpp
// Function: boodew::while_builtin(std::vector<boodew::value, std::allocator<boodew::value>> const&)
static value while_builtin(args arg) {
  value last;
  while (vtob(ex(vtos(get(arg,1))))) try {return last=ex(vtos(get(arg,2))); }
    catch (bool b) { if (b) break; else continue; }
  return last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd000
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4d70
movq %rax, -0x110(%rbp)
jmp 0x5b34
movq -0x110(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x4ba0
jmp 0x5b49
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x65e0
jmp 0x5b5f
leaq -0x70(%rbp), %rdi
callq 0x4d00
movb %al, -0x111(%rbp)
jmp 0x5b70
leaq -0x70(%rbp), %rdi
callq 0xc5d0
leaq -0x90(%rbp), %rdi
callq 0x3180
movb -0x111(%rbp), %al
testb $0x1, %al
jne 0x5b94
jmp 0x5d24
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x4d70
movq %rax, -0x120(%rbp)
jmp 0x5bab
movq -0x120(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
callq 0x4ba0
jmp 0x5bc0
xorl %eax, %eax
movl %eax, %edx
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x65e0
jmp 0x5bd9
leaq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xd020
movq -0x108(%rbp), %rdi
movq %rax, %rsi
callq 0xd060
jmp 0x5bfa
leaq -0xd0(%rbp), %rdi
callq 0xc5d0
leaq -0xf0(%rbp), %rdi
callq 0x3180
movl $0x1, -0xf4(%rbp)
jmp 0x5d3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x5d57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x5c67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc5d0
leaq -0x90(%rbp), %rdi
callq 0x3180
jmp 0x5d57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x5cca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x5cbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xc5d0
leaq -0xf0(%rbp), %rdi
callq 0x3180
movl -0x9c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5d57
movq -0x98(%rbp), %rdi
callq 0x30d0
movb (%rax), %al
andb $0x1, %al
movb %al, -0xf5(%rbp)
testb $0x1, -0xf5(%rbp)
je 0x5d04
movl $0x3, -0xf4(%rbp)
jmp 0x5d0e
movl $0x2, -0xf4(%rbp)
callq 0x33e0
movl -0xf4(%rbp), %eax
subl $0x2, %eax
je 0x5b1d
jmp 0x5d24
movq -0x108(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd0a0
movl $0x1, -0xf4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc5d0
movq -0x100(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0xc5d0
movq -0x98(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: bsegovia[P]boodew/tests.cpp
// Function: run(char const*, bool)
static void run(const char *str, bool fails=false) {
  const auto r = boodew::exec(str);
  if (!r.second != fails)
    cout << "FAILED with " << r.first;
  if (!fails)
    cout << endl;
  else
    cout << r.first << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3410
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0xc090
jmp 0x14f9f
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6430
jmp 0x14fae
leaq -0x58(%rbp), %rdi
callq 0x3180
leaq -0x59(%rbp), %rdi
callq 0x32c0
movb -0x18(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x1504c
movq 0xdff2(%rip), %rdi      # 0x22fd0
leaq 0x1ad6(%rip), %rsi      # 0x16abb
callq 0x3260
movq %rax, -0x88(%rbp)
jmp 0x14ff3
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3240
jmp 0x15005
jmp 0x1504c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1502a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3180
leaq -0x59(%rbp), %rdi
callq 0x32c0
jmp 0x150ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15860
jmp 0x150ab
testb $0x1, -0x9(%rbp)
jne 0x15069
movq 0xdf77(%rip), %rdi      # 0x22fd0
movq 0xdf40(%rip), %rsi      # 0x22fa0
callq 0x32a0
jmp 0x15067
jmp 0x15099
movq 0xdf60(%rip), %rdi      # 0x22fd0
leaq -0x38(%rbp), %rsi
callq 0x3240
movq %rax, -0x90(%rbp)
jmp 0x15082
movq -0x90(%rbp), %rdi
movq 0xdf10(%rip), %rsi      # 0x22fa0
callq 0x32a0
jmp 0x15097
jmp 0x15099
leaq -0x38(%rbp), %rdi
callq 0x15860
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: zengfenfei[P]codility/src/OddOccurrencesInArray.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	// write your code in C++11 (g++ 4.8.2)
	int odd = A[0];
	for (int i = 1; i < A.size(); i++) {
		odd ^= A[i];
	}
	return odd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1390
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x12a2
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x1390
movl (%rax), %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1265
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zengfenfei[P]codility/src/OddOccurrencesInArray.cpp
// Function: main
int main() {
	int a[] = { 9, 3, 9, 3, 9, 7, 9 };
	vector<int> vec(a, a + sizeof(a) / sizeof(int));
	cout << solution(vec) << "\n";	//7
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movups 0xd56(%rip), %xmm0      # 0x201c
movups %xmm0, -0x14(%rbp)
movaps 0xd3f(%rip), %xmm0      # 0x2010
movaps %xmm0, -0x20(%rbp)
leaq -0x4(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x13d0
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13f0
jmp 0x1301
leaq -0x39(%rbp), %rdi
callq 0x1470
leaq -0x38(%rbp), %rdi
callq 0x1240
movl %eax, %esi
movq 0x2cbc(%rip), %rdi      # 0x3fd8
callq 0x10e0
movq %rax, -0x68(%rbp)
jmp 0x1327
movq -0x68(%rbp), %rdi
leaq 0xcfa(%rip), %rsi       # 0x202c
callq 0x1090
jmp 0x1339
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1490
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x1470
jmp 0x137e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1490
movq -0x48(%rbp), %rdi
callq 0x10f0
nopw (%rax,%rax)
// File: tismith[P]tmp-play/conditional.cpp
// Function: main
int main() {
    std::cout << "true = " << IF<true, A, B>::TEST::RESULT << std::endl;
    std::cout << "false = " << IF<false, A, B>::TEST::RESULT << std::endl;

    std::cout << "true = ";
    IF<true, A1, B1>::TEST::EXEC();
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2e0d(%rip), %rdi      # 0x3fd8
leaq 0xe32(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl $0x1, %esi
callq 0x1070
movq %rax, %rdi
movq 0x2dda(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2dde(%rip), %rdi      # 0x3fd8
leaq 0xe0b(%rip), %rsi       # 0x200c
callq 0x1040
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
movq 0x2dae(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2db2(%rip), %rdi      # 0x3fd8
leaq 0xdd7(%rip), %rsi       # 0x2004
callq 0x1040
callq 0x1250
movq 0x2d9a(%rip), %rdi      # 0x3fd8
movq 0x2d83(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
popq %rbp
retq
nop
// File: tplinderoth[P]introDist/Dxyz.cpp
// Function: main
int main (int argc, char** argv) {
	int rv = 0;

	std::ifstream poptable;
	/*
	 * The poptable is a 2-column text file
	 * column 1: sample name in VCF
	 * column 2: INT indicating population, 0 = source, 1 = sink, 2 = outgroup
	*/
	std::ifstream vcf; // input VCF file
	std::ofstream outf; // output file
	double minmaf = 0; // minimum minor allele frequency
	int winsize = 15; // Number of SNPs in a window
	int step = 5; // step size in terms of number of SNPs
	int infmt; // input vcf forma:, 0 = uncompressed, 1 = gzipped/bgzipped, 2 = stdin

	if (!(rv=parseArgs(argc, argv, poptable, vcf, outf, winsize, step, minmaf, infmt))) {
		rv = vcf2Dxyz(poptable, vcf, outf, winsize, step, minmaf, infmt);
	}

	if (poptable.is_open()) poptable.close();
	if (vcf.is_open()) vcf.close();
	if (outf.is_open()) outf.close();

	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp            # imm = 0x670
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x84e0
leaq -0x428(%rbp), %rdi
callq 0x84e0
jmp 0x8a7a
leaq -0x638(%rbp), %rdi
callq 0x8800
jmp 0x8a88
movq $0x0, -0x640(%rbp)
movl $0xf, -0x644(%rbp)
movl $0x5, -0x648(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq %rsp, %rax
leaq -0x64c(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x640(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0x648(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x220(%rbp), %rdx
leaq -0x428(%rbp), %rcx
leaq -0x638(%rbp), %r8
leaq -0x644(%rbp), %r9
callq 0x8c90
movl %eax, -0x650(%rbp)
jmp 0x8afa
movl -0x650(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x8ba6
movl -0x644(%rbp), %ecx
movl -0x648(%rbp), %r8d
movsd -0x640(%rbp), %xmm0
movl -0x64c(%rbp), %r9d
leaq -0x220(%rbp), %rdi
leaq -0x428(%rbp), %rsi
leaq -0x638(%rbp), %rdx
callq 0x9130
movl %eax, -0x654(%rbp)
jmp 0x8b4a
movl -0x654(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x8ba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x430(%rbp)
movl %eax, -0x434(%rbp)
jmp 0x8c78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x430(%rbp)
movl %eax, -0x434(%rbp)
jmp 0x8c6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x430(%rbp)
movl %eax, -0x434(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x86c0
jmp 0x8c6c
leaq -0x220(%rbp), %rdi
callq 0x8770
movb %al, -0x655(%rbp)
jmp 0x8bba
movb -0x655(%rbp), %al
testb $0x1, %al
jne 0x8bc6
jmp 0x8bd6
leaq -0x220(%rbp), %rdi
callq 0x80c0
jmp 0x8bd4
jmp 0x8bd6
leaq -0x428(%rbp), %rdi
callq 0x8770
movb %al, -0x656(%rbp)
jmp 0x8bea
movb -0x656(%rbp), %al
testb $0x1, %al
jne 0x8bf6
jmp 0x8c06
leaq -0x428(%rbp), %rdi
callq 0x80c0
jmp 0x8c04
jmp 0x8c06
leaq -0x638(%rbp), %rdi
callq 0x8350
movb %al, -0x657(%rbp)
jmp 0x8c1a
movb -0x657(%rbp), %al
testb $0x1, %al
jne 0x8c26
jmp 0x8c36
leaq -0x638(%rbp), %rdi
callq 0x8650
jmp 0x8c34
jmp 0x8c36
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x86c0
leaq -0x428(%rbp), %rdi
callq 0x80f0
leaq -0x220(%rbp), %rdi
callq 0x80f0
movl -0x4(%rbp), %eax
addq $0x670, %rsp            # imm = 0x670
popq %rbp
retq
leaq -0x428(%rbp), %rdi
callq 0x80f0
leaq -0x220(%rbp), %rdi
callq 0x80f0
movq -0x430(%rbp), %rdi
callq 0x8830
// File: tplinderoth[P]introDist/Dxyz.cpp
// Function: setPopTable(std::basic_ifstream<char, std::char_traits<char>>&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>&)
int setPopTable(std::ifstream &popfile, std::map<std::string, int> &popmap) {
	std::string sample;
	int pop;
	while (popfile >> sample) {
		popfile >> pop;
		switch (pop) {
			case 0:
				break;
			case 1:
				break;
			case 2:
				break;
			default:
				std::cerr << "Invalid population label " << pop << "\n";
				return -1;
		}
		popmap.insert(std::pair<std::string, int>(sample, pop));
	}
	if (popmap.size() == 0) {
		std::cerr << "Population map is empty\n";
	}
	return popmap.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8620
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8590
movq %rax, -0x90(%rbp)
jmp 0xa542
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x8570
movb %al, -0x91(%rbp)
jmp 0xa560
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0xa56f
jmp 0xa693
movq -0x10(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x8290
jmp 0xa57e
movl -0x3c(%rbp), %eax
movl %eax, -0x98(%rbp)
testl %eax, %eax
je 0xa5b8
jmp 0xa58d
movl -0x98(%rbp), %eax
subl $0x1, %eax
je 0xa5ba
jmp 0xa59a
movl -0x98(%rbp), %eax
subl $0x2, %eax
je 0xa5bc
jmp 0xa5be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa6e1
jmp 0xa61a
jmp 0xa61a
jmp 0xa61a
movq 0x22a23(%rip), %rdi     # 0x2cfe8
leaq 0x13ec4(%rip), %rsi     # 0x1e490
callq 0x8400
movq %rax, -0xa0(%rbp)
jmp 0xa5da
movq -0xa0(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x8820
movq %rax, -0xa8(%rbp)
jmp 0xa5f2
movq -0xa8(%rbp), %rdi
leaq 0x13a83(%rip), %rsi     # 0x1e083
callq 0x8400
jmp 0xa607
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x50(%rbp)
jmp 0xa6cc
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0xbd20
jmp 0xa638
movq -0xb0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xbce0
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0xa657
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xbd60
jmp 0xa52c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xbd60
jmp 0xa6e1
movq -0x18(%rbp), %rdi
callq 0xbd80
cmpq $0x0, %rax
jne 0xa6b9
movq 0x2293f(%rip), %rdi     # 0x2cfe8
leaq 0x13dfa(%rip), %rsi     # 0x1e4aa
callq 0x8400
jmp 0xa6b7
jmp 0xa6b9
movq -0x18(%rbp), %rdi
callq 0xbd80
movl %eax, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x82a0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x82a0
movq -0x48(%rbp), %rdi
callq 0x8830
nopw %cs:(%rax,%rax)
// File: tplinderoth[P]introDist/Dxyz.cpp
// Function: printWindow(std::ostream&, double const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&, unsigned int const&, double const&, double const&, double*)
void printWindow (std::ostream &outstream, const double &dxyz, const std::string &seqid, const unsigned int &startpos, const unsigned int &endpos,
		const double &nseq, const double &nsites, double* dxy_comp) {
	outstream << seqid << "\t" << startpos << "\t" << endpos << "\t" << dxy_comp[0] << "\t" << dxy_comp[1] << "\t";
	if (dxyz != -9) {
		outstream << dxyz << "\t";
	} else {
		outstream << "NA\t";
	}
	outstream << nseq << "\t" << nsites << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x83c0
movq %rax, %rdi
leaq 0x1358f(%rip), %rsi     # 0x1e48e
callq 0x8400
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x85f0
movq %rax, %rdi
leaq 0x13572(%rip), %rsi     # 0x1e48e
callq 0x8400
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x85f0
movq %rax, %rdi
leaq 0x13555(%rip), %rsi     # 0x1e48e
callq 0x8400
movq %rax, %rdi
movq 0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0x13536(%rip), %rsi     # 0x1e48e
callq 0x8400
movq %rax, %rdi
movq 0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0x13516(%rip), %rsi     # 0x1e48e
callq 0x8400
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x13083(%rip), %xmm1    # 0x1e010
ucomisd %xmm1, %xmm0
jne 0xaf97
jp 0xaf97
jmp 0xafb9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0x134dc(%rip), %rsi     # 0x1e48e
callq 0x8400
jmp 0xafc9
movq -0x8(%rbp), %rdi
leaq 0x134c8(%rip), %rsi     # 0x1e48c
callq 0x8400
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0x134aa(%rip), %rsi     # 0x1e48e
callq 0x8400
movq %rax, %rdi
movq 0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0x13080(%rip), %rsi     # 0x1e083
callq 0x8400
addq $0x30, %rsp
popq %rbp
retq
nop
// File: tplinderoth[P]introDist/Dxyz.cpp
// Function: slideWindow(Matrix<double>&, unsigned int, unsigned int, unsigned int)
unsigned int slideWindow (Matrix<double> &win, const unsigned int winsize, const unsigned int step, unsigned int nsites) {
	/*
	 * Advances window along chromosome
	 * returns the number of sites shifted to the beginning of the window
	 */

	unsigned int nshift = 0;
	if (nsites == winsize) {
		// advance existing window
		nshift = winsize - step;
		for (unsigned int i=0; i<nshift; ++i) {
			int k=step+i;
			for (unsigned int j=0; j<win.ncol(); ++j) {
				win(i,j) = win(k,j);
			}
		}
	}

	return nshift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0xb0c2
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0xb0c0
movl -0x10(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbfd0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jae 0xb0b3
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0xba10
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0xba10
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb060
jmp 0xb0b5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb048
jmp 0xb0c2
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tplinderoth[P]introDist/Dxyz.cpp
// Function: altCount(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, unsigned int&)
unsigned int altCount (const std::vector<int> &alleles, const std::vector<int> &idx, unsigned int &nseq) {
	static std::vector<int>::const_iterator idxiter;
	nseq = 0;
	unsigned int altcount = 0;
	for (idxiter = idx.begin(); idxiter != idx.end(); ++idxiter) {
		if (alleles[*idxiter] == -9) continue;
		if (alleles[*idxiter] == 1) ++altcount;
		++nseq;
	}

	return altcount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbe10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x22203(%rip)     # 0x2d500
movq -0x10(%rbp), %rdi
callq 0xbe80
movq %rax, -0x30(%rbp)
leaq 0x221ef(%rip), %rdi     # 0x2d500
leaq -0x30(%rbp), %rsi
callq 0xbe40
testb $0x1, %al
jne 0xb320
jmp 0xb391
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x221d1(%rip), %rdi     # 0x2d500
callq 0xbed0
movq -0x38(%rbp), %rdi
movslq (%rax), %rsi
callq 0xbeb0
cmpl $-0x9, (%rax)
jne 0xb347
jmp 0xb380
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x221aa(%rip), %rdi     # 0x2d500
callq 0xbed0
movq -0x40(%rbp), %rdi
movslq (%rax), %rsi
callq 0xbeb0
cmpl $0x1, (%rax)
jne 0xb375
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x22179(%rip), %rdi     # 0x2d500
callq 0xbef0
jmp 0xb2fd
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tplinderoth[P]introDist/./Dxyz.h
// Function: Matrix<double>::Matrix(unsigned long, unsigned long)
Matrix (size_t n1, size_t n2)
		:   _nrow(0),
			_ncol(0),
			data(NULL)
	{
		if (n1 > 0 && n2 > 0) {
			_nrow = n1;
			_ncol = n2;
			data = new T* [n1];
			for (unsigned int i = 0; i < n1; ++i) {
				data[i] = new T [n2];
			}
		} else {
			std::cerr << "Unable to initialize matrix with " << n1 << "rows and " << n2 << " columns\n";
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0xb92c
cmpq $0x0, -0x18(%rbp)
jbe 0xb92c
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq -0x10(%rbp), %rax
jae 0xb92a
movq -0x18(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb8df
jmp 0xb975
movq 0x216b5(%rip), %rdi     # 0x2cfe8
leaq 0x13909(%rip), %rsi     # 0x1f243
callq 0x8400
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x80e0
movq %rax, %rdi
leaq 0x13910(%rip), %rsi     # 0x1f265
callq 0x8400
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x80e0
movq %rax, %rdi
leaq 0x138ff(%rip), %rsi     # 0x1f26f
callq 0x8400
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tplinderoth[P]introDist/./Dxyz.h
// Function: Matrix<double>::~Matrix()
~Matrix () {
		for (unsigned int i = 0; i < _nrow; ++i) {
			delete [] data[i];
		}
		delete [] data;
		data = NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jae 0xbc15
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbc08
movq -0x20(%rbp), %rdi
callq 0x85b0
jmp 0xbc0a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbbdb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbc30
movq -0x28(%rbp), %rdi
callq 0x85b0
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: minirop[P]JDecomqiler/src/main.cpp
// Function: main
int main(int argc, char** argv)
{
   if (argc != 2)
   {
      std::cerr << "usage: " << argv[0] << " <file.class>\n";
      return 1;
   }

	ClassFile cf(argv[1]);
	cf.generate();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x37cc
movq 0x3485a(%rip), %rdi     # 0x37ff0
leaq 0x26867(%rip), %rsi     # 0x2a004
callq 0x32a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0x26851(%rip), %rsi     # 0x2a00c
callq 0x32a0
movl $0x1, -0x4(%rbp)
jmp 0x38ba
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0xe1(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x34f0
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
callq 0x33d0
jmp 0x380a
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x3c70
jmp 0x381f
leaq -0xe0(%rbp), %rdi
callq 0x31d0
leaq -0xe1(%rbp), %rdi
callq 0x32e0
leaq -0xc0(%rbp), %rdi
callq 0x5540
jmp 0x3845
movl $0x0, -0x4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x54a0
jmp 0x38ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x388c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x31d0
leaq -0xe1(%rbp), %rdi
callq 0x32e0
jmp 0x38c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x54a0
jmp 0x38c6
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xf0(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: minirop[P]JDecomqiler/src/ClassFile.cpp
// Function: ClassFile::parseInterface[abi:cxx11]()
std::string ClassFile::parseInterface()
{
	std::uint16_t name_index;
	std::string interfaceName;
	
	stream >> name_index;
	CPinfo *data = &constant_pool[name_index];
	if(data->tag == CONSTANT_Class)
	{
		interfaceName = getName(data->ClassInfo.name_index);
	}
	else
	{
		cerr << "ERROR: index " << name_index << " in not a class" << endl;
	}
	
	return interfaceName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x13(%rbp)
callq 0x33e0
movq -0x58(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x12(%rbp), %rsi
callq 0x3b40
jmp 0x49e5
movzwl -0x12(%rbp), %eax
movl %eax, %esi
leaq 0x338d6(%rip), %rdi     # 0x382c8
callq 0x5760
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7, %eax
jne 0x4a49
movq -0x30(%rbp), %rax
movzwl 0x8(%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x28ed0
jmp 0x4a1a
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3350
leaq -0x50(%rbp), %rdi
callq 0x31d0
jmp 0x4a9f
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31d0
jmp 0x4abf
movq 0x335a0(%rip), %rdi     # 0x37ff0
leaq 0x25712(%rip), %rsi     # 0x2a169
callq 0x32a0
movq %rax, -0x70(%rbp)
jmp 0x4a62
movq -0x70(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x34a0
movq %rax, -0x78(%rbp)
jmp 0x4a75
movq -0x78(%rbp), %rdi
leaq 0x256f7(%rip), %rsi     # 0x2a177
callq 0x32a0
movq %rax, -0x80(%rbp)
jmp 0x4a8b
movq -0x80(%rbp), %rdi
movq 0x3352a(%rip), %rsi     # 0x37fc0
callq 0x32d0
jmp 0x4a9d
jmp 0x4a9f
movb $0x1, -0x13(%rbp)
testb $0x1, -0x13(%rbp)
jne 0x4ab2
movq -0x68(%rbp), %rdi
callq 0x31d0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34e0
nopl (%rax,%rax)
// File: minirop[P]JDecomqiler/src/ClassFile.cpp
// Function: ClassFile::parseAttribute[abi:cxx11]()
std::tuple<std::string, std::string> ClassFile::parseAttribute()
{
	std::uint16_t attribute_name_index;
	stream >> attribute_name_index;
	
	std::string name = getName(attribute_name_index);
	
	std::uint32_t length;
	stream >> length;
	if(length > 512)
	{
		cerr << "attribute " << name << " has more than 512 bytes of data" << endl;
		exit(1);
	}
	
	char tmp[512] = {0};
	stream.readRawData(tmp, length);
	std::string data(tmp, length);
	
	return std::make_tuple(name, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x298(%rbp)
movq %rdi, %rax
movq %rax, -0x290(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x288(%rbp)
addq $0xa8, %rdi
movq %rdi, -0x280(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x3b40
movzwl -0x12(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x28ed0
movq -0x280(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x3ba0
jmp 0x5305
cmpl $0x200, -0x3c(%rbp)     # imm = 0x200
jbe 0x5393
movq 0x32cd7(%rip), %rdi     # 0x37ff0
leaq 0x24dbe(%rip), %rsi     # 0x2a0de
callq 0x32a0
movq %rax, -0x2a0(%rbp)
jmp 0x532e
movq -0x2a0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3270
movq %rax, -0x2a8(%rbp)
jmp 0x5347
movq -0x2a8(%rbp), %rdi
leaq 0x24d94(%rip), %rsi     # 0x2a0e9
callq 0x32a0
movq %rax, -0x2b0(%rbp)
jmp 0x5363
movq -0x2b0(%rbp), %rdi
movq 0x32c4f(%rip), %rsi     # 0x37fc0
callq 0x32d0
jmp 0x5378
movl $0x1, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x548a
leaq -0x250(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x3180
movq -0x288(%rbp), %rdi
movq -0x2b8(%rbp), %rsi
addq $0xa8, %rdi
movl -0x3c(%rbp), %eax
movl %eax, %edx
callq 0x3910
jmp 0x53ce
movl -0x3c(%rbp), %eax
movq %rax, -0x2c8(%rbp)
leaq -0x271(%rbp), %rdi
movq %rdi, -0x2c0(%rbp)
callq 0x34f0
movq -0x2c8(%rbp), %rdx
movq -0x2c0(%rbp), %rcx
leaq -0x270(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x3310
jmp 0x540e
leaq -0x271(%rbp), %rdi
callq 0x32e0
movq -0x298(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x270(%rbp), %rdx
callq 0x5a80
jmp 0x5433
leaq -0x270(%rbp), %rdi
callq 0x31d0
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x290(%rbp), %rax
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x271(%rbp), %rdi
callq 0x32e0
jmp 0x548a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x31d0
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x48(%rbp), %rdi
callq 0x34e0
nopl (%rax)
// File: minirop[P]JDecomqiler/src/ClassFile.cpp
// Function: ClassFile::generate()
void ClassFile::generate()
{
	std::ofstream file("output.java");
	if(!file.is_open())
		return;
	
	output.generate(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq 0x24c26(%rip), %rsi     # 0x2a187
leaq -0x208(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movl $0x10, %edx
callq 0x32f0
movq -0x228(%rbp), %rdi
callq 0x3220
movb %al, -0x219(%rbp)
jmp 0x558d
movb -0x219(%rbp), %al
testb $0x1, %al
jne 0x55c5
jmp 0x5599
movl $0x1, -0x218(%rbp)
jmp 0x55e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3400
jmp 0x55f9
movq -0x230(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0xa6f0
jmp 0x55da
movl $0x0, -0x218(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3400
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nop
// File: minirop[P]JDecomqiler/src/FieldOutput.cpp
// Function: FieldOutput::generate(std::basic_ofstream<char, std::char_traits<char>>&)
void FieldOutput::generate(std::ofstream & file)
{
	if(isPublic)
		W("public ");
	if(isProtected)
		W("protected ");
	if(isPrivate)
		W("private ");
	if(isStatic)
		W("static ");
	if(isFinal)
		W("final ");
	if(isTransient)
		W("transient ");
	if(isVolatile)
		W("volatile ");
	
	W(type);
	W(" ");
	W(name);
	W(";\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x58(%rax)
je 0x28bde
movq -0x10(%rbp), %rdi
leaq 0x15d4(%rip), %rsi      # 0x2a1ad
callq 0x32a0
movq -0x18(%rbp), %rax
testb $0x1, 0x59(%rax)
je 0x28bf8
movq -0x10(%rbp), %rdi
leaq 0x1a35(%rip), %rsi      # 0x2a628
callq 0x32a0
movq -0x18(%rbp), %rax
testb $0x1, 0x5a(%rax)
je 0x28c12
movq -0x10(%rbp), %rdi
leaq 0x1a26(%rip), %rsi      # 0x2a633
callq 0x32a0
movq -0x18(%rbp), %rax
testb $0x1, 0x5d(%rax)
je 0x28c2c
movq -0x10(%rbp), %rdi
leaq 0x1a15(%rip), %rsi      # 0x2a63c
callq 0x32a0
movq -0x18(%rbp), %rax
testb $0x1, 0x5c(%rax)
je 0x28c46
movq -0x10(%rbp), %rdi
leaq 0x157e(%rip), %rsi      # 0x2a1bf
callq 0x32a0
movq -0x18(%rbp), %rax
testb $0x1, 0x5e(%rax)
je 0x28c60
movq -0x10(%rbp), %rdi
leaq 0x1ffe(%rip), %rsi      # 0x2ac59
callq 0x32a0
movq -0x18(%rbp), %rax
testb $0x1, 0x5b(%rax)
je 0x28c7a
movq -0x10(%rbp), %rdi
leaq 0x1fef(%rip), %rsi      # 0x2ac64
callq 0x32a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
callq 0x3270
movq -0x10(%rbp), %rdi
leaq 0x1ab1(%rip), %rsi      # 0x2a747
callq 0x32a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3270
movq -0x10(%rbp), %rdi
leaq 0x1b52(%rip), %rsi      # 0x2a805
callq 0x32a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: minirop[P]JDecomqiler/src/Helpers.cpp
// Function: letterFromType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char letterFromType(std::string type)
{
	if(type == "int")
		return 'i';
	else if(type == "long")
		return 'l';
	else if(type == "float")
		return 'f';
	else if(type == "double")
		return 'd';
	else
		return 'a';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x1a47(%rip), %rsi      # 0x2a71e
callq 0xb880
testb $0x1, %al
jne 0x28ce2
jmp 0x28ce8
movb $0x69, -0x1(%rbp)
jmp 0x28d40
movq -0x18(%rbp), %rdi
leaq 0x1a2f(%rip), %rsi      # 0x2a722
callq 0xb880
testb $0x1, %al
jne 0x28cfe
jmp 0x28d04
movb $0x6c, -0x1(%rbp)
jmp 0x28d40
movq -0x18(%rbp), %rdi
leaq 0x1a18(%rip), %rsi      # 0x2a727
callq 0xb880
testb $0x1, %al
jne 0x28d1a
jmp 0x28d20
movb $0x66, -0x1(%rbp)
jmp 0x28d40
movq -0x18(%rbp), %rdi
leaq 0x1a02(%rip), %rsi      # 0x2a72d
callq 0xb880
testb $0x1, %al
jne 0x28d36
jmp 0x28d3c
movb $0x64, -0x1(%rbp)
jmp 0x28d40
movb $0x61, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: minirop[P]JDecomqiler/src/Helpers.cpp
// Function: typeFromInt[abi:cxx11](int)
std::string typeFromInt(int typeInt)
{
	std::string ret = "*ERROR*";
	switch(typeInt)
	{
		case T_BOOLEAN:
			ret = "boolean";
			break;
		case T_CHAR:
			ret = "char";
			break;
		case T_FLOAT:
			ret = "float";
			break;
		case T_DOUBLE:
			ret = "double";
			break;
		case T_BYTE:
			ret = "byte";
			break;
		case T_SHORT:
			ret = "short";
			break;
		case T_INT:
			ret = "int";
			break;
		case T_LONG:
			ret = "long";
			break;
		default:
			;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
leaq -0xe(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x34f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1f6e(%rip), %rsi      # 0x2acf8
callq 0x33d0
jmp 0x28d91
leaq -0xe(%rbp), %rdi
callq 0x32e0
movl -0xc(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x7, %eax
ja 0x28e9a
movq -0x40(%rbp), %rax
leaq 0x1eb6(%rip), %rcx      # 0x2ac70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xe(%rbp), %rdi
callq 0x32e0
jmp 0x28eb9
movq -0x30(%rbp), %rdi
leaq 0x1f18(%rip), %rsi      # 0x2ad00
callq 0x33c0
jmp 0x28def
jmp 0x28e9c
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31d0
jmp 0x28eb9
movq -0x30(%rbp), %rdi
leaq 0x1eef(%rip), %rsi      # 0x2ad08
callq 0x33c0
jmp 0x28e20
jmp 0x28e9c
movq -0x30(%rbp), %rdi
leaq 0x18fa(%rip), %rsi      # 0x2a727
callq 0x33c0
jmp 0x28e34
jmp 0x28e9c
movq -0x30(%rbp), %rdi
leaq 0x18ec(%rip), %rsi      # 0x2a72d
callq 0x33c0
jmp 0x28e48
jmp 0x28e9c
movq -0x30(%rbp), %rdi
leaq 0x1eb8(%rip), %rsi      # 0x2ad0d
callq 0x33c0
jmp 0x28e5c
jmp 0x28e9c
movq -0x30(%rbp), %rdi
leaq 0x1ea9(%rip), %rsi      # 0x2ad12
callq 0x33c0
jmp 0x28e70
jmp 0x28e9c
movq -0x30(%rbp), %rdi
leaq 0x18a1(%rip), %rsi      # 0x2a71e
callq 0x33c0
jmp 0x28e84
jmp 0x28e9c
movq -0x30(%rbp), %rdi
leaq 0x1891(%rip), %rsi      # 0x2a722
callq 0x33c0
jmp 0x28e98
jmp 0x28e9c
jmp 0x28e9c
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x28eaf
movq -0x30(%rbp), %rdi
callq 0x31d0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: minirop[P]JDecomqiler/src/Helpers.cpp
// Function: getName[abi:cxx11](unsigned short)
std::string getName(std::uint16_t index)
{
	std::string ret_string("*ERROR*");
	
	CPinfo *data = &constant_pool[index];
	if(data->tag == CONSTANT_Utf8)
	{
		ret_string = std::string(data->UTF8Info.bytes);
	}
	
	return ret_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movw %si, %ax
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movb $0x0, -0xb(%rbp)
leaq -0xc(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34f0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x1de7(%rip), %rsi      # 0x2acf8
callq 0x33d0
jmp 0x28f18
leaq -0xc(%rbp), %rdi
callq 0x32e0
movzwl -0xa(%rbp), %eax
movl %eax, %esi
leaq 0xf39a(%rip), %rdi      # 0x382c8
callq 0x5760
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x28fcb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x34f0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x33d0
jmp 0x28f73
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3350
leaq -0x48(%rbp), %rdi
callq 0x31d0
leaq -0x49(%rbp), %rdi
callq 0x32e0
jmp 0x28fcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x32e0
jmp 0x28feb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x32e0
movq -0x60(%rbp), %rdi
callq 0x31d0
jmp 0x28feb
movb $0x1, -0xb(%rbp)
testb $0x1, -0xb(%rbp)
jne 0x28fde
movq -0x60(%rbp), %rdi
callq 0x31d0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: minirop[P]JDecomqiler/src/Helpers.cpp
// Function: checkClassName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string checkClassName(std::string classname)
{
	std::replace(classname.begin(), classname.end(), '/', '.');
	size_t start_pos = classname.find("java.lang.");
	if(start_pos != std::string::npos)
	{
		classname.replace(start_pos, 10, std::string());
	}
	return classname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq %rax, %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3250
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x31a0
movq %rax, -0x20(%rbp)
movb $0x2f, -0x21(%rbp)
movb $0x2e, -0x22(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x21(%rbp), %rdx
leaq -0x22(%rbp), %rcx
callq 0x298c0
movq -0x68(%rbp), %rdi
leaq 0x1cb1(%rip), %rsi      # 0x2ad18
xorl %eax, %eax
movl %eax, %edx
callq 0x3520
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x290d0
movq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33e0
movq -0x68(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rcx
movl $0xa, %edx
callq 0x3110
jmp 0x290ae
leaq -0x50(%rbp), %rdi
callq 0x31d0
jmp 0x290d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31d0
jmp 0x290ea
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x31b0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: minirop[P]JDecomqiler/src/Helpers.cpp
// Function: removeArray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string removeArray(std::string className)
{
	size_t start_pos;
	while((start_pos = className.find("[]")) != std::string::npos)
	{
		className.replace(start_pos, 2, "_arr");
	}
	
	return className;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x15f1(%rip), %rsi      # 0x2a71b
xorl %eax, %eax
movl %eax, %edx
callq 0x3520
movq %rax, -0x18(%rbp)
cmpq $-0x1, %rax
je 0x29158
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
leaq 0x1bd2(%rip), %rcx      # 0x2ad23
callq 0x31c0
jmp 0x2911f
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x31b0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jswaff[P]prophet3/src/apply.cpp
// Function: remove_captured_piece(position*, unsigned long long)
piece_t remove_captured_piece(position* p,move m) {
    assert(is_capture(m));
    piece_t captured;
    if (is_epcapture(m)) {
        // remove pawn
        if (p->player==WHITE) { // black WAS on move
            captured = remove_piece(p,north(p->ep_sq));
            assert(captured==PAWN);
        } else {
            captured = remove_piece(p,south(p->ep_sq));
            assert(captured==-PAWN);
        }
    } else {
        captured = remove_piece(p,get_to_sq(m));
    }

    assert(captured != NO_PIECE);
    return captured;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab20
testb $0x1, %al
jne 0x313f
jmp 0x3141
jmp 0x3160
leaq 0x31ef0(%rip), %rdi     # 0x35038
leaq 0x31ef7(%rip), %rsi     # 0x35046
movl $0x10, %edx
leaq 0x31ef9(%rip), %rcx     # 0x35054
callq 0x20c0
movq -0x10(%rbp), %rdi
callq 0xab50
testb $0x1, %al
jne 0x3172
jmp 0x321d
movq -0x8(%rbp), %rax
cmpl $0x1, 0x138(%rax)
jne 0x31cd
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x13c(%rax), %edi
callq 0x12410
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xee40
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x31ac
jmp 0x31cb
leaq 0x31ed1(%rip), %rdi     # 0x35084
leaq 0x31e8c(%rip), %rsi     # 0x35046
movl $0x16, %edx
leaq 0x31e8e(%rip), %rcx     # 0x35054
callq 0x20c0
jmp 0x321b
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x13c(%rax), %edi
callq 0x12490
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0xee40
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x31fa
jmp 0x3219
leaq 0x31e92(%rip), %rdi     # 0x35093
leaq 0x31e3e(%rip), %rsi     # 0x35046
movl $0x19, %edx
leaq 0x31e40(%rip), %rcx     # 0x35054
callq 0x20c0
jmp 0x321b
jmp 0x323c
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaaa0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0xee40
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3244
jmp 0x3263
leaq 0x31e58(%rip), %rdi     # 0x350a3
leaq 0x31df4(%rip), %rsi     # 0x35046
movl $0x1f, %edx
leaq 0x31df6(%rip), %rcx     # 0x35054
callq 0x20c0
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)