LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: BBRL(int, int)
void BBRL(int sw,int RN)
{
	//unconditional register branch
	assert(RN>= 0 && RN <= 31);
	uint64_t target = R[RN].getData();
	NIO = R[RN].getData() - PC.getData();
	if(sw == 0)
	{
		printf(" [log]-unconditional branch(register)\n");

		PC.setData(target);
	}
	else
	{
 		printf("[log]-unconditional call(register)\n");
		//first save the address of next instruction
		R[30].setData(PC.getData());
		subroutine++;
		PC.setData(target);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
jl 0x1423
cmpl $0x1f, -0x8(%rbp)
setle %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x142c
jmp 0x142e
jmp 0x144d
leaq 0x9c07(%rip), %rdi      # 0xb03c
leaq 0x9c13(%rip), %rsi      # 0xb04f
movl $0x1a, %edx
leaq 0x9c1a(%rip), %rcx      # 0xb062
callq 0x1060
movslq -0x8(%rbp), %rax
leaq 0xcc88(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq %rax, -0x10(%rbp)
movslq -0x8(%rbp), %rax
leaq 0xcc6d(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq %rax, -0x20(%rbp)
leaq 0x1cd5e(%rip), %rdi     # 0x1e1e8
callq 0xa6c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movl %eax, 0x1cd59(%rip)     # 0x1e1f8
cmpl $0x0, -0x4(%rbp)
jne 0x14c5
leaq 0x9bca(%rip), %rdi      # 0xb076
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rsi
leaq 0x1cd2a(%rip), %rdi     # 0x1e1e8
callq 0xa710
jmp 0x1514
leaq 0x9bd1(%rip), %rdi      # 0xb09d
movb $0x0, %al
callq 0x1030
leaq 0x1cd0e(%rip), %rdi     # 0x1e1e8
callq 0xa6c0
movq %rax, %rsi
leaq 0xcbf7(%rip), %rdi      # 0xe0e0
addq $0xf0, %rdi
callq 0xa710
movl 0x21d05(%rip), %eax     # 0x23200
addl $0x1, %eax
movl %eax, 0x21cfc(%rip)     # 0x23200
movq -0x10(%rbp), %rsi
leaq 0x1ccd9(%rip), %rdi     # 0x1e1e8
callq 0xa710
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: BBL(int, unsigned long)
void BBL(int sw,uint64_t offset)
{

	NIO = offset - PC.getData();		
	//unconditional immediate branch
	if(sw == 0)
	{
		printf(" [log]-unconditional branch(immediate)\n");
		PC.setData(offset);
	}
	else
	{
		printf("[log]-unconditional call(immediate)\n");
		subroutine++;
		R[30].setData(PC.getData());
		PC.setData(offset); 
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1ccaa(%rip), %rdi     # 0x1e1e8
callq 0xa6c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movl %eax, 0x1cca5(%rip)     # 0x1e1f8
cmpl $0x0, -0x4(%rbp)
jne 0x1579
leaq 0x9b61(%rip), %rdi      # 0xb0c1
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rsi
leaq 0x1cc76(%rip), %rdi     # 0x1e1e8
callq 0xa710
jmp 0x15c8
leaq 0x9b69(%rip), %rdi      # 0xb0e9
movb $0x0, %al
callq 0x1030
movl 0x21c73(%rip), %eax     # 0x23200
addl $0x1, %eax
movl %eax, 0x21c6a(%rip)     # 0x23200
leaq 0x1cc4b(%rip), %rdi     # 0x1e1e8
callq 0xa6c0
movq %rax, %rsi
leaq 0xcb34(%rip), %rdi      # 0xe0e0
addq $0xf0, %rdi
callq 0xa710
movq -0x10(%rbp), %rsi
leaq 0x1cc25(%rip), %rdi     # 0x1e1e8
callq 0xa710
addq $0x20, %rsp
popq %rbp
retq
nop
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: BCOND(unsigned long, int)
void BCOND(uint64_t offset,int condition)
{

	int cond = (condition&0x0000000e)>>1;
	bool result;
	switch(cond)
	{
		case 0:
			result = ZFLAG;
			break;
		case 1:
			result = CFLAG;
			break;
		case 2:
			result = NFLAG;
			break;
		case 3:
			result = OFLAG;
			break;
		case 4:
			result = CFLAG && !ZFLAG;
			break;
		case 5:
			result = NFLAG == OFLAG;
			break;
		case 6:
			result = (NFLAG== OFLAG)&& !ZFLAG ;
			break;
		case 7:
			result = true;
			break;


	}

	if((condition &0x01) && condition != 15)
		result = !result;

	if(result)
		BBL(0,offset);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xe, %eax
shrl %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x16ca
movq -0x20(%rbp), %rax
leaq 0x99fe(%rip), %rcx      # 0xb004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0xcabc(%rip), %al       # 0xe0d1
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16ca
movb 0xcaaf(%rip), %al       # 0xe0d4
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16ca
movb 0xca9e(%rip), %al       # 0xe0d3
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16ca
movb 0xca8d(%rip), %al       # 0xe0d2
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16ca
xorl %eax, %eax
testb $0x1, 0xca7f(%rip)      # 0xe0d4
movb %al, -0x21(%rbp)
je 0x1665
movb 0xca71(%rip), %al       # 0xe0d1
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16ca
movb 0xca5e(%rip), %al       # 0xe0d3
andb $0x1, %al
movzbl %al, %eax
movb 0xca52(%rip), %cl       # 0xe0d2
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16ca
movb 0xca3b(%rip), %al       # 0xe0d3
andb $0x1, %al
movzbl %al, %ecx
movb 0xca2f(%rip), %al       # 0xe0d2
andb $0x1, %al
movzbl %al, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x22(%rbp)
jne 0x16bc
movb 0xca1a(%rip), %al       # 0xe0d1
xorb $-0x1, %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16ca
movb $0x1, -0x11(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16e5
cmpl $0xf, -0xc(%rbp)
je 0x16e5
movb -0x11(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x16f6
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x1520
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: CBZNZ(int, int, int, unsigned long)
void CBZNZ(int sf,int sw,int RT,uint64_t offset)
{
	uint64_t dat;
	if(sf==1)
		dat = R[RT].getData();
	else if (sf == 0)
		dat = R[RT].getLowerData();

	if(sw == 0)
	{
		printf("[log]- CBZ instruction ");
		if(dat == 0)
			BBL(0,offset);
	}
	else if(sw ==1)
	{
		printf("[log]- CBNZ instruction ");
		if(dat != 0)
			BBL(0,offset);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x1738
movslq -0xc(%rbp), %rax
leaq 0xc9ba(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq %rax, -0x20(%rbp)
jmp 0x175d
cmpl $0x0, -0x4(%rbp)
jne 0x175b
movslq -0xc(%rbp), %rax
leaq 0xc997(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6e0
movl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x175d
cmpl $0x0, -0x8(%rbp)
jne 0x1785
leaq 0x99a4(%rip), %rdi      # 0xb10e
movb $0x0, %al
callq 0x1030
cmpq $0x0, -0x20(%rbp)
jne 0x1783
movq -0x18(%rbp), %rsi
xorl %edi, %edi
callq 0x1520
jmp 0x17af
cmpl $0x1, -0x8(%rbp)
jne 0x17ad
leaq 0x9994(%rip), %rdi      # 0xb126
movb $0x0, %al
callq 0x1030
cmpq $0x0, -0x20(%rbp)
je 0x17ab
movq -0x18(%rbp), %rsi
xorl %edi, %edi
callq 0x1520
jmp 0x17ad
jmp 0x17af
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: RET(int)
void RET(int n = 30)
{
	if(skip )
	{
		skip = false;
		return;
	}
	printf("[log] - RET instruction\n");
	assert(n>= 0 && n <= 31);
	NIO = R[n].getData() - PC.getData();
	subroutine--;
	PC.setData(R[n].getData());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
testb $0x1, 0x1ca2b(%rip)     # 0x1e1fd
je 0x17e0
movb $0x0, 0x1ca22(%rip)     # 0x1e1fd
jmp 0x1899
leaq 0x9958(%rip), %rdi      # 0xb13f
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x5(%rbp)
jl 0x1803
cmpl $0x1f, -0x4(%rbp)
setle %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x180c
jmp 0x180e
jmp 0x182d
leaq 0x9943(%rip), %rdi      # 0xb158
leaq 0x9833(%rip), %rsi      # 0xb04f
movl $0x8c, %edx
leaq 0x9941(%rip), %rcx      # 0xb169
callq 0x1060
movslq -0x4(%rbp), %rax
leaq 0xc8a8(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq %rax, -0x10(%rbp)
leaq 0x1c999(%rip), %rdi     # 0x1e1e8
callq 0xa6c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movl %eax, 0x1c994(%rip)     # 0x1e1f8
movl 0x21996(%rip), %eax     # 0x23200
addl $-0x1, %eax
movl %eax, 0x2198d(%rip)     # 0x23200
movslq -0x4(%rbp), %rax
leaq 0xc862(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq %rax, %rsi
leaq 0x1c954(%rip), %rdi     # 0x1e1e8
callq 0xa710
addq $0x10, %rsp
popq %rbp
retq
nop
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: MOV(int, int, int, int)
void MOV(int sf, int _switch,int op1, int op2 )
{
    if(sf)  //64 bit registers
    {
	
        if(_switch == 0) //immediate
        {
            printf("[log] - mov immediate 64 bit\n");
            R[op1].setData(op2);
        }
        
        else    //register
        {
            printf("[log] - mov register 64 bit\n");
            R[op1].setData(R[op2].getData());
        }
    }
    
    else
    {
        if(_switch == 0) //immediate
        {
			printf("[log] - mov immediate 32 bit\n");
            R[op1].setLowerData(op2);
        }
        
        else    //register
        {
			printf("[log] - mov immediate 32 bit\n");
            R[op1].setLowerData(R[op2].getLowerData());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x2414
cmpl $0x0, -0x8(%rbp)
jne 0x23cb
leaq 0x902e(%rip), %rdi      # 0xb3d5
movb $0x0, %al
callq 0x1030
movslq -0xc(%rbp), %rax
leaq 0xbd27(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa710
jmp 0x2412
leaq 0x9021(%rip), %rdi      # 0xb3f3
movb $0x0, %al
callq 0x1030
movslq -0xc(%rbp), %rcx
leaq 0xbcfc(%rip), %rax      # 0xe0e0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movslq -0x10(%rbp), %rax
leaq 0xbce6(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xa710
jmp 0x248c
cmpl $0x0, -0x8(%rbp)
jne 0x2444
leaq 0x8fef(%rip), %rdi      # 0xb410
movb $0x0, %al
callq 0x1030
movslq -0xc(%rbp), %rax
leaq 0xbcad(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0xa730
jmp 0x248a
leaq 0x8fc5(%rip), %rdi      # 0xb410
movb $0x0, %al
callq 0x1030
movslq -0xc(%rbp), %rcx
leaq 0xbc83(%rip), %rax      # 0xe0e0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movslq -0x10(%rbp), %rax
leaq 0xbc6d(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6e0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xa730
jmp 0x248c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: AND(int, int, int, int, int, int, int, int)
void AND(int sf, int sw, int op1, int op2, int op3, int N, int imms, int immr)
{
	//op1 - RD,op2 - RN, op3 - RM
    if(sf)
    {
		if(sw == 0)
		{
		    uint64_t imm = DecodeBitMask( N,  imms, immr, 64);
		    uint64_t dat = R[op2].getData() & imm;
		    R[op1].setData(dat);
		}
		
		else
		{
			uint64_t dat = R[op2].getData() & R[op3].getData();
			R[op1].setData(dat);
		}
    }
    else
    {
        if(sw == 0)
        {
      		uint32_t imm = DecodeBitMask(N, imms, immr, 32);
       	 	uint32_t dat = R[op2].getLowerData() & imm;
       	 	R[op1].setLowerData(dat);
       	 }
       	 else
       	 {
       	 	uint32_t dat = R[op2].getLowerData() & R[op3].getLowerData();
       	 	R[op1].setLowerData(dat);
       	 }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x2585
cmpl $0x0, -0x8(%rbp)
jne 0x2525
movl -0x18(%rbp), %edi
movl 0x10(%rbp), %esi
movl 0x18(%rbp), %edx
movl $0x40, %ecx
callq 0x2640
movq %rax, -0x20(%rbp)
movslq -0x10(%rbp), %rax
leaq 0xbbec(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
andq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rax
leaq 0xbbcd(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0xa710
jmp 0x2580
movslq -0x10(%rbp), %rax
leaq 0xbbb0(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq %rax, -0x48(%rbp)
movslq -0x14(%rbp), %rax
leaq 0xbb95(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rax
leaq 0xbb70(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0xa710
jmp 0x2631
cmpl $0x0, -0x8(%rbp)
jne 0x25da
movl -0x18(%rbp), %edi
movl 0x10(%rbp), %esi
movl 0x18(%rbp), %edx
movl $0x20, %ecx
callq 0x2640
movl %eax, -0x34(%rbp)
movslq -0x10(%rbp), %rax
leaq 0xbb34(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6e0
andl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movslq -0xc(%rbp), %rax
leaq 0xbb17(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
movl -0x38(%rbp), %esi
callq 0xa730
jmp 0x262f
movslq -0x10(%rbp), %rax
leaq 0xbafb(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6e0
movl %eax, -0x4c(%rbp)
movslq -0x14(%rbp), %rax
leaq 0xbae1(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
callq 0xa6e0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
andl %ecx, %eax
movl %eax, -0x3c(%rbp)
movslq -0xc(%rbp), %rax
leaq 0xbac0(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
movl -0x3c(%rbp), %esi
callq 0xa730
jmp 0x2631
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: akshayrajput[P]ARMV8_Simulator/./ADR_ADRP.cpp
// Function: ADR()
void ADR()
{
    int op = (IR.getLowerData() & 0x80000000) >> 31;
    int immlo = (IR.getLowerData() & 0x60000000) >> 29;
    int immhi = (IR.getLowerData() & 0x00ffffe0) >> 5;
    int rd = (IR.getLowerData() & 0x0000001f);
    uint64_t temp = ((uint64_t)immhi << 2) |((uint64_t)immlo);
    uint64_t base = BR.getData();
    bool page = (op == 1);
    uint64_t imm;
    if(page)
    {
        imm = signExtend(temp << 12,32);
        base = base & 0xfffff000;
    }
    
    else
    {
        imm = signExtend(temp,20);
    }
    
    uint64_t dat = base + imm;
    R[rd].setData(dat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x17081(%rip), %rdi     # 0x1e1e0
callq 0xa6e0
andl $0x80000000, %eax       # imm = 0x80000000
shrl $0x1f, %eax
movl %eax, -0x4(%rbp)
leaq 0x1706a(%rip), %rdi     # 0x1e1e0
callq 0xa6e0
andl $0x60000000, %eax       # imm = 0x60000000
shrl $0x1d, %eax
movl %eax, -0x8(%rbp)
leaq 0x17053(%rip), %rdi     # 0x1e1e0
callq 0xa6e0
andl $0xffffe0, %eax         # imm = 0xFFFFE0
shrl $0x5, %eax
movl %eax, -0xc(%rbp)
leaq 0x1703c(%rip), %rdi     # 0x1e1e0
callq 0xa6e0
andl $0x1f, %eax
movl %eax, -0x10(%rbp)
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
movslq -0x8(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq 0x17027(%rip), %rdi     # 0x1e1f0
callq 0xa6c0
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x4(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x720e
movq -0x18(%rbp), %rdi
shlq $0xc, %rdi
movl $0x20, %esi
callq 0x1350
movq %rax, -0x30(%rbp)
movabsq $0xfffff000, %rax       # imm = 0xFFFFF000
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x7220
movq -0x18(%rbp), %rdi
movl $0x14, %esi
callq 0x1350
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x10(%rbp), %rax
leaq 0x6ea9(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0xa710
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: akshayrajput[P]ARMV8_Simulator/simulo.cpp
// Function: initMem(unsigned long)
void initMem(uint64_t start)
{
	REP(i,0,4095)
	{
		Memory[i].data = 0;
		Memory[i].access = false;
		Memory[i].addr = start;
		start+= 1 ;//each location is of size 64 bits - 8 bytes
		breakpt[i] = false;
		SR[i] = false;
	}

	REP(i,0,31)
	{
		R[i].setData(0);

	}
	NIO = 4;
	ZFLAG =NFLAG= OFLAG = CFLAG = false;
	subroutine = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xfff, -0xc(%rbp)      # imm = 0xFFF
jg 0x8df0
movslq -0xc(%rbp), %rcx
leaq 0x5465(%rip), %rax      # 0xe1e0
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0x8(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x544f(%rip), %rax      # 0xe1e0
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0x9(%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
leaq 0x5435(%rip), %rax      # 0xe1e0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x15434(%rip), %rax     # 0x1e200
movb $0x0, (%rax,%rcx)
movslq -0xc(%rbp), %rcx
leaq 0x16425(%rip), %rax     # 0x1f200
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8d63
movl $0x0, -0x10(%rbp)
cmpl $0x1f, -0x10(%rbp)
jg 0x8e23
movslq -0x10(%rbp), %rax
leaq 0x52d8(%rip), %rdi      # 0xe0e0
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa710
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8df7
movl $0x4, 0x153cb(%rip)     # 0x1e1f8
movb $0x0, 0x52a0(%rip)      # 0xe0d4
movb $0x0, 0x5297(%rip)      # 0xe0d2
movb $0x0, 0x5291(%rip)      # 0xe0d3
movb $0x0, 0x5288(%rip)      # 0xe0d1
movl $0x0, 0x1a3ad(%rip)     # 0x23200
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: akshayrajput[P]ARMV8_Simulator/simulo.cpp
// Function: printMem(unsigned long, int, char)
void printMem(uint64_t addr,int off,char c)
{
	int startind = addr - Memory[0].addr;
	
	int endind = startind + off; 

	assert(c == 'x' || c == 'd');

	REP(i,startind,endind-1)
		if(c == 'd')
			printf("%d\n",Memory[i].getData());
		else if(c == 'x')
			printf("%x\n",Memory[i].getData());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
subq 0x5321(%rip), %rax      # 0xe1e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movsbl -0xd(%rbp), %ecx
movb $0x1, %al
cmpl $0x78, %ecx
movb %al, -0x1d(%rbp)
je 0x8ee6
movsbl -0xd(%rbp), %eax
cmpl $0x64, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x8eef
jmp 0x8ef1
jmp 0x8f10
leaq 0x2c1a(%rip), %rdi      # 0xbb12
leaq 0x2c28(%rip), %rsi      # 0xbb27
movl $0x33, %edx
leaq 0x2c27(%rip), %rcx      # 0xbb32
callq 0x1060
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x8f96
movsbl -0xd(%rbp), %eax
cmpl $0x64, %eax
jne 0x8f56
movslq -0x1c(%rbp), %rax
leaq 0x52a9(%rip), %rdi      # 0xe1e0
shlq $0x4, %rax
addq %rax, %rdi
callq 0xa6a0
movzbl %al, %esi
leaq 0x2c08(%rip), %rdi      # 0xbb55
movb $0x0, %al
callq 0x1030
jmp 0x8f89
movsbl -0xd(%rbp), %eax
cmpl $0x78, %eax
jne 0x8f87
movslq -0x1c(%rbp), %rax
leaq 0x5276(%rip), %rdi      # 0xe1e0
shlq $0x4, %rax
addq %rax, %rdi
callq 0xa6a0
movzbl %al, %esi
leaq 0x2bd9(%rip), %rdi      # 0xbb59
movb $0x0, %al
callq 0x1030
jmp 0x8f89
jmp 0x8f8b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8f16
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: akshayrajput[P]ARMV8_Simulator/simulo.cpp
// Function: printHelp()
void printHelp()
{
	printf("Check register :- print/p x/d r(0-31)\n");
	printf("Check memory :- print/p x/d <absolute addr hex>\n");
	printf("Set breakpoint :-break/b <absolute addr hex>\n");
	printf("Delete breakpoint :-del <absolute addr hex>\n");
	printf("Execute next instruction:- next/n\n");
	printf("Exit debugger and continue program execution:- run/r\n");
	printf("Quit simulo:- quit/q");
	printf("Print this help:- help/h\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x27a8(%rip), %rdi      # 0xbc43
movb $0x0, %al
callq 0x1030
leaq 0x27c1(%rip), %rdi      # 0xbc6a
movb $0x0, %al
callq 0x1030
leaq 0x27e4(%rip), %rdi      # 0xbc9b
movb $0x0, %al
callq 0x1030
leaq 0x2804(%rip), %rdi      # 0xbcc9
movb $0x0, %al
callq 0x1030
leaq 0x2823(%rip), %rdi      # 0xbcf6
movb $0x0, %al
callq 0x1030
leaq 0x2838(%rip), %rdi      # 0xbd19
movb $0x0, %al
callq 0x1030
leaq 0x2860(%rip), %rdi      # 0xbd4f
movb $0x0, %al
callq 0x1030
leaq 0x2867(%rip), %rdi      # 0xbd64
movb $0x0, %al
callq 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akshayrajput[P]ARMV8_Simulator/simulo.cpp
// Function: main
int main(int argc, char* argv[])
{

	int start_ind = 0;
	uint64_t start_addr ;
	char endian;
	debug_prompt = false;
	if(argc > 1)
		if(strcmp(argv[1],"debug") == 0)
	 		debug_prompt = true;
	FILE* info = fopen("info.txt","r");
	FILE* data = fopen("data.txt","r");
	fscanf(info,"%lx %c",&start_addr,&endian);
	fclose(info);

	int ind;
	initMem(start_addr);

	while(fscanf(data, "%d",&ind)>0)
	{
		if(ind >= 0 && ind<=4095)
			SR[ind]++ ;	
	}
	fclose(data);

	printf("[log]- Memory initialised\n");
	Loader loader("inst.txt");
	
	int x = loader.loadmem(start_ind,Memory,endian);
	printf("[log]-Hex file loaded\n");
	//init memory and breakpoints
	PC.setData(Memory[start_ind].addr);

	int i = start_ind;
	while(i <= x-4)
	{
		
		fetch();
		decode();
		i += NIO;
	}

	printf("[log]-Execution completed!\n");			
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, 0x13d28(%rip)     # 0x1e1fc
cmpl $0x1, -0x8(%rbp)
jle 0xa4fc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1bc2(%rip), %rsi      # 0xc0ab
callq 0x10f0
cmpl $0x0, %eax
jne 0xa4fa
movb $0x1, 0x13d02(%rip)     # 0x1e1fc
jmp 0xa4fc
leaq 0x1bae(%rip), %rdi      # 0xc0b1
leaq 0x1895(%rip), %rsi      # 0xbd9f
callq 0x10d0
movq %rax, -0x30(%rbp)
leaq 0x1ba0(%rip), %rdi      # 0xc0ba
leaq 0x187e(%rip), %rsi      # 0xbd9f
callq 0x10d0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1b8e(%rip), %rsi      # 0xc0c3
leaq -0x20(%rbp), %rdx
leaq -0x21(%rbp), %rcx
movb $0x0, %al
callq 0x1140
movq -0x30(%rbp), %rdi
callq 0x10b0
movq -0x20(%rbp), %rdi
callq 0x8d50
movq -0x38(%rbp), %rdi
leaq 0x1b69(%rip), %rsi      # 0xc0ca
leaq -0x3c(%rbp), %rdx
movb $0x0, %al
callq 0x1140
cmpl $0x0, %eax
jle 0xa59d
cmpl $0x0, -0x3c(%rbp)
jl 0xa59b
cmpl $0xfff, -0x3c(%rbp)     # imm = 0xFFF
jg 0xa59b
movslq -0x3c(%rbp), %rcx
leaq 0x14c75(%rip), %rax     # 0x1f200
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x14c68(%rip), %rax     # 0x1f200
movl %edx, (%rax,%rcx,4)
jmp 0xa556
movq -0x38(%rbp), %rdi
callq 0x10b0
leaq 0x1b20(%rip), %rdi      # 0xc0cd
movb $0x0, %al
callq 0x1030
leaq -0x48(%rbp), %rdi
leaq 0x1b29(%rip), %rsi      # 0xc0e8
callq 0xaa20
movl -0x14(%rbp), %esi
leaq -0x48(%rbp), %rdi
leaq 0x3c0e(%rip), %rdx      # 0xe1e0
movsbl -0x21(%rbp), %ecx
callq 0xaac0
movl %eax, -0x4c(%rbp)
leaq 0x1b0c(%rip), %rdi      # 0xc0f1
movb $0x0, %al
callq 0x1030
movslq -0x14(%rbp), %rcx
leaq 0x3be9(%rip), %rax      # 0xe1e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x13be0(%rip), %rdi     # 0x1e1e8
callq 0xa710
movl -0x14(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl -0x4c(%rbp), %ecx
subl $0x4, %ecx
cmpl %ecx, %eax
jg 0xa638
callq 0x97b0
callq 0x9990
movl 0x13bc8(%rip), %eax     # 0x1e1f8
addl -0x50(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0xa613
leaq 0x1ac9(%rip), %rdi      # 0xc108
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: akshayrajput[P]ARMV8_Simulator/mem.cpp
// Function: setDataW(mem*, unsigned int, int)
int setDataW(mem M[],uint32_t dat,int start)
{
	uint8_t w = (dat &0xff000000)>>24;
  	uint8_t x = (dat &0x00ff0000)>>16;
	uint8_t y = (dat &0x0000ff00)>>8;
	
	uint8_t z = (dat &0x000000ff);

	M[start].setData(w);
	start++;
	M[start].setData(x);
	start++;
	M[start].setData(y);
	start++;
	M[start].setData(z);
	start++;	

	return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
shrl $0x18, %eax
movb %al, -0x11(%rbp)
movl -0xc(%rbp), %eax
andl $0xff0000, %eax         # imm = 0xFF0000
shrl $0x10, %eax
movb %al, -0x12(%rbp)
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
shrl $0x8, %eax
movb %al, -0x13(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movzbl -0x11(%rbp), %esi
callq 0xa670
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movzbl -0x12(%rbp), %esi
callq 0xa670
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movzbl -0x13(%rbp), %esi
callq 0xa670
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movzbl -0x14(%rbp), %esi
callq 0xa670
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akshayrajput[P]ARMV8_Simulator/loader.cpp
// Function: Loader::loadmem(int, mem*, char)
int Loader::loadmem(int start , mem m[],char endian)
{
	uint32_t x;uint32_t bigendian;
	char c,data[17];
	//TODO-get an instance of memory and load ldfile from start pos
	

	while((c = fgetc(ldfile)) != EOF)
	{
		ungetc(c,ldfile);
		REP(i,0,7)//TODO - take in 8 hex letters (1 hex letter 1 nibble- write instructions bitwise)
		{
			if(c = fgetc(ldfile))
				data[i] = c;
			else
				exit(3);

		}
		data[8] = '\0';

			//TODO - check big or little endian swap if necessary
	
		x =(uint32_t) strtoul(data,NULL,16);	 //TODO - convert string to uint64_t
		if(endian == 'L')
		 bigendian = __builtin_bswap32(x);
		else 
			bigendian = x;

		start = setDataW(m,bigendian,start);//TODO - write to mem 32 bit word 

		//start++;
	}//TODO - repeat from (a) until EOF
	return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x1120
movb %al, -0x25(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0xab98
movq -0x50(%rbp), %rax
movsbl -0x25(%rbp), %edi
movq (%rax), %rsi
callq 0x1040
movl $0x0, -0x44(%rbp)
cmpl $0x7, -0x44(%rbp)
jg 0xab4f
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x1120
movb %al, -0x25(%rbp)
cmpb $0x0, %al
je 0xab38
movb -0x25(%rbp), %cl
movslq -0x44(%rbp), %rax
movb %cl, -0x40(%rbp,%rax)
jmp 0xab42
movl $0x3, %edi
callq 0x10e0
jmp 0xab44
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xab12
movb $0x0, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x1050
movl %eax, -0x20(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x4c, %eax
jne 0xab7b
movl -0x20(%rbp), %eax
bswapl %eax
movl %eax, -0x24(%rbp)
jmp 0xab81
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0xa750
movl %eax, -0xc(%rbp)
jmp 0xaae0
movl -0xc(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/refparms.cc
// Function: find_char(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, unsigned long&)
string::size_type find_char(const string &s, char c, 
                           string::size_type &occurs)
{
    auto ret = s.size();   // position of the first occurrence, if any
    occurs = 0;            // set the occurrence count parameter 

    for (decltype(ret) i = 0; i != s.size(); ++i) {
        if (s[i] == c) {
            if (ret == s.size()) 
                ret = i;   // remember the first occurrence of c
            ++occurs;      // increment the occurrence count
         }
	}
    return ret;            // count is returned implicitly in occurs
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x138e
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1120
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x137e
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x1370
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1380
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1316
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/refparms.cc
// Function: find_val(__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, int, unsigned long&)
vector<int>::const_iterator find_val(
    vector<int>::const_iterator beg,  // first element
    vector<int>::const_iterator end,  // one past last element
    int value,                        // the value we want
    vector<int>::size_type &occurs)   // number of times it occurs
{
    auto res_iter = end; // res_iter will hold first occurrence, if any
    occurs = 0;          // set occurrence count parameter 

    for ( ; beg != end; ++beg)
        if (*beg == value) {
            // remember first occurrence of value
            if (res_iter == end) 
                res_iter = beg;
            ++occurs;    // increment occurrence count
         }

    return res_iter;     // count returned implicitly in occurs
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x17b0
testb $0x1, %al
jne 0x13dd
jmp 0x1423
leaq -0x10(%rbp), %rdi
callq 0x17f0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x1416
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1810
testb $0x1, %al
jne 0x1400
jmp 0x1408
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1418
leaq -0x10(%rbp), %rdi
callq 0x1850
jmp 0x13ca
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: spatialfruitsalad[P]volume2position/main.cpp
// Function: CreateFolders(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void CreateFolders(std::string outfoldername)
{
    if(outfoldername.empty())
    {
        throw std::string("outfilepath is empty");
    }
    char lastCharOfFolder = *outfoldername.rbegin();  
    if (lastCharOfFolder != '/')
        outfoldername += '/';

    std::string imagefoldername= outfoldername + "images/";
    std::string thresfoldername= outfoldername + "threshold_histogram/";
   
    mkdir(outfoldername.c_str(),0755);    
    mkdir(imagefoldername.c_str(),0755);    
    mkdir(thresfoldername.c_str(),0755);    

}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
callq 0x3410
testb $0x1, %al
jne 0x3692
jmp 0x3721
movb $0x1, 0x6b(%rsp)
movl $0x20, %edi
callq 0x3150
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x34b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x24a6f(%rip), %rsi     # 0x28139
callq 0x3360
jmp 0x36d1
movq (%rsp), %rdi
movb $0x0, 0x6b(%rsp)
leaq 0x30697(%rip), %rsi     # 0x33d78
movq 0x308c0(%rip), %rdx     # 0x33fa8
callq 0x3460
jmp 0x380a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x7f(%rsp), %rdi
callq 0x32d0
testb $0x1, 0x6b(%rsp)
jne 0x3713
jmp 0x371c
movq (%rsp), %rdi
callq 0x3210
jmp 0x3800
movq 0x18(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x3480
leaq 0x60(%rsp), %rdi
callq 0x60d0
movb (%rax), %al
movb %al, 0x6a(%rsp)
movsbl 0x6a(%rsp), %eax
cmpl $0x2f, %eax
je 0x3759
movq 0x18(%rsp), %rdi
movl $0x2f, %esi
callq 0x31b0
movq 0x18(%rsp), %rsi
leaq 0x24ac6(%rip), %rdx     # 0x2822b
leaq 0x40(%rsp), %rdi
callq 0x6100
movq 0x18(%rsp), %rsi
leaq 0x249d3(%rip), %rdx     # 0x2814e
leaq 0x20(%rsp), %rdi
callq 0x6100
jmp 0x3787
movq 0x18(%rsp), %rdi
callq 0x3110
movq %rax, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x3130
leaq 0x40(%rsp), %rdi
callq 0x3110
movq %rax, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x3130
leaq 0x20(%rsp), %rdi
callq 0x3110
movq %rax, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x3130
leaq 0x20(%rsp), %rdi
callq 0x3538
leaq 0x40(%rsp), %rdi
callq 0x3538
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3538
movq 0x70(%rsp), %rdi
callq 0x34a0
nopw (%rax,%rax)
// File: spatialfruitsalad[P]volume2position/./tomogram.hpp
// Function: tomogram3d<unsigned short>::clear()
void clear()
    {
        data.clear();
        sx = 0;
        sy = 0;
        sz = 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21200
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: spatialfruitsalad[P]volume2position/./selectedAreaHistogram.hpp
// Function: selectedAreaHistogram::selectedAreaHistogram(unsigned long, unsigned long, unsigned long)
selectedAreaHistogram (unsigned long nx, unsigned long ny, unsigned long nz)
    {
        std::cout << "selectedAreaHistogram Constructor" << std::endl;
        for (unsigned long i = 0; i != nz; ++i)
        {
            area a;
            a.z = i;
            a.x1 = 0;
            a.y1 = 0;
            a.x2 = nx;
            a.y2 = ny;
            m_areas.push_back(a);
        }
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x11880
movq 0x2ae0b(%rip), %rdi     # 0x33fc0
leaq 0x1f4ab(%rip), %rsi     # 0x28667
callq 0x3290
movq %rax, 0x10(%rsp)
jmp 0x91c8
movq 0x10(%rsp), %rdi
movq 0x2adcc(%rip), %rsi     # 0x33fa0
callq 0x32c0
jmp 0x91db
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x9260
leaq 0x1c(%rsp), %rdi
callq 0x11890
jmp 0x91fc
movq 0x8(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x1c(%rsp), %rsi
callq 0x118c0
jmp 0x9235
jmp 0x9237
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x91e4
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x11930
jmp 0x9265
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x34a0
nop
// File: spatialfruitsalad[P]volume2position/./cSegmentationByOtsu.h
// Function: cSegmentationByOtsu::NormalizeHisto(std::vector<double, std::allocator<double>>&)
static void NormalizeHisto (std::vector<double> & vals)
    {
        double sum = 0;
        for (double v : vals)
        {
            sum += v;
        }
        for(size_t i = 0; i != vals.size(); ++i)
        {
            vals[i] /= sum;
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11640
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x115a0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x12420
testb $0x1, %al
jne 0x9daf
jmp 0x9de1
leaq 0x28(%rsp), %rdi
callq 0x12460
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x12470
jmp 0x9d9a
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10520
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x9e46
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9d40
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x9dea
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: spatialfruitsalad[P]volume2position/./tomogram.hpp
// Function: tomogram3d<unsigned char>::initialise(unsigned long, unsigned long, unsigned long, unsigned char)
void initialise(unsigned long a,unsigned long b,unsigned long c, VALUE value)
    {
        sx = a;
        sy = b;
        sz = c;
        std::cout << "resizing tomogram to " << a << " "  << b << " "  << c << std::endl;
        data.resize(sx*sy*sz);
        for (unsigned long i = 0; i < sx*sy*sz; ++i)
        {
            data.at(i) = value;
        }
        std::cout << "resize done" << std::endl;
    }

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x29d65(%rip), %rdi     # 0x33fc0
leaq 0x1e38e(%rip), %rsi     # 0x285f0
callq 0x3290
movq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x3090
movq %rax, %rdi
leaq 0x1e9ca(%rip), %rsi     # 0x28c48
callq 0x3290
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x3090
movq %rax, %rdi
leaq 0x1e9ae(%rip), %rsi     # 0x28c48
callq 0x3290
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x3090
movq %rax, %rdi
movq 0x29cea(%rip), %rsi     # 0x33fa0
callq 0x32c0
movq 0x10(%rsp), %rdi
movq 0x18(%rdi), %rsi
imulq 0x20(%rdi), %rsi
imulq 0x28(%rdi), %rsi
callq 0x1d860
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x18(%rdx), %rcx
imulq 0x20(%rdx), %rcx
imulq 0x28(%rdx), %rcx
cmpq %rcx, %rax
jae 0xa326
movq 0x10(%rsp), %rdi
movb 0x27(%rsp), %al
movb %al, 0xf(%rsp)
movq 0x18(%rsp), %rsi
callq 0x1d900
movb 0xf(%rsp), %cl
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xa2dc
movq 0x29c93(%rip), %rdi     # 0x33fc0
leaq 0x1e2d2(%rip), %rsi     # 0x28606
callq 0x3290
movq %rax, %rdi
movq 0x29c5d(%rip), %rsi     # 0x33fa0
callq 0x32c0
addq $0x48, %rsp
retq
nopl (%rax)
// File: spatialfruitsalad[P]volume2position/./bilateral.hpp
// Function: bilateralFilter::gauss(double, double)
static double gauss(double sigma, double v)
    {
        v = fabs(v);
        if (v > 4.0*sigma) return 0;
        double f = v/sigma;
        // i don't care about the prefactor right here, since the computation will have to calculate the weight anyway.
        return exp (-0.5 * (f * f)  );
    }

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movaps 0x17ce3(%rip), %xmm1    # 0x280e0
pand %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x17c13(%rip), %xmm1    # 0x28028
mulsd 0x18(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1042c
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x10461
movsd 0x10(%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
movsd 0x17c0e(%rip), %xmm0    # 0x28060
mulsd %xmm1, %xmm0
callq 0x34c0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: spatialfruitsalad[P]volume2position/./remove_inside_holes_2.hpp
// Function: removeInsideHoles::lookup_in_2(int, std::vector<int, std::allocator<int>>&)
static int lookup_in_2 (int x, std::vector<int> & rename)
    {
        int ret = rename.at(x);
        if (ret < 0)
            return lookup_in_2 (-ret, rename);
        else
            return ret;
    }

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x12f20
movl (%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x1288f
xorl %edi, %edi
subl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x12850
movl %eax, 0x14(%rsp)
jmp 0x12897
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: spatialfruitsalad[P]volume2position/./remove_inside_holes_2.hpp
// Function: removeInsideHoles::merge_clusters_in_2(int, int, std::vector<int, std::allocator<int>>&)
static int merge_clusters_in_2 (int a, int b, std::vector<int> & rename)
    {
        if (a > b)
            return merge_clusters_in_2 (b, a, rename);
        rename.at (b) = -a;
        return a;
    }

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x128d3
movl 0x1c(%rsp), %edi
movl 0x20(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x128a0
movl %eax, 0x24(%rsp)
jmp 0x128fa
xorl %eax, %eax
subl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x12f20
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x20(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: spatialfruitsalad[P]volume2position/./erodate.hpp
// Function: Erodate::erodate_binary_sphere(tomogram3d<unsigned char>&, tomogram3d<float>&, float)
static void erodate_binary_sphere(tomogram3d<uint8_t>& matrix_in, tomogram3d<float>& edm, float depth)
    {
        std::cout << "erodate sphere: erosion depth " << depth << "  ... " << std::flush;

        int sx = matrix_in.get_sx();
        int sy = matrix_in.get_sy();
        int sz = matrix_in.get_sz();

        for (int k = 0; k != sz; ++k)
        for (int j = 0; j != sy; ++j)
        for (int i = 0; i != sx; ++i)
            if (edm.get(i,j,k) < depth + 0.001 )
                matrix_in.set(i,j,k,0);

        std::cout << " done" << std::endl;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movq 0x1dc15(%rip), %rdi     # 0x33fc0
leaq 0x124c2(%rip), %rsi     # 0x28874
callq 0x3290
movq %rax, %rdi
movss 0x24(%rsp), %xmm0
callq 0x3230
movq %rax, %rdi
leaq 0x124c4(%rip), %rsi     # 0x28893
callq 0x3290
movq %rax, %rdi
movq 0x1dbea(%rip), %rsi     # 0x33fc8
callq 0x32c0
movq 0x30(%rsp), %rdi
callq 0x125e0
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x125f0
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
callq 0x12600
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
je 0x164d3
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x164c1
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x20(%rsp), %eax
je 0x164af
movq 0x28(%rsp), %rdi
movslq 0xc(%rsp), %rsi
movslq 0x10(%rsp), %rdx
movslq 0x14(%rsp), %rcx
callq 0x15be0
cvtss2sd %xmm0, %xmm1
movss 0x24(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x11bf6(%rip), %xmm2    # 0x28070
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x164a0
movq 0x30(%rsp), %rdi
movslq 0xc(%rsp), %rsi
movslq 0x10(%rsp), %rdx
movslq 0x14(%rsp), %rcx
xorl %r8d, %r8d
callq 0xa6f0
jmp 0x164a2
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16441
jmp 0x164b1
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1642b
jmp 0x164c3
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x16415
movq 0x1dae6(%rip), %rdi     # 0x33fc0
leaq 0x12369(%rip), %rsi     # 0x2884a
callq 0x3290
movq %rax, %rdi
movq 0x1dab0(%rip), %rsi     # 0x33fa0
callq 0x32c0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: spatialfruitsalad[P]volume2position/./watershed_segmentation.hpp
// Function: watershedSegmentation::lookup_2(int, std::vector<int, std::allocator<int>>&)
static int lookup_2 (int x, std::vector<int> & rename)
    {
        assert (x >= 0);
        int ret = rename.at(x);
        if (ret < 0)
            return lookup_2 (-ret, rename);
        else
            return ret;
    }

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0x183b6
jmp 0x183d5
leaq 0x10542(%rip), %rdi     # 0x288ff
leaq 0x105d5(%rip), %rsi     # 0x28999
movl $0x1f, %edx
leaq 0x105e6(%rip), %rcx     # 0x289b6
callq 0x31d0
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x12f20
movl (%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x18407
xorl %edi, %edi
subl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x183a0
movl %eax, 0x14(%rsp)
jmp 0x1840f
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: spatialfruitsalad[P]volume2position/./hk.hpp
// Function: HoshenKopelman::lookup(int, std::vector<int, std::allocator<int>>&)
static int lookup (int x, std::vector<int> & rename) {
        assert (x >= 0);
        int ret = rename.at(x);
        if (ret < 0)
            return lookup (-ret, rename);
        else
            return ret;
    }

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0x1c206
jmp 0x1c225
leaq 0xc6f2(%rip), %rdi      # 0x288ff
leaq 0xc6f2(%rip), %rsi      # 0x28906
movl $0x17, %edx
leaq 0xc6ef(%rip), %rcx      # 0x2890f
callq 0x31d0
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x12f20
movl (%rax), %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x1c257
xorl %edi, %edi
subl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x1c1f0
movl %eax, 0x14(%rsp)
jmp 0x1c25f
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: spatialfruitsalad[P]volume2position/./hk.hpp
// Function: HoshenKopelman::merge_clusters(int, int, std::vector<int, std::allocator<int>>&)
static int merge_clusters (int a, int b, std::vector<int> & rename) {
        assert (a != b);
        if (a > b)
            return merge_clusters (b, a, rename);
        rename.at (b) = -a;
        return a;
    }

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x1c28d
jmp 0x1c2ac
leaq 0xc6b6(%rip), %rdi      # 0x2894a
leaq 0xc66b(%rip), %rsi      # 0x28906
movl $0x20, %edx
leaq 0xc6aa(%rip), %rcx      # 0x28951
callq 0x31d0
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x1c2ce
movl 0x1c(%rsp), %edi
movl 0x20(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x1c270
movl %eax, 0x24(%rsp)
jmp 0x1c2f5
xorl %eax, %eax
subl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x12f20
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x20(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: spatialfruitsalad[P]volume2position/./bilateral.hpp
// Function: bilateralFilter::getGauss(double)
double getGauss (double v)
    {
        v = fabs (v);
        if (v >= 4.0*m_sigmaSimilarity)
            return 0;
        double dx = (4*m_sigmaSimilarity)/static_cast<double>(501);
        unsigned int idx = floor(v/dx);
        return gaussTable[idx];
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
movaps 0x77da(%rip), %xmm1     # 0x280e0
pand %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x770a(%rip), %xmm1     # 0x28028
mulsd 0x10(%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0x20934
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x20998
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x76e2(%rip), %xmm1     # 0x28028
mulsd %xmm1, %xmm0
movsd 0x7756(%rip), %xmm1     # 0x280a8
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x3430
movq 0x8(%rsp), %rdi
cvttsd2si %xmm0, %rax
movl %eax, 0x14(%rsp)
addq $0x50, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9d40
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)