LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5e5f
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 0x5e70
movb %al, (%rsp,%r13)
incq %r13
cmpq $0x8, %r13
jne 0x5e09
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 0x5c9c
movl %eax, %ebx
movq (%r15), %rdi
callq 0x1150
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
jne 0x5df9
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_O1/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 0x130a
pushq %rbp
movq %rsp, %rbp
xorl %r8d, %r8d
movq %rsi, %rax
cmpl %edx, (%rdi)
jne 0x12ff
cmpq %rsi, %rax
cmoveq %rdi, %rax
incq %r8
movq %r8, (%rcx)
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x12ee
popq %rbp
retq
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14b2d(%rip), %r13     # 0x1cfc8
leaq 0xf248(%rip), %rsi      # 0x176ea
movl $0x21, %edx
movq %r13, %rdi
callq 0x3300
movq (%r13), %rax
addq -0x18(%rax), %r13
movq %r13, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq 0x14afa(%rip), %rdi     # 0x1cfc8
callq 0x3040
movq %rax, %rdi
callq 0x31e0
testq %r14, %r14
je 0x8534
xorl %ebp, %ebp
xorl %r13d, %r13d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl %r13d, (%rsp)
movl %ebp, 0x4(%rsp)
movl %ebp, 0xc(%rsp)
movl %r12d, 0x8(%rsp)
movl %r15d, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8521
movl 0x10(%rsp), %eax
movl %eax, 0x10(%rsi)
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x14, 0x8(%rbx)
jmp 0x852c
movq %rbx, %rdi
movq %rsp, %rdx
callq 0xe1d2
incq %r13
cmpq %r13, %r14
jne 0x84e5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8545
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8555
callq 0x3290
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13fc3(%rip), %rbx     # 0x1cfc8
leaq 0xe667(%rip), %rsi      # 0x17673
movl $0x15, %edx
movq %rbx, %rdi
callq 0x3300
movq %rbx, %rdi
movq %r13, %rsi
callq 0x31d0
movq %rax, %r13
leaq 0xec99(%rip), %rbx      # 0x17cc7
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3300
movq %r13, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3300
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 0x32b0
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 0x1324e
movq 0x20(%r14), %rax
imulq 0x18(%r14), %rax
imulq 0x28(%r14), %rax
testq %rax, %rax
je 0x90e5
xorl %esi, %esi
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x9135
movb %bpl, (%rax,%rsi)
movq 0x20(%r14), %rax
imulq 0x18(%r14), %rax
incq %rsi
imulq 0x28(%r14), %rax
cmpq %rax, %rsi
jb 0x90bc
leaq 0xe59d(%rip), %rsi      # 0x17689
movl $0xb, %edx
movq 0x13ed0(%rip), %rbx     # 0x1cfc8
movq %rbx, %rdi
callq 0x3300
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
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 0xe62d(%rip), %rdi      # 0x17769
xorl %eax, %eax
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movslq %edi, %rsi
cmpq %rsi, %rdx
jbe 0xe4e2
movl (%rax,%rsi,4), %edi
testl %edi, %edi
jns 0xe4de
negl %edi
jmp 0xe4cb
movl %edi, %eax
popq %rcx
retq
leaq 0x9280(%rip), %rdi      # 0x17769
xorl %eax, %eax
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
movl %esi, %eax
movl %edi, %esi
movl %eax, %edi
cmpl %eax, %esi
jg 0xe4f1
cltq
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0xe51b
movl %esi, %edx
negl %edx
movl %edx, (%rcx,%rax,4)
movl %esi, %eax
popq %rcx
retq
leaq 0x9247(%rip), %rdi      # 0x17769
movq %rax, %rsi
xorl %eax, %eax
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd4d8(%rip), %rbx      # 0x1cfc8
leaq 0x7e00(%rip), %rsi      # 0x178f7
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x3300
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x33d0
movq %rax, %r12
leaq 0x7df3(%rip), %rsi      # 0x17916
movl $0x6, %edx
movq %rax, %rdi
callq 0x3300
movq %r12, %rdi
callq 0x31e0
movl 0x28(%r15), %eax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xfbce
movl 0x18(%r15), %ebx
movl 0x20(%r15), %eax
movq %rax, 0x8(%rsp)
movsd (%rsp), %xmm0
addsd 0x7514(%rip), %xmm0     # 0x17078
movsd %xmm0, (%rsp)
xorl %r12d, %r12d
cmpq $0x0, 0x8(%rsp)
je 0xfbc4
xorl %r13d, %r13d
testq %rbx, %rbx
je 0xfbba
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xf418
cvtss2sd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xfbb2
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x949e
incq %rbp
cmpq %rbp, %rbx
jne 0xfb7e
incq %r13
cmpq 0x8(%rsp), %r13
jne 0xfb77
incq %r12
cmpq 0x10(%rsp), %r12
jne 0xfb6c
leaq 0x7cf8(%rip), %rsi      # 0x178cd
movl $0x5, %edx
movq 0xd3e7(%rip), %rbx      # 0x1cfc8
movq %rbx, %rdi
callq 0x3300
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
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_O1/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 0x114ce
movl %edi, %eax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x114bd
movl (%rcx,%rax,4), %edi
testl %edi, %edi
jns 0x114b9
negl %edi
jmp 0x11495
movl %edi, %eax
popq %rcx
retq
leaq 0x62a5(%rip), %rdi      # 0x17769
movq %rax, %rsi
xorl %eax, %eax
callq 0x33a0
leaq 0x64ad(%rip), %rdi      # 0x17982
leaq 0x6540(%rip), %rsi      # 0x17a1c
leaq 0x6556(%rip), %rcx      # 0x17a39
movl $0x1f, %edx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12ebe
movl %edi, %eax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x12ead
movl (%rcx,%rax,4), %edi
testl %edi, %edi
jns 0x12ea9
negl %edi
jmp 0x12e85
movl %edi, %eax
popq %rcx
retq
leaq 0x48b5(%rip), %rdi      # 0x17769
movq %rax, %rsi
xorl %eax, %eax
callq 0x33a0
leaq 0x4abd(%rip), %rdi      # 0x17982
leaq 0x4abd(%rip), %rsi      # 0x17989
leaq 0x4abf(%rip), %rcx      # 0x17992
movl $0x17, %edx
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12f0b
movl %edi, %esi
movl %eax, %edi
jg 0x12edf
cltq
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x12f2a
movl %esi, %edx
negl %edx
movl %edx, (%rcx,%rax,4)
movl %esi, %eax
popq %rcx
retq
leaq 0x4abb(%rip), %rdi      # 0x179cd
leaq 0x4a70(%rip), %rsi      # 0x17989
leaq 0x4ab4(%rip), %rcx      # 0x179d4
movl $0x20, %edx
callq 0x31c0
leaq 0x4838(%rip), %rdi      # 0x17769
movq %rax, %rsi
xorl %eax, %eax
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x14b13
movq %rdi, %rbx
divsd 0x30(%rdi), %xmm0
cvttsd2si %xmm0, %eax
movslq %eax, %r15
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %r14
movq %r14, %rcx
testq %rdx, %rdx
je 0x14a92
movq %r14, %rcx
xorl %esi, %esi
cmpq %r15, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x14a7a
movq %r14, %rdx
cmpq %r14, %rcx
je 0x14aa5
cmpq %r15, 0x20(%rcx)
cmovaq %r14, %rcx
movq %rcx, %rdx
cmpq %r14, %rdx
jne 0x14ac1
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq $0x0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x14df4
movq 0x10(%rbx), %rcx
movq %r14, %rax
testq %rcx, %rcx
je 0x14ae7
movq %r14, %rax
xorl %edx, %edx
cmpq %r15, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x14ad0
cmpq %r14, %rax
je 0x14af4
cmpq %r15, 0x20(%rax)
cmovbeq %rax, %r14
movsd 0x28(%r14), %xmm0
addsd 0x254e(%rip), %xmm0     # 0x17050
movsd %xmm0, 0x28(%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3150
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
movb $0x1, %bpl
leaq 0x3145(%rip), %rsi      # 0x17c76
leaq 0x316f(%rip), %rdx      # 0x17ca7
movq %rbx, %rdi
callq 0x131be
xorl %ebp, %ebp
leaq 0x8237(%rip), %rsi      # 0x1cd80
movq 0x8458(%rip), %rdx      # 0x1cfa8
movq %rbx, %rdi
callq 0x3420
movq %rax, %r14
testb %bpl, %bpl
je 0x14b68
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14d0f
movq %rsi, %r14
movq 0x8437(%rip), %r12      # 0x1cfc8
leaq 0x3110(%rip), %rsi      # 0x17ca8
movl $0x1b, %edx
movq %r12, %rdi
callq 0x3300
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 0x32b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %r15, %rdi
callq 0x31a0
cmpq $0x0, 0x20(%rax)
je 0x14d0f
xorl %r13d, %r13d
leaq 0x30c0(%rip), %r12      # 0x17cc4
movq %r13, %xmm1
punpckldq 0x24df(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x24e7(%rip), %xmm1     # 0x17100
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x30(%r14), %xmm0
movq %rbx, %rdi
callq 0x33d0
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3300
movq 0x10(%r14), %rax
movq %r15, %rcx
testq %rax, %rax
je 0x14c6d
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 0x14c55
movq %r15, %rdx
cmpq %r15, %rcx
je 0x14c80
cmpq 0x20(%rcx), %r13
cmovbq %r15, %rcx
movq %rcx, %rdx
cmpq %r15, %rdx
je 0x14cc9
movq %r15, %rcx
testq %rax, %rax
je 0x14ca7
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 0x14c90
movq %r15, %rax
cmpq %r15, %rcx
je 0x14cba
cmpq 0x20(%rcx), %r13
cmovbq %r15, %rcx
movq %rcx, %rax
movsd 0x28(%rax), %xmm0
movq %rbx, %rdi
callq 0x33d0
jmp 0x14cd3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3430
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
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 0x14c04
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8e836
movq $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x88400
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8e81f
movq (%rdi), %rax
leaq 0x10(%rsp), %rdx
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8e82f
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x10(%rsp), %rax
jmp 0x8e846
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x8a250
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x8e891
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8e869
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x8e879
jmp 0x8e891
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8e889
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x138820
movq %rax, %rdi
callq 0x8e7d5
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH05_Statements/examples/doWhile.cc
// Function: main
int main()
{
    // repeatedly ask the user for a pair of numbers to sum
    string rsp;  // used in the condition; can't be defined inside the do
    do {
        cout << "please enter two values: ";
        int val1 = 0, val2 = 0;
        cin  >> val1 >> val2;
        cout << "The sum of " << val1 << " and " << val2
             << " = " << val1 + val2 << "\n\n"
             << "More? Enter yes or no: ";
        cin  >> rsp;
    } while (!rsp.empty() && rsp[0] != 'n');

	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2d89(%rip), %rbx      # 0x3fd0
xorl %r12d, %r12d
movq 0x2d8f(%rip), %r15      # 0x3fe0
leaq -0x50(%rbp), %r13
movl $0x19, %edx
movq %rbx, %rdi
leaq 0xda0(%rip), %rsi       # 0x2004
callq 0x1090
movl %r12d, -0x30(%rbp)
movl %r12d, -0x2c(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0x1040
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1040
movl $0xb, %edx
movq %rbx, %rdi
leaq 0xd86(%rip), %rsi       # 0x201e
callq 0x1090
movl -0x30(%rbp), %esi
movq %rbx, %rdi
callq 0x10c0
movq %rax, %r14
movl $0x5, %edx
movq %rax, %rdi
leaq 0xd70(%rip), %rsi       # 0x202a
callq 0x1090
movl -0x2c(%rbp), %esi
movq %r14, %rdi
callq 0x10c0
movq %rax, %r14
movl $0x3, %edx
movq %rax, %rdi
leaq 0xd54(%rip), %rsi       # 0x2030
callq 0x1090
movl -0x2c(%rbp), %esi
addl -0x30(%rbp), %esi
movq %r14, %rdi
callq 0x10c0
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
leaq 0xd33(%rip), %rsi       # 0x2034
callq 0x1090
movl $0x17, %edx
movq %r14, %rdi
leaq 0xd22(%rip), %rsi       # 0x2037
callq 0x1090
movq %r15, %rdi
movq %r13, %rsi
callq 0x10a0
cmpq $0x0, -0x48(%rbp)
je 0x1339
movq -0x50(%rbp), %rax
cmpb $0x6e, (%rax)
jne 0x1255
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq 0x2c79(%rip), %rdi      # 0x3fd0
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x137d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1080
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1392
jmp 0x1392
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x13ae
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x361e
movq %rsi, %r14
movq 0x8(%rsi), %rbx
leaq 0x2b0c(%rip), %rsi      # 0x6020
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x3534
leaq 0x354e(%rip), %rsi      # 0x6a75
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rbx
jmp 0x353e
movq 0x5a9d(%rip), %rax      # 0x8fd8
movq (%rax), %rbx
testq %rbx, %rbx
je 0x3645
leaq 0x10(%rsp), %rdi
movl $0x3e7, %esi            # imm = 0x3E7
movq %rbx, %rdx
callq 0x32b0
testq %rax, %rax
je 0x3602
leaq 0x10(%rsp), %r14
leaq 0x2ad1(%rip), %r13      # 0x603f
movq %r14, %rdi
callq 0x4723
movq %rax, %r15
movq %rax, %rdi
callq 0x30b0
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x3658
movl %eax, %ebp
movq %r15, %rdi
movl %r12d, %esi
callq 0x369e
leaq 0x2a91(%rip), %rdi      # 0x6034
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3040
movq %r15, %rdi
movl %r12d, %esi
movq %rsp, %rdx
callq 0x370f
movl $0x10, %r15d
movzbl -0x1(%rsp,%r15), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3040
decq %r15
jne 0x35c3
leaq 0x32b4(%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 0x356e
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 0x59bb(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
leaq 0x29d5(%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 0x29d2(%rip), %rdi      # 0x6022
xorl %eax, %eax
callq 0x3f7f
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c538
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 0x7b4e
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x1c5b2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c81a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7ba0
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 0x7bf7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7be2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5300
jmp 0x7be2
jmp 0x7bdf
movq %rax, %rbx
leaq 0x13a0(%rsp), %rdi
callq 0x52d0
movq %rbx, %rdi
callq 0x5470
movq %rax, %rdi
callq 0xafa5
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2247c(%rip), %rdi     # 0x2b030
callq 0xe4e3
movq 0x22458(%rip), %rax     # 0x2b018
subq 0x22449(%rip), %rax     # 0x2b010
sarq $0x5, %rax
js 0x8bd4
cvtsi2ss %rax, %xmm1
jmp 0x8be9
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)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %r15, (%rdx)
leaq 0x60f7(%rip), %rax      # 0xed0c
movq %rax, 0x18(%rdx)
leaq 0x6132(%rip), %rax      # 0xed52
movq %rax, 0x10(%rdx)
leaq 0x21c15(%rip), %rsi     # 0x2a840
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xe764
movq %r14, %rdi
movq %rax, %rsi
callq 0xecda
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8c59
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x223d0(%rip), %rdi     # 0x2b030
callq 0xe4e3
movq 0x223ac(%rip), %rax     # 0x2b018
subq 0x2239d(%rip), %rax     # 0x2b010
sarq $0x5, %rax
js 0x8c83
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
jmp 0x8c9b
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)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %r15, (%rdx)
leaq 0x64ed(%rip), %rax      # 0xf1b0
movq %rax, 0x18(%rdx)
leaq 0x6528(%rip), %rax      # 0xf1f6
movq %rax, 0x10(%rdx)
leaq 0x21b8f(%rip), %rsi     # 0x2a868
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xe764
movq %r14, %rdi
movq %rax, %rsi
callq 0xecda
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8d07
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaba0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8d67
jmp 0x8d67
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8d5f
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8d5f
jmp 0x8d67
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x8d5f
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5470
movq %rax, %rdi
callq 0xafa5
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x144fa(%rip), %rsi     # 0x1dd84
leaq 0x14503(%rip), %rdx     # 0x1dd94
movq %rsp, %r15
movq %r15, %rdi
callq 0xdbc8
leaq 0x212e5(%rip), %rsi     # 0x2ab88
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xa6d0
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x6314(%rip), %rcx      # 0xfbd6
movq %rcx, 0x18(%rdx)
leaq 0x6317(%rip), %rcx      # 0xfbe4
movq %rcx, 0x10(%rdx)
leaq 0x212d8(%rip), %rsi     # 0x2abb0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xf21c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaba0
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x9906
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x9921
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 0x9976
movq %rax, %rbx
jmp 0x9953
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x9953
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x996e
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x5300
movq %rbx, %rdi
callq 0x5470
movq %rax, %rdi
callq 0xafa5
// File: /workspace/github_cpp_makefile_star2_O1/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 0xed01
movq %rsi, %r14
movq %rbx, %rdi
callq 0x53f0
leaq 0x20(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0xee08
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfdda
movq (%r14), %r14
xorl %r13d, %r13d
movsbl (%r14,%r13), %esi
movq %rbx, %rdi
callq 0x5120
incq %r13
cmpq %r13, %r12
jne 0xfdc5
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xfde9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xfe04
movq (%r15), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x5300
movq %r14, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10420
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 0x1041b
movq 0x8(%r13), %r12
addq $0x8, %r13
leaq 0x1b8(%r12), %rbp
cmpq %r15, %r12
jne 0x103f1
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
movq 0x19b7c(%rip), %rsi     # 0x29fb0
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 0x10460
movq %rax, %rbx
movq 0x19b46(%rip), %rsi     # 0x29fb0
movq %rsp, %rdi
callq 0x5400
leaq 0x80(%rsp), %rdi
callq 0x50c0
movq %rbx, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10bf5
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 0xafa5
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rsi, %r14
movss 0x18(%rdi), %xmm6
subss 0x8(%rsi), %xmm6
divss 0x14(%rsi), %xmm6
xorl %eax, %eax
ucomiss %xmm6, %xmm0
ja 0x8451
ucomiss %xmm1, %xmm6
ja 0x8451
movq %rdi, %rsi
movsd (%r14), %xmm4
movsd 0xc(%r14), %xmm0
movaps %xmm6, %xmm1
mulss %xmm0, %xmm1
addss %xmm4, %xmm1
movss 0x8(%rdi), %xmm2
ucomiss %xmm1, %xmm2
ja 0x844f
movss 0xc(%rsi), %xmm3
ucomiss %xmm3, %xmm1
ja 0x844f
shufps $0x55, %xmm4, %xmm4     # xmm4 = xmm4[1,1,1,1]
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm6, %xmm0
addss %xmm4, %xmm0
movss 0x10(%rsi), %xmm4
ucomiss %xmm0, %xmm4
ja 0x844f
movss 0x14(%rsi), %xmm5
ucomiss %xmm5, %xmm0
jbe 0x8459
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
subss %xmm2, %xmm1
subss %xmm2, %xmm3
divss %xmm3, %xmm1
movss %xmm1, 0x4(%rdx)
subss %xmm4, %xmm0
subss %xmm4, %xmm5
divss %xmm5, %xmm0
movss %xmm0, 0x8(%rdx)
movss %xmm6, (%rdx)
movq 0x20(%rsi), %rax
movq %rax, 0x28(%rdx)
leaq 0x30(%rdx), %rdi
addq $0x28, %rsi
movss %xmm6, 0x4(%rsp)
callq 0x7a04
movss 0xc(%r14), %xmm0
movss 0x4(%rsp), %xmm2
mulss %xmm2, %xmm0
movss 0x10(%r14), %xmm1
mulss %xmm2, %xmm1
mulss 0x14(%r14), %xmm2
addss (%r14), %xmm0
addss 0x4(%r14), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
addss 0x8(%r14), %xmm2
movlps %xmm0, 0xc(%rbx)
movss %xmm2, 0x14(%rbx)
movq $0x0, 0x18(%rbx)
movl $0x3f800000, 0x20(%rbx) # imm = 0x3F800000
movb $0x1, %al
jmp 0x8451
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rsi, %r14
movss 0x18(%rdi), %xmm6
movsd (%rsi), %xmm3
movsd 0xc(%rsi), %xmm2
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
subss %xmm4, %xmm6
movaps %xmm2, %xmm4
shufps $0x55, %xmm2, %xmm4     # xmm4 = xmm4[1,1],xmm2[1,1]
divss %xmm4, %xmm6
xorl %eax, %eax
ucomiss %xmm6, %xmm0
ja 0x85ba
ucomiss %xmm1, %xmm6
ja 0x85ba
movq %rdi, %rsi
mulss %xmm6, %xmm2
addss %xmm3, %xmm2
movss 0x8(%rdi), %xmm1
ucomiss %xmm2, %xmm1
ja 0x85b8
movss 0xc(%rsi), %xmm3
ucomiss %xmm3, %xmm2
ja 0x85b8
movss 0x14(%r14), %xmm0
mulss %xmm6, %xmm0
addss 0x8(%r14), %xmm0
movss 0x10(%rsi), %xmm4
ucomiss %xmm0, %xmm4
ja 0x85b8
movss 0x14(%rsi), %xmm5
ucomiss %xmm5, %xmm0
jbe 0x85c2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
subss %xmm1, %xmm2
subss %xmm1, %xmm3
divss %xmm3, %xmm2
movss %xmm2, 0x4(%rdx)
subss %xmm4, %xmm0
subss %xmm4, %xmm5
divss %xmm5, %xmm0
movss %xmm0, 0x8(%rdx)
movss %xmm6, (%rdx)
movq 0x20(%rsi), %rax
movq %rax, 0x28(%rdx)
leaq 0x30(%rdx), %rdi
addq $0x28, %rsi
movss %xmm6, 0x4(%rsp)
callq 0x7a04
movss 0xc(%r14), %xmm0
movss 0x4(%rsp), %xmm2
mulss %xmm2, %xmm0
movss 0x10(%r14), %xmm1
mulss %xmm2, %xmm1
mulss 0x14(%r14), %xmm2
addss (%r14), %xmm0
addss 0x4(%r14), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
addss 0x8(%r14), %xmm2
movlps %xmm0, 0xc(%rbx)
movss %xmm2, 0x14(%rbx)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
movq %rax, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
movb $0x1, %al
jmp 0x85ba
nop
// File: /workspace/github_cpp_makefile_star2_O1/alan0201tw[P]RayTracer/src/aarect.cpp
// Function: yz_rect::hit(ray const&, float, float, hit_record&) const
bool yz_rect::hit(const ray& _ray, float t_min, float t_max, hit_record& rec) const
{
    float t = (k - _ray.origin().x()) / _ray.direction().x();
    if(t < t_min || t > t_max)
    {
        return false;
    }
    float y = _ray.origin().y() + t * _ray.direction().y();
    float z = _ray.origin().z() + t * _ray.direction().z();
    if(y < y0 || y > y1 || z < z0 || z > z1)
    {
        return false;
    }
    rec.u = (y - y0) / (y1 - y0);
    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(1.0f, 0.0f, 0.0f);
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movss 0x18(%rdi), %xmm6
movsd (%rsi), %xmm3
movsd 0xc(%rsi), %xmm2
subss %xmm3, %xmm6
divss %xmm2, %xmm6
xorl %eax, %eax
ucomiss %xmm6, %xmm0
ja 0x871c
ucomiss %xmm1, %xmm6
ja 0x871c
movq %rdi, %rsi
shufps $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
mulss %xmm6, %xmm2
addss %xmm3, %xmm2
movss 0x8(%rdi), %xmm1
ucomiss %xmm2, %xmm1
ja 0x871a
movss 0xc(%rsi), %xmm3
ucomiss %xmm3, %xmm2
ja 0x871a
movss 0x14(%r14), %xmm0
mulss %xmm6, %xmm0
addss 0x8(%r14), %xmm0
movss 0x10(%rsi), %xmm4
ucomiss %xmm0, %xmm4
ja 0x871a
movss 0x14(%rsi), %xmm5
ucomiss %xmm5, %xmm0
jbe 0x8724
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
subss %xmm1, %xmm2
subss %xmm1, %xmm3
divss %xmm3, %xmm2
movss %xmm2, 0x4(%rdx)
subss %xmm4, %xmm0
subss %xmm4, %xmm5
divss %xmm5, %xmm0
movss %xmm0, 0x8(%rdx)
movss %xmm6, (%rdx)
movq 0x20(%rsi), %rax
movq %rax, 0x28(%rdx)
leaq 0x30(%rdx), %rdi
addq $0x28, %rsi
movss %xmm6, 0x4(%rsp)
callq 0x7a04
movss 0xc(%r14), %xmm0
movss 0x4(%rsp), %xmm2
mulss %xmm2, %xmm0
movss 0x10(%r14), %xmm1
mulss %xmm2, %xmm1
mulss 0x14(%r14), %xmm2
addss (%r14), %xmm0
addss 0x4(%r14), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
addss 0x8(%r14), %xmm2
movlps %xmm0, 0xc(%rbx)
movss %xmm2, 0x14(%rbx)
movq $0x3f800000, 0x18(%rbx) # imm = 0x3F800000
movl $0x0, 0x20(%rbx)
movb $0x1, %al
jmp 0x871c
nop
// File: /workspace/github_cpp_makefile_star2_O1/alan0201tw[P]RayTracer/src/texture.cpp
// Function: checker_texture::value_at_uv(float, float, vec3 const&) const
vec3 checker_texture::value_at_uv(float _u, float _v, const vec3& _hit_point) const
{
    // TODO : 
    // need a way to distinguish sampling from odd and even texture.
    // currently using world space position to do the determination.
    // which will cause artifacts on bending surfaces like a sphere.

    float sines = std::sin(10 * _hit_point.x()) * std::sin(10 * _hit_point.y()) * std::sin(10 * _hit_point.z());
    if(sines < 0.0f)
    {
        return odd_texture->value_at_uv(_u, _v, _hit_point);
    }
    return even_texture->value_at_uv(_u, _v, _hit_point);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movss %xmm1, 0x14(%rsp)
movss %xmm0, 0x10(%rsp)
movq %rdi, %r14
movss (%rsi), %xmm0
mulss 0x339e3(%rip), %xmm0    # 0x3c220
callq 0x6340
movss %xmm0, 0xc(%rsp)
movss 0x4(%rbx), %xmm0
mulss 0x339cb(%rip), %xmm0    # 0x3c220
callq 0x6340
mulss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x339b2(%rip), %xmm0    # 0x3c220
mulss 0x8(%rbx), %xmm0
callq 0x6340
mulss 0xc(%rsp), %xmm0
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss %xmm0, %xmm1
seta %al
shll $0x4, %eax
movq 0x8(%r14,%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movss 0x10(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/alan0201tw[P]RayTracer/src/texture.cpp
// Function: perlin_noise_texture::value_at_uv(float, float, vec3 const&) const
vec3 perlin_noise_texture::value_at_uv(float _u, float _v, const vec3& _hit_point) const
{
    //return vec3(1, 1, 1) * perlin::get_noise(scale * _hit_point);
    //std::cout << perlin::turb(scale * _hit_point) << "\n";
    //return vec3(1, 1, 1) * perlin::turb(scale * _hit_point);
    return vec3(1, 1, 1) * 0.5f * (1 + std::sin(scale * _hit_point.x() + 5.0f * perlin::turb(_hit_point * scale)));
}

// Assembly:
subq $0x28, %rsp
movss 0x8(%rdi), %xmm0
movss (%rsi), %xmm2
mulss %xmm0, %xmm2
movaps %xmm2, (%rsp)
movss 0x4(%rsi), %xmm1
mulss %xmm0, %xmm1
mulss 0x8(%rsi), %xmm0
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq 0x18(%rsp), %rdi
movlps %xmm2, (%rdi)
movss %xmm0, 0x8(%rdi)
movl $0x7, %esi
callq 0xbcdc
mulss 0x3392f(%rip), %xmm0    # 0x3c224
addss (%rsp), %xmm0
callq 0x6340
addss 0x33921(%rip), %xmm0    # 0x3c228
mulss 0x3391d(%rip), %xmm0    # 0x3c22c
movaps %xmm0, %xmm2
shufps $0x0, %xmm0, %xmm2      # xmm2 = xmm2[0,0],xmm0[0,0]
movaps %xmm0, %xmm1
movaps %xmm2, %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/alan0201tw[P]RayTracer/src/texture.cpp
// Function: image_texture::image_texture(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
image_texture::image_texture(std::string _file_name)
{
    data = stbi_load(_file_name.c_str(), &width, &height, &channel, 0);
    std::cout << "SYS : Loading texture : " << _file_name << ", width = " << width << ", height = " << height << ", channel = " << channel << "\n";
    if(data == nullptr)
    {
        std::cerr << "Error when loading texture : " << _file_name << "\n";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x457c4(%rip), %rax     # 0x4e0f8
movq %rax, (%rdi)
movq (%rsi), %rdi
leaq 0x10(%r14), %rsi
leaq 0x14(%r14), %rdx
leaq 0x18(%r14), %rcx
xorl %r8d, %r8d
callq 0x24648
movq %rax, 0x8(%r14)
movq 0x4664f(%rip), %r15     # 0x4efa8
leaq 0x338d8(%rip), %rsi     # 0x3c238
movl $0x18, %edx
movq %r15, %rdi
callq 0x6470
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x6470
movq %rax, %r15
leaq 0x338cb(%rip), %rsi     # 0x3c251
movl $0xa, %edx
movq %rax, %rdi
callq 0x6470
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x66c0
movq %rax, %r15
leaq 0x338b3(%rip), %rsi     # 0x3c25c
movl $0xb, %edx
movq %rax, %rdi
callq 0x6470
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x66c0
movq %rax, %r15
leaq 0x3389c(%rip), %rsi     # 0x3c268
movl $0xc, %edx
movq %rax, %rdi
callq 0x6470
movl 0x18(%r14), %esi
movq %r15, %rdi
callq 0x66c0
leaq 0x341ac(%rip), %rsi     # 0x3cb98
movl $0x1, %edx
movq %rax, %rdi
callq 0x6470
cmpq $0x0, 0x8(%r14)
je 0x8a06
popq %rbx
popq %r14
popq %r15
retq
movq 0x465d3(%rip), %r14     # 0x4efe0
leaq 0x33861(%rip), %rsi     # 0x3c275
movl $0x1d, %edx
movq %r14, %rdi
callq 0x6470
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x6470
leaq 0x34161(%rip), %rsi     # 0x3cb98
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6470
nop