LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movsd %xmm0, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x88(%rsp), %xmm0
jbe 0x214cf
movb $0x1, 0x73(%rsp)
movl $0x20, %edi
callq 0x3150
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x34b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7784(%rip), %rsi      # 0x28bf7
callq 0x3360
jmp 0x2147a
movq 0x8(%rsp), %rdi
movb $0x0, 0x73(%rsp)
leaq 0x128ed(%rip), %rsi     # 0x33d78
movq 0x12b16(%rip), %rdx     # 0x33fa8
callq 0x3460
jmp 0x2158e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x32d0
testb $0x1, 0x73(%rsp)
jne 0x214c0
jmp 0x214ca
movq 0x8(%rsp), %rdi
callq 0x3210
jmp 0x21584
movq 0x20(%rsp), %rdi
movsd 0x88(%rsp), %xmm0
divsd 0x30(%rdi), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x6c(%rsp)
movslq 0x6c(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x21980
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2150d
jmp 0x21542
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x21a30
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x219e0
movq %rax, 0x38(%rsp)
movb %dl, 0x40(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x6c(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x21a60
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x21a90
movsd 0x6ace(%rip), %xmm0     # 0x28040
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x98, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x34a0
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22640
testb $0x1, %al
jne 0x21719
movq 0x12a09(%rip), %rdi     # 0x33fc0
leaq 0x766b(%rip), %rsi      # 0x28c29
callq 0x3290
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22660
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x22690
movq %rax, %rdi
callq 0x226c0
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x3090
movq %rax, %rdi
movq 0x129a0(%rip), %rsi     # 0x33fa0
callq 0x32c0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22660
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x22690
movq %rax, %rdi
callq 0x226c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq (%rcx), %rax
jae 0x21717
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
movsd 0x30(%rax), %xmm0
movaps 0x6a60(%rip), %xmm2     # 0x280c0
movq 0x28(%rsp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x6a5e(%rip), %xmm2     # 0x280d0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x34e0
movq 0x40(%rsp), %rdi
leaq 0x75af(%rip), %rsi      # 0x28c45
callq 0x3290
movq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21980
cmpq $0x0, %rax
je 0x216e7
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x226e0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x226c0
movq (%rsp), %rdi
movsd 0x8(%rax), %xmm0
callq 0x34e0
jmp 0x216f3
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x3470
movq 0x40(%rsp), %rdi
movq 0x128a1(%rip), %rsi     # 0x33fa0
callq 0x32c0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2160e
jmp 0x21719
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movl -0x1c(%rsp), %eax
cmpl (%rcx), %eax
je 0x2280a
movb $0x0, -0x1(%rsp)
jmp 0x22855
movq -0x28(%rsp), %rcx
movl -0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
ja 0x22826
movq -0x28(%rsp), %rcx
movl -0x14(%rsp), %eax
cmpl 0x4(%rcx), %eax
jae 0x2282d
movb $0x0, -0x1(%rsp)
jmp 0x22855
movq -0x28(%rsp), %rcx
movl -0x18(%rsp), %eax
cmpl 0x10(%rcx), %eax
ja 0x22849
movq -0x28(%rsp), %rcx
movl -0x18(%rsp), %eax
cmpl 0xc(%rcx), %eax
jae 0x22850
movb $0x0, -0x1(%rsp)
jmp 0x22855
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
movq 0x35b7(%rip), %rdi      # 0x4fe0
leaq 0x90(%rsp), %rsi
callq 0x1070
movl $0x0, 0x80(%rsp)
movl 0x80(%rsp), %eax
cmpl 0x90(%rsp), %eax
jge 0x1c20
movq 0x3584(%rip), %rdi      # 0x4fe0
leaq 0x8c(%rsp), %rsi
callq 0x1070
movq %rax, %rdi
leaq 0x88(%rsp), %rsi
callq 0x1070
leaq 0x68(%rsp), %rdi
callq 0x1c80
leaq 0x50(%rsp), %rdi
callq 0x1c80
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jge 0x1aee
movq 0x3537(%rip), %rdi      # 0x4fe0
leaq 0x84(%rsp), %rsi
callq 0x1070
jmp 0x1ab8
leaq 0x68(%rsp), %rdi
leaq 0x84(%rsp), %rsi
callq 0x1c90
jmp 0x1acc
jmp 0x1ace
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x1a95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1c0a
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jge 0x1b3c
movq 0x34d6(%rip), %rdi      # 0x4fe0
leaq 0x84(%rsp), %rsi
callq 0x1070
jmp 0x1b19
leaq 0x50(%rsp), %rdi
leaq 0x84(%rsp), %rsi
callq 0x1c90
jmp 0x1b2d
jmp 0x1b2f
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x1af6
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1d00
jmp 0x1b4d
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1d00
jmp 0x1b5e
movl 0x88(%rsp), %edx
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1250
movl %eax, %esi
movq 0x3453(%rip), %rdi      # 0x4fd0
callq 0x10f0
movq %rax, (%rsp)
jmp 0x1b88
movq (%rsp), %rdi
movq 0x342d(%rip), %rsi      # 0x4fc0
callq 0x10c0
jmp 0x1b9a
leaq 0x8(%rsp), %rdi
callq 0x1e00
leaq 0x20(%rsp), %rdi
callq 0x1e00
leaq 0x50(%rsp), %rdi
callq 0x1e00
leaq 0x68(%rsp), %rdi
callq 0x1e00
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0x1a41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1c00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1e00
leaq 0x20(%rsp), %rdi
callq 0x1e00
leaq 0x50(%rsp), %rdi
callq 0x1e00
leaq 0x68(%rsp), %rdi
callq 0x1e00
jmp 0x1c2a
xorl %eax, %eax
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
cmpl $0x2b89e12a, 0x4c(%rsp) # imm = 0x2B89E12A
jne 0xb992f
xorl %eax, %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0xb2f20
leaq 0x38(%rsp), %rdi
callq 0xae8c0
jmp 0xb98b2
leaq 0x40(%rsp), %rdi
callq 0xb3db0
movq %rax, 0x8(%rsp)
jmp 0xb98c3
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xb0030
jmp 0xb98d4
leaq 0x38(%rsp), %rdi
callq 0xafcd0
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xb5f40
jmp 0xb98ef
leaq 0x40(%rsp), %rdi
callq 0xb03b0
jmp 0xb9977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xb9923
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xafcd0
leaq 0x40(%rsp), %rdi
callq 0xb03b0
jmp 0xb9981
movl 0x4c(%rsp), %esi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xb2b20
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xb5f40
jmp 0xb9951
leaq 0x20(%rsp), %rdi
callq 0xb03b0
jmp 0xb9977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xb03b0
jmp 0xb9981
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x17a9b0
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1090
movq 0x2d7e(%rip), %rdi      # 0x3fd0
leaq 0xdab(%rip), %rsi       # 0x2004
callq 0x1060
jmp 0x1260
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq 0x2d6b(%rip), %rdi      # 0x3fe0
leaq -0x38(%rbp), %rsi
callq 0x1030
movq %rax, -0x48(%rbp)
jmp 0x1284
movq -0x48(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1030
jmp 0x1293
movq 0x2d36(%rip), %rdi      # 0x3fd0
leaq 0xd7d(%rip), %rsi       # 0x201e
callq 0x1060
movq %rax, -0x50(%rbp)
jmp 0x12ac
movq -0x50(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x10c0
movq %rax, -0x58(%rbp)
jmp 0x12be
movq -0x58(%rbp), %rdi
leaq 0xd61(%rip), %rsi       # 0x202a
callq 0x1060
movq %rax, -0x60(%rbp)
jmp 0x12d4
movq -0x60(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x10c0
movq %rax, -0x68(%rbp)
jmp 0x12e6
movq -0x68(%rbp), %rdi
leaq 0xd3f(%rip), %rsi       # 0x2030
callq 0x1060
movq %rax, -0x70(%rbp)
jmp 0x12fc
movq -0x70(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x3c(%rbp), %eax
addl %eax, %esi
callq 0x10c0
movq %rax, -0x78(%rbp)
jmp 0x1313
movq -0x78(%rbp), %rdi
leaq 0xd16(%rip), %rsi       # 0x2034
callq 0x1060
movq %rax, -0x80(%rbp)
jmp 0x1329
movq -0x80(%rbp), %rdi
leaq 0xd03(%rip), %rsi       # 0x2037
callq 0x1060
jmp 0x133b
movq 0x2c9e(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x1080
jmp 0x134d
jmp 0x134f
leaq -0x28(%rbp), %rdi
callq 0x10b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x81(%rbp)
jne 0x1393
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x10e0
movq %rax, -0x90(%rbp)
jmp 0x137d
movq -0x90(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
setne %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x124b
movq 0x2c28(%rip), %rdi      # 0x3fd0
movq 0x2c11(%rip), %rsi      # 0x3fc0
callq 0x1070
jmp 0x13b6
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movq -0x30(%rbp), %rdi
callq 0x10d0
// File: 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
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x34bd
movq 0x6b3a(%rip), %rax      # 0x9fe0
movq (%rax), %rsi
leaq 0x3b54(%rip), %rdi      # 0x7004
callq 0x31f0
movl %eax, -0x4(%rbp)
jmp 0x35f4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3b54(%rip), %rsi      # 0x7020
callq 0x3270
cmpl $0x0, %eax
je 0x34f3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x4590(%rip), %rsi      # 0x7a75
callq 0x3200
movq %rax, -0x428(%rbp)
jmp 0x3504
movq 0x6ade(%rip), %rax      # 0x9fd8
movq (%rax), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x352c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x3afd(%rip), %rdi      # 0x7022
movb $0x0, %al
callq 0x4d10
jmp 0x352e
leaq -0x400(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x3e7, %esi            # imm = 0x3E7
callq 0x32d0
cmpq $0x0, %rax
je 0x35e4
leaq -0x400(%rbp), %rdi
callq 0x59e0
movq %rax, -0x408(%rbp)
movq -0x408(%rbp), %rdi
callq 0x30b0
movl %eax, -0x40c(%rbp)
movq -0x408(%rbp), %rdi
movl -0x40c(%rbp), %esi
callq 0x3670
movl %eax, -0x42c(%rbp)
movq -0x408(%rbp), %rdi
movl -0x40c(%rbp), %esi
callq 0x3700
movl -0x42c(%rbp), %esi
movq %rax, %rdx
leaq 0x3a88(%rip), %rdi      # 0x7034
movb $0x0, %al
callq 0x3040
movq -0x408(%rbp), %rdi
movl -0x40c(%rbp), %esi
leaq -0x420(%rbp), %rdx
callq 0x37c0
leaq -0x420(%rbp), %rdi
leaq -0x400(%rbp), %rsi
callq 0x3600
jmp 0x352e
movq -0x18(%rbp), %rdi
callq 0x31a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
// File: 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:
subq $0x2788, %rsp           # imm = 0x2788
movq %rdi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x42a20
leaq 0x1400(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x42b10
movq 0x28(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x42b20
movq 0x30(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x42b40
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdx
callq 0x42ac0
jmp 0x9fbb
leaq 0x1400(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x42b10
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x42b20
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x48(%rsp), %rdi
callq 0x42b70
jmp 0x9ff0
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x42c50
jmp 0xa001
leaq 0x48(%rsp), %rdi
callq 0x42c80
leaq 0x78(%rsp), %rdi
callq 0x42c90
movq 0x20(%rsp), %rax
addq $0x2788, %rsp           # imm = 0x2788
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xa04a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x42c80
leaq 0x78(%rsp), %rdi
callq 0x42c90
movq 0x68(%rsp), %rdi
callq 0x67b0
nop
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
xorps %xmm0, %xmm0
movss 0x399c5(%rip), %xmm1    # 0x45004
callq 0x1bad0
movss %xmm0, 0x54(%rsp)
leaq 0x55b7f(%rip), %rdi     # 0x611d0
callq 0x19900
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x58(%rsp)
testq %rax, %rax
movss %xmm0, 0x5c(%rsp)
js 0xb68f
movss 0x58(%rsp), %xmm0
movss %xmm0, 0x5c(%rsp)
movss 0x54(%rsp), %xmm0
movss 0x5c(%rsp), %xmm1
mulss %xmm1, %xmm0
callq 0x6170
movss %xmm0, 0xc4(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xc4(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x98(%rsp), %rsi
callq 0x1c6d0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x5530b(%rip), %rsi     # 0x60a00
xorl %ecx, %ecx
callq 0x1c1f0
movq %rax, 0x38(%rsp)
jmp 0xb703
movq 0x38(%rsp), %rsi
movq 0xc8(%rsp), %rdi
callq 0x1c760
jmp 0xb717
leaq 0xa0(%rsp), %rdi
callq 0x1c7d0
xorps %xmm0, %xmm0
movss 0x398d5(%rip), %xmm1    # 0x45004
callq 0x1bad0
movss %xmm0, 0x1c(%rsp)
leaq 0x55a8f(%rip), %rdi     # 0x611d0
callq 0x19900
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x20(%rsp)
testq %rax, %rax
movss %xmm0, 0x24(%rsp)
js 0xb77f
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x1c(%rsp), %xmm0
movss 0x24(%rsp), %xmm1
mulss %xmm1, %xmm0
callq 0x6170
movss %xmm0, 0xc4(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, (%rsp)
leaq 0xc4(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1c7e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x5524e(%rip), %rsi     # 0x60a28
xorl %ecx, %ecx
callq 0x1c1f0
movq %rax, 0x10(%rsp)
jmp 0xb7e8
movq 0x10(%rsp), %rsi
movq 0xc8(%rsp), %rdi
callq 0x1c760
jmp 0xb7fc
leaq 0x68(%rsp), %rdi
callq 0x1c7d0
movq 0x40(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0xde50
movq 0x48(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1c7d0
jmp 0xb866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1c7d0
movq 0x90(%rsp), %rdi
callq 0x67b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x61d0
movq 0x30(%rsp), %rdx
leaq 0x396a8(%rip), %rsi     # 0x45e14
leaq 0x78(%rsp), %rdi
callq 0x9d80
jmp 0xc778
movq 0x28(%rsp), %rdi
leaq 0x545c4(%rip), %rsi     # 0x60d48
leaq 0x78(%rsp), %rdx
xorl %ecx, %ecx
callq 0xd9f0
movq %rax, 0x10(%rsp)
jmp 0xc797
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x3f(%rsp), %rsi
callq 0x1dfa0
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x545b6(%rip), %rsi     # 0x60d70
xorl %ecx, %ecx
callq 0x1d950
movq %rax, 0x8(%rsp)
jmp 0xc7c8
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0xde50
jmp 0xc7d9
leaq 0x40(%rsp), %rdi
callq 0x1e030
leaq 0x78(%rsp), %rdi
callq 0x6720
leaq 0x77(%rsp), %rdi
callq 0x67d0
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc846
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc83c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1e030
leaq 0x78(%rsp), %rdi
callq 0x6720
leaq 0x77(%rsp), %rdi
callq 0x67d0
movq 0x68(%rsp), %rdi
callq 0x67b0
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, 0x10(%rsp)
jne 0x1c78b
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c7bb
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6630
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x1cf30
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x6200
movq 0x48(%rsp), %rdi
callq 0x6320
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6050
jmp 0x1eb4d
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x6450
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x6820
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1f2e0
testb $0x1, %al
jne 0x1eb8a
jmp 0x1ebd5
leaq 0x20(%rsp), %rdi
callq 0x1f320
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %esi
callq 0x6290
jmp 0x1ebad
jmp 0x1ebaf
leaq 0x20(%rsp), %rdi
callq 0x1f330
jmp 0x1eb75
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x6720
jmp 0x1ebf4
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x1ebeb
movq 0x8(%rsp), %rdi
callq 0x6720
movq (%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x67b0
nop
// File: 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:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movb $0x0, 0x12f(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x1ec00
movq 0x138(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x21240
jmp 0x1efd6
movq 0x130(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x21240
jmp 0x1efea
jmp 0x1efec
leaq 0xd8(%rsp), %rdi
callq 0x202d0
cmpq $0x0, %rax
jbe 0x1f099
xorl %eax, %eax
movl %eax, %esi
leaq 0xd8(%rsp), %rdi
callq 0x213f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x21380
jmp 0x1f023
leaq 0xd8(%rsp), %rdi
callq 0x21420
leaq 0xd8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x21490
jmp 0x1efec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x1f15b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x1f135
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x1f270
jmp 0x1f135
leaq 0x78(%rsp), %rdi
callq 0x202d0
cmpq $0x0, %rax
jbe 0x1f10a
leaq 0x58(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x1ef10
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x1ef40
movq 0x18(%rsp), %rdi
callq 0x1ed00
movq %rax, 0x10(%rsp)
jmp 0x1f0dd
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdx
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x214c0
movq %rax, (%rsp)
jmp 0x1f101
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x1, 0x12f(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x1f270
leaq 0xd8(%rsp), %rdi
callq 0x1f270
testb $0x1, 0x12f(%rsp)
jne 0x1f14e
jmp 0x1f144
leaq 0xd8(%rsp), %rdi
callq 0x1f270
jmp 0x1f15b
movq 0x18(%rsp), %rdi
callq 0x1f270
movq 0x20(%rsp), %rax
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x18(%rsp), %rdi
callq 0x1f270
movq 0xd0(%rsp), %rdi
callq 0x67b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x6100
movq 0x1f8(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x216a0
movq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x216d0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21a40
testb $0x1, %al
jne 0x1f1ed
jmp 0x1f235
leaq 0x48(%rsp), %rdi
callq 0x21aa0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x226f0
jmp 0x1f20d
jmp 0x1f20f
leaq 0x48(%rsp), %rdi
callq 0x21ab0
jmp 0x1f1d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x65f0
jmp 0x1f25c
movq (%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x6500
jmp 0x1f245
leaq 0x70(%rsp), %rdi
callq 0x65f0
movq 0x8(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x18(%rsp), %rdi
callq 0x67b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, 0x10(%rsp)
jne 0x20fdb
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2100b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6860
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x21070
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8d70
movaps %xmm0, %xmm1
movss 0x6e68a(%rip), %xmm0    # 0x7e220
mulss %xmm1, %xmm0
callq 0x100e0
movss %xmm0, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8d90
movaps %xmm0, %xmm1
movss 0x6e668(%rip), %xmm0    # 0x7e220
mulss %xmm1, %xmm0
callq 0x100e0
movaps %xmm0, %xmm1
movss -0x68(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x64(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8db0
movaps %xmm0, %xmm1
movss 0x6e63a(%rip), %xmm0    # 0x7e220
mulss %xmm1, %xmm0
callq 0x100e0
movaps %xmm0, %xmm1
movss -0x64(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x2c(%rbp), %xmm0
jbe 0xfc49
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x10100
movq %rax, %rdi
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movss %xmm1, -0x38(%rbp)
movlpd %xmm0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfc87
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x10100
movq %rax, %rdi
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movss %xmm1, -0x48(%rbp)
movlpd %xmm0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movss -0x58(%rbp), %xmm1
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x10190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
leaq 0x9f288(%rip), %rcx     # 0xaf0d8
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0x71c0
movq -0x18(%rbp), %rcx
movq %rax, %rdi
movq %rcx, %rsi
addq $0x10, %rsi
movq %rcx, %rdx
addq $0x14, %rdx
addq $0x18, %rcx
xorl %r8d, %r8d
callq 0x55f80
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0xa0121(%rip), %rdi     # 0xaffb0
leaq 0x6e39e(%rip), %rsi     # 0x7e234
callq 0x74e0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x7450
movq %rax, %rdi
leaq 0x6e39c(%rip), %rsi     # 0x7e24d
callq 0x74e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x7840
movq %rax, %rdi
leaq 0x6e389(%rip), %rsi     # 0x7e258
callq 0x74e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x7840
movq %rax, %rdi
leaq 0x6e377(%rip), %rsi     # 0x7e264
callq 0x74e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x7840
movq %rax, %rdi
leaq 0x6ebe5(%rip), %rsi     # 0x7eaf0
callq 0x74e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xff49
movq 0xa00be(%rip), %rdi     # 0xaffe0
leaq 0x6e348(%rip), %rsi     # 0x7e271
callq 0x74e0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x7450
movq %rax, %rdi
leaq 0x6ebac(%rip), %rsi     # 0x7eaf0
callq 0x74e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/src/hitable_list.cpp
// Function: hitable_list::hit(ray const&, float, float, hit_record&) const
bool hitable_list::hit(const ray& _ray, float t_min, float t_max, hit_record& rec) const
{
    hit_record temp_rec;
    bool is_anything_hit = false;
    double closest_so_far = t_max;

    for(int i = 0; i < list_size; i++)
    {
        if(list[i]->hit(_ray, t_min, closest_so_far, temp_rec))
        {
            is_anything_hit = true;
            closest_so_far = temp_rec.t;
            rec = temp_rec;
        }
    }

    return is_anything_hit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x10540
movb $0x0, -0x59(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
movq -0x88(%rbp), %rcx
movl -0x6c(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x1034a
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movslq -0x6c(%rbp), %rsi
callq 0x10580
movq %rax, %rdi
callq 0x105a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
movq (%rdi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rdx
callq *%rax
movb %al, -0x89(%rbp)
jmp 0x102f6
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x10302
jmp 0x1033a
movb $0x1, -0x59(%rbp)
movss -0x58(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x105c0
jmp 0x1033a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x10610
jmp 0x1036d
jmp 0x1033c
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x1029e
movb -0x59(%rbp), %al
movb %al, -0x8a(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x10610
movb -0x8a(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x7860
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/src/hitable_list.cpp
// Function: hitable_list::bounding_box(float, float, aabb&) const
bool hitable_list::bounding_box(float t0, float t1, aabb& _box) const
{
    if(list_size < 1) return false;
    aabb result;
    bool first_true = list[0]->bounding_box(t0, t1, result);
    if(!first_true)
    {
        return false;
    }
    else
    {
        _box = result;
    }
    
    for(int i = 1; i < list_size; i++)
    {
        // TODO : Is this correct?
        // Reference to github issue page : https://github.com/RayTracing/raytracingthenextweek/issues/2
        // it should be list[i] rather than list[0]
        if(list[i]->bounding_box(t0, t1, result))
        {
            _box = surrounding_box(_box, result);
        }
        else
        {
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpl $0x1, 0x20(%rax)
jge 0x103b7
movb $0x0, -0x1(%rbp)
jmp 0x1052c
leaq -0x38(%rbp), %rdi
callq 0x10630
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10580
movq %rax, %rdi
callq 0x105a0
movq %rax, %rdi
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movq (%rdi), %rax
leaq -0x38(%rbp), %rsi
callq *0x8(%rax)
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x10407
movb $0x0, -0x1(%rbp)
jmp 0x1052c
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x40(%rbp)
movq -0x90(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x10528
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
movslq -0x40(%rbp), %rsi
callq 0x10580
movq %rax, %rdi
callq 0x105a0
movq %rax, %rdi
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movq (%rdi), %rax
leaq -0x38(%rbp), %rsi
callq *0x8(%rax)
testb $0x1, %al
jne 0x10478
jmp 0x10512
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rcx
leaq -0x88(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x1af90
movq -0x20(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x10518
movb $0x0, -0x1(%rbp)
jmp 0x1052c
jmp 0x1051a
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x10429
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/src/bvh.cpp
// Function: bvh_node::box_x_compare::operator()(std::shared_ptr<hitable> const&, std::shared_ptr<hitable> const&) const
bool bvh_node::box_x_compare::operator() (const hitable_reference& a, const hitable_reference& b) const
{
    aabb box_left, box_right;
    if(a->bounding_box(0, 0, box_left) == false || b->bounding_box(0, 0, box_right) == false)
    {
        std::cerr << "No bounding box in bvh_node constructor!\n";
    }

    // IMPORTANT !!!
    // Reference : https://stackoverflow.com/questions/1541817/sort-function-c-segmentation-fault
    // In C++, your "compare" predicate must be a strict weak ordering.
    // In particular, "compare(X,X)" must return "false" for any X.
    // ... (Otherwise) Therefore, this "compare" predicate does not impose a strict weak ordering,
    // and the result of passing it to "sort" is undefined.

    if(box_left.get_min().x() - box_right.get_min().x() <= 0.0f)
    {
        return false;
    }
    else
    {
        return true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10630
leaq -0x50(%rbp), %rdi
callq 0x10630
movq -0x18(%rbp), %rdi
callq 0x105a0
movq %rax, %rdi
movq (%rdi), %rax
xorps %xmm1, %xmm1
leaq -0x38(%rbp), %rsi
movaps %xmm1, %xmm0
callq *0x8(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x12e35
movq -0x20(%rbp), %rdi
callq 0x105a0
movq %rax, %rdi
movq (%rdi), %rax
xorps %xmm1, %xmm1
leaq -0x50(%rbp), %rsi
movaps %xmm1, %xmm0
callq *0x8(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x12e48
movq 0x9d1a4(%rip), %rdi     # 0xaffe0
leaq 0x6b53d(%rip), %rsi     # 0x7e380
callq 0x74e0
leaq -0x38(%rbp), %rdi
callq 0x13990
movss %xmm1, -0x68(%rbp)
movlpd %xmm0, -0x70(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8d70
movss %xmm0, -0x94(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x13990
movss %xmm1, -0x88(%rbp)
movlpd %xmm0, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x7c(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x7c(%rbp), %rdi
callq 0x8d70
movss -0x94(%rbp), %xmm1
subss %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jb 0x12eca
movb $0x0, -0x1(%rbp)
jmp 0x12ece
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/src/bvh.cpp
// Function: bvh_node::box_z_compare::operator()(std::shared_ptr<hitable> const&, std::shared_ptr<hitable> const&) const
bool bvh_node::box_z_compare::operator() (const hitable_reference& a, const hitable_reference& b) const
{
    aabb box_left, box_right;
    if(a->bounding_box(0, 0, box_left) == false || b->bounding_box(0, 0, box_right) == false)
    {
        std::cerr << "No bounding box in bvh_node constructor!\n";
    }

    if(box_left.get_min().z() - box_right.get_min().z() <= 0.0f)
    {
        return false;
    }
    else
    {
        return true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10630
leaq -0x50(%rbp), %rdi
callq 0x10630
movq -0x18(%rbp), %rdi
callq 0x105a0
movq %rax, %rdi
movq (%rdi), %rax
xorps %xmm1, %xmm1
leaq -0x38(%rbp), %rsi
movaps %xmm1, %xmm0
callq *0x8(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x13075
movq -0x20(%rbp), %rdi
callq 0x105a0
movq %rax, %rdi
movq (%rdi), %rax
xorps %xmm1, %xmm1
leaq -0x50(%rbp), %rsi
movaps %xmm1, %xmm0
callq *0x8(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x13088
movq 0x9cf64(%rip), %rdi     # 0xaffe0
leaq 0x6b2fd(%rip), %rsi     # 0x7e380
callq 0x74e0
leaq -0x38(%rbp), %rdi
callq 0x13990
movss %xmm1, -0x68(%rbp)
movlpd %xmm0, -0x70(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8db0
movss %xmm0, -0x94(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x13990
movss %xmm1, -0x88(%rbp)
movlpd %xmm0, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x7c(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x7c(%rbp), %rdi
callq 0x8db0
movss -0x94(%rbp), %xmm1
subss %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jb 0x1310a
movb $0x0, -0x1(%rbp)
jmp 0x1310e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/src/perlin.cpp
// Function: perlin::turb(vec3 const&, int)
float perlin::turb(const vec3& _p, int depth)
{
    float accum = 0.0f;
    vec3 temp_p = _p;
    float weight = 1.0f;
    for(int i = 0; i < depth; i++)
    {
        accum += weight * get_noise(temp_p);
        weight *= 0.5;
        temp_p *= 2;
    }

    //if(accum > 1.0f)
    // adding this line will produce what the book demonstrated
    accum -= 1.0f;

    return std::abs(accum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x1c(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movss 0x6524c(%rip), %xmm0    # 0x7e1fc
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1902b
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x18ce0
movaps %xmm0, %xmm2
movss -0x28(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x65466(%rip), %xmm1    # 0x7e468
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
movss 0x65449(%rip), %xmm0    # 0x7e464
callq 0x19380
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18fbc
movss -0x10(%rbp), %xmm0
movss 0x651c4(%rip), %xmm1    # 0x7e1fc
subss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
callq 0x193c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/src/perlin.cpp
// Function: perlin::perlin_generate()
std::vector<vec3> perlin::perlin_generate()
{
    std::vector<vec3> result;
    result.reserve(256);
    for(int i = 0; i < 256; i++)
    {
        // IMPORTANT : it has to be unit_vector here.
        result.push_back(unit_vector(vec3(-1 + 2 * drand48(), -1 + 2 * drand48(), -1 + 2 * drand48())));
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x193e0
movq -0x68(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x19400
jmp 0x19093
movl $0x0, -0x20(%rbp)
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jge 0x1919e
callq 0x7480
addsd %xmm0, %xmm0
movsd 0x653b8(%rip), %xmm1    # 0x7e470
movsd %xmm1, -0x80(%rbp)
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x74(%rbp)
callq 0x7480
movsd -0x80(%rbp), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x78(%rbp)
callq 0x7480
movsd -0x80(%rbp), %xmm3
movss -0x78(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x74(%rbp), %xmm0
addsd %xmm2, %xmm2
addsd %xmm3, %xmm2
cvtsd2ss %xmm2, %xmm2
leaq -0x3c(%rbp), %rdi
callq 0xf9b0
jmp 0x19113
movl -0x34(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x3c(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movss -0x48(%rbp), %xmm1
callq 0x18b10
movss %xmm1, -0x94(%rbp)
movaps %xmm0, -0x90(%rbp)
jmp 0x19141
movq -0x68(%rbp), %rdi
movss -0x94(%rbp), %xmm0
movaps -0x90(%rbp), %xmm1
movlpd %xmm1, -0x60(%rbp)
movss %xmm0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x19500
jmp 0x19177
jmp 0x19179
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1909a
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19530
jmp 0x191be
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x191b1
movq -0x68(%rbp), %rdi
callq 0x19530
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x7860
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/src/perlin.cpp
// Function: perlin::permute(std::vector<int, std::allocator<int>>&, int)
void perlin::permute(std::vector<int>& _p, int _n)
{
    for(int i = _n - 1; i > 0; i--)
    {
        int target = int(drand48() * (i+1));
        int tmp = _p[i];
        _p[i] = _p[target];
        _p[target] = tmp;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x19261
callq 0x7480
movl -0x10(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x19360
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x19360
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x19360
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x19360
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x191e8
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)