LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: GetFollow()
void GetFollow()                       //求所有非终结符的FOLLOW集的函数
{
	int i=0;
	bool Follow[VNnum]={false};        //判断某一非终结符的 FOLLOW 集是否已求的数组 
	for(i=0;i<VNnum;i++)
	{
		GetFollowGroup(i,Follow);
		Follow[i]=true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x27, %edx
callq 0x3140
movl $0x0, -0x4(%rbp)
cmpl $0x27, -0x4(%rbp)
jge 0x18aec
movl -0x4(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0x1b3f0
movslq -0x4(%rbp), %rax
movb $0x1, -0x30(%rbp,%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x18ac6
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: CreatAnalysisTable()
void CreatAnalysisTable(void)          //LL(1)分析表的创建函数
{
	int i,j,k,m,n;
	//初始化 
	for(i=0;i<VNnum;i++)
		for(j=0;j<VTnum+1;j++)
			AnalysisTable[i][j]=-1;
	
	for(i=0;i<GenerationNum;i++)
	{
		for(j=0;g[i].FIRST[j]!=-1;j++)
		{
			m=g[i].left;
			n=g[i].FIRST[j]-100;
			AnalysisTable[m][n]=i;
		}
		if(e_belongstoF(i))
		{
			for(j=0;g[i].FOLLOW[j]!=-1;j++)
			{
				m=g[i].left;
				n=g[i].FOLLOW[j]-100;
				AnalysisTable[m][n]=i;
			}	
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x27, -0x4(%rbp)
jge 0x18b5a
movl $0x0, -0x8(%rbp)
cmpl $0x2a, -0x8(%rbp)
jge 0x18b4d
movslq -0x4(%rbp), %rcx
leaq 0xabc23(%rip), %rax     # 0xc4750
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x18b1c
jmp 0x18b4f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x18b0f
movl $0x0, -0x4(%rbp)
cmpl $0x4c, -0x4(%rbp)
jge 0x18cb8
movl $0x0, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xa7dc3(%rip), %rax     # 0xc0940
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpl $-0x1, 0x30(%rax,%rcx,4)
je 0x18bfd
movslq -0x4(%rbp), %rcx
leaq 0xa7da3(%rip), %rax     # 0xc0940
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xa7d88(%rip), %rax     # 0xc0940
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movl 0x30(%rax,%rcx,4), %eax
subl $0x64, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edx
movslq -0x10(%rbp), %rcx
leaq 0xabb72(%rip), %rax     # 0xc4750
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x18b72
movl -0x4(%rbp), %edi
callq 0x1a950
testb $0x1, %al
jne 0x18c0e
jmp 0x18ca8
movl $0x0, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xa7d20(%rip), %rax     # 0xc0940
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpl $-0x1, 0x80(%rax,%rcx,4)
je 0x18ca6
movslq -0x4(%rbp), %rcx
leaq 0xa7cfd(%rip), %rax     # 0xc0940
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xa7ce2(%rip), %rax     # 0xc0940
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %eax
subl $0x64, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edx
movslq -0x10(%rbp), %rcx
leaq 0xabac9(%rip), %rax     # 0xc4750
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x18c15
jmp 0x18ca8
jmp 0x18caa
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x18b61
addq $0x20, %rsp
popq %rbp
retq
nop
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: initTree()
void initTree()
{
	tree.size=0;
    tree.node[0].type=0;
	tree.node[0].code="Program";
	for(int i=0;i<999;i++)
	{
		tree.node[i].childNum=0;
		tree.node[i].isT=false;
		tree.node[i].code="";
		tree.node[i].row=-1;
		tree.node[i].numType=-1;
		tree.node[i].value="";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0xac186(%rip)     # 0xc6138
movl $0x0, 0xac1d8(%rip)     # 0xc6194
leaq 0xac175(%rip), %rdi     # 0xc6138
addq $0x8, %rdi
addq $0x60, %rdi
leaq 0x4e1a(%rip), %rsi      # 0x1edec
callq 0x3380
movl $0x0, -0x4(%rbp)
cmpl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
jge 0x1a0d0
movslq -0x4(%rbp), %rcx
leaq 0xac142(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0xac123(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x58(%rax)
movslq -0x4(%rbp), %rax
leaq 0xac106(%rip), %rdi     # 0xc6138
addq $0x8, %rdi
imulq $0xa8, %rax, %rax
addq %rax, %rdi
addq $0x60, %rdi
leaq 0x42dd(%rip), %rsi      # 0x1e328
callq 0x3380
movslq -0x4(%rbp), %rcx
leaq 0xac0dd(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, 0xa4(%rax) # imm = 0xFFFFFFFF
movslq -0x4(%rbp), %rcx
leaq 0xac0ba(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
movslq -0x4(%rbp), %rax
leaq 0xac097(%rip), %rdi     # 0xc6138
addq $0x8, %rdi
imulq $0xa8, %rax, %rax
addq %rax, %rdi
addq $0x80, %rdi
leaq 0x426b(%rip), %rsi      # 0x1e328
callq 0x3380
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x19fde
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: DFS(int)
int DFS(int v)
{
	//若当前节点没有儿子节点 
	if(tree.node[v].childNum==0) 
	{
		if(tree.node[v].isT)  //当前节点是终结符，则没有找到 
		    return -1;
		else
		    return v; 
	}
	else //非终结符，有儿子节点 
	{
		for(int i=0;i<tree.node[v].childNum;i++)
		{
			int te=DFS(tree.node[v].child[i]);
			if(te!=-1)
				return te;
		} 
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xac042(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x1a139
movslq -0x8(%rbp), %rcx
leaq 0xac024(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x58(%rax)
je 0x1a131
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a1ad
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a1ad
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0xabfea(%rip), %rcx     # 0xc6138
addq $0x8, %rcx
imulq $0xa8, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0x1a1a4
movslq -0x8(%rbp), %rcx
leaq 0xabfcd(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %edi
callq 0x1a0e0
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x1a197
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a1ad
jmp 0x1a199
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a140
jmp 0x1a1a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: getVnVtString[abi:cxx11](int)
string getVnVtString(int a)
{
	for(int i=0;i<VNnum;i++)
		if(vn[i].value==a)
			return vn[i].name;
	for(int i=0;i<VTnum;i++)
		if(vt[i].value==a)
			return vt[i].name;
     return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x27, -0x10(%rbp)
jge 0x1a22e
movslq -0x10(%rbp), %rcx
leaq 0x2461fe(%rip), %rax    # 0x2603f0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1a221
movq -0x38(%rbp), %rdi
movslq -0x10(%rbp), %rax
leaq 0x2461e0(%rip), %rsi    # 0x2603f0
imulq $0x28, %rax, %rax
addq %rax, %rsi
callq 0x30e0
jmp 0x1a2c4
jmp 0x1a223
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a1e1
movl $0x0, -0x14(%rbp)
cmpl $0x29, -0x14(%rbp)
jge 0x1a27f
movslq -0x14(%rbp), %rcx
leaq 0x2467ca(%rip), %rax    # 0x260a10
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1a272
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0x2467ac(%rip), %rsi    # 0x260a10
imulq $0x28, %rax, %rax
addq %rax, %rsi
callq 0x30e0
jmp 0x1a2c4
jmp 0x1a274
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a235
leaq -0x15(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3460
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x408d(%rip), %rsi      # 0x1e328
callq 0x8750
jmp 0x1a2a2
leaq -0x15(%rbp), %rdi
callq 0x32d0
jmp 0x1a2c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x32d0
jmp 0x1a2ce
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: findTthId(int)
int findTthId(int t)
{
	int countTemp=0;
	for(int i=1;i<=token_count;i++)
	   if(token[i].type==101) //id
	   {
	   	    if(countTemp==t)
	   	       return i;
	   	    else
	   	       countTemp++;
	   }
	return -1; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0xecc1(%rip), %rcx      # 0x28fc0
cmpl (%rcx), %eax
jg 0x1a342
movslq -0x10(%rbp), %rcx
leaq 0xecd2(%rip), %rax      # 0x28fe0
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpl $0x65, (%rax)
jne 0x1a335
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x1a32a
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a349
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a335
jmp 0x1a337
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a2f5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: findTthNum(int)
int findTthNum(int t)
{
	int countTemp=0;
	for(int i=1;i<=token_count;i++)
	   if(token[i].type==119)   //num
	   {
	   	    if(countTemp==t)
	   	       return i;
	   	    else
	   	       countTemp++;
	   }
	return -1;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0xec51(%rip), %rcx      # 0x28fc0
cmpl (%rcx), %eax
jg 0x1a3b2
movslq -0x10(%rbp), %rcx
leaq 0xec62(%rip), %rax      # 0x28fe0
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpl $0x77, (%rax)
jne 0x1a3a5
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x1a39a
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a3b9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a3a5
jmp 0x1a3a7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a365
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: findTthOp(int)
int findTthOp(int t)
{
	int countTemp=0;
	for(int i=1;i<=token_count;i++)
	   if(token[i].type==131 || token[i].type==133)   //mulop relop 
	   {
	   	    if(countTemp==t)
	   	       return i;
	   	    else
	   	       countTemp++;
	   }
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0xebe1(%rip), %rcx      # 0x28fc0
cmpl (%rcx), %eax
jg 0x1a43f
movslq -0x10(%rbp), %rcx
leaq 0xebf2(%rip), %rax      # 0x28fe0
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpl $0x83, (%rax)
je 0x1a417
movslq -0x10(%rbp), %rcx
leaq 0xebd8(%rip), %rax      # 0x28fe0
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpl $0x85, (%rax)
jne 0x1a432
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x1a427
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a446
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a432
jmp 0x1a434
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a3d5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: e_belongstoF(int)
bool e_belongstoF(int num)             //判断编号为num的生成式右部字符串的FIRST集中是否含有ε
{
	int i,flag=1;                      //为1表示不含 ε
	for(i=0;g[num].FIRST[i]!=-1&&i<FIRSTnum;i++)
	{
		if(g[num].FIRST[i]==106)
			flag=0;
	}
	if(flag==1)//不含ε
		return false;
	else
		return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0x8(%rbp), %rax
leaq 0xa5fd0(%rip), %rcx     # 0xc0940
imulq $0xd0, %rax, %rax
addq %rax, %rcx
movslq -0xc(%rbp), %rdx
xorl %eax, %eax
cmpl $-0x1, 0x30(%rcx,%rdx,4)
movb %al, -0x11(%rbp)
je 0x1a994
cmpl $0x14, -0xc(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1a99d
jmp 0x1a9d1
movslq -0x8(%rbp), %rcx
leaq 0xa5f98(%rip), %rax     # 0xc0940
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
cmpl $0x6a, 0x30(%rax,%rcx,4)
jne 0x1a9c4
movl $0x0, -0x10(%rbp)
jmp 0x1a9c6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a965
cmpl $0x1, -0x10(%rbp)
jne 0x1a9dd
movb $0x0, -0x1(%rbp)
jmp 0x1a9e1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/app/genipaessentials/genipaessentials.cpp
// Function: getDualRailName(int)
int getDualRailName(int lit) {
	if (lit == 0) {
		return 0;
	}
	if (lit > 0) {
		return 2*lit;
	} else {
		return 2*(-lit) - 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1356
movl $0x0, -0x4(%rbp)
jmp 0x1373
cmpl $0x0, -0x8(%rbp)
jle 0x1366
movl -0x8(%rbp), %eax
shll %eax
movl %eax, -0x4(%rbp)
jmp 0x1373
xorl %eax, %eax
subl -0x8(%rbp), %eax
shll %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/app/genipaessentials/genipaessentials.cpp
// Function: learnCb(void*, int*)
void learnCb(void* state, int* clause) {
	if (clause[0] == 0) ;
	else if (clause[1] == 0) lunits++;
	else if (clause[2] == 0) lbins++;
	else if (clause[3] == 0) lterns++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1557
jmp 0x15ac
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1572
movl 0x20bdd(%rip), %eax     # 0x22144
addl $0x1, %eax
movl %eax, 0x20bd4(%rip)     # 0x22144
jmp 0x15aa
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x158d
movl 0x20bc6(%rip), %eax     # 0x22148
addl $0x1, %eax
movl %eax, 0x20bbd(%rip)     # 0x22148
jmp 0x15a8
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x15a6
movl 0x20baf(%rip), %eax     # 0x2214c
addl $0x1, %eax
movl %eax, 0x20ba6(%rip)     # 0x2214c
jmp 0x15a8
jmp 0x15aa
jmp 0x15ac
popq %rbp
retq
nop
// File: kaityo256[P]lj_simd/force_soa.cpp
// Function: SoADataManager::print_results(int)
void
    print_results(int particle_number) {
      for (int i = 0; i < 5; i++) {
        printf("%.10f %.10f %.10f\n", p[X][i], p[Y][i], p[Z][i]);
      }
      for (int i = particle_number - 5; i < particle_number; i++) {
        printf("%.10f %.10f %.10f\n", p[X][i], p[Y][i], p[Z][i]);
      }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x5, 0x18(%rsp)
jge 0x6708
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x18(%rsp), %rdx
vmovsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rcx
movslq 0x18(%rsp), %rdx
vmovsd 0x30d400(%rcx,%rdx,8), %xmm1
movq 0x8(%rax), %rax
movslq 0x18(%rsp), %rcx
vmovsd 0x61a800(%rax,%rcx,8), %xmm2
leaq 0x1982(%rip), %rdi      # 0x8076
movb $0x3, %al
callq 0x2030
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x66af
movl 0x1c(%rsp), %eax
subl $0x5, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x676f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x14(%rsp), %rdx
vmovsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rcx
movslq 0x14(%rsp), %rdx
vmovsd 0x30d400(%rcx,%rdx,8), %xmm1
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
vmovsd 0x61a800(%rax,%rcx,8), %xmm2
leaq 0x191b(%rip), %rdi      # 0x8076
movb $0x3, %al
callq 0x2030
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6713
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: kaityo256[P]lj_simd/force_soa.cpp
// Function: SoADataManager::add_particle(double, double, double, int&)
void
    add_particle(double x, double y, double z, int &particle_number) {
      static std::mt19937 mt(2);
      std::uniform_real_distribution<double> ud(0.0, 0.1);
      q[X][particle_number] = x + ud(mt);
      q[Y][particle_number] = y + ud(mt);
      q[Z][particle_number] = z + ud(mt);
      particle_number++;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
vmovsd %xmm0, 0x58(%rsp)
vmovsd %xmm1, 0x50(%rsp)
vmovsd %xmm2, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpb $0x0, 0xa7dd7b7(%rip)   # 0xa7e40a8
jne 0x6923
leaq 0xa7dd7ae(%rip), %rdi   # 0xa7e40a8
callq 0x2170
cmpl $0x0, %eax
je 0x6923
leaq 0xa7dc415(%rip), %rdi   # 0xa7e2d20
movl $0x2, %esi
callq 0x6b00
jmp 0x6917
leaq 0xa7dd78a(%rip), %rdi   # 0xa7e40a8
callq 0x2080
leaq 0x20(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
vmovsd 0x1724(%rip), %xmm1     # 0x8058
callq 0x6b30
vmovsd 0x58(%rsp), %xmm0
vmovsd %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xa7dc3d0(%rip), %rsi   # 0xa7e2d20
callq 0x6b60
movq 0x18(%rsp), %rax
vmovaps %xmm0, %xmm1
vmovsd (%rsp), %xmm0
vaddsd %xmm1, %xmm0, %xmm0
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq (%rcx), %rcx
vmovsd %xmm0, (%rax,%rcx,8)
vmovsd 0x50(%rsp), %xmm0
vmovsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xa7dc390(%rip), %rsi   # 0xa7e2d20
callq 0x6b60
movq 0x18(%rsp), %rax
vmovaps %xmm0, %xmm1
vmovsd 0x8(%rsp), %xmm0
vaddsd %xmm1, %xmm0, %xmm0
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq (%rcx), %rcx
vmovsd %xmm0, 0x30d400(%rax,%rcx,8)
vmovsd 0x48(%rsp), %xmm0
vmovsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xa7dc34b(%rip), %rsi   # 0xa7e2d20
callq 0x6b60
movq 0x18(%rsp), %rax
vmovaps %xmm0, %xmm1
vmovsd 0x10(%rsp), %xmm0
vaddsd %xmm1, %xmm0, %xmm0
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq (%rcx), %rcx
vmovsd %xmm0, 0x61a800(%rax,%rcx,8)
movq 0x40(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0xa7dd680(%rip), %rdi   # 0xa7e40a8
callq 0x2070
movq 0x38(%rsp), %rdi
callq 0x2160
nopw (%rax,%rax)
// File: kaityo256[P]lj_simd/force_soa.cpp
// Function: SoADataManager::calc_distance(int, int)
double
    calc_distance(int i, int j) {
      const double dx = q[X][i] - q[X][j];
      const double dy = q[Y][i] - q[Y][j];
      const double dz = q[Z][i] - q[Z][j];
      return dx * dx + dy * dy + dz * dz;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
vmovsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0x10(%rsp), %rdx
vsubsd (%rcx,%rdx,8), %xmm0, %xmm0
vmovsd %xmm0, -0x18(%rsp)
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
vmovsd 0x30d400(%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0x10(%rsp), %rdx
vsubsd 0x30d400(%rcx,%rdx,8), %xmm0, %xmm0
vmovsd %xmm0, -0x20(%rsp)
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
vmovsd 0x61a800(%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rax
movslq -0x10(%rsp), %rcx
vsubsd 0x61a800(%rax,%rcx,8), %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rsp)
vmovsd -0x18(%rsp), %xmm0
vmovsd -0x18(%rsp), %xmm2
vmovsd -0x20(%rsp), %xmm1
vmulsd -0x20(%rsp), %xmm1, %xmm1
vfmadd213sd %xmm1, %xmm0, %xmm2 # xmm2 = (xmm0 * xmm2) + xmm1
vmovsd -0x28(%rsp), %xmm1
vmovsd -0x28(%rsp), %xmm0
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/dbl_ptr.cc
// Function: main
int main()
{
    int ival = 1024;
    int *pi = &ival;   // pi points to an int
    int **ppi = &pi;   // ppi points to a pointer to an int
    cout << "The value of ival\n"
         << "direct value: " << ival << "\n"
         << "indirect value: " << *pi << "\n"
         << "doubly indirect value: " << **ppi
         << endl;

	int i = 2; 
	int *p1 = &i;     // p1 points to i
	*p1 = *p1 * *p1;  // equivalent to i = i * i
	cout << "i  = " << i << endl;

	*p1 *= *p1;       // equivalent to i *= i
	cout << "i  = " << i << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x400, -0x8(%rbp)      # imm = 0x400
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2deb(%rip), %rdi      # 0x3fd8
leaq 0xe10(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
leaq 0xe1d(%rip), %rsi       # 0x2020
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xdf8(%rip), %rsi       # 0x2015
callq 0x1040
movq %rax, %rdi
leaq 0xdf2(%rip), %rsi       # 0x201e
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xdcc(%rip), %rsi       # 0x2015
callq 0x1040
movq %rax, %rdi
leaq 0xdbf(%rip), %rsi       # 0x2017
callq 0x1040
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d50(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x2, -0x1c(%rbp)
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
imull (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq 0x2d32(%rip), %rdi      # 0x3fd8
leaq 0xd82(%rip), %rsi       # 0x202f
callq 0x1040
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d01(%rip), %rsi      # 0x3fc8
callq 0x1050
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
movq 0x2cf6(%rip), %rdi      # 0x3fd8
leaq 0xd46(%rip), %rsi       # 0x202f
callq 0x1040
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2cc5(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::Point(std::vector<double, std::allocator<double>>)
Point::Point(vector<double> new_pos) {
  pos = new_pos;
  dimension = new_pos.size();
  num_neighbors = 0;
  kth_neighbor_distance = 0;
  // ave_k_neighbor_distance = 0;
  ave_reachability_distance = 0;
  lof_val = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x3cd0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3cf0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3d10
jmp 0x3778
movq -0x28(%rbp), %rdi
callq 0x3f60
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, 0x50(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3f80
movq -0x30(%rbp), %rdi
callq 0x3fa0
movq -0x18(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::insertNeighbor(Point*)
void Point::insertNeighbor(Point* neighbor_point) {
  double new_dist = distance(this, neighbor_point);
  PointDistancePair new_pair(neighbor_point, new_dist);
  neighbors.insert(new_pair);
  num_neighbors++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x3850
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x4000
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x4030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movb %dl, -0x30(%rbp)
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::distance(Point const*, Point const*) const
double Point::distance(const Point* p1, const Point* p2) const {
  int d = p1->dimension;
  double sum = 0;
  for (int i = 0; i < d; i++) {
    sum += pow((p1->pos[i] - p2->pos[i]), 2);
  }
  return sqrt(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x38d0
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x4270
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x4270
movsd -0x38(%rbp), %xmm0
subsd (%rax), %xmm0
movl $0x2, %edi
callq 0x4240
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x387d
movsd -0x28(%rbp), %xmm0
callq 0x3210
addq $0x40, %rsp
popq %rbp
retq
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::addNewNeighbor(Point*)
void Point::addNewNeighbor(Point* new_point) {
  double new_dist = distance(this, new_point);
  PointDistancePair new_pair(new_point, new_dist);
  neighbors.insert(new_pair);
  num_neighbors++;

  // If the new point is within k nearest neighbor of it, then the kth_neighbor_distance needs to be updated
  if (new_dist <= kth_neighbor_distance) {
    updateStats();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x3850
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x4000
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x4030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movb %dl, -0x30(%rbp)
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
movsd -0x18(%rbp), %xmm1
movsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x395c
movq -0x40(%rbp), %rdi
callq 0x3970
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::updateStats()
void Point::updateStats() {
  if (num_neighbors >= k) {
    kth_neighbor_distance = calcKthNeighborDistance(); 
    // ave_k_neighbor_distance = calcAveKDistance();
    ave_reachability_distance = calcAveReachabilityDistance();
    lof_val = calcLof();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x50(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jl 0x39ba
movq -0x10(%rbp), %rdi
callq 0x3a60
movq -0x10(%rbp), %rdi
movsd %xmm0, 0x58(%rdi)
callq 0x3ab0
movq -0x10(%rbp), %rdi
movsd %xmm0, 0x60(%rdi)
callq 0x3b50
movq -0x10(%rbp), %rax
movsd %xmm0, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::removeNeighbor(Point*)
void Point::removeNeighbor(Point* remove_point) {
  double dist = distance(this, remove_point);
  PointDistancePair temp_pair(remove_point, dist);
  neighbors.erase(neighbors.find(temp_pair));
  num_neighbors--;
  
  // If the removed point is within k nearest neighbors of it, update stats field
  if (dist <= kth_neighbor_distance) {
    updateStats();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x3850
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x4000
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x40c0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x4080
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movl 0x50(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x50(%rax)
movsd -0x18(%rbp), %xmm1
movsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x3a55
movq -0x40(%rbp), %rdi
callq 0x3970
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::calcAveReachabilityDistance() const
double Point::calcAveReachabilityDistance() const {
  double sum = 0;
  auto it = neighbors.begin();
  int counter = 0;
  while (it->dist <= kth_neighbor_distance) {
    sum += calcReachabilityDistance(this, it->p);
    it++;
    counter++;
  }
  return sum / counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
addq $0x20, %rdi
callq 0x4100
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4180
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd 0x8(%rcx), %xmm1
movsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x3b3c
leaq -0x18(%rbp), %rdi
callq 0x4180
movq -0x30(%rbp), %rsi
movq (%rax), %rdx
movq %rsi, %rdi
callq 0x3c00
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x41a0
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ae0
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: ChristalC[P]Online-Outlier-Detection/point.cpp
// Function: Point::calcLof() const
double Point::calcLof() const {
  double dist;
  double sum = 0;
  int counter = 0;
  auto it = neighbors.begin();
  while (it->dist <= kth_neighbor_distance) {
    sum += ave_reachability_distance / it->p->ave_reachability_distance;
    it++;
    counter++;
  }
  return sum / counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
addq $0x20, %rdi
callq 0x4100
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4180
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd 0x8(%rcx), %xmm1
movsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x3be8
movq -0x38(%rbp), %rax
movsd 0x60(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4180
movsd -0x40(%rbp), %xmm0
movq (%rax), %rax
divsd 0x60(%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x41a0
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b80
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChristalC[P]Online-Outlier-Detection/./point.h
// Function: Point::PointDistancePair::operator<(Point::PointDistancePair const&) const
bool operator<(const PointDistancePair& right) const {
        if (dist < right.dist) {
          return true;
        }
        else if (dist == right.dist) {
          return p < right.p;
        }
        return false;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x592e
movb $0x1, -0x1(%rbp)
jmp 0x5962
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x595c
jp 0x595c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5962
jmp 0x595e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: ChristalC[P]Online-Outlier-Detection/lof.cpp
// Function: Lof::Lof(int)
Lof::Lof(int ws) {
  window_size = ws;
  point_count = 0;
  dimension = 0;
  group_size = 0;
  threshold = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x66d0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, (%rax)
movl $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChristalC[P]Online-Outlier-Detection/lof.cpp
// Function: Lof::~Lof()
Lof::~Lof() {
  auto it = all_points.begin();
  while (it != all_points.end()) {
    delete *it;
    it++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
callq 0x66f0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x6750
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6720
testb $0x1, %al
jne 0x5f05
jmp 0x5f43
leaq -0x10(%rbp), %rdi
callq 0x6780
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5f32
movq -0x30(%rbp), %rdi
callq 0x67a0
movq -0x30(%rbp), %rdi
movl $0x70, %esi
callq 0x32a0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x67d0
movq %rax, -0x20(%rbp)
jmp 0x5ee1
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x6800
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChristalC[P]Online-Outlier-Detection/lof.cpp
// Function: Lof::removeFrontPoint()
void Lof::removeFrontPoint() {
  Point* front_point = all_points.front();
  for (auto it = next(all_points.begin()); it != all_points.end(); it++) {
    (*it)->removeNeighbor(front_point);
  }
  delete front_point;
  all_points.pop_front();
  point_count--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x6a10
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0x66f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x6a40
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x6750
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6720
testb $0x1, %al
jne 0x62eb
jmp 0x6311
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x39c0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x67d0
movq %rax, -0x30(%rbp)
jmp 0x62c7
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x6336
movq -0x40(%rbp), %rdi
callq 0x67a0
movq -0x40(%rbp), %rdi
movl $0x70, %esi
callq 0x32a0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x6a70
movq -0x38(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChristalC[P]Online-Outlier-Detection/lof.cpp
// Function: Lof::decideGroupSize()
int Lof::decideGroupSize() {
  Point* p = all_points.back();
  double max_lof = 0;
  double lof = 0;
  int max_lof_k = 0;
  int test_k = 2;
  int group_num = 2;
  while (group_num <= 10) {
    test_k = window_size / group_num;
    changeGroupSize(test_k);
    lof = p->calcLof();
    if (lof > max_lof) {
      max_lof = lof;
      max_lof_k = test_k;
    }
    // cout << "test_k = " << test_k << ", lof = " << lof <<endl;
    group_num++;
  }
  // cout << "best k = " << max_lof_k << endl;
  return max_lof_k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x6b20
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x2, -0x28(%rbp)
movl $0x2, -0x2c(%rbp)
cmpl $0xa, -0x2c(%rbp)
jg 0x63fa
movq -0x38(%rbp), %rdi
movl 0x4(%rdi), %eax
cltd
idivl -0x2c(%rbp)
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0x6410
movq -0x10(%rbp), %rdi
callq 0x3b50
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x63ef
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x63a9
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChristalC[P]Online-Outlier-Detection/lof.cpp
// Function: Lof::changeGroupSize(int)
void Lof::changeGroupSize(int k_val) {
  group_size = k_val;
  
  // In the first iteration, update fields k, kth_neighbor_distance and ave_k_neighbor_distance of all existing points
  auto it = all_points.begin();
  while (it != all_points.end()) {
    (*it)->setK(k_val);
    (*it)->setKthNeighborDistance((*it)->calcKthNeighborDistance());
    // (*it)->setAveKNeighborDistance((*it)->calcAveKDistance());
    it++;
  }
  
  // In the second iteration, update ave_reachability_distance field of all points
  it = all_points.begin();
  while (it != all_points.end()) {
    double ar = (*it)->calcAveReachabilityDistance();
    (*it)->setAveReachabilityDistance((*it)->calcAveReachabilityDistance());
    (*it)->setLofVal((*it)->calcLof());
    it++;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
addq $0x18, %rdi
callq 0x66f0
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x6750
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6720
testb $0x1, %al
jne 0x645e
jmp 0x64ad
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x6aa0
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rdi
callq 0x3a60
movq -0x58(%rbp), %rdi
callq 0x6ac0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x67d0
movq %rax, -0x28(%rbp)
jmp 0x643a
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x66f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x6750
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6720
testb $0x1, %al
jne 0x64ea
jmp 0x6568
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rdi
callq 0x3ab0
movsd %xmm0, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rdi
callq 0x3ab0
movq -0x68(%rbp), %rdi
callq 0x6ae0
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6780
movq (%rax), %rdi
callq 0x3b50
movq -0x60(%rbp), %rdi
callq 0x6b00
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x67d0
movq %rax, -0x48(%rbp)
jmp 0x64c6
addq $0x70, %rsp
popq %rbp
retq
nop
// File: ChristalC[P]Online-Outlier-Detection/lof.cpp
// Function: Lof::decideThreshold()
double Lof::decideThreshold() {
  // Collect all lof_vals in a vector lof_vals, sort the vector and find the median
  vector<double> lof_vals;
  auto it = all_points.begin();
  while (*it != all_points.back()) {
    lof_vals.push_back((*it)->getLofVal());
    it++;
  }
  sort(lof_vals.begin(), lof_vals.end());
  
  double t = lof_vals[window_size * 0.9];
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3cd0
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
callq 0x66f0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6780
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
addq $0x18, %rdi
callq 0x6b20
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq (%rcx), %rax
je 0x6626
leaq -0x28(%rbp), %rdi
callq 0x6780
movq (%rax), %rdi
callq 0x69b0
movsd %xmm0, -0x78(%rbp)
jmp 0x65e2
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6b60
jmp 0x65fb
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x67d0
movq %rax, -0x48(%rbp)
jmp 0x65a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3fa0
jmp 0x66c7
leaq -0x20(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4c20
movq -0x80(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x4c50
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x6b90
jmp 0x6653
movq -0x68(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm0
movsd 0x69a4(%rip), %xmm1     # 0xd008
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
movsd 0x6991(%rip), %xmm1     # 0xd010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x41e0
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3fa0
movsd -0x88(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3450
// File: ChristalC[P]Online-Outlier-Detection/p2_helper.cpp
// Function: splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> splitString(string ip) {
  // Find the '#' and get rid of anything after, including '#'
  size_t pos;
  pos = ip.find("#");
  if (pos != string::npos) {
    ip = ip.substr(0, pos);
  }

  // Split the string by white spaces
  string buf;
  stringstream ss(ip);

  vector<string> tokens;

  while (ss >> buf) {
    tokens.push_back(buf);
  }
  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rsi, -0x208(%rbp)
movq %rdi, %rax
movq -0x208(%rbp), %rdi
movq %rax, -0x200(%rbp)
movq %rax, %rcx
movq %rcx, -0x1f8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x424f(%rip), %rsi      # 0xd07b
xorl %eax, %eax
movl %eax, %edx
callq 0x34b0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x8e71
movq -0x208(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x32b0
movq -0x208(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3310
leaq -0x38(%rbp), %rdi
callq 0x31a0
leaq -0x58(%rbp), %rdi
callq 0x3370
movl $0x10, %edi
movl $0x8, %esi
callq 0x98c0
movl %eax, -0x20c(%rbp)
jmp 0x8e91
movl -0x20c(%rbp), %edx
movq -0x208(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x33f0
jmp 0x8eac
movq -0x200(%rbp), %rdi
movb $0x0, -0x1ed(%rbp)
callq 0x98e0
leaq -0x1e0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3340
movq %rax, -0x218(%rbp)
jmp 0x8ed8
movq -0x218(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3330
movb %al, -0x219(%rbp)
jmp 0x8ef6
movb -0x219(%rbp), %al
testb $0x1, %al
jne 0x8f02
jmp 0x8f56
movq -0x200(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9900
jmp 0x8f14
jmp 0x8ebf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
jmp 0x8f97
movq -0x200(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
callq 0x9970
leaq -0x1e0(%rbp), %rdi
callq 0x31d0
jmp 0x8f97
movb $0x1, -0x1ed(%rbp)
testb $0x1, -0x1ed(%rbp)
jne 0x8f72
movq -0x200(%rbp), %rdi
callq 0x9970
leaq -0x1e0(%rbp), %rdi
callq 0x31d0
leaq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x1f8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x1e8(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: ChristalC[P]Online-Outlier-Detection/p2_helper.cpp
// Function: displayPos(std::vector<double, std::allocator<double>>)
void displayPos(vector<double> pos) {
  int n = pos.size();
  for (int i = 0; i < n; i++) {
    cout << pos[i] << ", ";
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x3f60
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x989e
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x41e0
movsd (%rax), %xmm0
movq 0xa749(%rip), %rdi      # 0x13fc8
callq 0x3490
movq %rax, %rdi
leaq 0x3776(%rip), %rsi      # 0xd004
callq 0x3280
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x985f
movq 0xa723(%rip), %rdi      # 0x13fc8
movq 0xa704(%rip), %rsi      # 0x13fb0
callq 0x32d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ChristalC[P]Online-Outlier-Detection/thread_org.cpp
// Function: thread_org_func(int, char const*, char const*)
void thread_org_func(int ws, const char* h, const char* p) {
  // Initialize the mutex before trying to use it
  pthread_mutex_init(&lock, NULL);
  pthread_cond_init(&has_new, NULL);

  // Push host and port to the arguments of socket_thread
  Socket_arg sa;
  sa.h = h;
  sa.p = p;

  // Initialize socket_thread
  pthread_t socket_thread;
  int socket_thread_res = pthread_create(&socket_thread, NULL, socket_thread_func, &sa);
  if (socket_thread_res != 0) {
    cout << "Socket_thread creation failed!" << endl;
    exit(1);
  }

  // Initialize lof_thread
  pthread_t lof_thread;
  int lof_thread_res = pthread_create(&lof_thread, NULL, lof_thread_func, &ws);
  if (lof_thread_res != 0) {
    cout << "lof_thread creation failed!" << endl;
    exit(1);
  }

  int socket_thread_end_res = pthread_join(socket_thread, NULL);
  int lof_thread_end_res = pthread_join(lof_thread, NULL);
  if (socket_thread_end_res != 0) {
    cout << "socket_thread_end failed!" << endl;
    exit(1);
  }
  if (lof_thread_end_res != 0) {
    cout << "lof_thread_end failed!" << endl;
    exit(1);
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x93fe(%rip), %rdi      # 0x142b8
xorl %eax, %eax
movl %eax, %esi
callq 0x33c0
leaq 0x93be(%rip), %rdi      # 0x14288
xorl %eax, %eax
movl %eax, %esi
callq 0x32f0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x11e(%rip), %rdx       # 0xb010
leaq -0x28(%rbp), %rcx
callq 0x3470
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xaf30
movq 0x90bd(%rip), %rdi      # 0x13fc8
leaq 0x2226(%rip), %rsi      # 0xd138
callq 0x3280
movq %rax, %rdi
movq 0x908f(%rip), %rsi      # 0x13fb0
callq 0x32d0
movl $0x1, %edi
callq 0x3300
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x711(%rip), %rdx       # 0xb650
leaq -0x4(%rbp), %rcx
callq 0x3470
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xaf7d
movq 0x9070(%rip), %rdi      # 0x13fc8
leaq 0x21f8(%rip), %rsi      # 0xd157
callq 0x3280
movq %rax, %rdi
movq 0x9042(%rip), %rsi      # 0x13fb0
callq 0x32d0
movl $0x1, %edi
callq 0x3300
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3250
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3250
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xafcf
movq 0x901e(%rip), %rdi      # 0x13fc8
leaq 0x21c2(%rip), %rsi      # 0xd173
callq 0x3280
movq %rax, %rdi
movq 0x8ff0(%rip), %rsi      # 0x13fb0
callq 0x32d0
movl $0x1, %edi
callq 0x3300
cmpl $0x0, -0x4c(%rbp)
je 0xb001
movq 0x8fec(%rip), %rdi      # 0x13fc8
leaq 0x21aa(%rip), %rsi      # 0xd18d
callq 0x3280
movq %rax, %rdi
movq 0x8fbe(%rip), %rsi      # 0x13fb0
callq 0x32d0
movl $0x1, %edi
callq 0x3300
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)