LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: alan0201tw[P]RayTracer/src/perlin.cpp
// Function: perlin::perlin_generate_perm()
std::vector<int> perlin::perlin_generate_perm()
{
    std::vector<int> result;
    result.reserve(256);

    for(int i = 0; i < 256; i++)
    {
        result.push_back(i);
    }
    permute(result, 256);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x19590
movq -0x28(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x195b0
jmp 0x192a0
movl $0x0, -0x20(%rbp)
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jge 0x192e3
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x196b0
jmp 0x192bf
jmp 0x192c1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x192a7
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19720
jmp 0x1930e
movq -0x28(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x191d0
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x19304
movq -0x28(%rbp), %rdi
callq 0x19720
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x7860
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/vec3.hpp
// Function: vec3::operator*=(float)
inline vec3& vec3::operator*=(const float t) {
    e[0]  *= t;
    e[1]  *= t;
    e[2]  *= t;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss -0xc(%rbp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss -0xc(%rbp), %xmm0
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss -0xc(%rbp), %xmm0
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseOnOff(char const**, bool)
static inline bool parseOnOff(const char **token, bool default_value = true) {
  (*token) += strspn((*token), " \t");
  const char *end = (*token) + strcspn((*token), " \t\r");

  bool ret = default_value;
  if ((0 == strncmp((*token), "on", 2))) {
    ret = true;
  } else if ((0 == strncmp((*token), "off", 3))) {
    ret = false;
  }

  (*token) = end;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x628fe(%rip), %rsi     # 0x7e5a0
callq 0x71d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x62ee1(%rip), %rsi     # 0x7ebae
callq 0x7060
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x65a43(%rip), %rsi     # 0x81739
movl $0x2, %edx
callq 0x7240
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1bd0e
movb $0x1, -0x19(%rbp)
jmp 0x1bd34
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x62e1d(%rip), %rsi     # 0x7eb39
movl $0x3, %edx
callq 0x7240
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1bd32
movb $0x0, -0x19(%rbp)
jmp 0x1bd34
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseReal(char const**, double)
static inline real_t parseReal(const char **token, double default_value = 0.0) {
  (*token) += strspn((*token), " \t");
  const char *end = (*token) + strcspn((*token), " \t\r");
  double val = default_value;
  tryParseDouble((*token), end, &val);
  real_t f = static_cast<real_t>(val);
  (*token) = end;
  return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x62831(%rip), %rsi     # 0x7e5a0
callq 0x71d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x62e14(%rip), %rsi     # 0x7ebae
callq 0x7060
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2a880
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movss -0x24(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseString[abi:cxx11](char const**)
static inline std::string parseString(const char **token) {
  std::string s;
  (*token) += strspn((*token), " \t");
  size_t e = strcspn((*token), " \t\r");
  s = std::string((*token), &(*token)[e]);
  (*token) += e;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7690
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x6250b(%rip), %rsi     # 0x7e5a0
callq 0x71d0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x62af6(%rip), %rsi     # 0x7ebae
callq 0x7060
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7870
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x2e730
jmp 0x1c0fb
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x75f0
leaq -0x40(%rbp), %rdi
callq 0x72e0
leaq -0x41(%rbp), %rdi
callq 0x7560
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1c15d
jmp 0x1c154
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x7560
movq -0x80(%rbp), %rdi
callq 0x72e0
jmp 0x1c16a
movq -0x80(%rbp), %rdi
callq 0x72e0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7860
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::safeGetline(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
static std::istream &safeGetline(std::istream &is, std::string &t) {
  t.clear();

  // The characters in the stream are read one-by-one using a std::streambuf.
  // That is faster than reading them one-by-one using the std::istream.
  // Code that uses streambuf this way must be guarded by a sentry object.
  // The sentry object performs various tasks,
  // such as thread synchronization and updating the stream state.

  std::istream::sentry se(is, true);
  std::streambuf *sb = is.rdbuf();

  if (se) {
    for (;;) {
      int c = sb->sbumpc();
      switch (c) {
        case '\n':
          return is;
        case '\r':
          if (sb->sgetc() == '\n') sb->sbumpc();
          return is;
        case EOF:
          // Also handle the case when the last line has no line ending
          if (t.empty()) is.setstate(std::ios::eofbit);
          return is;
        default:
          t += static_cast<char>(c);
      }
    }
  }

  return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7640
movq -0x10(%rbp), %rsi
leaq -0x19(%rbp), %rdi
movl $0x1, %edx
callq 0x7790
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x7200
movq %rax, -0x28(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x7130
testb $0x1, %al
jne 0x1df91
jmp 0x1e02d
jmp 0x1df93
movq -0x28(%rbp), %rdi
callq 0x7280
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $-0x1, %eax
je 0x1dfeb
jmp 0x1dfac
movl -0x30(%rbp), %eax
subl $0xa, %eax
je 0x1dfc0
jmp 0x1dfb6
movl -0x30(%rbp), %eax
subl $0xd, %eax
je 0x1dfca
jmp 0x1e019
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e035
movq -0x28(%rbp), %rdi
callq 0x7700
cmpl $0xa, %eax
jne 0x1dfe1
movq -0x28(%rbp), %rdi
callq 0x7280
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e035
movq -0x18(%rbp), %rdi
callq 0x77e0
testb $0x1, %al
jne 0x1dffa
jmp 0x1e00f
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2, %esi
callq 0x7300
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e035
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x72f0
jmp 0x1df93
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseInt(char const**)
static inline int parseInt(const char **token) {
  (*token) += strspn((*token), " \t");
  int i = atoi((*token));
  (*token) += strcspn((*token), " \t\r");
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x60546(%rip), %rsi     # 0x7e5a0
callq 0x71d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x7770
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x60b25(%rip), %rsi     # 0x7ebae
callq 0x7060
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::MaterialStreamReader::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<tinyobj::material_t, std::allocator<tinyobj::material_t>>*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool MaterialStreamReader::operator()(const std::string &matId,
                                      std::vector<material_t> *materials,
                                      std::map<std::string, int> *matMap,
                                      std::string *warn, std::string *err) {
  (void)err;
  (void)matId;
  if (!m_inStream) {
    std::stringstream ss;
    ss << "Material stream in error state. " << std::endl;
    if (warn) {
      (*warn) += ss.str();
    }
    return false;
  }

  LoadMtl(matMap, materials, &m_inStream, warn, err);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x7220
testb $0x1, %al
jne 0x1e3d7
jmp 0x1e4a4
leaq -0x1c0(%rbp), %rdi
callq 0x7360
leaq -0x1b0(%rbp), %rdi
leaq 0x60397(%rip), %rsi     # 0x7e788
callq 0x74e0
movq %rax, -0x200(%rbp)
jmp 0x1e3ff
movq -0x200(%rbp), %rdi
movq 0x91b63(%rip), %rsi     # 0xaff70
callq 0x7540
jmp 0x1e414
cmpq $0x0, -0x30(%rbp)
je 0x1e484
leaq -0x1f0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x74d0
jmp 0x1e430
movq -0x30(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x7620
jmp 0x1e442
leaq -0x1f0(%rbp), %rdi
callq 0x72e0
jmp 0x1e484
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x1e496
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x72e0
jmp 0x1e496
movb $0x0, -0x1(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x73b0
jmp 0x1e4c8
leaq -0x1c0(%rbp), %rdi
callq 0x73b0
jmp 0x1e4d6
movq -0x1f8(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x1c180
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x7860
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseVertexWithColor(float*, float*, float*, float*, float*, float*, char const**, double, double, double)
static inline bool parseVertexWithColor(real_t *x, real_t *y, real_t *z,
                                        real_t *r, real_t *g, real_t *b,
                                        const char **token,
                                        const double default_x = 0.0,
                                        const double default_y = 0.0,
                                        const double default_z = 0.0) {
  (*x) = parseReal(token, default_x);
  (*y) = parseReal(token, default_y);
  (*z) = parseReal(token, default_z);

  const bool found_color =
      parseReal(token, r) && parseReal(token, g) && parseReal(token, b);

  if (!found_color) {
    (*r) = (*g) = (*b) = 1.0;
  }

  return found_color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movsd %xmm2, -0x48(%rbp)
movq 0x10(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x1bd50
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq 0x10(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
callq 0x1bd50
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq 0x10(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
callq 0x1bd50
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq 0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2adf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x4a(%rbp)
jne 0x211a0
jmp 0x211cb
movq 0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2adf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x4a(%rbp)
jne 0x211bb
jmp 0x211cb
movq 0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2adf0
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
andb $0x1, %al
movb %al, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x21209
movq -0x30(%rbp), %rax
movss 0x5d017(%rip), %xmm0    # 0x7e1fc
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
movss 0x5d007(%rip), %xmm0    # 0x7e1fc
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movss 0x5cff7(%rip), %xmm0    # 0x7e1fc
movss %xmm0, (%rax)
movb -0x49(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
static void SplitString(const std::string &s, char delim,
                        std::vector<std::string> &elems) {
  std::stringstream ss;
  ss.str(s);
  std::string item;
  while (std::getline(ss, item, delim)) {
    elems.push_back(item);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x7360
movq -0x1d8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x75c0
jmp 0x228ee
leaq -0x1d0(%rbp), %rdi
callq 0x7690
movsbl -0x9(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x78d0
movq %rax, -0x1e0(%rbp)
jmp 0x2291a
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x7610
movb %al, -0x1e1(%rbp)
jmp 0x22938
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x22944
jmp 0x2298c
movq -0x18(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x2c130
jmp 0x22956
jmp 0x228fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x229ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x72e0
jmp 0x229ad
leaq -0x1d0(%rbp), %rdi
callq 0x72e0
leaq -0x1a0(%rbp), %rdi
callq 0x73b0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x73b0
movq -0x1a8(%rbp), %rdi
callq 0x7860
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseTagTriple(char const**)
static tag_sizes parseTagTriple(const char **token) {
  tag_sizes ts;

  (*token) += strspn((*token), " \t");
  ts.num_ints = atoi((*token));
  (*token) += strcspn((*token), "/ \t\r");
  if ((*token)[0] != '/') {
    return ts;
  }

  (*token)++;  // Skip '/'

  (*token) += strspn((*token), " \t");
  ts.num_reals = atoi((*token));
  (*token) += strcspn((*token), "/ \t\r");
  if ((*token)[0] != '/') {
    return ts;
  }
  (*token)++;  // Skip '/'

  ts.num_strings = parseInt(token);

  return ts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x36e20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5bbad(%rip), %rsi     # 0x7e5a0
callq 0x71d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7770
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5c18b(%rip), %rsi     # 0x7ebad
callq 0x7060
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x22a48
jmp 0x22ad0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5bb3c(%rip), %rsi     # 0x7e5a0
callq 0x71d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7770
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5c11a(%rip), %rsi     # 0x7ebad
callq 0x7060
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x22ab6
jmp 0x22ad0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1e040
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseV(float*, float*, float*, float*, char const**, double, double, double, double)
static inline void parseV(real_t *x, real_t *y, real_t *z, real_t *w,
                          const char **token, const double default_x = 0.0,
                          const double default_y = 0.0,
                          const double default_z = 0.0,
                          const double default_w = 1.0) {
  (*x) = parseReal(token, default_x);
  (*y) = parseReal(token, default_y);
  (*z) = parseReal(token, default_z);
  (*w) = parseReal(token, default_w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm3, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x1bd50
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x1bd50
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
callq 0x1bd50
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
callq 0x1bd50
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseRawTriple(char const**)
static vertex_index_t parseRawTriple(const char **token) {
  vertex_index_t vi(static_cast<int>(0));  // 0 is an invalid index in OBJ

  vi.v_idx = atoi((*token));
  (*token) += strcspn((*token), "/ \t\r");
  if ((*token)[0] != '/') {
    return vi;
  }
  (*token)++;

  // i//k
  if ((*token)[0] == '/') {
    (*token)++;
    vi.vn_idx = atoi((*token));
    (*token) += strcspn((*token), "/ \t\r");
    return vi;
  }

  // i/j/k or i/j
  vi.vt_idx = atoi((*token));
  (*token) += strcspn((*token), "/ \t\r");
  if ((*token)[0] != '/') {
    return vi;
  }

  // i/j/k
  (*token)++;  // skip '/'
  vi.vn_idx = atoi((*token));
  (*token) += strcspn((*token), "/ \t\r");
  return vi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
leaq -0xc(%rbp), %rdi
xorl %esi, %esi
callq 0x2f5f0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7770
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5adb9(%rip), %rsi     # 0x7ebad
callq 0x7060
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x23e1a
jmp 0x23ef3
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x23e76
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7770
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5ad4b(%rip), %rsi     # 0x7ebad
callq 0x7060
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x23ef3
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7770
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5ad1a(%rip), %rsi     # 0x7ebad
callq 0x7060
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x23eb6
jmp 0x23ef3
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7770
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5accc(%rip), %rsi     # 0x7ebad
callq 0x7060
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::ObjReader::ParseFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, tinyobj::ObjReaderConfig const&)
bool ObjReader::ParseFromFile(const std::string &filename,
                              const ObjReaderConfig &config) {
  std::string mtl_search_path;

  if (config.mtl_search_path.empty()) {
    //
    // split at last '/'(for unixish system) or '\\'(for windows) to get
    // the base directory of .obj file
    //
    if (filename.find_last_of("/\\") != std::string::npos) {
      mtl_search_path = filename.substr(0, filename.find_last_of("/\\"));
    }
  }

  valid_ = LoadObj(&attrib_, &shapes_, &materials_, &warning_, &error_,
                   filename.c_str(), mtl_search_path.c_str(),
                   config.triangulate, config.vertex_color);

  return valid_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7690
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x77e0
testb $0x1, %al
jne 0x23f4f
jmp 0x23fd1
movq -0x18(%rbp), %rdi
leaq 0x5aba9(%rip), %rsi     # 0x7eb03
movq $-0x1, %rdx
callq 0x74b0
cmpq $-0x1, %rax
je 0x23fcf
movq -0x18(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq 0x5ab88(%rip), %rsi     # 0x7eb03
movq $-0x1, %rdx
callq 0x74b0
movq -0x80(%rbp), %rsi
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rdi
callq 0x7520
jmp 0x23f9d
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x75f0
leaq -0x60(%rbp), %rdi
callq 0x72e0
jmp 0x23fcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x72e0
jmp 0x240c8
jmp 0x23fd1
movq -0x78(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xb8(%rbp)
movq %rax, %rcx
addq $0x98, %rcx
movq %rcx, -0xb0(%rbp)
movq %rax, %rcx
addq $0xb0, %rcx
movq %rcx, -0xa8(%rbp)
movq %rax, %rcx
addq $0xc8, %rcx
movq %rcx, -0xa0(%rbp)
addq $0xe8, %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x71c0
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x71c0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
movq -0x98(%rbp), %r8
movq -0x90(%rbp), %r9
movq %rax, %r10
movq -0x20(%rbp), %rax
movzbl (%rax), %r11d
movzbl 0x1(%rax), %ebx
andl $0x1, %ebx
movq %rsp, %rax
movl %ebx, 0x10(%rax)
andl $0x1, %r11d
movl %r11d, 0x8(%rax)
movq %r10, (%rax)
callq 0x1e4f0
movb %al, -0x81(%rbp)
jmp 0x24096
movq -0x78(%rbp), %rax
movb -0x81(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movb (%rax), %al
movb %al, -0xb9(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x72e0
movb -0xb9(%rbp), %al
andb $0x1, %al
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7860
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/src/util.cpp
// Function: get_sphere_uv(vec3 const&, float&, float&)
void get_sphere_uv(const vec3& point_on_surface, float& _u, float& _v)
{
    float phi = std::atan2(point_on_surface.z(), point_on_surface.x());
    float theta = std::asin(point_on_surface.y());
    _u = 1 - (phi + M_PI) / (2.0f * M_PI);
    _v = (theta + M_PI / 2.0f) / M_PI;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8db0
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8d70
movaps %xmm0, %xmm1
movss -0x24(%rbp), %xmm0
callq 0x2cbb0
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8d90
callq 0x2cbe0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5985f(%rip), %xmm0    # 0x7e480
addsd %xmm0, %xmm1
movsd 0x59863(%rip), %xmm0    # 0x7e490
divsd %xmm0, %xmm1
movsd 0x5983f(%rip), %xmm0    # 0x7e478
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5982e(%rip), %xmm1    # 0x7e488
addsd %xmm1, %xmm0
movsd 0x5981a(%rip), %xmm1    # 0x7e480
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::InitTexOpt(tinyobj::texture_option_t*, bool)
static void InitTexOpt(texture_option_t *texopt, const bool is_bump) {
  if (is_bump) {
    texopt->imfchan = 'l';
  } else {
    texopt->imfchan = 'm';
  }
  texopt->bump_multiplier = static_cast<real_t>(1.0);
  texopt->clamp = false;
  texopt->blendu = true;
  texopt->blendv = true;
  texopt->sharpness = static_cast<real_t>(1.0);
  texopt->brightness = static_cast<real_t>(0.0);
  texopt->contrast = static_cast<real_t>(1.0);
  texopt->origin_offset[0] = static_cast<real_t>(0.0);
  texopt->origin_offset[1] = static_cast<real_t>(0.0);
  texopt->origin_offset[2] = static_cast<real_t>(0.0);
  texopt->scale[0] = static_cast<real_t>(1.0);
  texopt->scale[1] = static_cast<real_t>(1.0);
  texopt->scale[2] = static_cast<real_t>(1.0);
  texopt->turbulence[0] = static_cast<real_t>(0.0);
  texopt->turbulence[1] = static_cast<real_t>(0.0);
  texopt->turbulence[2] = static_cast<real_t>(0.0);
  texopt->type = TEXTURE_TYPE_NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2ad00
movq -0x8(%rbp), %rax
movb $0x6c, 0x35(%rax)
jmp 0x2ad08
movq -0x8(%rbp), %rax
movb $0x6d, 0x35(%rax)
movq -0x8(%rbp), %rax
movss 0x534e8(%rip), %xmm0    # 0x7e1fc
movss %xmm0, 0x38(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x36(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x37(%rax)
movq -0x8(%rbp), %rax
movss 0x534bf(%rip), %xmm0    # 0x7e1fc
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movss 0x534a2(%rip), %xmm0    # 0x7e1fc
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movss 0x5346d(%rip), %xmm0    # 0x7e1fc
movss %xmm0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movss 0x5345c(%rip), %xmm0    # 0x7e1fc
movss %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movss 0x5344b(%rip), %xmm0    # 0x7e1fc
movss %xmm0, 0x24(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::parseReal(char const**, float*)
static inline bool parseReal(const char **token, real_t *out) {
  (*token) += strspn((*token), " \t");
  const char *end = (*token) + strcspn((*token), " \t\r");
  double val;
  bool ret = tryParseDouble((*token), end, &val);
  if (ret) {
    real_t f = static_cast<real_t>(val);
    (*out) = f;
  }
  (*token) = end;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x53792(%rip), %rsi     # 0x7e5a0
callq 0x71d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x53d75(%rip), %rsi     # 0x7ebae
callq 0x7060
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2a880
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x2ae86
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: tinyobj::fixIndex(int, int, int*)
static inline bool fixIndex(int idx, int n, int *ret) {
  if (!ret) {
    return false;
  }

  if (idx > 0) {
    (*ret) = idx - 1;
    return true;
  }

  if (idx == 0) {
    // zero is not allowed according to the spec.
    return false;
  }

  if (idx < 0) {
    (*ret) = n + idx;  // negative value = relative
    return true;
  }

  return false;  // never reach here.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2aebb
movb $0x0, -0x1(%rbp)
jmp 0x2aefb
cmpl $0x0, -0x8(%rbp)
jle 0x2aed3
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2aefb
cmpl $0x0, -0x8(%rbp)
jne 0x2aedf
movb $0x0, -0x1(%rbp)
jmp 0x2aefb
cmpl $0x0, -0x8(%rbp)
jge 0x2aef7
movl -0xc(%rbp), %ecx
addl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2aefb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/tiny_obj_loader.h
// Function: int tinyobj::pnpoly<float>(int, float*, float*, float, float)
static int pnpoly(int nvert, T *vertx, T *verty, T testx, T testy) {
  int i, j, c = 0;
  for (i = 0, j = nvert - 1; i < nvert; j = i++) {
    if (((verty[i] > testy) != (verty[j] > testy)) &&
        (testx <
         (vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) +
             vertx[i]))
      c = !c;
  }
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2b00e
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x20(%rbp), %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
ucomiss -0x20(%rbp), %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x2aff9
movss -0x1c(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss -0x20(%rbp), %xmm2
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
subss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
subss (%rax,%rcx,4), %xmm2
divss %xmm2, %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2aff9
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2affb
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movl %eax, -0x28(%rbp)
jmp 0x2af40
movl -0x2c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: alan0201tw[P]RayTracer/src/flip_normals.cpp
// Function: flip_normals::hit(ray const&, float, float, hit_record&) const
bool flip_normals::hit(const ray& _ray, float t_min, float t_max, hit_record& rec) const
{
    if(target->hit(_ray, t_min, t_max, rec) == true)
    {
        rec.normal = -rec.normal;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x105a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x540bc
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x54120
movss %xmm1, -0x40(%rbp)
movlpd %xmm0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x34(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq -0x34(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x540c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/src/transform.cpp
// Function: translate::hit(ray const&, float, float, hit_record&) const
bool translate::hit(const ray& _ray, float t_min, float t_max, hit_record& rec) const
{
    ray moved_ray(_ray.origin() - displacement, _ray.direction(), _ray.get_time());
    if(target->hit(moved_ray, t_min, t_max, rec) == true)
    {
        rec.hit_point += displacement;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf870
movq -0xa8(%rbp), %rsi
movss %xmm1, -0x68(%rbp)
movlpd %xmm0, -0x70(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x18, %rsi
leaq -0x60(%rbp), %rdi
callq 0x11890
movss %xmm1, -0x78(%rbp)
movlpd %xmm0, -0x80(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf8b0
movss %xmm1, -0x98(%rbp)
movlpd %xmm0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x8c(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11ae0
leaq -0x44(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x8c(%rbp), %rdx
callq 0x55430
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x105a0
movq %rax, %rdi
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rdx
movq (%rdi), %rax
leaq -0x44(%rbp), %rsi
callq *(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x5429b
movq -0xa8(%rbp), %rsi
addq $0x18, %rsi
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
callq 0x554a0
movb $0x1, -0x1(%rbp)
jmp 0x5429f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/src/transform.cpp
// Function: translate::bounding_box(float, float, aabb&) const
bool translate::bounding_box(float t0, float t1, aabb& _box) const
{
    if(target->bounding_box(t0, t1, _box) == true)
    {
        _box = aabb(_box.get_min() + displacement, _box.get_max() + displacement);
        return true;
    }
    return false;
}

// 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), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x8, %rdi
callq 0x105a0
movq %rax, %rdi
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x543fc
movq -0x20(%rbp), %rdi
callq 0x13990
movq -0xb8(%rbp), %rsi
movss %xmm1, -0x60(%rbp)
movlpd %xmm0, -0x68(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x18, %rsi
movq %rsi, -0xc0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xfa30
movss %xmm1, -0x70(%rbp)
movlpd %xmm0, -0x78(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b4e0
movq -0xc0(%rbp), %rsi
movss %xmm1, -0x98(%rbp)
movlpd %xmm0, -0xa0(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xfa30
movss %xmm1, -0xa8(%rbp)
movlpd %xmm0, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x84(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x84(%rbp), %rdx
callq 0x9330
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)
movb $0x1, -0x1(%rbp)
jmp 0x54400
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/vec3.hpp
// Function: vec3::operator+=(vec3 const&)
inline vec3& vec3::operator+=(const vec3 &v){
    e[0]  += v.e[0];
    e[1]  += v.e[1];
    e[2]  += v.e[2];
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rcx
movss 0x8(%rcx), %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/src/material.cpp
// Function: lambertian::scatter(ray const&, hit_record const&, vec3&, ray&) const
bool lambertian::scatter(const ray& _incoming_ray, const hit_record& _record, vec3& _attenuation, ray& _scattered_ray) const
{
    // Reference github issue :
    // https://github.com/RayTracing/raytracing.github.io/issues/145
    // here we use a normalized random_in_unit_sphere(random_on_unit_sphere) instead.
    vec3 target = _record.hit_point + _record.normal + random_on_unit_sphere();
    _scattered_ray = ray(_record.hit_point, target - _record.hit_point, _incoming_ray.get_time());
    _attenuation = albedo->value_at_uv(_record.u, _record.v, _record.hit_point);
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0xc, %rdi
addq $0x18, %rsi
callq 0xfa30
movss %xmm1, -0x50(%rbp)
movlpd %xmm0, -0x58(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x246e0
movss %xmm1, -0x70(%rbp)
movlpd %xmm0, -0x78(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xfa30
movss %xmm1, -0x80(%rbp)
movlpd %xmm0, -0x88(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
movq %rsi, -0xf0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11890
movss %xmm1, -0xb8(%rbp)
movlpd %xmm0, -0xc0(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11ae0
movq -0xf0(%rbp), %rsi
leaq -0xa4(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x55430
movq -0xe8(%rbp), %rdi
movq -0x28(%rbp), %rax
movups -0xa4(%rbp), %xmm0
movups -0x98(%rbp), %xmm1
movups %xmm1, 0xc(%rax)
movups %xmm0, (%rax)
addq $0x8, %rdi
callq 0x10100
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movss 0x4(%rsi), %xmm0
movss 0x8(%rsi), %xmm1
addq $0xc, %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movss %xmm1, -0xd8(%rbp)
movlpd %xmm0, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0xcc(%rbp)
movl -0xd8(%rbp), %eax
movl %eax, -0xc4(%rbp)
movq -0x20(%rbp), %rax
movq -0xcc(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc4(%rbp), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/src/material.cpp
// Function: metal::scatter(ray const&, hit_record const&, vec3&, ray&) const
bool metal::scatter(const ray& _incoming_ray, const hit_record& _record, vec3& _attenuation, ray& _scattered_ray) const
{
    vec3 reflected = reflect(unit_vector(_incoming_ray.direction()), _record.normal);
    _scattered_ray = ray(_record.hit_point, reflected + fuzziness * random_in_unit_sphere(), _incoming_ray.get_time());
    _attenuation = albedo;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf8b0
movss %xmm1, -0x60(%rbp)
movlpd %xmm0, -0x68(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
movsd -0x78(%rbp), %xmm0
movss -0x70(%rbp), %xmm1
callq 0x18b10
movss %xmm1, -0x80(%rbp)
movlpd %xmm0, -0x88(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x48(%rbp), %rdi
callq 0x24840
movq -0x118(%rbp), %rax
movss %xmm1, -0x90(%rbp)
movlpd %xmm0, -0x98(%rbp)
movl -0x90(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movq -0x98(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rcx
addq $0xc, %rcx
movq %rcx, -0x120(%rbp)
movss 0x14(%rax), %xmm0
movss %xmm0, -0x134(%rbp)
callq 0x24510
movaps %xmm0, %xmm2
movss -0x134(%rbp), %xmm0
movaps %xmm2, -0x130(%rbp)
movaps %xmm1, %xmm2
movaps -0x130(%rbp), %xmm1
movss %xmm2, -0xe8(%rbp)
movlpd %xmm1, -0xf0(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xd8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0xfaa0
movss %xmm1, -0xf8(%rbp)
movlpd %xmm0, -0x100(%rbp)
movl -0xf8(%rbp), %eax
movl %eax, -0xc8(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xfa30
movss %xmm1, -0x108(%rbp)
movlpd %xmm0, -0x110(%rbp)
movq -0x110(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0x108(%rbp), %eax
movl %eax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11ae0
movq -0x120(%rbp), %rsi
leaq -0xb4(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
callq 0x55430
movq -0x118(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0xb4(%rbp), %rdx
movq %rdx, (%rax)
movq -0xac(%rbp), %rdx
movq %rdx, 0x8(%rax)
movq -0xa4(%rbp), %rdx
movq %rdx, 0x10(%rax)
movl -0x9c(%rbp), %edx
movl %edx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi_load_from_file
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result;
   stbi__context s;
   stbi__start_file(&s,f);
   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
   if (result) {
      // need to 'unget' all the characters in the IO buffer
      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
   }
   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x560f0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq -0x108(%rbp), %rdi
callq 0x56120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x560d8
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movslq %eax, %rsi
movl $0x1, %edx
callq 0x75a0
movq -0x30(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)