LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq 0x117b4(%rip), %rdi     # 0x17fc8
leaq 0xae84(%rip), %rsi      # 0x1169f
callq 0x3260
movq %rax, %rdi
callq 0x3110
xorl %ebp, %ebp
leaq 0x4(%rsp), %r13
cmpq %rbp, %r14
je 0x685c
movl %ebp, 0x4(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, 0x10(%rsp)
movl %r12d, 0xc(%rsp)
movl %r15d, 0x14(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa526
incq %rbp
jmp 0x682f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x686d
movq %rax, %r14
movq %rbx, %rdi
callq 0xa6a4
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/spatialfruitsalad[P]volume2position/./tomogram.hpp
// Function: tomogram3d<double>::initialise(unsigned long, unsigned long, unsigned long, double)
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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0xe1b4(%rip), %rdi      # 0x17fc8
leaq 0x780d(%rip), %rsi      # 0x11628
callq 0x3260
movq %rax, %rdi
movq %r12, %rsi
callq 0x31a0
leaq 0x7e20(%rip), %r12      # 0x11c52
movq %rax, %rdi
movq %r12, %rsi
callq 0x3260
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3260
movq %rax, %rdi
movq %r14, %rsi
callq 0x31a0
movq %rax, %rdi
callq 0x3110
movq 0x20(%rbx), %rsi
imulq 0x18(%rbx), %rsi
imulq 0x28(%rbx), %rsi
movq %rbx, %rdi
callq 0xa14e
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
imulq 0x18(%rbx), %rax
imulq 0x28(%rbx), %rax
cmpq %rax, %r14
jae 0x9eab
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fb8
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r14
jmp 0x9e7f
movq 0xe116(%rip), %rdi      # 0x17fc8
leaq 0x7785(%rip), %rsi      # 0x1163e
callq 0x3260
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3110
nop
// File: /workspace/github_cpp_makefile_star2_O2/spatialfruitsalad[P]volume2position/./bilateral.hpp
// Function: bilateralFilter::gauss(double, double)
static double gauss(double sigma, double v)
    {
        v = fabs(v);
        if (v > 4.0*sigma) return 0;
        double f = v/sigma;
        // i don't care about the prefactor right here, since the computation will have to calculate the weight anyway.
        return exp (-0.5 * (f * f)  );
    }

// Assembly:
andpd 0x6fc2(%rip), %xmm1     # 0x110e0
movsd 0x6f02(%rip), %xmm2     # 0x11028
mulsd %xmm0, %xmm2
ucomisd %xmm2, %xmm1
jbe 0xa135
xorpd %xmm0, %xmm0
retq
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
mulsd 0x6f1b(%rip), %xmm1     # 0x11060
movapd %xmm1, %xmm0
jmp 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movq 0xc536(%rip), %rdi      # 0x17fc8
leaq 0x5e13(%rip), %rsi      # 0x118ac
callq 0x3260
movq %rax, %rdi
movss (%rsp), %xmm0
callq 0x31f0
leaq 0x5e19(%rip), %rsi      # 0x118cb
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x31b0
movl 0x18(%r14), %ebp
movl 0x20(%r14), %eax
movq %rax, 0x10(%rsp)
movl 0x28(%r14), %eax
movq %rax, 0x8(%rsp)
cvtss2sd (%rsp), %xmm0
addsd 0x558b(%rip), %xmm0     # 0x11070
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
je 0xbb49
xorl %r12d, %r12d
cmpq 0x10(%rsp), %r12
je 0xbb44
xorl %r13d, %r13d
cmpq %r13, %rbp
je 0xbb3f
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xb5c2
cvtss2sd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xbb3a
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x72fc
incq %r13
jmp 0xbb01
incq %r12
jmp 0xbaf7
incq %r15
jmp 0xbaed
movq 0xc478(%rip), %rdi      # 0x17fc8
leaq 0x5d2b(%rip), %rsi      # 0x11882
callq 0x3260
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
testl %edi, %edi
js 0xcb3c
movl %edi, %esi
movq %rbx, %rdi
callq 0xaaee
movl (%rax), %edi
testl %edi, %edi
jns 0xcb38
negl %edi
jmp 0xcb20
movl %edi, %eax
popq %rbx
retq
leaq 0x4df4(%rip), %rdi      # 0x11937
leaq 0x4e87(%rip), %rsi      # 0x119d1
leaq 0x4e9d(%rip), %rcx      # 0x119ee
pushq $0x1f
popq %rdx
callq 0x3190
nop
// File: /workspace/github_cpp_makefile_star2_O2/spatialfruitsalad[P]volume2position/./edm.hpp
// Function: edm::dt(float*, int)
static float *dt(float *f, int n)
    {
        float *d = new float[n];
        int *v = new int[n];
        float *z = new float[n+1];
        int k = 0;
        v[0] = 0;
        z[0] = -INF;
        z[1] = +INF;
        for (int q = 1; q <= n-1; q++)
        {
            float s  = ((f[q]+square(q))-(f[v[k]]+square(v[k])))/(2*q-2*v[k]);
            while (s <= z[k])
            {
                k--;
                s  = ((f[q]+square(q))-(f[v[k]]+square(v[k])))/(2*q-2*v[k]);
            }
            k++;
            v[k] = q;
            z[k] = s;
            z[k+1] = +INF;
        }

        k = 0;
        for (int q = 0; q <= n-1; q++)
        {
            while (z[k+1] < q)
                k++;
            d[q] = square(q-v[k]) + f[v[k]];
        }

        delete [] v;
        delete [] z;
        return d;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r12d
shlq $0x2, %r12
testl %esi, %esi
pushq $-0x1
popq %r13
cmovsq %r13, %r12
movq %r12, %rdi
callq 0x3030
movq %rax, %r15
movq %r12, %rdi
callq 0x3030
movq %rax, %r12
leal 0x1(%rbx), %edi
shlq $0x2, %rdi
cmpl $-0x1, %ebx
cmovlq %r13, %rdi
callq 0x3030
andl $0x0, (%r12)
movq %rax, %r13
movsd 0x3e9c(%rip), %xmm0     # 0x11100
movsd %xmm0, (%rax)
movslq %ebx, %rax
movq %r13, %rcx
addq $0x8, %rcx
movq %r12, %rdx
addq $-0x4, %rdx
pushq $0x1
popq %rsi
xorl %r8d, %r8d
xorl %edi, %edi
cmpq %rax, %rsi
jge 0xd321
movl %esi, %r9d
imull %esi, %r9d
cvtsi2ss %r9d, %xmm0
movslq %r8d, %r9
movl %r9d, %r10d
imull %r9d, %r10d
cvtsi2ss %r10d, %xmm1
addss (%r14,%rsi,4), %xmm0
addss (%r14,%r9,4), %xmm1
movslq %edi, %r10
leaq (%rcx,%r10,4), %r9
leaq (%rdx,%r10,4), %r11
xorl %r10d, %r10d
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movl %esi, %ebp
subl %r8d, %ebp
addl %ebp, %ebp
cvtsi2ss %ebp, %xmm1
divss %xmm1, %xmm2
movss -0x8(%r9,%r10,4), %xmm1
ucomiss %xmm2, %xmm1
jb 0xd2fb
movslq (%r11,%r10,4), %r8
movl %r8d, %ebp
imull %r8d, %ebp
cvtsi2ss %ebp, %xmm1
addss (%r14,%r8,4), %xmm1
decq %r10
jmp 0xd2bf
addl %r10d, %edi
incl %edi
movslq %edi, %r8
movl %esi, (%r12,%r8,4)
movss %xmm2, (%r13,%r8,4)
movl $0x60ad78ec, (%r9,%r10,4) # imm = 0x60AD78EC
movl %esi, %r8d
incq %rsi
jmp 0xd281
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rdx      # imm = 0x100000000
xorl %esi, %esi
cmpq %rbx, %rax
je 0xd391
cvtsi2ss %eax, %xmm0
movslq %esi, %r8
shlq $0x20, %rsi
movq %rsi, %rdi
addq %rcx, %rdi
decq %r8
movq %r8, %rsi
addq %rdx, %rdi
ucomiss 0x8(%r13,%rsi,4), %xmm0
leaq 0x1(%rsi), %rsi
ja 0xd35a
sarq $0x1e, %rdi
movslq (%r12,%rdi), %rdi
movl %eax, %r8d
subl %edi, %r8d
imull %r8d, %r8d
cvtsi2ss %r8d, %xmm0
addss (%r14,%rdi,4), %xmm0
movss %xmm0, (%r15,%rax,4)
incq %rax
jmp 0xd33e
movq %r12, %rdi
callq 0x32f0
movq %r13, %rdi
callq 0x32f0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/spatialfruitsalad[P]volume2position/./tomogram.hpp
// Function: tomogram3d<unsigned char>::write_pgm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long) const
void write_pgm (std::string outfilename, unsigned long picnumber) const
    {
        std::cout << "write " << outfilename << " ... " << std::flush;
        std::ofstream myfile;
        myfile.open (outfilename.c_str());
        myfile << "P2" << std::endl;
        myfile << sx << " " << sy << std::endl;

        VALUE maxvalue = *std::max_element (data.begin()+(picnumber*sx*sy),data.begin()+((picnumber+1)*sx*sy));

        myfile << int(maxvalue) << std::endl;
        for (unsigned long j = 0; j != sy; ++j)
            for (unsigned long i = 0; i != sx; ++i)
            {
                myfile << int(get(i,j,picnumber)) << std::endl;
            }
        myfile.close();
        std::cout << " done" << std::endl;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x9838(%rip), %rdi      # 0x17fc8
leaq 0x3163(%rip), %rsi      # 0x118fa
callq 0x3260
movq %rax, %rdi
movq %r15, %rsi
callq 0x3230
leaq 0x311e(%rip), %rsi      # 0x118cc
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x31b0
movq %rsp, %r12
movq %r12, %rdi
callq 0x33f0
movq (%r15), %rsi
pushq $0x10
popq %rdx
movq %r12, %rdi
callq 0x3040
leaq 0x313b(%rip), %rsi      # 0x11919
movq %rsp, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x3110
movq 0x18(%r14), %rsi
movq %rsp, %rdi
callq 0x31a0
leaq 0x3451(%rip), %rsi      # 0x11c52
movq %rax, %rdi
callq 0x3260
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x3110
movq (%r14), %rax
movq 0x20(%r14), %rdi
imulq 0x18(%r14), %rdi
leaq 0x1(%rbx), %rsi
imulq %rdi, %rsi
imulq %rbx, %rdi
addq %rax, %rdi
addq %rax, %rsi
callq 0xe8eb
movzbl (%rax), %esi
movq %rsp, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x3110
xorl %r15d, %r15d
movq %rsp, %r12
cmpq 0x20(%r14), %r15
je 0xe896
xorl %r13d, %r13d
cmpq 0x18(%r14), %r13
je 0xe891
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xad44
movzbl %al, %esi
movq %r12, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x3110
incq %r13
jmp 0xe862
incq %r15
jmp 0xe859
movq %rsp, %rdi
callq 0x3330
movq 0x9723(%rip), %rdi      # 0x17fc8
leaq 0x2fd6(%rip), %rsi      # 0x11882
callq 0x3260
movq %rax, %rdi
callq 0x3110
movq %rsp, %rdi
callq 0x3350
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xe8d8
jmp 0xe8d8
jmp 0xe8d8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3350
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
testl %edi, %edi
js 0xdf4c
movl %edi, %esi
movq %rbx, %rdi
callq 0xaaee
movl (%rax), %edi
testl %edi, %edi
jns 0xdf48
negl %edi
jmp 0xdf30
movl %edi, %eax
popq %rbx
retq
leaq 0x39e4(%rip), %rdi      # 0x11937
leaq 0x39e4(%rip), %rsi      # 0x1193e
leaq 0x39e6(%rip), %rcx      # 0x11947
pushq $0x17
popq %rdx
callq 0x3190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %ebx, %eax
cmpl %ebx, %edi
je 0xdf95
movl %edi, %ebx
movl %eax, %edi
jg 0xdf6f
movl %ebx, %ebp
negl %ebp
movslq %eax, %rsi
movq %rdx, %rdi
callq 0xaaee
movl %ebp, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x39e6(%rip), %rdi      # 0x11982
leaq 0x399b(%rip), %rsi      # 0x1193e
leaq 0x39df(%rip), %rcx      # 0x11989
pushq $0x20
popq %rdx
callq 0x3190
// File: /workspace/github_cpp_makefile_star2_O2/spatialfruitsalad[P]volume2position/./bilateral.hpp
// Function: bilateralFilter::getGauss(double)
double getGauss (double v)
    {
        v = fabs (v);
        if (v >= 4.0*m_sigmaSimilarity)
            return 0;
        double dx = (4*m_sigmaSimilarity)/static_cast<double>(501);
        unsigned int idx = floor(v/dx);
        return gaussTable[idx];
    }

// Assembly:
andpd 0x2022(%rip), %xmm0     # 0x110e0
movsd 0x10(%rdi), %xmm2
mulsd 0x1f5d(%rip), %xmm2     # 0x11028
xorps %xmm1, %xmm1
ucomisd %xmm2, %xmm0
jae 0xf0fa
pushq %rbx
movq %rdi, %rbx
divsd 0x1f50(%rip), %xmm2     # 0x11030
divsd %xmm2, %xmm0
callq 0x33e0
cvttsd2si %xmm0, %rax
movl %eax, %eax
movq 0x50(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm1
popq %rbx
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0xf46e
movq %rdi, %rbx
divsd 0x30(%rdi), %xmm0
cvttsd2si %xmm0, %ebp
movslq %ebp, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
callq 0xf694
testq %rax, %rax
jne 0xf445
movq %rsp, %rsi
movl %ebp, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rbx, %rdi
callq 0xf704
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xf88e
movsd 0x28(%rax), %xmm0
addsd 0x1be8(%rip), %xmm0     # 0x11048
movsd %xmm0, 0x28(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x2781(%rip), %rsi      # 0x11c01
movq %rsp, %rdx
movq %rax, %rdi
callq 0x30d0
leaq 0x88f6(%rip), %rsi      # 0x17d88
movq 0x8b17(%rip), %rdx      # 0x17fb0
movq %rbx, %rdi
callq 0x3400
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x28(%rsi)
je 0xf5aa
movq %rsi, %r14
movq 0x8af1(%rip), %rdi      # 0x17fc8
leaq 0x2755(%rip), %rsi      # 0x11c33
callq 0x3260
movq %rax, %r12
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x3170
movq 0x20(%rax), %rsi
movq %r12, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x3110
xorl %ebp, %ebp
leaq 0x2740(%rip), %r12      # 0x11c4f
movq %rsp, %r13
movq %rbp, (%rsp)
movq %r15, %rdi
callq 0x3170
cmpq 0x20(%rax), %rbp
jae 0xf5aa
movq %rbp, %xmm1
punpckldq 0x1b8b(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1b93(%rip), %xmm1     # 0x110d0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x30(%r14), %xmm0
movq %rbx, %rdi
callq 0x33a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3260
movq %r14, %rdi
movq %r13, %rsi
callq 0xf694
testq %rax, %rax
je 0xf58c
movq %r14, %rdi
movq %r13, %rsi
callq 0xf6ae
movsd 0x28(%rax), %xmm0
movq %rbx, %rdi
callq 0x33a0
jmp 0xf596
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3410
movq %rbx, %rdi
callq 0x3110
movq (%rsp), %rbp
incq %rbp
jmp 0xf512
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/spatialfruitsalad[P]volume2position/./selectedAreaHistogram.hpp
// Function: area::contains(unsigned int, unsigned int, unsigned int)
inline bool contains(unsigned int i, unsigned int j, unsigned int k)
    {
        if (k != z) return false;
        if (i > x2 || i < x1) return false;
        if (j > y2 || j < y1) return false;
        return true;
    }

// Assembly:
cmpl %ecx, (%rdi)
jne 0xf931
xorl %eax, %eax
cmpl %esi, 0x8(%rdi)
jb 0xf930
cmpl %esi, 0x4(%rdi)
ja 0xf930
cmpl %edx, 0x10(%rdi)
setae %cl
cmpl %edx, 0xc(%rdi)
setbe %al
andb %cl, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/grid-walking.cpp
// Function: main
int main() {
    int T, N, M, temp;
    cin >> T;

    for (int i = 0; i < T; i++) {
        cin >> N >> M;
        vector<int> x;
        vector<int> d;

        for (int j = 0; j < N; j++) {
            cin >> temp;
            x.push_back(temp);
        }

        for (int j = 0; j < N; j++) {
            cin >> temp;
            d.push_back(temp);
        }

        cout << getWays(x, d, M) << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x29c7(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1080
xorl %r14d, %r14d
leaq 0xc(%rsp), %r12
leaq 0x30(%rsp), %r13
leaq 0x10(%rsp), %rbp
cmpl 0x8(%rsp), %r14d
jge 0x1730
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x1080
movq %rax, %rdi
leaq 0x4(%rsp), %rsi
callq 0x1080
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
xorl %r15d, %r15d
movl (%rsp), %eax
cmpl %eax, %r15d
jge 0x169a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1080
movq %r13, %rdi
movq %r12, %rsi
callq 0x1782
incl %r15d
jmp 0x1677
xorl %r15d, %r15d
cmpl %eax, %r15d
jge 0x16c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1080
movq %rbp, %rdi
movq %r12, %rsi
callq 0x1782
incl %r15d
movl (%rsp), %eax
jmp 0x169d
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x17a0
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x17a0
movl 0x4(%rsp), %edx
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x123c
movq 0x28db(%rip), %rdi      # 0x3fd0
movl %eax, %esi
callq 0x10f0
movq %rax, %rdi
callq 0x1060
leaq 0x60(%rsp), %rdi
callq 0x17f8
leaq 0x48(%rsp), %rdi
callq 0x17f8
movq %rbp, %rdi
callq 0x17f8
movq %r13, %rdi
callq 0x17f8
incl %r14d
jmp 0x1638
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1755
jmp 0x1763
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x17f8
leaq 0x48(%rsp), %rdi
callq 0x17f8
jmp 0x1766
jmp 0x1763
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x17f8
leaq 0x30(%rsp), %rdi
callq 0x17f8
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x916bf
andq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x8a4f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x916a4
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
callq *0x28(%rax)
leaq 0x10(%rsp), %rdi
callq 0x8b040
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %rax, (%rbx)
andq $0x0, (%rdi)
jmp 0x916d9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8ca80
movq (%r14), %rax
movq %rax, (%rbx)
andq $0x0, (%r14)
movq %r14, %rdi
callq 0x8b4a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8b040
jmp 0x916fb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8b4a0
movq %rbx, %rdi
callq 0x13a690
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2dac(%rip), %rbx      # 0x3fd0
movq 0x2db5(%rip), %r15      # 0x3fe0
leaq 0xe02(%rip), %r14       # 0x2034
leaq 0xdfe(%rip), %r12       # 0x2037
leaq -0x50(%rbp), %r13
movq %rbx, %rdi
leaq 0xdbd(%rip), %rsi       # 0x2004
callq 0x1070
andl $0x0, -0x30(%rbp)
andl $0x0, -0x2c(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1050
movq %rbx, %rdi
leaq 0xda8(%rip), %rsi       # 0x201e
callq 0x1070
movl -0x30(%rbp), %esi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
leaq 0xd9a(%rip), %rsi       # 0x202a
callq 0x1070
movl -0x2c(%rbp), %esi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
leaq 0xd86(%rip), %rsi       # 0x2030
callq 0x1070
movl -0x2c(%rbp), %esi
addl -0x30(%rbp), %esi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
movq %rax, %rdi
movq %r12, %rsi
callq 0x1070
movq %r15, %rdi
movq %r13, %rsi
callq 0x1080
cmpq $0x0, -0x48(%rbp)
je 0x12f2
movq -0x50(%rbp), %rax
cmpb $0x6e, (%rax)
jne 0x123d
movq 0x2cd7(%rip), %rdi      # 0x3fd0
callq 0x1040
leaq -0x50(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x131c
jmp 0x131c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x356e
movq %rsi, %r14
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x348c
cmpb $0x0, 0x1(%rdi)
je 0x355f
leaq 0x35e2(%rip), %rsi      # 0x6a75
callq 0x31f0
movq %rax, %rbx
testq %rbx, %rbx
je 0x3595
leaq 0x10(%rsp), %r14
leaq 0x2b8d(%rip), %r13      # 0x603d
movq %r14, %rdi
movl $0x3e7, %esi            # imm = 0x3E7
movq %rbx, %rdx
callq 0x32b0
testq %rax, %rax
je 0x3543
movq %r14, %rdi
callq 0x4589
movq %rax, %r15
movq %rax, %rdi
callq 0x30b0
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x35a8
movl %eax, %ebp
movq %r15, %rdi
movl %r12d, %esi
callq 0x35de
leaq 0x2b38(%rip), %rdi      # 0x6032
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3040
movq %r15, %rdi
movl %r12d, %esi
movq %rsp, %rdx
callq 0x3642
pushq $0x10
popq %r15
movzbl -0x1(%rsp,%r15), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3040
decq %r15
jne 0x3518
leaq 0x335f(%rip), %rdi      # 0x6893
movq %r14, %rsi
xorl %eax, %eax
callq 0x3040
jmp 0x34b0
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 0x5a72(%rip), %rax      # 0x8fd8
movq (%rax), %rbx
jmp 0x349b
movq 0x5a6b(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
leaq 0x2a85(%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 0x2a80(%rip), %rdi      # 0x6020
xorl %eax, %eax
callq 0x3e21
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x2730, %rsp           # imm = 0x2730
movq %rdi, %rbx
leaq 0x13a8(%rsp), %r15
movq %r15, %rdi
callq 0x18752
leaq 0x13a0(%rsp), %r14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x187a7
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x187d4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a92
leaq 0x8(%rsp), %rdi
callq 0x18a74
leaq 0x13a8(%rsp), %rdi
callq 0x18842
movq %rbx, %rax
addq $0x2730, %rsp           # imm = 0x2730
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18a74
jmp 0x780f
jmp 0x780c
movq %rax, %rbx
leaq 0x13a8(%rsp), %rdi
callq 0x18842
movq %rbx, %rdi
callq 0x54a0
// File: /workspace/github_cpp_makefile_star2_O2/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
movss 0x10d39(%rip), %xmm1    # 0x19004
xorps %xmm0, %xmm0
callq 0xd036
movq 0x21d5e(%rip), %rax     # 0x2a038
subq 0x21d4f(%rip), %rax     # 0x2a030
sarq $0x5, %rax
js 0x82ee
cvtsi2ss %rax, %xmm1
jmp 0x8303
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
andq $0x0, 0x8(%rdx)
movq %r15, (%rdx)
leaq 0x52ba(%rip), %rax      # 0xd5e4
movq %rax, 0x18(%rdx)
leaq 0x52bd(%rip), %rax      # 0xd5f2
movq %rax, 0x10(%rdx)
leaq 0x21520(%rip), %rsi     # 0x29860
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xd2e4
movq %r14, %rdi
movq %rax, %rsi
callq 0xd59a
leaq 0x10(%rsp), %rdi
callq 0x10c7c
movss 0x10c9d(%rip), %xmm1    # 0x19004
xorps %xmm0, %xmm0
callq 0xd036
movq 0x21cc2(%rip), %rax     # 0x2a038
subq 0x21cb3(%rip), %rax     # 0x2a030
sarq $0x5, %rax
js 0x838a
cvtsi2ss %rax, %xmm1
jmp 0x839f
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
mulss %xmm1, %xmm0
callq 0x5110
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdx
andq $0x0, 0x8(%rdx)
movq %r15, (%rdx)
leaq 0x55ea(%rip), %rax      # 0xd9ac
movq %rax, 0x18(%rdx)
leaq 0x55ed(%rip), %rax      # 0xd9ba
movq %rax, 0x10(%rdx)
leaq 0x214b0(%rip), %rsi     # 0x29888
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xd2e4
movq %r14, %rdi
movq %rax, %rsi
callq 0xd59a
leaq 0x10(%rsp), %rdi
callq 0x10c7c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97ba
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8411
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x10c7c
movq %rbx, %rdi
callq 0x54a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x111cc(%rip), %rsi     # 0x19d54
leaq 0x30(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x76e8
leaq 0x21007(%rip), %rsi     # 0x29ba8
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x9546
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x53e2(%rip), %rcx      # 0xdfa2
movq %rcx, 0x18(%rdx)
leaq 0x53e5(%rip), %rcx      # 0xdfb0
movq %rcx, 0x10(%rdx)
leaq 0x20ffa(%rip), %rsi     # 0x29bd0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xda4e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97ba
leaq 0x10(%rsp), %rdi
callq 0x10c7c
leaq 0x30(%rsp), %rdi
callq 0x5060
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x8c1e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x10c7c
leaq 0x30(%rsp), %rdi
callq 0x5060
movq %rbx, %rdi
callq 0x54a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd5c1
movq %rsi, %r14
movq %rbx, %rdi
callq 0x5420
addq $0x20, %r14
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd6fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x5050
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0xe14a
movsbl (%r15,%r12), %esi
movq %rbx, %rdi
callq 0x5120
incq %r12
jmp 0xe133
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe15b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5060
movq %r14, %rdi
callq 0x54a0
// File: /workspace/github_cpp_makefile_star2_O2/deadshot465[P]OwoifyCpp/./owoify.h
// Function: std::deque<Word, std::allocator<Word>> Utility::interleaveArrays<Word>(std::deque<Word, std::allocator<Word>> const&, std::deque<Word, std::allocator<Word>> const&)
static std::deque<T> interleaveArrays(const std::deque<T>& a, const std::deque<T>& b)
	{
		auto arr = std::deque<T>();
		auto observed = a;
		auto other = b;

		while (observed.size() > 0)
		{
			arr.emplace_back(observed[0]);
			observed.pop_front();
			
			std::swap(observed, other);
		}

		if (other.size() > 0)
		{
			std::move(other.begin(), other.end(), std::back_inserter(arr));
		}

		return arr;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0xe506
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xed36
movq %rsp, %rdi
movq %r14, %rsi
callq 0xed36
leaq 0x60(%rsp), %r14
leaq 0x50(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
callq 0xe90c
testq %rax, %rax
je 0xe380
movq %r14, %rdi
xorl %esi, %esi
callq 0xf160
movq %rbx, %rdi
movq %rax, %rsi
callq 0xedd8
movq %r15, %rdi
callq 0xee26
movq %r15, %rdi
movq %r12, %rsi
callq 0xf25c
jmp 0xe349
movq %rsp, %rdi
callq 0xe90c
testq %rax, %rax
je 0xe3c7
movups 0x10(%rsp), %xmm0
movups 0x20(%rsp), %xmm1
movups 0x30(%rsp), %xmm2
movups 0x40(%rsp), %xmm3
leaq 0xc0(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm1, 0x10(%rdi)
leaq 0xa0(%rsp), %rsi
movaps %xmm2, (%rsi)
movaps %xmm3, 0x10(%rsi)
movq %rbx, %rdx
callq 0xee50
movq %rsp, %rdi
callq 0xe4ba
leaq 0x50(%rsp), %rdi
callq 0xe4ba
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xe3f7
movq %rax, %r14
jmp 0xe402
movq %rax, %r14
jmp 0xe40c
movq %rax, %r14
movq %rsp, %rdi
callq 0xe4ba
leaq 0x50(%rsp), %rdi
callq 0xe4ba
movq %rbx, %rdi
callq 0xe4ba
movq %r14, %rdi
callq 0x54a0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x50d0
movq 0x10(%r15), %r14
movq 0x20(%r15), %rbp
movq 0x28(%r15), %r12
movq 0x30(%r15), %r13
leaq 0x10(%rsp), %r15
cmpq %r13, %r14
je 0xe47b
movq %r15, %rdi
movq %r14, %rsi
callq 0x53c0
addq $0x58, %r14
cmpq %rbp, %r14
jne 0xe450
movq 0x8(%r12), %r14
addq $0x8, %r12
leaq 0x1b8(%r14), %rbp
jmp 0xe450
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x50b0
movq %rsp, %rdi
callq 0x53b0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe4a7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x53b0
movq %rbx, %rdi
callq 0x54a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xec95
movq %rsi, %r14
movq %rbx, %rdi
callq 0x5520
addq $0x20, %r14
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xeca0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rsi, %r14
movss 0x18(%rdi), %xmm6
subss 0x8(%rsi), %xmm6
divss 0x14(%rsi), %xmm6
xorl %eax, %eax
ucomiss %xmm6, %xmm0
ja 0x8611
ucomiss %xmm1, %xmm6
ja 0x8611
movq %rdi, %rsi
movsd (%r14), %xmm1
movsd 0xc(%r14), %xmm2
movaps %xmm6, %xmm0
shufps $0x0, %xmm6, %xmm0      # xmm0 = xmm0[0,0],xmm6[0,0]
mulps %xmm2, %xmm0
addps %xmm1, %xmm0
movss 0x8(%rdi), %xmm1
ucomiss %xmm0, %xmm1
ja 0x860f
movss 0xc(%rsi), %xmm2
ucomiss %xmm2, %xmm0
ja 0x860f
movss 0x10(%rsi), %xmm3
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
ucomiss %xmm5, %xmm3
ja 0x860f
movss 0x14(%rsi), %xmm4
ucomiss %xmm4, %xmm5
jbe 0x8619
xorl %eax, %eax
addq $0x18, %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)
addq $0x20, %rsi
leaq 0x28(%rdx), %rdi
movaps %xmm6, (%rsp)
callq 0x894e
movq %r14, %rdi
movaps (%rsp), %xmm0
callq 0x8924
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
andq $0x0, 0x18(%rbx)
movl $0x3f800000, 0x20(%rbx) # imm = 0x3F800000
movb $0x1, %al
jmp 0x8611
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %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 0x874d
ucomiss %xmm1, %xmm6
ja 0x874d
movq %rdi, %rsi
movaps %xmm6, %xmm1
shufps $0x0, %xmm6, %xmm1      # xmm1 = xmm1[0,0],xmm6[0,0]
movss 0x8(%r14), %xmm0
movss 0x14(%r14), %xmm4
movlhps %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm4     # xmm4 = xmm4[2,0],xmm3[2,3]
mulps %xmm1, %xmm4
movlhps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
shufps $0xe2, %xmm2, %xmm0     # xmm0 = xmm0[2,0],xmm2[2,3]
addps %xmm4, %xmm0
movss 0x8(%rdi), %xmm1
ucomiss %xmm0, %xmm1
ja 0x874b
movss 0xc(%rsi), %xmm2
ucomiss %xmm2, %xmm0
ja 0x874b
movss 0x10(%rsi), %xmm3
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
ucomiss %xmm5, %xmm3
ja 0x874b
movss 0x14(%rsi), %xmm4
ucomiss %xmm4, %xmm5
jbe 0x8755
xorl %eax, %eax
addq $0x18, %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)
addq $0x20, %rsi
leaq 0x28(%rdx), %rdi
movaps %xmm6, (%rsp)
callq 0x894e
movq %r14, %rdi
movaps (%rsp), %xmm0
callq 0x8924
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movsd 0x27a73(%rip), %xmm0    # 0x30210
movsd %xmm0, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movb $0x1, %al
jmp 0x874d
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %r14
movss 0x18(%rdi), %xmm6
movsd (%rsi), %xmm2
movsd 0xc(%rsi), %xmm3
subss %xmm2, %xmm6
divss %xmm3, %xmm6
xorl %eax, %eax
ucomiss %xmm6, %xmm0
ja 0x8879
ucomiss %xmm1, %xmm6
ja 0x8879
movq %rdi, %rsi
movaps %xmm6, %xmm1
shufps $0x0, %xmm6, %xmm1      # xmm1 = xmm1[0,0],xmm6[0,0]
movss 0x8(%r14), %xmm0
movss 0x14(%r14), %xmm4
shufps $0xd4, %xmm3, %xmm4     # xmm4 = xmm4[0,1],xmm3[1,3]
shufps $0x52, %xmm3, %xmm4     # xmm4 = xmm4[2,0],xmm3[1,1]
mulps %xmm1, %xmm4
shufps $0xd4, %xmm2, %xmm0     # xmm0 = xmm0[0,1],xmm2[1,3]
shufps $0x52, %xmm2, %xmm0     # xmm0 = xmm0[2,0],xmm2[1,1]
addps %xmm4, %xmm0
movss 0x8(%rdi), %xmm1
ucomiss %xmm0, %xmm1
ja 0x8877
movss 0xc(%rsi), %xmm2
ucomiss %xmm2, %xmm0
ja 0x8877
movss 0x10(%rsi), %xmm3
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
ucomiss %xmm5, %xmm3
ja 0x8877
movss 0x14(%rsi), %xmm4
ucomiss %xmm4, %xmm5
jbe 0x8881
xorl %eax, %eax
addq $0x18, %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)
addq $0x20, %rsi
leaq 0x28(%rdx), %rdi
movaps %xmm6, (%rsp)
callq 0x894e
movq %r14, %rdi
movaps (%rsp), %xmm0
callq 0x8924
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movss 0x2793b(%rip), %xmm0    # 0x30204
movlps %xmm0, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movb $0x1, %al
jmp 0x8879
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27877(%rip), %xmm0    # 0x3023c
callq 0x6370
movss %xmm0, 0xc(%rsp)
movss 0x4(%rbx), %xmm0
mulss 0x2785f(%rip), %xmm0    # 0x3023c
callq 0x6370
mulss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x27846(%rip), %xmm0    # 0x3023c
mulss 0x8(%rbx), %xmm0
callq 0x6370
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_O2/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 $0x18, %rsp
movss 0x8(%rdi), %xmm0
movss (%rsi), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movq %rsi, %rdi
callq 0x8c23
leaq 0x8(%rsp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
pushq $0x7
popq %rsi
callq 0xbd78
mulss 0x277cc(%rip), %xmm0    # 0x30240
addss 0x4(%rsp), %xmm0
callq 0x6370
addss 0x2777d(%rip), %xmm0    # 0x30204
mulss 0x277b5(%rip), %xmm0    # 0x30244
movaps %xmm0, %xmm2
shufps $0x0, %xmm0, %xmm2      # xmm2 = xmm2[0,0],xmm0[0,0]
movaps %xmm0, %xmm1
movaps %xmm2, %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3e65d(%rip), %rax     # 0x47110
movq %rax, (%rdi)
movq (%rsi), %rdi
leaq 0x10(%r14), %rsi
leaq 0x14(%r14), %rdx
leaq 0x18(%r14), %rcx
xorl %r8d, %r8d
callq 0x1f9dc
movq %rax, 0x8(%r14)
movq 0x3f4d8(%rip), %rdi     # 0x47fb0
leaq 0x27781(%rip), %rsi     # 0x30260
callq 0x6420
movq %rax, %rdi
movq %rbx, %rsi
callq 0x63b0
leaq 0x27783(%rip), %rsi     # 0x30279
movq %rax, %rdi
callq 0x6420
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x66f0
leaq 0x27773(%rip), %rsi     # 0x30284
movq %rax, %rdi
callq 0x6420
movl 0x14(%r14), %esi
movq %rax, %rdi
callq 0x66f0
leaq 0x27764(%rip), %rsi     # 0x30290
movq %rax, %rdi
callq 0x6420
movl 0x18(%r14), %esi
movq %rax, %rdi
callq 0x66f0
leaq 0x281a4(%rip), %rsi     # 0x30ceb
movq %rax, %rdi
callq 0x6420
cmpq $0x0, 0x8(%r14)
je 0x8b5e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3f47b(%rip), %rdi     # 0x47fe0
leaq 0x27731(%rip), %rsi     # 0x3029d
callq 0x6420
movq %rax, %rdi
movq %rbx, %rsi
callq 0x63b0
leaq 0x28168(%rip), %rsi     # 0x30ceb
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6420