LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1636a(%rip), %rbx     # 0x1a1f0
movq %rbx, %rdi
callq 0x5cb2
movl %eax, %r15d
movq %rbx, %rdi
callq 0x5cb2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5cb2
movl %eax, %r14d
movq %rbx, %rdi
callq 0x5cb2
movl %eax, %ebx
leaq 0x16349(%rip), %rdi     # 0x1a200
callq 0x5cae
testl %r15d, %r15d
js 0x3ef9
shrl $0x1d, %ebp
andl $0x3, %ebp
shrl $0x3, %r14d
movl %r14d, %edx
andl $0x1ffffc, %edx         # imm = 0x1FFFFC
orl %ebp, %edx
xorl %ecx, %ecx
xorl %esi, %esi
movl $0x1, %edi
shll %cl, %edi
andl %edx, %edi
addq %rdi, %rsi
incl %ecx
cmpl $0x14, %ecx
jne 0x3eda
andl $0x100000, %r14d        # imm = 0x100000
subq %r14, %rsi
jmp 0x3efe
andl $0xfffff000, %eax       # imm = 0xFFFFF000
addq %rax, %rsi
andl $0x1f, %ebx
leaq 0x61e5(%rip), %rax      # 0xa0f0
leaq (%rax,%rbx,8), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cb6
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x15660(%rip), %rdi     # 0x1a210
xorl %r14d, %r14d
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x1070
leaq 0x1664a(%rip), %rdi     # 0x1b210
movl $0x4000, %edx           # imm = 0x4000
xorl %esi, %esi
callq 0x1070
leaq 0x5617(%rip), %rax      # 0xa1f0
movw $0x0, 0x8(%r14,%rax)
movq %rbx, (%r14,%rax)
incq %rbx
addq $0x10, %r14
cmpq $0x10000, %r14          # imm = 0x10000
jne 0x4bd9
xorl %ebx, %ebx
leaq 0x54f2(%rip), %r14      # 0xa0f0
leaq (%r14,%rbx), %rdi
xorl %esi, %esi
callq 0x5cb6
addq $0x8, %rbx
cmpq $0x100, %rbx            # imm = 0x100
jne 0x4bfe
movl $0x4, 0x155e8(%rip)     # 0x1a208
xorl %eax, %eax
movb %al, 0x54bc(%rip)       # 0xa0e4
movb %al, 0x54b4(%rip)       # 0xa0e2
movb %al, 0x54af(%rip)       # 0xa0e3
movb %al, 0x54a7(%rip)       # 0xa0e1
movl $0x0, 0x1a5cc(%rip)     # 0x1f210
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
subq 0x557d(%rip), %rdi      # 0xa1f0
cmpl $0x64, %edx
je 0x4c7d
cmpl $0x78, %edx
jne 0x4ce8
testl %esi, %esi
jle 0x4cd9
addl %edi, %esi
movslq %edi, %r15
movslq %esi, %r12
movq %r15, %rax
shlq $0x4, %rax
leaq 0x5559(%rip), %rbx      # 0xa1f0
addq %rax, %rbx
movsbl %dl, %ebp
leaq 0x1520(%rip), %r13      # 0x61c4
movq %r13, %r14
cmpl $0x64, %ebp
je 0x4cb8
cmpl $0x78, %ebp
jne 0x4ccd
leaq 0x1510(%rip), %r14      # 0x61c8
movq %rbx, %rdi
callq 0x5caa
movzbl %al, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
incq %r15
addq $0x10, %rbx
cmpq %r12, %r15
jl 0x4ca4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1492(%rip), %rdi      # 0x6181
leaq 0x14a0(%rip), %rsi      # 0x6196
leaq 0x14a4(%rip), %rcx      # 0x61a1
movl $0x33, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/simulo.cpp
// Function: setBreak(char*)
void setBreak(char* arg)
{
	//TODO -set bp_flag at particular address
	while(*arg == ' ')arg++;
	int ind = addrToIndex(arg);
	breakpt[ind] = true;
}

// Assembly:
pushq %rax
decq %rdi
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x4ee7
xorl %esi, %esi
movl $0x10, %edx
callq 0x1060
subl 0x52ed(%rip), %eax      # 0xa1f0
cltq
leaq 0x15304(%rip), %rcx     # 0x1a210
movb $0x1, (%rax,%rcx)
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/simulo.cpp
// Function: delBreak(char*)
void delBreak(char* arg)
{
	//TODO -set bp_flag at particular address
	while(*arg == ' ')arg++;
	int ind = addrToIndex(arg);
	breakpt[ind] = false;
}

// Assembly:
pushq %rax
decq %rdi
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x4f16
xorl %esi, %esi
movl $0x10, %edx
callq 0x1060
subl 0x52be(%rip), %eax      # 0xa1f0
cltq
leaq 0x152d5(%rip), %rcx     # 0x1a210
movb $0x0, (%rax,%rcx)
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
leaq 0x1d23(%rip), %rdi      # 0x6c6c
callq 0x1140
leaq 0x1d3d(%rip), %rdi      # 0x6c92
callq 0x1140
leaq 0x1d61(%rip), %rdi      # 0x6cc2
callq 0x1140
leaq 0x1d82(%rip), %rdi      # 0x6cef
callq 0x1140
leaq 0x1da2(%rip), %rdi      # 0x6d1b
callq 0x1140
leaq 0x1db8(%rip), %rdi      # 0x6d3d
callq 0x1140
leaq 0x1287(%rip), %rdi      # 0x6218
xorl %eax, %eax
callq 0x1040
leaq 0x1dd3(%rip), %rdi      # 0x6d72
popq %rax
jmp 0x1140
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/simulo.cpp
// Function: fetch()
void fetch()
{

		
	uint64_t addr = PC.getData();
	int i = addr - Memory[0].addr; 
	if(SR[i]>1 && subroutine == 0)//don't mess with main flow of control
	{	
			skip = true;
	}
	else if(SR[i] == 1)
		SR[i]++;

	printf("[log]-fetching instruction\n");
	if(debug_prompt)
	{
		printf("DEBUG-mode enabled\n");
		show_prompt();
	}

	if(breakpt[i])
	{
		printf("Break point at address - %lx\n",addr);
		show_prompt();
	}
		//TODO - read the memory
	uint64_t w = Memory[i].getData()<<24; i++;
	uint64_t x = Memory[i].getData()<<16; i++;
	uint64_t y = Memory[i].getData()<<8; i++;
	uint64_t z = Memory[i].getData(); i++;


	//TODO - take data to IR

	IR.setData(w|x|y|z);
	BR.setData(PC.getData());
	PC.setData(addr + 4 );
	printf("[log]-done fetching instruction\n");

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x15093(%rip), %rdi     # 0x1a1f8
callq 0x5cae
movq %rax, %rbx
movq %rax, %r15
subq 0x5079(%rip), %r15      # 0xa1f0
movslq %r15d, %r14
leaq 0x1608f(%rip), %rax     # 0x1b210
movl (%rax,%r14,4), %ecx
cmpl $0x2, %ecx
jl 0x519c
cmpl $0x0, 0x1a07f(%rip)     # 0x1f210
jne 0x519c
movb $0x1, 0x15073(%rip)     # 0x1a20d
jmp 0x51a9
cmpl $0x1, %ecx
jne 0x51a9
movl $0x2, (%rax,%r14,4)
leaq 0x1c0a(%rip), %rdi      # 0x6dba
callq 0x1140
cmpb $0x1, 0x15050(%rip)     # 0x1a20c
jne 0x51cf
leaq 0x1c10(%rip), %rdi      # 0x6dd5
callq 0x1140
callq 0x4fa5
shlq $0x20, %r15
leaq 0x15036(%rip), %rax     # 0x1a210
cmpb $0x1, (%r14,%rax)
jne 0x51f7
leaq 0x108a(%rip), %rdi      # 0x6272
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
callq 0x4fa5
shlq $0x4, %r14
leaq 0x4fee(%rip), %r12      # 0xa1f0
addq %r12, %r14
movq %r14, %rdi
callq 0x5caa
movzbl %al, %eax
shll $0x18, %eax
movslq %eax, %r14
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r15, %rdi
sarq $0x1c, %rdi
addq %r12, %rdi
callq 0x5caa
movzbl %al, %r13d
shll $0x10, %r13d
orq %r14, %r13
movabsq $0x200000000, %rdi      # imm = 0x200000000
addq %r15, %rdi
sarq $0x1c, %rdi
addq %r12, %rdi
callq 0x5caa
movzbl %al, %r14d
shll $0x8, %r14d
orq %r13, %r14
movabsq $0x300000000, %rdi      # imm = 0x300000000
addq %r15, %rdi
sarq $0x1c, %rdi
addq %r12, %rdi
callq 0x5caa
movzbl %al, %esi
orq %r14, %rsi
leaq 0x14f6c(%rip), %rdi     # 0x1a1f0
callq 0x5cb6
leaq 0x14f68(%rip), %r14     # 0x1a1f8
movq %r14, %rdi
callq 0x5cae
leaq 0x14f61(%rip), %rdi     # 0x1a200
movq %rax, %rsi
callq 0x5cb6
addq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5cb6
leaq 0x1b2b(%rip), %rdi      # 0x6de8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1140
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movb $0x0, 0x146e1(%rip)     # 0x1a20c
cmpl $0x2, %edi
jl 0x5b4b
movq 0x8(%rsi), %rdi
leaq 0x76d(%rip), %rsi       # 0x62a8
callq 0x1110
testl %eax, %eax
jne 0x5b4b
movb $0x1, 0x146c1(%rip)     # 0x1a20c
leaq 0x75c(%rip), %rdi       # 0x62ae
leaq 0x1217(%rip), %rbx      # 0x6d70
movq %rbx, %rsi
callq 0x10f0
movq %rax, %r14
leaq 0x74c(%rip), %rdi       # 0x62b7
movq %rbx, %rsi
callq 0x10f0
movq %rax, %rbx
leaq 0x743(%rip), %rsi       # 0x62c0
leaq 0x18(%rsp), %r15
leaq 0xb(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1170
movq %r14, %rdi
callq 0x10d0
movq (%r15), %rdi
callq 0x4ba2
leaq 0x71c(%rip), %rsi       # 0x62c7
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1170
testl %eax, %eax
jle 0x5bf5
leaq 0x1564b(%rip), %r12     # 0x1b210
leaq 0x6fb(%rip), %r14       # 0x62c7
leaq 0xc(%rsp), %r15
movl 0xc(%rsp), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x5be1
incl (%r12,%rax,4)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1170
testl %eax, %eax
jg 0x5bd1
movq %rbx, %rdi
callq 0x10d0
leaq 0x1412(%rip), %rdi      # 0x7016
callq 0x1140
leaq 0x6ba(%rip), %rsi       # 0x62ca
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5d98
movsbl 0xb(%rsp), %ecx
leaq 0x45c7(%rip), %rdx      # 0xa1f0
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5df4
movl %eax, %ebx
leaq 0x13f2(%rip), %rdi      # 0x7030
callq 0x1140
movq 0x45a6(%rip), %rsi      # 0xa1f0
leaq 0x145a7(%rip), %rdi     # 0x1a1f8
callq 0x5cb6
cmpl $0x4, %ebx
jl 0x5c72
addl $-0x4, %ebx
callq 0x5155
callq 0x52cb
addl 0x1459a(%rip), %ebp     # 0x1a208
cmpl %ebx, %ebp
jle 0x5c5e
leaq 0x13cd(%rip), %rdi      # 0x7046
callq 0x1140
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x1150
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x5e87
movq %rsp, %r12
sarl $0x18, %eax
movq (%r15), %rsi
movl %eax, %edi
callq 0x1050
xorl %r13d, %r13d
movq (%r15), %rdi
callq 0x1150
testb %al, %al
je 0x5e98
movb %al, (%rsp,%r13)
incq %r13
cmpq $0x8, %r13
jne 0x5e31
movb $0x0, 0x8(%rsp)
movq %r12, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1060
cmpb $0x4c, %bpl
movl %eax, %esi
bswapl %esi
cmovnel %eax, %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x5cc4
movl %eax, %ebx
movq (%r15), %rdi
callq 0x1150
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
jne 0x5e21
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x3, %edi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq $0x0, (%rcx)
cmpq %rsi, %rdi
je 0x1310
pushq %rbp
movq %rsp, %rbp
xorl %r8d, %r8d
movq %rsi, %rax
cmpl %edx, (%rdi)
jne 0x1305
cmpq %rsi, %rax
cmoveq %rdi, %rax
incq %r8
movq %r8, (%rcx)
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x12f4
popq %rbp
retq
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x14c9d(%rip), %r13     # 0x1cfc8
leaq 0xf3a8(%rip), %rsi      # 0x176da
movl $0x21, %edx
movq %r13, %rdi
callq 0x32f0
movq (%r13), %rax
addq -0x18(%rax), %r13
movq %r13, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq 0x14c6a(%rip), %rdi     # 0x1cfc8
callq 0x3040
movq %rax, %rdi
callq 0x31e0
testq %r14, %r14
je 0x83c1
xorl %ebp, %ebp
xorl %r13d, %r13d
movl %r13d, 0x4(%rsp)
movl %ebp, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
movl %r12d, 0xc(%rsp)
movl %r15d, 0x14(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x83ac
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsi)
movups 0x4(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x14, 0x8(%rbx)
jmp 0x83b9
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0xe0ba
incq %r13
cmpq %r13, %r14
jne 0x8375
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x83d2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x83e2
callq 0x3280
movq %r14, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x14119(%rip), %rbx     # 0x1cfc8
leaq 0xe7ad(%rip), %rsi      # 0x17663
movl $0x15, %edx
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x31d0
movq %rax, %r13
leaq 0xeddf(%rip), %rbx      # 0x17cb7
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32f0
movq %r13, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq 0x20(%r14), %rsi
imulq 0x18(%r14), %rsi
imulq 0x28(%r14), %rsi
movq %r14, %rdi
callq 0x1310a
movq 0x20(%r14), %rax
imulq 0x18(%r14), %rax
imulq 0x28(%r14), %rax
testq %rax, %rax
je 0x8f8f
xorl %esi, %esi
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x8fdf
movb %bpl, (%rax,%rsi)
movq 0x20(%r14), %rax
imulq 0x18(%r14), %rax
incq %rsi
imulq 0x28(%r14), %rax
cmpq %rax, %rsi
jb 0x8f66
leaq 0xe6e3(%rip), %rsi      # 0x17679
movl $0xb, %edx
movq 0x14026(%rip), %rbx     # 0x1cfc8
movq %rbx, %rdi
callq 0x32f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
leaq 0xe773(%rip), %rdi      # 0x17759
xorl %eax, %eax
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movslq %edi, %rax
cmpq %rax, %rdx
jbe 0xe3cc
movl (%rcx,%rax,4), %eax
testl %eax, %eax
jns 0xe3ca
negl %eax
jmp 0xe3ba
popq %rcx
retq
leaq 0x9386(%rip), %rdi      # 0x17759
movq %rax, %rsi
xorl %eax, %eax
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0xd592(%rip), %rbx      # 0x1cfc8
leaq 0x7eaa(%rip), %rsi      # 0x178e7
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x32f0
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x33c0
movq %rax, %r12
leaq 0x7e9d(%rip), %rsi      # 0x17906
movl $0x6, %edx
movq %rax, %rdi
callq 0x32f0
movq %r12, %rdi
callq 0x31e0
movl 0x28(%r15), %eax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xfb14
movl 0x18(%r15), %ebx
movl 0x20(%r15), %eax
movq %rax, 0x8(%rsp)
movsd (%rsp), %xmm0
addsd 0x75c6(%rip), %xmm0     # 0x17070
movsd %xmm0, (%rsp)
xorl %r12d, %r12d
cmpq $0x0, 0x8(%rsp)
je 0xfb0a
xorl %r13d, %r13d
testq %rbx, %rbx
je 0xfb00
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xf342
cvtss2sd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xfaf8
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x9356
incq %rbp
cmpq %rbp, %rbx
jne 0xfac4
incq %r13
cmpq 0x8(%rsp), %r13
jne 0xfabd
incq %r12
cmpq 0x10(%rsp), %r12
jne 0xfab2
leaq 0x7da2(%rip), %rsi      # 0x178bd
movl $0x5, %edx
movq 0xd4a1(%rip), %rbx      # 0x1cfc8
movq %rbx, %rdi
callq 0x32f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rax
testl %edi, %edi
js 0x113e8
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movl %edi, %eax
cmpq %rax, %rdx
jbe 0x113d7
movl (%rcx,%rax,4), %eax
testl %eax, %eax
jns 0x113d5
negl %eax
jmp 0x113c5
popq %rcx
retq
leaq 0x637b(%rip), %rdi      # 0x17759
movq %rax, %rsi
xorl %eax, %eax
callq 0x3390
leaq 0x6583(%rip), %rdi      # 0x17972
leaq 0x6616(%rip), %rsi      # 0x17a0c
leaq 0x662c(%rip), %rcx      # 0x17a29
movl $0x1f, %edx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rax
testl %edi, %edi
js 0x12d5e
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movl %edi, %eax
cmpq %rax, %rdx
jbe 0x12d4d
movl (%rcx,%rax,4), %eax
testl %eax, %eax
jns 0x12d4b
negl %eax
jmp 0x12d3b
popq %rcx
retq
leaq 0x4a05(%rip), %rdi      # 0x17759
movq %rax, %rsi
xorl %eax, %eax
callq 0x3390
leaq 0x4c0d(%rip), %rdi      # 0x17972
leaq 0x4c0d(%rip), %rsi      # 0x17979
leaq 0x4c0f(%rip), %rcx      # 0x17982
movl $0x17, %edx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rax
movl %esi, %eax
cmpl %esi, %edi
je 0x12dab
movl %edi, %esi
movl %eax, %edi
jg 0x12d7f
cltq
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x12dca
movl %esi, %edx
negl %edx
movl %edx, (%rcx,%rax,4)
movl %esi, %eax
popq %rcx
retq
leaq 0x4c0b(%rip), %rdi      # 0x179bd
leaq 0x4bc0(%rip), %rsi      # 0x17979
leaq 0x4c04(%rip), %rcx      # 0x179c4
movl $0x20, %edx
callq 0x31c0
leaq 0x4988(%rip), %rdi      # 0x17759
movq %rax, %rsi
xorl %eax, %eax
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O3/spatialfruitsalad[P]volume2position/./cSummerLinear.h
// Function: cSummerLinear::Add(double)
void Add(double Radius)
    {
        if(Radius < 0.0)
        {
            throw std::string ("negative Keys are not supported by cSummerLinear.");
        }
        int idx = static_cast<int>(Radius/m_dBinSize);
        //std::cout << idx << " ";
        if ( !m_mapHistogram.count(idx) )
        {
            m_mapHistogram.insert(std::pair<unsigned int,double>(idx,0.0));
        }
        m_mapHistogram.find(idx)->second +=1.0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x149c3
movq %rdi, %rbx
divsd 0x30(%rdi), %xmm0
cvttsd2si %xmm0, %ecx
movslq %ecx, %r15
movq 0x10(%rdi), %rax
leaq 0x8(%rdi), %r14
testq %rax, %rax
je 0x14960
movq %rax, %rsi
movq %r14, %rdx
xorl %edi, %edi
cmpq %r15, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x1493d
cmpq %r14, %rdx
je 0x14960
cmpq %r15, 0x20(%rdx)
jbe 0x14979
movq %rsp, %rsi
movl %ecx, (%rsi)
movq $0x0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x14c84
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x149a5
movq %r14, %rcx
xorl %edx, %edx
cmpq %r15, 0x20(%rax)
setb %dl
cmovaeq %rax, %rcx
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x14981
cmpq %r14, %rcx
je 0x149a5
cmpq %r15, 0x20(%rcx)
cmovbeq %rcx, %r14
movsd 0x28(%r14), %xmm0
addsd 0x269d(%rip), %xmm0     # 0x17050
movsd %xmm0, 0x28(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x3150
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x3288(%rip), %rsi      # 0x17c66
leaq 0x32b2(%rip), %rdx      # 0x17c97
movq %rbx, %rdi
callq 0x13074
leaq 0x838c(%rip), %rsi      # 0x1cd80
movq 0x85ad(%rip), %rdx      # 0x1cfa8
movq %rbx, %rdi
callq 0x3410
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O3/spatialfruitsalad[P]volume2position/./cSummerLinear.h
// Function: operator<<(std::ostream&, cSummerLinear const&)
std::ostream& operator << (std::ostream &f, const cSummerLinear& S)
    {
        if (!S.m_mapHistogram.empty())
        {
            std::cout << "saving histogram up to bin " << (--S.m_mapHistogram.end())->first << std::endl;
            for ( unsigned long i = 0; i < (--S.m_mapHistogram.end())->first; ++i)
            {
                f << static_cast<double>(S.m_dBinSize * i);
                f << "    ";
                if ( S.m_mapHistogram.count(i) )
                {
                    f << S.m_mapHistogram.find(i)->second;
                }
                else
                {
                    f << 0;
                }

                f << std::endl;
            }

        }
        return f;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rsi)
je 0x14b9f
movq %rsi, %r14
movq 0x8591(%rip), %r12      # 0x1cfc8
leaq 0x325a(%rip), %rsi      # 0x17c98
movl $0x1b, %edx
movq %r12, %rdi
callq 0x32f0
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x31a0
movq 0x20(%rax), %rsi
movq %r12, %rdi
callq 0x31d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %r15, %rdi
callq 0x31a0
cmpq $0x0, 0x20(%rax)
je 0x14b9f
xorl %r13d, %r13d
leaq 0x320a(%rip), %r12      # 0x17cb4
movq %r13, %xmm1
punpckldq 0x2629(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2631(%rip), %xmm1     # 0x170f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x30(%r14), %xmm0
movq %rbx, %rdi
callq 0x33c0
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32f0
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x14b1b
movq %rax, %rdx
movq %r15, %rcx
xorl %esi, %esi
cmpq %r13, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x14af8
cmpq %r15, %rcx
je 0x14b1b
cmpq 0x20(%rcx), %r13
jae 0x14b63
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
incq %r13
movq %r15, %rdi
callq 0x31a0
cmpq 0x20(%rax), %r13
jb 0x14aaa
jmp 0x14b9f
movq %r15, %rcx
xorl %edx, %edx
cmpq %r13, 0x20(%rax)
setb %dl
cmovaeq %rax, %rcx
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x14b66
movq %r15, %rax
cmpq %r15, %rcx
je 0x14b90
cmpq 0x20(%rcx), %r13
cmovbq %r15, %rcx
movq %rcx, %rax
movsd 0x28(%rax), %xmm0
movq %rbx, %rdi
callq 0x33c0
jmp 0x14b25
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/plugin/co_class_set.h
// Function: Boss::RefObjPtr<Boss::IBase> Boss::Private::CoClassSet<std::tuple<Boss::ServiceRegistry>, 0>::CreateObject<>(unsigned int)
static RefObjPtr<IBase> CreateObject(ClassId clsId, Args const & ... args)
      {
        typedef typename std::tuple_element<I, T>::type CurType;
        if (clsId == GetCoClassId<CurType>::Id)
        {
          RefObjPtr<IBase> Obj;
          Base<CurType>::Create(args ... ).QueryInterface(Obj.GetPPtr());
          return std::move(Obj);
        }
        return std::move(CoClassSet<T, I - 1>::CreateObject(clsId, args ... ));
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x2b89e12a, %esi       # imm = 0x2B89E12A
jne 0x897a7
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x83400
movq (%r14), %rdi
testq %rdi, %rdi
je 0x897a0
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
callq *0x28(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x897a0
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
jmp 0x897b7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x85250
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x897f4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x897da
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x897ea
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x1330a0
jmp 0x897f4
movq %rax, %rdi
callq 0x89745
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/fnv_x.c
// Function: main
int
main(int argc, char const **argv)
{
    if (argc != 2)
        return fputs("Usage: fnv_x (keyfile | -)\n", stderr);

    FILE    *fp = strcmp(argv[1], "-") ? fopen(argv[1], "r") : stdin;
    if (!fp)
        die(": %s: cannot open", argv[1]);

    char    buf[999];
    while (fgets(buf, sizeof(buf), fp)) {
        char    *cp = strim(buf);
        int     len = strlen(cp);
        printf("%08X %16"F64"u", fnv04(cp, len), fnv08(cp, len));

        char    hash[16];
	fnv16(cp, len, hash);
	dump(hash, buf);
    }

    fclose(fp);

    return  0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
cmpl $0x2, %edi
jne 0x361a
movq %rsi, %r14
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x351c
cmpb $0x0, 0x1(%rdi)
je 0x360b
leaq 0x3552(%rip), %rsi      # 0x6a75
callq 0x31f0
movq %rax, %rbx
testq %rbx, %rbx
je 0x3641
leaq 0x10(%rsp), %rdi
movl $0x3e7, %esi            # imm = 0x3E7
movq %rbx, %rdx
callq 0x32b0
testq %rax, %rax
je 0x35ef
leaq 0x10(%rsp), %r14
leaq 0x2ae2(%rip), %r13      # 0x603d
movq %r14, %rdi
callq 0x4725
movq %rax, %r15
movq %rax, %rdi
callq 0x30b0
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x3654
movl %eax, %ebp
movq %r15, %rdi
movl %r12d, %esi
callq 0x369a
leaq 0x2aa2(%rip), %rdi      # 0x6032
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3040
movq %r15, %rdi
movl %r12d, %esi
movq %rsp, %rdx
callq 0x370b
movl $0x10, %r15d
movzbl -0x1(%rsp,%r15), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3040
decq %r15
jne 0x35b0
leaq 0x32c7(%rip), %rdi      # 0x6893
movq %r14, %rsi
xorl %eax, %eax
callq 0x3040
movq %r14, %rdi
movl $0x3e7, %esi            # imm = 0x3E7
movq %rbx, %rdx
callq 0x32b0
testq %rax, %rax
jne 0x355b
movq %rbx, %rdi
callq 0x3190
xorl %eax, %eax
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x59c6(%rip), %rax      # 0x8fd8
movq (%rax), %rbx
jmp 0x352b
movq 0x59bf(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
leaq 0x29d9(%rip), %rdi      # 0x6004
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
movq 0x8(%r14), %rsi
leaq 0x29d4(%rip), %rdi      # 0x6020
xorl %eax, %eax
callq 0x3f7e
nop
// File: /workspace/github_cpp_makefile_star2_O3/deadshot465[P]OwoifyCpp/./owoify.h
// Function: std::enable_if<624ul != 0, std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>>::type Utility::getRandomSeededEngine<std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>, 624ul>()
static auto getRandomSeededEngine() -> typename std::enable_if<N != 0, T>::type
	{
		typename T::result_type data[N];
		std::random_device rd;
		std::generate(std::begin(data), std::end(data), std::ref(rd));
		std::seed_seq seeds(std::begin(data), std::end(data));
		T engine(seeds);
		return engine;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2728, %rsp           # imm = 0x2728
movq %rdi, %rbx
leaq 0x13a0(%rsp), %r15
movq %r15, %rdi
callq 0x1c4c0
leaq 0x13a0(%rsp), %r14
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x53b0
movl %eax, %eax
movq %rax, 0x20(%rsp,%r12)
addq $0x8, %r12
cmpq $0x1380, %r12           # imm = 0x1380
jne 0x7b2e
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x1c53a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c7a8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7b80
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5300
leaq 0x13a0(%rsp), %rdi
callq 0x52d0
movq %rbx, %rax
addq $0x2728, %rsp           # imm = 0x2728
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7bd7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7bc2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5300
jmp 0x7bc2
jmp 0x7bbf
movq %rax, %rbx
leaq 0x13a0(%rsp), %rdi
callq 0x52d0
movq %rbx, %rdi
callq 0x5470
movq %rax, %rdi
callq 0xaf6b
nop
// File: /workspace/github_cpp_makefile_star2_O3/deadshot465[P]OwoifyCpp/./owoify.h
// Function: Utility::map_PeriodCommaExclamationSemicolon_To_Kaomojis(Word&)
static Word map_PeriodCommaExclamationSemicolon_To_Kaomojis(Word& input)
	{
		auto index = ::floorf(getRandomValue(0.0f, 1.0f) * m_faces.size());
		input = input.replace(MAP_PERIOD_COMMA_EXCLAMATION_SEMICOLON_TO_KAOMOJIS_FIRST, [&]() {
			return L" " + m_faces[index];
			});

		index = ::floorf(getRandomValue(0.0f, 1.0f) * m_faces.size());
		input = input.replace(MAP_PERIOD_COMMA_EXCLAMATION_SEMICOLON_TO_KAOMOJIS_SECOND, [&]() {
			return L" " + m_faces[index];
			});

		return input;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2249c(%rip), %rdi     # 0x2b030
callq 0xe4c9
movq 0x22478(%rip), %rax     # 0x2b018
subq 0x22469(%rip), %rax     # 0x2b010
sarq $0x5, %rax
js 0x8bb4
cvtsi2ss %rax, %xmm1
jmp 0x8bc9
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
mulss %xmm1, %xmm0
callq 0x5110
leaq 0xc(%rsp), %r15
movss %xmm0, (%r15)
leaq 0x10(%rsp), %rdx
movq $0x0, 0x8(%rdx)
movq %r15, (%rdx)
leaq 0x60fb(%rip), %rax      # 0xecee
movq %rax, 0x18(%rdx)
leaq 0x6136(%rip), %rax      # 0xed34
movq %rax, 0x10(%rdx)
leaq 0x21c37(%rip), %rsi     # 0x2a840
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xe74e
movq %r14, %rdi
movq %rax, %rsi
callq 0xecbc
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8c37
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x223f2(%rip), %rdi     # 0x2b030
callq 0xe4c9
movq 0x223ce(%rip), %rax     # 0x2b018
subq 0x223bf(%rip), %rax     # 0x2b010
sarq $0x5, %rax
js 0x8c61
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
jmp 0x8c79
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
mulss %xmm1, %xmm0
callq 0x5110
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdx
movq $0x0, 0x8(%rdx)
movq %r15, (%rdx)
leaq 0x64fb(%rip), %rax      # 0xf19a
movq %rax, 0x18(%rdx)
leaq 0x6536(%rip), %rax      # 0xf1e0
movq %rax, 0x10(%rdx)
leaq 0x21bb3(%rip), %rsi     # 0x2a868
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xe74e
movq %r14, %rdi
movq %rax, %rsi
callq 0xecbc
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8ce3
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab6a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8d43
jmp 0x8d43
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8d3b
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8d3b
jmp 0x8d43
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8d3b
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5470
movq %rax, %rdi
callq 0xaf6b
nop
// File: /workspace/github_cpp_makefile_star2_O3/deadshot465[P]OwoifyCpp/./owoify.h
// Function: Utility::map_SpecificConsonants_O_To_Letter_And_Wo(Word&)
static Word map_SpecificConsonants_O_To_Letter_And_Wo(Word& input)
	{
		return input.replace(MAP_SPECIFIC_CONSONANTS_O_TO_LETTER_AND_WO_LOWER, L"$1wo")
			.replace(MAP_SPECIFIC_CONSONANTS_O_TO_LETTER_AND_WO_UPPER, [&](const std::wstring& m1,
				const std::wstring& m2) {

					std::wstring upper = L"";
					for (const auto& c : m2)
					{
						upper += c;
					}

					return m1 + (upper == m2 ? L"W" : L"w") + m2;
				});
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1451e(%rip), %rsi     # 0x1dd84
leaq 0x14527(%rip), %rdx     # 0x1dd94
movq %rsp, %r15
movq %r15, %rdi
callq 0xdb98
leaq 0x21309(%rip), %rsi     # 0x2ab88
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xa6ac
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x6308(%rip), %rcx      # 0xfba6
movq %rcx, 0x18(%rdx)
leaq 0x630b(%rip), %rcx      # 0xfbb4
movq %rcx, 0x10(%rdx)
leaq 0x212fc(%rip), %rsi     # 0x2abb0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xf206
movq %rbx, %rdi
movq %rax, %rsi
callq 0xab6a
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x98e2
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x98fd
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x5300
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9952
movq %rax, %rbx
jmp 0x992f
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x992f
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x994a
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x5300
movq %rbx, %rdi
callq 0x5470
movq %rax, %rdi
callq 0xaf6b
// File: /workspace/github_cpp_makefile_star2_O3/deadshot465[P]OwoifyCpp/./owoify.h
// Function: Word::operator=(Word const&)
Word& operator=(const Word& word)
	{
		if (&word == this) return *this;

		m_word = word.m_word;
		m_replacedWords = word.m_replacedWords;
		return *this;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xece3
movq %rsi, %r14
movq %rbx, %rdi
callq 0x53f0
leaq 0x20(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0xedea
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/deadshot465[P]OwoifyCpp/./owoify.h
// Function: Owoifier::stringToWstring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::wstring stringToWstring(const std::string& source)
	{
		auto str = std::wstring();
		str.reserve(source.size());

		for (const auto& c : source)
		{
			str += c;
		}

		return str;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x5040
movq 0x8(%r14), %r12
testq %r12, %r12
je 0xfdb8
movq (%r14), %r14
xorl %r13d, %r13d
movsbl (%r14,%r13), %esi
movq %rbx, %rdi
callq 0x5120
incq %r13
cmpq %r13, %r12
jne 0xfda3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xfdc7
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xfde2
movq (%r15), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x5300
movq %r14, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O3/deadshot465[P]OwoifyCpp/./owoify.h
// Function: Owoifier::join[abi:cxx11](std::deque<Word, std::allocator<Word>> const&)
static std::wstring join(const std::deque<Word>& words)
	{
		auto ss = std::wstringstream();

		for (const auto& word : words)
		{
			ss << word;
		}

		return ss.str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x50b0
movq 0x10(%r14), %r12
movq 0x30(%r14), %r15
cmpq %r15, %r12
je 0x103d8
movq 0x20(%r14), %rbp
movq 0x28(%r14), %r13
leaq 0x10(%rsp), %r14
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x50f0
addq $0x58, %r12
cmpq %rbp, %r12
jne 0x103d3
movq 0x8(%r13), %r12
addq $0x8, %r13
leaq 0x1b8(%r12), %rbp
cmpq %r15, %r12
jne 0x103a9
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
movq 0x19bcc(%rip), %rsi     # 0x29fb8
movq %rsp, %rdi
callq 0x5400
leaq 0x80(%rsp), %rdi
callq 0x50c0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10418
movq %rax, %rbx
movq 0x19b96(%rip), %rsi     # 0x29fb8
movq %rsp, %rdi
callq 0x5400
leaq 0x80(%rsp), %rdi
callq 0x50c0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O3/deadshot465[P]OwoifyCpp/./owoify.h
// Function: Word::operator=(Word&&)
Word& operator=(Word&& word) noexcept
	{
		if (&word == this) return *this;

		m_word = std::move(word.m_word);
		m_replacedWords = std::move(word.m_replacedWords);
		return *this;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x10bb1
movq %rsi, %r14
movq %rbx, %rdi
callq 0x54e0
addq $0x20, %r14
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x5530
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xaf6b
// File: /workspace/github_cpp_makefile_star2_O3/alan0201tw[P]RayTracer/src/aarect.cpp
// Function: xy_rect::hit(ray const&, float, float, hit_record&) const
bool xy_rect::hit(const ray& _ray, float t_min, float t_max, hit_record& rec) const 
{
    float t = (k - _ray.origin().z()) / _ray.direction().z();
    if(t < t_min || t > t_max)
    {
        return false;
    }
    float x = _ray.origin().x() + t * _ray.direction().x();
    float y = _ray.origin().y() + t * _ray.direction().y();
    if(x < x0 || x > x1 || y < y0 || y > y1)
    {
        return false;
    }
    rec.u = (x - x0) / (x1 - x0);
    rec.v = (y - y0) / (y1 - y0);
    rec.t = t;
    rec.material_ref = rect_material;
    rec.hit_point = _ray.point_at_parameter(t);
    rec.normal = vec3(0.0f, 0.0f, 1.0f);
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movss 0x18(%rdi), %xmm6
subss 0x8(%rsi), %xmm6
divss 0x14(%rsi), %xmm6
xorl %eax, %eax
ucomiss %xmm6, %xmm0
ja 0x843d
ucomiss %xmm1, %xmm6
ja 0x843d
movq %rdi, %rsi
movsd (%r14), %xmm1
movsd 0xc(%r14), %xmm0
movaps %xmm6, %xmm7
shufps $0x0, %xmm6, %xmm7      # xmm7 = xmm7[0,0],xmm6[0,0]
mulps %xmm7, %xmm0
addps %xmm1, %xmm0
movss 0x8(%rdi), %xmm1
ucomiss %xmm0, %xmm1
ja 0x843b
movss 0xc(%rsi), %xmm2
ucomiss %xmm2, %xmm0
ja 0x843b
movss 0x10(%rsi), %xmm3
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
ucomiss %xmm5, %xmm3
ja 0x843b
movss 0x14(%rsi), %xmm4
ucomiss %xmm4, %xmm5
jbe 0x8445
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subps %xmm1, %xmm0
unpcklps %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subps %xmm1, %xmm2
divps %xmm2, %xmm0
movlps %xmm0, 0x4(%rdx)
movss %xmm6, (%rdx)
movq 0x20(%rsi), %rax
movq %rax, 0x28(%rdx)
leaq 0x30(%rdx), %rdi
addq $0x28, %rsi
movaps %xmm6, (%rsp)
movaps %xmm7, 0x10(%rsp)
callq 0x7a28
movaps (%rsp), %xmm2
mulss 0x14(%r14), %xmm2
movsd (%r14), %xmm0
movsd 0xc(%r14), %xmm1
movaps 0x10(%rsp), %xmm3
mulps %xmm1, %xmm3
addps %xmm0, %xmm3
addss 0x8(%r14), %xmm2
movlps %xmm3, 0xc(%rbx)
movss %xmm2, 0x14(%rbx)
movq $0x0, 0x18(%rbx)
movl $0x3f800000, 0x20(%rbx) # imm = 0x3F800000
movb $0x1, %al
jmp 0x843d
// File: /workspace/github_cpp_makefile_star2_O3/alan0201tw[P]RayTracer/src/aarect.cpp
// Function: xz_rect::hit(ray const&, float, float, hit_record&) const
bool xz_rect::hit(const ray& _ray, float t_min, float t_max, hit_record& rec) const
{
    float t = (k - _ray.origin().y()) / _ray.direction().y();
    if(t < t_min || t > t_max)
    {
        return false;
    }
    float x = _ray.origin().x() + t * _ray.direction().x();
    float z = _ray.origin().z() + t * _ray.direction().z();
    if(x < x0 || x > x1 || z < z0 || z > z1)
    {
        return false;
    }
    rec.u = (x - x0) / (x1 - x0);
    rec.v = (z - z0) / (z1 - z0);
    rec.t = t;
    rec.material_ref = rect_material;
    rec.hit_point = _ray.point_at_parameter(t);
    rec.normal = vec3(0.0f, 1.0f, 0.0f);
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movss 0x18(%rdi), %xmm6
movsd (%rsi), %xmm2
movsd 0xc(%rsi), %xmm3
movaps %xmm2, %xmm4
shufps $0x55, %xmm2, %xmm4     # xmm4 = xmm4[1,1],xmm2[1,1]
subss %xmm4, %xmm6
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
divss %xmm4, %xmm6
xorl %eax, %eax
ucomiss %xmm6, %xmm0
ja 0x85a5
ucomiss %xmm1, %xmm6
ja 0x85a5
movq %rdi, %rsi
movaps %xmm6, %xmm7
shufps $0x0, %xmm6, %xmm7      # xmm7 = xmm7[0,0],xmm6[0,0]
movss 0x8(%r14), %xmm1
movss 0x14(%r14), %xmm0
movlhps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm0     # xmm0 = xmm0[2,0],xmm3[2,3]
movlhps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
shufps $0xe2, %xmm2, %xmm1     # xmm1 = xmm1[2,0],xmm2[2,3]
mulps %xmm7, %xmm0
addps %xmm1, %xmm0
movss 0x8(%rdi), %xmm1
ucomiss %xmm0, %xmm1
ja 0x85a3
movss 0xc(%rsi), %xmm2
ucomiss %xmm2, %xmm0
ja 0x85a3
movss 0x10(%rsi), %xmm3
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
ucomiss %xmm5, %xmm3
ja 0x85a3
movss 0x14(%rsi), %xmm4
ucomiss %xmm4, %xmm5
jbe 0x85ad
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subps %xmm1, %xmm0
unpcklps %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subps %xmm1, %xmm2
divps %xmm2, %xmm0
movlps %xmm0, 0x4(%rdx)
movss %xmm6, (%rdx)
movq 0x20(%rsi), %rax
movq %rax, 0x28(%rdx)
leaq 0x30(%rdx), %rdi
addq $0x28, %rsi
movaps %xmm6, (%rsp)
movaps %xmm7, 0x10(%rsp)
callq 0x7a28
movaps (%rsp), %xmm2
mulss 0x14(%r14), %xmm2
movsd (%r14), %xmm0
movsd 0xc(%r14), %xmm1
movaps 0x10(%rsp), %xmm3
mulps %xmm1, %xmm3
addps %xmm0, %xmm3
addss 0x8(%r14), %xmm2
movlps %xmm3, 0xc(%rbx)
movss %xmm2, 0x14(%rbx)
movsd 0x33bf4(%rip), %xmm0    # 0x3c210
movsd %xmm0, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
movb $0x1, %al
jmp 0x85a5
nop