LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: renzibei[P]TSProxy/aes.cpp
// Function: aes(char*, char const*)
void aes(char *p, const char *key){

	int pArray[4][4];
	int i;

	extendKey(key);//扩展密钥

    // 开始加密
    strToArray(p, pArray);
    addKey(pArray, 0);//一开始的轮密钥加

    // 中间九轮
    for(i = 1; i < 10; i++){
        subBytes(pArray);//字节代换
        shiftRows(pArray);//行移位
        mixColumns(pArray);//列混合
        addKey(pArray, i);
    }

    // 最后一轮
    subBytes(pArray);//字节代换
    shiftRows(pArray);//行移位
    addKey(pArray, 10);

    arrayToStr(pArray, p);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xd9f0
movq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdb70
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xdbf0
movl $0x1, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0xd9ab
leaq 0x10(%rsp), %rdi
callq 0xdca0
leaq 0x10(%rsp), %rdi
callq 0xdd30
leaq 0x10(%rsp), %rdi
callq 0xddf0
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0xdbf0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd96b
leaq 0x10(%rsp), %rdi
callq 0xdca0
leaq 0x10(%rsp), %rdi
callq 0xdd30
leaq 0x10(%rsp), %rdi
movl $0xa, %esi
callq 0xdbf0
movq 0x60(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xdf80
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: extendKey(char const*)
static void extendKey(const char *key) {
	int i, j;
	// 前4个复制
	for(i = 0; i < 4; i++){
		int word = 0x00000000;
		for(j = 0; j < 4; j++){
			int theChar = charToInt(key[4*i + j]);
			word = word | theChar<<(24 - j*8);
		}
		w[i] = word;
	}

	// 对之后的所有
	int round = 0;
	for(i = 4; i < 44; i++){
		if( i % 4 == 0) {	//要进行T操作
			w[i] = w[i - 4] ^ T(w[i - 1], round);
			round++;	//轮数+1
		}else {		//只与前一个有关
			w[i] = w[i - 4] ^ w[i - 1];
		}
	}

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0xda93
movl $0x0, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x4, 0x18(%rsp)
jge 0xda70
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
shll $0x2, %ecx
addl 0x18(%rsp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0xefa0
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
movl 0x10(%rsp), %edx
movl 0x18(%rsp), %esi
shll $0x3, %esi
movl $0x18, %ecx
subl %esi, %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xda1c
movl 0x14(%rsp), %edx
movslq 0x1c(%rsp), %rcx
leaq 0xba290(%rip), %rax     # 0xc7d10
movl %edx, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xda01
movl $0x0, 0xc(%rsp)
movl $0x4, 0x1c(%rsp)
cmpl $0x2c, 0x1c(%rsp)
jge 0xdb5f
movl 0x1c(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xdb16
movl 0x1c(%rsp), %eax
subl $0x4, %eax
movslq %eax, %rcx
leaq 0xba240(%rip), %rax     # 0xc7d10
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xba228(%rip), %rax     # 0xc7d10
movl (%rax,%rcx,4), %edi
movl 0xc(%rsp), %esi
callq 0xefc0
movl 0x8(%rsp), %edx
xorl %eax, %edx
movslq 0x1c(%rsp), %rcx
leaq 0xba20a(%rip), %rax     # 0xc7d10
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xdb4d
movl 0x1c(%rsp), %eax
subl $0x4, %eax
movslq %eax, %rcx
leaq 0xba1e9(%rip), %rax     # 0xc7d10
movl (%rax,%rcx,4), %edx
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xba1d5(%rip), %rax     # 0xc7d10
xorl (%rax,%rcx,4), %edx
movslq 0x1c(%rsp), %rcx
leaq 0xba1c6(%rip), %rax     # 0xc7d10
movl %edx, (%rax,%rcx,4)
jmp 0xdb4f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xdaa3
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: strToArray(char*, int (&) [4][4])
static void strToArray(char *str, int (&array)[4][4]) {
	int i, j;
	for(i = 0; i < 4; i++){
		for(j = 0; j < 4; j++) {
			array[j][i] = charToInt(str[4*i+j]);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0xdbe9
movl $0x0, (%rsp)
cmpl $0x4, (%rsp)
jge 0xdbda
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
shll $0x2, %ecx
addl (%rsp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0xefa0
movl %eax, %edx
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xdb94
jmp 0xdbdc
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xdb86
addq $0x18, %rsp
retq
nop
// File: renzibei[P]TSProxy/aes.cpp
// Function: addKey(int (&) [4][4], int)
static void addKey(int (&array)[4][4], int round) {
	int warray[4];
	int i,j;
	for(i = 0; i < 4; i++) {
		intToArray(w[round*4 + i], warray);
		for(j = 0; j < 4; j++) {
			array[j][i] = array[j][i] ^ warray[j];
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0xdc9b
movl 0x2c(%rsp), %eax
shll $0x2, %eax
addl 0xc(%rsp), %eax
movslq %eax, %rcx
leaq 0xba0eb(%rip), %rax     # 0xc7d10
movl (%rax,%rcx,4), %edi
leaq 0x10(%rsp), %rsi
callq 0xf100
movl $0x0, 0x8(%rsp)
cmpl $0x4, 0x8(%rsp)
jge 0xdc89
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movslq 0x8(%rsp), %rax
xorl 0x10(%rsp,%rax,4), %edx
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xdc3a
jmp 0xdc8b
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xdc05
addq $0x38, %rsp
retq
// File: renzibei[P]TSProxy/aes.cpp
// Function: subBytes(int (&) [4][4])
static void subBytes(int (&array)[4][4]){
	int i,j;
	for(i = 0; i < 4; i++)
		for(j = 0; j < 4; j++)
			array[i][j] = getNumFromBox(S, array[i][j]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0xdd23
movl $0x0, 0x8(%rsp)
cmpl $0x4, 0x8(%rsp)
jge 0xdd14
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x3499(%rip), %rdi      # 0x11180
callq 0xf070
movl %eax, %edx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xdcc0
jmp 0xdd16
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xdcb1
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: shiftRows(int (&) [4][4])
static void shiftRows(int (&array)[4][4]) {
	int i,j;
	int copy[4];
	for(i=1; i<4; i++){
		// 记录下来
		for(j=0; j<4; j++){
			copy[j] = array[i][j];
		}
		for(j=0; j<4; j++){
			// 循环左移 i 位
			array[i][j] = copy[(4+j+i)%4];
		}
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0xdde7
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0xdd86
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movslq -0x10(%rsp), %rax
movl %ecx, -0x28(%rsp,%rax,4)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xdd50
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0xddd5
movl -0x10(%rsp), %eax
addl $0x4, %eax
addl -0xc(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movl -0x28(%rsp,%rax,4), %edx
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xdd8e
jmp 0xddd7
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xdd3d
retq
nopl (%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: mixColumns(int (&) [4][4])
static void mixColumns(int (&array)[4][4]) {

	int copy[4][4];
	int i,j;
	for(i = 0; i < 4; i++)
		for(j = 0; j < 4; j++)
			copy[i][j] = array[i][j];

	for(i = 0; i < 4; i++)
		for(j = 0; j < 4; j++){
			array[i][j] = GFMul(colM[i][0],copy[0][j]) ^ GFMul(colM[i][1],copy[1][j])
				^ GFMul(colM[i][2],copy[2][j]) ^ GFMul(colM[i][3], copy[3][j]);
		}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0xde65
movl $0x0, 0x18(%rsp)
cmpl $0x4, 0x18(%rsp)
jge 0xde56
movq 0x60(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movslq 0x1c(%rsp), %rcx
leaq 0x20(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xde10
jmp 0xde58
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xde01
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0xdf77
movl $0x0, 0x18(%rsp)
cmpl $0x4, 0x18(%rsp)
jge 0xdf65
movslq 0x1c(%rsp), %rcx
leaq 0x3719(%rip), %rax      # 0x115b0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
movslq 0x18(%rsp), %rax
movl 0x20(%rsp,%rax,4), %esi
callq 0xf180
movl %eax, 0xc(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x36f2(%rip), %rax      # 0x115b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
movslq 0x18(%rsp), %rax
movl 0x30(%rsp,%rax,4), %esi
callq 0xf180
movl %eax, %ecx
movl 0xc(%rsp), %eax
xorl %ecx, %eax
movl %eax, 0x10(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x36c2(%rip), %rax      # 0x115b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
movslq 0x18(%rsp), %rax
movl 0x40(%rsp,%rax,4), %esi
callq 0xf180
movl %eax, %ecx
movl 0x10(%rsp), %eax
xorl %ecx, %eax
movl %eax, 0x14(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x3692(%rip), %rax      # 0x115b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %edi
movslq 0x18(%rsp), %rax
movl 0x50(%rsp,%rax,4), %esi
callq 0xf180
movl 0x14(%rsp), %edx
xorl %eax, %edx
movq 0x60(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xde80
jmp 0xdf67
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xde6d
addq $0x68, %rsp
retq
nopl (%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: arrayToStr(int (&) [4][4], char*)
static void arrayToStr(int (&array)[4][4], char *str) {
	int i,j;
	for(i = 0; i < 4; i++)
		for(j = 0; j < 4; j++)
			*str++ = (char)array[j][i];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x4, -0x14(%rsp)
jge 0xdff2
movl $0x0, -0x18(%rsp)
cmpl $0x4, -0x18(%rsp)
jge 0xdfe3
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xdfa1
jmp 0xdfe5
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xdf92
retq
nopw %cs:(%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: showStr(char*)
void showStr(char *str){
	int i;
	for(i=0;i<16;i++)
		printf("%02x", (unsigned char)str[i]);
		// printf("%c", (unsigned char)str[i]);
	printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0xe041
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x2ee8(%rip), %rdi      # 0x10f15
movb $0x0, %al
callq 0x2050
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe011
leaq 0x26a0(%rip), %rdi      # 0x106e8
movb $0x0, %al
callq 0x2050
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: compute_hh(unsigned char (&) [16])
int compute_hh(unsigned char (&h)[16])
{//计算h<<1，h<<2，h<<3，....h<<127；p(x)=x128+ x7 + x2 +x + 1; 
		int i,msb,j;    
	memcpy(hh[0],h,16);//hh[0]=h
	for(i=1;i<128;i++)
	{
		msb=hh[i-1][0]>>7;//最高位
		for(j=0;j<15;j++)//h[i]=h[i-1]<<1 | ...
			hh[i][j] = ((hh[i-1][j]<<1) | (hh[i-1][j+1]>>7)) &255;
		hh[i][15] = hh[i-1][15]<<1;
		if(msb==1)
			hh[i][15] ^= 0x87;
	}
	return 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xb949c(%rip)     # 0xc7510
movq 0x8(%rax), %rax
movq %rax, 0xb9499(%rip)     # 0xc7518
movl $0x1, -0xc(%rsp)
cmpl $0x80, -0xc(%rsp)
jge 0xe1b9
movl -0xc(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xb946a(%rip), %rax     # 0xc7510
shlq $0x4, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
sarl $0x7, %eax
movl %eax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0xf, -0x14(%rsp)
jge 0xe14a
movl -0xc(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xb9435(%rip), %rax     # 0xc7510
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
shll %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0xb9412(%rip), %rcx     # 0xc7510
shlq $0x4, %rdx
addq %rdx, %rcx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
andl $0xff, %eax
movb %al, %dl
movslq -0xc(%rsp), %rcx
leaq 0xb93e5(%rip), %rax     # 0xc7510
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x14(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xe0bf
movl -0xc(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xb93b5(%rip), %rax     # 0xc7510
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0xf(%rax), %eax
shll %eax
movb %al, %cl
movslq -0xc(%rsp), %rdx
leaq 0xb939a(%rip), %rax     # 0xc7510
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0xf(%rax)
cmpl $0x1, -0x10(%rsp)
jne 0xe1a7
movslq -0xc(%rsp), %rcx
leaq 0xb937d(%rip), %rax     # 0xc7510
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0xf(%rax), %ecx
xorl $0x87, %ecx
movb %cl, 0xf(%rax)
jmp 0xe1a9
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xe087
xorl %eax, %eax
retq
nopl (%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: mult_h(unsigned char (&) [16], unsigned char (&) [16])
static int mult_h(unsigned char (&a)[16],unsigned char (&b)[16])
{//有限域乘法G(2128);注意：a，b不能为同一个地址（b在不停的更新）
	int i,j,k,m;
	memset(b,0,16);
	for(k=0,i=15; i>=0; i--)//从低位开始，数据都是从高位开始的，所以从15开始。
	{//k为从低位开始的计数器
		for(j=0; j<8; j++,k++)
		{
			if( ((a[i]>>j)&1) == 1)//每个字节也从低位开始
			{
				for(m=0;m<16;m++)
					b[m] ^= hh[k][m] ;
			}
		}
	}
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2140
movl $0x0, 0xc(%rsp)
movl $0xf, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0xe605
movl $0x0, 0x10(%rsp)
cmpl $0x8, 0x10(%rsp)
jge 0xe5f3
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl 0x10(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0xe5d6
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0xe5d4
movslq 0xc(%rsp), %rcx
leaq 0xb8f6c(%rip), %rax     # 0xc7510
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %esi
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xe591
jmp 0xe5d6
jmp 0xe5d8
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe562
jmp 0xe5f5
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe54f
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: T(int, int)
static int T(int num, int round) {
	int numArray[4];
	int i;
	int result;
	// 循环左移 1 位填入
	numArray[3] = (num >> 24) & 0x000000ff;
	numArray[0] = (num >> 16) & 0x000000ff;
	numArray[1] = (num >> 8) & 0x000000ff;
	numArray[2] = num & 0x000000ff;

	//字节代换
	for(i = 0; i < 4; i++)
		numArray[i] = getNumFromBox(S, numArray[i]);

	result = arrayToInt(numArray);
	return result ^ Rcon[round];
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl 0x24(%rsp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
andl $0xff, %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0xf045
movslq 0xc(%rsp), %rax
movl 0x10(%rsp,%rax,4), %esi
leaq 0x2158(%rip), %rdi      # 0x11180
callq 0xf070
movl %eax, %ecx
movslq 0xc(%rsp), %rax
movl %ecx, 0x10(%rsp,%rax,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xf011
leaq 0x10(%rsp), %rdi
callq 0xf0b0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movslq 0x20(%rsp), %rdx
leaq 0x251d(%rip), %rcx      # 0x11580
xorl (%rcx,%rdx,4), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: arrayToInt(int (&) [4])
static int arrayToInt(int (&array)[4]) {
	int one = array[0] << 24;
	int two = array[1] << 16;
	int three = array[2] << 8;
	int four = array[3];
	return one | two | three | four;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
shll $0x18, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %eax
shll $0x10, %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x8(%rax), %eax
shll $0x8, %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rsp)
movl -0xc(%rsp), %eax
orl -0x10(%rsp), %eax
orl -0x14(%rsp), %eax
orl -0x18(%rsp), %eax
retq
nop
// File: renzibei[P]TSProxy/aes.cpp
// Function: intToArray(int, int (&) [4])
static void intToArray(int num, int (&array)[4]) {
	int one, two, three;
	one = num >> 24;
	array[0] = one & 0x000000ff;
	two = num >> 16;
	array[1] = two & 0x000000ff;
	three = num >> 8;
	array[2] = three & 0x000000ff;
	array[3] = num & 0x000000ff;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl -0x4(%rsp), %eax
sarl $0x18, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %ecx
andl $0xff, %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x4(%rsp), %eax
sarl $0x10, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %ecx
andl $0xff, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rsp), %eax
sarl $0x8, %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
andl $0xff, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl -0x4(%rsp), %ecx
andl $0xff, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
retq
nopw %cs:(%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: GFMul(int, int)
static int GFMul(int n, int s) {
	int result;

	if(n == 1)
		result = s;
	else if(n == 2)
		result = GFMul2(s);
	else if(n == 3)
		result = GFMul3(s);
	else if(n == 0x9)
		result = GFMul9(s);
	else if(n == 0xb)//11
		result = GFMul11(s);
	else if(n == 0xd)//13
		result = GFMul13(s);
	else if(n == 0xe)//14
		result = GFMul14(s);

	return result;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0xf1a0
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xf22e
cmpl $0x2, 0x14(%rsp)
jne 0xf1b6
movl 0x10(%rsp), %edi
callq 0xf240
movl %eax, 0xc(%rsp)
jmp 0xf22c
cmpl $0x3, 0x14(%rsp)
jne 0xf1cc
movl 0x10(%rsp), %edi
callq 0xf280
movl %eax, 0xc(%rsp)
jmp 0xf22a
cmpl $0x9, 0x14(%rsp)
jne 0xf1e2
movl 0x10(%rsp), %edi
callq 0xf2a0
movl %eax, 0xc(%rsp)
jmp 0xf228
cmpl $0xb, 0x14(%rsp)
jne 0xf1f8
movl 0x10(%rsp), %edi
callq 0xf2c0
movl %eax, 0xc(%rsp)
jmp 0xf226
cmpl $0xd, 0x14(%rsp)
jne 0xf20e
movl 0x10(%rsp), %edi
callq 0xf2f0
movl %eax, 0xc(%rsp)
jmp 0xf224
cmpl $0xe, 0x14(%rsp)
jne 0xf222
movl 0x10(%rsp), %edi
callq 0xf310
movl %eax, 0xc(%rsp)
jmp 0xf224
jmp 0xf226
jmp 0xf228
jmp 0xf22a
jmp 0xf22c
jmp 0xf22e
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: renzibei[P]TSProxy/aes.cpp
// Function: GFMul2(int)
static int GFMul2(int s) {
	int result = s << 1;
	int a7 = result & 0x00000100;

	if(a7 != 0) {
		result = result & 0x000000ff;
		result = result ^ 0x1b;
	}

	return result;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
je 0xf27a
movl -0x8(%rsp), %eax
andl $0xff, %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
xorl $0x1b, %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nop
// File: millanek[P]evo/./process_vcf_utils.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> numToString<int>(int)
std::string numToString(T i) {
    std::string ret;
    std::stringstream out;
    out << i;
    ret = out.str();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0xa820
leaq -0x198(%rbp), %rdi
callq 0xa3f0
jmp 0x3e1ca
leaq -0x188(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xab20
jmp 0x3e1db
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa5a0
jmp 0x3e1f0
movq -0x1d8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xa710
leaq -0x1c8(%rbp), %rdi
callq 0xac88
movb $0x1, -0xd(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa450
testb $0x1, -0xd(%rbp)
jne 0x3e267
jmp 0x3e25b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x3e277
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa450
jmp 0x3e277
movq -0x1d8(%rbp), %rdi
callq 0xac88
movq -0x1d0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1d8(%rbp), %rdi
callq 0xac88
movq -0x1a0(%rbp), %rdi
callq 0xab50
nop
// File: millanek[P]evo/./process_vcf_annotation_tools.h
// Function: LinkedCoordsBed::getElementNames[abi:cxx11]()
std::vector<string> getElementNames() {
        std::vector<string> elementNames;
        for (int i = 0; i < (int)elementCoordsVector.size(); i++) {
            std::vector<std::vector<string> > thisElement = elementCoordsVector[i];
            //if (thisElement[0].size() < 4) {
            //    std::cerr << "thisElement[0].size()" << thisElement.size() << std::endl;
            //}
            elementNames.push_back(thisElement[0][3]);
        }
        return elementNames;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x48da0
movl $0x0, -0x18(%rbp)
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
callq 0x45780
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3ea28
movq -0x48(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x48430
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x45190
jmp 0x3e9c7
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x3ec10
movq %rax, %rdi
movl $0x3, %esi
callq 0x3d940
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x48dc0
jmp 0x3e9ef
leaq -0x30(%rbp), %rdi
callq 0x3ec50
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3e993
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3ea45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3ec50
jmp 0x3ea45
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3ea3b
movq -0x58(%rbp), %rdi
callq 0x3dfa0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3dfa0
movq -0x38(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/./process_vcf_annotation_tools.h
// Function: LinkedCoordsBed::getElementOuterBoundaries[abi:cxx11]()
std::vector<std::vector<string> > getElementOuterBoundaries() {
        std::vector<std::vector<string> > allOuterBounds;
        for (int i = 0; i < (int)elementCoordsVector.size(); i++) {
            std::vector<std::vector<string> > thisElement = elementCoordsVector[i];
            //if (thisElement[0].size() < 4) {
            //    std::cerr << "thisElement[0].size()" << thisElement.size() << std::endl;
            //}
            std::vector<string> elementOuterBounds;
            elementOuterBounds.push_back(thisElement[0][0]);
            elementOuterBounds.push_back(thisElement[0][1]);
            elementOuterBounds.push_back(thisElement.back()[2]);
            allOuterBounds.push_back(elementOuterBounds);
        }
        return allOuterBounds;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3f5f0
movl $0x0, -0x18(%rbp)
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x74(%rbp)
callq 0x45780
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x3ebb5
movq -0x60(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x48430
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x45190
jmp 0x3eace
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x48da0
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3ec10
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x3d940
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x48dc0
jmp 0x3eb0c
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x3ec10
movq %rax, %rdi
movl $0x1, %esi
callq 0x3d940
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x48dc0
jmp 0x3eb34
leaq -0x30(%rbp), %rdi
callq 0x49550
movq %rax, %rdi
movl $0x2, %esi
callq 0x3d940
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x48dc0
jmp 0x3eb58
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3f610
jmp 0x3eb67
leaq -0x58(%rbp), %rdi
callq 0x3dfa0
leaq -0x30(%rbp), %rdi
callq 0x3ec50
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3ea96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3ebd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3dfa0
leaq -0x30(%rbp), %rdi
callq 0x3ec50
jmp 0x3ebd5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3ebc8
movq -0x70(%rbp), %rdi
callq 0x3ec50
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3ec50
movq -0x38(%rbp), %rdi
callq 0xab50
nopw (%rax,%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: double vector_sum<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>>)
double vector_sum(T vector) {
    double sum = 0;
    for (int i = 0; i < vector.size(); i++) {
        sum += vector[i];
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x467f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4cf12
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x4d100
cvtsi2sdl (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4cecf
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: void print_vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::ostream&, char, bool)
void print_vector(T vector, std::ostream& outFile, char delim = '\t', bool endLine = true) {
    for (int i = 0; i < vector.size(); i++) {
        if (i == (vector.size()-1)) {
            if (endLine) outFile << vector[i] << std::endl;
            else outFile << vector[i];
        } else {
            outFile << vector[i] << delim;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3ffd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x50ea1
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3ffd0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x50e64
testb $0x1, -0x12(%rbp)
je 0x50e41
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x3d940
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xa520
movq %rax, %rdi
movq 0x14814e(%rip), %rsi    # 0x198f88
callq 0xa610
jmp 0x50e62
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x3d940
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xa520
jmp 0x50e91
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x3d940
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xa520
movq %rax, %rdi
movsbl -0x11(%rbp), %esi
callq 0xa6d0
jmp 0x50e93
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x50dc7
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/evo_abba_baba.cpp
// Function: getAAfromInfo(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
inline std::string getAAfromInfo(const std::vector<std::string>& info) {
    string AA = "?";
    for (std::vector<std::string>::size_type i = 0; i != info.size(); i++) {
        string infoKey = split(info[i],'=')[0];
        if (infoKey == "AA") {
            AA = split(info[i],'=')[1];
        }
    }
    return AA;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xab60
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0xf4b56(%rip), %rsi     # 0x146af3
callq 0x2d6c0
jmp 0x51fa4
leaq -0x12(%rbp), %rdi
callq 0xa640
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ffd0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
je 0x5211d
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x52960
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
movl $0x3d, %edx
callq 0x7bbe0
jmp 0x51ffc
xorl %eax, %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
callq 0x3d940
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0xa250
jmp 0x52017
leaq -0x68(%rbp), %rdi
callq 0x3dfa0
leaq 0xdc498(%rip), %rsi     # 0x12e4bf
leaq -0x50(%rbp), %rdi
callq 0x2d770
movb %al, -0xa1(%rbp)
jmp 0x52038
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x52047
jmp 0x520f8
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x52960
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
movl $0x3d, %edx
callq 0x7bbe0
jmp 0x52067
leaq -0x80(%rbp), %rdi
movl $0x1, %esi
callq 0x3d940
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0xa060
jmp 0x52086
leaq -0x80(%rbp), %rdi
callq 0x3dfa0
jmp 0x520f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0xa640
jmp 0x5214f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x52143
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3dfa0
jmp 0x52143
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x52112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3dfa0
jmp 0x52112
leaq -0x50(%rbp), %rdi
callq 0xac88
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x51fb5
leaq -0x50(%rbp), %rdi
callq 0xac88
jmp 0x52143
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x52133
movq -0x90(%rbp), %rdi
callq 0xac88
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xac88
movq -0x20(%rbp), %rdi
callq 0xab50
nopl (%rax,%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: double vector_average<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>)
double vector_average(T vector) {
    double sum = 0;
    for (int i = 0; i < vector.size(); i++) {
        sum += vector[i];
    }
    double average = (double)sum / (double)vector.size();
    return average;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3ebf0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x530c2
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3ec30
movsd (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5307f
movq -0x28(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x3ebf0
movsd -0x38(%rbp), %xmm0
movq %rax, %xmm1
movaps 0xdb07a(%rip), %xmm2    # 0x12e160
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xdb07e(%rip), %xmm2    # 0x12e170
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: millanek[P]evo/./process_vcf_annotation_tools.h
// Function: Annotation::getTranscriptName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&)
std::string getTranscriptName(const string& geneColumn, bool& bPartial) {
        string thisTranscriptName;
        std::vector<string> findIfPartial = split(geneColumn, '-');
        if (findIfPartial.size() == 2) {
            bPartial = true;
            thisTranscriptName = findIfPartial[1];
        } else if (findIfPartial.size() == 1) {
            thisTranscriptName = geneColumn;
        }
        return thisTranscriptName;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xa820
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x2d, %edx
callq 0x7bbe0
jmp 0x59130
leaq -0x40(%rbp), %rdi
callq 0x3ffd0
cmpq $0x2, %rax
jne 0x59189
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x3d940
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xa060
jmp 0x59162
jmp 0x591ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x591d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3dfa0
jmp 0x591d1
leaq -0x40(%rbp), %rdi
callq 0x3ffd0
cmpq $0x1, %rax
jne 0x591a9
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa060
jmp 0x591a7
jmp 0x591a9
jmp 0x591ab
movb $0x1, -0x21(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3dfa0
testb $0x1, -0x21(%rbp)
jne 0x591c7
movq -0x60(%rbp), %rdi
callq 0xac88
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xac88
movq -0x48(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]evo/process_vcf_cbs.cpp
// Function: numToStringVector[abi:cxx11](std::vector<int, std::allocator<int>>&)
std::vector<string> numToStringVector(std::vector<int>& vec) {
    std::vector<string> converted;
    for (std::vector<int>::size_type i = 0; i != vec.size(); i++) {
        converted.push_back(numToString(vec[i]));
    }
    return converted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x48da0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x467f0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0x67dfe
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d100
movl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x3e190
jmp 0x67db3
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5f980
jmp 0x67dc2
leaq -0x40(%rbp), %rdi
callq 0xac88
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x67d7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x67e1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xac88
jmp 0x67e1b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x67e11
movq -0x60(%rbp), %rdi
callq 0x3dfa0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3dfa0
movq -0x48(%rbp), %rdi
callq 0xab50
nopl (%rax)
// File: millanek[P]evo/process_vcf_cbs.cpp
// Function: numToStringMinFilterVector[abi:cxx11](std::vector<int, std::allocator<int>>&, int)
std::vector<string> numToStringMinFilterVector(std::vector<int>& vec, int min) {
    std::vector<string> converted;
    for (std::vector<int>::size_type i = 0; i != vec.size(); i++) {
        if (vec[i] >= min)
            converted.push_back(numToString(vec[i]));
    }
    return converted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x48da0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x467f0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0x67f00
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d100
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jl 0x67eed
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d100
movl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x3e190
jmp 0x67eae
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5f980
jmp 0x67ebd
leaq -0x40(%rbp), %rdi
callq 0xac88
jmp 0x67eed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x67f1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xac88
jmp 0x67f1d
jmp 0x67eef
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x67e5f
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x67f13
movq -0x60(%rbp), %rdi
callq 0x3dfa0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3dfa0
movq -0x48(%rbp), %rdi
callq 0xab50
nop
// File: millanek[P]evo/process_vcf_cbs.cpp
// Function: compareVectorsByLength(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
bool compareVectorsByLength (std::vector<string> a,std::vector<string> b) {
    if (a.size() >= b.size()) {
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x3ffd0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3ffd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0x67f68
movb $0x1, -0x1(%rbp)
jmp 0x67f6c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: millanek[P]evo/process_vcf_cbs.cpp
// Function: cbsMain(int, char**)
int cbsMain(int argc, char** argv) {
    parseCbsOptions(argc, argv);
    
    if (!opt::vcfFile.empty()) {
        std::cerr << "Calculating the lenghts of cbs tracts from: " << opt::vcfFile << std::endl;
        std::cerr << "and using information about scaffold lengths and the location of undetermined regions from: " << opt::undeterminedLociFile << std::endl;
        calculateCbs();
    } else if (!opt::genomeFile.empty()) {
        std::cerr << "Looking for undetermined regions (runs of Ns) in the reference genome: " << std::endl;
        std::cerr << opt::genomeFile << std::endl;
        findUndeterminedRegions();
    } else {
        assert(false);
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x6a3d0
leaq 0x13024e(%rip), %rdi    # 0x19a520
callq 0xaa70
testb $0x1, %al
jne 0x6a344
movq 0x12ed0e(%rip), %rdi    # 0x198ff0
leaq 0xcf302(%rip), %rsi     # 0x1395eb
callq 0xa5c0
movq %rax, %rdi
leaq 0x130228(%rip), %rsi    # 0x19a520
callq 0xa520
movq %rax, %rdi
movq 0x12ec81(%rip), %rsi    # 0x198f88
callq 0xa610
movq 0x12ecdd(%rip), %rdi    # 0x198ff0
leaq 0xcf2fe(%rip), %rsi     # 0x139618
callq 0xa5c0
movq %rax, %rdi
leaq 0x130297(%rip), %rsi    # 0x19a5c0
callq 0xa520
movq %rax, %rdi
movq 0x12ec50(%rip), %rsi    # 0x198f88
callq 0xa610
callq 0x67f80
jmp 0x6a3c0
leaq 0x1301f5(%rip), %rdi    # 0x19a540
callq 0xaa70
testb $0x1, %al
jne 0x6a39f
movq 0x12ec95(%rip), %rdi    # 0x198ff0
leaq 0xcf313(%rip), %rsi     # 0x139675
callq 0xa5c0
movq %rax, %rdi
movq 0x12ec17(%rip), %rsi    # 0x198f88
callq 0xa610
movq 0x12ec73(%rip), %rdi    # 0x198ff0
leaq 0x1301bc(%rip), %rsi    # 0x19a540
callq 0xa520
movq %rax, %rdi
movq 0x12ebf5(%rip), %rsi    # 0x198f88
callq 0xa610
callq 0x67810
jmp 0x6a3be
leaq 0xcf317(%rip), %rdi     # 0x1396bd
leaq 0xcf12b(%rip), %rsi     # 0x1394d8
movl $0x176, %edx            # imm = 0x176
leaq 0xcf30a(%rip), %rcx     # 0x1396c3
callq 0xa390
jmp 0x6a3c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: millanek[P]evo/./process_vcf_seq_utils.h
// Function: readScaffold(std::basic_ifstream<char, std::char_traits<char>>*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline std::string readScaffold(std::ifstream*& genomeFile, std::string& nextScaffoldName) {
    std::string scaffoldString;
    scaffoldString.reserve(100000000);
    std::string line = "";
    while (getline(*genomeFile, line) && line[0] != '>') {
        scaffoldString.append(line);
    }
    if (line[0] == '>')
        nextScaffoldName = split(line,' ')[0];
    else
        nextScaffoldName = "";
    return scaffoldString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa820
movq -0x78(%rbp), %rdi
movl $0x5f5e100, %esi        # imm = 0x5F5E100
callq 0xa980
jmp 0x6a81b
leaq -0x51(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xab60
movq -0x88(%rbp), %rdx
leaq 0xcb6a6(%rip), %rsi     # 0x135edf
leaq -0x50(%rbp), %rdi
callq 0x2d6c0
jmp 0x6a844
leaq -0x51(%rbp), %rdi
callq 0xa640
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x90(%rbp)
jmp 0x6a866
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x91(%rbp)
jmp 0x6a884
movb -0x91(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x92(%rbp)
jne 0x6a899
jmp 0x6a8c5
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0xac60
movq %rax, -0xa0(%rbp)
jmp 0x6a8af
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x92(%rbp)
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x6a8d1
jmp 0x6a921
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xac20
jmp 0x6a8e0
jmp 0x6a84d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x6a9e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xa640
jmp 0x6a9e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x6a9c0
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0xac60
movq %rax, -0xa8(%rbp)
jmp 0x6a937
movq -0xa8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x6a997
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x20, %edx
callq 0x7bbe0
jmp 0x6a95a
xorl %eax, %eax
movl %eax, %esi
leaq -0x70(%rbp), %rdi
callq 0x3d940
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0xa060
jmp 0x6a975
leaq -0x70(%rbp), %rdi
callq 0x3dfa0
jmp 0x6a9ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3dfa0
jmp 0x6a9c0
movq -0x18(%rbp), %rdi
leaq 0xcb53d(%rip), %rsi     # 0x135edf
callq 0xa810
jmp 0x6a9a9
jmp 0x6a9ab
movb $0x1, -0x19(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xac88
testb $0x1, -0x19(%rbp)
jne 0x6a9d4
jmp 0x6a9cb
leaq -0x50(%rbp), %rdi
callq 0xac88
jmp 0x6a9e1
movq -0x78(%rbp), %rdi
callq 0xac88
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xac88
movq -0x28(%rbp), %rdi
callq 0xab50
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: millanek[P]evo/./process_vcf_utils.h
// Function: void print_matrix<std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>(std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, std::ostream&)
void print_matrix(T matrix, std::ostream& outFile) {
    for (int i = 0; i < matrix.size(); i++) {
        for (int j = 0; j < matrix[i].size(); j++) {
            if (j == (matrix[i].size()-1))
                outFile << matrix[i][j] << std::endl;
            else 
                outFile << matrix[i][j] << "\t";
        }    
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x409f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c047
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x3ec10
movq %rax, %rdi
callq 0x3ffd0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c037
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x3ec10
movq %rax, %rdi
callq 0x3ffd0
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x6bfeb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x3ec10
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3d940
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xa520
movq %rax, %rdi
movq 0x12cfa4(%rip), %rsi    # 0x198f88
callq 0xa610
jmp 0x6c027
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x3ec10
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3d940
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xa520
movq %rax, %rdi
leaq 0xc9ebc(%rip), %rsi     # 0x135ede
callq 0xa5c0
jmp 0x6c029
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6bf53
jmp 0x6c039
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6bf2b
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: millanek[P]evo/./process_vcf_stats_utils.h
// Function: factorial(double)
inline double factorial(double num) {
    if (num < 0) {
        std::cerr << "Can't compute factorial of a negative number " << num << std::endl;
        exit(1);
    }
    return tgamma(num+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x703d0
movq 0x128c52(%rip), %rdi    # 0x198ff0
leaq 0xc939e(%rip), %rsi     # 0x139743
callq 0xa5c0
movq %rax, %rdi
movsd -0x8(%rbp), %xmm0
callq 0xabd0
movq %rax, %rdi
movq 0x128bc7(%rip), %rsi    # 0x198f88
callq 0xa610
movl $0x1, %edi
callq 0xa700
movsd 0xc1ee0(%rip), %xmm0    # 0x1322b8
addsd -0x8(%rbp), %xmm0
callq 0xa0a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)